Debian Codegraph @

test/testautomation_render.c

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