test/testgl.c
author Sam Lantinga <slouken@libsdl.org>
Thu, 28 Mar 2002 16:20:10 +0000
changeset 320 66f815c147ed
parent 243 cf4944faad96
child 363 ca0b4ba5313e
permissions -rw-r--r--
Date: Thu, 28 Mar 2002 09:20:03 +0200
From: "Mike Gorchak" <mike@malva.ua>
Subject: New QNX patch.

Hi !

1. Removed warning (possible bug) with invalid type, passing to the function
in ph_WarpedMotion.
2. Rewritten handler of Ph_WM_RESIZE message, now works, but buggy (old
handler doesn't work at all).
3. Added stub handler for Ph_WM_MAX (maximize) message.
4. Added more #ifdef HAVE_OPENGL to disable OpenGL stuff when it not needed.
5. Added support for SDL_NOFRAME and SDL_RESIZABLE flags (in OpenGL windows
too).
6. Added cosmetic changes, if no SDL_RESIZABLE flag defined, disable resize
handlers in window border and maximize button at caption.
7. Fixed my bug with invalid arguments count passed to PtCreateWidget call.
8. Fixed some palette problems.
9. Updated README.QNX file.

And I changed testgl.c test application:

10. Added in testgl.c application support for SDL_NOFRAME flag and
option -noframe.
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@233
    21
static SDL_bool USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
slouken@0
    22
slouken@234
    23
/**********************************************************************/
slouken@234
    24
slouken@0
    25
void HotKey_ToggleFullScreen(void)
slouken@0
    26
{
slouken@0
    27
	SDL_Surface *screen;
slouken@0
    28
slouken@0
    29
	screen = SDL_GetVideoSurface();
slouken@0
    30
	if ( SDL_WM_ToggleFullScreen(screen) ) {
slouken@0
    31
		printf("Toggled fullscreen mode - now %s\n",
slouken@0
    32
		    (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed");
slouken@0
    33
	} else {
slouken@0
    34
		printf("Unable to toggle fullscreen mode\n");
slouken@0
    35
	}
slouken@0
    36
}
slouken@0
    37
slouken@0
    38
void HotKey_ToggleGrab(void)
slouken@0
    39
{
slouken@0
    40
	SDL_GrabMode mode;
slouken@0
    41
slouken@0
    42
	printf("Ctrl-G: toggling input grab!\n");
slouken@0
    43
	mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
slouken@0
    44
	if ( mode == SDL_GRAB_ON ) {
slouken@0
    45
		printf("Grab was on\n");
slouken@0
    46
	} else {
slouken@0
    47
		printf("Grab was off\n");
slouken@0
    48
	}
slouken@0
    49
	mode = SDL_WM_GrabInput(!mode);
slouken@0
    50
	if ( mode == SDL_GRAB_ON ) {
slouken@0
    51
		printf("Grab is now on\n");
slouken@0
    52
	} else {
slouken@0
    53
		printf("Grab is now off\n");
slouken@0
    54
	}
slouken@0
    55
}
slouken@0
    56
slouken@0
    57
void HotKey_Iconify(void)
slouken@0
    58
{
slouken@0
    59
	printf("Ctrl-Z: iconifying window!\n");
slouken@0
    60
	SDL_WM_IconifyWindow();
slouken@0
    61
}
slouken@0
    62
slouken@0
    63
int HandleEvent(SDL_Event *event)
slouken@0
    64
{
slouken@0
    65
	int done;
slouken@0
    66
slouken@0
    67
	done = 0;
slouken@0
    68
	switch( event->type ) {
slouken@0
    69
	    case SDL_ACTIVEEVENT:
slouken@0
    70
		/* See what happened */
slouken@0
    71
		printf( "app %s ", event->active.gain ? "gained" : "lost" );
slouken@0
    72
		if ( event->active.state & SDL_APPACTIVE ) {
slouken@0
    73
			printf( "active " );
slouken@0
    74
		} else if ( event->active.state & SDL_APPMOUSEFOCUS ) {
slouken@0
    75
			printf( "mouse " );
slouken@0
    76
		} else if ( event->active.state & SDL_APPINPUTFOCUS ) {
slouken@0
    77
			printf( "input " );
slouken@0
    78
		}
slouken@0
    79
		printf( "focus\n" );
slouken@0
    80
		break;
slouken@0
    81
		
slouken@0
    82
slouken@0
    83
	    case SDL_KEYDOWN:
slouken@0
    84
		if ( event->key.keysym.sym == SDLK_ESCAPE ) {
slouken@0
    85
			done = 1;
slouken@0
    86
		}
slouken@0
    87
		if ( (event->key.keysym.sym == SDLK_g) &&
slouken@0
    88
		     (event->key.keysym.mod & KMOD_CTRL) ) {
slouken@0
    89
			HotKey_ToggleGrab();
slouken@0
    90
		}
slouken@0
    91
		if ( (event->key.keysym.sym == SDLK_z) &&
slouken@0
    92
		     (event->key.keysym.mod & KMOD_CTRL) ) {
slouken@0
    93
			HotKey_Iconify();
slouken@0
    94
		}
slouken@0
    95
		if ( (event->key.keysym.sym == SDLK_RETURN) &&
slouken@0
    96
		     (event->key.keysym.mod & KMOD_ALT) ) {
slouken@0
    97
			HotKey_ToggleFullScreen();
slouken@0
    98
		}
slouken@0
    99
		printf("key '%s' pressed\n", 
slouken@0
   100
			SDL_GetKeyName(event->key.keysym.sym));
slouken@0
   101
		break;
slouken@0
   102
	    case SDL_QUIT:
slouken@0
   103
		done = 1;
slouken@0
   104
		break;
slouken@0
   105
	}
slouken@0
   106
	return(done);
slouken@0
   107
}
slouken@0
   108
slouken@233
   109
void SDL_GL_Enter2DMode()
slouken@233
   110
{
slouken@233
   111
	SDL_Surface *screen = SDL_GetVideoSurface();
slouken@233
   112
slouken@233
   113
	/* Note, there may be other things you need to change,
slouken@233
   114
	   depending on how you have your OpenGL state set up.
slouken@233
   115
	*/
slouken@233
   116
	glPushAttrib(GL_ENABLE_BIT);
slouken@233
   117
	glDisable(GL_DEPTH_TEST);
slouken@233
   118
	glDisable(GL_CULL_FACE);
slouken@233
   119
	glEnable(GL_TEXTURE_2D);
slouken@233
   120
slouken@243
   121
	/* This allows alpha blending of 2D textures with the scene */
slouken@243
   122
	glEnable(GL_BLEND);
slouken@243
   123
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
slouken@243
   124
slouken@233
   125
	glViewport(0, 0, screen->w, screen->h);
slouken@233
   126
slouken@233
   127
	glMatrixMode(GL_PROJECTION);
slouken@233
   128
	glPushMatrix();
slouken@233
   129
	glLoadIdentity();
slouken@233
   130
slouken@233
   131
	glOrtho(0.0, (GLdouble)screen->w, (GLdouble)screen->h, 0.0, 0.0, 1.0);
slouken@233
   132
slouken@233
   133
	glMatrixMode(GL_MODELVIEW);
slouken@233
   134
	glPushMatrix();
slouken@233
   135
	glLoadIdentity();
slouken@233
   136
slouken@233
   137
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
slouken@233
   138
}
slouken@233
   139
slouken@233
   140
void SDL_GL_Leave2DMode()
slouken@233
   141
{
slouken@233
   142
	glMatrixMode(GL_MODELVIEW);
slouken@233
   143
	glPopMatrix();
slouken@233
   144
slouken@233
   145
	glMatrixMode(GL_PROJECTION);
slouken@233
   146
	glPopMatrix();
slouken@233
   147
slouken@233
   148
	glPopAttrib();
slouken@233
   149
}
slouken@233
   150
slouken@234
   151
/* Quick utility function for texture creation */
slouken@234
   152
static int power_of_two(int input)
slouken@234
   153
{
slouken@234
   154
	int value = 1;
slouken@234
   155
slouken@234
   156
	while ( value < input ) {
slouken@234
   157
		value <<= 1;
slouken@234
   158
	}
slouken@234
   159
	return value;
slouken@234
   160
}
slouken@234
   161
slouken@234
   162
GLuint SDL_GL_LoadTexture(SDL_Surface *surface, GLfloat *texcoord)
slouken@234
   163
{
slouken@234
   164
	GLuint texture;
slouken@234
   165
	int w, h;
slouken@234
   166
	SDL_Surface *image;
slouken@234
   167
	SDL_Rect area;
slouken@234
   168
	Uint32 saved_flags;
slouken@234
   169
	Uint8  saved_alpha;
slouken@234
   170
slouken@234
   171
	/* Use the surface width and height expanded to powers of 2 */
slouken@234
   172
	w = power_of_two(surface->w);
slouken@234
   173
	h = power_of_two(surface->h);
slouken@234
   174
	texcoord[0] = 0.0f;			/* Min X */
slouken@234
   175
	texcoord[1] = 0.0f;			/* Min Y */
slouken@234
   176
	texcoord[2] = (GLfloat)surface->w / w;	/* Max X */
slouken@234
   177
	texcoord[3] = (GLfloat)surface->h / h;	/* Max Y */
slouken@234
   178
slouken@234
   179
	image = SDL_CreateRGBSurface(
slouken@234
   180
			SDL_SWSURFACE,
slouken@234
   181
			w, h,
slouken@234
   182
			32,
slouken@234
   183
#if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
slouken@234
   184
			0x000000FF, 
slouken@234
   185
			0x0000FF00, 
slouken@234
   186
			0x00FF0000, 
slouken@234
   187
			0xFF000000
slouken@234
   188
#else
slouken@234
   189
			0xFF000000,
slouken@234
   190
			0x00FF0000, 
slouken@234
   191
			0x0000FF00, 
slouken@234
   192
			0x000000FF
slouken@234
   193
#endif
slouken@234
   194
		       );
slouken@234
   195
	if ( image == NULL ) {
slouken@234
   196
		return 0;
slouken@234
   197
	}
slouken@234
   198
slouken@234
   199
	/* Save the alpha blending attributes */
slouken@234
   200
	saved_flags = surface->flags&(SDL_SRCALPHA|SDL_RLEACCELOK);
slouken@234
   201
	saved_alpha = surface->format->alpha;
slouken@234
   202
	if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
slouken@234
   203
		SDL_SetAlpha(surface, 0, 0);
slouken@234
   204
	}
slouken@234
   205
slouken@234
   206
	/* Copy the surface into the GL texture image */
slouken@234
   207
	area.x = 0;
slouken@234
   208
	area.y = 0;
slouken@234
   209
	area.w = surface->w;
slouken@234
   210
	area.h = surface->h;
slouken@234
   211
	SDL_BlitSurface(surface, &area, image, &area);
slouken@234
   212
slouken@234
   213
	/* Restore the alpha blending attributes */
slouken@234
   214
	if ( (saved_flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
slouken@234
   215
		SDL_SetAlpha(surface, saved_flags, saved_alpha);
slouken@234
   216
	}
slouken@234
   217
slouken@234
   218
	/* Create an OpenGL texture for the image */
slouken@234
   219
	glGenTextures(1, &texture);
slouken@234
   220
	glBindTexture(GL_TEXTURE_2D, texture);
slouken@234
   221
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
slouken@234
   222
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
slouken@234
   223
	glTexImage2D(GL_TEXTURE_2D,
slouken@234
   224
		     0,
slouken@234
   225
		     GL_RGBA,
slouken@234
   226
		     w, h,
slouken@234
   227
		     0,
slouken@234
   228
		     GL_RGBA,
slouken@234
   229
		     GL_UNSIGNED_BYTE,
slouken@234
   230
		     image->pixels);
slouken@234
   231
	SDL_FreeSurface(image); /* No longer needed */
slouken@234
   232
slouken@234
   233
	return texture;
slouken@234
   234
}
slouken@234
   235
slouken@234
   236
void DrawLogoTexture(void)
slouken@234
   237
{
slouken@234
   238
	static GLuint texture;
slouken@234
   239
	static GLfloat texMinX, texMinY;
slouken@234
   240
	static GLfloat texMaxX, texMaxY;
slouken@234
   241
	static int x = 0;
slouken@234
   242
	static int y = 0;
slouken@234
   243
	static int w, h;
slouken@234
   244
	static int delta_x = 1;
slouken@234
   245
	static int delta_y = 1;
slouken@234
   246
	static Uint32 last_moved = 0;
slouken@234
   247
slouken@234
   248
	SDL_Surface *screen = SDL_GetVideoSurface();
slouken@234
   249
slouken@234
   250
	if ( ! texture ) {
slouken@234
   251
		SDL_Surface *image;
slouken@234
   252
		GLfloat texcoord[4];
slouken@234
   253
slouken@234
   254
		/* Load the image (could use SDL_image library here) */
slouken@234
   255
		image = SDL_LoadBMP(LOGO_FILE);
slouken@234
   256
		if ( image == NULL ) {
slouken@234
   257
			return;
slouken@234
   258
		}
slouken@234
   259
		w = image->w;
slouken@234
   260
		h = image->h;
slouken@234
   261
slouken@234
   262
		/* Convert the image into an OpenGL texture */
slouken@234
   263
		texture = SDL_GL_LoadTexture(image, texcoord);
slouken@234
   264
slouken@234
   265
		/* Make texture coordinates easy to understand */
slouken@234
   266
		texMinX = texcoord[0];
slouken@234
   267
		texMinY = texcoord[1];
slouken@234
   268
		texMaxX = texcoord[2];
slouken@234
   269
		texMaxY = texcoord[3];
slouken@234
   270
slouken@234
   271
		/* We don't need the original image anymore */
slouken@234
   272
		SDL_FreeSurface(image);
slouken@234
   273
slouken@234
   274
		/* Make sure that the texture conversion is okay */
slouken@234
   275
		if ( ! texture ) {
slouken@234
   276
			return;
slouken@234
   277
		}
slouken@234
   278
	}
slouken@234
   279
slouken@234
   280
	/* Move the image around */
slouken@234
   281
	x += delta_x;
slouken@234
   282
	if ( x < 0 ) {
slouken@234
   283
		x = 0;
slouken@234
   284
		delta_x = -delta_x;
slouken@234
   285
	} else
slouken@234
   286
	if ( (x+w) > screen->w ) {
slouken@234
   287
		x = screen->w-w;
slouken@234
   288
		delta_x = -delta_x;
slouken@234
   289
	}
slouken@234
   290
	y += delta_y;
slouken@234
   291
	if ( y < 0 ) {
slouken@234
   292
		y = 0;
slouken@234
   293
		delta_y = -delta_y;
slouken@234
   294
	} else
slouken@234
   295
	if ( (y+h) > screen->h ) {
slouken@234
   296
		y = screen->h-h;
slouken@234
   297
		delta_y = -delta_y;
slouken@234
   298
	}
slouken@234
   299
slouken@234
   300
	/* Show the image on the screen */
slouken@234
   301
	SDL_GL_Enter2DMode();
slouken@234
   302
	glBindTexture(GL_TEXTURE_2D, texture);
slouken@234
   303
	glBegin(GL_TRIANGLE_STRIP);
slouken@234
   304
	glTexCoord2f(texMinX, texMinY); glVertex2i(x,   y  );
slouken@234
   305
	glTexCoord2f(texMaxX, texMinY); glVertex2i(x+w, y  );
slouken@234
   306
	glTexCoord2f(texMinX, texMaxY); glVertex2i(x,   y+h);
slouken@234
   307
	glTexCoord2f(texMaxX, texMaxY); glVertex2i(x+w, y+h);
slouken@234
   308
	glEnd();
slouken@234
   309
	SDL_GL_Leave2DMode();
slouken@234
   310
}
slouken@234
   311
slouken@234
   312
/* This code is deprecated, but available for speed comparisons */
slouken@234
   313
void DrawLogoBlit(void)
slouken@0
   314
{
slouken@0
   315
	static SDL_Surface *image = NULL;
slouken@233
   316
	static GLuint texture;
slouken@234
   317
	static GLfloat texMinX, texMinY;
slouken@234
   318
	static GLfloat texMaxX, texMaxY;
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@0
   329
	if ( 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@0
   341
		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@234
   349
		if ( image ) {
slouken@0
   350
			SDL_BlitSurface(temp, NULL, 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@234
   355
		if ( ! 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@234
   389
	SDL_BlitSurface(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@320
   396
               int logo, int slowly, int bpp, float gamma, int noframe )
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@0
   457
		rgb_size[0] = 2;
slouken@0
   458
		rgb_size[1] = 3;
slouken@0
   459
		rgb_size[2] = 3;
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@0
   478
	if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) {
slouken@0
   479
		fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
slouken@0
   480
		SDL_Quit();
slouken@0
   481
		exit(1);
slouken@0
   482
	}
slouken@0
   483
slouken@0
   484
	printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
slouken@0
   485
	printf("\n");
slouken@0
   486
	printf( "Vendor     : %s\n", glGetString( GL_VENDOR ) );
slouken@0
   487
	printf( "Renderer   : %s\n", glGetString( GL_RENDERER ) );
slouken@0
   488
	printf( "Version    : %s\n", glGetString( GL_VERSION ) );
slouken@0
   489
	printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
slouken@0
   490
	printf("\n");
slouken@0
   491
slouken@0
   492
	SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
slouken@0
   493
	printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
slouken@0
   494
	SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
slouken@0
   495
	printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
slouken@0
   496
	SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
slouken@0
   497
	printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
slouken@0
   498
	SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
slouken@0
   499
	printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
slouken@0
   500
	SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
slouken@0
   501
	printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
slouken@0
   502
slouken@0
   503
	/* Set the window manager title bar */
slouken@0
   504
	SDL_WM_SetCaption( "SDL GL test", "testgl" );
slouken@0
   505
slouken@0
   506
	/* Set the gamma for the window */
slouken@0
   507
	if ( gamma != 0.0 ) {
slouken@0
   508
		SDL_SetGamma(gamma, gamma, gamma);
slouken@0
   509
	}
slouken@0
   510
slouken@0
   511
	glViewport( 0, 0, w, h );
slouken@0
   512
	glMatrixMode( GL_PROJECTION );
slouken@0
   513
	glLoadIdentity( );
slouken@0
   514
slouken@0
   515
	glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 );
slouken@0
   516
slouken@0
   517
	glMatrixMode( GL_MODELVIEW );
slouken@0
   518
	glLoadIdentity( );
slouken@0
   519
slouken@0
   520
	glEnable(GL_DEPTH_TEST);
slouken@0
   521
slouken@0
   522
	glDepthFunc(GL_LESS);
slouken@0
   523
slouken@0
   524
	glShadeModel(GL_SMOOTH);
slouken@0
   525
slouken@0
   526
	/* Loop until done. */
slouken@0
   527
	start_time = SDL_GetTicks();
slouken@0
   528
	frames = 0;
slouken@0
   529
	while( !done ) {
slouken@0
   530
		GLenum gl_error;
slouken@0
   531
		char* sdl_error;
slouken@0
   532
		SDL_Event event;
slouken@0
   533
slouken@0
   534
		/* Do our drawing, too. */
slouken@0
   535
		glClearColor( 0.0, 0.0, 0.0, 1.0 );
slouken@0
   536
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
slouken@0
   537
slouken@0
   538
		glBegin( GL_QUADS );
slouken@0
   539
slouken@0
   540
#ifdef SHADED_CUBE
slouken@0
   541
			glColor3fv(color[0]);
slouken@0
   542
			glVertex3fv(cube[0]);
slouken@0
   543
			glColor3fv(color[1]);
slouken@0
   544
			glVertex3fv(cube[1]);
slouken@0
   545
			glColor3fv(color[2]);
slouken@0
   546
			glVertex3fv(cube[2]);
slouken@0
   547
			glColor3fv(color[3]);
slouken@0
   548
			glVertex3fv(cube[3]);
slouken@0
   549
			
slouken@0
   550
			glColor3fv(color[3]);
slouken@0
   551
			glVertex3fv(cube[3]);
slouken@0
   552
			glColor3fv(color[4]);
slouken@0
   553
			glVertex3fv(cube[4]);
slouken@0
   554
			glColor3fv(color[7]);
slouken@0
   555
			glVertex3fv(cube[7]);
slouken@0
   556
			glColor3fv(color[2]);
slouken@0
   557
			glVertex3fv(cube[2]);
slouken@0
   558
			
slouken@0
   559
			glColor3fv(color[0]);
slouken@0
   560
			glVertex3fv(cube[0]);
slouken@0
   561
			glColor3fv(color[5]);
slouken@0
   562
			glVertex3fv(cube[5]);
slouken@0
   563
			glColor3fv(color[6]);
slouken@0
   564
			glVertex3fv(cube[6]);
slouken@0
   565
			glColor3fv(color[1]);
slouken@0
   566
			glVertex3fv(cube[1]);
slouken@0
   567
			
slouken@0
   568
			glColor3fv(color[5]);
slouken@0
   569
			glVertex3fv(cube[5]);
slouken@0
   570
			glColor3fv(color[4]);
slouken@0
   571
			glVertex3fv(cube[4]);
slouken@0
   572
			glColor3fv(color[7]);
slouken@0
   573
			glVertex3fv(cube[7]);
slouken@0
   574
			glColor3fv(color[6]);
slouken@0
   575
			glVertex3fv(cube[6]);
slouken@0
   576
slouken@0
   577
			glColor3fv(color[5]);
slouken@0
   578
			glVertex3fv(cube[5]);
slouken@0
   579
			glColor3fv(color[0]);
slouken@0
   580
			glVertex3fv(cube[0]);
slouken@0
   581
			glColor3fv(color[3]);
slouken@0
   582
			glVertex3fv(cube[3]);
slouken@0
   583
			glColor3fv(color[4]);
slouken@0
   584
			glVertex3fv(cube[4]);
slouken@0
   585
slouken@0
   586
			glColor3fv(color[6]);
slouken@0
   587
			glVertex3fv(cube[6]);
slouken@0
   588
			glColor3fv(color[1]);
slouken@0
   589
			glVertex3fv(cube[1]);
slouken@0
   590
			glColor3fv(color[2]);
slouken@0
   591
			glVertex3fv(cube[2]);
slouken@0
   592
			glColor3fv(color[7]);
slouken@0
   593
			glVertex3fv(cube[7]);
slouken@0
   594
#else // flat cube
slouken@0
   595
			glColor3f(1.0, 0.0, 0.0);
slouken@0
   596
			glVertex3fv(cube[0]);
slouken@0
   597
			glVertex3fv(cube[1]);
slouken@0
   598
			glVertex3fv(cube[2]);
slouken@0
   599
			glVertex3fv(cube[3]);
slouken@0
   600
			
slouken@0
   601
			glColor3f(0.0, 1.0, 0.0);
slouken@0
   602
			glVertex3fv(cube[3]);
slouken@0
   603
			glVertex3fv(cube[4]);
slouken@0
   604
			glVertex3fv(cube[7]);
slouken@0
   605
			glVertex3fv(cube[2]);
slouken@0
   606
			
slouken@0
   607
			glColor3f(0.0, 0.0, 1.0);
slouken@0
   608
			glVertex3fv(cube[0]);
slouken@0
   609
			glVertex3fv(cube[5]);
slouken@0
   610
			glVertex3fv(cube[6]);
slouken@0
   611
			glVertex3fv(cube[1]);
slouken@0
   612
			
slouken@0
   613
			glColor3f(0.0, 1.0, 1.0);
slouken@0
   614
			glVertex3fv(cube[5]);
slouken@0
   615
			glVertex3fv(cube[4]);
slouken@0
   616
			glVertex3fv(cube[7]);
slouken@0
   617
			glVertex3fv(cube[6]);
slouken@0
   618
slouken@0
   619
			glColor3f(1.0, 1.0, 0.0);
slouken@0
   620
			glVertex3fv(cube[5]);
slouken@0
   621
			glVertex3fv(cube[0]);
slouken@0
   622
			glVertex3fv(cube[3]);
slouken@0
   623
			glVertex3fv(cube[4]);
slouken@0
   624
slouken@0
   625
			glColor3f(1.0, 0.0, 1.0);
slouken@0
   626
			glVertex3fv(cube[6]);
slouken@0
   627
			glVertex3fv(cube[1]);
slouken@0
   628
			glVertex3fv(cube[2]);
slouken@0
   629
			glVertex3fv(cube[7]);
slouken@0
   630
#endif /* SHADED_CUBE */
slouken@0
   631
slouken@0
   632
		glEnd( );
slouken@0
   633
		
slouken@0
   634
		glMatrixMode(GL_MODELVIEW);
slouken@0
   635
		glRotatef(5.0, 1.0, 1.0, 1.0);
slouken@0
   636
slouken@0
   637
		/* Draw 2D logo onto the 3D display */
slouken@0
   638
		if ( logo ) {
slouken@234
   639
			if ( USE_DEPRECATED_OPENGLBLIT ) {
slouken@234
   640
				DrawLogoBlit();
slouken@234
   641
			} else {
slouken@234
   642
				DrawLogoTexture();
slouken@234
   643
			}
slouken@0
   644
		}
slouken@0
   645
slouken@0
   646
		SDL_GL_SwapBuffers( );
slouken@0
   647
slouken@0
   648
		/* Check for error conditions. */
slouken@0
   649
		gl_error = glGetError( );
slouken@0
   650
slouken@0
   651
		if( gl_error != GL_NO_ERROR ) {
slouken@0
   652
			fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error );
slouken@0
   653
		}
slouken@0
   654
slouken@0
   655
		sdl_error = SDL_GetError( );
slouken@0
   656
slouken@0
   657
		if( sdl_error[0] != '\0' ) {
slouken@0
   658
			fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
slouken@0
   659
			SDL_ClearError();
slouken@0
   660
		}
slouken@0
   661
slouken@0
   662
		/* Allow the user to see what's happening */
slouken@0
   663
		if ( slowly ) {
slouken@0
   664
			SDL_Delay( 20 );
slouken@0
   665
		}
slouken@0
   666
slouken@0
   667
		/* Check if there's a pending event. */
slouken@0
   668
		while( SDL_PollEvent( &event ) ) {
slouken@0
   669
			done = HandleEvent(&event);
slouken@0
   670
		}
slouken@0
   671
		++frames;
slouken@0
   672
	}
slouken@0
   673
slouken@0
   674
	/* Print out the frames per second */
slouken@0
   675
	this_time = SDL_GetTicks();
slouken@0
   676
	if ( this_time != start_time ) {
slouken@0
   677
		printf("%2.2f FPS\n",
slouken@0
   678
			((float)frames/(this_time-start_time))*1000.0);
slouken@0
   679
	}
slouken@0
   680
slouken@0
   681
	/* Destroy our GL context, etc. */
slouken@0
   682
	SDL_Quit( );
slouken@0
   683
	return(0);
slouken@0
   684
}
slouken@0
   685
slouken@0
   686
int main(int argc, char *argv[])
slouken@0
   687
{
slouken@0
   688
	int i, logo;
slouken@0
   689
	int numtests;
slouken@0
   690
	int bpp = 0;
slouken@0
   691
	int slowly;
slouken@0
   692
	float gamma = 0.0;
slouken@320
   693
        int noframe = 0;
slouken@0
   694
slouken@0
   695
	logo = 0;
slouken@0
   696
	slowly = 0;
slouken@0
   697
	numtests = 1;
slouken@0
   698
	for ( i=1; argv[i]; ++i ) {
slouken@0
   699
		if ( strcmp(argv[i], "-twice") == 0 ) {
slouken@0
   700
			++numtests;
slouken@0
   701
		}
slouken@0
   702
		if ( strcmp(argv[i], "-logo") == 0 ) {
slouken@0
   703
			logo = 1;
slouken@233
   704
			USE_DEPRECATED_OPENGLBLIT = SDL_FALSE;
slouken@233
   705
		}
slouken@233
   706
		if ( strcmp(argv[i], "-logoblit") == 0 ) {
slouken@233
   707
			logo = 1;
slouken@233
   708
			USE_DEPRECATED_OPENGLBLIT = SDL_TRUE;
slouken@0
   709
		}
slouken@0
   710
		if ( strcmp(argv[i], "-slow") == 0 ) {
slouken@0
   711
			slowly = 1;
slouken@0
   712
		}
slouken@0
   713
		if ( strcmp(argv[i], "-bpp") == 0 ) {
slouken@0
   714
 		       bpp = atoi(argv[++i]);
slouken@0
   715
		}
slouken@0
   716
		if ( strcmp(argv[i], "-gamma") == 0 ) {
slouken@0
   717
 		       gamma = (float)atof(argv[++i]);
slouken@0
   718
		}
slouken@320
   719
		if ( strcmp(argv[i], "-noframe") == 0 ) {
slouken@320
   720
 		       noframe = 1;
slouken@320
   721
		}
slouken@0
   722
		if ( strncmp(argv[i], "-h", 2) == 0 ) {
slouken@0
   723
 		       printf(
slouken@320
   724
"Usage: %s [-twice] [-logo] [-slow] [-bpp n] [-gamma n] [-noframe]\n",
slouken@0
   725
 			      argv[0]);
slouken@0
   726
			exit(0);
slouken@0
   727
		}
slouken@0
   728
	}
slouken@0
   729
	for ( i=0; i<numtests; ++i ) {
slouken@320
   730
 	       RunGLTest(argc, argv, logo, slowly, bpp, gamma, noframe);
slouken@0
   731
	}
slouken@0
   732
	return 0;
slouken@0
   733
}
slouken@0
   734
slouken@0
   735
#else /* HAVE_OPENGL */
slouken@0
   736
slouken@0
   737
int main(int argc, char *argv[])
slouken@0
   738
{
slouken@0
   739
	printf("No OpenGL support on this system\n");
slouken@0
   740
	return 1;
slouken@0
   741
}
slouken@0
   742
slouken@0
   743
#endif /* HAVE_OPENGL */