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

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

GIS编程

开发平台：

Visual C++

depthdof.c：源码内容
  2. /**
  4.    depthdof.c: depth-of-field simulator using stencilled convolutions
  5.       Jon Brandt, 1/97
  6.       converted to GLUT and libtiff by Mark Kilgard, 4/97
  8.    Compile with:
  10.      cc -o depthdof depthdof.c -ltiff -lglut -lGLU -lGL -lXmu -lXext -lX11 -lm
  11.     
  12.  **/
  14. #include <GL/glut.h>
  16. #include <tiffio.h>
  18. #include <assert.h>
  19. #include <math.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <strings.h>
  23. #include <unistd.h>
  25. #define FALSE 0
  26. #define TRUE 1
  28. const char *DefaultImage = "face.tif";
  29. int winWidth = 512, winHeight = 512;
  30. char *pixels = NULL;
  31. int stencilMax;
  32. int kSize = 5;
  33. int kRadius = 5 / 2;
  34. float sharpness = -1.5;
  35. float kernel[] =
  36. {.05, .1, .7, .1, .05};
  37. int passes = 5;
  38. int contour = 0;
  39. char focus = 160;
  40. float spread = 1;
  41. int focusPending = FALSE;
  42. int splitScreen = FALSE;
  43. int smoothDepth = FALSE;
  44. int frame = 0;
  45. int running = TRUE;
  46. int cursor_x, cursor_y;
  47. int multisample, hasConvolve = 0;
  49. TIFFRGBAImage img;
  50. uint32 *raster;
  51. uint32 *texture;
  52. size_t npixels;
  53. int tw, th;
  54. int angle;
  56. int hasABGR = 0;
  58. void drawFrame(int frame);
  59. void initScene(int argc, char *argv[]);
  60. void drawScene(int frame);
  61. void drawObject(float numRep);
  62. void changePassCount(int delta);
  63. void setBlurMap(void);
  64. void setKernel(void);
  65. void resize(int w, int h);
  66. void toggle(int *param, char *msg);
  68. void
  69. redraw(void)
  70. {
  71.   drawFrame(frame);
  72. }
  74. void
  75. idle(void)
  76. {
  77.   frame++;
  78.   glutPostRedisplay();
  79. }
  81. void
  82. visible(int vis)
  83. {
  84.   if (vis == GLUT_VISIBLE)
  85.     glutIdleFunc(idle);
  86.   else
  87.     glutIdleFunc(NULL);
  88. }
  90. /* ARGSUSED1 */
  91. void
  92. keyboard(unsigned char c, int x, int y)
  93. {
  94.   switch (c) {
  95.   case 27:
  96.     exit(0);
  97.     break;
  98.   case 'g':
  99.     running = !running;
  100.     if (running) {
  101.       glutIdleFunc(idle);
  102.     } else {
  103.       glutIdleFunc(NULL);
  104.     }
  105.     break;
  106.   case 'c':
  107.     toggle(&contour, NULL);
  108.     glutPostRedisplay();
  109.     break;
  110.   case 's':
  111.     toggle(&splitScreen, NULL);
  112.     glutPostRedisplay();
  113.     break;
  114.   case 'd':
  115.     toggle(&smoothDepth, "depth smoothing");
  116.     glutPostRedisplay();
  117.     break;
  118.   case ' ':
  119.     frame++;
  120.     glutPostRedisplay();
  121.     break;
  122.   case '-':
  123.     frame--;
  124.     glutPostRedisplay();
  125.     break;
  126.   case 'p':
  127.     changePassCount(1);
  128.     glutPostRedisplay();
  129.     break;
  130.   case 'P':
  131.     changePassCount(-1);
  132.     glutPostRedisplay();
  133.     break;
  134.   case 'a':
  135.     spread *= 1 / 1.2;
  136.     setBlurMap();
  137.     glutPostRedisplay();
  138.     break;
  139.   case 'A':
  140.     spread *= 1.2;
  141.     setBlurMap();
  142.     glutPostRedisplay();
  143.     break;
  144.   case 'k':
  145.     sharpness *= 1 / 1.2;
  146.     printf("sharpness == %gn", sharpness);
  147.     setKernel();
  148.     glutPostRedisplay();
  149.     break;
  150.   case 'K':
  151.     sharpness *= 1.2;
  152.     printf("sharpness == %gn", sharpness);
  153.     setKernel();
  154.     glutPostRedisplay();
  155.     break;
  156.   }
  157. }
  159. void
  160. mouse(int b, int state, int x, int y)
  161. {
  162.   if (b == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  163.     cursor_x = x;
  164.     cursor_y = winHeight - y;
  165.     focusPending = TRUE;
  166.     glutPostRedisplay();
  167.   }
  168. }
  170. void
  171. main(int argc, char *argv[])
  172. {
  173.   int c;
  175.   glutInit(&argc, argv);
  177.   while ((c = getopt(argc, argv, "p:")) != -1) {
  178.     switch (c) {
  179.     case 'p':
  180.       passes = atoi(optarg);
  181.       break;
  182.     }
  183.   }
  185.   glutInitDisplayString("samples depth stencil~8 double");
  186.   glutCreateWindow("Depth of Field via Depth-varying Convolve");
  187.   initScene(argc - optind + 1, argv + optind - 1);
  188.   changePassCount(0);
  189.   printf("Key commands:n");
  190.   printf("          c: show/hide outer blur limitn");
  191.   printf("          g: toggle free running animationn");
  192.   printf("          s: toggle split-screenn");
  193.   printf("          d: toggle depth smoothingn");
  194.   printf("    <space>: step one frame forwardn");
  195.   printf("          -: step one frame backwardn");
  196.   printf("       p(P): increment(decrement) number of passesn");
  197.   printf("       a(A): narrow(widen) lens aperturen");
  198.   printf("       k(K): increase(decrease) kernel blurinessn");
  199.   printf("      <esc>: exitn");
  200.   printf("Mouse clicking changes focus depth.n");
  202.   glutVisibilityFunc(visible);
  203.   glutKeyboardFunc(keyboard);
  204.   glutMouseFunc(mouse);
  205.   glutDisplayFunc(redraw);
  206.   glutReshapeFunc(resize);
  208.   multisample = glutGet(GLUT_WINDOW_NUM_SAMPLES) > 0;
  209.   if (glutExtensionSupported("GL_EXT_convolution")) {
  210.     hasConvolve = 1;
  211.   } else {
  212.     while (glGetError() != GL_NO_ERROR);  /* Clear any OpenGL errors. */
  214.     /* The following glDisable would be a no-op whether done on a freshly
  215.        initialized OpenGL context whether convolution is supported or not.
  216.        The only difference should be an OpenGL error should be reported if
  217.        the GL_CONVOLUTION_2D_EXT is not understood (ie, convolution is not
  218.        supported at all). */
  219.     glDisable(GL_CONVOLUTION_2D_EXT);
  221.     if (glGetError() == GL_NO_ERROR) {
  222.       /* RealityEngine only partially implements the convolve extension and
  223.          hence does not advertise the extension in its extension string (See
  224.          MACHINE DEPENDENCIES section of the glConvolutionFilter2DEXT man
  225.          page). We limit this program to use only the convolve functionality
  226.          supported by RealityEngine so we test if OpenGL lets us enable
  227.          convolution without an error (the indication that convolution is
  228.          partially supported). */
  229.       hasConvolve = 1;
  230.     }
  231.     /* Clear any further OpenGL errors (hopefully there should have only been
  232.        one or zero though). */
  233.     while (glGetError() != GL_NO_ERROR);
  234.   }
  236.   if (!hasConvolve) {
  237.     printf("nTHIS PROGRAM IS NOT VERY INTERESTING WITHOUT THE OPENGL CONVOLVUTION EXTENSIONnn");
  238.   }
  240.   glutMainLoop();
  241. }
  243. void
  244. initScene(int argc, char *argv[])
  245. {
  246.   TIFF *tif;
  247.   char emsg[1024];
  248.   int bits;
  249.   const char *fname = argc > 1 ? argv[1] : DefaultImage;
  251.   glViewport(0, 0, winWidth, winHeight);
  253.   glEnable(GL_TEXTURE_2D);
  254.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  255.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  256.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  257.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  258.   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  260.   tif = TIFFOpen(fname, "r");
  261.   if (tif == NULL) {
  262.     fprintf(stderr, "Problem showing %sn", fname);
  263.     exit(1);
  264.   }
  265.   if (TIFFRGBAImageBegin(&img, tif, 0, emsg)) {
  266.     npixels = img.width * img.height;
  267.     raster = (uint32 *) _TIFFmalloc((long) (npixels * sizeof(uint32)));
  268.     if (raster != NULL) {
  269.       if (TIFFRGBAImageGet(&img, raster, img.width, img.height) == 0) {
  270.         TIFFError(fname, emsg);
  271.         exit(1);
  272.       }
  273.     }
  274.     TIFFRGBAImageEnd(&img);
  275.   } else {
  276.     TIFFError(fname, emsg);
  277.     exit(1);
  278.   }
  280. #ifdef GL_EXT_abgr
  281.   if (glutExtensionSupported("GL_EXT_abgr"))
  282.     hasABGR = 1;
  283. #else
  284.   hasABGR = 0;
  285. #endif
  287.   /* If cannot directly display ABGR format, we need to reverse the component
  288.      ordering in each pixel. :-( */
  289.   if (!hasABGR) {
  290.     int i;
  292.     for (i = 0; i < npixels; i++) {
  293.       register unsigned char *cp = (unsigned char *) &raster[i];
  294.       int t;
  296.       t = cp[3];
  297.       cp[3] = cp[0];
  298.       cp[0] = t;
  299.       t = cp[2];
  300.       cp[2] = cp[1];
  301.       cp[1] = t;
  302.     }
  303.   }
  304.   /* OpenGL's default unpack (and pack) alignment is 4.  In the case of the
  305.      data returned by libtiff which is already aligned on 32-bit boundaries,
  306.      setting the pack to 1 isn't strictly necessary. */
  307.   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  309.   tw = 1 << (int) ceil(log((float) img.width) / log(2.0));
  310.   th = 1 << (int) ceil(log((float) img.height) / log(2.0));
  311.   if (tw > 512)
  312.     tw = 512;
  313.   if (th > 512)
  314.     th = 512;
  315.   texture = (uint32 *) malloc(sizeof(GLubyte) * 4 * tw * th);
  317. #ifdef GL_EXT_abgr
  318. #define APPROPRIATE_FORMAT (hasABGR ? GL_ABGR_EXT : GL_RGBA)
  319. #else
  320. #define APPROPRIATE_FORMAT GL_RGBA
  321. #endif
  323.   gluScaleImage(APPROPRIATE_FORMAT,
  324.     (int) img.width, (int) img.height, GL_UNSIGNED_BYTE, raster,
  325.     tw, th, GL_UNSIGNED_BYTE, texture);
  326.   _TIFFfree(raster);
  328.   if (gluBuild2DMipmaps(GL_TEXTURE_2D, 4, tw, th,
  329.       APPROPRIATE_FORMAT, GL_UNSIGNED_BYTE, texture)) {
  330.     fprintf(stderr, "couldn't build mip map");
  331.     exit(1);
  332.   }
  333.   glGetIntegerv(GL_STENCIL_BITS, &bits);
  334.   stencilMax = (1 << bits) - 1;
  335.   printf("stencil max = %dn", stencilMax);
  337.   setBlurMap();
  338.   setKernel();
  340.   glDrawBuffer(GL_BACK);
  341.   glReadBuffer(GL_BACK);
  342.   glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  344.   glLineStipple(4, 0xaaaa);
  345.   glEnable(GL_LINE_STIPPLE);
  346.   pixels = realloc(pixels, (winWidth + 4) * (winHeight + 4));
  347. }
  349. void
  350. drawFrame(int frame)
  351. {
  352.   int pass;
  353.   int activeWidth = splitScreen ? winWidth / 2 : winWidth;
  355.   glEnable(GL_DEPTH_TEST);
  356.   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  358.   glMatrixMode(GL_PROJECTION);
  359.   glLoadIdentity();
  360.   glFrustum(-1, 1, -1, 1, 1.5, 20);
  362.   glMatrixMode(GL_MODELVIEW);
  363.   glLoadIdentity();
  365. #ifdef GL_MULTISAMPLE_SGIS
  366.   if (multisample)
  367.     glEnable(GL_MULTISAMPLE_SGIS);
  368. #endif
  369.   drawScene(frame);
  370. #ifdef GL_MULTISAMPLE_SGIS
  371.   if (multisample)
  372.     glDisable(GL_MULTISAMPLE_SGIS);
  373. #endif
  375.   if (passes > 0) {
  376.     glDisable(GL_TEXTURE_2D);
  377.     glDisable(GL_DEPTH_TEST);
  378.     glMatrixMode(GL_PROJECTION);
  379.     glLoadIdentity();
  380.     glOrtho(0, winWidth, 0, winHeight, -1, 1);
  381.     glReadPixels(0, 0, activeWidth, winHeight, GL_DEPTH_COMPONENT,
  382.       GL_UNSIGNED_BYTE, pixels);
  384.     if (focusPending) {
  385.       glReadPixels(cursor_x, cursor_y, 1, 1, GL_DEPTH_COMPONENT,
  386.         GL_UNSIGNED_BYTE, &focus);
  387.       printf("focussing on depth == %dn", focus);
  388.       setBlurMap();
  389.       focusPending = FALSE;
  390.     }
  391.     if (smoothDepth && hasConvolve) {
  392. #ifdef GL_EXT_convolution
  393.       /* convolve the depth map into alpha and read it back */
  394.       glEnable(GL_SEPARABLE_2D_EXT);
  395.       glRasterPos2f(kRadius, kRadius);
  396.       glColorMask(0, 0, 0, 1);
  397.       glDrawPixels(activeWidth, winHeight, GL_ALPHA,
  398.         GL_UNSIGNED_BYTE, pixels);
  399.       glColorMask(1, 1, 1, 1);
  400.       glDisable(GL_SEPARABLE_2D_EXT);
  401.       glReadPixels(0, 0, activeWidth, winHeight, GL_ALPHA,
  402.         GL_UNSIGNED_BYTE, pixels);
  403. #endif
  404.     }
  405.     glRasterPos2f(0, 0);
  406.     glPixelTransferi(GL_MAP_STENCIL, GL_TRUE);
  407.     glDrawPixels(activeWidth, winHeight, GL_STENCIL_INDEX,
  408.       GL_UNSIGNED_BYTE, pixels);
  410.     glPixelTransferi(GL_MAP_STENCIL, GL_FALSE);
  411.     glEnable(GL_STENCIL_TEST);
  413. #ifdef GL_EXT_convolution
  414.     if (hasConvolve) {
  415.       glEnable(GL_SEPARABLE_2D_EXT);
  416.       for (pass = 0; pass < passes; pass++) {
  417.         glStencilFunc(GL_LEQUAL, (pass + 1), 255);
  418.         glRasterPos2f(kRadius, kRadius);
  419.         glCopyPixels(0, 0, activeWidth, winHeight, GL_COLOR);
  420.       }
  421.       glDisable(GL_SEPARABLE_2D_EXT);
  422.     }
  423. #endif
  425.     if (contour) {
  426.       /* mark edge of in-focus region with green contour */
  427.       glStencilFunc(GL_EQUAL, pass, 255);
  428.       glColor3f(0, 1, 0);
  429.       glBegin(GL_TRIANGLE_STRIP);
  430.       glVertex2f(0, 0);
  431.       glVertex2f(0, winHeight);
  432.       glVertex2f(winWidth, 0);
  433.       glVertex2f(winWidth, winHeight);
  434.       glEnd();
  435.     }
  436.     glDisable(GL_STENCIL_TEST);
  438.     if (splitScreen) {
  439.       /* yellow divider line */
  440.       glColor3f(1, 1, 0);
  441.       glBegin(GL_LINE_STRIP);
  442.       glVertex2f(activeWidth, 0);
  443.       glVertex2f(activeWidth, winHeight);
  444.       glEnd();
  445.     }
  446.   }
  447.   glutSwapBuffers();
  448. }
  450. void
  451. drawScene(int frame)
  452. {
  453.   glPushMatrix();
  454.   glTranslatef(0, 0, -18);
  455.   glDisable(GL_TEXTURE_2D);
  456.   glBegin(GL_TRIANGLE_STRIP);
  457.   glColor3ub(40, 0, 140);
  458.   glVertex2f(-15, -15);
  459.   glVertex2f(15, -15);
  460.   glColor3ub(52, 202, 226);
  461.   glVertex2f(-15, 15);
  462.   glVertex2f(15, 15);
  463.   glEnd();
  464.   glPopMatrix();
  466.   glPushMatrix();
  467.   glTranslatef(0, -1, 0);
  468.   glScalef(20, 20, 20);
  469.   glRotatef(90, 1, 0, 0);
  470.   drawObject(20);
  471.   glPopMatrix();
  473.   glPushMatrix();
  474.   glTranslatef(0, 0, -5 + 3 * sinf(frame * M_PI / 180));
  475.   glRotatef(frame * 3, 0, 1, 0);
  476.   drawObject(1);
  477.   glPopMatrix();
  479.   glPushMatrix();
  480.   glTranslatef(cosf(frame * M_PI / 120), 0, -6 + 4 * sinf(frame * M_PI / 210));
  481.   glRotatef(frame * 3, 1, 0, cosf(frame * M_PI / 360));
  482.   drawObject(1);
  483.   glPopMatrix();
  485.   glPushMatrix();
  486.   glTranslatef(0, 0, -5 + 3 * sinf(frame * M_PI / 300));
  487.   drawObject(1);
  488.   glPopMatrix();
  489. }
  491. void
  492. drawObject(float n)
  493. {
  494.   glEnable(GL_TEXTURE_2D);
  495.   glColor3f(1, 1, 1);
  496.   glBegin(GL_TRIANGLE_STRIP);
  497.   glTexCoord2f(0, 0);
  498.   glVertex2f(-.5, -.5);
  499.   glTexCoord2f(n, 0);
  500.   glVertex2f(.5, -.5);
  501.   glTexCoord2f(0, n);
  502.   glVertex2f(-.5, .5);
  503.   glTexCoord2f(n, n);
  504.   glVertex2f(.5, .5);
  505.   glEnd();
  506. }
  508. void
  509. setBlurMap(void)
  510. {
  511.   int i;
  512.   unsigned short blur[256];
  514.   for (i = 0; i < 256; i++) {
  515.     float del = (i - focus) / 255.;
  516.     del *= del * spread * stencilMax;
  517.     blur[i] = del < stencilMax ? del : stencilMax;
  518.   }
  519.   glPixelMapusv(GL_PIXEL_MAP_S_TO_S, 256, blur);
  520. }
  522. void
  523. setKernel(void)
  524. {
  525. #ifdef GL_EXT_convolution
  526.   float s1 = expf(sharpness), s2 = expf(2 * sharpness);
  527.   kernel[0] = kernel[4] = s2;
  528.   kernel[1] = kernel[3] = s1;
  529.   kernel[2] = 1 - 2 * (s1 + s2);
  530.   glSeparableFilter2DEXT(GL_SEPARABLE_2D_EXT, GL_LUMINANCE,
  531.     kSize, kSize, GL_RED,
  532.     GL_FLOAT, kernel, kernel);
  533. #endif
  534. }
  536. void
  537. toggle(int *param, char *msg)
  538. {
  539.   *param = !*param;
  540.   if (msg)
  541.     printf("%s == %dn", msg, *param);
  542.   drawFrame(frame);
  543. }
  545. void
  546. changePassCount(int delta)
  547. {
  548.   passes += delta;
  549.   if (passes < 0)
  550.     passes = 0;
  551.   printf("number of passes == %dn", passes);
  552. }
  554. void
  555. resize(int w, int h)
  556. {
  557.   winWidth = w;
  558.   winHeight = h;
  559.   pixels = realloc(pixels, (winWidth + 4) * (winHeight + 4));
  560.   glViewport(0, 0, winWidth, winHeight);
  561. }