test/testgl.c
author Patrice Mandin <patmandin@gmail.com>
Thu, 19 Jan 2006 21:28:52 +0000
changeset 1257 448a9a64537b
parent 933 4272450dd8d0
child 1265 670e74bf5cc8
permissions -rw-r--r--
[PATCH] SDL_GetVideoMode() does not find best mode, part 2

Following commit 1.51, I come accross a problem when SDL must choose between
several video modes that could suit the one asked.

If I ask 320x240 with this list:
768x480 768x240 640x400 640x200 384x480 384x240 320x400 320x200

The smallest selectables modes are 384x240 and 320x400. And SDL choose the later
in this list, but 384x240 is more suitable. So I added a check to compare
the pixel count (surface) of modes, and select the one which has the smallest
pixel count.

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