开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
envphong.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：16k
源码类别：

GIS编程

开发平台：

Visual C++

envphong.c：源码内容
  2. /* envphong.c - David G. Yu, SGI */
  4. /**
  5.  ** Demonstrates a use of environment texture mapping for improved highlight
  6.  ** shading.
  7.  **
  8.  ** Press mouse button one to move the object, press mouse button two to
  9.  ** move the light source.  Pressing the <s> key switches between using
  10.  ** regular lighting or texture mapping for the specular highlights. The
  11.  ** <o> key will cycle through objects (sphere, cylinder, torus).  Check
  12.  ** out the event loop code below for other keys which do will things.
  13.  **
  14.  ** TBD
  15.  **  - improve accuracy of the highlight texture map
  16.  **  - reduce or eliminate grazing angle artifacts
  17.  **  - improve user interaction
  18.  **
  19.  ** 1995 -- David G Yu
  20.  **
  21.  ** cc -o envphong envphong.c -lglut -lGLU -lGL -lXmu -lXext -lX11 -lm
  22.  **/
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <math.h>
  28. #include <GL/glut.h>
  30. /* Some <math.h> files do not define M_PI... */
  31. #ifndef M_PI
  32. #define M_PI 3.14159265358979323846
  33. #endif
  35. int win, win2;
  36. int needsLightUpdate = GL_TRUE;
  37. int useLighting = GL_TRUE;
  38. int useSpecularTexture = GL_FALSE;
  39. int useTexture = GL_FALSE;
  40. int useHighRes = GL_FALSE;
  41. int usePattern = GL_FALSE;
  42. int moveLight = GL_FALSE;
  43. int moveObject = GL_FALSE;
  44. int drawObj = 0, maxObj = 2;
  45. GLfloat lightRotX, lightRotY;
  46. GLfloat objectRotX, objectRotY;
  47. int curx, cury, width, height;
  49. void
  50. drawSphere(int numMajor, int numMinor, float radius)
  51. {
  52.   double majorStep = (M_PI / numMajor);
  53.   double minorStep = (2.0 * M_PI / numMinor);
  54.   int i, j;
  56.   for (i = 0; i < numMajor; ++i) {
  57.     double a = i * majorStep;
  58.     double b = a + majorStep;
  59.     double r0 = radius * sin(a);
  60.     double r1 = radius * sin(b);
  61.     GLfloat z0 = radius * cos(a);
  62.     GLfloat z1 = radius * cos(b);
  64.     glBegin(GL_TRIANGLE_STRIP);
  65.     for (j = 0; j <= numMinor; ++j) {
  66.       double c = j * minorStep;
  67.       GLfloat x = cos(c);
  68.       GLfloat y = sin(c);
  70.       glNormal3f((x * r0) / radius, (y * r0) / radius, z0 / radius);
  71.       glTexCoord2f(j / (GLfloat) numMinor, i / (GLfloat) numMajor);
  72.       glVertex3f(x * r0, y * r0, z0);
  74.       glNormal3f((x * r1) / radius, (y * r1) / radius, z1 / radius);
  75.       glTexCoord2f(j / (GLfloat) numMinor, (i + 1) / (GLfloat) numMajor);
  76.       glVertex3f(x * r1, y * r1, z1);
  77.     }
  78.     glEnd();
  79.   }
  80. }
  82. void
  83. drawCylinder(int numMajor, int numMinor, float height, float radius)
  84. {
  85.   double majorStep = height / numMajor;
  86.   double minorStep = 2.0 * M_PI / numMinor;
  87.   int i, j;
  89.   for (i = 0; i < numMajor; ++i) {
  90.     GLfloat z0 = 0.5 * height - i * majorStep;
  91.     GLfloat z1 = z0 - majorStep;
  93.     glBegin(GL_TRIANGLE_STRIP);
  94.     for (j = 0; j <= numMinor; ++j) {
  95.       double a = j * minorStep;
  96.       GLfloat x = radius * cos(a);
  97.       GLfloat y = radius * sin(a);
  99.       glNormal3f(x / radius, y / radius, 0.0);
  100.       glTexCoord2f(j / (GLfloat) numMinor, i / (GLfloat) numMajor);
  101.       glVertex3f(x, y, z0);
  103.       glNormal3f(x / radius, y / radius, 0.0);
  104.       glTexCoord2f(j / (GLfloat) numMinor, (i + 1) / (GLfloat) numMajor);
  105.       glVertex3f(x, y, z1);
  106.     }
  107.     glEnd();
  108.   }
  109. }
  111. void
  112. drawTorus(int numMajor, int numMinor, float majorRadius, float minorRadius)
  113. {
  114.   double majorStep = 2.0 * M_PI / numMajor;
  115.   double minorStep = 2.0 * M_PI / numMinor;
  116.   int i, j;
  118.   for (i = 0; i < numMajor; ++i) {
  119.     double a0 = i * majorStep;
  120.     double a1 = a0 + majorStep;
  121.     GLfloat x0 = cos(a0);
  122.     GLfloat y0 = sin(a0);
  123.     GLfloat x1 = cos(a1);
  124.     GLfloat y1 = sin(a1);
  126.     glBegin(GL_TRIANGLE_STRIP);
  127.     for (j = 0; j <= numMinor; ++j) {
  128.       double b = j * minorStep;
  129.       GLfloat c = cos(b);
  130.       GLfloat r = minorRadius * c + majorRadius;
  131.       GLfloat z = minorRadius * sin(b);
  133.       glNormal3f(x0 * c, y0 * c, z / minorRadius);
  134.       glTexCoord2f(i / (GLfloat) numMajor, j / (GLfloat) numMinor);
  135.       glVertex3f(x0 * r, y0 * r, z);
  137.       glNormal3f(x1 * c, y1 * c, z / minorRadius);
  138.       glTexCoord2f((i + 1) / (GLfloat) numMajor, j / (GLfloat) numMinor);
  139.       glVertex3f(x1 * r, y1 * r, z);
  140.     }
  141.     glEnd();
  142.   }
  143. }
  145. void
  146. setNullTexture(void)
  147. {
  148.   GLubyte texPixel[4] =
  149.   {0xff, 0xff, 0xff, 0xff};
  150.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  151.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  152.   glTexImage2D(GL_TEXTURE_2D, 0, 4, 1, 1, 0,
  153.     GL_RGBA, GL_UNSIGNED_BYTE, texPixel);
  154. }
  156. void
  157. setCheckTexture(void)
  158. {
  159.   int texWidth = 64;
  160.   int texHeight = 64;
  161.   GLubyte *texPixels, *p;
  162.   int i, j;
  164.   texPixels = (GLubyte *) malloc(texWidth * texHeight * 4 * sizeof(GLubyte));
  165.   if (texPixels == NULL) {
  166.     return;
  167.   }
  168.   p = texPixels;
  169.   for (i = 0; i < texHeight; ++i) {
  170.     for (j = 0; j < texWidth; ++j) {
  171.       if ((i ^ j) & 8) {
  172.         p[0] = 0xff;
  173.         p[1] = 0xff;
  174.         p[2] = 0xff;
  175.         p[3] = 0xff;
  176.       } else {
  177.         p[0] = 0x08;
  178.         p[1] = 0x08;
  179.         p[2] = 0x08;
  180.         p[3] = 0xff;
  181.       }
  182.       p += 4;
  183.     }
  184.   }
  186.   glTexParameteri(GL_TEXTURE_2D,
  187.     GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
  188.   glTexParameteri(GL_TEXTURE_2D,
  189.     GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  190.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  191.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  192.   gluBuild2DMipmaps(GL_TEXTURE_2D, 4, texWidth, texHeight,
  193.     GL_RGBA, GL_UNSIGNED_BYTE, texPixels);
  194.   free(texPixels);
  195. }
  197. void
  198. setLight(void)
  199. {
  200.   GLfloat light0Pos[4] =
  201.   {0.70, 0.70, 1.25, 0.00};
  202.   GLfloat light0Amb[4] =
  203.   {0.00, 0.00, 0.00, 1.00};
  204.   GLfloat light0Diff[4] =
  205.   {1.00, 1.00, 1.00, 1.00};
  206.   GLfloat light0Spec[4] =
  207.   {1.00, 1.00, 1.00, 1.00};
  208.   GLfloat light0SpotDir[3] =
  209.   {0.00, 0.00, -1.00};
  210.   GLfloat light0SpotExp = 0.00;
  211.   GLfloat light0SpotCutoff = 180.00;
  212.   GLfloat light0Atten0 = 1.00;
  213.   GLfloat light0Atten1 = 0.00;
  214.   GLfloat light0Atten2 = 0.00;
  216.   glEnable(GL_LIGHT0);
  217.   glLightfv(GL_LIGHT0, GL_POSITION, light0Pos);
  218.   glLightfv(GL_LIGHT0, GL_AMBIENT, light0Amb);
  219.   glLightfv(GL_LIGHT0, GL_DIFFUSE, light0Diff);
  220.   glLightfv(GL_LIGHT0, GL_SPECULAR, light0Spec);
  221.   glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light0SpotDir);
  222.   glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, light0SpotExp);
  223.   glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, light0SpotCutoff);
  224.   glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, light0Atten0);
  225.   glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, light0Atten1);
  226.   glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light0Atten2);
  227. }
  229. #define MAT_ALL 0
  230. #define MAT_NO_SPECULAR 1
  231. #define MAT_SPECULAR_ONLY 2
  232. #define MAT_SPECULAR_TEXTURE_ONLY 3
  233. #define MAT_GEN_SPECULAR_TEXTURE 4
  235. void
  236. setMaterial(int mode)
  237. {
  238.   static GLubyte *texPixels;
  239.   int texWidth = 128;
  240.   int texHeight = 128;
  242.   GLfloat matZero[4] =
  243.   {0.00, 0.00, 0.00, 1.00};
  244.   GLfloat matOne[4] =
  245.   {1.00, 1.00, 1.00, 1.00};
  246.   GLfloat matEm[4] =
  247.   {0.00, 0.00, 0.00, 1.00};
  248.   GLfloat matAmb[4] =
  249.   {0.01, 0.01, 0.01, 1.00};
  250.   GLfloat matDiff[4] =
  251.   {0.02, 0.20, 0.16, 1.00};
  252.   GLfloat matSpec[4] =
  253.   {0.50, 0.50, 0.50, 1.00};
  254.   GLfloat matShine = 20.00;
  256.   if ((mode == MAT_ALL) || (mode == MAT_NO_SPECULAR)) {
  257.     glMaterialfv(GL_FRONT, GL_EMISSION, matEm);
  258.     glMaterialfv(GL_FRONT, GL_AMBIENT, matAmb);
  259.     glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiff);
  260.   } else {
  261.     glMaterialfv(GL_FRONT, GL_EMISSION, matZero);
  262.     glMaterialfv(GL_FRONT, GL_AMBIENT, matZero);
  263.     glMaterialfv(GL_FRONT, GL_DIFFUSE, matZero);
  264.   }
  266.   if ((mode == MAT_ALL) || (mode == MAT_SPECULAR_ONLY)) {
  267.     glMaterialfv(GL_FRONT, GL_SPECULAR, matSpec);
  268.     glMaterialf(GL_FRONT, GL_SHININESS, matShine);
  269.   } else {
  270.     glMaterialfv(GL_FRONT, GL_SPECULAR, matZero);
  271.     glMaterialf(GL_FRONT, GL_SHININESS, 1);
  272.   }
  274.   if (mode == MAT_SPECULAR_TEXTURE_ONLY) {
  275.     if (texPixels == NULL) {
  276.       return;
  277.     }
  278.     glMaterialfv(GL_FRONT, GL_SPECULAR, matOne);
  279.     glMaterialf(GL_FRONT, GL_SHININESS, 0);
  281.     glTexParameteri(GL_TEXTURE_2D,
  282.       GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
  283.     glTexParameteri(GL_TEXTURE_2D,
  284.       GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  285.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  286.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  287.     gluBuild2DMipmaps(GL_TEXTURE_2D, 4, texWidth, texHeight,
  288.       GL_RGBA, GL_UNSIGNED_BYTE, texPixels);
  289.   }
  290.   if (mode == MAT_GEN_SPECULAR_TEXTURE) {
  291.     if (texPixels == NULL) {
  292.       texPixels = (GLubyte *)
  293.         malloc(texWidth * texHeight * 4 * sizeof(GLubyte));
  294.       if (texPixels == NULL) {
  295.         return;
  296.       }
  297.     }
  298.     glPushAttrib(GL_ALL_ATTRIB_BITS);
  300.     glClearColor(0.0, 0.0, 0.0, 1.0);
  301.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  303.     setMaterial(MAT_SPECULAR_ONLY);
  305.     glMatrixMode(GL_PROJECTION);
  306.     glPushMatrix();
  307.     glLoadIdentity();
  308.     glOrtho(-1, 1, -1, 1, 1, 3);
  309.     glMatrixMode(GL_MODELVIEW);
  310.     glPushMatrix();
  311.     glLoadIdentity();
  312.     glTranslatef(0, 0, -2);
  314.     glPushMatrix();
  315.     glRotatef(lightRotY, 0, 1, 0);
  316.     glRotatef(lightRotX, 1, 0, 0);
  317.     setLight();
  318.     glPopMatrix();
  320.     glEnable(GL_DEPTH_TEST);
  321.     glEnable(GL_LIGHTING);
  323.     glViewport(0, 0, 128, 128);
  324.     glClearColor(.25, .25, .25, .25);
  325.     glClear(GL_COLOR_BUFFER_BIT);
  326.     drawSphere(128, 128, 1.0);
  328.     glMatrixMode(GL_PROJECTION);
  329.     glPopMatrix();
  330.     glMatrixMode(GL_MODELVIEW);
  331.     glPopMatrix();
  333.     glReadPixels(0, 0, texWidth, texHeight,
  334.       GL_RGBA, GL_UNSIGNED_BYTE, texPixels);
  336.     glPopAttrib();
  337.   }
  338. }
  340. void
  341. initialize(void)
  342. {
  343.   glMatrixMode(GL_PROJECTION);
  344.   glFrustum(-0.50, 0.50, -0.50, 0.50, 1.0, 3.0);
  345.   glMatrixMode(GL_MODELVIEW);
  346.   glTranslatef(0.0, 0.0, -2.0);
  348.   glDepthFunc(GL_LEQUAL);
  350.   glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
  351. }
  353. void
  354. redraw(void)
  355. {
  356.   glClearColor(0.1, 0.1, 0.1, 1.0);
  357.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  359.   glBegin(GL_QUADS);
  360.   glColor3f(0.9, 0.0, 1.0);
  361.   glVertex3f(-2.0, -2.0, -1.0);
  362.   glColor3f(0.9, 0.0, 1.0);
  363.   glVertex3f(2.0, -2.0, -1.0);
  364.   glColor3f(0.0, 0.1, 0.1);
  365.   glVertex3f(2.0, 2.0, -1.0);
  366.   glColor3f(0.0, 0.1, 0.1);
  367.   glVertex3f(-2.0, 2.0, -1.0);
  368.   glEnd();
  370.   glEnable(GL_DEPTH_TEST);
  372.   if (useLighting) {
  373.     glEnable(GL_LIGHTING);
  374.     glPushMatrix();
  375.     glRotatef(lightRotY, 0, 1, 0);
  376.     glRotatef(lightRotX, 1, 0, 0);
  377.     setLight();
  378.     glPopMatrix();
  379.   } else {
  380.     glColor3f(0.2, 0.2, 0.2);
  381.   }
  382.   if (useTexture || useSpecularTexture) {
  383.     glEnable(GL_TEXTURE_2D);
  384.   }
  385.   if (useTexture) {
  386.     setCheckTexture();
  387.   } else {
  388.     setNullTexture();
  389.   }
  390.   if (useSpecularTexture) {
  391.     /* pass one */
  392.     glEnable(GL_BLEND);
  393.     glBlendFunc(GL_ONE, GL_ZERO);
  394.     setMaterial(MAT_NO_SPECULAR);
  395.   } else {
  396.     setMaterial(MAT_ALL);
  397.   }
  398.   glPushMatrix();
  399.   glRotatef(objectRotY, 0, 1, 0);
  400.   glRotatef(objectRotX, 1, 0, 0);
  401.   if (useHighRes) {
  402.     switch (drawObj) {
  403.     case 0:
  404.       drawSphere(64, 64, 0.8);
  405.       break;
  406.     case 1:
  407.       drawCylinder(32, 64, 1.0, 0.4);
  408.       break;
  409.     case 2:
  410.       drawTorus(64, 64, 0.6, 0.2);
  411.       break;
  412.     default:
  413.       break;
  414.     }
  415.   } else {
  416.     switch (drawObj) {
  417.     case 0:
  418.       drawSphere(16, 32, 0.8);
  419.       break;
  420.     case 1:
  421.       drawCylinder(6, 16, 1.0, 0.4);
  422.       break;
  423.     case 2:
  424.       drawTorus(32, 16, 0.6, 0.2);
  425.       break;
  426.     default:
  427.       break;
  428.     }
  429.   }
  430.   glPopMatrix();
  432.   if (useSpecularTexture) {
  433.     /* pass two */
  434.     if (!useLighting) {
  435.       glColor3f(1.0, 1.0, 1.0);
  436.     }
  437.     glBlendFunc(GL_ONE, GL_ONE);
  438.     glEnable(GL_TEXTURE_GEN_S);
  439.     glEnable(GL_TEXTURE_GEN_T);
  440.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  441.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  443.     setMaterial(MAT_SPECULAR_TEXTURE_ONLY);
  444.     glPushMatrix();
  445.     glRotatef(objectRotY, 0, 1, 0);
  446.     glRotatef(objectRotX, 1, 0, 0);
  447.     if (useHighRes) {
  448.       switch (drawObj) {
  449.       case 0:
  450.         drawSphere(64, 64, 0.8);
  451.         break;
  452.       case 1:
  453.         drawCylinder(32, 64, 1.0, 0.4);
  454.         break;
  455.       case 2:
  456.         drawTorus(64, 64, 0.6, 0.2);
  457.         break;
  458.       default:
  459.         break;
  460.       }
  461.     } else {
  462.       switch (drawObj) {
  463.       case 0:
  464.         drawSphere(16, 32, 0.8);
  465.         break;
  466.       case 1:
  467.         drawCylinder(6, 16, 1.0, 0.4);
  468.         break;
  469.       case 2:
  470.         drawTorus(32, 16, 0.6, 0.2);
  471.         break;
  472.       default:
  473.         break;
  474.       }
  475.     }
  476.     glPopMatrix();
  477.   }
  478.   glDisable(GL_DEPTH_TEST);
  479.   glDisable(GL_LIGHTING);
  480.   glDisable(GL_TEXTURE_2D);
  481.   glDisable(GL_BLEND);
  482.   glDisable(GL_TEXTURE_GEN_S);
  483.   glDisable(GL_TEXTURE_GEN_T);
  484. }
  486. void
  487. checkErrors(void)
  488. {
  489.   GLenum error;
  490.   while ((error = glGetError()) != GL_NO_ERROR) {
  491.     fprintf(stderr, "Error: %sn", (char *) gluErrorString(error));
  492.   }
  493. }
  495. void
  496. usage(char *name)
  497. {
  498.   fprintf(stderr, "n");
  499.   fprintf(stderr, "usage: %s [ options ]n", name);
  500.   fprintf(stderr, "n");
  501.   fprintf(stderr, "  Options:n");
  502.   fprintf(stderr, "    nonen");
  503.   fprintf(stderr, "n");
  504. }
  506. void 
  507. help(void)
  508. {
  509.   printf("'h'      - helpn");
  510.   printf("'l'      - toggle lightingn");
  511.   printf("'o'      - switch objectsn");
  512.   printf("'r'      - toggle resolutionn");
  513.   printf("'s'      - toggle two pass lightingn");
  514.   printf("'t'      - toggle texturingn");
  515.   printf("left mouse     - move objectn");
  516.   printf("middle mouse   - move lightn");
  517. }
  519. void
  520. motion(int x, int y)
  521. {
  522.   if (moveLight || moveObject) {
  523.     GLfloat dx = (y - cury) * 360.0 / height;
  524.     GLfloat dy = (x - curx) * 360.0 / width;
  525.     if (moveLight) {
  526.       lightRotX += dx;
  527.       if (lightRotX > 360)
  528.         lightRotX -= 360;
  529.       if (lightRotX < 0)
  530.         lightRotX += 360;
  531.       lightRotY += dy;
  532.       if (lightRotY > 360)
  533.         lightRotY -= 360;
  534.       if (lightRotY < 0)
  535.         lightRotY += 360;
  536.       needsLightUpdate = GL_TRUE;
  537.     } else if (moveObject) {
  538.       objectRotX += dx;
  539.       if (objectRotX > 360)
  540.         objectRotX -= 360;
  541.       if (objectRotX < 0)
  542.         objectRotX += 360;
  543.       objectRotY += dy;
  544.       if (objectRotY > 360)
  545.         objectRotY -= 360;
  546.       if (objectRotY < 0)
  547.         objectRotY += 360;
  548.     }
  549.     curx = x;
  550.     cury = y;
  551.   }
  552.   glutPostRedisplay();
  553. }
  555. void
  556. mouse(int button, int state, int x, int y)
  557. {
  558.   if (state == GLUT_DOWN) {
  559.     switch (button) {
  560.     case GLUT_LEFT_BUTTON:
  561.       moveObject = GL_TRUE;
  562.       motion(curx = x, cury = y);
  563.       break;
  564.     case GLUT_MIDDLE_BUTTON:
  565.       moveLight = GL_TRUE;
  566.       motion(curx = x, cury = y);
  567.       break;
  568.     }
  569.   } else if (state == GLUT_UP) {
  570.     switch (button) {
  571.     case GLUT_LEFT_BUTTON:
  572.       moveObject = GL_FALSE;
  573.       break;
  574.     case GLUT_MIDDLE_BUTTON:
  575.       moveLight = GL_FALSE;
  576.       break;
  577.     }
  578.   }
  579. }
  581. void
  582. display(void)
  583. {
  584.   if (useSpecularTexture && needsLightUpdate) {
  585.     setMaterial(MAT_GEN_SPECULAR_TEXTURE);
  586.     needsLightUpdate = GL_FALSE;
  587.   }
  588.   redraw();
  589.   glFlush();
  590.   glutSwapBuffers();
  591.   checkErrors();
  592. }
  594. void
  595. reshape(int w, int h)
  596. {
  597.   glViewport(0, 0, width = w, height = h);
  598. }
  600. /* ARGSUSED1 */
  601. void
  602. key(unsigned char key, int x, int y)
  603. {
  604.   switch (key) {
  605.   case 'h':
  606.     help();
  607.     break;
  608.   case ' ':
  609.     break;
  610.   case 'l':
  611.     useLighting = !useLighting;
  612.     break;
  613.   case 's':
  614.     useSpecularTexture = !useSpecularTexture;
  615.     needsLightUpdate = GL_TRUE;
  616.     break;
  617.   case 't':
  618.     useTexture = !useTexture;
  619.     break;
  620.   case 'r':
  621.     useHighRes = !useHighRes;
  622.     break;
  623.   case 'o':
  624.     ++drawObj;
  625.     if (drawObj > maxObj)
  626.       drawObj = 0;
  627.     break;
  628.   case '33':
  629.     exit(0);
  630.   }
  631.   glutPostRedisplay();
  632. }
  634. /* ARGSUSED1 */
  635. void
  636. domenu(int value)
  637. {
  638.   key((unsigned char) value, 0, 0);
  639. }
  641. int
  642. main(int argc, char **argv)
  643. {
  644.   int i;
  646.   glutInit(&argc, argv);
  647.   glutInitWindowSize(width = 300, height = 300);
  648.   glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
  650.   for (i = 1; i < argc; ++i) {
  651.     usage(argv[0]);
  652.     exit(1);
  653.   }
  654.   win = glutCreateWindow("envphong");
  655.   glutDisplayFunc(display);
  656.   glutKeyboardFunc(key);
  657.   glutReshapeFunc(reshape);
  658.   glutMouseFunc(mouse);
  659.   glutMotionFunc(motion);
  660.   glutCreateMenu(domenu);
  661.   glutAddMenuEntry("Toggle lighting", 'l');
  662.   glutAddMenuEntry("Toggle checker texture", 't');
  663.   glutAddMenuEntry("Toggle two-pass textured specular", 's');
  664.   glutAddMenuEntry("Toggle object resolution", 'r');
  665.   glutAddMenuEntry("Switch object", 'o');
  666.   glutAddMenuEntry("Print help", 'h');
  667.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  668.   initialize();
  669.   glutMainLoop();
  670.   return 0;             /* ANSI C requires main to return int. */
  671. }