From ce65a8debe623d72cb4af142ace2be33a2fc575c Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Mon, 15 Feb 2010 09:55:01 -0700 Subject: [PATCH] progs/redbook: add additional tests for GL 1.4 --- progs/redbook/Makefile | 84 +++++++- progs/redbook/SConscript | 13 ++ progs/redbook/combiner.c | 377 ++++++++++++++++++++++++++++++++++++ progs/redbook/convolution.c | 206 ++++++++++++++++++++ progs/redbook/cubemap.c | 205 ++++++++++++++++++++ progs/redbook/fogcoord.c | 194 +++++++++++++++++++ progs/redbook/histogram.c | 201 +++++++++++++++++++ progs/redbook/minmax.c | 169 ++++++++++++++++ progs/redbook/multisamp.c | 188 ++++++++++++++++++ progs/redbook/multitex.c | 175 +++++++++++++++++ progs/redbook/mvarray.c | 136 +++++++++++++ progs/redbook/pointp.c | 179 +++++++++++++++++ progs/redbook/shadowmap.c | 352 +++++++++++++++++++++++++++++++++ progs/redbook/surfpoints.c | 280 ++++++++++++++++++++++++++ progs/redbook/texture3d.c | 161 +++++++++++++++ 15 files changed, 2912 insertions(+), 8 deletions(-) create mode 100644 progs/redbook/combiner.c create mode 100644 progs/redbook/convolution.c create mode 100644 progs/redbook/cubemap.c create mode 100644 progs/redbook/fogcoord.c create mode 100644 progs/redbook/histogram.c create mode 100644 progs/redbook/minmax.c create mode 100644 progs/redbook/multisamp.c create mode 100644 progs/redbook/multitex.c create mode 100644 progs/redbook/mvarray.c create mode 100644 progs/redbook/pointp.c create mode 100644 progs/redbook/shadowmap.c create mode 100644 progs/redbook/surfpoints.c create mode 100644 progs/redbook/texture3d.c diff --git a/progs/redbook/Makefile b/progs/redbook/Makefile index 0ba5fbbb986..b73ad056d11 100644 --- a/progs/redbook/Makefile +++ b/progs/redbook/Makefile @@ -9,14 +9,82 @@ LIB_DEP = $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME) $(TOP)/$(LIB_DIR)/$(GLU_LIB_NAME) $(T LIBS = -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLU_LIB) -l$(GL_LIB) $(APP_LIB_DEPS) -PROGS = aaindex aapoly aargb accanti accpersp alpha alpha3D anti \ - bezcurve bezmesh checker clip colormat cube depthcue dof \ - double drawf feedback fog fogindex font hello image light \ - lines list material mipmap model movelight nurbs pickdepth \ - picksquare plane planet polyoff polys quadric robot sccolorlight \ - scene scenebamb sceneflat select smooth stencil stroke surface \ - teaambient teapots tess tesswind texbind texgen texprox texsub \ - texturesurf torus trim unproject varray wrap +PROGS = aaindex \ + aapoly \ + aargb \ + accanti \ + accpersp \ + alpha \ + alpha3D \ + anti \ + bezcurve \ + bezmesh \ + checker \ + clip \ + colormat \ + combiner \ + convolution \ + cube \ + cubemap \ + depthcue \ + dof \ + double \ + drawf \ + feedback \ + fog \ + fogcoord \ + fogindex \ + font \ + hello \ + histogram \ + image \ + light \ + lines \ + list \ + material \ + minmax \ + mipmap \ + model \ + movelight \ + multitex \ + multisamp \ + mvarray \ + nurbs \ + pickdepth \ + picksquare \ + plane \ + planet \ + pointp \ + polyoff \ + polys \ + quadric \ + robot \ + sccolorlight \ + scene \ + scenebamb \ + sceneflat \ + select \ + shadowmap \ + smooth \ + stencil \ + stroke \ + surface \ + surfpoints \ + teaambient \ + teapots \ + tess \ + tesswind \ + texbind \ + texgen \ + texprox \ + texsub \ + texturesurf \ + texture3d \ + torus \ + trim \ + unproject \ + varray \ + wrap diff --git a/progs/redbook/SConscript b/progs/redbook/SConscript index 24d7cff1b67..750ad36fe01 100644 --- a/progs/redbook/SConscript +++ b/progs/redbook/SConscript @@ -14,29 +14,39 @@ progs = [ 'checker', 'clip', 'colormat', + 'combiner', + 'convolution', 'cube', + 'cubemap', 'depthcue', 'dof', 'double', 'drawf', 'feedback', 'fog', + 'fogcoord', 'fogindex', 'font', 'hello', + 'histogram', 'image', 'light', 'lines', 'list', 'material', + 'minmax', 'mipmap', 'model', 'movelight', + 'multisamp', + 'multitex', + 'mvarray', 'nurbs', 'pickdepth', 'picksquare', 'plane', 'planet', + 'pointp', 'polyoff', 'polys', 'quadric', @@ -46,10 +56,12 @@ progs = [ 'scene', 'sceneflat', 'select', + 'shadowmap', 'smooth', 'stencil', 'stroke', 'surface', + 'surfpoints', 'teaambient', 'teapots', 'tess', @@ -59,6 +71,7 @@ progs = [ 'texprox', 'texsub', 'texturesurf', + 'texture3d', 'torus', 'trim', 'unproject', diff --git a/progs/redbook/combiner.c b/progs/redbook/combiner.c new file mode 100644 index 00000000000..5e7e44152a1 --- /dev/null +++ b/progs/redbook/combiner.c @@ -0,0 +1,377 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* combiner.c + * This program renders a variety of quads showing different + * effects of texture combiner functions. + * + * The first row renders an untextured polygon (so you can + * compare the fragment colors) and then the 2 textures. + * The second row shows several different combiner functions + * on a single texture: replace, modulate, add, add-signed, + * and subtract. + * The third row shows the interpolate combiner function + * on a single texture with a constant color/alpha value, + * varying the amount of interpolation. + * The fourth row uses multitexturing with two textures + * and different combiner functions. + * The fifth row are some combiner experiments: using the + * scaling factor and reversing the order of subtraction + * for a combination function. + */ +#include +#include +#include + +#define imageWidth 8 +#define imageHeight 8 +/* arrays for two textures */ +static GLubyte image0[imageHeight][imageWidth][4]; +static GLubyte image1[imageHeight][imageWidth][4]; + +static GLuint texName[4]; + +static void makeImages(void) +{ + int i, j, c; + for (i = 0; i < imageHeight; i++) { + for (j = 0; j < imageWidth; j++) { + c = ((i&2)==0)*255; /* horiz b & w stripes */ + image0[i][j][0] = (GLubyte) c; + image0[i][j][1] = (GLubyte) c; + image0[i][j][2] = (GLubyte) c; + image0[i][j][3] = (GLubyte) 255; + c = ((j&4)!=0)*128; /* wider vertical 50% cyan and black stripes */ + image1[i][j][0] = (GLubyte) 0; + image1[i][j][1] = (GLubyte) c; + image1[i][j][2] = (GLubyte) c; + image1[i][j][3] = (GLubyte) 255; + } + } +} + +static void init(void) +{ + glClearColor (0.0, 0.0, 0.0, 0.0); + glShadeModel(GL_SMOOTH); + + makeImages(); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(4, texName); + + glBindTexture(GL_TEXTURE_2D, texName[0]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, + 0, GL_RGBA, GL_UNSIGNED_BYTE, image0); + + glBindTexture(GL_TEXTURE_2D, texName[1]); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, + 0, GL_RGBA, GL_UNSIGNED_BYTE, image1); + +/* smooth-shaded polygon with multiple texture coordinates */ + glNewList (1, GL_COMPILE); + glBegin(GL_QUADS); + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 0.0); + glColor3f (0.5, 1.0, 0.25); + glVertex3f(0.0, 0.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.0, 2.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.0, 2.0); + glColor3f (1.0, 1.0, 1.0); + glVertex3f(0.0, 1.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 2.0, 2.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 2.0, 2.0); + glColor3f (1.0, 1.0, 1.0); + glVertex3f(1.0, 1.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 2.0, 0.0); + glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 2.0, 0.0); + glColor3f (1.0, 0.5, 0.25); + glVertex3f(1.0, 0.0, 0.0); + glEnd(); + glEndList (); +} + +static void display(void) +{ + static GLfloat constColor[4] = {0.0, 0.0, 0.0, 0.0}; /* for use as constant texture color */ + + glClear(GL_COLOR_BUFFER_BIT); + + glDisable(GL_TEXTURE_2D); /* untextured polygon--see the "fragment" colors */ + glPushMatrix(); + glTranslatef(0.0, 5.0, 0.0); + glCallList(1); + glPopMatrix(); + + glEnable(GL_TEXTURE_2D); +/* draw ordinary textured polys; 1 texture unit; combine mode disabled */ + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glPushMatrix(); + glBindTexture(GL_TEXTURE_2D, texName[0]); + glTranslatef(1.0, 5.0, 0.0); + glCallList(1); + glPopMatrix(); + + glPushMatrix(); + glBindTexture(GL_TEXTURE_2D, texName[1]); + glTranslatef(2.0, 5.0, 0.0); + glCallList(1); + glPopMatrix(); + +/* different combine modes enabled; 1 texture unit + * defaults are: + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + */ + glBindTexture(GL_TEXTURE_2D, texName[0]); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glPushMatrix(); + glTranslatef(1.0, 4.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glPushMatrix(); + glTranslatef(2.0, 4.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD); + glPushMatrix(); + glTranslatef(3.0, 4.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB); + glPushMatrix(); + glTranslatef(4.0, 4.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_SUBTRACT_ARB); + glPushMatrix(); + glTranslatef(5.0, 4.0, 0.0); + glCallList(1); + glPopMatrix(); + +/* interpolate combine with constant color; 1 texture unit + * use different alpha values for constant color + * defaults are: + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT_ARB); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA); + */ + constColor[3] = 0.2; + glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constColor); + glBindTexture(GL_TEXTURE_2D, texName[0]); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA); + glPushMatrix(); + glTranslatef(1.0, 3.0, 0.0); + glCallList(1); + glPopMatrix(); + + constColor[3] = 0.4; + glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constColor); + glPushMatrix(); + glTranslatef(2.0, 3.0, 0.0); + glCallList(1); + glPopMatrix(); + + constColor[3] = 0.6; + glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constColor); + glPushMatrix(); + glTranslatef(3.0, 3.0, 0.0); + glCallList(1); + glPopMatrix(); + + constColor[4] = 0.8; + glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constColor); + glPushMatrix(); + glTranslatef(4.0, 3.0, 0.0); + glCallList(1); + glPopMatrix(); + +/* combine textures 0 & 1 + * defaults are: + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + * glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB); + * glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + */ + + glActiveTextureARB (GL_TEXTURE0_ARB); + glEnable (GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, texName[0]); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glActiveTextureARB (GL_TEXTURE1_ARB); + glEnable (GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, texName[1]); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glPushMatrix(); + glTranslatef(1.0, 2.0, 0.0); + glCallList(1); + glPopMatrix(); + + /* try different combiner modes of texture unit 1 */ + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); + glPushMatrix(); + glTranslatef(2.0, 2.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD); + glPushMatrix(); + glTranslatef(3.0, 2.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB); + glPushMatrix(); + glTranslatef(4.0, 2.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_SUBTRACT_ARB); + glPushMatrix(); + glTranslatef(5.0, 2.0, 0.0); + glCallList(1); + glPopMatrix(); + +/* some experiments */ + +/* see the effect of RGB_SCALE */ + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2.0); + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); + glPushMatrix(); + glTranslatef(1.0, 1.0, 0.0); + glCallList(1); + glPopMatrix(); + + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE); + glPushMatrix(); + glTranslatef(2.0, 1.0, 0.0); + glCallList(1); + glPopMatrix(); + glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0); + +/* using SOURCE0 and SOURCE1, reverse the order of subtraction Arg1-Arg0 */ + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_SUBTRACT_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR); + glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE); + glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glPushMatrix(); + glTranslatef(5.0, 1.0, 0.0); + glCallList(1); + glPopMatrix(); + + glActiveTextureARB (GL_TEXTURE1_ARB); /* deactivate multitexturing */ + glDisable (GL_TEXTURE_2D); + glActiveTextureARB (GL_TEXTURE0_ARB); /* activate single texture unit */ + + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluOrtho2D(0.0, 7.0, 0.0, 7.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +static void keyboard (unsigned char key, int x, int y) +{ + switch (key) { + case 27: + exit(0); + break; + default: + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); + glutInitWindowSize(400, 400); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutDisplayFunc(display); + glutReshapeFunc(reshape); + glutKeyboardFunc(keyboard); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/convolution.c b/progs/redbook/convolution.c new file mode 100644 index 00000000000..e120c586327 --- /dev/null +++ b/progs/redbook/convolution.c @@ -0,0 +1,206 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * convolution.c + * Use various 2D convolutions filters to find edges in an image. + * + */ +#include +#include +#include +#include + + +static GLuint bswap(GLuint x) +{ + const GLuint ui = 1; + const GLubyte *ubp = (const GLubyte *) &ui; + if (*ubp == 1) { + /* we're on little endiang so byteswap x */ + GLsizei y = ((x >> 24) + | ((x >> 8) & 0xff00) + | ((x << 8) & 0xff0000) + | ((x << 24) & 0xff000000)); + return y; + } + else { + return x; + } +} + + +static GLubyte * +readImage( const char* filename, GLsizei* width, GLsizei *height ) +{ + int n; + GLubyte* pixels; + + FILE* infile = fopen( filename, "rb" ); + + if ( !infile ) { + fprintf( stderr, "Unable to open file '%s'\n", filename ); + exit(1); + } + + fread( width, sizeof( GLsizei ), 1, infile ); + fread( height, sizeof( GLsizei ), 1, infile ); + + *width = bswap(*width); + *height = bswap(*height); + + assert(*width > 0); + assert(*height > 0); + + n = 3 * (*width) * (*height); + + pixels = (GLubyte *) malloc( n * sizeof( GLubyte )); + if ( !pixels ) { + fprintf( stderr, "Unable to malloc() bytes for pixels\n" ); + return NULL; + } + + fread( pixels, sizeof( GLubyte ), n, infile ); + + fclose( infile ); + + return pixels; +} + + +GLubyte *pixels; +GLsizei width, height; + +GLfloat horizontal[3][3] = { + { 0, -1, 0 }, + { 0, 1, 0 }, + { 0, 0, 0 } +}; + +GLfloat vertical[3][3] = { + { 0, 0, 0 }, + { -1, 1, 0 }, + { 0, 0, 0 } +}; + +GLfloat laplacian[3][3] = { + { -0.125, -0.125, -0.125 }, + { -0.125, 1.0 , -0.125 }, + { -0.125, -0.125, -0.125 }, +}; + + +static void init(void) +{ + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glClearColor(0.0, 0.0, 0.0, 0.0); + + printf("Using the horizontal filter\n"); + glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_LUMINANCE, + 3, 3, GL_LUMINANCE, GL_FLOAT, horizontal); + glEnable(GL_CONVOLUTION_2D); +} + +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT); + glRasterPos2i( 1, 1); + glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, w, 0, h, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 'h' : + printf("Using a horizontal filter\n"); + glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_LUMINANCE, 3, 3, + GL_LUMINANCE, GL_FLOAT, horizontal); + break; + + case 'v' : + printf("Using the vertical filter\n"); + glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_LUMINANCE, 3, 3, + GL_LUMINANCE, GL_FLOAT, vertical); + break; + + case 'l' : + printf("Using the laplacian filter\n"); + glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_LUMINANCE, 3, 3, + GL_LUMINANCE, GL_FLOAT, laplacian); + break; + + case 27: + exit(0); + } + glutPostRedisplay(); +} + +/* Main Loop + * Open window with initial window size, title bar, + * RGBA display mode, and handle input events. + */ +int main(int argc, char** argv) +{ + pixels = readImage("leeds.bin", &width, &height); + + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); + glutInitWindowSize(width, height); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutKeyboardFunc(keyboard); + glutDisplayFunc(display); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/cubemap.c b/progs/redbook/cubemap.c new file mode 100644 index 00000000000..92026c70897 --- /dev/null +++ b/progs/redbook/cubemap.c @@ -0,0 +1,205 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* cubemap.c + * + * This program demonstrates cube map textures. + * Six different colored checker board textures are + * created and applied to a lit sphere. + * + * Pressing the 'f' and 'b' keys translate the viewer + * forward and backward. + */ + +#include +#include +#include + +#define imageSize 4 +static GLubyte image1[imageSize][imageSize][4]; +static GLubyte image2[imageSize][imageSize][4]; +static GLubyte image3[imageSize][imageSize][4]; +static GLubyte image4[imageSize][imageSize][4]; +static GLubyte image5[imageSize][imageSize][4]; +static GLubyte image6[imageSize][imageSize][4]; + +static GLdouble ztrans = 0.0; + +static void makeImages(void) +{ + int i, j, c; + + for (i = 0; i < imageSize; i++) { + for (j = 0; j < imageSize; j++) { + c = ( ((i & 0x1) == 0) ^ ((j & 0x1) == 0) ) * 255; + image1[i][j][0] = (GLubyte) c; + image1[i][j][1] = (GLubyte) c; + image1[i][j][2] = (GLubyte) c; + image1[i][j][3] = (GLubyte) 255; + + image2[i][j][0] = (GLubyte) c; + image2[i][j][1] = (GLubyte) c; + image2[i][j][2] = (GLubyte) 0; + image2[i][j][3] = (GLubyte) 255; + + image3[i][j][0] = (GLubyte) c; + image3[i][j][1] = (GLubyte) 0; + image3[i][j][2] = (GLubyte) c; + image3[i][j][3] = (GLubyte) 255; + + image4[i][j][0] = (GLubyte) 0; + image4[i][j][1] = (GLubyte) c; + image4[i][j][2] = (GLubyte) c; + image4[i][j][3] = (GLubyte) 255; + + image5[i][j][0] = (GLubyte) 255; + image5[i][j][1] = (GLubyte) c; + image5[i][j][2] = (GLubyte) c; + image5[i][j][3] = (GLubyte) 255; + + image6[i][j][0] = (GLubyte) c; + image6[i][j][1] = (GLubyte) c; + image6[i][j][2] = (GLubyte) 255; + image6[i][j][3] = (GLubyte) 255; + } + } +} + +static void init(void) +{ + GLfloat diffuse[4] = {1.0, 1.0, 1.0, 1.0}; + + glClearColor (0.0, 0.0, 0.0, 0.0); + glEnable(GL_DEPTH_TEST); + glShadeModel(GL_SMOOTH); + + makeImages(); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_WRAP_R, GL_REPEAT); + glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image1); + glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image4); + glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image2); + glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image5); + glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image3); + glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT, 0, GL_RGBA, imageSize, + imageSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, image6); + glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT); + glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT); + glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_EXT); + glEnable(GL_TEXTURE_GEN_S); + glEnable(GL_TEXTURE_GEN_T); + glEnable(GL_TEXTURE_GEN_R); + + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + glEnable(GL_TEXTURE_CUBE_MAP_EXT); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_AUTO_NORMAL); + glEnable(GL_NORMALIZE); + glMaterialfv (GL_FRONT, GL_DIFFUSE, diffuse); +} + +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glPushMatrix (); + glTranslatef (0.0, 0.0, ztrans); + glutSolidSphere (5.0, 20, 10); + glPopMatrix (); + glutSwapBuffers(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(40.0, (GLfloat) w/(GLfloat) h, 1.0, 300.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -20.0); +} + +static void keyboard (unsigned char key, int x, int y) +{ + switch (key) { + case 'f': + ztrans = ztrans - 0.2; + glutPostRedisplay(); + break; + case 'b': + ztrans = ztrans + 0.2; + glutPostRedisplay(); + break; + case 27: + exit(0); + break; + default: + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); + glutInitWindowSize(400, 400); + glutInitWindowPosition(100, 100); + glutCreateWindow (argv[0]); + init (); + glutDisplayFunc(display); + glutReshapeFunc(reshape); + glutKeyboardFunc(keyboard); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/fogcoord.c b/progs/redbook/fogcoord.c new file mode 100644 index 00000000000..39e4689948d --- /dev/null +++ b/progs/redbook/fogcoord.c @@ -0,0 +1,194 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * fogcoord.c + * + * This program demonstrates the use of explicit fog + * coordinates. You can press the keyboard and change + * the fog coordinate value at any vertex. You can + * also switch between using explicit fog coordinates + * and the default fog generation mode. + * + * Pressing the 'f' and 'b' keys move the viewer forward + * and backwards. + * Pressing 'c' initiates the default fog generation. + * Pressing capital 'C' restores explicit fog coordinates. + * Pressing '1', '2', '3', '8', '9', and '0' add or + * subtract from the fog coordinate values at one of the + * three vertices of the triangle. + */ + +#define GL_GLEXT_PROTOTYPES + +#include +#include +#include +#include + +static GLfloat f1, f2, f3; + +/* Initialize fog + */ +static void init(void) +{ + GLfloat fogColor[4] = {0.0, 0.25, 0.25, 1.0}; + f1 = 1.0f; + f2 = 5.0f; + f3 = 10.0f; + + glEnable(GL_FOG); + glFogi (GL_FOG_MODE, GL_EXP); + glFogfv (GL_FOG_COLOR, fogColor); + glFogf (GL_FOG_DENSITY, 0.25); + glHint (GL_FOG_HINT, GL_DONT_CARE); + glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT); + glClearColor(0.0, 0.25, 0.25, 1.0); /* fog color */ +} + +/* display() draws a triangle at an angle. + */ +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT); + + glColor3f (1.0f, 0.75f, 0.0f); + glBegin (GL_TRIANGLES); + glFogCoordfEXT (f1); + glVertex3f (2.0f, -2.0f, 0.0f); + glFogCoordfEXT (f2); + glVertex3f (-2.0f, 0.0f, -5.0f); + glFogCoordfEXT (f3); + glVertex3f (0.0f, 2.0f, -10.0f); + glEnd(); + + glutSwapBuffers(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective (45.0, 1.0, 0.25, 25.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity (); + glTranslatef (0.0, 0.0, -5.0); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 'c': + glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT); + glutPostRedisplay(); + break; + case 'C': + glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT); + glutPostRedisplay(); + break; + case '1': + f1 = f1 + 0.25; + glutPostRedisplay(); + break; + case '2': + f2 = f2 + 0.25; + glutPostRedisplay(); + break; + case '3': + f3 = f3 + 0.25; + glutPostRedisplay(); + break; + case '8': + if (f1 > 0.25) { + f1 = f1 - 0.25; + glutPostRedisplay(); + } + break; + case '9': + if (f2 > 0.25) { + f2 = f2 - 0.25; + glutPostRedisplay(); + } + break; + case '0': + if (f3 > 0.25) { + f3 = f3 - 0.25; + glutPostRedisplay(); + } + break; + case 'b': + glMatrixMode (GL_MODELVIEW); + glTranslatef (0.0, 0.0, -0.25); + glutPostRedisplay(); + break; + case 'f': + glMatrixMode (GL_MODELVIEW); + glTranslatef (0.0, 0.0, 0.25); + glutPostRedisplay(); + break; + case 27: + exit(0); + break; + default: + break; + } +} + + +/* Main Loop + * Open window with initial window size, title bar, + * RGBA display mode, depth buffer, and handle input events. + */ +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); + glutInitWindowSize(500, 500); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc (reshape); + glutKeyboardFunc (keyboard); + glutDisplayFunc (display); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/histogram.c b/progs/redbook/histogram.c new file mode 100644 index 00000000000..7ddceb69e2e --- /dev/null +++ b/progs/redbook/histogram.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * histogram.c + * Compute the histogram of the image. This program illustrates the + * use of the glHistogram() function. + */ + +#include +#include +#include +#include + +#define HISTOGRAM_SIZE 256 /* Must be a power of 2 */ + + +static GLubyte *pixels; +static GLsizei width, height; + + + +static GLuint bswap(GLuint x) +{ + const GLuint ui = 1; + const GLubyte *ubp = (const GLubyte *) &ui; + if (*ubp == 1) { + /* we're on little endiang so byteswap x */ + GLsizei y = ((x >> 24) + | ((x >> 8) & 0xff00) + | ((x << 8) & 0xff0000) + | ((x << 24) & 0xff000000)); + return y; + } + else { + return x; + } +} + + +static GLubyte* +readImage( const char* filename, GLsizei* width, GLsizei *height ) +{ + int n; + GLubyte* pixels; + + FILE* infile = fopen( filename, "rb" ); + + if ( !infile ) { + fprintf( stderr, "Unable to open file '%s'\n", filename ); + exit(1); + } + + fread( width, sizeof( GLsizei ), 1, infile ); + fread( height, sizeof( GLsizei ), 1, infile ); + + *width = bswap(*width); + *height = bswap(*height); + + n = 3 * (*width) * (*height); + + pixels = (GLubyte *) malloc( n * sizeof( GLubyte )); + if ( !pixels ) { + fprintf( stderr, "Unable to malloc() bytes for pixels\n" ); + return NULL; + } + + fread( pixels, sizeof( GLubyte ), n, infile ); + + fclose( infile ); + + return pixels; +} + +static void init(void) +{ + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glClearColor(0.0, 0.0, 0.0, 0.0); + + glHistogram(GL_HISTOGRAM, HISTOGRAM_SIZE, GL_RGB, GL_FALSE); + glEnable(GL_HISTOGRAM); +} + +static void display(void) +{ + int i; + GLushort values[HISTOGRAM_SIZE][3]; + + glClear(GL_COLOR_BUFFER_BIT); + glRasterPos2i(1, 1); + glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); + + glGetHistogram(GL_HISTOGRAM, GL_TRUE, GL_RGB, GL_UNSIGNED_SHORT, values); + + /* Plot histogram */ + + glBegin(GL_LINE_STRIP); + glColor3f(1.0, 0.0, 0.0); + for ( i = 0; i < HISTOGRAM_SIZE; i++ ) + glVertex2s(i, values[i][0]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glColor3f(0.0, 1.0, 0.0); + for ( i = 0; i < HISTOGRAM_SIZE; i++ ) + glVertex2s(i, values[i][1]); + glEnd(); + + glBegin(GL_LINE_STRIP); + glColor3f(0.0, 0.0, 1.0); + for ( i = 0; i < HISTOGRAM_SIZE; i++ ) + glVertex2s(i, values[i][2]); + glEnd(); + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, 256, 0, 10000, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); +} + +static void keyboard(unsigned char key, int x, int y) +{ + static GLboolean sink = GL_FALSE; + + switch (key) { + case 's' : + sink = !sink; + glHistogram(GL_HISTOGRAM, HISTOGRAM_SIZE, GL_RGB, sink); + break; + + case 27: + exit(0); + } + glutPostRedisplay(); + +} + +/* Main Loop + * Open window with initial window size, title bar, + * RGBA display mode, and handle input events. + */ +int main(int argc, char** argv) +{ + pixels = readImage("leeds.bin", &width, &height); + + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); + glutInitWindowSize(width, height); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutKeyboardFunc(keyboard); + glutDisplayFunc(display); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/minmax.c b/progs/redbook/minmax.c new file mode 100644 index 00000000000..6ff97e9121c --- /dev/null +++ b/progs/redbook/minmax.c @@ -0,0 +1,169 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * minmax.c + * Determine the minimum and maximum values of a group of pixels. + * This demonstrates use of the glMinmax() call. + */ +#include +#include +#include + + +static GLubyte *pixels; +static GLsizei width, height; + + +static GLuint bswap(GLuint x) +{ + const GLuint ui = 1; + const GLubyte *ubp = (const GLubyte *) &ui; + if (*ubp == 1) { + /* we're on little endiang so byteswap x */ + GLsizei y = ((x >> 24) + | ((x >> 8) & 0xff00) + | ((x << 8) & 0xff0000) + | ((x << 24) & 0xff000000)); + return y; + } + else { + return x; + } +} + + +static GLubyte * +readImage( const char* filename, GLsizei* width, GLsizei *height ) +{ + int n; + GLubyte* pixels; + + FILE* infile = fopen( filename, "rb" ); + + if ( !infile ) { + fprintf( stderr, "Unable to open file '%s'\n", filename ); + return NULL; + } + + fread( width, sizeof( GLsizei ), 1, infile ); + fread( height, sizeof( GLsizei ), 1, infile ); + + *width = bswap(*width); + *height = bswap(*height); + + n = 3 * (*width) * (*height); + + pixels = (GLubyte *) malloc( n * sizeof( GLubyte )); + if ( !pixels ) { + fprintf( stderr, "Unable to malloc() bytes for pixels\n" ); + return NULL; + } + + fread( pixels, sizeof( GLubyte ), n, infile ); + + fclose( infile ); + + return pixels; +} + +static void init(void) +{ + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glClearColor(0.0, 0.0, 0.0, 0.0); + + glMinmax(GL_MINMAX, GL_RGB, GL_FALSE); + glEnable(GL_MINMAX); +} + +static void display(void) +{ + GLubyte values[6]; + + glClear(GL_COLOR_BUFFER_BIT); + glRasterPos2i(1, 1); + glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); + glFlush(); + + glGetMinmax(GL_MINMAX, GL_TRUE, GL_RGB, GL_UNSIGNED_BYTE, values); + printf(" Red : min = %d max = %d\n", values[0], values[3]); + printf(" Green : min = %d max = %d\n", values[1], values[4]); + printf(" Blue : min = %d max = %d\n", values[2], values[5]); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0, w, 0, h, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 27: + exit(0); + } +} + +/* Main Loop + * Open window with initial window size, title bar, + * RGBA display mode, and handle input events. + */ +int main(int argc, char** argv) +{ + pixels = readImage("leeds.bin", &width, &height); + + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); + glutInitWindowSize(width, height); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutKeyboardFunc(keyboard); + glutDisplayFunc(display); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/multisamp.c b/progs/redbook/multisamp.c new file mode 100644 index 00000000000..38bd572fc13 --- /dev/null +++ b/progs/redbook/multisamp.c @@ -0,0 +1,188 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * multisamp.c + * This program draws shows how to use multisampling to + * draw anti-aliased geometric primitives. The same + * display list, a pinwheel of triangles and lines of + * varying widths, is rendered twice. Multisampling is + * enabled when the left side is drawn. Multisampling is + * disabled when the right side is drawn. + * + * Pressing the 'b' key toggles drawing of the checkerboard + * background. Antialiasing is sometimes easier to see + * when objects are rendered over a contrasting background. + */ +#include +#include +#include + +static int bgtoggle = 1; + +/* + * Print out state values related to multisampling. + * Create display list with "pinwheel" of lines and + * triangles. + */ +static void init(void) +{ + static GLint buf[1], sbuf[1]; + int i, j; + + glClearColor(0.0, 0.0, 0.0, 0.0); + glGetIntegerv (GL_SAMPLE_BUFFERS_ARB, buf); + printf ("number of sample buffers is %d\n", buf[0]); + glGetIntegerv (GL_SAMPLES_ARB, sbuf); + printf ("number of samples is %d\n", sbuf[0]); + + glNewList (1, GL_COMPILE); + for (i = 0; i < 19; i++) { + glPushMatrix(); + glRotatef(360.0*(float)i/19.0, 0.0, 0.0, 1.0); + glColor3f (1.0, 1.0, 1.0); + glLineWidth((i%3)+1.0); + glBegin (GL_LINES); + glVertex2f (0.25, 0.05); + glVertex2f (0.9, 0.2); + glEnd (); + glColor3f (0.0, 1.0, 1.0); + glBegin (GL_TRIANGLES); + glVertex2f (0.25, 0.0); + glVertex2f (0.9, 0.0); + glVertex2f (0.875, 0.10); + glEnd (); + glPopMatrix(); + } + glEndList (); + + glNewList (2, GL_COMPILE); + glColor3f (1.0, 0.5, 0.0); + glBegin (GL_QUADS); + for (i = 0; i < 16; i++) { + for (j = 0; j < 16; j++) { + if (((i + j) % 2) == 0) { + glVertex2f (-2.0 + (i * 0.25), -2.0 + (j * 0.25)); + glVertex2f (-2.0 + (i * 0.25), -1.75 + (j * 0.25)); + glVertex2f (-1.75 + (i * 0.25), -1.75 + (j * 0.25)); + glVertex2f (-1.75 + (i * 0.25), -2.0 + (j * 0.25)); + } + } + } + glEnd (); + glEndList (); +} + +/* Draw two sets of primitives, so that you can + * compare the user of multisampling against its absence. + * + * This code enables antialiasing and draws one display list + * and disables and draws the other display list + */ +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT); + + if (bgtoggle) + glCallList (2); + + glEnable (GL_MULTISAMPLE_ARB); + glPushMatrix(); + glTranslatef (-1.0, 0.0, 0.0); + glCallList (1); + glPopMatrix(); + + glDisable (GL_MULTISAMPLE_ARB); + glPushMatrix(); + glTranslatef (1.0, 0.0, 0.0); + glCallList (1); + glPopMatrix(); + glutSwapBuffers(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, w, h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + if (w <= (2 * h)) + gluOrtho2D (-2.0, 2.0, + -2.0*(GLfloat)h/(GLfloat)w, 2.0*(GLfloat)h/(GLfloat)w); + else + gluOrtho2D (-2.0*(GLfloat)w/(GLfloat)h, + 2.0*(GLfloat)w/(GLfloat)h, -2.0, 2.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 'b': + case 'B': + bgtoggle = !bgtoggle; + glutPostRedisplay(); + break; + case 27: /* Escape Key */ + exit(0); + default: + break; + } +} + +/* Main Loop + * Open window with initial window size, title bar, + * RGBA display mode, and handle input events. + */ +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE); + glutInitWindowSize (600, 300); + glutCreateWindow (argv[0]); + init(); + glutReshapeFunc (reshape); + glutKeyboardFunc (keyboard); + glutDisplayFunc (display); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/multitex.c b/progs/redbook/multitex.c new file mode 100644 index 00000000000..060db3b1762 --- /dev/null +++ b/progs/redbook/multitex.c @@ -0,0 +1,175 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* multitex.c + */ +#include +#include +#include + + +static GLubyte texels0[32][32][4]; +static GLubyte texels1[16][16][4]; + +static void makeCheckImages(void) +{ + int i, j; + + for (i = 0; i < 32; i++) { + for (j = 0; j < 32; j++) { + texels0[i][j][0] = (GLubyte) (255 * i / 31); + texels0[i][j][1] = (GLubyte) (255 * j / 31); + texels0[i][j][2] = (GLubyte) (i*j)/255; + texels0[i][j][3] = (GLubyte) 255; + } + } + + for (i = 0; i < 16; i++) { + for (j = 0; j < 16; j++) { + texels1[i][j][0] = (GLubyte) 255; + texels1[i][j][1] = (GLubyte) (255 * i / 15); + texels1[i][j][2] = (GLubyte) (255 * j / 15); + texels1[i][j][3] = (GLubyte) 255; + } + } +} + +static void init(void) +{ + GLuint texNames[2]; + + glClearColor (0.0, 0.0, 0.0, 0.0); + glShadeModel(GL_FLAT); + glEnable(GL_DEPTH_TEST); + + makeCheckImages(); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(2, texNames); + glBindTexture(GL_TEXTURE_2D, texNames[0]); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, + GL_UNSIGNED_BYTE, texels0); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + glBindTexture(GL_TEXTURE_2D, texNames[1]); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, + GL_UNSIGNED_BYTE, texels1); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + /* Use the two texture objects to define two texture units + * for use in multitexturing */ + glActiveTextureARB (GL_TEXTURE0_ARB); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, texNames[0]); + glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + glMatrixMode (GL_TEXTURE); + glLoadIdentity(); + glTranslatef(0.5f, 0.5f, 0.0f); + glRotatef(45.0f, 0.0f, 0.0f, 1.0f); + glTranslatef(-0.5f, -0.5f, 0.0f); + glMatrixMode (GL_MODELVIEW); + glActiveTextureARB (GL_TEXTURE1_ARB); + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, texNames[1]); + glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); +} + +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glBegin(GL_TRIANGLES); + glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0.0, 0.0); + glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 1.0, 0.0); + glVertex2f(0.0, 0.0); + glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 0.5, 1.0); + glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 0.5, 0.0); + glVertex2f(50.0, 100.0); + glMultiTexCoord2fARB (GL_TEXTURE0_ARB, 1.0, 0.0); + glMultiTexCoord2fARB (GL_TEXTURE1_ARB, 1.0, 1.0); + glVertex2f(100.0, 0.0); + glEnd(); + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + if (w <= h) + gluOrtho2D(0.0, 100.0, 0.0, 100.0 * (GLdouble)h/(GLdouble)w); + else + gluOrtho2D(0.0, 100.0 * (GLdouble)w/(GLdouble)h, 0.0, 100.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 27: + exit(0); + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); + glutInitWindowSize(250, 250); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutDisplayFunc(display); + glutKeyboardFunc (keyboard); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/mvarray.c b/progs/redbook/mvarray.c new file mode 100644 index 00000000000..cbc3937ee94 --- /dev/null +++ b/progs/redbook/mvarray.c @@ -0,0 +1,136 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * mvarray.c + * This program demonstrates multiple vertex arrays, + * specifically the OpenGL routine glMultiDrawElements(). + */ + +#define GL_GLEXT_PROTOTYPES + +#include +#include +#include + +#ifdef GL_VERSION_1_3 + +static void setupPointer(void) +{ + static GLint vertices[] = {25, 25, + 75, 75, + 100, 125, + 150, 75, + 200, 175, + 250, 150, + 300, 125, + 100, 200, + 150, 250, + 200, 225, + 250, 300, + 300, 250}; + + glEnableClientState (GL_VERTEX_ARRAY); + glVertexPointer (2, GL_INT, 0, vertices); +} + +static void init(void) +{ + glClearColor (0.0, 0.0, 0.0, 0.0); + glShadeModel (GL_SMOOTH); + setupPointer (); +} + +static void display(void) +{ + static GLubyte oneIndices[] = {0, 1, 2, 3, 4, 5, 6}; + static GLubyte twoIndices[] = {1, 7, 8, 9, 10, 11}; + static GLsizei count[] = {7, 6}; + static GLvoid * indices[2] = {oneIndices, twoIndices}; + + glClear (GL_COLOR_BUFFER_BIT); + glColor3f (1.0, 1.0, 1.0); + glMultiDrawElementsEXT (GL_LINE_STRIP, count, GL_UNSIGNED_BYTE, + (const GLvoid **) indices, 2); + glFlush (); +} + +static void reshape (int w, int h) +{ + glViewport (0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode (GL_PROJECTION); + glLoadIdentity (); + gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 27: + exit(0); + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); + glutInitWindowSize (350, 350); + glutInitWindowPosition (100, 100); + glutCreateWindow (argv[0]); + init (); + glutDisplayFunc(display); + glutReshapeFunc(reshape); + glutKeyboardFunc (keyboard); + glutMainLoop(); + return 0; +} +#else +int main(int argc, char** argv) +{ + fprintf (stderr, "This program demonstrates a feature which is not in OpenGL Version 1.0.\n"); + fprintf (stderr, "If your implementation of OpenGL Version 1.0 has the right extensions,\n"); + fprintf (stderr, "you may be able to modify this program to make it run.\n"); + return 0; +} +#endif diff --git a/progs/redbook/pointp.c b/progs/redbook/pointp.c new file mode 100644 index 00000000000..ed62fa1771b --- /dev/null +++ b/progs/redbook/pointp.c @@ -0,0 +1,179 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * pointp.c + * This program demonstrates point parameters and their effect + * on point primitives. + * 250 points are randomly generated within a 10 by 10 by 40 + * region, centered at the origin. In some modes (including the + * default), points that are closer to the viewer will appear larger. + * + * Pressing the 'l', 'q', and 'c' keys switch the point + * parameters attenuation mode to linear, quadratic, or constant, + * respectively. + * Pressing the 'f' and 'b' keys move the viewer forward + * and backwards. In either linear or quadratic attenuation + * mode, the distance from the viewer to the point will change + * the size of the point primitive. + * Pressing the '+' and '-' keys will change the current point + * size. In this program, the point size is bounded, so it + * will not get less than 2.0, nor greater than GL_POINT_SIZE_MAX. + */ + +#define GL_GLEXT_PROTOTYPES + +#include +#include +#include + +static GLfloat psize = 7.0; +static GLfloat pmax[1]; +static GLfloat constant[3] = {1.0, 0.0, 0.0}; +static GLfloat linear[3] = {0.0, 0.12, 0.0}; +static GLfloat quadratic[3] = {0.0, 0.0, 0.01}; + +static void init(void) +{ + int i; + + srand (12345); + + glNewList(1, GL_COMPILE); + glBegin (GL_POINTS); + for (i = 0; i < 250; i++) { + glColor3f (1.0, ((rand()/(float) RAND_MAX) * 0.5) + 0.5, + rand()/(float) RAND_MAX); +/* randomly generated vertices: + -5 < x < 5; -5 < y < 5; -5 < z < -45 */ + glVertex3f ( ((rand()/(float)RAND_MAX) * 10.0) - 5.0, + ((rand()/(float)RAND_MAX) * 10.0) - 5.0, + ((rand()/(float)RAND_MAX) * 40.0) - 45.0); + } + glEnd(); + glEndList(); + + glEnable(GL_DEPTH_TEST); + glEnable(GL_POINT_SMOOTH); + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glPointSize(psize); + glGetFloatv(GL_POINT_SIZE_MAX_EXT, pmax); + + glPointParameterfvEXT (GL_DISTANCE_ATTENUATION_EXT, linear); + glPointParameterfEXT (GL_POINT_FADE_THRESHOLD_SIZE_EXT, 2.0); +} + +static void display(void) +{ + glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glCallList (1); + glutSwapBuffers (); +} + +static void reshape (int w, int h) +{ + glViewport (0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode (GL_PROJECTION); + glLoadIdentity (); + gluPerspective (35.0, 1.0, 0.25, 200.0); + glMatrixMode (GL_MODELVIEW); + glTranslatef (0.0, 0.0, -10.0); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 'b': + glMatrixMode (GL_MODELVIEW); + glTranslatef (0.0, 0.0, -0.5); + glutPostRedisplay(); + break; + case 'c': + glPointParameterfvEXT (GL_DISTANCE_ATTENUATION_EXT, constant); + glutPostRedisplay(); + break; + case 'f': + glMatrixMode (GL_MODELVIEW); + glTranslatef (0.0, 0.0, 0.5); + glutPostRedisplay(); + break; + case 'l': + glPointParameterfvEXT (GL_DISTANCE_ATTENUATION_EXT, linear); + glutPostRedisplay(); + break; + case 'q': + glPointParameterfvEXT (GL_DISTANCE_ATTENUATION_EXT, quadratic); + glutPostRedisplay(); + break; + case '+': + if (psize < (pmax[0] + 1.0)) + psize = psize + 1.0; + glPointSize (psize); + glutPostRedisplay(); + break; + case '-': + if (psize >= 2.0) + psize = psize - 1.0; + glPointSize (psize); + glutPostRedisplay(); + break; + case 27: + exit(0); + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE); + glutInitWindowSize (500, 500); + glutInitWindowPosition (100, 100); + glutCreateWindow (argv[0]); + init (); + glutDisplayFunc (display); + glutReshapeFunc (reshape); + glutKeyboardFunc (keyboard); + glutMainLoop(); + return 0; +} diff --git a/progs/redbook/shadowmap.c b/progs/redbook/shadowmap.c new file mode 100644 index 00000000000..3fe1d1e8df2 --- /dev/null +++ b/progs/redbook/shadowmap.c @@ -0,0 +1,352 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +#define GL_GLEXT_PROTOTYPES + +#include +#include +#include +#include +/*#include "helpers.h"*/ + +#define SHADOW_MAP_WIDTH 256 +#define SHADOW_MAP_HEIGHT 256 + +#define PI 3.14159265359 + +GLdouble fovy = 60.0; +GLdouble nearPlane = 10.0; +GLdouble farPlane = 100.0; + +GLfloat angle = 0.0; +GLfloat torusAngle = 0.0; + +GLfloat lightPos[] = { 25.0, 25.0, 25.0, 1.0 }; +GLfloat lookat[] = { 0.0, 0.0, 0.0 }; +GLfloat up[] = { 0.0, 0.0, 1.0 }; + +GLboolean showShadow = GL_FALSE; + +static void +init( void ) +{ + GLfloat white[] = { 1.0, 1.0, 1.0, 1.0 }; + + glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, + SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT, 0, + GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL ); + + glLightfv( GL_LIGHT0, GL_POSITION, lightPos ); + glLightfv( GL_LIGHT0, GL_SPECULAR, white ); + glLightfv( GL_LIGHT0, GL_DIFFUSE, white ); + + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL ); + glTexParameteri( GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, + GL_COMPARE_R_TO_TEXTURE ); + + glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + glTexGeni( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR ); + + glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE ); + + glCullFace( GL_BACK ); + + glEnable( GL_DEPTH_TEST ); + glEnable( GL_LIGHT0 ); + glEnable( GL_LIGHTING ); + glEnable( GL_TEXTURE_2D ); + glEnable( GL_TEXTURE_GEN_S ); + glEnable( GL_TEXTURE_GEN_T ); + glEnable( GL_TEXTURE_GEN_R ); + glEnable( GL_TEXTURE_GEN_Q ); + glEnable( GL_COLOR_MATERIAL ); + glEnable( GL_CULL_FACE ); +} + +static void +reshape( int width, int height ) +{ + glViewport( 0, 0, width, height ); + + glMatrixMode( GL_PROJECTION ); + glLoadIdentity(); + gluPerspective( fovy, (GLdouble) width/height, nearPlane, farPlane ); + glMatrixMode( GL_MODELVIEW ); +} + +static void +idle( void ) +{ + angle += PI / 10000; + torusAngle += .1; + glutPostRedisplay(); +} + +static void +keyboard( unsigned char key, int x, int y ) +{ + switch( key ) { + case 27: /* Escape */ + exit( 0 ); + break; + + case 't': { + static GLboolean textureOn = GL_TRUE; + textureOn = !textureOn; + if ( textureOn ) + glEnable( GL_TEXTURE_2D ); + else + glDisable( GL_TEXTURE_2D ); + } + break; + + case 'm': { + static GLboolean compareMode = GL_TRUE; + compareMode = !compareMode; + printf( "Compare mode %s\n", compareMode ? "On" : "Off" ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, + compareMode ? GL_COMPARE_R_TO_TEXTURE : GL_NONE ); + } + break; + + case 'f': { + static GLboolean funcMode = GL_TRUE; + funcMode = !funcMode; + printf( "Operator %s\n", funcMode ? "GL_LEQUAL" : "GL_GEQUAL" ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, + funcMode ? GL_LEQUAL : GL_GEQUAL ); + } + break; + + case 's': + showShadow = !showShadow; + break; + + case 'p': { + static GLboolean animate = GL_TRUE; + animate = !animate; + glutIdleFunc( animate ? idle : NULL ); + } + break; + } + + glutPostRedisplay(); +} + +static void +transposeMatrix( GLfloat m[16] ) +{ + GLfloat tmp; +#define Swap( a, b ) tmp = a; a = b; b = tmp + Swap( m[1], m[4] ); + Swap( m[2], m[8] ); + Swap( m[3], m[12] ); + Swap( m[6], m[9] ); + Swap( m[7], m[13] ); + Swap( m[11], m[14] ); +#undef Swap +} + +static void +drawObjects( GLboolean shadowRender ) +{ + GLboolean textureOn = glIsEnabled( GL_TEXTURE_2D ); + + if ( shadowRender ) + glDisable( GL_TEXTURE_2D ); + + if ( !shadowRender ) { + glNormal3f( 0, 0, 1 ); + glColor3f( 1, 1, 1 ); + glRectf( -20.0, -20.0, 20.0, 20.0 ); + } + + glPushMatrix(); + glTranslatef( 11, 11, 11 ); + glRotatef( 54.73, -5, 5, 0 ); + glRotatef( torusAngle, 1, 0, 0 ); + glColor3f( 1, 0, 0 ); + glutSolidTorus( 1, 4, 8, 36 ); + glPopMatrix(); + + glPushMatrix(); + glTranslatef( 2, 2, 2 ); + glColor3f( 0, 0, 1 ); + glutSolidCube( 4 ); + glPopMatrix(); + + glPushMatrix(); + glTranslatef( lightPos[0], lightPos[1], lightPos[2] ); + glColor3f( 1, 1, 1 ); + glutWireSphere( 0.5, 6, 6 ); + glPopMatrix(); + + if ( shadowRender && textureOn ) + glEnable( GL_TEXTURE_2D ); +} + +static void +generateShadowMap( void ) +{ + GLint viewport[4]; + GLfloat lightPos[4]; + + glGetLightfv( GL_LIGHT0, GL_POSITION, lightPos ); + glGetIntegerv( GL_VIEWPORT, viewport ); + + glViewport( 0, 0, SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT ); + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glMatrixMode( GL_PROJECTION ); + glPushMatrix(); + glLoadIdentity(); + gluPerspective( 80.0, 1.0, 10.0, 1000.0 ); + glMatrixMode( GL_MODELVIEW ); + + glPushMatrix(); + glLoadIdentity(); + gluLookAt( lightPos[0], lightPos[1], lightPos[2], + lookat[0], lookat[1], lookat[2], + up[0], up[1], up[2] ); + + drawObjects( GL_TRUE ); + + glPopMatrix(); + glMatrixMode( GL_PROJECTION ); + glPopMatrix(); + glMatrixMode( GL_MODELVIEW ); + + glCopyTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, + SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT, 0 ); + + glViewport( viewport[0], viewport[1], viewport[2], viewport[3] ); + + if ( showShadow ) { + GLfloat depthImage[SHADOW_MAP_WIDTH][SHADOW_MAP_HEIGHT]; + glReadPixels( 0, 0, SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT, + GL_DEPTH_COMPONENT, GL_FLOAT, depthImage ); + glWindowPos2f( viewport[2]/2, 0 ); + glDrawPixels( SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT, GL_LUMINANCE, + GL_FLOAT, depthImage ); + glutSwapBuffers(); + } +} + +static void +generateTextureMatrix( void ) +{ + GLfloat tmpMatrix[16]; + + /* + * Set up projective texture matrix. We use the GL_MODELVIEW matrix + * stack and OpenGL matrix commands to make the matrix. + */ + glPushMatrix(); + glLoadIdentity(); + glTranslatef( 0.5, 0.5, 0.0 ); + glScalef( 0.5, 0.5, 1.0 ); + gluPerspective( 60.0, 1.0, 1.0, 1000.0 ); + gluLookAt( lightPos[0], lightPos[1], lightPos[2], + lookat[0], lookat[1], lookat[2], + up[0], up[1], up[2] ); + glGetFloatv( GL_MODELVIEW_MATRIX, tmpMatrix ); + glPopMatrix(); + + transposeMatrix( tmpMatrix ); + + glTexGenfv( GL_S, GL_OBJECT_PLANE, &tmpMatrix[0] ); + glTexGenfv( GL_T, GL_OBJECT_PLANE, &tmpMatrix[4] ); + glTexGenfv( GL_R, GL_OBJECT_PLANE, &tmpMatrix[8] ); + glTexGenfv( GL_Q, GL_OBJECT_PLANE, &tmpMatrix[12] ); +} + +static void +display( void ) +{ + GLfloat radius = 30; + + generateShadowMap(); + generateTextureMatrix(); + + if ( showShadow ) + return; + + glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); + + glPushMatrix(); + gluLookAt( radius*cos(angle), radius*sin(angle), 30, + lookat[0], lookat[1], lookat[2], + up[0], up[1], up[2] ); + drawObjects( GL_FALSE ); + glPopMatrix(); + + glutSwapBuffers(); +} + +int +main( int argc, char** argv ) +{ + glutInit( &argc, argv ); + glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE ); + glutInitWindowSize( 512, 512 ); + glutInitWindowPosition( 100, 100 ); + glutCreateWindow( argv[0] ); + + init(); + + glutDisplayFunc( display ); + glutReshapeFunc( reshape ); + glutKeyboardFunc( keyboard ); + glutIdleFunc( idle ); + + glutMainLoop(); + + return 0; +} diff --git a/progs/redbook/surfpoints.c b/progs/redbook/surfpoints.c new file mode 100644 index 00000000000..094f0dada80 --- /dev/null +++ b/progs/redbook/surfpoints.c @@ -0,0 +1,280 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* + * surfpoints.c + * This program is a modification of the earlier surface.c + * program. The vertex data are not directly rendered, + * but are instead passed to the callback function. + * The values of the tessellated vertices are printed + * out there. + * + * This program draws a NURBS surface in the shape of a + * symmetrical hill. The 'c' keyboard key allows you to + * toggle the visibility of the control points themselves. + * Note that some of the control points are hidden by the + * surface itself. + */ +#include +#include +#include + +#ifdef GLU_VERSION_1_3 + +#ifndef CALLBACK +#define CALLBACK +#endif + +GLfloat ctlpoints[4][4][3]; +int showPoints = 0; + +GLUnurbsObj *theNurb; + +/* + * Initializes the control points of the surface to a small hill. + * The control points range from -3 to +3 in x, y, and z + */ +static void init_surface(void) +{ + int u, v; + for (u = 0; u < 4; u++) { + for (v = 0; v < 4; v++) { + ctlpoints[u][v][0] = 2.0*((GLfloat)u - 1.5); + ctlpoints[u][v][1] = 2.0*((GLfloat)v - 1.5); + + if ( (u == 1 || u == 2) && (v == 1 || v == 2)) + ctlpoints[u][v][2] = 3.0; + else + ctlpoints[u][v][2] = -3.0; + } + } +} + +static void CALLBACK nurbsError(GLenum errorCode) +{ + const GLubyte *estring; + + estring = gluErrorString(errorCode); + fprintf (stderr, "Nurbs Error: %s\n", estring); + exit (0); +} + +static void CALLBACK beginCallback(GLenum whichType) +{ + glBegin (whichType); /* resubmit rendering directive */ + printf ("glBegin("); + switch (whichType) { /* print diagnostic message */ + case GL_LINES: + printf ("GL_LINES)\n"); + break; + case GL_LINE_LOOP: + printf ("GL_LINE_LOOP)\n"); + break; + case GL_LINE_STRIP: + printf ("GL_LINE_STRIP)\n"); + break; + case GL_TRIANGLES: + printf ("GL_TRIANGLES)\n"); + break; + case GL_TRIANGLE_STRIP: + printf ("GL_TRIANGLE_STRIP)\n"); + break; + case GL_TRIANGLE_FAN: + printf ("GL_TRIANGLE_FAN)\n"); + break; + case GL_QUADS: + printf ("GL_QUADS)\n"); + break; + case GL_QUAD_STRIP: + printf ("GL_QUAD_STRIP)\n"); + break; + case GL_POLYGON: + printf ("GL_POLYGON)\n"); + break; + default: + break; + } +} + +static void CALLBACK endCallback() +{ + glEnd(); /* resubmit rendering directive */ + printf ("glEnd()\n"); +} + +static void CALLBACK vertexCallback(GLfloat *vertex) +{ + glVertex3fv(vertex); /* resubmit rendering directive */ + printf ("glVertex3f (%5.3f, %5.3f, %5.3f)\n", + vertex[0], vertex[1], vertex[2]); +} + +static void CALLBACK normalCallback(GLfloat *normal) +{ + glNormal3fv(normal); /* resubmit rendering directive */ + printf ("glNormal3f (%5.3f, %5.3f, %5.3f)\n", + normal[0], normal[1], normal[2]); +} + +/* Initialize material property and depth buffer. + */ +static void init(void) +{ + GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 }; + GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; + GLfloat mat_shininess[] = { 100.0 }; + + glClearColor (0.0, 0.0, 0.0, 0.0); + glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse); + glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); + glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess); + + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + glEnable(GL_DEPTH_TEST); + glEnable(GL_AUTO_NORMAL); + glEnable(GL_NORMALIZE); + + init_surface(); + + theNurb = gluNewNurbsRenderer(); + gluNurbsProperty(theNurb, GLU_NURBS_MODE, + GLU_NURBS_TESSELLATOR); + gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0); + gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL); + gluNurbsCallback(theNurb, GLU_ERROR, nurbsError); + gluNurbsCallback(theNurb, GLU_NURBS_BEGIN, beginCallback); + gluNurbsCallback(theNurb, GLU_NURBS_VERTEX, vertexCallback); + gluNurbsCallback(theNurb, GLU_NURBS_NORMAL, normalCallback); + gluNurbsCallback(theNurb, GLU_NURBS_END, endCallback); + +} + +static void display(void) +{ + GLfloat knots[8] = {0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0}; + int i, j; + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glPushMatrix(); + glRotatef(330.0, 1.,0.,0.); + glScalef (0.5, 0.5, 0.5); + + gluBeginSurface(theNurb); + gluNurbsSurface(theNurb, + 8, knots, 8, knots, + 4 * 3, 3, &ctlpoints[0][0][0], + 4, 4, GL_MAP2_VERTEX_3); + gluEndSurface(theNurb); + + if (showPoints) { + glPointSize(5.0); + glDisable(GL_LIGHTING); + glColor3f(1.0, 1.0, 0.0); + glBegin(GL_POINTS); + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + glVertex3f(ctlpoints[i][j][0], + ctlpoints[i][j][1], ctlpoints[i][j][2]); + } + } + glEnd(); + glEnable(GL_LIGHTING); + } + glPopMatrix(); + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective (45.0, (GLdouble)w/(GLdouble)h, 3.0, 8.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef (0.0, 0.0, -5.0); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 'c': + case 'C': + showPoints = !showPoints; + glutPostRedisplay(); + break; + case 27: + exit(0); + break; + default: + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); + glutInitWindowSize (500, 500); + glutInitWindowPosition (100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutDisplayFunc(display); + glutKeyboardFunc (keyboard); + glutMainLoop(); + return 0; +} + +#else +int main(int argc, char** argv) +{ + fprintf (stderr, "This program demonstrates a feature which is introduced in the\n"); + fprintf (stderr, "OpenGL Utility Library (GLU) Version 1.3.\n"); + fprintf (stderr, "If your implementation of GLU has the right extensions,\n"); + fprintf (stderr, "you may be able to modify this program to make it run.\n"); + return 0; +} +#endif + diff --git a/progs/redbook/texture3d.c b/progs/redbook/texture3d.c new file mode 100644 index 00000000000..9f57e08c6d9 --- /dev/null +++ b/progs/redbook/texture3d.c @@ -0,0 +1,161 @@ +/* + * Copyright (c) 1993-2003, 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. + * 1500 Crittenden Lane + * Mountain View, CA 94043 + * United State of America + * + * OpenGL(R) is a registered trademark of Silicon Graphics, Inc. + */ + +/* texture3d.c + * This program demonstrates using a three-dimensional texture. + * It creates a 3D texture and then renders two rectangles + * with different texture coordinates to obtain different + * "slices" of the 3D texture. + */ +#include +#include +#include + +#ifdef GL_VERSION_1_2 +#define iWidth 16 +#define iHeight 16 +#define iDepth 16 + +static GLubyte image[iDepth][iHeight][iWidth][3]; +static GLuint texName; + +/* Create a 16x16x16x3 array with different color values in + * each array element [r, g, b]. Values range from 0 to 255. + */ + +static void makeImage(void) +{ + int s, t, r; + + for (s = 0; s < 16; s++) + for (t = 0; t < 16; t++) + for (r = 0; r < 16; r++) { + image[r][t][s][0] = (GLubyte) (s * 17); + image[r][t][s][1] = (GLubyte) (t * 17); + image[r][t][s][2] = (GLubyte) (r * 17); + } +} + +static void init(void) +{ + glClearColor (0.0, 0.0, 0.0, 0.0); + glShadeModel(GL_FLAT); + glEnable(GL_DEPTH_TEST); + + makeImage(); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(1, &texName); + glBindTexture(GL_TEXTURE_3D, texName); + glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP); + glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP); + glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, + GL_NEAREST); + glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, + GL_NEAREST); + glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, iWidth, iHeight, + iDepth, 0, GL_RGB, GL_UNSIGNED_BYTE, image); + glEnable(GL_TEXTURE_3D); +} + +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glBegin(GL_QUADS); + glTexCoord3f(0.0, 0.0, 0.0); glVertex3f(-2.25, -1.0, 0.0); + glTexCoord3f(0.0, 1.0, 0.0); glVertex3f(-2.25, 1.0, 0.0); + glTexCoord3f(1.0, 1.0, 1.0); glVertex3f(-0.25, 1.0, 0.0); + glTexCoord3f(1.0, 0.0, 1.0); glVertex3f(-0.25, -1.0, 0.0); + + glTexCoord3f(0.0, 0.0, 1.0); glVertex3f(0.25, -1.0, 0.0); + glTexCoord3f(0.0, 1.0, 1.0); glVertex3f(0.25, 1.0, 0.0); + glTexCoord3f(1.0, 1.0, 0.0); glVertex3f(2.25, 1.0, 0.0); + glTexCoord3f(1.0, 0.0, 0.0); glVertex3f(2.25, -1.0, 0.0); + glEnd(); + glFlush(); +} + +static void reshape(int w, int h) +{ + glViewport(0, 0, (GLsizei) w, (GLsizei) h); + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + glTranslatef(0.0, 0.0, -4.0); +} + +static void keyboard(unsigned char key, int x, int y) +{ + switch (key) { + case 27: + exit(0); + break; + } +} + +int main(int argc, char** argv) +{ + glutInit(&argc, argv); + glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH); + glutInitWindowSize(250, 250); + glutInitWindowPosition(100, 100); + glutCreateWindow(argv[0]); + init(); + glutReshapeFunc(reshape); + glutDisplayFunc(display); + glutKeyboardFunc (keyboard); + glutMainLoop(); + return 0; +} +#else +int main(int argc, char** argv) +{ + fprintf (stderr, "This program demonstrates a feature which is not in OpenGL Version 1.0 or 1.1.\n"); + fprintf (stderr, "If your implementation of OpenGL has the right extensions,\n"); + fprintf (stderr, "you may be able to modify this program to make it run.\n"); + return 0; +} +#endif + -- 2.30.2