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
'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',
'scene',
'sceneflat',
'select',
+ 'shadowmap',
'smooth',
'stencil',
'stroke',
'surface',
+ 'surfpoints',
'teaambient',
'teapots',
'tess',
'texprox',
'texsub',
'texturesurf',
+ 'texture3d',
'torus',
'trim',
'unproject',
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+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;
+}
--- /dev/null
+/*
+ * 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 <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/glut.h>
+/*#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;
+}
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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
+
--- /dev/null
+/*
+ * 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 <GL/glut.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#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
+
projects / mesa.git / commitdiff