test/testgl.c - third_party/sdl - Git at Google

 #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"

 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);
     SDL_GetSurfaceAlphaMod(surface, &saved_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();
 }

 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 */
     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 >= 0) {
         SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, accel);
     }
     if (SDL_SetVideoMode(w, h, bpp, video_flags) == NULL) {
         fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
         SDL_Quit();
         exit(1);
     }
     if (sync) {
         SDL_GL_SetSwapInterval(1);
     } else {
         SDL_GL_SetSwapInterval(0);
     }

     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 >= 0) {
         SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
         printf("SDL_GL_ACCELERATED_VISUAL: requested %d, got %d\n", accel,
                value);
     }
     if (sync) {
         printf("Buffer swap interval: requested 1, got %d\n",
                SDL_GL_GetSwapInterval());
     }

     /* 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) {
             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 = -1;
     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;
         }
         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 = atoi(argv[++i]);
         }
         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 n] [-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 */
	#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"

	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);
	SDL_GetSurfaceAlphaMod(surface, &saved_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();
	}

	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 */
	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 >= 0) {
	SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, accel);
	}
	if (SDL_SetVideoMode(w, h, bpp, video_flags) == NULL) {
	fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
	SDL_Quit();
	exit(1);
	}
	if (sync) {
	SDL_GL_SetSwapInterval(1);
	} else {
	SDL_GL_SetSwapInterval(0);
	}

	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 >= 0) {
	SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
	printf("SDL_GL_ACCELERATED_VISUAL: requested %d, got %d\n", accel,
	value);
	}
	if (sync) {
	printf("Buffer swap interval: requested 1, got %d\n",
	SDL_GL_GetSwapInterval());
	}

	/* 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) {
	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 = -1;
	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;
	}
	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 = atoi(argv[++i]);
	}
	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 n] [-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 */