d5/d43/G4VSceneHandler_8hh_source.html

//

// ********************************************************************

// * 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"


class G4Scene;

class G4VViewer;

class G4Colour;

class G4Visible;

class G4ModelingParameters;

class G4VModel;

class G4VGraphicsSystem;

class G4LogicalVolume;

class G4VPhysicalVolume;

class G4Material;

class G4Event;

class G4AttHolder;

class G4DisplacedSolid;


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>&);


  // 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 ();

  //   ...

  // }


  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 G4Scale&);

  // Default implementation in this class but can be over-ridden.

  virtual void AddPrimitive (const G4Text&)       = 0;

  virtual void AddPrimitive (const G4Circle&)     = 0;

  virtual void AddPrimitive (const G4Square&)     = 0;

  virtual void AddPrimitive (const G4Polymarker&);

  // Default implementation in this class but can be over-ridden.

  virtual void AddPrimitive (const G4Polyhedron&) = 0;


  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 ();

  const G4Colour& GetColor  ();

  // Returns colour - checks fpVisAttribs and gets applicable colour.


  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.


  // 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;


private:


  G4VSceneHandler (const G4VSceneHandler&);

  G4VSceneHandler& operator = (const G4VSceneHandler&);

};


#include "G4VSceneHandler.icc"


#endif