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 6.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4OpenGLStoredSceneHandler.cc,v 1.16 2003/06/10 17:13:33 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-06-00 $
 27 //                                                 26 //
 28 //                                                 27 // 
 29 // Andrew Walkden  10th February 1997              28 // Andrew Walkden  10th February 1997
 30 // OpenGL stored scene - creates OpenGL displa     29 // OpenGL stored scene - creates OpenGL display lists.
 31                                                    30 
 32 #include "G4OpenGLStoredSceneHandler.hh"       <<  31 #ifdef G4VIS_BUILD_OPENGL_DRIVER
 33                                                << 
 34 #include "G4PhysicalVolumeModel.hh"            << 
 35 #include "G4LogicalVolumeModel.hh"             << 
 36 #include "G4VPhysicalVolume.hh"                << 
 37 #include "G4LogicalVolume.hh"                  << 
 38 #include "G4Polyline.hh"                       << 
 39 #include "G4Polymarker.hh"                     << 
 40 #include "G4Text.hh"                           << 
 41 #include "G4Circle.hh"                         << 
 42 #include "G4Square.hh"                         << 
 43 #include "G4Polyhedron.hh"                     << 
 44 #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                                                    32 
 84 G4OpenGLStoredSceneHandler::PO& G4OpenGLStored <<  33 // Included here - problems with HP compiler if not before other includes?
 85   (const G4OpenGLStoredSceneHandler::PO& rhs)  <<  34 #include "G4NURBS.hh"
 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                                                    35 
 97 G4OpenGLStoredSceneHandler::TO::TO():          <<  36 // Here follows a special for Mesa, the OpenGL emulator.  Does not affect
 98   fDisplayListId(0),                           <<  37 // other OpenGL's, as far as I'm aware.   John Allison 18/9/96.
 99   fPickName(0),                                <<  38 #define CENTERLINE_CLPP  /* CenterLine C++ workaround: */
100   fStartTime(-G4VisAttributes::fVeryLongTime), <<  39 // Also seems to be required for HP's CC and AIX xlC, at least.
101   fEndTime(G4VisAttributes::fVeryLongTime),    << 
102   fpG4TextPlus(0),                             << 
103   fMarkerOrPolyline(false)                     << 
104 {}                                             << 
105                                                << 
106 G4OpenGLStoredSceneHandler::TO::TO(const G4Ope << 
107   fDisplayListId(to.fDisplayListId),           << 
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                                                    40 
127 G4OpenGLStoredSceneHandler::TO::~TO()          <<  41 #include "G4OpenGLStoredSceneHandler.hh"
128 {                                              << 
129   delete fpG4TextPlus;                         << 
130 }                                              << 
131                                                    42 
132 G4OpenGLStoredSceneHandler::TO& G4OpenGLStored <<  43 #include "G4VPhysicalVolume.hh"
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                                                    44 
147 G4OpenGLStoredSceneHandler::G4OpenGLStoredScen <<  45 G4OpenGLStoredSceneHandler::G4OpenGLStoredSceneHandler (G4VGraphicsSystem& system,
148 (G4VGraphicsSystem& system,                    <<  46             const G4String& name):
149  const G4String& name):                        << 
150 G4OpenGLSceneHandler (system, fSceneIdCount++,     47 G4OpenGLSceneHandler (system, fSceneIdCount++, name),
151 fDoNotUseDisplayList(false),                   <<  48 fMemoryForDisplayLists (true),
152 fTopPODL (0)                                       49 fTopPODL (0)
153 {}                                             << 
154                                                << 
155 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSce << 
156 {}                                             << 
157                                                << 
158 void G4OpenGLStoredSceneHandler::BeginPrimitiv << 
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 {                                                  50 {
168   // See all primitives immediately...  At lea <<  51   fSceneCount++;
169   ScaledFlush();                               << 
170   glDrawBuffer (GL_BACK);                      << 
171   G4OpenGLSceneHandler::EndPrimitives ();      << 
172 }                                                  52 }
173                                                    53 
174 void G4OpenGLStoredSceneHandler::BeginPrimitiv <<  54 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
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 {                                                  55 {
199   return AddPrimitivePreambleInternal(visible, <<  56   fSceneCount--;
200 }                                                  57 }
201                                                    58 
202 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv <<  59 void G4OpenGLStoredSceneHandler::BeginPrimitives
203 (const G4Visible& visible, bool isMarker, bool <<  60 (const G4Transform3D& objectTransformation) {
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                                                    61   
264   // Loads G4Atts for picking...               <<  62   G4VSceneHandler::BeginPrimitives (objectTransformation);
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                                                << 
274   // Because of our need to control colour of  << 
275   // time fading), display lists may only cove << 
276   // So display list setup is here.            << 
277                                                << 
278   if (fDoNotUseDisplayList) {                  << 
279                                                << 
280     glPushMatrix();                            << 
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                                                << 
289   } else {                                     << 
290                                                    63 
                                                   >>  64   if (fMemoryForDisplayLists) {
291     fDisplayListId = glGenLists (1);               65     fDisplayListId = glGenLists (1);
292     if (glGetError() == GL_OUT_OF_MEMORY) {    <<  66     if (!fDisplayListId) {  // Could pre-allocate?
293       static G4int errorCount = 0;             <<  67       G4cout << "********************* WARNING! ********************\n"
294       if (errorCount < 5) {                    <<  68      <<"Unable to allocate any more display lists in OpenGL.\n "
295         errorCount++;                          <<  69      << "      Continuing drawing in IMMEDIATE MODE.\n"
296         G4ExceptionDescription ed;             <<  70      << "***************************************************" << G4endl;
297         ed <<                                  <<  71       fMemoryForDisplayLists = false;
298         "Error attempting to create an OpenGL  << 
299         "\nCurrent display list id: " << fDisp << 
300         "\nMaybe out of memory?";              << 
301         G4Exception                            << 
302         ("G4OpenGLStoredSceneHandler::AddPrimi << 
303          JustWarning,ed);                      << 
304       }                                        << 
305       return false;                            << 
306     }                                              72     }
                                                   >>  73   }
                                                   >>  74   if (fMemoryForDisplayLists) {
307     if (fReadyForTransients) {                     75     if (fReadyForTransients) {
308       TO to(fDisplayListId, fObjectTransformat <<  76       fTODLList.push_back (fDisplayListId);
309       if (isPicking) to.fPickName = fPickName; <<  77       fTODLTransformList.push_back (objectTransformation);
310       to.fColour = c;                          <<  78       glDrawBuffer (GL_FRONT);
311       to.fStartTime = fpVisAttribs->GetStartTi << 
312       to.fEndTime = fpVisAttribs->GetEndTime() << 
313       to.fMarkerOrPolyline = isMarkerOrPolylin << 
314       fTOList.push_back(to);                   << 
315       // For transient objects, colour, transf << 
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();                              79       glPushMatrix();
321       G4OpenGLTransform3D oglt (fObjectTransfo <<  80       G4OpenGLTransform3D oglt (objectTransformation);
322       glMultMatrixd (oglt.GetGLMatrix ());         81       glMultMatrixd (oglt.GetGLMatrix ());
323       if (transparency_enabled) {              << 
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     82       glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
333     } else {                                   << 
334       PO po(fDisplayListId, fObjectTransformat << 
335       if (isPicking) po.fPickName = fPickName; << 
336       po.fColour = c;                          << 
337       po.fMarkerOrPolyline = isMarkerOrPolylin << 
338       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);  << 
361     }                                              83     }
362   }                                            <<  84     else {
363                                                <<  85       fPODLList.push_back (fDisplayListId);
364   if (fProcessing2D) {                         <<  86       fPODLTransformList.push_back (objectTransformation);
365     // Push current 3D world matrices and load <<  87       glNewList (fDisplayListId, GL_COMPILE);
366     // coordinates...                          << 
367     glMatrixMode (GL_PROJECTION);              << 
368     glPushMatrix();                            << 
369     glLoadIdentity();                          << 
370     if (pOGLViewer) {                          << 
371       pOGLViewer->g4GlOrtho (-1., 1., -1., 1., << 
372     }                                              88     }
373     glMatrixMode (GL_MODELVIEW);               <<  89   } else {
                                                   >>  90     glDrawBuffer (GL_FRONT);
374     glPushMatrix();                                91     glPushMatrix();
375     glLoadIdentity();                          <<  92     G4OpenGLTransform3D oglt (objectTransformation);
376     G4OpenGLTransform3D oglt (fObjectTransform << 
377     glMultMatrixd (oglt.GetGLMatrix ());           93     glMultMatrixd (oglt.GetGLMatrix ());
378     glDisable (GL_LIGHTING);                   << 
379   } else {                                     << 
380     if (isMarker) {                            << 
381       glDisable (GL_LIGHTING);                 << 
382     } else {                                   << 
383       glEnable (GL_LIGHTING);                  << 
384     }                                          << 
385   }                                                94   }
386                                                << 
387   return true;                                 << 
388 }                                                  95 }
389                                                    96 
390 void G4OpenGLStoredSceneHandler::AddPrimitiveP <<  97 void G4OpenGLStoredSceneHandler::EndPrimitives () {
391 {                                              <<  98   if (fMemoryForDisplayLists) {
392   if (fProcessing2D) {                         << 
393     // Pop current 3D world matrices back agai << 
394     glMatrixMode (GL_PROJECTION);              << 
395     glPopMatrix();                             << 
396     glMatrixMode (GL_MODELVIEW);               << 
397     glPopMatrix();                             << 
398   }                                            << 
399                                                << 
400   //  if ((glGetError() == GL_TABLE_TOO_LARGE) << 
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();                                   99     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   }                                               100   }
416   if (fReadyForTransients || fDoNotUseDisplayL << 101   if (fReadyForTransients || !fMemoryForDisplayLists) {
417     glPopMatrix();                                102     glPopMatrix();
                                                   >> 103     glFlush ();
                                                   >> 104     glDrawBuffer (GL_BACK);
418   }                                               105   }
419 }                                              << 106   G4VSceneHandler::EndPrimitives ();
420                                                << 
421 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
422 {                                              << 
423   G4bool furtherprocessing = AddPrimitivePream << 
424   if (furtherprocessing) {                     << 
425     G4OpenGLSceneHandler::AddPrimitive(polylin << 
426     AddPrimitivePostamble();                   << 
427   }                                            << 
428 }                                              << 
429                                                << 
430 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
431 {                                              << 
432   G4bool furtherprocessing = AddPrimitivePream << 
433   if (furtherprocessing) {                     << 
434     G4OpenGLSceneHandler::AddPrimitive(polymar << 
435     AddPrimitivePostamble();                   << 
436   }                                            << 
437 }                                              << 
438                                                << 
439 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
440 {                                              << 
441   // Note: colour is still handled in          << 
442   // G4OpenGLSceneHandler::AddPrimitive(const  << 
443   // gets into the display list                << 
444   G4bool furtherprocessing = AddPrimitivePream << 
445   if (furtherprocessing) {                     << 
446     G4OpenGLSceneHandler::AddPrimitive(text);  << 
447     AddPrimitivePostamble();                   << 
448   }                                            << 
449 }                                              << 
450                                                << 
451 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
452 {                                              << 
453   G4bool furtherprocessing = AddPrimitivePream << 
454   if (furtherprocessing) {                     << 
455     G4OpenGLSceneHandler::AddPrimitive(circle) << 
456     AddPrimitivePostamble();                   << 
457   }                                            << 
458 }                                              << 
459                                                << 
460 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
461 {                                              << 
462   G4bool furtherprocessing = AddPrimitivePream << 
463   if (furtherprocessing) {                     << 
464     G4OpenGLSceneHandler::AddPrimitive(square) << 
465     AddPrimitivePostamble();                   << 
466   }                                            << 
467 }                                              << 
468                                                << 
469 void G4OpenGLStoredSceneHandler::AddPrimitive  << 
470 {                                              << 
471   // Note: colour is still handled in          << 
472   // G4OpenGLSceneHandler::AddPrimitive(const  << 
473   // gets into the display list                << 
474   G4bool furtherprocessing = AddPrimitivePream << 
475   if (furtherprocessing) {                     << 
476     G4OpenGLSceneHandler::AddPrimitive(polyhed << 
477     AddPrimitivePostamble();                   << 
478   }                                            << 
479 }                                                 107 }
480                                                   108 
481 void G4OpenGLStoredSceneHandler::BeginModeling    109 void G4OpenGLStoredSceneHandler::BeginModeling () {
482   G4VSceneHandler::BeginModeling();               110   G4VSceneHandler::BeginModeling();
483   /* Debug...                                  << 111   if (fpViewer -> GetViewParameters ().GetDrawingStyle() == G4ViewParameters::hlr) {
484   fDisplayListId = glGenLists (1);             << 112     initialize_hlr = true;
485   G4cout << "OGL::fDisplayListId (start): " << << 113   }
486   */                                           << 114   ClearStore();  // ...and all that goes with it.
487 }                                                 115 }
488                                                   116 
489 void G4OpenGLStoredSceneHandler::EndModeling (    117 void G4OpenGLStoredSceneHandler::EndModeling () {
490   // Make a List which calls the other lists.     118   // Make a List which calls the other lists.
491   fTopPODL = glGenLists (1);                      119   fTopPODL = glGenLists (1);
492   if (glGetError() == GL_OUT_OF_MEMORY) {  //  << 120   if (!fTopPODL) {
493     G4cerr <<                                  << 121     G4cout <<
494       "ERROR: G4OpenGLStoredSceneHandler::EndM    122       "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
495       "  display List for fTopPODL - try OpenG    123       "  display List for fTopPODL - try OpenGL Immediated mode."
496      << G4endl;                                   124      << G4endl;
497   } else {                                     << 125   }
                                                   >> 126   else {
498                                                   127 
499     glNewList (fTopPODL, GL_COMPILE); {           128     glNewList (fTopPODL, GL_COMPILE); {
500       for (size_t i = 0; i < fPOList.size ();  << 129       for (size_t i = 0; i < fPODLList.size (); i++) {
501   glPushMatrix();                                 130   glPushMatrix();
502   G4OpenGLTransform3D oglt (fPOList[i].fTransf << 131   G4OpenGLTransform3D oglt (fPODLTransformList [i]);
503   glMultMatrixd (oglt.GetGLMatrix ());            132   glMultMatrixd (oglt.GetGLMatrix ());
504   if (fpViewer->GetViewParameters().IsPicking( << 133   glCallList (fPODLList[i]);
505     glLoadName(fPOList[i].fPickName);          << 
506   glCallList (fPOList[i].fDisplayListId);      << 
507   glPopMatrix();                                  134   glPopMatrix();
508       }                                           135       }
509     }                                             136     }
510     glEndList ();                                 137     glEndList ();
511                                                   138 
512     if (glGetError() == GL_OUT_OF_MEMORY) {  / << 139     if (fpViewer -> GetViewParameters ().GetDrawingStyle() == G4ViewParameters::hlr) {
513       G4cerr <<                                << 140       initialize_hlr = false;
514         "ERROR: G4OpenGLStoredSceneHandler::En << 141       //    glDisable (GL_POLYGON_OFFSET_FILL);
515         "  display List for fTopPODL - try Ope << 
516              << G4endl;                        << 
517     }                                             142     }
                                                   >> 143 
518   }                                               144   }
519                                                   145 
520   G4VSceneHandler::EndModeling ();                146   G4VSceneHandler::EndModeling ();
521 }                                                 147 }
522                                                   148 
523 void G4OpenGLStoredSceneHandler::ClearStore ()    149 void G4OpenGLStoredSceneHandler::ClearStore () {
524                                                   150 
525   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 
526                                                << 
527   G4VSceneHandler::ClearStore ();  // Sets nee    151   G4VSceneHandler::ClearStore ();  // Sets need kernel visit, etc.
528                                                   152 
                                                   >> 153   size_t i;
                                                   >> 154 
529   // Delete OpenGL permanent display lists.       155   // Delete OpenGL permanent display lists.
530   for (size_t i = 0; i < fPOList.size (); i++) << 156   for (i = 0; i < fPODLList.size (); i++) {
531     glDeleteLists (fPOList[i].fDisplayListId,  << 157     if (fPODLList [i]) {
                                                   >> 158       glDeleteLists (fPODLList [i], 1);
                                                   >> 159     } else {
                                                   >> 160       G4cerr << "Warning : NULL display List in fPODLList." << G4endl;
                                                   >> 161     }
                                                   >> 162   }
                                                   >> 163 
532   if (fTopPODL) glDeleteLists (fTopPODL, 1);      164   if (fTopPODL) glDeleteLists (fTopPODL, 1);
533   fTopPODL = 0;                                   165   fTopPODL = 0;
534                                                   166 
535   // Clear other lists, dictionary, etc.          167   // Clear other lists, dictionary, etc.
536   fPOList.clear ();                            << 168   fPODLList.clear ();
                                                   >> 169   fPODLTransformList.clear ();
537   fSolidMap.clear ();                             170   fSolidMap.clear ();
538   ClearAndDestroyAtts();                       << 
539                                                   171 
540   // ...and clear transient store...              172   // ...and clear transient store...
541   for (size_t i = 0; i < fTOList.size (); i++) << 173   for (i = 0; i < fTODLList.size (); i++) {
542     glDeleteLists(fTOList[i].fDisplayListId, 1 << 174     if (fTODLList [i]) {
543   fTOList.clear ();                            << 175       glDeleteLists (fTODLList [i], 1);
                                                   >> 176     } else {
                                                   >> 177       G4cerr << "Warning : NULL display List in fTODLList." << G4endl;
                                                   >> 178     }
                                                   >> 179   }
                                                   >> 180   fTODLList.clear ();
                                                   >> 181   fTODLTransformList.clear ();
544 }                                                 182 }
545                                                   183 
546 void G4OpenGLStoredSceneHandler::ClearTransien << 184 void G4OpenGLStoredSceneHandler::ClearTransientStore () {
547 {                                              << 
548   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 
549                                                   185 
550   // Delete OpenGL transient display lists and << 186   G4VSceneHandler::ClearTransientStore ();
551   for (size_t i = 0; i < fTOList.size (); i++) << 
552     glDeleteLists(fTOList[i].fDisplayListId, 1 << 
553   fTOList.clear ();                            << 
554                                                   187 
555   // Redraw the scene ready for the next event << 188   size_t i;
                                                   >> 189 
                                                   >> 190   // Delete OpenGL transient display lists.
                                                   >> 191   for (i = 0; i < fTODLList.size (); i++) {
                                                   >> 192     if (fTODLList [i]) {
                                                   >> 193       glDeleteLists (fTODLList [i], 1);
                                                   >> 194     } else {
                                                   >> 195       G4cerr << "Warning : NULL display List in fTODLList." << G4endl;
                                                   >> 196     }
                                                   >> 197   }
                                                   >> 198 
                                                   >> 199   // Clear other lists, dictionary, etc.
                                                   >> 200   fTODLList.clear ();
                                                   >> 201   fTODLTransformList.clear ();
                                                   >> 202 
                                                   >> 203   // Make sure screen corresponds to graphical database...
556   if (fpViewer) {                                 204   if (fpViewer) {
557     fpViewer -> SetView ();                       205     fpViewer -> SetView ();
558     fpViewer -> ClearView ();                     206     fpViewer -> ClearView ();
559     fpViewer -> DrawView ();                      207     fpViewer -> DrawView ();
560   }                                               208   }
561 }                                                 209 }
                                                   >> 210 
                                                   >> 211 void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid) {
                                                   >> 212   if (fReadyForTransients) {
                                                   >> 213     G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 214   }
                                                   >> 215   else {
                                                   >> 216     // Stop-gap solution for display List re-use.  A proper
                                                   >> 217     // implementation would use geometry hierarchy.
                                                   >> 218     const G4VSolid* pSolid = &solid;
                                                   >> 219     if (!(fpCurrentPV -> IsReplicated ()) &&
                                                   >> 220   (fSolidMap.find (pSolid) != fSolidMap.end ())) {
                                                   >> 221       fDisplayListId = fSolidMap [pSolid];
                                                   >> 222       fPODLList.push_back (fDisplayListId);
                                                   >> 223       fPODLTransformList.push_back (*fpObjectTransformation);
                                                   >> 224     }
                                                   >> 225     else {
                                                   >> 226       G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 227       fSolidMap [pSolid] = fDisplayListId;
                                                   >> 228     }
                                                   >> 229   }
                                                   >> 230 }
                                                   >> 231 
                                                   >> 232 G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
                                                   >> 233 
                                                   >> 234 G4int G4OpenGLStoredSceneHandler::fSceneCount = 0;
                                                   >> 235 
                                                   >> 236 #endif
562                                                   237