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