test/testgl.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 28 Mar 2002 16:20:10 +0000
changeset 320 66f815c147ed
parent 243 cf4944faad96
child 363 ca0b4ba5313e
permissions -rw-r--r--
Date: Thu, 28 Mar 2002 09:20:03 +0200
From: "Mike Gorchak" <mike@malva.ua>
Subject: New QNX patch.

Hi !

1. Removed warning (possible bug) with invalid type, passing to the function
in ph_WarpedMotion.
2. Rewritten handler of Ph_WM_RESIZE message, now works, but buggy (old
handler doesn't work at all).
3. Added stub handler for Ph_WM_MAX (maximize) message.
4. Added more #ifdef HAVE_OPENGL to disable OpenGL stuff when it not needed.
5. Added support for SDL_NOFRAME and SDL_RESIZABLE flags (in OpenGL windows
too).
6. Added cosmetic changes, if no SDL_RESIZABLE flag defined, disable resize
handlers in window border and maximize button at caption.
7. Fixed my bug with invalid arguments count passed to PtCreateWidget call.
8. Fixed some palette problems.
9. Updated README.QNX file.

And I changed testgl.c test application:

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