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

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

3D图形编程

开发平台：

Visual C++

DisplayMesh.cc：源码内容
  1. //############################################################
  2. // DisplayMesh.cc
  3. // Matt Ginzton / Brian Curless
  4. // Wed Jul  1 15:08:21 PDT 1998
  5. // 
  6. // Rendering code for mesh data
  7. //############################################################
  10. #include <vector.h>
  11. #include <algo.h>
  12. #include "RigidScan.h"
  13. #include "Mesh.h"
  14. #include "DisplayMesh.h"
  15. #include "plvMeshCmds.h"
  16. #include "plvScene.h"
  17. #include "plvDraw.h"
  18. #include "plvGlobals.h"
  19. #include "togl.h"
  20. #include "GlobalReg.h"
  21. #include "BailDetector.h"
  22. #include "VertexFilter.h"
  23. #include "Bbox.h"
  24. #include "MeshTransport.h"
  25. #include "plvViewerCmds.h"
  26. #include "OrganizingScan.h"
  29. // we use some rendering features (glPolygonOffset, vertex arrays) that
  30. // are only supported under OpenGL 1.1.  IRIX versions prior to 6.5 only
  31. // have OpenGL 1.0, but have EXT versions of the same functionality that
  32. // work almost as well.
  33. // g_glVersion >= 1.1 enables usage of OpenGL 1.1 features.
  37. // Core functionality: shared by both real meshes and organizing groups.
  38. // Lots of other stuff is "supported" by both (in the public interface)
  39. // but is stubbed out by one or the other and doesn't share implementation.
  40. DisplayableMesh::DisplayableMesh()
  41. {
  42.   meshData = NULL;
  43.   displayName = NULL;
  44. }
  46. DisplayableMesh::~DisplayableMesh()
  47. {
  48.   delete[] displayName;
  49. }
  52. bool
  53. DisplayableMesh::getVisible (void)
  54. {
  55.   return bVisible
  56.     && meshData->localBbox().valid();
  57. }
  60. void
  61. DisplayableMesh::setVisible (bool bVis)
  62. {
  63.   bVisible = bVis;
  64. }
  67. RigidScan*
  68. DisplayableMesh::getMeshData (void) const
  69. {
  70.   return meshData;
  71. }
  74. void
  75. DisplayableMesh::resetMeshData (RigidScan* _meshData)
  76. {
  77.   invalidateCachedData();
  78.   meshData = _meshData;
  79. }
  82. RigidScan*
  83. MeshData (DisplayableMesh* disp)
  84. {
  85.   return disp ? disp->getMeshData() : NULL;
  86. }
  89. const char*
  90. DisplayableMesh::getName (void) const
  91. {
  92.   return displayName;
  93. }
  96. void
  97. DisplayableMesh::setName (const char* name)
  98. {
  99.   displayName = new char [strlen (name) + 1];
  100.   strcpy (displayName, name);
  101. }
  104. const vec3uc&
  105. DisplayableMesh::getFalseColor (void) const
  106. {
  107.   return colorFalse;
  108. }
  111. void
  112. DisplayableMesh::setFalseColor (const vec3uc& color)
  113. {
  114.   colorFalse[0] = color[0];
  115.   colorFalse[1] = color[1];
  116.   colorFalse[2] = color[2];
  117. }
  121. //////////////////////////////////////////////////////////////////////
  122. // a real DisplayableMesh::
  123. //////////////////////////////////////////////////////////////////////
  126. DisplayableRealMesh::DisplayableRealMesh (RigidScan* _meshData, char* nameBase)
  127. {
  128.   meshData = _meshData;
  129.   setHome();
  130.   if (nameBase == NULL)
  131.     setName((char*)meshData->get_basename().c_str());
  132.   else
  133.     setName (nameBase);
  135.   theScene->meshColors.chooseNewColor(colorFalse);
  136.   myTexture = NULL;
  137.   bBlend = false;
  138.   alpha = 1.0;
  140.   bUseDisplayList = false;
  141.   iDisplayList = 0;
  143.   bVisible = true;
  145.   mBounds = NULL;
  146.   cache[0].mesh = cache[1].mesh = NULL;
  147.   invalidateCachedData();
  148. }
  151. DisplayableRealMesh::~DisplayableRealMesh (void)
  152. {
  153.   invalidateCachedData();
  154. }
  157. bool
  158. DisplayableRealMesh::useDisplayList (void) const
  159. {
  160.   return bUseDisplayList;
  161. }
  164. void
  165. DisplayableRealMesh::useDisplayList (bool bUseNow)
  166. {
  167.   if (bUseDisplayList && !bUseNow) {
  168.     invalidateDisplayList();
  169.   }
  171.   bUseDisplayList = bUseNow;
  172. }
  175. void
  176. DisplayableRealMesh::invalidateCachedData (void)
  177. {
  178.   for (int iCache = 0; iCache < 2; iCache++) {
  179.     delete cache[iCache].mesh;
  180.     cache[iCache].mesh = NULL;
  181.     cache[iCache].bPerVertex = 0;
  182.     cache[iCache].bStrips = 0;
  183.     cache[iCache].color = RigidScan::colorNone;
  184.     cache[iCache].cbColor = 0;
  185.   }
  187.   invalidateDisplayList();
  188. }
  191. void
  192. DisplayableRealMesh::invalidateDisplayList (void)
  193. {
  194.   if (iDisplayList != 0) {
  195.     cout << "Warning: nuking display list for "
  196.  << displayName << endl;
  197.     glDeleteLists(iDisplayList, 1);
  198.     iDisplayList = 0;
  199.   }
  200. }
  203. void 
  204. DisplayableRealMesh::setHome (void)
  205. {
  206.   homePos.setXform (meshData->getXform());
  207.   homePos.new_rotation_center (meshData->worldCenter());
  208. }
  211. void 
  212. DisplayableRealMesh::goHome (void)
  213. {
  214.   meshData->setXform (homePos.getXform());
  215.   meshData->new_rotation_center (homePos.worldCenter());
  216.   theScene->computeBBox();
  217. }
  220. void
  221. DisplayableRealMesh::setBlend (bool newBlend, float newAlpha)
  222. {
  223.   bBlend = newBlend;
  224.   alpha = newAlpha;
  225. }
  228. bool
  229. DisplayableRealMesh::transparent (void)
  230. {
  231.   return (theRenderParams->blend && bBlend)
  232.     || (theRenderParams->colorMode == registrationColor);
  233. }
  236. void
  237. DisplayableRealMesh::setTexture(Ref<TextureObj> newtexture)
  238. {
  239.   myTexture = newtexture;  // Ain't reference counting great!
  240. }
  243. void
  244. DisplayableRealMesh::drawSelf (bool bAllowList)
  245. {
  246.   if (!getVisible())
  247.     return;
  248.   
  249.   glMatrixMode (GL_MODELVIEW);
  250.   glPushMatrix();
  251.   meshData->gl_xform();
  252.   glMatrixMode (GL_TEXTURE);
  253.   glPushMatrix();
  254.   meshData->gl_xform();
  255.   
  256.   // get clipping filter, if we're using bbox acceleration
  257.   if (theRenderParams->accelerateWithBbox)
  258.     mBounds = new ScreenBox (NULL,
  259.      0, Togl_Width(toglCurrent) - 1,
  260.      0, Togl_Height(toglCurrent) - 1);
  261.   // but if the whole thing is onscreen, testing the fragment bboxes
  262.   // is a waste of time
  263.   if (mBounds && mBounds->acceptFully (meshData->localBbox())) {
  264.     //cout << displayName << ": whole scan onscreen; no clip test necessary" 
  265.     // << endl;
  266.     delete mBounds;
  267.     mBounds = NULL;
  268.   }
  270.   if (!mBounds || mBounds->accept (meshData->localBbox())) {
  272.     bManipulating = isManipulatingRender();
  273.     if (transparent()) {
  274.       glEnable (GL_BLEND);
  275.       glDepthMask (GL_FALSE);
  276.       glBlendFunc (GL_SRC_ALPHA, GL_DST_ALPHA);
  277.     }
  278.     
  279.     if (bAllowList)
  280.       drawList();
  281.     else
  282.       drawImmediate();
  283.     
  284.     if (theScene->wantMeshBBox (this))
  285.       drawBoundingBox();
  286.     
  287.     if (transparent()) {
  288.       glDisable(GL_BLEND);
  289.       glDepthMask (GL_TRUE);
  290.     }
  292.   } else {
  293.     cerr << displayName << ": skipping entire mesh" << endl;
  294.   }
  296.   glMatrixMode (GL_TEXTURE);
  297.   glPopMatrix();
  298.   glMatrixMode (GL_MODELVIEW);
  299.   glPopMatrix();
  301.   delete mBounds;
  302.   mBounds = NULL;
  303. }
  306. void
  307. DisplayableRealMesh::drawList (void)
  308. {
  309.   if (bUseDisplayList
  310.       && !(bManipulating && theRenderParams->bRenderManipsSkipDlist)) {
  311.     if (iDisplayList > 0) {
  312.       glCallList (iDisplayList);
  313.     } else {
  314.       cout << "Warning: building new display list for mesh "
  315.    << meshData->get_name() << endl;
  317.       iDisplayList = glGenLists (1);
  318.       glNewList(iDisplayList, GL_COMPILE);
  319.       drawImmediate();
  320.       glEndList();
  321.       glCallList (iDisplayList);
  322.     }
  323.   } else {
  324.     drawImmediate();
  325.   }
  326. }
  329. // hidden line rendering -- works by rendering black polygons shifted
  330. // just slightly back in z, to fill the z buffer with the necessary values
  331. // for depth testing, then rendering visible lines -- which only win the
  332. // depth test if they should be visible (in case of a tie, they should win 
  333. // due to the offset given the polygons).
  335. // This is carried out with glPolygonOffset, but it's a bit of a pain
  336. // because I can't get the OGL-1.1 specified call to work on SGI's --
  337. // whereas an older EXT flavor works fine.  On WIN32, at least with the
  338. // AccelGraphics card, glPolygonOffset with the same parameters works fine.
  340. // here, for nobody's benefit, but since it took me a while to figure this 
  341. // out, is a table of what works where:
  342. // glPolygonOffset: (supp'd) (works); glPolygonOffsetEXT: (supp'd) (works)
  343. // Lambert: (RE2, OGL1.0)  no,no                           yes,yes
  344. // Aegean: (O2, OGL1.0)    yes,no                          yes,yes
  345. // Radiance: (IR, OGL1.0)  yes,no                          yes,no
  346. // Maglio: (IR, OGL1.1)    yes,???                         yes,yes
  347. // Wavelet: (RE2, OGL1.1)  yes,yes                         yes,yes
  348. // Shape: (GLINT, OGL1.1)  yes,yes                         yes*,?
  349. //             * glGetString says it's there, but no way to link to it
  350. // This applies to the display, not the computational host -- so if you
  351. // run plyview on radiance using lambert's display, it works ok.
  353. // The problem appears to be that lambert, radiance, and aegean are using
  354. // pre-IRIX 6.5 OS's that implement OGL 1.0.  On IRIX 6.3 and 6.4,
  355. // glPolygonOffset is supported as a no-op; on IRIX 6.2 it fails and exits 
  356. // the program.  Hopefully once everyone is running IRIX 6.5 this can be
  357. // revisited.
  361. void
  362. DisplayableRealMesh::drawImmediate (void)
  363. {
  364.   if (theRenderParams->hiddenLine && !bManipulating) {
  365.     //valid for lines and points... don't use this for polys
  366.     GLenum realMode = theRenderParams->polyMode;
  367.     GLenum ofsMode;
  368.     if (g_glVersion >= 1.1) {
  369.       glEnable (ofsMode = GL_POLYGON_OFFSET_FILL);
  370.       glPolygonOffset (1.0, 1.0);
  371.     } else {
  372. #ifdef sgi
  373.       glEnable (ofsMode = GL_POLYGON_OFFSET_EXT);
  374.       glPolygonOffsetEXT (1.0, 1.0e-6);
  375. #endif
  376.     }
  378.     //first render polys to fill depth buffer
  379.     theRenderParams->polyMode = GL_FILL;
  380.     drawImmediateOnce();
  381.       
  382.     //then render the visible lines/points
  383.     theRenderParams->polyMode = realMode;
  384.     glDisable (ofsMode);
  385.   }
  387.   drawImmediateOnce();
  388. }
  391. void
  392. DisplayableRealMesh::drawImmediateOnce (void)
  393. {
  394.   if (meshData->num_resolutions() == 0)
  395.     return;         //nothing to do
  397.   int cbColor;
  398.   RigidScan::ColorSource color;
  399.   setMaterials (cbColor, color);
  401.   bool perVertex = theRenderParams->shadeModel != realPerFace;
  402.   bool strips = theRenderParams->useTstrips && perVertex;
  404.   getMeshTransport (perVertex, strips, color, cbColor);
  405.   renderMeshTransport();
  407.   if (!theRenderParams->shadows) {
  408.     // A bit of cleanup...
  409.     glDisable(GL_TEXTURE_2D);
  410.   }
  411. }
  414. void
  415. DisplayableRealMesh::getMeshTransport (bool perVertex, bool strips,
  416.    ColorSource color, int cbColor)
  417. {
  418.   bool bLores = bManipulating && theRenderParams->bRenderManipsLores;
  419.   DrawData& cache = bLores ? this->cache[1] : this->cache[0];
  421.   if (perVertex != cache.bPerVertex
  422.       || strips != cache.bStrips
  423.       || color != cache.color
  424.       || cbColor != cache.cbColor) {
  425.     delete cache.mesh;
  426.     cache.mesh = NULL;
  427.   }
  429.   if (!cache.mesh) {
  430.     int iOldRes = 0;
  431.     if (bLores) {
  432.       iOldRes = meshData->current_resolution().abs_resolution;
  433.       meshData->select_coarsest(); 
  434.     }
  435.     // RigidScan* meshData
  436.     cache.mesh = meshData->mesh (perVertex, strips, color, cbColor);
  437.     if (bLores)
  438.       meshData->select_by_count (iOldRes);
  440.     cache.bPerVertex = perVertex;
  441.     cache.bStrips = strips;
  442.     cache.color = color;
  443.     cache.cbColor = cbColor;
  444.     buildStripInds (cache);
  445.   }
  446. }
  450. void
  451. DisplayableRealMesh::renderMeshTransport (void)
  452. {
  453.   bool bLores = bManipulating && theRenderParams->bRenderManipsLores;
  454.   DrawData& cache = bLores ? this->cache[1] : this->cache[0];
  456.   if (!cache.mesh) {
  457.     if (!meshData->render_self (cache.color))
  458.       cerr << displayName << ": cannot render!" << endl;
  459.     return;
  460.   }
  462.   if (cache.bPerVertex) {
  463.     renderMeshArrays();
  464.   } else {
  465.     renderMeshSingle();
  466.   }
  467. }
  470. void
  471. DisplayableRealMesh::renderMeshArrays (void)
  472. {
  473.   BailDetector bail;
  475.   bool bPointsOnly = (theRenderParams->polyMode == GL_POINT);
  476.   bool bGeometryOnly = false;
  477.   bool bLores = bManipulating && theRenderParams->bRenderManipsLores;
  478.   DrawData& cache = bLores ? this->cache[1] : this->cache[0];
  480.   if (!bUseDisplayList || theRenderParams->bRenderManipsSkipDlist) {
  481.     // don't stick the points-only view in a dlist!
  482.     if (bManipulating) {
  483.       if (theRenderParams->bRenderManipsPoints) {
  484. // draw points-only view for speed
  485. bPointsOnly = true;
  487. if (theRenderParams->bRenderManipsTinyPoints) {
  488.   glPointSize (1.0);
  489. } else {
  490.   glPointSize (2.0);
  491. }
  492.       }
  493.       
  494.       if (theRenderParams->bRenderManipsUnlit) {
  495. glDisable (GL_LIGHTING);
  496. bGeometryOnly = true;
  497.       }
  498.     }
  499.   }
  501.   // hidden-line back pass doesn't need anything but geometry
  502.   if (theRenderParams->hiddenLine &&
  503.       (theRenderParams->polyMode == GL_FILL))
  504.     bGeometryOnly = true;
  506.   bool bWantNormals = theRenderParams->light && !bGeometryOnly;
  507.   bool bWantColor = (cache.mesh->color.size() == cache.mesh->vtx.size()
  508.      && !bGeometryOnly);
  510.   if (bWantColor)
  511.     glEnable (GL_COLOR_MATERIAL);
  513.   // set up client vertex-pointer state with relevant pointers
  514.   if (g_glVersion >= 1.1) {
  515.     // vertex arrays -- only supported under OpenGL 1.1 (Irix 6.5)
  516.     glEnableClientState (GL_VERTEX_ARRAY);
  517.     if (bWantNormals)
  518.       glEnableClientState (GL_NORMAL_ARRAY);
  520.     for (int imesh = 0; imesh < cache.mesh->vtx.size(); imesh++) {
  521.       if (cache.mesh->bbox[imesh].valid()) {
  522. Bbox bbox = cache.mesh->bbox[imesh].worldBox (cache.mesh->xf[imesh]);
  523. if (mBounds != NULL && !mBounds->accept (bbox)) {
  524.   //cerr << displayName << ": skipping fragment " << imesh << endl;
  525.   continue;
  526. }
  527.       }
  529.       glVertexPointer (3, GL_FLOAT, 0, cache.mesh->vtx[imesh]->begin());
  531.       glMatrixMode (GL_MODELVIEW);
  532.       glPushMatrix();
  533.       glMultMatrixf (cache.mesh->xf[imesh]);
  534.       // we should do this but it overflows the texture matrix stack...
  535.       // TODO: make our own internalPushMatrix function
  536.       //glMatrixMode (GL_TEXTURE);
  537.       //glPushMatrix();
  538.       //glMultMatrixf (cache.mesh->xf[imesh]);
  539.       
  540.       if (bWantNormals)
  541. glNormalPointer (MeshTransport::normal_type, 0,
  542.  cache.mesh->nrm[imesh]->begin());
  544.       // the second test below avoids using color arrays of size 1, even
  545.       // if there is only 1 vertex -- this tends to hang GL on maglio.
  546.       // The "color the whole fragment that color without using
  547.       // glColorPointer" case takes care of it anyway, without hanging.
  548.       bool bThisWantColor = bWantColor
  549. && (cache.mesh->color[imesh]->size() > 4)
  550. && (cache.mesh->color[imesh]->size()
  551.     == 4 * cache.mesh->vtx[imesh]->size());
  553.       if (bThisWantColor) {
  554. // only enable vertex-array color if array is expected size.
  555. glEnableClientState (GL_COLOR_ARRAY);
  556. glColorPointer (4, GL_UNSIGNED_BYTE, 0,
  557. cache.mesh->color[imesh]->begin());
  558.       } else {
  559. // don't have a full color array...
  560. glDisableClientState (GL_COLOR_ARRAY);
  561. // but we might have a per-fragment color for all these vertices.
  562. if (bWantColor && cache.mesh->color[imesh]->size() == 4) {
  563.   glColor4ubv (cache.mesh->color[imesh]->begin());
  564. }
  565.       }
  566.       
  567.       if (bPointsOnly) {
  568. glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  569. #if 1
  570. // this is obviously slower than hell for small count.  But maglio
  571. // appears to have a bug such that the second form times out and
  572. // hangs for a huge vtx list, if lighting is enabled.  Turn off
  573. // lighting or glDisableClientState (GL_NORMAL_ARRAY) and it's ok.
  574. // And if we render the same data 1 at a time, no prob.
  575. // In fact, it works for count = 1M, but not 1.5M. ???
  577. // one more note on this: a dejanews search for "GL:Wait Rdata"
  578. // turns up exactly one pair of hits, in which someone else
  579. // complains of a similar situation on an Onyx2 IR irix 6.5.1, and
  580. // an sgi rep acknowledges it sounds like an sgi bug.
  582. // with any significant value for count, this shouldn't be any
  583. // slower anyway so I'll leave it enabled.
  585. // 1M vertices per pass works fine for non-colored renderings
  586. // but crashes for color sometimes, so
  587. // we'll use 400K.
  589. // While we're documenting the follies of the IR, when color is
  590. // enabled, maglio consistently hits the same GL:Wait Rdata timeout
  591. // for vertex arrays of size 1.
  593. int total = cache.mesh->vtx[imesh]->size();
  594. int count = 400000;
  595. if (bThisWantColor ) {
  596.   while ((total % count) == 1)  // to avoid yet another hang
  597.     --count;
  598. }
  599. glDrawArrays (GL_POINTS, 0, total % count);
  600. for (int i = total%count; i < total; i += count) {
  601.   glDrawArrays (GL_POINTS, i, count);
  602. }
  603. #else
  604. glDrawArrays (GL_POINTS, 0, cache.mesh->vtx[imesh]->size());
  605. #endif
  606.       } else if (cache.bStrips) {
  607. const int* lenEnd = cache.StripInds[imesh].end();
  608. const int* start = cache.mesh->tri_inds[imesh]->begin();
  609. for (const int* len = cache.StripInds[imesh].begin();
  610.      len < lenEnd; len++) {
  611.   glDrawElements (GL_TRIANGLE_STRIP, *len,
  612.   GL_UNSIGNED_INT, start);
  613.   start += *len + 1;
  614. }
  615.       } else {
  616. #if 1
  617. int total = cache.mesh->tri_inds[imesh]->size();
  618. int count = 600000; // must be divisible by 3
  619. glDrawElements (GL_TRIANGLES, total%count,
  620. GL_UNSIGNED_INT, cache.mesh->tri_inds[imesh]->begin());
  621. for (int i = total%count; i < total; i += count)
  622.   glDrawElements (GL_TRIANGLES, count,
  623.   GL_UNSIGNED_INT,
  624.   cache.mesh->tri_inds[imesh]->begin() + i);
  625. #else
  626. glDrawElements (GL_TRIANGLES, cache.mesh->tri_inds[imesh]->size(),
  627. GL_UNSIGNED_INT, cache.mesh->tri_inds[imesh]->begin());
  628. #endif
  629.       }
  631.       //glMatrixMode (GL_TEXTURE);
  632.       //glPopMatrix();
  633.       glMatrixMode (GL_MODELVIEW);
  634.       glPopMatrix();
  636.       if (bail())
  637. break;
  638.     }
  640.     glDisableClientState (GL_VERTEX_ARRAY);
  641.     glDisableClientState (GL_NORMAL_ARRAY);
  642.     glDisableClientState (GL_COLOR_ARRAY);
  643.   } else {
  644.     // OpenGL 1.0 -- no standard vertex arrays
  645.     // but can use gldrawarraysext, glvertexpointerext, etc. on older IRIX
  646.     // if anyone needs this, they need to rewrite it
  647.     cerr << "OpenGL 1.0 not currently supported.  "
  648.  << "Have fun doing anything but rendering." << endl;
  649.   }
  651.   glDisable (GL_COLOR_MATERIAL);
  652.   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  653. }
  656. void
  657. DisplayableRealMesh::renderMeshSingle (void)
  658. {
  659.   // kberg 10 July 2001 - actually draws while manipulating now
  660.   //DrawData& cache = bManipulating ? this->cache[1] : this->cache[0];
  661.   bool bLores = bManipulating && theRenderParams->bRenderManipsLores;
  662.   DrawData& cache = bLores ? this->cache[1] : this->cache[0];
  664.   bool bPointsOnly = (theRenderParams->polyMode == GL_POINT);
  665.   
  666.   if (!bUseDisplayList || theRenderParams->bRenderManipsSkipDlist) {
  667.     // don't stick the points-only view in a dlist!
  668.     if (bManipulating) {
  669.       if (theRenderParams->bRenderManipsPoints) {
  670. // draw points-only view for speed
  671. bPointsOnly = true;
  673. if (theRenderParams->bRenderManipsTinyPoints) {
  674.   glPointSize (1.0);
  675. } else {
  676.   glPointSize (2.0);
  677. }
  678.       }
  679.       
  680.       /* TODO: implement bGeometryOnly in renderMeshSingle*/
  681.       if (theRenderParams->bRenderManipsUnlit) {
  682. glDisable (GL_LIGHTING);
  683. //bGeometryOnly = true;
  684.       } 
  685.     }
  686.   }
  688.   int frags = cache.mesh->vtx.size();
  689.   const vector<Pnt3>* vtx = NULL;
  690.   const vector<int>* tri = NULL;
  691.   const vector<short>* nrm = NULL;
  692.   const vector<uchar>* color = NULL;
  694.   for (int ifrag = 0; ifrag < frags; ifrag++) {
  695.     vtx = cache.mesh->vtx[ifrag];
  696.     tri = cache.mesh->tri_inds[ifrag];
  697.     int nTris = tri->size() / 3;
  698. #ifndef SCZ_NORMAL_FORCEFLOAT
  699.     if (ifrag < cache.mesh->nrm.size())
  700.       nrm = cache.mesh->nrm[ifrag];
  701.     else
  702. #else
  703. cerr << "Flat normals not supported in hack-normals-back-to-floats mode" << endl;
  704. #endif
  705.       nrm = NULL;
  706.     if (nrm && nrm->size() != nTris * 3)
  707.       nrm = NULL;
  708.     if (ifrag < cache.mesh->color.size())
  709.       color = cache.mesh->color[ifrag];
  710.     else
  711.       color = NULL;
  712.     if (color && color->size() != nTris * 4)
  713.       color = NULL;
  715.     if (color)
  716.       glEnable (GL_COLOR_MATERIAL);
  718.     if (bPointsOnly) 
  719.       glBegin (GL_POINTS);
  720.     else 
  721.       glBegin(GL_TRIANGLES);
  722.     
  723.     for (int it = 0; it < nTris; it++) {
  724.       int it3 = 3*it;
  725.       if (color)
  726. glColor4ubv (&(*color)[4*it]);
  727.       if (nrm)
  728. glNormal3sv (&(*nrm)[it3]);
  730.       glVertex3fv (&((*vtx)[(*tri)[it3]])[0]);
  731.       glVertex3fv (&((*vtx)[(*tri)[it3+1]])[0]);
  732.       glVertex3fv (&((*vtx)[(*tri)[it3+2]])[0]);
  733.     }
  734.     glEnd();
  735.     glDisable (GL_COLOR_MATERIAL);
  736.   }
  737. }
  740. void
  741. DisplayableRealMesh::buildStripInds (DrawData& cache)
  742. {
  743.   cache.StripInds.clear();
  744.   if (cache.bStrips && cache.mesh) {
  745.     // store indices of ends of strips
  747.     for (int imesh = 0; imesh < cache.mesh->tri_inds.size(); imesh++) {
  748.       cache.StripInds.push_back (vector<int>());
  749.       vector<int>& si = cache.StripInds.back();
  750.       const int* last = cache.mesh->tri_inds[imesh]->begin() - 1;
  751.       const int* triEnd = cache.mesh->tri_inds[imesh]->end();
  752.       for (const int *i = cache.mesh->tri_inds[imesh]->begin();
  753.    i < triEnd; i++) {
  754. if (*i == -1) { // end of strip
  755.   si.push_back (i - last - 1);
  756.   last = i;
  757. }
  758.       }
  759.     }
  760.   }
  761. }
  764. #if 0
  765. #define OFFSETOF(Struct,Field) 
  766.       ((char*)((Struct).Field) - (char*)&(Struct))
  769. void
  770. DisplayableRealMesh::cache_smooth_confidence (const vector<Pnt3>& vtx,
  771.  const vector<Pnt3>& nrm,
  772.  const vector<int>& tri_inds,
  773.  const vector<uchar>& colors,
  774.  bool stripped)
  775. {
  776.   uchar conf;
  777.   uchar _alpha = alpha * 255;
  779.   const int* triEnd = tri_inds.end();
  780.   freeVtxArray();
  781.   buildStripInds (stripped, tri_inds);
  783.   // optimization for InfiniteReality: (man glVertexPointerEXT)
  784.   // need to store: GLubyte c[4]; GLshort n[3]; GLfloat v[3];
  785.   struct {
  786.     GLubyte c[4];
  787.     NORMAL  n[3];
  788.     GLfloat v[3];
  789.   } vertex;
  790.   cachedVertSize = sizeof (vertex);
  791.   cachedVertCount = vtx.size();
  792.   cache = new char [cachedVertSize * cachedVertCount];
  793.   cachedClrOfs = OFFSETOF (vertex, c);
  794.   cachedNrmOfs = OFFSETOF (vertex, n);
  795.   cachedVtxOfs = OFFSETOF (vertex, v);
  797.   for (int vert = 0; vert < cachedVertCount; vert++) {
  798.     char* basePtr = cache + (vert * cachedVertSize);
  799.     GLubyte* colorPtr = (GLubyte*)(basePtr + cachedClrOfs);
  800.     NORMAL* normPtr =   (NORMAL*) (basePtr + cachedNrmOfs);
  801.     GLfloat* vertPtr =  (GLfloat*)(basePtr + cachedVtxOfs);
  803.     conf = colors[vert] * theRenderParams->confScale;
  804.     conf = MIN(conf, 255) * 0.7;
  805.     colorPtr[0] = 178;
  806.     colorPtr[1] = conf;
  807.     colorPtr[2] = conf;
  808.     colorPtr[3] = _alpha;
  809.     normPtr[0] = nrm[vert][0] * NRM_SCALE;
  810.     normPtr[1] = nrm[vert][1] * NRM_SCALE;
  811.     normPtr[2] = nrm[vert][2] * NRM_SCALE;
  812.     memcpy (vertPtr, &vtx[vert][0], 3 * sizeof(vertPtr[0]));
  813.   }
  815.   cachedType = smooth_conf;
  816. }
  819. void
  820. DisplayableRealMesh::cache_smooth_color (const vector<Pnt3>& vtx,
  821.     const vector<Pnt3>& nrm,
  822.     const vector<int>& tri_inds,
  823.     const vector<uchar>& colors,
  824.     int colorsize,
  825.     bool stripped)
  826. {
  827.   uchar _alpha = 255 * alpha;
  829.   freeVtxArray();
  830.   buildStripInds (stripped, tri_inds);
  832.   // need to store: GLubyte c[4]; GLshort n[3]; GLfloat v[3];
  833.   struct {
  834.     GLubyte c[4];
  835.     NORMAL  n[3];
  836.     GLfloat v[3];
  837.   } vertex;
  838.   cachedVertSize = sizeof (vertex);
  839.   cachedVertCount = vtx.size();
  840.   cache = new char [cachedVertSize * cachedVertCount];
  841.   cachedClrOfs = OFFSETOF (vertex, c);
  842.   cachedNrmOfs = OFFSETOF (vertex, n);
  843.   cachedVtxOfs = OFFSETOF (vertex, v);
  845.   for (int vert = 0; vert < cachedVertCount; vert++) {
  846.     char* basePtr = cache + (vert * cachedVertSize);
  847.     GLubyte* colorPtr = (GLubyte*)(basePtr + cachedClrOfs);
  848.     NORMAL* normPtr =   (NORMAL*) (basePtr + cachedNrmOfs);
  849.     GLfloat* vertPtr =  (GLfloat*)(basePtr + cachedVtxOfs);
  851.     if (colorsize == 3) {
  852.       colorPtr[0] = colors[3*vert + 0];
  853.       colorPtr[1] = colors[3*vert + 1];
  854.       colorPtr[2] = colors[3*vert + 2];
  855.     } else {
  856.       colorPtr[0] = colorPtr[1] = colorPtr[2] = colors[vert];
  857.     }
  858.     colorPtr[3] = _alpha;
  860.     normPtr[0] = nrm[vert][0] * NRM_SCALE;
  861.     normPtr[1] = nrm[vert][1] * NRM_SCALE;
  862.     normPtr[2] = nrm[vert][2] * NRM_SCALE;
  863.     memcpy (vertPtr, &vtx[vert][0], 3 * sizeof (vertPtr[0]));
  864.   }
  866.   cachedType = smooth_color;
  867. }
  870. void
  871. DisplayableRealMesh::cache_smooth_solid (const vector<Pnt3>& vtx,
  872.     const vector<Pnt3>& nrm,
  873.     const vector<int>& tri_inds,
  874.     bool stripped)
  875. {
  876.   freeVtxArray();
  877.   buildStripInds (stripped, tri_inds);
  879.   // need to store: GLshort n[3]; GLfloat v[3];
  880.   struct {
  881.     NORMAL  n[3];
  882.     GLfloat v[3];
  883.   } vertex;
  884.   cachedVertSize = sizeof (vertex);
  885.   cachedVertCount = vtx.size();
  886.   cache = new char [cachedVertSize * cachedVertCount];
  887.   cachedNrmOfs = OFFSETOF (vertex, n);
  888.   cachedVtxOfs = OFFSETOF (vertex, v);
  889.   cachedClrOfs = -1;
  891.   for (int vert = 0; vert < cachedVertCount; vert++) {
  892.     char* basePtr = cache + (vert * cachedVertSize);
  893.     NORMAL* normPtr =   (NORMAL*) (basePtr + cachedNrmOfs);
  894.     GLfloat* vertPtr =  (GLfloat*)(basePtr + cachedVtxOfs);
  896.     normPtr[0] = nrm[vert][0] * NRM_SCALE;
  897.     normPtr[1] = nrm[vert][1] * NRM_SCALE;
  898.     normPtr[2] = nrm[vert][2] * NRM_SCALE;
  899.     memcpy (vertPtr, &vtx[vert][0], 3 * sizeof (vertPtr[0]));
  900.   }
  902.   cachedType = smooth_solid;
  903. }
  906. void
  907. DisplayableRealMesh::draw_flat_confidence (const vector<Pnt3>& vtx,
  908.        const vector<Pnt3>& nrm,
  909.        const vector<int>& tri_inds,
  910.        const vector<uchar>& colors)
  911. {
  912.   uchar conf;
  913.   uchar confColor[4];
  914.   confColor[0] = 178;
  915.   confColor[3] = alpha * 255;
  917.   glEnable (GL_COLOR_MATERIAL);
  918.   glBegin (GL_TRIANGLES);
  920.   const int* triEnd = tri_inds.end();
  921.   int iTri = 0;
  922.   for (const int* tri = &tri_inds[0];
  923.        tri < triEnd; tri += 3, iTri++) {
  925.     conf = theRenderParams->confScale*colors[*tri];
  926.     conf = MIN(conf, 255);
  927.     conf *= 0.7;
  928.     confColor[1] = conf;
  929.     confColor[2] = conf;
  930.     glColor4ubv(confColor);
  931.     
  932.     glNormal3fv(nrm[iTri]);
  933.     
  934.     glVertex3fv (vtx[tri[0]]);
  935.     glVertex3fv (vtx[tri[1]]);
  936.     glVertex3fv (vtx[tri[2]]);
  937.   }
  939.   glEnd();
  940.   glDisable (GL_COLOR_MATERIAL);
  941.   cachedType = flat_conf;
  942. }
  945. void
  946. DisplayableRealMesh::draw_flat_color (const vector<Pnt3>& vtx,
  947.   const vector<Pnt3>& nrm,
  948.   const vector<int>& tri_inds,
  949.   const vector<uchar>& colors,
  950.   int colorsize)
  951. {
  952.   glEnable (GL_COLOR_MATERIAL);
  953.   glBegin (GL_TRIANGLES);
  955.   const int* triEnd = tri_inds.end();
  956.   int iTri = 0;
  957.   for (const int* tri = &tri_inds[0];
  958.        tri < triEnd; tri += 3, iTri++) {
  959.     
  960.     if (colorsize == 3)
  961.       glColor3ubv(&colors[3*iTri]);
  962.     else
  963.       glColor3ub (colors[iTri], colors[iTri], colors[iTri]);
  965.     glNormal3fv(nrm[iTri]);
  967.     glVertex3fv(vtx[tri[0]]);
  968.     glVertex3fv(vtx[tri[1]]);
  969.     glVertex3fv(vtx[tri[2]]);
  970.   }
  972.   glEnd();
  973.   glDisable (GL_COLOR_MATERIAL);
  974.   cachedType = flat_color;
  975. }
  978. void
  979. DisplayableRealMesh::draw_flat_solid (const vector<Pnt3>& vtx,
  980.   const vector<Pnt3>& nrm,
  981.   const vector<int>& tri_inds)
  982. {
  983.   glBegin (GL_TRIANGLES);
  984.   const int* triEnd = tri_inds.end();
  985.   int iTri = 0;
  986.   for (const int* tri = &tri_inds[0];
  987.        tri < triEnd; tri += 3, iTri++) {
  989.     glNormal3fv(nrm[iTri]);
  991.     glVertex3fv(vtx[tri[0]]);
  992.     glVertex3fv(vtx[tri[1]]);
  993.     glVertex3fv(vtx[tri[2]]);
  994.   }
  996.   glEnd();
  997.   cachedType = flat_solid;
  998. }
  999. #endif
  1002. void glMaterialubv (GLenum face, GLenum pname, const uchar* bp)
  1003. {
  1004.   // glMaterialubv doesn't exist, this wraps glMaterialfv
  1005.   float fp[4] = { bp[0] / 255., bp[1] / 255., bp[2] / 255., bp[3] / 255. };
  1006.   glMaterialfv (face, pname, fp);
  1007. }
  1010. void
  1011. DisplayableRealMesh::setMaterials (int& colorSize,
  1012.        RigidScan::ColorSource& colorSource)
  1013. {
  1014.   static float nocolor[4] =  { 0, 0, 0, 1 };
  1015.   static float regThisColor[4] = { 0, 0, 1, .5 };
  1016.   static float regYesColor[4] = { 0, 1, 0, .5 };
  1017.   static float regNoColor[4] = { 1, 0, 0, .5 };
  1018.   static float white[4] = { 1, 1, 1, 1 };
  1019.   float diff[4];
  1020.   bool bDontReset = false;
  1022.   // Reset materials
  1023.   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, nocolor);
  1024.   glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, nocolor);
  1025.   glMaterialubv(GL_FRONT, GL_SPECULAR, theRenderParams->specular);
  1026.   glMaterialfv(GL_BACK, GL_SPECULAR, nocolor);
  1027.   glMaterialf (GL_FRONT, GL_SHININESS, 
  1028.        theRenderParams->shininess);
  1029.   if (!theRenderParams->shadows) {
  1030.     glDisable(GL_TEXTURE_2D);
  1031.     glDisable(GL_TEXTURE_GEN_S);
  1032.     glDisable(GL_TEXTURE_GEN_T);
  1033.     glDisable(GL_TEXTURE_GEN_R);
  1034.   }
  1036.   // not needed - two sided lighting takes care of back emmisive
  1037.   //if (theRenderParams->backFaceEmissive)
  1038.   //  glMaterialubv(GL_BACK, GL_EMISSION, theRenderParams->background);
  1039.  
  1040.   if (theRenderParams->twoSidedLighting) {
  1041.     if (theRenderParams->backfaceMode == lit) {
  1042.       glMaterialubv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, theRenderParams->backDiffuse);
  1043.       glMaterialubv(GL_BACK, GL_SPECULAR, theRenderParams->backSpecular);
  1044.       glMaterialf(GL_BACK, GL_SHININESS, theRenderParams->backShininess);
  1045.     }
  1046.     else if (theRenderParams->backfaceMode == emissive)
  1047.       glMaterialubv(GL_BACK, GL_EMISSION, theRenderParams->backDiffuse);
  1048.   }
  1050.   // default to solid color unless otherwise overridden
  1051.   colorSize = 0;
  1052.   colorSource = RigidScan::colorNone;
  1054.   if (theRenderParams->hiddenLine
  1055.       && theRenderParams->polyMode == GL_FILL)
  1056.   {
  1057.     // "fill the depth buffer" pass -- render black
  1058.     // so reset the only materials that were not set to nocolor above
  1059.     glMaterialfv(GL_FRONT, GL_SPECULAR, nocolor);
  1060.     glMaterialf (GL_FRONT, GL_SHININESS, 0);
  1061.     glColor4fv (nocolor);
  1063.     // we need to go through the below switch statement to set the
  1064.     // showColor and showConfidence vars, but we don't want to make
  1065.     // any more glMaterial/glColor calls...
  1066.     bDontReset = true;
  1067.   }
  1069.   GLenum matMode = theRenderParams->useEmissive ?
  1070.     GL_EMISSION : GL_AMBIENT_AND_DIFFUSE;
  1071.   if (!bDontReset)
  1072.     glMaterialubv(GL_FRONT, matMode, theRenderParams->diffuse);
  1073.   
  1074.   switch (theRenderParams->colorMode) {
  1075.   case falseColor:
  1076.     if (!bDontReset) {
  1077.       diff[0] = colorFalse[0]/255.0;
  1078.       diff[1] = colorFalse[1]/255.0;
  1079.       diff[2] = colorFalse[2]/255.0;
  1080.       diff[3] = alpha;
  1081.       
  1082.       glMaterialfv (GL_FRONT, matMode, diff);
  1083.       glColor4fv (diff);
  1084.     }
  1085.     break;
  1086.     
  1087.   case boundaryColor:
  1088.   case confidenceColor:
  1089.   case intensityColor:
  1090.   case trueColor:
  1091.     colorSize = 4;
  1092.     switch (theRenderParams->colorMode) {
  1093.     case confidenceColor:
  1094.       colorSource = RigidScan::colorConf; break;
  1095.     case intensityColor:
  1096.       colorSource = RigidScan::colorIntensity; break;
  1097.     case trueColor:
  1098.       colorSource = RigidScan::colorTrue; break;
  1099.     case boundaryColor:
  1100.       colorSource = RigidScan::colorBoundary; break;
  1101.     }
  1102.     
  1103.     if (!bDontReset) {
  1104.       if (theRenderParams->useEmissive)
  1105. glMaterialfv(GL_FRONT, GL_SPECULAR, nocolor);
  1106.       glColorMaterial(GL_FRONT, matMode);
  1107.     }
  1108.     break;
  1109.     
  1110.   case registrationColor:
  1111.     if (!bDontReset) {
  1112.       if (this == theSelectedScan) {
  1113. glMaterialfv (GL_FRONT, matMode, regThisColor);
  1114.       } else {
  1115. assert (theScene->globalReg);
  1116. bool bTrans = atoi (Tcl_GetVar (g_tclInterp, "regColorTransitive",
  1117. TCL_GLOBAL_ONLY));
  1118. if (theScene->globalReg->pairRegistered
  1119.     (this->getMeshData(), theSelectedScan->getMeshData(), bTrans)) {
  1120.   glMaterialfv (GL_FRONT, matMode, regYesColor);
  1121. } else {
  1122.   glMaterialfv (GL_FRONT, matMode, regNoColor);
  1123. }
  1124.       }
  1125.     }
  1126.     break;
  1127.     
  1128.   case noColor:
  1129.     glColor4ubv (theRenderParams->diffuse);
  1130.     break;
  1132.   case textureColor:
  1133.     if (myTexture) {
  1134.       myTexture->setupTexture();
  1135.       glMaterialfv(GL_FRONT, matMode, white);
  1136.       glColor4fv(white);
  1137.       break;
  1138.     }
  1139.     // else fall through...
  1140.     
  1141.   case grayColor:
  1142.   default:
  1143.     // just set color in case it's not set from lighting
  1144.     // material properties are already ok (they have to be, since this
  1145.     // is the fallback case and may be invoked without warning if we
  1146.     // fail to extract color info requested from the RigidScan)
  1147.     if (!bDontReset) {
  1148.       diff[0] = diff[1] = diff[2] = 0.7;
  1149.       diff[3] = alpha;
  1150.       glColor4fv (diff);
  1151.     }
  1152.     break;
  1153.   }
  1155.   // set polygon mode, so we can draw points/lines/polys with same
  1156.   // series of calls to glBegin/glVertex/glEnd
  1157.   if (theRenderParams->polyMode == GL_FILL) {
  1158.     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  1159.   }
  1160.   else if (theRenderParams->polyMode == GL_POINT) {
  1161.     glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);
  1162.     glPointSize(theRenderParams->pointSize);
  1163.   }
  1164.   else { // if (theRenderParams->polyMode == GL_LINE)
  1165.     glLineWidth(theRenderParams->lineWidth);
  1166.     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
  1167.   }
  1168. }
  1171. void
  1172. DisplayableRealMesh::drawBoundingBox (void)
  1173. {
  1174.   // assumes mesh transformation is in place, and draws bounding box edges
  1175.   // in local (mesh) coordinates
  1177.   ::drawBoundingBox (meshData->localBbox());
  1178. }
  1181. void
  1182. DisplayableRealMesh::setName (const char* baseName)
  1183. {
  1184.   char bName[1024];
  1185.   strcpy(bName, baseName);
  1186.   
  1187.   char* begin = strrchr (bName, '/');
  1188.   char tempName[500];
  1189.   
  1190.   if (begin == NULL)
  1191.     {
  1192.       begin=bName;
  1193.       strcpy(tempName, bName);
  1194.     }
  1195.   else
  1196.     {
  1197.       begin[0]='';
  1198.       // printf ("suffix:%sn",begin-3);
  1199.       // Check if this is really a sweep, if so name funkyness
  1200.       if (strcmp(begin-3,".sd")==0)
  1201. {
  1202.  
  1203.   char* begin2 = strrchr (bName, '/');
  1204.   if (begin2 == NULL)
  1205.     {
  1206.       begin2=bName;
  1207.     }
  1208.   else
  1209.     {
  1210.       begin2++;
  1211.     }
  1212.   // printf ("begin2:%sn",begin2);
  1213.   *(begin-3)='';
  1214.   strcpy(tempName,begin2);
  1215.   strcat(tempName,"__");
  1216.   strcat(tempName,begin+1);
  1217.    
  1218. }
  1219.       else
  1220. {
  1221.   //  printf("fail:%sn",begin+1);
  1222. begin++;
  1223. strcpy(tempName,begin  );
  1224. }
  1225.     }
  1226.  
  1227.  
  1228.   //printf ("tempname:%sn",tempName);
  1229.   int suffix = 0;
  1230.   while (FindMeshDisplayInfo (tempName) != NULL) {
  1231.     ++suffix;
  1232.     sprintf (tempName + strlen(tempName), "%d", suffix);
  1233.   }
  1235.   DisplayableMesh::setName (tempName);
  1236. }