--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/testgl.c	Thu Apr 26 16:45:43 2001 +0000
@@ -0,0 +1,519 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "SDL.h"
+
+#ifdef HAVE_OPENGL
+#ifdef WIN32
+#include <windows.h>
+#endif
+#if defined(__APPLE__) && defined(__MACH__)
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+
+#define SHADED_CUBE
+
+
+void HotKey_ToggleFullScreen(void)
+{
+	SDL_Surface *screen;
+
+	screen = SDL_GetVideoSurface();
+	if ( SDL_WM_ToggleFullScreen(screen) ) {
+		printf("Toggled fullscreen mode - now %s\n",
+		    (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed");
+	} else {
+		printf("Unable to toggle fullscreen mode\n");
+	}
+}
+
+void HotKey_ToggleGrab(void)
+{
+	SDL_GrabMode mode;
+
+	printf("Ctrl-G: toggling input grab!\n");
+	mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
+	if ( mode == SDL_GRAB_ON ) {
+		printf("Grab was on\n");
+	} else {
+		printf("Grab was off\n");
+	}
+	mode = SDL_WM_GrabInput(!mode);
+	if ( mode == SDL_GRAB_ON ) {
+		printf("Grab is now on\n");
+	} else {
+		printf("Grab is now off\n");
+	}
+}
+
+void HotKey_Iconify(void)
+{
+	printf("Ctrl-Z: iconifying window!\n");
+	SDL_WM_IconifyWindow();
+}
+
+int HandleEvent(SDL_Event *event)
+{
+	int done;
+
+	done = 0;
+	switch( event->type ) {
+	    case SDL_ACTIVEEVENT:
+		/* See what happened */
+		printf( "app %s ", event->active.gain ? "gained" : "lost" );
+		if ( event->active.state & SDL_APPACTIVE ) {
+			printf( "active " );
+		} else if ( event->active.state & SDL_APPMOUSEFOCUS ) {
+			printf( "mouse " );
+		} else if ( event->active.state & SDL_APPINPUTFOCUS ) {
+			printf( "input " );
+		}
+		printf( "focus\n" );
+		break;
+		
+
+	    case SDL_KEYDOWN:
+		if ( event->key.keysym.sym == SDLK_ESCAPE ) {
+			done = 1;
+		}
+		if ( (event->key.keysym.sym == SDLK_g) &&
+		     (event->key.keysym.mod & KMOD_CTRL) ) {
+			HotKey_ToggleGrab();
+		}
+		if ( (event->key.keysym.sym == SDLK_z) &&
+		     (event->key.keysym.mod & KMOD_CTRL) ) {
+			HotKey_Iconify();
+		}
+		if ( (event->key.keysym.sym == SDLK_RETURN) &&
+		     (event->key.keysym.mod & KMOD_ALT) ) {
+			HotKey_ToggleFullScreen();
+		}
+		printf("key '%s' pressed\n", 
+			SDL_GetKeyName(event->key.keysym.sym));
+		break;
+	    case SDL_QUIT:
+		done = 1;
+		break;
+	}
+	return(done);
+}
+
+void DrawSDLLogo(void)
+{
+	static SDL_Surface *image = NULL;
+	static int x = 0;
+	static int y = 0;
+	static int delta_x = 1;
+	static int delta_y = 1;
+	static Uint32 last_moved = 0;
+
+	SDL_Rect dst;
+	SDL_Surface *screen;
+
+	if ( image == NULL ) {
+		SDL_Surface *temp;
+
+		temp = SDL_LoadBMP("icon.bmp");
+		if ( temp == NULL ) {
+			return;
+		}
+		image = SDL_CreateRGBSurface(
+				SDL_SWSURFACE,
+				temp->w, temp->h,
+				32,
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+				0x000000FF, 
+				0x0000FF00, 
+				0x00FF0000, 
+ 			       0xFF000000
+#else
+ 			       0xFF000000,
+ 			       0x00FF0000, 
+ 			       0x0000FF00, 
+ 			       0x000000FF
+#endif
+ 			       );
+		if ( image != NULL ) {
+			SDL_BlitSurface(temp, NULL, image, NULL);
+		}
+		SDL_FreeSurface(temp);
+		if ( image == NULL ) {
+			return;
+		}
+	}
+
+	screen = SDL_GetVideoSurface();
+
+	/* Show the image on the screen */
+	dst.x = x;
+	dst.y = y;
+	dst.w = image->w;
+	dst.h = image->h;
+
+	/* Move it around
+           Note that we do not clear the old position.  This is because we
+           perform a glClear() which clears the framebuffer and then only
+           update the new area.
+           Note that you can also achieve interesting effects by modifying
+           the screen surface alpha channel.  It's set to 255 by default..
+         */
+	if ( (SDL_GetTicks() - last_moved) > 100 ) {
+		x += delta_x;
+		if ( x < 0 ) {
+			x = 0;
+			delta_x = -delta_x;
+		} else
+		if ( (x+image->w) > screen->w ) {
+			x = screen->w-image->w;
+			delta_x = -delta_x;
+		}
+		y += delta_y;
+		if ( y < 0 ) {
+			y = 0;
+			delta_y = -delta_y;
+		} else
+		if ( (y+image->h) > screen->h ) {
+			y = screen->h-image->h;
+			delta_y = -delta_y;
+		}
+		SDL_BlitSurface(image, NULL, screen, &dst);
+	}
+	SDL_UpdateRects(screen, 1, &dst);
+}
+
+int RunGLTest( int argc, char* argv[],
+               int logo, int slowly, int bpp, float gamma )
+{
+	int i;
+	int rgb_size[3];
+	int w = 640;
+	int h = 480;
+	int done = 0;
+	int frames;
+	Uint32 start_time, this_time;
+        float color[8][3]= {{ 1.0,  1.0,  0.0}, 
+			    { 1.0,  0.0,  0.0},
+			    { 0.0,  0.0,  0.0},
+			    { 0.0,  1.0,  0.0},
+			    { 0.0,  1.0,  1.0},
+			    { 1.0,  1.0,  1.0},
+			    { 1.0,  0.0,  1.0},
+			    { 0.0,  0.0,  1.0}};
+	float cube[8][3]= {{ 0.5,  0.5, -0.5}, 
+			   { 0.5, -0.5, -0.5},
+			   {-0.5, -0.5, -0.5},
+			   {-0.5,  0.5, -0.5},
+			   {-0.5,  0.5,  0.5},
+			   { 0.5,  0.5,  0.5},
+			   { 0.5, -0.5,  0.5},
+			   {-0.5, -0.5,  0.5}};
+	Uint32 video_flags;
+	int value;
+
+	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
+		fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
+		exit( 1 );
+	}
+
+	/* See if we should detect the display depth */
+	if ( bpp == 0 ) {
+		if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
+			bpp = 8;
+		} else {
+			bpp = 16;  /* More doesn't seem to work */
+		}
+	}
+
+	/* Set the flags we want to use for setting the video mode */
+	if ( logo ) {
+		video_flags = SDL_OPENGLBLIT;
+	} else {
+		video_flags = SDL_OPENGL;
+	}
+	for ( i=1; argv[i]; ++i ) {
+		if ( strcmp(argv[1], "-fullscreen") == 0 ) {
+			video_flags |= SDL_FULLSCREEN;
+		}
+	}
+
+	/* Initialize the display */
+	switch (bpp) {
+	    case 8:
+		rgb_size[0] = 2;
+		rgb_size[1] = 3;
+		rgb_size[2] = 3;
+		break;
+	    case 15:
+	    case 16:
+		rgb_size[0] = 5;
+		rgb_size[1] = 5;
+		rgb_size[2] = 5;
+		break;
+            default:
+		rgb_size[0] = 8;
+		rgb_size[1] = 8;
+		rgb_size[2] = 8;
+		break;
+	}
+	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
+	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
+	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
+	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
+	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+	if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
+		fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
+		SDL_Quit();
+		exit(1);
+	}
+
+	printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
+	printf("\n");
+	printf( "Vendor     : %s\n", glGetString( GL_VENDOR ) );
+	printf( "Renderer   : %s\n", glGetString( GL_RENDERER ) );
+	printf( "Version    : %s\n", glGetString( GL_VERSION ) );
+	printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
+	printf("\n");
+
+	SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
+	printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
+	SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
+	printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
+	SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
+	printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
+	SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
+	printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
+	SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
+	printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
+
+	/* Set the window manager title bar */
+	SDL_WM_SetCaption( "SDL GL test", "testgl" );
+
+	/* Set the gamma for the window */
+	if ( gamma != 0.0 ) {
+		SDL_SetGamma(gamma, gamma, gamma);
+	}
+
+	glViewport( 0, 0, w, h );
+	glMatrixMode( GL_PROJECTION );
+	glLoadIdentity( );
+
+	glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
+
+	glMatrixMode( GL_MODELVIEW );
+	glLoadIdentity( );
+
+	glEnable(GL_DEPTH_TEST);
+
+	glDepthFunc(GL_LESS);
+
+	glShadeModel(GL_SMOOTH);
+
+	/* Loop until done. */
+	start_time = SDL_GetTicks();
+	frames = 0;
+	while( !done ) {
+		GLenum gl_error;
+		char* sdl_error;
+		SDL_Event event;
+
+		/* Do our drawing, too. */
+		glClearColor( 0.0, 0.0, 0.0, 1.0 );
+		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		glBegin( GL_QUADS );
+
+#ifdef SHADED_CUBE
+			glColor3fv(color[0]);
+			glVertex3fv(cube[0]);
+			glColor3fv(color[1]);
+			glVertex3fv(cube[1]);
+			glColor3fv(color[2]);
+			glVertex3fv(cube[2]);
+			glColor3fv(color[3]);
+			glVertex3fv(cube[3]);
+			
+			glColor3fv(color[3]);
+			glVertex3fv(cube[3]);
+			glColor3fv(color[4]);
+			glVertex3fv(cube[4]);
+			glColor3fv(color[7]);
+			glVertex3fv(cube[7]);
+			glColor3fv(color[2]);
+			glVertex3fv(cube[2]);
+			
+			glColor3fv(color[0]);
+			glVertex3fv(cube[0]);
+			glColor3fv(color[5]);
+			glVertex3fv(cube[5]);
+			glColor3fv(color[6]);
+			glVertex3fv(cube[6]);
+			glColor3fv(color[1]);
+			glVertex3fv(cube[1]);
+			
+			glColor3fv(color[5]);
+			glVertex3fv(cube[5]);
+			glColor3fv(color[4]);
+			glVertex3fv(cube[4]);
+			glColor3fv(color[7]);
+			glVertex3fv(cube[7]);
+			glColor3fv(color[6]);
+			glVertex3fv(cube[6]);
+
+			glColor3fv(color[5]);
+			glVertex3fv(cube[5]);
+			glColor3fv(color[0]);
+			glVertex3fv(cube[0]);
+			glColor3fv(color[3]);
+			glVertex3fv(cube[3]);
+			glColor3fv(color[4]);
+			glVertex3fv(cube[4]);
+
+			glColor3fv(color[6]);
+			glVertex3fv(cube[6]);
+			glColor3fv(color[1]);
+			glVertex3fv(cube[1]);
+			glColor3fv(color[2]);
+			glVertex3fv(cube[2]);
+			glColor3fv(color[7]);
+			glVertex3fv(cube[7]);
+#else // flat cube
+			glColor3f(1.0, 0.0, 0.0);
+			glVertex3fv(cube[0]);
+			glVertex3fv(cube[1]);
+			glVertex3fv(cube[2]);
+			glVertex3fv(cube[3]);
+			
+			glColor3f(0.0, 1.0, 0.0);
+			glVertex3fv(cube[3]);
+			glVertex3fv(cube[4]);
+			glVertex3fv(cube[7]);
+			glVertex3fv(cube[2]);
+			
+			glColor3f(0.0, 0.0, 1.0);
+			glVertex3fv(cube[0]);
+			glVertex3fv(cube[5]);
+			glVertex3fv(cube[6]);
+			glVertex3fv(cube[1]);
+			
+			glColor3f(0.0, 1.0, 1.0);
+			glVertex3fv(cube[5]);
+			glVertex3fv(cube[4]);
+			glVertex3fv(cube[7]);
+			glVertex3fv(cube[6]);
+
+			glColor3f(1.0, 1.0, 0.0);
+			glVertex3fv(cube[5]);
+			glVertex3fv(cube[0]);
+			glVertex3fv(cube[3]);
+			glVertex3fv(cube[4]);
+
+			glColor3f(1.0, 0.0, 1.0);
+			glVertex3fv(cube[6]);
+			glVertex3fv(cube[1]);
+			glVertex3fv(cube[2]);
+			glVertex3fv(cube[7]);
+#endif /* SHADED_CUBE */
+
+		glEnd( );
+		
+		glMatrixMode(GL_MODELVIEW);
+		glRotatef(5.0, 1.0, 1.0, 1.0);
+
+		/* Draw 2D logo onto the 3D display */
+		if ( logo ) {
+			DrawSDLLogo();
+		}
+
+		SDL_GL_SwapBuffers( );
+
+		/* Check for error conditions. */
+		gl_error = glGetError( );
+
+		if( gl_error != GL_NO_ERROR ) {
+			fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error );
+		}
+
+		sdl_error = SDL_GetError( );
+
+		if( sdl_error[0] != '\0' ) {
+			fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
+			SDL_ClearError();
+		}
+
+		/* Allow the user to see what's happening */
+		if ( slowly ) {
+			SDL_Delay( 20 );
+		}
+
+		/* Check if there's a pending event. */
+		while( SDL_PollEvent( &event ) ) {
+			done = HandleEvent(&event);
+		}
+		++frames;
+	}
+
+	/* Print out the frames per second */
+	this_time = SDL_GetTicks();
+	if ( this_time != start_time ) {
+		printf("%2.2f FPS\n",
+			((float)frames/(this_time-start_time))*1000.0);
+	}
+
+	/* Destroy our GL context, etc. */
+	SDL_Quit( );
+	return(0);
+}
+
+int main(int argc, char *argv[])
+{
+	int i, logo;
+	int numtests;
+	int bpp = 0;
+	int slowly;
+	float gamma = 0.0;
+
+	logo = 0;
+	slowly = 0;
+	numtests = 1;
+	for ( i=1; argv[i]; ++i ) {
+		if ( strcmp(argv[i], "-twice") == 0 ) {
+			++numtests;
+		}
+		if ( strcmp(argv[i], "-logo") == 0 ) {
+			logo = 1;
+		}
+		if ( strcmp(argv[i], "-slow") == 0 ) {
+			slowly = 1;
+		}
+		if ( strcmp(argv[i], "-bpp") == 0 ) {
+ 		       bpp = atoi(argv[++i]);
+		}
+		if ( strcmp(argv[i], "-gamma") == 0 ) {
+ 		       gamma = (float)atof(argv[++i]);
+		}
+		if ( strncmp(argv[i], "-h", 2) == 0 ) {
+ 		       printf(
+"Usage: %s [-twice] [-logo] [-slow] [-bpp n] [-gamma n]\n",
+ 			      argv[0]);
+			exit(0);
+		}
+	}
+	for ( i=0; i<numtests; ++i ) {
+ 	       RunGLTest(argc, argv, logo, slowly, bpp, gamma);
+	}
+	return 0;
+}
+
+#else /* HAVE_OPENGL */
+
+int main(int argc, char *argv[])
+{
+	printf("No OpenGL support on this system\n");
+	return 1;
+}
+
+#endif /* HAVE_OPENGL */