Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenGL/src/G4OpenGLImmediateSceneHandler.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/G4OpenGLImmediateSceneHandler.cc (Version 11.3.0) and /visualization/OpenGL/src/G4OpenGLImmediateSceneHandler.cc (Version 10.6.p3)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
 27 //                                                 27 //
 28 //                                                 28 // 
 29 // Andrew Walkden  10th February 1997              29 // Andrew Walkden  10th February 1997
 30 // OpenGL immediate scene - draws immediately      30 // OpenGL immediate scene - draws immediately to buffer
 31 //                           (saving space on      31 //                           (saving space on server).
 32                                                    32 
                                                   >>  33 #ifdef G4VIS_BUILD_OPENGL_DRIVER
                                                   >>  34 
 33 #include "G4OpenGLImmediateSceneHandler.hh"        35 #include "G4OpenGLImmediateSceneHandler.hh"
 34                                                    36 
 35 #include "G4OpenGLViewer.hh"                       37 #include "G4OpenGLViewer.hh"
 36 #include "G4OpenGLTransform3D.hh"                  38 #include "G4OpenGLTransform3D.hh"
 37 #include "G4Polyline.hh"                           39 #include "G4Polyline.hh"
 38 #include "G4Polymarker.hh"                         40 #include "G4Polymarker.hh"
 39 #include "G4Text.hh"                               41 #include "G4Text.hh"
 40 #include "G4Circle.hh"                             42 #include "G4Circle.hh"
 41 #include "G4Square.hh"                             43 #include "G4Square.hh"
                                                   >>  44 #include "G4Scale.hh"
 42 #include "G4Polyhedron.hh"                         45 #include "G4Polyhedron.hh"
 43 #include "G4AttHolder.hh"                          46 #include "G4AttHolder.hh"
 44                                                    47 
 45 #include <typeinfo>                                48 #include <typeinfo>
 46                                                    49 
 47 G4OpenGLImmediateSceneHandler::G4OpenGLImmedia     50 G4OpenGLImmediateSceneHandler::G4OpenGLImmediateSceneHandler
 48 (G4VGraphicsSystem& system,const G4String& nam     51 (G4VGraphicsSystem& system,const G4String& name):
 49   G4OpenGLSceneHandler (system, fSceneIdCount+     52   G4OpenGLSceneHandler (system, fSceneIdCount++, name)
 50 {}                                                 53 {}
 51                                                    54 
 52 G4OpenGLImmediateSceneHandler::~G4OpenGLImmedi     55 G4OpenGLImmediateSceneHandler::~G4OpenGLImmediateSceneHandler ()
 53 {}                                                 56 {}
 54                                                    57 
 55 #include <iomanip>                                 58 #include <iomanip>
 56                                                    59 
 57 G4bool G4OpenGLImmediateSceneHandler::AddPrimi     60 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4VMarker& visible)
 58 {                                                  61 {
 59     return AddPrimitivePreambleInternal(visibl     62     return AddPrimitivePreambleInternal(visible, true, false);
 60 }                                                  63 }
 61 G4bool G4OpenGLImmediateSceneHandler::AddPrimi     64 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4Polyline& visible)
 62 {                                                  65 {
 63   return AddPrimitivePreambleInternal(visible,     66   return AddPrimitivePreambleInternal(visible, false, true);
 64 }                                                  67 }
 65 G4bool G4OpenGLImmediateSceneHandler::AddPrimi     68 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4Polyhedron& visible)
 66 {                                                  69 {
 67   return AddPrimitivePreambleInternal(visible,     70   return AddPrimitivePreambleInternal(visible, false, false);
 68 }                                                  71 }
 69                                                    72 
 70 G4bool G4OpenGLImmediateSceneHandler::AddPrimi     73 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(const G4Visible& visible, bool isMarker, bool isPolyline)
 71 {                                                  74 {
 72   // Get applicable vis attributes for all pri     75   // Get applicable vis attributes for all primitives.
 73   fpVisAttribs = fpViewer->GetApplicableVisAtt     76   fpVisAttribs = fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
 74   const G4Colour& c = GetColour ();                77   const G4Colour& c = GetColour ();
 75   G4double opacity = c.GetAlpha ();                78   G4double opacity = c.GetAlpha ();
 76                                                    79   
 77   G4bool transparency_enabled = true;              80   G4bool transparency_enabled = true;
 78   G4bool isMarkerNotHidden = true;                 81   G4bool isMarkerNotHidden = true;
 79   G4OpenGLViewer* pViewer = dynamic_cast<G4Ope     82   G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
 80   if (pViewer) {                                   83   if (pViewer) {
 81     transparency_enabled = pViewer->transparen     84     transparency_enabled = pViewer->transparency_enabled;
 82     isMarkerNotHidden = pViewer->fVP.IsMarkerN     85     isMarkerNotHidden = pViewer->fVP.IsMarkerNotHidden();
 83   }                                                86   }
 84                                                    87 
 85   G4bool isMarkerOrPolyline = isMarker || isPo     88   G4bool isMarkerOrPolyline = isMarker || isPolyline;
 86   G4bool treatAsTransparent = transparency_ena     89   G4bool treatAsTransparent = transparency_enabled && opacity < 1.;
 87   G4bool treatAsNotHidden = isMarkerNotHidden      90   G4bool treatAsNotHidden = isMarkerNotHidden && (isMarker || isPolyline);
 88                                                    91   
 89   if (fProcessing2D) glDisable (GL_DEPTH_TEST)     92   if (fProcessing2D) glDisable (GL_DEPTH_TEST);
 90   else {                                           93   else {
 91     if (isMarkerOrPolyline && isMarkerNotHidde     94     if (isMarkerOrPolyline && isMarkerNotHidden)
 92       glDisable (GL_DEPTH_TEST);                   95       glDisable (GL_DEPTH_TEST);
 93     else {glEnable (GL_DEPTH_TEST); glDepthFun     96     else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);}
 94   }                                                97   }
 95                                                    98 
 96   if (fThreePassCapable) {                         99   if (fThreePassCapable) {
 97                                                   100     
 98     // Ensure transparent objects are drawn op    101     // Ensure transparent objects are drawn opaque ones and before
 99     // non-hidden markers.  The problem of ble    102     // non-hidden markers.  The problem of blending/transparency/alpha
100     // is quite a tricky one - see History of     103     // is quite a tricky one - see History of opengl-V07-01-01/2/3.
101     if (!(fSecondPassForTransparency || fThird    104     if (!(fSecondPassForTransparency || fThirdPassForNonHiddenMarkers)) {
102       // First pass...                            105       // First pass...
103       if (treatAsTransparent) {  // Request pa    106       if (treatAsTransparent) {  // Request pass for transparent objects...
104         fSecondPassForTransparencyRequested =     107         fSecondPassForTransparencyRequested = true;
105       }                                           108       }
106       if (treatAsNotHidden) {    // Request pa    109       if (treatAsNotHidden) {    // Request pass for non-hidden markers...
107         fThirdPassForNonHiddenMarkersRequested    110         fThirdPassForNonHiddenMarkersRequested = true;
108       }                                           111       }
109       // On first pass, transparent objects an    112       // On first pass, transparent objects and non-hidden markers are not drawn...
110       if (treatAsTransparent || treatAsNotHidd    113       if (treatAsTransparent || treatAsNotHidden) {
111         return false;                             114         return false;
112       }                                           115       }
113     }                                             116     }
114                                                   117     
115     // On second pass, only transparent object    118     // On second pass, only transparent objects are drawn...
116     if (fSecondPassForTransparency) {             119     if (fSecondPassForTransparency) {
117       if (!treatAsTransparent) {                  120       if (!treatAsTransparent) {
118         return false;                             121         return false;
119       }                                           122       }
120     }                                             123     }
121                                                   124     
122     // On third pass, only non-hidden markers     125     // On third pass, only non-hidden markers are drawn...
123     if (fThirdPassForNonHiddenMarkers) {          126     if (fThirdPassForNonHiddenMarkers) {
124       if (!treatAsNotHidden) {                    127       if (!treatAsNotHidden) {
125         return false;                             128         return false;
126       }                                           129       }
127     }                                             130     }
128   }  // fThreePassCapable                         131   }  // fThreePassCapable
129                                                   132   
130   // Loads G4Atts for picking...                  133   // Loads G4Atts for picking...
131   if (fpViewer->GetViewParameters().IsPicking(    134   if (fpViewer->GetViewParameters().IsPicking()) {
132     glLoadName(++fPickName);                      135     glLoadName(++fPickName);
133     G4AttHolder* holder = new G4AttHolder;        136     G4AttHolder* holder = new G4AttHolder;
134     LoadAtts(visible, holder);                    137     LoadAtts(visible, holder);
135     fPickMap[fPickName] = holder;                 138     fPickMap[fPickName] = holder;
136   }                                               139   }
137                                                   140 
138   if (transparency_enabled) {                     141   if (transparency_enabled) {
139     glColor4d(c.GetRed(),c.GetGreen(),c.GetBlu    142     glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
140   } else {                                        143   } else {
141     glColor3d(c.GetRed(),c.GetGreen(),c.GetBlu    144     glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());    
142   }                                               145   }
143                                                   146 
144   return true;                                    147   return true;
145 }                                                 148 }
146                                                   149 
147 void G4OpenGLImmediateSceneHandler::AddPrimiti    150 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polyline& polyline)
148 {                                                 151 {
149   G4bool furtherprocessing = AddPrimitivePream    152   G4bool furtherprocessing = AddPrimitivePreamble(polyline);
150   if (furtherprocessing) {                        153   if (furtherprocessing) {
151     G4OpenGLSceneHandler::AddPrimitive(polylin    154     G4OpenGLSceneHandler::AddPrimitive(polyline);
152   }                                               155   }
153 }                                                 156 }
154                                                   157 
155 void G4OpenGLImmediateSceneHandler::AddPrimiti    158 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polymarker& polymarker)
156 {                                                 159 {
157   G4bool furtherprocessing = AddPrimitivePream    160   G4bool furtherprocessing = AddPrimitivePreamble(polymarker);
158   if (furtherprocessing) {                        161   if (furtherprocessing) {
159     G4OpenGLSceneHandler::AddPrimitive(polymar    162     G4OpenGLSceneHandler::AddPrimitive(polymarker);
160   }                                               163   }
161 }                                                 164 }
162                                                   165 
163 void G4OpenGLImmediateSceneHandler::AddPrimiti    166 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Text& text)
164 {                                                 167 {
165   // Note: colour is still handled in             168   // Note: colour is still handled in
166   // G4OpenGLSceneHandler::AddPrimitive(const     169   // G4OpenGLSceneHandler::AddPrimitive(const G4Text&).
167   G4bool furtherprocessing = AddPrimitivePream    170   G4bool furtherprocessing = AddPrimitivePreamble(text);
168   if (furtherprocessing) {                        171   if (furtherprocessing) {
169     G4OpenGLSceneHandler::AddPrimitive(text);     172     G4OpenGLSceneHandler::AddPrimitive(text);
170   }                                               173   }
171 }                                                 174 }
172                                                   175 
173 void G4OpenGLImmediateSceneHandler::AddPrimiti    176 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Circle& circle)
174 {                                                 177 {
175   G4bool furtherprocessing = AddPrimitivePream    178   G4bool furtherprocessing = AddPrimitivePreamble(circle);
176   if (furtherprocessing) {                        179   if (furtherprocessing) {
177     G4OpenGLSceneHandler::AddPrimitive(circle)    180     G4OpenGLSceneHandler::AddPrimitive(circle);
178   }                                               181   }
179 }                                                 182 }
180                                                   183 
181 void G4OpenGLImmediateSceneHandler::AddPrimiti    184 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Square& square)
182 {                                                 185 {
183   G4bool furtherprocessing = AddPrimitivePream    186   G4bool furtherprocessing = AddPrimitivePreamble(square);
184   if (furtherprocessing) {                        187   if (furtherprocessing) {
185     G4OpenGLSceneHandler::AddPrimitive(square)    188     G4OpenGLSceneHandler::AddPrimitive(square);
186   }                                               189   }
187 }                                                 190 }
188                                                   191 
                                                   >> 192 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Scale& scale)
                                                   >> 193 {
                                                   >> 194   G4bool furtherprocessing = AddPrimitivePreamble(scale);
                                                   >> 195   if (furtherprocessing) {
                                                   >> 196     G4OpenGLSceneHandler::AddPrimitive(scale);
                                                   >> 197   }
                                                   >> 198 }
                                                   >> 199 
189 void G4OpenGLImmediateSceneHandler::AddPrimiti    200 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron)
190 {                                                 201 {
191   // Note: colour is still handled in             202   // Note: colour is still handled in
192   // G4OpenGLSceneHandler::AddPrimitive(const     203   // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&).
193   G4bool furtherprocessing = AddPrimitivePream    204   G4bool furtherprocessing = AddPrimitivePreamble(polyhedron);
194   if (furtherprocessing) {                        205   if (furtherprocessing) {
195     G4OpenGLSceneHandler::AddPrimitive(polyhed    206     G4OpenGLSceneHandler::AddPrimitive(polyhedron);
196   }                                               207   }
197 }                                                 208 }
198                                                   209 
199 void G4OpenGLImmediateSceneHandler::BeginPrimi    210 void G4OpenGLImmediateSceneHandler::BeginPrimitives
200 (const G4Transform3D& objectTransformation)       211 (const G4Transform3D& objectTransformation)
201 {                                                 212 {
202   G4OpenGLSceneHandler::BeginPrimitives (objec    213   G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
203                                                   214 
204   G4OpenGLTransform3D oglt (objectTransformati    215   G4OpenGLTransform3D oglt (objectTransformation);
205                                                   216 
206   glPushMatrix();                                 217   glPushMatrix();
207                                                   218 
208   /*************************** Check matrix.      219   /*************************** Check matrix.
209   const GLdouble* m = oglt.GetGLMatrix ();        220   const GLdouble* m = oglt.GetGLMatrix ();
210   G4cout << "G4OpenGLTransform3D matrix:";        221   G4cout << "G4OpenGLTransform3D matrix:";
211   for (int i = 0; i < 16; i++) {                  222   for (int i = 0; i < 16; i++) {
212     if ((i % 4) == 0) G4cout << '\n';             223     if ((i % 4) == 0) G4cout << '\n';
213     G4cout << std::setw (15) << m[i];             224     G4cout << std::setw (15) << m[i];
214   }                                               225   }
215   G4cout << G4endl;                               226   G4cout << G4endl;
216   *****************************************/      227   *****************************************/
217                                                   228 
218   glMultMatrixd (oglt.GetGLMatrix ());            229   glMultMatrixd (oglt.GetGLMatrix ());
219 }                                                 230 }
220                                                   231 
221 void G4OpenGLImmediateSceneHandler::EndPrimiti    232 void G4OpenGLImmediateSceneHandler::EndPrimitives ()
222 {                                                 233 {
223   glPopMatrix();                                  234   glPopMatrix();
224                                                   235 
225   // See all primitives immediately...  At lea    236   // See all primitives immediately...  At least soon...
226   ScaledFlush();                                  237   ScaledFlush();
227                                                   238 
228   G4OpenGLSceneHandler::EndPrimitives ();         239   G4OpenGLSceneHandler::EndPrimitives ();
229 }                                                 240 }
230                                                   241 
231 void G4OpenGLImmediateSceneHandler::BeginPrimi    242 void G4OpenGLImmediateSceneHandler::BeginPrimitives2D
232 (const G4Transform3D& objectTransformation)       243 (const G4Transform3D& objectTransformation)
233 {                                                 244 {
234   G4OpenGLSceneHandler::BeginPrimitives2D(obje    245   G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
235                                                   246 
236   // Push current 3D world matrices and load i    247   // Push current 3D world matrices and load identity to define screen
237   // coordinates...                               248   // coordinates...
238   glMatrixMode (GL_PROJECTION);                   249   glMatrixMode (GL_PROJECTION);
239   glPushMatrix();                                 250   glPushMatrix();
240   glLoadIdentity();                               251   glLoadIdentity();
241   G4OpenGLViewer* pViewer = dynamic_cast<G4Ope    252   G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
242   if (pViewer) {                                  253   if (pViewer) {
243     pViewer->g4GlOrtho (-1., 1., -1., 1., -G4O    254     pViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
244   }                                               255   }
245   glMatrixMode (GL_MODELVIEW);                    256   glMatrixMode (GL_MODELVIEW);
246   glPushMatrix();                                 257   glPushMatrix();
247   glLoadIdentity();                               258   glLoadIdentity();
248   G4OpenGLTransform3D oglt (objectTransformati    259   G4OpenGLTransform3D oglt (objectTransformation);
249   glMultMatrixd (oglt.GetGLMatrix ());            260   glMultMatrixd (oglt.GetGLMatrix ());
250   glDisable(GL_DEPTH_TEST);  // But see parent    261   glDisable(GL_DEPTH_TEST);  // But see parent scene handler!!  In
                                                   >> 262 #ifndef G4OPENGL_VERSION_2
251   glDisable (GL_LIGHTING);   // some cases, we    263   glDisable (GL_LIGHTING);   // some cases, we need to re-iterate this.
                                                   >> 264 #endif
252 }                                                 265 }
253                                                   266 
254 void G4OpenGLImmediateSceneHandler::EndPrimiti    267 void G4OpenGLImmediateSceneHandler::EndPrimitives2D()
255 {                                                 268 {
256   // Pop current 3D world matrices back again.    269   // Pop current 3D world matrices back again...
257   glMatrixMode (GL_PROJECTION);                   270   glMatrixMode (GL_PROJECTION);
258   glPopMatrix();                                  271   glPopMatrix();
259   glMatrixMode (GL_MODELVIEW);                    272   glMatrixMode (GL_MODELVIEW);
260   glPopMatrix();                                  273   glPopMatrix();
261                                                   274 
262   // See all primitives immediately...  At lea    275   // See all primitives immediately...  At least soon...
263   ScaledFlush();                                  276   ScaledFlush();
264                                                   277 
265   G4OpenGLSceneHandler::EndPrimitives2D ();       278   G4OpenGLSceneHandler::EndPrimitives2D ();
266 }                                                 279 }
267                                                   280 
268 void G4OpenGLImmediateSceneHandler::BeginModel    281 void G4OpenGLImmediateSceneHandler::BeginModeling () {
269   G4VSceneHandler::BeginModeling();               282   G4VSceneHandler::BeginModeling();
270 }                                                 283 }
271                                                   284 
272 void G4OpenGLImmediateSceneHandler::EndModelin    285 void G4OpenGLImmediateSceneHandler::EndModeling () {
273   G4VSceneHandler::EndModeling ();                286   G4VSceneHandler::EndModeling ();
274 }                                                 287 }
275                                                   288 
276 void G4OpenGLImmediateSceneHandler::ClearTrans    289 void G4OpenGLImmediateSceneHandler::ClearTransientStore ()
277 {                                                 290 {
278   // Nothing to do except redraw the scene rea    291   // Nothing to do except redraw the scene ready for the next event.
279   if (fpViewer) {                                 292   if (fpViewer) {
280     fpViewer -> SetView ();                       293     fpViewer -> SetView ();
281     fpViewer -> ClearView ();                     294     fpViewer -> ClearView ();
282     fpViewer -> DrawView ();                      295     fpViewer -> DrawView ();
283   }                                               296   }
284 }                                                 297 }
285                                                   298 
286 G4int G4OpenGLImmediateSceneHandler::fSceneIdC    299 G4int G4OpenGLImmediateSceneHandler::fSceneIdCount = 0;
                                                   >> 300 
                                                   >> 301 #endif
287                                                   302