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

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

GIS编程

开发平台：

Visual C++

volume.c：源码内容
  1. #include <GL/glut.h>
  2. #include <math.h>
  3. #include "texture.h"
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  8. /* nonzero if not power of 2 */ 
  9. #define NOTPOW2(num) ((num) & (num - 1))
  11. int
  12. makepow2(int val)
  13. {
  14.     int power = 0;
  15.     if(!val)
  16. return 0;
  18.     while(val >>= 1)
  19. power++;
  21.     return(1 << power);
  22. }
  24. #define CHECK_ERROR(str)                                           
  25. {                                                                  
  26.     GLenum error;                                                  
  27.     if(error = glGetError())                                       
  28.        printf("GL Error: %s (%s)n", gluErrorString(error), str);  
  29. }
  31. enum {X, Y, Z, W};
  32. enum {R, G, B, A};
  33. enum {OVER, ATTENUATE, NONE, LASTOP}; /* blend modes */
  34. /* mouse modes */
  35. enum {OBJ_ANGLE, SLICES, CUTTING, GEOMXY, GEOMZ, MINBOOST, BOOSTWID, BOOST}; 
  36. enum {NOLIST, SPHERE}; /* display list */
  38. /* window dimensions */
  39. int winWidth = 512;
  40. int winHeight = 512;
  41. int active;
  42. int operator = OVER;
  43. GLboolean texture = GL_TRUE;
  44. GLboolean dblbuf = GL_TRUE;
  45. GLboolean cut = GL_FALSE;
  46. GLboolean geom = GL_FALSE;
  47. GLboolean map = GL_FALSE;
  48. GLint cutbias = 50;
  49. int hasBlendColor = 0;
  50. #if defined(_WIN32) && !defined(MESA)
  51. #include <windows.h>
  52. PFNGLBLENDCOLOREXTPROC glBlendColorEXT;
  53. #endif
  55. GLfloat objangle[2] = {0.f, 0.f};
  56. GLfloat objpos[3] = {0.f, 0.f, 0.f};
  59. GLfloat minboost = 0.f, boostwid = .03f, boost = 3.f; /* transfer function */
  61. /* 3d texture data that's read in */
  62. /* XXX TODO; make command line arguments */
  63. int Texwid = 128; /* dimensions of each 2D texture */
  64. int Texht = 128;
  65. int Texdepth = 69; /* number of 2D textures */
  67. /* Actual dimensions of the texture (restricted to max 3d texture size) */
  68. int texwid, texht, texdepth;
  69. int slices;
  70. GLubyte *tex3ddata; /* pointer to 3D texture data */
  73. GLfloat *lighttex = 0;
  74. GLfloat lightpos[4] = {0.f, 0.f, 1.f, 0.f};
  75. GLboolean lightchanged[2] = {GL_TRUE, GL_TRUE};
  78. void
  79. reshape(int wid, int ht)
  80. {
  81.     winWidth = wid;
  82.     winHeight = ht;
  83.     glViewport(0, 0, wid, ht);
  84. }
  87. void
  88. motion(int x, int y)
  89. {
  90.     switch(active)
  91.     {
  92.     case OBJ_ANGLE:
  93. objangle[X] = (x - winWidth/2) * 360./winWidth;
  94. objangle[Y] = (y - winHeight/2) * 360./winHeight;
  95. glutPostRedisplay();
  96. break;
  97.     case SLICES:
  98. slices = x * texwid/winWidth;
  99. glutPostRedisplay();
  100. break;
  101.     case CUTTING:
  102. cutbias = (x - winWidth/2) * 300/winWidth;
  103. glutPostRedisplay();
  104. break;
  105.     case GEOMXY:
  106. objpos[X] = (x - winWidth/2) * 300/winWidth;
  107. objpos[Y] = (winHeight/2 - y) * 300/winHeight;
  108. glutPostRedisplay();
  109. break;
  110.     case GEOMZ:
  111. objpos[Z] = (x - winWidth/2) * 300/winWidth;
  112. glutPostRedisplay();
  113. break;
  114.     case MINBOOST:
  115. minboost = x * .25f/winWidth;
  116. glutPostRedisplay();
  117. break;
  118.     case BOOSTWID:
  119. boostwid = x * .5f/winWidth;
  120. glutPostRedisplay();
  121. break;
  122.     case BOOST:
  123. boost = x * 20.f/winWidth;
  124. glutPostRedisplay();
  125. break;
  126.     }
  127. }
  129. void
  130. mouse(int button, int state, int x, int y)
  131. {
  132.     if(state == GLUT_DOWN)
  133. switch(button)
  134. {
  135. case GLUT_LEFT_BUTTON: /* rotate the data volume */
  136.     if(map)
  137. active = MINBOOST;
  138.     else
  139. active = OBJ_ANGLE;
  140.     motion(x, y);
  141.     break;
  142. case GLUT_MIDDLE_BUTTON:
  143.     if(map)
  144. active = BOOSTWID;
  145.     else
  146. if(cut)
  147.     active = CUTTING; /* move cutting plane */
  148. else
  149.     active = GEOMXY; /* move geometry */
  150.     motion(x, y);
  151.     break;
  152. case GLUT_RIGHT_BUTTON: /* move the polygon */
  153.     if(map)
  154. active = BOOST;
  155.     else
  156. if(geom)
  157.     active = GEOMZ;
  158. else
  159.     active = SLICES;
  160.     motion(x, y);
  161.     break;
  162. }
  163. }
  165. /* use pixel path to remap 3D texture data */
  166. void
  167. remaptex(void)
  168. {
  169.     int i, size;
  170.     GLfloat *map;
  172.     glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
  174.     glGetIntegerv(GL_MAX_PIXEL_MAP_TABLE, &size);
  176.     map = (GLfloat *)malloc(sizeof(GLfloat) * size);
  177.     for(i = 0; i < size;i++)
  178.     {
  179. map[i] = (GLfloat)i/(size - 1);
  180. if(((GLfloat)i/size > minboost) &&
  181.    ((GLfloat)i/size < minboost + boostwid))
  182. {
  183.     map[i] *= boost;
  184. }
  185. else
  186.     map[i] /= boost;
  187.     }
  189.     glPixelMapfv(GL_PIXEL_MAP_R_TO_R, size, map);
  190.     glPixelMapfv(GL_PIXEL_MAP_G_TO_G, size, map);
  191.     glPixelMapfv(GL_PIXEL_MAP_B_TO_B, size, map);
  192.     glPixelMapfv(GL_PIXEL_MAP_A_TO_A, size, map);
  194. #ifdef GL_EXT_texture3D
  195.     glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE_ALPHA,
  196.     texwid, texht, texdepth,
  197.     0,
  198.     GL_RGBA, GL_UNSIGNED_BYTE, tex3ddata);
  199. #endif
  201.     glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
  202.     free(map);
  204.     CHECK_ERROR("OpenGL Error in remaptex()");
  205. }
  208. GLdouble clipplane0[] = {-1.,  0.,  0., 100.}; /* x < 100 out */
  209. GLdouble clipplane1[] = { 1.,  0.,  0., 100.}; /* x > 100 out */
  210. GLdouble clipplane2[] = { 0., -1.,  0., 100.}; /* y < 100 out */
  211. GLdouble clipplane3[] = { 0.,  1.,  0., 100.}; /* y > 100 out */
  212. GLdouble clipplane4[] = { 0.,  0., -1., 100.}; /* z < 100 out */
  213. GLdouble clipplane5[] = { 0.,  0.,  1., 100.}; /* z > 100 out */
  215. /* define a cutting plane */
  216. GLdouble cutplane[] = {0.f, -.5f, -2.f, 50.f};
  218. /* draw the object unlit without surface texture */
  219. void redraw(void)
  220. {
  221.     int i;
  222.     GLfloat offS, offT, offR; /* mapping texture to planes */
  224.     offS = 200.f/texwid;
  225.     offT = 200.f/texht;
  226.     offR = 200.f/texdepth;
  227.     
  228.     clipplane0[W] = 100.f - offS;
  229.     clipplane1[W] = 100.f - offS;
  230.     clipplane2[W] = 100.f - offT;
  231.     clipplane3[W] = 100.f - offT;
  232.     clipplane4[W] = 100.f - offR;
  233.     clipplane5[W] = 100.f - offR;
  235.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  237.     if(map)
  238. remaptex();
  240.     /* GL_MODELVIEW */
  241.     if(cut)
  242.     {
  243. cutplane[W] = cutbias;
  244. glClipPlane(GL_CLIP_PLANE5, cutplane);
  245.     }
  247.     glPushMatrix(); /* identity */
  248.     glRotatef(objangle[X], 0.f, 1.f, 0.f);
  249.     glRotatef(objangle[Y], 1.f, 0.f, 0.f);
  250.     glClipPlane(GL_CLIP_PLANE0, clipplane0);
  251.     glClipPlane(GL_CLIP_PLANE1, clipplane1);
  252.     glClipPlane(GL_CLIP_PLANE2, clipplane2);
  253.     glClipPlane(GL_CLIP_PLANE3, clipplane3);
  254.     glClipPlane(GL_CLIP_PLANE4, clipplane4);
  255.     if(!cut)
  256. glClipPlane(GL_CLIP_PLANE5, clipplane5);
  257.     glPopMatrix(); /* back to identity */
  259.     /* draw opaque geometry here */
  260.     glDisable(GL_CLIP_PLANE0);
  261.     glDisable(GL_CLIP_PLANE1);
  262.     glDisable(GL_CLIP_PLANE2);
  263.     glDisable(GL_CLIP_PLANE3);
  264.     glDisable(GL_CLIP_PLANE4);
  265.     if(geom)
  266.     {
  267. if(!cut)
  268.     glDisable(GL_CLIP_PLANE5);
  269. glPushMatrix();
  270. glTranslatef(objpos[X], objpos[Y], objpos[Z]);
  271. glCallList(SPHERE);
  272. glPopMatrix();
  273.     }
  274.     glMatrixMode(GL_TEXTURE);
  275.     glEnable(GL_CLIP_PLANE0);
  276.     glEnable(GL_CLIP_PLANE1);
  277.     glEnable(GL_CLIP_PLANE2);
  278.     glEnable(GL_CLIP_PLANE3);
  279.     glEnable(GL_CLIP_PLANE4);
  280.     glEnable(GL_CLIP_PLANE5);
  282.     glMatrixMode(GL_TEXTURE);
  283.     glPushMatrix(); /* identity */
  284.     glTranslatef( .5f,  .5f, .5f);
  285.     glRotatef(objangle[Y], 1.f, 0.f, 0.f);
  286.     glRotatef(objangle[X], 0.f, 0.f, 1.f);
  287.     glTranslatef( -.5f,  -.5f, -.5f);
  289.     switch(operator)
  290.     {
  291.     case OVER:
  292. glEnable(GL_BLEND);
  293. glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  294. break;
  295.     case ATTENUATE:
  296. #ifdef GL_EXT_blend_color
  297.         if (hasBlendColor){
  298.     glEnable(GL_BLEND);
  299.     glBlendFunc(GL_CONSTANT_ALPHA_EXT, GL_ONE);
  300.     glBlendColorEXT(1.f, 1.f, 1.f, 1.f/slices);
  301.         } else
  302. #endif
  303.         {
  304.             fprintf(stderr, "volume: attenuate not supported!n");
  305.         }
  306.         break;
  307.     case NONE:
  308. /* don't blend */
  309. break;
  310.     }
  312.     if(texture) {
  313. #ifdef GL_EXT_texture3D
  314.        glEnable(GL_TEXTURE_3D_EXT);
  315. #endif
  316.     } else {
  317. #ifdef GL_EXT_texture3D
  318.        glDisable(GL_TEXTURE_3D_EXT);
  319. #endif
  320.        glEnable(GL_LIGHTING);
  321.        glEnable(GL_LIGHT0);
  322.     }
  324.     
  326.     for(i = 0; i < slices; i++)
  327.     {
  328. glBegin(GL_QUADS);
  329. glVertex3f(-100.f, -100.f, 
  330.    -100.f + offR + i * (200.f - 2 * offR)/(slices - 1));
  331. glVertex3f( 100.f, -100.f,
  332.    -100.f + offR + i * (200.f - 2 * offR)/(slices - 1));
  333. glVertex3f( 100.f,  100.f,
  334.    -100.f + offR + i * (200.f - 2 * offR)/(slices - 1));
  335. glVertex3f(-100.f,  100.f,
  336.    -100.f + offR + i * (200.f - 2 * offR)/(slices - 1));
  337. glEnd();
  338.     }
  339. #ifdef GL_EXT_texture3D
  340.     glDisable(GL_TEXTURE_3D_EXT);
  341. #endif
  342.     if(!texture)
  343.     {
  344.        glDisable(GL_LIGHTING);
  345.     }
  346.     glDisable(GL_BLEND);
  348.     glPopMatrix(); /* back to identity */
  349.     glMatrixMode(GL_MODELVIEW);
  351.     if(operator == ATTENUATE)
  352.     {
  353. glPixelTransferf(GL_RED_SCALE, 3.f); /* brighten image */
  354. glPixelTransferf(GL_GREEN_SCALE, 3.f);
  355. glPixelTransferf(GL_BLUE_SCALE, 3.f);
  356. glCopyPixels(0, 0, winWidth, winHeight, GL_COLOR);
  357.     }
  358.     if(dblbuf)
  359. glutSwapBuffers(); 
  360.     else
  361. glFlush(); 
  363.     CHECK_ERROR("OpenGL Error in redraw()");
  364. }
  366. /* ARGSUSED1 */
  367. void key(unsigned char key, int x, int y)
  368. {
  369.     switch(key)
  370.     {
  371.     case 'm': /* remap texture values */
  372. if(map)
  373. {
  374.     fprintf(stderr, "remapping offn");
  375.     map = GL_FALSE;
  376. }
  377. else
  378. {
  379.     fprintf(stderr, "remapping on:n"
  380.             "left mouse moves emphasize valuen"
  381.             "middle mouse moves emphasize widthn"
  382.             "right mouse adjusts gainn");
  383.     map = GL_TRUE;
  384. }
  386. remaptex();
  387. glutPostRedisplay();
  388. break;
  389.     case 'o':
  390. operator++;
  391. if(operator == LASTOP)
  392.     operator = OVER;
  393. glutPostRedisplay();
  394. break;
  395.     case 't':
  396. if(texture)
  397.     texture = GL_FALSE;
  398. else
  399.     texture = GL_TRUE;
  400. glutPostRedisplay();
  401. break;
  402.     case 'c':
  403. if(cut)
  404. {
  405.     fprintf(stderr, "cutting plane offn");
  406.     cut = GL_FALSE;
  407. }
  408. else
  409. {
  410.     fprintf(stderr, 
  411.     "Cutting plane on: "
  412.     "middle mouse (horizontal) moves cutting planen");
  413.     cut = GL_TRUE;
  414. }
  415. glutPostRedisplay();
  416. break;
  417.     case 'g': /* toggle geometry */
  418. if(geom)
  419.     geom = GL_FALSE;
  420. else
  421.     geom = GL_TRUE;
  422. glutPostRedisplay();
  423. break;
  424.     case '33':
  425. exit(0);
  426. break;
  427.     case '?':
  428.     case 'h':
  429.     default:
  430. fprintf(stderr, 
  431. "Keyboard Commandsn"
  432. "m - toggle transfer function (remapping)n"
  433. "o - toggle operatorn"
  434. "t - toggle 3D texturingn"
  435. "c - toggle cutting planen"
  436. "g - toggle geometryn");
  437. break;
  438.     }
  439. }
  441. GLubyte *
  442. loadtex3d(int *texwid, int *texht, int *texdepth, int *texcomps)
  443. {
  444.     char *filename;
  445.     GLubyte *tex3ddata;
  446.     GLuint *texslice; /* 2D slice of 3D texture */
  447.     GLint max3dtexdims; /* maximum allowed 3d texture dimension */
  448.     GLint newval;
  449.     int i;
  451.     /* load 3D texture data */
  452.     filename = (char*)malloc(sizeof(char) * strlen("../data/skull/skullXX.la"));
  454.     tex3ddata = (GLubyte *)malloc(Texwid * Texht * Texdepth * 
  455.   4 * sizeof(GLubyte));
  456.     for(i = 0; i < Texdepth; i++)
  457.     {
  458. sprintf(filename, "../data/skull/skull%d.la", i);
  459. /* read_texture reads as RGBA */
  460. texslice = read_texture(filename, texwid, texht, texcomps);
  461. memcpy(&tex3ddata[i * Texwid * Texht * 4],  /* copy in a slice */
  462.        texslice, 
  463.        Texwid * Texht * 4 * sizeof(GLubyte));
  464. free(texslice);
  465.     }
  466.     free(filename);
  468.     *texdepth = Texdepth;
  470.     max3dtexdims = 0;
  471. #ifdef GL_EXT_texture3D
  472.     glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &max3dtexdims);
  473. #endif
  475.     /* adjust width */
  476.     newval = *texwid;
  477.     if(*texwid > max3dtexdims)
  478. newval = max3dtexdims;
  479.     if(NOTPOW2(*texwid))
  480.         newval = makepow2(*texwid);
  481.     if(newval != *texwid)
  482.     {
  483. glPixelStorei(GL_UNPACK_ROW_LENGTH, *texwid);
  484. glPixelStorei(GL_UNPACK_SKIP_PIXELS, (*texwid - newval)/2);
  485. *texwid = newval;
  486.     }
  488.     /* adjust height */
  489.     newval = *texht;
  490.     if(*texht > max3dtexdims)
  491. newval = max3dtexdims;
  492.     if(NOTPOW2(*texht))
  493.         newval = makepow2(*texht);
  494.     if(*texht > newval)
  495.     {
  496. #ifdef GL_EXT_texture3D
  497. glPixelStorei(GL_UNPACK_IMAGE_HEIGHT_EXT, *texht);
  498. #endif
  499. glPixelStorei(GL_UNPACK_SKIP_ROWS, (*texht - newval)/2);
  500. *texht = newval;
  501.     }
  503.     /* adjust depth */
  504.     newval = *texdepth;
  505.     if(*texdepth > max3dtexdims)
  506. newval = max3dtexdims;
  507.     if(NOTPOW2(*texdepth))
  508.         newval = makepow2(*texdepth);
  509.     if(*texdepth > newval)
  510.     {
  511. *texdepth = newval;
  512.     }
  513.     return tex3ddata;
  514. }
  518. main(int argc, char *argv[])
  519. {
  520.     int texcomps;
  521.     static GLfloat splane[4] = {1.f/200.f, 0.f, 0.f, .5f};
  522.     static GLfloat rplane[4] = {0, 1.f/200.f, 0, .5f};
  523.     static GLfloat tplane[4] = {0, 0, 1.f/200.f, .5f};
  524.     static GLfloat lightpos[4] = {150., 150., 150., 1.f};
  527.     glutInit(&argc, argv);
  528.     glutInitWindowSize(winWidth, winHeight);
  529.     if(argc > 1)
  530.     {
  531. char *args = argv[1];
  532. GLboolean done = GL_FALSE;
  533. while(!done)
  534. {
  535.     switch(*args)
  536.     {
  537.     case 's': /* single buffer */
  538. printf("Single Bufferedn");
  539. dblbuf = GL_FALSE;
  540. break;
  541.     case '-': /* do nothing */
  542. break;
  543.     case 0:
  544. done = GL_TRUE;
  545. break;
  546.     }
  547.     args++;
  548. }
  549.     }
  550.     if(dblbuf)
  551. glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  552.     else
  553. glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH);
  555.     (void)glutCreateWindow("volume rendering demo");
  556.     glutDisplayFunc(redraw);
  557.     glutReshapeFunc(reshape);
  558.     glutMouseFunc(mouse);
  559.     glutMotionFunc(motion);
  560.     glutKeyboardFunc(key);
  562.     /* Initialize OpenGL State */
  564.     /* draw a perspective scene */
  565. #if 0
  566.     glMatrixMode(GL_PROJECTION);
  567.     /* cube, 300 on a side */
  568.     glFrustum(-150., 150., -150., 150., 300., 600.);
  569.     glMatrixMode(GL_MODELVIEW);
  570.     /* look at scene from (0, 0, 450) */
  571.     gluLookAt(0., 0., 450., 0., 0., 0., 0., 1., 0.);
  572. #else
  573.     glMatrixMode(GL_PROJECTION);
  574.     /* cube, 300 on a side */
  575.     glOrtho(-150., 150., -150., 150., -150., 150.);
  576.     glMatrixMode(GL_MODELVIEW);
  577. #endif
  579.     glEnable(GL_DEPTH_TEST);
  580. #ifdef GL_EXT_texture3D
  581.     glEnable(GL_TEXTURE_3D_EXT);
  582. #endif
  584.     glEnable(GL_TEXTURE_GEN_S);
  585.     glEnable(GL_TEXTURE_GEN_T);
  586.     glEnable(GL_TEXTURE_GEN_R);
  588.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  589.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  590.     glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  592.     glTexGenfv(GL_S, GL_OBJECT_PLANE, splane);
  593.     glTexGenfv(GL_T, GL_OBJECT_PLANE, tplane);
  594.     glTexGenfv(GL_R, GL_OBJECT_PLANE, rplane);
  596. #ifdef GL_EXT_texture3D
  597.     /* to avoid boundary problems */
  598.     glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP);
  599.     glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP);
  600.     glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_CLAMP);
  601. #endif
  603.     glEnable(GL_CLIP_PLANE0);
  604.     glEnable(GL_CLIP_PLANE1);
  605.     glEnable(GL_CLIP_PLANE2);
  606.     glEnable(GL_CLIP_PLANE3);
  607.     glEnable(GL_CLIP_PLANE4);
  608.     glEnable(GL_CLIP_PLANE5);
  610.     glDisable(GL_LIGHT0);
  611.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  615.     tex3ddata = loadtex3d(&texwid, &texht, &texdepth, &texcomps);
  617.     slices = texht;
  619. #ifdef GL_EXT_texture3D
  620.     glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  621.     glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE_ALPHA,
  622.     texwid, texht, texdepth,
  623.     0,
  624.     GL_RGBA, GL_UNSIGNED_BYTE, tex3ddata);
  625. #endif
  627.     /* make a display list containing a sphere */
  628.     glNewList(SPHERE, GL_COMPILE);
  629.     {
  630. static GLfloat lightpos[] = {150.f, 150.f, 150.f, 1.f};
  631. static GLfloat material[] = {1.f, .5f, 1.f, 1.f};
  632. GLUquadricObj *qobj = gluNewQuadric();
  633. glPushAttrib(GL_LIGHTING_BIT);
  634. glEnable(GL_LIGHTING);
  635. glEnable(GL_LIGHT0);
  636. glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  637. glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, material);
  638. gluSphere(qobj, 20.f, 20, 20);
  639. gluDeleteQuadric(qobj);
  640. glPopAttrib();
  641.     }
  642.     glEndList();
  644.     key('?', 0, 0); /* print usage message */
  646.     CHECK_ERROR("end of main");
  648.     if(!glutExtensionSupported("GL_EXT_texture3d")) {
  649.       fprintf(stderr,
  650.         "volume: requires OpenGL texture 3D extension to operate correctly.n");
  651.     }
  652.     hasBlendColor = glutExtensionSupported("GL_EXT_blend_color");
  653.     if(!hasBlendColor) {
  654.       fprintf(stderr,
  655.         "volume: needs OpenGL blend color extension to attenuate.n");
  656. #if defined(_WIN32) && !defined(MESA)
  657.       glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC) wglGetProcAddress("glBlendColorEXT");
  658.       if (glBlendColorEXT == NULL) {
  659.         hasBlendColor = 0;
  660.       }
  661. #endif
  662.     }
  664.     glutMainLoop();
  665.     return 0;             /* ANSI C requires main to return int. */
  666. }