?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove CBitmapSurface.
[SDL.s60v3.git] / test / testgl.c
blob34b88cfba9193934c38934f8ecec371e4cf6a558
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <math.h>
5
6 #include "SDL.h"
7
8 #ifdef __MACOS__
9 #define HAVE_OPENGL
10 #endif
11
12 #ifdef HAVE_OPENGL
13
14 #include "SDL_opengl.h"
15
16 /* Undefine this if you want a flat cube instead of a rainbow cube */
17 #define SHADED_CUBE
18
19 /* Define this to be the name of the logo image to use with -logo */
20 #define LOGO_FILE "icon.bmp"
21
22 /* The SDL_OPENGLBLIT interface is deprecated.
23 The code is still available for benchmark purposes though.
24 */
25
26 static SDL_bool USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
27
28 static SDL_Surface *global_image = NULL;
29 static GLuint global_texture = 0;
30 static GLuint cursor_texture = 0;
31
32 /**********************************************************************/
33
34 void HotKey_ToggleFullScreen(void)
35 {
36 SDL_Surface *screen;
37
38 screen = SDL_GetVideoSurface();
39 if ( SDL_WM_ToggleFullScreen(screen) ) {
40 printf("Toggled fullscreen mode - now %s\n",
41 (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed");
42 } else {
43 printf("Unable to toggle fullscreen mode\n");
44 }
45 }
46
47 void HotKey_ToggleGrab(void)
48 {
49 SDL_GrabMode mode;
50
51 printf("Ctrl-G: toggling input grab!\n");
52 mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
53 if ( mode == SDL_GRAB_ON ) {
54 printf("Grab was on\n");
55 } else {
56 printf("Grab was off\n");
57 }
58 mode = SDL_WM_GrabInput(!mode);
59 if ( mode == SDL_GRAB_ON ) {
60 printf("Grab is now on\n");
61 } else {
62 printf("Grab is now off\n");
63 }
64 }
65
66 void HotKey_Iconify(void)
67 {
68 printf("Ctrl-Z: iconifying window!\n");
69 SDL_WM_IconifyWindow();
70 }
71
72 int HandleEvent(SDL_Event *event)
73 {
74 int done;
75
76 done = 0;
77 switch( event->type ) {
78 case SDL_ACTIVEEVENT:
79 /* See what happened */
80 printf( "app %s ", event->active.gain ? "gained" : "lost" );
81 if ( event->active.state & SDL_APPACTIVE ) {
82 printf( "active " );
83 } else if ( event->active.state & SDL_APPMOUSEFOCUS ) {
84 printf( "mouse " );
85 } else if ( event->active.state & SDL_APPINPUTFOCUS ) {
86 printf( "input " );
87 }
88 printf( "focus\n" );
89 break;
90
91
92 case SDL_KEYDOWN:
93 if ( event->key.keysym.sym == SDLK_ESCAPE ) {
94 done = 1;
95 }
96 if ( (event->key.keysym.sym == SDLK_g) &&
97 (event->key.keysym.mod & KMOD_CTRL) ) {
98 HotKey_ToggleGrab();
99 }
100 if ( (event->key.keysym.sym == SDLK_z) &&
101 (event->key.keysym.mod & KMOD_CTRL) ) {
102 HotKey_Iconify();
103 }
104 if ( (event->key.keysym.sym == SDLK_RETURN) &&
105 (event->key.keysym.mod & KMOD_ALT) ) {
106 HotKey_ToggleFullScreen();
107 }
108 printf("key '%s' pressed\n",
109 SDL_GetKeyName(event->key.keysym.sym));
110 break;
111 case SDL_QUIT:
112 done = 1;
113 break;
114 }
115 return(done);
116 }
117
118 void SDL_GL_Enter2DMode()
119 {
120 SDL_Surface *screen = SDL_GetVideoSurface();
121
122 /* Note, there may be other things you need to change,
123 depending on how you have your OpenGL state set up.
124 */
125 glPushAttrib(GL_ENABLE_BIT);
126 glDisable(GL_DEPTH_TEST);
127 glDisable(GL_CULL_FACE);
128 glEnable(GL_TEXTURE_2D);
129
130 /* This allows alpha blending of 2D textures with the scene */
131 glEnable(GL_BLEND);
132 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
133
134 glViewport(0, 0, screen->w, screen->h);
135
136 glMatrixMode(GL_PROJECTION);
137 glPushMatrix();
138 glLoadIdentity();
139
140 glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
141
142 glMatrixMode(GL_MODELVIEW);
143 glPushMatrix();
144 glLoadIdentity();
145
146 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
147 }
148
149 void SDL_GL_Leave2DMode()
150 {
151 glMatrixMode(GL_MODELVIEW);
152 glPopMatrix();
153
154 glMatrixMode(GL_PROJECTION);
155 glPopMatrix();
156
157 glPopAttrib();
158 }
159
160 /* Quick utility function for texture creation */
161 static int power_of_two(int input)
162 {
163 int value = 1;
164
165 while ( value < input ) {
166 value <<= 1;
167 }
168 return value;
169 }
170
171 GLuint SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
172 {
173 GLuint texture;
174 int w, h;
175 SDL_Surface *image;
176 SDL_Rect area;
177 Uint32 saved_flags;
178 Uint8 saved_alpha;
179
180 /* Use the surface width and height expanded to powers of 2 */
181 w = power_of_two(surface->w);
182 h = power_of_two(surface->h);
183 texcoord[0] = 0.0f; /* Min X */
184 texcoord[1] = 0.0f; /* Min Y */
185 texcoord[2] = (GLfloat)surface->w / w; /* Max X */
186 texcoord[3] = (GLfloat)surface->h / h; /* Max Y */
187
188 image = SDL_CreateRGBSurface(
189 SDL_SWSURFACE,
190 w, h,
191 32,
192 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
193 0x000000FF,
194 0x0000FF00,
195 0x00FF0000,
196 0xFF000000
197 #else
198 0xFF000000,
199 0x00FF0000,
200 0x0000FF00,
201 0x000000FF
202 #endif
203 );
204 if ( image == NULL ) {
205 return 0;
206 }
207
208 /* Save the alpha blending attributes */
209 saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
210 saved_alpha = surface->format->alpha;
211 if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
212 SDL_SetAlpha(surface, 0, 0);
213 }
214
215 /* Copy the surface into the GL texture image */
216 area.x = 0;
217 area.y = 0;
218 area.w = surface->w;
219 area.h = surface->h;
220 SDL_BlitSurface(surface, &area, image, &area);
221
222 /* Restore the alpha blending attributes */
223 if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
224 SDL_SetAlpha(surface, saved_flags, saved_alpha);
225 }
226
227 /* Create an OpenGL texture for the image */
228 glGenTextures(1, &texture);
229 glBindTexture(GL_TEXTURE_2D, texture);
230 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
231 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
232 glTexImage2D(GL_TEXTURE_2D,
233 0,
234 GL_RGBA,
235 w, h,
236 0,
237 GL_RGBA,
238 GL_UNSIGNED_BYTE,
239 image->pixels);
240 SDL_FreeSurface(image); /* No longer needed */
241
242 return texture;
243 }
244
245 void DrawLogoCursor(void)
246 {
247 static GLfloat texMinX, texMinY;
248 static GLfloat texMaxX, texMaxY;
249 static int w, h;
250 int x, y;
251
252 if ( ! cursor_texture ) {
253 SDL_Surface *image;
254 GLfloat texcoord[4];
255
256 /* Load the image (could use SDL_image library here) */
257 image = SDL_LoadBMP(LOGO_FILE);
258 if ( image == NULL ) {
259 return;
260 }
261 w = image->w;
262 h = image->h;
263
264 /* Convert the image into an OpenGL texture */
265 cursor_texture = SDL_GL_LoadTexture(image, texcoord);
266
267 /* Make texture coordinates easy to understand */
268 texMinX = texcoord[0];
269 texMinY = texcoord[1];
270 texMaxX = texcoord[2];
271 texMaxY = texcoord[3];
272
273 /* We don't need the original image anymore */
274 SDL_FreeSurface(image);
275
276 /* Make sure that the texture conversion is okay */
277 if ( ! cursor_texture ) {
278 return;
279 }
280 }
281
282 /* Move the image around */
283 SDL_GetMouseState(&x, &y);
284 x -= w/2;
285 y -= h/2;
286
287 /* Show the image on the screen */
288 SDL_GL_Enter2DMode();
289 glBindTexture(GL_TEXTURE_2D, cursor_texture);
290 glBegin(GL_TRIANGLE_STRIP);
291 glTexCoord2f(texMinX, texMinY); glVertex2i(x, y );
292 glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y );
293 glTexCoord2f(texMinX, texMaxY); glVertex2i(x, y+h);
294 glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
295 glEnd();
296 SDL_GL_Leave2DMode();
297 }
298
299 void DrawLogoTexture(void)
300 {
301 static GLfloat texMinX, texMinY;
302 static GLfloat texMaxX, texMaxY;
303 static int x = 0;
304 static int y = 0;
305 static int w, h;
306 static int delta_x = 1;
307 static int delta_y = 1;
308
309 SDL_Surface *screen = SDL_GetVideoSurface();
310
311 if ( ! global_texture ) {
312 SDL_Surface *image;
313 GLfloat texcoord[4];
314
315 /* Load the image (could use SDL_image library here) */
316 image = SDL_LoadBMP(LOGO_FILE);
317 if ( image == NULL ) {
318 return;
319 }
320 w = image->w;
321 h = image->h;
322
323 /* Convert the image into an OpenGL texture */
324 global_texture = SDL_GL_LoadTexture(image, texcoord);
325
326 /* Make texture coordinates easy to understand */
327 texMinX = texcoord[0];
328 texMinY = texcoord[1];
329 texMaxX = texcoord[2];
330 texMaxY = texcoord[3];
331
332 /* We don't need the original image anymore */
333 SDL_FreeSurface(image);
334
335 /* Make sure that the texture conversion is okay */
336 if ( ! global_texture ) {
337 return;
338 }
339 }
340
341 /* Move the image around */
342 x += delta_x;
343 if ( x < 0 ) {
344 x = 0;
345 delta_x = -delta_x;
346 } else
347 if ( (x+w) > screen->w ) {
348 x = screen->w-w;
349 delta_x = -delta_x;
350 }
351 y += delta_y;
352 if ( y < 0 ) {
353 y = 0;
354 delta_y = -delta_y;
355 } else
356 if ( (y+h) > screen->h ) {
357 y = screen->h-h;
358 delta_y = -delta_y;
359 }
360
361 /* Show the image on the screen */
362 SDL_GL_Enter2DMode();
363 glBindTexture(GL_TEXTURE_2D, global_texture);
364 glBegin(GL_TRIANGLE_STRIP);
365 glTexCoord2f(texMinX, texMinY); glVertex2i(x, y );
366 glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y );
367 glTexCoord2f(texMinX, texMaxY); glVertex2i(x, y+h);
368 glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
369 glEnd();
370 SDL_GL_Leave2DMode();
371 }
372
373 /* This code is deprecated, but available for speed comparisons */
374 void DrawLogoBlit(void)
375 {
376 static int x = 0;
377 static int y = 0;
378 static int w, h;
379 static int delta_x = 1;
380 static int delta_y = 1;
381
382 SDL_Rect dst;
383 SDL_Surface *screen = SDL_GetVideoSurface();
384
385 if ( global_image == NULL ) {
386 SDL_Surface *temp;
387
388 /* Load the image (could use SDL_image library here) */
389 temp = SDL_LoadBMP(LOGO_FILE);
390 if ( temp == NULL ) {
391 return;
392 }
393 w = temp->w;
394 h = temp->h;
395
396 /* Convert the image into the screen format */
397 global_image = SDL_CreateRGBSurface(
398 SDL_SWSURFACE,
399 w, h,
400 screen->format->BitsPerPixel,
401 screen->format->Rmask,
402 screen->format->Gmask,
403 screen->format->Bmask,
404 screen->format->Amask);
405 if ( global_image ) {
406 SDL_BlitSurface(temp, NULL, global_image, NULL);
407 }
408 SDL_FreeSurface(temp);
409
410 /* Make sure that the texture conversion is okay */
411 if ( ! global_image ) {
412 return;
413 }
414 }
415
416 /* Move the image around
417 Note that we do not clear the old position. This is because we
418 perform a glClear() which clears the framebuffer and then only
419 update the new area.
420 Note that you can also achieve interesting effects by modifying
421 the screen surface alpha channel. It's set to 255 by default..
422 */
423 x += delta_x;
424 if ( x < 0 ) {
425 x = 0;
426 delta_x = -delta_x;
427 } else
428 if ( (x+w) > screen->w ) {
429 x = screen->w-w;
430 delta_x = -delta_x;
431 }
432 y += delta_y;
433 if ( y < 0 ) {
434 y = 0;
435 delta_y = -delta_y;
436 } else
437 if ( (y+h) > screen->h ) {
438 y = screen->h-h;
439 delta_y = -delta_y;
440 }
441 dst.x = x;
442 dst.y = y;
443 dst.w = w;
444 dst.h = h;
445 SDL_BlitSurface(global_image, NULL, screen, &dst);
446
447 /* Show the image on the screen */
448 SDL_UpdateRects(screen, 1, &dst);
449 }
450
451 int RunGLTest( int argc, char* argv[],
452 int logo, int logocursor, int slowly, int bpp, float gamma, int noframe, int fsaa, int sync, int accel )
453 {
454 int i;
455 int rgb_size[3];
456 int w = 640;
457 int h = 480;
458 int done = 0;
459 int frames;
460 Uint32 start_time, this_time;
461 float color[8][3]= {{ 1.0, 1.0, 0.0},
462 { 1.0, 0.0, 0.0},
463 { 0.0, 0.0, 0.0},
464 { 0.0, 1.0, 0.0},
465 { 0.0, 1.0, 1.0},
466 { 1.0, 1.0, 1.0},
467 { 1.0, 0.0, 1.0},
468 { 0.0, 0.0, 1.0}};
469 float cube[8][3]= {{ 0.5, 0.5, -0.5},
470 { 0.5, -0.5, -0.5},
471 {-0.5, -0.5, -0.5},
472 {-0.5, 0.5, -0.5},
473 {-0.5, 0.5, 0.5},
474 { 0.5, 0.5, 0.5},
475 { 0.5, -0.5, 0.5},
476 {-0.5, -0.5, 0.5}};
477 Uint32 video_flags;
478 int value;
479
480 if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
481 fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
482 exit( 1 );
483 }
484
485 /* See if we should detect the display depth */
486 if ( bpp == 0 ) {
487 if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
488 bpp = 8;
489 } else {
490 bpp = 16; /* More doesn't seem to work */
491 }
492 }
493
494 /* Set the flags we want to use for setting the video mode */
495 if ( logo && USE_DEPRECATED_OPENGLBLIT ) {
496 video_flags = SDL_OPENGLBLIT;
497 } else {
498 video_flags = SDL_OPENGL;
499 }
500 for ( i=1; argv[i]; ++i ) {
501 if ( strcmp(argv[i], "-fullscreen") == 0 ) {
502 video_flags |= SDL_FULLSCREEN;
503 }
504 }
505
506 if (noframe) {
507 video_flags |= SDL_NOFRAME;
508 }
509
510 /* Initialize the display */
511 switch (bpp) {
512 case 8:
513 rgb_size[0] = 3;
514 rgb_size[1] = 3;
515 rgb_size[2] = 2;
516 break;
517 case 15:
518 case 16:
519 rgb_size[0] = 5;
520 rgb_size[1] = 5;
521 rgb_size[2] = 5;
522 break;
523 default:
524 rgb_size[0] = 8;
525 rgb_size[1] = 8;
526 rgb_size[2] = 8;
527 break;
528 }
529 SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
530 SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
531 SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
532 SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
533 SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
534 if ( fsaa ) {
535 SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 );
536 SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, fsaa );
537 }
538 if ( accel ) {
539 SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
540 }
541 if ( sync ) {
542 SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
543 } else {
544 SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 );
545 }
546 if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
547 fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
548 SDL_Quit();
549 exit(1);
550 }
551
552 printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
553 printf("\n");
554 printf( "Vendor : %s\n", glGetString( GL_VENDOR ) );
555 printf( "Renderer : %s\n", glGetString( GL_RENDERER ) );
556 printf( "Version : %s\n", glGetString( GL_VERSION ) );
557 printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
558 printf("\n");
559
560 SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
561 printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
562 SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
563 printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
564 SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
565 printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
566 SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
567 printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
568 SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
569 printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
570 if ( fsaa ) {
571 SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &value );
572 printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value );
573 SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &value );
574 printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value );
575 }
576 if ( accel ) {
577 SDL_GL_GetAttribute( SDL_GL_ACCELERATED_VISUAL, &value );
578 printf( "SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value );
579 }
580 if ( sync ) {
581 SDL_GL_GetAttribute( SDL_GL_SWAP_CONTROL, &value );
582 printf( "SDL_GL_SWAP_CONTROL: requested 1, got %d\n", value );
583 }
584
585 /* Set the window manager title bar */
586 SDL_WM_SetCaption( "SDL GL test", "testgl" );
587
588 /* Set the gamma for the window */
589 if ( gamma != 0.0 ) {
590 SDL_SetGamma(gamma, gamma, gamma);
591 }
592
593 glViewport( 0, 0, w, h );
594 glMatrixMode( GL_PROJECTION );
595 glLoadIdentity( );
596
597 glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
598
599 glMatrixMode( GL_MODELVIEW );
600 glLoadIdentity( );
601
602 glEnable(GL_DEPTH_TEST);
603
604 glDepthFunc(GL_LESS);
605
606 glShadeModel(GL_SMOOTH);
607
608 /* Loop until done. */
609 start_time = SDL_GetTicks();
610 frames = 0;
611 while( !done ) {
612 GLenum gl_error;
613 char* sdl_error;
614 SDL_Event event;
615
616 /* Do our drawing, too. */
617 glClearColor( 0.0, 0.0, 0.0, 1.0 );
618 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
619
620 glBegin( GL_QUADS );
621
622 #ifdef SHADED_CUBE
623 glColor3fv(color[0]);
624 glVertex3fv(cube[0]);
625 glColor3fv(color[1]);
626 glVertex3fv(cube[1]);
627 glColor3fv(color[2]);
628 glVertex3fv(cube[2]);
629 glColor3fv(color[3]);
630 glVertex3fv(cube[3]);
631
632 glColor3fv(color[3]);
633 glVertex3fv(cube[3]);
634 glColor3fv(color[4]);
635 glVertex3fv(cube[4]);
636 glColor3fv(color[7]);
637 glVertex3fv(cube[7]);
638 glColor3fv(color[2]);
639 glVertex3fv(cube[2]);
640
641 glColor3fv(color[0]);
642 glVertex3fv(cube[0]);
643 glColor3fv(color[5]);
644 glVertex3fv(cube[5]);
645 glColor3fv(color[6]);
646 glVertex3fv(cube[6]);
647 glColor3fv(color[1]);
648 glVertex3fv(cube[1]);
649
650 glColor3fv(color[5]);
651 glVertex3fv(cube[5]);
652 glColor3fv(color[4]);
653 glVertex3fv(cube[4]);
654 glColor3fv(color[7]);
655 glVertex3fv(cube[7]);
656 glColor3fv(color[6]);
657 glVertex3fv(cube[6]);
658
659 glColor3fv(color[5]);
660 glVertex3fv(cube[5]);
661 glColor3fv(color[0]);
662 glVertex3fv(cube[0]);
663 glColor3fv(color[3]);
664 glVertex3fv(cube[3]);
665 glColor3fv(color[4]);
666 glVertex3fv(cube[4]);
667
668 glColor3fv(color[6]);
669 glVertex3fv(cube[6]);
670 glColor3fv(color[1]);
671 glVertex3fv(cube[1]);
672 glColor3fv(color[2]);
673 glVertex3fv(cube[2]);
674 glColor3fv(color[7]);
675 glVertex3fv(cube[7]);
676 #else /* flat cube */
677 glColor3f(1.0, 0.0, 0.0);
678 glVertex3fv(cube[0]);
679 glVertex3fv(cube[1]);
680 glVertex3fv(cube[2]);
681 glVertex3fv(cube[3]);
682
683 glColor3f(0.0, 1.0, 0.0);
684 glVertex3fv(cube[3]);
685 glVertex3fv(cube[4]);
686 glVertex3fv(cube[7]);
687 glVertex3fv(cube[2]);
688
689 glColor3f(0.0, 0.0, 1.0);
690 glVertex3fv(cube[0]);
691 glVertex3fv(cube[5]);
692 glVertex3fv(cube[6]);
693 glVertex3fv(cube[1]);
694
695 glColor3f(0.0, 1.0, 1.0);
696 glVertex3fv(cube[5]);
697 glVertex3fv(cube[4]);
698 glVertex3fv(cube[7]);
699 glVertex3fv(cube[6]);
700
701 glColor3f(1.0, 1.0, 0.0);
702 glVertex3fv(cube[5]);
703 glVertex3fv(cube[0]);
704 glVertex3fv(cube[3]);
705 glVertex3fv(cube[4]);
706
707 glColor3f(1.0, 0.0, 1.0);
708 glVertex3fv(cube[6]);
709 glVertex3fv(cube[1]);
710 glVertex3fv(cube[2]);
711 glVertex3fv(cube[7]);
712 #endif /* SHADED_CUBE */
713
714 glEnd( );
715
716 glMatrixMode(GL_MODELVIEW);
717 glRotatef(5.0, 1.0, 1.0, 1.0);
718
719 /* Draw 2D logo onto the 3D display */
720 if ( logo ) {
721 if ( USE_DEPRECATED_OPENGLBLIT ) {
722 DrawLogoBlit();
723 } else {
724 DrawLogoTexture();
725 }
726 }
727 if ( logocursor ) {
728 DrawLogoCursor();
729 }
730
731 SDL_GL_SwapBuffers( );
732
733 /* Check for error conditions. */
734 gl_error = glGetError( );
735
736 if( gl_error != GL_NO_ERROR ) {
737 fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error );
738 }
739
740 sdl_error = SDL_GetError( );
741
742 if( sdl_error[0] != '\0' ) {
743 fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
744 SDL_ClearError();
745 }
746
747 /* Allow the user to see what's happening */
748 if ( slowly ) {
749 SDL_Delay( 20 );
750 }
751
752 /* Check if there's a pending event. */
753 while( SDL_PollEvent( &event ) ) {
754 done = HandleEvent(&event);
755 }
756 ++frames;
757 }
758
759 /* Print out the frames per second */
760 this_time = SDL_GetTicks();
761 if ( this_time != start_time ) {
762 printf("%2.2f FPS\n",
763 ((float)frames/(this_time-start_time))*1000.0);
764 }
765
766 if ( global_image ) {
767 SDL_FreeSurface(global_image);
768 global_image = NULL;
769 }
770 if ( global_texture ) {
771 glDeleteTextures( 1, &global_texture );
772 global_texture = 0;
773 }
774 if ( cursor_texture ) {
775 glDeleteTextures( 1, &cursor_texture );
776 cursor_texture = 0;
777 }
778
779 /* Destroy our GL context, etc. */
780 SDL_Quit( );
781 return(0);
782 }
783
784 int main(int argc, char *argv[])
785 {
786 int i, logo, logocursor = 0;
787 int numtests;
788 int bpp = 0;
789 int slowly;
790 float gamma = 0.0;
791 int noframe = 0;
792 int fsaa = 0;
793 int accel = 0;
794 int sync = 0;
795
796 logo = 0;
797 slowly = 0;
798 numtests = 1;
799 for ( i=1; argv[i]; ++i ) {
800 if ( strcmp(argv[i], "-twice") == 0 ) {
801 ++numtests;
802 }
803 if ( strcmp(argv[i], "-logo") == 0 ) {
804 logo = 1;
805 USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
806 }
807 if ( strcmp(argv[i], "-logoblit") == 0 ) {
808 logo = 1;
809 USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
810 }
811 if ( strcmp(argv[i], "-logocursor") == 0 ) {
812 logocursor = 1;
813 }
814 if ( strcmp(argv[i], "-slow") == 0 ) {
815 slowly = 1;
816 }
817 if ( strcmp(argv[i], "-bpp") == 0 ) {
818 bpp = atoi(argv[++i]);
819 }
820 if ( strcmp(argv[i], "-gamma") == 0 ) {
821 gamma = (float)atof(argv[++i]);
822 }
823 if ( strcmp(argv[i], "-noframe") == 0 ) {
824 noframe = 1;
825 }
826 if ( strcmp(argv[i], "-fsaa") == 0 ) {
827 ++fsaa;
828 }
829 if ( strcmp(argv[i], "-accel") == 0 ) {
830 ++accel;
831 }
832 if ( strcmp(argv[i], "-sync") == 0 ) {
833 ++sync;
834 }
835 if ( strncmp(argv[i], "-h", 2) == 0 ) {
836 printf(
837 "Usage: %s [-twice] [-logo] [-logocursor] [-slow] [-bpp n] [-gamma n] [-noframe] [-fsaa] [-accel] [-sync] [-fullscreen]\n",
838 argv[0]);
839 exit(0);
840 }
841 }
842 for ( i=0; i<numtests; ++i ) {
843 RunGLTest(argc, argv, logo, logocursor, slowly, bpp, gamma, noframe, fsaa, sync, accel);
844 }
845 return 0;
846 }
847
848 #else /* HAVE_OPENGL */
849
850 int main(int argc, char *argv[])
851 {
852 printf("No OpenGL support on this system\n");
853 return 1;
854 }
855
856 #endif /* HAVE_OPENGL */
S60v3 port of SDL