Geant4 Cross Reference |
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 #include "G4OpenGLImmediateSceneHandler.hh" 33 #include "G4OpenGLImmediateSceneHandler.hh" 34 34 35 #include "G4OpenGLViewer.hh" 35 #include "G4OpenGLViewer.hh" 36 #include "G4OpenGLTransform3D.hh" 36 #include "G4OpenGLTransform3D.hh" 37 #include "G4Polyline.hh" 37 #include "G4Polyline.hh" 38 #include "G4Polymarker.hh" 38 #include "G4Polymarker.hh" 39 #include "G4Text.hh" 39 #include "G4Text.hh" 40 #include "G4Circle.hh" 40 #include "G4Circle.hh" 41 #include "G4Square.hh" 41 #include "G4Square.hh" 42 #include "G4Polyhedron.hh" 42 #include "G4Polyhedron.hh" 43 #include "G4AttHolder.hh" 43 #include "G4AttHolder.hh" 44 44 45 #include <typeinfo> 45 #include <typeinfo> 46 46 47 G4OpenGLImmediateSceneHandler::G4OpenGLImmedia 47 G4OpenGLImmediateSceneHandler::G4OpenGLImmediateSceneHandler 48 (G4VGraphicsSystem& system,const G4String& nam 48 (G4VGraphicsSystem& system,const G4String& name): 49 G4OpenGLSceneHandler (system, fSceneIdCount+ 49 G4OpenGLSceneHandler (system, fSceneIdCount++, name) 50 {} 50 {} 51 51 52 G4OpenGLImmediateSceneHandler::~G4OpenGLImmedi 52 G4OpenGLImmediateSceneHandler::~G4OpenGLImmediateSceneHandler () 53 {} 53 {} 54 54 55 #include <iomanip> 55 #include <iomanip> 56 56 57 G4bool G4OpenGLImmediateSceneHandler::AddPrimi 57 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4VMarker& visible) 58 { 58 { 59 return AddPrimitivePreambleInternal(visibl 59 return AddPrimitivePreambleInternal(visible, true, false); 60 } 60 } 61 G4bool G4OpenGLImmediateSceneHandler::AddPrimi 61 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4Polyline& visible) 62 { 62 { 63 return AddPrimitivePreambleInternal(visible, 63 return AddPrimitivePreambleInternal(visible, false, true); 64 } 64 } 65 G4bool G4OpenGLImmediateSceneHandler::AddPrimi 65 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreamble(const G4Polyhedron& visible) 66 { 66 { 67 return AddPrimitivePreambleInternal(visible, 67 return AddPrimitivePreambleInternal(visible, false, false); 68 } 68 } 69 69 70 G4bool G4OpenGLImmediateSceneHandler::AddPrimi 70 G4bool G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(const G4Visible& visible, bool isMarker, bool isPolyline) 71 { 71 { 72 // Get applicable vis attributes for all pri 72 // Get applicable vis attributes for all primitives. 73 fpVisAttribs = fpViewer->GetApplicableVisAtt 73 fpVisAttribs = fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes()); 74 const G4Colour& c = GetColour (); 74 const G4Colour& c = GetColour (); 75 G4double opacity = c.GetAlpha (); 75 G4double opacity = c.GetAlpha (); 76 76 77 G4bool transparency_enabled = true; 77 G4bool transparency_enabled = true; 78 G4bool isMarkerNotHidden = true; 78 G4bool isMarkerNotHidden = true; 79 G4OpenGLViewer* pViewer = dynamic_cast<G4Ope 79 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer); 80 if (pViewer) { 80 if (pViewer) { 81 transparency_enabled = pViewer->transparen 81 transparency_enabled = pViewer->transparency_enabled; 82 isMarkerNotHidden = pViewer->fVP.IsMarkerN 82 isMarkerNotHidden = pViewer->fVP.IsMarkerNotHidden(); 83 } 83 } 84 84 85 G4bool isMarkerOrPolyline = isMarker || isPo 85 G4bool isMarkerOrPolyline = isMarker || isPolyline; 86 G4bool treatAsTransparent = transparency_ena 86 G4bool treatAsTransparent = transparency_enabled && opacity < 1.; 87 G4bool treatAsNotHidden = isMarkerNotHidden 87 G4bool treatAsNotHidden = isMarkerNotHidden && (isMarker || isPolyline); 88 88 89 if (fProcessing2D) glDisable (GL_DEPTH_TEST) 89 if (fProcessing2D) glDisable (GL_DEPTH_TEST); 90 else { 90 else { 91 if (isMarkerOrPolyline && isMarkerNotHidde 91 if (isMarkerOrPolyline && isMarkerNotHidden) 92 glDisable (GL_DEPTH_TEST); 92 glDisable (GL_DEPTH_TEST); 93 else {glEnable (GL_DEPTH_TEST); glDepthFun 93 else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);} 94 } 94 } 95 95 96 if (fThreePassCapable) { 96 if (fThreePassCapable) { 97 97 98 // Ensure transparent objects are drawn op 98 // Ensure transparent objects are drawn opaque ones and before 99 // non-hidden markers. The problem of ble 99 // non-hidden markers. The problem of blending/transparency/alpha 100 // is quite a tricky one - see History of 100 // is quite a tricky one - see History of opengl-V07-01-01/2/3. 101 if (!(fSecondPassForTransparency || fThird 101 if (!(fSecondPassForTransparency || fThirdPassForNonHiddenMarkers)) { 102 // First pass... 102 // First pass... 103 if (treatAsTransparent) { // Request pa 103 if (treatAsTransparent) { // Request pass for transparent objects... 104 fSecondPassForTransparencyRequested = 104 fSecondPassForTransparencyRequested = true; 105 } 105 } 106 if (treatAsNotHidden) { // Request pa 106 if (treatAsNotHidden) { // Request pass for non-hidden markers... 107 fThirdPassForNonHiddenMarkersRequested 107 fThirdPassForNonHiddenMarkersRequested = true; 108 } 108 } 109 // On first pass, transparent objects an 109 // On first pass, transparent objects and non-hidden markers are not drawn... 110 if (treatAsTransparent || treatAsNotHidd 110 if (treatAsTransparent || treatAsNotHidden) { 111 return false; 111 return false; 112 } 112 } 113 } 113 } 114 114 115 // On second pass, only transparent object 115 // On second pass, only transparent objects are drawn... 116 if (fSecondPassForTransparency) { 116 if (fSecondPassForTransparency) { 117 if (!treatAsTransparent) { 117 if (!treatAsTransparent) { 118 return false; 118 return false; 119 } 119 } 120 } 120 } 121 121 122 // On third pass, only non-hidden markers 122 // On third pass, only non-hidden markers are drawn... 123 if (fThirdPassForNonHiddenMarkers) { 123 if (fThirdPassForNonHiddenMarkers) { 124 if (!treatAsNotHidden) { 124 if (!treatAsNotHidden) { 125 return false; 125 return false; 126 } 126 } 127 } 127 } 128 } // fThreePassCapable 128 } // fThreePassCapable 129 129 130 // Loads G4Atts for picking... 130 // Loads G4Atts for picking... 131 if (fpViewer->GetViewParameters().IsPicking( 131 if (fpViewer->GetViewParameters().IsPicking()) { 132 glLoadName(++fPickName); 132 glLoadName(++fPickName); 133 G4AttHolder* holder = new G4AttHolder; 133 G4AttHolder* holder = new G4AttHolder; 134 LoadAtts(visible, holder); 134 LoadAtts(visible, holder); 135 fPickMap[fPickName] = holder; 135 fPickMap[fPickName] = holder; 136 } 136 } 137 137 138 if (transparency_enabled) { 138 if (transparency_enabled) { 139 glColor4d(c.GetRed(),c.GetGreen(),c.GetBlu 139 glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha()); 140 } else { 140 } else { 141 glColor3d(c.GetRed(),c.GetGreen(),c.GetBlu 141 glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue()); 142 } 142 } 143 143 144 return true; 144 return true; 145 } 145 } 146 146 147 void G4OpenGLImmediateSceneHandler::AddPrimiti 147 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polyline& polyline) 148 { 148 { 149 G4bool furtherprocessing = AddPrimitivePream 149 G4bool furtherprocessing = AddPrimitivePreamble(polyline); 150 if (furtherprocessing) { 150 if (furtherprocessing) { 151 G4OpenGLSceneHandler::AddPrimitive(polylin 151 G4OpenGLSceneHandler::AddPrimitive(polyline); 152 } 152 } 153 } 153 } 154 154 155 void G4OpenGLImmediateSceneHandler::AddPrimiti 155 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polymarker& polymarker) 156 { 156 { 157 G4bool furtherprocessing = AddPrimitivePream 157 G4bool furtherprocessing = AddPrimitivePreamble(polymarker); 158 if (furtherprocessing) { 158 if (furtherprocessing) { 159 G4OpenGLSceneHandler::AddPrimitive(polymar 159 G4OpenGLSceneHandler::AddPrimitive(polymarker); 160 } 160 } 161 } 161 } 162 162 163 void G4OpenGLImmediateSceneHandler::AddPrimiti 163 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Text& text) 164 { 164 { 165 // Note: colour is still handled in 165 // Note: colour is still handled in 166 // G4OpenGLSceneHandler::AddPrimitive(const 166 // G4OpenGLSceneHandler::AddPrimitive(const G4Text&). 167 G4bool furtherprocessing = AddPrimitivePream 167 G4bool furtherprocessing = AddPrimitivePreamble(text); 168 if (furtherprocessing) { 168 if (furtherprocessing) { 169 G4OpenGLSceneHandler::AddPrimitive(text); 169 G4OpenGLSceneHandler::AddPrimitive(text); 170 } 170 } 171 } 171 } 172 172 173 void G4OpenGLImmediateSceneHandler::AddPrimiti 173 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Circle& circle) 174 { 174 { 175 G4bool furtherprocessing = AddPrimitivePream 175 G4bool furtherprocessing = AddPrimitivePreamble(circle); 176 if (furtherprocessing) { 176 if (furtherprocessing) { 177 G4OpenGLSceneHandler::AddPrimitive(circle) 177 G4OpenGLSceneHandler::AddPrimitive(circle); 178 } 178 } 179 } 179 } 180 180 181 void G4OpenGLImmediateSceneHandler::AddPrimiti 181 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Square& square) 182 { 182 { 183 G4bool furtherprocessing = AddPrimitivePream 183 G4bool furtherprocessing = AddPrimitivePreamble(square); 184 if (furtherprocessing) { 184 if (furtherprocessing) { 185 G4OpenGLSceneHandler::AddPrimitive(square) 185 G4OpenGLSceneHandler::AddPrimitive(square); 186 } 186 } 187 } 187 } 188 188 189 void G4OpenGLImmediateSceneHandler::AddPrimiti 189 void G4OpenGLImmediateSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron) 190 { 190 { 191 // Note: colour is still handled in 191 // Note: colour is still handled in 192 // G4OpenGLSceneHandler::AddPrimitive(const 192 // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&). 193 G4bool furtherprocessing = AddPrimitivePream 193 G4bool furtherprocessing = AddPrimitivePreamble(polyhedron); 194 if (furtherprocessing) { 194 if (furtherprocessing) { 195 G4OpenGLSceneHandler::AddPrimitive(polyhed 195 G4OpenGLSceneHandler::AddPrimitive(polyhedron); 196 } 196 } 197 } 197 } 198 198 199 void G4OpenGLImmediateSceneHandler::BeginPrimi 199 void G4OpenGLImmediateSceneHandler::BeginPrimitives 200 (const G4Transform3D& objectTransformation) 200 (const G4Transform3D& objectTransformation) 201 { 201 { 202 G4OpenGLSceneHandler::BeginPrimitives (objec 202 G4OpenGLSceneHandler::BeginPrimitives (objectTransformation); 203 203 204 G4OpenGLTransform3D oglt (objectTransformati 204 G4OpenGLTransform3D oglt (objectTransformation); 205 205 206 glPushMatrix(); 206 glPushMatrix(); 207 207 208 /*************************** Check matrix. 208 /*************************** Check matrix. 209 const GLdouble* m = oglt.GetGLMatrix (); 209 const GLdouble* m = oglt.GetGLMatrix (); 210 G4cout << "G4OpenGLTransform3D matrix:"; 210 G4cout << "G4OpenGLTransform3D matrix:"; 211 for (int i = 0; i < 16; i++) { 211 for (int i = 0; i < 16; i++) { 212 if ((i % 4) == 0) G4cout << '\n'; 212 if ((i % 4) == 0) G4cout << '\n'; 213 G4cout << std::setw (15) << m[i]; 213 G4cout << std::setw (15) << m[i]; 214 } 214 } 215 G4cout << G4endl; 215 G4cout << G4endl; 216 *****************************************/ 216 *****************************************/ 217 217 218 glMultMatrixd (oglt.GetGLMatrix ()); 218 glMultMatrixd (oglt.GetGLMatrix ()); 219 } 219 } 220 220 221 void G4OpenGLImmediateSceneHandler::EndPrimiti 221 void G4OpenGLImmediateSceneHandler::EndPrimitives () 222 { 222 { 223 glPopMatrix(); 223 glPopMatrix(); 224 224 225 // See all primitives immediately... At lea 225 // See all primitives immediately... At least soon... 226 ScaledFlush(); 226 ScaledFlush(); 227 227 228 G4OpenGLSceneHandler::EndPrimitives (); 228 G4OpenGLSceneHandler::EndPrimitives (); 229 } 229 } 230 230 231 void G4OpenGLImmediateSceneHandler::BeginPrimi 231 void G4OpenGLImmediateSceneHandler::BeginPrimitives2D 232 (const G4Transform3D& objectTransformation) 232 (const G4Transform3D& objectTransformation) 233 { 233 { 234 G4OpenGLSceneHandler::BeginPrimitives2D(obje 234 G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation); 235 235 236 // Push current 3D world matrices and load i 236 // Push current 3D world matrices and load identity to define screen 237 // coordinates... 237 // coordinates... 238 glMatrixMode (GL_PROJECTION); 238 glMatrixMode (GL_PROJECTION); 239 glPushMatrix(); 239 glPushMatrix(); 240 glLoadIdentity(); 240 glLoadIdentity(); 241 G4OpenGLViewer* pViewer = dynamic_cast<G4Ope 241 G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer); 242 if (pViewer) { 242 if (pViewer) { 243 pViewer->g4GlOrtho (-1., 1., -1., 1., -G4O 243 pViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG); 244 } 244 } 245 glMatrixMode (GL_MODELVIEW); 245 glMatrixMode (GL_MODELVIEW); 246 glPushMatrix(); 246 glPushMatrix(); 247 glLoadIdentity(); 247 glLoadIdentity(); 248 G4OpenGLTransform3D oglt (objectTransformati 248 G4OpenGLTransform3D oglt (objectTransformation); 249 glMultMatrixd (oglt.GetGLMatrix ()); 249 glMultMatrixd (oglt.GetGLMatrix ()); 250 glDisable(GL_DEPTH_TEST); // But see parent 250 glDisable(GL_DEPTH_TEST); // But see parent scene handler!! In 251 glDisable (GL_LIGHTING); // some cases, we 251 glDisable (GL_LIGHTING); // some cases, we need to re-iterate this. 252 } 252 } 253 253 254 void G4OpenGLImmediateSceneHandler::EndPrimiti 254 void G4OpenGLImmediateSceneHandler::EndPrimitives2D() 255 { 255 { 256 // Pop current 3D world matrices back again. 256 // Pop current 3D world matrices back again... 257 glMatrixMode (GL_PROJECTION); 257 glMatrixMode (GL_PROJECTION); 258 glPopMatrix(); 258 glPopMatrix(); 259 glMatrixMode (GL_MODELVIEW); 259 glMatrixMode (GL_MODELVIEW); 260 glPopMatrix(); 260 glPopMatrix(); 261 261 262 // See all primitives immediately... At lea 262 // See all primitives immediately... At least soon... 263 ScaledFlush(); 263 ScaledFlush(); 264 264 265 G4OpenGLSceneHandler::EndPrimitives2D (); 265 G4OpenGLSceneHandler::EndPrimitives2D (); 266 } 266 } 267 267 268 void G4OpenGLImmediateSceneHandler::BeginModel 268 void G4OpenGLImmediateSceneHandler::BeginModeling () { 269 G4VSceneHandler::BeginModeling(); 269 G4VSceneHandler::BeginModeling(); 270 } 270 } 271 271 272 void G4OpenGLImmediateSceneHandler::EndModelin 272 void G4OpenGLImmediateSceneHandler::EndModeling () { 273 G4VSceneHandler::EndModeling (); 273 G4VSceneHandler::EndModeling (); 274 } 274 } 275 275 276 void G4OpenGLImmediateSceneHandler::ClearTrans 276 void G4OpenGLImmediateSceneHandler::ClearTransientStore () 277 { 277 { 278 // Nothing to do except redraw the scene rea 278 // Nothing to do except redraw the scene ready for the next event. 279 if (fpViewer) { 279 if (fpViewer) { 280 fpViewer -> SetView (); 280 fpViewer -> SetView (); 281 fpViewer -> ClearView (); 281 fpViewer -> ClearView (); 282 fpViewer -> DrawView (); 282 fpViewer -> DrawView (); 283 } 283 } 284 } 284 } 285 285 286 G4int G4OpenGLImmediateSceneHandler::fSceneIdC 286 G4int G4OpenGLImmediateSceneHandler::fSceneIdCount = 0; 287 287