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 4.1.p1)


  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.14 2002/02/24 01:48:11 johna Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-04-01 $
 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                                                    32 
 49 #include <typeinfo>                            <<  33 // Included here - problems with HP compiler if not before other includes?
 50                                                <<  34 #include "G4NURBS.hh"
 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                                                    35 
 84 G4OpenGLStoredSceneHandler::PO& G4OpenGLStored <<  36 // Here follows a special for Mesa, the OpenGL emulator.  Does not affect
 85   (const G4OpenGLStoredSceneHandler::PO& rhs)  <<  37 // other OpenGL's, as far as I'm aware.   John Allison 18/9/96.
 86 {                                              <<  38 #define CENTERLINE_CLPP  /* CenterLine C++ workaround: */
 87   if (&rhs == this) return *this;              <<  39 // Also seems to be required for HP's CC and AIX xlC, at least.
 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                                                    40 
 97 G4OpenGLStoredSceneHandler::TO::TO():          <<  41 #include <GL/gl.h>
 98   fDisplayListId(0),                           << 
 99   fPickName(0),                                << 
100   fStartTime(-G4VisAttributes::fVeryLongTime), << 
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                                                    42 
127 G4OpenGLStoredSceneHandler::TO::~TO()          <<  43 #include "G4OpenGLStoredSceneHandler.hh"
128 {                                              << 
129   delete fpG4TextPlus;                         << 
130 }                                              << 
131                                                    44 
132 G4OpenGLStoredSceneHandler::TO& G4OpenGLStored <<  45 #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                                                    46 
147 G4OpenGLStoredSceneHandler::G4OpenGLStoredScen <<  47 G4OpenGLStoredSceneHandler::G4OpenGLStoredSceneHandler (G4VGraphicsSystem& system,
148 (G4VGraphicsSystem& system,                    <<  48             const G4String& name):
149  const G4String& name):                        << 
150 G4OpenGLSceneHandler (system, fSceneIdCount++,     49 G4OpenGLSceneHandler (system, fSceneIdCount++, name),
151 fDoNotUseDisplayList(false),                   <<  50 fMemoryForDisplayLists (true),
152 fTopPODL (0)                                       51 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 {                                              << 
168   // See all primitives immediately...  At lea << 
169   ScaledFlush();                               << 
170   glDrawBuffer (GL_BACK);                      << 
171   G4OpenGLSceneHandler::EndPrimitives ();      << 
172 }                                              << 
173                                                << 
174 void G4OpenGLStoredSceneHandler::BeginPrimitiv << 
175 (const G4Transform3D& objectTransformation)    << 
176 {                                                  52 {
177   G4OpenGLSceneHandler::BeginPrimitives2D(obje <<  53   fSceneCount++;
178   if (fReadyForTransients) glDrawBuffer (GL_FR << 
179 }                                                  54 }
180                                                    55 
181 void G4OpenGLStoredSceneHandler::EndPrimitives <<  56 G4OpenGLStoredSceneHandler::~G4OpenGLStoredSceneHandler ()
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 {                                                  57 {
199   return AddPrimitivePreambleInternal(visible, <<  58   fSceneCount--;
200 }                                                  59 }
201                                                    60 
202 G4bool G4OpenGLStoredSceneHandler::AddPrimitiv <<  61 void G4OpenGLStoredSceneHandler::BeginPrimitives
203 (const G4Visible& visible, bool isMarker, bool <<  62 (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                                                    63   
264   // Loads G4Atts for picking...               <<  64   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                                                    65 
                                                   >>  66   if (fMemoryForDisplayLists) {
291     fDisplayListId = glGenLists (1);               67     fDisplayListId = glGenLists (1);
292     if (glGetError() == GL_OUT_OF_MEMORY) {    <<  68     if (!fDisplayListId) {  // Could pre-allocate?
293       static G4int errorCount = 0;             <<  69       G4cout << "********************* WARNING! ********************\n"
294       if (errorCount < 5) {                    <<  70      <<"Unable to allocate any more display lists in OpenGL.\n "
295         errorCount++;                          <<  71      << "      Continuing drawing in IMMEDIATE MODE.\n"
296         G4ExceptionDescription ed;             <<  72      << "***************************************************" << G4endl;
297         ed <<                                  <<  73       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     }                                              74     }
                                                   >>  75   }
                                                   >>  76   if (fMemoryForDisplayLists) {
307     if (fReadyForTransients) {                     77     if (fReadyForTransients) {
308       TO to(fDisplayListId, fObjectTransformat <<  78       fTODLList.push_back (fDisplayListId);
309       if (isPicking) to.fPickName = fPickName; <<  79       fTODLTransformList.push_back (objectTransformation);
310       to.fColour = c;                          <<  80       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();                              81       glPushMatrix();
321       G4OpenGLTransform3D oglt (fObjectTransfo <<  82       G4OpenGLTransform3D oglt (objectTransformation);
322       glMultMatrixd (oglt.GetGLMatrix ());         83       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     84       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     }                                              85     }
362   }                                            <<  86     else {
363                                                <<  87       fPODLList.push_back (fDisplayListId);
364   if (fProcessing2D) {                         <<  88       fPODLTransformList.push_back (objectTransformation);
365     // Push current 3D world matrices and load <<  89       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     }                                              90     }
373     glMatrixMode (GL_MODELVIEW);               <<  91   } else {
                                                   >>  92     glDrawBuffer (GL_FRONT);
374     glPushMatrix();                                93     glPushMatrix();
375     glLoadIdentity();                          <<  94     G4OpenGLTransform3D oglt (objectTransformation);
376     G4OpenGLTransform3D oglt (fObjectTransform << 
377     glMultMatrixd (oglt.GetGLMatrix ());           95     glMultMatrixd (oglt.GetGLMatrix ());
378     glDisable (GL_LIGHTING);                   << 
379   } else {                                     << 
380     if (isMarker) {                            << 
381       glDisable (GL_LIGHTING);                 << 
382     } else {                                   << 
383       glEnable (GL_LIGHTING);                  << 
384     }                                          << 
385   }                                                96   }
386                                                << 
387   return true;                                 << 
388 }                                                  97 }
389                                                    98 
390 void G4OpenGLStoredSceneHandler::AddPrimitiveP <<  99 void G4OpenGLStoredSceneHandler::EndPrimitives () {
391 {                                              << 100   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();                                  101     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   }                                               102   }
416   if (fReadyForTransients || fDoNotUseDisplayL << 103   if (fReadyForTransients || !fMemoryForDisplayLists) {
417     glPopMatrix();                                104     glPopMatrix();
                                                   >> 105     glFlush ();
                                                   >> 106     glDrawBuffer (GL_BACK);
418   }                                               107   }
419 }                                              << 108   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 }                                                 109 }
480                                                   110 
481 void G4OpenGLStoredSceneHandler::BeginModeling    111 void G4OpenGLStoredSceneHandler::BeginModeling () {
482   G4VSceneHandler::BeginModeling();               112   G4VSceneHandler::BeginModeling();
483   /* Debug...                                  << 113   if (fpViewer -> GetViewParameters ().GetDrawingStyle() == G4ViewParameters::hlr) {
484   fDisplayListId = glGenLists (1);             << 114     initialize_hlr = true;
485   G4cout << "OGL::fDisplayListId (start): " << << 115   }
486   */                                           << 116   ClearStore();  // ...and all that goes with it.
487 }                                                 117 }
488                                                   118 
489 void G4OpenGLStoredSceneHandler::EndModeling (    119 void G4OpenGLStoredSceneHandler::EndModeling () {
490   // Make a List which calls the other lists.     120   // Make a List which calls the other lists.
491   fTopPODL = glGenLists (1);                      121   fTopPODL = glGenLists (1);
492   if (glGetError() == GL_OUT_OF_MEMORY) {  //  << 122   if (!fTopPODL) {
493     G4cerr <<                                  << 123     G4cout <<
494       "ERROR: G4OpenGLStoredSceneHandler::EndM    124       "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
495       "  display List for fTopPODL - try OpenG << 125       "  display List for fTopPODL - suggest trying OpenGL Immediated mode."
496      << G4endl;                                   126      << G4endl;
497   } else {                                     << 127   }
                                                   >> 128   else {
498                                                   129 
499     glNewList (fTopPODL, GL_COMPILE); {           130     glNewList (fTopPODL, GL_COMPILE); {
500       for (size_t i = 0; i < fPOList.size ();  << 131       for (size_t i = 0; i < fPODLList.size (); i++) {
501   glPushMatrix();                                 132   glPushMatrix();
502   G4OpenGLTransform3D oglt (fPOList[i].fTransf << 133   G4OpenGLTransform3D oglt (fPODLTransformList [i]);
503   glMultMatrixd (oglt.GetGLMatrix ());            134   glMultMatrixd (oglt.GetGLMatrix ());
504   if (fpViewer->GetViewParameters().IsPicking( << 135   glCallList (fPODLList[i]);
505     glLoadName(fPOList[i].fPickName);          << 
506   glCallList (fPOList[i].fDisplayListId);      << 
507   glPopMatrix();                                  136   glPopMatrix();
508       }                                           137       }
509     }                                             138     }
510     glEndList ();                                 139     glEndList ();
511                                                   140 
512     if (glGetError() == GL_OUT_OF_MEMORY) {  / << 141     if (fpViewer -> GetViewParameters ().GetDrawingStyle() == G4ViewParameters::hlr) {
513       G4cerr <<                                << 142       initialize_hlr = false;
514         "ERROR: G4OpenGLStoredSceneHandler::En << 143       //    glDisable (GL_POLYGON_OFFSET_FILL);
515         "  display List for fTopPODL - try Ope << 
516              << G4endl;                        << 
517     }                                             144     }
                                                   >> 145 
518   }                                               146   }
519                                                   147 
520   G4VSceneHandler::EndModeling ();                148   G4VSceneHandler::EndModeling ();
521 }                                                 149 }
522                                                   150 
523 void G4OpenGLStoredSceneHandler::ClearStore ()    151 void G4OpenGLStoredSceneHandler::ClearStore () {
524                                                   152 
525   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 
526                                                << 
527   G4VSceneHandler::ClearStore ();  // Sets nee    153   G4VSceneHandler::ClearStore ();  // Sets need kernel visit, etc.
528                                                   154 
                                                   >> 155   size_t i;
                                                   >> 156 
529   // Delete OpenGL permanent display lists.       157   // Delete OpenGL permanent display lists.
530   for (size_t i = 0; i < fPOList.size (); i++) << 158   for (i = 0; i < fPODLList.size (); i++) {
531     glDeleteLists (fPOList[i].fDisplayListId,  << 159     if (fPODLList [i]) {
                                                   >> 160       glDeleteLists (fPODLList [i], 1);
                                                   >> 161     } else {
                                                   >> 162       G4cerr << "Warning : NULL display List in fPODLList." << G4endl;
                                                   >> 163     }
                                                   >> 164   }
                                                   >> 165 
532   if (fTopPODL) glDeleteLists (fTopPODL, 1);      166   if (fTopPODL) glDeleteLists (fTopPODL, 1);
533   fTopPODL = 0;                                   167   fTopPODL = 0;
534                                                   168 
535   // Clear other lists, dictionary, etc.          169   // Clear other lists, dictionary, etc.
536   fPOList.clear ();                            << 170   fPODLList.clear ();
                                                   >> 171   fPODLTransformList.clear ();
537   fSolidMap.clear ();                             172   fSolidMap.clear ();
538   ClearAndDestroyAtts();                       << 
539                                                   173 
540   // ...and clear transient store...              174   // ...and clear transient store...
541   for (size_t i = 0; i < fTOList.size (); i++) << 175   for (i = 0; i < fTODLList.size (); i++) {
542     glDeleteLists(fTOList[i].fDisplayListId, 1 << 176     if (fTODLList [i]) {
543   fTOList.clear ();                            << 177       glDeleteLists (fTODLList [i], 1);
                                                   >> 178     } else {
                                                   >> 179       G4cerr << "Warning : NULL display List in fTODLList." << G4endl;
                                                   >> 180     }
                                                   >> 181   }
                                                   >> 182   fTODLList.clear ();
                                                   >> 183   fTODLTransformList.clear ();
544 }                                                 184 }
545                                                   185 
546 void G4OpenGLStoredSceneHandler::ClearTransien << 186 void G4OpenGLStoredSceneHandler::ClearTransientStore () {
547 {                                              << 
548   //G4cout << "G4OpenGLStoredSceneHandler::Cle << 
549                                                   187 
550   // Delete OpenGL transient display lists and << 188   G4VSceneHandler::ClearTransientStore ();
551   for (size_t i = 0; i < fTOList.size (); i++) << 
552     glDeleteLists(fTOList[i].fDisplayListId, 1 << 
553   fTOList.clear ();                            << 
554                                                   189 
555   // Redraw the scene ready for the next event << 190   size_t i;
                                                   >> 191 
                                                   >> 192   // Delete OpenGL transient display lists.
                                                   >> 193   for (i = 0; i < fTODLList.size (); i++) {
                                                   >> 194     if (fTODLList [i]) {
                                                   >> 195       glDeleteLists (fTODLList [i], 1);
                                                   >> 196     } else {
                                                   >> 197       G4cerr << "Warning : NULL display List in fTODLList." << G4endl;
                                                   >> 198     }
                                                   >> 199   }
                                                   >> 200 
                                                   >> 201   // Clear other lists, dictionary, etc.
                                                   >> 202   fTODLList.clear ();
                                                   >> 203   fTODLTransformList.clear ();
                                                   >> 204 
                                                   >> 205   // Make sure screen corresponds to graphical database...
556   if (fpViewer) {                                 206   if (fpViewer) {
557     fpViewer -> SetView ();                       207     fpViewer -> SetView ();
558     fpViewer -> ClearView ();                     208     fpViewer -> ClearView ();
559     fpViewer -> DrawView ();                      209     fpViewer -> DrawView ();
560   }                                               210   }
561 }                                                 211 }
                                                   >> 212 
                                                   >> 213 void G4OpenGLStoredSceneHandler::RequestPrimitives (const G4VSolid& solid) {
                                                   >> 214   if (fReadyForTransients) {
                                                   >> 215     G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 216   }
                                                   >> 217   else {
                                                   >> 218     // Stop-gap solution for display List re-use.  A proper
                                                   >> 219     // implementation would use geometry hierarchy.
                                                   >> 220     const G4VSolid* pSolid = &solid;
                                                   >> 221     if (!(fpCurrentPV -> IsReplicated ()) &&
                                                   >> 222   (fSolidMap.find (pSolid) != fSolidMap.end ())) {
                                                   >> 223       fDisplayListId = fSolidMap [pSolid];
                                                   >> 224       fPODLList.push_back (fDisplayListId);
                                                   >> 225       fPODLTransformList.push_back (*fpObjectTransformation);
                                                   >> 226     }
                                                   >> 227     else {
                                                   >> 228       G4VSceneHandler::RequestPrimitives (solid);
                                                   >> 229       fSolidMap [pSolid] = fDisplayListId;
                                                   >> 230     }
                                                   >> 231   }
                                                   >> 232 }
                                                   >> 233 
                                                   >> 234 G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0;
                                                   >> 235 
                                                   >> 236 G4int G4OpenGLStoredSceneHandler::fSceneCount = 0;
                                                   >> 237 
                                                   >> 238 #endif
562                                                   239