Geant4  10.02
G4VSceneHandler.hh
Go to the documentation of this file.
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 // $Id: G4VSceneHandler.hh 73126 2013-08-19 08:01:37Z gcosmo $
28 //
29 //
30 // John Allison 19th July 1996.
31 //
32 // Class description
33 //
34 // Abstract interface class for graphics scene handlers.
35 // Inherits from G4VGraphicsScene, in the intercoms category, which is
36 // a minimal abstract interface for the GEANT4 kernel.
37 
38 #ifndef G4VSCENEHANDLER_HH
39 #define G4VSCENEHANDLER_HH
40 
41 #include "globals.hh"
42 
43 #include "G4VGraphicsScene.hh"
44 #include "G4ViewerList.hh"
45 #include "G4ViewParameters.hh"
46 #include "G4THitsMap.hh"
47 
48 class G4Scene;
49 class G4VViewer;
50 class G4Colour;
51 class G4Visible;
53 class G4VModel;
54 class G4VGraphicsSystem;
55 class G4LogicalVolume;
56 class G4VPhysicalVolume;
57 class G4Material;
58 class G4Event;
59 class G4AttHolder;
60 
62 
63  friend class G4VViewer;
64  friend std::ostream& operator << (std::ostream& os, const G4VSceneHandler& s);
65 
66 public: // With description
67 
69 
71  G4int id,
72  const G4String& name = "");
73 
74  virtual ~G4VSceneHandler ();
75 
77  // Methods for adding raw GEANT4 objects to the scene handler. They
78  // must always be called in the triplet PreAddSolid, AddSolid and
79  // PostAddSolid. The transformation and visualization attributes
80  // must be set by the call to PreAddSolid. If your graphics system
81  // is sophisticated enough to handle a particular solid shape as a
82  // primitive, in your derived class write a function to override one
83  // or more of the following. See the implementation of
84  // G4VSceneHandler::AddSolid (const G4Box& box) for more
85  // suggestions. If not, please implement the base class invocation.
86 
87  virtual void PreAddSolid (const G4Transform3D& objectTransformation,
88  const G4VisAttributes&);
89  // objectTransformation is the transformation in the world
90  // coordinate system of the object about to be added, and visAttribs
91  // is its visualization attributes.
92  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
93  // void MyXXXSceneHandler::PreAddSolid
94  // (const G4Transform3D& objectTransformation,
95  // const G4VisAttributes& visAttribs) {
96  // G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
97  // ...
98  // }
99 
100  virtual void PostAddSolid ();
101  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
102  // void MyXXXSceneHandler::PostAddSolid () {
103  // ...
104  // G4VSceneHandler::PostAddSolid ();
105  // }
106 
107  virtual void AddSolid (const G4Box&);
108  virtual void AddSolid (const G4Cons&);
109  virtual void AddSolid (const G4Tubs&);
110  virtual void AddSolid (const G4Trd&);
111  virtual void AddSolid (const G4Trap&);
112  virtual void AddSolid (const G4Sphere&);
113  virtual void AddSolid (const G4Para&);
114  virtual void AddSolid (const G4Torus&);
115  virtual void AddSolid (const G4Polycone&);
116  virtual void AddSolid (const G4Polyhedra&);
117  virtual void AddSolid (const G4VSolid&); // For solids not above.
118 
120  // Methods for adding "compound" GEANT4 objects to the scene
121  // handler. These methods may either (a) invoke "user code" that
122  // uses the "user interface", G4VVisManager (see, for example,
123  // G4VSceneHandler, which for trajectories uses
124  // G4VTrajectory::DrawTrajectory, via G4TrajectoriesModel in the
125  // Modeling Category) or (b) invoke AddPrimitives below (between
126  // calls to Begin/EndPrimitives) or (c) use graphics-system-specific
127  // code or (d) any combination of the above.
128 
129  virtual void AddCompound (const G4VTrajectory&);
130  virtual void AddCompound (const G4VHit&);
131  virtual void AddCompound (const G4VDigi&);
132  virtual void AddCompound (const G4THitsMap<G4double>&);
133 
135  // Functions for adding primitives.
136 
137  virtual void BeginModeling ();
138  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
139  // void MyXXXSceneHandler::BeginModeling () {
140  // G4VSceneHandler::BeginModeling ();
141  // ...
142  // }
143 
144  virtual void EndModeling ();
145  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
146  // void MyXXXSceneHandler::EndModeling () {
147  // ...
148  // G4VSceneHandler::EndModeling ();
149  // }
150 
151  virtual void BeginPrimitives
152  (const G4Transform3D& objectTransformation);
153  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
154  // void MyXXXSceneHandler::BeginPrimitives
155  // (const G4Transform3D& objectTransformation) {
156  // G4VSceneHandler::BeginPrimitives (objectTransformation);
157  // ...
158  // }
159 
160  virtual void EndPrimitives ();
161  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
162  // void MyXXXSceneHandler::EndPrimitives () {
163  // ...
164  // G4VSceneHandler::EndPrimitives ();
165  // }
166 
167  virtual void BeginPrimitives2D
168  (const G4Transform3D& objectTransformation);
169  // The x,y coordinates of the primitives passed to AddPrimitive are
170  // intrepreted as screen coordinates, -1 < x,y < 1. The
171  // z-coordinate is ignored.
172  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
173  // void MyXXXSceneHandler::BeginPrimitives2D
174  // (const G4Transform3D& objectTransformation) {
175  // G4VSceneHandler::BeginPrimitives2D ();
176  // ...
177  // }
178 
179  virtual void EndPrimitives2D ();
180  // IMPORTANT: invoke this from your polymorphic versions, e.g.:
181  // void MyXXXSceneHandler::EndPrimitives2D () {
182  // ...
183  // G4VSceneHandler::EndPrimitives2D ();
184  // }
185 
186  virtual void AddPrimitive (const G4Polyline&) = 0;
187  virtual void AddPrimitive (const G4Scale&);
188  // Default implementation in this class but can be over-ridden.
189  virtual void AddPrimitive (const G4Text&) = 0;
190  virtual void AddPrimitive (const G4Circle&) = 0;
191  virtual void AddPrimitive (const G4Square&) = 0;
192  virtual void AddPrimitive (const G4Polymarker&);
193  // Default implementation in this class but can be over-ridden.
194  virtual void AddPrimitive (const G4Polyhedron&) = 0;
195 
196  virtual const G4VisExtent& GetExtent() const;
197 
199  // Access functions.
200  const G4String& GetName () const;
201  G4int GetSceneHandlerId () const;
202  G4int GetViewCount () const;
204  G4Scene* GetScene () const;
205  const G4ViewerList& GetViewerList () const;
206  G4VModel* GetModel () const;
207  G4VViewer* GetCurrentViewer () const;
209  G4bool IsReadyForTransients () const;
212  const G4Transform3D& GetObjectTransformation () const;
213  void SetName (const G4String&);
214  void SetCurrentViewer (G4VViewer*);
215  virtual void SetScene (G4Scene*);
216  G4ViewerList& SetViewerList (); // Non-const so you can change.
217  void SetModel (G4VModel*);
219  // Sets flag which will cause transient store to be cleared at the
220  // next call to BeginPrimitives(). Maintained by vis manager.
224  // Maintained by vis manager.
225 
227  // Public utility functions.
228 
229  const G4Colour& GetColour (const G4Visible&);
230  const G4Colour& GetColor (const G4Visible&);
231  // Returns colour of G4Visible object, or default global colour.
232 
233  const G4Colour& GetTextColour (const G4Text&);
234  const G4Colour& GetTextColor (const G4Text&);
235  // Returns colour of G4Text object, or default text colour.
236 
238  // Returns line width of G4VisAttributes multiplied by GlobalLineWidthScale.
239 
241  // Returns drawing style from current view parameters, unless the user
242  // has forced through the vis attributes, thereby over-riding the
243  // current view parameter.
244 
246  // Returns auxiliary edge visibility from current view parameters,
247  // unless the user has forced through the vis attributes, thereby
248  // over-riding the current view parameter.
249 
251  // Returns no. of sides (lines segments per circle) from current
252  // view parameters, unless the user has forced through the vis
253  // attributes, thereby over-riding the current view parameter.
254 
256  // Returns applicable marker size (diameter) and type (in second
257  // argument). Uses global default marker if marker sizes are not
258  // set. Multiplies by GlobalMarkerScale.
259 
261  // Alias for GetMarkerSize.
262 
264  // GetMarkerSize / 2.
265 
267  // Only the scene handler and view know what the Modeling Parameters should
268  // be. For historical reasons, the GEANT4 Visualization Environment
269  // maintains its own Scene Data and View Parameters, which must be
270  // converted, when needed, to Modeling Parameters.
271 
272  void DrawEvent(const G4Event*);
273  // Checks scene's end-of-event model list and draws trajectories,
274  // hits, etc.
275 
276  void DrawEndOfRunModels();
277  // Draws end-of-run models.
278 
280  // Administration functions.
281 
283 
284  virtual void ClearStore ();
285  // Clears graphics database (display lists) if any.
286 
287  virtual void ClearTransientStore ();
288  // Clears transient part of graphics database (display lists) if any.
289 
290  void AddViewerToList (G4VViewer* pView); // Add view to view List.
291  void RemoveViewerFromList (G4VViewer* pView); // Remove view from view List.
292 
293 protected:
294 
296  // Core routine for looping over models, redrawing stored events, etc.
297  // Overload with care (see, for example,
298  // G4OpenGLScenehandler::ProcessScene).
299  virtual void ProcessScene ();
300 
302  // Default routine used by default AddSolid ().
303  virtual void RequestPrimitives (const G4VSolid& solid);
304 
306  // Other internal routines...
307 
308  virtual G4VSolid* CreateSectionSolid ();
309  virtual G4VSolid* CreateCutawaySolid ();
310  // Generic clipping using the BooleanProcessor in graphics_reps is
311  // implemented in this class. Subclasses that implement their own
312  // clipping should provide an override that returns zero.
313 
314  void LoadAtts(const G4Visible&, G4AttHolder*);
315  // Load G4AttValues and G4AttDefs associated with the G4Visible
316  // object onto the G4AttHolder object. It checks fpModel, and also
317  // loads the G4AttValues and G4AttDefs from G4PhysicalVolumeModel,
318  // G4VTrajectory, G4VTrajectoryPoint, G4VHit or G4VDigi, as
319  // appropriate. The G4AttHolder object is an object of a class that
320  // publicly inherits G4AttHolder - see, e.g., SoG4Polyhedron in the
321  // Open Inventor driver. G4AttHolder deletes G4AttValues in its
322  // destructor to ensure proper clean-up of G4AttValues.
323 
325  // Data members
326 
327  G4VGraphicsSystem& fSystem; // Graphics system.
328  const G4int fSceneHandlerId; // Id of this instance.
330  G4int fViewCount; // To determine view ids.
332  G4VViewer* fpViewer; // Current viewer.
333  G4Scene* fpScene; // Scene for this scene handler.
335  G4bool fReadyForTransients; // I.e., not processing the
336  // run-duration part of scene.
337  G4bool fTransientsDrawnThisEvent; // Maintained by vis
339  G4bool fProcessingSolid; // True if within Pre/PostAddSolid.
340  G4bool fProcessing2D; // True for 2D.
341  G4VModel* fpModel; // Current model.
342  G4Transform3D fObjectTransformation; // Current accumulated
343  // object transformation.
344  G4int fNestingDepth; // For Begin/EndPrimitives.
345  const G4VisAttributes* fpVisAttribs; // Working vis attributes.
347 
348 private:
349 
352 };
353 
354 #include "G4VSceneHandler.icc"
355 
356 #endif
const G4Colour & GetColor(const G4Visible &)
G4VModel * GetModel() const
virtual void ClearStore()
virtual ~G4VSceneHandler()
Definition: G4Para.hh:77
virtual void AddSolid(const G4Box &)
Definition: G4Text.hh:73
virtual G4VSolid * CreateSectionSolid()
G4double GetMarkerDiameter(const G4VMarker &, MarkerSizeType &)
virtual void BeginModeling()
G4ModelingParameters * CreateModelingParameters()
virtual void BeginPrimitives(const G4Transform3D &objectTransformation)
G4ViewerList & SetViewerList()
G4int GetViewCount() const
G4bool IsReadyForTransients() const
void LoadAtts(const G4Visible &, G4AttHolder *)
Definition: G4Box.hh:64
G4VViewer * fpViewer
G4String name
Definition: TRTMaterials.hh:40
G4VViewer * GetCurrentViewer() const
Definition: G4Tubs.hh:85
G4int IncrementViewCount()
void RemoveViewerFromList(G4VViewer *pView)
virtual void PostAddSolid()
const G4String & GetName() const
G4Transform3D fObjectTransformation
Definition: G4VHit.hh:48
Definition: G4Trd.hh:72
G4int GetNoOfSides(const G4VisAttributes *)
G4bool GetMarkForClearingTransientStore() const
virtual const G4VisExtent & GetExtent() const
int G4int
Definition: G4Types.hh:78
virtual void AddPrimitive(const G4Polyline &)=0
virtual G4VSolid * CreateCutawaySolid()
G4VSceneHandler(G4VGraphicsSystem &system, G4int id, const G4String &name="")
const G4Transform3D & GetObjectTransformation() const
const G4ViewerList & GetViewerList() const
static const double s
Definition: G4SIunits.hh:168
void SetTransientsDrawnThisEvent(G4bool)
G4double GetLineWidth(const G4VisAttributes *)
const G4int fSceneHandlerId
void AddViewerToList(G4VViewer *pView)
bool G4bool
Definition: G4Types.hh:79
friend std::ostream & operator<<(std::ostream &os, const G4VSceneHandler &s)
const G4Transform3D fIdentityTransformation
Definition: G4Cons.hh:83
void SetName(const G4String &)
G4bool GetTransientsDrawnThisRun() const
G4double GetMarkerRadius(const G4VMarker &, MarkerSizeType &)
G4ViewerList fViewerList
virtual void EndModeling()
G4VGraphicsSystem * GetGraphicsSystem() const
virtual void EndPrimitives()
HepGeom::Transform3D G4Transform3D
G4bool GetTransientsDrawnThisEvent() const
void SetObjectTransformation(const G4Transform3D &)
virtual void BeginPrimitives2D(const G4Transform3D &objectTransformation)
virtual void SetScene(G4Scene *)
const G4VisAttributes * fpVisAttribs
G4Scene * GetScene() const
G4bool fMarkForClearingTransientStore
virtual void AddCompound(const G4VTrajectory &)
void DrawEvent(const G4Event *)
virtual void ProcessScene()
G4bool fTransientsDrawnThisEvent
const G4Colour & GetTextColor(const G4Text &)
G4ViewParameters::DrawingStyle GetDrawingStyle(const G4VisAttributes *)
G4double GetMarkerSize(const G4VMarker &, MarkerSizeType &)
G4bool GetAuxEdgeVisible(const G4VisAttributes *)
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)
const G4Colour & GetColour(const G4Visible &)
virtual void RequestPrimitives(const G4VSolid &solid)
void SetModel(G4VModel *)
double G4double
Definition: G4Types.hh:76
virtual void ClearTransientStore()
G4bool fTransientsDrawnThisRun
void SetTransientsDrawnThisRun(G4bool)
G4int GetSceneHandlerId() const
G4VGraphicsSystem & fSystem
G4VSceneHandler & operator=(const G4VSceneHandler &)
void SetCurrentViewer(G4VViewer *)
void SetMarkForClearingTransientStore(G4bool)
virtual void EndPrimitives2D()
const G4Colour & GetTextColour(const G4Text &)