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

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

GIS编程

开发平台：

Visual C++

zcomposite.c：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <GL/glut.h>
  5. /*
  6. ** Create a single component texture map
  7. */
  8. GLfloat *make_texture(int maxs, int maxt)
  9. {
  10.     int s, t;
  11.     static GLfloat *texture;
  13.     texture = (GLfloat *)malloc(maxs * maxt * sizeof(GLfloat));
  14.     for(t = 0; t < maxt; t++) {
  15. for(s = 0; s < maxs; s++) {
  16.     texture[s + maxs * t] = ((s >> 4) & 0x1) ^ ((t >> 4) & 0x1);
  17. }
  18.     }
  19.     return texture;
  20. }
  22. GLboolean stencil = GL_TRUE;
  24. /* ARGSUSED1 */
  25. void key(unsigned char key, int x, int y)
  26. {
  27.     switch(key) {
  28.     case 't': /* toggle using stencil */
  29.       if(stencil == GL_TRUE)
  30. stencil = GL_FALSE;
  31.       else
  32. stencil = GL_TRUE;
  33.       glutPostRedisplay();
  34.       break;
  35.     case '33':
  36.       exit(0);
  37.       break;
  38.     }
  39. }
  41. enum {SPHERE = 1, CONE};
  42. enum {X, Y, Z};
  44. int startx, starty;
  45. int wid, ht;
  46. int oldwid = 0, oldht = 0;
  48. const int WINDIM = 512;
  49. const GLfloat FRUSTDIM = 110.f;
  50. const GLfloat FRUSTNEAR = 320.f;
  51. const GLfloat FRUSTFAR = 540.f;
  52. const GLfloat FRUSTDIFF = 540.f - 320.f;
  54. GLboolean drawmode = GL_FALSE;
  55. GLboolean depthmode = GL_FALSE;
  56. GLboolean rubberbandmode = GL_FALSE;
  57. GLfloat *color;
  58. GLfloat *depth;
  59. GLfloat depthbias = 0.f;
  60. GLfloat raspos[] = {0.f, 0.f, -430.f};
  63. int winWidth = 512;
  64. int winHeight = 512;
  66. GLfloat sx = 0;
  67. GLfloat sy = 0;
  70. /* Overlay Stuff */
  71. int transparent;
  72. int red;
  74. void
  75. setRasterPosXY(int x, int y)
  76. {
  77.       raspos[X] = (x - winWidth/2) * sx;
  78.       raspos[Y] = (y - winHeight/2) * sy;
  80.       glRasterPos3fv(raspos);
  82.       glutPostRedisplay();
  83. }
  85. void
  86. setRasterPosZ(int y)
  87. {
  88.       raspos[Z] = -(FRUSTNEAR + y * FRUSTDIFF/winHeight);
  90.       depthbias = (y - winHeight/2.f)/winHeight;
  92.       glRasterPos3fv(raspos);
  94.       glutPostRedisplay();
  95. }
  99. void
  100. motion(int x, int y)
  101. {
  102.   y = winHeight - y;
  103.   if(drawmode)
  104.     setRasterPosXY(x, y);
  106.   if(rubberbandmode) {
  107.     wid = x - startx;
  108.     ht = y - starty;
  109.     glutPostOverlayRedisplay();
  110.   }
  112.   if(depthmode)
  113.      setRasterPosZ(y);
  114. }
  116. /* redraw function for overlay: used to show selected region */
  117. void
  118. overlay(void)
  119. {
  120.   if(glutLayerGet(GLUT_OVERLAY_DAMAGED)) {
  121.     glClear(GL_COLOR_BUFFER_BIT);
  122.   } else {
  123.     glIndexi(transparent);
  124.     glBegin(GL_LINE_LOOP);
  125.     glVertex2i(startx, starty);
  126.     glVertex2i(startx + oldwid, starty);
  127.     glVertex2i(startx + oldwid, starty + oldht);
  128.     glVertex2i(startx, starty + oldht);
  129.     glEnd();
  130.   }
  132.   glIndexi(red);
  133.   glBegin(GL_LINE_LOOP);
  134.   glVertex2i(startx, starty);
  135.   glVertex2i(startx + wid, starty);
  136.   glVertex2i(startx + wid, starty + ht);
  137.   glVertex2i(startx, starty + ht);
  138.   glEnd();
  140.   oldwid = wid;
  141.   oldht = ht;
  143.   glFlush();
  144. }
  147. /* used to get current width and height of viewport */
  148. void
  149. reshape(int wid, int ht)
  150. {
  151.   glutUseLayer(GLUT_OVERLAY);
  152.   glMatrixMode(GL_PROJECTION);
  153.   glLoadIdentity();
  154.   gluOrtho2D(0, wid, 0, ht); /* 1 to 1 with window */
  155.   glMatrixMode(GL_MODELVIEW);
  156.   glViewport(0, 0, wid, ht);
  158.   glutUseLayer(GLUT_NORMAL);
  159.   glViewport((GLint) (-wid * .1), (GLint) (-ht * .1),
  160.     (GLsizei) (wid * 1.2), (GLsizei) (ht * 1.2));
  162.   winWidth = wid;
  163.   winHeight = ht;
  165.   sx = 2 * FRUSTDIM/(winWidth * 1.2);
  166.   sy = 2 * FRUSTDIM/(winHeight * 1.2);
  167. }
  170. void
  171. mouse(int button, int state, int x, int y)
  172. {
  173.   y = winHeight - y; /* flip y orientation */
  174.   if(state == GLUT_DOWN)
  175.     switch(button) {
  176.     case GLUT_LEFT_BUTTON: /* select an image */
  177.       startx = x;
  178.       starty = y;
  179.       wid = 0; ht = 0;
  180.       rubberbandmode = GL_TRUE;
  181.       glutShowOverlay();
  182.       break;
  183.     case GLUT_MIDDLE_BUTTON:
  184.       glutUseLayer(GLUT_NORMAL);
  185.       if(color && depth) {
  186.   drawmode = GL_TRUE;
  187.   setRasterPosXY(x, y);
  188.       }
  189.       break;
  190.     case GLUT_RIGHT_BUTTON: /* change depth */
  191.       glutUseLayer(GLUT_NORMAL);
  192.       if(color && depth) {
  193. depthmode = GL_TRUE;
  194. setRasterPosZ(y);
  195.       }
  196.       break;
  197.     }
  198.   else /* GLUT_UP */
  199.     switch(button) {
  200.     case GLUT_LEFT_BUTTON:
  201.       rubberbandmode = GL_FALSE;
  202.       glutHideOverlay();
  203.       wid = x - startx;
  204.       ht = y - starty;
  205.       if(wid < 0) {
  206. wid = -wid;
  207. startx = x;
  208.       }
  209.       if(ht < 0) {
  210. ht = -ht;
  211. starty = y;
  212.       }
  213.       color = (GLfloat *)realloc(color, wid * ht * 3 * sizeof(GLfloat));
  214.       depth = (GLfloat *)realloc(depth, wid * ht * sizeof(GLfloat));
  216.       glutUseLayer(GLUT_NORMAL);
  217.       glReadPixels(startx, starty, wid, ht, GL_RGB, GL_FLOAT, color);
  218.       glReadPixels(startx, starty, wid, ht, GL_DEPTH_COMPONENT, GL_FLOAT,
  219.    depth);
  220.       break;
  221.     case GLUT_MIDDLE_BUTTON:
  222.       drawmode = GL_FALSE;
  223.       break;
  224.     case GLUT_RIGHT_BUTTON: /* change depth */
  225.       depthmode = GL_FALSE;
  226.       break;
  227.     }
  228. }
  231. /* Called when window needs to be redrawn */
  232. void 
  233. redraw(void)
  234. {
  235.     /* material properties for objects in scene */
  236.     static GLfloat wall_mat[] = {1.f, 1.f, 1.f, 1.f};
  238.     glutUseLayer(GLUT_NORMAL);
  239.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
  241.     /*
  242.     ** Note: wall verticies are ordered so they are all front facing
  243.     ** this lets me do back face culling to speed things up.
  244.     */
  245.  
  246.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, wall_mat);
  248.     /* floor */
  249.     /* make the floor textured */
  250.     glEnable(GL_TEXTURE_2D);
  252.     /*
  253.     ** Since we want to turn texturing on for floor only, we have to
  254.     ** make floor a separate glBegin()/glEnd() sequence. You can't
  255.     ** turn texturing on and off between begin and end calls
  256.     */
  257.     glBegin(GL_QUADS);
  258.     glNormal3f(0.f, 1.f, 0.f);
  259.     glTexCoord2i(0, 0);
  260.     glVertex3f(-100.f, -100.f, -320.f);
  261.     glTexCoord2i(1, 0);
  262.     glVertex3f( 100.f, -100.f, -320.f);
  263.     glTexCoord2i(1, 1);
  264.     glVertex3f( 100.f, -100.f, -520.f);
  265.     glTexCoord2i(0, 1);
  266.     glVertex3f(-100.f, -100.f, -520.f);
  267.     glEnd();
  269.     glDisable(GL_TEXTURE_2D);
  271.     /* walls */
  273.     glBegin(GL_QUADS);
  274.     /* left wall */
  275.     glNormal3f(1.f, 0.f, 0.f);
  276.     glVertex3f(-100.f, -100.f, -320.f);
  277.     glVertex3f(-100.f, -100.f, -520.f);
  278.     glVertex3f(-100.f,  100.f, -520.f);
  279.     glVertex3f(-100.f,  100.f, -320.f);
  281.     /* right wall */
  282.     glNormal3f(-1.f, 0.f, 0.f);
  283.     glVertex3f( 100.f, -100.f, -320.f);
  284.     glVertex3f( 100.f,  100.f, -320.f);
  285.     glVertex3f( 100.f,  100.f, -520.f);
  286.     glVertex3f( 100.f, -100.f, -520.f);
  288.     /* ceiling */
  289.     glNormal3f(0.f, -1.f, 0.f);
  290.     glVertex3f(-100.f,  100.f, -320.f);
  291.     glVertex3f(-100.f,  100.f, -520.f);
  292.     glVertex3f( 100.f,  100.f, -520.f);
  293.     glVertex3f( 100.f,  100.f, -320.f);
  295.     /* back wall */
  296.     glNormal3f(0.f, 0.f, 1.f);
  297.     glVertex3f(-100.f, -100.f, -520.f);
  298.     glVertex3f( 100.f, -100.f, -520.f);
  299.     glVertex3f( 100.f,  100.f, -520.f);
  300.     glVertex3f(-100.f,  100.f, -520.f);
  301.     glEnd();
  303.     glPushMatrix();
  304.     glTranslatef(-40.f, -60.f, -400.f);
  305.     glScalef(2, 2, 2);
  306.     glCallList(SPHERE);
  307.     glPopMatrix();
  309.     glPushMatrix();
  310.     glTranslatef(50.f, -120.f, -400.f);
  311.     glScalef(2, 2, 2);
  312.     glCallList(CONE);
  313.     glPopMatrix();
  315.     if(stencil) {
  316.       glEnable(GL_STENCIL_TEST);
  317.       glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  318.       glStencilFunc(GL_ALWAYS, 1, 1);
  319.       glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  320.       glPixelTransferf(GL_DEPTH_BIAS, depthbias);
  322.       glDrawPixels(wid, ht, GL_DEPTH_COMPONENT, GL_FLOAT, depth);
  324.       glPixelTransferf(GL_DEPTH_BIAS, 0.f);
  325.       glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  326.       glStencilFunc(GL_EQUAL, 1, 1);
  327.       glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  328.       glDisable(GL_DEPTH_TEST);
  330.       glDrawPixels(wid, ht, GL_RGB, GL_FLOAT, color);
  332.       glEnable(GL_DEPTH_TEST);
  333.       glDisable(GL_STENCIL_TEST);
  334.     } else
  335.       glDrawPixels(wid, ht, GL_RGB, GL_FLOAT, color);
  337.     glutSwapBuffers();
  338. }
  341. const int TEXDIM = 256;
  342. /* Parse arguments, and set up interface between OpenGL and window system */
  343. main(int argc, char *argv[])
  344. {
  345.     GLfloat *tex;
  346.     static GLfloat lightpos[] = {50.f, 50.f, -320.f, 1.f};
  347.     static GLfloat sphere_mat[] = {1.f, .5f, 0.f, 1.f};
  348.     static GLfloat cone_mat[] = {0.f, .5f, 1.f, 1.f};
  349.     GLUquadricObj *sphere, *cone, *base;
  351.     glutInit(&argc, argv);
  352.     glutInitWindowSize(WINDIM, WINDIM);
  354.     glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE);
  355.     (void)glutCreateWindow("compositing images with depth");
  356.     glutDisplayFunc(redraw);
  357.     glutKeyboardFunc(key);
  358.     glutMouseFunc(mouse);
  359.     glutMotionFunc(motion);
  360.     glutReshapeFunc(reshape);
  362.     /* draw a perspective scene */
  363.     glMatrixMode(GL_PROJECTION);
  364.     glFrustum(-FRUSTDIM, FRUSTDIM, -FRUSTDIM, FRUSTDIM, FRUSTNEAR, FRUSTFAR); 
  365.     glMatrixMode(GL_MODELVIEW);
  367.     /* turn on features */
  368.     glEnable(GL_DEPTH_TEST);
  369.     glEnable(GL_LIGHTING);
  370.     glEnable(GL_LIGHT0);
  372.     /* place light 0 in the right place */
  373.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  375.     /* remove back faces to speed things up */
  376.     glCullFace(GL_BACK);
  378.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  380.     glNewList(SPHERE, GL_COMPILE);
  381.     /* make display lists for sphere and cone; for efficiency */
  382.     sphere = gluNewQuadric();
  383.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, sphere_mat);
  384.     gluSphere(sphere, 20.f, 20, 20);
  385.     gluDeleteQuadric(sphere);
  386.     glEndList();
  388.     glNewList(CONE, GL_COMPILE);
  389.     cone = gluNewQuadric();
  390.     base = gluNewQuadric();
  391.     glRotatef(-90.f, 1.f, 0.f, 0.f);
  392.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cone_mat);
  393.     gluQuadricOrientation(base, GLU_INSIDE);
  394.     gluDisk(base, 0., 20., 20, 1);
  395.     gluCylinder(cone, 20., 0., 60., 20, 20);
  396.     gluDeleteQuadric(cone);
  397.     gluDeleteQuadric(base);
  398.     glEndList();
  400.     /* load pattern for current 2d texture */
  401.     tex = make_texture(TEXDIM, TEXDIM);
  402.     glTexImage2D(GL_TEXTURE_2D, 0, 1, TEXDIM, TEXDIM, 0, GL_RED, GL_FLOAT, tex);
  403.     free(tex);
  405.     /* storage for saved image */
  406.     color = 0;
  407.     depth = 0;
  408.     
  409.     glReadBuffer(GL_FRONT);/* so glReadPixel() always get the right image */
  411.     glutInitDisplayMode(GLUT_SINGLE|GLUT_INDEX);
  412.     if(glutLayerGet(GLUT_OVERLAY_POSSIBLE)) {
  413.       glutEstablishOverlay();
  414.       glutHideOverlay();
  415.       transparent = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  416.       glClearIndex(transparent);
  417.       red = (transparent + 1) % glutGet(GLUT_WINDOW_COLORMAP_SIZE);
  418.       glutSetColor(red, 1.0, 0.0, 0.0);  /* Red. */
  419.       glutOverlayDisplayFunc(overlay);
  420.     }
  421. else
  422. {
  423. printf( "Overlay support unavailable - aborting.n" );
  424. return 1;
  425. }
  427.     glutMainLoop();
  429.     return 0;
  430. }