Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/include/G4VSceneHandler.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/management/include/G4VSceneHandler.hh (Version 11.3.0) and /visualization/management/include/G4VSceneHandler.hh (Version 10.4.p3)


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