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

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

GIS编程

开发平台：

Visual C++

lightmap.c：源码内容
  1. #include <GL/glut.h>
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include "texture.h"
  5. #include <stdlib.h>
  7. #ifndef __sgi
  8. /* Most math.h's do not define float versions of the math functions. */
  9. #define sqrtf(x) (float)sqrt((x))
  10. #endif
  12. #if !defined(GL_VERSION_1_1) && !defined(GL_VERSION_1_2)
  13. #define glBindTexture glBindTextureEXT
  14. #endif
  16. #define CHECK_ERROR(str)                                           
  17. {                                                                  
  18.     GLenum error;                                                  
  19.     if(error = glGetError())                                       
  20.        printf("GL Error: %s (%s)n", gluErrorString(error), str);  
  21. }
  23. /* display lists */
  24. enum {SPHERE = 1, CONE, LIGHT, DISK, FLOOR, BACK, LEFT, RIGHT, CEIL};
  26. /* texture objects */
  27. enum {DEFAULT, LIGHTMAP, SURFMAP}; 
  29. enum {NONE, LIGHT_XY, LIGHT_Z, LIGHT_INTENS};
  31. #ifndef TRUE
  32. enum {FALSE, TRUE};
  33. #endif
  34. enum {X, Y, Z, W};
  35. enum {R, G, B, A};
  37. GLfloat staticlightpos[] = {50.f, 70.f, -10.f, 1.f};
  38. GLfloat lightpos[] = {50.f, 70.f, -10.f, 1.f};
  39. GLfloat intensity = 1.f;
  40. GLfloat nearScale = .49f, farScale = .0001f;
  42. int dblbuf = TRUE;
  43. int action = NONE;
  44. int winWidth = 512;
  45. int winHeight = 512;
  46. int curtess = 1; /* current tessellation level */
  47. int lasttess = 1; /* last set tessellation level */
  49. void
  50. reshape(int wid, int ht)
  51. {
  52.     winWidth = wid;
  53.     winHeight = ht;
  54.     glViewport(0, 0, wid, ht);
  55. }
  57. void
  58. motion(int x, int y)
  59. {
  60.     switch(action)
  61.     {
  62.     case LIGHT_XY:
  63. lightpos[X] = (x - winWidth/2) * 200.f/winWidth;
  64. lightpos[Y] = (winHeight/2 - y) * 200.f/winHeight;
  65. glutPostRedisplay();
  66. break;
  67.     case LIGHT_Z:
  68. lightpos[Z] = (winHeight/2 - y) * 200.f/winWidth;
  69. glutPostRedisplay();
  70. break;
  71.     case LIGHT_INTENS:
  72. intensity = x/(GLfloat)winWidth;
  73. glutPostRedisplay();
  74. break;
  75.     }
  76. }
  78. void
  79. mouse(int button, int state, int x, int y)
  80. {
  81.     if(state == GLUT_DOWN)
  82. switch(button)
  83. {
  84. case GLUT_LEFT_BUTTON: /* move the light */
  85.     action = LIGHT_XY;
  86.     motion(x, y);
  87.     break;
  88. case GLUT_MIDDLE_BUTTON:
  89.     action = LIGHT_INTENS;
  90.     motion(x, y);
  91.     break;
  92. case GLUT_RIGHT_BUTTON: /* move the polygon */
  93.     action = LIGHT_Z;
  94.     motion(x, y);
  95.     break;
  96. }
  97. }
  100. /*
  101. ** Create a single component texture map
  102. */
  103. GLfloat *make_texture(int maxs, int maxt)
  104. {
  105.     int s, t;
  106.     GLfloat *texture;
  108.     texture = (GLfloat *)malloc(maxs * maxt * sizeof(GLfloat));
  109.     for(t = 0; t < maxt; t++) {
  110. for(s = 0; s < maxs; s++) {
  111.     texture[s + maxs * t] = ((s >> 3) & 0x1) ^ ((t >> 3) & 0x1);
  112. }
  113.     }
  114.     return texture;
  115. }
  117. /* make tesselated surface for display list dlist */
  118. /* normal tells you surface position and orientation */
  119. /* count = tesselation count */
  120. void
  121. tess_surface(GLuint dlist, int count)
  122. {
  123.     int i, j;
  124.     GLfloat x0, y0, z0;
  125.     GLfloat over[3], up[3]; /* axes */
  126.     int Sindex, Tindex; /* active texture axes */
  128.     glNewList(dlist, GL_COMPILE);
  129.     glBegin(GL_QUADS);
  131.     switch(dlist)
  132.     {
  133.     case FLOOR:
  134. glNormal3f( 0.f,  1.f, 0.f);
  135. x0 = -100.f; y0 = -100.f; z0 = 100.f;
  136. over[X] = 1.f/count; over[Y] = 0.f; over[Z] = 0.f;
  137. up[X] = 0.f; up[Y] = 0.f; up[Z] = -1.f/count;
  138. Sindex = X; Tindex = Z;
  139. break;
  140.     case CEIL:
  141. glNormal3f( 0.f, -1.f, 0.f);
  142. x0 = -100.f; y0 = 100.f; z0 = 100.f;
  143. over[X] = 0.f; over[Y] = 0.f; over[Z] = -1.f/count;
  144. up[X] = 1.f/count; up[Y] = 0.f; up[Z] = 0.f;
  145. Sindex = X; Tindex = Z;
  146. break;
  147.     case LEFT:
  148. glNormal3f( 1.f,  0.f, 0.f);
  149. x0 = -100.f; y0 = -100.f; z0 = 100.f;
  150. over[X] = 0.f; over[Y] = 0.f; over[Z] = -1.f/count; 
  151. up[X] = 0.f; up[Y] = 1.f/count; up[Z] = 0.f;
  152. Sindex = Z; Tindex = Y;
  153. break;
  154.     case RIGHT:
  155. glNormal3f(-1.f,  0.f, 0.f);
  156. x0 =  100.f; y0 = -100.f; z0 = 100.f;
  157. over[X] = 0.f; over[Y] = 1.f/count; over[Z] = 0.f;
  158. up[X] = 0.f; up[Y] = 0.f; up[Z] = -1.f/count; 
  159. Sindex = Z; Tindex = Y;
  160. break;
  161.     case BACK:
  162. glNormal3f( 0.f,  0.f, 1.f);
  163. x0 = -100.f; y0 = -100.f; z0 = -100.f;
  164. over[X] = 1.f/count; over[Y] = 0.f; over[Z] = 0.f;
  165. up[X] = 0.f; up[Y] = 1.f/count; up[Z] = 0.f;
  166. Sindex = X; Tindex = Y;
  167. break;
  168.     default:
  169. fprintf(stderr, "tess_surface(): bad display list argument %dn",
  170. dlist);
  171. glEnd();
  172. glEndList();
  173. return;
  174.     }
  176.     for(j = 0; j < count; j++)
  177. for(i = 0; i < count; i++)
  178. {
  179.     glTexCoord2f(i * over[Sindex], j * up[Tindex]);
  180.     glVertex3f(x0 + i * 200 * over[X] + j * 200 * up[X],
  181.        y0 + i * 200 * over[Y] + j * 200 * up[Y],
  182.        z0 + i * 200 * over[Z] + j * 200 * up[Z]);
  183.     glTexCoord2f((i + 1) * over[Sindex], j * up[Tindex]);
  184.     glVertex3f(x0 + (i + 1) * 200 * over[X] + j * 200 * up[X],
  185.        y0 + (i + 1) * 200 * over[Y] + j * 200 * up[Y],
  186.        z0 + (i + 1) * 200 * over[Z] + j * 200 * up[Z]);
  187.     glTexCoord2f((i + 1) * over[Sindex], (j + 1) * up[Tindex]);
  188.     glVertex3f(x0 + (i + 1) * 200 * over[X] + (j + 1) * 200 * up[X],
  189.        y0 + (i + 1) * 200 * over[Y] + (j + 1) * 200 * up[Y],
  190.        z0 + (i + 1) * 200 * over[Z] + (j + 1) * 200 * up[Z]);
  191.     glTexCoord2f(i * over[Sindex], (j + 1) * up[Tindex]);
  192.     glVertex3f(x0 + i * 200 * over[X] + (j + 1) * 200 * up[X],
  193.        y0 + i * 200 * over[Y] + (j + 1) * 200 * up[Y],
  194.        z0 + i * 200 * over[Z] + (j + 1) * 200 * up[Z]);
  195. }
  196.     glEnd();
  197.     glEndList();
  198. }
  204. static GLfloat zero[] = {0.f, 0.f, 0.f, 1.f};
  205. static GLfloat one[] = {1.f, 1.f, 1.f, 1.f};
  206. static GLfloat diff[] = {.25f, .25f, .25f, .25f};
  209. /* create a lightmap simulating a local light with attenuation */
  210. void
  211. make_lightmap(GLenum light, int dim)
  212. {
  213.     GLfloat quadratic, linear, constant;
  214.     GLfloat diffuse[4], ambient[4]; /* light color */
  215.     GLfloat *texture;
  216.     GLfloat dist, scale, edge;
  217.     int size;
  218.     int i, j;
  220.     glPushAttrib(GL_TEXTURE_BIT);
  221.     /* get from light to simplify api */
  222.     glGetLightfv(light, GL_QUADRATIC_ATTENUATION, &quadratic);
  223.     glGetLightfv(light, GL_LINEAR_ATTENUATION, &linear);
  224.     glGetLightfv(light, GL_CONSTANT_ATTENUATION, &constant);
  226.     glGetLightfv(light, GL_AMBIENT, ambient);
  227.     glGetLightfv(light, GL_DIFFUSE, diffuse);
  229.     size = dim + 2;
  230.     texture = (GLfloat *)malloc(sizeof(GLfloat) * 3 * size * size);
  232.     dist = dim/2; /* 1 in from border */
  233.     edge = 1.f/(constant + linear * dist + quadratic * dist * dist);
  235.     for(j = 0; j < size; j++)
  236. for(i = 0; i < size; i++)
  237. {
  238.     dist = sqrtf((float)((size/2.f - i) * (size/2.f - i) +
  239.  (size/2.f - j) * (size/2.f - j)));
  240.     scale = 1.f/(constant + linear * dist + quadratic * dist * dist);
  241.     if(dist >= dim/2)
  242.     {
  243. texture[3 * (i + size * j) + 0] = 
  244.     diffuse[R] * edge + ambient[R];
  245. texture[3 * (i + size * j) + 1] = 
  246.     diffuse[G] * edge + ambient[G];
  247. texture[3 * (i + size * j) + 2] = 
  248.     diffuse[B] * edge + ambient[B];
  249.     }
  250.     else
  251.     {
  252. texture[3 * (i + size * j) + 0] = 
  253.     diffuse[R] * scale + ambient[R];
  254. texture[3 * (i + size * j) + 1] = 
  255.     diffuse[G] * scale + ambient[G];
  256. texture[3 * (i + size * j) + 2] = 
  257.     diffuse[B] * scale + ambient[B];
  258.     }
  259. }
  261.     glBindTexture(GL_TEXTURE_2D, LIGHTMAP);
  262.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  264.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  265.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  267.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 
  268.  size, size, 1, GL_RGB, GL_FLOAT, texture);
  269.     free(texture);
  270.     glPopAttrib();
  271. }
  273. /* draw a highly tesselated disk with local light */
  274. void
  275. draw_lightmap(int dim, int dist)
  276. {
  277.     GLUquadricObj *qobj;
  278.     GLfloat *texture;
  279.     GLfloat light[4] = {0.f, 0.f, 1.f, 1.f};
  281.     texture = (GLfloat *)malloc(sizeof(GLfloat) * 3 * dim * dim);
  283.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  285.     glPushMatrix(); /* starts as modelview */
  286.     glLoadIdentity();
  287.     glTranslatef(0.f, 0.f, -dist);
  289.     glMatrixMode(GL_PROJECTION);
  290.     glPushMatrix();
  291.     glLoadIdentity();
  292.     glOrtho(-dim/2., dim/2., -dim/2., dim/2., 0., (double)dist);
  294.     glPushAttrib(GL_LIGHTING_BIT|GL_VIEWPORT_BIT);
  295.     glViewport(0, 0, dim, dim);
  296.     glEnable(GL_LIGHTING);
  298.     light[Z] = dist;
  299.     glLightfv(GL_LIGHT0, GL_POSITION, light); /* light position */
  301.     /* XXX TODO, range check an report errors */
  302.     glDisable(GL_TEXTURE_2D);
  304.     qobj = gluNewQuadric();
  305.     gluDisk(qobj, 0., dim/2. * sqrt(2.), dim/4, dim/4);
  306.     gluDeleteQuadric(qobj);
  308.     glEnable(GL_TEXTURE_2D);
  309.     glPopAttrib();
  310.     glPopMatrix();
  311.     glMatrixMode(GL_MODELVIEW);
  312.     glPopMatrix();
  314.     glReadPixels(0, 0, dim, dim, GL_RGB, GL_FLOAT, texture);
  316.     glBindTexture(GL_TEXTURE_2D, LIGHTMAP);
  317.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  318.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, dim, dim, 0, GL_RGB,
  319.  GL_FLOAT, texture);
  321.     free(texture);
  322. }
  325. int texdim = 256;
  328. /* draw the lightmap texture */
  329. void redraw_lightmap(void)
  330. {
  331.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  333.     glPushAttrib(GL_LIGHTING_BIT|GL_TEXTURE_BIT);
  335.     /* assume GL_MODELVIEW */
  336.     glPushMatrix();
  337.     glLoadIdentity();
  338.     glMatrixMode(GL_PROJECTION);
  339.     glPushMatrix();
  340.     glLoadIdentity();
  342.     glEnable(GL_TEXTURE_2D);
  343.     glBindTexture(GL_TEXTURE_2D, LIGHTMAP);
  344.     glDisable(GL_LIGHTING);
  346.     glColor3f(1.f, 1.f, 1.f);
  347.     glBegin(GL_QUADS);
  348.     glTexCoord2i(0, 0);
  349.     glVertex2i(-1, -1);
  351.     glTexCoord2i(1, 0);
  352.     glVertex2i(1, -1);
  354.     glTexCoord2i(1, 1);
  355.     glVertex2i(1,  1);
  357.     glTexCoord2i(0, 1);
  358.     glVertex2i(-1,  1);
  359.     glEnd();
  361.     glPopMatrix();
  362.     glMatrixMode(GL_MODELVIEW);
  363.     glPopMatrix();
  365.     glPopAttrib();
  367.     CHECK_ERROR("OpenGL Error in redraw_map()");
  369.     if(dblbuf)
  370. glutSwapBuffers(); 
  371.     else
  372. glFlush(); 
  373. }
  375. /* draw the lightmap texture */
  376. void redraw_combomap(void)
  377. {
  378.     GLfloat scale;
  379.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  381.     glPushAttrib(GL_LIGHTING_BIT|GL_TEXTURE_BIT|GL_COLOR_BUFFER_BIT|
  382.  GL_DEPTH_BUFFER_BIT);
  384.     /* assume GL_MODELVIEW */
  385.     glPushMatrix();
  386.     glLoadIdentity();
  387.     glMatrixMode(GL_PROJECTION);
  388.     glPushMatrix();
  389.     glLoadIdentity();
  391.     glEnable(GL_TEXTURE_2D);
  392.     glDisable(GL_LIGHTING);
  395.     glBindTexture(GL_TEXTURE_2D, SURFMAP);
  397.     glColor3f(intensity, intensity, intensity);
  398.     glBegin(GL_QUADS);
  399.     glTexCoord2i(0, 0);
  400.     glVertex2i(-1, -1);
  402.     glTexCoord2i(5, 0);
  403.     glVertex2i(1, -1);
  405.     glTexCoord2i(5, 5);
  406.     glVertex2i(1,  1);
  408.     glTexCoord2i(0, 5);
  409.     glVertex2i(-1,  1);
  410.     glEnd();
  412.     glEnable(GL_BLEND);
  413.     glDepthFunc(GL_LEQUAL);
  414.     glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  415.     glBindTexture(GL_TEXTURE_2D, LIGHTMAP);
  417.     glMatrixMode(GL_TEXTURE);
  418.     glPushMatrix();
  419.     glTranslatef(.5f, .5f, 0.f);
  420.     scale = .25f + (lightpos[Z] + 100.f) * 3.75f/200.f;
  421.     glScalef(scale, scale, 0.f);
  422.     glTranslatef(-.5f, -.5f, 0.f);
  423.     glTranslatef(-lightpos[X]/200.f, -lightpos[Y]/200.f, 0.f);
  425.     glColor3f(1.f, 1.f, 1.f);
  426.     glBegin(GL_QUADS);
  427.     glTexCoord2i(0, 0);
  428.     glVertex2i(-1, -1);
  430.     glTexCoord2i(1, 0);
  431.     glVertex2i(1, -1);
  433.     glTexCoord2i(1, 1);
  434.     glVertex2i(1,  1);
  436.     glTexCoord2i(0, 1);
  437.     glVertex2i(-1,  1);
  438.     glEnd();
  440.     /* GL_TEXTURE */
  441.     glPopMatrix();
  442.     glMatrixMode(GL_PROJECTION);
  443.     glPopMatrix();
  444.     glMatrixMode(GL_MODELVIEW);
  445.     glPopMatrix();
  447.     glPopAttrib();
  449.     CHECK_ERROR("OpenGL Error in redraw_combomap()");
  451.     if(dblbuf)
  452. glutSwapBuffers(); 
  453.     else
  454. glFlush(); 
  455. }
  457. /* draw the openGL scene with lighting off */
  458. void render_scene(int tess)
  459. {
  460.     /* material properties for objects in scene */
  462.     /* update tessellation if it changed */
  463.     if(tess != lasttess)
  464.     {
  465. tess_surface(FLOOR, tess);
  466. tess_surface(CEIL,  tess);
  467. tess_surface(LEFT,  tess);
  468. tess_surface(RIGHT, tess);
  469. tess_surface(BACK,  tess);
  470. lasttess = tess;
  471.     }
  472.     glPushAttrib(GL_LIGHTING_BIT|GL_TEXTURE_BIT);
  474.     /* floor */
  475.     glColor3f(.5f, .35f, .35f); /* reddish */
  476.     glEnable(GL_TEXTURE_2D);
  477.     glCallList(FLOOR);
  478.     glDisable(GL_TEXTURE_2D);
  480.     /* ceiling */
  481.     glColor3f(.35f, .5f, .35f); /* greenish */
  482.     glCallList(CEIL);
  484.     /* right wall */
  485.     glColor3f(.35f, .35f, .5f); /* bluish */
  486.     glCallList(RIGHT);
  488.     /* left wall */
  489.     glCallList(LEFT);
  491.     /* back wall */
  492.     glCallList(BACK);
  494.     /* draw the sphere */
  495.     
  496.     glCallList(SPHERE);
  498.     /* draw the cone */
  499.     glCallList(CONE);
  501.     /* draw the light */
  502.     glPushMatrix();
  503.     glTranslatef(lightpos[X], lightpos[Y], lightpos[Z]);
  504.     glCallList(LIGHT);
  505.     glPopMatrix();
  507.     glPopAttrib();
  508.     CHECK_ERROR("OpenGL Error in render_unlit()");
  509. }
  511. void
  512. redraw_opengl(void)
  513. {
  514.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  515.     glPushAttrib(GL_LIGHTING_BIT);
  517.     glEnable(GL_LIGHTING);
  518.     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
  519.     glEnable(GL_COLOR_MATERIAL);
  520.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos); /* opengl lit */ 
  523.     render_scene(curtess);
  525.     glPopAttrib();
  527.     if(dblbuf)
  528. glutSwapBuffers(); 
  529.     else
  530. glFlush(); 
  531. }
  534. void
  535. redraw_unlit(void)
  536. {
  537.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  538.     glPushAttrib(GL_LIGHTING_BIT);
  540.     glDisable(GL_LIGHTING);
  541.     render_scene(1);
  543.     glPopAttrib();
  545.     if(dblbuf)
  546. glutSwapBuffers(); 
  547.     else
  548. glFlush(); 
  549. }
  552. /* draw the scene white, modulated by lightmap */
  553. /* unlit, uncolored simulated by lighting */
  554. /* texgen overrides texture coords */
  555. void render_white(void)
  556. {
  557.     GLfloat scale;
  559.     /* texgen used to override texure coords */
  560.     static GLfloat XZs[] = {1/200.f, 0.f, 0.f, .5f};
  561.     static GLfloat XZt[] = {0.f, 0.f, 1/200.f, .5f};
  563.     static GLfloat YZs[]  = {0.f, 0.f, 1/200.f, .5f};
  564.     static GLfloat YZt[]  = {0.f, 1/200.f, 0.f, .5f};
  566.     static GLfloat XYs[]  = {1/200.f, 0.f, 0.f, .5f};
  567.     static GLfloat XYt[]  = {0.f, 1/200.f, 0.f, .5f};
  569.     /* material properties for objects in scene */
  571.     glPushAttrib(GL_LIGHTING_BIT|GL_TEXTURE_BIT);
  573.     glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  574.     glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  576.     glEnable(GL_LIGHTING);
  578.     /* simulate unlit, color = white */
  579.     glLightfv(GL_LIGHT0, GL_AMBIENT, diff);
  580.     glMaterialfv(GL_FRONT, GL_DIFFUSE, zero);
  581.     glColorMaterial(GL_FRONT, GL_AMBIENT);
  582.     glEnable(GL_COLOR_MATERIAL);
  584.     glEnable(GL_TEXTURE_2D);
  585.     glBindTexture(GL_TEXTURE_2D, LIGHTMAP);
  586.     
  587.     glEnable(GL_TEXTURE_GEN_S);
  588.     glEnable(GL_TEXTURE_GEN_T);
  589.     glMatrixMode(GL_TEXTURE);
  590.     glPushMatrix();
  592.     glTexGenfv(GL_S, GL_OBJECT_PLANE, XZs);
  593.     glTexGenfv(GL_T, GL_OBJECT_PLANE, XZt);
  595.     glLoadIdentity();
  596.     glTranslatef(.5f, .5f, 0.f);
  597.     scale = nearScale - (nearScale - farScale)/200.f * (100.f + lightpos[Y]);
  598.     glScalef(scale, scale, 1.f);
  599.     glTranslatef(-.5f, -.5f, 0.f);
  600.     glTranslatef(-lightpos[X]/200.f, -lightpos[Z]/200.f, 0.f);
  601.     /* add intensity (colorchange) */
  603.     scale = lightpos[Y] + 100;
  604.     scale /= 200.f;
  605.     scale *= scale;
  606.     scale = 1.f/(1.f + scale);
  607.     scale = 1.f;
  608.     glColor3f(scale, scale, scale);
  610.     /* floor */
  611.     glCallList(FLOOR);
  613.     glLoadIdentity();
  614.     glTranslatef(.5f, .5f, 0.f);
  615.     scale = nearScale - (nearScale - farScale)/200.f * (100.f - lightpos[Y]);
  616.     glScalef(scale, scale, 1.f);
  617.     glTranslatef(-.5f, -.5f, 0.f);
  618.     glTranslatef(-lightpos[X]/200.f, -lightpos[Z]/200.f, 0.f);
  620.     scale = 100 - lightpos[Y];
  621.     scale /= 100.f;
  622.     scale *= scale;
  623.     scale = 1.f/(1.f + scale);
  624.     scale = 1.f;
  625.     glColor3f(scale, scale, scale);
  627.     /* ceiling */
  628.      glCallList(CEIL);
  630.     glTexGenfv(GL_S, GL_OBJECT_PLANE, YZs);
  631.     glTexGenfv(GL_T, GL_OBJECT_PLANE, YZt);
  632.     glLoadIdentity();
  633.     glTranslatef(.5f, .5f, 0.f);
  634.     scale = nearScale - (nearScale - farScale)/200.f * (100.f - lightpos[X]);
  635.     glScalef(scale, scale, 1.f);
  636.     glTranslatef(-.5f, -.5f, 0.f);
  637.     glTranslatef(-lightpos[Z]/200.f, -lightpos[Y]/200.f, 0.f);
  639.     scale = 100 - lightpos[X];
  640.     scale /= 100.f;
  641.     scale *= scale;
  642.     scale = 1.f/(1.f + scale);
  643.     scale = 1.f;
  644.     glColor3f(scale, scale, scale);
  646.     /* right wall */
  647.     glCallList(RIGHT);
  649.     glLoadIdentity();
  650.     glTranslatef(.5f, .5f, 0.f);
  651.     scale = nearScale - (nearScale - farScale)/200.f * (100.f + lightpos[X]);
  652.     glScalef(scale, scale, 1.f);
  653.     glTranslatef(-.5f, -.5f, 0.f);
  654.     glTranslatef(-lightpos[Z]/200.f, -lightpos[Y]/200.f, 0.f);
  656.     scale = lightpos[X] + 100;
  657.     scale /= 100.f;
  658.     scale *= scale;
  659.     scale = 1.f/(1.f + scale);
  660.     scale = 1.f;
  661.     glColor3f(scale, scale, scale);
  663.     /* left wall */
  664.     glCallList(LEFT);
  666.     glTexGenfv(GL_S, GL_OBJECT_PLANE, XYs);
  667.     glTexGenfv(GL_T, GL_OBJECT_PLANE, XYt);
  668.     glLoadIdentity();
  669.     glTranslatef(.5f, .5f, 0.f);
  670.     scale = nearScale - (nearScale - farScale)/200.f * (100.f + lightpos[Z]);
  671.     glScalef(scale, scale, 1.f);
  672.     glTranslatef(-.5f, -.5f, 0.f);
  673.     glTranslatef(-lightpos[X]/200.f, -lightpos[Y]/200.f, 0.f);
  675.     scale = lightpos[Z] + 100;
  676.     scale /= 100.f;
  677.     scale *= scale;
  678.     scale = 1.f/(1.f + scale);
  679.     scale = 1.f;
  680.     glColor3f(scale, scale, scale);
  682.     /* back wall */
  683.     glCallList(BACK);
  685.     /* done with texture matrix */
  686.     glPopMatrix();
  687.     glMatrixMode(GL_MODELVIEW);
  689.     /* no contribution to highly tesselated objects */
  690.     glMaterialfv(GL_FRONT, GL_AMBIENT, zero);
  691.     glLightfv(GL_LIGHT0, GL_AMBIENT, zero);
  693.     /* draw the sphere */
  694.     
  695.     glCallList(SPHERE);
  697.     /* draw the cone */
  698.     glCallList(CONE);
  700.     glPopAttrib();
  701.     CHECK_ERROR("OpenGL Error in render_white()");
  702. }
  704. void
  705. redraw_white(void)
  706. {
  707.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  708.     render_white();
  710.     if(dblbuf)
  711. glutSwapBuffers(); 
  712.     else
  713. glFlush(); 
  714. }
  717. void
  718. redraw_lightmapped(void)
  719. {
  720.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  722.     glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_LIGHTING_BIT);
  723.     glDisable(GL_LIGHTING);
  724.     render_scene(1);
  725.     glEnable(GL_LIGHTING);
  726.     glEnable(GL_BLEND);
  727.     glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  728.     glDepthFunc(GL_LEQUAL);
  729.     render_white();
  730.     glPopAttrib();
  732.     if(dblbuf)
  733. glutSwapBuffers(); 
  734.     else
  735. glFlush(); 
  736. }
  738. void
  739. redraw_maponly(void)
  740. {
  741.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  743.     glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_LIGHTING_BIT);
  744.     glDisable(GL_LIGHTING);
  745.     render_scene(1);
  746.     glEnable(GL_LIGHTING);
  747.     glEnable(GL_BLEND);
  748.     glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  749.     glDepthFunc(GL_LEQUAL);
  750.     render_white();
  751.     glBlendFunc(GL_ONE, GL_ONE);
  752.     glDisable(GL_LIGHTING); /* add in unlit scene again */
  753.     render_scene(1);
  754.     
  755.     glPopAttrib();
  757.     if(dblbuf)
  758. glutSwapBuffers(); 
  759.     else
  760. glFlush(); 
  761. }
  763. void
  764. redraw_complete(void)
  765. {
  766.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  768.     glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_LIGHTING_BIT);
  770.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos); /* opengl lit */ 
  771.     glDisable(GL_LIGHTING);
  772.     render_scene(1);
  773.     glEnable(GL_LIGHTING);
  774.     glEnable(GL_BLEND);
  775.     glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  776.     glDepthFunc(GL_LEQUAL);
  777.     render_white();
  778.     glBlendFunc(GL_ONE, GL_ONE);
  779.     glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
  780.     glEnable(GL_COLOR_MATERIAL);
  781.     render_scene(1);
  783.     glPopAttrib();
  785.     if(dblbuf)
  786. glutSwapBuffers(); 
  787.     else
  788. glFlush(); 
  789. }
  793. /* ARGSUSED1 */
  794. void key(unsigned char key, int x, int y)
  795. {
  796.     switch(key)
  797.     {
  798.     case 'l': /* show lightmap */
  799. glutDisplayFunc(redraw_lightmap);
  800. glutPostRedisplay();
  801. break;
  802.     case 'w': /* show white scene modulated by lightmap */
  803. glutDisplayFunc(redraw_white);
  804. glutPostRedisplay();
  805. break;
  806.     case 'm': /* unlit scene modified by lightmap */
  807. glutDisplayFunc(redraw_lightmapped);
  808. glutPostRedisplay();
  809. break;
  810.     case 'u': /* draw scene without lighting */
  811. glutDisplayFunc(redraw_unlit);
  812. glutPostRedisplay();
  813. break;
  814.     case 'o': /* draw scene lit using OpenGL */
  815. glutDisplayFunc(redraw_opengl);
  816. glutPostRedisplay();
  817. break;
  818.     case 'a': /* show scene lit with OpenGL and lightmaps */
  819. glutDisplayFunc(redraw_complete);
  820. glutPostRedisplay();
  821. break;
  822.     case 'p': /* show scene lit with pure lightmaps */
  823. glutDisplayFunc(redraw_maponly);
  824. glutPostRedisplay();
  825. break;
  826.     case 'x': /* surface texture with lightmap combined */
  827. glutDisplayFunc(redraw_combomap);
  828. glutPostRedisplay();
  829. break;
  830.     case 'T': /* surface texture with lightmap combined */
  831. curtess++;
  832. glutPostRedisplay();
  833. break;
  834.     case 't': /* surface texture with lightmap combined */
  835. curtess--;
  836. if(curtess < 1)
  837.     curtess = 1;
  838. glutPostRedisplay();
  839. break;
  840.     case '1': /* surface texture with lightmap combined */
  841. curtess = 1;
  842. glutPostRedisplay();
  843. break;
  844.     case 'y':
  845. farScale -= .0001f;
  846. if(farScale < .0001f)
  847.     farScale = .0001f;
  848. printf("farScale = %.4fn", farScale);
  849. glutPostRedisplay();
  850. break;
  851.     case 'Y':
  852. farScale += .0001f;
  853. printf("farScale = %.4fn", farScale);
  854. glutPostRedisplay();
  855. break;
  856.     case 'z':
  857. nearScale -= .01f;
  858. if(nearScale < .01f)
  859.     nearScale = .01f;
  860. printf("nearScale = %.2fn", nearScale);
  861. glutPostRedisplay();
  862. break;
  863.     case 'Z':
  864. nearScale += .01f;
  865. printf("nearScale = %.2fn", nearScale);
  866. glutPostRedisplay();
  867. break;
  868.     case '33':
  869. exit(0);
  870. break;
  871.     case '?':
  872.     case 'h':
  873.     default:
  874. fprintf(stderr, 
  875. "Keyboard Commandsn"
  876. "l - draw lightmapn"
  877. "w - draw white scene modulated by lightmapn"
  878. "m - draw unlit scene modified by lightmapn"
  879. "u - draw unlit scenen"
  880. "o - draw scene lit by OpenGLn"
  881. "a - draw scene lit by OpenGL (tess = 1) + lightmapsn"
  882. "p - draw scene lit only by lightmapsn"
  883. "x - interactive lightmap on brick walln"
  884. "T - increase surface tessellationn"
  885. "t - decrease surface tessellationn"
  886. "1 - set tessellation to onen"
  887. "y - decrease far scale for lightmapsn"
  888. "Y - increase far scale for lightmapsn"
  889. "z - decrease near scale for lightmapsn"
  890. "Z - increase near scale for lightmapsn");
  891. break;
  892.     }
  893.     glutPostRedisplay();
  894. }
  899. main(int argc, char *argv[])
  900. {
  901.     GLfloat *tex;
  903.     GLUquadricObj *qobj;
  905.     glutInit(&argc, argv);
  906.     glutInitWindowSize(winWidth, winHeight);
  907.     if(argc > 1)
  908.     {
  909. char *args = argv[1];
  910. int done = FALSE;
  911. while(!done)
  912. {
  913.     switch(*args)
  914.     {
  915.     case 's': /* single buffer */
  916. printf("Single Bufferedn");
  917. dblbuf = FALSE;
  918. break;
  919.     case '-': /* do nothing */
  920. break;
  921.     case 0:
  922. done = TRUE;
  923. break;
  924.     }
  925.     args++;
  926. }
  927.     }
  929.     if(dblbuf)
  930. glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE);
  931.     else
  932. glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH);
  935.     (void)glutCreateWindow("example program");
  936.     glutDisplayFunc(redraw_opengl);
  937.     glutKeyboardFunc(key);
  938.     glutMouseFunc(mouse);
  939.     glutMotionFunc(motion);
  940.     glutReshapeFunc(reshape);
  942.     /* draw a perspective scene */
  943.     glMatrixMode(GL_PROJECTION);
  944.     glFrustum(-100., 100., -100., 100., 300., 501.); 
  945.     glMatrixMode(GL_MODELVIEW);
  946.     /* look at scene from (0, 0, 400) */
  947.     gluLookAt(0., 0., 400., 0., 0., 0., 0., 1., 0.);
  949.     /* turn on features */
  950.     glEnable(GL_DEPTH_TEST);
  951.     glEnable(GL_LIGHT0);
  952.     glLightfv(GL_LIGHT0, GL_POSITION, staticlightpos);
  954.     /* remove back faces to speed things up */
  955.     glCullFace(GL_BACK);
  958.     /* make a display list containing a sphere */
  959.     glNewList(SPHERE, GL_COMPILE);
  960.     {
  961. glPushMatrix();
  962. glTranslatef(0.f, -80.f, -80.f);
  963. qobj = gluNewQuadric();
  964. gluQuadricTexture(qobj, GL_TRUE);
  965. glColor3f(.5f, .25f, 0.f);
  966. gluSphere(qobj, 20.f, 20, 20);
  967. gluDeleteQuadric(qobj);
  968. glPopMatrix();
  969.     }
  970.     glEndList();
  972.     /* make a display list containing a sphere */
  973.     glNewList(LIGHT, GL_COMPILE);
  974.     {
  975. qobj = gluNewQuadric();
  976. glColor3f(1.f, 1.f, 1.f);
  977. glPushAttrib(GL_LIGHTING_BIT);
  978. glDisable(GL_LIGHTING);
  979. gluSphere(qobj, 3.f, 20, 20);
  980. glPopAttrib();
  981. gluDeleteQuadric(qobj);
  982.     }
  983.     glEndList();
  985.     /* create a display list containing a cone */
  986.     glNewList(CONE, GL_COMPILE);
  987.     {
  988. glPushMatrix();
  989. glTranslatef(-60.f, -100.f, -5.f);
  991. qobj = gluNewQuadric();
  992. gluQuadricTexture(qobj, GL_TRUE);
  993. glRotatef(-90.f, 1.f, 0.f, 0.f);
  994. glColor3f(0.f, .25f, .5f);
  996. gluCylinder(qobj, 20., 0., 60., 20, 20);
  997. gluDeleteQuadric(qobj);
  999. qobj = gluNewQuadric();
  1000. gluQuadricOrientation(qobj, GLU_INSIDE);
  1001. gluDisk(qobj, 0., 20., 20, 1);
  1002. gluDeleteQuadric(qobj);
  1003. glPopMatrix();
  1004.     }
  1005.     glEndList();
  1007.     /* load pattern for current 2d texture */
  1008.     tex = make_texture(128, 128);
  1010.     /* makes texturing faster, and looks better than GL_LINEAR */
  1011.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  1012.     glTexImage2D(GL_TEXTURE_2D, 0, 1, 128, 128, 0, GL_RED, GL_FLOAT, tex);
  1013.     free(tex);
  1015.     {
  1016. GLuint *surftex;
  1017. int texwid, texht, texcomps;
  1018. surftex = read_texture("../data/brick.rgb", &texwid, &texht, &texcomps);
  1020. glBindTexture(GL_TEXTURE_2D, SURFMAP);
  1021. glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  1023. glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texwid, texht, 0, GL_RGBA,
  1024.      GL_UNSIGNED_BYTE, surftex);
  1026.     }
  1028.     glBindTexture(GL_TEXTURE_2D, DEFAULT);
  1030.     tess_surface(FLOOR, 1);
  1031.     tess_surface(CEIL, 1);
  1032.     tess_surface(LEFT, 1);
  1033.     tess_surface(RIGHT, 1);
  1034.     tess_surface(BACK, 1);
  1036.     /* 1/80 intensity at edges */
  1037.     glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 100.f/(texdim * texdim/4));
  1038.     /* 1/2 intensity at edges */
  1039.     glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 1.f/texdim/2);
  1040.     glLightfv(GL_LIGHT1, GL_DIFFUSE, one);
  1042.     make_lightmap(GL_LIGHT1, 128);
  1044.     key('?', 0, 0);
  1046.     CHECK_ERROR("end of main");
  1048.     glutMainLoop();
  1050.     return 0;
  1051. }