Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLStoredSceneHandler.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/G4OpenGLStoredSceneHandler.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLStoredSceneHandler.cc (Version 9.0.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 // $Id: G4OpenGLStoredSceneHandler.cc,v 1.34 2007/04/04 16:50:27 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-00-patch-01 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // Andrew Walkden  10th February 1997              31 // Andrew Walkden  10th February 1997
 30 // OpenGL stored scene - creates OpenGL displa     32 // OpenGL stored scene - creates OpenGL display lists.
 31                                                    33 
                                                   >>  34 #ifdef G4VIS_BUILD_OPENGL_DRIVER
                                                   >>  35 
                                                   >>  36 // Included here - problems with HP compiler if not before other includes?
                                                   >>  37 #include "G4NURBS.hh"
                                                   >>  38 
                                                   >>  39 // Here follows a special for Mesa, the OpenGL emulator.  Does not affect
                                                   >>  40 // other OpenGL's, as far as I'm aware.   John Allison 18/9/96.
                                                   >>  41 #define CENTERLINE_CLPP  /* CenterLine C++ workaround: */
                                                   >>  42 // Also seems to be required for HP's CC and AIX xlC, at least.
                                                   >>  43 
 32 #include "G4OpenGLStoredSceneHandler.hh"           44 #include "G4OpenGLStoredSceneHandler.hh"
 33                                                    45 
 34 #include "G4PhysicalVolumeModel.hh"                46 #include "G4PhysicalVolumeModel.hh"
 35 #include "G4LogicalVolumeModel.hh"             << 
 36 #include "G4VPhysicalVolume.hh"                    47 #include "G4VPhysicalVolume.hh"
 37 #include "G4LogicalVolume.hh"                      48 #include "G4LogicalVolume.hh"
 38 #include "G4Polyline.hh"                           49 #include "G4Polyline.hh"
 39 #include "G4Polymarker.hh"                         50 #include "G4Polymarker.hh"
 40 #include "G4Text.hh"                               51 #include "G4Text.hh"
 41 #include "G4Circle.hh"                             52 #include "G4Circle.hh"
 42 #include "G4Square.hh"                             53 #include "G4Square.hh"
 43 #include "G4Polyhedron.hh"                         54 #include "G4Polyhedron.hh"
 44 #include "G4AttHolder.hh"                          55 #include "G4AttHolder.hh"
 45 #include "G4OpenGLTransform3D.hh"              << 
 46 #include "G4OpenGLViewer.hh"                   << 
 47 #include "G4AttHolder.hh"                      << 
 48                                                << 
 49 #include <typeinfo>                            << 
 50                                                << 
 51 G4int G4OpenGLStoredSceneHandler::fSceneIdCoun << 
 52                                                << 
 53 G4int  G4OpenGLStoredSceneHandler::fDisplayLis << 
 54                                                << 
 55 G4OpenGLStoredSceneHandler::PO::PO():          << 
 56   fDisplayListId(0),                           << 
 57   fPickName(0),                                << 
 58   fpG4TextPlus(0),                             << 
 59   fMarkerOrPolyline(false)                     << 
 60 {}                                             << 
 61                                                << 
 62 G4OpenGLStoredSceneHandler::PO::PO(const G4Ope << 
 63   fDisplayListId(po.fDisplayListId),           << 
 64   fTransform(po.fTransform),                   << 
 65   fPickName(po.fPickName),                     << 
 66   fColour(po.fColour),                         << 
 67   fpG4TextPlus(po.fpG4TextPlus? new G4TextPlus << 
 68   fMarkerOrPolyline(po.fMarkerOrPolyline)      << 
 69 {}                                             << 
 70                                                << 
 71 G4OpenGLStoredSceneHandler::PO::PO(G4int id, c << 
 72   fDisplayListId(id),                          << 
 73   fTransform(tr),                              << 
 74   fPickName(0),                                << 
 75   fpG4TextPlus(0),                             << 
 76   fMarkerOrPolyline(false)                     << 
 77 {}                                             << 
 78                                                << 
 79 G4OpenGLStoredSceneHandler::PO::~PO()          << 
 80 {                                              << 
 81   delete fpG4TextPlus;                         << 
 82 }                                              << 
 83                                                << 
 84 G4OpenGLStoredSceneHandler::PO& G4OpenGLStored << 
 85   (const G4OpenGLStoredSceneHandler::PO& rhs)  << 
 86 {                                              << 
 87   if (&rhs == this) return *this;              << 
 88   fDisplayListId = rhs.fDisplayListId;         << 
 89   fTransform = rhs.fTransform;                 << 
 90   fPickName = rhs.fPickName;                   << 
 91   fColour = rhs.fColour;                       << 
 92   fpG4TextPlus = rhs.fpG4TextPlus? new G4TextP << 
 93   fMarkerOrPolyline = rhs.fMarkerOrPolyline;   << 
 94   return *this;                                << 
 95 }                                              << 
 96                                                << 
 97 G4OpenGLStoredSceneHandler::TO::TO():          << 
 98   fDisplayListId(0),                           << 
 99   fPickName(0),                                << 
100   fStartTime(-G4VisAttributes::fVeryLongTime), << 
101   fEndTime(G4VisAttributes::fVeryLongTime),    << 
102   fpG4TextPlus(0),                             << 
103   fMarkerOrPolyline(false)                     << 
104 {}                                             << 
105                                                    56 
106 G4OpenGLStoredSceneHandler::TO::TO(const G4Ope <<  57 G4OpenGLStoredSceneHandler::G4OpenGLStoredSceneHandler (G4VGraphicsSystem& system,
107   fDisplayListId(to.fDisplayListId),           <<  58             const G4String& name):
108   fTransform(to.fTransform),                   << 
109   fPickName(to.fPickName),                     << 
110   fStartTime(to.fStartTime),                   << 
111   fEndTime(to.fEndTime),                       << 
112   fColour(to.fColour),                         << 
113   fpG4TextPlus(to.fpG4TextPlus? new G4TextPlus << 
114   fMarkerOrPolyline(to.fMarkerOrPolyline)      << 
115 {}                                             << 
116                                                << 
117 G4OpenGLStoredSceneHandler::TO::TO(G4int id, c << 
118   fDisplayListId(id),                          << 
119   fTransform(tr),                              << 
120   fPickName(0),                                << 
121   fStartTime(-G4VisAttributes::fVeryLongTime), << 
122   fEndTime(G4VisAttributes::fVeryLongTime),    << 
123   fpG4TextPlus(0),                             << 
124   fMarkerOrPolyline(false)                     << 
125 {}                                             << 
126                                                << 
127 G4OpenGLStoredSceneHandler::TO::~TO()          << 
128 {                                              << 
129   delete fpG4TextPlus;                         << 
130 }                                              << 
131                                                << 
132 G4OpenGLStoredSceneHandler::TO& G4OpenGLStored << 
133   (const G4OpenGLStoredSceneHandler::TO& rhs)  << 
134 {                                              << 
135   if (&rhs == this) return *this;              << 
136   fDisplayListId = rhs.fDisplayListId;         << 
137   fTransform = rhs.fTransform;                 << 
138   fPickName = rhs.fPickName;                   << 
139   fStartTime = rhs.fStartTime;                 << 
140   fEndTime = rhs.fEndTime;                     << 
141   fColour = rhs.fColour;                       << 
142   fpG4TextPlus = rhs.fpG4TextPlus? new G4TextP << 
143   fMarkerOrPolyline = rhs.fMarkerOrPolyline;   << 
144   return *this;                                << 
145 }                                              << 
146                                                << 
147 G4OpenGLStoredSceneHandler::G4OpenGLStoredScen << 
148 (G4VGraphicsSystem& system,                    << 
149  const G4String& name):                        << 
150 G4OpenGLSceneHandler (system, fSceneIdCount++,     59 G4OpenGLSceneHandler (system, fSceneIdCount++, name),
151 fDoNotUseDisplayList(false),                   <<  60 fMemoryForDisplayLists (true),
152 fTopPODL (0)                                   <<  61 fAddPrimitivePreambleNestingDepth (0),
                                                   >>  62 fTopPODL (0),
                                                   >>  63 fProcessing2D (false)
153 {}                                                 64 {}
154                                                    65 
155 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSce     66 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
156 {}                                                 67 {}
157                                                    68 
158 void G4OpenGLStoredSceneHandler::BeginPrimitiv <<  69 void G4OpenGLStoredSceneHandler::AddPrimitivePreamble(const G4Visible& visible)
159 (const G4Transform3D& objectTransformation)    << 
160 {                                              << 
161   G4OpenGLSceneHandler::BeginPrimitives (objec << 
162   if (fReadyForTransients) glDrawBuffer (GL_FR << 
163   // Display list setup moved to AddPrimitiveP << 
164 }                                              << 
165                                                << 
166 void G4OpenGLStoredSceneHandler::EndPrimitives << 
167 {                                                  70 {
168   // See all primitives immediately...  At lea <<  71   // Track nesting depth to avoid recursive calls, for example, from a
169   ScaledFlush();                               <<  72   // G4Polymarker that invokes a G4Circle...
170   glDrawBuffer (GL_BACK);                      <<  73   fAddPrimitivePreambleNestingDepth++;
171   G4OpenGLSceneHandler::EndPrimitives ();      <<  74   if (fAddPrimitivePreambleNestingDepth > 1) return;
172 }                                              << 
173                                                << 
174 void G4OpenGLStoredSceneHandler::BeginPrimitiv << 
175 (const G4Transform3D& objectTransformation)    << 
176 {                                              << 
177   G4OpenGLSceneHandler::BeginPrimitives2D(obje << 
178   if (fReadyForTransients) glDrawBuffer (GL_FR << 
179 }                                              << 
180                                                << 
181 void G4OpenGLStoredSceneHandler::EndPrimitives << 
182 {                                              << 
183   // See all primitives immediately...  At lea << 
184   ScaledFlush();                               << 
185   glDrawBuffer (GL_BACK);                      << 
186   G4OpenGLSceneHandler::EndPrimitives2D ();    << 
187 }                                              << 
188                                                << 
189 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv << 
190 {                                              << 
191   return AddPrimitivePreambleInternal(visible, << 
192 }                                              << 
193 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv << 
194 {                                              << 
195   return AddPrimitivePreambleInternal(visible, << 
196 }                                              << 
197 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv << 
198 {                                              << 
199   return AddPrimitivePreambleInternal(visible, << 
200 }                                              << 
201                                                << 
202 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv << 
203 (const G4Visible& visible, bool isMarker, bool << 
204 {                                              << 
205 // Get applicable vis attributes for all primi << 
206   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
207   const G4Colour& c = GetColour ();            << 
208   G4double opacity = c.GetAlpha ();            << 
209                                                << 
210   G4bool transparency_enabled = true;          << 
211   G4bool isMarkerNotHidden = true;             << 
212   G4OpenGLViewer* pOGLViewer = dynamic_cast<G4 << 
213   if (pOGLViewer) {                            << 
214     transparency_enabled = pOGLViewer->transpa << 
215     isMarkerNotHidden = pOGLViewer->fVP.IsMark << 
216   }                                            << 
217                                                << 
218   G4bool isTransparent = opacity < 1.;         << 
219   G4bool isMarkerOrPolyline = isMarker || isPo << 
220   G4bool treatAsTransparent = transparency_ena << 
221   G4bool treatAsNotHidden = isMarkerNotHidden  << 
222                                                << 
223   if (fProcessing2D) glDisable (GL_DEPTH_TEST) << 
224   else {                                       << 
225     if (isMarkerOrPolyline && isMarkerNotHidde << 
226       glDisable (GL_DEPTH_TEST);               << 
227     else {glEnable (GL_DEPTH_TEST); glDepthFun << 
228   }                                            << 
229                                                << 
230   if (fThreePassCapable) {                     << 
231                                                << 
232     // Ensure transparent objects are drawn *a << 
233     // non-hidden markers.  The problem of ble << 
234     // is quite a tricky one - see History of  << 
235     if (!(fSecondPassForTransparency || fThird << 
236       // First pass...                         << 
237       if (treatAsTransparent) {  // Request pa << 
238         fSecondPassForTransparencyRequested =  << 
239       }                                        << 
240       if (treatAsNotHidden) {    // Request pa << 
241         fThirdPassForNonHiddenMarkersRequested << 
242       }                                        << 
243       // On first pass, transparent objects an << 
244       if (treatAsTransparent || treatAsNotHidd << 
245         return false;  // No further processin << 
246       }                                        << 
247     }                                          << 
248                                                << 
249     // On second pass, only transparent object << 
250     if (fSecondPassForTransparency) {          << 
251       if (!treatAsTransparent) {               << 
252         return false;  // No further processin << 
253       }                                        << 
254     }                                          << 
255                                                << 
256     // On third pass, only non-hidden markers  << 
257     if (fThirdPassForNonHiddenMarkers) {       << 
258       if (!treatAsNotHidden) {                 << 
259         return false;  // No further processin << 
260       }                                        << 
261     }                                          << 
262   }  // fThreePassCapable                      << 
263                                                << 
264   // Loads G4Atts for picking...               << 
265   G4bool isPicking = false;                    << 
266   if (fpViewer->GetViewParameters().IsPicking( << 
267     isPicking = true;                          << 
268     glLoadName(++fPickName);                   << 
269     G4AttHolder* holder = new G4AttHolder;     << 
270     LoadAtts(visible, holder);                 << 
271     fPickMap[fPickName] = holder;              << 
272   }                                            << 
273                                                    75 
274   // Because of our need to control colour of      76   // Because of our need to control colour of transients (display by
275   // time fading), display lists may only cove     77   // time fading), display lists may only cover a single primitive.
276   // So display list setup is here.                78   // So display list setup is here.
277                                                    79 
278   if (fDoNotUseDisplayList) {                  <<  80   if (fpViewer->GetViewParameters().IsPicking()) {
279                                                <<  81     fPickMap[++fPickName] = 0;
280     glPushMatrix();                            <<  82   }
281     G4OpenGLTransform3D oglt (fObjectTransform << 
282     glMultMatrixd (oglt.GetGLMatrix ());       << 
283     if (transparency_enabled) {                << 
284       glColor4d(c.GetRed(),c.GetGreen(),c.GetB << 
285     } else {                                   << 
286       glColor3d(c.GetRed(),c.GetGreen(),c.GetB << 
287     }                                          << 
288                                                    83 
289   } else {                                     <<  84   const G4Colour& c = GetColour (visible);
290                                                    85 
                                                   >>  86   if (fMemoryForDisplayLists) {
291     fDisplayListId = glGenLists (1);               87     fDisplayListId = glGenLists (1);
292     if (glGetError() == GL_OUT_OF_MEMORY) {    <<  88     if (!fDisplayListId) {  // Could pre-allocate?
293       static G4int errorCount = 0;             <<  89       G4cout <<
294       if (errorCount < 5) {                    <<  90   "********************* WARNING! ********************"
295         errorCount++;                          <<  91   "\nUnable to allocate any more display lists in OpenGL."
296         G4ExceptionDescription ed;             <<  92   "\n     Continuing drawing in IMMEDIATE MODE."
297         ed <<                                  <<  93   "\n***************************************************"
298         "Error attempting to create an OpenGL  <<  94        << G4endl;
299         "\nCurrent display list id: " << fDisp <<  95       fMemoryForDisplayLists = false;
300         "\nMaybe out of memory?";              << 
301         G4Exception                            << 
302         ("G4OpenGLStoredSceneHandler::AddPrimi << 
303          JustWarning,ed);                      << 
304       }                                        << 
305       return false;                            << 
306     }                                              96     }
                                                   >>  97   }
                                                   >>  98   if (fMemoryForDisplayLists) {
307     if (fReadyForTransients) {                     99     if (fReadyForTransients) {
308       TO to(fDisplayListId, fObjectTransformat << 100       TO to(fDisplayListId, *fpObjectTransformation);
309       if (isPicking) to.fPickName = fPickName; << 101       to.fPickName = fPickName;
310       to.fColour = c;                             102       to.fColour = c;
311       to.fStartTime = fpVisAttribs->GetStartTi << 103       const G4VisAttributes* pVA =
312       to.fEndTime = fpVisAttribs->GetEndTime() << 104   fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
313       to.fMarkerOrPolyline = isMarkerOrPolylin << 105       to.fStartTime = pVA->GetStartTime();
                                                   >> 106       to.fEndTime = pVA->GetEndTime();
314       fTOList.push_back(to);                      107       fTOList.push_back(to);
315       // For transient objects, colour, transf << 108       glDrawBuffer (GL_FRONT);
316       // the TO, so should *not* be in the dis << 
317       // above, in some cases (display-by-time << 
318       // independent control of colour.  But f << 
319       // colour for immediate display.         << 
320       glPushMatrix();                             109       glPushMatrix();
321       G4OpenGLTransform3D oglt (fObjectTransfo << 110       G4OpenGLTransform3D oglt (*fpObjectTransformation);
322       glMultMatrixd (oglt.GetGLMatrix ());        111       glMultMatrixd (oglt.GetGLMatrix ());
323       if (transparency_enabled) {              << 112       glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
324         glColor4d(c.GetRed(),c.GetGreen(),c.Ge << 
325       } else {                                 << 
326         glColor3d(c.GetRed(),c.GetGreen(),c.Ge << 
327       }                                        << 
328       (void) ExtraTOProcessing(visible, fTOLis << 
329       // Ignore return value of the above.  If << 
330       // gl commands, a display list is create << 
331       // used.                                 << 
332       glNewList (fDisplayListId, GL_COMPILE_AN    113       glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
333     } else {                                   << 114     }
334       PO po(fDisplayListId, fObjectTransformat << 115     else {
335       if (isPicking) po.fPickName = fPickName; << 116       PO po(fDisplayListId, *fpObjectTransformation);
336       po.fColour = c;                          << 117       po.fPickName = fPickName;
337       po.fMarkerOrPolyline = isMarkerOrPolylin << 
338       fPOList.push_back(po);                      118       fPOList.push_back(po);
339       // For permanent objects, colour is kept << 
340       // *not* be in the display list.  This i << 
341       // may implement colour modifications ac << 
342       // criteria, e.g., scene tree slider in  << 
343       // colour for immediate display.         << 
344       if (transparency_enabled) {              << 
345         glColor4d(c.GetRed(),c.GetGreen(),c.Ge << 
346       } else {                                 << 
347         glColor3d(c.GetRed(),c.GetGreen(),c.Ge << 
348       }                                        << 
349       G4bool usesGLCommands = ExtraPOProcessin << 
350       // Transients are displayed as they come << 
351       // above) but persistents are compiled i << 
352       // (GL_COMPILE only) and then drawn from << 
353       // their fObjectTransformation as stored << 
354       // there is no need to do glMultMatrixd  << 
355       // ExtraPOProcessing says the visible ob << 
356       // commands, simply return and abandon f << 
357       // is assumed that all relevant informat << 
358       // POList.                               << 
359       if (!usesGLCommands) return false;       << 
360       glNewList (fDisplayListId, GL_COMPILE);     119       glNewList (fDisplayListId, GL_COMPILE);
                                                   >> 120       glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
361     }                                             121     }
                                                   >> 122   } else {
                                                   >> 123     glDrawBuffer (GL_FRONT);
                                                   >> 124     glPushMatrix();
                                                   >> 125     G4OpenGLTransform3D oglt (*fpObjectTransformation);
                                                   >> 126     glMultMatrixd (oglt.GetGLMatrix ());
                                                   >> 127     glColor3d (c.GetRed (), c.GetGreen (), c.GetBlue ());
362   }                                               128   }
363                                                   129 
364   if (fProcessing2D) {                            130   if (fProcessing2D) {
365     // Push current 3D world matrices and load    131     // Push current 3D world matrices and load identity to define screen
366     // coordinates...                             132     // coordinates...
367     glMatrixMode (GL_PROJECTION);                 133     glMatrixMode (GL_PROJECTION);
368     glPushMatrix();                               134     glPushMatrix();
369     glLoadIdentity();                             135     glLoadIdentity();
370     if (pOGLViewer) {                          << 136     glOrtho (-1., 1., -1., 1., -G4OPENGL_DBL_MAX, G4OPENGL_DBL_MAX);
371       pOGLViewer->g4GlOrtho (-1., 1., -1., 1., << 
372     }                                          << 
373     glMatrixMode (GL_MODELVIEW);                  137     glMatrixMode (GL_MODELVIEW);
374     glPushMatrix();                               138     glPushMatrix();
375     glLoadIdentity();                             139     glLoadIdentity();
376     G4OpenGLTransform3D oglt (fObjectTransform << 
377     glMultMatrixd (oglt.GetGLMatrix ());       << 
378     glDisable (GL_LIGHTING);                   << 
379   } else {                                     << 
380     if (isMarker) {                            << 
381       glDisable (GL_LIGHTING);                 << 
382     } else {                                   << 
383       glEnable (GL_LIGHTING);                  << 
384     }                                          << 
385   }                                               140   }
386                                                << 
387   return true;                                 << 
388 }                                                 141 }
389                                                   142 
390 void G4OpenGLStoredSceneHandler::AddPrimitiveP    143 void G4OpenGLStoredSceneHandler::AddPrimitivePostamble()
391 {                                                 144 {
392   if (fProcessing2D) {                            145   if (fProcessing2D) {
393     // Pop current 3D world matrices back agai    146     // Pop current 3D world matrices back again...
394     glMatrixMode (GL_PROJECTION);                 147     glMatrixMode (GL_PROJECTION);
395     glPopMatrix();                                148     glPopMatrix();
396     glMatrixMode (GL_MODELVIEW);                  149     glMatrixMode (GL_MODELVIEW);
397     glPopMatrix();                                150     glPopMatrix();
398   }                                               151   }
399                                                   152 
400   //  if ((glGetError() == GL_TABLE_TOO_LARGE) << 153   if (fMemoryForDisplayLists) {
401   if (glGetError() == GL_OUT_OF_MEMORY) {  //  << 
402     G4cerr <<                                  << 
403       "ERROR: G4OpenGLStoredSceneHandler::AddP << 
404       "  to allocate display List for fTopPODL << 
405            << G4endl;                          << 
406   }                                            << 
407   if (!fDoNotUseDisplayList) {                 << 
408     glEndList();                                  154     glEndList();
409     if (glGetError() == GL_OUT_OF_MEMORY) {  / << 
410       G4cerr <<                                << 
411         "ERROR: G4OpenGLStoredSceneHandler::Ad << 
412   "  to allocate display List for fTopPODL - t << 
413              << G4endl;                        << 
414     }                                          << 
415   }                                               155   }
416   if (fReadyForTransients || fDoNotUseDisplayL << 156   if (fReadyForTransients || !fMemoryForDisplayLists) {
417     glPopMatrix();                                157     glPopMatrix();
                                                   >> 158     glFlush ();
                                                   >> 159     glDrawBuffer (GL_BACK);
418   }                                               160   }
                                                   >> 161   fAddPrimitivePreambleNestingDepth--;
419 }                                                 162 }
420                                                   163 
421 void G4OpenGLStoredSceneHandler::AddPrimitive     164 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyline& polyline)
422 {                                                 165 {
423   G4bool furtherprocessing = AddPrimitivePream << 166   AddPrimitivePreamble(polyline);
424   if (furtherprocessing) {                     << 167   G4OpenGLSceneHandler::AddPrimitive(polyline);
425     G4OpenGLSceneHandler::AddPrimitive(polylin << 168   AddPrimitivePostamble();
426     AddPrimitivePostamble();                   << 
427   }                                            << 
428 }                                                 169 }
429                                                   170 
430 void G4OpenGLStoredSceneHandler::AddPrimitive     171 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
431 {                                                 172 {
432   G4bool furtherprocessing = AddPrimitivePream << 173   AddPrimitivePreamble(polymarker);
433   if (furtherprocessing) {                     << 174   G4OpenGLSceneHandler::AddPrimitive(polymarker);
434     G4OpenGLSceneHandler::AddPrimitive(polymar << 175   AddPrimitivePostamble();
435     AddPrimitivePostamble();                   << 
436   }                                            << 
437 }                                                 176 }
438                                                   177 
439 void G4OpenGLStoredSceneHandler::AddPrimitive     178 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Text& text)
440 {                                                 179 {
441   // Note: colour is still handled in             180   // Note: colour is still handled in
442   // G4OpenGLSceneHandler::AddPrimitive(const     181   // G4OpenGLSceneHandler::AddPrimitive(const G4Text&), so it still
443   // gets into the display list                   182   // gets into the display list
444   G4bool furtherprocessing = AddPrimitivePream << 183   AddPrimitivePreamble(text);
445   if (furtherprocessing) {                     << 184   G4OpenGLSceneHandler::AddPrimitive(text);
446     G4OpenGLSceneHandler::AddPrimitive(text);  << 185   AddPrimitivePostamble();
447     AddPrimitivePostamble();                   << 
448   }                                            << 
449 }                                                 186 }
450                                                   187 
451 void G4OpenGLStoredSceneHandler::AddPrimitive     188 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Circle& circle)
452 {                                                 189 {
453   G4bool furtherprocessing = AddPrimitivePream << 190   AddPrimitivePreamble(circle);
454   if (furtherprocessing) {                     << 191   G4OpenGLSceneHandler::AddPrimitive(circle);
455     G4OpenGLSceneHandler::AddPrimitive(circle) << 192   AddPrimitivePostamble();
456     AddPrimitivePostamble();                   << 
457   }                                            << 
458 }                                                 193 }
459                                                   194 
460 void G4OpenGLStoredSceneHandler::AddPrimitive     195 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Square& square)
461 {                                                 196 {
462   G4bool furtherprocessing = AddPrimitivePream << 197   AddPrimitivePreamble(square);
463   if (furtherprocessing) {                     << 198   G4OpenGLSceneHandler::AddPrimitive(square);
464     G4OpenGLSceneHandler::AddPrimitive(square) << 199   AddPrimitivePostamble();
465     AddPrimitivePostamble();                   << 200 }
466   }                                            << 201 
                                                   >> 202 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Scale& scale)
                                                   >> 203 {
                                                   >> 204   // Let base class split into primitives.
                                                   >> 205   G4OpenGLSceneHandler::AddPrimitive(scale);
467 }                                                 206 }
468                                                   207 
469 void G4OpenGLStoredSceneHandler::AddPrimitive     208 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron)
470 {                                                 209 {
471   // Note: colour is still handled in             210   // Note: colour is still handled in
472   // G4OpenGLSceneHandler::AddPrimitive(const     211   // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&), so it still
473   // gets into the display list                   212   // gets into the display list
474   G4bool furtherprocessing = AddPrimitivePream << 213   AddPrimitivePreamble(polyhedron);
475   if (furtherprocessing) {                     << 214   G4OpenGLSceneHandler::AddPrimitive(polyhedron);
476     G4OpenGLSceneHandler::AddPrimitive(polyhed << 215   AddPrimitivePostamble();
477     AddPrimitivePostamble();                   << 216 }
478   }                                            << 217 
                                                   >> 218 void G4OpenGLStoredSceneHandler::AddPrimitive (const G4NURBS& nurbs)
                                                   >> 219 {
                                                   >> 220   // Note: colour is still handled in
                                                   >> 221   // G4OpenGLSceneHandler::AddPrimitive(const G4NURBS&), so it still
                                                   >> 222   // gets into the display list
                                                   >> 223   AddPrimitivePreamble(nurbs);
                                                   >> 224   G4OpenGLSceneHandler::AddPrimitive(nurbs);
                                                   >> 225   AddPrimitivePostamble();
                                                   >> 226 }
                                                   >> 227 
                                                   >> 228 void G4OpenGLStoredSceneHandler::BeginPrimitives
                                                   >> 229 (const G4Transform3D& objectTransformation)
                                                   >> 230 {  
                                                   >> 231   G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
                                                   >> 232 
                                                   >> 233   // Display list setup moved to AddPrimitivePreamble.  See notes there.
                                                   >> 234 }
                                                   >> 235 
                                                   >> 236 void G4OpenGLStoredSceneHandler::EndPrimitives ()
                                                   >> 237 {
                                                   >> 238   G4OpenGLSceneHandler::EndPrimitives ();
                                                   >> 239 }
                                                   >> 240 
                                                   >> 241 void G4OpenGLStoredSceneHandler::BeginPrimitives2D()
                                                   >> 242 {
                                                   >> 243   G4OpenGLSceneHandler::BeginPrimitives2D();
                                                   >> 244   fProcessing2D = true;
                                                   >> 245 }
                                                   >> 246 
                                                   >> 247 void G4OpenGLStoredSceneHandler::EndPrimitives2D ()
                                                   >> 248 {
                                                   >> 249   fProcessing2D = false;
                                                   >> 250   G4OpenGLSceneHandler::EndPrimitives2D ();
479 }                                                 251 }
480                                                   252 
481 void G4OpenGLStoredSceneHandler::BeginModeling    253 void G4OpenGLStoredSceneHandler::BeginModeling () {
482   G4VSceneHandler::BeginModeling();               254   G4VSceneHandler::BeginModeling();
                                                   >> 255   ClearStore();  // ...and all that goes with it.
483   /* Debug...                                     256   /* Debug...
484   fDisplayListId = glGenLists (1);                257   fDisplayListId = glGenLists (1);
485   G4cout << "OGL::fDisplayListId (start): " <<    258   G4cout << "OGL::fDisplayListId (start): " << fDisplayListId << G4endl;
486   */                                              259   */
487 }                                                 260 }
488                                                   261 
489 void G4OpenGLStoredSceneHandler::EndModeling (    262 void G4OpenGLStoredSceneHandler::EndModeling () {
490   // Make a List which calls the other lists.     263   // Make a List which calls the other lists.
491   fTopPODL = glGenLists (1);                      264   fTopPODL = glGenLists (1);
492   if (glGetError() == GL_OUT_OF_MEMORY) {  //  << 265   if (!fTopPODL) {
493     G4cerr <<                                  << 266     G4cout <<
494       "ERROR: G4OpenGLStoredSceneHandler::EndM    267       "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
495       "  display List for fTopPODL - try OpenG    268       "  display List for fTopPODL - try OpenGL Immediated mode."
496      << G4endl;                                   269      << G4endl;
497   } else {                                        270   } else {
498                                                << 271     glNewList (fTopPODL, GL_COMPILE_AND_EXECUTE); {
499     glNewList (fTopPODL, GL_COMPILE); {        << 
500       for (size_t i = 0; i < fPOList.size ();     272       for (size_t i = 0; i < fPOList.size (); i++) {
501   glPushMatrix();                                 273   glPushMatrix();
502   G4OpenGLTransform3D oglt (fPOList[i].fTransf    274   G4OpenGLTransform3D oglt (fPOList[i].fTransform);
503   glMultMatrixd (oglt.GetGLMatrix ());            275   glMultMatrixd (oglt.GetGLMatrix ());
504   if (fpViewer->GetViewParameters().IsPicking(    276   if (fpViewer->GetViewParameters().IsPicking())
505     glLoadName(fPOList[i].fPickName);             277     glLoadName(fPOList[i].fPickName);
506   glCallList (fPOList[i].fDisplayListId);         278   glCallList (fPOList[i].fDisplayListId);
507   glPopMatrix();                                  279   glPopMatrix();
508       }                                           280       }
509     }                                             281     }
510     glEndList ();                                 282     glEndList ();
511                                                << 
512     if (glGetError() == GL_OUT_OF_MEMORY) {  / << 
513       G4cerr <<                                << 
514         "ERROR: G4OpenGLStoredSceneHandler::En << 
515         "  display List for fTopPODL - try Ope << 
516              << G4endl;                        << 
517     }                                          << 
518   }                                               283   }
519                                                   284 
520   G4VSceneHandler::EndModeling ();                285   G4VSceneHandler::EndModeling ();
                                                   >> 286 
                                                   >> 287   /* Debug...
                                                   >> 288   fDisplayListId = glGenLists (1);
                                                   >> 289   G4cout << "OGL::fDisplayListId (end): " << fDisplayListId << G4endl;
                                                   >> 290   */
521 }                                                 291 }
522                                                   292 
523 void G4OpenGLStoredSceneHandler::ClearStore ()    293 void G4OpenGLStoredSceneHandler::ClearStore () {
524                                                   294 
525   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 
526                                                << 
527   G4VSceneHandler::ClearStore ();  // Sets nee    295   G4VSceneHandler::ClearStore ();  // Sets need kernel visit, etc.
528                                                   296 
529   // Delete OpenGL permanent display lists.       297   // Delete OpenGL permanent display lists.
530   for (size_t i = 0; i < fPOList.size (); i++)    298   for (size_t i = 0; i < fPOList.size (); i++)
531     glDeleteLists (fPOList[i].fDisplayListId,     299     glDeleteLists (fPOList[i].fDisplayListId, 1);
532   if (fTopPODL) glDeleteLists (fTopPODL, 1);      300   if (fTopPODL) glDeleteLists (fTopPODL, 1);
533   fTopPODL = 0;                                   301   fTopPODL = 0;
534                                                   302 
535   // Clear other lists, dictionary, etc.          303   // Clear other lists, dictionary, etc.
536   fPOList.clear ();                               304   fPOList.clear ();
537   fSolidMap.clear ();                             305   fSolidMap.clear ();
538   ClearAndDestroyAtts();                          306   ClearAndDestroyAtts();
539                                                   307 
540   // ...and clear transient store...              308   // ...and clear transient store...
541   for (size_t i = 0; i < fTOList.size (); i++)    309   for (size_t i = 0; i < fTOList.size (); i++)
542     glDeleteLists(fTOList[i].fDisplayListId, 1    310     glDeleteLists(fTOList[i].fDisplayListId, 1);
543   fTOList.clear ();                               311   fTOList.clear ();
544 }                                                 312 }
545                                                   313 
546 void G4OpenGLStoredSceneHandler::ClearTransien << 314 void G4OpenGLStoredSceneHandler::ClearTransientStore () {
547 {                                              << 315 
548   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 316   G4VSceneHandler::ClearTransientStore ();
549                                                   317 
550   // Delete OpenGL transient display lists and    318   // Delete OpenGL transient display lists and Transient Objects themselves.
551   for (size_t i = 0; i < fTOList.size (); i++)    319   for (size_t i = 0; i < fTOList.size (); i++)
552     glDeleteLists(fTOList[i].fDisplayListId, 1    320     glDeleteLists(fTOList[i].fDisplayListId, 1);
553   fTOList.clear ();                               321   fTOList.clear ();
554                                                   322 
555   // Redraw the scene ready for the next event << 323   // Make sure screen corresponds to graphical database...
556   if (fpViewer) {                                 324   if (fpViewer) {
557     fpViewer -> SetView ();                       325     fpViewer -> SetView ();
558     fpViewer -> ClearView ();                     326     fpViewer -> ClearView ();
559     fpViewer -> DrawView ();                      327     fpViewer -> DrawView ();
560   }                                               328   }
561 }                                                 329 }
                                                   >> 330 
                                                   >> 331 void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid)
                                                   >> 332 {
                                                   >> 333   if (fReadyForTransients) {
                                                   >> 334     // Always draw transient solids, e.g., hits represented as solids.
                                                   >> 335     // (As we have no control over the order of drawing of transient
                                                   >> 336     // objects, we cannot do anything about transparent ones, as
                                                   >> 337     // below, so always draw them.)
                                                   >> 338     G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 339     return;
                                                   >> 340   }
                                                   >> 341 
                                                   >> 342   // For non-transient (run-duration) objects, ensure transparent
                                                   >> 343   // objects are drawn last.  The problem of
                                                   >> 344   // blending/transparency/alpha is quite a tricky one - see History
                                                   >> 345   // of opengl-V07-01-01/2/3.
                                                   >> 346   // Get vis attributes - pick up defaults if none.
                                                   >> 347   const G4VisAttributes* pVA =
                                                   >> 348     fpViewer -> GetApplicableVisAttributes(fpVisAttribs);
                                                   >> 349   const G4Colour& c = pVA -> GetColour ();
                                                   >> 350   G4double opacity = c.GetAlpha ();
                                                   >> 351 
                                                   >> 352   if (!fSecondPass) {
                                                   >> 353     G4bool transparency_enabled = true;
                                                   >> 354     G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
                                                   >> 355     if (pViewer) transparency_enabled = pViewer->transparency_enabled;
                                                   >> 356     if (transparency_enabled && opacity < 1.) {
                                                   >> 357       // On first pass, transparent objects are not drawn, but flag is set...
                                                   >> 358       fSecondPassRequested = true;
                                                   >> 359       return;
                                                   >> 360     }
                                                   >> 361   }
                                                   >> 362 
                                                   >> 363   // On second pass, opaque objects are not drwan...
                                                   >> 364   if (fSecondPass && opacity >= 1.) return;
                                                   >> 365 
                                                   >> 366   G4PhysicalVolumeModel* pPVModel =
                                                   >> 367     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
                                                   >> 368  
                                                   >> 369   if (pPVModel) {
                                                   >> 370     // If part of the geometry hierarchy, i.e., from a
                                                   >> 371     // G4PhysicalVolumeModel, check if a display list already exists for
                                                   >> 372     // this solid, re-use it if possible.  We could be smarter, and
                                                   >> 373     // recognise repeated branches of the geometry hierarchy, for
                                                   >> 374     // example.  But this algorithm should be secure, I think...
                                                   >> 375     const G4VSolid* pSolid = &solid;
                                                   >> 376     EAxis axis = kRho;
                                                   >> 377     G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
                                                   >> 378     if (pCurrentPV -> IsReplicated ()) {
                                                   >> 379       G4int nReplicas;
                                                   >> 380       G4double width;
                                                   >> 381       G4double offset;
                                                   >> 382       G4bool consuming;
                                                   >> 383       pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
                                                   >> 384     }
                                                   >> 385     // Provided it is not parametrised (because if so, the
                                                   >> 386     // solid's parameters might have been changed)...
                                                   >> 387     if (!(pCurrentPV -> IsParameterised ()) &&
                                                   >> 388   // Provided it is not replicated radially (because if so, the
                                                   >> 389   // solid's parameters will have been changed)...
                                                   >> 390   !(pCurrentPV -> IsReplicated () && axis == kRho) &&
                                                   >> 391   // ...and if the solid has already been rendered...
                                                   >> 392   (fSolidMap.find (pSolid) != fSolidMap.end ())) {
                                                   >> 393       fDisplayListId = fSolidMap [pSolid];
                                                   >> 394       PO po(fDisplayListId,*fpObjectTransformation);
                                                   >> 395       if (fpViewer->GetViewParameters().IsPicking()) {
                                                   >> 396   G4AttHolder* holder = new G4AttHolder;
                                                   >> 397   // Load G4Atts from G4VisAttributes, if any...
                                                   >> 398   const G4VisAttributes* va = pPVModel->GetCurrentLV()->GetVisAttributes();
                                                   >> 399   if (va) {
                                                   >> 400     const std::map<G4String,G4AttDef>* vaDefs = va->GetAttDefs();
                                                   >> 401     if (vaDefs) holder->AddAtts(va->CreateAttValues(), vaDefs);
                                                   >> 402   }
                                                   >> 403   // Load G4Atts from G4PhysicalVolumeModel...
                                                   >> 404   const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
                                                   >> 405   if (defs) holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
                                                   >> 406   fPickMap[++fPickName] = holder;
                                                   >> 407   po.fPickName = fPickName;
                                                   >> 408       }
                                                   >> 409       fPOList.push_back(po);
                                                   >> 410     }
                                                   >> 411     else {
                                                   >> 412       G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 413       fSolidMap [pSolid] = fDisplayListId;
                                                   >> 414     }
                                                   >> 415     return;
                                                   >> 416   }
                                                   >> 417 
                                                   >> 418   // Otherwise invoke base class method...
                                                   >> 419   G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 420 }
                                                   >> 421 
                                                   >> 422 G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
                                                   >> 423 
                                                   >> 424 #endif
562                                                   425