GLES 1.1 3D Cube Demo

From WebOS Internals

Jump to: navigation, search


Contents

testgl (ported to GLES 1.1)

3dcube.png
This is a test demo of a rotating 3d cube found in libsdl source code (test/testgl.c).


Running

root@palm-webos-device:/# /var/testgl -h
Usage: /var/testgl [-twice] [-logo] [-logocursor] [-slow] [-bpp n] [-gamma n] [-noframe] [-fsaa] [-accel] [-sync] [-fullscreen]
root@palm-webos-device:/# /var/testgl   
Screen BPP: 32

Vendor     : Imagination Technologies
Renderer   : PowerVR SGX 530
Version    : OpenGL ES-CM 1.1
Extensions : GL_OES_byte_coordinates GL_OES_fixed_point GL_OES_single_precision GL_OES_matrix_get GL_OES_read_format GL_OES_compressed_paletted_texture GL_OES_point_sprite GL_OES_point_size_array GL_OES_matrix_palette GL_OES_draw_texture GL_OES_query_matrix GL_OES_texture_env_crossbar GL_OES_texture_mirrored_repeat GL_OES_texture_cube_map GL_OES_blend_subtract GL_OES_blend_func_separate GL_OES_blend_equation_separate GL_OES_stencil_wrap GL_OES_extended_matrix_palette GL_OES_framebuffer_object GL_OES_rgb8_rgba8 GL_OES_depth24 GL_OES_stencil8 GL_OES_compressed_ETC1_RGB8_texture GL_OES_mapbuffer GL_OES_EGL_image GL_EXT_multi_draw_arrays GL_OES_required_internalformat GL_IMG_read_format GL_IMG_texture_compression_pvrtc GL_IMG_texture_format_BGRA8888 GL_EXT_texture_format_BGRA8888 GL_IMG_texture_stream GL_IMG_vertex_program 

SDL_GL_RED_SIZE: requested 5, got 0
SDL_GL_GREEN_SIZE: requested 5, got 0
SDL_GL_BLUE_SIZE: requested 5, got 0
SDL_GL_DEPTH_SIZE: requested 16, got 0
SDL_GL_DOUBLEBUFFER: requested 1, got 0
testgl: SDL error 'GL_GetAttribute not supported'
key 'world 71' pressed
key 'world 71' pressed
app lost active focus
296.67 FPS

GL -> GL|ES diff

diff --git a/test/testgl.c b/test/testgl.c
index dfee443..04f9c0d 100644
--- a/test/testgl.c
+++ b/test/testgl.c
@@ -11,7 +11,7 @@
 
 #ifdef HAVE_OPENGL
 
-#include "SDL_opengl.h"
+#include "SDL_opengles.h"
 
 /* Undefine this if you want a flat cube instead of a rainbow cube */
 #define SHADED_CUBE
@@ -122,7 +122,6 @@ void SDL_GL_Enter2DMode()
 	/* 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);
@@ -137,7 +136,7 @@ void SDL_GL_Enter2DMode()
 	glPushMatrix();
 	glLoadIdentity();
 
-	glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
+	glOrthof(0.0, screen->w, screen->h, 0.0, 0.0, 1.0);
 
 	glMatrixMode(GL_MODELVIEW);
 	glPushMatrix();
@@ -153,8 +152,6 @@ void SDL_GL_Leave2DMode()
 
 	glMatrixMode(GL_PROJECTION);
 	glPopMatrix();
-
-	glPopAttrib();
 }
 
 /* Quick utility function for texture creation */
@@ -287,12 +284,29 @@ void DrawLogoCursor(void)
 	/* 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();
+
+  float tex[8] = {
+    texMinX, texMinY,
+    texMaxX, texMinY,
+    texMinX, texMaxY,
+    texMaxX, texMaxY,
+  };
+
+  float ver[8] = {
+    x, y,
+    x+w, y,
+    x, y+h,
+    x+w, y+h
+  };
+
+  glEnableClientState(GL_VERTEX_ARRAY);
+  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+  glTexCoordPointer(2, GL_FLOAT, 0, tex);
+  glVertexPointer(2, GL_FLOAT, 0, ver);
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  glDisableClientState(GL_VERTEX_ARRAY);
+  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
 	SDL_GL_Leave2DMode();
 }
 
@@ -361,12 +375,29 @@ void DrawLogoTexture(void)
 	/* 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();
+
+  float tex[8] = {
+    texMinX, texMinY,
+    texMaxX, texMinY,
+    texMinX, texMaxY,
+    texMaxX, texMaxY,
+  };
+
+  float ver[8] = {
+    x, y,
+    x+w, y,
+    x, y+h,
+    x+w, y+h
+  };
+
+  glEnableClientState(GL_VERTEX_ARRAY);
+  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+  glTexCoordPointer(2, GL_FLOAT, 0, tex);
+  glVertexPointer(2, GL_FLOAT, 0, ver);
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  glDisableClientState(GL_VERTEX_ARRAY);
+  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
 	SDL_GL_Leave2DMode();
 }
 
@@ -458,22 +489,93 @@ int RunGLTest( int argc, char* argv[],
 	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}};
+#if 0
+        float color[24]= {
+           1.0,  1.0,  0.0,  // 0
+			     1.0,  0.0,  0.0,  // 1
+			     0.0,  0.0,  0.0,  // 2
+			     0.0,  1.0,  0.0,  // 3
+			     0.0,  1.0,  1.0,  // 4
+			     1.0,  1.0,  1.0,  // 5
+			     1.0,  0.0,  1.0,  // 6
+			     0.0,  0.0,  1.0   // 7
+           };
+	float cube[24]= {
+          0.5,  0.5, -0.5,   // 0
+			    0.5, -0.5, -0.5,   // 1
+			   -0.5, -0.5, -0.5,   // 2
+			   -0.5,  0.5, -0.5,   // 3
+			   -0.5,  0.5,  0.5,   // 4
+			    0.5,  0.5,  0.5,   // 5
+			    0.5, -0.5,  0.5,   // 6
+			   -0.5, -0.5,  0.5    // 7
+         };
+#endif
+  GLfloat color[96] = {
+           1.0,  1.0,  0.0, 1.0,  // 0
+			     1.0,  0.0,  0.0,  1.0, // 1
+			     0.0,  1.0,  0.0, 1.0,  // 3
+			     0.0,  0.0,  0.0,  1.0, // 2
+
+			     0.0,  1.0,  0.0, 1.0,  // 3
+			     0.0,  1.0,  1.0,  1.0, // 4
+			     0.0,  0.0,  0.0, 1.0,  // 2
+			     0.0,  0.0,  1.0, 1.0,  // 7
+
+           1.0,  1.0,  0.0, 1.0,  // 0
+			     1.0,  1.0,  1.0, 1.0,  // 5
+			     1.0,  0.0,  0.0, 1.0,  // 1
+			     1.0,  0.0,  1.0, 1.0,  // 6
+
+			     1.0,  1.0,  1.0, 1.0,  // 5
+			     0.0,  1.0,  1.0, 1.0,  // 4
+			     1.0,  0.0,  1.0, 1.0,  // 6
+			     0.0,  0.0,  1.0, 1.0,  // 7
+
+			     1.0,  1.0,  1.0, 1.0,  // 5
+           1.0,  1.0,  0.0, 1.0,  // 0
+			     0.0,  1.0,  1.0, 1.0,  // 4
+			     0.0,  1.0,  0.0, 1.0,  // 3
+
+			     1.0,  0.0,  1.0, 1.0,  // 6
+			     1.0,  0.0,  0.0, 1.0,  // 1
+			     0.0,  0.0,  1.0, 1.0,  // 7
+			     0.0,  0.0,  0.0, 1.0,  // 2
+  };
+
+  GLfloat cube[72] = {
+    
+          0.5,  0.5, -0.5,   // 0
+			    0.5, -0.5, -0.5,   // 1
+			   -0.5,  0.5, -0.5,   // 3
+			   -0.5, -0.5, -0.5,   // 2
+    
+			   -0.5,  0.5, -0.5,   // 3
+			   -0.5,  0.5,  0.5,   // 4
+			   -0.5, -0.5, -0.5,   // 2
+			   -0.5, -0.5,  0.5,   // 7
+    
+          0.5,  0.5, -0.5,   // 0
+			    0.5,  0.5,  0.5,   // 5
+			    0.5, -0.5, -0.5,   // 1
+			    0.5, -0.5,  0.5,   // 6
+    
+			    0.5,  0.5,  0.5,   // 5
+			   -0.5,  0.5,  0.5,   // 4
+			    0.5, -0.5,  0.5,   // 6
+			   -0.5, -0.5,  0.5,   // 7
+    
+			    0.5,  0.5,  0.5,   // 5
+          0.5,  0.5, -0.5,   // 0
+			   -0.5,  0.5,  0.5,   // 4
+			   -0.5,  0.5, -0.5,   // 3
+    
+			    0.5, -0.5,  0.5,   // 6
+			    0.5, -0.5, -0.5,   // 1
+			   -0.5, -0.5,  0.5,   // 7
+			   -0.5, -0.5, -0.5,   // 2
+  };
+
 	Uint32 video_flags;
 	int value;
 
@@ -482,6 +584,9 @@ int RunGLTest( int argc, char* argv[],
 		exit( 1 );
 	}
 
+       SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 1);
+       SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
 	/* See if we should detect the display depth */
 	if ( bpp == 0 ) {
 		if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
@@ -594,7 +699,7 @@ int RunGLTest( int argc, char* argv[],
 	glMatrixMode( GL_PROJECTION );
 	glLoadIdentity( );
 
-	glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
+	glOrthof( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
 
 	glMatrixMode( GL_MODELVIEW );
 	glLoadIdentity( );
@@ -617,63 +722,16 @@ int RunGLTest( int argc, char* argv[],
 		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]);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glColorPointer(4, GL_FLOAT, 0, color);
+    glVertexPointer(3, GL_FLOAT, 0, cube);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 24);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
 #else /* flat cube */
+#error NOT PORTED
 			glColor3f(1.0, 0.0, 0.0);
 			glVertex3fv(cube[0]);
 			glVertex3fv(cube[1]);
@@ -711,8 +769,6 @@ int RunGLTest( int argc, char* argv[],
 			glVertex3fv(cube[7]);
 #endif /* SHADED_CUBE */
 
-		glEnd( );
-		
 		glMatrixMode(GL_MODELVIEW);
 		glRotatef(5.0, 1.0, 1.0, 1.0);


<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_opengles.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.
	*/
	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();

	glOrthof(0.0, screen->w, 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();
}

/* 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);

  float tex[8] = {
    texMinX, texMinY,
    texMaxX, texMinY,
    texMinX, texMaxY,
    texMaxX, texMaxY,
  };

  float ver[8] = {
    x, y,
    x+w, y,
    x, y+h,
    x+w, y+h
  };

  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glTexCoordPointer(2, GL_FLOAT, 0, tex);
  glVertexPointer(2, GL_FLOAT, 0, ver);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);

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

  float tex[8] = {
    texMinX, texMinY,
    texMaxX, texMinY,
    texMinX, texMaxY,
    texMaxX, texMaxY,
  };

  float ver[8] = {
    x, y,
    x+w, y,
    x, y+h,
    x+w, y+h
  };

  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glTexCoordPointer(2, GL_FLOAT, 0, tex);
  glVertexPointer(2, GL_FLOAT, 0, ver);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);

	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 = 320;
	int h = 480;
	int done = 0;
	int frames;
	Uint32 start_time, this_time;
#if 0
        float color[24]= {
           1.0,  1.0,  0.0,  // 0
			     1.0,  0.0,  0.0,  // 1
			     0.0,  0.0,  0.0,  // 2
			     0.0,  1.0,  0.0,  // 3
			     0.0,  1.0,  1.0,  // 4
			     1.0,  1.0,  1.0,  // 5
			     1.0,  0.0,  1.0,  // 6
			     0.0,  0.0,  1.0   // 7
           };
	float cube[24]= {
          0.5,  0.5, -0.5,   // 0
			    0.5, -0.5, -0.5,   // 1
			   -0.5, -0.5, -0.5,   // 2
			   -0.5,  0.5, -0.5,   // 3
			   -0.5,  0.5,  0.5,   // 4
			    0.5,  0.5,  0.5,   // 5
			    0.5, -0.5,  0.5,   // 6
			   -0.5, -0.5,  0.5    // 7
         };
#endif
  GLfloat color[96] = {
           1.0,  1.0,  0.0, 1.0,  // 0
			     1.0,  0.0,  0.0,  1.0, // 1
			     0.0,  1.0,  0.0, 1.0,  // 3
			     0.0,  0.0,  0.0,  1.0, // 2

			     0.0,  1.0,  0.0, 1.0,  // 3
			     0.0,  1.0,  1.0,  1.0, // 4
			     0.0,  0.0,  0.0, 1.0,  // 2
			     0.0,  0.0,  1.0, 1.0,  // 7

           1.0,  1.0,  0.0, 1.0,  // 0
			     1.0,  1.0,  1.0, 1.0,  // 5
			     1.0,  0.0,  0.0, 1.0,  // 1
			     1.0,  0.0,  1.0, 1.0,  // 6

			     1.0,  1.0,  1.0, 1.0,  // 5
			     0.0,  1.0,  1.0, 1.0,  // 4
			     1.0,  0.0,  1.0, 1.0,  // 6
			     0.0,  0.0,  1.0, 1.0,  // 7

			     1.0,  1.0,  1.0, 1.0,  // 5
           1.0,  1.0,  0.0, 1.0,  // 0
			     0.0,  1.0,  1.0, 1.0,  // 4
			     0.0,  1.0,  0.0, 1.0,  // 3

			     1.0,  0.0,  1.0, 1.0,  // 6
			     1.0,  0.0,  0.0, 1.0,  // 1
			     0.0,  0.0,  1.0, 1.0,  // 7
			     0.0,  0.0,  0.0, 1.0,  // 2
  };

  GLfloat cube[72] = {
    
          0.5,  0.5, -0.5,   // 0
			    0.5, -0.5, -0.5,   // 1
			   -0.5,  0.5, -0.5,   // 3
			   -0.5, -0.5, -0.5,   // 2
    
			   -0.5,  0.5, -0.5,   // 3
			   -0.5,  0.5,  0.5,   // 4
			   -0.5, -0.5, -0.5,   // 2
			   -0.5, -0.5,  0.5,   // 7
    
          0.5,  0.5, -0.5,   // 0
			    0.5,  0.5,  0.5,   // 5
			    0.5, -0.5, -0.5,   // 1
			    0.5, -0.5,  0.5,   // 6
    
			    0.5,  0.5,  0.5,   // 5
			   -0.5,  0.5,  0.5,   // 4
			    0.5, -0.5,  0.5,   // 6
			   -0.5, -0.5,  0.5,   // 7
    
			    0.5,  0.5,  0.5,   // 5
          0.5,  0.5, -0.5,   // 0
			   -0.5,  0.5,  0.5,   // 4
			   -0.5,  0.5, -0.5,   // 3
    
			    0.5, -0.5,  0.5,   // 6
			    0.5, -0.5, -0.5,   // 1
			   -0.5, -0.5,  0.5,   // 7
			   -0.5, -0.5, -0.5,   // 2
  };

	Uint32 video_flags;
	int value;

	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
		fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
		exit( 1 );
	}

       SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 1);
       SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 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( );

	glOrthof( -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);

#ifdef SHADED_CUBE
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(4, GL_FLOAT, 0, color);
    glVertexPointer(3, GL_FLOAT, 0, cube);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 24);
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
#else /* flat cube */
#error NOT PORTED
			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 */

		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 */
Personal tools
Google AdSense