| 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 // $Id: G4VSceneHandler.hh,v 1.37 2006/11/15 19:25:31 allison Exp $
>> 28 // GEANT4 tag $Name: geant4-08-02-patch-01 $
27 // 29 //
28 // << 30 //
29 // John Allison 19th July 1996. 31 // John Allison 19th July 1996.
30 // 32 //
31 // Class description 33 // Class description
32 // 34 //
33 // Abstract interface class for graphics scene 35 // Abstract interface class for graphics scene handlers.
34 // Inherits from G4VGraphicsScene, in the inte 36 // Inherits from G4VGraphicsScene, in the intercoms category, which is
35 // a minimal abstract interface for the GEANT4 37 // a minimal abstract interface for the GEANT4 kernel.
36 38
37 #ifndef G4VSCENEHANDLER_HH 39 #ifndef G4VSCENEHANDLER_HH
38 #define G4VSCENEHANDLER_HH 40 #define G4VSCENEHANDLER_HH
39 41
40 #include "globals.hh" 42 #include "globals.hh"
41 43
>> 44 #include <stack>
>> 45
42 #include "G4VGraphicsScene.hh" 46 #include "G4VGraphicsScene.hh"
43 #include "G4ViewerList.hh" 47 #include "G4ViewerList.hh"
44 #include "G4ViewParameters.hh" 48 #include "G4ViewParameters.hh"
45 #include "G4THitsMap.hh" <<
46 #include "G4PseudoScene.hh" <<
47 <<
48 #include <map> <<
49 49
50 class G4Scene; 50 class G4Scene;
>> 51 class G4VViewer;
>> 52 class G4Colour;
>> 53 class G4Visible;
>> 54 class G4ModelingParameters;
>> 55 class G4VModel;
51 class G4VGraphicsSystem; 56 class G4VGraphicsSystem;
52 class G4AttHolder; << 57 class G4LogicalVolume;
>> 58 class G4VPhysicalVolume;
>> 59 class G4Material;
>> 60 class G4Event;
53 61
54 class G4VSceneHandler: public G4VGraphicsScene 62 class G4VSceneHandler: public G4VGraphicsScene {
55 63
56 friend class G4VViewer; <<
57 friend std::ostream& operator << (std::ostre <<
58 <<
59 public: // With description 64 public: // With description
60 65
>> 66 friend std::ostream& operator << (std::ostream& os, const G4VSceneHandler& s);
>> 67
61 enum MarkerSizeType {world, screen}; 68 enum MarkerSizeType {world, screen};
62 69
63 G4VSceneHandler (G4VGraphicsSystem& system, 70 G4VSceneHandler (G4VGraphicsSystem& system,
64 G4int id, 71 G4int id,
65 const G4String& name = ""); 72 const G4String& name = "");
66 73
67 virtual ~G4VSceneHandler (); 74 virtual ~G4VSceneHandler ();
68 75
69 //////////////////////////////////////////// 76 ///////////////////////////////////////////////////////////////////
70 // Methods for adding raw GEANT4 objects to 77 // Methods for adding raw GEANT4 objects to the scene handler. They
71 // must always be called in the triplet PreA 78 // must always be called in the triplet PreAddSolid, AddSolid and
72 // PostAddSolid. The transformation and vis 79 // PostAddSolid. The transformation and visualization attributes
73 // must be set by the call to PreAddSolid. 80 // must be set by the call to PreAddSolid. If your graphics system
74 // is sophisticated enough to handle a parti 81 // is sophisticated enough to handle a particular solid shape as a
75 // primitive, in your derived class write a 82 // primitive, in your derived class write a function to override one
76 // or more of the following. See the implem 83 // or more of the following. See the implementation of
77 // G4VSceneHandler::AddSolid (const G4Box& b 84 // G4VSceneHandler::AddSolid (const G4Box& box) for more
78 // suggestions. If not, please implement th 85 // suggestions. If not, please implement the base class invocation.
79 86
80 virtual void PreAddSolid (const G4Transform3 87 virtual void PreAddSolid (const G4Transform3D& objectTransformation,
81 const G4VisAttributes&); << 88 const G4VisAttributes& visAttribs);
82 // objectTransformation is the transformatio 89 // objectTransformation is the transformation in the world
83 // coordinate system of the object about to 90 // coordinate system of the object about to be added, and visAttribs
84 // is its visualization attributes. 91 // is its visualization attributes.
85 // IMPORTANT: invoke this from your polymorp 92 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
86 // void MyXXXSceneHandler::PreAddSolid 93 // void MyXXXSceneHandler::PreAddSolid
87 // (const G4Transform3D& objectTransformati 94 // (const G4Transform3D& objectTransformation,
88 // const G4VisAttributes& visAttribs) { 95 // const G4VisAttributes& visAttribs) {
89 // G4VSceneHandler::PreAddSolid (objectTra 96 // G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
90 // ... 97 // ...
91 // } 98 // }
92 99
93 virtual void PostAddSolid (); 100 virtual void PostAddSolid ();
94 // IMPORTANT: invoke this from your polymorp 101 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
95 // void MyXXXSceneHandler::PostAddSolid () { 102 // void MyXXXSceneHandler::PostAddSolid () {
96 // ... 103 // ...
97 // G4VSceneHandler::PostAddSolid (); 104 // G4VSceneHandler::PostAddSolid ();
98 // } 105 // }
99 106
100 // From geometry/solids/CSG <<
101 virtual void AddSolid (const G4Box&); 107 virtual void AddSolid (const G4Box&);
102 virtual void AddSolid (const G4Cons&); 108 virtual void AddSolid (const G4Cons&);
103 virtual void AddSolid (const G4Orb&); << 109 virtual void AddSolid (const G4Tubs&);
104 virtual void AddSolid (const G4Para&); << 110 virtual void AddSolid (const G4Trd&);
>> 111 virtual void AddSolid (const G4Trap&);
105 virtual void AddSolid (const G4Sphere&); 112 virtual void AddSolid (const G4Sphere&);
>> 113 virtual void AddSolid (const G4Para&);
106 virtual void AddSolid (const G4Torus&); 114 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&); 115 virtual void AddSolid (const G4Polycone&);
114 virtual void AddSolid (const G4Polyhedra&); 116 virtual void AddSolid (const G4Polyhedra&);
115 virtual void AddSolid (const G4TessellatedSo << 117 virtual void AddSolid (const G4VSolid&); // For solids not above.
116 <<
117 // For solids not above. <<
118 virtual void AddSolid (const G4VSolid&); <<
119 118
120 //////////////////////////////////////////// 119 ///////////////////////////////////////////////////////////////////
121 // Methods for adding "compound" GEANT4 obje 120 // Methods for adding "compound" GEANT4 objects to the scene
122 // handler. These methods may either (a) in 121 // handler. These methods may either (a) invoke "user code" that
123 // uses the "user interface", G4VVisManager 122 // uses the "user interface", G4VVisManager (see, for example,
124 // G4VSceneHandler, which for trajectories u 123 // G4VSceneHandler, which for trajectories uses
125 // G4VTrajectory::DrawTrajectory, via G4Traj 124 // G4VTrajectory::DrawTrajectory, via G4TrajectoriesModel in the
126 // Modeling Category) or (b) invoke AddPrimi 125 // Modeling Category) or (b) invoke AddPrimitives below (between
127 // calls to Begin/EndPrimitives) or (c) use 126 // calls to Begin/EndPrimitives) or (c) use graphics-system-specific
128 // code or (d) any combination of the above. 127 // code or (d) any combination of the above.
129 128
130 virtual void AddCompound (const G4VTrajector 129 virtual void AddCompound (const G4VTrajectory&);
131 virtual void AddCompound (const G4VHit&); 130 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 131
137 //////////////////////////////////////////// 132 //////////////////////////////////////////////////////////////
138 // Functions for adding primitives. 133 // Functions for adding primitives.
139 134
140 virtual void BeginModeling (); 135 virtual void BeginModeling ();
141 // IMPORTANT: invoke this from your polymorp 136 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
142 // void MyXXXSceneHandler::BeginModeling () 137 // void MyXXXSceneHandler::BeginModeling () {
143 // G4VSceneHandler::BeginModeling (); 138 // G4VSceneHandler::BeginModeling ();
144 // ... 139 // ...
145 // } 140 // }
146 141
147 virtual void EndModeling (); 142 virtual void EndModeling ();
148 // IMPORTANT: invoke this from your polymorp 143 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
149 // void MyXXXSceneHandler::EndModeling () { 144 // void MyXXXSceneHandler::EndModeling () {
150 // ... 145 // ...
151 // G4VSceneHandler::EndModeling (); 146 // G4VSceneHandler::EndModeling ();
152 // } 147 // }
153 148
154 virtual void BeginPrimitives 149 virtual void BeginPrimitives
155 (const G4Transform3D& objectTransformation = << 150 (const G4Transform3D& objectTransformation);
156 // IMPORTANT: invoke this from your polymorp 151 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
157 // void MyXXXSceneHandler::BeginPrimitives 152 // void MyXXXSceneHandler::BeginPrimitives
158 // (const G4Transform3D& objectTransformatio 153 // (const G4Transform3D& objectTransformation) {
159 // G4VSceneHandler::BeginPrimitives (objec 154 // G4VSceneHandler::BeginPrimitives (objectTransformation);
160 // ... 155 // ...
161 // } 156 // }
162 157
163 virtual void EndPrimitives (); 158 virtual void EndPrimitives ();
164 // IMPORTANT: invoke this from your polymorp 159 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
165 // void MyXXXSceneHandler::EndPrimitives () 160 // void MyXXXSceneHandler::EndPrimitives () {
166 // ... 161 // ...
167 // G4VSceneHandler::EndPrimitives (); 162 // G4VSceneHandler::EndPrimitives ();
168 // } 163 // }
169 164
170 virtual void BeginPrimitives2D << 165 virtual void BeginPrimitives2D ();
171 (const G4Transform3D& objectTransformation = <<
172 // The x,y coordinates of the primitives pas 166 // The x,y coordinates of the primitives passed to AddPrimitive are
173 // intrepreted as screen coordinates, -1 < x 167 // intrepreted as screen coordinates, -1 < x,y < 1. The
174 // z-coordinate is ignored. 168 // z-coordinate is ignored.
175 // IMPORTANT: invoke this from your polymorp 169 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
176 // void MyXXXSceneHandler::BeginPrimitives2D 170 // void MyXXXSceneHandler::BeginPrimitives2D
177 // (const G4Transform3D& objectTransformatio 171 // (const G4Transform3D& objectTransformation) {
178 // G4VSceneHandler::BeginPrimitives2D (obj << 172 // G4VSceneHandler::BeginPrimitives2D ();
179 // ... 173 // ...
180 // } 174 // }
181 175
182 virtual void EndPrimitives2D (); 176 virtual void EndPrimitives2D ();
183 // IMPORTANT: invoke this from your polymorp 177 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
184 // void MyXXXSceneHandler::EndPrimitives2D ( 178 // void MyXXXSceneHandler::EndPrimitives2D () {
185 // ... 179 // ...
186 // G4VSceneHandler::EndPrimitives2D (); 180 // G4VSceneHandler::EndPrimitives2D ();
187 // } 181 // }
188 182
189 virtual void AddPrimitive (const G4Polyline& 183 virtual void AddPrimitive (const G4Polyline&) = 0;
>> 184 virtual void AddPrimitive (const G4Scale&);
>> 185 // Default implementation in this class but can be over-ridden.
190 virtual void AddPrimitive (const G4Text&) 186 virtual void AddPrimitive (const G4Text&) = 0;
191 virtual void AddPrimitive (const G4Circle&) 187 virtual void AddPrimitive (const G4Circle&) = 0;
192 virtual void AddPrimitive (const G4Square&) 188 virtual void AddPrimitive (const G4Square&) = 0;
193 virtual void AddPrimitive (const G4Polymarke 189 virtual void AddPrimitive (const G4Polymarker&);
194 virtual void AddPrimitive (const G4Polyhedro << 190 // Default implementation in this class but can be over-ridden.
195 virtual void AddPrimitive (const G4Plotter&) << 191 virtual void AddPrimitive (const G4Polyhedron&) = 0;
196 << 192 virtual void AddPrimitive (const G4NURBS&) = 0;
197 // Other virtual functions <<
198 virtual const G4VisExtent& GetExtent() const <<
199 193
200 //////////////////////////////////////////// 194 //////////////////////////////////////////////////////////////
201 // Access functions. 195 // Access functions.
202 const G4String& GetName () con 196 const G4String& GetName () const;
203 G4int GetSceneHandlerId () con 197 G4int GetSceneHandlerId () const;
204 G4int GetViewCount () con 198 G4int GetViewCount () const;
205 G4VGraphicsSystem* GetGraphicsSystem () con 199 G4VGraphicsSystem* GetGraphicsSystem () const;
206 G4Scene* GetScene () con 200 G4Scene* GetScene () const;
207 const G4ViewerList& GetViewerList () con 201 const G4ViewerList& GetViewerList () const;
208 G4VModel* GetModel () con 202 G4VModel* GetModel () const;
209 G4VViewer* GetCurrentViewer () con 203 G4VViewer* GetCurrentViewer () const;
210 G4bool GetMarkForClearingTransi 204 G4bool GetMarkForClearingTransientStore () const;
211 G4bool IsReadyForTransients () 205 G4bool IsReadyForTransients () const;
212 G4bool GetTransientsDrawnThisEv 206 G4bool GetTransientsDrawnThisEvent () const;
213 G4bool GetTransientsDrawnThisRu 207 G4bool GetTransientsDrawnThisRun () const;
214 const G4Transform3D& GetObjectTransformation << 208 void SetName (const G4String&);
215 void SetName (const <<
216 void SetCurrentViewer (G4VViewer*); 209 void SetCurrentViewer (G4VViewer*);
217 virtual void SetScene (G4Scen << 210 void SetScene (G4Scene*);
218 G4ViewerList& SetViewerList (); // Non-c 211 G4ViewerList& SetViewerList (); // Non-const so you can change.
219 void SetModel (G4VModel*); 212 void SetModel (G4VModel*);
220 void SetMarkForClearingTransientSto 213 void SetMarkForClearingTransientStore (G4bool);
221 // Sets flag which will cause transient stor 214 // Sets flag which will cause transient store to be cleared at the
222 // next call to BeginPrimitives(). Maintain 215 // next call to BeginPrimitives(). Maintained by vis manager.
223 void SetTransientsDrawnThisEvent 216 void SetTransientsDrawnThisEvent (G4bool);
224 void SetTransientsDrawnThisRun 217 void SetTransientsDrawnThisRun (G4bool);
225 void SetObjectTransformation <<
226 // Maintained by vis manager. 218 // Maintained by vis manager.
>> 219 void SetEvent (const G4Event*);
>> 220 // If non-zero, this event is used in ProcessScene. Otherwise, the
>> 221 // current event, or last event(s) are used. The user must
>> 222 // SetEvent(0) when finished.
227 223
228 //////////////////////////////////////////// 224 //////////////////////////////////////////////////////////////
229 // Public utility functions. 225 // Public utility functions.
230 226
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&) 227 const G4Colour& GetColour (const G4Visible&);
239 const G4Colour& GetColor (const G4Visible&) 228 const G4Colour& GetColor (const G4Visible&);
240 // Returns colour, or viewer default colour. << 229 // Returns colour of G4Visible object, or default global 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 230
246 const G4Colour& GetTextColour (const G4Text& 231 const G4Colour& GetTextColour (const G4Text&);
247 const G4Colour& GetTextColor (const G4Text& 232 const G4Colour& GetTextColor (const G4Text&);
248 // Returns colour of G4Text object, or defau 233 // Returns colour of G4Text object, or default text colour.
249 234
250 G4double GetLineWidth(const G4VisAttributes* << 235 G4double GetLineWidth(const G4Visible& visible);
251 // Returns line width of G4VisAttributes mul << 236 // Returns line width of G4Visible object, or default line width.
>> 237 // Multiplies by GlobalLineWidthScale.
252 238
253 G4ViewParameters::DrawingStyle GetDrawingSty 239 G4ViewParameters::DrawingStyle GetDrawingStyle (const G4VisAttributes*);
254 // Returns drawing style from current view p 240 // Returns drawing style from current view parameters, unless the user
255 // has forced through the vis attributes, th 241 // has forced through the vis attributes, thereby over-riding the
256 // current view parameter. 242 // current view parameter.
257 243
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 244 G4bool GetAuxEdgeVisible (const G4VisAttributes*);
264 // Returns auxiliary edge visibility from cu 245 // Returns auxiliary edge visibility from current view parameters,
265 // unless the user has forced through the vi 246 // unless the user has forced through the vis attributes, thereby
266 // over-riding the current view parameter. 247 // over-riding the current view parameter.
267 248
268 G4int GetNoOfSides(const G4VisAttributes*); << 249 G4int GetNoOfSides(const G4VisAttributes* pVisAttribs);
269 // Returns no. of sides (lines segments per 250 // Returns no. of sides (lines segments per circle) from current
270 // view parameters, unless the user has forc 251 // view parameters, unless the user has forced through the vis
271 // attributes, thereby over-riding the curre 252 // attributes, thereby over-riding the current view parameter.
272 253
273 G4double GetMarkerSize (const G4VMarker&, Ma 254 G4double GetMarkerSize (const G4VMarker&, MarkerSizeType&);
274 // Returns applicable marker size (diameter) 255 // Returns applicable marker size (diameter) and type (in second
275 // argument). Uses global default marker if 256 // argument). Uses global default marker if marker sizes are not
276 // set. Multiplies by GlobalMarkerScale. 257 // set. Multiplies by GlobalMarkerScale.
277 258
278 G4double GetMarkerDiameter (const G4VMarker& 259 G4double GetMarkerDiameter (const G4VMarker&, MarkerSizeType&);
279 // Alias for GetMarkerSize. 260 // Alias for GetMarkerSize.
280 261
281 G4double GetMarkerRadius (const G4VMarker&, 262 G4double GetMarkerRadius (const G4VMarker&, MarkerSizeType&);
282 // GetMarkerSize / 2. 263 // GetMarkerSize / 2.
283 264
284 G4ModelingParameters* CreateModelingParamete 265 G4ModelingParameters* CreateModelingParameters ();
285 // Only the scene handler and view know what 266 // Only the scene handler and view know what the Modeling Parameters should
286 // be. For historical reasons, the GEANT4 V 267 // be. For historical reasons, the GEANT4 Visualization Environment
287 // maintains its own Scene Data and View Par 268 // maintains its own Scene Data and View Parameters, which must be
288 // converted, when needed, to Modeling Param 269 // converted, when needed, to Modeling Parameters.
289 270
290 void DrawEvent(const G4Event*); 271 void DrawEvent(const G4Event*);
291 // Checks scene's end-of-event model list an 272 // Checks scene's end-of-event model list and draws trajectories,
292 // hits, etc. 273 // hits, etc.
293 274
294 void DrawEndOfRunModels(); <<
295 // Draws end-of-run models. <<
296 <<
297 //////////////////////////////////////////// 275 //////////////////////////////////////////////////////////////
298 // Administration functions. 276 // Administration functions.
299 277
300 template <class T> void AddSolidT (const T& <<
301 template <class T> void AddSolidWithAuxiliar <<
302 <<
303 G4int IncrementViewCount (); 278 G4int IncrementViewCount ();
304 279
305 virtual void ClearStore (); 280 virtual void ClearStore ();
306 // Clears graphics database (display lists) << 281 // Clears graphics database (display lists) if any. This base class
>> 282 // implements some common functionality so...
>> 283 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
>> 284 // void MyXXXSceneHandler::ClearStore () {
>> 285 // G4VSceneHandler::ClearStore ();
>> 286 // ...
>> 287 // }
307 288
308 virtual void ClearTransientStore (); 289 virtual void ClearTransientStore ();
309 // Clears transient part of graphics databas 290 // Clears transient part of graphics database (display lists) if any.
>> 291 // This base class implements some common functionality so...
>> 292 // IMPORTANT: invoke this from your polymorphic versions, e.g.:
>> 293 // void MyXXXSceneHandler::ClearTransientStore () {
>> 294 // G4VSceneHandler::ClearTransientStore ();
>> 295 // ...
>> 296 // }
310 297
311 void AddViewerToList (G4VViewer* pView) 298 void AddViewerToList (G4VViewer* pView); // Add view to view List.
312 void RemoveViewerFromList (G4VViewer* pView) 299 void RemoveViewerFromList (G4VViewer* pView); // Remove view from view List.
313 300
314 protected: 301 protected:
315 302
316 //////////////////////////////////////////// 303 //////////////////////////////////////////////////////////////
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 304 // Default routine used by default AddSolid ().
>> 305
324 virtual void RequestPrimitives (const G4VSol 306 virtual void RequestPrimitives (const G4VSolid& solid);
325 307
326 //////////////////////////////////////////// 308 //////////////////////////////////////////////////////////////
327 // Other internal routines... 309 // Other internal routines...
328 310
329 virtual G4DisplacedSolid* CreateSectionSolid << 311 virtual const G4Polyhedron* CreateSectionPolyhedron ();
330 virtual G4DisplacedSolid* CreateCutawaySolid << 312 virtual const G4Polyhedron* CreateCutawayPolyhedron ();
331 // Generic clipping using the BooleanProcess 313 // Generic clipping using the BooleanProcessor in graphics_reps is
332 // implemented in this class. Subclasses th 314 // implemented in this class. Subclasses that implement their own
333 // clipping should provide an override that 315 // clipping should provide an override that returns zero.
334 316
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 //////////////////////////////////////////// 317 //////////////////////////////////////////////////////////////
434 // Data members 318 // Data members
435 319
436 G4VGraphicsSystem& fSystem; // Grap 320 G4VGraphicsSystem& fSystem; // Graphics system.
437 const G4int fSceneHandlerId; // Id o 321 const G4int fSceneHandlerId; // Id of this instance.
438 G4String fName; 322 G4String fName;
439 G4int fViewCount; // To d 323 G4int fViewCount; // To determine view ids.
440 G4ViewerList fViewerList; // View 324 G4ViewerList fViewerList; // Viewers.
441 G4VViewer* fpViewer; // Curr 325 G4VViewer* fpViewer; // Current viewer.
442 G4Scene* fpScene; // Scen 326 G4Scene* fpScene; // Scene for this scene handler.
443 G4bool fMarkForClearingTransient 327 G4bool fMarkForClearingTransientStore;
444 G4bool fReadyForTransients; // 328 G4bool fReadyForTransients; // I.e., not processing the
445 // run-duration part 329 // run-duration part of scene.
446 G4bool fTransientsDrawnThisEvent 330 G4bool fTransientsDrawnThisEvent; // Maintained by vis
447 G4bool fTransientsDrawnThisRun; 331 G4bool fTransientsDrawnThisRun; // manager.
448 G4bool fProcessingSolid; // True 332 G4bool fProcessingSolid; // True if within Pre/PostAddSolid.
449 G4bool fProcessing2D; // True << 333 G4bool fSecondPassRequested;
450 G4VModel* fpModel; // Curr << 334 G4bool fSecondPass; // ...in process.
451 G4Transform3D fObjectTransformation; // Curr << 335 G4VModel* fpModel; // Current model.
452 // object transformation. << 336 const G4Transform3D* fpObjectTransformation; // Current accumulated
453 G4int fNestingDepth; // For << 337 // object transformation.
454 const G4VisAttributes* fpVisAttribs; // Work << 338 G4int fNestingDepth; // For Begin/EndPrimitives.
>> 339 const G4VisAttributes* fpVisAttribs; // Working vis attributes.
>> 340 const G4Event* fRequestedEvent; // If non-zero, use this event.
455 const G4Transform3D fIdentityTransformation; 341 const G4Transform3D fIdentityTransformation;
456 std::map<G4VPhysicalVolume*,G4String> fProbl <<
457 342
458 private: 343 private:
459 344
460 G4VSceneHandler (const G4VSceneHandler&); 345 G4VSceneHandler (const G4VSceneHandler&);
461 G4VSceneHandler& operator = (const G4VSceneH 346 G4VSceneHandler& operator = (const G4VSceneHandler&);
>> 347
>> 348 //////////////////////////////////////////////////////////////
>> 349 // Friend function accessed only by views of this scene.
>> 350
>> 351 friend void G4VViewer::ProcessView ();
>> 352
>> 353 //////////////////////////////////////////////////////////////
>> 354 // Private functions, etc..
>> 355
>> 356 void ProcessScene (G4VViewer& view);
>> 357 // Accessed by G4VViewer::ProcessView ().
>> 358
462 }; 359 };
463 360
464 #include "G4VSceneHandler.icc" 361 #include "G4VSceneHandler.icc"
465 362
466 #endif 363 #endif
467 364