1 /*
2
3 TestGfxPrimitives.c: test graphics primitive routines for
4 accuracy (visual) and speed.
5
6 (C) A. Schiffler, June 2001, zlib License
7
8 */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <math.h>
14 #include <time.h>
15
16 #include "SDL.h"
17
18 #ifdef WIN32
19 #include "SDL_gfxPrimitives.h"
20 #else
21 #include "SDL/SDL_gfxPrimitives.h"
22 #endif
23
24 #define WIDTH 640
25 #define HEIGHT 480
26
27 #define NUM_RANDOM 512
28
29 /* Coordinates */
30 static Sint16 rx1[NUM_RANDOM], rx2[NUM_RANDOM], ry1[NUM_RANDOM], ry2[NUM_RANDOM];
31
32 /* Triangles */
33 static Sint16 tx1[NUM_RANDOM][3], tx2[NUM_RANDOM][3], ty1[NUM_RANDOM][3], ty2[NUM_RANDOM][3];
34
35 /* Squares (made of 2 triangles) */
36 static Sint16 sx1[NUM_RANDOM][6], sx2[NUM_RANDOM][6], sy1[NUM_RANDOM][6], sy2[NUM_RANDOM][6];
37
38 /* Line widths */
39 static Uint8 lw[NUM_RANDOM];
40
41 /* Radii and offsets */
42 static Sint16 rr1[NUM_RANDOM], rr2[NUM_RANDOM];
43
44 /* Start and stop angles */
45 static Sint16 a1[NUM_RANDOM], a2[NUM_RANDOM];
46
47 /* RGB colors and alpha */
48 static char rr[NUM_RANDOM], rg[NUM_RANDOM], rb[NUM_RANDOM], ra[NUM_RANDOM];
49
50 /* Generate an array of random screen coordinates and RGBA values with an offset */
51
InitRandomPoints()52 void InitRandomPoints()
53 {
54 int i;
55 float af;
56
57 for (i=0; i<NUM_RANDOM; i++) {
58 /* Random points in the 4 quadrants */
59 rx1[i]=rand() % (WIDTH/2);
60 rx2[i]=WIDTH/2+rx1[i];
61 ry1[i]=60+(rand() % ((HEIGHT-80)/2));
62 ry2[i]=20+((HEIGHT-80)/2)+ry1[i];
63
64 /* 5-Pixel Triangle */
65 tx1[i][0]=rx1[i];
66 tx2[i][0]=rx2[i];
67 ty1[i][0]=ry1[i];
68 ty2[i][0]=ry2[i];
69 tx1[i][1]=rx1[i]+1;
70 tx2[i][1]=rx2[i]+1;
71 ty1[i][1]=ry1[i]+2;
72 ty2[i][1]=ry2[i]+2;
73 tx1[i][2]=rx1[i]+2;
74 tx2[i][2]=rx2[i]+2;
75 ty1[i][2]=ry1[i]+1;
76 ty2[i][2]=ry2[i]+1;
77
78 /* 10x10 square made from 3 triangles */
79 sx1[i][0]=rx1[i];
80 sx2[i][0]=rx2[i];
81 sy1[i][0]=ry1[i];
82 sy2[i][0]=ry2[i];
83 sx1[i][1]=rx1[i]+10;
84 sx2[i][1]=rx2[i]+10;
85 sy1[i][1]=ry1[i];
86 sy2[i][1]=ry2[i];
87 sx1[i][2]=rx1[i];
88 sx2[i][2]=rx2[i];
89 sy1[i][2]=ry1[i]+10;
90 sy2[i][2]=ry2[i]+10;
91 sx1[i][3]=rx1[i];
92 sx2[i][3]=rx2[i];
93 sy1[i][3]=ry1[i]+10;
94 sy2[i][3]=ry2[i]+10;
95 sx1[i][4]=rx1[i]+10;
96 sx2[i][4]=rx2[i]+10;
97 sy1[i][4]=ry1[i];
98 sy2[i][4]=ry2[i];
99 sx1[i][5]=rx1[i]+10;
100 sx2[i][5]=rx2[i]+10;
101 sy1[i][5]=ry1[i]+10;
102 sy2[i][5]=ry2[i]+10;
103
104 /* Line widths */
105 lw[i]=2 + (rand() % 7);
106
107 /* Random Radii */
108 rr1[i]=rand() % 32;
109 rr2[i]=rand() % 32;
110
111 /* Random Angles */
112 a1[i]=rand() % 360;
113 a2[i]=rand() % 360;
114
115 /* Random Colors */
116 rr[i]=rand() & 255;
117 rg[i]=rand() & 255;
118 rb[i]=rand() & 255;
119
120 /* X-position dependent Alpha */
121 af=((float)rx1[i]/(float)(WIDTH/2));
122 ra[i]=(int)(255.0*af);
123 }
124 }
125
126 #define BORDER 10
127
128 /* Set a clipping rectangle based on a rect with a border */
129
SetClip(SDL_Surface * screen,int x1,int y1,int x2,int y2)130 void SetClip (SDL_Surface *screen, int x1, int y1, int x2, int y2)
131 {
132 SDL_Rect clip;
133 clip.x = x1+BORDER;
134 clip.y = y1+BORDER;
135 clip.w = x2-x1-2*BORDER;
136 clip.h = y2-y1-2*BORDER;
137 SDL_SetClipRect(screen, &clip);
138 }
139
SetClipNoBorder(SDL_Surface * screen,int x1,int y1,int x2,int y2)140 void SetClipNoBorder (SDL_Surface *screen, int x1, int y1, int x2, int y2)
141 {
142 SDL_Rect clip;
143 clip.x = x1;
144 clip.y = y1;
145 clip.w = x2-x1;
146 clip.h = y2-y1;
147 SDL_SetClipRect(screen, &clip);
148 }
149
ClearScreen(SDL_Surface * screen,char * title)150 void ClearScreen(SDL_Surface *screen, char *title)
151 {
152 int x,y;
153 float stepx, stepy, fx, fy, fxy;
154 char titletext[257];
155 Uint32 color;
156
157 /* Setup clear color color */
158 if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
159 color=SDL_MapRGBA(screen->format, 0,0,0,0);
160 } else {
161 color=SDL_MapRGBA(screen->format, 0,0,0,0);
162 }
163
164 /* Clear the screen */
165 SetClipNoBorder (screen,0,0,WIDTH-1,HEIGHT-1);
166 SDL_FillRect (screen, NULL, color);
167
168 /* Draw the colored area */
169 stepx=1.0f/(WIDTH/2);
170 stepy=1.0f/((HEIGHT-80)/2);
171 fx=0.0;
172 for (x=WIDTH/2; x<WIDTH; x++) {
173 fy=0.0;
174 for (y=(HEIGHT-40)/2+60; y<HEIGHT; y++) {
175 fxy=1.0f-fx*fy;
176 pixelRGBA(screen,x,y,(int)(128.0*fx*fx),(int)(128.0*fxy*fxy),(int)(128.0*fy*fy),255);
177 fy += stepy;
178 }
179 fx += stepx;
180 }
181 /* Segment and titles */
182 hlineRGBA(screen, 0, WIDTH, 20-1, 255,255,255,255);
183 hlineRGBA(screen, 0, WIDTH, 60-1, 255,255,255,255);
184 hlineRGBA(screen, 0, WIDTH, (HEIGHT-40)/2+40+1, 255,255,255,255);
185 hlineRGBA(screen, 0, WIDTH, (HEIGHT-40)/2+60-1, 255,255,255,255);
186 vlineRGBA(screen, WIDTH/2, 20, HEIGHT, 255,255,255,255);
187 strncpy(titletext,"Current Primitive: ",256);
188 strncat(titletext,title,256);
189 strncat(titletext," - Click to continue. Key to Quit.",256);
190 stringRGBA (screen, WIDTH/2-4*(Sint16)strlen(titletext),10-4,titletext,255,255,255,255);
191 strncpy(titletext,"A=255 on Black",256);
192 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),50-4,titletext,255,255,255,255);
193 strncpy(titletext,"A=0-254 on Black",256);
194 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),50-4,titletext,255,255,255,255);
195 strncpy(titletext,"A=255, Color Test",256);
196 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),(HEIGHT-40)/2+50-4,titletext,255,255,255,255);
197 strncpy(titletext,"A=0-254 on Color",256);
198 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),(HEIGHT-40)/2+50-4,titletext,255,255,255,255);
199 }
200
201 /* ======== Test and Benchmark routines ======= */
202
TestPixel(SDL_Surface * screen)203 void TestPixel(SDL_Surface *screen)
204 {
205 int i;
206 char r,g,b;
207
208 /* Create random points */
209 srand((int)time(NULL));
210 InitRandomPoints();
211
212 /* Draw A=255 */
213 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
214 for (i=0; i<NUM_RANDOM; i++) {
215 pixelRGBA(screen, rx1[i], ry1[i], rr[i], rg[i], rb[i], 255);
216 }
217
218 /* Draw A=various */
219 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
220 for (i=0; i<NUM_RANDOM; i++) {
221 pixelRGBA(screen, rx2[i], ry1[i], rr[i], rg[i], rb[i], ra[i]);
222 }
223
224 /* Draw A=various */
225 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
226 for (i=0; i<NUM_RANDOM; i++) {
227 pixelRGBA(screen, rx2[i], ry2[i], rr[i], rg[i], rb[i], ra[i]);
228 }
229
230 /* Draw Colortest */
231 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
232 for (i=0; i<NUM_RANDOM; i++) {
233 if (rx1[i] < (WIDTH/6)) {
234 r=255; g=0; b=0;
235 } else if (rx1[i] < (WIDTH/3) ) {
236 r=0; g=255; b=0;
237 } else {
238 r=0; g=0; b=255;
239 }
240 pixelRGBA(screen, rx1[i], ry2[i], r, g, b, 255);
241 }
242 }
243
BenchmarkPixel(SDL_Surface * screen)244 void BenchmarkPixel(SDL_Surface *screen)
245 {
246 int i,j;
247 int repeat;
248 Uint32 time1, time2;
249 char titletext[256];
250
251 /* Draw A=255 */
252 repeat=200;
253 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
254 time1=SDL_GetTicks();
255 for (j=0; j<repeat; j++) {
256 for (i=0; i<NUM_RANDOM; i++) {
257 pixelRGBA(screen, rx1[i], ry1[i], rr[i], rg[i], rb[i], 255);
258 }
259 }
260 time2=SDL_GetTicks();
261 /* Results */
262 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
263 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
264 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
265
266 /* Draw A=various */
267 repeat=100;
268 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
269 time1=SDL_GetTicks();
270 for (j=0; j<repeat; j++) {
271 for (i=0; i<NUM_RANDOM; i++) {
272 pixelRGBA(screen, rx2[i], ry1[i], rr[i], rg[i], rb[i], ra[i]);
273 }
274 }
275 time2=SDL_GetTicks();
276
277 /* Results */
278 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
279 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
280 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
281 }
282
TestHline(SDL_Surface * screen)283 void TestHline(SDL_Surface *screen)
284 {
285 int i;
286 char r,g,b;
287
288 /* Create random points */
289 srand((int)time(NULL));
290 InitRandomPoints();
291
292 /* Draw A=255 */
293 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
294 for (i=0; i<NUM_RANDOM; i += 2) {
295 hlineRGBA(screen, rx1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
296 }
297
298 /* Draw A=various */
299 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
300 for (i=0; i<NUM_RANDOM; i += 2) {
301 hlineRGBA(screen, rx2[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
302 }
303
304 /* Draw A=various */
305 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
306 for (i=0; i<NUM_RANDOM; i += 2) {
307 hlineRGBA(screen, rx2[i], rx2[i+1], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
308 }
309
310 /* Draw Colortest */
311 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
312 for (i=0; i<NUM_RANDOM; i += 2) {
313 if (rx1[i] < (WIDTH/6)) {
314 r=255; g=0; b=0;
315 } else if (rx1[i] < (WIDTH/3) ) {
316 r=0; g=255; b=0;
317 } else {
318 r=0; g=0; b=255;
319 }
320 hlineRGBA(screen, rx1[i], rx1[i]+rr1[i], ry2[i+1], r, g, b, 255);
321 }
322 }
323
BenchmarkHline(SDL_Surface * screen)324 void BenchmarkHline(SDL_Surface *screen)
325 {
326 int i,j;
327 int repeat;
328 Uint32 time1, time2;
329 char titletext[256];
330
331 /* Draw A=255 */
332 repeat=200;
333 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
334 time1=SDL_GetTicks();
335 for (j=0; j<repeat; j++) {
336 for (i=0; i<NUM_RANDOM; i++) {
337 hlineRGBA(screen, rx1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
338 }
339 }
340 time2=SDL_GetTicks();
341 /* Results */
342 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
343 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
344 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
345
346 /* Draw A=various */
347 repeat=100;
348 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
349 time1=SDL_GetTicks();
350 for (j=0; j<repeat; j++) {
351 for (i=0; i<NUM_RANDOM; i++) {
352 hlineRGBA(screen, rx2[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
353 }
354 }
355 time2=SDL_GetTicks();
356
357 /* Results */
358 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
359 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
360 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
361
362 }
363
TestVline(SDL_Surface * screen)364 void TestVline(SDL_Surface *screen)
365 {
366 int i;
367 char r,g,b;
368
369 /* Create random points */
370 srand((int)time(NULL));
371 InitRandomPoints();
372
373 /* Draw A=255 */
374 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
375 for (i=0; i<NUM_RANDOM; i += 2) {
376 vlineRGBA(screen, rx1[i], ry1[i], ry1[i+1], rr[i], rg[i], rb[i], 255);
377 }
378
379 /* Draw A=various */
380 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
381 for (i=0; i<NUM_RANDOM; i += 2) {
382 vlineRGBA(screen, rx2[i], ry1[i], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
383 }
384
385 /* Draw A=various */
386 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
387 for (i=0; i<NUM_RANDOM; i += 2) {
388 vlineRGBA(screen, rx2[i], ry2[i], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
389 }
390
391 /* Draw Colortest */
392 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
393 for (i=0; i<NUM_RANDOM; i += 2) {
394 if (rx1[i] < (WIDTH/6)) {
395 r=255; g=0; b=0;
396 } else if (rx1[i] < (WIDTH/3) ) {
397 r=0; g=255; b=0;
398 } else {
399 r=0; g=0; b=255;
400 }
401 vlineRGBA(screen, rx1[i], ry2[i], ry2[i]+rr1[i], r, g, b, 255);
402 }
403 }
404
BenchmarkVline(SDL_Surface * screen)405 void BenchmarkVline(SDL_Surface *screen)
406 {
407 int i,j;
408 int repeat;
409 Uint32 time1, time2;
410 char titletext[256];
411
412 /* Draw A=255 */
413 repeat=200;
414 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
415 time1=SDL_GetTicks();
416 for (j=0; j<repeat; j++) {
417 for (i=0; i<NUM_RANDOM; i++) {
418 vlineRGBA(screen, rx1[i], ry1[i], ry1[i+1], rr[i], rg[i], rb[i], 255);
419 }
420 }
421 time2=SDL_GetTicks();
422 /* Results */
423 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
424 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
425 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
426
427 /* Draw A=various */
428 repeat=100;
429 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
430 time1=SDL_GetTicks();
431 for (j=0; j<repeat; j++) {
432 for (i=0; i<NUM_RANDOM; i++) {
433 vlineRGBA(screen, rx2[i], ry1[i], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
434 }
435 }
436 time2=SDL_GetTicks();
437
438 /* Results */
439 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
440 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
441 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
442
443 }
444
TestRectangle(SDL_Surface * screen)445 void TestRectangle(SDL_Surface *screen)
446 {
447 int i;
448 char r,g,b;
449
450 /* Create random points */
451 srand((int)time(NULL));
452 InitRandomPoints();
453
454 /* Draw A=255 */
455 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
456 for (i=0; i<NUM_RANDOM; i += 2) {
457 rectangleRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
458 }
459
460 /* Draw A=various */
461 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
462 for (i=0; i<NUM_RANDOM; i += 2) {
463 rectangleRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
464 }
465
466 /* Draw A=various */
467 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
468 for (i=0; i<NUM_RANDOM; i += 2) {
469 rectangleRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
470 }
471
472 /* Draw Colortest */
473 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
474 for (i=0; i<NUM_RANDOM; i += 2) {
475 if (rx1[i] < (WIDTH/6)) {
476 r=255; g=0; b=0;
477 } else if (rx1[i] < (WIDTH/3) ) {
478 r=0; g=255; b=0;
479 } else {
480 r=0; g=0; b=255;
481 }
482 rectangleRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], r, g, b, 255);
483 }
484 }
485
BenchmarkRectangle(SDL_Surface * screen)486 void BenchmarkRectangle(SDL_Surface *screen)
487 {
488 int i,j;
489 int repeat;
490 Uint32 time1, time2;
491 char titletext[256];
492
493 /* Draw A=255 */
494 repeat=200;
495 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
496 time1=SDL_GetTicks();
497 for (j=0; j<repeat; j++) {
498 for (i=0; i<NUM_RANDOM; i += 2) {
499 rectangleRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
500 }
501 }
502 time2=SDL_GetTicks();
503 /* Results */
504 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
505 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
506 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
507
508 /* Draw A=various */
509 repeat=10;
510 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
511 time1=SDL_GetTicks();
512 for (j=0; j<repeat; j++) {
513 for (i=0; i<NUM_RANDOM; i += 2) {
514 rectangleRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
515 }
516 }
517 time2=SDL_GetTicks();
518
519 /* Results */
520 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
521 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
522 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
523 }
524
TestRoundedRectangle(SDL_Surface * screen)525 void TestRoundedRectangle(SDL_Surface *screen)
526 {
527 int i;
528 char r,g,b;
529
530 /* Create random points */
531 srand((int)time(NULL));
532 InitRandomPoints();
533
534 /* Draw A=255 */
535 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
536 for (i=0; i<NUM_RANDOM; i += 2) {
537 roundedRectangleRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], 255);
538 }
539
540 /* Draw A=various */
541 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
542 for (i=0; i<NUM_RANDOM; i += 2) {
543 roundedRectangleRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
544 }
545
546 /* Draw A=various */
547 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
548 for (i=0; i<NUM_RANDOM; i += 2) {
549 roundedRectangleRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
550 }
551
552 /* Draw Colortest */
553 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
554 for (i=0; i<NUM_RANDOM; i += 2) {
555 if (rx1[i] < (WIDTH/6)) {
556 r=255; g=0; b=0;
557 } else if (rx1[i] < (WIDTH/3) ) {
558 r=0; g=255; b=0;
559 } else {
560 r=0; g=0; b=255;
561 }
562 roundedRectangleRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], 4, r, g, b, 255);
563 }
564 }
565
BenchmarkRoundedRectangle(SDL_Surface * screen)566 void BenchmarkRoundedRectangle(SDL_Surface *screen)
567 {
568 int i,j;
569 int repeat;
570 Uint32 time1, time2;
571 char titletext[256];
572
573 /* Draw A=255 */
574 repeat=200;
575 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
576 time1=SDL_GetTicks();
577 for (j=0; j<repeat; j++) {
578 for (i=0; i<NUM_RANDOM; i += 2) {
579 roundedRectangleRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], 255);
580 }
581 }
582 time2=SDL_GetTicks();
583 /* Results */
584 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
585 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
586 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
587
588 /* Draw A=various */
589 repeat=10;
590 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
591 time1=SDL_GetTicks();
592 for (j=0; j<repeat; j++) {
593 for (i=0; i<NUM_RANDOM; i += 2) {
594 roundedRectangleRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
595 }
596 }
597 time2=SDL_GetTicks();
598
599 /* Results */
600 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
601 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
602 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
603 }
604
TestRoundedBox(SDL_Surface * screen)605 void TestRoundedBox(SDL_Surface *screen)
606 {
607 int i;
608 char r,g,b;
609
610 /* Create random points */
611 srand((int)time(NULL));
612 InitRandomPoints();
613
614 /* Draw A=255 */
615 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
616 for (i=0; i<NUM_RANDOM; i += 4) {
617 roundedBoxRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], 255);
618 }
619
620 /* Draw A=various */
621 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
622 for (i=0; i<NUM_RANDOM; i += 4) {
623 roundedBoxRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
624 }
625
626 /* Draw A=various */
627 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
628 for (i=0; i<NUM_RANDOM; i += 4) {
629 roundedBoxRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
630 }
631
632 /* Draw Colortest */
633 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
634 for (i=0; i<NUM_RANDOM; i += 4) {
635 if (rx1[i] < (WIDTH/6)) {
636 r=255; g=0; b=0;
637 } else if (rx1[i] < (WIDTH/3) ) {
638 r=0; g=255; b=0;
639 } else {
640 r=0; g=0; b=255;
641 }
642 roundedBoxRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], 4, r, g, b, 255);
643 }
644 }
645
BenchmarkRoundedBox(SDL_Surface * screen)646 void BenchmarkRoundedBox(SDL_Surface *screen)
647 {
648 int i,j;
649 int repeat;
650 Uint32 time1, time2;
651 char titletext[256];
652
653 /* Draw A=255 */
654 repeat=200;
655 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
656 time1=SDL_GetTicks();
657 for (j=0; j<repeat; j++) {
658 for (i=0; i<NUM_RANDOM; i += 4) {
659 roundedBoxRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], 255);
660 }
661 }
662 time2=SDL_GetTicks();
663 /* Results */
664 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
665 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
666 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
667
668 /* Draw A=various */
669 repeat=10;
670 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
671 time1=SDL_GetTicks();
672 for (j=0; j<repeat; j++) {
673 for (i=0; i<NUM_RANDOM; i += 4) {
674 roundedBoxRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], 4, rr[i], rg[i], rb[i], ra[i]);
675 }
676 }
677 time2=SDL_GetTicks();
678
679 /* Results */
680 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
681 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/4)*repeat)/(float)(time2-time1));
682 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
683 }
684
TestBoxTwo(SDL_Surface * screen)685 void TestBoxTwo(SDL_Surface *screen)
686 {
687 int i;
688 char r,g,b;
689
690 /* Create random points */
691 srand((int)time(NULL));
692 InitRandomPoints();
693
694 /* Draw A=255 */
695 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
696 for (i=0; i<NUM_RANDOM; i++) {
697 boxRGBA(screen, rx1[i], ry1[i], rx1[i]+1, ry1[i]+1, rr[i], rg[i], rb[i], 255);
698 }
699
700 /* Draw A=various */
701 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
702 for (i=0; i<NUM_RANDOM; i++) {
703 boxRGBA(screen, rx2[i], ry1[i], rx2[i]+1, ry1[i]+1, rr[i], rg[i], rb[i], ra[i]);
704 }
705
706 /* Draw A=various */
707 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
708 for (i=0; i<NUM_RANDOM; i++) {
709 boxRGBA(screen, rx2[i], ry2[i], rx2[i]+1, ry2[i]+1, rr[i], rg[i], rb[i], ra[i]);
710 }
711
712 /* Draw Colortest */
713 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
714 for (i=0; i<NUM_RANDOM; i++) {
715 if (rx1[i] < (WIDTH/6)) {
716 r=255; g=0; b=0;
717 } else if (rx1[i] < (WIDTH/3) ) {
718 r=0; g=255; b=0;
719 } else {
720 r=0; g=0; b=255;
721 }
722 boxRGBA(screen, rx1[i], ry2[i], rx1[i]+1, ry2[i]+1, r, g, b, 255);
723 }
724 }
725
BenchmarkBoxTwo(SDL_Surface * screen)726 void BenchmarkBoxTwo(SDL_Surface *screen)
727 {
728 int i,j;
729 int repeat;
730 Uint32 time1, time2;
731 char titletext[256];
732
733 /* Draw A=255 */
734 repeat=50;
735 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
736 time1=SDL_GetTicks();
737 for (j=0; j<repeat; j++) {
738 for (i=0; i<NUM_RANDOM; i++) {
739 boxRGBA(screen, rx1[i], ry1[i], rx1[i]+1, ry1[i]+1, rr[i], rg[i], rb[i], 255);
740 }
741 }
742 time2=SDL_GetTicks();
743 /* Results */
744 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
745 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
746 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
747
748 /* Draw A=various */
749 repeat=50;
750 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
751 time1=SDL_GetTicks();
752 for (j=0; j<repeat; j++) {
753 for (i=0; i<NUM_RANDOM; i++) {
754 boxRGBA(screen, rx2[i], ry1[i], rx2[i]+1, ry1[i]+1, rr[i], rg[i], rb[i], ra[i]);
755 }
756 }
757 time2=SDL_GetTicks();
758
759 /* Results */
760 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
761 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
762 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
763
764 }
765
TestBox(SDL_Surface * screen)766 void TestBox(SDL_Surface *screen)
767 {
768 int i;
769 char r,g,b;
770
771 /* Create random points */
772 srand((int)time(NULL));
773 InitRandomPoints();
774
775 /* Draw A=255 */
776 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
777 for (i=0; i<NUM_RANDOM; i += 2) {
778 boxRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
779 }
780
781 /* Draw A=various */
782 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
783 for (i=0; i<NUM_RANDOM; i += 2) {
784 boxRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
785 }
786
787 /* Draw A=various */
788 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
789 for (i=0; i<NUM_RANDOM; i += 2) {
790 boxRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
791 }
792
793 /* Draw Colortest */
794 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
795 for (i=0; i<NUM_RANDOM; i += 2) {
796 if (rx1[i] < (WIDTH/6)) {
797 r=255; g=0; b=0;
798 } else if (rx1[i] < (WIDTH/3) ) {
799 r=0; g=255; b=0;
800 } else {
801 r=0; g=0; b=255;
802 }
803 boxRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], r, g, b, 255);
804 }
805 }
806
BenchmarkBox(SDL_Surface * screen)807 void BenchmarkBox(SDL_Surface *screen)
808 {
809 int i,j;
810 int repeat;
811 Uint32 time1, time2;
812 char titletext[256];
813
814 /* Draw A=255 */
815 repeat=10;
816 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
817 time1=SDL_GetTicks();
818 for (j=0; j<repeat; j++) {
819 for (i=0; i<NUM_RANDOM; i += 2) {
820 boxRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
821 }
822 }
823 time2=SDL_GetTicks();
824 /* Results */
825 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
826 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
827 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
828
829 /* Draw A=various */
830 repeat=1;
831 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
832 time1=SDL_GetTicks();
833 for (j=0; j<repeat; j++) {
834 for (i=0; i<NUM_RANDOM; i += 2) {
835 boxRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
836 }
837 }
838 time2=SDL_GetTicks();
839
840 /* Results */
841 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
842 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
843 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
844
845 }
846
TestLine(SDL_Surface * screen)847 void TestLine(SDL_Surface *screen)
848 {
849 int i;
850 char r,g,b;
851
852 /* Create random points */
853 srand((int)time(NULL));
854 InitRandomPoints();
855
856 /* Draw A=255 */
857 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
858 for (i=0; i<NUM_RANDOM; i += 2) {
859 lineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
860 }
861
862 /* Draw A=various */
863 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
864 for (i=0; i<NUM_RANDOM; i += 2) {
865 lineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
866 }
867
868 /* Draw A=various */
869 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
870 for (i=0; i<NUM_RANDOM; i += 2) {
871 lineRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
872 }
873
874 /* Draw Colortest */
875 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
876 for (i=0; i<NUM_RANDOM; i += 2) {
877 if (rx1[i] < (WIDTH/6)) {
878 r=255; g=0; b=0;
879 } else if (rx1[i] < (WIDTH/3) ) {
880 r=0; g=255; b=0;
881 } else {
882 r=0; g=0; b=255;
883 }
884 lineRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], r, g, b, 255);
885 }
886 }
887
BenchmarkLine(SDL_Surface * screen)888 void BenchmarkLine(SDL_Surface *screen)
889 {
890 int i,j;
891 int repeat;
892 Uint32 time1, time2;
893 char titletext[256];
894
895 /* Draw A=255 */
896 repeat=100;
897 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
898 time1=SDL_GetTicks();
899 for (j=0; j<repeat; j++) {
900 for (i=0; i<NUM_RANDOM; i += 2) {
901 lineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
902 }
903 }
904 time2=SDL_GetTicks();
905 /* Results */
906 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
907 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
908 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
909
910 /* Draw A=various */
911 repeat=5;
912 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
913 time1=SDL_GetTicks();
914 for (j=0; j<repeat; j++) {
915 for (i=0; i<NUM_RANDOM; i += 2) {
916 lineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
917 }
918 }
919 time2=SDL_GetTicks();
920
921 /* Results */
922 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
923 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
924 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
925
926 }
927
TestAALine(SDL_Surface * screen)928 void TestAALine(SDL_Surface *screen)
929 {
930 int i;
931 char r,g,b;
932
933 /* Create random points */
934 srand((int)time(NULL));
935 InitRandomPoints();
936
937 /* Draw A=255 */
938 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
939 for (i=0; i<NUM_RANDOM; i += 2) {
940 aalineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
941 }
942
943 /* Draw A=various */
944 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
945 for (i=0; i<NUM_RANDOM; i += 2) {
946 aalineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
947 }
948
949 /* Draw A=various */
950 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
951 for (i=0; i<NUM_RANDOM; i += 2) {
952 aalineRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], rr[i], rg[i], rb[i], ra[i]);
953 }
954
955 /* Draw Colortest */
956 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
957 for (i=0; i<NUM_RANDOM; i += 2) {
958 if (rx1[i] < (WIDTH/6)) {
959 r=255; g=0; b=0;
960 } else if (rx1[i] < (WIDTH/3) ) {
961 r=0; g=255; b=0;
962 } else {
963 r=0; g=0; b=255;
964 }
965 aalineRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], r, g, b, 255);
966 }
967 }
968
BenchmarkAALine(SDL_Surface * screen)969 void BenchmarkAALine(SDL_Surface *screen)
970 {
971 int i,j;
972 int repeat;
973 Uint32 time1, time2;
974 char titletext[256];
975
976 /* Draw A=255 */
977 repeat=5;
978 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
979 time1=SDL_GetTicks();
980 for (j=0; j<repeat; j++) {
981 for (i=0; i<NUM_RANDOM; i += 2) {
982 aalineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], rr[i], rg[i], rb[i], 255);
983 }
984 }
985 time2=SDL_GetTicks();
986 /* Results */
987 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
988 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
989 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
990
991 /* Draw A=various */
992 repeat=5;
993 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
994 time1=SDL_GetTicks();
995 for (j=0; j<repeat; j++) {
996 for (i=0; i<NUM_RANDOM; i += 2) {
997 aalineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], rr[i], rg[i], rb[i], ra[i]);
998 }
999 }
1000 time2=SDL_GetTicks();
1001
1002 /* Results */
1003 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1004 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/2)*repeat)/(float)(time2-time1));
1005 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1006
1007 }
1008
TestThickLine(SDL_Surface * screen)1009 void TestThickLine(SDL_Surface *screen)
1010 {
1011 int i;
1012 char r,g,b;
1013
1014 /* Create random points */
1015 srand((int)time(NULL));
1016 InitRandomPoints();
1017
1018 /* Draw A=255 */
1019 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1020 for (i=0; i<NUM_RANDOM; i += 5) {
1021 thickLineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], lw[i], rr[i], rg[i], rb[i], 255);
1022 }
1023
1024 /* Draw A=various */
1025 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1026 for (i=0; i<NUM_RANDOM; i += 5) {
1027 thickLineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], lw[i], rr[i], rg[i], rb[i], ra[i]);
1028 }
1029
1030 /* Draw A=various */
1031 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1032 for (i=0; i<NUM_RANDOM; i += 5) {
1033 thickLineRGBA(screen, rx2[i], ry2[i], rx2[i+1], ry2[i+1], lw[i], rr[i], rg[i], rb[i], ra[i]);
1034 }
1035
1036 /* Draw Colortest */
1037 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1038 for (i=0; i<NUM_RANDOM; i += 5) {
1039 if (rx1[i] < (WIDTH/6)) {
1040 r=255; g=0; b=0;
1041 } else if (rx1[i] < (WIDTH/3) ) {
1042 r=0; g=255; b=0;
1043 } else {
1044 r=0; g=0; b=255;
1045 }
1046 thickLineRGBA(screen, rx1[i], ry2[i], rx1[i]+rr1[i], ry2[i]+rr2[i], lw[i], r, g, b, 255);
1047 }
1048 }
1049
BenchmarkThickLine(SDL_Surface * screen)1050 void BenchmarkThickLine(SDL_Surface *screen)
1051 {
1052 int i,j;
1053 int repeat;
1054 Uint32 time1, time2;
1055 char titletext[256];
1056
1057 /* Draw A=255 */
1058 repeat=10;
1059 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1060 time1=SDL_GetTicks();
1061 for (j=0; j<repeat; j++) {
1062 for (i=0; i<NUM_RANDOM; i += 5) {
1063 thickLineRGBA(screen, rx1[i], ry1[i], rx1[i+1], ry1[i+1], lw[i], rr[i], rg[i], rb[i], 255);
1064 }
1065 }
1066 time2=SDL_GetTicks();
1067 /* Results */
1068 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1069 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/5)*repeat)/(float)(time2-time1));
1070 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1071
1072 /* Draw A=various */
1073 repeat=10;
1074 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1075 time1=SDL_GetTicks();
1076 for (j=0; j<repeat; j++) {
1077 for (i=0; i<NUM_RANDOM; i += 5) {
1078 thickLineRGBA(screen, rx2[i], ry1[i], rx2[i+1], ry1[i+1], lw[i], rr[i], rg[i], rb[i], ra[i]);
1079 }
1080 }
1081 time2=SDL_GetTicks();
1082
1083 /* Results */
1084 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1085 sprintf (titletext, "%.0f per sec",1000.0*(float)((NUM_RANDOM/5)*repeat)/(float)(time2-time1));
1086 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1087
1088 }
1089
TestThickLineAccuracy(SDL_Surface * screen)1090 void TestThickLineAccuracy(SDL_Surface *screen)
1091 {
1092 int i;
1093 char r,g,b;
1094 int cx, cy;
1095
1096 /* Create random points */
1097 srand((int)time(NULL));
1098 InitRandomPoints();
1099
1100 /* Draw A=255 */
1101 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1102 cx = WIDTH/4;
1103 cy = 60+(HEIGHT-80)/4;
1104 for (i=0; i<NUM_RANDOM; i += 10) {
1105 thickLineRGBA(screen, cx, cy, rx1[i], ry1[i], lw[i], rr[i], rg[i], rb[i], 255);
1106 pixelRGBA(screen, rx1[i], ry1[i], 255, 255, 255, 255);
1107 }
1108 pixelRGBA(screen, cx, cy, 255, 255, 255, 255);
1109
1110 /* Draw A=various */
1111 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1112 cx = WIDTH/2 + WIDTH/4;
1113 cy = 60+(HEIGHT-80)/4;
1114 for (i=0; i<NUM_RANDOM; i += 10) {
1115 thickLineRGBA(screen, cx, cy, rx2[i], ry1[i], lw[i], rr[i], rg[i], rb[i], ra[i]);
1116 pixelRGBA(screen, rx2[i], ry1[i], 255, 255, 255, 255);
1117 }
1118 pixelRGBA(screen, cx, cy, 255, 255, 255, 255);
1119
1120 /* Draw A=various */
1121 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1122 cx = WIDTH/2 + WIDTH/4;
1123 cy = 80 + (HEIGHT-80)/2 + (HEIGHT-80)/4;
1124 for (i=0; i<NUM_RANDOM; i += 10) {
1125 thickLineRGBA(screen, cx, cy, rx2[i], ry2[i], lw[i], rr[i], rg[i], rb[i], ra[i]);
1126 pixelRGBA(screen, rx2[i], ry2[i], 255, 255, 255, 255);
1127 }
1128 pixelRGBA(screen, cx, cy, 255, 255, 255, 255);
1129
1130 /* Draw Colortest */
1131 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1132 cx = WIDTH/4;
1133 cy = 80 + (HEIGHT-80)/2 + (HEIGHT-80)/4;
1134 for (i=0; i<NUM_RANDOM; i += 10) {
1135 if (rx1[i] < (WIDTH/6)) {
1136 r=255; g=0; b=0;
1137 } else if (rx1[i] < (WIDTH/3) ) {
1138 r=0; g=255; b=0;
1139 } else {
1140 r=0; g=0; b=255;
1141 }
1142 thickLineRGBA(screen, cx, cy, rx1[i], ry2[i], lw[i], r, g, b, 255);
1143 pixelRGBA(screen, rx1[i], ry2[i], 255, 255, 255, 255);
1144 }
1145 pixelRGBA(screen, cx, cy, 255, 255, 255, 255);
1146 }
1147
TestCircle(SDL_Surface * screen)1148 void TestCircle(SDL_Surface *screen)
1149 {
1150 int i;
1151 char r,g,b;
1152
1153 /* Create random points */
1154 srand((int)time(NULL));
1155 InitRandomPoints();
1156
1157 /* Draw A=255 */
1158 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1159 for (i=0; i<NUM_RANDOM; i++) {
1160 circleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1161 }
1162
1163 /* Draw A=various */
1164 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1165 for (i=0; i<NUM_RANDOM; i++) {
1166 circleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1167 }
1168
1169 /* Draw A=various */
1170 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1171 for (i=0; i<NUM_RANDOM; i++) {
1172 circleRGBA(screen, rx2[i], ry2[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1173 }
1174
1175 /* Draw Colortest */
1176 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1177 for (i=0; i<NUM_RANDOM; i++) {
1178 if (rx1[i] < (WIDTH/6)) {
1179 r=255; g=0; b=0;
1180 } else if (rx1[i] < (WIDTH/3) ) {
1181 r=0; g=255; b=0;
1182 } else {
1183 r=0; g=0; b=255;
1184 }
1185 circleRGBA(screen, rx1[i], ry2[i], rr1[i], r, g, b, 255);
1186 }
1187 }
1188
BenchmarkCircle(SDL_Surface * screen)1189 void BenchmarkCircle(SDL_Surface *screen)
1190 {
1191 int i,j;
1192 int repeat;
1193 Uint32 time1, time2;
1194 char titletext[256];
1195
1196 /* Draw A=255 */
1197 repeat=20;
1198 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1199 time1=SDL_GetTicks();
1200 for (j=0; j<repeat; j++) {
1201 for (i=0; i<NUM_RANDOM; i++) {
1202 circleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1203 }
1204 }
1205 time2=SDL_GetTicks();
1206 /* Results */
1207 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1208 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1209 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1210
1211 /* Draw A=various */
1212 repeat=5;
1213 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1214 time1=SDL_GetTicks();
1215 for (j=0; j<repeat; j++) {
1216 for (i=0; i<NUM_RANDOM; i++) {
1217 circleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1218 }
1219 }
1220 time2=SDL_GetTicks();
1221
1222 /* Results */
1223 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1224 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1225 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1226 }
1227
TestAACircle(SDL_Surface * screen)1228 void TestAACircle(SDL_Surface *screen)
1229 {
1230 int i;
1231 char r,g,b;
1232
1233 /* Create random points */
1234 srand((int)time(NULL));
1235 InitRandomPoints();
1236
1237 /* Draw A=255 */
1238 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1239 for (i=0; i<NUM_RANDOM; i++) {
1240 aacircleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1241 }
1242
1243 /* Draw A=various */
1244 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1245 for (i=0; i<NUM_RANDOM; i++) {
1246 aacircleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1247 }
1248
1249 /* Draw A=various */
1250 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1251 for (i=0; i<NUM_RANDOM; i++) {
1252 aacircleRGBA(screen, rx2[i], ry2[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1253 }
1254
1255 /* Draw Colortest */
1256 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1257 for (i=0; i<NUM_RANDOM; i++) {
1258 if (rx1[i] < (WIDTH/6)) {
1259 r=255; g=0; b=0;
1260 } else if (rx1[i] < (WIDTH/3) ) {
1261 r=0; g=255; b=0;
1262 } else {
1263 r=0; g=0; b=255;
1264 }
1265 aacircleRGBA(screen, rx1[i], ry2[i], rr1[i], r, g, b, 255);
1266 }
1267 }
1268
BenchmarkAACircle(SDL_Surface * screen)1269 void BenchmarkAACircle(SDL_Surface *screen)
1270 {
1271 int i,j;
1272 int repeat;
1273 Uint32 time1, time2;
1274 char titletext[256];
1275
1276 /* Draw A=255 */
1277 repeat=20;
1278 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1279 time1=SDL_GetTicks();
1280 for (j=0; j<repeat; j++) {
1281 for (i=0; i<NUM_RANDOM; i++) {
1282 aacircleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1283 }
1284 }
1285 time2=SDL_GetTicks();
1286 /* Results */
1287 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1288 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1289 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1290
1291 /* Draw A=various */
1292 repeat=5;
1293 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1294 time1=SDL_GetTicks();
1295 for (j=0; j<repeat; j++) {
1296 for (i=0; i<NUM_RANDOM; i++) {
1297 aacircleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1298 }
1299 }
1300 time2=SDL_GetTicks();
1301
1302 /* Results */
1303 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1304 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1305 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1306 }
1307
TestFilledCircle(SDL_Surface * screen)1308 void TestFilledCircle(SDL_Surface *screen)
1309 {
1310 int i;
1311 char r,g,b;
1312
1313 /* Create random points */
1314 srand((int)time(NULL));
1315 InitRandomPoints();
1316
1317 /* Draw A=255 */
1318 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1319 for (i=0; i<NUM_RANDOM; i++) {
1320 filledCircleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1321 }
1322
1323 /* Draw A=various */
1324 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1325 for (i=0; i<NUM_RANDOM; i++) {
1326 filledCircleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1327 }
1328
1329 /* Draw A=various */
1330 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1331 for (i=0; i<NUM_RANDOM; i++) {
1332 filledCircleRGBA(screen, rx2[i], ry2[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1333 }
1334
1335 /* Draw Colortest */
1336 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1337 for (i=0; i<NUM_RANDOM; i++) {
1338 if (rx1[i] < (WIDTH/6)) {
1339 r=255; g=0; b=0;
1340 } else if (rx1[i] < (WIDTH/3) ) {
1341 r=0; g=255; b=0;
1342 } else {
1343 r=0; g=0; b=255;
1344 }
1345 filledCircleRGBA(screen, rx1[i], ry2[i], rr1[i], r, g, b, 255);
1346 }
1347 }
1348
BenchmarkFilledCircle(SDL_Surface * screen)1349 void BenchmarkFilledCircle(SDL_Surface *screen)
1350 {
1351 int i,j;
1352 int repeat;
1353 Uint32 time1, time2;
1354 char titletext[256];
1355
1356 /* Draw A=255 */
1357 repeat=20;
1358 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1359 time1=SDL_GetTicks();
1360 for (j=0; j<repeat; j++) {
1361 for (i=0; i<NUM_RANDOM; i++) {
1362 filledCircleRGBA(screen, rx1[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], 255);
1363 }
1364 }
1365 time2=SDL_GetTicks();
1366 /* Results */
1367 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1368 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1369 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1370
1371 /* Draw A=various */
1372 repeat=5;
1373 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1374 time1=SDL_GetTicks();
1375 for (j=0; j<repeat; j++) {
1376 for (i=0; i<NUM_RANDOM; i++) {
1377 filledCircleRGBA(screen, rx2[i], ry1[i], rr1[i], rr[i], rg[i], rb[i], ra[i]);
1378 }
1379 }
1380 time2=SDL_GetTicks();
1381
1382 /* Results */
1383 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1384 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1385 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1386 }
1387
TestEllipse(SDL_Surface * screen)1388 void TestEllipse(SDL_Surface *screen)
1389 {
1390 int i;
1391 char r,g,b;
1392
1393 /* Create random points */
1394 srand((int)time(NULL));
1395 InitRandomPoints();
1396
1397 /* Draw A=255 */
1398 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1399 for (i=0; i<NUM_RANDOM; i++) {
1400 ellipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1401 }
1402
1403 /* Draw A=various */
1404 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1405 for (i=0; i<NUM_RANDOM; i++) {
1406 ellipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1407 }
1408
1409 /* Draw A=various */
1410 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1411 for (i=0; i<NUM_RANDOM; i++) {
1412 ellipseRGBA(screen, rx2[i], ry2[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1413 }
1414
1415 /* Draw Colortest */
1416 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1417 for (i=0; i<NUM_RANDOM; i++) {
1418 if (rx1[i] < (WIDTH/6)) {
1419 r=255; g=0; b=0;
1420 } else if (rx1[i] < (WIDTH/3) ) {
1421 r=0; g=255; b=0;
1422 } else {
1423 r=0; g=0; b=255;
1424 }
1425 ellipseRGBA(screen, rx1[i], ry2[i], rr1[i], rr2[i], r, g, b, 255);
1426 }
1427 }
1428
BenchmarkEllipse(SDL_Surface * screen)1429 void BenchmarkEllipse(SDL_Surface *screen)
1430 {
1431 int i,j;
1432 int repeat;
1433 Uint32 time1, time2;
1434 char titletext[256];
1435
1436 /* Draw A=255 */
1437 repeat=20;
1438 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1439 time1=SDL_GetTicks();
1440 for (j=0; j<repeat; j++) {
1441 for (i=0; i<NUM_RANDOM; i++) {
1442 ellipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1443 }
1444 }
1445 time2=SDL_GetTicks();
1446 /* Results */
1447 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1448 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1449 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1450
1451 /* Draw A=various */
1452 repeat=5;
1453 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1454 time1=SDL_GetTicks();
1455 for (j=0; j<repeat; j++) {
1456 for (i=0; i<NUM_RANDOM; i++) {
1457 ellipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1458 }
1459 }
1460 time2=SDL_GetTicks();
1461
1462 /* Results */
1463 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1464 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1465 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1466 }
1467
TestAAEllipse(SDL_Surface * screen)1468 void TestAAEllipse(SDL_Surface *screen)
1469 {
1470 int i;
1471 char r,g,b;
1472
1473 /* Create random points */
1474 srand((int)time(NULL));
1475 InitRandomPoints();
1476
1477 /* Draw A=255 */
1478 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1479 for (i=0; i<NUM_RANDOM; i++) {
1480 aaellipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1481 }
1482
1483 /* Draw A=various */
1484 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1485 for (i=0; i<NUM_RANDOM; i++) {
1486 aaellipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1487 }
1488
1489 /* Draw A=various */
1490 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1491 for (i=0; i<NUM_RANDOM; i++) {
1492 aaellipseRGBA(screen, rx2[i], ry2[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1493 }
1494
1495 /* Draw Colortest */
1496 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1497 for (i=0; i<NUM_RANDOM; i++) {
1498 if (rx1[i] < (WIDTH/6)) {
1499 r=255; g=0; b=0;
1500 } else if (rx1[i] < (WIDTH/3) ) {
1501 r=0; g=255; b=0;
1502 } else {
1503 r=0; g=0; b=255;
1504 }
1505 aaellipseRGBA(screen, rx1[i], ry2[i], rr1[i], rr2[i], r, g, b, 255);
1506 }
1507 }
1508
BenchmarkAAEllipse(SDL_Surface * screen)1509 void BenchmarkAAEllipse(SDL_Surface *screen)
1510 {
1511 int i,j;
1512 int repeat;
1513 Uint32 time1, time2;
1514 char titletext[256];
1515
1516 /* Draw A=255 */
1517 repeat=20;
1518 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1519 time1=SDL_GetTicks();
1520 for (j=0; j<repeat; j++) {
1521 for (i=0; i<NUM_RANDOM; i++) {
1522 ellipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1523 }
1524 }
1525 time2=SDL_GetTicks();
1526 /* Results */
1527 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1528 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1529 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1530
1531 /* Draw A=various */
1532 repeat=5;
1533 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1534 time1=SDL_GetTicks();
1535 for (j=0; j<repeat; j++) {
1536 for (i=0; i<NUM_RANDOM; i++) {
1537 aaellipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1538 }
1539 }
1540 time2=SDL_GetTicks();
1541
1542 /* Results */
1543 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1544 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1545 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1546 }
1547
TestFilledEllipse(SDL_Surface * screen)1548 void TestFilledEllipse(SDL_Surface *screen)
1549 {
1550 int i;
1551 char r,g,b;
1552
1553 /* Create random points */
1554 srand((int)time(NULL));
1555 InitRandomPoints();
1556
1557 /* Draw A=255 */
1558 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1559 for (i=0; i<NUM_RANDOM; i++) {
1560 filledEllipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1561 }
1562
1563 /* Draw A=various */
1564 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1565 for (i=0; i<NUM_RANDOM; i++) {
1566 filledEllipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1567 }
1568
1569 /* Draw A=various */
1570 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1571 for (i=0; i<NUM_RANDOM; i++) {
1572 filledEllipseRGBA(screen, rx2[i], ry2[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1573 }
1574
1575 /* Draw Colortest */
1576 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1577 for (i=0; i<NUM_RANDOM; i++) {
1578 if (rx1[i] < (WIDTH/6)) {
1579 r=255; g=0; b=0;
1580 } else if (rx1[i] < (WIDTH/3) ) {
1581 r=0; g=255; b=0;
1582 } else {
1583 r=0; g=0; b=255;
1584 }
1585 filledEllipseRGBA(screen, rx1[i], ry2[i], rr1[i], rr2[i], r, g, b, 255);
1586 }
1587 }
1588
BenchmarkFilledEllipse(SDL_Surface * screen)1589 void BenchmarkFilledEllipse(SDL_Surface *screen)
1590 {
1591 int i,j;
1592 int repeat;
1593 Uint32 time1, time2;
1594 char titletext[256];
1595
1596 /* Draw A=255 */
1597 repeat=20;
1598 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1599 time1=SDL_GetTicks();
1600 for (j=0; j<repeat; j++) {
1601 for (i=0; i<NUM_RANDOM; i++) {
1602 filledEllipseRGBA(screen, rx1[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], 255);
1603 }
1604 }
1605 time2=SDL_GetTicks();
1606 /* Results */
1607 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1608 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1609 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1610
1611 /* Draw A=various */
1612 repeat=5;
1613 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1614 time1=SDL_GetTicks();
1615 for (j=0; j<repeat; j++) {
1616 for (i=0; i<NUM_RANDOM; i++) {
1617 filledEllipseRGBA(screen, rx2[i], ry1[i], rr1[i], rr2[i], rr[i], rg[i], rb[i], ra[i]);
1618 }
1619 }
1620 time2=SDL_GetTicks();
1621
1622 /* Results */
1623 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1624 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1625 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1626 }
1627
TestArc(SDL_Surface * screen)1628 void TestArc(SDL_Surface *screen)
1629 {
1630 int i;
1631 char r,g,b;
1632
1633 /* Create random points */
1634 srand((int)time(NULL));
1635 InitRandomPoints();
1636
1637 /* Draw A=255 */
1638 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1639 for (i=0; i<NUM_RANDOM; i++) {
1640 arcRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1641 }
1642
1643 /* Draw A=various */
1644 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1645 for (i=0; i<NUM_RANDOM; i++) {
1646 arcRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1647 }
1648
1649 /* Draw A=various */
1650 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1651 for (i=0; i<NUM_RANDOM; i++) {
1652 arcRGBA(screen, rx2[i], ry2[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1653 }
1654
1655 /* Draw Colortest */
1656 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1657 for (i=0; i<NUM_RANDOM; i++) {
1658 if (rx1[i] < (WIDTH/6)) {
1659 r=255; g=0; b=0;
1660 } else if (rx1[i] < (WIDTH/3) ) {
1661 r=0; g=255; b=0;
1662 } else {
1663 r=0; g=0; b=255;
1664 }
1665 arcRGBA(screen, rx1[i], ry2[i], rr1[i], a1[i], a2[i], r, g, b, 255);
1666 }
1667 }
1668
BenchmarkArc(SDL_Surface * screen)1669 void BenchmarkArc(SDL_Surface *screen)
1670 {
1671 int i,j;
1672 int repeat;
1673 Uint32 time1, time2;
1674 char titletext[256];
1675
1676 /* Draw A=255 */
1677 repeat=50;
1678 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1679 time1=SDL_GetTicks();
1680 for (j=0; j<repeat; j++) {
1681 for (i=0; i<NUM_RANDOM; i++) {
1682 arcRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1683 }
1684 }
1685 time2=SDL_GetTicks();
1686 /* Results */
1687 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1688 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1689 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1690
1691 /* Draw A=various */
1692 repeat=5;
1693 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1694 time1=SDL_GetTicks();
1695 for (j=0; j<repeat; j++) {
1696 for (i=0; i<NUM_RANDOM; i++) {
1697 arcRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1698 }
1699 }
1700 time2=SDL_GetTicks();
1701
1702 /* Results */
1703 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1704 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1705 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1706 }
1707
TestPie(SDL_Surface * screen)1708 void TestPie(SDL_Surface *screen)
1709 {
1710 int i;
1711 char r,g,b;
1712
1713 /* Create random points */
1714 srand((int)time(NULL));
1715 InitRandomPoints();
1716
1717 /* Draw A=255 */
1718 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1719 for (i=0; i<NUM_RANDOM; i++) {
1720 pieRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1721 }
1722
1723 /* Draw A=various */
1724 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1725 for (i=0; i<NUM_RANDOM; i++) {
1726 pieRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1727 }
1728
1729 /* Draw A=various */
1730 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1731 for (i=0; i<NUM_RANDOM; i++) {
1732 pieRGBA(screen, rx2[i], ry2[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1733 }
1734
1735 /* Draw Colortest */
1736 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1737 for (i=0; i<NUM_RANDOM; i++) {
1738 if (rx1[i] < (WIDTH/6)) {
1739 r=255; g=0; b=0;
1740 } else if (rx1[i] < (WIDTH/3) ) {
1741 r=0; g=255; b=0;
1742 } else {
1743 r=0; g=0; b=255;
1744 }
1745 pieRGBA(screen, rx1[i], ry2[i], rr1[i], a1[i], a2[i], r, g, b, 255);
1746 }
1747 }
1748
BenchmarkPie(SDL_Surface * screen)1749 void BenchmarkPie(SDL_Surface *screen)
1750 {
1751 int i,j;
1752 int repeat;
1753 Uint32 time1, time2;
1754 char titletext[256];
1755
1756 /* Draw A=255 */
1757 repeat=20;
1758 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1759 time1=SDL_GetTicks();
1760 for (j=0; j<repeat; j++) {
1761 for (i=0; i<NUM_RANDOM; i++) {
1762 pieRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1763 }
1764 }
1765 time2=SDL_GetTicks();
1766 /* Results */
1767 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1768 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1769 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1770
1771 /* Draw A=various */
1772 repeat=5;
1773 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1774 time1=SDL_GetTicks();
1775 for (j=0; j<repeat; j++) {
1776 for (i=0; i<NUM_RANDOM; i++) {
1777 pieRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1778 }
1779 }
1780 time2=SDL_GetTicks();
1781
1782 /* Results */
1783 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1784 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1785 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1786 }
1787
TestFilledPie(SDL_Surface * screen)1788 void TestFilledPie(SDL_Surface *screen)
1789 {
1790 int i;
1791 char r,g,b;
1792
1793 /* Create random points */
1794 srand((int)time(NULL));
1795 InitRandomPoints();
1796
1797 /* Draw A=255 */
1798 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1799 for (i=0; i<NUM_RANDOM; i++) {
1800 filledPieRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1801 }
1802
1803 /* Draw A=various */
1804 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1805 for (i=0; i<NUM_RANDOM; i++) {
1806 filledPieRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1807 }
1808
1809 /* Draw A=various */
1810 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1811 for (i=0; i<NUM_RANDOM; i++) {
1812 filledPieRGBA(screen, rx2[i], ry2[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1813 }
1814
1815 /* Draw Colortest */
1816 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1817 for (i=0; i<NUM_RANDOM; i++) {
1818 if (rx1[i] < (WIDTH/6)) {
1819 r=255; g=0; b=0;
1820 } else if (rx1[i] < (WIDTH/3) ) {
1821 r=0; g=255; b=0;
1822 } else {
1823 r=0; g=0; b=255;
1824 }
1825 filledPieRGBA(screen, rx1[i], ry2[i], rr1[i], a1[i], a2[i], r, g, b, 255);
1826 }
1827 }
1828
BenchmarkFilledPie(SDL_Surface * screen)1829 void BenchmarkFilledPie(SDL_Surface *screen)
1830 {
1831 int i,j;
1832 int repeat;
1833 Uint32 time1, time2;
1834 char titletext[256];
1835
1836 /* Draw A=255 */
1837 repeat=20;
1838 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1839 time1=SDL_GetTicks();
1840 for (j=0; j<repeat; j++) {
1841 for (i=0; i<NUM_RANDOM; i++) {
1842 filledPieRGBA(screen, rx1[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], 255);
1843 }
1844 }
1845 time2=SDL_GetTicks();
1846 /* Results */
1847 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1848 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1849 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1850
1851 /* Draw A=various */
1852 repeat=5;
1853 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1854 time1=SDL_GetTicks();
1855 for (j=0; j<repeat; j++) {
1856 for (i=0; i<NUM_RANDOM; i++) {
1857 filledPieRGBA(screen, rx2[i], ry1[i], rr1[i], a1[i], a2[i], rr[i], rg[i], rb[i], ra[i]);
1858 }
1859 }
1860 time2=SDL_GetTicks();
1861
1862 /* Results */
1863 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1864 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1865 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1866 }
1867
TestTrigon(SDL_Surface * screen)1868 void TestTrigon(SDL_Surface *screen)
1869 {
1870 int i;
1871 char r,g,b;
1872
1873 /* Create random points */
1874 srand((int)time(NULL));
1875 InitRandomPoints();
1876
1877 /* Draw A=255 */
1878 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1879 for (i=0; i<NUM_RANDOM; i++) {
1880 trigonRGBA(screen, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], rr[i], rg[i], rb[i], 255);
1881 }
1882
1883 /* Draw A=various */
1884 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1885 for (i=0; i<NUM_RANDOM; i++) {
1886 trigonRGBA(screen, tx2[i][0], ty1[i][0], tx2[i][1], ty1[i][1], tx2[i][2], ty1[i][2], rr[i], rg[i], rb[i], ra[i]);
1887 }
1888
1889 /* Draw A=various */
1890 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1891 for (i=0; i<NUM_RANDOM; i++) {
1892 trigonRGBA(screen, tx2[i][0], ty2[i][0], tx2[i][1], ty2[i][1], tx2[i][2], ty2[i][2], rr[i], rg[i], rb[i], ra[i]);
1893 }
1894
1895 /* Draw Colortest */
1896 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1897 for (i=0; i<NUM_RANDOM; i++) {
1898 if (rx1[i] < (WIDTH/6)) {
1899 r=255; g=0; b=0;
1900 } else if (rx1[i] < (WIDTH/3) ) {
1901 r=0; g=255; b=0;
1902 } else {
1903 r=0; g=0; b=255;
1904 }
1905 trigonRGBA(screen, tx1[i][0], ty2[i][0], tx1[i][1], ty2[i][1], tx1[i][2], ty2[i][2], r, g, b, 255);
1906 }
1907 }
1908
BenchmarkTrigon(SDL_Surface * screen)1909 void BenchmarkTrigon(SDL_Surface *screen)
1910 {
1911 int i,j;
1912 int repeat;
1913 Uint32 time1, time2;
1914 char titletext[256];
1915
1916 /* Create random points */
1917 srand((int)time(NULL));
1918 InitRandomPoints();
1919
1920 /* Draw A=255 */
1921 repeat=50;
1922 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1923 time1=SDL_GetTicks();
1924 for (j=0; j<repeat; j++) {
1925 for (i=0; i<NUM_RANDOM; i++) {
1926 trigonRGBA(screen, tx1[i][0], ty1[i][0], tx1[i][1], ty1[i][1], tx1[i][2], ty1[i][2], rr[i], rg[i], rb[i], 255);
1927 }
1928 }
1929 time2=SDL_GetTicks();
1930 /* Results */
1931 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1932 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1933 stringRGBA (screen, WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1934
1935 /* Draw A=various */
1936 repeat=10;
1937 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1938 time1=SDL_GetTicks();
1939 for (j=0; j<repeat; j++) {
1940 for (i=0; i<NUM_RANDOM; i++) {
1941 trigonRGBA(screen, tx2[i][0], ty1[i][0], tx2[i][1], ty1[i][1], tx2[i][2], ty1[i][2], rr[i], rg[i], rb[i], ra[i]);
1942 }
1943 }
1944 time2=SDL_GetTicks();
1945
1946 /* Results */
1947 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
1948 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
1949 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
1950 }
1951
TestTexturedTrigon(SDL_Surface * screen)1952 void TestTexturedTrigon(SDL_Surface *screen)
1953 {
1954 int i;
1955 char r,g,b;
1956 SDL_Surface *texture;
1957
1958 /* Create random points */
1959 srand((int)time(NULL));
1960 InitRandomPoints();
1961
1962 /* Create texture */
1963 texture = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_HWSURFACE | SDL_SRCALPHA,
1964 2, 2, 32,
1965 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
1966
1967 /* Draw A=255 */
1968 boxRGBA(texture,0,0,1,1,255,255,255,255);
1969 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
1970 for (i=0; i<NUM_RANDOM; i++) {
1971 texturedPolygon(screen, &tx1[i][0], &ty1[i][0], 3, texture, 0, 0);
1972 }
1973
1974 /* Draw A=various */
1975 boxRGBA(texture,0,0,1,1,255,255,255,ra[i]);
1976 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
1977 for (i=0; i<NUM_RANDOM; i++) {
1978 texturedPolygon(screen, &tx2[i][0], &ty1[i][0], 3, texture, 0, 0);
1979 }
1980
1981 /* Draw A=various */
1982 boxRGBA(texture,0,0,1,1,255,255,255,ra[i]);
1983 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
1984 for (i=0; i<NUM_RANDOM; i++) {
1985 texturedPolygon(screen, &tx2[i][0], &ty2[i][0], 3, texture, 0, 0);
1986 }
1987
1988 /* Draw Colortest */
1989 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
1990 for (i=0; i<NUM_RANDOM; i++) {
1991 if (rx1[i] < (WIDTH/6)) {
1992 r=255; g=0; b=0;
1993 } else if (rx1[i] < (WIDTH/3) ) {
1994 r=0; g=255; b=0;
1995 } else {
1996 r=0; g=0; b=255;
1997 }
1998 boxRGBA(texture,0,0,1,1,r,g,b,255);
1999 texturedPolygon(screen, &tx1[i][0], &ty2[i][0], 3, texture, 0, 0);
2000 }
2001
2002 SDL_FreeSurface(texture);
2003 }
2004
BenchmarkTexturedTrigon(SDL_Surface * screen)2005 void BenchmarkTexturedTrigon(SDL_Surface *screen)
2006 {
2007 int i,j;
2008 int repeat;
2009 Uint32 time1, time2;
2010 char titletext[256];
2011 SDL_Surface *texture;
2012
2013 /* Create random points */
2014 srand((int)time(NULL));
2015 InitRandomPoints();
2016
2017 /* Create texture */
2018 texture = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_HWSURFACE | SDL_SRCALPHA,
2019 2, 2, 32,
2020 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
2021
2022 /* Draw A=255 */
2023 boxRGBA(texture,0,0,1,1,255,255,255,255);
2024 repeat=50;
2025 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2026 time1=SDL_GetTicks();
2027 for (j=0; j<repeat; j++) {
2028 for (i=0; i<NUM_RANDOM; i++) {
2029 texturedPolygon(screen, &tx1[i][0], &ty1[i][0], 3, texture, 0, 0);
2030 }
2031 }
2032 time2=SDL_GetTicks();
2033 /* Results */
2034 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2035 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2036 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2037
2038 /* Draw A=255 */
2039 boxRGBA(texture,0,0,1,1,255,255,255,255);
2040 repeat=10;
2041 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2042 time1=SDL_GetTicks();
2043 for (j=0; j<repeat; j++) {
2044 for (i=0; i<NUM_RANDOM; i++) {
2045 texturedPolygon(screen, &tx2[i][0], &ty1[i][0], 3, texture, 0, 0);
2046 }
2047 }
2048 time2=SDL_GetTicks();
2049
2050 /* Results */
2051 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2052 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2053 stringRGBA (screen, 3*WIDTH/4-4* (Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2054
2055 SDL_FreeSurface(texture);
2056 }
2057
TestSquarePolygon(SDL_Surface * screen)2058 void TestSquarePolygon(SDL_Surface *screen)
2059 {
2060 int i;
2061 char r,g,b;
2062
2063 /* Create random points */
2064 srand((int)time(NULL));
2065 InitRandomPoints();
2066
2067 /* Draw A=255 */
2068 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2069 for (i=0; i<NUM_RANDOM; i++) {
2070 polygonRGBA(screen, &sx1[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], 255);
2071 polygonRGBA(screen, &sx1[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], 255);
2072 }
2073
2074 /* Draw A=various */
2075 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2076 for (i=0; i<NUM_RANDOM; i++) {
2077 polygonRGBA(screen, &sx2[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], ra[i]);
2078 polygonRGBA(screen, &sx2[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], ra[i]);
2079 }
2080
2081 /* Draw A=various */
2082 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2083 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2084 polygonRGBA(screen, &sx2[i][0], &sy2[i][0], 3, rr[i], rg[i], rb[i], ra[i]);
2085 polygonRGBA(screen, &sx2[i][3], &sy2[i][3], 3, rr[i], rg[i], rb[i], ra[i]);
2086 }
2087
2088 /* Draw Colortest */
2089 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2090 for (i=0; i<NUM_RANDOM; i++) {
2091 if (rx1[i] < (WIDTH/6)) {
2092 r=255; g=0; b=0;
2093 } else if (rx1[i] < (WIDTH/3) ) {
2094 r=0; g=255; b=0;
2095 } else {
2096 r=0; g=0; b=255;
2097 }
2098 polygonRGBA(screen, &sx1[i][0], &sy2[i][0], 3, r, g, b, 255);
2099 polygonRGBA(screen, &sx1[i][3], &sy2[i][3], 3, r, g, b, 255);
2100 }
2101 }
2102
BenchmarkSquarePolygon(SDL_Surface * screen)2103 void BenchmarkSquarePolygon(SDL_Surface *screen)
2104 {
2105 int i,j;
2106 int repeat;
2107 Uint32 time1, time2;
2108 char titletext[256];
2109
2110 /* Create random points */
2111 srand((int)time(NULL));
2112 InitRandomPoints();
2113
2114 /* Draw A=255 */
2115 repeat=50;
2116 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2117 time1=SDL_GetTicks();
2118 for (j=0; j<repeat; j++) {
2119 for (i=0; i<NUM_RANDOM; i++) {
2120 polygonRGBA(screen, &sx1[i][0], &sy1[i][0], 6, rr[i], rg[i], rb[i], 255);
2121 }
2122 }
2123 time2=SDL_GetTicks();
2124 /* Results */
2125 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2126 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2127 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2128
2129 /* Draw A=various */
2130 repeat=10;
2131 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2132 time1=SDL_GetTicks();
2133 for (j=0; j<repeat; j++) {
2134 for (i=0; i<NUM_RANDOM; i++) {
2135 polygonRGBA(screen, &sx2[i][0], &sy1[i][0], 6, rr[i], rg[i], rb[i], ra[i]);
2136 }
2137 }
2138 time2=SDL_GetTicks();
2139
2140 /* Results */
2141 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2142 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2143 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2144 }
2145
TestPolygon(SDL_Surface * screen)2146 void TestPolygon(SDL_Surface *screen)
2147 {
2148 int i;
2149 char r,g,b;
2150
2151 /* Create random points */
2152 srand((int)time(NULL));
2153 InitRandomPoints();
2154
2155 /* Draw A=255 */
2156 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2157 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2158 polygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2159 }
2160
2161 /* Draw A=various */
2162 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2163 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2164 polygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2165 }
2166
2167 /* Draw A=various */
2168 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2169 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2170 polygonRGBA(screen, &rx2[i], &ry2[i], 3, rr[i], rg[i], rb[i], ra[i]);
2171 }
2172
2173 /* Draw Colortest */
2174 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2175 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2176 if (rx1[i] < (WIDTH/6)) {
2177 r=255; g=0; b=0;
2178 } else if (rx1[i] < (WIDTH/3) ) {
2179 r=0; g=255; b=0;
2180 } else {
2181 r=0; g=0; b=255;
2182 }
2183 rx1[i+1]=rx1[i]+rr1[i];
2184 rx1[i+2]=rx1[i];
2185 ry2[i+1]=ry2[i];
2186 ry2[i+2]=ry2[i]+rr2[i];
2187 polygonRGBA(screen, &rx1[i], &ry2[i], 3, r, g, b, 255);
2188 }
2189 }
2190
BenchmarkPolygon(SDL_Surface * screen)2191 void BenchmarkPolygon(SDL_Surface *screen)
2192 {
2193 int i,j;
2194 int repeat;
2195 Uint32 time1, time2;
2196 char titletext[256];
2197
2198 /* Create random points */
2199 srand((int)time(NULL));
2200 InitRandomPoints();
2201
2202 /* Draw A=255 */
2203 repeat=50;
2204 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2205 time1=SDL_GetTicks();
2206 for (j=0; j<repeat; j++) {
2207 for (i=0; i<NUM_RANDOM; i += 3) {
2208 polygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2209 }
2210 }
2211 time2=SDL_GetTicks();
2212 /* Results */
2213 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2214 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2215 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2216
2217 /* Draw A=various */
2218 repeat=10;
2219 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2220 time1=SDL_GetTicks();
2221 for (j=0; j<repeat; j++) {
2222 for (i=0; i<NUM_RANDOM; i += 3) {
2223 polygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2224 }
2225 }
2226 time2=SDL_GetTicks();
2227
2228 /* Results */
2229 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2230 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2231 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2232 }
2233
TestAAPolygon(SDL_Surface * screen)2234 void TestAAPolygon(SDL_Surface *screen)
2235 {
2236 int i;
2237 char r,g,b;
2238
2239 /* Create random points */
2240 srand((int)time(NULL));
2241 InitRandomPoints();
2242
2243 /* Draw A=255 */
2244 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2245 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2246 aapolygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2247 }
2248
2249 /* Draw A=various */
2250 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2251 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2252 aapolygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2253 }
2254
2255 /* Draw A=various */
2256 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2257 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2258 aapolygonRGBA(screen, &rx2[i], &ry2[i], 3, rr[i], rg[i], rb[i], ra[i]);
2259 }
2260
2261 /* Draw Colortest */
2262 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2263 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2264 if (rx1[i] < (WIDTH/6)) {
2265 r=255; g=0; b=0;
2266 } else if (rx1[i] < (WIDTH/3) ) {
2267 r=0; g=255; b=0;
2268 } else {
2269 r=0; g=0; b=255;
2270 }
2271 rx1[i+1]=rx1[i]+rr1[i];
2272 rx1[i+2]=rx1[i];
2273 ry2[i+1]=ry2[i];
2274 ry2[i+2]=ry2[i]+rr2[i];
2275 aapolygonRGBA(screen, &rx1[i], &ry2[i], 3, r, g, b, 255);
2276 }
2277 }
2278
BenchmarkAAPolygon(SDL_Surface * screen)2279 void BenchmarkAAPolygon(SDL_Surface *screen)
2280 {
2281 int i,j;
2282 int repeat;
2283 Uint32 time1, time2;
2284 char titletext[256];
2285
2286 /* Create random points */
2287 srand((int)time(NULL));
2288 InitRandomPoints();
2289
2290 /* Draw A=255 */
2291 repeat=5;
2292 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2293 time1=SDL_GetTicks();
2294 for (j=0; j<repeat; j++) {
2295 for (i=0; i<NUM_RANDOM; i += 3) {
2296 aapolygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2297 }
2298 }
2299 time2=SDL_GetTicks();
2300 /* Results */
2301 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2302 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2303 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2304
2305 /* Draw A=various */
2306 repeat=2;
2307 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2308 time1=SDL_GetTicks();
2309 for (j=0; j<repeat; j++) {
2310 for (i=0; i<NUM_RANDOM; i += 3) {
2311 aapolygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2312 }
2313 }
2314 time2=SDL_GetTicks();
2315
2316 /* Results */
2317 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2318 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2319 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2320 }
2321
2322
TestFilledPolygon(SDL_Surface * screen)2323 void TestFilledPolygon(SDL_Surface *screen)
2324 {
2325 int i;
2326 char r,g,b;
2327
2328 /* Create random points */
2329 srand((int)time(NULL));
2330 InitRandomPoints();
2331
2332 /* Draw A=255 */
2333 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2334 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2335 filledPolygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2336 }
2337
2338 /* Draw A=various */
2339 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2340 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2341 filledPolygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2342 }
2343
2344 /* Draw A=various */
2345 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2346 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2347 filledPolygonRGBA(screen, &rx2[i], &ry2[i], 3, rr[i], rg[i], rb[i], ra[i]);
2348 }
2349
2350 /* Draw Colortest */
2351 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2352 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2353 if (rx1[i] < (WIDTH/6)) {
2354 r=255; g=0; b=0;
2355 } else if (rx1[i] < (WIDTH/3) ) {
2356 r=0; g=255; b=0;
2357 } else {
2358 r=0; g=0; b=255;
2359 }
2360 rx1[i+1]=rx1[i]+rr1[i];
2361 rx1[i+2]=rx1[i];
2362 ry2[i+1]=ry2[i];
2363 ry2[i+2]=ry2[i]+rr2[i];
2364 filledPolygonRGBA(screen, &rx1[i], &ry2[i], 3, r, g, b, 255);
2365 }
2366 }
2367
BenchmarkFilledPolygon(SDL_Surface * screen)2368 void BenchmarkFilledPolygon(SDL_Surface *screen)
2369 {
2370 int i,j;
2371 int repeat;
2372 Uint32 time1, time2;
2373 char titletext[256];
2374
2375 /* Create random points */
2376 srand((int)time(NULL));
2377 InitRandomPoints();
2378
2379 /* Draw A=255 */
2380 repeat=20;
2381 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2382 time1=SDL_GetTicks();
2383 for (j=0; j<repeat; j++) {
2384 for (i=0; i<NUM_RANDOM; i += 3) {
2385 filledPolygonRGBA(screen, &rx1[i], &ry1[i], 3, rr[i], rg[i], rb[i], 255);
2386 }
2387 }
2388 time2=SDL_GetTicks();
2389 /* Results */
2390 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2391 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2392 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2393
2394 /* Draw A=various */
2395 repeat=5;
2396 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2397 time1=SDL_GetTicks();
2398 for (j=0; j<repeat; j++) {
2399 for (i=0; i<NUM_RANDOM; i += 3) {
2400 filledPolygonRGBA(screen, &rx2[i], &ry1[i], 3, rr[i], rg[i], rb[i], ra[i]);
2401 }
2402 }
2403 time2=SDL_GetTicks();
2404
2405 /* Results */
2406 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2407 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2408 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2409 }
2410
TestFilledSquarePolygon(SDL_Surface * screen)2411 void TestFilledSquarePolygon(SDL_Surface *screen)
2412 {
2413 int i;
2414 char r,g,b;
2415
2416 /* Create random points */
2417 srand((int)time(NULL));
2418 InitRandomPoints();
2419
2420 /* Draw A=255 */
2421 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2422 for (i=0; i<NUM_RANDOM; i++) {
2423 filledPolygonRGBA(screen, &sx1[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], 255);
2424 filledPolygonRGBA(screen, &sx1[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], 255);
2425 }
2426
2427 /* Draw A=various */
2428 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2429 for (i=0; i<NUM_RANDOM; i++) {
2430 filledPolygonRGBA(screen, &sx2[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], ra[i]);
2431 filledPolygonRGBA(screen, &sx2[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], ra[i]);
2432 }
2433
2434 /* Draw A=various */
2435 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2436 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2437 filledPolygonRGBA(screen, &sx2[i][0], &sy2[i][0], 3, rr[i], rg[i], rb[i], ra[i]);
2438 filledPolygonRGBA(screen, &sx2[i][3], &sy2[i][3], 3, rr[i], rg[i], rb[i], ra[i]);
2439 }
2440
2441 /* Draw Colortest */
2442 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2443 for (i=0; i<NUM_RANDOM; i++) {
2444 if (rx1[i] < (WIDTH/6)) {
2445 r=255; g=0; b=0;
2446 } else if (rx1[i] < (WIDTH/3) ) {
2447 r=0; g=255; b=0;
2448 } else {
2449 r=0; g=0; b=255;
2450 }
2451 filledPolygonRGBA(screen, &sx1[i][0], &sy2[i][0], 3, r, g, b, 255);
2452 filledPolygonRGBA(screen, &sx1[i][3], &sy2[i][3], 3, r, g, b, 255);
2453 }
2454 }
2455
BenchmarkFilledSquarePolygon(SDL_Surface * screen)2456 void BenchmarkFilledSquarePolygon(SDL_Surface *screen)
2457 {
2458 int i,j;
2459 int repeat;
2460 Uint32 time1, time2;
2461 char titletext[256];
2462
2463 /* Create random points */
2464 srand((int)time(NULL));
2465 InitRandomPoints();
2466
2467 /* Draw A=255 */
2468 repeat=50;
2469 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2470 time1=SDL_GetTicks();
2471 for (j=0; j<repeat; j++) {
2472 for (i=0; i<NUM_RANDOM; i++) {
2473 filledPolygonRGBA(screen, &sx1[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], 255);
2474 filledPolygonRGBA(screen, &sx1[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], 255);
2475 }
2476 }
2477 time2=SDL_GetTicks();
2478 /* Results */
2479 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2480 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2481 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2482
2483 /* Draw A=various */
2484 repeat=10;
2485 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2486 time1=SDL_GetTicks();
2487 for (j=0; j<repeat; j++) {
2488 for (i=0; i<NUM_RANDOM; i++) {
2489 filledPolygonRGBA(screen, &sx2[i][0], &sy1[i][0], 3, rr[i], rg[i], rb[i], ra[i]);
2490 filledPolygonRGBA(screen, &sx2[i][3], &sy1[i][3], 3, rr[i], rg[i], rb[i], ra[i]);
2491 }
2492 }
2493 time2=SDL_GetTicks();
2494
2495 /* Results */
2496 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2497 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2498 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2499 }
2500
TestTexturedPolygon(SDL_Surface * screen)2501 void TestTexturedPolygon(SDL_Surface *screen)
2502 {
2503 int i;
2504 SDL_Surface *texture;
2505
2506 /* Create random points */
2507 srand((int)time(NULL));
2508 InitRandomPoints();
2509
2510 /* Load texture surface */
2511 texture = SDL_LoadBMP("texture.bmp");
2512
2513 /* Draw A=255 */
2514 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2515 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2516 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2517 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2518 texturedPolygon(screen, &rx1[i], &ry1[i], 3, texture, rr1[i], rr2[i]);
2519 }
2520
2521 /* Draw A=various */
2522 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2523 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2524 SDL_SetAlpha(texture, SDL_SRCALPHA, ra[i]);
2525 texturedPolygon(screen, &rx2[i], &ry1[i], 3, texture, rr1[i], rr2[i]);
2526 }
2527
2528 /* Draw A=various */
2529 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2530 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2531 SDL_SetAlpha(texture, SDL_SRCALPHA, ra[i]);
2532 texturedPolygon(screen, &rx2[i], &ry2[i], 3, texture, rr1[i], rr2[i]);
2533 }
2534
2535 /* Draw Colortest */
2536 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2537 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2538 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2539 rx1[i+1]=rx1[i]+rr1[i];
2540 rx1[i+2]=rx1[i];
2541 ry2[i+1]=ry2[i];
2542 ry2[i+2]=ry2[i]+rr2[i];
2543 texturedPolygon(screen, &rx1[i], &ry2[i], 3, texture, 0, 0);
2544 }
2545
2546 SDL_FreeSurface(texture);
2547 }
2548
BenchmarkTexturedPolygon(SDL_Surface * screen)2549 void BenchmarkTexturedPolygon(SDL_Surface *screen)
2550 {
2551 int i,j;
2552 int repeat;
2553 Uint32 time1, time2;
2554 char titletext[256];
2555 SDL_Surface *texture;
2556
2557 /* Load texture surface */
2558 texture = SDL_LoadBMP("texture.bmp");
2559
2560 /* Create random points */
2561 srand((int)time(NULL));
2562 InitRandomPoints();
2563
2564 /* Draw A=255 */
2565 repeat=20;
2566 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2567 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2568 time1=SDL_GetTicks();
2569 for (j=0; j<repeat; j++) {
2570 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2571 texturedPolygon(screen, &rx1[i], &ry1[i], 3, texture, rr1[i], rr2[i]);
2572 }
2573 }
2574 time2=SDL_GetTicks();
2575 /* Results */
2576 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2577 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM/2-3)/3)*repeat)/(float)(time2-time1));
2578 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2579
2580 /* Draw A=various */
2581 repeat=5;
2582 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2583 time1=SDL_GetTicks();
2584 for (j=0; j<repeat; j++) {
2585 for (i=0; i<(NUM_RANDOM/2-3); i += 3) {
2586 SDL_SetAlpha(texture, SDL_SRCALPHA, ra[i]);
2587 texturedPolygon(screen, &rx2[i], &ry1[i], 3, texture, rr1[i], rr2[i]);
2588 }
2589 }
2590 time2=SDL_GetTicks();
2591
2592 /* Results */
2593 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2594 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM/2-3)/3)*repeat)/(float)(time2-time1));
2595 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2596
2597 SDL_FreeSurface(texture);
2598 }
2599
TestTexturedSquarePolygon(SDL_Surface * screen)2600 void TestTexturedSquarePolygon(SDL_Surface *screen)
2601 {
2602 int i;
2603 char r,g,b;
2604 SDL_Surface *texture;
2605
2606 /* Load texture surface */
2607 texture = SDL_LoadBMP("texture.bmp");
2608
2609 /* Create random points */
2610 srand((int)time(NULL));
2611 InitRandomPoints();
2612
2613 /* Draw A=255 */
2614 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2615 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2616 for (i=0; i<NUM_RANDOM; i++) {
2617 texturedPolygon(screen, &sx1[i][0], &sy1[i][0], 3, texture, rr1[i], rr2[i]);
2618 texturedPolygon(screen, &sx1[i][3], &sy1[i][3], 3, texture, rr1[i], rr2[i]);
2619 }
2620
2621 /* Draw A=various */
2622 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2623 for (i=0; i<NUM_RANDOM; i++) {
2624 SDL_SetAlpha(texture, SDL_SRCALPHA, ra[i]);
2625 texturedPolygon(screen, &sx2[i][0], &sy1[i][0], 3, texture, rr1[i], rr2[i]);
2626 texturedPolygon(screen, &sx2[i][3], &sy1[i][3], 3, texture, rr1[i], rr2[i]);
2627 }
2628
2629 /* Draw A=various */
2630 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2631 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2632 SDL_SetAlpha(texture, SDL_SRCALPHA, ra[i]);
2633 texturedPolygon(screen, &sx2[i][0], &sy2[i][0], 3, texture, rr1[i], rr2[i]);
2634 texturedPolygon(screen, &sx2[i][3], &sy2[i][3], 3, texture, rr1[i], rr2[i]);
2635 }
2636
2637 /* Create texture */
2638 SDL_FreeSurface(texture);
2639 texture = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_HWSURFACE | SDL_SRCALPHA,
2640 2, 2, 32,
2641 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
2642
2643 /* Draw Colortest */
2644 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2645 for (i=0; i<NUM_RANDOM; i++) {
2646 if (rx1[i] < (WIDTH/6)) {
2647 r=255; g=0; b=0;
2648 } else if (rx1[i] < (WIDTH/3) ) {
2649 r=0; g=255; b=0;
2650 } else {
2651 r=0; g=0; b=255;
2652 }
2653 boxRGBA(texture,0,0,1,1,r,g,b,255);
2654 texturedPolygon(screen, &sx1[i][0], &sy2[i][0], 3, texture, 0, 0);
2655 texturedPolygon(screen, &sx1[i][3], &sy2[i][3], 3, texture, 0, 0);
2656 }
2657
2658 SDL_FreeSurface(texture);
2659 }
2660
BenchmarkTexturedSquarePolygon(SDL_Surface * screen)2661 void BenchmarkTexturedSquarePolygon(SDL_Surface *screen)
2662 {
2663 int i,j;
2664 int repeat;
2665 Uint32 time1, time2;
2666 char titletext[256];
2667 SDL_Surface *texture;
2668
2669 /* Load texture surface */
2670 texture = SDL_LoadBMP("texture.bmp");
2671
2672 /* Create random points */
2673 srand((int)time(NULL));
2674 InitRandomPoints();
2675
2676 /* Draw shift */
2677 repeat=50;
2678 SDL_SetAlpha(texture, SDL_SRCALPHA, 255);
2679 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2680 time1=SDL_GetTicks();
2681 for (j=0; j<repeat; j++) {
2682 for (i=0; i<NUM_RANDOM; i++) {
2683 texturedPolygon(screen, &sx1[i][0], &sy1[i][0], 3, texture, rr1[i], rr2[i]);
2684 texturedPolygon(screen, &sx1[i][3], &sy1[i][3], 3, texture, rr1[i], rr2[i]);
2685 }
2686 }
2687 time2=SDL_GetTicks();
2688 /* Results */
2689 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2690 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2691 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2692
2693 /* Draw no shift */
2694 repeat=10;
2695 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2696 time1=SDL_GetTicks();
2697 for (j=0; j<repeat; j++) {
2698 for (i=0; i<NUM_RANDOM; i++) {
2699 texturedPolygon(screen, &sx2[i][0], &sy1[i][0], 3, texture, 0, 0);
2700 texturedPolygon(screen, &sx2[i][3], &sy1[i][3], 3, texture, 0, 0);
2701 }
2702 }
2703 time2=SDL_GetTicks();
2704
2705 /* Results */
2706 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2707 sprintf (titletext, "%.0f per sec",1000.0*(float)(NUM_RANDOM*repeat)/(float)(time2-time1));
2708 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2709
2710 SDL_FreeSurface(texture);
2711 }
2712
TestBezier(SDL_Surface * screen)2713 void TestBezier(SDL_Surface *screen)
2714 {
2715 int i;
2716 char r,g,b;
2717
2718 /* Create random points */
2719 srand((int)time(NULL));
2720 InitRandomPoints();
2721
2722 /* Draw A=255 */
2723 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2724 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2725 bezierRGBA(screen, &rx1[i], &ry1[i], 3, 100, rr[i], rg[i], rb[i], 255);
2726 }
2727
2728 /* Draw A=various */
2729 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2730 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2731 bezierRGBA(screen, &rx2[i], &ry1[i], 3, 100, rr[i], rg[i], rb[i], ra[i]);
2732 }
2733
2734 /* Draw A=various */
2735 SetClip(screen,WIDTH/2,80+(HEIGHT-80)/2,WIDTH,HEIGHT);
2736 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2737 bezierRGBA(screen, &rx2[i], &ry2[i], 3, 100, rr[i], rg[i], rb[i], ra[i]);
2738 }
2739
2740 /* Draw Colortest */
2741 SetClip(screen,0,80+(HEIGHT-80)/2,WIDTH/2,HEIGHT);
2742 for (i=0; i<(NUM_RANDOM-3); i += 3) {
2743 if (rx1[i] < (WIDTH/6)) {
2744 r=255; g=0; b=0;
2745 } else if (rx1[i] < (WIDTH/3) ) {
2746 r=0; g=255; b=0;
2747 } else {
2748 r=0; g=0; b=255;
2749 }
2750 rx1[i+1]=rx1[i]+rr1[i];
2751 rx1[i+2]=rx1[i];
2752 ry2[i+1]=ry2[i];
2753 ry2[i+2]=ry2[i]+rr2[i];
2754 bezierRGBA(screen, &rx1[i], &ry2[i], 3, 100, r, g, b, 255);
2755 }
2756 }
2757
BenchmarkBezier(SDL_Surface * screen)2758 void BenchmarkBezier(SDL_Surface *screen)
2759 {
2760 int i,j;
2761 int repeat;
2762 Uint32 time1, time2;
2763 char titletext[256];
2764
2765 /* Create random points */
2766 srand((int)time(NULL));
2767 InitRandomPoints();
2768
2769 /* Draw A=255 */
2770 repeat=20;
2771 SetClip(screen,0,60,WIDTH/2,60+(HEIGHT-80)/2);
2772 time1=SDL_GetTicks();
2773 for (j=0; j<repeat; j++) {
2774 for (i=0; i<NUM_RANDOM; i += 3) {
2775 bezierRGBA(screen, &rx1[i], &ry1[i], 3, 100, rr[i], rg[i], rb[i], 255);
2776 }
2777 }
2778 time2=SDL_GetTicks();
2779 /* Results */
2780 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2781 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2782 stringRGBA (screen, WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2783
2784 /* Draw A=various */
2785 repeat=10;
2786 SetClip(screen,WIDTH/2,60,WIDTH,60+(HEIGHT-80)/2);
2787 time1=SDL_GetTicks();
2788 for (j=0; j<repeat; j++) {
2789 for (i=0; i<NUM_RANDOM; i += 3) {
2790 bezierRGBA(screen, &rx2[i], &ry1[i], 3, 100, rr[i], rg[i], rb[i], ra[i]);
2791 }
2792 }
2793 time2=SDL_GetTicks();
2794
2795 /* Results */
2796 SetClip(screen,0,0,WIDTH-1,HEIGHT-1);
2797 sprintf (titletext, "%.0f per sec",1000.0*(float)(((NUM_RANDOM-3)/3)*repeat)/(float)(time2-time1));
2798 stringRGBA (screen, 3*WIDTH/4-4*(Sint16)strlen(titletext),30-4,titletext,255,255,255,255);
2799 }
2800
2801 /* ======== Main Program ======= */
2802
main(int argc,char * argv[])2803 int main(int argc, char *argv[])
2804 {
2805 const SDL_VideoInfo *info;
2806 SDL_Surface *screen;
2807 Uint8 video_bpp;
2808 Uint32 videoflags;
2809 int done;
2810 SDL_Event event;
2811 int oldprim, curprim;
2812 char title[64];
2813
2814 /* Generate title string */
2815 sprintf (title,"TestGfxPrimitives - v%i.%i.%i",SDL_GFXPRIMITIVES_MAJOR, SDL_GFXPRIMITIVES_MINOR, SDL_GFXPRIMITIVES_MICRO);
2816
2817 /* Initialize SDL */
2818 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
2819 fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
2820 exit(1);
2821 }
2822 atexit(SDL_Quit);
2823
2824 /* Alpha blending doesn't work well at 8-bit color */
2825 info = SDL_GetVideoInfo();
2826 if ( info->vfmt->BitsPerPixel > 8 ) {
2827 video_bpp = info->vfmt->BitsPerPixel;
2828 } else {
2829 video_bpp = 16;
2830 }
2831 videoflags = SDL_SWSURFACE | SDL_SRCALPHA | SDL_RESIZABLE;
2832 while ( argc > 1 ) {
2833 --argc;
2834 if ( strcmp(argv[argc-1], "-bpp") == 0 ) {
2835 video_bpp = atoi(argv[argc]);
2836 --argc;
2837 } else
2838 if ( strcmp(argv[argc], "-hw") == 0 ) {
2839 videoflags |= SDL_HWSURFACE;
2840 } else
2841 if ( strcmp(argv[argc], "-warp") == 0 ) {
2842 videoflags |= SDL_HWPALETTE;
2843 } else
2844 if ( strcmp(argv[argc], "-fullscreen") == 0 ) {
2845 videoflags |= SDL_FULLSCREEN;
2846 } else {
2847 fprintf(stderr,
2848 "Usage: %s [-bpp N] [-warp] [-hw] [-fullscreen]\n",
2849 argv[0]);
2850 exit(1);
2851 }
2852 }
2853
2854 /* Set video mode */
2855 if ( (screen=SDL_SetVideoMode(WIDTH,HEIGHT,video_bpp,videoflags)) == NULL ) {
2856 fprintf(stderr, "Couldn't set %ix%i %i bpp video mode: %s\n",WIDTH,HEIGHT,video_bpp,SDL_GetError());
2857 exit(2);
2858 }
2859
2860 /* Use alpha blending */
2861 SDL_SetAlpha(screen, SDL_SRCALPHA, 0);
2862
2863 /* Set title for window */
2864 SDL_WM_SetCaption(title,title);
2865
2866 /* Wait for a keystroke */
2867 done = 0;
2868 oldprim = 0;
2869 curprim = 1;
2870 while ( !done ) {
2871
2872 /* Draw on screen if primitive changes */
2873 if (curprim != oldprim) {
2874
2875 ClearScreen(screen, "TestGfxPrimitives");
2876
2877 /* Draw according to curprim setting */
2878 switch (curprim) {
2879
2880 /* Pixels */
2881 case 1:
2882 ClearScreen(screen, "Pixel");
2883 TestPixel(screen);
2884 BenchmarkPixel(screen);
2885 /* Next primitive */
2886 oldprim=curprim;
2887 break;
2888
2889 /* Horizontal Lines */
2890 case 2:
2891 ClearScreen(screen, "Hline");
2892 TestHline(screen);
2893 BenchmarkHline(screen);
2894 /* Next primitive */
2895 oldprim=curprim;
2896 break;
2897
2898 /* Vertical Lines */
2899 case 3:
2900 ClearScreen(screen, "Vline");
2901 TestVline(screen);
2902 BenchmarkVline(screen);
2903 /* Next primitive */
2904 oldprim=curprim;
2905 break;
2906
2907 /* Rectangles */
2908 case 4:
2909 ClearScreen(screen, "Rectangle");
2910 TestRectangle(screen);
2911 BenchmarkRectangle(screen);
2912 /* Next primitive */
2913 oldprim=curprim;
2914 break;
2915
2916 /* --- Box */
2917 case 5:
2918 ClearScreen(screen, "Box");
2919 TestBox(screen);
2920 BenchmarkBox(screen);
2921 /* Next primitive */
2922 oldprim=curprim;
2923 break;
2924
2925 /* --- 2x2 Box */
2926 case 6:
2927 ClearScreen(screen, "2x2 Box");
2928 TestBoxTwo(screen);
2929 BenchmarkBoxTwo(screen);
2930 /* Next primitive */
2931 oldprim=curprim;
2932 break;
2933
2934 /* --- Lines */
2935 case 7:
2936 ClearScreen(screen, "Line");
2937 TestLine(screen);
2938 BenchmarkLine(screen);
2939 /* Next primitive */
2940 oldprim=curprim;
2941 break;
2942
2943 /* --- AA Line */
2944 case 8:
2945 ClearScreen(screen, "Anti-Aliased Line");
2946 TestAALine(screen);
2947 BenchmarkAALine(screen);
2948 /* Next primitive */
2949 oldprim=curprim;
2950 break;
2951
2952 /* --- Circle */
2953 case 9:
2954 ClearScreen(screen, "Circle");
2955 TestCircle(screen);
2956 BenchmarkCircle(screen);
2957 /* Next primitive */
2958 oldprim=curprim;
2959 break;
2960
2961 /* --- AA Circle */
2962 case 10:
2963 ClearScreen(screen, "AA Circle");
2964 TestAACircle(screen);
2965 BenchmarkAACircle(screen);
2966 /* Next primitive */
2967 oldprim=curprim;
2968 break;
2969
2970 /* --- Filled Circle */
2971 case 11:
2972 ClearScreen(screen, "Filled Circle");
2973 TestFilledCircle(screen);
2974 BenchmarkFilledCircle(screen);
2975 /* Next primitive */
2976 oldprim=curprim;
2977 break;
2978
2979 /* --- Ellipse */
2980 case 12:
2981 ClearScreen(screen, "Ellipse");
2982 TestEllipse(screen);
2983 BenchmarkEllipse(screen);
2984 /* Next primitive */
2985 oldprim=curprim;
2986 break;
2987
2988 /* --- AA Ellipse */
2989 case 13:
2990 ClearScreen(screen, "AA Ellipse");
2991 TestAAEllipse(screen);
2992 BenchmarkAAEllipse(screen);
2993 /* Next primitive */
2994 oldprim=curprim;
2995 break;
2996
2997 /* --- Filled Ellipse */
2998 case 14:
2999 ClearScreen(screen, "Filled Ellipse");
3000 TestFilledEllipse(screen);
3001 BenchmarkFilledEllipse(screen);
3002 /* Next primitive */
3003 oldprim=curprim;
3004 break;
3005
3006 /* --- Arc */
3007 case 15:
3008 ClearScreen(screen, "Arc");
3009 TestArc(screen);
3010 BenchmarkArc(screen);
3011 /* Next primitive */
3012 oldprim=curprim;
3013 break;
3014
3015 /* --- Pie */
3016 case 16:
3017 ClearScreen(screen, "Pie");
3018 TestPie(screen);
3019 BenchmarkPie(screen);
3020 /* Next primitive */
3021 oldprim=curprim;
3022 break;
3023
3024 /* --- Filled Pie */
3025 case 17:
3026 ClearScreen(screen, "Filled Pie");
3027 TestFilledPie(screen);
3028 BenchmarkFilledPie(screen);
3029 /* Next primitive */
3030 oldprim=curprim;
3031 break;
3032
3033 /* --- 3-Pixel Trigon */
3034 case 18:
3035 ClearScreen(screen, "5-Pixel Trigon");
3036 TestTrigon(screen);
3037 BenchmarkTrigon(screen);
3038 /* Next primitive */
3039 oldprim=curprim;
3040 break;
3041
3042 /* --- 3-Pixel Textured Trigon */
3043 case 19:
3044 ClearScreen(screen, "5-Pixel Textured Trigon");
3045 TestTexturedTrigon(screen);
3046 BenchmarkTexturedTrigon(screen);
3047 /* Next primitive */
3048 oldprim=curprim;
3049 break;
3050
3051 /* --- Square Polygon */
3052 case 20:
3053 ClearScreen(screen, "Square Polygon");
3054 TestSquarePolygon(screen);
3055 BenchmarkSquarePolygon(screen);
3056 /* Next primitive */
3057 oldprim=curprim;
3058 break;
3059
3060 /* --- Polygon */
3061 case 21:
3062 ClearScreen(screen, "Polygon");
3063 TestPolygon(screen);
3064 BenchmarkPolygon(screen);
3065 /* Next primitive */
3066 oldprim=curprim;
3067 break;
3068
3069 /* --- AA-Polygon */
3070 case 22:
3071 ClearScreen(screen, "AA-Polygon");
3072 TestAAPolygon(screen);
3073 BenchmarkAAPolygon(screen);
3074 /* Next primitive */
3075 oldprim=curprim;
3076 break;
3077
3078 /* ---- Filled Polygon */
3079 case 23:
3080 ClearScreen(screen, "Filled Polygon");
3081 TestFilledPolygon(screen);
3082 BenchmarkFilledPolygon(screen);
3083 /* Next primitive */
3084 oldprim=curprim;
3085 break;
3086
3087 /* ---- Filled Square Polygon */
3088 case 24:
3089 ClearScreen(screen, "Square from 2 Filled Polygons");
3090 TestFilledSquarePolygon(screen);
3091 BenchmarkFilledSquarePolygon(screen);
3092 /* Next primitive */
3093 oldprim=curprim;
3094 break;
3095
3096 /* ---- Textured Polygon */
3097 case 25:
3098 ClearScreen(screen, "Textured Polygon");
3099 TestTexturedPolygon(screen);
3100 BenchmarkTexturedPolygon(screen);
3101 /* Next primitive */
3102 oldprim=curprim;
3103 break;
3104
3105 /* ---- Textured Square Polygon */
3106 case 26:
3107 ClearScreen(screen, "Textured Square Polygon");
3108 TestTexturedSquarePolygon(screen);
3109 BenchmarkTexturedSquarePolygon(screen);
3110 /* Next primitive */
3111 oldprim=curprim;
3112 break;
3113
3114 /* ---- Bezier Curve */
3115 case 27:
3116 ClearScreen(screen, "Bezier Curve");
3117 TestBezier(screen);
3118 BenchmarkBezier(screen);
3119 /* Next primitive */
3120 oldprim=curprim;
3121 break;
3122
3123 /* ---- Rounded Rectangle */
3124 case 28:
3125 ClearScreen(screen, "Rounded Rectangle");
3126 TestRoundedRectangle(screen);
3127 BenchmarkRoundedRectangle(screen);
3128 /* Next primitive */
3129 oldprim=curprim;
3130 break;
3131
3132 /* ---- Rounded Box */
3133 case 29:
3134 ClearScreen(screen, "Rounded Box");
3135 TestRoundedBox(screen);
3136 BenchmarkRoundedBox(screen);
3137 /* Next primitive */
3138 oldprim=curprim;
3139 break;
3140
3141 /* ---- Thick Line */
3142 case 30:
3143 ClearScreen(screen, "Thick Line");
3144 TestThickLine(screen);
3145 BenchmarkThickLine(screen);
3146 /* Next primitive */
3147 oldprim=curprim;
3148 break;
3149
3150 /* ---- Thick Line (accuracy) */
3151 case 31:
3152 ClearScreen(screen, "Thick Line (Accuracy)");
3153 TestThickLineAccuracy(screen);
3154 /* Next primitive */
3155 oldprim=curprim;
3156 break;
3157
3158 /* --- Wrap start*/
3159 case 0:
3160 oldprim=0;
3161 curprim=31;
3162 break;
3163
3164 /* --- Wrap end */
3165 default:
3166 oldprim=0;
3167 curprim=1;
3168 break;
3169 }
3170
3171 /* Show */
3172 SDL_UpdateRect(screen, 0, 0, 0, 0);
3173 SDL_Flip(screen);
3174 }
3175
3176 /* Slow down polling */
3177 SDL_Delay(100);
3178
3179 /* Check for events */
3180 while ( SDL_PollEvent(&event) ) {
3181 switch (event.type) {
3182 case SDL_MOUSEBUTTONDOWN:
3183 if ( event.button.button == SDL_BUTTON_LEFT ) {
3184 /* Switch to next graphics */
3185 curprim++;
3186 } else if ( event.button.button == SDL_BUTTON_RIGHT ) {
3187 /* Switch to prev graphics */
3188 curprim--;
3189 }
3190 break;
3191 case SDL_KEYDOWN:
3192 /* Any keypress quits the app... */
3193 case SDL_QUIT:
3194 done = 1;
3195 break;
3196 default:
3197 break;
3198 }
3199 }
3200 }
3201
3202 return(0);
3203 }
3204