EIC code displayed by LXR master/​include/​Geant4/​G4VSceneHandler.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-09-18 09:16:08

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 //
 //
 //
 // John Allison  19th July 1996.
 //
 // Class description
 //
 // Abstract interface class for graphics scene handlers.
 // Inherits from G4VGraphicsScene, in the intercoms category, which is
 // a minimal abstract interface for the GEANT4 kernel.
 
 #ifndef G4VSCENEHANDLER_HH
 #define G4VSCENEHANDLER_HH
 
 #include "globals.hh"
 
 #include "G4VGraphicsScene.hh"
 #include "G4ViewerList.hh"
 #include "G4ViewParameters.hh"
 #include "G4THitsMap.hh"
 #include "G4PseudoScene.hh"
 
 #include <map>
 
 class G4Scene;
 class G4VGraphicsSystem;
 class G4AttHolder;
 
 class G4VSceneHandler: public G4VGraphicsScene {
 
   friend class G4VViewer;
   friend std::ostream& operator << (std::ostream& os, const G4VSceneHandler& s);
 
 public: // With description
 
   enum MarkerSizeType {world, screen};
 
   G4VSceneHandler (G4VGraphicsSystem& system,
            G4int id,
            const G4String& name = "");
 
   virtual ~G4VSceneHandler ();
 
   ///////////////////////////////////////////////////////////////////
   // Methods for adding raw GEANT4 objects to the scene handler.  They
   // must always be called in the triplet PreAddSolid, AddSolid and
   // PostAddSolid.  The transformation and visualization attributes
   // must be set by the call to PreAddSolid.  If your graphics system
   // is sophisticated enough to handle a particular solid shape as a
   // primitive, in your derived class write a function to override one
   // or more of the following.  See the implementation of
   // G4VSceneHandler::AddSolid (const G4Box& box) for more
   // suggestions.  If not, please implement the base class invocation.
 
   virtual void PreAddSolid (const G4Transform3D& objectTransformation,
                 const G4VisAttributes&);
   // objectTransformation is the transformation in the world
   // coordinate system of the object about to be added, and visAttribs
   // is its visualization attributes.
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::PreAddSolid
   //  (const G4Transform3D& objectTransformation,
   //   const G4VisAttributes& visAttribs) {
   //   G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
   //   ...
   // }
 
   virtual void PostAddSolid ();
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::PostAddSolid () {
   //   ...
   //   G4VSceneHandler::PostAddSolid ();
   // }
 
   // From geometry/solids/CSG
   virtual void AddSolid (const G4Box&);
   virtual void AddSolid (const G4Cons&);
   virtual void AddSolid (const G4Orb&);
   virtual void AddSolid (const G4Para&);
   virtual void AddSolid (const G4Sphere&);
   virtual void AddSolid (const G4Torus&);
   virtual void AddSolid (const G4Trap&);
   virtual void AddSolid (const G4Trd&);
   virtual void AddSolid (const G4Tubs&);
 
   // From geometry/solids/specific
   virtual void AddSolid (const G4Ellipsoid&);
   virtual void AddSolid (const G4Polycone&);
   virtual void AddSolid (const G4Polyhedra&);
   virtual void AddSolid (const G4TessellatedSolid&);
 
   // For solids not above.
   virtual void AddSolid (const G4VSolid&);
 
   ///////////////////////////////////////////////////////////////////
   // Methods for adding "compound" GEANT4 objects to the scene
   // handler.  These methods may either (a) invoke "user code" that
   // uses the "user interface", G4VVisManager (see, for example,
   // G4VSceneHandler, which for trajectories uses
   // G4VTrajectory::DrawTrajectory, via G4TrajectoriesModel in the
   // Modeling Category) or (b) invoke AddPrimitives below (between
   // calls to Begin/EndPrimitives) or (c) use graphics-system-specific
   // code or (d) any combination of the above.
 
   virtual void AddCompound (const G4VTrajectory&);
   virtual void AddCompound (const G4VHit&);
   virtual void AddCompound (const G4VDigi&);
   virtual void AddCompound (const G4THitsMap<G4double>&);
   virtual void AddCompound (const G4THitsMap<G4StatDouble>&);
   virtual void AddCompound (const G4Mesh&);
 
   //////////////////////////////////////////////////////////////
   // Functions for adding primitives.
 
   virtual void BeginModeling ();
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::BeginModeling () {
   //   G4VSceneHandler::BeginModeling ();
   //   ...
   // }
 
   virtual void EndModeling ();
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::EndModeling () {
   //   ...
   //   G4VSceneHandler::EndModeling ();
   // }
 
   virtual void BeginPrimitives
   (const G4Transform3D& objectTransformation = G4Transform3D());
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::BeginPrimitives
   // (const G4Transform3D& objectTransformation) {
   //   G4VSceneHandler::BeginPrimitives (objectTransformation);
   //   ...
   // }
 
   virtual void EndPrimitives ();
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::EndPrimitives () {
   //   ...
   //   G4VSceneHandler::EndPrimitives ();
   // }
 
   virtual void BeginPrimitives2D
   (const G4Transform3D& objectTransformation = G4Transform3D());
   // The x,y coordinates of the primitives passed to AddPrimitive are
   // intrepreted as screen coordinates, -1 < x,y < 1.  The
   // z-coordinate is ignored.
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::BeginPrimitives2D
   // (const G4Transform3D& objectTransformation) {
   //   G4VSceneHandler::BeginPrimitives2D (objectTransformation);
   //   ...
   // }
 
   virtual void EndPrimitives2D ();
   // IMPORTANT: invoke this from your polymorphic versions, e.g.:
   // void MyXXXSceneHandler::EndPrimitives2D () {
   //   ...
   //   G4VSceneHandler::EndPrimitives2D ();
   // }
 
   virtual void AddPrimitive (const G4Polyline&)   = 0;
   virtual void AddPrimitive (const G4Text&)       = 0;
   virtual void AddPrimitive (const G4Circle&)     = 0;      
   virtual void AddPrimitive (const G4Square&)     = 0;      
   virtual void AddPrimitive (const G4Polymarker&);
   virtual void AddPrimitive (const G4Polyhedron&) = 0;
   virtual void AddPrimitive (const G4Plotter&);
   
   // Other virtual functions
   virtual const G4VisExtent& GetExtent() const;
 
   //////////////////////////////////////////////////////////////
   // Access functions.
   const G4String&     GetName           () const;
   G4int               GetSceneHandlerId () const;
   G4int               GetViewCount      () const;
   G4VGraphicsSystem*  GetGraphicsSystem () const;
   G4Scene*            GetScene          () const;
   const G4ViewerList& GetViewerList     () const;
   G4VModel*           GetModel          () const;
   G4VViewer*          GetCurrentViewer  () const;
   G4bool              GetMarkForClearingTransientStore () const;
   G4bool              IsReadyForTransients () const;
   G4bool              GetTransientsDrawnThisEvent () const;
   G4bool              GetTransientsDrawnThisRun   () const;
   const G4Transform3D& GetObjectTransformation    () const;
   void                SetName          (const G4String&);
   void          SetCurrentViewer (G4VViewer*);
   virtual void        SetScene         (G4Scene*);
   G4ViewerList& SetViewerList    ();  // Non-const so you can change.
   void          SetModel         (G4VModel*);
   void          SetMarkForClearingTransientStore (G4bool);
   // Sets flag which will cause transient store to be cleared at the
   // next call to BeginPrimitives().  Maintained by vis manager.
   void          SetTransientsDrawnThisEvent      (G4bool);
   void          SetTransientsDrawnThisRun        (G4bool);
   void          SetObjectTransformation          (const G4Transform3D&);
   // Maintained by vis manager.
 
   //////////////////////////////////////////////////////////////
   // Public utility functions.
 
   const G4Colour& GetColour ();  // To be deprecated?
   const G4Colour& GetColor  ();
   // Returns colour - checks fpVisAttribs and gets applicable colour.
   // Assumes fpVisAttribs point to the G4VisAttributes of the current object.
   // If the pointer is null, the colour is obtained from the default view
   // parameters of the current viewer.
 
   const G4Colour& GetColour (const G4Visible&);
   const G4Colour& GetColor  (const G4Visible&);
   // Returns colour, or viewer default colour.
   // Makes no assumptions about the validity of data member fpVisAttribs.
   // If the G4Visible has no vis attributes, i.e., the pointer is null,
   // the colour is obtained from the default view parameters of the
   // current viewer.
 
   const G4Colour& GetTextColour (const G4Text&);
   const G4Colour& GetTextColor  (const G4Text&);
   // Returns colour of G4Text object, or default text colour.
 
   G4double GetLineWidth(const G4VisAttributes*);
   // Returns line width of G4VisAttributes multiplied by GlobalLineWidthScale.
 
   G4ViewParameters::DrawingStyle GetDrawingStyle (const G4VisAttributes*);
   // Returns drawing style from current view parameters, unless the user
   // has forced through the vis attributes, thereby over-riding the
   // current view parameter.
 
   G4int GetNumberOfCloudPoints (const G4VisAttributes*) const;
   // Returns no of cloud points from current view parameters, unless the user
   // has forced through the vis attributes, thereby over-riding the
   // current view parameter.
 
   G4bool GetAuxEdgeVisible (const G4VisAttributes*);
   // Returns auxiliary edge visibility from current view parameters,
   // unless the user has forced through the vis attributes, thereby
   // over-riding the current view parameter.
 
   G4int GetNoOfSides(const G4VisAttributes*);
   // Returns no. of sides (lines segments per circle) from current
   // view parameters, unless the user has forced through the vis
   // attributes, thereby over-riding the current view parameter.
 
   G4double GetMarkerSize (const G4VMarker&, MarkerSizeType&);
   // Returns applicable marker size (diameter) and type (in second
   // argument).  Uses global default marker if marker sizes are not
   // set.  Multiplies by GlobalMarkerScale.
 
   G4double GetMarkerDiameter (const G4VMarker&, MarkerSizeType&);
   // Alias for GetMarkerSize.
 
   G4double GetMarkerRadius (const G4VMarker&, MarkerSizeType&);
   // GetMarkerSize / 2.
 
   G4ModelingParameters* CreateModelingParameters ();
   // Only the scene handler and view know what the Modeling Parameters should
   // be.  For historical reasons, the GEANT4 Visualization Environment
   // maintains its own Scene Data and View Parameters, which must be
   // converted, when needed, to Modeling Parameters.
 
   void DrawEvent(const G4Event*);
   // Checks scene's end-of-event model list and draws trajectories,
   // hits, etc.
 
   void DrawEndOfRunModels();
   // Draws end-of-run models.
 
   //////////////////////////////////////////////////////////////
   // Administration functions.
 
   template <class T> void AddSolidT (const T& solid);
   template <class T> void AddSolidWithAuxiliaryEdges (const T& solid);
 
   G4int IncrementViewCount ();
 
   virtual void ClearStore ();
   // Clears graphics database (display lists) if any.
 
   virtual void ClearTransientStore ();
   // Clears transient part of graphics database (display lists) if any.
 
   void AddViewerToList      (G4VViewer* pView);  // Add view to view List.
   void RemoveViewerFromList (G4VViewer* pView);  // Remove view from view List.
 
 protected:
 
   //////////////////////////////////////////////////////////////
   // Core routine for looping over models, redrawing stored events, etc.
   // Overload with care (see, for example,
   // G4OpenGLScenehandler::ProcessScene).
   virtual void ProcessScene ();
 
   //////////////////////////////////////////////////////////////
   // Default routine used by default AddSolid ().
   virtual void RequestPrimitives (const G4VSolid& solid);
 
   //////////////////////////////////////////////////////////////
   // Other internal routines...
 
   virtual G4DisplacedSolid* CreateSectionSolid ();
   virtual G4DisplacedSolid* CreateCutawaySolid ();
   // Generic clipping using the BooleanProcessor in graphics_reps is
   // implemented in this class.  Subclasses that implement their own
   // clipping should provide an override that returns zero.
 
   void LoadAtts(const G4Visible&, G4AttHolder*);
   // Load G4AttValues and G4AttDefs associated with the G4Visible
   // object onto the G4AttHolder object.  It checks fpModel, and also
   // loads the G4AttValues and G4AttDefs from G4PhysicalVolumeModel,
   // G4VTrajectory, G4VTrajectoryPoint, G4VHit or G4VDigi, as
   // appropriate.  The G4AttHolder object is an object of a class that
   // publicly inherits G4AttHolder - see, e.g., SoG4Polyhedron in the
   // Open Inventor driver.  G4AttHolder deletes G4AttValues in its
   // destructor to ensure proper clean-up of G4AttValues.
 
   //////////////////////////////////////////////////////////////
   // Special mesh rendering utilities...
 
   struct NameAndVisAtts {
     NameAndVisAtts(const G4String& name = "",const G4VisAttributes& visAtts = G4VisAttributes())
     : fName(name),fVisAtts(visAtts) {}
     G4String fName;
     G4VisAttributes fVisAtts;
   };
 
   class PseudoSceneFor3DRectMeshPositions: public G4PseudoScene {
   public:
     PseudoSceneFor3DRectMeshPositions
     (G4PhysicalVolumeModel* pvModel  // input
      , const G4Mesh* pMesh  // input...the following are outputs by reference
      , std::multimap<const G4Material*,const G4ThreeVector>& positionByMaterial
      , std::map<const G4Material*,NameAndVisAtts>& nameAndVisAttsByMaterial)
     : fpPVModel(pvModel)
     , fpMesh(pMesh)
     , fPositionByMaterial(positionByMaterial)
     , fNameAndVisAttsByMaterial(nameAndVisAttsByMaterial)
     {}
   private:
     using G4PseudoScene::AddSolid;  // except for...
     void AddSolid(const G4Box&) override;
     void ProcessVolume(const G4VSolid&) override {
       // Do nothing if uninteresting solids found, e.g., the container if not marked invisible.
     }
     G4PhysicalVolumeModel* fpPVModel;
     const G4Mesh* fpMesh;
     std::multimap<const G4Material*,const G4ThreeVector>& fPositionByMaterial;
     std::map<const G4Material*,NameAndVisAtts>& fNameAndVisAttsByMaterial;
   };
 
   class PseudoSceneForTetVertices: public G4PseudoScene {
   public:
     PseudoSceneForTetVertices
     (G4PhysicalVolumeModel* pvModel  // input
      , const G4Mesh* pMesh  // input...the following are outputs by reference
      , std::multimap<const G4Material*,std::vector<G4ThreeVector>>& verticesByMaterial
      , std::map<const G4Material*,NameAndVisAtts>& nameAndVisAttsByMaterial)
     : fpPVModel(pvModel)
     , fpMesh(pMesh)
     , fVerticesByMaterial(verticesByMaterial)
     , fNameAndVisAttsByMaterial(nameAndVisAttsByMaterial)
     {}
   private:
     using G4PseudoScene::AddSolid;  // except for...
     void AddSolid(const G4VSolid& solid) override;
     void ProcessVolume(const G4VSolid&) override {
       // Do nothing if uninteresting solids found, e.g., the container if not marked invisible.
     }
     G4PhysicalVolumeModel* fpPVModel;
     const G4Mesh* fpMesh;
     std::multimap<const G4Material*,std::vector<G4ThreeVector>>& fVerticesByMaterial;
     std::map<const G4Material*,NameAndVisAtts>& fNameAndVisAttsByMaterial;
   };
 
   void StandardSpecialMeshRendering(const G4Mesh&);
   // Standard way of special mesh rendering.
   // MySceneHandler::AddCompound(const G4Mesh& mesh) may use this if
   // appropriate or implement its own special mesh rendereing.
 
   void Draw3DRectMeshAsDots(const G4Mesh&);
   // For a rectangular 3-D mesh, draw as coloured dots by colour and material,
   // one dot randomly placed in each visible mesh cell.
 
   void Draw3DRectMeshAsSurfaces(const G4Mesh&);
   // For a rectangular 3-D mesh, draw as surfaces by colour and material
   // with inner shared faces removed.
 
   void DrawTetMeshAsDots(const G4Mesh&);
   // For a tetrahedron mesh, draw as coloured dots by colour and material,
   // one dot randomly placed in each visible mesh cell.
 
   void DrawTetMeshAsSurfaces(const G4Mesh&);
   // For a tetrahedron mesh, draw as surfaces by colour and material
   // with inner shared faces removed.
 
   G4ThreeVector GetPointInBox(const G4ThreeVector& pos,
                               G4double halfX,
                               G4double halfY,
                               G4double halfZ) const;
   // Sample a random point inside the box
 
   G4ThreeVector GetPointInTet(const std::vector<G4ThreeVector>& vertices) const;
   // Sample a random point inside the tetrahedron
 
   //////////////////////////////////////////////////////////////
   // Data members
 
   G4VGraphicsSystem& fSystem;          // Graphics system.
   const G4int        fSceneHandlerId;  // Id of this instance.
   G4String           fName;
   G4int              fViewCount;       // To determine view ids.
   G4ViewerList       fViewerList;      // Viewers.
   G4VViewer*         fpViewer;         // Current viewer.
   G4Scene*           fpScene;          // Scene for this scene handler.
   G4bool             fMarkForClearingTransientStore;
   G4bool             fReadyForTransients;  // I.e., not processing the
                                // run-duration part of scene.
   G4bool             fTransientsDrawnThisEvent;  // Maintained by vis
   G4bool             fTransientsDrawnThisRun;    // manager.
   G4bool             fProcessingSolid; // True if within Pre/PostAddSolid.
   G4bool             fProcessing2D;    // True for 2D.
   G4VModel*          fpModel;          // Current model.
   G4Transform3D fObjectTransformation; // Current accumulated
                        // object transformation.
   G4int              fNestingDepth;    // For Begin/EndPrimitives.
   const G4VisAttributes* fpVisAttribs; // Working vis attributes.
   const G4Transform3D fIdentityTransformation;
   std::map<G4VPhysicalVolume*,G4String> fProblematicVolumes;
 
 private:
 
   G4VSceneHandler (const G4VSceneHandler&);
   G4VSceneHandler& operator = (const G4VSceneHandler&);
 };
 
 #include "G4VSceneHandler.icc"
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team