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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
opengl_renderer.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：64k
源码类别：

生物技术

开发平台：

C/C++

opengl_renderer.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: opengl_renderer.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 18:28:52  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.79
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: opengl_renderer.cpp,v 1000.3 2004/06/01 18:28:52 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Paul Thiessen
  36. *
  37. * File Description:
  38. *      Classes to hold the OpenGL rendering engine
  39. *
  40. * ===========================================================================
  41. */
  43. #ifdef _MSC_VER
  44. #pragma warning(disable:4018)   // disable signed/unsigned mismatch warning in MSVC
  45. #endif
  47. #include <ncbi_pch.hpp>
  48. #include <corelib/ncbistd.hpp>
  49. #include <corelib/ncbitime.hpp> // avoids some 'CurrentTime' conflict later on...
  50. #include <corelib/ncbiobj.hpp>
  52. #if defined(__WXMSW__)
  53. #include <windows.h>
  54. #include <GL/gl.h>
  55. #include <GL/glu.h>
  57. #elif defined(__WXGTK__)
  58. #include <GL/gl.h>
  59. #include <GL/glu.h>
  60. #include <GL/glx.h>
  61. #include <gdk/gdk.h>    // needed for GdkFont
  63. #elif defined(__WXMAC__)
  64. //#include <Fonts.h>
  65. #include <OpenGL/gl.h>
  66. #include <OpenGL/glu.h>
  67. #endif
  69. #include <math.h>
  70. #include <stdlib.h> // for rand, srand
  72. #include <objects/cn3d/Cn3d_GL_matrix.hpp>
  73. #include <objects/cn3d/Cn3d_vector.hpp>
  75. #include "opengl_renderer.hpp"
  76. #include "structure_window.hpp"
  77. #include "cn3d_glcanvas.hpp"
  78. #include "structure_set.hpp"
  79. #include "style_manager.hpp"
  80. #include "messenger.hpp"
  81. #include "cn3d_tools.hpp"
  82. #include "asn_converter.hpp"
  83. #include "cn3d_colors.hpp"
  85. USING_NCBI_SCOPE;
  86. USING_SCOPE(objects);
  89. BEGIN_SCOPE(Cn3D)
  91. static const double PI = acos(-1.0);
  92. static inline double DegreesToRad(double deg) { return deg*PI/180.0; }
  93. static inline double RadToDegrees(double rad) { return rad*180.0/PI; }
  95. const unsigned int OpenGLRenderer::NO_LIST = 0;
  96. const unsigned int OpenGLRenderer::FIRST_LIST = 1;
  97. const unsigned int OpenGLRenderer::FONT_BASE = 1000;
  99. static const unsigned int ALL_FRAMES = 4294967295;
  101. // it's easier to keep one global qobj for now
  102. static GLUquadricObj *qobj = NULL;
  104. // pick buffer
  105. const unsigned int OpenGLRenderer::NO_NAME = 0;
  106. static const int pickBufSize = 1024;
  107. static GLuint selectBuf[pickBufSize];
  109. /* these are used for both matrial colors and light colors */
  110. static const GLfloat Color_Off[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
  111. static const GLfloat Color_MostlyOff[4] = { 0.05f, 0.05f, 0.05f, 1.0f };
  112. static const GLfloat Color_MostlyOn[4] = { 0.95f, 0.95f, 0.95f, 1.0f };
  113. static const GLfloat Color_On[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
  114. static const GLfloat Color_Specular[4] = { 0.5f, 0.5f, 0.5f, 1.0f };
  115. static const GLint Shininess = 40;
  117. // to cache registry values
  118. static int atomSlices, atomStacks, bondSides, wormSides, wormSegments, helixSides;
  119. static bool highlightsOn;
  120. static string projectionType;
  123. // matrix conversion utility functions
  125. // convert from Matrix to GL-matrix ordering
  126. static void Matrix2GL(const Matrix& m, GLdouble *g)
  127. {
  128.     g[0]=m.m[0];  g[4]=m.m[1];  g[8]=m.m[2];   g[12]=m.m[3];
  129.     g[1]=m.m[4];  g[5]=m.m[5];  g[9]=m.m[6];   g[13]=m.m[7];
  130.     g[2]=m.m[8];  g[6]=m.m[9];  g[10]=m.m[10]; g[14]=m.m[11];
  131.     g[3]=m.m[12]; g[7]=m.m[13]; g[11]=m.m[14]; g[15]=m.m[15];
  132. }
  134. // convert from GL-matrix to Matrix ordering
  135. static void GL2Matrix(GLdouble *g, Matrix *m)
  136. {
  137.     m->m[0]=g[0];  m->m[1]=g[4];  m->m[2]=g[8];   m->m[3]=g[12];
  138.     m->m[4]=g[1];  m->m[5]=g[5];  m->m[6]=g[9];   m->m[7]=g[13];
  139.     m->m[8]=g[2];  m->m[9]=g[6];  m->m[10]=g[10]; m->m[11]=g[14];
  140.     m->m[12]=g[3]; m->m[13]=g[7]; m->m[14]=g[11]; m->m[15]=g[15];
  141. }
  143. // OpenGLRenderer methods - initialization and setup
  145. OpenGLRenderer::OpenGLRenderer(Cn3DGLCanvas *parentGLCanvas) :
  146.     structureSet(NULL), glCanvas(parentGLCanvas),
  147.     selectMode(false), currentDisplayList(NO_LIST), cameraAngleRad(0.0), rotateSpeed(0.5),
  148.     stereoOn(false)
  149. {
  150.     // make sure a name will fit in a GLuint
  151.     if (sizeof(GLuint) < sizeof(unsigned int))
  152.         FATALMSG("Cn3D requires that sizeof(GLuint) >= sizeof(unsigned int)");
  153. }
  155. void OpenGLRenderer::Init(void) const
  156. {
  157.     glMatrixMode(GL_MODELVIEW);
  158.     glLoadIdentity();
  160.     // set up the lighting
  161.     // directional light (faster) when LightPosition[4] == 0.0
  162.     GLfloat LightPosition[4] = { 0.0f, 0.0f, 1.0f, 0.0f };
  163.     glLightfv(GL_LIGHT0, GL_POSITION, LightPosition);
  164.     glLightfv(GL_LIGHT0, GL_AMBIENT, Color_Off);
  165.     glLightfv(GL_LIGHT0, GL_DIFFUSE, Color_MostlyOn);
  166.     glLightfv(GL_LIGHT0, GL_SPECULAR, Color_On);
  167.     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, Color_On); // global ambience
  168.     glEnable(GL_LIGHTING);
  169.     glEnable(GL_LIGHT0);
  171.     // set these material colors
  172.     glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Color_Off);
  173.     glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, Shininess);
  175.     // turn on culling to speed rendering
  176.     glEnable(GL_CULL_FACE);
  177.     glCullFace(GL_BACK);
  178.     glFrontFace(GL_CCW);
  180.     // misc options
  181.     glShadeModel(GL_SMOOTH);
  182.     glEnable(GL_DEPTH_TEST);
  183.     glDisable(GL_NORMALIZE);
  184.     glDisable(GL_SCISSOR_TEST);
  186.     RecreateQuadric();
  187. }
  190. // methods dealing with the view
  192. void OpenGLRenderer::NewView(double eyeTranslateToAngleDegrees) const
  193. {
  194.     if (cameraAngleRad <= 0.0) return;
  196.     GLint Viewport[4];
  197.     glGetIntegerv(GL_VIEWPORT, Viewport);
  199.     glMatrixMode(GL_PROJECTION);
  200.     glLoadIdentity();
  202.     if (selectMode) {
  203.         gluPickMatrix(static_cast<GLdouble>(selectX),
  204.                       static_cast<GLdouble>(Viewport[3] - selectY),
  205.                       1.0, 1.0, Viewport);
  206.     }
  208.     GLdouble aspect = (static_cast<GLdouble>(Viewport[2])) / Viewport[3];
  210.     // set camera angle/perspective
  211.     if (projectionType == "Perspective") {
  212.         gluPerspective(RadToDegrees(cameraAngleRad),    // viewing angle (degrees)
  213.                        aspect,                          // w/h aspect
  214.                        cameraClipNear,                  // near clipping plane
  215.                        cameraClipFar);                  // far clipping plane
  216.     } else { // Orthographic
  217.         GLdouble right, top;
  218.         top = ((cameraClipNear + cameraClipFar) / 2.0) * sin(cameraAngleRad / 2.0);
  219.         right = top * aspect;
  220.         glOrtho(-right,             // sides of viewing box, assuming eye is at (0,0,0)
  221.                 right,
  222.                 -top,
  223.                 top,
  224.                 cameraClipNear,     // near clipping plane
  225.                 cameraClipFar);     // far clipping plane
  226.     }
  228.     Vector cameraLoc(0.0, 0.0, cameraDistance);
  230.     if (stereoOn && eyeTranslateToAngleDegrees != 0.0) {
  231.         Vector view(cameraLookAtX, cameraLookAtY, -cameraDistance);
  232.         Vector translate = vector_cross(view, Vector(0.0, 1.0, 0.0));
  233.         translate.normalize();
  234.         translate *= view.length() * tan(DegreesToRad(eyeTranslateToAngleDegrees));
  235.         cameraLoc += translate;
  236.     }
  238.     // set camera position and direction
  239.     gluLookAt(cameraLoc.x, cameraLoc.y, cameraLoc.z,    // the camera position
  240.               cameraLookAtX, cameraLookAtY, 0.0,        // the "look-at" point
  241.               0.0, 1.0, 0.0);                           // the up direction
  243.     glMatrixMode(GL_MODELVIEW);
  244. }
  246. void OpenGLRenderer::Display(void)
  247. {
  248.     if (structureSet) {
  249.         const Vector& background = structureSet->styleManager->GetBackgroundColor();
  250.         glClearColor(background[0], background[1], background[2], 1.0);
  251.     } else
  252.         glClearColor(0.0, 0.0, 0.0, 1.0);
  253.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  255.     if (selectMode) {
  256.         glInitNames();
  257.         glPushName(0);
  258.     }
  260.     GLint viewport[4] = {0, 0, 0, 0};
  261.     double eyeSeparationDegrees = 0.0;
  262.     if (stereoOn) {
  263.         bool proximalStereo;
  264.         glGetIntegerv(GL_VIEWPORT, viewport);
  265.         if (!RegistryGetDouble(REG_ADVANCED_SECTION, REG_STEREO_SEPARATION, &eyeSeparationDegrees) ||
  266.             !RegistryGetBoolean(REG_ADVANCED_SECTION, REG_PROXIMAL_STEREO, &proximalStereo))
  267.         {
  268.             ERRORMSG("OpenGLRenderer::Display() - error getting stereo settings from registry");
  269.             return;
  270.         }
  271.         if (!proximalStereo)
  272.             eyeSeparationDegrees = -eyeSeparationDegrees;
  273.     }
  275.     int first = 1, last = stereoOn ? 2 : 1;
  276.     for (int e=first; e<=last; ++e) {
  278.         glLoadMatrixd(viewMatrix);
  280.         // adjust viewport & camera angle for stereo
  281.         if (stereoOn) {
  282.             if (e == first) {
  283.                 // left side
  284.                 glViewport(0, viewport[1], viewport[2] / 2, viewport[3]);
  285.                 NewView(eyeSeparationDegrees / 2);
  286.             } else {
  287.                 // right side
  288.                 glViewport(viewport[2] / 2, viewport[1], viewport[2] - viewport[2] / 2, viewport[3]);
  289.                 NewView(-eyeSeparationDegrees / 2);
  290.             }
  291.         }
  293.         if (structureSet) {
  294.             if (currentFrame == ALL_FRAMES) {
  295.                 for (unsigned int i=FIRST_LIST; i<=structureSet->lastDisplayList; ++i) {
  296.                     PushMatrix(*(structureSet->transformMap[i]));
  297.                     glCallList(i);
  298.                     PopMatrix();
  299.                     AddTransparentSpheresForList(i);
  300.                 }
  301.             } else {
  302.                 StructureSet::DisplayLists::const_iterator
  303.                     l, le=structureSet->frameMap[currentFrame].end();
  304.                 for (l=structureSet->frameMap[currentFrame].begin(); l!=le; ++l) {
  305.                     PushMatrix(*(structureSet->transformMap[*l]));
  306.                     glCallList(*l);
  307.                     PopMatrix();
  308.                     AddTransparentSpheresForList(*l);
  309.                 }
  310.             }
  312.             // draw transparent spheres, which are already stored in view-transformed coordinates
  313.             glLoadIdentity();
  314.             RenderTransparentSpheres();
  315.         }
  317.         // draw logo if no structure
  318.         else {
  319.             glCallList(FIRST_LIST);
  320.         }
  321.     }
  323.     glFlush();
  325.     // restore full viewport
  326.     if (stereoOn)
  327.         glViewport(0, viewport[1], viewport[2], viewport[3]);
  328. }
  330. void OpenGLRenderer::EnableStereo(bool enableStereo)
  331. {
  332.     TRACEMSG("turning " << (enableStereo ? "on" : "off" ) << " stereo");
  333.     stereoOn = enableStereo;
  334.     if (!stereoOn)
  335.         NewView();
  336. }
  338. void OpenGLRenderer::ResetCamera(void)
  339. {
  340.     // set up initial camera
  341.     glLoadIdentity();
  342.     cameraLookAtX = cameraLookAtY = 0.0;
  344.     if (structureSet) { // for structure
  345.         cameraAngleRad = DegreesToRad(35.0);
  346.         // calculate camera distance so that structure fits exactly in
  347.         // the window in any rotation (based on structureSet's maxDistFromCenter)
  348.         GLint Viewport[4];
  349.         glGetIntegerv(GL_VIEWPORT, Viewport);
  350.         double angle = cameraAngleRad, aspect = (static_cast<double>(Viewport[2])) / Viewport[3];
  351.         if (aspect < 1.0) angle *= aspect;
  352.         cameraDistance = structureSet->maxDistFromCenter / sin(angle/2);
  353.         // allow a little "extra" room between clipping planes
  354.         cameraClipNear = (cameraDistance - structureSet->maxDistFromCenter) * 0.66;
  355.         cameraClipFar = (cameraDistance + structureSet->maxDistFromCenter) * 1.2;
  356.         // move structureSet's center to origin
  357.         glTranslated(-structureSet->center.x, -structureSet->center.y, -structureSet->center.z);
  358.         structureSet->rotationCenter = structureSet->center;
  360.     } else { // for logo
  361.         cameraAngleRad = PI / 14;
  362.         cameraDistance = 200;
  363.         cameraClipNear = 0.5*cameraDistance;
  364.         cameraClipFar = 1.5*cameraDistance;
  365.     }
  367.     // reset matrix
  368.     glGetDoublev(GL_MODELVIEW_MATRIX, viewMatrix);
  369.     NewView();
  370. }
  372. void OpenGLRenderer::ChangeView(eViewAdjust control, int dX, int dY, int X2, int Y2)
  373. {
  374.     bool doTranslation = false;
  375.     Vector rotCenter;
  376.     double pixelSize;
  377.     GLint viewport[4];
  379.     // find out where rotation center is in current GL coordinates
  380.     if (structureSet && (control==eXYRotateHV || control==eZRotateH) &&
  381.         structureSet->rotationCenter != structureSet->center) {
  382.         Matrix m;
  383.         GL2Matrix(viewMatrix, &m);
  384.         rotCenter = structureSet->rotationCenter;
  385.         ApplyTransformation(&rotCenter, m);
  386.         doTranslation = true;
  387.     }
  389.     glLoadIdentity();
  391.     // rotate relative to rotationCenter
  392.     if (doTranslation) glTranslated(rotCenter.x, rotCenter.y, rotCenter.z);
  394. #define MIN_CAMERA_ANGLE 0.001
  395. #define MAX_CAMERA_ANGLE (0.999 * PI)
  397.     switch (control) {
  398.         case eXYRotateHV:
  399.             glRotated(rotateSpeed*dY, 1.0, 0.0, 0.0);
  400.             glRotated(rotateSpeed*dX, 0.0, 1.0, 0.0);
  401.             break;
  403.         case eZRotateH:
  404.             glRotated(rotateSpeed*dX, 0.0, 0.0, 1.0);
  405.             break;
  407.         case eXYTranslateHV:
  408.             glGetIntegerv(GL_VIEWPORT, viewport);
  409.             pixelSize = tan(cameraAngleRad / 2.0) * 2.0 * cameraDistance / viewport[3];
  410.             cameraLookAtX -= dX * pixelSize;
  411.             cameraLookAtY += dY * pixelSize;
  412.             NewView();
  413.             break;
  415.         case eZoomH:
  416.             cameraAngleRad *= 1.0 - 0.01 * dX;
  417.             if (cameraAngleRad < MIN_CAMERA_ANGLE) cameraAngleRad = MIN_CAMERA_ANGLE;
  418.             else if (cameraAngleRad > MAX_CAMERA_ANGLE) cameraAngleRad = MAX_CAMERA_ANGLE;
  419.             NewView();
  420.             break;
  422.         case eZoomHHVV:
  423.             break;
  425.         case eZoomOut:
  426.             cameraAngleRad *= 1.5;
  427.             if (cameraAngleRad > MAX_CAMERA_ANGLE) cameraAngleRad = MAX_CAMERA_ANGLE;
  428.             NewView();
  429.             break;
  431.         case eZoomIn:
  432.             cameraAngleRad /= 1.5;
  433.             if (cameraAngleRad < MIN_CAMERA_ANGLE) cameraAngleRad = MIN_CAMERA_ANGLE;
  434.             NewView();
  435.             break;
  437.         case eCenterCamera:
  438.             cameraLookAtX = cameraLookAtY = 0.0;
  439.             NewView();
  440.             break;
  441.     }
  443.     if (doTranslation) glTranslated(-rotCenter.x, -rotCenter.y, -rotCenter.z);
  445.     glMultMatrixd(viewMatrix);
  446.     glGetDoublev(GL_MODELVIEW_MATRIX, viewMatrix);
  447. }
  449. void OpenGLRenderer::CenterView(const Vector& viewCenter, double radius)
  450. {
  451.     ResetCamera();
  453.     structureSet->rotationCenter = viewCenter;
  455.     Vector cameraLocation(0.0, 0.0, cameraDistance);
  456.     Vector centerWRTcamera = viewCenter - structureSet->center;
  457.     Vector direction = centerWRTcamera - cameraLocation;
  458.     direction.normalize();
  459.     double cosAngleZ = -direction.z;
  460.     Vector lookAt = centerWRTcamera + direction * (centerWRTcamera.z / cosAngleZ);
  461.     cameraLookAtX = lookAt.x;
  462.     cameraLookAtY = lookAt.y;
  464.     cameraAngleRad = 2.0 * atan(radius / (cameraLocation - centerWRTcamera).length());
  466.     NewView();
  467.     TRACEMSG("looking at " << lookAt << " angle " << RadToDegrees(cameraAngleRad));
  469.     // do this so that this view is used upon restore
  470.     SaveToASNViewSettings(NULL);
  471. }
  473. void OpenGLRenderer::PushMatrix(const Matrix* m)
  474. {
  475.     glPushMatrix();
  476.     if (m) {
  477.         GLdouble g[16];
  478.         Matrix2GL(*m, g);
  479.         glMultMatrixd(g);
  480.     }
  481. }
  483. void OpenGLRenderer::PopMatrix(void)
  484. {
  485.     glPopMatrix();
  486. }
  488. // display list management stuff
  489. void OpenGLRenderer::StartDisplayList(unsigned int list)
  490. {
  491.     if (list >= FONT_BASE) {
  492.         ERRORMSG("OpenGLRenderer::StartDisplayList() - too many display lists;n"
  493.             << "increase OpenGLRenderer::FONT_BASE");
  494.         return;
  495.     }
  496.     ClearTransparentSpheresForList(list);
  497.     SetColor(GL_NONE); // reset color caches in SetColor
  499.     glNewList(list, GL_COMPILE);
  500.     currentDisplayList = list;
  502.     if (currentDisplayList >= displayListEmpty.size()) displayListEmpty.resize(currentDisplayList + 1, true);
  503.     displayListEmpty[currentDisplayList] = true;
  504. }
  506. void OpenGLRenderer::EndDisplayList(void)
  507. {
  508.     glEndList();
  509.     currentDisplayList = NO_LIST;
  510. }
  513. // frame management methods
  515. void OpenGLRenderer::ShowAllFrames(void)
  516. {
  517.     if (structureSet) currentFrame = ALL_FRAMES;
  518. }
  520. bool OpenGLRenderer::IsFrameEmpty(unsigned int frame) const
  521. {
  522.     if (!structureSet || structureSet->frameMap.size() <= frame) return false;
  524.     StructureSet::DisplayLists::const_iterator l, le=structureSet->frameMap[frame].end();
  525.     for (l=structureSet->frameMap[frame].begin(); l!=le; ++l)
  526.         if (!displayListEmpty[*l])
  527.             return false;
  528.     return true;
  529. }
  531. void OpenGLRenderer::ShowFirstFrame(void)
  532. {
  533.     if (!structureSet || structureSet->frameMap.size() == 0) return;
  534.     currentFrame = 0;
  535.     while (IsFrameEmpty(currentFrame) && currentFrame < structureSet->frameMap.size() - 1)
  536.         ++currentFrame;
  537. }
  539. void OpenGLRenderer::ShowLastFrame(void)
  540. {
  541.     if (!structureSet || structureSet->frameMap.size() == 0) return;
  542.     currentFrame = structureSet->frameMap.size() - 1;
  543.     while (IsFrameEmpty(currentFrame) && currentFrame > 0)
  544.         --currentFrame;
  545. }
  547. void OpenGLRenderer::ShowNextFrame(void)
  548. {
  549.     if (!structureSet || structureSet->frameMap.size() == 0) return;
  550.     if (currentFrame == ALL_FRAMES) currentFrame = structureSet->frameMap.size() - 1;
  551.     int originalFrame = currentFrame;
  552.     do {
  553.         if (currentFrame == structureSet->frameMap.size() - 1)
  554.             currentFrame = 0;
  555.         else
  556.             ++currentFrame;
  557.     } while (IsFrameEmpty(currentFrame) && currentFrame != originalFrame);
  558. }
  560. void OpenGLRenderer::ShowPreviousFrame(void)
  561. {
  562.     if (!structureSet || structureSet->frameMap.size() == 0) return;
  563.     if (currentFrame == ALL_FRAMES) currentFrame = 0;
  564.     int originalFrame = currentFrame;
  565.     do {
  566.         if (currentFrame == 0)
  567.             currentFrame = structureSet->frameMap.size() - 1;
  568.         else
  569.             --currentFrame;
  570.     } while (IsFrameEmpty(currentFrame) && currentFrame != originalFrame);
  571. }
  573. void OpenGLRenderer::ShowFrameNumber(int frame)
  574. {
  575.     if (!structureSet) return;
  576.     if (frame >= 0 && frame < structureSet->frameMap.size() && !IsFrameEmpty(frame))
  577.         currentFrame = frame;
  578.     else
  579.         currentFrame = ALL_FRAMES;
  580. }
  582. // process selection; return gl-name of result
  583. bool OpenGLRenderer::GetSelected(int x, int y, unsigned int *name)
  584. {
  585.     // render with GL_SELECT mode, to fill selection buffer
  586.     glSelectBuffer(pickBufSize, selectBuf);
  587.     glRenderMode(GL_SELECT);
  588.     selectMode = true;
  589.     selectX = x;
  590.     selectY = y;
  591.     NewView();
  592.     Display();
  593.     GLint hits = glRenderMode(GL_RENDER);
  594.     selectMode = false;
  595.     NewView();
  597.     // parse selection buffer to find name of selected item
  598.     int i, j, p=0, n, top=0;
  599.     GLuint minZ=0;
  600.     *name = NO_NAME;
  601.     for (i=0; i<hits; ++i) {
  602.         n = selectBuf[p++];                 // # names
  603.         if (i==0 || minZ > selectBuf[p]) {  // find item with min depth
  604.             minZ = selectBuf[p];
  605.             top = 1;
  606.         } else
  607.             top = 0;
  608.         ++p;
  609.         ++p;                                // skip max depth
  610.         for (j=0; j<n; ++j) {               // loop through n names
  611.             switch (j) {
  612.                 case 0:
  613.                     if (top) *name = static_cast<unsigned int>(selectBuf[p]);
  614.                     break;
  615.                 default:
  616.                     WARNINGMSG("GL select: Got more than 1 name!");
  617.             }
  618.             ++p;
  619.         }
  620.     }
  622.     if (*name != NO_NAME)
  623.         return true;
  624.     else
  625.         return false;
  626. }
  628. void OpenGLRenderer::AttachStructureSet(StructureSet *targetStructureSet)
  629. {
  630.     structureSet = targetStructureSet;
  631.     currentFrame = ALL_FRAMES;
  632.     if (!structureSet) initialViewFromASN.Reset();
  634.     Init();             // init GL system
  635.     Construct();        // draw structures
  636.     RestoreSavedView(); // load initial view if present
  637. }
  639. void OpenGLRenderer::RecreateQuadric(void) const
  640. {
  641.     if (qobj)
  642.         gluDeleteQuadric(qobj);
  643.     if (!(qobj = gluNewQuadric())) {
  644.         ERRORMSG("unable to create a new GLUQuadricObj");
  645.         return;
  646.     }
  647.     gluQuadricDrawStyle(qobj, (GLenum) GLU_FILL);
  648.     gluQuadricNormals(qobj, (GLenum) GLU_SMOOTH);
  649.     gluQuadricOrientation(qobj, (GLenum) GLU_OUTSIDE);
  650.     gluQuadricTexture(qobj, GL_FALSE);
  651. }
  653. void OpenGLRenderer::Construct(void)
  654. {
  655.     glMatrixMode(GL_MODELVIEW);
  656.     glLoadIdentity();
  658.     if (structureSet) {
  660.         // get quality values from registry - assumes some values have been set already!
  661.         if (!RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_ATOM_SLICES, &atomSlices) ||
  662.             !RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_ATOM_STACKS, &atomStacks) ||
  663.             !RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_BOND_SIDES, &bondSides) ||
  664.             !RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_WORM_SIDES, &wormSides) ||
  665.             !RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_WORM_SEGMENTS, &wormSegments) ||
  666.             !RegistryGetInteger(REG_QUALITY_SECTION, REG_QUALITY_HELIX_SIDES, &helixSides) ||
  667.             !RegistryGetBoolean(REG_QUALITY_SECTION, REG_HIGHLIGHTS_ON, &highlightsOn) ||
  668.             !RegistryGetString(REG_QUALITY_SECTION, REG_PROJECTION_TYPE, &projectionType))
  669.             ERRORMSG("OpenGLRenderer::Construct() - error getting quality setting from registry");
  671.         // do the drawing
  672.         structureSet->DrawAll();
  674.     } else {
  675.         SetColor(GL_NONE);
  676.         ConstructLogo();
  677.     }
  679.     GlobalMessenger()->UnPostStructureRedraws();
  680. }
  682. // set current GL color; don't change color if it's same as what's current
  683. void OpenGLRenderer::SetColor(int type, double red, double green, double blue, double alpha)
  684. {
  685.     static double pr, pg, pb, pa;
  686.     static GLenum pt = GL_NONE;
  688.     if (type == GL_NONE) {
  689.         pt = GL_NONE;
  690.         return;
  691.     }
  692.     if (alpha <= 0.0) WARNINGMSG("SetColor request alpha <= 0.0");
  694.     if (red != pr || green != pg || blue != pb || type != pt || alpha != pa) {
  695.         if (type != pt) {
  696.             if (type == GL_DIFFUSE) {
  697.                 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Color_MostlyOff);
  698.                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,
  699.                     highlightsOn ? Color_Specular : Color_Off);
  700.             } else if (type == GL_AMBIENT) {
  701.                 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Color_Off);
  702.                 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Color_Off); // no specular for ambient coloring
  703.             } else {
  704.                 ERRORMSG("don't know how to handle material type " << type);
  705.             }
  706.             pt = (GLenum) type;
  707.         }
  708.         GLfloat rgba[4] = { red, green, blue, alpha };
  709.         glMaterialfv(GL_FRONT_AND_BACK, (GLenum) type, rgba);
  710.         // this is necessary so that fonts are rendered in correct
  711.         // color in SGI's OpenGL implementation, and maybe others
  712.         if (type == GL_AMBIENT) glColor4fv(rgba);
  714.         pr = red;
  715.         pg = green;
  716.         pb = blue;
  717.         pa = alpha;
  718.     }
  719. }
  721. /* create display list with logo */
  722. void OpenGLRenderer::ConstructLogo(void)
  723. {
  724.     static const GLfloat logoColor[3] = { 100.0f/255, 240.0f/255, 150.0f/255 };
  725.     static const int LOGO_SIDES = 36, segments = 180;
  726.     int i, n, s, g;
  727.     GLdouble bigRad = 12.0, height = 24.0,
  728.         minRad = 0.1, maxRad = 2.0,
  729.         ringPts[LOGO_SIDES * 3], *pRingPts = ringPts,
  730.         prevRing[LOGO_SIDES * 3], *pPrevRing = prevRing, *tmp,
  731.         ringNorm[LOGO_SIDES * 3], *pRingNorm = ringNorm,
  732.         prevNorm[LOGO_SIDES * 3], *pPrevNorm = prevNorm,
  733.         length, startRad, midRad, phase, currentRad, CR[3], H[3], V[3];
  735.     ClearTransparentSpheresForList(FIRST_LIST);
  736.     glNewList(FIRST_LIST, GL_COMPILE);
  738.     /* create logo */
  739.     SetColor(GL_DIFFUSE, logoColor[0], logoColor[1], logoColor[2]);
  741.     for (n = 0; n < 2; ++n) { /* helix strand */
  742.         if (n == 0) {
  743.             startRad = maxRad;
  744.             midRad = minRad;
  745.             phase = 0;
  746.         } else {
  747.             startRad = minRad;
  748.             midRad = maxRad;
  749.             phase = PI;
  750.         }
  751.         for (g = 0; g <= segments; ++g) { /* segment (bottom to top) */
  753.             if (g < segments/2)
  754.                 currentRad = startRad + (midRad - startRad) *
  755.                     (0.5 - 0.5 * cos(PI * g / (segments/2)));
  756.             else
  757.                 currentRad = midRad + (startRad - midRad) *
  758.                     (0.5 - 0.5 * cos(PI * (g - segments/2) / (segments/2)));
  760.             CR[1] = height * g / segments - height/2;
  761.             if (g > 0) phase += PI * 2 / segments;
  762.             CR[2] = bigRad * cos(phase);
  763.             CR[0] = bigRad * sin(phase);
  765.             /* make a strip around the strand circumference */
  766.             for (s = 0; s < LOGO_SIDES; ++s) {
  767.                 V[0] = CR[0];
  768.                 V[2] = CR[2];
  769.                 V[1] = 0;
  770.                 length = sqrt(V[0]*V[0] + V[1]*V[1] + V[2]*V[2]);
  771.                 for (i = 0; i < 3; ++i) V[i] /= length;
  772.                 H[0] = H[2] = 0;
  773.                 H[1] = 1;
  774.                 for (i = 0; i < 3; ++i) {
  775.                     pRingNorm[3*s + i] = V[i] * cos(PI * 2 * s / LOGO_SIDES) +
  776.                                          H[i] * sin(PI * 2 * s / LOGO_SIDES);
  777.                     pRingPts[3*s + i] = CR[i] + pRingNorm[3*s + i] * currentRad;
  778.                 }
  779.             }
  780.             if (g > 0) {
  781.                 glBegin(GL_TRIANGLE_STRIP);
  782.                 for (s = 0; s < LOGO_SIDES; ++s) {
  783.                     glNormal3d(pPrevNorm[3*s], pPrevNorm[3*s + 1], pPrevNorm[3*s + 2]);
  784.                     glVertex3d(pPrevRing[3*s], pPrevRing[3*s + 1], pPrevRing[3*s + 2]);
  785.                     glNormal3d(pRingNorm[3*s], pRingNorm[3*s + 1], pRingNorm[3*s + 2]);
  786.                     glVertex3d(pRingPts[3*s], pRingPts[3*s + 1], pRingPts[3*s + 2]);
  787.                 }
  788.                 glNormal3d(pPrevNorm[0], pPrevNorm[1], pPrevNorm[2]);
  789.                 glVertex3d(pPrevRing[0], pPrevRing[1], pPrevRing[2]);
  790.                 glNormal3d(pRingNorm[0], pRingNorm[1], pRingNorm[2]);
  791.                 glVertex3d(pRingPts[0], pRingPts[1], pRingPts[2]);
  792.                 glEnd();
  793.             }
  795.             /* cap the ends */
  796.             glBegin(GL_POLYGON);
  797.             if ((g == 0 && n == 0) || (g == segments && n == 1))
  798.                 glNormal3d(-1, 0, 0);
  799.             else
  800.                 glNormal3d(1, 0, 0);
  801.             if (g == 0) {
  802.                 for (s = 0; s < LOGO_SIDES; ++s)
  803.                     glVertex3d(pRingPts[3*s], pRingPts[3*s + 1], pRingPts[3*s + 2]);
  804.             } else if (g == segments) {
  805.                 for (s = LOGO_SIDES - 1; s >= 0; --s)
  806.                     glVertex3d(pRingPts[3*s], pRingPts[3*s + 1], pRingPts[3*s + 2]);
  807.             }
  808.             glEnd();
  810.             /* switch pointers to store previous ring */
  811.             tmp = pPrevRing;
  812.             pPrevRing = pRingPts;
  813.             pRingPts = tmp;
  814.             tmp = pPrevNorm;
  815.             pPrevNorm = pRingNorm;
  816.             pRingNorm = tmp;
  817.         }
  818.     }
  820.     glEndList();
  821. }
  823. // stuff dealing with rendering of transparent spheres
  825. void OpenGLRenderer::AddTransparentSphere(const Vector& color, unsigned int name,
  826.     const Vector& site, double radius, double alpha)
  827. {
  828.     if (currentDisplayList == NO_LIST) {
  829.         WARNINGMSG("OpenGLRenderer::AddTransparentSphere() - not called during display list creation");
  830.         return;
  831.     }
  833.     SphereList& spheres = transparentSphereMap[currentDisplayList];
  834.     spheres.resize(spheres.size() + 1);
  835.     SphereInfo& info = spheres.back();
  836.     info.site = site;
  837.     info.name = name;
  838.     info.color = color;
  839.     info.radius = radius;
  840.     info.alpha = alpha;
  841. }
  843. // add spheres associated with this display list; calculate distance from camera to each one
  844. void OpenGLRenderer::AddTransparentSpheresForList(unsigned int list)
  845. {
  846.     SphereMap::const_iterator sL = transparentSphereMap.find(list);
  847.     if (sL == transparentSphereMap.end()) return;
  849.     const SphereList& sphereList = sL->second;
  851.     Matrix view;
  852.     GL2Matrix(viewMatrix, &view);
  854.     transparentSpheresToRender.resize(transparentSpheresToRender.size() + sphereList.size());
  855.     SpherePtrList::reverse_iterator sph = transparentSpheresToRender.rbegin();
  857.     SphereList::const_iterator i, ie=sphereList.end();
  858.     const Matrix *slaveTransform;
  859.     for (i=sphereList.begin(); i!=ie; ++i, ++sph) {
  860.         sph->siteGL = i->site;
  861.         slaveTransform = *(structureSet->transformMap[list]);
  862.         if (slaveTransform)
  863.             ApplyTransformation(&(sph->siteGL), *slaveTransform);               // slave->master transform
  864.         ApplyTransformation(&(sph->siteGL), view);                              // current view transform
  865.         sph->distanceFromCamera = (Vector(0,0,cameraDistance) - sph->siteGL).length() - i->radius;
  866.         sph->ptr = &(*i);
  867.     }
  868. }
  870. void OpenGLRenderer::RenderTransparentSpheres(void)
  871. {
  872.     if (transparentSpheresToRender.size() == 0) return;
  874.     // sort spheres by distance from camera, via operator < defined for SpherePtr
  875.     transparentSpheresToRender.sort();
  877.     // turn on blending
  878.     glEnable(GL_BLEND);
  879.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  881.     SetColor(GL_NONE); // reset color caches in SetColor
  883.     // render spheres in order (farthest first)
  884.     SpherePtrList::reverse_iterator i, ie=transparentSpheresToRender.rend();
  885.     for (i=transparentSpheresToRender.rbegin(); i!=ie; ++i) {
  886.         SetColor(GL_DIFFUSE, i->ptr->color[0], i->ptr->color[1], i->ptr->color[2], i->ptr->alpha);
  887.         glLoadName(static_cast<GLuint>(i->ptr->name));
  888.         glPushMatrix();
  889.         glTranslated(i->siteGL.x, i->siteGL.y, i->siteGL.z);
  891.         // apply a random spin so they're not all facing the same direction
  892.         srand(static_cast<unsigned int>(fabs(i->ptr->site.x * 1000)));
  893.         glRotated(360.0*rand()/RAND_MAX,
  894.             1.0*rand()/RAND_MAX - 0.5, 1.0*rand()/RAND_MAX - 0.5, 1.0*rand()/RAND_MAX - 0.5);
  896.         gluSphere(qobj, i->ptr->radius, atomSlices, atomStacks);
  897.         glPopMatrix();
  898.     }
  900.     // turn off blending
  901.     glDisable(GL_BLEND);
  903.     // clear list; recreate it upon each Display()
  904.     transparentSpheresToRender.clear();
  905. }
  907. void OpenGLRenderer::DrawAtom(const Vector& site, const AtomStyle& atomStyle)
  908. {
  909.     if (atomStyle.style == StyleManager::eNotDisplayed || atomStyle.radius <= 0.0)
  910.         return;
  912.     if (atomStyle.style == StyleManager::eSolidAtom) {
  913.         SetColor(GL_DIFFUSE, atomStyle.color[0], atomStyle.color[1], atomStyle.color[2]);
  914.         glLoadName(static_cast<GLuint>(atomStyle.name));
  915.         glPushMatrix();
  916.         glTranslated(site.x, site.y, site.z);
  917.         gluSphere(qobj, atomStyle.radius, atomSlices, atomStacks);
  918.         glPopMatrix();
  919.     }
  920.     // need to delay rendering of transparent spheres
  921.     else {
  922.         AddTransparentSphere(atomStyle.color, atomStyle.name, site, atomStyle.radius, atomStyle.alpha);
  923.         // but can put labels on now
  924.         if (atomStyle.centerLabel.size() > 0)
  925.             DrawLabel(atomStyle.centerLabel, site,
  926.                 (atomStyle.isHighlighted ? GlobalColors()->Get(Colors::eHighlight) : Vector(1,1,1)));
  927.     }
  929.     displayListEmpty[currentDisplayList] = false;
  930. }
  932. /* add a thick splined curve from point 1 *halfway* to point 2 */
  933. static void DrawHalfWorm(const Vector *p0, const Vector& p1,
  934.     const Vector& p2, const Vector *p3,
  935.     double radius, bool cap1, bool cap2,
  936.     double tension)
  937. {
  938.     int i, j, k, m, offset;
  939.     Vector R1, R2, Qt, p, dQt, H, V;
  940.     double len, MG[4][3], T[4], t, prevlen=0.0, cosj, sinj;
  941.     GLdouble *Nx = NULL, *Ny, *Nz, *Cx, *Cy, *Cz,
  942.         *pNx, *pNy, *pNz, *pCx, *pCy, *pCz, *tmp;
  944.     if (!p0 || !p3) {
  945.         ERRORMSG("DrawHalfWorm: got NULL 0th and/or 3rd coords for worm");
  946.         return;
  947.     }
  949.     /*
  950.      * The Hermite matrix Mh.
  951.      */
  952.     static double Mh[4][4] = {
  953.         { 2, -2,  1,  1},
  954.         {-3,  3, -2, -1},
  955.         { 0,  0,  1,  0},
  956.         { 1,  0,  0,  0}
  957.     };
  959.     /*
  960.      * Variables that affect the curve shape
  961.      *   a=b=0 = Catmull-Rom
  962.      */
  963.     double a = tension,         /* tension    (adjustable)  */
  964.         c = 0,                  /* continuity (should be 0) */
  965.         b = 0;                  /* bias       (should be 0) */
  967.     if (wormSides % 2) {
  968.         WARNINGMSG("worm sides must be an even number");
  969.         ++wormSides;
  970.     }
  971.     GLdouble *fblock = NULL;
  973.     /* First, calculate the coordinate points of the center of the worm,
  974.      * using the Kochanek-Bartels variant of the Hermite curve.
  975.      */
  976.     R1 = 0.5 * (1 - a) * (1 + b) * (1 + c) * (p1 - *p0) + 0.5 * (1 - a) * (1 - b) * (1 - c) * ( p2 - p1);
  977.     R2 = 0.5 * (1 - a) * (1 + b) * (1 - c) * (p2 -  p1) + 0.5 * (1 - a) * (1 - b) * (1 + c) * (*p3 - p2);
  979.     /*
  980.      * Multiply MG=Mh.Gh, where Gh = [ P(1) P(2) R(1) R(2) ]. This
  981.      * 4x1 matrix of vectors is constant for each segment.
  982.      */
  983.     for (i = 0; i < 4; ++i) {   /* calculate Mh.Gh */
  984.         MG[i][0] = Mh[i][0] * p1.x + Mh[i][1] * p2.x + Mh[i][2] * R1.x + Mh[i][3] * R2.x;
  985.         MG[i][1] = Mh[i][0] * p1.y + Mh[i][1] * p2.y + Mh[i][2] * R1.y + Mh[i][3] * R2.y;
  986.         MG[i][2] = Mh[i][0] * p1.z + Mh[i][1] * p2.z + Mh[i][2] * R1.z + Mh[i][3] * R2.z;
  987.     }
  989.     for (i = 0; i <= wormSegments; ++i) {
  991.         /* t goes from [0,1] from P(1) to P(2) (and we want to go halfway only),
  992.            and the function Q(t) defines the curve of this segment. */
  993.         t = (0.5 / wormSegments) * i;
  994.         /*
  995.            * Q(t)=T.(Mh.Gh), where T = [ t^3 t^2 t 1 ]
  996.          */
  997.         T[0] = t * t * t;
  998.         T[1] = t * t;
  999.         T[2] = t;
  1000.         //T[3] = 1;
  1001.         Qt.x = T[0] * MG[0][0] + T[1] * MG[1][0] + T[2] * MG[2][0] + MG[3][0] /* *T[3] */ ;
  1002.         Qt.y = T[0] * MG[0][1] + T[1] * MG[1][1] + T[2] * MG[2][1] + MG[3][1] /* *T[3] */ ;
  1003.         Qt.z = T[0] * MG[0][2] + T[1] * MG[1][2] + T[2] * MG[2][2] + MG[3][2] /* *T[3] */ ;
  1005.         if (radius == 0.0) {
  1006.             if (i > 0) {
  1007.                 glBegin(GL_LINES);
  1008.                 glVertex3d(p.x, p.y, p.z);
  1009.                 glVertex3d(Qt.x, Qt.y, Qt.z);
  1010.                 glEnd();
  1011.             }
  1012.             /* save to use as previous point for connecting points together */
  1013.             p = Qt;
  1015.         } else {
  1016.             /* construct a circle of points centered at and
  1017.                in a plane normal to the curve at t - these points will
  1018.                be used to construct the "thick" worm */
  1020.             /* allocate single block of storage for two circles of points */
  1021.             if (!Nx) {
  1022.                 fblock = new GLdouble[12 * wormSides];
  1023.                 Nx = fblock;
  1024.                 Ny = &Nx[wormSides];
  1025.                 Nz = &Nx[wormSides * 2];
  1026.                 Cx = &Nx[wormSides * 3];
  1027.                 Cy = &Nx[wormSides * 4];
  1028.                 Cz = &Nx[wormSides * 5];
  1029.                 pNx = &Nx[wormSides * 6];
  1030.                 pNy = &Nx[wormSides * 7];
  1031.                 pNz = &Nx[wormSides * 8];
  1032.                 pCx = &Nx[wormSides * 9];
  1033.                 pCy = &Nx[wormSides * 10];
  1034.                 pCz = &Nx[wormSides * 11];
  1035.             }
  1037.             /*
  1038.              * The first derivative of Q(t), d(Q(t))/dt, is the slope
  1039.              * (tangent) at point Q(t); now T = [ 3t^2 2t 1 0 ]
  1040.              */
  1041.             T[0] = t * t * 3;
  1042.             T[1] = t * 2;
  1043.             //T[2] = 1;
  1044.             //T[3] = 0;
  1045.             dQt.x = T[0] * MG[0][0] + T[1] * MG[1][0] + MG[2][0] /* *T[2] + T[3]*MG[3][0] */ ;
  1046.             dQt.y = T[0] * MG[0][1] + T[1] * MG[1][1] + MG[2][1] /* *T[2] + T[3]*MG[3][1] */ ;
  1047.             dQt.z = T[0] * MG[0][2] + T[1] * MG[1][2] + MG[2][2] /* *T[2] + T[3]*MG[3][2] */ ;
  1049.             /* use cross prod't of [1,0,0] x normal as horizontal */
  1050.             H.Set(0.0, -dQt.z, dQt.y);
  1051.             if (H.length() < 0.000001) /* nearly colinear - use [1,0.1,0] instead */
  1052.                 H.Set(0.1 * dQt.z, -dQt.z, dQt.y - 0.1 * dQt.x);
  1053.             H.normalize();
  1055.             /* and a vertical vector = normal x H */
  1056.             V = vector_cross(dQt, H);
  1057.             V.normalize();
  1059.             /* finally, the worm circumference points (C) and normals (N) are
  1060.                simple trigonometric combinations of H and V */
  1061.             for (j = 0; j < wormSides; ++j) {
  1062.                 cosj = cos(2 * PI * j / wormSides);
  1063.                 sinj = sin(2 * PI * j / wormSides);
  1064.                 Nx[j] = H.x * cosj + V.x * sinj;
  1065.                 Ny[j] = H.y * cosj + V.y * sinj;
  1066.                 Nz[j] = H.z * cosj + V.z * sinj;
  1067.                 Cx[j] = Qt.x + Nx[j] * radius;
  1068.                 Cy[j] = Qt.y + Ny[j] * radius;
  1069.                 Cz[j] = Qt.z + Nz[j] * radius;
  1070.             }
  1072.             /* figure out which points on the previous circle "match" best
  1073.                with these, to minimize envelope twisting */
  1074.             if (i > 0) {
  1075.                 for (m = 0; m < wormSides; ++m) {
  1076.                     len = 0.0;
  1077.                     for (j = 0; j < wormSides; ++j) {
  1078.                         k = j + m;
  1079.                         if (k >= wormSides)
  1080.                             k -= wormSides;
  1081.                         len += (Cx[k] - pCx[j]) * (Cx[k] - pCx[j]) +
  1082.                                (Cy[k] - pCy[j]) * (Cy[k] - pCy[j]) +
  1083.                                (Cz[k] - pCz[j]) * (Cz[k] - pCz[j]);
  1084.                     }
  1085.                     if (m == 0 || len < prevlen) {
  1086.                         prevlen = len;
  1087.                         offset = m;
  1088.                     }
  1089.                 }
  1090.             }
  1092.             /* create triangles from points along this and previous circle */
  1093.             if (i > 0) {
  1094.                 glBegin(GL_TRIANGLE_STRIP);
  1095.                 for (j = 0; j < wormSides; ++j) {
  1096.                     k = j + offset;
  1097.                     if (k >= wormSides) k -= wormSides;
  1098.                     glNormal3d(Nx[k], Ny[k], Nz[k]);
  1099.                     glVertex3d(Cx[k], Cy[k], Cz[k]);
  1100.                     glNormal3d(pNx[j], pNy[j], pNz[j]);
  1101.                     glVertex3d(pCx[j], pCy[j], pCz[j]);
  1102.                 }
  1103.                 glNormal3d(Nx[offset], Ny[offset], Nz[offset]);
  1104.                 glVertex3d(Cx[offset], Cy[offset], Cz[offset]);
  1105.                 glNormal3d(pNx[0], pNy[0], pNz[0]);
  1106.                 glVertex3d(pCx[0], pCy[0], pCz[0]);
  1107.                 glEnd();
  1108.             }
  1110.             /* put caps on the end */
  1111.             if (cap1 && i == 0) {
  1112.                 glBegin(GL_POLYGON);
  1113.                 dQt.normalize();
  1114.                 glNormal3d(-dQt.x, -dQt.y, -dQt.z);
  1115.                 for (j = wormSides - 1; j >= 0; --j) {
  1116.                     glVertex3d(Cx[j], Cy[j], Cz[j]);
  1117.                 }
  1118.                 glEnd();
  1119.             }
  1120.             else if (cap2 && i == wormSegments) {
  1121.                 glBegin(GL_POLYGON);
  1122.                 dQt.normalize();
  1123.                 glNormal3d(dQt.x, dQt.y, dQt.z);
  1124.                 for (j = 0; j < wormSides; ++j) {
  1125.                     k = j + offset;
  1126.                     if (k >= wormSides) k -= wormSides;
  1127.                     glVertex3d(Cx[k], Cy[k], Cz[k]);
  1128.                 }
  1129.                 glEnd();
  1130.             }
  1132.             /* store this circle as previous for next round; instead of copying
  1133.                all values, just swap pointers */
  1134. #define SWAPPTR(p1,p2) tmp=(p1); (p1)=(p2); (p2)=tmp
  1135.             SWAPPTR(Nx, pNx);
  1136.             SWAPPTR(Ny, pNy);
  1137.             SWAPPTR(Nz, pNz);
  1138.             SWAPPTR(Cx, pCx);
  1139.             SWAPPTR(Cy, pCy);
  1140.             SWAPPTR(Cz, pCz);
  1141.         }
  1142.     }
  1144.     if (fblock) delete[] fblock;
  1145. }
  1147. static void DoCylinderPlacementTransform(const Vector& a, const Vector& b, double length)
  1148. {
  1149.     /* to translate into place */
  1150.     glTranslated(a.x, a.y, a.z);
  1152.     /* to rotate from initial position, so bond points right direction;
  1153.        handle special case where both ends share ~same x,y */
  1154.     if (fabs(a.y - b.y) < 0.000001 && fabs(a.x - b.x) < 0.000001) {
  1155.         if (b.z - a.z < 0.0) glRotated(180.0, 1.0, 0.0, 0.0);
  1156.     } else {
  1157.         glRotated(RadToDegrees(acos((b.z - a.z) / length)),
  1158.                   a.y - b.y, b.x - a.x, 0.0);
  1159.     }
  1160. }
  1162. static void DrawHalfBond(const Vector& site1, const Vector& midpoint,
  1163.     StyleManager::eDisplayStyle style, double radius,
  1164.     bool cap1, bool cap2)
  1165. {
  1166.     // straight line bond
  1167.     if (style == StyleManager::eLineBond || (style == StyleManager::eCylinderBond && radius <= 0.0)) {
  1168.         glBegin(GL_LINES);
  1169.         glVertex3d(site1.x, site1.y, site1.z);
  1170.         glVertex3d(midpoint.x, midpoint.y, midpoint.z);
  1171.         glEnd();
  1172.     }
  1174.     // cylinder bond
  1175.     else if (style == StyleManager::eCylinderBond) {
  1176.         double length = (site1 - midpoint).length();
  1177.         if (length <= 0.000001 || bondSides <= 1) return;
  1178.         glPushMatrix();
  1179.         DoCylinderPlacementTransform(site1, midpoint, length);
  1180.         gluCylinder(qobj, radius, radius, length, bondSides, 1);
  1181.         if (cap1) {
  1182.             glPushMatrix();
  1183.             glRotated(180.0, 0.0, 1.0, 0.0);
  1184.             gluDisk(qobj, 0.0, radius, bondSides, 1);
  1185.             glPopMatrix();
  1186.         }
  1187.         if (cap2) {
  1188.             glPushMatrix();
  1189.             glTranslated(0.0, 0.0, length);
  1190.             gluDisk(qobj, 0.0, radius, bondSides, 1);
  1191.             glPopMatrix();
  1192.         }
  1193.         glPopMatrix();
  1194.     }
  1195. }
  1197. void OpenGLRenderer::DrawBond(const Vector& site1, const Vector& site2,
  1198.     const BondStyle& style, const Vector *site0, const Vector* site3)
  1199. {
  1200.     GLenum colorType;
  1201.     Vector midpoint = (site1 + site2) / 2;
  1203.     if (style.end1.style != StyleManager::eNotDisplayed) {
  1204.         colorType =
  1205.             (style.end1.style == StyleManager::eLineBond ||
  1206.             style.end1.style == StyleManager::eLineWormBond ||
  1207.             style.end1.radius <= 0.0)
  1208.             ? GL_AMBIENT : GL_DIFFUSE;
  1209.         SetColor(colorType, style.end1.color[0], style.end1.color[1], style.end1.color[2]);
  1210.         glLoadName(static_cast<GLuint>(style.end1.name));
  1211.         if (style.end1.style == StyleManager::eLineWormBond ||
  1212.             style.end1.style == StyleManager::eThickWormBond)
  1213.             DrawHalfWorm(site0, site1, site2, site3,
  1214.                 (style.end1.style == StyleManager::eThickWormBond) ? style.end1.radius : 0.0,
  1215.                 style.end1.atomCap, style.midCap,
  1216.                 style.tension);
  1217.         else
  1218.             DrawHalfBond(site1, midpoint,
  1219.                 style.end1.style, style.end1.radius,
  1220.                 style.end1.atomCap, style.midCap);
  1221.         displayListEmpty[currentDisplayList] = false;
  1222.     }
  1224.     if (style.end2.style != StyleManager::eNotDisplayed) {
  1225.         colorType =
  1226.             (style.end2.style == StyleManager::eLineBond ||
  1227.             style.end2.style == StyleManager::eLineWormBond ||
  1228.             style.end2.radius <= 0.0)
  1229.             ? GL_AMBIENT : GL_DIFFUSE;
  1230.         SetColor(colorType, style.end2.color[0], style.end2.color[1], style.end2.color[2]);
  1231.         glLoadName(static_cast<GLuint>(style.end2.name));
  1232.         if (style.end2.style == StyleManager::eLineWormBond ||
  1233.             style.end2.style == StyleManager::eThickWormBond)
  1234.             DrawHalfWorm(site3, site2, site1, site0,
  1235.                 (style.end2.style == StyleManager::eThickWormBond) ? style.end2.radius : 0.0,
  1236.                 style.end2.atomCap, style.midCap,
  1237.                 style.tension);
  1238.         else
  1239.             DrawHalfBond(midpoint, site2,
  1240.                 style.end2.style, style.end2.radius,
  1241.                 style.midCap, style.end2.atomCap);
  1242.         displayListEmpty[currentDisplayList] = false;
  1243.     }
  1244. }
  1246. void OpenGLRenderer::DrawHelix(const Vector& Nterm, const Vector& Cterm, const HelixStyle& style)
  1247. {
  1248.     SetColor(GL_DIFFUSE, style.color[0], style.color[1], style.color[2]);
  1249.     glLoadName(static_cast<GLuint>(NO_NAME));
  1251.     double wholeLength = (Nterm - Cterm).length();
  1252.     if (wholeLength <= 0.000001) return;
  1254.     // transformation for whole helix
  1255.     glPushMatrix();
  1256.     DoCylinderPlacementTransform(Nterm, Cterm, wholeLength);
  1258.     // helix body
  1259.     double shaftLength =
  1260.         (style.style == StyleManager::eObjectWithArrow && style.arrowLength < wholeLength) ?
  1261.             wholeLength - style.arrowLength : wholeLength;
  1262.     gluCylinder(qobj, style.radius, style.radius, shaftLength, helixSides, 1);
  1264.     // Nterm cap
  1265.     glPushMatrix();
  1266.     glRotated(180.0, 0.0, 1.0, 0.0);
  1267.     gluDisk(qobj, 0.0, style.radius, helixSides, 1);
  1268.     glPopMatrix();
  1270.     // Cterm Arrow
  1271.     if (style.style == StyleManager::eObjectWithArrow && style.arrowLength < wholeLength) {
  1272.         // arrow base
  1273.         if (style.arrowBaseWidthProportion > 1.0) {
  1274.             glPushMatrix();
  1275.             glTranslated(0.0, 0.0, shaftLength);
  1276.             glRotated(180.0, 0.0, 1.0, 0.0);
  1277.             gluDisk(qobj, style.radius, style.radius * style.arrowBaseWidthProportion, helixSides, 1);
  1278.             glPopMatrix();
  1279.         }
  1280.         // arrow body
  1281.         glPushMatrix();
  1282.         glTranslated(0.0, 0.0, shaftLength);
  1283.         gluCylinder(qobj, style.radius * style.arrowBaseWidthProportion,
  1284.             style.radius * style.arrowTipWidthProportion, style.arrowLength, helixSides, 10);
  1285.         glPopMatrix();
  1286.         // arrow tip
  1287.         if (style.arrowTipWidthProportion > 0.0) {
  1288.             glPushMatrix();
  1289.             glTranslated(0.0, 0.0, wholeLength);
  1290.             gluDisk(qobj, 0.0, style.radius * style.arrowTipWidthProportion, helixSides, 1);
  1291.             glPopMatrix();
  1292.         }
  1293.     }
  1295.     // Cterm cap
  1296.     else {
  1297.         glPushMatrix();
  1298.         glTranslated(0.0, 0.0, wholeLength);
  1299.         gluDisk(qobj, 0.0, style.radius, helixSides, 1);
  1300.         glPopMatrix();
  1301.     }
  1303.     glPopMatrix();
  1304.     displayListEmpty[currentDisplayList] = false;
  1305. }
  1307. void OpenGLRenderer::DrawStrand(const Vector& Nterm, const Vector& Cterm,
  1308.     const Vector& unitNormal, const StrandStyle& style)
  1309. {
  1310.     GLdouble c000[3], c001[3], c010[3], c011[3],
  1311.              c100[3], c101[3], c110[3], c111[3], n[3];
  1312.     Vector a, h;
  1313.     int i;
  1315.     SetColor(GL_DIFFUSE, style.color[0], style.color[1], style.color[2]);
  1316.     glLoadName(static_cast<GLuint>(NO_NAME));
  1318.     /* in this brick's world coordinates, the long axis (N-C direction) is
  1319.        along +Z, with N terminus at Z=0; width is in the X direction, and
  1320.        thickness in Y. Arrowhead at C-terminus, of course. */
  1322.     a = Cterm - Nterm;
  1323.     a.normalize();
  1324.     h = vector_cross(unitNormal, a);
  1326.     Vector lCterm(Cterm);
  1327.     if (style.style == StyleManager::eObjectWithArrow)
  1328.         lCterm -= a * style.arrowLength;
  1330.     for (i=0; i<3; ++i) {
  1331.         c000[i] =  Nterm[i] - h[i]*style.width/2 - unitNormal[i]*style.thickness/2;
  1332.         c001[i] = lCterm[i] - h[i]*style.width/2 - unitNormal[i]*style.thickness/2;
  1333.         c010[i] =  Nterm[i] - h[i]*style.width/2 + unitNormal[i]*style.thickness/2;
  1334.         c011[i] = lCterm[i] - h[i]*style.width/2 + unitNormal[i]*style.thickness/2;
  1335.         c100[i] =  Nterm[i] + h[i]*style.width/2 - unitNormal[i]*style.thickness/2;
  1336.         c101[i] = lCterm[i] + h[i]*style.width/2 - unitNormal[i]*style.thickness/2;
  1337.         c110[i] =  Nterm[i] + h[i]*style.width/2 + unitNormal[i]*style.thickness/2;
  1338.         c111[i] = lCterm[i] + h[i]*style.width/2 + unitNormal[i]*style.thickness/2;
  1339.     }
  1341.     glBegin(GL_QUADS);
  1343.     for (i=0; i<3; ++i) n[i] = unitNormal[i];
  1344.     glNormal3dv(n);
  1345.     glVertex3dv(c010);
  1346.     glVertex3dv(c011);
  1347.     glVertex3dv(c111);
  1348.     glVertex3dv(c110);
  1350.     for (i=0; i<3; ++i) n[i] = -unitNormal[i];
  1351.     glNormal3dv(n);
  1352.     glVertex3dv(c000);
  1353.     glVertex3dv(c100);
  1354.     glVertex3dv(c101);
  1355.     glVertex3dv(c001);
  1357.     for (i=0; i<3; ++i) n[i] = h[i];
  1358.     glNormal3dv(n);
  1359.     glVertex3dv(c100);
  1360.     glVertex3dv(c110);
  1361.     glVertex3dv(c111);
  1362.     glVertex3dv(c101);
  1364.     for (i=0; i<3; ++i) n[i] = -h[i];
  1365.     glNormal3dv(n);
  1366.     glVertex3dv(c000);
  1367.     glVertex3dv(c001);
  1368.     glVertex3dv(c011);
  1369.     glVertex3dv(c010);
  1371.     for (i=0; i<3; ++i) n[i] = -a[i];
  1372.     glNormal3dv(n);
  1373.     glVertex3dv(c000);
  1374.     glVertex3dv(c010);
  1375.     glVertex3dv(c110);
  1376.     glVertex3dv(c100);
  1378.     if (style.style == StyleManager::eObjectWithoutArrow) {
  1379.         for (i=0; i<3; ++i) n[i] = a[i];
  1380.         glNormal3dv(n);
  1381.         glVertex3dv(c001);
  1382.         glVertex3dv(c101);
  1383.         glVertex3dv(c111);
  1384.         glVertex3dv(c011);
  1386.     } else {
  1387.         GLdouble FT[3], LT[3], RT[3], FB[3], LB[3], RB[3];
  1389.         for (i=0; i<3; ++i) {
  1390.             FT[i] = lCterm[i] + unitNormal[i]*style.thickness/2 +
  1391.                 a[i]*style.arrowLength;
  1392.             LT[i] = lCterm[i] + unitNormal[i]*style.thickness/2 +
  1393.                 h[i]*style.arrowBaseWidthProportion*style.width/2;
  1394.             RT[i] = lCterm[i] + unitNormal[i]*style.thickness/2 -
  1395.                 h[i]*style.arrowBaseWidthProportion*style.width/2;
  1396.             FB[i] = lCterm[i] - unitNormal[i]*style.thickness/2 +
  1397.                 a[i]*style.arrowLength;
  1398.             LB[i] = lCterm[i] - unitNormal[i]*style.thickness/2 +
  1399.                 h[i]*style.arrowBaseWidthProportion*style.width/2;
  1400.             RB[i] = lCterm[i] - unitNormal[i]*style.thickness/2 -
  1401.                 h[i]*style.arrowBaseWidthProportion*style.width/2;
  1402.         }
  1404.         // the back-facing rectangles on the base of the arrow
  1405.         for (i=0; i<3; ++i) n[i] = -a[i];
  1406.         glNormal3dv(n);
  1407.         glVertex3dv(c111);
  1408.         glVertex3dv(LT);
  1409.         glVertex3dv(LB);
  1410.         glVertex3dv(c101);
  1412.         glVertex3dv(c011);
  1413.         glVertex3dv(c001);
  1414.         glVertex3dv(RB);
  1415.         glVertex3dv(RT);
  1417.         // the left side of the arrow
  1418.         for (i=0; i<3; ++i) h[i] = FT[i] - LT[i];
  1419.         Vector nL = vector_cross(unitNormal, h);
  1420.         nL.normalize();
  1421.         for (i=0; i<3; ++i) n[i] = nL[i];
  1422.         glNormal3dv(n);
  1423.         glVertex3dv(FT);
  1424.         glVertex3dv(FB);
  1425.         glVertex3dv(LB);
  1426.         glVertex3dv(LT);
  1428.         // the right side of the arrow
  1429.         for (i=0; i<3; ++i) h[i] = FT[i] - RT[i];
  1430.         Vector nR = vector_cross(h, unitNormal);
  1431.         nR.normalize();
  1432.         for (i=0; i<3; ++i) n[i] = nR[i];
  1433.         glNormal3dv(n);
  1434.         glVertex3dv(FT);
  1435.         glVertex3dv(RT);
  1436.         glVertex3dv(RB);
  1437.         glVertex3dv(FB);
  1439.         glEnd();
  1440.         glBegin(GL_TRIANGLES);
  1442.         // the top and bottom arrow triangles
  1443.         for (i=0; i<3; ++i) n[i] = unitNormal[i];
  1444.         glNormal3dv(n);
  1445.         glVertex3dv(FT);
  1446.         glVertex3dv(LT);
  1447.         glVertex3dv(RT);
  1449.         for (i=0; i<3; ++i) n[i] = -unitNormal[i];
  1450.         glNormal3dv(n);
  1451.         glVertex3dv(FB);
  1452.         glVertex3dv(RB);
  1453.         glVertex3dv(LB);
  1454.     }
  1456.     glEnd();
  1457.     displayListEmpty[currentDisplayList] = false;
  1458. }
  1460. void OpenGLRenderer::DrawLabel(const string& text, const Vector& center, const Vector& color)
  1461. {
  1462.     int width, height, textCenterX = 0, textCenterY = 0;
  1464.     if (text.empty()) return;
  1465.     if (!glCanvas->MeasureText(text, &width, &height, &textCenterX, &textCenterY))
  1466.         WARNINGMSG("MeasureText() failed");
  1468.     SetColor(GL_AMBIENT, color[0], color[1], color[2]);
  1469.     glListBase(FONT_BASE);
  1470.     glRasterPos3d(center.x, center.y, center.z);
  1471.     glBitmap(0, 0, 0.0, 0.0, -textCenterX, -textCenterY, NULL);
  1472.     glCallLists(text.size(), GL_UNSIGNED_BYTE, text.data());
  1473.     glListBase(0);
  1474.     displayListEmpty[currentDisplayList] = false;
  1475. }
  1477. bool OpenGLRenderer::SaveToASNViewSettings(ncbi::objects::CCn3d_user_annotations *annotations)
  1478. {
  1479.     // save current camera settings
  1480.     initialViewFromASN.Reset(new CCn3d_view_settings());
  1481.     initialViewFromASN->SetCamera_distance(cameraDistance);
  1482.     initialViewFromASN->SetCamera_angle_rad(cameraAngleRad);
  1483.     initialViewFromASN->SetCamera_look_at_X(cameraLookAtX);
  1484.     initialViewFromASN->SetCamera_look_at_Y(cameraLookAtY);
  1485.     initialViewFromASN->SetCamera_clip_near(cameraClipNear);
  1486.     initialViewFromASN->SetCamera_clip_far(cameraClipFar);
  1487.     initialViewFromASN->SetMatrix().SetM0(viewMatrix[0]);
  1488.     initialViewFromASN->SetMatrix().SetM1(viewMatrix[1]);
  1489.     initialViewFromASN->SetMatrix().SetM2(viewMatrix[2]);
  1490.     initialViewFromASN->SetMatrix().SetM3(viewMatrix[3]);
  1491.     initialViewFromASN->SetMatrix().SetM4(viewMatrix[4]);
  1492.     initialViewFromASN->SetMatrix().SetM5(viewMatrix[5]);
  1493.     initialViewFromASN->SetMatrix().SetM6(viewMatrix[6]);
  1494.     initialViewFromASN->SetMatrix().SetM7(viewMatrix[7]);
  1495.     initialViewFromASN->SetMatrix().SetM8(viewMatrix[8]);
  1496.     initialViewFromASN->SetMatrix().SetM9(viewMatrix[9]);
  1497.     initialViewFromASN->SetMatrix().SetM10(viewMatrix[10]);
  1498.     initialViewFromASN->SetMatrix().SetM11(viewMatrix[11]);
  1499.     initialViewFromASN->SetMatrix().SetM12(viewMatrix[12]);
  1500.     initialViewFromASN->SetMatrix().SetM13(viewMatrix[13]);
  1501.     initialViewFromASN->SetMatrix().SetM14(viewMatrix[14]);
  1502.     initialViewFromASN->SetMatrix().SetM15(viewMatrix[15]);
  1503.     initialViewFromASN->SetRotation_center().SetX(structureSet->rotationCenter.x);
  1504.     initialViewFromASN->SetRotation_center().SetY(structureSet->rotationCenter.y);
  1505.     initialViewFromASN->SetRotation_center().SetZ(structureSet->rotationCenter.z);
  1507.     if (annotations) {
  1508.         // store copy in given annotations
  1509.         string err;
  1510.         CRef < CCn3d_view_settings > copy(CopyASNObject(*initialViewFromASN, &err));
  1511.         if (copy.Empty()) {
  1512.             ERRORMSG("OpenGLRenderer::SaveToASNViewSettings() - failed to copy settings:n" << err);
  1513.             return false;
  1514.         }
  1515.         annotations->SetView(*copy);
  1516.     }
  1518.     return true;
  1519. }
  1521. bool OpenGLRenderer::LoadFromASNViewSettings(const ncbi::objects::CCn3d_user_annotations& annotations)
  1522. {
  1523.     initialViewFromASN.Reset();
  1524.     if (!annotations.IsSetView()) return true;
  1526.     // save a copy of the view settings
  1527.     string err;
  1528.     initialViewFromASN.Reset(CopyASNObject(annotations.GetView(), &err));
  1529.     if (err.size() > 0 || initialViewFromASN.Empty()) {
  1530.         ERRORMSG("OpenGLRenderer::LoadFromASNViewSettings() - failed to copy settings:n" << err);
  1531.         return false;
  1532.     }
  1533.     return true;
  1534. }
  1536. void OpenGLRenderer::RestoreSavedView(void)
  1537. {
  1538.     if (initialViewFromASN.Empty() || !structureSet) {
  1539.         ResetCamera();
  1540.         return;
  1541.     }
  1543.     // restore current camera settings
  1544.     cameraDistance = initialViewFromASN->GetCamera_distance();
  1545.     cameraAngleRad = initialViewFromASN->GetCamera_angle_rad();
  1546.     cameraLookAtX = initialViewFromASN->GetCamera_look_at_X();
  1547.     cameraLookAtY = initialViewFromASN->GetCamera_look_at_Y();
  1548.     cameraClipNear = initialViewFromASN->GetCamera_clip_near();
  1549.     cameraClipFar = initialViewFromASN->GetCamera_clip_far();
  1550.     viewMatrix[0] = initialViewFromASN->GetMatrix().GetM0();
  1551.     viewMatrix[1] = initialViewFromASN->GetMatrix().GetM1();
  1552.     viewMatrix[2] = initialViewFromASN->GetMatrix().GetM2();
  1553.     viewMatrix[3] = initialViewFromASN->GetMatrix().GetM3();
  1554.     viewMatrix[4] = initialViewFromASN->GetMatrix().GetM4();
  1555.     viewMatrix[5] = initialViewFromASN->GetMatrix().GetM5();
  1556.     viewMatrix[6] = initialViewFromASN->GetMatrix().GetM6();
  1557.     viewMatrix[7] = initialViewFromASN->GetMatrix().GetM7();
  1558.     viewMatrix[8] = initialViewFromASN->GetMatrix().GetM8();
  1559.     viewMatrix[9] = initialViewFromASN->GetMatrix().GetM9();
  1560.     viewMatrix[10] = initialViewFromASN->GetMatrix().GetM10();
  1561.     viewMatrix[11] = initialViewFromASN->GetMatrix().GetM11();
  1562.     viewMatrix[12] = initialViewFromASN->GetMatrix().GetM12();
  1563.     viewMatrix[13] = initialViewFromASN->GetMatrix().GetM13();
  1564.     viewMatrix[14] = initialViewFromASN->GetMatrix().GetM14();
  1565.     viewMatrix[15] = initialViewFromASN->GetMatrix().GetM15();
  1566.     structureSet->rotationCenter.Set(
  1567.         initialViewFromASN->GetRotation_center().GetX(),
  1568.         initialViewFromASN->GetRotation_center().GetY(),
  1569.         initialViewFromASN->GetRotation_center().GetZ());
  1571.     NewView();
  1572. }
  1574. void OpenGLRenderer::GetViewport(int *viewport)
  1575. {
  1576.     glCanvas->SetCurrent();
  1577.     GLint viewportGL[4];    // just in case GLint != int
  1578.     glGetIntegerv(GL_VIEWPORT, viewportGL);
  1579.     for (int i=0; i<4; ++i) viewport[i] = (int) viewportGL[i];
  1580. }
  1582. const wxFont& OpenGLRenderer::GetGLFont(void) const
  1583. {
  1584.     return glCanvas->GetGLFont();
  1585. }
  1587. bool OpenGLRenderer::SetGLFont(int firstChar, int nChars, int fontBase)
  1588. {
  1589.     bool okay = true;
  1591. #if defined(__WXMSW__)
  1592.     HDC hdc = wglGetCurrentDC();
  1593.     HGDIOBJ currentFont = SelectObject(hdc, reinterpret_cast<HGDIOBJ>(GetGLFont().GetHFONT()));
  1594.     if (!wglUseFontBitmaps(hdc, firstChar, nChars, fontBase)) {
  1595.         ERRORMSG("OpenGLRenderer::SetGLFont() - wglUseFontBitmaps() failed");
  1596.         okay = false;
  1597.     }
  1598.     SelectObject(hdc, currentFont);
  1600. #elif defined(__WXGTK__)
  1601.     glXUseXFont(gdk_font_id(GetGLFont().GetInternalFont()), firstChar, nChars, fontBase);
  1603. #elif defined(__WXMAC__)
  1604.     wxFontRefData *fontRefData = (wxFontRefData *) GetGLFont().GetRefData();
  1605.     if (RealFont(fontRefData->m_macFontNum, fontRefData->m_macFontSize)) {
  1606.         if (aglUseFont(aglGetCurrentContext(),
  1607.                 (GLint) fontRefData->m_macFontNum,
  1608.                 fontRefData->m_macFontStyle, fontRefData->m_macFontSize,
  1609.                 firstChar, nChars, fontBase) != GL_TRUE) {
  1610.             ERRORMSG("OpenGLRenderer::SetGLFont() - aglUseFont() failed");
  1611.             okay = false;
  1612.         }
  1613.     } else {
  1614.         ERRORMSG("OpenGLRenderer::SetGLFont() - RealFont() returned false");
  1615.         okay = false;
  1616.     }
  1617. #endif
  1619.     return okay;
  1620. }
  1622. END_SCOPE(Cn3D)
  1624. /*
  1625. * ---------------------------------------------------------------------------
  1626. * $Log: opengl_renderer.cpp,v $
  1627. * Revision 1000.3  2004/06/01 18:28:52  gouriano
  1628. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.79
  1629. *
  1630. * Revision 1.79  2004/05/21 21:41:39  gorelenk
  1631. * Added PCH ncbi_pch.hpp
  1632. *
  1633. * Revision 1.78  2004/04/19 19:36:07  thiessen
  1634. * fix frame switch bug when no structures present
  1635. *
  1636. * Revision 1.77  2004/03/15 17:59:20  thiessen
  1637. * prefer prefix vs. postfix ++/-- operators
  1638. *
  1639. * Revision 1.76  2004/03/15 17:51:29  thiessen
  1640. * prefer prefix vs. postfix ++/-- operators
  1641. *
  1642. * Revision 1.75  2004/02/19 17:05:00  thiessen
  1643. * remove cn3d/ from include paths; add pragma to disable annoying msvc warning
  1644. *
  1645. * Revision 1.74  2003/12/04 15:58:36  thiessen
  1646. * fix const problem
  1647. *
  1648. * Revision 1.73  2003/12/04 15:49:40  thiessen
  1649. * fix stereo and PNG export problems on Mac
  1650. *
  1651. * Revision 1.72  2003/11/15 16:08:36  thiessen
  1652. * add stereo
  1653. *
  1654. * Revision 1.71  2003/10/06 22:05:52  thiessen
  1655. * fix max camera angle to < PI
  1656. *
  1657. * Revision 1.70  2003/05/22 19:08:17  thiessen
  1658. * add limits to camera angle
  1659. *
  1660. * Revision 1.69  2003/03/13 14:26:18  thiessen
  1661. * add file_messaging module; split cn3d_main_wxwin into cn3d_app, cn3d_glcanvas, structure_window, cn3d_tools
  1662. *
  1663. * Revision 1.68  2003/02/03 19:20:04  thiessen
  1664. * format changes: move CVS Log to bottom of file, remove std:: from .cpp files, and use new diagnostic macros
  1665. *
  1666. * Revision 1.67  2003/01/09 13:46:54  thiessen
  1667. * highlight atom labels
  1668. *
  1669. * Revision 1.66  2002/12/19 15:58:26  thiessen
  1670. * fix quadric problem on Mac
  1671. *
  1672. * Revision 1.65  2002/10/11 17:21:39  thiessen
  1673. * initial Mac OSX build
  1674. *
  1675. * Revision 1.64  2002/10/08 12:35:42  thiessen
  1676. * use delete[] for arrays
  1677. *
  1678. * Revision 1.63  2002/09/14 18:14:31  thiessen
  1679. * fix trigonometry error
  1680. *
  1681. * Revision 1.62  2002/09/14 17:03:07  thiessen
  1682. * center initial view on aligned residues
  1683. *
  1684. * Revision 1.61  2002/08/15 22:13:15  thiessen
  1685. * update for wx2.3.2+ only; add structure pick dialog; fix MultitextDialog bug
  1686. *
  1687. * Revision 1.60  2002/03/04 15:52:14  thiessen
  1688. * hide sequence windows instead of destroying ; add perspective/orthographic projection choice
  1689. *
  1690. * Revision 1.59  2002/02/01 13:55:54  thiessen
  1691. * fix view restore bug when new file loaded
  1692. *
  1693. * Revision 1.58  2002/01/11 15:48:58  thiessen
  1694. * update for Mac CW7
  1695. *
  1696. * Revision 1.57  2001/12/15 03:15:59  thiessen
  1697. * adjustments for slightly changed object loader Set...() API
  1698. *
  1699. * Revision 1.56  2001/12/12 14:04:14  thiessen
  1700. * add missing object headers after object loader change
  1701. *
  1702. * Revision 1.55  2001/11/30 14:02:05  thiessen
  1703. * progress on sequence imports to single structures
  1704. *
  1705. * Revision 1.54  2001/10/23 20:10:23  thiessen
  1706. * fix scaling of fonts in high-res PNG output
  1707. *
  1708. * Revision 1.53  2001/10/23 13:53:38  thiessen
  1709. * add PNG export
  1710. *
  1711. * Revision 1.52  2001/10/17 17:46:22  thiessen
  1712. * save camera setup and rotation center in files
  1713. *
  1714. * Revision 1.51  2001/09/06 18:15:44  thiessen
  1715. * fix OpenGL window initialization/OnSize to work on Mac
  1716. *
  1717. * Revision 1.50  2001/08/24 18:53:42  thiessen
  1718. * add filename to sequence viewer window titles
  1719. *
  1720. * Revision 1.49  2001/08/24 13:29:28  thiessen
  1721. * header and GTK font tweaks
  1722. *
  1723. * Revision 1.48  2001/08/24 00:41:35  thiessen
  1724. * tweak conservation colors and opengl font handling
  1725. *
  1726. * Revision 1.47  2001/08/21 01:10:45  thiessen
  1727. * add labeling
  1728. *
  1729. * Revision 1.46  2001/08/15 20:52:15  juran
  1730. * On the Mac, include OpenGL headers that can actually be located.
  1731. *
  1732. * Revision 1.45  2001/08/13 22:30:59  thiessen
  1733. * add structure window mouse drag/zoom; add highlight option to render settings
  1734. *
  1735. * Revision 1.44  2001/08/09 19:07:13  thiessen
  1736. * add temperature and hydrophobicity coloring
  1737. *
  1738. * Revision 1.43  2001/08/08 02:26:18  thiessen
  1739. * fixes for gnu ; make DrawHelix more logical
  1740. *
  1741. * Revision 1.42  2001/08/06 20:22:00  thiessen
  1742. * add preferences dialog ; make sure OnCloseWindow get wxCloseEvent
  1743. *
  1744. * Revision 1.41  2001/07/10 21:50:45  thiessen
  1745. * fix ambient/specular coloring
  1746. *
  1747. * Revision 1.40  2001/07/10 21:27:52  thiessen
  1748. * add some specular reflection
  1749. *
  1750. * Revision 1.39  2001/06/29 18:13:57  thiessen
  1751. * initial (incomplete) user annotation system
  1752. *
  1753. * Revision 1.38  2001/05/31 18:47:08  thiessen
  1754. * add preliminary style dialog; remove LIST_TYPE; add thread single and delete all; misc tweaks
  1755. *
  1756. * Revision 1.37  2001/05/25 15:18:24  thiessen
  1757. * fixes for visual id settings in wxGTK
  1758. *
  1759. * Revision 1.36  2001/05/25 01:38:16  thiessen
  1760. * minor fixes for compiling on SGI
  1761. *
  1762. * Revision 1.35  2001/05/22 19:09:31  thiessen
  1763. * many minor fixes to compile/run on Solaris/GTK
  1764. *
  1765. * Revision 1.34  2001/05/17 18:34:25  thiessen
  1766. * spelling fixes; change dialogs to inherit from wxDialog
  1767. *
  1768. * Revision 1.33  2001/05/15 23:48:37  thiessen
  1769. * minor adjustments to compile under Solaris/wxGTK
  1770. *
  1771. * Revision 1.32  2001/01/30 20:51:19  thiessen
  1772. * minor fixes
  1773. *
  1774. * Revision 1.31  2000/12/19 16:39:09  thiessen
  1775. * tweaks to show/hide
  1776. *
  1777. * Revision 1.30  2000/12/15 15:51:47  thiessen
  1778. * show/hide system installed
  1779. *
  1780. * Revision 1.29  2000/11/30 15:49:39  thiessen
  1781. * add show/hide rows; unpack sec. struc. and domain features
  1782. *
  1783. * Revision 1.28  2000/11/02 16:56:02  thiessen
  1784. * working editor undo; dynamic slave transforms
  1785. *
  1786. * Revision 1.27  2000/09/11 01:46:15  thiessen
  1787. * working messenger for sequence<->structure window communication
  1788. *
  1789. * Revision 1.26  2000/09/08 20:16:55  thiessen
  1790. * working dynamic alignment views
  1791. *
  1792. * Revision 1.25  2000/08/27 18:52:21  thiessen
  1793. * extract sequence information
  1794. *
  1795. * Revision 1.24  2000/08/25 14:22:00  thiessen
  1796. * minor tweaks
  1797. *
  1798. * Revision 1.23  2000/08/24 23:40:19  thiessen
  1799. * add 'atomic ion' labels
  1800. *
  1801. * Revision 1.22  2000/08/24 18:43:52  thiessen
  1802. * tweaks for transparent sphere display
  1803. *
  1804. * Revision 1.21  2000/08/21 17:22:38  thiessen
  1805. * add primitive highlighting for testing
  1806. *
  1807. * Revision 1.20  2000/08/19 02:59:04  thiessen
  1808. * fix transparent sphere bug
  1809. *
  1810. * Revision 1.19  2000/08/18 23:07:08  thiessen
  1811. * minor efficiency tweaks
  1812. *
  1813. * Revision 1.18  2000/08/18 18:57:39  thiessen
  1814. * added transparent spheres
  1815. *
  1816. * Revision 1.17  2000/08/17 14:24:06  thiessen
  1817. * added working StyleManager
  1818. *
  1819. * Revision 1.16  2000/08/16 14:18:46  thiessen
  1820. * map 3-d objects to molecules
  1821. *
  1822. * Revision 1.15  2000/08/13 02:43:01  thiessen
  1823. * added helix and strand objects
  1824. *
  1825. * Revision 1.14  2000/08/11 12:58:31  thiessen
  1826. * added worm; get 3d-object coords from asn1
  1827. *
  1828. * Revision 1.13  2000/08/07 14:13:15  thiessen
  1829. * added animation frames
  1830. *
  1831. * Revision 1.12  2000/08/07 00:21:17  thiessen
  1832. * add display list mechanism
  1833. *
  1834. * Revision 1.11  2000/08/04 22:49:03  thiessen
  1835. * add backbone atom classification and selection feedback mechanism
  1836. *
  1837. * Revision 1.10  2000/08/03 15:12:23  thiessen
  1838. * add skeleton of style and show/hide managers
  1839. *
  1840. * Revision 1.9  2000/07/27 13:30:51  thiessen
  1841. * remove 'using namespace ...' from all headers
  1842. *
  1843. * Revision 1.8  2000/07/18 16:50:11  thiessen
  1844. * more friendly rotation center setting
  1845. *
  1846. * Revision 1.7  2000/07/18 02:41:33  thiessen
  1847. * fix bug in virtual bonds and altConfs
  1848. *
  1849. * Revision 1.6  2000/07/18 00:06:00  thiessen
  1850. * allow arbitrary rotation center
  1851. *
  1852. * Revision 1.5  2000/07/17 22:37:18  thiessen
  1853. * fix vector_math typo; correctly set initial view
  1854. *
  1855. * Revision 1.4  2000/07/17 04:20:49  thiessen
  1856. * now does correct structure alignment transformation
  1857. *
  1858. * Revision 1.3  2000/07/16 23:19:11  thiessen
  1859. * redo of drawing system
  1860. *
  1861. * Revision 1.2  2000/07/12 23:27:49  thiessen
  1862. * now draws basic CPK model
  1863. *
  1864. * Revision 1.1  2000/07/12 14:11:30  thiessen
  1865. * added initial OpenGL rendering engine
  1866. *
  1867. */