[sdl_omap.git] / test / testgl.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include "SDL.h"

#ifdef __MACOS__
#define HAVE_OPENGL
#endif

#ifdef HAVE_OPENGL

#include "SDL_opengl.h"

/* Undefine this if you want a flat cube instead of a rainbow cube */
#define SHADED_CUBE

/* Define this to be the name of the logo image to use with -logo */
#define LOGO_FILE	"icon.bmp"

/* The SDL_OPENGLBLIT interface is deprecated.
   The code is still available for benchmark purposes though.
*/

static SDL_bool USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;

static SDL_Surface *global_image = NULL;
static GLuint global_texture = 0;
static GLuint cursor_texture = 0;

/**********************************************************************/

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 SDL_GL_Enter2DMode()
{
	SDL_Surface *screen = SDL_GetVideoSurface();

	/* Note, there may be other things you need to change,
	   depending on how you have your OpenGL state set up.
	*/
	glPushAttrib(GL_ENABLE_BIT);
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);
	glEnable(GL_TEXTURE_2D);

	/* This allows alpha blending of 2D textures with the scene */
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glViewport(0, 0, screen->w, screen->h);

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();

	glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
}

void SDL_GL_Leave2DMode()
{
	glMatrixMode(GL_MODELVIEW);
	glPopMatrix();

	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

	glPopAttrib();
}

/* Quick utility function for texture creation */
static int power_of_two(int input)
{
	int value = 1;

	while ( value < input ) {
		value <<= 1;
	}
	return value;
}

GLuint SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
{
	GLuint texture;
	int w, h;
	SDL_Surface *image;
	SDL_Rect area;
	Uint32 saved_flags;
	Uint8  saved_alpha;

	/* Use the surface width and height expanded to powers of 2 */
	w = power_of_two(surface->w);
	h = power_of_two(surface->h);
	texcoord[0] = 0.0f;			/* Min X */
	texcoord[1] = 0.0f;			/* Min Y */
	texcoord[2] = (GLfloat)surface->w / w;	/* Max X */
	texcoord[3] = (GLfloat)surface->h / h;	/* Max Y */

	image = SDL_CreateRGBSurface(
			SDL_SWSURFACE,
			w, h,
			32,
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
			0x000000FF, 
			0x0000FF00, 
			0x00FF0000, 
			0xFF000000
#else
			0xFF000000,
			0x00FF0000, 
			0x0000FF00, 
			0x000000FF
#endif
		       );
	if ( image == NULL ) {
		return 0;
	}

	/* Save the alpha blending attributes */
	saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
	saved_alpha = surface->format->alpha;
	if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
		SDL_SetAlpha(surface, 0, 0);
	}

	/* Copy the surface into the GL texture image */
	area.x = 0;
	area.y = 0;
	area.w = surface->w;
	area.h = surface->h;
	SDL_BlitSurface(surface, &area, image, &area);

	/* Restore the alpha blending attributes */
	if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
		SDL_SetAlpha(surface, saved_flags, saved_alpha);
	}

	/* Create an OpenGL texture for the image */
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D,
		     0,
		     GL_RGBA,
		     w, h,
		     0,
		     GL_RGBA,
		     GL_UNSIGNED_BYTE,
		     image->pixels);
	SDL_FreeSurface(image); /* No longer needed */

	return texture;
}

void DrawLogoCursor(void)
{
	static GLfloat texMinX, texMinY;
	static GLfloat texMaxX, texMaxY;
	static int w, h;
	int x, y;

	if ( ! cursor_texture ) {
		SDL_Surface *image;
		GLfloat texcoord[4];

		/* Load the image (could use SDL_image library here) */
		image = SDL_LoadBMP(LOGO_FILE);
		if ( image == NULL ) {
			return;
		}
		w = image->w;
		h = image->h;

		/* Convert the image into an OpenGL texture */
		cursor_texture = SDL_GL_LoadTexture(image, texcoord);

		/* Make texture coordinates easy to understand */
		texMinX = texcoord[0];
		texMinY = texcoord[1];
		texMaxX = texcoord[2];
		texMaxY = texcoord[3];

		/* We don't need the original image anymore */
		SDL_FreeSurface(image);

		/* Make sure that the texture conversion is okay */
		if ( ! cursor_texture ) {
			return;
		}
	}

	/* Move the image around */
	SDL_GetMouseState(&x, &y);
	x -= w/2;
	y -= h/2;

	/* Show the image on the screen */
	SDL_GL_Enter2DMode();
	glBindTexture(GL_TEXTURE_2D, cursor_texture);
	glBegin(GL_TRIANGLE_STRIP);
	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
	glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
	glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
	glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
	glEnd();
	SDL_GL_Leave2DMode();
}

void DrawLogoTexture(void)
{
	static GLfloat texMinX, texMinY;
	static GLfloat texMaxX, texMaxY;
	static int x = 0;
	static int y = 0;
	static int w, h;
	static int delta_x = 1;
	static int delta_y = 1;

	SDL_Surface *screen = SDL_GetVideoSurface();

	if ( ! global_texture ) {
		SDL_Surface *image;
		GLfloat texcoord[4];

		/* Load the image (could use SDL_image library here) */
		image = SDL_LoadBMP(LOGO_FILE);
		if ( image == NULL ) {
			return;
		}
		w = image->w;
		h = image->h;

		/* Convert the image into an OpenGL texture */
		global_texture = SDL_GL_LoadTexture(image, texcoord);

		/* Make texture coordinates easy to understand */
		texMinX = texcoord[0];
		texMinY = texcoord[1];
		texMaxX = texcoord[2];
		texMaxY = texcoord[3];

		/* We don't need the original image anymore */
		SDL_FreeSurface(image);

		/* Make sure that the texture conversion is okay */
		if ( ! global_texture ) {
			return;
		}
	}

	/* Move the image around */
	x += delta_x;
	if ( x < 0 ) {
		x = 0;
		delta_x = -delta_x;
	} else
	if ( (x+w) > screen->w ) {
		x = screen->w-w;
		delta_x = -delta_x;
	}
	y += delta_y;
	if ( y < 0 ) {
		y = 0;
		delta_y = -delta_y;
	} else
	if ( (y+h) > screen->h ) {
		y = screen->h-h;
		delta_y = -delta_y;
	}

	/* Show the image on the screen */
	SDL_GL_Enter2DMode();
	glBindTexture(GL_TEXTURE_2D, global_texture);
	glBegin(GL_TRIANGLE_STRIP);
	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
	glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
	glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
	glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
	glEnd();
	SDL_GL_Leave2DMode();
}

/* This code is deprecated, but available for speed comparisons */
void DrawLogoBlit(void)
{
	static int x = 0;
	static int y = 0;
	static int w, h;
	static int delta_x = 1;
	static int delta_y = 1;

	SDL_Rect dst;
	SDL_Surface *screen = SDL_GetVideoSurface();

	if ( global_image == NULL ) {
		SDL_Surface *temp;

		/* Load the image (could use SDL_image library here) */
		temp = SDL_LoadBMP(LOGO_FILE);
		if ( temp == NULL ) {
			return;
		}
		w = temp->w;
		h = temp->h;

		/* Convert the image into the screen format */
		global_image = SDL_CreateRGBSurface(
				SDL_SWSURFACE,
				w, h,
				screen->format->BitsPerPixel,
				screen->format->Rmask,
				screen->format->Gmask,
				screen->format->Bmask,
				screen->format->Amask);
		if ( global_image ) {
			SDL_BlitSurface(temp, NULL, global_image, NULL);
		}
		SDL_FreeSurface(temp);

		/* Make sure that the texture conversion is okay */
		if ( ! global_image ) {
			return;
		}
	}

	/* Move the image 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..
         */
	x += delta_x;
	if ( x < 0 ) {
		x = 0;
		delta_x = -delta_x;
	} else
	if ( (x+w) > screen->w ) {
		x = screen->w-w;
		delta_x = -delta_x;
	}
	y += delta_y;
	if ( y < 0 ) {
		y = 0;
		delta_y = -delta_y;
	} else
	if ( (y+h) > screen->h ) {
		y = screen->h-h;
		delta_y = -delta_y;
	}
	dst.x = x;
	dst.y = y;
	dst.w = w;
	dst.h = h;
	SDL_BlitSurface(global_image, NULL, screen, &dst);

	/* Show the image on the screen */
	SDL_UpdateRects(screen, 1, &dst);
}

int RunGLTest( int argc, char* argv[],
               int logo, int logocursor, int slowly, int bpp, float gamma, int noframe, int fsaa, int sync, int accel )
{
	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 && USE_DEPRECATED_OPENGLBLIT ) {
		video_flags = SDL_OPENGLBLIT;
	} else {
		video_flags = SDL_OPENGL;
	}
	for ( i=1; argv[i]; ++i ) {
		if ( strcmp(argv[i], "-fullscreen") == 0 ) {
			video_flags |= SDL_FULLSCREEN;
		}
	}

        if (noframe) {
           video_flags |= SDL_NOFRAME;
        }

	/* Initialize the display */
	switch (bpp) {
	    case 8:
		rgb_size[0] = 3;
		rgb_size[1] = 3;
		rgb_size[2] = 2;
		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 ( fsaa ) {
		SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 );
		SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, fsaa );
	}
	if ( accel ) {
		SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
	}
	if ( sync ) {
		SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
	} else {
		SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 );
	}
	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 );
	if ( fsaa ) {
		SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &value );
		printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value );
		SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &value );
		printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value );
	}
	if ( accel ) {
		SDL_GL_GetAttribute( SDL_GL_ACCELERATED_VISUAL, &value );
		printf( "SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value );
	}
	if ( sync ) {
		SDL_GL_GetAttribute( SDL_GL_SWAP_CONTROL, &value );
		printf( "SDL_GL_SWAP_CONTROL: 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 ) {
			if ( USE_DEPRECATED_OPENGLBLIT ) {
				DrawLogoBlit();
			} else {
				DrawLogoTexture();
			}
		}
		if ( logocursor ) {
			DrawLogoCursor();
		}

		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);
	}

	if ( global_image ) {
	   	SDL_FreeSurface(global_image);
		global_image = NULL;
	}
	if ( global_texture ) {
		glDeleteTextures( 1, &global_texture );
		global_texture = 0;
	}
	if ( cursor_texture ) {
		glDeleteTextures( 1, &cursor_texture );
		cursor_texture = 0;
	}

	/* Destroy our GL context, etc. */
	SDL_Quit( );
	return(0);
}

int main(int argc, char *argv[])
{
	int i, logo, logocursor = 0;
	int numtests;
	int bpp = 0;
	int slowly;
	float gamma = 0.0;
	int noframe = 0;
	int fsaa = 0;
	int accel = 0;
	int sync = 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;
			USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
		}
		if ( strcmp(argv[i], "-logoblit") == 0 ) {
			logo = 1;
			USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
		}
		if ( strcmp(argv[i], "-logocursor") == 0 ) {
			logocursor = 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 ( strcmp(argv[i], "-noframe") == 0 ) {
 		       noframe = 1;
		}
		if ( strcmp(argv[i], "-fsaa") == 0 ) {
 		       ++fsaa;
		}
		if ( strcmp(argv[i], "-accel") == 0 ) {
 		       ++accel;
		}
		if ( strcmp(argv[i], "-sync") == 0 ) {
 		       ++sync;
		}
		if ( strncmp(argv[i], "-h", 2) == 0 ) {
 		       printf(
"Usage: %s [-twice] [-logo] [-logocursor] [-slow] [-bpp n] [-gamma n] [-noframe] [-fsaa] [-accel] [-sync] [-fullscreen]\n",
 			      argv[0]);
			exit(0);
		}
	}
	for ( i=0; i<numtests; ++i ) {
 		RunGLTest(argc, argv, logo, logocursor, slowly, bpp, gamma, noframe, fsaa, sync, accel);
	}
	return 0;
}

#else /* HAVE_OPENGL */

int main(int argc, char *argv[])
{
	printf("No OpenGL support on this system\n");
	return 1;
}

#endif /* HAVE_OPENGL */
Commit	Line	Data
e14743d1	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 */