Home | History | Annotate | Download | only in test
      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 */
    857