SDL  2.0
testautomation_render.c
Go to the documentation of this file.
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  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  */
66 void 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/moin.cgi/SDL_GetNumRenderDrivers
87  */
88 int
89 render_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/moin.cgi/SDL_SetRenderDrawColor
103  * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
104  * http://wiki.libsdl.org/moin.cgi/SDL_RenderDrawLine
105  *
106  */
107 int 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/moin.cgi/SDL_SetRenderDrawColor
210  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
211  * http://wiki.libsdl.org/moin.cgi/SDL_RenderFillRect
212  */
213 int 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/moin.cgi/SDL_RenderCopy
359  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
360  */
361 int
362 render_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/moin.cgi/SDL_SetTextureColorMod
428  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
429  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
430  */
431 int
432 render_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/moin.cgi/SDL_SetTextureAlphaMod
502  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
503  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
504  */
505 int
506 render_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/moin.cgi/SDL_SetTextureBlendMode
580  * http://wiki.libsdl.org/moin.cgi/SDL_RenderCopy
581  */
582 static 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/moin.cgi/SDL_SetTextureColorMod
630  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureAlphaMod
631  * http://wiki.libsdl.org/moin.cgi/SDL_SetTextureBlendMode
632  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
633  */
634 int
635 render_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  */
772 static 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/moin.cgi/SDL_SetRenderDrawColor
783  * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawColor
784  */
785 static 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/moin.cgi/SDL_SetRenderDrawBlendMode
821  * http://wiki.libsdl.org/moin.cgi/SDL_GetRenderDrawBlendMode
822  */
823 static 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/moin.cgi/SDL_CreateTextureFromSurface
878  */
879 static 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/moin.cgi/SDL_SetTextureColorMod
906  * http://wiki.libsdl.org/moin.cgi/SDL_GetTextureColorMod
907  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
908  */
909 static 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/moin.cgi/SDL_SetTextureAlphaMod
946  * http://wiki.libsdl.org/moin.cgi/SDL_GetTextureAlphaMod
947  * http://wiki.libsdl.org/moin.cgi/SDL_DestroyTexture
948  */
949 static 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/moin.cgi/SDL_RenderReadPixels
988  * http://wiki.libsdl.org/moin.cgi/SDL_CreateRGBSurfaceFrom
989  * http://wiki.libsdl.org/moin.cgi/SDL_FreeSurface
990  */
991 static 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/moin.cgi/SDL_SetRenderDrawColor
1031  * http://wiki.libsdl.org/moin.cgi/SDL_RenderClear
1032  * http://wiki.libsdl.org/moin.cgi/SDL_RenderPresent
1033  * http://wiki.libsdl.org/moin.cgi/SDL_SetRenderDrawBlendMode
1034  */
1035 static 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 */
1064 static const SDLTest_TestCaseReference renderTest1 =
1065  { (SDLTest_TestCaseFp)render_testGetNumRenderDrivers, "render_testGetNumRenderDrivers", "Tests call to SDL_GetNumRenderDrivers", TEST_ENABLED };
1066 
1067 static 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 */
1071 static const SDLTest_TestCaseReference renderTest3 =
1072  { (SDLTest_TestCaseFp)render_testPrimitivesBlend, "render_testPrimitivesBlend", "Tests rendering primitives with blending", TEST_DISABLED };
1073 
1074 static const SDLTest_TestCaseReference renderTest4 =
1075  { (SDLTest_TestCaseFp)render_testBlit, "render_testBlit", "Tests blitting", TEST_ENABLED };
1076 
1077 static 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 */
1081 static 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 */
1085 static const SDLTest_TestCaseReference renderTest7 =
1086  { (SDLTest_TestCaseFp)render_testBlitBlend, "render_testBlitBlend", "Tests blitting with blending", TEST_DISABLED };
1087 
1088 /* Sequence of Render test cases */
1089 static const SDLTest_TestCaseReference *renderTests[] = {
1090  &renderTest1, &renderTest2, &renderTest3, &renderTest4, &renderTest5, &renderTest6, &renderTest7, NULL
1091 };
1092 
1093 /* Render test suite (global) */
1094 SDLTest_TestSuiteReference renderTestSuite = {
1095  "Render",
1096  InitCreateRenderer,
1097  renderTests,
1098  CleanupDestroyRenderer
1099 };