| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 //
29 // John Allison 19th July 1996.
30 //
31 // Class description
32 //
33 // Abstract interface class for graphics scene
34 // Inherits from G4VGraphicsScene, in the inte
35 // a minimal abstract interface for the GEANT4
36
37 #ifndef G4VSCENEHANDLER_HH
38 #define G4VSCENEHANDLER_HH
39
40 #include "globals.hh"
41
42 #include "G4VGraphicsScene.hh"
43 #include "G4ViewerList.hh"
44 #include "G4ViewParameters.hh"
45 #include "G4THitsMap.hh"
46 #include "G4PseudoScene.hh"
47
48 #include <map>
49
50 class G4Scene;
51 class G4VGraphicsSystem;
52 class G4AttHolder;
53
54 class G4VSceneHandler: public G4VGraphicsScene
55
56 friend class G4VViewer;
57 friend std::ostream& operator << (std::ostre
58
59 public: // With description
60
61 enum MarkerSizeType {world, screen};
62
63 G4VSceneHandler (G4VGraphicsSystem& system,
64 G4int id,
65 const G4String& name = "");
66
67 virtual ~G4VSceneHandler ();
68
69 ////////////////////////////////////////////
70 // Methods for adding raw GEANT4 objects to
71 // must always be called in the triplet PreA
72 // PostAddSolid. The transformation and vis
73 // must be set by the call to PreAddSolid.
74 // is sophisticated enough to handle a parti
75 // primitive, in your derived class write a
76 // or more of the following. See the implem
77 // G4VSceneHandler::AddSolid (const G4Box& b
78 // suggestions. If not, please implement th
79
80 virtual void PreAddSolid (const G4Transform3
81 const G4VisAttributes&);
82 // objectTransformation is the transformatio
83 // coordinate system of the object about to
84 // is its visualization attributes.
85 // IMPORTANT: invoke this from your polymorp
86 // void MyXXXSceneHandler::PreAddSolid
87 // (const G4Transform3D& objectTransformati
88 // const G4VisAttributes& visAttribs) {
89 // G4VSceneHandler::PreAddSolid (objectTra
90 // ...
91 // }
92
93 virtual void PostAddSolid ();
94 // IMPORTANT: invoke this from your polymorp
95 // void MyXXXSceneHandler::PostAddSolid () {
96 // ...
97 // G4VSceneHandler::PostAddSolid ();
98 // }
99
100 // From geometry/solids/CSG
101 virtual void AddSolid (const G4Box&);
102 virtual void AddSolid (const G4Cons&);
103 virtual void AddSolid (const G4Orb&);
104 virtual void AddSolid (const G4Para&);
105 virtual void AddSolid (const G4Sphere&);
106 virtual void AddSolid (const G4Torus&);
107 virtual void AddSolid (const G4Trap&);
108 virtual void AddSolid (const G4Trd&);
109 virtual void AddSolid (const G4Tubs&);
110
111 // From geometry/solids/specific
112 virtual void AddSolid (const G4Ellipsoid&);
113 virtual void AddSolid (const G4Polycone&);
114 virtual void AddSolid (const G4Polyhedra&);
115 virtual void AddSolid (const G4TessellatedSo
116
117 // For solids not above.
118 virtual void AddSolid (const G4VSolid&);
119
120 ////////////////////////////////////////////
121 // Methods for adding "compound" GEANT4 obje
122 // handler. These methods may either (a) in
123 // uses the "user interface", G4VVisManager
124 // G4VSceneHandler, which for trajectories u
125 // G4VTrajectory::DrawTrajectory, via G4Traj
126 // Modeling Category) or (b) invoke AddPrimi
127 // calls to Begin/EndPrimitives) or (c) use
128 // code or (d) any combination of the above.
129
130 virtual void AddCompound (const G4VTrajector
131 virtual void AddCompound (const G4VHit&);
132 virtual void AddCompound (const G4VDigi&);
133 virtual void AddCompound (const G4THitsMap<G
134 virtual void AddCompound (const G4THitsMap<G
135 virtual void AddCompound (const G4Mesh&);
136
137 ////////////////////////////////////////////
138 // Functions for adding primitives.
139
140 virtual void BeginModeling ();
141 // IMPORTANT: invoke this from your polymorp
142 // void MyXXXSceneHandler::BeginModeling ()
143 // G4VSceneHandler::BeginModeling ();
144 // ...
145 // }
146
147 virtual void EndModeling ();
148 // IMPORTANT: invoke this from your polymorp
149 // void MyXXXSceneHandler::EndModeling () {
150 // ...
151 // G4VSceneHandler::EndModeling ();
152 // }
153
154 virtual void BeginPrimitives
155 (const G4Transform3D& objectTransformation =
156 // IMPORTANT: invoke this from your polymorp
157 // void MyXXXSceneHandler::BeginPrimitives
158 // (const G4Transform3D& objectTransformatio
159 // G4VSceneHandler::BeginPrimitives (objec
160 // ...
161 // }
162
163 virtual void EndPrimitives ();
164 // IMPORTANT: invoke this from your polymorp
165 // void MyXXXSceneHandler::EndPrimitives ()
166 // ...
167 // G4VSceneHandler::EndPrimitives ();
168 // }
169
170 virtual void BeginPrimitives2D
171 (const G4Transform3D& objectTransformation =
172 // The x,y coordinates of the primitives pas
173 // intrepreted as screen coordinates, -1 < x
174 // z-coordinate is ignored.
175 // IMPORTANT: invoke this from your polymorp
176 // void MyXXXSceneHandler::BeginPrimitives2D
177 // (const G4Transform3D& objectTransformatio
178 // G4VSceneHandler::BeginPrimitives2D (obj
179 // ...
180 // }
181
182 virtual void EndPrimitives2D ();
183 // IMPORTANT: invoke this from your polymorp
184 // void MyXXXSceneHandler::EndPrimitives2D (
185 // ...
186 // G4VSceneHandler::EndPrimitives2D ();
187 // }
188
189 virtual void AddPrimitive (const G4Polyline&
190 virtual void AddPrimitive (const G4Text&)
191 virtual void AddPrimitive (const G4Circle&)
192 virtual void AddPrimitive (const G4Square&)
193 virtual void AddPrimitive (const G4Polymarke
194 virtual void AddPrimitive (const G4Polyhedro
195 virtual void AddPrimitive (const G4Plotter&)
196
197 // Other virtual functions
198 virtual const G4VisExtent& GetExtent() const
199
200 ////////////////////////////////////////////
201 // Access functions.
202 const G4String& GetName () con
203 G4int GetSceneHandlerId () con
204 G4int GetViewCount () con
205 G4VGraphicsSystem* GetGraphicsSystem () con
206 G4Scene* GetScene () con
207 const G4ViewerList& GetViewerList () con
208 G4VModel* GetModel () con
209 G4VViewer* GetCurrentViewer () con
210 G4bool GetMarkForClearingTransi
211 G4bool IsReadyForTransients ()
212 G4bool GetTransientsDrawnThisEv
213 G4bool GetTransientsDrawnThisRu
214 const G4Transform3D& GetObjectTransformation
215 void SetName (const
216 void SetCurrentViewer (G4VViewer*);
217 virtual void SetScene (G4Scen
218 G4ViewerList& SetViewerList (); // Non-c
219 void SetModel (G4VModel*);
220 void SetMarkForClearingTransientSto
221 // Sets flag which will cause transient stor
222 // next call to BeginPrimitives(). Maintain
223 void SetTransientsDrawnThisEvent
224 void SetTransientsDrawnThisRun
225 void SetObjectTransformation
226 // Maintained by vis manager.
227
228 ////////////////////////////////////////////
229 // Public utility functions.
230
231 const G4Colour& GetColour (); // To be depr
232 const G4Colour& GetColor ();
233 // Returns colour - checks fpVisAttribs and
234 // Assumes fpVisAttribs point to the G4VisAt
235 // If the pointer is null, the colour is obt
236 // parameters of the current viewer.
237
238 const G4Colour& GetColour (const G4Visible&)
239 const G4Colour& GetColor (const G4Visible&)
240 // Returns colour, or viewer default colour.
241 // Makes no assumptions about the validity o
242 // If the G4Visible has no vis attributes, i
243 // the colour is obtained from the default v
244 // current viewer.
245
246 const G4Colour& GetTextColour (const G4Text&
247 const G4Colour& GetTextColor (const G4Text&
248 // Returns colour of G4Text object, or defau
249
250 G4double GetLineWidth(const G4VisAttributes*
251 // Returns line width of G4VisAttributes mul
252
253 G4ViewParameters::DrawingStyle GetDrawingSty
254 // Returns drawing style from current view p
255 // has forced through the vis attributes, th
256 // current view parameter.
257
258 G4int GetNumberOfCloudPoints (const G4VisAtt
259 // Returns no of cloud points from current v
260 // has forced through the vis attributes, th
261 // current view parameter.
262
263 G4bool GetAuxEdgeVisible (const G4VisAttribu
264 // Returns auxiliary edge visibility from cu
265 // unless the user has forced through the vi
266 // over-riding the current view parameter.
267
268 G4int GetNoOfSides(const G4VisAttributes*);
269 // Returns no. of sides (lines segments per
270 // view parameters, unless the user has forc
271 // attributes, thereby over-riding the curre
272
273 G4double GetMarkerSize (const G4VMarker&, Ma
274 // Returns applicable marker size (diameter)
275 // argument). Uses global default marker if
276 // set. Multiplies by GlobalMarkerScale.
277
278 G4double GetMarkerDiameter (const G4VMarker&
279 // Alias for GetMarkerSize.
280
281 G4double GetMarkerRadius (const G4VMarker&,
282 // GetMarkerSize / 2.
283
284 G4ModelingParameters* CreateModelingParamete
285 // Only the scene handler and view know what
286 // be. For historical reasons, the GEANT4 V
287 // maintains its own Scene Data and View Par
288 // converted, when needed, to Modeling Param
289
290 void DrawEvent(const G4Event*);
291 // Checks scene's end-of-event model list an
292 // hits, etc.
293
294 void DrawEndOfRunModels();
295 // Draws end-of-run models.
296
297 ////////////////////////////////////////////
298 // Administration functions.
299
300 template <class T> void AddSolidT (const T&
301 template <class T> void AddSolidWithAuxiliar
302
303 G4int IncrementViewCount ();
304
305 virtual void ClearStore ();
306 // Clears graphics database (display lists)
307
308 virtual void ClearTransientStore ();
309 // Clears transient part of graphics databas
310
311 void AddViewerToList (G4VViewer* pView)
312 void RemoveViewerFromList (G4VViewer* pView)
313
314 protected:
315
316 ////////////////////////////////////////////
317 // Core routine for looping over models, red
318 // Overload with care (see, for example,
319 // G4OpenGLScenehandler::ProcessScene).
320 virtual void ProcessScene ();
321
322 ////////////////////////////////////////////
323 // Default routine used by default AddSolid
324 virtual void RequestPrimitives (const G4VSol
325
326 ////////////////////////////////////////////
327 // Other internal routines...
328
329 virtual G4DisplacedSolid* CreateSectionSolid
330 virtual G4DisplacedSolid* CreateCutawaySolid
331 // Generic clipping using the BooleanProcess
332 // implemented in this class. Subclasses th
333 // clipping should provide an override that
334
335 void LoadAtts(const G4Visible&, G4AttHolder*
336 // Load G4AttValues and G4AttDefs associated
337 // object onto the G4AttHolder object. It c
338 // loads the G4AttValues and G4AttDefs from
339 // G4VTrajectory, G4VTrajectoryPoint, G4VHit
340 // appropriate. The G4AttHolder object is a
341 // publicly inherits G4AttHolder - see, e.g.
342 // Open Inventor driver. G4AttHolder delete
343 // destructor to ensure proper clean-up of G
344
345 ////////////////////////////////////////////
346 // Special mesh rendering utilities...
347
348 struct NameAndVisAtts {
349 NameAndVisAtts(const G4String& name = "",c
350 : fName(name),fVisAtts(visAtts) {}
351 G4String fName;
352 G4VisAttributes fVisAtts;
353 };
354
355 class PseudoSceneFor3DRectMeshPositions: pub
356 public:
357 PseudoSceneFor3DRectMeshPositions
358 (G4PhysicalVolumeModel* pvModel // input
359 , const G4Mesh* pMesh // input...the fol
360 , std::multimap<const G4Material*,const G
361 , std::map<const G4Material*,NameAndVisAt
362 : fpPVModel(pvModel)
363 , fpMesh(pMesh)
364 , fPositionByMaterial(positionByMaterial)
365 , fNameAndVisAttsByMaterial(nameAndVisAtts
366 {}
367 private:
368 using G4PseudoScene::AddSolid; // except
369 void AddSolid(const G4Box&) override;
370 void ProcessVolume(const G4VSolid&) overri
371 // Do nothing if uninteresting solids fo
372 }
373 G4PhysicalVolumeModel* fpPVModel;
374 const G4Mesh* fpMesh;
375 std::multimap<const G4Material*,const G4Th
376 std::map<const G4Material*,NameAndVisAtts>
377 };
378
379 class PseudoSceneForTetVertices: public G4Ps
380 public:
381 PseudoSceneForTetVertices
382 (G4PhysicalVolumeModel* pvModel // input
383 , const G4Mesh* pMesh // input...the fol
384 , std::multimap<const G4Material*,std::ve
385 , std::map<const G4Material*,NameAndVisAt
386 : fpPVModel(pvModel)
387 , fpMesh(pMesh)
388 , fVerticesByMaterial(verticesByMaterial)
389 , fNameAndVisAttsByMaterial(nameAndVisAtts
390 {}
391 private:
392 using G4PseudoScene::AddSolid; // except
393 void AddSolid(const G4VSolid& solid) overr
394 void ProcessVolume(const G4VSolid&) overri
395 // Do nothing if uninteresting solids fo
396 }
397 G4PhysicalVolumeModel* fpPVModel;
398 const G4Mesh* fpMesh;
399 std::multimap<const G4Material*,std::vecto
400 std::map<const G4Material*,NameAndVisAtts>
401 };
402
403 void StandardSpecialMeshRendering(const G4Me
404 // Standard way of special mesh rendering.
405 // MySceneHandler::AddCompound(const G4Mesh&
406 // appropriate or implement its own special
407
408 void Draw3DRectMeshAsDots(const G4Mesh&);
409 // For a rectangular 3-D mesh, draw as colou
410 // one dot randomly placed in each visible m
411
412 void Draw3DRectMeshAsSurfaces(const G4Mesh&)
413 // For a rectangular 3-D mesh, draw as surfa
414 // with inner shared faces removed.
415
416 void DrawTetMeshAsDots(const G4Mesh&);
417 // For a tetrahedron mesh, draw as coloured
418 // one dot randomly placed in each visible m
419
420 void DrawTetMeshAsSurfaces(const G4Mesh&);
421 // For a tetrahedron mesh, draw as surfaces
422 // with inner shared faces removed.
423
424 G4ThreeVector GetPointInBox(const G4ThreeVec
425 G4double halfX,
426 G4double halfY,
427 G4double halfZ)
428 // Sample a random point inside the box
429
430 G4ThreeVector GetPointInTet(const std::vecto
431 // Sample a random point inside the tetrahed
432
433 ////////////////////////////////////////////
434 // Data members
435
436 G4VGraphicsSystem& fSystem; // Grap
437 const G4int fSceneHandlerId; // Id o
438 G4String fName;
439 G4int fViewCount; // To d
440 G4ViewerList fViewerList; // View
441 G4VViewer* fpViewer; // Curr
442 G4Scene* fpScene; // Scen
443 G4bool fMarkForClearingTransient
444 G4bool fReadyForTransients; //
445 // run-duration part
446 G4bool fTransientsDrawnThisEvent
447 G4bool fTransientsDrawnThisRun;
448 G4bool fProcessingSolid; // True
449 G4bool fProcessing2D; // True
450 G4VModel* fpModel; // Curr
451 G4Transform3D fObjectTransformation; // Curr
452 // object transformation.
453 G4int fNestingDepth; // For
454 const G4VisAttributes* fpVisAttribs; // Work
455 const G4Transform3D fIdentityTransformation;
456 std::map<G4VPhysicalVolume*,G4String> fProbl
457
458 private:
459
460 G4VSceneHandler (const G4VSceneHandler&);
461 G4VSceneHandler& operator = (const G4VSceneH
462 };
463
464 #include "G4VSceneHandler.icc"
465
466 #endif
467