Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLStoredViewer.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenGL/src/G4OpenGLStoredViewer.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLStoredViewer.cc (Version 9.4.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4OpenGLStoredViewer.cc,v 1.29 2010-10-06 10:05:52 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-04-patch-01 $
 27 //                                                 29 //
 28 //                                             <<  30 // 
 29 // Andrew Walkden  7th February 1997               31 // Andrew Walkden  7th February 1997
 30 // Class G4OpenGLStoredViewer : Encapsulates t     32 // Class G4OpenGLStoredViewer : Encapsulates the `storedness' of
 31 //                            an OpenGL view,      33 //                            an OpenGL view, for inheritance by
 32 //                            derived (X, Xm..     34 //                            derived (X, Xm...) classes.
 33                                                    35 
                                                   >>  36 #ifdef G4VIS_BUILD_OPENGL_DRIVER
                                                   >>  37 
 34 #include "G4OpenGLStoredViewer.hh"                 38 #include "G4OpenGLStoredViewer.hh"
 35                                                    39 
 36 #include "G4PhysicalConstants.hh"              << 
 37 #include "G4OpenGLStoredSceneHandler.hh"           40 #include "G4OpenGLStoredSceneHandler.hh"
 38 #include "G4Text.hh"                               41 #include "G4Text.hh"
 39 #include "G4Circle.hh"                             42 #include "G4Circle.hh"
 40 #include "G4UnitsTable.hh"                         43 #include "G4UnitsTable.hh"
 41 #include "G4Scene.hh"                              44 #include "G4Scene.hh"
 42 #include "G4OpenGLTransform3D.hh"              << 
 43                                                    45 
 44 G4OpenGLStoredViewer::G4OpenGLStoredViewer         46 G4OpenGLStoredViewer::G4OpenGLStoredViewer
 45 (G4OpenGLStoredSceneHandler& sceneHandler):        47 (G4OpenGLStoredSceneHandler& sceneHandler):
 46 G4VViewer (sceneHandler, -1),                  <<  48 G4VViewer (sceneHandler, -1),  
 47 G4OpenGLViewer (sceneHandler),                 <<  49 G4OpenGLViewer (sceneHandler), 
 48 fG4OpenGLStoredSceneHandler (sceneHandler),    <<  50 fG4OpenGLStoredSceneHandler (sceneHandler)
 49 fDepthTestEnable(true)                         << 
 50 {                                                  51 {
 51   fLastVP = fDefaultVP;  // Update in sub-clas <<  52   fLastVP = fDefaultVP; // Not sure if this gets executed before or
                                                   >>  53   // after G4VViewer::G4VViewer!!  Doesn't matter much.
 52 }                                                  54 }
 53                                                    55 
 54 G4OpenGLStoredViewer::~G4OpenGLStoredViewer ()     56 G4OpenGLStoredViewer::~G4OpenGLStoredViewer () {}
 55                                                    57 
 56 void G4OpenGLStoredViewer::KernelVisitDecision     58 void G4OpenGLStoredViewer::KernelVisitDecision () {
 57                                                    59   
 58   // If there's a significant difference with      60   // If there's a significant difference with the last view parameters
 59   // of either the scene handler or this viewe     61   // of either the scene handler or this viewer, trigger a rebuild.
 60                                                <<  62 
 61   if (!fG4OpenGLStoredSceneHandler.fTopPODL ||     63   if (!fG4OpenGLStoredSceneHandler.fTopPODL ||
 62       CompareForKernelVisit(fLastVP)) {            64       CompareForKernelVisit(fLastVP)) {
 63     NeedKernelVisit ();                            65     NeedKernelVisit ();
 64   }                                            <<  66   }      
                                                   >>  67   fLastVP = fVP;
 65 }                                                  68 }
 66                                                    69 
 67 G4bool G4OpenGLStoredViewer::CompareForKernelV     70 G4bool G4OpenGLStoredViewer::CompareForKernelVisit(G4ViewParameters& lastVP) {
 68                                                <<  71 
 69   if (                                             72   if (
 70       (lastVP.GetDrawingStyle ()    != fVP.Get     73       (lastVP.GetDrawingStyle ()    != fVP.GetDrawingStyle ())    ||
 71       (lastVP.GetNumberOfCloudPoints()  != fVP << 
 72       (lastVP.IsAuxEdgeVisible ()   != fVP.IsA     74       (lastVP.IsAuxEdgeVisible ()   != fVP.IsAuxEdgeVisible ())   ||
                                                   >>  75       (lastVP.GetRepStyle ()        != fVP.GetRepStyle ())        ||
 73       (lastVP.IsCulling ()          != fVP.IsC     76       (lastVP.IsCulling ()          != fVP.IsCulling ())          ||
 74       (lastVP.IsCullingInvisible () != fVP.IsC     77       (lastVP.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
 75       (lastVP.IsDensityCulling ()   != fVP.IsD     78       (lastVP.IsDensityCulling ()   != fVP.IsDensityCulling ())   ||
 76       (lastVP.IsCullingCovered ()   != fVP.IsC     79       (lastVP.IsCullingCovered ()   != fVP.IsCullingCovered ())   ||
 77       (lastVP.GetCBDAlgorithmNumber() !=       << 
 78        fVP.GetCBDAlgorithmNumber())            << 
 79       // Note: Section and Cutaway can reveal  << 
 80       // backface culling is implemented, the  << 
 81       // the back-facing faces are not there.  << 
 82       // (commented out) backface culling (it  << 
 83       // in fact, performance seems to improve << 
 84       (lastVP.IsSection ()          != fVP.IsS     80       (lastVP.IsSection ()          != fVP.IsSection ())          ||
 85       // Section (DCUT) is NOT implemented loc <<  81       // Section (DCUT) implemented locally.  But still need to visit
 86       // (lastVP.IsCutaway ()          != fVP. <<  82       // kernel if status changes so that back plane culling can be
 87       // Cutaways are implemented locally so w <<  83       // switched.
                                                   >>  84       (lastVP.IsCutaway ()          != fVP.IsCutaway ())          ||
                                                   >>  85       // Cutaways implemented locally.  But still need to visit kernel
                                                   >>  86       // if status changes so that back plane culling can be switched.
 88       (lastVP.IsExplode ()          != fVP.IsE     87       (lastVP.IsExplode ()          != fVP.IsExplode ())          ||
 89       (lastVP.GetNoOfSides ()       != fVP.Get     88       (lastVP.GetNoOfSides ()       != fVP.GetNoOfSides ())       ||
 90       (lastVP.GetGlobalMarkerScale()    != fVP << 
 91       (lastVP.GetGlobalLineWidthScale() != fVP << 
 92       (lastVP.IsMarkerNotHidden ()  != fVP.IsM     89       (lastVP.IsMarkerNotHidden ()  != fVP.IsMarkerNotHidden ())  ||
 93       (lastVP.GetDefaultVisAttributes()->GetCo     90       (lastVP.GetDefaultVisAttributes()->GetColour() !=
 94        fVP.GetDefaultVisAttributes()->GetColou     91        fVP.GetDefaultVisAttributes()->GetColour())                ||
 95       (lastVP.GetDefaultTextVisAttributes()->G     92       (lastVP.GetDefaultTextVisAttributes()->GetColour() !=
 96        fVP.GetDefaultTextVisAttributes()->GetC     93        fVP.GetDefaultTextVisAttributes()->GetColour())            ||
 97       (lastVP.GetBackgroundColour ()!= fVP.Get     94       (lastVP.GetBackgroundColour ()!= fVP.GetBackgroundColour ())||
 98       (lastVP.IsPicking ()          != fVP.IsP <<  95       (lastVP.IsPicking ()          != fVP.IsPicking ())
 99       (lastVP.GetVisAttributesModifiers() !=   << 
100        fVP.GetVisAttributesModifiers())        << 
101       (lastVP.IsSpecialMeshRendering() !=      << 
102        fVP.IsSpecialMeshRendering())           << 
103       (lastVP.GetSpecialMeshRenderingOption()  << 
104        fVP.GetSpecialMeshRenderingOption())    << 
105       )                                            96       )
106   return true;                                 <<  97     return true;
107                                                    98   
108   if (lastVP.IsDensityCulling () &&                99   if (lastVP.IsDensityCulling () &&
109       (lastVP.GetVisibleDensity () != fVP.GetV    100       (lastVP.GetVisibleDensity () != fVP.GetVisibleDensity ()))
110   return true;                                 << 101     return true;
111                                                << 102 
112 //  /***************************************** << 103   /**************************************************************
113 //   If section (DCUT) is implemented locally, << 104   Section (DCUT) implemented locally.  No need to visit kernel if
                                                   >> 105   section plane itself changes.
114   if (lastVP.IsSection () &&                      106   if (lastVP.IsSection () &&
115       (lastVP.GetSectionPlane () != fVP.GetSec    107       (lastVP.GetSectionPlane () != fVP.GetSectionPlane ()))
116     return true;                                  108     return true;
117 //   ***************************************** << 109   ***************************************************************/
118                                                << 110 
119   /*******************************************    111   /**************************************************************
120    If cutaways are implemented locally, commen << 112   Cutaways implemented locally.  No need to visit kernel if cutaway
121    if (lastVP.IsCutaway ()) {                  << 113   planes themselves change.
122    if (vp.GetCutawayMode() != fVP.GetCutawayMo << 114   if (lastVP.IsCutaway ()) {
123    if (lastVP.GetCutawayPlanes ().size () !=   << 115     if (lastVP.GetCutawayPlanes ().size () !=
124    fVP.GetCutawayPlanes ().size ()) return tru << 116   fVP.GetCutawayPlanes ().size ()) return true;
125    for (size_t i = 0; i < lastVP.GetCutawayPla << 117     for (size_t i = 0; i < lastVP.GetCutawayPlanes().size(); ++i)
126    if (lastVP.GetCutawayPlanes()[i] != fVP.Get << 118       if (lastVP.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i])
127    return true;                                << 119   return true;
128    }                                           << 
129    ******************************************* << 
130                                                << 
131   if (lastVP.GetCBDAlgorithmNumber() > 0) {    << 
132     if (lastVP.GetCBDParameters().size() != fV << 
133     else if (lastVP.GetCBDParameters() != fVP. << 
134   }                                               120   }
                                                   >> 121   ***************************************************************/
135                                                   122 
136   if (lastVP.IsExplode () &&                      123   if (lastVP.IsExplode () &&
137       (lastVP.GetExplodeFactor () != fVP.GetEx    124       (lastVP.GetExplodeFactor () != fVP.GetExplodeFactor ()))
138     return true;                                  125     return true;
139                                                   126 
140   if (lastVP.IsSpecialMeshRendering() &&       << 
141       (lastVP.GetSpecialMeshVolumes() != fVP.G << 
142     return true;                               << 
143                                                << 
144   // Time window parameters operate on the exi << 
145   // to rebuild even if they change.           << 
146                                                << 
147   return false;                                   127   return false;
148 }                                                 128 }
149                                                   129 
150 void G4OpenGLStoredViewer::DrawDisplayLists ()    130 void G4OpenGLStoredViewer::DrawDisplayLists () {
151                                                << 131 #ifdef G4DEBUG_VIS_OGL
152   // We moved these from G4OpenGLViewer to G4V << 132       printf("G4OpenGLStoredViewer::DrawDisplayLists \n");
153   // editing many lines below we introduce the << 133 #endif
154 #define CONVENIENT_DOUBLE_ALIAS(q) const G4dou << 
155 #define CONVENIENT_BOOL_ALIAS(q) const G4bool& << 
156   CONVENIENT_DOUBLE_ALIAS(StartTime)           << 
157   CONVENIENT_DOUBLE_ALIAS(EndTime)             << 
158   CONVENIENT_DOUBLE_ALIAS(FadeFactor)          << 
159   CONVENIENT_BOOL_ALIAS(DisplayHeadTime)       << 
160   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeX)    << 
161   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeY)    << 
162   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeSize) << 
163   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeRed)  << 
164   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeGreen << 
165   CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeBlue) << 
166   CONVENIENT_BOOL_ALIAS(DisplayLightFront)     << 
167   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontX)  << 
168   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontY)  << 
169   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontZ)  << 
170   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontT)  << 
171   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontRed << 
172   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontGre << 
173   CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontBlu << 
174                                                   134 
175   const G4Planes& cutaways = fVP.GetCutawayPla    135   const G4Planes& cutaways = fVP.GetCutawayPlanes();
176   G4bool cutawayUnion = fVP.IsCutaway() &&        136   G4bool cutawayUnion = fVP.IsCutaway() &&
177   fVP.GetCutawayMode() == G4ViewParameters::cu << 137     fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion;
178   const size_t nCutaways = cutawayUnion? cutaw << 138   size_t nPasses = cutawayUnion? cutaways.size(): 1;
179   G4int iPass = 1;                             << 139 #ifdef G4DEBUG_VIS_OGL
180   G4bool secondPassForTransparencyRequested =  << 140   printf("G4OpenGLStoredViewer::DrawDisplayLists");
181   G4bool thirdPassForNonHiddenMarkersRequested << 141 #endif
182   fDepthTestEnable = true;                     << 142   for (size_t i = 0; i < nPasses; ++i) {
183   glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LE << 143 #ifdef G4DEBUG_VIS_OGL
184   do {                                         << 144     printf("+");
185     for (size_t iCutaway = 0; iCutaway < nCuta << 145 #endif
186                                                << 146 
187       if (cutawayUnion) {                      << 147     if (cutawayUnion) {
188         double a[4];                           << 148       double a[4];
189         a[0] = cutaways[iCutaway].a();         << 149       a[0] = cutaways[i].a();
190         a[1] = cutaways[iCutaway].b();         << 150       a[1] = cutaways[i].b();
191         a[2] = cutaways[iCutaway].c();         << 151       a[2] = cutaways[i].c();
192         a[3] = cutaways[iCutaway].d();         << 152       a[3] = cutaways[i].d();
193         glClipPlane (GL_CLIP_PLANE2, a);       << 153       glClipPlane (GL_CLIP_PLANE2, a);
194         glEnable (GL_CLIP_PLANE2);             << 154       glEnable (GL_CLIP_PLANE2);
195       }                                        << 155     }
196                                                << 156 
197       G4bool isPicking = fVP.IsPicking();      << 157     if (fG4OpenGLStoredSceneHandler.fTopPODL) 
198                                                << 158       glCallList (fG4OpenGLStoredSceneHandler.fTopPODL);
199       for (size_t iPO = 0;                     << 159 
200            iPO < fG4OpenGLStoredSceneHandler.f << 160     for (size_t i = 0; i < fG4OpenGLStoredSceneHandler.fTOList.size(); ++i) {
201         if (POSelected(iPO)) {                 << 161 #ifdef G4DEBUG_VIS_OGL
202           G4OpenGLStoredSceneHandler::PO& po = << 162       //      printf("-");
203           fG4OpenGLStoredSceneHandler.fPOList[ << 163 #endif
204           G4Colour c = po.fColour;             << 164       G4OpenGLStoredSceneHandler::TO& to =
205           DisplayTimePOColourModification(c,iP << 165   fG4OpenGLStoredSceneHandler.fTOList[i];
206           const G4bool isTransparent = c.GetAl << 166       if (to.fEndTime >= fStartTime && to.fStartTime <= fEndTime) {
207           if ( iPass == 1) {                   << 167   glPushMatrix();
208             if (isTransparent && transparency_ << 168   G4OpenGLTransform3D oglt (to.fTransform);
209               secondPassForTransparencyRequest << 169   glMultMatrixd (oglt.GetGLMatrix ());
210               continue;                        << 170   if (fVP.IsPicking()) glLoadName(to.fPickName);
211             }                                  << 171   const G4Colour& c = to.fColour;
212             if (po.fMarkerOrPolyline && fVP.Is << 172   const G4Colour& bg = fVP.GetBackgroundColour();
213               thirdPassForNonHiddenMarkersRequ << 173   G4double bsf = 1.;  // Brightness scaling factor.
214               continue;                        << 174   if (fFadeFactor > 0. && to.fEndTime < fEndTime)
215             }                                  << 175     bsf = 1. - fFadeFactor *
216           } else if (iPass == 2) {  // Second  << 176       ((fEndTime - to.fEndTime) / (fEndTime - fStartTime));
217             if (!isTransparent) {              << 177   glColor3d
218               continue;                        << 178     (bsf * c.GetRed() + (1. - bsf) * bg.GetRed(),
219             }                                  << 179      bsf * c.GetGreen() + (1. - bsf) * bg.GetGreen(),
220           } else {  // Third pass for non-hidd << 180      bsf * c.GetBlue() + (1. - bsf) * bg.GetBlue());
221             if (!po.fMarkerOrPolyline) {       << 181   glCallList (to.fDisplayListId);
222               continue;                        << 182   glPopMatrix();
223             }                                  << 
224           }                                    << 
225           if (isPicking) glLoadName(po.fPickNa << 
226           if (transparency_enabled) {          << 
227             glColor4d(c.GetRed(),c.GetGreen(), << 
228           } else {                             << 
229             glColor3d(c.GetRed(),c.GetGreen(), << 
230           }                                    << 
231           if (po.fMarkerOrPolyline && fVP.IsMa << 
232             if (fDepthTestEnable !=false) {    << 
233               glDisable (GL_DEPTH_TEST);       << 
234               fDepthTestEnable = false;        << 
235             }                                  << 
236           } else {                             << 
237             if (fDepthTestEnable !=true) {     << 
238               glEnable (GL_DEPTH_TEST); glDept << 
239               fDepthTestEnable = true;         << 
240             }                                  << 
241           }                                    << 
242           if (po.fpG4TextPlus) {               << 
243             if (po.fpG4TextPlus->fProcessing2D << 
244               glMatrixMode (GL_PROJECTION);    << 
245               glPushMatrix();                  << 
246               glLoadIdentity();                << 
247               g4GlOrtho (-1., 1., -1., 1., -G4 << 
248               glMatrixMode (GL_MODELVIEW);     << 
249               glPushMatrix();                  << 
250               glLoadIdentity();                << 
251               G4OpenGLTransform3D oglt (po.fTr << 
252               glMultMatrixd (oglt.GetGLMatrix  << 
253               // This text is from a PODL. We  << 
254               AddPrimitiveForASingleFrame(po.f << 
255             } else {                           << 
256               glPushMatrix();                  << 
257               G4OpenGLTransform3D oglt (po.fTr << 
258               glMultMatrixd (oglt.GetGLMatrix  << 
259               // This text is from a PODL. We  << 
260               AddPrimitiveForASingleFrame(po.f << 
261               glPopMatrix();                   << 
262             }                                  << 
263                                                << 
264             if (po.fpG4TextPlus->fProcessing2D << 
265               glMatrixMode (GL_PROJECTION);    << 
266               glPopMatrix();                   << 
267               glMatrixMode (GL_MODELVIEW);     << 
268               glPopMatrix();                   << 
269             }                                  << 
270           } else {                             << 
271             glPushMatrix();                    << 
272             G4OpenGLTransform3D oglt (po.fTran << 
273             glMultMatrixd (oglt.GetGLMatrix () << 
274             glCallList (po.fDisplayListId);    << 
275             glPopMatrix();                     << 
276           }                                    << 
277         }                                      << 
278       }                                        << 
279                                                << 
280       G4Transform3D lastMatrixTransform;       << 
281       G4bool first = true;                     << 
282                                                << 
283       for (size_t iTO = 0;                     << 
284            iTO < fG4OpenGLStoredSceneHandler.f << 
285         if (TOSelected(iTO)) {                 << 
286           G4OpenGLStoredSceneHandler::TO& to = << 
287           fG4OpenGLStoredSceneHandler.fTOList[ << 
288           const G4Colour& c = to.fColour;      << 
289           const G4bool isTransparent = c.GetAl << 
290           if ( iPass == 1) {                   << 
291             if (isTransparent && transparency_ << 
292               secondPassForTransparencyRequest << 
293               continue;                        << 
294             }                                  << 
295             if (to.fMarkerOrPolyline && fVP.Is << 
296               thirdPassForNonHiddenMarkersRequ << 
297               continue;                        << 
298             }                                  << 
299           } else if (iPass == 2) {  // Second  << 
300             if (!isTransparent) {              << 
301               continue;                        << 
302             }                                  << 
303           } else {  // Third pass for non-hidd << 
304             if (!to.fMarkerOrPolyline) {       << 
305               continue;                        << 
306             }                                  << 
307           }                                    << 
308           if (to.fMarkerOrPolyline && fVP.IsMa << 
309             if (fDepthTestEnable !=false) {    << 
310               glDisable (GL_DEPTH_TEST);       << 
311               fDepthTestEnable = false;        << 
312             }                                  << 
313           } else {                             << 
314             if (fDepthTestEnable !=true) {     << 
315               glEnable (GL_DEPTH_TEST); glDept << 
316               fDepthTestEnable = true;         << 
317             }                                  << 
318           }                                    << 
319           if (to.fEndTime >= fStartTime && to. << 
320             if (fVP.IsPicking()) glLoadName(to << 
321             if (to.fpG4TextPlus) {             << 
322               if (to.fpG4TextPlus->fProcessing << 
323                 glMatrixMode (GL_PROJECTION);  << 
324                 glPushMatrix();                << 
325                 glLoadIdentity();              << 
326                 g4GlOrtho (-1., 1., -1., 1., - << 
327                 glMatrixMode (GL_MODELVIEW);   << 
328                 glPushMatrix();                << 
329                 glLoadIdentity();              << 
330               }                                << 
331               G4OpenGLTransform3D oglt (to.fTr << 
332               glMultMatrixd (oglt.GetGLMatrix  << 
333               // This text is from a TODL. We  << 
334               AddPrimitiveForASingleFrame(to.f << 
335               if (to.fpG4TextPlus->fProcessing << 
336                 glMatrixMode (GL_PROJECTION);  << 
337                 glPopMatrix();                 << 
338                 glMatrixMode (GL_MODELVIEW);   << 
339                 glPopMatrix();                 << 
340               }                                << 
341             } else {                           << 
342               if (to.fTransform != lastMatrixT << 
343                 if (! first) {                 << 
344                   glPopMatrix();               << 
345                 }                              << 
346                 first = false;                 << 
347                 glPushMatrix();                << 
348                 G4OpenGLTransform3D oglt (to.f << 
349                 glMultMatrixd (oglt.GetGLMatri << 
350               }                                << 
351               const G4Colour& cc = to.fColour; << 
352               if (fFadeFactor > 0. && to.fEndT << 
353                 // Brightness scaling factor   << 
354                 G4double bsf = 1. - fFadeFacto << 
355                 ((fEndTime - to.fEndTime) / (f << 
356                 const G4Colour& bg = fVP.GetBa << 
357                 if (transparency_enabled) {    << 
358                   glColor4d                    << 
359                   (bsf * cc.GetRed() + (1. - b << 
360                    bsf * cc.GetGreen() + (1. - << 
361                    bsf * cc.GetBlue() + (1. -  << 
362                    bsf * cc.GetAlpha() + (1. - << 
363                 } else {                       << 
364                   glColor3d                    << 
365                   (bsf * cc.GetRed() + (1. - b << 
366                    bsf * cc.GetGreen() + (1. - << 
367                    bsf * cc.GetBlue() + (1. -  << 
368                 }                              << 
369               } else {                         << 
370                 if (transparency_enabled) {    << 
371                   glColor4d(cc.GetRed(),cc.Get << 
372                 } else {                       << 
373                   glColor3d(cc.GetRed(),cc.Get << 
374                 }                              << 
375               }                                << 
376               glCallList (to.fDisplayListId);  << 
377             }                                  << 
378             if (to.fTransform != lastMatrixTra << 
379               lastMatrixTransform = to.fTransf << 
380             }                                  << 
381           }                                    << 
382         }                                      << 
383       }                                        << 
384       if (! first) {                           << 
385         glPopMatrix();                         << 
386       }                                           183       }
387                                                << 184     }
388       if (cutawayUnion) glDisable (GL_CLIP_PLA << 185 
389     }  // iCutaway                             << 186     if (cutawayUnion) glDisable (GL_CLIP_PLANE2);
390                                                << 187   }
391     if (iPass == 2) secondPassForTransparencyR << 188 #ifdef G4DEBUG_VIS_OGL
392     if (iPass == 3) thirdPassForNonHiddenMarke << 189       printf("\n");
393                                                << 190 #endif
394     if (secondPassForTransparencyRequested) iP << 191 
395     else if (thirdPassForNonHiddenMarkersReque << 
396     else break;                                << 
397                                                << 
398   } while (true);                              << 
399                                                << 
400   // Display time at "head" of time range, whi    192   // Display time at "head" of time range, which is fEndTime...
401   if (fDisplayHeadTime && fEndTime < G4VisAttr << 193   if (fDisplayHeadTime && fEndTime < DBL_MAX) {
402     glMatrixMode (GL_PROJECTION);                 194     glMatrixMode (GL_PROJECTION);
403     glPushMatrix();                               195     glPushMatrix();
404     glLoadIdentity();                             196     glLoadIdentity();
405     g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT << 197     glOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
406     glMatrixMode (GL_MODELVIEW);                  198     glMatrixMode (GL_MODELVIEW);
407     glPushMatrix();                               199     glPushMatrix();
408     glLoadIdentity();                             200     glLoadIdentity();
409     G4Text headTimeText(G4BestUnit(fEndTime,"T    201     G4Text headTimeText(G4BestUnit(fEndTime,"Time"),
410                         G4Point3D(fDisplayHead << 202       G4Point3D(fDisplayHeadTimeX, fDisplayHeadTimeY, 0.));
411     headTimeText.SetScreenSize(fDisplayHeadTim    203     headTimeText.SetScreenSize(fDisplayHeadTimeSize);
412     G4VisAttributes visAtts (G4Colour             204     G4VisAttributes visAtts (G4Colour
413                              (fDisplayHeadTime << 205            (fDisplayHeadTimeRed,
414                               fDisplayHeadTime << 206             fDisplayHeadTimeGreen,
415                               fDisplayHeadTime << 207             fDisplayHeadTimeBlue));
416     headTimeText.SetVisAttributes(&visAtts);      208     headTimeText.SetVisAttributes(&visAtts);
417     AddPrimitiveForASingleFrame(headTimeText); << 209     static_cast<G4OpenGLSceneHandler&>(fSceneHandler).
                                                   >> 210       G4OpenGLSceneHandler::AddPrimitive(headTimeText);
418     glMatrixMode (GL_PROJECTION);                 211     glMatrixMode (GL_PROJECTION);
419     glPopMatrix();                                212     glPopMatrix();
420     glMatrixMode (GL_MODELVIEW);                  213     glMatrixMode (GL_MODELVIEW);
421     glPopMatrix();                                214     glPopMatrix();
422   }                                               215   }
423                                                << 216 
424   // Display light front...                       217   // Display light front...
425   if (fDisplayLightFront && fEndTime < G4VisAt << 218   if (fDisplayLightFront && fEndTime < DBL_MAX) {
426     G4double lightFrontRadius = (fEndTime - fD    219     G4double lightFrontRadius = (fEndTime - fDisplayLightFrontT) * c_light;
427     if (lightFrontRadius > 0.) {                  220     if (lightFrontRadius > 0.) {
428       G4Point3D lightFrontCentre(fDisplayLight    221       G4Point3D lightFrontCentre(fDisplayLightFrontX, fDisplayLightFrontY, fDisplayLightFrontZ);
429       G4Point3D circleCentre = lightFrontCentr    222       G4Point3D circleCentre = lightFrontCentre;
430       G4double circleRadius = lightFrontRadius    223       G4double circleRadius = lightFrontRadius;
431       if (fVP.GetFieldHalfAngle() > 0.) {         224       if (fVP.GetFieldHalfAngle() > 0.) {
432         // Perspective view.  Find horizon cen << 225   // Perspective view.  Find horizon centre and radius...
433         G4Point3D targetPoint = fSceneHandler. << 226   G4Point3D targetPoint = fSceneHandler.GetScene()->GetStandardTargetPoint() +
434         fVP.GetCurrentTargetPoint();           << 227     fVP.GetCurrentTargetPoint();
435         G4double sceneRadius = fSceneHandler.G << 228   G4double sceneRadius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
436         if(sceneRadius <= 0.) sceneRadius = 1. << 229   if(sceneRadius <= 0.) sceneRadius = 1.;
437         G4double cameraDistance = fVP.GetCamer << 230   G4double cameraDistance = fVP.GetCameraDistance(sceneRadius);
438         G4Point3D cameraPosition = targetPoint << 231   G4Point3D cameraPosition = targetPoint + cameraDistance * fVP.GetViewpointDirection().unit();
439         G4Vector3D lightFrontToCameraDirection << 232   G4Vector3D lightFrontToCameraDirection = cameraPosition - lightFrontCentre;
440         G4double lightFrontCentreDistance = li << 233   G4double lightFrontCentreDistance = lightFrontToCameraDirection.mag();
441         /*                                     << 234   /*
442          G4cout << "cameraPosition: " << camer << 235   G4cout << "cameraPosition: " << cameraPosition
443          << ", lightFrontCentre: " << lightFro << 236          << ", lightFrontCentre: " << lightFrontCentre
444          << ", lightFrontRadius: " << lightFro << 237          << ", lightFrontRadius: " << lightFrontRadius
445          << ", lightFrontCentreDistance: " <<  << 238          << ", lightFrontCentreDistance: " << lightFrontCentreDistance
446          << ", dot: " << lightFrontToCameraDir << 239          << ", dot: " << lightFrontToCameraDirection * fVP.GetViewpointDirection()
447          << G4endl;                            << 240          << G4endl;
448          */                                    << 241   */
449         if (lightFrontToCameraDirection * fVP. << 242   if (lightFrontToCameraDirection * fVP.GetViewpointDirection() > 0. && lightFrontRadius < lightFrontCentreDistance) {
450           // Light front in front of camera... << 243     // Light front in front of camera...
451           G4double sineHorizonAngle = lightFro << 244     G4double sineHorizonAngle = lightFrontRadius / lightFrontCentreDistance;
452           circleCentre = lightFrontCentre + (l << 245     circleCentre = lightFrontCentre + (lightFrontRadius * sineHorizonAngle) * lightFrontToCameraDirection.unit();
453           circleRadius = lightFrontRadius * st << 246     circleRadius = lightFrontRadius * std::sqrt(1. - std::pow(sineHorizonAngle, 2));
454           /*                                   << 247     /*
455            G4cout << "sineHorizonAngle: " << s << 248     G4cout << "sineHorizonAngle: " << sineHorizonAngle
456            << ", circleCentre: " << circleCent << 249      << ", circleCentre: " << circleCentre
457            << ", circleRadius: " << circleRadi << 250      << ", circleRadius: " << circleRadius
458            << G4endl;                          << 251      << G4endl;
459            */                                  << 252     */
460         } else {                               << 253   } else {
461           circleRadius = -1.;                  << 254     circleRadius = -1.;
462         }                                      << 255   }
463       }                                           256       }
464       if (circleRadius > 0.) {                    257       if (circleRadius > 0.) {
465         G4Circle lightFront(circleCentre);     << 258   G4Circle lightFront(circleCentre);
466         lightFront.SetWorldRadius(circleRadius << 259   lightFront.SetWorldRadius(circleRadius);
467         G4VisAttributes visAtts(G4Colour       << 260   glColor3d(fDisplayLightFrontRed,
468          (fDisplayLightFrontRed,               << 261       fDisplayLightFrontGreen,
469           fDisplayLightFrontGreen,             << 262       fDisplayLightFrontBlue);
470           fDisplayLightFrontBlue));            << 263   static_cast<G4OpenGLSceneHandler&>(fSceneHandler).
471         lightFront.SetVisAttributes(visAtts);  << 264     G4OpenGLSceneHandler::AddPrimitive(lightFront);
472         AddPrimitiveForASingleFrame(lightFront << 
473       }                                           265       }
474     }                                             266     }
475   }                                               267   }
476 }                                                 268 }
477                                                   269 
478 void G4OpenGLStoredViewer::AddPrimitiveForASin << 270 #endif
479 {                                              << 
480   // We don't want this to get into a display  << 
481   // use the fMemoryForDisplayLists flag.      << 
482   fG4OpenGLStoredSceneHandler.fDoNotUseDisplay << 
483   fG4OpenGLStoredSceneHandler.G4OpenGLStoredSc << 
484   fG4OpenGLStoredSceneHandler.fDoNotUseDisplay << 
485 }                                              << 
486                                                << 
487 void G4OpenGLStoredViewer::AddPrimitiveForASin << 
488 {                                              << 
489   // We don't want this to get into a display  << 
490   // use the fMemoryForDisplayLists flag.      << 
491   fG4OpenGLStoredSceneHandler.fDoNotUseDisplay << 
492   fG4OpenGLStoredSceneHandler.G4OpenGLStoredSc << 
493   fG4OpenGLStoredSceneHandler.fDoNotUseDisplay << 
494 }                                              << 
495                                                   271