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

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

GIS编程

开发平台：

Visual C++

hello2rts.c：源码内容
  2. /* Copyright (c) Mark J. Kilgard, 1997, 1998.  */
  4. /* This program is freely distributable without licensing fees and is
  5.    provided without guarantee or warrantee expressed or implied.  This
  6.    program is -not- in the public domain. */
  8. /* This code demonstrates use of the OpenGL Real-time Shadowing (RTS)
  9.    routines.  The program renders two objects with two light sources in a
  10.    scene with several other walls and curved surfaces.  Objects cast shadows
  11.    on the walls and curved surfaces as well as each other.  The shadowing
  12.    objects spin.  See the rts.c and  rtshadow.h source code for more details. */
  14. #include <stdio.h>
  15. #include <string.h>
  16. #include <math.h>
  17. #include <stdlib.h>
  18. #include <GL/glut.h>
  20. #ifdef GLU_VERSION_1_2
  22. #include "rtshadow.h"
  24. extern GLuint makeNVidiaLogo(GLuint dlistBase);
  26. /* Some <math.h> files do not define M_PI... */
  27. #ifndef M_PI
  28. #define M_PI 3.14159265358979323846
  29. #endif
  31. enum {
  32.   X, Y, Z
  33. };
  35. enum {
  36.   DL_NONE, DL_TORUS, DL_CUBE, DL_DOUBLE_TORUS, DL_SPHERE, DL_NVIDIA_LOGO
  37. };
  39. enum {
  40.   M_TORUS, M_CUBE, M_DOUBLE_TORUS, M_NVIDIA_LOGO,
  41.   M_NORMAL_VIEW, M_LIGHT1_VIEW, M_LIGHT2_VIEW,
  42.   M_START_MOTION, M_ROTATING,
  43.   M_TWO_BIT_STENCIL, M_ALL_STENCIL,
  44.   M_RENDER_SILHOUETTE,
  45.   M_ENABLE_STENCIL_HACK, M_DISABLE_STENCIL_HACK
  46. };
  48. #define OBJECT_1  0x8000
  49. #define OBJECT_2  0x4000
  51. int fullscreen = 0, forceStencilHack = 0;
  52. int lightView = M_NORMAL_VIEW;
  53. int rotate1 = 1, rotate2 = 1;
  55. RTSscene *scene;
  56. RTSlight *light;
  57. RTSlight *light2;
  58. RTSobject *object, *object2;
  60. GLfloat eyePos[3] =
  61. {0.0, 0.0, 10.0};
  62. GLfloat lightPos[4] =
  63. {-3.9, 5.0, 1.0, 1.0};
  64. GLfloat lightPos2[4] =
  65. {4.0, 5.0, 0.0, 1.0};
  66. GLfloat objectPos[3] =
  67. {-1.0, 1.0, 0.0};
  68. GLfloat objectPos2[3] =
  69. {2.0, -2.0, 0.0};
  71. GLfloat pink[4] =
  72. {0.75, 0.5, 0.5, 1.0};
  73. GLfloat greeny[4] =
  74. {0.5, 0.75, 0.5, 1.0};
  76. int shape1 = M_TORUS, shape2 = M_CUBE;
  77. int renderSilhouette1, renderSilhouette2;
  79. GLfloat angle1 = 75.0;
  80. GLfloat angle2 = 75.0;
  81. GLfloat viewAngle = 0.0;
  82. int moving, begin;
  84. void
  85. renderBasicObject(int shape)
  86. {
  87.   switch (shape) {
  88.   case M_TORUS:
  89.     glCallList(DL_TORUS);
  90.     break;
  91.   case M_CUBE:
  92.     glCallList(DL_CUBE);
  93.     break;
  94.   case M_DOUBLE_TORUS:
  95.     glCallList(DL_DOUBLE_TORUS);
  96.     break;
  97.   case M_NVIDIA_LOGO:
  98.     glCallList(DL_NVIDIA_LOGO);
  99.     break;
  100.   }
  101. }
  103. /* ARGSUSED */
  104. void
  105. renderObject(void *data)
  106. {
  107.   glPushMatrix();
  108.   glTranslatef(objectPos[X], objectPos[Y], objectPos[Z]);
  109.   glRotatef(angle1, 1.0, 1.2, 0.0);
  110.   renderBasicObject(shape1);
  111.   glPopMatrix();
  112. }
  114. /* ARGSUSED */
  115. void
  116. renderObject2(void *data)
  117. {
  118.   glPushMatrix();
  119.   glTranslatef(objectPos2[X], objectPos2[Y], objectPos2[Z]);
  120.   glRotatef(-angle2, 1.3, 0.0, 1.0);
  121.   renderBasicObject(shape2);
  122.   glPopMatrix();
  123. }
  125. /* ARGSUSED1 */
  126. void
  127. renderScene(GLenum castingLight, void *sceneData, RTSscene * scene)
  128. {
  129.   glMatrixMode(GL_MODELVIEW);
  130.   glLoadIdentity();
  131.   switch (lightView) {
  132.   case M_NORMAL_VIEW:
  133.     gluLookAt(eyePos[X], eyePos[Y], eyePos[Z],
  134.       objectPos[X], objectPos[Y], objectPos[Z],
  135.       0.0, 1.0, 0.0);
  136.     break;
  137.   case M_LIGHT1_VIEW:
  138.     gluLookAt(lightPos[X], lightPos[Y], lightPos[Z],
  139.       objectPos[X], objectPos[Y], objectPos[Z],
  140.       0.0, 1.0, 0.0);
  141.     break;
  142.   case M_LIGHT2_VIEW:
  143.     gluLookAt(lightPos2[X], lightPos2[Y], lightPos2[Z],
  144.       objectPos[X], objectPos[Y], objectPos[Z],
  145.       0.0, 1.0, 0.0);
  146.     break;
  147.   }
  148.   glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
  149.   glLightfv(GL_LIGHT1, GL_POSITION, lightPos2);
  151.   glEnable(GL_NORMALIZE);
  152.   glPushMatrix();
  153.   glTranslatef(0.0, 8.0, -5.0);
  154.   glScalef(3.0, 3.0, 3.0);
  155.   glCallList(DL_SPHERE);
  156.   glPopMatrix();
  157.   glDisable(GL_NORMALIZE);
  159.   glPushMatrix();
  160.   glTranslatef(-5.0, 0.0, 0.0);
  161.   glCallList(DL_SPHERE);
  162.   glPopMatrix();
  164.   glBegin(GL_QUADS);
  165.   glNormal3f(0.0, 0.0, 1.0);
  166.   glVertex3f(-7.5, -7.5, -7.0);
  167.   glVertex3f(7.5, -7.5, -7.0);
  168.   glVertex3f(7.5, 7.5, -7.0);
  169.   glVertex3f(-7.5, 7.5, -7.0);
  171.   glNormal3f(-1.0, 0.0, 0.0);
  172.   glVertex3f(5.0, -5.0, -5.0);
  173.   glVertex3f(5.0, -5.0, 5.0);
  174.   glVertex3f(5.0, 5.0, 5.0);
  175.   glVertex3f(5.0, 5.0, -5.0);
  177.   glNormal3f(0.0, 1.0, 0.0);
  178.   glVertex3f(-5.0, -5.0, -5.0);
  179.   glVertex3f(-5.0, -5.0, 5.0);
  180.   glVertex3f(5.0, -5.0, 5.0);
  181.   glVertex3f(5.0, -5.0, -5.0);
  183.   glEnd();
  185.   if (castingLight == GL_NONE) {
  186.     /* Rendering that is not affected by lighting should be drawn only once.
  187.        The time to render it is when no light is casting. */
  188.     glDisable(GL_LIGHTING);
  190.     glColor3fv(pink);
  191.     glPushMatrix();
  192.     glTranslatef(lightPos[X], lightPos[Y], lightPos[Z]);
  193.     glutSolidSphere(0.3, 8, 8);
  194.     glPopMatrix();
  196.     glColor3fv(greeny);
  197.     glPushMatrix();
  198.     glTranslatef(lightPos2[X], lightPos2[Y], lightPos2[Z]);
  199.     glutSolidSphere(0.3, 8, 8);
  200.     glPopMatrix();
  202.     glEnable(GL_LIGHTING);
  203.   }
  204.   renderObject(NULL);
  205.   renderObject2(NULL);
  206. }
  208. void
  209. reshape(int w, int h)
  210. {
  211.   GLfloat wf = w, hf = h;
  213.   glViewport(0, 0, w, h);
  214.   glMatrixMode(GL_PROJECTION);
  215.   glLoadIdentity();
  216.   gluPerspective(70.0, wf/hf, 0.5, 30.0);
  217.   glMatrixMode(GL_MODELVIEW);
  218. }
  220. void
  221. display(void)
  222. {
  223.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  224.   rtsRenderScene(scene, RTS_USE_SHADOWS);
  225.   if (renderSilhouette1) {
  226.     glColor3f(0.0, 1.0, 0.0);
  227.     rtsRenderSilhouette(scene, light, object);
  228.     glColor3f(0.0, 0.0, 1.0);
  229.     rtsRenderSilhouette(scene, light2, object);
  230.   }
  231.   if (renderSilhouette2) {
  232.     glColor3f(1.0, 0.0, 0.0);
  233.     rtsRenderSilhouette(scene, light, object2);
  234.     glColor3f(1.0, 1.0, 0.0);
  235.     rtsRenderSilhouette(scene, light2, object2);
  236.   }
  237.   glutSwapBuffers();
  238. }
  240. void
  241. idle(void)
  242. {
  243.   if (rotate1) {
  244.     angle1 += 10;
  245.     rtsUpdateObjectShape(object);
  246.   }
  247.   if (rotate2) {
  248.     angle2 += 10;
  249.     rtsUpdateObjectShape(object2);
  250.   }
  251.   glutPostRedisplay();
  252. }
  254. /* ARGSUSED1 */
  255. void
  256. special(int c, int x, int y)
  257. {
  258.   switch (c) {
  259.   case GLUT_KEY_UP:
  260.     lightPos[Y] += 0.5;
  261.     rtsUpdateLightPos(light, lightPos);
  262.     break;
  263.   case GLUT_KEY_DOWN:
  264.     lightPos[Y] -= 0.5;
  265.     rtsUpdateLightPos(light, lightPos);
  266.     break;
  267.   case GLUT_KEY_RIGHT:
  268.     lightPos[X] += 0.5;
  269.     rtsUpdateLightPos(light, lightPos);
  270.     break;
  271.   case GLUT_KEY_LEFT:
  272.     lightPos[X] -= 0.5;
  273.     rtsUpdateLightPos(light, lightPos);
  274.     break;
  275.   case GLUT_KEY_PAGE_UP:
  276.     lightPos[Z] += 0.5;
  277.     rtsUpdateLightPos(light, lightPos);
  278.     break;
  279.   case GLUT_KEY_PAGE_DOWN:
  280.     lightPos[Z] -= 0.5;
  281.     rtsUpdateLightPos(light, lightPos);
  282.     break;
  283.   case GLUT_KEY_HOME:
  284.     angle1 += 15;
  285.     angle2 += 15;
  286.     rtsUpdateObjectShape(object);
  287.     rtsUpdateObjectShape(object2);
  288.     break;
  289.   case GLUT_KEY_END:
  290.     angle1 -= 15;
  291.     angle2 -= 15;
  292.     rtsUpdateObjectShape(object);
  293.     rtsUpdateObjectShape(object2);
  294.     break;
  295.   case GLUT_KEY_F1:
  296.     lightView = !lightView;
  297.     break;
  298.   }
  299.   glutPostRedisplay();
  300. }
  302. void
  303. updateIdleCallback(void)
  304. {
  305.   if (rotate1 || rotate2) {
  306.     glutIdleFunc(idle);
  307.   } else {
  308.     glutIdleFunc(NULL);
  309.   }
  310. }
  312. /* ARGSUSED1 */
  313. void
  314. menuHandler(int value)
  315. {
  316.   switch (value) {
  317.   case OBJECT_1 | M_TORUS:
  318.   case OBJECT_1 | M_CUBE:
  319.   case OBJECT_1 | M_DOUBLE_TORUS:
  320.   case OBJECT_1 | M_NVIDIA_LOGO:
  321.     shape1 = value & ~OBJECT_1;
  322.     rtsUpdateObjectShape(object);
  323.     glutPostRedisplay();
  324.     break;
  325.   case OBJECT_2 | M_TORUS:
  326.   case OBJECT_2 | M_CUBE:
  327.   case OBJECT_2 | M_DOUBLE_TORUS:
  328.   case OBJECT_2 | M_NVIDIA_LOGO:
  329.     shape2 = value & ~OBJECT_2;
  330.     rtsUpdateObjectShape(object2);
  331.     glutPostRedisplay();
  332.     break;
  333.   case M_NORMAL_VIEW:
  334.   case M_LIGHT1_VIEW:
  335.   case M_LIGHT2_VIEW:
  336.     lightView = value;
  337.     glutPostRedisplay();
  338.     break;
  339.   case M_START_MOTION:
  340.     rotate1 = 1;
  341.     rotate2 = 1;
  342.     glutIdleFunc(idle);
  343.     break;
  344.   case OBJECT_1 | M_ROTATING:
  345.     rotate1 = !rotate1;
  346.     updateIdleCallback();
  347.     break;
  348.   case OBJECT_2 | M_ROTATING:
  349.     rotate2 = !rotate2;
  350.     updateIdleCallback();
  351.     break;
  352.   case M_ALL_STENCIL:
  353.     rtsUpdateUsableStencilBits(scene, ~0);
  354.     glutPostRedisplay();
  355.     break;
  356.   case M_TWO_BIT_STENCIL:
  357.     rtsUpdateUsableStencilBits(scene, 0x3);
  358.     glutPostRedisplay();
  359.     break;
  360.   case OBJECT_1 | M_RENDER_SILHOUETTE:
  361.     renderSilhouette1 = !renderSilhouette1;
  362.     glutPostRedisplay();
  363.     break;
  364.   case OBJECT_2 | M_RENDER_SILHOUETTE:
  365.     renderSilhouette2 = !renderSilhouette2;
  366.     glutPostRedisplay();
  367.     break;
  368.   case M_ENABLE_STENCIL_HACK:
  369.     rtsStencilRenderingInvariantHack(scene, GL_TRUE);
  370.     glutPostRedisplay();
  371.     break;
  372.   case M_DISABLE_STENCIL_HACK:
  373.     rtsStencilRenderingInvariantHack(scene, GL_FALSE);
  374.     glutPostRedisplay();
  375.     break;
  376.   }
  377. }
  379. void
  380. keyboard(unsigned char c, int x, int y)
  381. {
  382.   switch (c) {
  383.   case 27:
  384.     exit(0);
  385.     /* NOTREACHED */
  386.     break;
  387.   case ' ':
  388.     if (rotate1 || rotate2) {
  389.       glutIdleFunc(NULL);
  390.       rotate1 = 0;
  391.       rotate2 = 0;
  392.     } else {
  393.       glutIdleFunc(idle);
  394.       rotate1 = 1;
  395.       rotate2 = 1;
  396.     }
  397.     break;
  398.   case '1':
  399.     menuHandler(OBJECT_1 | M_TORUS);
  400.     break;
  401.   case '2':
  402.     menuHandler(OBJECT_1 | M_CUBE);
  403.     break;
  404.   case '3':
  405.     menuHandler(OBJECT_1 | M_DOUBLE_TORUS);
  406.     break;
  407.   case '4':
  408.     menuHandler(OBJECT_1 | M_NVIDIA_LOGO);
  409.     break;
  410.   case '5':
  411.     menuHandler(OBJECT_2 | M_TORUS);
  412.     break;
  413.   case '6':
  414.     menuHandler(OBJECT_2 | M_CUBE);
  415.     break;
  416.   case '7':
  417.     menuHandler(OBJECT_2 | M_DOUBLE_TORUS);
  418.     break;
  419.   case '8':
  420.     menuHandler(OBJECT_2 | M_NVIDIA_LOGO);
  421.     break;
  422.   }
  423. }
  425. void
  426. visible(int vis)
  427. {
  428.   if (vis == GLUT_VISIBLE)
  429.     updateIdleCallback();
  430.   else
  431.     glutIdleFunc(NULL);
  432. }
  434. void
  435. initMenu(void)
  436. {
  437.   glutCreateMenu(menuHandler);
  439.   glutAddMenuEntry("1 Torus", OBJECT_1 | M_TORUS);
  440.   glutAddMenuEntry("1 Cube", OBJECT_1 | M_CUBE);
  441.   glutAddMenuEntry("1 Double torus", OBJECT_1 | M_DOUBLE_TORUS);
  442.   glutAddMenuEntry("1 NVIDIA logo", OBJECT_1 | M_NVIDIA_LOGO);
  444.   glutAddMenuEntry("2 Torus", OBJECT_2 | M_TORUS);
  445.   glutAddMenuEntry("2 Cube", OBJECT_2 | M_CUBE);
  446.   glutAddMenuEntry("2 Double torus", OBJECT_2 | M_DOUBLE_TORUS);
  447.   glutAddMenuEntry("2 NVIDIA logo", OBJECT_2 | M_NVIDIA_LOGO);
  449.   glutAddMenuEntry("Normal view", M_NORMAL_VIEW);
  450.   glutAddMenuEntry("View from light 1", M_LIGHT1_VIEW);
  451.   glutAddMenuEntry("View from light 2", M_LIGHT2_VIEW);
  453.   glutAddMenuEntry("Start motion", M_START_MOTION);
  454.   glutAddMenuEntry("1 Toggle rotating", OBJECT_1 | M_ROTATING);
  455.   glutAddMenuEntry("2 Toggle rotating", OBJECT_2 | M_ROTATING);
  457.   glutAddMenuEntry("Use all stencil", M_ALL_STENCIL);
  458.   glutAddMenuEntry("Use only 2 bits stencil", M_TWO_BIT_STENCIL);
  460.   glutAddMenuEntry("1 Toggle silhouette", OBJECT_1 | M_RENDER_SILHOUETTE);
  461.   glutAddMenuEntry("2 Toggle silhouette", OBJECT_2 | M_RENDER_SILHOUETTE);
  463.   glutAddMenuEntry("Enable stencil hack", M_ENABLE_STENCIL_HACK);
  464.   glutAddMenuEntry("Disable stencil hack", M_DISABLE_STENCIL_HACK);
  466.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  467. }
  469. /* ARGSUSED2 */
  470. void
  471. mouse(int button, int state, int x, int y)
  472. {
  473.   if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  474.     moving = 1;
  475.     begin = x;
  476.   }
  477.   if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {
  478.     moving = 0;
  479.   }
  480. }
  482. /* ARGSUSED1 */
  483. void
  484. motion(int x, int y)
  485. {
  486.   if (moving) {
  487.     viewAngle = viewAngle + (x - begin);
  488.     eyePos[X] = sin(viewAngle * M_PI / 180.0) * 10.0;
  489.     eyePos[Z] = cos(viewAngle * M_PI / 180.0) * 10.0;
  490.     begin = x;
  491.     glutPostRedisplay();
  492.   }
  493. }
  495. /* XXX RIVA 128 board vendors may change their GL_VENDOR
  496.    and GL_RENDERER strings. */
  497. int
  498. needsStencilRenderingInvariantHack(void)
  499. {
  500.   const char *renderer;
  501.   GLint bits;
  503.   renderer = glGetString(GL_RENDERER);
  504.   /* Stencil rendering on RIVA 128 and RIVA 128 ZX 
  505.      is not invariant with stencil-disabled rendering
  506.      in 16-bit hardware accelerated mode. */
  507.   if (!strncmp("RIVA 128", renderer, 8)) {
  508.     glGetIntegerv(GL_INDEX_BITS, &bits);
  509.     return bits == 16;
  510.   }
  511.   /* Stencil rendering on RIVA 128 and RIVA 128 ZX 
  512.      is not invariant with stencil-disabled rendering
  513.      in 16-bit hardware accelerated mode.  32-bit mode
  514.      is invariant (and hardware accelerated though!).  */
  515.   if (!strncmp("RIVA TNT", renderer, 8)) {
  516.     glGetIntegerv(GL_INDEX_BITS, &bits);
  517.     return bits == 16;
  518.   }
  519.   return 1;
  520. }
  522. void
  523. parseArgs(int argc, char **argv)
  524. {
  525.   int i;
  527.   for (i=1; i<argc; i++) {
  528.     if (!strcmp("-fullscreen", argv[i])) {
  529.       fullscreen = 1;
  530.     } else if (!strcmp("-stencilhack", argv[i])) {
  531.       forceStencilHack = 1;
  532.     }
  533.   }
  534. }
  536. int
  537. main(int argc, char **argv)
  538. {
  539.   glutInitDisplayString("stencil>=2 rgb depth samples");
  540.   glutInitDisplayString("stencil>=2 rgb double depth samples");
  541.   glutInit(&argc, argv);
  543.   parseArgs(argc, argv);
  545.   if (fullscreen) {
  546.     glutGameModeString("640x480:32@60");
  547.     glutEnterGameMode();
  548.   } else {
  549.     glutCreateWindow("Hello to Real Time Shadows");
  550.   }
  551.   glutReshapeFunc(reshape);
  552.   glutDisplayFunc(display);
  553.   glutSpecialFunc(special);
  554.   glutKeyboardFunc(keyboard);
  555.   glutVisibilityFunc(visible);
  556.   glutMouseFunc(mouse);
  557.   glutMotionFunc(motion);
  559.   /* 0xffffffff means "use as much stencil as is available". */
  560.   scene = rtsCreateScene(eyePos, 0xffffffff, renderScene, NULL);
  562.   glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
  563.   glLightfv(GL_LIGHT0, GL_DIFFUSE, pink);
  564.   light = rtsCreateLight(GL_LIGHT0, lightPos, 1000.0);
  565.   glLightfv(GL_LIGHT1, GL_POSITION, lightPos2);
  566.   glLightfv(GL_LIGHT1, GL_DIFFUSE, greeny);
  567.   light2 = rtsCreateLight(GL_LIGHT1, lightPos2, 1000.0);
  569.   object = rtsCreateObject(objectPos, 1.0, renderObject, NULL, 100);
  570.   object2 = rtsCreateObject(objectPos2, 1.0, renderObject2, NULL, 100);
  572.   rtsAddLightToScene(scene, light);
  573.   rtsAddObjectToLight(light, object);
  574.   rtsAddObjectToLight(light, object2);
  576.   rtsAddLightToScene(scene, light2);
  577.   rtsAddObjectToLight(light2, object);
  578.   rtsAddObjectToLight(light2, object2);
  580.   if (forceStencilHack || needsStencilRenderingInvariantHack()) {
  581.     /* RIVA 128 and RIVA 128 ZX lack hardware stencil
  582.        support and the hardware rasterization path
  583.        (non-stenciled) and the software rasterization
  584.        path (with stenciling enabled) do not meet the
  585.        invariants. */
  586.     rtsStencilRenderingInvariantHack(scene, GL_TRUE);
  587.   }
  589.   glEnable(GL_CULL_FACE);
  590.   glEnable(GL_DEPTH_TEST);
  592.   if (!fullscreen) {
  593.     initMenu();
  594.   }
  596.   glNewList(DL_TORUS, GL_COMPILE);
  597.   glutSolidTorus(0.2, 0.8, 10, 10);
  598.   glEndList();
  600.   glNewList(DL_CUBE, GL_COMPILE);
  601.   glutSolidCube(1.0);
  602.   glEndList();
  604.   glNewList(DL_DOUBLE_TORUS, GL_COMPILE);
  605.   glCallList(DL_TORUS);
  606.   glRotatef(90.0, 0.0, 1.0, 0.0);
  607.   glCallList(DL_TORUS);
  608.   glRotatef(-90.0, 0.0, 1.0, 0.0);
  609.   glEndList();
  611.   glNewList(DL_SPHERE, GL_COMPILE);
  612.   glutSolidSphere(1.5, 20, 20);
  613.   glEndList();
  615.   makeNVidiaLogo(1000);
  616.   glNewList(DL_NVIDIA_LOGO, GL_COMPILE);
  617.   glPushMatrix();
  618.   glScalef(.25, .25, .25);
  619.   glEnable(GL_NORMALIZE);
  620.   glCallList(1000);
  621.   glDisable(GL_NORMALIZE);
  622.   glPopMatrix();
  623.   glEndList();
  625.   glutMainLoop();
  626.   return 0;             /* ANSI C requires main to return int. */
  627. }
  629. #else
  630. int main(int argc, char** argv)
  631. {
  632.   fprintf(stderr, "This program requires the new tesselator API in GLU 1.2.n");
  633.   fprintf(stderr, "Your GLU library does not support this new interface, sorry.n");
  634.   return 0;
  635. }
  636. #endif  /* GLU_VERSION_1_2 */