test/testgl.c
author Sam Lantinga <slouken@libsdl.org>
Mon, 20 Feb 2012 23:51:08 -0500
branchSDL-1.2
changeset 6297 c787fb1b5699
parent 1815 871090feb7ad
child 1895 c121d94672cb
permissions -rw-r--r--
Fixed bug 1426 - SDL_SemWaitTimeout returns -1 and sets error instead of SDL_MUTEX_TIMEDOUT on time out

deraj 2012-02-19 19:01:08 PST

Fix to treat ETIMEDOUT as a time out instead of an error (and update the 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 */