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

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

GIS编程

开发平台：

Visual C++

decal.c：源码内容
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <GL/glut.h>
  6. /* Some <math.h> files do not define M_PI... */
  7. #ifndef M_PI
  8. #define M_PI 3.14159265358979323846
  9. #endif
  11. GLUquadricObj *quadric;
  12. GLfloat  black[] = {0, 0, 0, 1};
  13. GLfloat  white[] = {1, 1, 1, 1};
  16. int  winWidth, winHeight;
  17. GLfloat  *depthSave = NULL;
  18. GLubyte  *stencilSave = NULL;
  19. GLubyte  *colorSave = NULL;
  22. void resizeBuffers(void)
  23. {
  24.     colorSave = realloc(colorSave, winWidth * winHeight * 4 * sizeof(GLubyte));
  25.     depthSave = realloc(depthSave, winWidth * winHeight * 4 * sizeof(GLfloat));
  26.     stencilSave = (GLubyte *)depthSave;
  27. }
  30. void pushOrthoView(float left, float right, float bottom, float top,
  31.     float znear, float zfar)
  32. {
  33.     glPushMatrix();
  34.     glLoadIdentity();
  35.     glMatrixMode(GL_PROJECTION);
  36.     glPushMatrix();
  37.     glLoadIdentity();
  38.     glOrtho(left, right, bottom, top, znear, zfar);
  39. }
  42. void popView(void)
  43. {
  44.     glPopMatrix();
  45.     glMatrixMode(GL_MODELVIEW);
  46.     glPopMatrix();
  47. }
  50. void copyDepthToColor(GLenum whichColorBuffer)
  51. {
  52.     int x, y;
  53.     GLfloat max, min;
  54.     GLint previousColorBuffer;
  56.     glReadPixels(0, 0, winWidth, winHeight, GL_DEPTH_COMPONENT, GL_FLOAT,
  57.         depthSave);
  59.     /* I'm sure this could be done much better with OpenGL */
  60.     max = 0;
  61.     min = 1;
  62.     for(y = 0; y < winHeight; y++)
  63. for(x = 0; x < winWidth; x++) {
  64.     if(depthSave[winWidth * y + x] < min)
  65. min = depthSave[winWidth * y + x];
  66.     if(depthSave[winWidth * y + x] > max && depthSave[winWidth * y + x] < .999)
  67. max = depthSave[winWidth * y + x];
  68. }
  70.     for(y = 0; y < winHeight; y++)
  71. for(x = 0; x < winWidth; x++) {
  72.     if(depthSave[winWidth * y + x] <= max)
  73. depthSave[winWidth * y + x] = 1 -  (depthSave[winWidth * y + x] - min) / (max - min);
  74.     else
  75. depthSave[winWidth * y + x] = 0;
  76. }
  78.     pushOrthoView(0, 1, 0, 1, 0, 1);
  79.     glRasterPos3f(0, 0, -.5);
  80.     glDisable(GL_DEPTH_TEST);
  81.     glDisable(GL_STENCIL_TEST);
  82.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  83.     glGetIntegerv(GL_DRAW_BUFFER, &previousColorBuffer);
  84.     glDrawBuffer(whichColorBuffer);
  85.     glDrawPixels(winWidth, winHeight, GL_LUMINANCE , GL_FLOAT, depthSave);
  86.     glDrawBuffer(previousColorBuffer);
  87.     glEnable(GL_DEPTH_TEST);
  88.     popView();
  89. }
  92. unsigned char colors[][3] =
  93. {
  94.     {255, 0, 0}, /* red */
  95.     {255, 218, 0}, /* yellow */
  96.     {72, 255, 0}, /* yellowish green */
  97.     {0, 255, 145}, /* bluish cyan */
  98.     {0, 145, 255}, /* cyanish blue */
  99.     {72, 0, 255}, /* purplish blue */
  100.     {255, 0, 218}, /* reddish purple */
  101. };
  104. void copyStencilToColor(GLenum whichColorBuffer)
  105. {
  106.     int x, y;
  107.     GLint previousColorBuffer;
  109.     glReadPixels(0, 0, winWidth, winHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
  110.         stencilSave);
  112.     /* I'm sure this could be done much better with OpenGL */
  113.     for(y = 0; y < winHeight; y++)
  114. for(x = 0; x < winWidth; x++) {
  115.     int stencilValue;
  116.     
  117.     stencilValue = stencilSave[winWidth * y + x];
  119.     colorSave[(winWidth * y + x) * 3 + 0] = colors[stencilValue % 7][0];
  120.     colorSave[(winWidth * y + x) * 3 + 1] = colors[stencilValue % 7][1];
  121.     colorSave[(winWidth * y + x) * 3 + 2] = colors[stencilValue % 7][2];
  122. }
  124.     pushOrthoView(0, 1, 0, 1, 0, 1);
  125.     glRasterPos3f(0, 0, -.5);
  126.     glDisable(GL_DEPTH_TEST);
  127.     glDisable(GL_STENCIL_TEST);
  128.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  129.     glGetIntegerv(GL_DRAW_BUFFER, &previousColorBuffer);
  130.     glDrawBuffer(whichColorBuffer);
  131.     glDrawPixels(winWidth, winHeight, GL_RGB, GL_UNSIGNED_BYTE, colorSave);
  132.     glDrawBuffer(previousColorBuffer);
  133.     glEnable(GL_DEPTH_TEST);
  134.     popView();
  135. }
  138. int useStencil = 0;
  139. int stage = 6;
  140. typedef enum {COLOR, DEPTH, STENCIL} DataChoice;
  141. DataChoice dataChoice = COLOR;
  143. void init(void)
  144. {
  145.     glEnable(GL_DEPTH_TEST);
  146.     glEnable(GL_CULL_FACE);
  147.     glCullFace(GL_BACK);
  149.     quadric = gluNewQuadric();
  151.     glMatrixMode(GL_PROJECTION);
  152.     glFrustum(-.33, .33, -.33, .33, .5, 40);
  154.     glMatrixMode(GL_MODELVIEW);
  155.     gluLookAt(-4, 10, 6, 0, 0, 0, 0, 1, 0);
  157.     glEnable(GL_LIGHTING);
  158.     glEnable(GL_LIGHT0);
  160.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  162.     glEnable(GL_NORMALIZE);
  164.     /*
  165.      * only need this to clear stencil and only need to clear stencil
  166.      * when you're looking at it; the algorithm works without it.
  167.      */
  168.     glClearStencil(5);
  169. }
  172. void setupLight(void)
  173. {
  174.     static GLfloat  lightpos[] = {0, 1, 0, 0};
  176.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  177. }
  180. void setupNormalDrawingState(void)
  181. {
  182.     glDisable(GL_STENCIL_TEST);
  183.     glEnable(GL_DEPTH_TEST);
  184.     glDepthMask(1);
  185. }
  187. void setupBasePolygonState(int maxDecal)
  188. {
  189.     glEnable(GL_DEPTH_TEST);
  190.     if(useStencil) {
  191. glEnable(GL_STENCIL_TEST);
  192. glStencilFunc(GL_ALWAYS, maxDecal + 1, 0xff);
  193. glStencilOp(GL_KEEP, GL_REPLACE, GL_ZERO);
  194.     }
  195. }
  198. void setupDecalState(int decalNum)
  199. {
  200.     if(useStencil) {
  201. glDisable(GL_DEPTH_TEST);
  202. glDepthMask(0);
  203. glEnable(GL_STENCIL_TEST);
  204. glStencilFunc(GL_GREATER, decalNum, 0xff);
  205. glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  206.     }
  207. }
  210. void drawAirplane(void)
  211. {
  212.     GLfloat airplaneColor[4] = {.75, .75, .75, 1};
  214.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, airplaneColor);
  216.     glDisable(GL_CULL_FACE);
  218.     glPushMatrix();
  219.     glTranslatef(0, 0, -2.5);
  221.     gluCylinder(quadric, .5, .5, 5, 10, 10);
  223.     glPushMatrix();
  224.     glTranslatef(0, 0, 5);
  225.     gluCylinder(quadric, .5, 0, 1, 10, 10);
  226.     glPopMatrix();
  228.     glPushMatrix();
  229.     glTranslatef(0, 0, 3);
  230.     glScalef(3, .1, 1);
  231.     gluSphere(quadric, 1, 10, 10);
  232.     glPopMatrix();
  234.     glPushMatrix();
  235.     glTranslatef(0, 0, .5);
  236.     glScalef(2, .1, .5);
  237.     gluSphere(quadric, 1, 10, 10);
  238.     glPopMatrix();
  240.     glEnable(GL_CULL_FACE);
  242.     glBegin(GL_TRIANGLES);
  243.     glNormal3f(1, 0, 0);
  244.     glVertex3f(0, 1.5, 0);
  245.     glVertex3f(0, .5, 1);
  246.     glVertex3f(0, .5, 0);
  247.     glNormal3f(-1, 0, 0);
  248.     glVertex3f(0, 1.5, 0);
  249.     glVertex3f(0, .5, 0);
  250.     glVertex3f(0, .5, 1);
  251.     glEnd();
  253.     glDisable(GL_CULL_FACE);
  255.     glRotatef(180, 0, 1, 0);
  256.     gluDisk(quadric, 0, .5, 10, 10);
  258.     glPopMatrix();
  260.     glEnable(GL_CULL_FACE);
  261. }
  264. void drawGround(void)
  265. {
  266.     GLfloat groundColor[4] = {.647, .165, .165, 1};
  268.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, groundColor);
  270.     glBegin(GL_QUADS);
  271.     glNormal3i(0, 1, 0);
  272.     glVertex3f(10, 0, 10);
  273.     glVertex3f(10, 0, -10);
  274.     glVertex3f(-10, 0, -10);
  275.     glVertex3f(-10, 0, 10);
  276.     glEnd();
  277. }
  280. void drawAsphalt(void)
  281. {
  282.     GLfloat asphaltColor[4] = {.25, .25, .25, 1};
  284.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, asphaltColor);
  286.     glBegin(GL_QUADS);
  287.     glNormal3i(0, 1, 0);
  288.     glVertex3f(5, 0, 9.5);
  289.     glVertex3f(5, 0, -9.5);
  290.     glVertex3f(-5, 0, -9.5);
  291.     glVertex3f(-5, 0, 9.5);
  292.     glEnd();
  293. }
  296. int numStripes = 5;
  297. float stripeGap = .66;
  300. void drawStripes(void)
  301. {
  302.     GLfloat stripeColor[4] = {1, 1, 0, 1};
  303.     int i;
  304.     float stripeLength;
  306.     stripeLength = (16 - stripeGap * (numStripes - 1)) / numStripes;
  308.     glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, stripeColor);
  310.     glBegin(GL_QUADS);
  312.     glNormal3i(0, 1, 0);
  314.     glVertex3f(4.5, 0, 8.5);
  315.     glVertex3f(4.5, 0, -8.5);
  316.     glVertex3f(3.5, 0, -8.5);
  317.     glVertex3f(3.5, 0, 8.5);
  319.     glVertex3f(-3.5, 0, 8.5);
  320.     glVertex3f(-3.5, 0, -8.5);
  321.     glVertex3f(-4.5, 0, -8.5);
  322.     glVertex3f(-4.5, 0, 8.5);
  324.     for(i = 0; i < numStripes; i++) {
  325.         glVertex3f(.5, 0, 8 - i * (stripeLength + stripeGap));
  326.         glVertex3f(.5, 0, 8 - i * (stripeLength + stripeGap) - stripeLength);
  327.         glVertex3f(-.5, 0, 8 - i * (stripeLength + stripeGap) - stripeLength);
  328.         glVertex3f(-.5, 0, 8 - i * (stripeLength + stripeGap));
  329.     }
  330.     glEnd();
  331. }
  334. void redraw(void)
  335. {
  336.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  337.     
  338.     /* Only need this if you care to look at the stencil buffer */
  339.     if(dataChoice == STENCIL)
  340. glClear(GL_STENCIL_BUFFER_BIT);
  342.     glPushMatrix();
  343.     glScalef(.5, .5, .5);
  345.     if(stage == 1)
  346.        goto doneWithFrame;
  348.     setupLight();
  350.     setupNormalDrawingState();
  351.     glPushMatrix();
  352.     glTranslatef(0, 1, 4);
  353.     glRotatef(135, 0, 1, 0);
  354.     drawAirplane();
  355.     glPopMatrix();
  357.     if(stage == 2)
  358.        goto doneWithFrame;
  360.     setupBasePolygonState(3); /* 2 decals */
  361.     drawGround();
  363.     if(stage == 3)
  364.        goto doneWithFrame;
  366.     setupDecalState(1); /* decal # 1 = the runway asphalt */
  367.     drawAsphalt();
  369.     if(stage == 4)
  370.        goto doneWithFrame;
  372.     setupDecalState(2); /* decal # 2 = yellow paint on the runway */
  373.     drawStripes();
  375.     if(stage == 5)
  376.        goto doneWithFrame;
  378.     setupDecalState(3); /* decal # 3 = the plane's shadow */
  379.     glDisable(GL_LIGHTING);
  380.     glEnable(GL_BLEND);
  381.     glPushMatrix();
  382.     glColor4f(0, 0, 0, .5);
  383.     glTranslatef(0, 0, 4);
  384.     glRotatef(135, 0, 1, 0);
  385.     glScalef(1, 0, 1);
  386.     drawAirplane();
  387.     glPopMatrix();
  388.     glDisable(GL_BLEND);
  389.     glEnable(GL_LIGHTING);
  391. doneWithFrame:
  393.     setupNormalDrawingState();
  395.     glPopMatrix();
  397.     switch(dataChoice) {
  398.         case COLOR:
  399.     break; /* color already in back buffer */
  401. case STENCIL:
  402.     copyStencilToColor(GL_BACK);
  403.     break;
  405. case DEPTH:
  406.     copyDepthToColor(GL_BACK);
  407.     break;
  408.     }
  410.     glutSwapBuffers();
  411. }
  414. void reshape(int width, int height)
  415. {
  416.     glViewport(0, 0, width, height);
  417.     winWidth = width;
  418.     winHeight = height;
  419.     resizeBuffers();
  420.     glutPostRedisplay();
  421. }
  424. static int ox, oy;
  425. static int mode;
  428. /* ARGSUSED */
  429. void button(int b, int state, int x, int y)
  430. {
  431.     ox = x;
  432.     oy = y;
  433.     mode = b;
  434. }
  437. void motion(int x, int y)
  438. {
  439.     static float ang = 0;
  440.     static float height = 10;
  441.     float eyex, eyez;
  443.     if(mode == GLUT_LEFT_BUTTON)
  444.     {
  445.         ang += (x - ox) / 512.0 * M_PI;
  446.         height += (y - oy) / 512.0 * 10;
  447. eyex = cos(ang) * 7;
  448. eyez = sin(ang) * 7;
  449. glLoadIdentity();
  450. gluLookAt(eyex, height, eyez, 0, 0, 0, 0, 1, 0);
  451.         glutPostRedisplay();
  452. ox = x;
  453. oy = y;
  454.     }
  455. }
  458. void changeData(int data)
  459. {
  460.     char *s;
  462.     dataChoice = data;
  463.     glutPostRedisplay();
  465.     switch(data) {
  466.         case COLOR:
  467.     s = "color";
  468.     break;
  470.         case STENCIL:
  471.     s = "stencil";
  472.     break;
  474.         case DEPTH:
  475.     s = "depth";
  476.     break;
  477.     }
  478.     printf("Now displaying %s datan", s);
  479. }
  482. void changeStage(int data)
  483. {
  484.     char *s;
  486.     stage = data;
  487.     glutPostRedisplay();
  488.     switch(data) {
  489.         case 1:
  490.     s = "clearing";
  491.     break;
  493.         case 2:
  494.     s = "drawing airplane";
  495.     break;
  497.         case 3:
  498.     s = "drawing ground";
  499.     break;
  501.         case 4:
  502.     s = "drawing asphalt";
  503.     break;
  505.         case 5:
  506.     s = "drawing paint";
  507.     break;
  509.         case 6:
  510.     s = "drawing shadow";
  511.     break;
  512.     }
  513.     printf("Now displaying frame after %sn", s);
  514. }
  517. int mainMenu;
  519. void stencilDecalEnable(int enabled)
  520. {
  521.     glutSetMenu(mainMenu);
  522.     if(enabled){
  523. glutChangeToMenuEntry(1, "Turn off stencil decal", 0);
  524. printf("Stencil decaling turned onn");
  525. glutPostRedisplay();
  526.     } else {
  527. glutChangeToMenuEntry(1, "Turn on stencil decal", 1);
  528. printf("Stencil decaling turned offn");
  529. glutPostRedisplay();
  530.     }
  531.     useStencil = enabled;
  532. }
  535. /*
  536.  * Basically shortcuts for menu items
  537.  */
  538. /* ARGSUSED1 */
  539. void keyboard(unsigned char key, int x, int y)
  540. {
  541.     switch(key) {
  542.         case '1':
  543.         case '2':
  544.         case '3':
  545.         case '4':
  546.         case '5':
  547.         case '6':
  548.     changeStage(key - '0');
  549.     break;
  551. case 's': case 'S':
  552.     stencilDecalEnable(! useStencil);
  553.     break;
  555. case 'q': case 'Q': case '33':
  556.     exit(0);
  557.     break;
  559. default:
  560.     fprintf(stderr, "Push right mouse button for menun");
  561.     break;
  562.     }
  563. }
  566. int main(int argc, char **argv)
  567. {
  568.     int bufferMenu;
  569.     int finishMenu;
  570.     int stenSize;
  572.     glutInitWindowSize(winWidth = 512, winHeight = 512);
  573.     glutInit(&argc, argv);
  574.     glutInitDisplayString("samples stencil>=3 rgb double depth");
  575.     /* glutInitDisplayMode(GLUT_DOUBLE|GLUT_STENCIL|GLUT_DEPTH|GLUT_ALPHA); */
  576.     (void)glutCreateWindow("decaling using stencil");
  577.     glutDisplayFunc(redraw);
  578.     glutKeyboardFunc(keyboard);
  579.     glutMotionFunc(motion);
  580.     glutMouseFunc(button);
  581.     glutReshapeFunc(reshape);
  583.     resizeBuffers();
  584.     glGetIntegerv(GL_STENCIL_BITS, &stenSize);
  585.     fprintf(stderr, "(%d bits of stencil available in this visual)n", stenSize);
  587.     fprintf(stderr, "Hit 'h' for help messagen");
  589.     finishMenu = glutCreateMenu(changeStage);
  590.     glutAddMenuEntry("Clearing screen", 1);
  591.     glutAddMenuEntry("Drawing airplane", 2);
  592.     glutAddMenuEntry("Drawing ground ", 3);
  593.     glutAddMenuEntry("Drawing asphalt", 4);
  594.     glutAddMenuEntry("Drawing paint", 5);
  595.     glutAddMenuEntry("Drawing shadow", 6);
  597.     bufferMenu = glutCreateMenu(changeData);
  598.     glutAddMenuEntry("Color data", COLOR);
  599.     glutAddMenuEntry("Stencil data", STENCIL);
  600.     glutAddMenuEntry("Depth data", DEPTH);
  602.     mainMenu = glutCreateMenu(stencilDecalEnable);
  603.     glutAddMenuEntry("Turn on stencil decal", 1);
  604.     glutAddSubMenu("Visible buffer", bufferMenu);
  605.     glutAddSubMenu("Finish frame after...", finishMenu);
  606.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  607.     init();
  608.     glutMainLoop();
  610.     return 0;
  611. }