diff options
Diffstat (limited to 'nx-X11/extras/Mesa_6.4.2/progs/demos/texenv.c')
| -rw-r--r-- | nx-X11/extras/Mesa_6.4.2/progs/demos/texenv.c | 815 |
1 files changed, 815 insertions, 0 deletions
diff --git a/nx-X11/extras/Mesa_6.4.2/progs/demos/texenv.c b/nx-X11/extras/Mesa_6.4.2/progs/demos/texenv.c new file mode 100644 index 000000000..590867b49 --- /dev/null +++ b/nx-X11/extras/Mesa_6.4.2/progs/demos/texenv.c @@ -0,0 +1,815 @@ + +/* 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; +} |