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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
plvDraw.cc
资源名称：scanalyze-1.0.3_source_code.rar　[点击查看]
上传用户：kellyonhid
上传日期：2013-10-12
资源大小：932k
文件大小：31k
源码类别：

3D图形编程

开发平台：

Visual C++

plvDraw.cc：源码内容
  1. #include <tcl.h>
  2. #ifdef WIN32
  3. # include "winGLdecs.h"
  4. #endif
  5. #include <GL/gl.h>
  6. #include <GL/glu.h>
  7. #include <algo.h>
  8. #include <vector.h>
  9. #include "plvDraw.h"
  10. #include "plvScene.h"
  11. #include "plvGlobals.h"
  13. #ifdef no_overlay_support
  14. #include "plvDrawCmds.h" // overlay planes work around
  15. #endif
  17. #include "accpersp.h"
  18. #include "togl.h"
  19. #include "RigidScan.h"
  20. #include "DisplayMesh.h"
  21. #include "DrawObj.h"
  22. #include "plvClipBoxCmds.h"
  23. #include "BailDetector.h"
  24. #include "plvAnalyze.h"
  25. #include "defines.h"
  26. #include "TclCmdUtils.h"
  29. static void drawCenterOfRotation();
  30. static bool drawMeshes (bool bDrawAnnotations = true);
  31. static bool drawShadowedMeshes();
  32. static bool setupViewing (bool bFirstPass);
  33. static void setupLighting();
  34. static void setupShading();
  35. static void initRenderParams();
  38. static const int NUM_POWERS = 100;
  39. static const int NUM_POWER_ARGS = 5000;
  40. static float *thePowers;
  41. static int hiliteColor = -1;
  44. DrawObjects draw_other_things;
  47. bool
  48. initDrawing()
  49. {
  50.   float camera[3] = { 0, 0, 5 };
  51.   float object[3] = { 0, 0, 0 };
  52.   float up[3] = { 0, 1, 0 };
  53.   tbView->setup (camera, object, up, 10);
  54.   tbView->setOrthographic (false);
  56.   theScene->centerCamera();
  58.   initRenderParams();
  60.   thePowers = new float[NUM_POWERS*NUM_POWER_ARGS];
  61.   for (int i = 0; i < NUM_POWERS; i++) {
  62.     for (int j = 0; j < NUM_POWER_ARGS; j++) {
  63.       thePowers[j + i*NUM_POWER_ARGS] = 
  64. pow(float(j)/(NUM_POWER_ARGS-1), i);
  65.     }
  66.   }
  68.   return true;
  69. }
  72. bool
  73. initDrawingPostCreation()
  74. {
  75.   if (toglCurrent != NULL) {
  76.     initSelection (toglCurrent);
  78.     hiliteColor = Togl_AllocColorOverlay (toglCurrent, 0, 1, 1);
  79.     Togl_ShowOverlay (toglCurrent);
  80.   }
  82.   glLightModelfv (GL_LIGHT_MODEL_AMBIENT, theRenderParams->lightAmbient);
  83.   return true;
  84. }
  87. static void
  88. initRenderParams()
  89. {
  90.     theRenderParams = new RenderParams;
  91.     theRenderParams->polyMode = GL_FILL;
  92.     theRenderParams->hiddenLine = false;
  93.     theRenderParams->shadeModel = perVertex;
  94.     theRenderParams->cull = false;
  95.     theRenderParams->useTstrips = false;
  96.     theRenderParams->boundSelection = true;
  98.     theRenderParams->light = true;
  99.     theRenderParams->colorMode = grayColor;
  100.     theRenderParams->useEmissive = false;
  101.     theRenderParams->twoSidedLighting = false;
  102.     
  103.     // taken care of by two sided lighting
  104.     // kberg - 6/5/01
  105.     //theRenderParams->backFaceEmissive = false;
  107.     theRenderParams->backfaceMode = lit;
  109.     theRenderParams->confScale = 1;
  111.     theRenderParams->pointSize = 1.0;
  112.     theRenderParams->lineWidth = 1.0;
  114.     theRenderParams->blend = 0;
  115.     
  116.     theRenderParams->shininess = 20;
  118.     theRenderParams->specular[0] = 128;
  119.     theRenderParams->specular[1] = 128;
  120.     theRenderParams->specular[2] = 128;
  121.     theRenderParams->specular[3] = 255;
  123.     theRenderParams->diffuse[0] = 178; // .7 * 255
  124.     theRenderParams->diffuse[1] = 178;
  125.     theRenderParams->diffuse[2] = 178;
  126.     theRenderParams->diffuse[3] = 255;
  128.     /* added by kberg 6/5/01
  129.        paramters used when two sided lighting is turne don
  130.     */
  131.     theRenderParams->backDiffuse[0] = 25;
  132.     theRenderParams->backDiffuse[1] = 25;
  133.     theRenderParams->backDiffuse[2] = 25;
  134.     theRenderParams->backDiffuse[3] = 255;
  135.     
  136.     theRenderParams->backSpecular[0] = 18;
  137.     theRenderParams->backSpecular[1] = 18;
  138.     theRenderParams->backSpecular[2] = 18;
  139.     theRenderParams->backSpecular[3] = 255;
  140.     
  141.     theRenderParams->backShininess = 20;
  143.     theRenderParams->background[0] = 0;
  144.     theRenderParams->background[1] = 0;
  145.     theRenderParams->background[2] = 0;
  146.     theRenderParams->background[3] = 255;
  148.     theRenderParams->lightPosition[0] = 0.0;
  149.     theRenderParams->lightPosition[1] = 0.0;
  150.     theRenderParams->lightPosition[2] = 1.0;
  152.     theRenderParams->lightAmbient[0] = 0.0;
  153.     theRenderParams->lightAmbient[1] = 0.0;
  154.     theRenderParams->lightAmbient[2] = 0.0;
  155.     theRenderParams->lightAmbient[3] = 1.0;
  157.     theRenderParams->lightDiffuse[0] = 1.0;
  158.     theRenderParams->lightDiffuse[1] = 1.0;
  159.     theRenderParams->lightDiffuse[2] = 1.0;
  160.     theRenderParams->lightDiffuse[3] = 1.0;
  162.     theRenderParams->lightSpecular[0] = 1.0;
  163.     theRenderParams->lightSpecular[1] = 1.0;
  164.     theRenderParams->lightSpecular[2] = 1.0;
  165.     theRenderParams->lightSpecular[3] = 1.0;
  167.     theRenderParams->shadows = false;
  168.     theRenderParams->antiAlias = false;
  169.     theRenderParams->numAntiAliasSamps = 8;
  170.     theRenderParams->jitterX = 0;
  171.     theRenderParams->jitterY = 0;
  172.     theRenderParams->jitterArray = (jitter_point *)j8;
  173.     theRenderParams->dofJitterX = 0;
  174.     theRenderParams->dofJitterY = 0;
  175.     theRenderParams->dofCenter = 0.5; // ratio between near and far
  176.     theRenderParams->shadowLength = 0.05;
  177.     theRenderParams->fromLightPOV = false;
  179.     theRenderParams->flipnorm = false;
  180.     theRenderParams->clearBeforeRender = true;
  181.     theRenderParams->accelerateWithBbox = true;
  183.     theRenderParams->bRenderManipsPoints = true;
  184.     theRenderParams->bRenderManipsTinyPoints = false;
  185.     theRenderParams->bRenderManipsUnlit = false;
  186.     theRenderParams->bRenderManipsLores = false;
  187.     theRenderParams->bRenderManipsSkipDlist = true;
  188.     theRenderParams->iFastManipsThreshold = 0;
  189.     
  190. #ifdef no_overlay_support
  191.     // RGBA being read back in
  192.     theRenderParams->savedImage = new char[4 * theWidth * theHeight];
  193.     
  194.     theRenderParams->savedImageWidth = theWidth;
  195.     theRenderParams->savedImageHeight = theHeight;
  196. #endif
  197. }
  200. static bool
  201. setupViewing (bool bFirstPass)
  202. {
  203.   struct RenderParams* gRP = theRenderParams; // for convenience
  205.   // Viewport
  206.   int width = theWidth;
  207.   int height = theHeight;
  208.   if (theResCap > 0) {
  209.     width = min (theResCap, width);
  210.     height = min (theResCap, height);
  211.   }
  213.   glViewport((theWidth - width) / 2, (theHeight - height) / 2, width, height);
  214.   
  215.   // Prepare projection
  216.   tbView->applyProjection();
  218.   // if antialiasing, have to jitter projection matrix
  219.   if (gRP->antiAlias) {
  220.     if (!tbView->getOrthographic()) {
  221.       // perspective
  222.       // rebuild projection matrix with jitter code
  223.       float left, right, top, bottom, znear, zfar;
  224.       tbView->getFrustum (left, right, top, bottom, znear, zfar);
  226.       // zFocus = lerp (dofCenter, znear, zfar)
  227.       float zFocus = gRP->dofCenter * zfar + (1 - gRP->dofCenter) * znear;
  228.       // this doesn't actually work; I think to get true depth of field
  229.       // you have to call accFrustum a bunch of times as depth of what you 
  230.       // draw changes?  I can get this to draw things blurry as the scene
  231.       // approaches the camera, but a) not as they recede from the camera,
  232.       // and b) it draws the whole scene with the same blurriness, regardless
  233.       // of how far individual objects are from camera.
  234.       
  235.       accFrustum (left, right, top, bottom, znear, zfar,
  236.   gRP->jitterX, gRP->jitterY,
  237.   gRP->jitterX * gRP->dofJitterX,
  238.   gRP->jitterY * gRP->dofJitterY,
  239.   zFocus);
  240.     } else {
  241.       // orthographic
  242.       // have to modify projection matrix with jitter code
  243.       float heightAngle, aspectRatio, nearDistance, farDistance;
  244.       tbView->getProjection(heightAngle, 
  245.     aspectRatio,
  246.     nearDistance, 
  247.     farDistance);
  249.       float cameraHeight = tbView->getOrthoHeight();
  250.       glTranslatef(gRP->jitterX * cameraHeight * aspectRatio / theWidth,
  251.    gRP->jitterY * cameraHeight / theHeight,
  252.    0.0);
  253.     }
  254.   }
  255.     
  256.   // Prepare viewing orientation/trans
  257.   if (bFirstPass)    tbView->applyXform();   // apply spin()
  258.   else               tbView->reapplyXform(); // no spin
  260.   return true;
  261. }
  265. static void
  266. setupLighting()
  267. {
  268.   if (theRenderParams->light) {
  269.     // Enable lighting
  270.     glEnable (GL_LIGHTING);
  271.     glEnable (GL_LIGHT0);
  272.     
  273.     glMatrixMode (GL_MODELVIEW);
  274.     glPushMatrix();
  275.     glLoadIdentity();
  277.     // if rendering with "flipped" normals, actually flip light dir
  278.     if (theRenderParams->flipnorm)
  279.       glRotatef (180, 0, 1, 0);
  280.     
  281.     glLightfv (GL_LIGHT0, GL_POSITION, theRenderParams->lightPosition);
  282.     glLightfv (GL_LIGHT0, GL_AMBIENT, theRenderParams->lightAmbient);
  283.     glLightfv (GL_LIGHT0, GL_DIFFUSE, theRenderParams->lightDiffuse);
  284.     glLightfv (GL_LIGHT0, GL_SPECULAR, theRenderParams->lightSpecular);
  286.     glPopMatrix();
  287.   } else {
  288.     glDisable (GL_LIGHTING);
  289.   }
  290. }
  294. static void
  295. setupShading()
  296. {
  297.   if (theRenderParams->shadeModel == perVertex)
  298.     glShadeModel(GL_SMOOTH);
  299.   else
  300.     glShadeModel(GL_FLAT);
  302.   //this is for the old pseudo-hidden line draw mode --
  303.   //draw front faces outline and back faces solid black
  304.   //glPolygonMode(GL_FRONT, theRenderParams->polyMode);
  306.   // depending on whether normals are flipped, specify the orientation
  307.   // of the faces - removed from if (...->cull) by kberg 7/5/01 so that
  308.   // flipping normals did not cause nothing to be drawn when 2 sided lighting
  309.   // was selected
  310.   glFrontFace (theRenderParams->flipnorm ? GL_CW : GL_CCW);
  312.   // don't cull back faces if two sided lighting is enabled
  313.   if (theRenderParams->cull && !theRenderParams->twoSidedLighting) {
  314.     glEnable (GL_CULL_FACE);
  315.   } else {
  316.     glDisable (GL_CULL_FACE);
  317.   }
  319.   //two sided lighting will take care of this
  320.   //glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, theRenderParams->backFaceEmissive);
  321.   glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, theRenderParams->twoSidedLighting);
  322. }
  325. bool
  326. setupSceneDrawing()
  327. {
  328.   theScene->computeBBox (Scene::flush);
  330.   // Prepare buffer
  331.   glDepthFunc(GL_LESS);
  332.   glEnable(GL_DEPTH_TEST);
  334.   // Lighting
  335.   setupLighting();
  336.   setupShading();
  338.   // Viewing
  339.   setupViewing (true);
  340.   
  341.   // clear buffer
  342.   if (theRenderParams->clearBeforeRender) {
  343.     glClearColor(theRenderParams->background[0] / 255.,
  344.  theRenderParams->background[1] / 255.,
  345.  theRenderParams->background[2] / 255.,
  346.  theRenderParams->background[3] / 255.);
  347.   }
  349.   // bbox-clipping for this render pass?
  350.   theRenderParams->accelerateWithBbox = GetTclGlobalBool ("noclip");
  352.   if (theRenderParams->accelerateWithBbox) {
  353.     // if the whole scene is onscreen, bbox clipping for individual
  354.     // meshes is a waste of time.
  355.     ScreenBox* filter = new ScreenBox (NULL,
  356.      0, Togl_Width(toglCurrent) - 1,
  357.      0, Togl_Height(toglCurrent) - 1);
  358.     if (filter->acceptFully (theScene->worldBbox())) {
  359.       //cout << "Whole scene onscreen; no need to clip test" << endl;
  360.       theRenderParams->accelerateWithBbox = false;
  361.     }
  362.     delete filter;
  363.   }
  365.   return true;
  366. }
  369. bool
  370. drawScene()
  371. {
  372.   if (!setupSceneDrawing())
  373.     return false;
  375.   if (theRenderParams->antiAlias) {
  377.     glClear(GL_ACCUM_BUFFER_BIT);
  378.     for (int i = 0; i < theRenderParams->numAntiAliasSamps; i++) {
  379.       printf("rRender pass %d of %d...", i+1,
  380.      theRenderParams->numAntiAliasSamps);
  381.       fflush(stdout);
  382.       
  383.       theRenderParams->jitterX = theRenderParams->jitterArray[i].x;
  384.       theRenderParams->jitterY = theRenderParams->jitterArray[i].y;
  385.       
  386.       // Viewing
  387.       setupViewing (i == 0);
  388.       drawShadowedMeshes();
  389.       
  390.       glAccum(GL_ACCUM, 1.0/theRenderParams->numAntiAliasSamps);
  391.       if (GetTclGlobalBool ("aaswap"))
  392. Togl_SwapBuffers (toglCurrent);
  393.     }
  395.     glAccum(GL_RETURN, 1.0);
  396.     printf("Antialiased render (%d passes) complete.n", i);
  398.   } else {
  400.     drawShadowedMeshes();
  402.   }
  404.   if (!(   GetTclGlobalBool ("highQualSingle")
  405. && GetTclGlobalBool ("highQualHideBbox"))) {
  407.     if (theScene->wantMeshBBox()) {
  408.       drawBoundingBox (theScene->worldBbox());
  409.     }
  410.     
  411.     // bugnote, do this last b/c it hoses render modes
  412.     drawCenterOfRotation();
  413.   }
  414.  
  415. #ifdef no_overlay_support
  416.   // only allocate new memory if the window has been resized
  417.   if (theRenderParams->savedImageWidth != theWidth || 
  418.       theRenderParams->savedImageHeight != theHeight) {
  419.     delete [] theRenderParams->savedImage;
  420.     
  421.     theRenderParams->savedImageWidth = theWidth;
  422.     theRenderParams->savedImageHeight = theHeight;
  423.   
  424.     theRenderParams->savedImage = new char[theWidth*theHeight*4];
  425.   }
  427.   glReadBuffer(GL_BACK);
  428.   glReadPixels(0,0,theWidth, theHeight, GL_RGBA, GL_UNSIGNED_BYTE, 
  429.        theRenderParams->savedImage);
  431.   drawOverlay(toglCurrent);
  432. #endif
  434.   return true;
  435. }
  438. static void 
  439. initTextureParmsForShadowMap(void)
  440. {
  441. #ifdef GL_SGIX_shadow
  442.   glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
  443.   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  444.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  445.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  446.   
  447.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  448.   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  449.   
  450.   glTexParameterf(GL_TEXTURE_2D, GL_SHADOW_AMBIENT_SGIX, 0.3);
  451.   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_OPERATOR_SGIX,
  452.   GL_TEXTURE_LEQUAL_R_SGIX);
  454.   // Enable texgen to get texture-coods (x, y, z, w) at every point.These
  455.   // texture co-ordinates are then transformed by the texture matrix.
  456.   glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  457.   glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  458.   glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  459.   glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  461.   GLfloat p[4];
  462.   p[0] = 1.0;
  463.   p[1] = p[2] = p[3] = 0.0;
  464.   glTexGenfv(GL_S, GL_OBJECT_PLANE, p);
  466.   p[0] = 0.0;
  467.   p[1] = 1.0;
  468.   p[2] = p[3] = 0.0;
  469.   glTexGenfv(GL_T, GL_OBJECT_PLANE, p);
  471.   p[0] = p[1] = 0.0;
  472.   p[2] = 1.0, p[3] = 0.0;
  473.   glTexGenfv(GL_R, GL_OBJECT_PLANE, p);
  475.   p[0] = p[1] = p[2] = 0.0;
  476.   p[3] = 1.0;
  477.   glTexGenfv(GL_Q, GL_OBJECT_PLANE, p);
  479.   glEnable(GL_TEXTURE_GEN_S);
  480.   glEnable(GL_TEXTURE_GEN_T);
  481.   glEnable(GL_TEXTURE_GEN_R);
  482.   glEnable(GL_TEXTURE_GEN_Q);
  483. #endif
  484. }
  486. static float lightview_mat[16] = {0};
  487. static float lightview_proj_mat[16] = {0};
  489. static bool
  490. drawMeshesFromLightView (void)
  491. {
  492.   // may need to render to back buffer to get info about where to position 
  493.   // "light-cam" and have relevant area onscreen
  494.   bool bReadFromFront = true;
  495.   if (theRenderParams->fromLightPOV
  496.       || !GetTclGlobalBool ("shadowFastPass")) {
  497.     drawMeshes();
  498.     bReadFromFront = false;
  499.   }
  501.   int vp[4];
  502.   glGetIntegerv(GL_VIEWPORT, vp);
  503.   int curWidth = vp[2], curHeight = vp[3];
  505.   // first, calculate desired light angle:
  506.   Pnt3 current (0, 0, 1);
  507.   Pnt3 wanted (theRenderParams->lightPosition);
  509.   // if we're antialiasing, also jitter light for soft shadows
  510.   if (theRenderParams->antiAlias) {
  511.     Pnt3 jitter (theRenderParams->jitterX, theRenderParams->jitterY, 0);
  512.     jitter *= theRenderParams->shadowLength;
  513.     wanted += jitter;
  514.   }
  516.   // and rotation center:
  517.   // first get camera parms
  518.   float sceneCenter[3]; tbView->getRotationCenter (sceneCenter);
  519.   float cameraCenter[3]; tbView->getCameraCenter (cameraCenter);
  520.   float viewRot[4][4], viewTrans[3];
  521.   tbView->getXform(viewRot,viewTrans);
  523.   // try to get rotation center from center of screen instead of scene bbox
  524.   Pnt3 objectCenter;
  525.   if (!findZBufferNeighborExt (curWidth / 2, curHeight / 2, objectCenter,
  526.        toglCurrent, tbView, 100,
  527.        NULL, false, bReadFromFront)) {
  528.     objectCenter = sceneCenter;
  529.   }
  530.   if (GetTclGlobalBool ("shadowHackCenter", "false"))
  531.     objectCenter = sceneCenter;
  533.   // get corners, sides while we're at it
  534.   vector<Pnt3> cornerPos;
  535.   for (int i = 0; i < 8; i++) {
  536.     int x = (i & 1) ? 0 : curWidth - 1;
  537.     int y = (i & 2) ? 0 : curHeight - 1;
  538.     if (i >= 4) {
  539.       if (x) {
  540. x /= 2;
  541.       } else {
  542. if (y)
  543.   x = curWidth - 1;
  544. y = curHeight / 2;
  545.       }
  546.     }
  547.     Pnt3 corner;
  548.     if (findZBufferNeighborExt (x, y, corner, toglCurrent, tbView, 100,
  549. NULL, false, bReadFromFront)) {
  550.       //cerr << "accept screen corner " << x << ", " << y 
  551.       //   << ": " << corner << endl;
  552.       cornerPos.push_back (corner);
  553.     }
  554.   }
  555.   // and toss in any corners of the scene bbox that fall onscreen
  556.   ScreenBox screen (NULL, 0, curWidth-1, 0, curHeight-1);
  557.   const Bbox& bb = theScene->worldBbox();
  558.   for (i = 0; i < 8; i++) {
  559.     if (screen.accept (bb.corner(i))) {
  560.       cornerPos.push_back (bb.corner (i));
  561.       //cerr << "accept bb corner " << i << endl;
  562.     }
  563.   }
  564.   
  565.   // now start setting matrices the way we need them
  566.   glMatrixMode (GL_MODELVIEW);
  567.   glPushMatrix();
  568.   glLoadIdentity();
  570.   // rotate to light direction
  571.   Pnt3 axis = cross (current, wanted);
  572.   if (axis.norm2() > 0.0) {
  573.     float angle = dot (current, wanted);
  574.     angle = -180 / M_PI * acos (angle);
  575.     if (!GetTclGlobalBool ("shadowHackRotate", false))
  576.       glRotatef (angle, axis[0], axis[1], axis[2]);
  577.   }
  579.   // apply viewing xform (rotation only) so we're looking at correct face
  580.   glMultMatrixf (&viewRot[0][0]);
  582.   // translate back to object coords
  583.   glTranslatef (-objectCenter[0], -objectCenter[1], -objectCenter[2]);
  585.   // set up orthographic projection (since directional light)
  586.   glMatrixMode (GL_PROJECTION);
  587.   float oldProj[16];
  588.   glGetFloatv (GL_PROJECTION_MATRIX, oldProj);
  590.   float dummy, aspect, znear, zfar;
  591.   tbView->getProjection(dummy, aspect, znear, zfar);
  592.   float orthoHeight = tbView->getOrthoHeight();
  593.   float halfScene = theScene->sceneRadius(); // conservative
  594.   glLoadIdentity();
  595.   glOrtho(-orthoHeight/2*aspect, orthoHeight/2*aspect,
  596.   -orthoHeight/2, orthoHeight/2,
  597.         -halfScene, +halfScene);
  598.   glGetFloatv (GL_PROJECTION_MATRIX, lightview_proj_mat);
  600.   glMatrixMode (GL_MODELVIEW);
  601.   // zoom scene (part rendered from camera view) so that it fits onscreen
  602.   // and try to get it to fill screen, since shadow resolution is
  603.   // screen-space dependent
  604.   float shadScale = atof (GetTclGlobal ("shadowZoom", "1.0"));
  606.   // and now we want to move the scene so the old viewport bbox is still
  607.   // centered and fills the new viewport.
  608.   Projector proj;
  609.   int x1 = 1e6, x2 = -1e6, y1 = 1e6, y2 = -1e6;
  610.   for (i = 0; i < cornerPos.size(); i++) {
  611.     cornerPos[i] = proj (cornerPos[i]);
  612.     x1 = MIN (x1, cornerPos[i][0]);
  613.     x2 = MAX (x2, cornerPos[i][0]);
  614.     y1 = MIN (y1, cornerPos[i][1]);
  615.     y2 = MAX (y2, cornerPos[i][1]);
  616.   }
  617.   int dx = x2 - x1; int dy = y2 - y1;
  619.   int tx = (curWidth - (x1 + x2)) / 2;
  620.   int ty = (curHeight - (y1 + y2)) / 2;
  622.   float scale = MIN ((float)curWidth / dx, (float)curHeight / dy);
  623.   scale *= .9; // slightly conservative
  624.   scale *= shadScale;
  625.   cerr << "Using " << scale 
  626.        << " as shadow scale factor; set shadowZoom to change" << endl;
  627.   
  628.   // apply scale, translate on right
  629.   glGetFloatv (GL_MODELVIEW_MATRIX, lightview_mat);
  630.   glLoadIdentity(); 
  631.   glScalef (scale, scale, 1.0); // z=1 b/c ortho, so doesn't matter, and
  632. // we don't want to hose clipping planes
  633.   if (!GetTclGlobalBool ("shadowHackTranslate", false)) {
  634.     glTranslatef (tx * scale, ty * scale, 0);
  635.   }
  636.   glMultMatrixf (lightview_mat);
  638.   // save for retexturing
  639.   glGetFloatv (GL_MODELVIEW_MATRIX, lightview_mat);
  641.   bool ret = drawMeshes (false);
  643.   glMatrixMode (GL_PROJECTION);
  644.   glLoadIdentity();
  645.   glMultMatrixf (oldProj);
  646.   glMatrixMode (GL_MODELVIEW);
  647.   glPopMatrix();
  649.   return ret;
  650. }
  653. static void dumpGLerror (void)
  654. {
  655.   while (int a = glGetError()) {
  656.     cerr << "GL error: " << a << endl << flush;
  657.   }
  658. }
  661. static bool
  662. generateShadowMap (void)
  663. {
  664. #ifdef GL_SGIX_shadow
  665.   int x, y;
  666.   GLfloat log2 = log(2.0);
  668.   x = 1 << ((int) (log((float) theWidth) / log2));
  669.   y = 1 << ((int) (log((float) theHeight) / log2));
  670.   glViewport(0, 0, x, y);
  672.   initTextureParmsForShadowMap();
  673.   glEnable (GL_POLYGON_OFFSET_FILL);
  674.   char* of1 = GetTclGlobal ("shadowOffset1", "3");
  675.   char* of2 = GetTclGlobal ("shadowOffset2", "0");
  676.   glPolygonOffset (atof (of1), atof (of2));
  677.   bool ret = drawMeshesFromLightView();
  678.   glDisable (GL_POLYGON_OFFSET_FILL);
  680.   if (ret) {
  681.     // Read in frame-buffer into a depth texture map
  682.     // do NOT remove the glError calls (either one) or it hoses the pipe!
  683.     // really the problem is some context switching/synchronization error
  684.     // look at /usr/adm/crash/diag/gfx/IR/*.rslt for fun
  685.     // but really make sure not to run gr_osview while running this.'
  686.     // calling glGetError() causes it to occur much less frequently,
  687.     // but doesn't stop it entirely.
  688.     dumpGLerror();
  689.     //cerr << "extracting texture:" << endl;
  690.     glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16_SGIX,
  691.      0, 0, x, y, 0);
  692.     dumpGLerror();
  693.   }
  695.   glViewport(0, 0, theWidth, theHeight);
  696.   return ret;
  697. #endif
  698. }
  701. bool
  702. drawShadowedMeshes (void)
  703. {
  704. #ifdef GL_SGIX_shadow
  705.   if (theRenderParams->fromLightPOV) {
  707.     return drawMeshesFromLightView();
  709.   } else if (theRenderParams->shadows) {
  711.     // algorithm from Siggraph 99 course notes, OpenGL advanced
  712.     // techniques, section 11.4.3: shadow maps
  713.     // also Tom McReynolds' shadowmap.c sample
  714.     if (!generateShadowMap())
  715.       return false;
  716.     
  717.     // Now render the normal scene using projective textures to get the depth
  718.     // value from the light's point of view into the r-cood of the texture.
  719.     glEnable(GL_TEXTURE_2D);
  721.     glMatrixMode (GL_TEXTURE);
  722.     glLoadIdentity();
  723.     glTranslatef (0.5, 0.5, 0.4994); // magic numbers?
  724.     glScalef (0.5, 0.5, 0.5);
  725.     glMultMatrixf (lightview_proj_mat);
  726.     glMultMatrixf (lightview_mat);
  727.     glMatrixMode (GL_MODELVIEW);
  729.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_SGIX, GL_TRUE);
  730.     bool ret = drawMeshes();
  732.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_SGIX, GL_FALSE);
  733.     glDisable (GL_TEXTURE_2D);
  734.     return ret;
  736.   } else {
  738.     return drawMeshes();
  740.   }
  741. #else
  742.     return drawMeshes();
  743. #endif
  744. }
  747. bool
  748. drawSceneIndexColored (int scale = 1)
  749. {
  750.   PushRenderParams();
  751.   theRenderParams->polyMode = GL_FILL;
  752.   theRenderParams->hiddenLine = false;
  753.   theRenderParams->shadeModel = fakePerFace;
  754.   theRenderParams->colorMode = noColor;
  755.   theRenderParams->light = false;
  756.   theRenderParams->useEmissive = false;
  757.   theRenderParams->antiAlias = false;
  758.   theRenderParams->boundSelection = false;
  759.   theRenderParams->blend = false;
  760.   theRenderParams->diffuse[0] = 0;
  761.   theRenderParams->diffuse[1] = 0;
  762.   theRenderParams->diffuse[2] = 0;
  763.   theRenderParams->diffuse[3] = 255;
  764.   theRenderParams->background[0] = 0;
  765.   theRenderParams->background[1] = 0;
  766.   theRenderParams->background[2] = 0;
  767.   theRenderParams->background[3] = 255;
  769.   setupSceneDrawing();
  770.   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  771.   for (int i = 0; i < theScene->meshSets.size(); i++) {
  772.     // encode mesh index as 3 floats, suitable for representation in
  773.     // quantized 15-bit (or better) frame buffer.  Allows 32767 meshes.
  774.     int is = (i + 1) * scale;
  775.     uchar r = is % 32;
  776.     uchar g = (is / 32) % 32;
  777.     uchar b = is / 1024;
  779.     theRenderParams->diffuse[0] = r * 8;
  780.     theRenderParams->diffuse[1] = g * 8;
  781.     theRenderParams->diffuse[2] = b * 8;
  783.     // sanity check to make sure packing/unpacking works right
  784.     int i2 = b * 1024 + g * 32 + r;
  785.     i2 /= scale;
  786.     assert (i2 == i + 1);
  788.     theScene->meshSets[i]->drawSelf (false);
  789.   }
  791.   PopRenderParams();
  793.   return true;
  794. }
  797. bool
  798. drawSceneThicknessColored (void)
  799. {
  800.   // draw once normally...
  801.   if (!setupSceneDrawing())
  802.     return false;
  803.   PushRenderParams();
  804.   theRenderParams->boundSelection = false;
  805.   drawMeshes();
  807.   // save the near z-buffer
  808.   vector<Pnt3> nearPts, farPts;
  809.   Selection screen;
  810.   screen.type = Selection::rect;
  811.   screen.pts.push_back (Selection::Pt (0, 0));
  812.   screen.pts.push_back (Selection::Pt (0, theHeight));
  813.   screen.pts.push_back (Selection::Pt (theWidth, theHeight));
  814.   screen.pts.push_back (Selection::Pt (theWidth, 0));
  815.   if (!ReadZBufferArea (nearPts, screen, true, false)) {
  816.     PopRenderParams();
  817.     return false;
  818.   }
  820.   // then clear everything, and draw again with reversed depth test
  821.   glClearDepth (0);
  822.   setupSceneDrawing();
  823.   glClearDepth (1);
  824.   glDepthFunc (GL_GREATER);
  825.   drawMeshes();
  827.   // save the far z-buffer
  828.   if (!ReadZBufferArea (farPts, screen, true, false, true)) {
  829.     PopRenderParams();
  830.     return false;
  831.   }
  833.   // create a nice visualization of this
  834.   vector<unsigned int> depth;
  835.   depth.reserve (theWidth * theHeight);
  836.   for (int y = 0; y < theHeight; y++) {
  837.     int yofs = y * theWidth;
  838.     for (int x = 0; x < theWidth; x++) {
  839.       float nz = nearPts [yofs + x] [2];
  840.       float fz = farPts [yofs + x] [2];
  841.       if (nz != 0 && fz != 0) {
  842. depth.push_back (((255 - (int)MIN (255, (nz-fz) * 10)) << 16)
  843.  + 65535 + (255<<24));
  844. //printf ("%f %f %xn", nz, fz, depth.back());
  845.       } else {
  846. depth.push_back (0);
  847.       }
  848.     }
  849.   }
  851.   // and blit it to screen.
  852.   glMatrixMode (GL_PROJECTION);
  853.   glLoadIdentity();
  854.   glMatrixMode (GL_MODELVIEW);
  855.   glLoadIdentity();
  856.   glDisable (GL_DEPTH_TEST);
  857.   glRasterPos2f (-1, -1);
  858.   glDrawPixels (theWidth, theHeight, GL_RGBA, GL_UNSIGNED_BYTE, depth.begin());
  859.   while (int err = glGetError()) {
  860.     cerr << "Error: " << err << endl;
  861.   }
  863.   PopRenderParams();
  864.   return true;
  865. }
  868. bool
  869. drawScanHilites (void)
  870. {
  871.   char* which = GetTclGlobal ("showScanHilites", "");
  872.   if (!strcmp (which, "never"))
  873.     return false;
  875.   bool bInvis = (0 == strcmp (which, "always"));
  877.   int nToHilite = g_hilitedScans.size();
  878.   if (nToHilite) {
  879.     setupViewing (false);
  880. #ifndef no_overlay_support
  881.     glIndexi (hiliteColor);
  882. #else
  883.     glColor3f(0,1,1);
  884. #endif
  886.     for (int i = 0; i < nToHilite; i++) {
  887.    
  888.       if (bInvis || g_hilitedScans[i]->getVisible()) {
  889. glMatrixMode (GL_MODELVIEW);
  890. glPushMatrix();
  891. g_hilitedScans[i]->getMeshData()->gl_xform();
  892. drawBoundingBox (g_hilitedScans[i]->getMeshData()->localBbox(),
  893.  false);
  894. glPopMatrix();
  895.       }
  896.     }
  897.   }
  899.   return true;
  900. }
  903. static void
  904. drawCenterOfRotation()
  905. {
  906.   if (g_tclInterp != NULL) {
  907.     if (GetTclGlobalBool ("rotCenterVisible")) {
  908.       //show center of rotation
  909.       float redcolor[3] = { .5, 0, 0 };
  910.       Pnt3 center;
  911.       glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, redcolor);
  913.       if (theActiveScan == NULL) {
  914. tbView->getRotationCenter (center);
  915.       } else {
  916. center = theActiveScan->getMeshData()->worldCenter();
  917.       }
  919.       glTranslatef(center[0],center[1], center[2]);
  920.       if (GetTclGlobalBool ("rotCenterOnTop"))
  921. glDisable (GL_DEPTH_TEST);
  922.       GLUquadric* quad;
  923.       quad = gluNewQuadric();
  924.       gluSphere (quad, theScene->sceneRadius() / 100, 10, 10);
  925.       gluDeleteQuadric (quad);
  926.     }
  927.   }
  928. }
  931. static bool
  932. drawMeshes (bool bDrawAnnotations)
  933. {
  934.   int k;
  935.   int nMeshes = theScene->meshSets.size();
  936.   BailDetector bail;
  938.   // clear before rendering
  939.   if (theRenderParams->clearBeforeRender)
  940.     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  942.   // ensure that bounding box is up-to-date
  943.   theScene->computeBBox (Scene::flush);
  945.   if (GetTclGlobalBool ("renderOnlyActiveMesh")) {
  946.     theSelectedScan->drawSelf();
  947.   } else {
  948.     // two passes, draw opaque meshes then transparent ones
  949.     for (k = 0; k < nMeshes; k++) {
  950.       
  951.       if (!theScene->meshSets[k]->transparent()) {
  952. theScene->meshSets[k]->drawSelf();
  953. //int g = 255 * ++i / nMeshes;
  954. //sprintf (cmd, "redrawStatus #%02x%02x00", 255 - g, g);
  955. //Tcl_Eval (g_tclInterp, cmd);
  957. if (bail())
  958.   break;
  959.       }
  960.     }
  961.     
  962.     for (k = 0; k < nMeshes; k++) {
  963.       
  964.       if (theScene->meshSets[k]->transparent()) {
  965. theScene->meshSets[k]->drawSelf();
  966. //int g = 255 * ++i / nMeshes;
  967. //sprintf (cmd, "redrawStatus #%02x%02x00", 255 - g, g);
  968. //Tcl_Eval (g_tclInterp, cmd);
  970. if (bail())
  971.   break;
  972.       }
  973.     }
  974.   }
  976.   if (bDrawAnnotations) {
  977.     draw_other_things();
  978.   }
  979.   
  980.   return true;
  981. }
  984. static void
  985. glvtx(const Pnt3 &p)
  986. {
  987.   glVertex3fv(&p[0]);
  988. }
  991. void
  992. drawBoundingBox (const Bbox& box, bool bUseDefaultColor)
  993. {
  994.   vector<Pnt3> bbox_edges(24);
  996.   // don't draw the bounding box if the max is less than the min
  997.   if (box.max()[0] < box.min()[0] && 
  998.       box.max()[1] < box.min()[1] &&
  999.       box.max()[2] < box.min()[2])
  1000.     return;
  1002.   if (bUseDefaultColor)
  1003.     glColor3f (1, 0, 0);
  1005.   glPushAttrib (GL_LIGHTING_BIT);
  1006.   glDisable (GL_LIGHTING);
  1007.   box.edgeList(bbox_edges);
  1008.   glBegin(GL_LINES);
  1009.   for_each(bbox_edges.begin(), bbox_edges.end(), glvtx);
  1010.   glEnd();
  1011.   glPopAttrib();
  1012. }
  1015. static vector<RenderParams> renderParamsStack;
  1017. void
  1018. PushRenderParams (void)
  1019. {
  1020.   renderParamsStack.push_back (*theRenderParams);
  1021. }
  1024. void
  1025. PopRenderParams (void)
  1026. {
  1027.   assert (renderParamsStack.size() > 0);
  1028.   *theRenderParams = renderParamsStack.back();
  1029.   renderParamsStack.pop_back();
  1030. }
  1035. #if 0  // texture code inactive
  1037. #ifdef WIN32
  1038. #undef PARALLEL //revisit this someday?  I just did it to get
  1039.                 //this to compile... -- magi
  1040. #else
  1041. #include <ulocks.h>
  1042. #include <task.h>
  1043. #include <unistd.h>
  1044. #define PARALLEL
  1045. #endif
  1047. #include "Xform.h"
  1049. void texLightDiff(MeshSet *meshSet);
  1050. void texLightAll(MeshSet *meshSet);
  1053. void
  1054. texLightDiff(MeshSet *meshSet)
  1055. {
  1056.    int nx, ny, nz;
  1057.    int color;
  1059. #ifdef PARALLEL
  1060.    int myid = m_get_myid();
  1061.    int processes = m_get_numprocs();
  1062. #else
  1063.    int myid = 0;
  1064.    int processes = 1;
  1065. #endif
  1067.    int start = (meshSet->texXdim * meshSet->texYdim)/processes * myid;
  1068.    int stop = (meshSet->texXdim * meshSet->texYdim)/processes * (myid+1);
  1070.    float lx = theRenderParams->lightPosition[0];
  1071.    float ly = theRenderParams->lightPosition[1];
  1072.    float lz = theRenderParams->lightPosition[2];
  1074.    Xform<float> rotxf;
  1075.    float q[4], t[3];
  1076.    tbView->getXform(q,t);
  1077.    rotxf.rotQ(q[0], q[1], q[2], q[3]);
  1078.    rotxf = rotxf * meshSet->getXform();
  1080.    Pnt3 light(lx,ly,lz), newLight;
  1081.    rotxf.apply(light, newLight);
  1083.    lx = newLight[0]*theRenderParams->diffuse[0]*2;
  1084.    ly = newLight[1]*theRenderParams->diffuse[0]*2;
  1085.    lz = newLight[2]*theRenderParams->diffuse[0]*2;
  1087.    uchar *buf = meshSet->texture + start*3;
  1088.    uchar *newBuf = meshSet->newTexture + start;
  1089.    float diff;
  1091.    for (int i=start; i < stop; i++) {
  1092.       nx = int(*buf++ - 128);
  1093.       ny = int(*buf++ - 128);
  1094.       nz = int(*buf++ - 128);
  1096.       diff = nx*lx + ny*ly + nz*lz;
  1097.       if (diff > 0) {
  1098.  color = uchar(diff);
  1099.  if (color < 0)
  1100.     *newBuf++ = 0;
  1101.  else if (color > 255)
  1102.     *newBuf++=  255;
  1103.  else
  1104.     *newBuf++ = color;
  1105.       } 
  1106.       else {
  1107.  *newBuf++ = 0;
  1108.       }
  1109.    }
  1110. }
  1111.     
  1113. void
  1114. texLightAll(MeshSet *meshSet)
  1115. {
  1116.   int nx, ny, nz;
  1117.   int color;
  1119. #ifdef PARALLEL
  1120.   int myid = m_get_myid();
  1121.   int processes = m_get_numprocs();
  1122. #else
  1123.   int myid = 0;
  1124.   int processes = 1;
  1125. #endif
  1127.   Xform<float> rotxf;
  1128.   float q[4], t[3];
  1129.   tbView->getXform(q,t);
  1130.   rotxf.rotQ(q[0], q[1], q[2], q[3]);
  1131.   rotxf = rotxf * meshSet->getXform();
  1133.   int start = (meshSet->texXdim * meshSet->texYdim)/processes * myid;
  1134.   int stop = (meshSet->texXdim * meshSet->texYdim)/processes * (myid+1);
  1136.   float lx = theRenderParams->lightPosition[0];
  1137.   float ly = theRenderParams->lightPosition[1];
  1138.   float lz = theRenderParams->lightPosition[2];
  1140.   Pnt3 light(lx,ly,lz), newLight;
  1141.   rotxf.apply(light, newLight);
  1142.   lx = newLight[0];
  1143.   ly = newLight[1];
  1144.   lz = newLight[2];
  1146.   Pnt3 viewer(0,0,1), newViewer;
  1147.   rotxf.apply(viewer, newViewer);
  1149.   float hx = lx + newViewer[0];
  1150.   float hy = ly + newViewer[1];
  1151.   float hz = lz + newViewer[2];
  1153.   float hnorm = (NUM_POWER_ARGS-1)/sqrt(hx*hx + hy*hy + hz*hz)/127;
  1154.   hx *= hnorm;
  1155.   hy *= hnorm;
  1156.   hz *= hnorm;
  1158.   uchar *buf = meshSet->texture + start*3;
  1159.   uchar *newBuf = meshSet->newTexture + start;
  1160.   float diff, spec, hn, diffFactor, specFactor;
  1161.   float *powerPtr;
  1163.   specFactor = theRenderParams->specular[0] * 350;
  1164.   diffFactor = 2 * theRenderParams->diffuse[0];
  1166.   if (theRenderParams->shininess < NUM_POWERS) {
  1167.     powerPtr = thePowers + 
  1168.       int(theRenderParams->shininess) * NUM_POWER_ARGS;
  1169.   }
  1170.   else {
  1171.     powerPtr = thePowers + (NUM_POWER_ARGS-1)*NUM_POWERS;
  1172.   }
  1174.   lx *= diffFactor;
  1175.   ly *= diffFactor;
  1176.   lz *= diffFactor;
  1177.    
  1178.   for (int i=start; i < stop; i++) {
  1179.     nx = int(*buf++ - 128);
  1180.     ny = int(*buf++ - 128);
  1181.     nz = int(*buf++ - 128);
  1183.     diff = nx*lx + ny*ly + nz*lz;
  1184.     if (diff > 0) {
  1185.       hn = nx*hx + ny*hy + nz*hz;
  1186.       if (hn > 0) {
  1187. //spec = pow(hn, theRenderParams->shininess) * 
  1188. //   specFactor;
  1189. if (hn >= NUM_POWER_ARGS)
  1190.   spec = specFactor;
  1191. else {
  1192.   spec = *(powerPtr + int(hn)) * specFactor;
  1193. }
  1194.       } else {
  1195. spec = 0;
  1196.       }
  1198.       color = uchar(diff + spec);
  1199.       if      (color < 0) *newBuf++ = 0;
  1200.       else if (color > 255) *newBuf++ = 255;
  1201.       else                 *newBuf++ = color;
  1202.     } else {
  1203.       *newBuf++ = 0;
  1204.     }
  1205.   }
  1206. }
  1208. #endif // texture code