test/testgl.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 18 Jul 2004 19:46:38 +0000
changeset 910 4ab6d1fd028f
parent 656 864e2d2a9a55
child 933 4272450dd8d0
permissions -rw-r--r--
Date: Sat, 26 Jun 2004 14:58:42 +0300
From: "Mike Gorchak"
Subject: QNX 6.3 fixes for SDL

Sam, I've added new OpenGL framework for SDL, which appeared in the new QNX version - 6.3. I've leave compatibility with previous QNX versions. And I've moved all GL specific functions to the separate module, like it done for the other platforms.

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