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

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

GIS编程

开发平台：

Visual C++

softshadow.c：源码内容
  2. /* softshadow.c - by Tom McReynolds, SGI */
  4. /* Using the accumulation buffer for soft shadows. */
  6. #include <GL/glut.h>
  7. #include <stdlib.h>
  9. /* Demonstrate the use of accumulation buffer to create soft shadows */
  11. /* Create a single component texture map */
  12. GLfloat *
  13. make_texture(int maxs, int maxt)
  14. {
  15.   int s, t;
  16.   static GLfloat *texture;
  18.   texture = (GLfloat *) malloc(maxs * maxt * sizeof(GLfloat));
  19.   for (t = 0; t < maxt; t++) {
  20.     for (s = 0; s < maxs; s++) {
  21.       texture[s + maxs * t] = ((s >> 4) & 0x1) ^ ((t >> 4) & 0x1);
  22.     }
  23.   }
  24.   return texture;
  25. }
  27. enum {
  28.   SPHERE = 1, CONE, LIGHT, LEFTWALL, FLOOR
  29. };
  31. /* create a matrix that will project the desired shadow */
  32. void
  33. shadowmatrix(GLfloat shadowMat[4][4],
  34.   GLfloat groundplane[4],
  35.   GLfloat lightpos[4])
  36. {
  37.   GLfloat dot;
  39.   /* find dot product between light position vector and ground plane normal */
  40.   dot = groundplane[0] * lightpos[0] +
  41.     groundplane[1] * lightpos[1] +
  42.     groundplane[2] * lightpos[2] +
  43.     groundplane[3] * lightpos[3];
  45.   shadowMat[0][0] = dot - lightpos[0] * groundplane[0];
  46.   shadowMat[1][0] = 0.f - lightpos[0] * groundplane[1];
  47.   shadowMat[2][0] = 0.f - lightpos[0] * groundplane[2];
  48.   shadowMat[3][0] = 0.f - lightpos[0] * groundplane[3];
  50.   shadowMat[0][1] = 0.f - lightpos[1] * groundplane[0];
  51.   shadowMat[1][1] = dot - lightpos[1] * groundplane[1];
  52.   shadowMat[2][1] = 0.f - lightpos[1] * groundplane[2];
  53.   shadowMat[3][1] = 0.f - lightpos[1] * groundplane[3];
  55.   shadowMat[0][2] = 0.f - lightpos[2] * groundplane[0];
  56.   shadowMat[1][2] = 0.f - lightpos[2] * groundplane[1];
  57.   shadowMat[2][2] = dot - lightpos[2] * groundplane[2];
  58.   shadowMat[3][2] = 0.f - lightpos[2] * groundplane[3];
  60.   shadowMat[0][3] = 0.f - lightpos[3] * groundplane[0];
  61.   shadowMat[1][3] = 0.f - lightpos[3] * groundplane[1];
  62.   shadowMat[2][3] = 0.f - lightpos[3] * groundplane[2];
  63.   shadowMat[3][3] = dot - lightpos[3] * groundplane[3];
  65. }
  67. enum {
  68.   X, Y, Z
  69. };
  70. enum {
  71.   A, B, C, D
  72. };
  74. /* find the plane equation given 3 points */
  75. void
  76. findplane(GLfloat plane[4],
  77.   GLfloat v0[3], GLfloat v1[3], GLfloat v2[3])
  78. {
  79.   GLfloat vec0[3], vec1[3];
  81.   /* need 2 vectors to find cross product */
  82.   vec0[X] = v1[X] - v0[X];
  83.   vec0[Y] = v1[Y] - v0[Y];
  84.   vec0[Z] = v1[Z] - v0[Z];
  86.   vec1[X] = v2[X] - v0[X];
  87.   vec1[Y] = v2[Y] - v0[Y];
  88.   vec1[Z] = v2[Z] - v0[Z];
  90.   /* find cross product to get A, B, and C of plane equation */
  91.   plane[A] = vec0[Y] * vec1[Z] - vec0[Z] * vec1[Y];
  92.   plane[B] = -(vec0[X] * vec1[Z] - vec0[Z] * vec1[X]);
  93.   plane[C] = vec0[X] * vec1[Y] - vec0[Y] * vec1[X];
  95.   plane[D] = -(plane[A] * v0[X] + plane[B] * v0[Y] + plane[C] * v0[Z]);
  96. }
  98. void 
  99. sphere(void)
  100. {
  101.   glPushMatrix();
  102.   glTranslatef(60.f, -50.f, -360.f);
  103.   glCallList(SPHERE);
  104.   glPopMatrix();
  105. }
  107. void 
  108. cone(void)
  109. {
  110.   glPushMatrix();
  111.   glTranslatef(-40.f, -40.f, -400.f);
  112.   glCallList(CONE);
  113.   glPopMatrix();
  115. }
  117. enum {
  118.   NONE, SHADOW
  119. };
  121. int rendermode = NONE;
  123. void
  124. menu(int mode)
  125. {
  126.   rendermode = mode;
  127.   glutPostRedisplay();
  128. }
  130. GLfloat leftwallshadow[4][4];
  131. GLfloat floorshadow[4][4];
  133. GLfloat lightpos[] =
  134. {50.f, 50.f, -320.f, 1.f};
  136. /* render while jittering the shadows */
  137. void
  138. render(GLfloat dx, GLfloat dy, GLfloat dz)
  139. {
  141.   /* material properties for objects in scene */
  142.   static GLfloat wall_mat[] =
  143.   {1.f, 1.f, 1.f, 1.f};
  144.   static GLfloat sphere_mat[] =
  145.   {1.f, .5f, 0.f, 1.f};
  146.   static GLfloat cone_mat[] =
  147.   {0.f, .5f, 1.f, 1.f};
  149.   glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  151.   /* Note: wall verticies are ordered so they are all front facing this lets
  152.      me do back face culling to speed things up.  */
  154.   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, wall_mat);
  156.   /* floor */
  157.   /* make the floor textured */
  158.   glEnable(GL_TEXTURE_2D);
  160.   /* Since we want to turn texturing on for floor only, we have to make floor 
  161.      a separate glBegin()/glEnd() sequence. You can't turn texturing on and
  162.      off between begin and end calls */
  163.   glBegin(GL_QUADS);
  164.   glNormal3f(0.f, 1.f, 0.f);
  165.   glTexCoord2i(0, 0);
  166.   glVertex3f(-100.f, -100.f, -320.f);
  167.   glTexCoord2i(1, 0);
  168.   glVertex3f(100.f, -100.f, -320.f);
  169.   glTexCoord2i(1, 1);
  170.   glVertex3f(100.f, -100.f, -520.f);
  171.   glTexCoord2i(0, 1);
  172.   glVertex3f(-100.f, -100.f, -520.f);
  173.   glEnd();
  175.   glDisable(GL_TEXTURE_2D);
  177.   if (rendermode == SHADOW) {
  179.     glDisable(GL_DEPTH_TEST);
  180.     glDisable(GL_LIGHTING);
  181.     glColor3f(0.f, 0.f, 0.f);  /* shadow color */
  183.     glPushMatrix();
  184.     glMultMatrixf((GLfloat *) floorshadow);
  185.     glTranslatef(dx, dy, dz);
  186.     cone();
  187.     glPopMatrix();
  189.     glPushMatrix();
  190.     glMultMatrixf((GLfloat *) floorshadow);
  191.     glTranslatef(dx, dy, dz);
  192.     sphere();
  193.     glPopMatrix();
  194.     glEnable(GL_DEPTH_TEST);
  195.     glEnable(GL_LIGHTING);
  196.   }
  197.   /* walls */
  199.   if (rendermode == SHADOW) {
  200.     glEnable(GL_STENCIL_TEST);
  201.     glStencilFunc(GL_ALWAYS, 1, 0);
  202.     glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  203.   }
  204.   glBegin(GL_QUADS);
  205.   /* left wall */
  206.   glNormal3f(1.f, 0.f, 0.f);
  207.   glVertex3f(-100.f, -100.f, -320.f);
  208.   glVertex3f(-100.f, -100.f, -520.f);
  209.   glVertex3f(-100.f, 100.f, -520.f);
  210.   glVertex3f(-100.f, 100.f, -320.f);
  211.   glEnd();
  213.   if (rendermode == SHADOW) {
  214.     glStencilFunc(GL_EQUAL, 1, 1);
  215.     glDisable(GL_DEPTH_TEST);
  216.     glDisable(GL_LIGHTING);
  217.     glColor3f(0.f, 0.f, 0.f);  /* shadow color */
  218.     glDisable(GL_DEPTH_TEST);
  219.     glPushMatrix();
  220.     glMultMatrixf((GLfloat *) leftwallshadow);
  221.     glTranslatef(dx, dy, dz);
  222.     cone();
  223.     glPopMatrix();
  224.     glEnable(GL_DEPTH_TEST);
  225.     glDisable(GL_STENCIL_TEST);
  226.     glEnable(GL_DEPTH_TEST);
  227.     glEnable(GL_LIGHTING);
  228.   }
  229.   glBegin(GL_QUADS);
  230.   /* right wall */
  231.   glNormal3f(-1.f, 0.f, 0.f);
  232.   glVertex3f(100.f, -100.f, -320.f);
  233.   glVertex3f(100.f, 100.f, -320.f);
  234.   glVertex3f(100.f, 100.f, -520.f);
  235.   glVertex3f(100.f, -100.f, -520.f);
  237.   /* ceiling */
  238.   glNormal3f(0.f, -1.f, 0.f);
  239.   glVertex3f(-100.f, 100.f, -320.f);
  240.   glVertex3f(-100.f, 100.f, -520.f);
  241.   glVertex3f(100.f, 100.f, -520.f);
  242.   glVertex3f(100.f, 100.f, -320.f);
  244.   /* back wall */
  245.   glNormal3f(0.f, 0.f, 1.f);
  246.   glVertex3f(-100.f, -100.f, -520.f);
  247.   glVertex3f(100.f, -100.f, -520.f);
  248.   glVertex3f(100.f, 100.f, -520.f);
  249.   glVertex3f(-100.f, 100.f, -520.f);
  250.   glEnd();
  252.   glPushMatrix();
  253.   glTranslatef(lightpos[X], lightpos[Y], lightpos[Z]);
  254.   glDisable(GL_LIGHTING);
  255.   glColor3f(1.f, 1.f, .7f);
  256.   glCallList(LIGHT);
  257.   glEnable(GL_LIGHTING);
  258.   glPopMatrix();
  260.   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cone_mat);
  261.   cone();
  263.   glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, sphere_mat);
  264.   sphere();
  266. }
  268. void
  269. redraw(void)
  270. {
  271.   int dx, dy, dz;
  273.   dy = 0;
  274.   /* jitter the light around */
  275.   if (rendermode == SHADOW) {
  276.     glClear(GL_ACCUM_BUFFER_BIT);
  277.     for (dz = -4; dz < 5; dz += 2) {
  278.       for (dx = -4; dx < 5; dx += 2) {
  279.         render((GLfloat) dx, (GLfloat) dy, (GLfloat) dz);
  280.         glAccum(GL_ACCUM, 1.f / 25);
  281.       }
  282.     }
  283.     glAccum(GL_RETURN, 1.f);
  284.   } else
  285.     render(0.f, 0.f, 0.f);
  287.   glutSwapBuffers();
  288. }
  290. /* ARGSUSED1 */
  291. void 
  292. key(unsigned char key, int x, int y)
  293. {
  294.   if (key == '33')
  295.     exit(0);
  296. }
  298. const int TEXDIM = 256;
  299. /* Parse arguments, and set up interface between OpenGL and window system */
  300. int
  301. main(int argc, char *argv[])
  302. {
  303.   GLfloat *tex;
  304.   GLUquadricObj *sphere, *cone, *base;
  305.   GLfloat plane[4];
  306.   GLfloat v0[3], v1[3], v2[3];
  308.   glutInit(&argc, argv);
  309.   glutInitWindowSize(512, 512);
  310.   glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_STENCIL | GLUT_DOUBLE | GLUT_ACCUM);
  311.   (void) glutCreateWindow("soft shadows");
  312.   glutDisplayFunc(redraw);
  313.   glutKeyboardFunc(key);
  315.   glutCreateMenu(menu);
  316.   glutAddMenuEntry("No Shadows", NONE);
  317.   glutAddMenuEntry("Shadows", SHADOW);
  318.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  320.   /* draw a perspective scene */
  321.   glMatrixMode(GL_PROJECTION);
  322.   glFrustum(-100., 100., -100., 100., 320., 640.);
  323.   glMatrixMode(GL_MODELVIEW);
  325.   /* turn on features */
  326.   glEnable(GL_DEPTH_TEST);
  327.   glEnable(GL_LIGHTING);
  328.   glEnable(GL_LIGHT0);
  330.   /* make shadow matricies */
  332.   /* 3 points on floor */
  333.   v0[X] = -100.f;
  334.   v0[Y] = -100.f;
  335.   v0[Z] = -320.f;
  336.   v1[X] = 100.f;
  337.   v1[Y] = -100.f;
  338.   v1[Z] = -320.f;
  339.   v2[X] = 100.f;
  340.   v2[Y] = -100.f;
  341.   v2[Z] = -520.f;
  343.   findplane(plane, v0, v1, v2);
  344.   shadowmatrix(floorshadow, plane, lightpos);
  346.   /* 3 points on left wall */
  347.   v0[X] = -100.f;
  348.   v0[Y] = -100.f;
  349.   v0[Z] = -320.f;
  350.   v1[X] = -100.f;
  351.   v1[Y] = -100.f;
  352.   v1[Z] = -520.f;
  353.   v2[X] = -100.f;
  354.   v2[Y] = 100.f;
  355.   v2[Z] = -520.f;
  357.   findplane(plane, v0, v1, v2);
  358.   shadowmatrix(leftwallshadow, plane, lightpos);
  360.   /* place light 0 in the right place */
  361.   glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  363.   /* remove back faces to speed things up */
  364.   glCullFace(GL_BACK);
  366.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  368.   /* make display lists for sphere and cone; for efficiency */
  370.   glNewList(SPHERE, GL_COMPILE);
  371.   sphere = gluNewQuadric();
  372.   gluSphere(sphere, 20.f, 20, 20);
  373.   gluDeleteQuadric(sphere);
  374.   glEndList();
  376.   glNewList(LIGHT, GL_COMPILE);
  377.   sphere = gluNewQuadric();
  378.   gluSphere(sphere, 5.f, 20, 20);
  379.   gluDeleteQuadric(sphere);
  380.   glEndList();
  382.   glNewList(CONE, GL_COMPILE);
  383.   cone = gluNewQuadric();
  384.   base = gluNewQuadric();
  385.   glRotatef(-90.f, 1.f, 0.f, 0.f);
  386.   gluDisk(base, 0., 20., 20, 1);
  387.   gluCylinder(cone, 20., 0., 60., 20, 20);
  388.   gluDeleteQuadric(cone);
  389.   gluDeleteQuadric(base);
  390.   glEndList();
  392.   glNewList(FLOOR, GL_COMPILE);
  393.   glEndList();
  395.   glNewList(LEFTWALL, GL_COMPILE);
  396.   glEndList();
  398.   /* load pattern for current 2d texture */
  399.   tex = make_texture(TEXDIM, TEXDIM);
  400.   glTexImage2D(GL_TEXTURE_2D, 0, 1, TEXDIM, TEXDIM, 0, GL_RED, GL_FLOAT, tex);
  401.   free(tex);
  403.   glutMainLoop();
  404.   return 0;             /* ANSI C requires main to return int. */
  405. }