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

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

3D图形编程

开发平台：

Visual C++

plvDrawCmds.cc：源码内容
  1. #ifdef WIN32
  2. # include "winGLdecs.h"
  3. #else
  4. # include <sys/time.h>
  5. #endif
  6. #include <GL/glu.h>
  7. #include <tk.h>
  8. #include <stdlib.h>
  10. #include "togl.h"
  11. #include "plvDraw.h"
  12. #include "plvGlobals.h"
  13. #include "plvDrawCmds.h"
  14. #include "plvMeshCmds.h"
  15. #include "plvScene.h"
  16. #include "ToglHash.h"
  17. #include "DisplayMesh.h"
  18. #include "ToglCache.h"
  19. #include "plvClipBoxCmds.h"
  20. #include "TextureObj.h"
  21. #include "plvViewerCmds.h"
  22. #include "TclCmdUtils.h"
  25. static const char ToglPaneName[] = ".toglFrame.toglPane";
  26. static void resizeMainTogl (struct Togl* togl);
  29. class DisplayListValidityCheck
  30. {
  31. public:
  32.   DisplayListValidityCheck (RenderParams* rp)
  33.     {
  34.       assert (rp != NULL);
  35.       realData = rp;
  36.       memcpy (&oldData, rp, sizeof(oldData));
  37.     };
  39.   ~DisplayListValidityCheck()
  40.     {
  41.       if (memcmp (&oldData, realData, sizeof(oldData))) {
  42. //render params changed -- kill display lists
  43. theScene->invalidateDisplayCaches();
  44. if (toglCurrent && Togl_Interp (toglCurrent)) {
  45.   DisplayCache::InvalidateToglCache (toglCurrent);
  46.   Tcl_Eval (Togl_Interp (toglCurrent), "renderParamsChanged");
  47. }
  48.       }
  49.     };
  51. private:
  52.   RenderParams *realData;
  53.   RenderParams oldData;
  54. };
  57. static void
  58. SetResultFromColorU (Tcl_Interp* interp, uchar* color)
  59. {
  60.   char buffer[20];
  61.   sprintf (buffer, "#%02x%02x%02x",
  62.    (int)color[0], (int)color[1], (int)color[2]);
  63.   Tcl_SetResult (interp, buffer, TCL_VOLATILE);
  64. }
  67. static void
  68. SetResultFromColorF (Tcl_Interp* interp, float* color)
  69. {
  70.   char buffer[20];
  71.   sprintf (buffer, "#%02x%02x%02x",
  72.    (int)(255*color[0]), (int)(255*color[1]), (int)(255*color[2]));
  73.   Tcl_SetResult (interp, buffer, TCL_VOLATILE);
  74. }
  77. int
  78. PlvDrawStyleCmd(ClientData clientData, Tcl_Interp *interp, 
  79. int argc, char *argv[])
  80. {
  81.   if (g_bNoUI)
  82.     return TCL_OK;
  84.   DisplayListValidityCheck dlvc (theRenderParams);
  86.   for (int i = 1; i < argc; i++) {
  87.     if (!strcmp(argv[i], "-shademodel")) {
  88.       i++;
  89.       if (!strcmp(argv[i], "realflat")) {
  90. theRenderParams->shadeModel = realPerFace;
  91.       } 
  92.       else if (!strcmp(argv[i], "fakeflat")) {
  93. theRenderParams->shadeModel = fakePerFace;
  94.       } 
  95.       else if (!strcmp(argv[i], "smooth")){
  96. theRenderParams->shadeModel = perVertex;
  97.       }
  98.       else {
  99. interp->result = "bad arg to plv_drawstyle -shademodel";
  100. return TCL_ERROR;
  101.       }
  102.     }
  103.     else if (!strcmp(argv[i], "-polymode")) {
  104.       i++;
  105.       if (!strcmp(argv[i], "fill")) {
  106. theRenderParams->polyMode = GL_FILL;
  107. theRenderParams->hiddenLine = FALSE;
  108.       } 
  109.       else if (!strcmp(argv[i], "line")){
  110. theRenderParams->polyMode = GL_LINE;
  111. theRenderParams->hiddenLine = FALSE;
  112.       }
  113.       else if (!strcmp(argv[i], "hiddenline")){
  114. theRenderParams->polyMode = GL_LINE;
  115. theRenderParams->hiddenLine = TRUE;
  116.       }
  117.       else if (!strcmp(argv[i], "point")){
  118. theRenderParams->polyMode = GL_POINT;
  119. theRenderParams->hiddenLine = FALSE;
  120.       }
  121.       else if (!strcmp(argv[i], "hiddenpoint")){
  122. theRenderParams->polyMode = GL_POINT;
  123. theRenderParams->hiddenLine = TRUE;
  124.       }
  125.       else {
  126. interp->result = "bad arg to plv_drawstyle -polymode";
  127. return TCL_ERROR;
  128.       }
  129.     }
  130.     else if (!strcmp(argv[i], "-blend")) {
  131.       SetBoolFromArgIndex (++i, theRenderParams->blend);
  132.     }
  133.     else if (!strcmp(argv[i], "-cull")) {
  134.       SetBoolFromArgIndex (++i, theRenderParams->cull);
  135.     }
  136.     else if (!strcmp(argv[i], "-bbox")) {
  137.       SetBoolFromArgIndex (++i, theRenderParams->boundSelection);
  138.     }
  139.     else if (!strcmp(argv[i], "-cachetogl")) {
  140.       if (!toglCurrent)
  141. continue;  // too early
  143.       bool bCache;
  144.       SetBoolFromArgIndex (++i, bCache);
  145.       DisplayCache::EnableToglCache (toglCurrent, bCache);
  146.     }
  147.     else if (!strcmp(argv[i], "-clearbuffer")) {
  148.       SetBoolFromArgIndex (++i, theRenderParams->clearBeforeRender);
  149.     }
  150.     else if (!strcmp(argv[i], "-displaylist")) {
  151.       bool bDispList;
  152.       SetBoolFromArgIndex (++i, bDispList);
  153.       for (int k = 0; k < theScene->meshSets.size(); k++) {
  154. theScene->meshSets[k]->useDisplayList (bDispList);
  155.       } 
  156.     }
  157.     else if (!strcmp(argv[i], "-flipnorm")) {
  158.       SetBoolFromArgIndex (++i, theRenderParams->flipnorm);
  159.     }
  160.     else if (!strcmp(argv[i], "-lighting")) {
  161.       SetBoolFromArgIndex (++i, theRenderParams->light);
  162.     }
  163.     else if (!strcmp(argv[i], "-tstrip")) {
  164.       SetBoolFromArgIndex (++i, theRenderParams->useTstrips);
  165.     }
  166.     else if (!strcmp(argv[i], "-background")) {
  167.       i++;
  168.       if (i == argc) { // query
  169. SetResultFromColorU (interp, theRenderParams->background);
  170. return TCL_OK;
  171.       } else {
  172. theRenderParams->background[0] = 255 * atof(argv[i]);  i++;
  173. theRenderParams->background[1] = 255 * atof(argv[i]);  i++;
  174. theRenderParams->background[2] = 255 * atof(argv[i]);
  175.       }
  176.     }
  177.     else if (!strcmp(argv[i], "-pointsize")) {
  178.       i++;
  179.       theRenderParams->pointSize = atof(argv[i]);
  180.     }
  181.     else if (!strcmp(argv[i], "-linewidth")) {
  182.       i++;
  183.       theRenderParams->lineWidth = atof(argv[i]);
  184.     }
  185.     else if (!strcmp(argv[i], "-emissive")) {
  186.       SetBoolFromArgIndex (++i, theRenderParams->useEmissive);
  187.     }
  188.     /* two sided lighting takes care of backface emissive
  189.     else if (!strcmp(argv[i], "-backfaceemissive")) {
  190.       SetBoolFromArgIndex (++i, theRenderParams->backFaceEmissive);
  191.     } */
  192.     else if (!strcmp(argv[i], "-twosidedlighting")) {
  193.       SetBoolFromArgIndex (++i, theRenderParams->twoSidedLighting);
  194.     }
  195.     else if (!strcmp(argv[i], "-antialias")) {
  196.       SetBoolFromArgIndex (++i, theRenderParams->antiAlias);
  197.     }
  198.     else if (!strcmp(argv[i], "-depthoffield")) {
  199.       if (i + 4 > argc) {
  200. interp->result = "bad # args to plv_drawstyle -depthoffield";
  201. return TCL_ERROR;
  202.       }
  204.       // arg format: [X jitter pixels] [Y jitter pixels] [center]
  205.       theRenderParams->dofJitterX = atof (argv[i + 1]);
  206.       theRenderParams->dofJitterY = atof (argv[i + 2]);
  207.       theRenderParams->dofCenter = atof (argv[i + 3]);
  209.       i += 4;      
  210.     }
  211.     else if (!strcmp(argv[i], "-shadows")) {
  212.       SetBoolFromArgIndex (++i, theRenderParams->shadows);
  213.     }
  214.     else if (!strcmp(argv[i], "-softshadowlength")) {
  215.       i++;
  216.       theRenderParams->shadowLength = atof (argv[i]);
  217.     }
  218.     else if (!strcmp(argv[i], "-fromlightpov")) {
  219.       SetBoolFromArgIndex (++i, theRenderParams->fromLightPOV);
  220.     }
  221.     else if (!strcmp(argv[i], "-aasamps")) {
  222.       i++;
  223.       int aasamps = atoi(argv[i]); i++;
  224.       switch (aasamps) {
  226.       case 2:
  227. theRenderParams->numAntiAliasSamps = 2;
  228. theRenderParams->jitterArray = (jitter_point *)j2;
  229. break;
  231.       case 3:
  232. theRenderParams->numAntiAliasSamps = 3;
  233. theRenderParams->jitterArray = (jitter_point *)j3;
  234. break;
  236.       case 4:
  237. theRenderParams->numAntiAliasSamps = 4;
  238. theRenderParams->jitterArray = (jitter_point *)j4;
  239. break;
  241.       case 8:
  242. theRenderParams->numAntiAliasSamps = 8;
  243. theRenderParams->jitterArray = (jitter_point *)j8;
  244. break;
  246.       case 15:
  247. theRenderParams->numAntiAliasSamps = 15;
  248. theRenderParams->jitterArray = (jitter_point *)j15;
  249. break;
  251.       case 24:
  252. theRenderParams->numAntiAliasSamps = 24;
  253. theRenderParams->jitterArray = (jitter_point *)j24;
  254. break;
  256.       case 66:
  257. theRenderParams->numAntiAliasSamps = 66;
  258. theRenderParams->jitterArray = (jitter_point *)j66;
  259. break;
  261.       default:
  262. interp->result = "bad args to plv_drawstyle -aasamps"
  263.   "  -  should be [2, 3, 4, 8, 15, 24, 66]";
  264. return TCL_ERROR;
  265.       }
  266.     }
  267.     else {
  268.       interp->result = "bad args to plv_drawstyle";
  269.       return TCL_ERROR;
  270.     }
  271.   }
  272.   
  273.   return TCL_OK;
  274. }
  277. int
  278. PlvFillPhotoCmd(ClientData clientData, Tcl_Interp *interp, 
  279. int argc, char *argv[])
  280. {
  281.   uchar *cbuf;
  282.   GLint lastBuffer;
  283.    
  284.   if (argc != 3) {
  285.     interp->result = "Usage: plv_fillphoto <togl-widget> <photo-widget>";
  286.     return TCL_ERROR;
  287.   }    
  289. #if TK_MAJOR_VERSION >= 8
  290.   Tk_PhotoHandle handle = Tk_FindPhoto(interp, argv[2]);
  291. #else
  292.   Tk_PhotoHandle handle = Tk_FindPhoto(argv[2]);
  293. #endif
  294.   if (handle == NULL) {
  295.     interp->result = "Could not find photo widget.";
  296.     return TCL_ERROR;
  297.   }
  298.    
  299.   prepareDrawInWin(argv[1]);
  301.   cbuf = (uchar *)malloc(theWidth*theHeight*4);
  303.   glGetIntegerv(GL_DRAW_BUFFER, &lastBuffer);
  304.   glDrawBuffer(GL_FRONT);
  305.   glReadPixels(0, 0, theWidth, theHeight, GL_RGBA, GL_UNSIGNED_BYTE, cbuf);
  306.   glDrawBuffer(GLenum(lastBuffer));
  308.   Tk_PhotoSetSize(handle, theWidth, theHeight);
  310.   Tk_PhotoImageBlock block;
  311.     
  312.   block.pixelPtr = cbuf;
  313.   block.pitch = theWidth*4;
  315.   block.pixelSize = 4;
  316.   block.offset[0] = 0;
  317.   block.offset[1] = 1;
  318.   block.offset[2] = 2;
  319.   block.width = theWidth;
  320.   block.height = theHeight;
  322.   Tk_PhotoPutBlock(handle, &block, 0, 0, theWidth, theHeight);
  324.   free(cbuf);
  326.   return TCL_OK;
  327. }
  330. int
  331. PlvDrawCmd(ClientData clientData, Tcl_Interp *interp, 
  332.    int argc, char *argv[])
  333. {
  334.   prepareDrawInWin(argv[1]);
  335.   drawInTogl (toglCurrent);
  336.     
  337.   return TCL_OK;
  338. }
  341. int
  342. PlvClearWinCmd(ClientData clientData, Tcl_Interp *interp, 
  343.        int argc, char *argv[])
  344. {
  345.   prepareDrawInWin(argv[1]);
  347.   glClear(GL_COLOR_BUFFER_BIT);
  348.   Togl_SwapBuffers (toglCurrent);
  349.     
  350.   return TCL_OK;
  351. }
  354. int
  355. PlvMaterialCmd(ClientData clientData, Tcl_Interp *interp, 
  356.        int argc, char *argv[])
  357. {
  358.   if (g_bNoUI)
  359.     return TCL_OK;
  361.   DisplayListValidityCheck dlvc (theRenderParams);
  363.   int i;
  364.   if (argc == 1) {
  365.     char* colorModeName = NULL;
  366.     switch (theRenderParams->colorMode) {
  367.     case grayColor:       colorModeName = "gray";       break;
  368.     case falseColor:      colorModeName = "false";      break;
  369.     case confidenceColor: colorModeName = "confidence"; break;
  370.     case boundaryColor:   colorModeName = "boundary";   break;
  371.     case intensityColor:  colorModeName = "intensity";  break;
  372.     case trueColor:       colorModeName = "true";       break;
  373.     case textureColor:    colorModeName = "texture";    break;
  374.     case registrationColor: colorModeName = "registration"; break;
  375.     }
  377.     printf("Command: %s [-option value]n", argv[0]);
  378.     printf("  -diffuse <float> <float> <float> (%f %f %f)n", 
  379.    theRenderParams->diffuse[0] / 255.,
  380.    theRenderParams->diffuse[1] / 255., 
  381.    theRenderParams->diffuse[2] / 255.);
  382.     printf("  -specular <float> <float> <float> (%f %f %f)n", 
  383.    theRenderParams->specular[0] / 255.,
  384.    theRenderParams->specular[1] / 255., 
  385.    theRenderParams->specular[2] / 255.);
  386.     printf("  -shininess <float> (%f)n", theRenderParams->shininess);
  387.     printf("  -confscale <float> (%f)n", theRenderParams->confScale);
  388.     printf("  -colormode [gray|false|intensity|true|confidence|"
  389.    "boundary|registration|texture (%s)n",
  390.    colorModeName);
  391.   }
  392.   else {
  393.     for (i = 1; i < argc; i++) {
  394.       if (!strcmp(argv[i], "-shininess")) {
  395. i++;
  396. theRenderParams->shininess = atof(argv[i]);
  397.       }
  398.       else if (!strcmp(argv[i], "-specular")) {
  399. i++;
  400. if (i == argc) { // query
  401.   SetResultFromColorU (interp, theRenderParams->specular);
  402.   return TCL_OK;
  403. }
  405. theRenderParams->specular[0] = 255 * atof(argv[i]);  i++;
  406. theRenderParams->specular[1] = 255 * atof(argv[i]);  i++;
  407. theRenderParams->specular[2] = 255 * atof(argv[i]);
  408.       }
  409.       else if (!strcmp(argv[i], "-diffuse")) {
  410. i++;
  411. if (i == argc) { // query
  412.   SetResultFromColorU (interp, theRenderParams->diffuse);
  413.   return TCL_OK;
  414. }
  416. theRenderParams->diffuse[0] = 255 * atof(argv[i]);  i++;
  417. theRenderParams->diffuse[1] = 255 * atof(argv[i]);  i++;
  418. theRenderParams->diffuse[2] = 255 * atof(argv[i]);
  419.       }
  420.       // backDiffuse added by kberg 6/5/01
  421.       else if (!strcmp(argv[i], "-backDiffuse")) {
  422. i++;
  423. if (i == argc) { // query
  424.   SetResultFromColorU (interp, theRenderParams->backDiffuse);
  425.   return TCL_OK;
  426. }
  428. theRenderParams->backDiffuse[0] = 255 * atof(argv[i]);  i++;
  429. theRenderParams->backDiffuse[1] = 255 * atof(argv[i]);  i++;
  430. theRenderParams->backDiffuse[2] = 255 * atof(argv[i]);
  431.       }
  432.       else if (!strcmp(argv[i], "-backSpecular")) {
  433. i++;
  434. if (i == argc) { // query
  435.   SetResultFromColorU (interp, theRenderParams->backSpecular);
  436.   return TCL_OK;
  437. }
  439. theRenderParams->backSpecular[0] = 255 * atof(argv[i]);  i++;
  440. theRenderParams->backSpecular[1] = 255 * atof(argv[i]);  i++;
  441. theRenderParams->backSpecular[2] = 255 * atof(argv[i]);
  442.       }
  443.       else if (!strcmp(argv[i], "-lightambient")) {
  444. i++;
  445. if (i == argc) { // query
  446.   SetResultFromColorF (interp, theRenderParams->lightAmbient);
  447.   return TCL_OK;
  448. }
  450. theRenderParams->lightAmbient[0] = atof(argv[i]);  i++;
  451. theRenderParams->lightAmbient[1] = atof(argv[i]);  i++;
  452. theRenderParams->lightAmbient[2] = atof(argv[i]);
  453.       }
  454.       else if (!strcmp(argv[i], "-lightspecular")) {
  455. i++;
  456. if (i == argc) { // query
  457.   SetResultFromColorF (interp, theRenderParams->lightSpecular);
  458.   return TCL_OK;
  459. }
  461. theRenderParams->lightSpecular[0] = atof(argv[i]);  i++;
  462. theRenderParams->lightSpecular[1] = atof(argv[i]);  i++;
  463. theRenderParams->lightSpecular[2] = atof(argv[i]);
  464.       }
  465.       else if (!strcmp(argv[i], "-lightdiffuse")) {
  466. i++;
  467. if (i == argc) { // query
  468.   SetResultFromColorF (interp, theRenderParams->lightDiffuse);
  469.   return TCL_OK;
  470. }
  472. theRenderParams->lightDiffuse[0] = atof(argv[i]);  i++;
  473. theRenderParams->lightDiffuse[1] = atof(argv[i]);  i++;
  474. theRenderParams->lightDiffuse[2] = atof(argv[i]);
  475.       }
  476.       else if (!strcmp(argv[i], "-backfacemode")) {
  477. i++;
  478. if (!strcmp(argv[i], "lit")) {
  479.   theRenderParams->backfaceMode = lit;
  480. }
  481. else if (!strcmp(argv[i], "emissive")) {
  482.   theRenderParams->backfaceMode = emissive;
  483. }
  484.       }
  485.       else if (!strcmp(argv[i], "-colormode")) {
  486. i++;
  487. if (     !strcmp (argv[i], "gray")) {
  488.   theRenderParams->colorMode = grayColor;
  489. }
  490. else if (!strcmp (argv[i], "false")) {
  491.   theRenderParams->colorMode = falseColor;
  492. }
  493. else if (!strcmp (argv[i], "intensity")) {
  494.   theRenderParams->colorMode = intensityColor;
  495. }
  496. else if (!strcmp (argv[i], "true")) {
  497.   theRenderParams->colorMode = trueColor;
  498. }
  499. else if (!strcmp (argv[i], "confidence")) {
  500.   theRenderParams->colorMode = confidenceColor;
  501. }
  502. else if (!strcmp (argv[i], "boundary")) {
  503.   theRenderParams->colorMode = boundaryColor;
  504. }
  505. else if (!strcmp (argv[i], "registration")) {
  506.   theRenderParams->colorMode = registrationColor;
  507. }
  508. else if (!strcmp (argv[i], "texture")) {
  509.   theRenderParams->colorMode = textureColor;
  510. }
  511. else {
  512.   interp->result = "Bad argument to plv_material -color";
  513.   return TCL_ERROR;
  514. }
  515.       }
  516.       else if (!strcmp(argv[i], "-confscale")) {
  517. i++;
  518. theRenderParams->confScale = atof(argv[i]);
  519.       }
  520.       else {
  521. interp->result = "bad arg to plv_material";
  522. return TCL_ERROR;
  523.       }
  524.     }
  525.   }
  526.   
  527.   return TCL_OK;
  528. }
  530. int
  531. PlvLoadProjectiveTexture(ClientData clientData, Tcl_Interp *interp, 
  532.   int argc, char *argv[])
  533. {
  534.   if (g_bNoUI)
  535.     return TCL_OK;
  537.   if (argc < 2) {
  538.     printf("Usage: %s filename.rgb [green] [nomipmap]n", argv[0]);
  539.     printf("       green : Don't actually load image, just use a green projectionn");
  540.     return TCL_OK;
  541.   }
  543.   int mesh;
  544.   // This applies the perspective texture to all visible meshes, so
  545.   // check whether anything's visible...
  546.   int nMeshes = theScene->meshSets.size();
  548.   if (!nMeshes)
  549.     return TCL_OK;
  550.   for (mesh = 0; mesh < nMeshes; mesh++) {
  551.     if (theScene->meshSets[mesh]->getVisible())
  552. break;
  553.   }
  554.   if (mesh == nMeshes)
  555.     return TCL_OK;
  558.   // Try to load the texture 
  559.   bool actuallyLoad=true, use_mipmaps=true;
  560.   for (int arg = 2; arg < argc; arg++) {
  561.    if (argv[arg][0] == 'g')
  562. actuallyLoad = false;
  563. else if (argv[arg][0] == 'n')
  564. use_mipmaps = false;
  565.   }
  567.   Ref<ProjectiveTexture> thetexture =
  568.    ProjectiveTexture::loadImage(argv[1], NULL, NULL, NULL, NULL,
  569.      actuallyLoad, use_mipmaps);
  570.   
  571.   if (!thetexture)
  572.     return TCL_OK;
  574.   for (mesh = 0; mesh < nMeshes; mesh++)
  575.     if (theScene->meshSets[mesh]->getVisible()) {
  576. DisplayableMesh *themesh = theScene->meshSets[mesh];
  577. const float *meshxform = (float *)(themesh->getMeshData()->getXform());
  578. themesh->setTexture(MeshAffixedProjectiveTexture::AffixToMesh(thetexture, meshxform));
  579.     }
  581.   return TCL_OK;
  582. }
  584. int 
  585. prepareDrawInWin(char *name)
  586. {
  587.   toglCurrent = toglHash.FindTogl (name);
  589.   assert (toglCurrent != NULL);
  590.   Togl_MakeCurrent (toglCurrent);
  592.   return 1;
  593. }
  596. void
  597. catchToglCreate (struct Togl *togl)
  598. {
  599.   toglHash.AddToHash (Togl_Ident (togl), togl);
  600.   if (!strcmp (Togl_Ident(togl), ToglPaneName)) {
  601.     toglCurrent = togl;
  602.     Togl_SetReshapeFunc (togl, resizeMainTogl);
  603.     new DisplayCache (togl);
  604.     Tcl_Eval (Togl_Interp (togl), "prefs_setRendererBasedDefaults");
  605.   }
  606. }
  609. void
  610. redraw (bool bForceRender)
  611. {
  612.   //just so other modules don't have to know about toglCurrent
  613.   if (bForceRender)
  614.     DisplayCache::InvalidateToglCache (toglCurrent);
  616.   Togl_PostRedisplay (toglCurrent);
  617. }
  620. void
  621. resizeMainTogl (struct Togl* togl)
  622. {
  623.   //printf ("from %dx%d to %dx%dn", theWidth, theHeight,
  624.   //  Togl_Width (togl), Togl_Height (togl));
  626.   resizeSelectionToWindow (togl);
  627. }
  630. void
  631. drawInTogl(struct Togl *togl)
  632. {
  633.   // don't redraw if redraw is disabled
  634.   if (atoi (Tcl_GetVar (g_tclInterp, "noRedraw", TCL_GLOBAL_ONLY)) <= 0) {
  635.     
  636.     // ok, we have permission to draw
  637.     drawInToglBuffer (togl, GL_FRONT, true);
  638.   }
  639. }
  641. void
  642. drawInToglBuffer (struct Togl *togl, int buffer, bool bCacheable)
  643. {
  644.   //puts ("drawInToglBuffer");
  646.   // Take ms time at start of render
  647.   unsigned long startTime = Get_Milliseconds();
  648.   
  649.   // update global size info
  650.   theWidth = Togl_Width (togl);
  651.   theHeight = Togl_Height (togl);
  653.   if (togl == toglCurrent) { // only if in main window, update trackball too
  654.     tbView->setSize (theWidth, theHeight);
  655.   }
  657.   //Tcl_Eval (g_tclInterp, "redrawStatus start");
  658. #if TOGLCACHE_DEBUG
  659.   cout << "rendering manually" << endl;
  660. #endif
  661.   glDrawBuffer (GL_BACK);
  662.   drawScene();
  663.   if (bCacheable) {
  664.     if (isManipulatingRender()) {
  665. #if TOGLCACHE_DEBUG
  666.       cout << "uncacheable data: clearing cache" << endl;
  667. #endif
  668.       DisplayCache::InvalidateToglCache (togl);
  669.     } else {
  670. #if TOGLCACHE_DEBUG
  671.       cout << "data is cacheable" << endl;
  672. #endif
  673.       //Tcl_Eval (g_tclInterp, "redrawStatus cache");
  674.       DisplayCache::UpdateToglCache (togl);
  675.     }
  676.   }
  678.   if (buffer == GL_FRONT)    
  679.     Togl_SwapBuffers (togl);
  680.   else
  681.     glFinish();
  683.   // Take time at end of render and save
  684.   unsigned long endTime = Get_Milliseconds();
  685.   lastRenderTime(endTime-startTime);
  686.   
  687.   //puts ("Leaving drawinTOglBuffer");
  688.   //Tcl_Eval (g_tclInterp, "redrawStatus end");
  689. }
  692. int
  693. PlvSetSlowPolyCountCmd(ClientData clientData, Tcl_Interp *interp, 
  694.        int argc, char *argv[])
  695. {
  696.   if (argc != 2) {
  697.     interp->result = "Bad args to PlvSetSlowPolyCountCmd";
  698.     return TCL_ERROR;
  699.   }
  701.   theScene->setSlowPolyCount (atoi (argv[1]));
  702.   return TCL_OK;
  703. }
  706. int
  707. PlvInvalidateToglCacheCmd(ClientData clientData, Tcl_Interp *interp, 
  708.        int argc, char *argv[])
  709. {
  710.   DisplayCache::InvalidateToglCache (toglCurrent);
  711.   return TCL_OK;
  712. }
  715. /* drawOverlayAndSwap
  716.  * ------------------
  717.  * function to draw the overlay and then swap the buffer.  Used
  718.  * when overlay planes are not available, but are being simulated
  719.  */
  720. void drawOverlayAndSwap(struct Togl* togl)
  721. {
  722.   drawOverlay(togl);
  723.   Togl_SwapBuffers(togl);
  724. }
  726. void
  727. drawOverlay (struct Togl* togl)
  728. {
  729. #ifndef no_overlay_support
  730.   Togl_UseLayer (togl, TOGL_OVERLAY);
  731.   glClear(GL_COLOR_BUFFER_BIT);
  732. #else
  733.   // overlay planes not supported - use a work around
  735.   // make the togl current (should be the main frame) since 
  736.   Togl_MakeCurrent(togl);
  737.   //glDrawBuffer (GL_BACK);
  739.   // save all the bits just so I don't turn off something
  740.   // that someone else expects to be on
  741.   glPushAttrib(GL_ALL_ATTRIB_BITS);
  742.   
  743.   glDisable (GL_DEPTH_TEST);
  744.   glDisable (GL_LIGHTING);
  745.   glDisable (GL_BLEND);
  746.   
  747.   glMatrixMode(GL_MODELVIEW);
  748.   glPushMatrix();
  749.   glLoadIdentity();
  751.   glViewport(0,0,theWidth, theHeight);
  752.   glMatrixMode(GL_PROJECTION);
  753.   glPushMatrix();
  754.   
  755.   glLoadIdentity();
  756.   gluOrtho2D(0, theWidth, 0, theHeight);
  757.   glRasterPos2i(0,0);
  758.   
  759.   glDrawPixels(theRenderParams->savedImageWidth, 
  760.        theRenderParams->savedImageHeight, GL_RGBA, GL_UNSIGNED_BYTE,
  761.        theRenderParams->savedImage);
  762.   
  763.   glPopMatrix();
  764.   glMatrixMode(GL_MODELVIEW);
  765.   glPopMatrix();
  767.   glFinish();
  768.   
  769. #endif
  770.   
  771.   // selection tools
  772.   drawSelection (togl);
  774.   // mouseover hint
  775.   drawScanHilites();
  776.   
  777. #ifndef no_overlay_support
  778.   Togl_UseLayer (togl, TOGL_NORMAL);
  779. #else  
  780.   glPopAttrib();
  781.   //Togl_SwapBuffers (togl); 
  782. #endif
  783. }
  786. int
  787. PlvRenderThicknessCmd(ClientData clientData, Tcl_Interp *interp, 
  788.       int argc, char *argv[])
  789. {
  790.   Togl_MakeCurrent (toglCurrent);
  791.   if (!drawSceneThicknessColored()) {
  792.     return TCL_ERROR;
  793.   }
  795.   Togl_SwapBuffers (toglCurrent);
  797.   return TCL_OK;
  798. }
  801. unsigned long Get_Milliseconds(void)
  802. {
  803.   unsigned long time;
  805. #ifdef WIN32
  806.   time = GetTickCount();
  807. #else
  808.   struct timeval mytime;
  809.   static unsigned long base=0;
  811.   gettimeofday(&mytime, NULL);
  813.   time=(mytime.tv_sec-base)*1000 + (mytime.tv_usec/1000) ;
  814. #endif
  816.   return time;
  817. }
  819. // Read and optionally set the amount of time the last render took.
  820. // We record this whenever a render takes place and then expose an
  821. // interface to read this value.
  822. long lastRenderTime(long milliseconds)
  823. {
  824.   static long lastDrawTime=0;
  826.   long tmpSaveTime = lastDrawTime;
  827.   
  828.   if (milliseconds != -1)
  829.     lastDrawTime = milliseconds;
  831.   return tmpSaveTime;
  832. }
  834. int
  835. PlvLastRenderTime(ClientData clientData, Tcl_Interp *interp, 
  836.       int argc, char *argv[])
  837. {
  838.  
  840.   sprintf(interp->result,"%ld",lastRenderTime());
  842.   return TCL_OK;
  843. }