test/testgl.c
author Sam Lantinga <slouken@libsdl.org>
Tue, 09 May 2006 07:26:58 +0000
changeset 1790 828a17e05192
parent 1737 eacc5bc01d1c
child 1815 871090feb7ad
permissions -rw-r--r--
Date: Mon, 8 May 2006 14:19:30 -0700
From: Bob Ippolito
Subject: SDL trunk (r2346) and Mac OS X

The current state of the trunk doesn't quite compile on Mac OS X,
I've attached a series of patches that gets it to compile and kills a
few warnings.

sdl-trunk-r2346-dlcompat-warnings.diff:
The dlcompat thing is just loaded with incorrect type signatures ..
some of them have changed since 10.2 and others are just flat wrong.
This puts it in sync with the latest headers. People on 10.2 will get
the warnings instead of people with new kits.
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
	if ( ! cursor_texture ) {
slouken@933
   249
		SDL_Surface *image;
slouken@933
   250
		GLfloat texcoord[4];
slouken@933
   251
slouken@933
   252
		/* Load the image (could use SDL_image library here) */
slouken@933
   253
		image = SDL_LoadBMP(LOGO_FILE);
slouken@933
   254
		if ( image == NULL ) {
slouken@933
   255
			return;
slouken@933
   256
		}
slouken@933
   257
		w = image->w;
slouken@933
   258
		h = image->h;
slouken@933
   259
slouken@933
   260
		/* Convert the image into an OpenGL texture */
slouken@933
   261
		cursor_texture = SDL_GL_LoadTexture(image, texcoord);
slouken@933
   262
slouken@933
   263
		/* Make texture coordinates easy to understand */
slouken@933
   264
		texMinX = texcoord[0];
slouken@933
   265
		texMinY = texcoord[1];
slouken@933
   266
		texMaxX = texcoord[2];
slouken@933
   267
		texMaxY = texcoord[3];
slouken@933
   268
slouken@933
   269
		/* We don't need the original image anymore */
slouken@933
   270
		SDL_FreeSurface(image);
slouken@933
   271
slouken@933
   272
		/* Make sure that the texture conversion is okay */
slouken@933
   273
		if ( ! cursor_texture ) {
slouken@933
   274
			return;
slouken@933
   275
		}
slouken@933
   276
	}
slouken@933
   277
slouken@933
   278
	/* Move the image around */
slouken@933
   279
	SDL_GetMouseState(&x, &y);
slouken@933
   280
	x -= w/2;
slouken@933
   281
	y -= h/2;
slouken@933
   282
slouken@933
   283
	/* Show the image on the screen */
slouken@933
   284
	SDL_GL_Enter2DMode();
slouken@933
   285
	glBindTexture(GL_TEXTURE_2D, cursor_texture);
slouken@933
   286
	glBegin(GL_TRIANGLE_STRIP);
slouken@933
   287
	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
slouken@933
   288
	glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
slouken@933
   289
	glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
slouken@933
   290
	glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
slouken@933
   291
	glEnd();
slouken@933
   292
	SDL_GL_Leave2DMode();
slouken@933
   293
}
slouken@492
   294
slouken@234
   295
void DrawLogoTexture(void)
slouken@234
   296
{
slouken@234
   297
	static GLfloat texMinX, texMinY;
slouken@234
   298
	static GLfloat texMaxX, texMaxY;
slouken@234
   299
	static int x = 0;
slouken@234
   300
	static int y = 0;
slouken@234
   301
	static int w, h;
slouken@234
   302
	static int delta_x = 1;
slouken@234
   303
	static int delta_y = 1;
slouken@234
   304
slouken@234
   305
	SDL_Surface *screen = SDL_GetVideoSurface();
slouken@234
   306
slouken@492
   307
	if ( ! global_texture ) {
slouken@234
   308
		SDL_Surface *image;
slouken@234
   309
		GLfloat texcoord[4];
slouken@234
   310
slouken@234
   311
		/* Load the image (could use SDL_image library here) */
slouken@234
   312
		image = SDL_LoadBMP(LOGO_FILE);
slouken@234
   313
		if ( image == NULL ) {
slouken@234
   314
			return;
slouken@234
   315
		}
slouken@234
   316
		w = image->w;
slouken@234
   317
		h = image->h;
slouken@234
   318
slouken@234
   319
		/* Convert the image into an OpenGL texture */
slouken@492
   320
		global_texture = SDL_GL_LoadTexture(image, texcoord);
slouken@234
   321
slouken@234
   322
		/* Make texture coordinates easy to understand */
slouken@234
   323
		texMinX = texcoord[0];
slouken@234
   324
		texMinY = texcoord[1];
slouken@234
   325
		texMaxX = texcoord[2];
slouken@234
   326
		texMaxY = texcoord[3];
slouken@234
   327
slouken@234
   328
		/* We don't need the original image anymore */
slouken@234
   329
		SDL_FreeSurface(image);
slouken@234
   330
slouken@234
   331
		/* Make sure that the texture conversion is okay */
slouken@492
   332
		if ( ! global_texture ) {
slouken@234
   333
			return;
slouken@234
   334
		}
slouken@234
   335
	}
slouken@234
   336
slouken@234
   337
	/* Move the image around */
slouken@234
   338
	x += delta_x;
slouken@234
   339
	if ( x < 0 ) {
slouken@234
   340
		x = 0;
slouken@234
   341
		delta_x = -delta_x;
slouken@234
   342
	} else
slouken@234
   343
	if ( (x+w) > screen->w ) {
slouken@234
   344
		x = screen->w-w;
slouken@234
   345
		delta_x = -delta_x;
slouken@234
   346
	}
slouken@234
   347
	y += delta_y;
slouken@234
   348
	if ( y < 0 ) {
slouken@234
   349
		y = 0;
slouken@234
   350
		delta_y = -delta_y;
slouken@234
   351
	} else
slouken@234
   352
	if ( (y+h) > screen->h ) {
slouken@234
   353
		y = screen->h-h;
slouken@234
   354
		delta_y = -delta_y;
slouken@234
   355
	}
slouken@234
   356
slouken@234
   357
	/* Show the image on the screen */
slouken@234
   358
	SDL_GL_Enter2DMode();
slouken@492
   359
	glBindTexture(GL_TEXTURE_2D, global_texture);
slouken@234
   360
	glBegin(GL_TRIANGLE_STRIP);
slouken@234
   361
	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
slouken@234
   362
	glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
slouken@234
   363
	glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
slouken@234
   364
	glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
slouken@234
   365
	glEnd();
slouken@234
   366
	SDL_GL_Leave2DMode();
slouken@234
   367
}
slouken@234
   368
slouken@234
   369
/* This code is deprecated, but available for speed comparisons */
slouken@234
   370
void DrawLogoBlit(void)
slouken@0
   371
{
slouken@0
   372
	static int x = 0;
slouken@0
   373
	static int y = 0;
slouken@233
   374
	static int w, h;
slouken@0
   375
	static int delta_x = 1;
slouken@0
   376
	static int delta_y = 1;
slouken@0
   377
slouken@0
   378
	SDL_Rect dst;
slouken@234
   379
	SDL_Surface *screen = SDL_GetVideoSurface();
slouken@0
   380
slouken@492
   381
	if ( global_image == NULL ) {
slouken@0
   382
		SDL_Surface *temp;
slouken@0
   383
slouken@234
   384
		/* Load the image (could use SDL_image library here) */
slouken@234
   385
		temp = SDL_LoadBMP(LOGO_FILE);
slouken@0
   386
		if ( temp == NULL ) {
slouken@0
   387
			return;
slouken@0
   388
		}
slouken@234
   389
		w = temp->w;
slouken@234
   390
		h = temp->h;
slouken@234
   391
slouken@234
   392
		/* Convert the image into the screen format */
slouken@492
   393
		global_image = SDL_CreateRGBSurface(
slouken@0
   394
				SDL_SWSURFACE,
slouken@234
   395
				w, h,
slouken@234
   396
				screen->format->BitsPerPixel,
slouken@234
   397
				screen->format->Rmask,
slouken@234
   398
				screen->format->Gmask,
slouken@234
   399
				screen->format->Bmask,
slouken@234
   400
				screen->format->Amask);
slouken@492
   401
		if ( global_image ) {
slouken@492
   402
			SDL_BlitSurface(temp, NULL, global_image, NULL);
slouken@0
   403
		}
slouken@0
   404
		SDL_FreeSurface(temp);
slouken@234
   405
slouken@234
   406
		/* Make sure that the texture conversion is okay */
slouken@492
   407
		if ( ! global_image ) {
slouken@0
   408
			return;
slouken@0
   409
		}
slouken@0
   410
	}
slouken@0
   411
slouken@234
   412
	/* Move the image around
slouken@0
   413
           Note that we do not clear the old position.  This is because we
slouken@0
   414
           perform a glClear() which clears the framebuffer and then only
slouken@0
   415
           update the new area.
slouken@0
   416
           Note that you can also achieve interesting effects by modifying
slouken@0
   417
           the screen surface alpha channel.  It's set to 255 by default..
slouken@0
   418
         */
slouken@234
   419
	x += delta_x;
slouken@234
   420
	if ( x < 0 ) {
slouken@234
   421
		x = 0;
slouken@234
   422
		delta_x = -delta_x;
slouken@234
   423
	} else
slouken@234
   424
	if ( (x+w) > screen->w ) {
slouken@234
   425
		x = screen->w-w;
slouken@234
   426
		delta_x = -delta_x;
slouken@0
   427
	}
slouken@234
   428
	y += delta_y;
slouken@234
   429
	if ( y < 0 ) {
slouken@234
   430
		y = 0;
slouken@234
   431
		delta_y = -delta_y;
slouken@234
   432
	} else
slouken@234
   433
	if ( (y+h) > screen->h ) {
slouken@234
   434
		y = screen->h-h;
slouken@234
   435
		delta_y = -delta_y;
slouken@233
   436
	}
slouken@234
   437
	dst.x = x;
slouken@234
   438
	dst.y = y;
slouken@234
   439
	dst.w = w;
slouken@234
   440
	dst.h = h;
slouken@492
   441
	SDL_BlitSurface(global_image, NULL, screen, &dst);
slouken@234
   442
slouken@234
   443
	/* Show the image on the screen */
slouken@234
   444
	SDL_UpdateRects(screen, 1, &dst);
slouken@0
   445
}
slouken@0
   446
slouken@0
   447
int RunGLTest( int argc, char* argv[],
slouken@1737
   448
               int logo, int logocursor, int slowly, int bpp, float gamma, int noframe, int fsaa, int sync, int accel )
slouken@0
   449
{
slouken@0
   450
	int i;
slouken@0
   451
	int rgb_size[3];
slouken@0
   452
	int w = 640;
slouken@0
   453
	int h = 480;
slouken@0
   454
	int done = 0;
slouken@0
   455
	int frames;
slouken@0
   456
	Uint32 start_time, this_time;
slouken@0
   457
        float color[8][3]= {{ 1.0,  1.0,  0.0}, 
slouken@0
   458
			    { 1.0,  0.0,  0.0},
slouken@0
   459
			    { 0.0,  0.0,  0.0},
slouken@0
   460
			    { 0.0,  1.0,  0.0},
slouken@0
   461
			    { 0.0,  1.0,  1.0},
slouken@0
   462
			    { 1.0,  1.0,  1.0},
slouken@0
   463
			    { 1.0,  0.0,  1.0},
slouken@0
   464
			    { 0.0,  0.0,  1.0}};
slouken@0
   465
	float cube[8][3]= {{ 0.5,  0.5, -0.5}, 
slouken@0
   466
			   { 0.5, -0.5, -0.5},
slouken@0
   467
			   {-0.5, -0.5, -0.5},
slouken@0
   468
			   {-0.5,  0.5, -0.5},
slouken@0
   469
			   {-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
	Uint32 video_flags;
slouken@0
   474
	int value;
slouken@0
   475
slouken@0
   476
	if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
slouken@0
   477
		fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError());
slouken@0
   478
		exit( 1 );
slouken@0
   479
	}
slouken@0
   480
slouken@0
   481
	/* See if we should detect the display depth */
slouken@0
   482
	if ( bpp == 0 ) {
slouken@0
   483
		if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) {
slouken@0
   484
			bpp = 8;
slouken@0
   485
		} else {
slouken@0
   486
			bpp = 16;  /* More doesn't seem to work */
slouken@0
   487
		}
slouken@0
   488
	}
slouken@0
   489
slouken@0
   490
	/* Set the flags we want to use for setting the video mode */
slouken@233
   491
	if ( logo && USE_DEPRECATED_OPENGLBLIT ) {
slouken@0
   492
		video_flags = SDL_OPENGLBLIT;
slouken@0
   493
	} else {
slouken@0
   494
		video_flags = SDL_OPENGL;
slouken@0
   495
	}
slouken@0
   496
	for ( i=1; argv[i]; ++i ) {
slouken@1265
   497
		if ( strcmp(argv[i], "-fullscreen") == 0 ) {
slouken@0
   498
			video_flags |= SDL_FULLSCREEN;
slouken@0
   499
		}
slouken@0
   500
	}
slouken@0
   501
slouken@320
   502
        if (noframe) {
slouken@320
   503
           video_flags |= SDL_NOFRAME;
slouken@320
   504
        }
slouken@320
   505
slouken@0
   506
	/* Initialize the display */
slouken@0
   507
	switch (bpp) {
slouken@0
   508
	    case 8:
slouken@363
   509
		rgb_size[0] = 3;
slouken@0
   510
		rgb_size[1] = 3;
slouken@363
   511
		rgb_size[2] = 2;
slouken@0
   512
		break;
slouken@0
   513
	    case 15:
slouken@0
   514
	    case 16:
slouken@0
   515
		rgb_size[0] = 5;
slouken@0
   516
		rgb_size[1] = 5;
slouken@0
   517
		rgb_size[2] = 5;
slouken@0
   518
		break;
slouken@0
   519
            default:
slouken@0
   520
		rgb_size[0] = 8;
slouken@0
   521
		rgb_size[1] = 8;
slouken@0
   522
		rgb_size[2] = 8;
slouken@0
   523
		break;
slouken@0
   524
	}
slouken@0
   525
	SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
slouken@0
   526
	SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
slouken@0
   527
	SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
slouken@0
   528
	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
slouken@0
   529
	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
slouken@655
   530
	if ( fsaa ) {
slouken@656
   531
		SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 );
slouken@656
   532
		SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, fsaa );
slouken@655
   533
	}
slouken@1737
   534
	if ( accel ) {
slouken@1737
   535
		SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
slouken@1737
   536
	}
slouken@1736
   537
	if ( sync ) {
slouken@1736
   538
		SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
slouken@1736
   539
	} else {
slouken@1736
   540
		SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 );
slouken@1736
   541
	}
slouken@0
   542
	if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
slouken@0
   543
		fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
slouken@0
   544
		SDL_Quit();
slouken@0
   545
		exit(1);
slouken@0
   546
	}
slouken@0
   547
slouken@0
   548
	printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
slouken@0
   549
	printf("\n");
slouken@0
   550
	printf( "Vendor     : %s\n", glGetString( GL_VENDOR ) );
slouken@0
   551
	printf( "Renderer   : %s\n", glGetString( GL_RENDERER ) );
slouken@0
   552
	printf( "Version    : %s\n", glGetString( GL_VERSION ) );
slouken@0
   553
	printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
slouken@0
   554
	printf("\n");
slouken@0
   555
slouken@0
   556
	SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
slouken@0
   557
	printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
slouken@0
   558
	SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
slouken@0
   559
	printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
slouken@0
   560
	SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
slouken@0
   561
	printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
slouken@0
   562
	SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
slouken@0
   563
	printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
slouken@0
   564
	SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
slouken@0
   565
	printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
slouken@655
   566
	if ( fsaa ) {
slouken@656
   567
		SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &value );
slouken@1736
   568
		printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value );
slouken@656
   569
		SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &value );
slouken@1736
   570
		printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value );
slouken@1736
   571
	}
slouken@1737
   572
	if ( accel ) {
slouken@1737
   573
		SDL_GL_GetAttribute( SDL_GL_ACCELERATED_VISUAL, &value );
slouken@1737
   574
		printf( "SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value );
slouken@1737
   575
	}
slouken@1736
   576
	if ( sync ) {
slouken@1736
   577
		SDL_GL_GetAttribute( SDL_GL_SWAP_CONTROL, &value );
slouken@1736
   578
		printf( "SDL_GL_SWAP_CONTROL: requested 1, got %d\n", value );
slouken@655
   579
	}
slouken@0
   580
slouken@0
   581
	/* Set the window manager title bar */
slouken@0
   582
	SDL_WM_SetCaption( "SDL GL test", "testgl" );
slouken@0
   583
slouken@0
   584
	/* Set the gamma for the window */
slouken@0
   585
	if ( gamma != 0.0 ) {
slouken@0
   586
		SDL_SetGamma(gamma, gamma, gamma);
slouken@0
   587
	}
slouken@0
   588
slouken@0
   589
	glViewport( 0, 0, w, h );
slouken@0
   590
	glMatrixMode( GL_PROJECTION );
slouken@0
   591
	glLoadIdentity( );
slouken@0
   592
slouken@0
   593
	glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
slouken@0
   594
slouken@0
   595
	glMatrixMode( GL_MODELVIEW );
slouken@0
   596
	glLoadIdentity( );
slouken@0
   597
slouken@0
   598
	glEnable(GL_DEPTH_TEST);
slouken@0
   599
slouken@0
   600
	glDepthFunc(GL_LESS);
slouken@0
   601
slouken@0
   602
	glShadeModel(GL_SMOOTH);
slouken@0
   603
slouken@0
   604
	/* Loop until done. */
slouken@0
   605
	start_time = SDL_GetTicks();
slouken@0
   606
	frames = 0;
slouken@0
   607
	while( !done ) {
slouken@0
   608
		GLenum gl_error;
slouken@0
   609
		char* sdl_error;
slouken@0
   610
		SDL_Event event;
slouken@0
   611
slouken@0
   612
		/* Do our drawing, too. */
slouken@0
   613
		glClearColor( 0.0, 0.0, 0.0, 1.0 );
slouken@0
   614
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
slouken@0
   615
slouken@0
   616
		glBegin( GL_QUADS );
slouken@0
   617
slouken@0
   618
#ifdef SHADED_CUBE
slouken@0
   619
			glColor3fv(color[0]);
slouken@0
   620
			glVertex3fv(cube[0]);
slouken@0
   621
			glColor3fv(color[1]);
slouken@0
   622
			glVertex3fv(cube[1]);
slouken@0
   623
			glColor3fv(color[2]);
slouken@0
   624
			glVertex3fv(cube[2]);
slouken@0
   625
			glColor3fv(color[3]);
slouken@0
   626
			glVertex3fv(cube[3]);
slouken@0
   627
			
slouken@0
   628
			glColor3fv(color[3]);
slouken@0
   629
			glVertex3fv(cube[3]);
slouken@0
   630
			glColor3fv(color[4]);
slouken@0
   631
			glVertex3fv(cube[4]);
slouken@0
   632
			glColor3fv(color[7]);
slouken@0
   633
			glVertex3fv(cube[7]);
slouken@0
   634
			glColor3fv(color[2]);
slouken@0
   635
			glVertex3fv(cube[2]);
slouken@0
   636
			
slouken@0
   637
			glColor3fv(color[0]);
slouken@0
   638
			glVertex3fv(cube[0]);
slouken@0
   639
			glColor3fv(color[5]);
slouken@0
   640
			glVertex3fv(cube[5]);
slouken@0
   641
			glColor3fv(color[6]);
slouken@0
   642
			glVertex3fv(cube[6]);
slouken@0
   643
			glColor3fv(color[1]);
slouken@0
   644
			glVertex3fv(cube[1]);
slouken@0
   645
			
slouken@0
   646
			glColor3fv(color[5]);
slouken@0
   647
			glVertex3fv(cube[5]);
slouken@0
   648
			glColor3fv(color[4]);
slouken@0
   649
			glVertex3fv(cube[4]);
slouken@0
   650
			glColor3fv(color[7]);
slouken@0
   651
			glVertex3fv(cube[7]);
slouken@0
   652
			glColor3fv(color[6]);
slouken@0
   653
			glVertex3fv(cube[6]);
slouken@0
   654
slouken@0
   655
			glColor3fv(color[5]);
slouken@0
   656
			glVertex3fv(cube[5]);
slouken@0
   657
			glColor3fv(color[0]);
slouken@0
   658
			glVertex3fv(cube[0]);
slouken@0
   659
			glColor3fv(color[3]);
slouken@0
   660
			glVertex3fv(cube[3]);
slouken@0
   661
			glColor3fv(color[4]);
slouken@0
   662
			glVertex3fv(cube[4]);
slouken@0
   663
slouken@0
   664
			glColor3fv(color[6]);
slouken@0
   665
			glVertex3fv(cube[6]);
slouken@0
   666
			glColor3fv(color[1]);
slouken@0
   667
			glVertex3fv(cube[1]);
slouken@0
   668
			glColor3fv(color[2]);
slouken@0
   669
			glVertex3fv(cube[2]);
slouken@0
   670
			glColor3fv(color[7]);
slouken@0
   671
			glVertex3fv(cube[7]);
slouken@1439
   672
#else /* flat cube */
slouken@0
   673
			glColor3f(1.0, 0.0, 0.0);
slouken@0
   674
			glVertex3fv(cube[0]);
slouken@0
   675
			glVertex3fv(cube[1]);
slouken@0
   676
			glVertex3fv(cube[2]);
slouken@0
   677
			glVertex3fv(cube[3]);
slouken@0
   678
			
slouken@0
   679
			glColor3f(0.0, 1.0, 0.0);
slouken@0
   680
			glVertex3fv(cube[3]);
slouken@0
   681
			glVertex3fv(cube[4]);
slouken@0
   682
			glVertex3fv(cube[7]);
slouken@0
   683
			glVertex3fv(cube[2]);
slouken@0
   684
			
slouken@0
   685
			glColor3f(0.0, 0.0, 1.0);
slouken@0
   686
			glVertex3fv(cube[0]);
slouken@0
   687
			glVertex3fv(cube[5]);
slouken@0
   688
			glVertex3fv(cube[6]);
slouken@0
   689
			glVertex3fv(cube[1]);
slouken@0
   690
			
slouken@0
   691
			glColor3f(0.0, 1.0, 1.0);
slouken@0
   692
			glVertex3fv(cube[5]);
slouken@0
   693
			glVertex3fv(cube[4]);
slouken@0
   694
			glVertex3fv(cube[7]);
slouken@0
   695
			glVertex3fv(cube[6]);
slouken@0
   696
slouken@0
   697
			glColor3f(1.0, 1.0, 0.0);
slouken@0
   698
			glVertex3fv(cube[5]);
slouken@0
   699
			glVertex3fv(cube[0]);
slouken@0
   700
			glVertex3fv(cube[3]);
slouken@0
   701
			glVertex3fv(cube[4]);
slouken@0
   702
slouken@0
   703
			glColor3f(1.0, 0.0, 1.0);
slouken@0
   704
			glVertex3fv(cube[6]);
slouken@0
   705
			glVertex3fv(cube[1]);
slouken@0
   706
			glVertex3fv(cube[2]);
slouken@0
   707
			glVertex3fv(cube[7]);
slouken@0
   708
#endif /* SHADED_CUBE */
slouken@0
   709
slouken@0
   710
		glEnd( );
slouken@0
   711
		
slouken@0
   712
		glMatrixMode(GL_MODELVIEW);
slouken@0
   713
		glRotatef(5.0, 1.0, 1.0, 1.0);
slouken@0
   714
slouken@0
   715
		/* Draw 2D logo onto the 3D display */
slouken@0
   716
		if ( logo ) {
slouken@234
   717
			if ( USE_DEPRECATED_OPENGLBLIT ) {
slouken@234
   718
				DrawLogoBlit();
slouken@234
   719
			} else {
slouken@234
   720
				DrawLogoTexture();
slouken@234
   721
			}
slouken@0
   722
		}
slouken@933
   723
		if ( logocursor ) {
slouken@933
   724
			DrawLogoCursor();
slouken@933
   725
		}
slouken@0
   726
slouken@0
   727
		SDL_GL_SwapBuffers( );
slouken@0
   728
slouken@0
   729
		/* Check for error conditions. */
slouken@0
   730
		gl_error = glGetError( );
slouken@0
   731
slouken@0
   732
		if( gl_error != GL_NO_ERROR ) {
slouken@0
   733
			fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error );
slouken@0
   734
		}
slouken@0
   735
slouken@0
   736
		sdl_error = SDL_GetError( );
slouken@0
   737
slouken@0
   738
		if( sdl_error[0] != '\0' ) {
slouken@0
   739
			fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
slouken@0
   740
			SDL_ClearError();
slouken@0
   741
		}
slouken@0
   742
slouken@0
   743
		/* Allow the user to see what's happening */
slouken@0
   744
		if ( slowly ) {
slouken@0
   745
			SDL_Delay( 20 );
slouken@0
   746
		}
slouken@0
   747
slouken@0
   748
		/* Check if there's a pending event. */
slouken@0
   749
		while( SDL_PollEvent( &event ) ) {
slouken@0
   750
			done = HandleEvent(&event);
slouken@0
   751
		}
slouken@0
   752
		++frames;
slouken@0
   753
	}
slouken@0
   754
slouken@0
   755
	/* Print out the frames per second */
slouken@0
   756
	this_time = SDL_GetTicks();
slouken@0
   757
	if ( this_time != start_time ) {
slouken@0
   758
		printf("%2.2f FPS\n",
slouken@0
   759
			((float)frames/(this_time-start_time))*1000.0);
slouken@0
   760
	}
slouken@0
   761
slouken@492
   762
	if ( global_image ) {
slouken@492
   763
	   	SDL_FreeSurface(global_image);
slouken@492
   764
		global_image = NULL;
slouken@492
   765
	}
slouken@492
   766
	if ( global_texture ) {
slouken@492
   767
		glDeleteTextures( 1, &global_texture );
slouken@492
   768
		global_texture = 0;
slouken@492
   769
	}
slouken@933
   770
	if ( cursor_texture ) {
slouken@933
   771
		glDeleteTextures( 1, &cursor_texture );
slouken@933
   772
		cursor_texture = 0;
slouken@933
   773
	}
slouken@492
   774
slouken@0
   775
	/* Destroy our GL context, etc. */
slouken@0
   776
	SDL_Quit( );
slouken@0
   777
	return(0);
slouken@0
   778
}
slouken@0
   779
slouken@0
   780
int main(int argc, char *argv[])
slouken@0
   781
{
slouken@1439
   782
	int i, logo, logocursor = 0;
slouken@0
   783
	int numtests;
slouken@0
   784
	int bpp = 0;
slouken@0
   785
	int slowly;
slouken@0
   786
	float gamma = 0.0;
slouken@492
   787
	int noframe = 0;
slouken@655
   788
	int fsaa = 0;
slouken@1737
   789
	int accel = 0;
slouken@1736
   790
	int sync = 0;
slouken@0
   791
slouken@0
   792
	logo = 0;
slouken@0
   793
	slowly = 0;
slouken@0
   794
	numtests = 1;
slouken@0
   795
	for ( i=1; argv[i]; ++i ) {
slouken@0
   796
		if ( strcmp(argv[i], "-twice") == 0 ) {
slouken@0
   797
			++numtests;
slouken@0
   798
		}
slouken@0
   799
		if ( strcmp(argv[i], "-logo") == 0 ) {
slouken@0
   800
			logo = 1;
slouken@233
   801
			USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
slouken@233
   802
		}
slouken@233
   803
		if ( strcmp(argv[i], "-logoblit") == 0 ) {
slouken@233
   804
			logo = 1;
slouken@233
   805
			USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
slouken@0
   806
		}
slouken@933
   807
		if ( strcmp(argv[i], "-logocursor") == 0 ) {
slouken@933
   808
			logocursor = 1;
slouken@933
   809
		}
slouken@0
   810
		if ( strcmp(argv[i], "-slow") == 0 ) {
slouken@0
   811
			slowly = 1;
slouken@0
   812
		}
slouken@0
   813
		if ( strcmp(argv[i], "-bpp") == 0 ) {
slouken@0
   814
 		       bpp = atoi(argv[++i]);
slouken@0
   815
		}
slouken@0
   816
		if ( strcmp(argv[i], "-gamma") == 0 ) {
slouken@0
   817
 		       gamma = (float)atof(argv[++i]);
slouken@0
   818
		}
slouken@320
   819
		if ( strcmp(argv[i], "-noframe") == 0 ) {
slouken@320
   820
 		       noframe = 1;
slouken@320
   821
		}
slouken@655
   822
		if ( strcmp(argv[i], "-fsaa") == 0 ) {
slouken@655
   823
 		       ++fsaa;
slouken@655
   824
		}
slouken@1737
   825
		if ( strcmp(argv[i], "-accel") == 0 ) {
slouken@1737
   826
 		       ++accel;
slouken@1737
   827
		}
slouken@1736
   828
		if ( strcmp(argv[i], "-sync") == 0 ) {
slouken@1736
   829
 		       ++sync;
slouken@1736
   830
		}
slouken@0
   831
		if ( strncmp(argv[i], "-h", 2) == 0 ) {
slouken@0
   832
 		       printf(
slouken@933
   833
"Usage: %s [-twice] [-logo] [-logocursor] [-slow] [-bpp n] [-gamma n] [-noframe] [-fsaa] [-fullscreen]\n",
slouken@0
   834
 			      argv[0]);
slouken@0
   835
			exit(0);
slouken@0
   836
		}
slouken@0
   837
	}
slouken@0
   838
	for ( i=0; i<numtests; ++i ) {
slouken@1737
   839
 		RunGLTest(argc, argv, logo, logocursor, slowly, bpp, gamma, noframe, fsaa, sync, accel);
slouken@0
   840
	}
slouken@0
   841
	return 0;
slouken@0
   842
}
slouken@0
   843
slouken@0
   844
#else /* HAVE_OPENGL */
slouken@0
   845
slouken@0
   846
int main(int argc, char *argv[])
slouken@0
   847
{
slouken@0
   848
	printf("No OpenGL support on this system\n");
slouken@0
   849
	return 1;
slouken@0
   850
}
slouken@0
   851
slouken@0
   852
#endif /* HAVE_OPENGL */