Geant4 Cross Reference |
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 // John Allison 27th March 1996 30 // 31 // Class description 32 // 33 // Abstract interface class for graphics viewers. 34 35 #ifndef G4VVIEWER_HH 36 #define G4VVIEWER_HH 37 38 #include "globals.hh" 39 40 #include "G4SceneTreeItem.hh" 41 42 #include "G4ViewParameters.hh" 43 #include "G4PhysicalVolumeModel.hh" 44 #include "G4PseudoScene.hh" 45 46 #include <vector> 47 #include <list> 48 49 class G4VSceneHandler; 50 51 // clang-format off 52 class G4VViewer { 53 54 public: // With description 55 56 friend std::ostream& operator << (std::ostream& os, const G4VViewer& v); 57 58 G4VViewer (G4VSceneHandler&, G4int id, const G4String& name = ""); 59 virtual ~G4VViewer (); 60 61 virtual void Initialise (); 62 // Called immediately after construction for those operations that 63 // must await complete contruction of viewer and all its bases. For 64 // example, if this class (G4VViewer) is inherited virtually, as in 65 // the OpenGL sub-category, it will not be fully constructed until 66 // *after* the the derived viewer (this is the rule about order of 67 // construction for virtual inheritance), so the derived viewer may 68 // not use information in G4VViewer in its contructor. Hence such 69 // code must be in Initialise(). 70 71 ////////////////////////////////////////////////////////////// 72 // View manipulation functions. 73 74 virtual void ResetView (); 75 // Reset view parameters to default, including sub-class parameters, if any. 76 // The sub-class should always invoke the base class implementation, i.e: 77 // virtual void SubClass::ResetView () { 78 // G4VViewer::ResetView(); 79 // // Then reset sub-class parameters 80 // ... 81 82 virtual void SetView () = 0; 83 // Take view parameters and work out model/view transformation, 84 // projection transformation, lighting, etc. 85 86 virtual void ClearView () = 0; 87 // Clear screen/viewing buffers. 88 89 virtual void DrawView () = 0; 90 // Draw view of the scene currently attached to the scene handler - 91 // see example of a minimal function at end of this file. 92 93 void RefreshView (); 94 // Simply invokes SetView, ClearView, DrawView. 95 96 virtual void ShowView (); 97 // Show view (for graphics systems which require to process 98 // all drawn objects before finalising the view). 99 100 virtual void FinishView (); 101 // Called at the end of drawing scene. Used to flush streams, or 102 // swap buffers. (Perhaps it is inappropriately named, perhaps its 103 // function could be incorporated into EndModeling (). It marks the 104 // end of scene drawing; be aware hits and digi drawing may Follow. 105 // It is not yet the end of all drawing; that is signalled by 106 // ShowView ().) 107 108 virtual G4bool ReadyToDraw() {return true;} 109 110 std::vector<G4ThreeVector> ComputeFlyThrough(G4Vector3D*); 111 112 // Note: the order of calling of MovingToVisSubThread and SwitchToVisSubThread 113 // is undefined, so you may need to implement mutexes to ensure your preferred 114 // order - see, e.g., G4OpenGLQtViewer. To summarise, the order of calling is 115 // as follows - see G4VisManager.cc. 116 // DoneWithMasterThread 117 // MovingToVisSubThread ) or ( SwitchToVisSubThread 118 // SwitchToVisSubThread ) ( MovingToVisSubThread 119 // DoneWithVisSubThread 120 // MovingToMasterThread 121 // SwitchToMasterThread 122 123 // Called on the master thread before starting the vis sub-thread. 124 virtual void DoneWithMasterThread () {} 125 126 // Called on the master thread after starting the vis sub-thread. 127 virtual void MovingToVisSubThread () {} 128 129 // Called on the vis sub-thread at start of vis sub-thread. 130 virtual void SwitchToVisSubThread () {} 131 132 // Called on the vis sub-thread when all events have been processed. 133 virtual void DoneWithVisSubThread () {} 134 135 // Called on the vis sub-thread when all events have been processed. 136 virtual void MovingToMasterThread () {} 137 138 // Called on the master thread after the vis sub-thread has terminated. 139 virtual void SwitchToMasterThread () {} 140 141 ////////////////////////////////////////////////////////////// 142 // Stuff for scene tree. 143 /** 144 - The scene tree is a tree of G4SceneTreeItem objects (see graphics-reps). 145 - Its root is a data member fSceneTree of all viewers by virtue of 146 G4VViewer inheritance, 147 - G4SceneTreeItem is an aggregate of data members that represent 148 properties of objects in the scene (G4Scene). Its data members are 149 low-level types - G4String, G4VisAttributes and G4AttDef/Value - so 150 that it can be used across categories, avoiding coupling. 151 - The root item has children that represent the models (G4VModel 152 sub-classes) in the scene. 153 - For a G4PhysicalVolumeModel (detector components), its children and 154 children's children, etc., imitate the geometry hierarchy of that 155 model. These descendants are called "touchables". 156 - There may be more than one G4PhysicalVolumeModel, depending how 157 the user creates his/her scene. 158 - The scene tree is reviewed, and updated if necessary, at every pass 159 of G4VSceneHandler::ProcessScene. This is called a "kernel visit". 160 - A kernel visit is triggered by some vis commands (e.g., 161 /vis/viewer/rebuild) and by a viewer if it deems necessary. For 162 example, a kernel visit may not be required for a rotation, zoom, etc., 163 but required for a change from surface to wireframe. 164 - The idea is that the scene tree can be passed to a GUI, the GUI can 165 create a tree widget, and interactions with it raise UI commands such as 166 /vis/scene/activateModel, /vis/set/touchable and /vis/touchable/set/... 167 The viewer decides if this requires a kernel visit, otherwise it 168 must update fSceneTree itself (utilities are provided - 169 G4VViewer::TouchableSetVisibility/Colour). 170 */ 171 class SceneTreeScene: public G4PseudoScene { 172 // G4PhysicalVolumeModel sends touchables to this scene 173 public: 174 SceneTreeScene(G4VViewer*, G4PhysicalVolumeModel*); 175 ~SceneTreeScene() = default; 176 private: 177 void ProcessVolume(const G4VSolid& solid) override; 178 std::list<G4SceneTreeItem>::iterator FindOrInsertTouchable 179 (const G4String& modelID, G4SceneTreeItem& mother, 180 G4int depth, const G4String& partialPathString, const G4String& fullPathString); 181 G4VViewer* fpViewer = nullptr; 182 G4PhysicalVolumeModel* fpPVModel = nullptr; 183 std::list<G4SceneTreeItem>::iterator fModelIter; // Points to scene tree item for this model 184 G4int fMaximumExpandedDepth = 0; // To be calculated in constructor 185 const G4int fMaximumExpanded = 30; // So as not to swamp the GUI 186 }; 187 void InsertModelInSceneTree(G4VModel*); 188 const G4SceneTreeItem& GetSceneTree() {return fSceneTree;} 189 G4SceneTreeItem& AccessSceneTree() {return fSceneTree;} 190 void UpdateGUISceneTree(); // A utility 191 const G4int fMaxNTouchables = 10000; // Limits memory to about 50 MB 192 G4bool fCurtailDescent = false; // Flag to curtail descent into PV model for scene tree 193 194 ////////////////////////////////////////////////////////////// 195 // Access functions. 196 const G4String& GetName () const; 197 const G4String& GetShortName () const; 198 void SetName (const G4String&); 199 G4int GetViewId () const; 200 G4VSceneHandler* GetSceneHandler () const; 201 const G4ViewParameters& GetViewParameters () const; 202 const G4ViewParameters& GetDefaultViewParameters () const; 203 G4double GetKernelVisitElapsedTimeSeconds () const; 204 205 virtual const std::vector<G4ModelingParameters::VisAttributesModifier>* 206 GetPrivateVisAttributesModifiers() const; 207 // So that privately accumulated vis attributes modifiers may be 208 // concatenated with the standard vis attributes modifiers for commands 209 // such as /vis/viewer/set/all and /vis/viewer/save. 210 211 void SetViewParameters (const G4ViewParameters& vp); 212 void SetDefaultViewParameters (const G4ViewParameters& vp); 213 214 ////////////////////////////////////////////////////////////// 215 // Public utility functions. 216 217 const G4VisAttributes* GetApplicableVisAttributes 218 (const G4VisAttributes*) const; 219 220 void SetNeedKernelVisit (G4bool need); 221 // Sets individual need-visit flag. 222 223 void NeedKernelVisit (); 224 // Flags all views the need to re-visit the GEANT4 kernel to refresh 225 // the scene. 226 227 void ProcessView (); 228 // Used by DrawView (). Invokes SetView (). The basic logic is here. 229 230 protected: 231 232 ////////////////////////////////////////////////////////////// 233 // Protected utility functions. 234 235 void SetTouchable 236 (const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath); 237 // Set the touchable for /vis/touchable/set/... commands. 238 239 void TouchableSetVisibility 240 (const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath, 241 G4bool visibility); 242 // Set the touchable visibility attribute. 243 // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild. 244 245 void TouchableSetColour 246 (const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& fullPath, 247 const G4Colour&); 248 // Set the touchable colour attribute. 249 // Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild. 250 251 ////////////////////////////////////////////////////////////// 252 // Data members 253 G4VSceneHandler& fSceneHandler; // Abstract scene for this view. 254 G4int fViewId; // Id of this instance. 255 G4String fName; 256 G4String fShortName; // Up to first ' ' character, if any. 257 G4ViewParameters fVP; // View parameters. 258 G4ViewParameters fDefaultVP; // Default view parameters. 259 G4double fKernelVisitElapsedTimeSeconds = 999.; // Default to a large number 260 // Note: fKernelVisitElapsedTimeSeconds is measured in ProcessView(). 261 G4SceneTreeItem fSceneTree; 262 263 ////////////////////////////////////////////////////////////// 264 // Other parameters. 265 G4bool fNeedKernelVisit; // See DrawView() for comments. 266 }; 267 268 #include "G4VViewer.icc" 269 270 /********************************************* 271 272 Here is a minimal DrawView () as it might be implemented in the 273 concrete viewer. 274 275 void G4VViewer::DrawView () { // Default - concrete view usually overrides. 276 277 // First, a view should decide when to re-visit the G4 kernel. 278 // Sometimes it might not be necessary, e.g., if the scene is stored 279 // in a graphical database (e.g., OpenGL's display lists) and only 280 // the viewing angle has changed. But graphics systems without a 281 // graphical database will always need to visit the G4 kernel. 282 283 NeedKernelVisit (); // Default is - always visit G4 kernel. 284 // Note: this routine sets the fNeedKernelVisit flag of *all* the views of 285 // the scene. 286 287 ProcessView (); // The basic logic is here. 288 289 // Then a view may have more to do, e.g., display the graphical 290 // database. That code should come here before finally... 291 292 FinishView (); // Flush streams and/or swap buffers. 293 } 294 295 *********************************************/ 296 297 #endif 298