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


  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: G4OpenGLImmediateSceneHandler.cc,v 1.13 2005/06/02 17:43:46 allison Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-07-01 $
 27 //                                                 26 //
 28 //                                                 27 // 
 29 // Andrew Walkden  10th February 1997              28 // Andrew Walkden  10th February 1997
 30 // OpenGL immediate scene - draws immediately      29 // OpenGL immediate scene - draws immediately to buffer
 31 //                           (saving space on      30 //                           (saving space on server).
 32                                                    31 
 33 #include "G4OpenGLImmediateSceneHandler.hh"    <<  32 #ifdef G4VIS_BUILD_OPENGL_DRIVER
                                                   >>  33 
                                                   >>  34 // Included here - problems with HP compiler if not before other includes?
                                                   >>  35 #include "G4NURBS.hh"
 34                                                    36 
                                                   >>  37 // Here follows a special for Mesa, the OpenGL emulator.  Does not affect
                                                   >>  38 // other OpenGL's, as far as I'm aware.   John Allison 18/9/96.
                                                   >>  39 #define CENTERLINE_CLPP  /* CenterLine C++ workaround: */
                                                   >>  40 // Also seems to be required for HP's CC and AIX xlC, at least.
                                                   >>  41 
                                                   >>  42 #include "G4OpenGLSceneHandler.hh"
 35 #include "G4OpenGLViewer.hh"                       43 #include "G4OpenGLViewer.hh"
 36 #include "G4OpenGLTransform3D.hh"                  44 #include "G4OpenGLTransform3D.hh"
                                                   >>  45 #include "G4Point3D.hh"
                                                   >>  46 #include "G4Normal3D.hh"
                                                   >>  47 #include "G4Transform3D.hh"
 37 #include "G4Polyline.hh"                           48 #include "G4Polyline.hh"
 38 #include "G4Polymarker.hh"                     << 
 39 #include "G4Text.hh"                               49 #include "G4Text.hh"
 40 #include "G4Circle.hh"                             50 #include "G4Circle.hh"
 41 #include "G4Square.hh"                             51 #include "G4Square.hh"
 42 #include "G4Polyhedron.hh"                         52 #include "G4Polyhedron.hh"
 43 #include "G4AttHolder.hh"                      <<  53 #include "G4VisAttributes.hh"
 44                                                    54 
 45 #include <typeinfo>                            <<  55 #include "G4OpenGLImmediateSceneHandler.hh"
 46                                                    56 
 47 G4OpenGLImmediateSceneHandler::G4OpenGLImmedia <<  57 G4OpenGLImmediateSceneHandler::G4OpenGLImmediateSceneHandler (G4VGraphicsSystem& system,
 48 (G4VGraphicsSystem& system,const G4String& nam <<  58             const G4String& name):
 49   G4OpenGLSceneHandler (system, fSceneIdCount+ <<  59 G4OpenGLSceneHandler (system, fSceneIdCount++, name)
 50 {}                                                 60 {}
 51                                                    61 
 52 G4OpenGLImmediateSceneHandler::~G4OpenGLImmedi     62 G4OpenGLImmediateSceneHandler::~G4OpenGLImmediateSceneHandler ()
 53 {}                                                 63 {}
 54                                                    64 
 55 #include <iomanip>                                 65 #include <iomanip>
 56                                                    66 
 57 G4bool G4OpenGLImmediateSceneHandler::AddPrimi << 
 58 {                                              << 
 59     return AddPrimitivePreambleInternal(visibl << 
 60 }                                              << 
 61 G4bool G4OpenGLImmediateSceneHandler::AddPrimi << 
 62 {                                              << 
 63   return AddPrimitivePreambleInternal(visible, << 
 64 }                                              << 
 65 G4bool G4OpenGLImmediateSceneHandler::AddPrimi << 
 66 {                                              << 
 67   return AddPrimitivePreambleInternal(visible, << 
 68 }                                              << 
 69                                                << 
 70 G4bool G4OpenGLImmediateSceneHandler::AddPrimi << 
 71 {                                              << 
 72   // Get applicable vis attributes for all pri << 
 73   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
 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<G4Ope << 
 80   if (pViewer) {                               << 
 81     transparency_enabled = pViewer->transparen << 
 82     isMarkerNotHidden = pViewer->fVP.IsMarkerN << 
 83   }                                            << 
 84                                                << 
 85   G4bool isMarkerOrPolyline = isMarker || isPo << 
 86   G4bool treatAsTransparent = transparency_ena << 
 87   G4bool treatAsNotHidden = isMarkerNotHidden  << 
 88                                                << 
 89   if (fProcessing2D) glDisable (GL_DEPTH_TEST) << 
 90   else {                                       << 
 91     if (isMarkerOrPolyline && isMarkerNotHidde << 
 92       glDisable (GL_DEPTH_TEST);               << 
 93     else {glEnable (GL_DEPTH_TEST); glDepthFun << 
 94   }                                            << 
 95                                                << 
 96   if (fThreePassCapable) {                     << 
 97                                                << 
 98     // Ensure transparent objects are drawn op << 
 99     // non-hidden markers.  The problem of ble << 
100     // is quite a tricky one - see History of  << 
101     if (!(fSecondPassForTransparency || fThird << 
102       // First pass...                         << 
103       if (treatAsTransparent) {  // Request pa << 
104         fSecondPassForTransparencyRequested =  << 
105       }                                        << 
106       if (treatAsNotHidden) {    // Request pa << 
107         fThirdPassForNonHiddenMarkersRequested << 
108       }                                        << 
109       // On first pass, transparent objects an << 
110       if (treatAsTransparent || treatAsNotHidd << 
111         return false;                          << 
112       }                                        << 
113     }                                          << 
114                                                << 
115     // On second pass, only transparent object << 
116     if (fSecondPassForTransparency) {          << 
117       if (!treatAsTransparent) {               << 
118         return false;                          << 
119       }                                        << 
120     }                                          << 
121                                                << 
122     // On third pass, only non-hidden markers  << 
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.GetBlu << 
140   } else {                                     << 
141     glColor3d(c.GetRed(),c.GetGreen(),c.GetBlu << 
142   }                                            << 
143                                                << 
144   return true;                                 << 
145 }                                              << 
146                                                << 
147 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
148 {                                              << 
149   G4bool furtherprocessing = AddPrimitivePream << 
150   if (furtherprocessing) {                     << 
151     G4OpenGLSceneHandler::AddPrimitive(polylin << 
152   }                                            << 
153 }                                              << 
154                                                << 
155 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
156 {                                              << 
157   G4bool furtherprocessing = AddPrimitivePream << 
158   if (furtherprocessing) {                     << 
159     G4OpenGLSceneHandler::AddPrimitive(polymar << 
160   }                                            << 
161 }                                              << 
162                                                << 
163 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
164 {                                              << 
165   // Note: colour is still handled in          << 
166   // G4OpenGLSceneHandler::AddPrimitive(const  << 
167   G4bool furtherprocessing = AddPrimitivePream << 
168   if (furtherprocessing) {                     << 
169     G4OpenGLSceneHandler::AddPrimitive(text);  << 
170   }                                            << 
171 }                                              << 
172                                                << 
173 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
174 {                                              << 
175   G4bool furtherprocessing = AddPrimitivePream << 
176   if (furtherprocessing) {                     << 
177     G4OpenGLSceneHandler::AddPrimitive(circle) << 
178   }                                            << 
179 }                                              << 
180                                                << 
181 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
182 {                                              << 
183   G4bool furtherprocessing = AddPrimitivePream << 
184   if (furtherprocessing) {                     << 
185     G4OpenGLSceneHandler::AddPrimitive(square) << 
186   }                                            << 
187 }                                              << 
188                                                << 
189 void G4OpenGLImmediateSceneHandler::AddPrimiti << 
190 {                                              << 
191   // Note: colour is still handled in          << 
192   // G4OpenGLSceneHandler::AddPrimitive(const  << 
193   G4bool furtherprocessing = AddPrimitivePream << 
194   if (furtherprocessing) {                     << 
195     G4OpenGLSceneHandler::AddPrimitive(polyhed << 
196   }                                            << 
197 }                                              << 
198                                                << 
199 void G4OpenGLImmediateSceneHandler::BeginPrimi     67 void G4OpenGLImmediateSceneHandler::BeginPrimitives
200 (const G4Transform3D& objectTransformation)    <<  68 (const G4Transform3D& objectTransformation) {
201 {                                              <<  69   G4VSceneHandler::BeginPrimitives (objectTransformation);
202   G4OpenGLSceneHandler::BeginPrimitives (objec << 
203                                                << 
204   G4OpenGLTransform3D oglt (objectTransformati << 
205                                                << 
206   glPushMatrix();                                  70   glPushMatrix();
                                                   >>  71   G4OpenGLTransform3D oglt (objectTransformation);
207                                                    72 
208   /*************************** Check matrix.       73   /*************************** Check matrix.
209   const GLdouble* m = oglt.GetGLMatrix ();         74   const GLdouble* m = oglt.GetGLMatrix ();
210   G4cout << "G4OpenGLTransform3D matrix:";         75   G4cout << "G4OpenGLTransform3D matrix:";
211   for (int i = 0; i < 16; i++) {                   76   for (int i = 0; i < 16; i++) {
212     if ((i % 4) == 0) G4cout << '\n';              77     if ((i % 4) == 0) G4cout << '\n';
213     G4cout << std::setw (15) << m[i];              78     G4cout << std::setw (15) << m[i];
214   }                                                79   }
215   G4cout << G4endl;                                80   G4cout << G4endl;
216   *****************************************/       81   *****************************************/
217                                                    82 
218   glMultMatrixd (oglt.GetGLMatrix ());             83   glMultMatrixd (oglt.GetGLMatrix ());
219 }                                                  84 }
220                                                    85 
221 void G4OpenGLImmediateSceneHandler::EndPrimiti <<  86 void G4OpenGLImmediateSceneHandler::EndPrimitives () {
222 {                                              << 
223   glPopMatrix();                                   87   glPopMatrix();
224                                                <<  88   if (fReadyForTransients) {
225   // See all primitives immediately...  At lea <<  89     glFlush ();
226   ScaledFlush();                               << 
227                                                << 
228   G4OpenGLSceneHandler::EndPrimitives ();      << 
229 }                                              << 
230                                                << 
231 void G4OpenGLImmediateSceneHandler::BeginPrimi << 
232 (const G4Transform3D& objectTransformation)    << 
233 {                                              << 
234   G4OpenGLSceneHandler::BeginPrimitives2D(obje << 
235                                                << 
236   // Push current 3D world matrices and load i << 
237   // coordinates...                            << 
238   glMatrixMode (GL_PROJECTION);                << 
239   glPushMatrix();                              << 
240   glLoadIdentity();                            << 
241   G4OpenGLViewer* pViewer = dynamic_cast<G4Ope << 
242   if (pViewer) {                               << 
243     pViewer->g4GlOrtho (-1., 1., -1., 1., -G4O << 
244   }                                                90   }
245   glMatrixMode (GL_MODELVIEW);                 <<  91   G4VSceneHandler::EndPrimitives ();
246   glPushMatrix();                              << 
247   glLoadIdentity();                            << 
248   G4OpenGLTransform3D oglt (objectTransformati << 
249   glMultMatrixd (oglt.GetGLMatrix ());         << 
250   glDisable(GL_DEPTH_TEST);  // But see parent << 
251   glDisable (GL_LIGHTING);   // some cases, we << 
252 }                                              << 
253                                                << 
254 void G4OpenGLImmediateSceneHandler::EndPrimiti << 
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 lea << 
263   ScaledFlush();                               << 
264                                                << 
265   G4OpenGLSceneHandler::EndPrimitives2D ();    << 
266 }                                                  92 }
267                                                    93 
268 void G4OpenGLImmediateSceneHandler::BeginModel     94 void G4OpenGLImmediateSceneHandler::BeginModeling () {
269   G4VSceneHandler::BeginModeling();                95   G4VSceneHandler::BeginModeling();
270 }                                                  96 }
271                                                    97 
272 void G4OpenGLImmediateSceneHandler::EndModelin     98 void G4OpenGLImmediateSceneHandler::EndModeling () {
273   G4VSceneHandler::EndModeling ();                 99   G4VSceneHandler::EndModeling ();
274 }                                                 100 }
275                                                   101 
276 void G4OpenGLImmediateSceneHandler::ClearTrans << 102 void G4OpenGLImmediateSceneHandler::ClearTransientStore () {
277 {                                              << 103 
278   // Nothing to do except redraw the scene rea << 104   G4VSceneHandler::ClearTransientStore ();
                                                   >> 105 
                                                   >> 106   // Make sure screen corresponds to graphical database...
279   if (fpViewer) {                                 107   if (fpViewer) {
280     fpViewer -> SetView ();                       108     fpViewer -> SetView ();
281     fpViewer -> ClearView ();                     109     fpViewer -> ClearView ();
282     fpViewer -> DrawView ();                      110     fpViewer -> DrawView ();
283   }                                               111   }
284 }                                                 112 }
285                                                   113 
286 G4int G4OpenGLImmediateSceneHandler::fSceneIdC    114 G4int G4OpenGLImmediateSceneHandler::fSceneIdCount = 0;
                                                   >> 115 
                                                   >> 116 #endif
287                                                   117