1/**
2 * Original code: automated SDL platform test written by Edgar Simo "bobbens"
3 * Extended and extensively updated by aschiffler at ferzkopp dot net
4 */
5
6#include <stdio.h>
7
8#include "SDL.h"
9#include "SDL_test.h"
10
11/* ================= Test Case Implementation ================== */
12
13#define TESTRENDER_SCREEN_W 80
14#define TESTRENDER_SCREEN_H 60
15
16#define RENDER_COMPARE_FORMAT SDL_PIXELFORMAT_ARGB8888
17#define RENDER_COMPARE_AMASK 0xff000000 /**< Alpha bit mask. */
18#define RENDER_COMPARE_RMASK 0x00ff0000 /**< Red bit mask. */
19#define RENDER_COMPARE_GMASK 0x0000ff00 /**< Green bit mask. */
20#define RENDER_COMPARE_BMASK 0x000000ff /**< Blue bit mask. */
21
22#define ALLOWABLE_ERROR_OPAQUE 0
23#define ALLOWABLE_ERROR_BLENDED 64
24
25/* Test window and renderer */
26SDL_Window *window = NULL;
27SDL_Renderer *renderer = NULL;
28
29/* Prototypes for helper functions */
30
31static int _clearScreen (void);
32static void _compare(SDL_Surface *reference, int allowable_error);
33static int _hasTexAlpha(void);
34static int _hasTexColor(void);
35static SDL_Texture *_loadTestFace(void);
36static int _hasBlendModes(void);
37static int _hasDrawColor(void);
38static int _isSupported(int code);
39
40/**
41 * Create software renderer for tests
42 */
43void InitCreateRenderer(void *arg)
44{
45 int posX = 100, posY = 100, width = 320, height = 240;
46 renderer = NULL;
47 window = SDL_CreateWindow("render_testCreateRenderer", posX, posY, width, height, 0);
48 SDLTest_AssertPass("SDL_CreateWindow()");
49 SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result");
50 if (window == NULL) {
51 return;
52 }
53
54 renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
55 SDLTest_AssertPass("SDL_CreateRenderer()");
56 SDLTest_AssertCheck(renderer != 0, "Check SDL_CreateRenderer result");
57 if (renderer == NULL) {
58 SDL_DestroyWindow(window);
59 return;
60 }
61}
62
63/*
64 * Destroy renderer for tests
65 */
66void CleanupDestroyRenderer(void *arg)
67{
68 if (renderer != NULL) {
69 SDL_DestroyRenderer(renderer);
70 renderer = NULL;
71 SDLTest_AssertPass("SDL_DestroyRenderer()");
72 }
73
74 if (window != NULL) {
75 SDL_DestroyWindow(window);
76 window = NULL;
77 SDLTest_AssertPass("SDL_DestroyWindow");
78 }
79}
80
81
82/**
83 * @brief Tests call to SDL_GetNumRenderDrivers
84 *
85 * \sa
86 * http://wiki.libsdl.org/SDL_GetNumRenderDrivers
87 */
88int
89render_testGetNumRenderDrivers(void *arg)
90{
91 int n;
92 n = SDL_GetNumRenderDrivers();
93 SDLTest_AssertCheck(n >= 1, "Number of renderers >= 1, reported as %i", n);
94 return TEST_COMPLETED;
95}
96
97
98/**
99 * @brief Tests the SDL primitives for rendering.
100 *
101 * \sa
102 * http://wiki.libsdl.org/SDL_SetRenderDrawColor
103 * http://wiki.libsdl.org/SDL_RenderFillRect
104 * http://wiki.libsdl.org/SDL_RenderDrawLine
105 *
106 */
107int render_testPrimitives (void *arg)
108{
109 int ret;
110 int x, y;
111 SDL_Rect rect;
112 SDL_Surface *referenceSurface = NULL;
113 int checkFailCount1;
114 int checkFailCount2;
115
116 /* Clear surface. */
117 _clearScreen();
118
119 /* Need drawcolor or just skip test. */
120 SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
121
122 /* Draw a rectangle. */
123 rect.x = 40;
124 rect.y = 0;
125 rect.w = 40;
126 rect.h = 80;
127
128 ret = SDL_SetRenderDrawColor(renderer, 13, 73, 200, SDL_ALPHA_OPAQUE );
129 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
130
131 ret = SDL_RenderFillRect(renderer, &rect );
132 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
133
134 /* Draw a rectangle. */
135 rect.x = 10;
136 rect.y = 10;
137 rect.w = 60;
138 rect.h = 40;
139 ret = SDL_SetRenderDrawColor(renderer, 200, 0, 100, SDL_ALPHA_OPAQUE );
140 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
141
142 ret = SDL_RenderFillRect(renderer, &rect );
143 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
144
145 /* Draw some points like so:
146 * X.X.X.X..
147 * .X.X.X.X.
148 * X.X.X.X.. */
149 checkFailCount1 = 0;
150 checkFailCount2 = 0;
151 for (y=0; y<3; y++) {
152 for (x = y % 2; x<TESTRENDER_SCREEN_W; x+=2) {
153 ret = SDL_SetRenderDrawColor(renderer, x*y, x*y/2, x*y/3, SDL_ALPHA_OPAQUE );
154 if (ret != 0) checkFailCount1++;
155
156 ret = SDL_RenderDrawPoint(renderer, x, y );
157 if (ret != 0) checkFailCount2++;
158 }
159 }
160 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
161 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount2);
162
163 /* Draw some lines. */
164 ret = SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE );
165 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor");
166
167 ret = SDL_RenderDrawLine(renderer, 0, 30, TESTRENDER_SCREEN_W, 30 );
168 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
169
170 ret = SDL_SetRenderDrawColor(renderer, 55, 55, 5, SDL_ALPHA_OPAQUE );
171 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
172
173 ret = SDL_RenderDrawLine(renderer, 40, 30, 40, 60 );
174 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
175
176 ret = SDL_SetRenderDrawColor(renderer, 5, 105, 105, SDL_ALPHA_OPAQUE );
177 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
178
179 ret = SDL_RenderDrawLine(renderer, 0, 0, 29, 29 );
180 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
181
182 ret = SDL_RenderDrawLine(renderer, 29, 30, 0, 59 );
183 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
184
185 ret = SDL_RenderDrawLine(renderer, 79, 0, 50, 29 );
186 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
187
188 ret = SDL_RenderDrawLine(renderer, 79, 59, 50, 30 );
189 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderDrawLine, expected: 0, got: %i", ret);
190
191 /* Make current */
192 SDL_RenderPresent(renderer);
193
194 /* See if it's the same. */
195 referenceSurface = SDLTest_ImagePrimitives();
196 _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
197
198 /* Clean up. */
199 SDL_FreeSurface(referenceSurface);
200 referenceSurface = NULL;
201
202 return TEST_COMPLETED;
203}
204
205/**
206 * @brief Tests the SDL primitives with alpha for rendering.
207 *
208 * \sa
209 * http://wiki.libsdl.org/SDL_SetRenderDrawColor
210 * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
211 * http://wiki.libsdl.org/SDL_RenderFillRect
212 */
213int render_testPrimitivesBlend (void *arg)
214{
215 int ret;
216 int i, j;
217 SDL_Rect rect;
218 SDL_Surface *referenceSurface = NULL;
219 int checkFailCount1;
220 int checkFailCount2;
221 int checkFailCount3;
222
223 /* Clear surface. */
224 _clearScreen();
225
226 /* Need drawcolor and blendmode or just skip test. */
227 SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
228 SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
229
230 /* Create some rectangles for each blend mode. */
231 ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0 );
232 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
233
234 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
235 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
236
237 ret = SDL_RenderFillRect(renderer, NULL );
238 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
239
240 rect.x = 10;
241 rect.y = 25;
242 rect.w = 40;
243 rect.h = 25;
244 ret = SDL_SetRenderDrawColor(renderer, 240, 10, 10, 75 );
245 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
246
247 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD );
248 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
249
250 ret = SDL_RenderFillRect(renderer, &rect );
251 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
252
253 rect.x = 30;
254 rect.y = 40;
255 rect.w = 45;
256 rect.h = 15;
257 ret = SDL_SetRenderDrawColor(renderer, 10, 240, 10, 100 );
258 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
259
260 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND );
261 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
262
263 ret = SDL_RenderFillRect(renderer, &rect );
264 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
265
266 rect.x = 25;
267 rect.y = 25;
268 rect.w = 25;
269 rect.h = 25;
270 ret = SDL_SetRenderDrawColor(renderer, 10, 10, 240, 125 );
271 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
272
273 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
274 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
275
276 ret = SDL_RenderFillRect(renderer, &rect );
277 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderFillRect, expected: 0, got: %i", ret);
278
279
280 /* Draw blended lines, lines for everyone. */
281 checkFailCount1 = 0;
282 checkFailCount2 = 0;
283 checkFailCount3 = 0;
284 for (i=0; i<TESTRENDER_SCREEN_W; i+=2) {
285 ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
286 if (ret != 0) checkFailCount1++;
287
288 ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
289 (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
290 if (ret != 0) checkFailCount2++;
291
292 ret = SDL_RenderDrawLine(renderer, 0, 0, i, 59 );
293 if (ret != 0) checkFailCount3++;
294 }
295 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
296 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
297 SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
298
299 checkFailCount1 = 0;
300 checkFailCount2 = 0;
301 checkFailCount3 = 0;
302 for (i=0; i<TESTRENDER_SCREEN_H; i+=2) {
303 ret = SDL_SetRenderDrawColor(renderer, 60+2*i, 240-2*i, 50, 3*i );
304 if (ret != 0) checkFailCount1++;
305
306 ret = SDL_SetRenderDrawBlendMode(renderer,(((i/2)%3)==0) ? SDL_BLENDMODE_BLEND :
307 (((i/2)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
308 if (ret != 0) checkFailCount2++;
309
310 ret = SDL_RenderDrawLine(renderer, 0, 0, 79, i );
311 if (ret != 0) checkFailCount3++;
312 }
313 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
314 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
315 SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawLine, expected: 0, got: %i", checkFailCount3);
316
317 /* Draw points. */
318 checkFailCount1 = 0;
319 checkFailCount2 = 0;
320 checkFailCount3 = 0;
321 for (j=0; j<TESTRENDER_SCREEN_H; j+=3) {
322 for (i=0; i<TESTRENDER_SCREEN_W; i+=3) {
323 ret = SDL_SetRenderDrawColor(renderer, j*4, i*3, j*4, i*3 );
324 if (ret != 0) checkFailCount1++;
325
326 ret = SDL_SetRenderDrawBlendMode(renderer, ((((i+j)/3)%3)==0) ? SDL_BLENDMODE_BLEND :
327 ((((i+j)/3)%3)==1) ? SDL_BLENDMODE_ADD : SDL_BLENDMODE_NONE );
328 if (ret != 0) checkFailCount2++;
329
330 ret = SDL_RenderDrawPoint(renderer, i, j );
331 if (ret != 0) checkFailCount3++;
332 }
333 }
334 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetRenderDrawColor, expected: 0, got: %i", checkFailCount1);
335 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetRenderDrawBlendMode, expected: 0, got: %i", checkFailCount2);
336 SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_RenderDrawPoint, expected: 0, got: %i", checkFailCount3);
337
338 /* Make current */
339 SDL_RenderPresent(renderer);
340
341 /* See if it's the same. */
342 referenceSurface = SDLTest_ImagePrimitivesBlend();
343 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
344
345 /* Clean up. */
346 SDL_FreeSurface(referenceSurface);
347 referenceSurface = NULL;
348
349 return TEST_COMPLETED;
350}
351
352
353
354/**
355 * @brief Tests some blitting routines.
356 *
357 * \sa
358 * http://wiki.libsdl.org/SDL_RenderCopy
359 * http://wiki.libsdl.org/SDL_DestroyTexture
360 */
361int
362render_testBlit(void *arg)
363{
364 int ret;
365 SDL_Rect rect;
366 SDL_Texture *tface;
367 SDL_Surface *referenceSurface = NULL;
368 Uint32 tformat;
369 int taccess, tw, th;
370 int i, j, ni, nj;
371 int checkFailCount1;
372
373 /* Clear surface. */
374 _clearScreen();
375
376 /* Need drawcolor or just skip test. */
377 SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor)");
378
379 /* Create face surface. */
380 tface = _loadTestFace();
381 SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
382 if (tface == NULL) {
383 return TEST_ABORTED;
384 }
385
386 /* Constant values. */
387 ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
388 SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
389 rect.w = tw;
390 rect.h = th;
391 ni = TESTRENDER_SCREEN_W - tw;
392 nj = TESTRENDER_SCREEN_H - th;
393
394 /* Loop blit. */
395 checkFailCount1 = 0;
396 for (j=0; j <= nj; j+=4) {
397 for (i=0; i <= ni; i+=4) {
398 /* Blitting. */
399 rect.x = i;
400 rect.y = j;
401 ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
402 if (ret != 0) checkFailCount1++;
403 }
404 }
405 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount1);
406
407 /* Make current */
408 SDL_RenderPresent(renderer);
409
410 /* See if it's the same */
411 referenceSurface = SDLTest_ImageBlit();
412 _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
413
414 /* Clean up. */
415 SDL_DestroyTexture( tface );
416 SDL_FreeSurface(referenceSurface);
417 referenceSurface = NULL;
418
419 return TEST_COMPLETED;
420}
421
422
423/**
424 * @brief Blits doing color tests.
425 *
426 * \sa
427 * http://wiki.libsdl.org/SDL_SetTextureColorMod
428 * http://wiki.libsdl.org/SDL_RenderCopy
429 * http://wiki.libsdl.org/SDL_DestroyTexture
430 */
431int
432render_testBlitColor (void *arg)
433{
434 int ret;
435 SDL_Rect rect;
436 SDL_Texture *tface;
437 SDL_Surface *referenceSurface = NULL;
438 Uint32 tformat;
439 int taccess, tw, th;
440 int i, j, ni, nj;
441 int checkFailCount1;
442 int checkFailCount2;
443
444 /* Clear surface. */
445 _clearScreen();
446
447 /* Create face surface. */
448 tface = _loadTestFace();
449 SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
450 if (tface == NULL) {
451 return TEST_ABORTED;
452 }
453
454 /* Constant values. */
455 ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
456 SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
457 rect.w = tw;
458 rect.h = th;
459 ni = TESTRENDER_SCREEN_W - tw;
460 nj = TESTRENDER_SCREEN_H - th;
461
462 /* Test blitting with color mod. */
463 checkFailCount1 = 0;
464 checkFailCount2 = 0;
465 for (j=0; j <= nj; j+=4) {
466 for (i=0; i <= ni; i+=4) {
467 /* Set color mod. */
468 ret = SDL_SetTextureColorMod( tface, (255/nj)*j, (255/ni)*i, (255/nj)*j );
469 if (ret != 0) checkFailCount1++;
470
471 /* Blitting. */
472 rect.x = i;
473 rect.y = j;
474 ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
475 if (ret != 0) checkFailCount2++;
476 }
477 }
478 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
479 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
480
481 /* Make current */
482 SDL_RenderPresent(renderer);
483
484 /* See if it's the same. */
485 referenceSurface = SDLTest_ImageBlitColor();
486 _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
487
488 /* Clean up. */
489 SDL_DestroyTexture( tface );
490 SDL_FreeSurface(referenceSurface);
491 referenceSurface = NULL;
492
493 return TEST_COMPLETED;
494}
495
496
497/**
498 * @brief Tests blitting with alpha.
499 *
500 * \sa
501 * http://wiki.libsdl.org/SDL_SetTextureAlphaMod
502 * http://wiki.libsdl.org/SDL_RenderCopy
503 * http://wiki.libsdl.org/SDL_DestroyTexture
504 */
505int
506render_testBlitAlpha (void *arg)
507{
508 int ret;
509 SDL_Rect rect;
510 SDL_Texture *tface;
511 SDL_Surface *referenceSurface = NULL;
512 Uint32 tformat;
513 int taccess, tw, th;
514 int i, j, ni, nj;
515 int checkFailCount1;
516 int checkFailCount2;
517
518 /* Clear surface. */
519 _clearScreen();
520
521 /* Need alpha or just skip test. */
522 SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
523
524 /* Create face surface. */
525 tface = _loadTestFace();
526 SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
527 if (tface == NULL) {
528 return TEST_ABORTED;
529 }
530
531 /* Constant values. */
532 ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
533 SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
534 rect.w = tw;
535 rect.h = th;
536 ni = TESTRENDER_SCREEN_W - tw;
537 nj = TESTRENDER_SCREEN_H - th;
538
539 /* Test blitting with alpha mod. */
540 checkFailCount1 = 0;
541 checkFailCount2 = 0;
542 for (j=0; j <= nj; j+=4) {
543 for (i=0; i <= ni; i+=4) {
544 /* Set alpha mod. */
545 ret = SDL_SetTextureAlphaMod( tface, (255/ni)*i );
546 if (ret != 0) checkFailCount1++;
547
548 /* Blitting. */
549 rect.x = i;
550 rect.y = j;
551 ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
552 if (ret != 0) checkFailCount2++;
553 }
554 }
555 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount1);
556 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
557
558 /* Make current */
559 SDL_RenderPresent(renderer);
560
561 /* See if it's the same. */
562 referenceSurface = SDLTest_ImageBlitAlpha();
563 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
564
565 /* Clean up. */
566 SDL_DestroyTexture( tface );
567 SDL_FreeSurface(referenceSurface);
568 referenceSurface = NULL;
569
570 return TEST_COMPLETED;
571}
572
573/* Helper functions */
574
575/**
576 * @brief Tests a blend mode.
577 *
578 * \sa
579 * http://wiki.libsdl.org/SDL_SetTextureBlendMode
580 * http://wiki.libsdl.org/SDL_RenderCopy
581 */
582static void
583_testBlitBlendMode( SDL_Texture * tface, int mode )
584{
585 int ret;
586 Uint32 tformat;
587 int taccess, tw, th;
588 int i, j, ni, nj;
589 SDL_Rect rect;
590 int checkFailCount1;
591 int checkFailCount2;
592
593 /* Clear surface. */
594 _clearScreen();
595
596 /* Constant values. */
597 ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
598 SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
599 rect.w = tw;
600 rect.h = th;
601 ni = TESTRENDER_SCREEN_W - tw;
602 nj = TESTRENDER_SCREEN_H - th;
603
604 /* Test blend mode. */
605 checkFailCount1 = 0;
606 checkFailCount2 = 0;
607 for (j=0; j <= nj; j+=4) {
608 for (i=0; i <= ni; i+=4) {
609 /* Set blend mode. */
610 ret = SDL_SetTextureBlendMode( tface, (SDL_BlendMode)mode );
611 if (ret != 0) checkFailCount1++;
612
613 /* Blitting. */
614 rect.x = i;
615 rect.y = j;
616 ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
617 if (ret != 0) checkFailCount2++;
618 }
619 }
620 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureBlendMode, expected: 0, got: %i", checkFailCount1);
621 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount2);
622}
623
624
625/**
626 * @brief Tests some more blitting routines.
627 *
628 * \sa
629 * http://wiki.libsdl.org/SDL_SetTextureColorMod
630 * http://wiki.libsdl.org/SDL_SetTextureAlphaMod
631 * http://wiki.libsdl.org/SDL_SetTextureBlendMode
632 * http://wiki.libsdl.org/SDL_DestroyTexture
633 */
634int
635render_testBlitBlend (void *arg)
636{
637 int ret;
638 SDL_Rect rect;
639 SDL_Texture *tface;
640 SDL_Surface *referenceSurface = NULL;
641 Uint32 tformat;
642 int taccess, tw, th;
643 int i, j, ni, nj;
644 int mode;
645 int checkFailCount1;
646 int checkFailCount2;
647 int checkFailCount3;
648 int checkFailCount4;
649
650 SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
651 SDLTest_AssertCheck(_hasTexColor(), "_hasTexColor");
652 SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
653
654 /* Create face surface. */
655 tface = _loadTestFace();
656 SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
657 if (tface == NULL) {
658 return TEST_ABORTED;
659 }
660
661 /* Constant values. */
662 ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
663 SDLTest_AssertCheck(ret == 0, "Verify result from SDL_QueryTexture, expected 0, got %i", ret);
664 rect.w = tw;
665 rect.h = th;
666 ni = TESTRENDER_SCREEN_W - tw;
667 nj = TESTRENDER_SCREEN_H - th;
668
669 /* Set alpha mod. */
670 ret = SDL_SetTextureAlphaMod( tface, 100 );
671 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetTextureAlphaMod, expected: 0, got: %i", ret);
672
673 /* Test None. */
674 _testBlitBlendMode( tface, SDL_BLENDMODE_NONE );
675 referenceSurface = SDLTest_ImageBlitBlendNone();
676
677 /* Make current and compare */
678 SDL_RenderPresent(renderer);
679 _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE );
680 SDL_FreeSurface(referenceSurface);
681 referenceSurface = NULL;
682
683 /* Test Blend. */
684 _testBlitBlendMode( tface, SDL_BLENDMODE_BLEND );
685 referenceSurface = SDLTest_ImageBlitBlend();
686
687 /* Make current and compare */
688 SDL_RenderPresent(renderer);
689 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
690 SDL_FreeSurface(referenceSurface);
691 referenceSurface = NULL;
692
693 /* Test Add. */
694 _testBlitBlendMode( tface, SDL_BLENDMODE_ADD );
695 referenceSurface = SDLTest_ImageBlitBlendAdd();
696
697 /* Make current and compare */
698 SDL_RenderPresent(renderer);
699 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
700 SDL_FreeSurface(referenceSurface);
701 referenceSurface = NULL;
702
703 /* Test Mod. */
704 _testBlitBlendMode( tface, SDL_BLENDMODE_MOD);
705 referenceSurface = SDLTest_ImageBlitBlendMod();
706
707 /* Make current and compare */
708 SDL_RenderPresent(renderer);
709 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED );
710 SDL_FreeSurface(referenceSurface);
711 referenceSurface = NULL;
712
713 /* Clear surface. */
714 _clearScreen();
715
716 /* Loop blit. */
717 checkFailCount1 = 0;
718 checkFailCount2 = 0;
719 checkFailCount3 = 0;
720 checkFailCount4 = 0;
721 for (j=0; j <= nj; j+=4) {
722 for (i=0; i <= ni; i+=4) {
723
724 /* Set color mod. */
725 ret = SDL_SetTextureColorMod( tface, (255/nj)*j, (255/ni)*i, (255/nj)*j );
726 if (ret != 0) checkFailCount1++;
727
728 /* Set alpha mod. */
729 ret = SDL_SetTextureAlphaMod( tface, (100/ni)*i );
730 if (ret != 0) checkFailCount2++;
731
732 /* Crazy blending mode magic. */
733 mode = (i/4*j/4) % 4;
734 if (mode==0) mode = SDL_BLENDMODE_NONE;
735 else if (mode==1) mode = SDL_BLENDMODE_BLEND;
736 else if (mode==2) mode = SDL_BLENDMODE_ADD;
737 else if (mode==3) mode = SDL_BLENDMODE_MOD;
738 ret = SDL_SetTextureBlendMode( tface, (SDL_BlendMode)mode );
739 if (ret != 0) checkFailCount3++;
740
741 /* Blitting. */
742 rect.x = i;
743 rect.y = j;
744 ret = SDL_RenderCopy(renderer, tface, NULL, &rect );
745 if (ret != 0) checkFailCount4++;
746 }
747 }
748 SDLTest_AssertCheck(checkFailCount1 == 0, "Validate results from calls to SDL_SetTextureColorMod, expected: 0, got: %i", checkFailCount1);
749 SDLTest_AssertCheck(checkFailCount2 == 0, "Validate results from calls to SDL_SetTextureAlphaMod, expected: 0, got: %i", checkFailCount2);
750 SDLTest_AssertCheck(checkFailCount3 == 0, "Validate results from calls to SDL_SetTextureBlendMode, expected: 0, got: %i", checkFailCount3);
751 SDLTest_AssertCheck(checkFailCount4 == 0, "Validate results from calls to SDL_RenderCopy, expected: 0, got: %i", checkFailCount4);
752
753 /* Clean up. */
754 SDL_DestroyTexture( tface );
755
756 /* Make current */
757 SDL_RenderPresent(renderer);
758
759 /* Check to see if final image matches. */
760 referenceSurface = SDLTest_ImageBlitBlendAll();
761 _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
762 SDL_FreeSurface(referenceSurface);
763 referenceSurface = NULL;
764
765 return TEST_COMPLETED;
766}
767
768
769/**
770 * @brief Checks to see if functionality is supported. Helper function.
771 */
772static int
773_isSupported( int code )
774{
775 return (code == 0);
776}
777
778/**
779 * @brief Test to see if we can vary the draw color. Helper function.
780 *
781 * \sa
782 * http://wiki.libsdl.org/SDL_SetRenderDrawColor
783 * http://wiki.libsdl.org/SDL_GetRenderDrawColor
784 */
785static int
786_hasDrawColor (void)
787{
788 int ret, fail;
789 Uint8 r, g, b, a;
790
791 fail = 0;
792
793 /* Set color. */
794 ret = SDL_SetRenderDrawColor(renderer, 100, 100, 100, 100 );
795 if (!_isSupported(ret))
796 fail = 1;
797 ret = SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a );
798 if (!_isSupported(ret))
799 fail = 1;
800
801 /* Restore natural. */
802 ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE );
803 if (!_isSupported(ret))
804 fail = 1;
805
806 /* Something failed, consider not available. */
807 if (fail)
808 return 0;
809
810 /* Not set properly, consider failed. */
811 else if ((r != 100) || (g != 100) || (b != 100) || (a != 100))
812 return 0;
813 return 1;
814}
815
816/**
817 * @brief Test to see if we can vary the blend mode. Helper function.
818 *
819 * \sa
820 * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
821 * http://wiki.libsdl.org/SDL_GetRenderDrawBlendMode
822 */
823static int
824_hasBlendModes (void)
825{
826 int fail;
827 int ret;
828 SDL_BlendMode mode;
829
830 fail = 0;
831
832 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND );
833 if (!_isSupported(ret))
834 fail = 1;
835 ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
836 if (!_isSupported(ret))
837 fail = 1;
838 ret = (mode != SDL_BLENDMODE_BLEND);
839 if (!_isSupported(ret))
840 fail = 1;
841 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD );
842 if (!_isSupported(ret))
843 fail = 1;
844 ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
845 if (!_isSupported(ret))
846 fail = 1;
847 ret = (mode != SDL_BLENDMODE_ADD);
848 if (!_isSupported(ret))
849 fail = 1;
850 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_MOD );
851 if (!_isSupported(ret))
852 fail = 1;
853 ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
854 if (!_isSupported(ret))
855 fail = 1;
856 ret = (mode != SDL_BLENDMODE_MOD);
857 if (!_isSupported(ret))
858 fail = 1;
859 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
860 if (!_isSupported(ret))
861 fail = 1;
862 ret = SDL_GetRenderDrawBlendMode(renderer, &mode );
863 if (!_isSupported(ret))
864 fail = 1;
865 ret = (mode != SDL_BLENDMODE_NONE);
866 if (!_isSupported(ret))
867 fail = 1;
868
869 return !fail;
870}
871
872
873/**
874 * @brief Loads the test image 'Face' as texture. Helper function.
875 *
876 * \sa
877 * http://wiki.libsdl.org/SDL_CreateTextureFromSurface
878 */
879static SDL_Texture *
880_loadTestFace(void)
881{
882 SDL_Surface *face;
883 SDL_Texture *tface;
884
885 face = SDLTest_ImageFace();
886 if (face == NULL) {
887 return NULL;
888 }
889
890 tface = SDL_CreateTextureFromSurface(renderer, face);
891 if (tface == NULL) {
892 SDLTest_LogError("SDL_CreateTextureFromSurface() failed with error: %s", SDL_GetError());
893 }
894
895 SDL_FreeSurface(face);
896
897 return tface;
898}
899
900
901/**
902 * @brief Test to see if can set texture color mode. Helper function.
903 *
904 * \sa
905 * http://wiki.libsdl.org/SDL_SetTextureColorMod
906 * http://wiki.libsdl.org/SDL_GetTextureColorMod
907 * http://wiki.libsdl.org/SDL_DestroyTexture
908 */
909static int
910_hasTexColor (void)
911{
912 int fail;
913 int ret;
914 SDL_Texture *tface;
915 Uint8 r, g, b;
916
917 /* Get test face. */
918 tface = _loadTestFace();
919 if (tface == NULL)
920 return 0;
921
922 /* See if supported. */
923 fail = 0;
924 ret = SDL_SetTextureColorMod( tface, 100, 100, 100 );
925 if (!_isSupported(ret))
926 fail = 1;
927 ret = SDL_GetTextureColorMod( tface, &r, &g, &b );
928 if (!_isSupported(ret))
929 fail = 1;
930
931 /* Clean up. */
932 SDL_DestroyTexture( tface );
933
934 if (fail)
935 return 0;
936 else if ((r != 100) || (g != 100) || (b != 100))
937 return 0;
938 return 1;
939}
940
941/**
942 * @brief Test to see if we can vary the alpha of the texture. Helper function.
943 *
944 * \sa
945 * http://wiki.libsdl.org/SDL_SetTextureAlphaMod
946 * http://wiki.libsdl.org/SDL_GetTextureAlphaMod
947 * http://wiki.libsdl.org/SDL_DestroyTexture
948 */
949static int
950_hasTexAlpha(void)
951{
952 int fail;
953 int ret;
954 SDL_Texture *tface;
955 Uint8 a;
956
957 /* Get test face. */
958 tface = _loadTestFace();
959 if (tface == NULL)
960 return 0;
961
962 /* See if supported. */
963 fail = 0;
964 ret = SDL_SetTextureAlphaMod( tface, 100 );
965 if (!_isSupported(ret))
966 fail = 1;
967 ret = SDL_GetTextureAlphaMod( tface, &a );
968 if (!_isSupported(ret))
969 fail = 1;
970
971 /* Clean up. */
972 SDL_DestroyTexture( tface );
973
974 if (fail)
975 return 0;
976 else if (a != 100)
977 return 0;
978 return 1;
979}
980
981/**
982 * @brief Compares screen pixels with image pixels. Helper function.
983 *
984 * @param s Image to compare against.
985 *
986 * \sa
987 * http://wiki.libsdl.org/SDL_RenderReadPixels
988 * http://wiki.libsdl.org/SDL_CreateRGBSurfaceFrom
989 * http://wiki.libsdl.org/SDL_FreeSurface
990 */
991static void
992_compare(SDL_Surface *referenceSurface, int allowable_error)
993{
994 int result;
995 SDL_Rect rect;
996 Uint8 *pixels;
997 SDL_Surface *testSurface;
998
999 /* Read pixels. */
1000 pixels = (Uint8 *)SDL_malloc(4*TESTRENDER_SCREEN_W*TESTRENDER_SCREEN_H);
1001 SDLTest_AssertCheck(pixels != NULL, "Validate allocated temp pixel buffer");
1002 if (pixels == NULL) return;
1003
1004 /* Explicitly specify the rect in case the window isn't the expected size... */
1005 rect.x = 0;
1006 rect.y = 0;
1007 rect.w = TESTRENDER_SCREEN_W;
1008 rect.h = TESTRENDER_SCREEN_H;
1009 result = SDL_RenderReadPixels(renderer, &rect, RENDER_COMPARE_FORMAT, pixels, 80*4 );
1010 SDLTest_AssertCheck(result == 0, "Validate result from SDL_RenderReadPixels, expected: 0, got: %i", result);
1011
1012 /* Create surface. */
1013 testSurface = SDL_CreateRGBSurfaceFrom(pixels, TESTRENDER_SCREEN_W, TESTRENDER_SCREEN_H, 32, TESTRENDER_SCREEN_W*4,
1014 RENDER_COMPARE_RMASK, RENDER_COMPARE_GMASK, RENDER_COMPARE_BMASK, RENDER_COMPARE_AMASK);
1015 SDLTest_AssertCheck(testSurface != NULL, "Verify result from SDL_CreateRGBSurfaceFrom is not NULL");
1016
1017 /* Compare surface. */
1018 result = SDLTest_CompareSurfaces( testSurface, referenceSurface, allowable_error );
1019 SDLTest_AssertCheck(result == 0, "Validate result from SDLTest_CompareSurfaces, expected: 0, got: %i", result);
1020
1021 /* Clean up. */
1022 SDL_free(pixels);
1023 SDL_FreeSurface(testSurface);
1024}
1025
1026/**
1027 * @brief Clears the screen. Helper function.
1028 *
1029 * \sa
1030 * http://wiki.libsdl.org/SDL_SetRenderDrawColor
1031 * http://wiki.libsdl.org/SDL_RenderClear
1032 * http://wiki.libsdl.org/SDL_RenderPresent
1033 * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
1034 */
1035static int
1036_clearScreen(void)
1037{
1038 int ret;
1039
1040 /* Set color. */
1041 ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE );
1042 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
1043
1044 /* Clear screen. */
1045 ret = SDL_RenderClear(renderer);
1046 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_RenderClear, expected: 0, got: %i", ret);
1047
1048 /* Make current */
1049 SDL_RenderPresent(renderer);
1050
1051 /* Set defaults. */
1052 ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE );
1053 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawBlendMode, expected: 0, got: %i", ret);
1054
1055 ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE );
1056 SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetRenderDrawColor, expected: 0, got: %i", ret);
1057
1058 return 0;
1059}
1060
1061/* ================= Test References ================== */
1062
1063/* Render test cases */
1064static const SDLTest_TestCaseReference renderTest1 =
1065 { (SDLTest_TestCaseFp)render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED };
1066
1067static const SDLTest_TestCaseReference renderTest2 =
1068 { (SDLTest_TestCaseFp)render_testPrimitives, "render_testPrimitives", "Tests rendering primitives", TEST_ENABLED };
1069
1070/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1071static const SDLTest_TestCaseReference renderTest3 =
1072 { (SDLTest_TestCaseFp)render_testPrimitivesBlend, "render_testPrimitivesBlend", "Tests rendering primitives with blending", TEST_DISABLED };
1073
1074static const SDLTest_TestCaseReference renderTest4 =
1075 { (SDLTest_TestCaseFp)render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED };
1076
1077static const SDLTest_TestCaseReference renderTest5 =
1078 { (SDLTest_TestCaseFp)render_testBlitColor, "render_testBlitColor", "Tests blitting with color", TEST_ENABLED };
1079
1080/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1081static const SDLTest_TestCaseReference renderTest6 =
1082 { (SDLTest_TestCaseFp)render_testBlitAlpha, "render_testBlitAlpha", "Tests blitting with alpha", TEST_DISABLED };
1083
1084/* TODO: rewrite test case, define new test data and re-enable; current implementation fails */
1085static const SDLTest_TestCaseReference renderTest7 =
1086 { (SDLTest_TestCaseFp)render_testBlitBlend, "render_testBlitBlend", "Tests blitting with blending", TEST_DISABLED };
1087
1088/* Sequence of Render test cases */
1089static const SDLTest_TestCaseReference *renderTests[] = {
1090 &renderTest1, &renderTest2, &renderTest3, &renderTest4, &renderTest5, &renderTest6, &renderTest7, NULL
1091};
1092
1093/* Render test suite (global) */
1094SDLTest_TestSuiteReference renderTestSuite = {
1095 "Render",
1096 InitCreateRenderer,
1097 renderTests,
1098 CleanupDestroyRenderer
1099};
1100