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

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

GIS编程

开发平台：

Visual C++

csg.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. #define TRUE 1
  12. #define FALSE 0
  14. /*
  15.  * #define the following symbol if you know your glClear honors the
  16.  * stencil mask.  The O2 workstation stencil clear doesn't appear
  17.  * to honor the mask, so we use a workaround.  The workaround may work
  18.  * on any other OpenGL which has this clear bug.
  19.  */
  20. #undef CLEAR_HONORS_STENCIL_MASK
  23. GLUquadricObj *quadric;
  26. int doCSG = 0;
  27. int whereToStop = -1;
  28. typedef enum {CONTINUE, STOP} progressEnum;
  29. int whichTree = 0;
  30. int showSurfaces = 1;
  31. int showOnlyCurrent = 0;
  32. int stenSize;
  33. enum {COLOR, DEPTH, STENCILVALUES, STENCILPLANES} bufferInterest = COLOR;
  36. void drawFace(void)
  37. {
  38.     glBegin(GL_QUADS);
  39.     glNormal3i(0, 0, 1);
  40.     glVertex3f(1, 1, 1);
  41.     glVertex3f(-1, 1, 1);
  42.     glVertex3f(-1, -1, 1);
  43.     glVertex3f(1, -1, 1);
  44.     glEnd();
  45. }
  48. void drawBox(void)
  49. {
  50.     glPushMatrix();
  52.     drawFace();
  54.     glRotatef(90, 1, 0, 0);
  55.     drawFace();
  57.     glRotatef(90, 1, 0, 0);
  58.     drawFace();
  60.     glRotatef(90, 1, 0, 0);
  61.     drawFace();
  63.     glPopMatrix();
  65.     glPushMatrix();
  67.     glRotatef(90, 0, 1, 0);
  68.     drawFace();
  70.     glRotatef(180, 0, 1, 0);
  71.     drawFace();
  73.     glPopMatrix();
  74. }
  77. void drawCylinder(void)
  78. {
  79.     glPushMatrix();
  81.     glTranslatef(0, 0, -.5);
  82.     gluCylinder(quadric, 1, 1, 1, 30, 5);
  84.     glRotatef(180, 0, 1, 0);
  85.     gluDisk(quadric, 0, 1, 30, 2);
  87.     glPopMatrix();
  89.     glPushMatrix();
  91.     glTranslatef(0, 0, .5);
  92.     gluDisk(quadric, 0, 1, 30, 2);
  94.     glPopMatrix();
  95. }
  98. void drawCone(void)
  99. {
  100.     glPushMatrix();
  102.     glTranslatef(0, 0, -.5);
  103.     gluCylinder(quadric, 1, 0, 1, 30, 5);
  105.     glRotatef(180, 0, 1, 0);
  106.     gluDisk(quadric, 0, 1, 30, 2);
  108.     glPopMatrix();
  109. }
  112. void drawSphere(void)
  113. {
  114.     gluSphere(quadric, 1, 30, 20);
  115. }
  118. struct transformation {
  119.     float translation[3];
  120.     float rotation[4];
  121.     float scale[3];
  122. };
  125. struct primitive {
  126.     float color[4];
  127.     void (*draw)(void);
  128.     struct transformation xform;
  129. };
  132. struct transformation globalXform = {
  133.     0, 0, 0,
  134.     1, 0, 0, 0,
  135.     1, 1, 1
  136. };
  139. struct primitive prims[20] = {
  140.     {
  141.         {.5, .5, 1},
  142. drawBox,
  143. {
  144.     -3, 0, 0,
  145.     1, 0, 0, 0,
  146.     1, 1, 1
  147. }
  148.     },
  149.     {
  150.         {1, .5, .5},
  151. drawCylinder,
  152. {
  153.     -1, 0, 0,
  154.     1, 0, 0, 0,
  155.     1, 1, 1
  156. }
  157.     },
  158.     {
  159.         {.5, 1, .5},
  160. drawCone,
  161. {
  162.     1, 0, 0,
  163.     1, 0, 0, 0,
  164.     1, 1, 1
  165. }
  166.     },
  167.     {
  168.         {1, .5, 1},
  169. drawSphere,
  170. {
  171.     3, 0, 0,
  172.     1, 0, 0, 0,
  173.     1, 1, 1
  174. }
  175.     }
  176. };
  179. int numPrims = 4;
  180. int curPrim = 0;
  183. void drawXform(struct transformation *xform, int applyScale)
  184. {
  185.     glTranslatef(xform->translation[0], xform->translation[1], xform->translation[2]);
  186.     glRotatef(xform->rotation[3] / M_PI * 180, xform->rotation[0], xform->rotation[1], xform->rotation[2]);
  187.     if(applyScale)
  188. glScalef(xform->scale[0], xform->scale[1], xform->scale[2]);
  189. }
  192. int magicTranspHack = 0;
  195. void drawPrim(int i)
  196. {
  197.     struct primitive *p = &prims[i];
  198.     struct transformation *xform = &p->xform;
  200.     if(magicTranspHack)
  201.     {
  202.         float c[4];
  203. c[0] = p->color[0];
  204. c[1] = p->color[1];
  205. c[2] = p->color[2];
  206. c[3] = .25;
  207. glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, c);
  208.     }
  209.     else
  210. glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, p->color);
  211.     glPushMatrix();
  212.     drawXform(xform, TRUE);
  213.     p->draw();
  214.     glPopMatrix();
  215. }
  218. struct product {
  219.     int targetPrim;
  220.     int frontFace;
  221.     int whichSurface;
  222.     int numTrimPrims;
  223.     int *trimmingPrims;
  224.     int *isComplemented;
  225. };
  228. int prodAtrimmingPrims1[] = {1};
  229. int prodAisComplemented1[] = {1};
  230. int prodBtrimmingPrims1[] = {0};
  231. int prodBisComplemented1[] = {0};
  234. int prodAtrimmingPrims2[] = {1};
  235. int prodAisComplemented2[] = {0};
  236. int prodBtrimmingPrims2[] = {0};
  237. int prodBisComplemented2[] = {1};
  240. int prodAtrimmingPrims3[] = {1};
  241. int prodAisComplemented3[] = {0};
  242. int prodBtrimmingPrims3[] = {0};
  243. int prodBisComplemented3[] = {0};
  246. int prodAtrimmingPrims4[] = {1, 2, 3};
  247. int prodAisComplemented4[] = {0, 1, 1};
  248. int prodBtrimmingPrims4[] = {1, 0, 2};
  249. int prodBisComplemented4[] = {0, 0, 1};
  250. int prodCtrimmingPrims4[] = {1, 0, 3};
  251. int prodCisComplemented4[] = {0, 0, 1};
  252. int prodDtrimmingPrims4[] = {0, 2, 3};
  253. int prodDisComplemented4[] = {0, 1, 1};
  256. struct product products[][4] = {
  257.     { /* A - B */
  258. {
  259.     0, 1, 0,
  260.     1,
  261.     prodAtrimmingPrims1,
  262.     prodAisComplemented1,
  263. },
  264. {
  265.     1, 0, 0,
  266.     1,
  267.     prodBtrimmingPrims1,
  268.     prodBisComplemented1,
  269. },
  270.     },
  272.     {    /* B - A */
  273. {
  274.     0, 0, 0,
  275.     1,
  276.     prodAtrimmingPrims2,
  277.     prodAisComplemented2,
  278. },
  279. {
  280.     1, 1, 0,
  281.     1,
  282.     prodBtrimmingPrims2,
  283.     prodBisComplemented2,
  284. },
  285.     },
  287.     {    /* A and B */
  288. {
  289.     0, 1, 0,
  290.     1,
  291.     prodAtrimmingPrims3,
  292.     prodAisComplemented3,
  293. },
  294. {
  295.     1, 1, 0,
  296.     1,
  297.     prodBtrimmingPrims3,
  298.     prodBisComplemented3,
  299. },
  300.     },
  302.     { /* A and B - D - C */
  303. {
  304.     0, 1, 0,
  305.     3,
  306.     prodAtrimmingPrims4,
  307.     prodAisComplemented4,
  308. },
  309. {
  310.     3, 0, 0,
  311.     3,
  312.     prodBtrimmingPrims4,
  313.     prodBisComplemented4,
  314. },
  315. {
  316.     2, 0, 0,
  317.     3,
  318.     prodCtrimmingPrims4,
  319.     prodCisComplemented4,
  320. },
  321. {
  322.     1, 1, 0,
  323.     3,
  324.     prodDtrimmingPrims4,
  325.     prodDisComplemented4,
  326. },
  327.     },
  328. };
  331. int numProducts[4] = {2, 2, 2, 4};
  334. int  winWidth, winHeight;
  335. GLfloat  *depthSave = NULL;
  336. GLubyte  *stencilSave = NULL;
  337. GLubyte  *colorSave = NULL;
  340. void resizeBuffers(void)
  341. {
  342.     if(colorSave != NULL)
  343.         free(colorSave);
  344.     colorSave = malloc(winWidth * winHeight * 4 * sizeof(GLubyte));
  345.     if(depthSave != NULL)
  346.         free(depthSave);
  347.     depthSave = malloc(winWidth * winHeight * sizeof(GLfloat));
  348.     stencilSave = (GLubyte *)depthSave;
  349. }
  352. void pushOrthoView(float left, float right, float bottom, float top,
  353.     float znear, float zfar)
  354. {
  355.     glPushMatrix();
  356.     glLoadIdentity();
  357.     glMatrixMode(GL_PROJECTION);
  358.     glPushMatrix();
  359.     glLoadIdentity();
  360.     glOrtho(left, right, bottom, top, znear, zfar);
  361. }
  364. void popView(void)
  365. {
  366.     glPopMatrix();
  367.     glMatrixMode(GL_MODELVIEW);
  368.     glPopMatrix();
  369. }
  372. void copyDepthToColor(GLenum whichColorBuffer)
  373. {
  374.     int x, y;
  375.     GLfloat max, min;
  376.     GLint previousColorBuffer;
  378.     glReadPixels(0, 0, winWidth, winHeight, GL_DEPTH_COMPONENT, GL_FLOAT,
  379.         depthSave);
  381.     /* I'm sure this could be done much better with OpenGL */
  382.     max = 0;
  383.     min = 1;
  384.     for(y = 0; y < winHeight; y++)
  385. for(x = 0; x < winWidth; x++) {
  386.     if(depthSave[winWidth * y + x] < min)
  387. min = depthSave[winWidth * y + x];
  388.     if(depthSave[winWidth * y + x] > max && depthSave[winWidth * y + x] < .999)
  389. max = depthSave[winWidth * y + x];
  390. }
  392.     for(y = 0; y < winHeight; y++)
  393. for(x = 0; x < winWidth; x++) {
  394.     if(depthSave[winWidth * y + x] <= max)
  395. depthSave[winWidth * y + x] = 1 -  (depthSave[winWidth * y + x] - min) / (max - min);
  396.     else
  397. depthSave[winWidth * y + x] = 0;
  398. }
  400.     pushOrthoView(0, 1, 0, 1, 0, 1);
  401.     glRasterPos3f(0, 0, -.5);
  402.     glDisable(GL_DEPTH_TEST);
  403.     glDisable(GL_STENCIL_TEST);
  404.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  405.     glGetIntegerv(GL_DRAW_BUFFER, &previousColorBuffer);
  406.     glDrawBuffer(whichColorBuffer);
  407.     glDrawPixels(winWidth, winHeight, GL_LUMINANCE , GL_FLOAT, depthSave);
  408.     glDrawBuffer(previousColorBuffer);
  409.     glEnable(GL_DEPTH_TEST);
  410.     popView();
  411. }
  414. unsigned char stencilValueToColorMap[][3] =
  415. {
  416.     {255, 0, 0}, /* red */
  417.     {255, 218, 0}, /* yellow */
  418.     {72, 255, 0}, /* yellowish green */
  419.     {0, 255, 145}, /* bluish cyan */
  420.     {0, 145, 255}, /* cyanish blue */
  421.     {72, 0, 255}, /* purplish blue */
  422.     {255, 0, 218}, /* reddish purple */
  423. };
  426. void copyStencilValuesToColor(GLenum whichColorBuffer)
  427. {
  428.     int x, y;
  429.     GLint previousColorBuffer;
  431.     glReadPixels(0, 0, winWidth, winHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
  432.         stencilSave);
  434.     /* I'm sure this could be done much better with OpenGL */
  435.     for(y = 0; y < winHeight; y++)
  436. for(x = 0; x < winWidth; x++) {
  437.     int stencilValue;
  438.     
  439.     stencilValue = stencilSave[winWidth * y + x];
  441.     colorSave[(winWidth * y + x) * 3 + 0] =
  442.         stencilValueToColorMap[stencilValue % 7][0];
  443.     colorSave[(winWidth * y + x) * 3 + 1] =
  444.         stencilValueToColorMap[stencilValue % 7][1];
  445.     colorSave[(winWidth * y + x) * 3 + 2] =
  446.         stencilValueToColorMap[stencilValue % 7][2];
  447. }
  449.     pushOrthoView(0, 1, 0, 1, 0, 1);
  450.     glRasterPos3f(0, 0, -.5);
  451.     glDisable(GL_DEPTH_TEST);
  452.     glDisable(GL_STENCIL_TEST);
  453.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  454.     glGetIntegerv(GL_DRAW_BUFFER, &previousColorBuffer);
  455.     glDrawBuffer(whichColorBuffer);
  456.     glDrawPixels(winWidth, winHeight, GL_RGB, GL_UNSIGNED_BYTE, colorSave);
  457.     glDrawBuffer(previousColorBuffer);
  458.     glEnable(GL_DEPTH_TEST);
  459.     popView();
  460. }
  463. /*
  464.  * XXX This function should make colors that identify individual bits in
  465.  * the stencil buffer, but it seems like too hard a problem to solve
  466.  * in five minutes.  Fix later.
  467.  */
  468. void copyStencilPlanesToColor(GLenum whichColorBuffer)
  469. {
  470.     int x, y;
  471.     GLint previousColorBuffer;
  473.     glReadPixels(0, 0, winWidth, winHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
  474.         stencilSave);
  476.     /* I'm sure this could be done much better with OpenGL */
  477.     for(y = 0; y < winHeight; y++)
  478. for(x = 0; x < winWidth; x++) {
  479.     /* Have to think of something clever to do here */
  480. }
  482.     pushOrthoView(0, 1, 0, 1, 0, 1);
  483.     glRasterPos3f(0, 0, -.5);
  484.     glDisable(GL_DEPTH_TEST);
  485.     glDisable(GL_STENCIL_TEST);
  486.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  487.     glGetIntegerv(GL_DRAW_BUFFER, &previousColorBuffer);
  488.     glDrawBuffer(whichColorBuffer);
  489.     glDrawPixels(winWidth, winHeight, GL_RGB, GL_UNSIGNED_BYTE, colorSave);
  490.     glDrawBuffer(previousColorBuffer);
  491.     glEnable(GL_DEPTH_TEST);
  492.     popView();
  493. }
  496. void copyInterest(void)
  497. {
  498.     switch(bufferInterest) {
  499.         case COLOR:
  500.     break; /* Well, that's already there. */
  502. case STENCILVALUES:
  503.     copyStencilValuesToColor(GL_BACK);
  504.     break;
  506. case STENCILPLANES:
  507.     copyStencilPlanesToColor(GL_BACK);
  508.     break;
  510. case DEPTH:
  511.     copyDepthToColor(GL_BACK);
  512.     break;
  513.     }
  514. }
  517. void axisamountToMat(float aa[], float mat[])
  518. {
  519.     float c, s, t;
  521.     c = (float)cos(aa[3]);
  522.     s = (float)sin(aa[3]);
  523.     t = 1.0f - c;
  525.     mat[0] = t * aa[0] * aa[0] + c;
  526.     mat[1] = t * aa[0] * aa[1] + s * aa[2];
  527.     mat[2] = t * aa[0] * aa[2] - s * aa[1];
  528.     mat[3] = t * aa[0] * aa[1] - s * aa[2];
  529.     mat[4] = t * aa[1] * aa[1] + c;
  530.     mat[5] = t * aa[1] * aa[2] + s * aa[0];
  531.     mat[6] = t * aa[0] * aa[2] + s * aa[1];
  532.     mat[7] = t * aa[1] * aa[2] - s * aa[0];
  533.     mat[8] = t * aa[2] * aa[2] + c;
  534. }
  537. void matToAxisamount(float mat[], float aa[])
  538. {
  539.     float c;
  540.     float s;
  542.     c = (mat[0] + mat[4] + mat[8] - 1.0f) / 2.0f;
  543.     aa[3] = (float)acos(c);
  544.     s = (float)sin(aa[3]);
  545.     if(fabs(s / M_PI - (int)(s / M_PI)) < .0000001)
  546.     {
  547.         aa[0] = 0.0f;
  548.         aa[1] = 1.0f;
  549.         aa[2] = 0.0f;
  550.     }
  551.     else
  552.     {
  553. aa[0] = (mat[5] - mat[7]) / (2.0f * s);
  554. aa[1] = (mat[6] - mat[2]) / (2.0f * s);
  555. aa[2] = (mat[1] - mat[3]) / (2.0f * s);
  556.     }
  557. }
  560. void multMat(float m1[], float m2[], float r[])
  561. {
  562.     float t[9];
  563.     int i;
  565.     t[0] = m1[0] * m2[0] + m1[1] * m2[3] + m1[2] * m2[6];
  566.     t[1] = m1[0] * m2[1] + m1[1] * m2[4] + m1[2] * m2[7];
  567.     t[2] = m1[0] * m2[2] + m1[1] * m2[5] + m1[2] * m2[8];
  568.     t[3] = m1[3] * m2[0] + m1[4] * m2[3] + m1[5] * m2[6];
  569.     t[4] = m1[3] * m2[1] + m1[4] * m2[4] + m1[5] * m2[7];
  570.     t[5] = m1[3] * m2[2] + m1[4] * m2[5] + m1[5] * m2[8];
  571.     t[6] = m1[6] * m2[0] + m1[7] * m2[3] + m1[8] * m2[6];
  572.     t[7] = m1[6] * m2[1] + m1[7] * m2[4] + m1[8] * m2[7];
  573.     t[8] = m1[6] * m2[2] + m1[7] * m2[5] + m1[8] * m2[8];
  574.     for(i = 0; i < 9; i++)
  575.     {
  576.         r[i] = t[i];
  577.     }
  578. }
  581. void rotateTrackball(int dx, int dy, float rotation[4])
  582. {
  583.     float dist;
  584.     float oldMat[9];
  585.     float rotMat[9];
  586.     float newRot[4];
  588.     dist = (float)sqrt((double)(dx * dx + dy * dy));
  589.     if(fabs(dist) < 0.99)
  590.         return;
  592.     newRot[0] = (float) dy / dist;
  593.     newRot[1] = (float) dx / dist;
  594.     newRot[2] = 0.0f;
  595.     newRot[3] = (float)M_PI * dist / winWidth;
  597.     axisamountToMat(rotation, oldMat);
  598.     axisamountToMat(newRot, rotMat);
  599.     multMat(oldMat, rotMat, oldMat);
  600.     matToAxisamount(oldMat, rotation);
  602.     dist = (float)sqrt(rotation[0] * rotation[0] + rotation[1] * rotation[1] +
  603.         rotation[2] * rotation[2]);
  605.     rotation[0] /= dist;
  606.     rotation[1] /= dist;
  607.     rotation[2] /= dist;
  608. }
  611. struct transformation *curXform;
  614. void init(void)
  615. {
  616.     glMatrixMode(GL_PROJECTION);
  617.     glFrustum(-.33, .33, -.33, .33, .5, 40);
  619.     glMatrixMode(GL_MODELVIEW);
  620.     gluLookAt(0, 0, 7, 0, 0, 0, 0, 1, 0);
  622.     glEnable(GL_LIGHTING);
  623.     glEnable(GL_LIGHT0);
  625.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  627.     glEnable(GL_NORMALIZE);
  629.     quadric = gluNewQuadric();
  631.     glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
  633.     curXform = &prims[0].xform;
  634. }
  637. void setupLight(void)
  638. {
  639.     static GLfloat lightpos[] = {0, 1, 0, 0};
  641.     glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  642. }
  645. void redrawNoCSG(void)
  646. {
  647.     int i;
  649.     glDisable(GL_STENCIL_TEST);
  650.     glEnable(GL_DEPTH_TEST);
  651.     glDepthFunc(GL_LESS);
  652.     glEnable(GL_CULL_FACE);
  653.     glCullFace(GL_BACK);
  654.     glDepthMask(GL_TRUE);
  655.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  657.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  659.     glPushMatrix();
  661.     drawXform(&globalXform, FALSE);
  663.     for(i = 0; i < numPrims; i++)
  664.     {
  665.         if(i == curPrim || !showOnlyCurrent)
  666.     drawPrim(i);
  667.     }
  669.     glPopMatrix();
  671.     copyInterest();
  673.     glutSwapBuffers();
  674. }
  677. int whereSoFar;
  680. GLfloat *depthResults = NULL;
  683. void saveDepth(void)
  684. {
  685.     depthResults = realloc(depthResults, winWidth * winHeight *
  686.         sizeof(GLfloat));
  687.     glReadPixels(0, 0, winWidth, winHeight, GL_DEPTH_COMPONENT, GL_FLOAT,
  688. depthResults);
  689. }
  692. void restoreDepth(void)
  693. {
  694.     glStencilMask(0);
  695.     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  696.     glDepthMask(GL_TRUE);
  697.     glEnable(GL_DEPTH_TEST);
  698.     glDepthFunc(GL_ALWAYS);
  699.     glDisable(GL_STENCIL_TEST);
  701.     pushOrthoView(0, 1, 0, 1, 0, 1);
  702.     glRasterPos3f(0, 0, -.5);
  704.     glDrawPixels(winWidth, winHeight, GL_DEPTH_COMPONENT, GL_FLOAT,
  705.         depthResults);
  707.     popView();
  708. }
  711. #define COPY_AND_RETURN_IF_DONE(s) 
  712.     { 
  713. if(whereSoFar++ == whereToStop) { 
  714.     printf("%sn", s); 
  715.     return(STOP);  
  716. } 
  717.     }
  720. #define COPY_AND_GOTO_IF_DONE(s) 
  721.     { 
  722. if(whereSoFar++ == whereToStop) { 
  723.     printf("%sn", s); 
  724.     goto doneWithFrame;  
  725. } 
  726.     }
  729. int sCountMask = 0x01; /* 1-convexity maximum */
  730. int sCountShift = 0;
  731. int sPMask = 1;
  732. int sPShift = 0;
  735. void drawFarRect(void)
  736. {
  737.     pushOrthoView(0, 1, 0, 1, 0, 1);
  739.     /* Can I just draw & let be clipped? */
  740.     glBegin(GL_QUADS);
  741.     glVertex3f(0, 0, -1);
  742.     glVertex3f(1, 0, -1);
  743.     glVertex3f(1, 1, -1);
  744.     glVertex3f(0, 1, -1);
  745.     glEnd();
  747.     popView();
  748. }
  751. progressEnum renderPrimDepths(int targetPrim, int frontFace, int whichSurface)
  752. {
  753.     glClear(GL_DEPTH_BUFFER_BIT);
  756.     glDepthFunc(GL_ALWAYS);
  757.     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  758.     glStencilMask(sCountMask);
  760. #ifndef CLEAR_HONORS_STENCIL_MASK /* see comment at beginning of source */
  762.     glDisable(GL_CULL_FACE);
  763.     glDisable(GL_DEPTH_TEST);
  764.     glDepthMask(GL_FALSE);
  766.     glStencilFunc(GL_ALWAYS, 0, 0);
  767.     glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  768.     drawFarRect();
  770.     COPY_AND_RETURN_IF_DONE("After clearing p bit in stencil");
  772. #else
  774.     glClearStencil(0);
  775.     glClear(GL_STENCIL_BUFFER_BIT);
  777. #endif
  779.     glEnable(GL_CULL_FACE);
  780.     if(frontFace)
  781.         glCullFace(GL_BACK);
  782.     else
  783.         glCullFace(GL_FRONT);
  785.     glEnable(GL_DEPTH_TEST);
  786.     glDepthMask(GL_TRUE);
  788.     glStencilFunc(GL_EQUAL, whichSurface, sCountMask);
  789.     glStencilOp(GL_INCR, GL_INCR, GL_INCR);
  791.     drawPrim(targetPrim);
  793.     return(CONTINUE);
  794. }
  797. progressEnum trimWithPrimitive(int trimPrim, int isComplemented)
  798. {
  799.     glDepthFunc(GL_LESS);
  800.     glEnable(GL_STENCIL_TEST);
  801.     glDepthMask(GL_FALSE);
  802.     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  803.     glStencilMask(sPMask);
  804.     glDisable(GL_CULL_FACE);
  806. #ifndef CLEAR_HONORS_STENCIL_MASK /* see comment at beginning of source */
  808.     glDisable(GL_DEPTH_TEST);
  810.     glStencilFunc(GL_ALWAYS, isComplemented ? (1 << sPShift) : 0, 0);
  811.     glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  812.     drawFarRect();
  814. #else
  816.     glClearStencil(isComplemented ? (1 << sPShift) : 0);
  817.     glClear(GL_STENCIL_BUFFER_BIT);
  819. #endif
  821.     glEnable(GL_DEPTH_TEST);
  822.     glStencilFunc(GL_ALWAYS, 0, 0);
  823.     glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
  824.     drawPrim(trimPrim);
  826.     COPY_AND_RETURN_IF_DONE("After setting stencil to mark depths "
  827.         "inside trimming primitive");
  829.     /* stencil == 0 where pixels were not inside */
  830.     /* so now set Z to far where stencil == 0, everywhere pixels trimmed */
  832.     glStencilFunc(GL_EQUAL, 0, sPMask);
  833.     glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  834.     glDepthMask(1);
  835.     glDepthFunc(GL_ALWAYS);
  836.     glDisable(GL_LIGHTING);
  837.     drawFarRect();
  838.     glEnable(GL_LIGHTING);
  840.     COPY_AND_RETURN_IF_DONE("After clearing depths where target outside "
  841.         "trimming primitive");
  843.     return(CONTINUE);
  844. }
  847. progressEnum markProductPixels(int product, int accumBit)
  848. {
  849.     int i;
  851.     struct product *p;
  853.     p = &products[whichTree][product];
  855.     if(renderPrimDepths(p->targetPrim, p->frontFace, p->whichSurface) == STOP)
  856.         return(STOP);
  858.     COPY_AND_RETURN_IF_DONE("After rendering target depths");
  860.     for(i = 0; i < p->numTrimPrims; i++)
  861.     {
  862.         if(trimWithPrimitive(p->trimmingPrims[i], p->isComplemented[i]) == STOP)
  863.     return(STOP);
  864.     }
  866.     COPY_AND_RETURN_IF_DONE("After target has been trimmed by all "
  867.         "trimming primitives");
  869.     /* set accumulator stencil bit for this primitive everywhere depth != far */
  870.     glStencilFunc(GL_ALWAYS, 1 << accumBit, 0);
  871.     glStencilOp(GL_KEEP, GL_ZERO, GL_REPLACE);
  872.     glStencilMask(1 << accumBit);
  873.     glDepthMask(0);
  874.     glDepthFunc(GL_GREATER);
  875.     glDisable(GL_LIGHTING);
  876.     drawFarRect();
  877.     glEnable(GL_LIGHTING);
  879.     COPY_AND_RETURN_IF_DONE("After setting accumulator where depths != far");
  881.     return(CONTINUE);
  882. }
  885. progressEnum drawProduct(int product, int accumBit)
  886. {
  887.     struct product *p;
  888.     p = &products[whichTree][product];
  890.     glEnable(GL_CULL_FACE);
  891.     if(p->frontFace)
  892.         glCullFace(GL_BACK);
  893.     else
  894.         glCullFace(GL_FRONT);
  896.     glDepthMask(GL_TRUE);
  897.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  898.     glEnable(GL_DEPTH_TEST);
  899.     glDepthFunc(GL_LESS);
  900.     glEnable(GL_STENCIL_TEST);
  901.     glStencilFunc(GL_EQUAL, 1 << accumBit, 1 << accumBit);
  902.     glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  903.     drawPrim(p->targetPrim);
  905.     COPY_AND_RETURN_IF_DONE("After drawing target color and depth");
  907.     return(CONTINUE);
  908. }
  911. void redrawCSG(void)
  912. {
  913.     int i;
  914.     int accumBit;
  915.     int firstProduct;
  916.     int lastProduct;
  918.     whereSoFar = 0;
  919.     glDepthMask(GL_TRUE);
  920.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
  921.     glClear(GL_COLOR_BUFFER_BIT);
  923.     /* Only have to do this if you're going to look at the stencil buffer */
  924.     glClearStencil(0);
  925.     glStencilMask((1 << stenSize) - 1);
  926.     glClear(GL_STENCIL_BUFFER_BIT);
  928.     glPushMatrix();
  930.     drawXform(&globalXform, FALSE);
  932.     firstProduct = 0;
  934.     while(firstProduct != numProducts[whichTree]) {
  935.     
  936.   /*
  937.  * set lastProduct so that accum bits for first to last fit in
  938.  * stencil buffer minus bits needed for surface counting bits
  939.  */
  940. lastProduct = firstProduct + (stenSize - 1) - 1;
  941. if(lastProduct >= numProducts[whichTree])
  942.     lastProduct = numProducts[whichTree] - 1;
  944. if(firstProduct > 0) /* know depth is clear before 1st group */
  945.     saveDepth();
  947. accumBit = 1; /* first available after counting bits */
  949. for(i = firstProduct; i <= lastProduct; i++)
  950.     if(markProductPixels(i, accumBit++) == STOP)
  951. goto doneWithFrame;
  953. COPY_AND_GOTO_IF_DONE("After marking "inside" target accumulators");
  955. if(firstProduct > 0) /* know depth was clear before first group */
  956.     restoreDepth();
  957. else {
  958.     glDepthMask(GL_TRUE);
  959.     glClear(GL_DEPTH_BUFFER_BIT);
  960. }
  962. accumBit = 1; /* first available after counting bits */
  964. for(i = firstProduct; i <= lastProduct; i++)
  965.     if(drawProduct(i, accumBit++) == STOP)
  966. goto doneWithFrame;
  968. COPY_AND_GOTO_IF_DONE("After drawing all target colors and depths");
  970. firstProduct = lastProduct + 1;
  971.     }
  973.     if(showSurfaces) {
  974. glDisable(GL_STENCIL_TEST);
  975. glDepthMask(GL_FALSE);
  976. glEnable(GL_CULL_FACE);
  977. glCullFace(GL_BACK);
  978. glEnable(GL_BLEND);
  979. magicTranspHack = 1;
  980. for(i = 0; i < numProducts[whichTree]; i++)
  981. {
  982.     struct product *p;
  983.     p = &products[whichTree][i];
  985.     if(i == curPrim || !showOnlyCurrent)
  986. drawPrim(p->targetPrim);
  987. }
  988. magicTranspHack = 0;
  989. glDisable(GL_BLEND);
  990.     }
  992. doneWithFrame:
  994.     glPopMatrix();
  996.     copyInterest();
  997.     glutSwapBuffers();
  998. }
  1001. enum trackballModeEnum {
  1002.     ROTATE,
  1003.     TRANSLATEXY,
  1004.     TRANSLATEZ,
  1005.     SCALEX,
  1006.     SCALEY,
  1007.     SCALEZ
  1008. } trackballMode = ROTATE;
  1011. /* ARGSUSED1 */
  1012. void special(int thing, int x, int y)
  1013. {
  1014.      switch(thing) {
  1015.          case GLUT_KEY_F1:
  1016.      prims[curPrim].draw = drawBox;
  1017.      glutPostRedisplay();
  1018.      break;
  1020.          case GLUT_KEY_F2:
  1021.      prims[curPrim].draw = drawCylinder;
  1022.      glutPostRedisplay();
  1023.      break;
  1025.          case GLUT_KEY_F3:
  1026.      prims[curPrim].draw = drawCone;
  1027.      glutPostRedisplay();
  1028.      break;
  1030.          case GLUT_KEY_F4:
  1031.      prims[curPrim].draw = drawSphere;
  1032.      glutPostRedisplay();
  1033.      break;
  1034.      }
  1035. }
  1037. /* ARGSUSED1 */
  1038. void keyboard(unsigned char key, int x, int y)
  1039. {
  1040.     switch(key)
  1041.     {
  1042.         case '1':
  1043.         case '2':
  1044.         case '3':
  1045.         case '4':
  1046.     whichTree = key - '1';
  1047.     glutPostRedisplay();
  1048.     break;
  1050.         case 'r':
  1051.     trackballMode = ROTATE;
  1052.     break;
  1054. case 't':
  1055.     trackballMode = TRANSLATEXY;
  1056.     break;
  1058. case 'T':
  1059.     trackballMode = TRANSLATEZ;
  1060.     break;
  1062. case 'x':
  1063.     trackballMode = SCALEX;
  1064.     break;
  1066. case 'y':
  1067.     trackballMode = SCALEY;
  1068.     break;
  1070. case 'z':
  1071.     trackballMode = SCALEZ;
  1072.     break;
  1074. case 'q': case 'Q': case '33':
  1075.     exit(0);
  1076.     break;
  1078. case '<': case ',':
  1079.     if(curXform != &globalXform)
  1080.     {
  1081. curPrim = (curPrim - 1 + numPrims) % numPrims;
  1082. curXform = &prims[curPrim].xform;
  1083. printf("Manipulating transformation for object %dn", curPrim);
  1084.     }
  1085.     else
  1086.     {
  1087.         printf("Have to toggle out of global mode firstn");
  1088.     }
  1089.     glutPostRedisplay();
  1090.     break;
  1092. case '>': case '.':
  1093.     if(curXform != &globalXform)
  1094.     {
  1095. curPrim = (curPrim + 1) % numPrims;
  1096. curXform = &prims[curPrim].xform;
  1097. printf("Manipulating transformation for object %dn", curPrim);
  1098.     }
  1099.     else
  1100.     {
  1101.         printf("Have to toggle out of global mode firstn");
  1102.     }
  1103.     break;
  1105. case 'g':
  1106.     if(curXform == &globalXform){
  1107. curXform = &prims[curPrim].xform;
  1108. printf("Manipulating transformation for object %dn", curPrim);
  1109.     }else{
  1110. curXform = &globalXform;
  1111. printf("Manipulating global transformationn");
  1112.     }
  1113.     break;
  1115. case '+': case '=':
  1116.     whereToStop++;
  1117.     glutPostRedisplay();
  1118.     break;
  1120. case '-': case '_':
  1121.     whereToStop--;
  1122.     glutPostRedisplay();
  1123.     break;
  1125. case 's':
  1126.     glutPostRedisplay();
  1127.     showSurfaces = !showSurfaces;
  1128.     break;
  1130. case 'c':
  1131.     doCSG = ! doCSG;
  1132.     if(doCSG)
  1133. glutDisplayFunc(redrawCSG);
  1134.     else
  1135. glutDisplayFunc(redrawNoCSG);
  1136.     glutPostRedisplay();
  1137.     break;
  1139. case ' ':
  1140.     showOnlyCurrent = !showOnlyCurrent;
  1141.     glutPostRedisplay();
  1142.     break;
  1143.     }
  1144. }
  1147. static int ox, oy;
  1149. /* ARGSUSED */
  1150. void button(int b, int state, int x, int y)
  1151. {
  1152.     ox = x;
  1153.     oy = y;
  1154. }
  1156. void motion(int x, int y)
  1157. {
  1158.     int dx, dy;
  1160.     dx = x - ox;
  1161.     dy = y - oy;
  1163.     ox = x;
  1164.     oy = y;
  1166.     switch(trackballMode) {
  1167. case ROTATE:
  1168.     rotateTrackball(dx, dy, curXform->rotation);
  1169.     break;
  1171. case SCALEX:
  1172.     curXform->scale[0] += (dx + dy) / 40.0f;
  1173.     if(curXform->scale[0] < 1/40.0)
  1174.         curXform->scale[0] = 1/40.0;
  1175.     break;
  1177. case SCALEY:
  1178.     curXform->scale[1] += (dx + dy) / 40.0f;
  1179.     if(curXform->scale[1] < 1/40.0)
  1180.         curXform->scale[1] = 1/40.0;
  1181.     break;
  1183. case SCALEZ:
  1184.     curXform->scale[2] += (dx + dy) / 40.0f;
  1185.     if(curXform->scale[2] < 1/40.0)
  1186.         curXform->scale[2] = 1/40.0;
  1187.     break;
  1189. case TRANSLATEXY:
  1190.     curXform->translation[0] += dx / 40.0f;
  1191.     curXform->translation[1] -= dy / 40.0f;
  1192.     break;
  1194. case TRANSLATEZ:
  1195.     curXform->translation[2] += (dx + dy) / 40.0f;
  1196.     break;
  1197.     }
  1198.     glutPostRedisplay();
  1199. }
  1202. void reshape(int width, int height)
  1203. {
  1204.     glViewport(0, 0, width, height);
  1205.     winWidth = width;
  1206.     winHeight = height;
  1207.     resizeBuffers();
  1208.     glutPostRedisplay();
  1209. }
  1212. int mainMenu;
  1215. void mainMenuFunc(int choice)
  1216. {
  1217.     switch(choice)
  1218.     {
  1219.         case 1:
  1220.     doCSG = !doCSG;
  1221.     if(doCSG) {
  1222.      printf("CSG expression onn");
  1223. glutDisplayFunc(redrawCSG);
  1224. glutChangeToMenuEntry(1, "Turn off CSG", 0);
  1225.     }
  1226.     else {
  1227.      printf("CSG expression offn");
  1228. glutDisplayFunc(redrawNoCSG);
  1229. glutChangeToMenuEntry(1, "Turn on CSG", 0);
  1230.     }
  1231. glutPostRedisplay();
  1232.     break;
  1233.         case 2:
  1234.     showSurfaces = !showSurfaces;
  1235.     if(showSurfaces) {
  1236.      printf("Transparent surfaces onn");
  1237. glutChangeToMenuEntry(2, "(s) Don't show objects transparent in CSG", 2);
  1238.     }
  1239.     else {
  1240.      printf("Transparent surfaces offn");
  1241. glutChangeToMenuEntry(2, "(s) Show objects transparent in CSG", 2);
  1242.     }
  1243. glutPostRedisplay();
  1244.     break;
  1245.     }
  1246. }
  1249. void interestBufferFunc(int data)
  1250. {
  1251.     char *s;
  1253.     bufferInterest = data;
  1255.     switch(data) {
  1256.         case COLOR:
  1257.     s = "color";
  1258.     break;
  1260.         case STENCILVALUES:
  1261.     s = "stencil values";
  1262.     break;
  1264.         case STENCILPLANES:
  1265.     s = "individual stencil plane converage";
  1266.     break;
  1268.         case DEPTH:
  1269.     s = "depth";
  1270.     break;
  1271.     }
  1272.     printf("Now displaying %s datan", s);
  1273.     glutPostRedisplay();
  1274. }
  1277. void csgMenuFunc(int data)
  1278. {
  1279.     whichTree = data;
  1280.     glutPostRedisplay();
  1281. }
  1284. void whichObjectFunc(int data)
  1285. {
  1286.     switch(data)
  1287.     {
  1288.         case 0:
  1289.         case 1:
  1290.         case 2:
  1291.         case 3:
  1292.     curPrim = data;
  1293.     curXform = &prims[curPrim].xform;
  1294.     printf("Editing object %dn", data);
  1295.     break;
  1297. case 4:
  1298.     curXform = &globalXform;
  1299.     printf("Editing global transformation %dn", data);
  1300.     break;
  1301.     }
  1302. }
  1305. void morphMenuFunc(int data)
  1306. {
  1307.     switch(data) {
  1308.         case 0:
  1309.     prims[curPrim].draw = drawBox;
  1310.     glutPostRedisplay();
  1311.     break;
  1313.         case 1:
  1314.     prims[curPrim].draw = drawCylinder;
  1315.     glutPostRedisplay();
  1316.     break;
  1318.         case 2:
  1319.     prims[curPrim].draw = drawCone;
  1320.     glutPostRedisplay();
  1321.     break;
  1323.         case 3:
  1324.     prims[curPrim].draw = drawSphere;
  1325.     glutPostRedisplay();
  1326.     break;
  1327.      }
  1328. }
  1331. void helpFakeFunc(int d)
  1332. {
  1333. }
  1336. int main(int argc, char **argv)
  1337. {
  1338.     int bufferMenu;
  1339.     int csgMenu;
  1340.     int whichObjectMenu;
  1341.     int morphMenu;
  1342.     int helpFakeMenu;
  1344.     glutInitWindowSize(512,512);
  1345.     glutInit(&argc, argv);
  1346.     glutInitDisplayString("samples stencil>=3 rgb double depth");
  1347.     /* glutInitDisplayMode(GLUT_DOUBLE|GLUT_STENCIL|GLUT_DEPTH|GLUT_RGBA); */
  1348.     (void)glutCreateWindow("csg using stencil");
  1349.     glutDisplayFunc(redrawNoCSG);
  1350.     glutKeyboardFunc(keyboard);
  1351.     glutSpecialFunc(special);
  1352.     glutMotionFunc(motion);
  1353.     glutMouseFunc(button);
  1354.     glutReshapeFunc(reshape);
  1356.     glGetIntegerv(GL_STENCIL_BITS, &stenSize);
  1357.     printf("%d bits of stencil available in this visualn", stenSize);
  1359.     printf("Hit 'S' to turn stencil on/offn");
  1361.     bufferMenu = glutCreateMenu(interestBufferFunc);
  1362.     glutAddMenuEntry("Color data", COLOR);
  1363.     glutAddMenuEntry("Stencil values", STENCILVALUES);
  1364.     glutAddMenuEntry("Coverage in each stencil plane", STENCILPLANES);
  1365.     glutAddMenuEntry("Depth data", DEPTH);
  1367.     csgMenu = glutCreateMenu(csgMenuFunc);
  1368.     glutAddMenuEntry("(1) obj 1 MINUS obj 2", 0);
  1369.     glutAddMenuEntry("(2) obj 2 MINUS obj 1", 1);
  1370.     glutAddMenuEntry("(3) obj 1 AND obj 2", 2);
  1371.     glutAddMenuEntry("(4) (obj 1 AND obj 2) MINUS (obj 3 or obj 4)", 3);
  1373.     whichObjectMenu = glutCreateMenu(whichObjectFunc);
  1374.     glutAddMenuEntry("Object 1 (blue)", 0);
  1375.     glutAddMenuEntry("Object 2 (peach)", 1);
  1376.     glutAddMenuEntry("Object 3 (green)", 2);
  1377.     glutAddMenuEntry("Object 4 (purple)", 3);
  1378.     glutAddMenuEntry("(g) Toggle between global and local", 4);
  1380.     morphMenu = glutCreateMenu(morphMenuFunc);
  1381.     glutAddMenuEntry("(F1) Box", 0);
  1382.     glutAddMenuEntry("(F2) Cylinder", 1);
  1383.     glutAddMenuEntry("(F3) Cone", 2);
  1384.     glutAddMenuEntry("(F4) Sphere", 3);
  1386.     helpFakeMenu = glutCreateMenu(helpFakeFunc);
  1387.     glutAddMenuEntry("Click the left mouse button and drag to manipulaten", 0);
  1388.     glutAddMenuEntry("Push 'r' to rotate like a trackballn", 0);
  1389.     glutAddMenuEntry("Push 't' to translate in the X-Y planen", 0);
  1390.     glutAddMenuEntry("Push 'T' to translate in the Z axisn", 0);
  1391.     glutAddMenuEntry("Push 'X' to scale in Xn", 0);
  1392.     glutAddMenuEntry("Push 'X' to scale in Yn", 0);
  1393.     glutAddMenuEntry("Push 'Z' to scale in Zn", 0);
  1395.     mainMenu = glutCreateMenu(mainMenuFunc);
  1396.     glutAddMenuEntry("(c) Turn on CSG", 1);
  1397.     glutAddMenuEntry("(s) Show objects transparent in CSG", 2);
  1398.     glutAddSubMenu("Buffer of interest", bufferMenu);
  1399.     glutAddSubMenu("Which CSG expression", csgMenu);
  1400.     glutAddSubMenu("Object for manipulation", whichObjectMenu);
  1401.     glutAddSubMenu("Turn current object into...", morphMenu);
  1402.     glutAddSubMenu("Help with moving and rotating:", helpFakeMenu);
  1403.     glutAttachMenu(GLUT_RIGHT_BUTTON);
  1404.     init();
  1405.     glutMainLoop();
  1407.     return 0;
  1408. }