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

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

GIS编程

开发平台：

Visual C++

bump.c：源码内容
  1. #include <GL/glut.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <math.h>
  6. #include "texture.h"
  8. /* Some <math.h> files do not define M_PI... */
  9. #ifndef M_PI
  10. #define M_PI 3.14159265358979323846
  11. #endif
  13. #ifndef __sgi
  14. /* Most math.h's do not define float versions of the math functions. */
  15. #define sqrtf(x) (float)sqrt((x))
  16. #define cosf(x) (float)cos((x))
  17. #define sinf(x) (float)sin((x))
  18. #endif
  20. #ifdef GL_EXT_blend_subtract
  21. #if defined(_WIN32) && !defined(MESA)
  22. #include <windows.h>
  23. PFNGLBLENDEQUATIONEXTPROC glBlendEquationEXT = NULL;
  24. #endif
  25. static int hasBlendSubtract = 0;
  26. #else
  27. static const int hasBlendSubtract = 0;
  28. #endif
  30. int winWidth = 512;
  31. int winHeight = 512;
  33. #ifndef FALSE
  34. enum {FALSE, TRUE};
  35. #endif
  36. enum {S, T}; /* make array indexing more intuitive */
  37. enum {X, Y, Z, W};
  38. enum {R, G, B, A};
  39. enum {DEFAULT_TEX, ACCUM_TEX, ADD_TEX, SUB_TEX}; /* texture names */
  40. enum {LIGHT_XY, LIGHT_Z, PGON}; /* what should move */
  42. int dblbuf = TRUE;
  43. int accum = FALSE;
  44. int color = FALSE;
  45. int wire = FALSE;
  46. int textureOnly = FALSE;
  47. int lightOnly = FALSE;
  48. int bindtex = FALSE;
  49. int embossed = FALSE;
  50. int steps_xz = 20, steps_y = 20;
  52. int texture_width;
  53. int texture_height;
  55. /* is bumpmap shifting on? */
  56. int bumpEnabled = FALSE;
  58. int move = LIGHT_XY;
  60. /* current tangent vector */
  61. GLfloat curTangent[3];
  63. /* current texture coordinate */
  64. GLfloat curTex[2];
  67. /* current normal */
  68. GLfloat curNormal[3];
  70. /* current light position */
  71. GLfloat curLight[3];
  72. GLfloat lightpos[4] = {100.f, 100.f, 100.f, 1.f};
  73. GLfloat angles[2]; /* x and y angle */
  75. unsigned *bumptex; /* pointer to bumpmap texture */
  76. GLfloat bumpscale = .39f; /* scale down bumpmap texture (a smidgen under .4) */
  78. /* TEST PROGRAM */
  80. #if !defined(GL_VERSION_1_1) && !defined(GL_VERSION_1_2)
  81. #define glBindTexture glBindTextureEXT
  82. #endif
  84. #define CHECK_ERROR(str)                                           
  85. {                                                                  
  86.     GLenum error;                                                  
  87.     if(error = glGetError())                                       
  88.        printf("GL Error: %s (%s)n", gluErrorString(error), str);  
  89. }
  91. void
  92. bumpEnable(void)
  93. {
  94.     bumpEnabled = TRUE;
  95. }
  97. void
  98. bumpDisable(void)
  99. {
  100.     bumpEnabled = FALSE;
  101. }
  103. void
  104. reshape(int wid, int ht)
  105. {
  106.     winWidth = wid;
  107.     winHeight = ht;
  108.     glViewport(0, 0, wid, ht);
  109. }
  113. void
  114. mouse(int button, int state, int x, int y)
  115. {
  116.     if(state == GLUT_DOWN)
  117. switch(button)
  118. {
  119. case GLUT_LEFT_BUTTON: /* move the light */
  120.     move = LIGHT_XY;
  121.     lightpos[X] = (x - winWidth/2) * 300.f/winWidth;
  122.     lightpos[Y] = (winHeight/2 - y) * 300.f/winHeight;
  123.     glutPostRedisplay();
  124.     break;
  125. case GLUT_MIDDLE_BUTTON:
  126.     move = PGON;
  127.     angles[X] = (x - winWidth/2) * 180.f/winWidth;
  128.     angles[Y] = (y - winHeight/2) * 180.f/winHeight;
  129.     glutPostRedisplay();
  130.     break;
  131. case GLUT_RIGHT_BUTTON: /* move the polygon */
  132.     move = LIGHT_Z;
  133.     lightpos[Z] = (winHeight/2 - y) * 300.f/winWidth;
  134.     glutPostRedisplay();
  135.     break;
  136. }
  137. }
  139. void
  140. motion(int x, int y)
  141. {
  142.     switch(move)
  143.     {
  144.     case LIGHT_XY:
  145. lightpos[X] = (x - winWidth/2) * 300.f/winWidth;
  146. lightpos[Y] = (winHeight/2 - y) * 300.f/winHeight;
  147. glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  148. glutPostRedisplay();
  149. break;
  150.     case LIGHT_Z:
  151. lightpos[Z] = (winHeight/2 - y) * 300.f/winWidth;
  152. glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  153. glutPostRedisplay();
  154. break;
  155.     case PGON:
  156. angles[X] = (x - winWidth/2) * 180.f/winWidth;
  157. angles[Y] = (y - winHeight/2) * 180.f/winHeight;
  158. glutPostRedisplay();
  159. break;
  160.     }
  161. }
  164. /*
  165. ** Create a single component texture map
  166. */
  167. GLfloat *make_texture(int maxs, int maxt)
  168. {
  169.     int s, t;
  170.     GLfloat *texture;
  172.     /* assumed format; LUMINANCE */
  173.     texture = (GLfloat *)malloc(maxs * maxt * sizeof(GLfloat));
  174.     for(t = 0; t < maxt; t++) {
  175. for(s = 0; s < maxs; s++) {
  176.     texture[s + maxs * t] = ((s >> 3) & 0x1) ^ ((t >> 3) & 0x1);
  177. }
  178.     }
  179.     return texture;
  180. }
  182. /* get current light position in object space */
  183. void
  184. bumpLightPos(GLfloat *x, GLfloat *y, GLfloat *z)
  185. {
  186.     GLdouble mvmatrix[16];
  187.     GLint viewport[4];
  188.     static GLdouble projmatrix[16]; /* to make them zero */
  189.     GLfloat light[4];
  190.     GLdouble Ex, Ey, Ez;
  191.     GLdouble Ox, Oy, Oz;
  193.     CHECK_ERROR("bumpLightPos");
  194.     glGetLightfv(GL_LIGHT0, GL_POSITION, light);
  195.     Ex = light[X]; Ey = light[Y]; Ez = (light[Z] + 1)/2.;
  197.     CHECK_ERROR("bumpLightPos");
  198.     glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
  199.     
  200.     /* identity projection matrix */
  201.     projmatrix[0] = projmatrix[5] = projmatrix[10] = projmatrix[15] = 1.;
  203.     /* identity viewport */
  204.     viewport[0] = viewport[1] = -1; 
  205.     viewport[2] = viewport[3] =  2;
  207.     /*
  208.     ** use the inverse of the modelview matrix to
  209.     ** transform light from eye to object space
  210.     */
  211.     gluUnProject(Ex, Ey, Ez, mvmatrix, projmatrix, viewport, &Ox, &Oy, &Oz);
  213.     *x = Ox; *y = Oy; *z = Oz;
  214.     CHECK_ERROR("bumpLightPos");
  215. }
  218. /* compute binormal from current normal and tangent vector, using cross prod */
  219. /* assuming normal and tangent are already normalized */
  220. void
  221. biNormal(GLfloat *x, GLfloat *y, GLfloat *z)
  222. {
  223.     /* normal <cross> tangent = binormal */
  225.     *x = curNormal[Y] * curTangent[Z] - curNormal[Z] * curTangent[Y];
  226.     *y = curNormal[Z] * curTangent[X] - curNormal[X] * curTangent[Z];
  227.     *z = curNormal[X] * curTangent[Y] - curNormal[Y] * curTangent[X];
  228. }
  230. void
  231. Normalize2f(GLfloat *x, GLfloat *y)
  232. {
  233.     GLfloat len;
  234.     len = *x * *x + *y * *y;
  235.     len = sqrtf(len);
  237.     *x /= len;
  238.     *y /= len;
  239. }
  241. /* rotate point by supplied rotatation matrix */
  242. void
  243. Rotate(GLfloat *rot, GLfloat *light, GLfloat *s, GLfloat *t)
  244. {
  245.     GLfloat r;
  246.     r = rot[3] * light[X] + rot[4] * light[Y] + rot[5] * light[Z];
  247.     if(r < 0.f) /* light below surface */
  248.     {
  249. *s = 0.f;
  250. *t = 0.f;
  251. return;
  252.     }
  253.     *s = rot[0] * light[X] + rot[1] * light[Y] + rot[2] * light[Z];
  254.     *t = rot[6] * light[X] + rot[7] * light[Y] + rot[8] * light[Z];
  255.     Normalize2f(s, t);
  256. }
  259. /* find out where the current normal is */
  260. void
  261. bumpNormal3f(GLfloat x, GLfloat y, GLfloat z)
  262. {
  263.     curNormal[X] = x;
  264.     curNormal[Y] = y;
  265.     curNormal[Z] = z;
  266.     glNormal3f(x, y, z);
  267. }
  269. void
  270. bumpTangent3f(GLfloat x, GLfloat y, GLfloat z)
  271. {
  272.     curTangent[X] = x;
  273.     curTangent[Y] = y;
  274.     curTangent[Z] = z;
  275. }
  277. /* save the texture coordinate call; will shift to do bumpmapping */
  278. void
  279. bumpTexCoord2f(GLfloat s, GLfloat t)
  280. {
  281.     curTex[S] = s;
  282.     curTex[T] = t;
  283. }
  285. /*
  286. ** use current tangent vector to compute texture coordinate shift
  287. ** then apply it by passing through vertex call
  288. */
  289. void
  290. bumpVertex3f(GLfloat x, GLfloat y, GLfloat z)
  291. {
  293.     GLfloat Light[3]; /* light in tangent space */
  294.     GLfloat length;
  295.     GLfloat s, t; /* tranformed light, used to shift */
  296.     GLfloat rot[9]; /* rotation matrix (just enought for x and y */
  297.     GLfloat Bx, By, Bz; /* binormal axis */
  299.     if(bumpEnabled)
  300.     {
  302. /* get current light position */
  303. Light[X] = curLight[X];
  304. Light[Y] = curLight[Y];
  305. Light[Z] = curLight[Z];
  307. /* find light vector from vertex */
  308. Light[X] -= x; Light[Y] -= y; Light[Z] -= z;
  310. length = 1.f/ sqrtf(Light[X] * Light[X] + 
  311.     Light[Y] * Light[Y] +
  312.     Light[Z] * Light[Z]);
  314. Light[X] *= length; Light[Y] *= length; Light[Z] *= length;
  316. /* create rotation matrix (rotate into tangent space) */
  317.     
  318. biNormal(&Bx, &By, &Bz); /* find binormal axis */
  320. rot[0] = curTangent[X]; rot[1] = curTangent[Y]; rot[2] = curTangent[Z];
  321. rot[3] = curNormal[X]; rot[4] = curNormal[Y]; rot[5] = curNormal[Z];
  322. rot[6] = Bx; rot[7] = By; rot[8] = Bz;
  324. Rotate(rot, Light, &s, &t);
  326. /* shift coordinates in opposite direction of desired texture shift */
  327. glTexCoord2f(curTex[S] - s/texture_width, curTex[T] - t/texture_height);
  328.     }
  329.     else
  330. glTexCoord2f(curTex[S], curTex[T]);
  332.     glVertex3f(x, y, z); /* pass on the vertex call */
  333. }
  335. void
  336. bumpBegin(GLenum prim)
  337. {
  338.     if(bumpEnabled)
  339.     {
  340. /* get light position; map back from eye to object space */
  341. bumpLightPos(&curLight[X], &curLight[Y], &curLight[Z]);
  342.     }
  343.     glBegin(prim);
  344. }
  346. void draw(void)
  347. {
  348.     int i, j;
  349.     GLfloat Vx, Vy, Vz; /* vertex */
  350.     GLfloat Tx, Ty, Tz; /* tangent */
  351.     GLfloat Nx, Ny, Nz; /* normal */
  352.     GLfloat c, s; /* cos, sin */
  354.     CHECK_ERROR("start of draw()");
  357.     Ny = 0.f;
  358.     Ty = 0.f;
  359.     /* v(i, j) v(i+1, j), v(i+1, j+1), v(i, j+1) */
  360.     bumpBegin(GL_QUADS);
  361.     for(j = 0; j < steps_y; j ++)
  362. for(i = 0; i < steps_xz; i++) /* 180 -> 0 degrees */
  363. {
  364.     /* v(i, j) */
  365.     c = cosf(M_PI * (1.f - (GLfloat)i/(steps_xz - 1)));
  366.     s = sinf(M_PI * (1.f - (GLfloat)i/(steps_xz - 1)));
  367.     Vx = 100 * c;
  368.     Vy = j * 200.f/steps_y - 100.f;
  369.     Vz = 100 * s - 100.f;
  370.     Nx = c;
  371.     Nz = s;
  372.     Tx = s;
  373.     Ty = -c;
  374. Tz = 0;
  375.     bumpNormal3f(Nx, Ny, Nz);
  376.     bumpTangent3f(Tx, Ty, Tz);
  377.     bumpTexCoord2f(i/(GLfloat)steps_xz, j/(GLfloat)steps_y);
  378.     bumpVertex3f(Vx, Vy, Vz);
  380.     /* v(i+1, j) */
  381.     c = cosf(M_PI * (1.f - (GLfloat)(i + 1)/(steps_xz - 1)));
  382.     s = sinf(M_PI * (1.f - (GLfloat)(i + 1)/(steps_xz - 1)));
  383.     Vx = 100 * c;
  384.     Vz = 100 * s - 100.f;
  385.     Nx = c;
  386.     Nz = s;
  387.     Tx = s;
  388.     Ty = -c;
  389.     bumpNormal3f(Nx, Ny, Nz);
  390.     bumpTangent3f(Tx, Ty, Tz);
  391.     bumpTexCoord2f((i + 1)/(GLfloat)steps_xz, j/(GLfloat)steps_y);
  392.     bumpVertex3f(Vx, Vy, Vz);
  394.     /* v(i+1, j+1) */
  395.     Vy = (j + 1) * 200.f/steps_y - 100.f;
  396.     bumpNormal3f(Nx, Ny, Nz);
  397.     bumpTangent3f(Tx, Ty, Tz);
  398.     bumpTexCoord2f((i + 1)/(GLfloat)steps_xz, (j + 1)/(GLfloat)steps_y);
  399.     bumpVertex3f(Vx, Vy, Vz);
  401.     /* v(i, j+1) */
  402.     c = cosf(M_PI * (1.f - (GLfloat)i/(steps_xz - 1)));
  403.     s = sinf(M_PI * (1.f - (GLfloat)i/(steps_xz - 1)));
  404.     Vx = 100 * c;
  405.     Vz = 100 * s - 100.f;
  406.     Nx = c;
  407.     Nz = s;
  408.     Tx = s;
  409.     Ty = -c;
  410.     bumpNormal3f(Nx, Ny, Nz);
  411.     bumpTangent3f(Tx, Ty, Tz);
  412.     bumpTexCoord2f(i/(GLfloat)steps_xz, (j + 1)/(GLfloat)steps_y);
  413.     bumpVertex3f(Vx, Vy, Vz);
  414. }
  415.     glEnd();
  417.     CHECK_ERROR("end of draw()");
  418. }
  422. /* Called when window needs to be redrawn */
  423. void redraw_blendext(void)
  424. {
  425.     GLUquadricObj *obj;
  426.     void draw(void);
  427.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  430.     glLoadIdentity();
  432.     gluLookAt(0., 0., 650., 0., 0., 0., 0., 1., 0.);
  433.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  435.     glPushMatrix();
  436.     glTranslatef(lightpos[X], lightpos[Y], lightpos[Z]);
  437.     obj = gluNewQuadric();
  438.     gluSphere(obj, 7., 10, 10);
  439.     gluDeleteQuadric(obj);
  440.     glPopMatrix();
  442.     glRotatef(angles[X], 0.f, 1.f, 0.f);
  443.     glRotatef(angles[Y], 1.f, 0.f, 0.f);
  445.     if(textureOnly)
  446.     {
  447. glEnable(GL_TEXTURE_2D);
  448. draw();
  449. glDisable(GL_TEXTURE_2D);
  450.     }
  451.     else if(lightOnly)
  452.     {
  453. /* draw "z" diffuse component */
  454. glEnable(GL_LIGHTING);
  455. glEnable(GL_LIGHT0);
  456. draw();
  457. glDisable(GL_LIGHTING);
  458.     }
  459.     else /* bumpmapping */
  460.     {
  462. /* find N dot L */
  464. /* draw "z" diffuse component */
  465. /* also do ambient here */
  466. if(!embossed)
  467. {
  468.     glEnable(GL_LIGHTING);
  469.     glEnable(GL_LIGHT0);
  470.     draw();
  471.     glDisable(GL_LIGHTING);
  472. }
  473. /* add in shifted values */
  474. glEnable(GL_TEXTURE_2D);
  475. glEnable(GL_BLEND);
  476. glBlendFunc(GL_ONE, GL_ONE);
  477. bumpEnable(); /* shift texture coords */
  478. draw();
  479. bumpDisable();
  481. #ifdef GL_EXT_blend_subtract
  482.         if (hasBlendSubtract) {
  483.        /* subtract unshifted */
  484.     glBlendEquationEXT(GL_FUNC_REVERSE_SUBTRACT_EXT);
  485.     draw();
  486.     glBlendEquationEXT(GL_FUNC_ADD_EXT);
  487. }
  488. #endif
  489. glDisable(GL_BLEND);
  490. glDisable(GL_TEXTURE_2D);
  492. if(color)
  493. {
  494.     /* Modulate the color texture with N dot L */
  495.     glEnable(GL_TEXTURE_2D);
  496.     glEnable(GL_BLEND);
  497.     glBlendFunc(GL_DST_COLOR, GL_ZERO);
  498.     glBindTexture(GL_TEXTURE_2D, 1); /* use color texture */
  499.     draw();
  500.     glBindTexture(GL_TEXTURE_2D, 0);
  501.     glDisable(GL_BLEND);
  502.     glDisable(GL_TEXTURE_2D);
  503. }
  505.     }
  507.     /* scale up the image */
  509.     glPixelTransferf(GL_RED_SCALE, 2.f);
  510.     glPixelTransferf(GL_GREEN_SCALE, 2.f);
  511.     glPixelTransferf(GL_BLUE_SCALE, 2.f);
  512.     glCopyPixels(0, 0, winWidth, winHeight, GL_COLOR);
  514.     CHECK_ERROR("OpenGL Error in redraw()");
  516.     if(dblbuf)
  517. glutSwapBuffers(); 
  518.     else
  519. glFlush(); 
  520. }
  523. /* Called when window needs to be redrawn */
  524. void redraw_accum(void)
  525. {
  526.     GLUquadricObj *obj;
  527.     void draw(void);
  528.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  531.     glLoadIdentity();
  533.     gluLookAt(0., 0., 650., 0., 0., 0., 0., 1., 0.);
  534.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  536.     glRotatef(angles[X], 0.f, 1.f, 0.f);
  537.     glRotatef(angles[Y], 1.f, 0.f, 0.f);
  539.     if(textureOnly)
  540.     {
  541. glEnable(GL_TEXTURE_2D);
  542. draw();
  543. glDisable(GL_TEXTURE_2D);
  544.     }
  545.     else if(lightOnly)
  546.     {
  547. /* draw "z" diffuse component */
  548. glEnable(GL_LIGHTING);
  549. glEnable(GL_LIGHT0);
  550. draw();
  551. glDisable(GL_LIGHTING);
  552.     }
  553.     else /* bumpmapping */
  554.     {
  556. CHECK_ERROR("start");
  557. /* draw "z" diffuse component */
  558. glEnable(GL_LIGHTING);
  559. glEnable(GL_LIGHT0);
  560. draw();
  561. glAccum(GL_LOAD, .5f);
  562. CHECK_ERROR("load");
  563. glDisable(GL_LIGHTING);
  565. /* draw shifted */
  566. glEnable(GL_TEXTURE_2D);
  567. bumpEnable();
  568. draw();
  569. glAccum(GL_ACCUM, .5f);
  570. bumpDisable();
  572. /* subtract unshifted */
  573. draw();
  574. glAccum(GL_ACCUM, -.5f);
  576. glDisable(GL_TEXTURE_2D);
  577. glAccum(GL_RETURN, 2.f);
  579. if(color)
  580. {
  581.     /* Modulate the color texture with N dot L */
  582.     glEnable(GL_TEXTURE_2D);
  583.     glEnable(GL_BLEND);
  584.     glBlendFunc(GL_DST_COLOR, GL_ZERO);
  585.     glBindTexture(GL_TEXTURE_2D, 1); /* use color texture */
  586.     draw();
  587.     glBindTexture(GL_TEXTURE_2D, 0);
  588.     glDisable(GL_BLEND);
  589.     glDisable(GL_TEXTURE_2D);
  590. }
  592.     }
  594.     
  596.     CHECK_ERROR("OpenGL Error in redraw()");
  598.     glPushMatrix();
  599.     glLoadIdentity();
  600.     gluLookAt(0., 0., 650., 0., 0., 0., 0., 1., 0.);
  601.     glTranslatef(lightpos[X], lightpos[Y], lightpos[Z]);
  602.     obj = gluNewQuadric();
  603.     gluSphere(obj, 7., 10, 10);
  604.     gluDeleteQuadric(obj);
  605.     glPopMatrix();
  608.     if(dblbuf)
  609. glutSwapBuffers(); 
  610.     else
  611. glFlush(); 
  612. }
  614. /* ARGSUSED1 */
  615. void key(unsigned char key, int x, int y)
  616. {
  617.     switch(key)
  618.     {
  619.     case 't':
  620. if(textureOnly)
  621.     textureOnly = FALSE;
  622. else
  623.     textureOnly = TRUE;
  624. glutPostRedisplay();
  625. break;
  626.     case 'l':
  627. if(lightOnly)
  628.     lightOnly = FALSE;
  629. else
  630.     lightOnly = TRUE;
  631. glutPostRedisplay();
  632. break;
  633.     case 'e':
  634. if(embossed)
  635.     embossed = FALSE;
  636. else
  637.     embossed = TRUE;
  638. glutPostRedisplay();
  639. break;
  640.     case 'B': /* make bumps taller */
  641. bumpscale += .01f;
  642. printf("bump map scale = %.2fn", bumpscale);
  643. glPixelTransferf(GL_RED_SCALE, bumpscale);
  644. glPixelTransferf(GL_GREEN_SCALE, bumpscale);
  645. glPixelTransferf(GL_BLUE_SCALE, bumpscale);
  648. glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
  649.      texture_width, texture_height, 0, GL_RGBA,
  650.      GL_UNSIGNED_BYTE, bumptex);
  651. glutPostRedisplay();
  652. break;
  653.     case 'b': /* make bumps flatter */
  654. bumpscale -= .01f;
  655. if(bumpscale < 0.f)
  656.     bumpscale = 0.f;
  657. printf("bump map scale = %.2fn", bumpscale);
  658. glPixelTransferf(GL_RED_SCALE, bumpscale);
  659. glPixelTransferf(GL_GREEN_SCALE, bumpscale);
  660. glPixelTransferf(GL_BLUE_SCALE, bumpscale);
  663. glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
  664.      texture_width, texture_height, 0, GL_RGBA,
  665.      GL_UNSIGNED_BYTE, bumptex);
  666. glutPostRedisplay();
  667. break;
  668.     case 'c':
  669. if(color == TRUE)
  670.     color = FALSE;
  671. else
  672.     color = TRUE;
  673. glutPostRedisplay();
  674. break;
  675.     case 'w':
  676. if(wire == TRUE)
  677. {
  678.     glPolygonMode(GL_FRONT, GL_FILL);
  679.     wire = FALSE;
  680. }
  681. else
  682. {
  683.     glPolygonMode(GL_FRONT, GL_LINE);
  684.     wire = TRUE;
  685. }
  686. glutPostRedisplay();
  687. break;
  688.     case 'x':
  689. steps_xz -= 2;
  690. if(steps_xz < 1)
  691.     steps_xz = 1;
  692. glutPostRedisplay();
  693. break;
  694.     case 'X':
  695. steps_xz += 2;
  696. glutPostRedisplay();
  697. break;
  698.     case 'y':
  699. steps_y -= 2;
  700. if(steps_y < 1)
  701.     steps_y = 1;
  702. glutPostRedisplay();
  703. break;
  704.     case 'Y':
  705. steps_y += 2;
  706. glutPostRedisplay();
  707. break;
  708.     case '33':
  709. exit(0);
  710. break;
  711.     case 'h':
  712.     case '?':
  713.     default:
  714. fprintf(stderr, 
  715. "Keyboard commands:n"
  716. "t-texture onlyn"
  717. "l-light onlyn"
  718. "c-color texturen"
  719. "e-embossed (horizontal part)n"
  720. "w-toggle wireframen"
  721. "B-increase bumps b-decrease bumpsn");
  722. break;
  723.     }
  725. }
  729. main(int argc, char *argv[])
  730. {
  731.     unsigned *tex;
  732.     GLfloat lightpos[4];
  733.     GLfloat diffuse[4];
  734.     GLboolean valid;
  735.     int texcomps, texwid, texht;
  736.     const char *version;
  737.     char varray[32];
  739.     glutInit(&argc, argv);
  740.     glutInitWindowSize(winWidth, winHeight);
  741.     if(argc > 1)
  742.     {
  743. char *args = argv[1];
  744. int done = FALSE;
  745. while(!done)
  746. {
  747.     switch(*args)
  748.     {
  749.     case 's': /* single buffer */
  750. printf("Single Bufferedn");
  751. dblbuf = FALSE;
  752. break;
  753.     case 'a': /* use accumulation buffer */
  754. printf("Use accumulation buffern");
  755. accum = TRUE;
  756. break;
  757.     case '-': /* do nothing */
  758. break;
  759.     case 0:
  760. done = TRUE;
  761. break;
  762.     }
  763.     args++;
  764. }
  765.     }
  766.     if(dblbuf)
  767. if(accum)
  768.     glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH|GLUT_ACCUM);
  769.         else
  770.     glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
  771.     else
  772. if(accum)
  773.     glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_ACCUM);
  774.         else
  775.     glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH);
  777.     (void)glutCreateWindow("bump mapping example program");
  778.     if(accum)
  779. glutDisplayFunc(redraw_accum);
  780.     else
  781. glutDisplayFunc(redraw_blendext);
  783.     glutKeyboardFunc(key);
  784.     glutMouseFunc(mouse);
  785.     glutMotionFunc(motion);
  786.     glutReshapeFunc(reshape);
  789.     
  790.     version = (char *) glGetString(GL_VERSION);
  791.     strncpy(varray, version, strcspn(version, " "));
  792.     printf("%sn", version);
  793.     if(atof(varray) > 1.f)
  794. bindtex = TRUE;
  795.     else
  796. bindtex = FALSE;
  798.     glRasterPos3i(-1, -1, -1);
  799.     glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &valid);
  800.     if(!valid)
  801. printf("invalid raster position!n");
  802.     /* draw a perspective scene */
  803.     glMatrixMode(GL_PROJECTION);
  804.     glFrustum(-150., 150., -150., 150., 500., 800.);
  805.     glMatrixMode(GL_MODELVIEW);
  807.     /* turn on features */
  808.     glEnable(GL_DEPTH_TEST);
  809.     glDepthFunc(GL_LEQUAL);
  811.     /* remove back faces to speed things up */
  812.     glCullFace(GL_BACK);
  815.     diffuse[R] = diffuse[G] = diffuse[B] = .4f;
  816.     diffuse[A] = 1.f;
  817.     glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
  818.     bumptex = read_texture("../data/opengl.bw", &texture_width, 
  819.        &texture_height, &texcomps);
  820.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  822.     if(!accum)
  823.     {
  824. /* scale to match maximum z (default Kd = .8, default Ld = 1. */
  825. /* divide by 2 to stay in range of 0 to 1 */
  826. glPixelTransferf(GL_RED_SCALE, bumpscale);
  827. glPixelTransferf(GL_GREEN_SCALE, bumpscale);
  828. glPixelTransferf(GL_BLUE_SCALE, bumpscale);
  829.     }
  831.     glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
  832.  texture_width, texture_height, 0, GL_RGBA,
  833.  GL_UNSIGNED_BYTE, bumptex);
  835.     tex = read_texture("../data/plank.rgb", &texwid, &texht, &texcomps);
  837.     glBindTexture(GL_TEXTURE_2D, 1); /* for color */
  838.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  840.     glPixelTransferf(GL_RED_SCALE, 1.f);
  841.     glPixelTransferf(GL_GREEN_SCALE, 1.f);
  842.     glPixelTransferf(GL_BLUE_SCALE, 1.f);
  844.     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
  845.  texwid, texht, 0, GL_RGBA,
  846.  GL_UNSIGNED_BYTE, tex);
  848.     glBindTexture(GL_TEXTURE_2D, 0);
  850.     free(tex);
  852.     lightpos[X] = lightpos[Y] = 0.f;
  853.     lightpos[Z] = -90.f;
  854.     lightpos[W] = 1.f;
  855.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  856.     glDisable(GL_DITHER);
  858.     CHECK_ERROR("end of main");
  860. #ifdef GL_EXT_blend_subtract
  861.     if(!glutExtensionSupported("GL_EXT_blend_subtract")) {
  862.       fprintf(stderr,
  863.         "bump: requires OpenGL blend subtract extension to operate correctly.n");
  864.       hasBlendSubtract = 0;
  865.     } else {
  866.       hasBlendSubtract = 1;
  867. #if defined(_WIN32) && !defined(MESA)
  868.       glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC) wglGetProcAddress("glBlendEquationEXT");
  869.       if (glBlendEquationEXT == NULL) {
  870.         hasBlendSubtract = 0;
  871.       }
  872. #endif
  873.     }
  874. #endif
  876.     key('?', 0, 0); /* startup message */
  877.     glutMainLoop();
  878.     return(0);
  879. }