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 10.6.p2)


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