/* Copyright (c) Mark J. Kilgard, 1994. */ /** * (c) Copyright 1993, Silicon Graphics, Inc. * ALL RIGHTS RESERVED * Permission to use, copy, modify, and distribute this software for * any purpose and without fee is hereby granted, provided that the above * copyright notice appear in all copies and that both the copyright notice * and this permission notice appear in supporting documentation, and that * the name of Silicon Graphics, Inc. not be used in advertising * or publicity pertaining to distribution of the software without specific, * written prior permission. * * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS" * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR * FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON * GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT, * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION, * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC. HAS BEEN * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE. * * US Government Users Restricted Rights * Use, duplication, or disclosure by the Government is subject to * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph * (c)(1)(ii) of the Rights in Technical Data and Computer Software * clause at DFARS 252.227-7013 and/or in similar or successor * clauses in the FAR or the DOD or NASA FAR Supplement. * Unpublished-- rights reserved under the copyright laws of the * United States. Contractor/manufacturer is Silicon Graphics, * Inc., 2011 N. Shoreline Blvd., Mountain View, CA 94039-7311. * * OpenGL(TM) is a trademark of Silicon Graphics, Inc. */ /* * Demonstrates texture environment modes and internal image formats. */ /* * Hacked on, updated by Gareth Hughes <gareth@valinux.com> */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <GL/glut.h> #undef max #undef min #define max( a, b ) ((a) >= (b) ? (a) : (b)) #define min( a, b ) ((a) <= (b) ? (a) : (b)) GLfloat lightCheck[4] = { 0.7, 0.7, 0.7, 1.0 }; GLfloat darkCheck[4] = { 0.3, 0.3, 0.3, 1.0 }; GLfloat labelColor0[4] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat labelColor1[4] = { 1.0, 1.0, 0.4, 1.0 }; GLfloat *labelInfoColor = labelColor0; GLfloat labelLevelColor0[4] = { 0.8, 0.8, 0.1, 1.0 }; GLfloat labelLevelColor1[4] = { 0.0, 0.0, 0.0, 1.0 }; GLboolean doubleBuffered = GL_TRUE; GLboolean drawBackground = GL_FALSE; GLboolean drawBlended = GL_TRUE; GLboolean drawSmooth = GL_FALSE; GLboolean drawTextured = GL_TRUE; GLboolean displayLevelInfo = GL_FALSE; int textureWidth = 64; int textureHeight = 64; int winWidth = 580, winHeight = 720; struct formatInfo { GLenum baseFormat; GLenum internalFormat; char *name; }; #define NUM_LUMINANCE_FORMATS (sizeof(luminanceFormats) / sizeof(luminanceFormats[0])) struct formatInfo luminanceFormats[] = { { GL_LUMINANCE, GL_LUMINANCE, "LUMINANCE" }, { GL_LUMINANCE, GL_LUMINANCE4, "LUMINANCE4" }, { GL_LUMINANCE, GL_LUMINANCE8, "LUMINANCE8" }, { GL_LUMINANCE, GL_LUMINANCE12, "LUMINANCE12" }, { GL_LUMINANCE, GL_LUMINANCE16, "LUMINANCE16" }, }; #define NUM_ALPHA_FORMATS (sizeof(alphaFormats) / sizeof(alphaFormats[0])) struct formatInfo alphaFormats[] = { { GL_ALPHA, GL_ALPHA, "ALPHA" }, { GL_ALPHA, GL_ALPHA4, "ALPHA4" }, { GL_ALPHA, GL_ALPHA8, "ALPHA8" }, { GL_ALPHA, GL_ALPHA12, "ALPHA12" }, { GL_ALPHA, GL_ALPHA16, "ALPHA16" }, }; #define NUM_INTENSITY_FORMATS (sizeof(intensityFormats) / sizeof(intensityFormats[0])) struct formatInfo intensityFormats[] = { { GL_INTENSITY, GL_INTENSITY, "INTENSITY" }, { GL_INTENSITY, GL_INTENSITY4, "INTENSITY4" }, { GL_INTENSITY, GL_INTENSITY8, "INTENSITY8" }, { GL_INTENSITY, GL_INTENSITY12, "INTENSITY12" }, { GL_INTENSITY, GL_INTENSITY16, "INTENSITY16" }, }; #define NUM_LUMINANCE_ALPHA_FORMATS (sizeof(luminanceAlphaFormats) / sizeof(luminanceAlphaFormats[0])) struct formatInfo luminanceAlphaFormats[] = { { GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, "LUMINANCE_ALPHA" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, "LUMINANCE4_ALPHA4" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, "LUMINANCE6_ALPHA2" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE8_ALPHA8, "LUMINANCE8_ALPHA8" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE12_ALPHA4, "LUMINANCE12_ALPHA4" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE12_ALPHA12, "LUMINANCE12_ALPHA12" }, { GL_LUMINANCE_ALPHA, GL_LUMINANCE16_ALPHA16, "LUMINANCE16_ALPHA16" }, }; #define NUM_RGB_FORMATS (sizeof(rgbFormats) / sizeof(rgbFormats[0])) struct formatInfo rgbFormats[] = { { GL_RGB, GL_RGB, "RGB" }, { GL_RGB, GL_R3_G3_B2, "R3_G3_B2" }, { GL_RGB, GL_RGB4, "RGB4" }, { GL_RGB, GL_RGB5, "RGB5" }, { GL_RGB, GL_RGB8, "RGB8" }, { GL_RGB, GL_RGB10, "RGB10" }, { GL_RGB, GL_RGB12, "RGB12" }, { GL_RGB, GL_RGB16, "RGB16" }, }; #define NUM_RGBA_FORMATS (sizeof(rgbaFormats) / sizeof(rgbaFormats[0])) struct formatInfo rgbaFormats[] = { { GL_RGBA, GL_RGBA, "RGBA" }, { GL_RGBA, GL_RGBA2, "RGBA2" }, { GL_RGBA, GL_RGBA4, "RGBA4" }, { GL_RGBA, GL_RGB5_A1, "RGB5_A1" }, { GL_RGBA, GL_RGBA8, "RGBA8" }, { GL_RGBA, GL_RGB10_A2, "RGB10_A2" }, { GL_RGBA, GL_RGBA12, "RGBA12" }, { GL_RGBA, GL_RGBA16, "RGBA16" }, }; struct baseFormatInfo { struct formatInfo *format; int current, number; }; #define NUM_BASE_FORMATS (sizeof(baseFormats) / sizeof(baseFormats[0])) int baseFormat; struct baseFormatInfo baseFormats[] = { { luminanceFormats, 0, NUM_LUMINANCE_FORMATS }, { alphaFormats, 0, NUM_ALPHA_FORMATS }, { intensityFormats, 0, NUM_INTENSITY_FORMATS }, { luminanceAlphaFormats, 0, NUM_LUMINANCE_ALPHA_FORMATS }, { rgbFormats, 0, NUM_RGB_FORMATS }, { rgbaFormats, 0, NUM_RGBA_FORMATS }, }; #define NUM_ENV_COLORS (sizeof(envColors) / sizeof(envColors[0])) int envColor = 0; GLfloat envColors[][4] = { { 0.0, 0.0, 0.0, 1.0 }, { 1.0, 0.0, 0.0, 1.0 }, { 0.0, 1.0, 0.0, 1.0 }, { 0.0, 0.0, 1.0, 1.0 }, { 1.0, 1.0, 1.0, 1.0 }, }; struct envModeInfo { GLenum mode; char *name; }; /* allow for run-time check for GL_EXT_texture_env_add */ int NUM_ENV_MODES = 5; struct envModeInfo envModes[] = { { GL_REPLACE, "REPLACE" }, { GL_MODULATE, "MODULATE" }, { GL_BLEND, "BLEND" }, { GL_DECAL, "DECAL" }, #if GL_EXT_texture_env_add { GL_ADD, "ADD" }, #endif }; static void checkErrors( void ) { GLenum error; while ( (error = glGetError()) != GL_NO_ERROR ) { fprintf( stderr, "Error: %s\n", (char *) gluErrorString( error ) ); } } static void drawString( const char *string, GLfloat x, GLfloat y, const GLfloat color[4] ) { glColor4fv( color ); glRasterPos2f( x, y ); while ( *string ) { glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_10, *string ); string++; } } static void drawStringOutline( const char *string, GLfloat x, GLfloat y, const GLfloat color[4], const GLfloat outline[4] ) { drawString( string, x - 1, y, outline ); drawString( string, x + 1, y, outline ); drawString( string, x, y - 1, outline ); drawString( string, x, y + 1, outline ); drawString( string, x, y, color ); } static void begin2D( int width, int height ) { glMatrixMode( GL_PROJECTION ); glPushMatrix(); glLoadIdentity(); glOrtho( 0, width, 0, height, -1, 1 ); glMatrixMode( GL_MODELVIEW ); glPushMatrix(); glLoadIdentity(); } static void end2D( void ) { glMatrixMode( GL_PROJECTION ); glPopMatrix(); glMatrixMode( GL_MODELVIEW ); glPopMatrix(); } static void initialize( void ) { glMatrixMode( GL_PROJECTION ); glLoadIdentity(); glOrtho( -1.5, 1.5, -1.5, 1.5, -1.5, 1.5 ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glShadeModel( GL_FLAT ); } /* ARGSUSED1 */ static void keyboard( unsigned char c, int x, int y ) { switch ( c ) { case 'c': envColor++; envColor = envColor % (int) NUM_ENV_COLORS; break; case 'g': drawBackground = !drawBackground; break; case 'b': drawBlended = !drawBlended; break; case 's': drawSmooth = !drawSmooth; break; case 't': drawTextured = !drawTextured; break; case 'i': displayLevelInfo = !displayLevelInfo; break; case 27: /* Escape key should force exit. */ exit(0); break; default: break; } glutPostRedisplay(); } /* ARGSUSED1 */ static void special( int key, int x, int y ) { switch ( key ) { case GLUT_KEY_DOWN: if ( ++baseFormat > NUM_BASE_FORMATS - 1 ) { baseFormat = 0; } break; case GLUT_KEY_UP: if ( --baseFormat < 0 ) { baseFormat = NUM_BASE_FORMATS - 1; } break; case GLUT_KEY_LEFT: --baseFormats[baseFormat].current; if ( baseFormats[baseFormat].current < 0 ) { baseFormats[baseFormat].current = baseFormats[baseFormat].number - 1; } break; case GLUT_KEY_RIGHT: ++baseFormats[baseFormat].current; if ( baseFormats[baseFormat].current > baseFormats[baseFormat].number - 1 ) { baseFormats[baseFormat].current = 0; } break; default: break; } glutPostRedisplay(); } static void reshape( int w, int h ) { winWidth = w; winHeight = h; /* No need to call glViewPort here since "draw" calls it! */ } static void loadTexture( int width, int height, const struct formatInfo *format ) { int luminanceSize = 0; int alphaSize = 0; int rgbSize = 0; GLenum textureFormat; GLubyte *texImage, *p; int elementsPerGroup, elementSize, groupSize, rowSize; int i, j; switch ( format->baseFormat ) { case GL_LUMINANCE: luminanceSize = 1; textureFormat = GL_LUMINANCE; break; case GL_INTENSITY: luminanceSize = 1; /* Note: format=GL_INTENSITY for glTexImage is not legal */ textureFormat = GL_LUMINANCE; break; case GL_ALPHA: alphaSize = 1; textureFormat = GL_ALPHA; break; case GL_LUMINANCE_ALPHA: luminanceSize = 1; alphaSize = 1; textureFormat = GL_LUMINANCE_ALPHA; break; case GL_RGB: rgbSize = 3; textureFormat = GL_RGB; break; case GL_RGBA: rgbSize = 3; alphaSize = 1; textureFormat = GL_RGBA; break; default: fprintf(stderr, "bad internal format info\n"); return; } elementsPerGroup = luminanceSize + alphaSize + rgbSize; elementSize = sizeof(GLubyte); groupSize = elementsPerGroup * elementSize; rowSize = width * groupSize; if ( (texImage = (GLubyte *) malloc( height * rowSize ) ) == NULL ) { fprintf( stderr, "texture malloc failed\n" ); return; } for ( i = 0 ; i < height ; i++ ) { p = texImage + i * rowSize; for ( j = 0 ; j < width ; j++ ) { if ( luminanceSize > 0 ) { /** ** +-----+-----+ ** | | | ** | W | LG | ** | | | ** +-----+-----+ ** | | | ** | DG | B | ** | | | ** +-----+-----+ **/ if ( i > height / 2 ) { if ( j < width / 2 ) { p[0] = 0xff; } else { p[0] = 0xaa; } } else { if ( j < width / 2 ) { p[0] = 0x55; } else { p[0] = 0x00; } } p += elementSize; } if ( rgbSize > 0 ) { /** ** +-----+-----+ ** | | | ** | R | G | ** | | | ** +-----+-----+ ** | | | ** | Y | B | ** | | | ** +-----+-----+ **/ if ( i > height / 2 ) { if ( j < width / 2 ) { p[0] = 0xff; p[1] = 0x00; p[2] = 0x00; } else { p[0] = 0x00; p[1] = 0xff; p[2] = 0x00; } } else { if ( j < width / 2 ) { p[0] = 0xff; p[1] = 0xff; p[2] = 0x00; } else { p[0] = 0x00; p[1] = 0x00; p[2] = 0xff; } } p += 3 * elementSize; } if ( alphaSize > 0 ) { /** ** +-----------+ ** | W | ** | +-----+ | ** | | | | ** | | B | | ** | | | | ** | +-----+ | ** | | ** +-----------+ **/ int i2 = i - height / 2; int j2 = j - width / 2; int h8 = height / 8; int w8 = width / 8; if ( -h8 <= i2 && i2 <= h8 && -w8 <= j2 && j2 <= w8 ) { p[0] = 0x00; } else if ( -2 * h8 <= i2 && i2 <= 2 * h8 && -2 * w8 <= j2 && j2 <= 2 * w8 ) { p[0] = 0x55; } else if ( -3 * h8 <= i2 && i2 <= 3 * h8 && -3 * w8 <= j2 && j2 <= 3 * w8 ) { p[0] = 0xaa; } else { p[0] = 0xff; } p += elementSize; } } } glTexImage2D( GL_TEXTURE_2D, 0, format->internalFormat, width, height, 0, textureFormat, GL_UNSIGNED_BYTE, texImage ); free( texImage ); } static void drawCheck( int w, int h, const GLfloat lightCheck[4], const GLfloat darkCheck[4] ) { float dw = 2.0 / w; float dh = 2.0 / h; int i, j; for ( i = 0 ; i < w ; i++ ) { GLfloat x0 = -1.0 + i * dw; GLfloat x1 = x0 + dw; glBegin( GL_QUAD_STRIP ); for ( j = 0 ; j <= h ; j++ ) { GLfloat y = -1.0 + j * dh; if ( (i ^ j) & 1 ) { glColor4fv( lightCheck ); } else { glColor4fv( darkCheck ); } glVertex2f( x0, y ); glVertex2f( x1, y ); } glEnd(); } } static const char *lookupFormat( GLint format ) { switch ( format ) { case GL_RGBA: return "GL_RGBA"; case GL_RGB: return "GL_RGB"; case GL_ALPHA: return "GL_ALPHA"; case GL_LUMINANCE: return "GL_LUMINANCE"; case GL_LUMINANCE_ALPHA: return "GL_LUMINANCE_ALPHA"; case GL_INTENSITY: return "GL_INTENSITY"; case GL_COLOR_INDEX: return "GL_COLOR_INDEX"; case GL_BGRA: return "GL_BGRA"; case GL_BGR: return "GL_BGR"; default: return "unknown format"; } } static void drawSample( int x, int y, int w, int h, const struct formatInfo *format, const struct envModeInfo *envMode ) { glViewport( x, y, w, h ); glScissor( x, y, w, h ); glClearColor( 0.1, 0.1, 0.1, 1.0 ); glClear( GL_COLOR_BUFFER_BIT ); begin2D( w, h ); drawString( format->name, 10, h - 15, labelInfoColor ); drawString( envMode->name, 10, 5, labelInfoColor ); end2D(); glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, envMode->mode ); glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, envColors[envColor] ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP ); loadTexture( textureWidth, textureHeight, format ); if ( drawBackground ) { drawCheck( 15, 15, lightCheck, darkCheck ); } if ( drawBlended ) { glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glEnable( GL_BLEND ); } if ( drawSmooth ) { glShadeModel( GL_SMOOTH ); } else { glShadeModel( GL_FLAT ); glColor4f(1, 1, 1, 1); } if ( drawTextured ) { glEnable( GL_TEXTURE_2D ); } /* * if (drawSmooth) then draw quad which goes from purple at the * bottom (100% alpha) to green at the top (50% alpha). */ glBegin( GL_QUADS ); if ( drawSmooth ) glColor4f( 1.0, 0.0, 1.0, 1.0 ); glTexCoord2f( 0.0, 0.0 ); glVertex2f( -0.8, -0.8 ); if ( drawSmooth ) glColor4f( 1.0, 0.0, 1.0, 1.0 ); glTexCoord2f( 1.0, 0.0 ); glVertex2f( 0.8, -0.8 ); if ( drawSmooth ) glColor4f( 0.0, 1.0, 0.0, 0.5 ); glTexCoord2f( 1.0, 1.0 ); glVertex2f( 0.8, 0.8 ); if ( drawSmooth ) glColor4f( 0.0, 1.0, 0.0, 0.5 ); glTexCoord2f( 0.0, 1.0 ); glVertex2f( -0.8, 0.8 ); glEnd(); glDisable( GL_BLEND ); glShadeModel( GL_FLAT ); glDisable( GL_TEXTURE_2D ); if ( envMode->mode == GL_DECAL && (format->baseFormat == GL_ALPHA || format->baseFormat == GL_LUMINANCE || format->baseFormat == GL_LUMINANCE_ALPHA || format->baseFormat == GL_INTENSITY)) { /* undefined format/mode combination */ begin2D( w, h ); drawStringOutline( "UNDEFINED MODE", 15, h / 2, labelLevelColor0, labelLevelColor1 ); end2D(); } else if ( displayLevelInfo ) { GLint width, height, border, format; GLint redSize, greenSize, blueSize, alphaSize; GLint luminanceSize, intensitySize; char buf[255]; glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_BORDER, &border ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &redSize ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE, &greenSize ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE, &blueSize ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &alphaSize ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_LUMINANCE_SIZE, &luminanceSize ); glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_INTENSITY_SIZE, &intensitySize ); begin2D( w, h ); sprintf( buf, "dimensions: %d x %d", width, height ); drawStringOutline( buf, 15, h / 2 + 20, labelLevelColor0, labelLevelColor1 ); sprintf( buf, "border: %d", border ); drawStringOutline( buf, 15, h / 2 + 10, labelLevelColor0, labelLevelColor1 ); sprintf( buf, "internal format:" ); drawStringOutline( buf, 15, h / 2, labelLevelColor0, labelLevelColor1 ); sprintf( buf, " %s", lookupFormat( format ) ); drawStringOutline( buf, 15, h / 2 - 10, labelLevelColor0, labelLevelColor1 ); sprintf( buf, "sizes:" ); drawStringOutline( buf, 15, h / 2 - 20, labelLevelColor0, labelLevelColor1 ); sprintf( buf, " %d / %d / %d / %d / %d / %d", redSize, greenSize, blueSize, alphaSize, luminanceSize, intensitySize ); drawStringOutline( buf, 15, h / 2 - 30, labelLevelColor0, labelLevelColor1 ); end2D(); } } static void display( void ) { int numX = NUM_ENV_MODES, numY = NUM_BASE_FORMATS; float xBase = (float) winWidth * 0.01; float xOffset = (winWidth - xBase) / numX; float xSize = max( xOffset - xBase, 1 ); float yBase = (float) winHeight * 0.01; float yOffset = (winHeight - yBase) / numY; float ySize = max( yOffset - yBase, 1 ); float x, y; int i, j; glViewport( 0, 0, winWidth, winHeight ); glDisable( GL_SCISSOR_TEST ); glClearColor( 0.0, 0.0, 0.0, 0.0 ); glClear( GL_COLOR_BUFFER_BIT ); glEnable( GL_SCISSOR_TEST ); x = xBase; y = (winHeight - 1) - yOffset; for ( i = 0 ; i < NUM_BASE_FORMATS ; i++ ) { struct formatInfo *format; if ( i == baseFormat ) { labelInfoColor = labelColor1; } else { labelInfoColor = labelColor0; } format = &baseFormats[i].format[baseFormats[i].current]; for ( j = 0 ; j < NUM_ENV_MODES ; j++ ) { struct envModeInfo *envMode; envMode = &envModes[j]; drawSample( x, y, xSize, ySize, format, envMode ); x += xOffset; } x = xBase; y -= yOffset; } if ( doubleBuffered ) { glutSwapBuffers(); } else { glFlush(); } checkErrors(); } static void usage( char *name ) { fprintf( stderr, "usage: %s [ options ]\n", name ); fprintf( stderr, "\n" ); fprintf( stderr, "options:\n" ); fprintf( stderr, " -sb single buffered\n" ); fprintf( stderr, " -db double buffered\n" ); fprintf( stderr, " -info print OpenGL driver info\n" ); } static void instructions( void ) { fprintf( stderr, "texenv - texture environment and internal format test\n" ); fprintf( stderr, "\n" ); fprintf( stderr, " [c] - cycle through background colors\n" ); fprintf( stderr, " [g] - toggle background\n" ); fprintf( stderr, " [b] - toggle blend\n" ); fprintf( stderr, " [s] - toggle smooth shading\n" ); fprintf( stderr, " [t] - toggle texturing\n" ); fprintf( stderr, " [i] - toggle information display\n" ); fprintf( stderr, " up/down - select row\n" ); fprintf( stderr, " left/right - change row's internal format\n" ); } int main( int argc, char *argv[] ) { GLboolean info = GL_FALSE; int i; glutInit( &argc, argv ); for ( i = 1 ; i < argc ; i++ ) { if ( !strcmp( "-sb", argv[i] ) ) { doubleBuffered = GL_FALSE; } else if ( !strcmp( "-db", argv[i] ) ) { doubleBuffered = GL_TRUE; } else if ( !strcmp( "-info", argv[i] ) ) { info = GL_TRUE; } else { usage( argv[0] ); exit( 1 ); } } if ( doubleBuffered ) { glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE ); } else { glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE ); } glutInitWindowSize( winWidth, winHeight ); glutInitWindowPosition( 0, 0 ); glutCreateWindow( "Texture Environment Test" ); initialize(); instructions(); if ( info ) { printf( "\n" ); printf( "GL_RENDERER = %s\n", (char *) glGetString( GL_RENDERER ) ); printf( "GL_VERSION = %s\n", (char *) glGetString( GL_VERSION ) ); printf( "GL_VENDOR = %s\n", (char *) glGetString( GL_VENDOR ) ) ; printf( "GL_EXTENSIONS = %s\n", (char *) glGetString( GL_EXTENSIONS ) ); } #if GL_EXT_texture_env_add if ( !glutExtensionSupported( "GL_EXT_texture_env_add" ) ) { fprintf( stderr, "missing extension: GL_EXT_texture_env_add\n" ); NUM_ENV_MODES--; } #endif glutDisplayFunc( display ); glutReshapeFunc( reshape ); glutKeyboardFunc( keyboard ); glutSpecialFunc( special ); glutMainLoop(); return 0; }