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 ]

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