KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

progs/redbook: add additional tests for GL 1.4

This commit is contained in:
Brian Paul 2010-02-15 09:55:01 -07:00
parent 3be1c11001
commit ce65a8debe
15 changed files with 2912 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
progs/redbook/Makefile
View File

@ -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

13
progs/redbook/SConscript
View File

@ -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',

377
progs/redbook/combiner.c Normal file
View File

@ -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 <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;
}

206
progs/redbook/convolution.c Normal file
View File

@ -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 <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;
}

205
progs/redbook/cubemap.c Normal file
View File

@ -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 <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;
}

194
progs/redbook/fogcoord.c Normal file
View File

@ -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 <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;
}

201
progs/redbook/histogram.c Normal file
View File

@ -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 <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;
}

169
progs/redbook/minmax.c Normal file
View File

@ -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 <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;
}

188
progs/redbook/multisamp.c Normal file
View File

@ -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 <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;
}

175
progs/redbook/multitex.c Normal file
View File

@ -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 <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;
}

136
progs/redbook/mvarray.c Normal file
View File

@ -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 <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

179
progs/redbook/pointp.c Normal file
View File

@ -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 <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;
}

352
progs/redbook/shadowmap.c Normal file
View File

@ -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 <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;
}

280
progs/redbook/surfpoints.c Normal file
View File

@ -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 <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

161
progs/redbook/texture3d.c Normal file
View File

@ -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 <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