G4VSceneHandler Class Reference

#include <G4VSceneHandler.hh>

Inheritance diagram for G4VSceneHandler:

Classes
struct	NameAndVisAtts
class	PseudoSceneFor3DRectMeshPositions
class	PseudoSceneForTetVertices

Public Types
enum	MarkerSizeType { world , screen }

Public Member Functions
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
virtual	~G4VSceneHandler ()
virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
virtual void	PostAddSolid ()
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 &)
virtual void	AddSolid (const G4Ellipsoid &)
virtual void	AddSolid (const G4Polycone &)
virtual void	AddSolid (const G4Polyhedra &)
virtual void	AddSolid (const G4TessellatedSolid &)
virtual void	AddSolid (const G4VSolid &)
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 &)
virtual void	BeginModeling ()
virtual void	EndModeling ()
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	EndPrimitives ()
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	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 &)
virtual const G4VisExtent &	GetExtent () const
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 ()
void	SetModel (G4VModel *)
void	SetMarkForClearingTransientStore (G4bool)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetTransientsDrawnThisRun (G4bool)
void	SetObjectTransformation (const G4Transform3D &)
const G4Colour &	GetColour ()
const G4Colour &	GetColor ()
const G4Colour &	GetColour (const G4Visible &)
const G4Colour &	GetColor (const G4Visible &)
const G4Colour &	GetTextColour (const G4Text &)
const G4Colour &	GetTextColor (const G4Text &)
G4double	GetLineWidth (const G4VisAttributes *)
G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)
G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const
G4bool	GetAuxEdgeVisible (const G4VisAttributes *)
G4int	GetNoOfSides (const G4VisAttributes *)
G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
G4ModelingParameters *	CreateModelingParameters ()
void	DrawEvent (const G4Event *)
void	DrawEndOfRunModels ()
template<class T >
void	AddSolidT (const T &solid)
template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)
G4int	IncrementViewCount ()
virtual void	ClearStore ()
virtual void	ClearTransientStore ()
void	AddViewerToList (G4VViewer *pView)
void	RemoveViewerFromList (G4VViewer *pView)
Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()
virtual	~G4VGraphicsScene ()

Protected Member Functions
virtual void	ProcessScene ()
virtual void	RequestPrimitives (const G4VSolid &solid)
virtual G4DisplacedSolid *	CreateSectionSolid ()
virtual G4DisplacedSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
void	StandardSpecialMeshRendering (const G4Mesh &)
void	Draw3DRectMeshAsDots (const G4Mesh &)
void	Draw3DRectMeshAsSurfaces (const G4Mesh &)
void	DrawTetMeshAsDots (const G4Mesh &)
void	DrawTetMeshAsSurfaces (const G4Mesh &)
G4ThreeVector	GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const
G4ThreeVector	GetPointInTet (const std::vector< G4ThreeVector > &vertices) const

Protected Attributes
G4VGraphicsSystem &	fSystem
const G4int	fSceneHandlerId
G4String	fName
G4int	fViewCount
G4ViewerList	fViewerList
G4VViewer *	fpViewer
G4Scene *	fpScene
G4bool	fMarkForClearingTransientStore
G4bool	fReadyForTransients
G4bool	fTransientsDrawnThisEvent
G4bool	fTransientsDrawnThisRun
G4bool	fProcessingSolid
G4bool	fProcessing2D
G4VModel *	fpModel
G4Transform3D	fObjectTransformation
G4int	fNestingDepth
const G4VisAttributes *	fpVisAttribs
const G4Transform3D	fIdentityTransformation

Friends
class	G4VViewer
std::ostream &	operator<< (std::ostream &os, const G4VSceneHandler &s)

Detailed Description

Definition at line 52 of file G4VSceneHandler.hh.

Member Enumeration Documentation

MarkerSizeType

enum G4VSceneHandler::MarkerSizeType

Enumerator
world
screen

Definition at line 59 of file G4VSceneHandler.hh.

{world, screen};

Constructor & Destructor Documentation

G4VSceneHandler()

G4VSceneHandler::G4VSceneHandler	(	G4VGraphicsSystem &	system,
		G4int	id,
		const G4String &	name = "" )

Definition at line 101 of file G4VSceneHandler.cc.

                                                                                          :
  fSystem                (system),
  fSceneHandlerId        (id),
  fViewCount             (0),
  fpViewer               (0),
  fpScene                (0),
  fMarkForClearingTransientStore (true),  // Ready for first
                      // ClearTransientStoreIfMarked(),
                      // e.g., at end of run (see
                      // G4VisManager.cc).
  fReadyForTransients    (true),  // Only false while processing scene.
  fProcessingSolid       (false),
  fProcessing2D          (false),
  fpModel                (0),
  fNestingDepth          (0),
  fpVisAttribs           (0)
{
  G4VisManager* pVMan = G4VisManager::GetInstance ();
  fpScene = pVMan -> GetCurrentScene ();
  if (name == "") {
    std::ostringstream ost;
    ost << fSystem.GetName () << '-' << fSceneHandlerId;
    fName = ost.str();
  }
  else {
    fName = name;
  }
  fTransientsDrawnThisEvent = pVMan->GetTransientsDrawnThisEvent();
  fTransientsDrawnThisRun = pVMan->GetTransientsDrawnThisRun();
}

~G4VSceneHandler()

G4VSceneHandler::~G4VSceneHandler ( )

virtual

Definition at line 132 of file G4VSceneHandler.cc.

                                   {
  G4VViewer* last;
  while( ! fViewerList.empty() ) {
    last = fViewerList.back();
    fViewerList.pop_back();
    delete last;
  }
}

Member Function Documentation

AddCompound() [1/6]

void G4VSceneHandler::AddCompound ( const G4Mesh & mesh )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 433 of file G4VSceneHandler.cc.

{
  G4warn <<
  "There has been an attempt to draw a mesh with option \""
  << fpViewer->GetViewParameters().GetSpecialMeshRenderingOption()
  << "\":\n" << mesh
  << "but it is not of a recognised type or is not implemented"
  "\nby the current graphics driver. Instead we draw its"
  "\ncontainer \"" << mesh.GetContainerVolume()->GetName() << "\"."
  << G4endl;
  const auto& pv = mesh.GetContainerVolume();
  const auto& lv = pv->GetLogicalVolume();
  const auto& solid = lv->GetSolid();
  const auto& transform = mesh.GetTransform();
  // Make sure container is visible
  G4VisAttributes tmpVisAtts;  // Visible, white, not forced.
  const auto& saveVisAtts = lv->GetVisAttributes();
  if (saveVisAtts) {
    tmpVisAtts = *saveVisAtts;
    tmpVisAtts.SetVisibility(true);
    auto colour = saveVisAtts->GetColour();
    colour.SetAlpha(1.);
    tmpVisAtts.SetColour(colour);
  }
  // Draw container
  PreAddSolid(transform,tmpVisAtts);
  solid->DescribeYourselfTo(*this);
  PostAddSolid();
  // Restore vis attributes
  lv->SetVisAttributes(saveVisAtts);
}

AddCompound() [2/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4double > & hits )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 347 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      if (scoreMapName == mapNam) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
  }
}

AddCompound() [3/6]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & hits )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 390 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      const G4THitsMap<G4StatDouble>* foundHits = i->second;
      if (foundHits == &hits) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4StatDouble>&>(hits).DrawAllHits();
  }
}

AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi & digi )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 342 of file G4VSceneHandler.cc.

                                                      {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VDigi&>(digi).Draw();
}

AddCompound() [5/6]

void G4VSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 337 of file G4VSceneHandler.cc.

                                                    {
  // Cast away const because Draw is non-const!!!!
  const_cast<G4VHit&>(hit).Draw();
}

AddCompound() [6/6]

void G4VSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 325 of file G4VSceneHandler.cc.

                                                            {
  G4TrajectoriesModel* trajectoriesModel =
    dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajectoriesModel)
    traj.DrawTrajectory();
  else {
    G4Exception
    ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
     "visman0105", FatalException, "Not a G4TrajectoriesModel.");
  }
}

Referenced by G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddCompound(), and StandardSpecialMeshRendering().

AddPrimitive() [1/7]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle & )

pure virtual

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

Definition at line 512 of file G4VSceneHandler.cc.

                                                    {
  G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
  G4warn << "  Open a plotter-aware graphics system or remove plotter with" << G4endl;
  G4warn << "  /vis/scene/removeModel Plotter" << G4endl;
}

AddPrimitive() [3/7]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron & )

pure virtual

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

AddPrimitive() [4/7]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline & )

pure virtual

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

Referenced by AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), Draw3DRectMeshAsDots(), Draw3DRectMeshAsSurfaces(), DrawTetMeshAsDots(), DrawTetMeshAsSurfaces(), RequestPrimitives(), and StandardSpecialMeshRendering().

AddPrimitive() [5/7]

void G4VSceneHandler::AddPrimitive ( const G4Polymarker & polymarker )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

Definition at line 469 of file G4VSceneHandler.cc.

                                                                  {
  switch (polymarker.GetMarkerType()) {
    default:
    case G4Polymarker::dots:
    {
      G4Circle dot (polymarker);
      dot.SetWorldSize  (0.);
      dot.SetScreenSize (0.1);  // Very small circle.
      for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        dot.SetPosition (polymarker[iPoint]);
        AddPrimitive (dot);
      }
    }
      break;
    case G4Polymarker::circles:
    {
      G4Circle circle (polymarker);  // Default circle
      for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        circle.SetPosition (polymarker[iPoint]);
        AddPrimitive (circle);
      }
    }
      break;
    case G4Polymarker::squares:
    {
      G4Square square (polymarker);  // Default square
      for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        square.SetPosition (polymarker[iPoint]);
        AddPrimitive (square);
      }
    }
      break;
  }
}

AddPrimitive() [6/7]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square & )

pure virtual

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

AddPrimitive() [7/7]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text & )

pure virtual

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, G4VtkQtSceneHandler, G4VtkSceneHandler, and G4VTreeSceneHandler.

AddSolid() [1/14]

void G4VSceneHandler::AddSolid ( const G4Box & box )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 254 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (box);
  // 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 this.
  // Your function might look like this...
  // void G4MySceneHandler::AddSolid (const G4Box& box) {
  // Get and check applicable vis attributes.
  //   fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  // Do not draw if not visible.
  //   if (fpVisAttribs->IsVisible()) {
  //   Get parameters of appropriate object, e.g.:
  //     G4double dx = box.GetXHalfLength ();
  //     G4double dy = box.GetYHalfLength ();
  //     G4double dz = box.GetZHalfLength ();
  //     ...
  //     and Draw or Store in your display List.
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), and G4VtkSceneHandler::AddSolid().

AddSolid() [2/14]

void G4VSceneHandler::AddSolid ( const G4Cons & cons )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 273 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (cons);
}

AddSolid() [3/14]

void G4VSceneHandler::AddSolid ( const G4Ellipsoid & ellipsoid )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 305 of file G4VSceneHandler.cc.

                                                            {
  AddSolidWithAuxiliaryEdges (ellipsoid);
}

AddSolid() [4/14]

void G4VSceneHandler::AddSolid ( const G4Orb & orb )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 277 of file G4VSceneHandler.cc.

                                                {
  AddSolidWithAuxiliaryEdges (orb);
}

AddSolid() [5/14]

void G4VSceneHandler::AddSolid ( const G4Para & para )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 281 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (para);
}

AddSolid() [6/14]

void G4VSceneHandler::AddSolid ( const G4Polycone & polycone )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 309 of file G4VSceneHandler.cc.

                                                          {
  AddSolidT (polycone);
}

AddSolid() [7/14]

void G4VSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 313 of file G4VSceneHandler.cc.

                                                            {
  AddSolidT (polyhedra);
}

AddSolid() [8/14]

void G4VSceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 285 of file G4VSceneHandler.cc.

                                                      {
  AddSolidWithAuxiliaryEdges (sphere);
}

AddSolid() [9/14]

void G4VSceneHandler::AddSolid ( const G4TessellatedSolid & tess )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 317 of file G4VSceneHandler.cc.

                                                              {
  AddSolidT (tess);
}

AddSolid() [10/14]

void G4VSceneHandler::AddSolid ( const G4Torus & torus )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 289 of file G4VSceneHandler.cc.

                                                    {
  AddSolidWithAuxiliaryEdges (torus);
}

AddSolid() [11/14]

void G4VSceneHandler::AddSolid ( const G4Trap & trap )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 293 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (trap);
}

AddSolid() [12/14]

void G4VSceneHandler::AddSolid ( const G4Trd & trd )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 297 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (trd);
}

AddSolid() [13/14]

void G4VSceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 301 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (tubs);
}

AddSolid() [14/14]

void G4VSceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 321 of file G4VSceneHandler.cc.

                                                     {
  AddSolidT (solid);
}

AddSolidT()

template<class T >

void G4VSceneHandler::AddSolidT

(

const T &

solid

)

Definition at line 227 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  RequestPrimitives (solid);
}

Referenced by AddSolid(), AddSolid(), AddSolid(), AddSolid(), AddSolid(), AddSolid(), AddSolid(), AddSolid(), AddSolid(), and AddSolid().

AddSolidWithAuxiliaryEdges()

template<class T >

void G4VSceneHandler::AddSolidWithAuxiliaryEdges

(

const T &

solid

)

Definition at line 235 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  // Draw with auxiliary edges unless otherwise specified.
  if (!fpVisAttribs->IsForceAuxEdgeVisible()) {
    // Create a vis atts object for the modified vis atts.
    // It is static so that we may return a reliable pointer to it.
    static G4VisAttributes visAttsWithAuxEdges;
    // Initialise it with the current vis atts and reset the pointer.
    visAttsWithAuxEdges = *fpVisAttribs;
    // Force auxiliary edges visible.
    visAttsWithAuxEdges.SetForceAuxEdgeVisible();
    fpVisAttribs = &visAttsWithAuxEdges;
  }
  RequestPrimitives (solid);
}

Referenced by AddSolid(), AddSolid(), AddSolid(), and AddSolid().

AddViewerToList()

void G4VSceneHandler::AddViewerToList

(

G4VViewer *

pView

)

Definition at line 465 of file G4VSceneHandler.cc.

                                                         {
  fViewerList.push_back (pViewer);
}

BeginModeling()

void G4VSceneHandler::BeginModeling ( )

virtual

Reimplemented in G4ASCIITreeSceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredSceneHandler, G4VRML2FileSceneHandler, and G4VTreeSceneHandler.

Definition at line 215 of file G4VSceneHandler.cc.

                                     {
}

Referenced by G4GMocrenFileSceneHandler::BeginModeling(), G4HepRepFileSceneHandler::BeginModeling(), G4OpenGLImmediateSceneHandler::BeginModeling(), G4OpenGLStoredSceneHandler::BeginModeling(), G4VTreeSceneHandler::BeginModeling(), G4GMocrenFileSceneHandler::GFBeginModeling(), and ProcessScene().

BeginPrimitives()

void G4VSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation = G4Transform3D() )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 167 of file G4VSceneHandler.cc.

                                            {
  //static G4int count = 0;
  //G4cout << "G4VSceneHandler::BeginPrimitives: " << count++ << G4endl;
  fNestingDepth++;
  if (fNestingDepth > 1)
    G4Exception
      ("G4VSceneHandler::BeginPrimitives",
       "visman0101", FatalException,
       "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
  fObjectTransformation = objectTransformation;
}

Referenced by G4GMocrenFileSceneHandler::BeginPrimitives(), G4OpenGLSceneHandler::BeginPrimitives(), G4OpenInventorSceneHandler::BeginPrimitives(), G4Qt3DSceneHandler::BeginPrimitives(), Draw3DRectMeshAsDots(), Draw3DRectMeshAsSurfaces(), DrawTetMeshAsDots(), DrawTetMeshAsSurfaces(), RequestPrimitives(), and StandardSpecialMeshRendering().

BeginPrimitives2D()

void G4VSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation = G4Transform3D() )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, and G4Qt3DSceneHandler.

Definition at line 191 of file G4VSceneHandler.cc.

                                            {
  fNestingDepth++;
  if (fNestingDepth > 1)
    G4Exception
      ("G4VSceneHandler::BeginPrimitives2D",
       "visman0103", FatalException,
       "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
  fObjectTransformation = objectTransformation;
  fProcessing2D = true;
}

Referenced by G4HepRepFileSceneHandler::BeginPrimitives2D(), G4OpenGLSceneHandler::BeginPrimitives2D(), and G4Qt3DSceneHandler::BeginPrimitives2D().

ClearStore()

void G4VSceneHandler::ClearStore ( )

virtual

Reimplemented in G4OpenGLStoredQtSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, G4ToolsSGSceneHandler, and G4VtkSceneHandler.

Definition at line 223 of file G4VSceneHandler.cc.

{}

Referenced by G4OpenGLStoredSceneHandler::ClearStore(), G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), G4VViewer::ProcessView(), and G4OpenGLSceneHandler::~G4OpenGLSceneHandler().

ClearTransientStore()

void G4VSceneHandler::ClearTransientStore ( )

virtual

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredQtSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4ToolsSGSceneHandler, G4VRML2FileSceneHandler, and G4VtkSceneHandler.

Definition at line 225 of file G4VSceneHandler.cc.

{}

Referenced by G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), G4VisCommandViewerClearTransients::SetNewValue(), and G4VisCommandViewerRebuild::SetNewValue().

CreateCutawaySolid()

G4DisplacedSolid * G4VSceneHandler::CreateCutawaySolid ( )

protectedvirtual

Reimplemented in G4OpenGLSceneHandler.

Definition at line 1000 of file G4VSceneHandler.cc.

{
  const auto& vp = fpViewer->GetViewParameters();
  const auto& nPlanes = vp.GetCutawayPlanes().size();
 
  if (nPlanes == 0) return nullptr;
 
  std::vector<G4DisplacedSolid*> cutaway_solids;
 
  G4double radius = fpScene->GetExtent().GetExtentRadius();
  G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
  auto cutawayBox = new G4Box("_cutaway_box", safe, safe, safe);
 
  // if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion) we need a subtractor that is
  // the intersection of displaced cutaway boxes, displaced so that a subtraction keeps the
  // positive values a*x+b*y+c*z+d>0, so we have to invert the normal. This may appear
  // "back to front". The parameter "cutawayUnion" means "the union of volumes
  // that remain *after* cutaway", because we base the concept on OpenGL cutaway planes and make
  // a "union" of what remains by superimposing up to 3 passes - see G4OpenGLViewer::SetView
  // and G4OpenGLImmediate/StoredViewer::ProcessView. So we have to create a subtractor
  // that is the intersection of inverted cutaway planes.
 
  // Conversely, if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection) we have to
  // create an intersector that is the intersector of intersected non-inverted cutaway planes.
 
  for (size_t plane_no = 0; plane_no < nPlanes; plane_no++)
  {
    const G4Plane3D& sp = vp.GetCutawayPlanes()[plane_no];
    G4Transform3D requiredTransform;
    G4ThreeVector normal;
    switch (vp.GetCutawayMode()) {
      case G4ViewParameters::cutawayUnion:
        normal = -sp.normal();  // Invert normal - we want a subtractor
        requiredTransform = G4Translate3D(normal*(safe + sp.d())) *
        G4Rotate3D(G4ThreeVector(0,0,1), G4ThreeVector(0,1,0), normal, normal.orthogonal());
        break;
      case G4ViewParameters::cutawayIntersection:
        normal = sp.normal();
        requiredTransform = G4Translate3D(normal*(safe - sp.d())) *
        G4Rotate3D(G4ThreeVector(0,0,1), G4ThreeVector(0,1,0), normal, normal.orthogonal());
        break;
    }
    cutaway_solids.push_back
    (new G4DisplacedSolid("_displaced_cutaway_box", cutawayBox, requiredTransform));
  }
 
  if (nPlanes == 1) return (G4DisplacedSolid*) cutaway_solids[0];
 
  G4IntersectionSolid *union2 = nullptr, *union3 = nullptr;
  G4IntersectionSolid *intersection2 = nullptr, *intersection3 = nullptr;
  switch (vp.GetCutawayMode()) {
 
    case G4ViewParameters::cutawayUnion:
      // Here we make a subtractor of intersections of inverted cutaway planes.
      union2 = new G4IntersectionSolid("_union_2", cutaway_solids[0], cutaway_solids[1]);
      if (nPlanes == 2) return (G4DisplacedSolid*)union2;
      else if (nPlanes == 3) {
        union3 = new G4IntersectionSolid("_union_3", union2, cutaway_solids[2]);
        return (G4DisplacedSolid*)union3;
      }
      break;
 
    case G4ViewParameters::cutawayIntersection:
      // And here we make an intersector of intersections of non-inverted cutaway planes.
      intersection2
      = new G4IntersectionSolid("_intersection_2", cutaway_solids[0], cutaway_solids[1]);
      if (nPlanes == 2) return (G4DisplacedSolid*)intersection2;
      else if (nPlanes == 3) {
        intersection3
        = new G4IntersectionSolid("_intersection_3", intersection2, cutaway_solids[2]);
        return (G4DisplacedSolid*)intersection3;
      }
      break;
  }
 
  G4Exception("G4VSceneHandler::CreateCutawaySolid", "visman107", JustWarning,
              "Not programmed for more than 3 cutaway planes");
  return nullptr;
}

Referenced by CreateModelingParameters().

CreateModelingParameters()

G4ModelingParameters * G4VSceneHandler::CreateModelingParameters

(

)

Definition at line 900 of file G4VSceneHandler.cc.

{
  // Create modeling parameters from View Parameters...
  if (!fpViewer) return NULL;
 
  const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
 
  // Convert drawing styles...
  G4ModelingParameters::DrawingStyle modelDrawingStyle =
  G4ModelingParameters::wf;
  switch (vp.GetDrawingStyle ()) {
    default:
    case G4ViewParameters::wireframe:
      modelDrawingStyle = G4ModelingParameters::wf;
      break;
    case G4ViewParameters::hlr:
      modelDrawingStyle = G4ModelingParameters::hlr;
      break;
    case G4ViewParameters::hsr:
      modelDrawingStyle = G4ModelingParameters::hsr;
      break;
    case G4ViewParameters::hlhsr:
      modelDrawingStyle = G4ModelingParameters::hlhsr;
      break;
    case G4ViewParameters::cloud:
      modelDrawingStyle = G4ModelingParameters::cloud;
      break;
  }
 
  // Decide if covered daughters are really to be culled...
  G4bool reallyCullCovered =
    vp.IsCullingCovered()   // Culling daughters depends also on...
    && !vp.IsSection ()     // Sections (DCUT) not requested.
    && !vp.IsCutaway ()     // Cutaways not requested.
    ;
 
  G4ModelingParameters* pModelingParams = new G4ModelingParameters
    (vp.GetDefaultVisAttributes (),
     modelDrawingStyle,
     vp.IsCulling (),
     vp.IsCullingInvisible (),
     vp.IsDensityCulling (),
     vp.GetVisibleDensity (),
     reallyCullCovered,
     vp.GetNoOfSides ()
     );
 
  pModelingParams->SetNumberOfCloudPoints(vp.GetNumberOfCloudPoints());
  pModelingParams->SetWarning
    (G4VisManager::GetVerbosity() >= G4VisManager::warnings);
 
  pModelingParams->SetCBDAlgorithmNumber(vp.GetCBDAlgorithmNumber());
  pModelingParams->SetCBDParameters(vp.GetCBDParameters());
 
  pModelingParams->SetExplodeFactor(vp.GetExplodeFactor());
  pModelingParams->SetExplodeCentre(vp.GetExplodeCentre());
 
  pModelingParams->SetSectionSolid(CreateSectionSolid());
 
  if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion) {
    pModelingParams->SetCutawayMode(G4ModelingParameters::cutawayUnion);
  } else if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection) {
    pModelingParams->SetCutawayMode(G4ModelingParameters::cutawayIntersection);
  }
 
  pModelingParams->SetCutawaySolid(CreateCutawaySolid());
  // The polyhedron objects are deleted in the modeling parameters destructor.
  
  pModelingParams->SetVisAttributesModifiers(vp.GetVisAttributesModifiers());
 
  pModelingParams->SetSpecialMeshRendering(vp.IsSpecialMeshRendering());
  pModelingParams->SetSpecialMeshVolumes(vp.GetSpecialMeshVolumes());
 
  return pModelingParams;
}

Referenced by DrawEndOfRunModels(), DrawEvent(), G4VisManager::DrawGeometry(), and ProcessScene().

CreateSectionSolid()

G4DisplacedSolid * G4VSceneHandler::CreateSectionSolid ( )

protectedvirtual

Reimplemented in G4OpenGLSceneHandler.

Definition at line 976 of file G4VSceneHandler.cc.

{
  G4DisplacedSolid* sectioner = 0;
 
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  if (vp.IsSection () ) {
 
    G4double radius = fpScene->GetExtent().GetExtentRadius();
    G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
    G4VSolid* sectionBox =
      new G4Box("_sectioner", safe, safe, 1.e-5 * radius);  // Thin in z-plane...
 
    const G4Plane3D& sp = vp.GetSectionPlane ();
    G4ThreeVector normal = sp.normal();
    G4Transform3D requiredTransform = G4Translate3D(normal*(-sp.d())) *
    G4Rotate3D(G4ThreeVector(0,0,1), G4ThreeVector(0,1,0), normal, normal.orthogonal());
 
    sectioner = new G4DisplacedSolid
    ("_displaced_sectioning_box", sectionBox, requiredTransform);
  }
  
  return sectioner;
}

Referenced by CreateModelingParameters(), and G4OpenGLSceneHandler::CreateSectionSolid().

Draw3DRectMeshAsDots()

void G4VSceneHandler::Draw3DRectMeshAsDots ( const G4Mesh & mesh )

protected

Definition at line 1410 of file G4VSceneHandler.cc.

{
  // Check
  if (mesh.GetMeshType() != G4Mesh::rectangle &&
      mesh.GetMeshType() != G4Mesh::nested3DRectangular) {
    G4ExceptionDescription ed;
    ed << "Called with a mesh that is not rectangular:" << mesh;
    G4Exception("G4VSceneHandler::Draw3DRectMeshAsDots","visman0108",JustWarning,ed);
    return;
  }
 
  static G4bool firstPrint = true;
  const auto& verbosity = G4VisManager::GetVerbosity();
  G4bool print = firstPrint && verbosity >= G4VisManager::errors;
  if (print) {
    G4cout
    << "Special case drawing of 3D rectangular G4VNestedParameterisation as dots:"
    << '\n' << mesh
    << G4endl;
  }
 
  const auto& container = mesh.GetContainerVolume();
 
  // This map is static so that once filled it stays filled.
  static std::map<G4String,std::map<const G4Material*,G4Polymarker>> dotsByMaterialAndMesh;
  auto& dotsByMaterial = dotsByMaterialAndMesh[mesh.GetContainerVolume()->GetName()];
 
  // Fill map if not already filled
  if (dotsByMaterial.empty()) {
 
    // Get positions and material one cell at a time (using PseudoSceneFor3DRectMeshPositions).
    // The pseudo scene allows a "private" descent into the parameterisation.
    // Instantiate a temporary G4PhysicalVolumeModel
    G4ModelingParameters tmpMP;
    tmpMP.SetCulling(true);  // This avoids drawing transparent...
    tmpMP.SetCullingInvisible(true);  // ... or invisble volumes.
    const G4bool useFullExtent = true;  // To avoid calculating the extent
    G4PhysicalVolumeModel tmpPVModel
    (container,
     G4PhysicalVolumeModel::UNLIMITED,
     G4Transform3D(),  // so that positions are in local coordinates
     &tmpMP,
     useFullExtent);
    // Accumulate information in temporary maps by material
    std::multimap<const G4Material*,const G4ThreeVector> positionByMaterial;
    std::map<const G4Material*,G4VSceneHandler::NameAndVisAtts> nameAndVisAttsByMaterial;
    // Instantiate the pseudo scene
    PseudoSceneFor3DRectMeshPositions pseudoScene
    (&tmpPVModel,&mesh,positionByMaterial,nameAndVisAttsByMaterial);
    // Make private descent into the parameterisation
    tmpPVModel.DescribeYourselfTo(pseudoScene);
    // Now we have a map of positions by material.
    // Also a map of name and colour by material.
 
    const auto& prms = mesh.GetThreeDRectParameters();
    const auto& halfX = prms.fHalfX;
    const auto& halfY = prms.fHalfY;
    const auto& halfZ = prms.fHalfZ;
 
    // Fill the permanent (static) map of dots by material
    G4int nDotsTotal = 0;
    for (const auto& entry: nameAndVisAttsByMaterial) {
      G4int nDots = 0;
      const auto& material = entry.first;
      const auto& nameAndVisAtts = nameAndVisAttsByMaterial[material];
      const auto& name = nameAndVisAtts.fName;
      const auto& visAtts = nameAndVisAtts.fVisAtts;
      G4Polymarker dots;
      dots.SetInfo(name);
      dots.SetVisAttributes(visAtts);
      dots.SetMarkerType(G4Polymarker::dots);
      dots.SetSize(G4VMarker::screen,1.);
      // Enter empty polymarker into the map
      dotsByMaterial[material] = dots;
      // Now fill it in situ
      auto& dotsInMap = dotsByMaterial[material];
      const auto& range = positionByMaterial.equal_range(material);
      for (auto posByMat = range.first; posByMat != range.second; ++posByMat) {
        dotsInMap.push_back(GetPointInBox(posByMat->second, halfX, halfY, halfZ));
        ++nDots;
      }
 
      if (print) {
        G4cout
        << std::setw(30) << std::left << name.substr(0,30) << std::right
        << ": " << std::setw(7) << nDots << " dots"
        << ": colour " << std::fixed << std::setprecision(2)
        << visAtts.GetColour() << std::defaultfloat
        << G4endl;
      }
 
      nDotsTotal += nDots;
    }
 
    if (print) {
      G4cout << "Total number of dots: " << nDotsTotal << G4endl;
    }
  }
 
  // Some subsequent expressions apply only to G4PhysicalVolumeModel
  auto pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  G4String parameterisationName;
  if (pPVModel) {
    parameterisationName = pPVModel->GetFullPVPath().back().GetPhysicalVolume()->GetName();
  }
 
  // Draw the dots by material
  // Ensure they are "hidden", i.e., use the z-buffer as non-marker primitives do
  auto keepVP = fpViewer->GetViewParameters();
  auto vp = fpViewer->GetViewParameters();
  vp.SetMarkerHidden();
  fpViewer->SetViewParameters(vp);
  // Now we transform to world coordinates
  BeginPrimitives (mesh.GetTransform());
  for (const auto& entry: dotsByMaterial) {
    const auto& dots = entry.second;
    // The current "leaf" node in the PVPath is the parameterisation. Here it has
    // been converted into polymarkers by material. So...temporarily...change
    // its name to that of the material (whose name has been stored in Info)
    // so that its appearance in the scene tree of, e.g., G4OpenGLQtViewer, has
    // an appropriate name and its visibility and colour may be changed.
    if (pPVModel) {
      const auto& fullPVPath = pPVModel->GetFullPVPath();
      auto leafPV = fullPVPath.back().GetPhysicalVolume();
      leafPV->SetName(dots.GetInfo());
    }
    // Add dots to the scene
    AddPrimitive(dots);
  }
  EndPrimitives ();
  // Restore view parameters
  fpViewer->SetViewParameters(keepVP);
  // Restore parameterisation name
  if (pPVModel) {
    pPVModel->GetFullPVPath().back().GetPhysicalVolume()->SetName(parameterisationName);
  }
 
  firstPrint = false;
  return;
}

Referenced by StandardSpecialMeshRendering().

Draw3DRectMeshAsSurfaces()

void G4VSceneHandler::Draw3DRectMeshAsSurfaces ( const G4Mesh & mesh )

protected

Definition at line 1554 of file G4VSceneHandler.cc.

{
  // Check
  if (mesh.GetMeshType() != G4Mesh::rectangle &&
      mesh.GetMeshType() != G4Mesh::nested3DRectangular) {
    G4ExceptionDescription ed;
    ed << "Called with a mesh that is not rectangular:" << mesh;
    G4Exception("G4VSceneHandler::Draw3DRectMeshAsSurfaces","visman0108",JustWarning,ed);
    return;
  }
 
  static G4bool firstPrint = true;
  const auto& verbosity = G4VisManager::GetVerbosity();
  G4bool print = firstPrint && verbosity >= G4VisManager::errors;
  if (print) {
    G4cout
    << "Special case drawing of 3D rectangular G4VNestedParameterisation as surfaces:"
    << '\n' << mesh
    << G4endl;
  }
 
  const auto& container = mesh.GetContainerVolume();
 
  // This map is static so that once filled it stays filled.
  static std::map<G4String,std::map<const G4Material*,G4Polyhedron>> boxesByMaterialAndMesh;
  auto& boxesByMaterial = boxesByMaterialAndMesh[mesh.GetContainerVolume()->GetName()];
 
  // Fill map if not already filled
  if (boxesByMaterial.empty()) {
 
    // Get positions and material one cell at a time (using PseudoSceneFor3DRectMeshPositions).
    // The pseudo scene allows a "private" descent into the parameterisation.
    // Instantiate a temporary G4PhysicalVolumeModel
    G4ModelingParameters tmpMP;
    tmpMP.SetCulling(true);  // This avoids drawing transparent...
    tmpMP.SetCullingInvisible(true);  // ... or invisble volumes.
    const G4bool useFullExtent = true;  // To avoid calculating the extent
    G4PhysicalVolumeModel tmpPVModel
    (container,
     G4PhysicalVolumeModel::UNLIMITED,
     G4Transform3D(),  // so that positions are in local coordinates
     &tmpMP,
     useFullExtent);
    // Accumulate information in temporary maps by material
    std::multimap<const G4Material*,const G4ThreeVector> positionByMaterial;
    std::map<const G4Material*,G4VSceneHandler::NameAndVisAtts> nameAndVisAttsByMaterial;
    // Instantiate the pseudo scene
    PseudoSceneFor3DRectMeshPositions pseudoScene
    (&tmpPVModel,&mesh,positionByMaterial,nameAndVisAttsByMaterial);
    // Make private descent into the parameterisation
    tmpPVModel.DescribeYourselfTo(pseudoScene);
    // Now we have a map of positions by material.
    // Also a map of name and colour by material.
 
    const auto& prms = mesh.GetThreeDRectParameters();
    const auto& sizeX = 2.*prms.fHalfX;
    const auto& sizeY = 2.*prms.fHalfY;
    const auto& sizeZ = 2.*prms.fHalfZ;
 
    // Fill the permanent (static) map of boxes by material
    G4int nBoxesTotal = 0, nFacetsTotal = 0;
    for (const auto& entry: nameAndVisAttsByMaterial) {
      G4int nBoxes = 0;
      const auto& material = entry.first;
      const auto& nameAndVisAtts = nameAndVisAttsByMaterial[material];
      const auto& name = nameAndVisAtts.fName;
      const auto& visAtts = nameAndVisAtts.fVisAtts;
      // Transfer positions into a vector ready for creating polyhedral surface
      std::vector<G4ThreeVector> positionsForPolyhedron;
      const auto& range = positionByMaterial.equal_range(material);
      for (auto posByMat = range.first; posByMat != range.second; ++posByMat) {
        const auto& position = posByMat->second;
        positionsForPolyhedron.push_back(position);
        ++nBoxes;
      }
      // The polyhedron will be in local coordinates
      // Add an empty place-holder to the map and get a reference to it
      auto& polyhedron = boxesByMaterial[material];
      // Replace with the desired polyhedron (uses efficient "move assignment")
      polyhedron = G4PolyhedronBoxMesh(sizeX,sizeY,sizeZ,positionsForPolyhedron);
      polyhedron.SetVisAttributes(visAtts);
      polyhedron.SetInfo(name);
 
      if (print) {
        G4cout
        << std::setw(30) << std::left << name.substr(0,30) << std::right
        << ": " << std::setw(7) << nBoxes << " boxes"
        << " (" << std::setw(7) << 6*nBoxes << " faces)"
        << ": reduced to " << std::setw(7) << polyhedron.GetNoFacets() << " facets ("
        << std::setw(2) << std::fixed << std::setprecision(2) << 100*polyhedron.GetNoFacets()/(6*nBoxes)
        << "%): colour " << std::fixed << std::setprecision(2)
        << visAtts.GetColour() << std::defaultfloat
        << G4endl;
      }
 
      nBoxesTotal += nBoxes;
      nFacetsTotal += polyhedron.GetNoFacets();
    }
 
    if (print) {
      G4cout << "Total number of boxes: " << nBoxesTotal << " (" << 6*nBoxesTotal << " faces)"
      << ": reduced to " << nFacetsTotal << " facets ("
      << std::setw(2) << std::fixed << std::setprecision(2) << 100*nFacetsTotal/(6*nBoxesTotal) << "%)"
      << G4endl;
    }
  }
 
  // Some subsequent expressions apply only to G4PhysicalVolumeModel
  auto pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  G4String parameterisationName;
  if (pPVModel) {
    parameterisationName = pPVModel->GetFullPVPath().back().GetPhysicalVolume()->GetName();
  }
 
  // Draw the boxes by material
  // Now we transform to world coordinates
  BeginPrimitives (mesh.GetTransform());
  for (const auto& entry: boxesByMaterial) {
    const auto& poly = entry.second;
    // The current "leaf" node in the PVPath is the parameterisation. Here it has
    // been converted into polyhedra by material. So...temporarily...change
    // its name to that of the material (whose name has been stored in Info)
    // so that its appearance in the scene tree of, e.g., G4OpenGLQtViewer, has
    // an appropriate name and its visibility and colour may be changed.
    if (pPVModel) {
      const auto& fullPVPath = pPVModel->GetFullPVPath();
      auto leafPV = fullPVPath.back().GetPhysicalVolume();
      leafPV->SetName(poly.GetInfo());
    }
    AddPrimitive(poly);
  }
  EndPrimitives ();
  // Restore parameterisation name
  if (pPVModel) {
    pPVModel->GetFullPVPath().back().GetPhysicalVolume()->SetName(parameterisationName);
  }
 
  firstPrint = false;
  return;
}

Referenced by StandardSpecialMeshRendering().

DrawEndOfRunModels()

void G4VSceneHandler::DrawEndOfRunModels

(

)

Definition at line 870 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EORModelList =
    fpScene -> GetEndOfRunModelList ();
  std::size_t nModels = EORModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(0);
    for (std::size_t i = 0; i < nModels; ++i) {
      if (EORModelList[i].fActive) {
        fpModel = EORModelList[i].fpModel;
        fpModel -> SetModelingParameters(pMP);
 
        // Describe to the current scene handler
    fpModel -> DescribeYourselfTo (*this);
 
        // Enter models in the scene tree
        auto& sceneTreeScene = fpViewer->AccessSceneTreeScene();
        sceneTreeScene.SetViewer(fpViewer);
        sceneTreeScene.SetModel(fpModel);
 
        // Reset modeling parameters pointer
        fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

Referenced by ProcessScene().

DrawEvent()

void G4VSceneHandler::DrawEvent

(

const G4Event *

event

)

Definition at line 840 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EOEModelList =
    fpScene -> GetEndOfEventModelList ();
  std::size_t nModels = EOEModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(event);
    for (std::size_t i = 0; i < nModels; ++i) {
      if (EOEModelList[i].fActive) {
        fpModel = EOEModelList[i].fpModel;
        fpModel -> SetModelingParameters(pMP);
 
        // Describe to the current scene handler
        fpModel -> DescribeYourselfTo (*this);
 
        // Enter models in the scene tree
        auto& sceneTreeScene = fpViewer->AccessSceneTreeScene();
        sceneTreeScene.SetViewer(fpViewer);
        sceneTreeScene.SetModel(fpModel);
 
        // Reset modeling parameters pointer
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

Referenced by ProcessScene().

DrawTetMeshAsDots()

void G4VSceneHandler::DrawTetMeshAsDots ( const G4Mesh & mesh )

protected

Definition at line 1698 of file G4VSceneHandler.cc.

{
  // Check
  if (mesh.GetMeshType() != G4Mesh::tetrahedron) {
    G4ExceptionDescription ed;
    ed << "Called with mesh that is not a tetrahedron mesh:" << mesh;
    G4Exception("G4VSceneHandler::DrawTetMeshAsDots","visman0108",JustWarning,ed);
    return;
  }
 
  static G4bool firstPrint = true;
  const auto& verbosity = G4VisManager::GetVerbosity();
  G4bool print = firstPrint && verbosity >= G4VisManager::errors;
 
  if (print) {
    G4cout
    << "Special case drawing of tetrahedron mesh as dots"
    << '\n' << mesh
    << G4endl;
  }
 
  const auto& container = mesh.GetContainerVolume();
 
  // This map is static so that once filled it stays filled.
  static std::map<G4String,std::map<const G4Material*,G4Polymarker>> dotsByMaterialAndMesh;
  auto& dotsByMaterial = dotsByMaterialAndMesh[mesh.GetContainerVolume()->GetName()];
 
  // Fill map if not already filled
  if (dotsByMaterial.empty()) {
 
    // Get vertices and colour one cell at a time (using PseudoSceneForTetVertices).
    // The pseudo scene allows a "private" descent into the parameterisation.
    // Instantiate a temporary G4PhysicalVolumeModel
    G4ModelingParameters tmpMP;
    tmpMP.SetCulling(true);  // This avoids drawing transparent...
    tmpMP.SetCullingInvisible(true);  // ... or invisble volumes.
    const G4bool useFullExtent = true;  // To avoid calculating the extent
    G4PhysicalVolumeModel tmpPVModel
    (container,
     G4PhysicalVolumeModel::UNLIMITED,
     G4Transform3D(),  // so that positions are in local coordinates
     &tmpMP,
     useFullExtent);
    // Accumulate information in temporary maps by material
    std::multimap<const G4Material*,std::vector<G4ThreeVector>> verticesByMaterial;
    std::map<const G4Material*,G4VSceneHandler::NameAndVisAtts> nameAndVisAttsByMaterial;
    // Instantiate a pseudo scene
    PseudoSceneForTetVertices pseudoScene
    (&tmpPVModel,&mesh,verticesByMaterial,nameAndVisAttsByMaterial);
    // Make private descent into the parameterisation
    tmpPVModel.DescribeYourselfTo(pseudoScene);
    // Now we have a map of vertices by material.
    // Also a map of name and colour by material.
 
    // Fill the permanent (static) map of dots by material
    G4int nDotsTotal = 0;
    for (const auto& entry: nameAndVisAttsByMaterial) {
      G4int nDots = 0;
      const auto& material = entry.first;
      const auto& nameAndVisAtts = nameAndVisAttsByMaterial[material];
      const auto& name = nameAndVisAtts.fName;
      const auto& visAtts = nameAndVisAtts.fVisAtts;
      G4Polymarker dots;
      dots.SetVisAttributes(visAtts);
      dots.SetMarkerType(G4Polymarker::dots);
      dots.SetSize(G4VMarker::screen,1.);
      dots.SetInfo(name);
      // Enter empty polymarker into the map
      dotsByMaterial[material] = dots;
      // Now fill it in situ
      auto& dotsInMap = dotsByMaterial[material];
      const auto& range = verticesByMaterial.equal_range(material);
      for (auto vByMat = range.first; vByMat != range.second; ++vByMat) {
        dotsInMap.push_back(GetPointInTet(vByMat->second));
        ++nDots;
      }
 
      if (print) {
        G4cout
        << std::setw(30) << std::left << name.substr(0,30) << std::right
        << ": " << std::setw(7) << nDots << " dots"
        << ": colour " << std::fixed << std::setprecision(2)
        << visAtts.GetColour() << std::defaultfloat
        << G4endl;
      }
 
      nDotsTotal += nDots;
    }
 
    if (print) {
      G4cout << "Total number of dots: " << nDotsTotal << G4endl;
    }
  }
 
  // Some subsequent expressions apply only to G4PhysicalVolumeModel
  auto pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  G4String parameterisationName;
  if (pPVModel) {
    parameterisationName = pPVModel->GetFullPVPath().back().GetPhysicalVolume()->GetName();
  }
 
  // Draw the dots by material
  // Ensure they are "hidden", i.e., use the z-buffer as non-marker primitives do
  auto keepVP = fpViewer->GetViewParameters();
  auto vp = fpViewer->GetViewParameters();
  vp.SetMarkerHidden();
  fpViewer->SetViewParameters(vp);
 
  // Now we transform to world coordinates
  BeginPrimitives (mesh.GetTransform());
  for (const auto& entry: dotsByMaterial) {
    const auto& dots = entry.second;
    // The current "leaf" node in the PVPath is the parameterisation. Here it has
    // been converted into polymarkers by material. So...temporarily...change
    // its name to that of the material (whose name has been stored in Info)
    // so that its appearance in the scene tree of, e.g., G4OpenGLQtViewer, has
    // an appropriate name and its visibility and colour may be changed.
    if (pPVModel) {
      const auto& fullPVPath = pPVModel->GetFullPVPath();
      auto leafPV = fullPVPath.back().GetPhysicalVolume();
      leafPV->SetName(dots.GetInfo());
    }
    AddPrimitive(dots);
  }
  EndPrimitives ();
 
  // Restore view parameters
  fpViewer->SetViewParameters(keepVP);
  // Restore parameterisation name
  if (pPVModel) {
    pPVModel->GetFullPVPath().back().GetPhysicalVolume()->SetName(parameterisationName);
  }
 
  firstPrint = false;
  return;
}

Referenced by StandardSpecialMeshRendering().

DrawTetMeshAsSurfaces()

void G4VSceneHandler::DrawTetMeshAsSurfaces ( const G4Mesh & mesh )

protected

Definition at line 1838 of file G4VSceneHandler.cc.

{
  // Check
  if (mesh.GetMeshType() != G4Mesh::tetrahedron) {
    G4ExceptionDescription ed;
    ed << "Called with mesh that is not a tetrahedron mesh:" << mesh;
    G4Exception("G4VSceneHandler::DrawTetMeshAsSurfaces","visman0108",JustWarning,ed);
    return;
  }
 
  static G4bool firstPrint = true;
  const auto& verbosity = G4VisManager::GetVerbosity();
  G4bool print = firstPrint && verbosity >= G4VisManager::errors;
 
  if (print) {
    G4cout
    << "Special case drawing of tetrahedron mesh as surfaces"
    << '\n' << mesh
    << G4endl;
  }
 
  // This map is static so that once filled it stays filled.
  static std::map<G4String,std::map<const G4Material*,G4Polyhedron>> surfacesByMaterialAndMesh;
  auto& surfacesByMaterial = surfacesByMaterialAndMesh[mesh.GetContainerVolume()->GetName()];
 
  // Fill map if not already filled
  if (surfacesByMaterial.empty()) {
 
    // Get vertices and colour one cell at a time (using PseudoSceneForTetVertices).
    // The pseudo scene allows a "private" descent into the parameterisation.
    // Instantiate a temporary G4PhysicalVolumeModel
    G4ModelingParameters tmpMP;
    tmpMP.SetCulling(true);  // This avoids drawing transparent...
    tmpMP.SetCullingInvisible(true);  // ... or invisble volumes.
    const G4bool useFullExtent = true;  // To avoid calculating the extent
    G4PhysicalVolumeModel tmpPVModel
    (mesh.GetContainerVolume(),
     G4PhysicalVolumeModel::UNLIMITED,
     G4Transform3D(),  // so that positions are in local coordinates
     &tmpMP,
     useFullExtent);
    // Accumulate information in temporary maps by material
    std::multimap<const G4Material*,std::vector<G4ThreeVector>> verticesByMaterial;
    std::map<const G4Material*,G4VSceneHandler::NameAndVisAtts> nameAndVisAttsByMaterial;
    // Instantiate a pseudo scene
    PseudoSceneForTetVertices pseudoScene
    (&tmpPVModel,&mesh,verticesByMaterial,nameAndVisAttsByMaterial);
    // Make private descent into the parameterisation
    tmpPVModel.DescribeYourselfTo(pseudoScene);
    // Now we have a map of vertices by material.
    // Also a map of name and colour by material.
 
    // Fill the permanent (static) map of surfaces by material
    G4int nTetsTotal = 0, nFacetsTotal = 0;
    for (const auto& entry: nameAndVisAttsByMaterial) {
      G4int nTets = 0;
      const auto& material = entry.first;
      const auto& nameAndVisAtts = nameAndVisAttsByMaterial[material];
      const auto& name = nameAndVisAtts.fName;
      const auto& visAtts = nameAndVisAtts.fVisAtts;
      // Transfer vertices into a vector ready for creating polyhedral surface
      std::vector<G4ThreeVector> verticesForPolyhedron;
      const auto& range = verticesByMaterial.equal_range(material);
      for (auto vByMat = range.first; vByMat != range.second; ++vByMat) {
        const std::vector<G4ThreeVector>& vertices = vByMat->second;
        for (const auto& vertex: vertices)
          verticesForPolyhedron.push_back(vertex);
        ++nTets;
      }
      // The polyhedron will be in local coordinates
      // Add an empty place-holder to the map and get a reference to it
      auto& polyhedron = surfacesByMaterial[material];
      // Replace with the desired polyhedron (uses efficient "move assignment")
      polyhedron = G4PolyhedronTetMesh(verticesForPolyhedron);
      polyhedron.SetVisAttributes(visAtts);
      polyhedron.SetInfo(name);
 
      if (print) {
        G4cout
        << std::setw(30) << std::left << name.substr(0,30) << std::right
        << ": " << std::setw(7) << nTets << " tetrahedra"
        << " (" << std::setw(7) << 4*nTets << " faces)"
        << ": reduced to " << std::setw(7) << polyhedron.GetNoFacets() << " facets ("
        << std::setw(2) << std::fixed << std::setprecision(2) << 100*polyhedron.GetNoFacets()/(4*nTets)
        << "%): colour " << std::fixed << std::setprecision(2)
        << visAtts.GetColour() << std::defaultfloat
        << G4endl;
     }
 
      nTetsTotal += nTets;
      nFacetsTotal += polyhedron.GetNoFacets();
    }
 
    if (print) {
      G4cout << "Total number of tetrahedra: " << nTetsTotal << " (" << 4*nTetsTotal << " faces)"
      << ": reduced to " << nFacetsTotal << " facets ("
      << std::setw(2) << std::fixed << std::setprecision(2) << 100*nFacetsTotal/(4*nTetsTotal) << "%)"
      << G4endl;
    }
  }
 
  // Some subsequent expressions apply only to G4PhysicalVolumeModel
  auto pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
 
  G4String parameterisationName;
  if (pPVModel) {
    parameterisationName = pPVModel->GetFullPVPath().back().GetPhysicalVolume()->GetName();
  }
 
  // Draw the surfaces by material
  // Now we transform to world coordinates
  BeginPrimitives (mesh.GetTransform());
  for (const auto& entry: surfacesByMaterial) {
    const auto& poly = entry.second;
    // The current "leaf" node in the PVPath is the parameterisation. Here it has
    // been converted into polyhedra by material. So...temporarily...change
    // its name to that of the material (whose name has been stored in Info)
    // so that its appearance in the scene tree of, e.g., G4OpenGLQtViewer, has
    // an appropriate name and its visibility and colour may be changed.
    if (pPVModel) {
      const auto& fullPVPath = pPVModel->GetFullPVPath();
      auto leafPV = fullPVPath.back().GetPhysicalVolume();
      leafPV->SetName(poly.GetInfo());
    }
    AddPrimitive(poly);
  }
  EndPrimitives ();
 
  // Restore parameterisation name
  if (pPVModel) {
    pPVModel->GetFullPVPath().back().GetPhysicalVolume()->SetName(parameterisationName);
  }
 
  firstPrint = false;
  return;
}

Referenced by StandardSpecialMeshRendering().

EndModeling()

void G4VSceneHandler::EndModeling ( )

virtual

Reimplemented in G4ASCIITreeSceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLStoredSceneHandler, G4VRML2FileSceneHandler, and G4VTreeSceneHandler.

Definition at line 218 of file G4VSceneHandler.cc.

{
  fpModel = 0;
}

Referenced by G4GMocrenFileSceneHandler::EndModeling(), G4HepRepFileSceneHandler::EndModeling(), G4OpenGLImmediateSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::EndModeling(), G4VTreeSceneHandler::EndModeling(), G4GMocrenFileSceneHandler::GFEndModeling(), and ProcessScene().

EndPrimitives()

void G4VSceneHandler::EndPrimitives ( )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 180 of file G4VSceneHandler.cc.

                                     {
  if (fNestingDepth <= 0)
    G4Exception("G4VSceneHandler::EndPrimitives",
        "visman0102", FatalException, "Nesting error.");
  fNestingDepth--;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

Referenced by Draw3DRectMeshAsDots(), Draw3DRectMeshAsSurfaces(), DrawTetMeshAsDots(), DrawTetMeshAsSurfaces(), G4GMocrenFileSceneHandler::EndPrimitives(), G4OpenGLSceneHandler::EndPrimitives(), G4Qt3DSceneHandler::EndPrimitives(), RequestPrimitives(), and StandardSpecialMeshRendering().

EndPrimitives2D()

void G4VSceneHandler::EndPrimitives2D ( )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, and G4Qt3DSceneHandler.

Definition at line 203 of file G4VSceneHandler.cc.

                                       {
  if (fNestingDepth <= 0)
    G4Exception("G4VSceneHandler::EndPrimitives2D",
        "visman0104", FatalException, "Nesting error.");
  fNestingDepth--;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
  fProcessing2D = false;
}

Referenced by G4HepRepFileSceneHandler::EndPrimitives2D(), G4OpenGLSceneHandler::EndPrimitives2D(), and G4Qt3DSceneHandler::EndPrimitives2D().

GetAuxEdgeVisible()

G4bool G4VSceneHandler::GetAuxEdgeVisible

(

const G4VisAttributes *

pVisAttribs

)

Definition at line 1227 of file G4VSceneHandler.cc.

                                                                             {
  G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
  if (pVisAttribs -> IsForceAuxEdgeVisible()) {
    isAuxEdgeVisible = pVisAttribs->IsForcedAuxEdgeVisible();
  }
  return isAuxEdgeVisible;
}

Referenced by G4OpenGLSceneHandler::AddPrimitive().

GetColor() [1/2]

const G4Colour & G4VSceneHandler::GetColor

(

)

GetColor() [2/2]

const G4Colour & G4VSceneHandler::GetColor

(

const G4Visible &

)

GetColour() [1/2]

const G4Colour & G4VSceneHandler::GetColour

(

)

Definition at line 1140 of file G4VSceneHandler.cc.

                                            {
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  const G4Colour& colour = fpVisAttribs -> GetColour ();
  return colour;
}

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::addPVSceneTreeElement(), and GetColour().

GetColour() [2/2]

const G4Colour & G4VSceneHandler::GetColour

(

const G4Visible &

visible

)

Definition at line 1146 of file G4VSceneHandler.cc.

                                                                    {
  auto pVA = visible.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultVisAttributes();
  return pVA->GetColour();
}

GetCurrentViewer()

G4VViewer * G4VSceneHandler::GetCurrentViewer

(

)

const

GetDrawingStyle()

G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle

(

const G4VisAttributes *

pVisAttribs

)

Definition at line 1167 of file G4VSceneHandler.cc.

                                     {
  // Drawing style is normally determined by the view parameters, but
  // it can be overriddden by the ForceDrawingStyle flag in the vis
  // attributes.
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  const G4ViewParameters::DrawingStyle viewerStyle = vp.GetDrawingStyle();
  G4ViewParameters::DrawingStyle resultantStyle = viewerStyle;
  if (pVisAttribs -> IsForceDrawingStyle ()) {
    G4VisAttributes::ForcedDrawingStyle forcedStyle =
    pVisAttribs -> GetForcedDrawingStyle ();
    // This is complicated because if hidden line and surface removal
    // has been requested we wish to preserve this sometimes.
    switch (forcedStyle) {
      case (G4VisAttributes::solid):
        switch (viewerStyle) {
          case (G4ViewParameters::hlr):
            resultantStyle = G4ViewParameters::hlhsr;
            break;
          case (G4ViewParameters::wireframe):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::cloud):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::hlhsr):
          case (G4ViewParameters::hsr):
            break;
        }
        break;
      case (G4VisAttributes::cloud):
        resultantStyle = G4ViewParameters::cloud;
        break;
      case (G4VisAttributes::wireframe):
      default:
        // But if forced style is wireframe, do it, because one of its
        // main uses is in displaying the consituent solids of a Boolean
        // solid and their surfaces overlap with the resulting Booean
        // solid, making a mess if hlr is specified.
        resultantStyle = G4ViewParameters::wireframe;
        break;
    }
  }
  return resultantStyle;
}

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), and RequestPrimitives().

GetExtent()

const G4VisExtent & G4VSceneHandler::GetExtent ( ) const

virtual

Reimplemented from G4VGraphicsScene.

Definition at line 141 of file G4VSceneHandler.cc.

{
  if (fpScene) {
    return fpScene->GetExtent();
  } else {
    static const G4VisExtent defaultExtent = G4VisExtent();
    return defaultExtent;
  }
}

Referenced by G4VtkViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::wheel_rotate(), and G4Qt3DViewer::wheelEvent().

GetGraphicsSystem()

G4VGraphicsSystem * G4VSceneHandler::GetGraphicsSystem

(

)

const

Referenced by G4ASCIITreeSceneHandler::BeginModeling(), G4ASCIITreeSceneHandler::EndModeling(), G4OpenInventorViewer::G4OpenInventorViewer(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VisCommandViewerList::SetNewValue(), and G4ASCIITreeSceneHandler::WriteHeader().

GetLineWidth()

G4double G4VSceneHandler::GetLineWidth

(

const G4VisAttributes *

pVisAttribs

)

Definition at line 1158 of file G4VSceneHandler.cc.

{
  G4double lineWidth = pVisAttribs->GetLineWidth();
  if (lineWidth < 1.) lineWidth = 1.;
  lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
  if (lineWidth < 1.) lineWidth = 1.;
  return lineWidth;
}

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), and G4OpenGLSceneHandler::AddPrimitive().

GetMarkerDiameter()

G4double G4VSceneHandler::GetMarkerDiameter	(	const G4VMarker &	,
		MarkerSizeType &	)

GetMarkerRadius()

G4double G4VSceneHandler::GetMarkerRadius	(	const G4VMarker &	,
		MarkerSizeType &	)

GetMarkerSize()

G4double G4VSceneHandler::GetMarkerSize	(	const G4VMarker &	marker,
		G4VSceneHandler::MarkerSizeType &	markerSizeType )

Definition at line 1235 of file G4VSceneHandler.cc.

{
  G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
  const G4VMarker& defaultMarker =
    fpViewer -> GetViewParameters().GetDefaultMarker();
  G4double size = userSpecified ?
    marker.GetWorldSize() : defaultMarker.GetWorldSize();
  if (size) {
    // Draw in world coordinates.
    markerSizeType = world;
  }
  else {
    size = userSpecified ?
      marker.GetScreenSize() : defaultMarker.GetScreenSize();
    // Draw in screen coordinates.
    markerSizeType = screen;
  }
  size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
  if (markerSizeType == screen && size < 1.) size = 1.;
  return size;
}

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

GetMarkForClearingTransientStore()

G4bool G4VSceneHandler::GetMarkForClearingTransientStore

(

)

const

GetModel()

G4VModel * G4VSceneHandler::GetModel

(

)

const

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), and G4VtkSceneHandler::AddSolid().

GetName()

const G4String & G4VSceneHandler::GetName

(

)

const

Referenced by G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), AddCompound(), G4GMocrenFileSceneHandler::AddSolid(), G4VViewer::G4VViewer(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandSceneHandlerList::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), and G4VisCommandViewerUpdate::SetNewValue().

GetNoOfSides()

G4int G4VSceneHandler::GetNoOfSides

(

const G4VisAttributes *

pVisAttribs

)

Definition at line 1259 of file G4VSceneHandler.cc.

{
  // No. of sides (lines segments per circle) is normally determined
  // by the view parameters, but it can be overriddden by the
  // ForceLineSegmentsPerCircle in the vis attributes.
  G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
  if (pVisAttribs) {
    if (pVisAttribs->IsForceLineSegmentsPerCircle())
      lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
    if (lineSegmentsPerCircle < pVisAttribs->GetMinLineSegmentsPerCircle()) {
      lineSegmentsPerCircle = pVisAttribs->GetMinLineSegmentsPerCircle();
      G4warn <<
    "G4VSceneHandler::GetNoOfSides: attempt to set the"
    "\nnumber of line segments per circle < " << lineSegmentsPerCircle
         << "; forced to " << pVisAttribs->GetMinLineSegmentsPerCircle() << G4endl;
    }
  }
  return lineSegmentsPerCircle;
}

Referenced by G4OpenGLSceneHandler::AddPrimitive(), and RequestPrimitives().

GetNumberOfCloudPoints()

G4int G4VSceneHandler::GetNumberOfCloudPoints

(

const G4VisAttributes *

pVisAttribs

)

const

Definition at line 1213 of file G4VSceneHandler.cc.

                                           {
  // 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.
  G4int numberOfCloudPoints = fpViewer->GetViewParameters().GetNumberOfCloudPoints();
  if (pVisAttribs -> IsForceDrawingStyle() &&
      pVisAttribs -> GetForcedDrawingStyle() == G4VisAttributes::cloud &&
      pVisAttribs -> GetForcedNumberOfCloudPoints() > 0) {
    numberOfCloudPoints = pVisAttribs -> GetForcedNumberOfCloudPoints();
  }
  return numberOfCloudPoints;
}

Referenced by RequestPrimitives().

GetObjectTransformation()

const G4Transform3D & G4VSceneHandler::GetObjectTransformation

(

)

const

GetPointInBox()

G4ThreeVector G4VSceneHandler::GetPointInBox ( const G4ThreeVector & pos, G4double halfX, G4double halfY, G4double halfZ ) const

protected

Definition at line 1978 of file G4VSceneHandler.cc.

{
  G4double x = pos.getX() + (2.*G4QuickRand() - 1.)*halfX;
  G4double y = pos.getY() + (2.*G4QuickRand() - 1.)*halfY;
  G4double z = pos.getZ() + (2.*G4QuickRand() - 1.)*halfZ;
  return G4ThreeVector(x, y, z);
}

Referenced by Draw3DRectMeshAsDots().

GetPointInTet()

G4ThreeVector G4VSceneHandler::GetPointInTet ( const std::vector< G4ThreeVector > & vertices ) const

protected

Definition at line 1990 of file G4VSceneHandler.cc.

{
  G4double p = G4QuickRand();
  G4double q = G4QuickRand();
  G4double r = G4QuickRand();
  if (p + q > 1.)
  {
    p = 1. - p;
    q = 1. - q;
  }
  if (q + r > 1.)
  {
    G4double tmp = r;
    r = 1. - p - q;
    q = 1. - tmp;
  }
  else if (p + q + r > 1.)
  {
    G4double tmp = r;
    r = p + q + r - 1.;
    p = 1. - q - tmp;
  }
  G4double a = 1. - p - q - r;
  return vertices[0]*a + vertices[1]*p + vertices[2]*q + vertices[3]*r;
}

Referenced by DrawTetMeshAsDots().

GetScene()

G4Scene * G4VSceneHandler::GetScene

(

)

const

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CheckSceneAndNotifyHandlers(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4GMocrenFileSceneHandler::GFBeginModeling(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLXmViewer::left_right_pan_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4VVisCommand::RefreshIfRequired(), G4OpenGLXmViewer::ResetView(), G4DAWNFILEViewer::SendViewParameters(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetSceneHandlerId()

G4int G4VSceneHandler::GetSceneHandlerId

(

)

const

Referenced by G4OpenGLXmViewer::actions_callback(), and G4OpenGLXmViewer::misc_callback().

GetTextColor()

const G4Colour & G4VSceneHandler::GetTextColor

(

const G4Text &

)

GetTextColour()

const G4Colour & G4VSceneHandler::GetTextColour

(

const G4Text &

text

)

Definition at line 1152 of file G4VSceneHandler.cc.

                                                                  {
  auto pVA = text.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultTextVisAttributes();
  return pVA->GetColour();
}

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), and G4OpenGLXViewer::DrawText().

GetTransientsDrawnThisEvent()

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent

(

)

const

GetTransientsDrawnThisRun()

G4bool G4VSceneHandler::GetTransientsDrawnThisRun

(

)

const

GetViewCount()

G4int G4VSceneHandler::GetViewCount

(

)

const

GetViewerList()

const G4ViewerList & G4VSceneHandler::GetViewerList

(

)

const

IncrementViewCount()

G4int G4VSceneHandler::IncrementViewCount

(

)

IsReadyForTransients()

G4bool G4VSceneHandler::IsReadyForTransients

(

)

const

LoadAtts()

void G4VSceneHandler::LoadAtts ( const G4Visible & visible, G4AttHolder * holder )

protected

Definition at line 1080 of file G4VSceneHandler.cc.

{
  // Load G4Atts from G4VisAttributes, if any...
  const G4VisAttributes* va = visible.GetVisAttributes();
  if (va) {
    const std::map<G4String,G4AttDef>* vaDefs =
      va->GetAttDefs();
    if (vaDefs) {
      holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
    }
  }
 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (pPVModel) {
    // Load G4Atts from G4PhysicalVolumeModel...
    const std::map<G4String,G4AttDef>* pvDefs = pPVModel->GetAttDefs();
    if (pvDefs) {
      holder->AddAtts(pPVModel->CreateCurrentAttValues(), pvDefs);
    }
  }
 
  G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajModel) {
    // Load G4Atts from trajectory model...
    const std::map<G4String,G4AttDef>* trajModelDefs = trajModel->GetAttDefs();
    if (trajModelDefs) {
      holder->AddAtts(trajModel->CreateCurrentAttValues(), trajModelDefs);
    }
    // Load G4Atts from trajectory...
    const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
    if (traj) {
      const std::map<G4String,G4AttDef>* trajDefs = traj->GetAttDefs();
      if (trajDefs) {
        holder->AddAtts(traj->CreateAttValues(), trajDefs);
      }
      G4int nPoints = traj->GetPointEntries();
      for (G4int i = 0; i < nPoints; ++i) {
        G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
        if (trajPoint) {
          const std::map<G4String,G4AttDef>* pointDefs = trajPoint->GetAttDefs();
          if (pointDefs) {
            holder->AddAtts(trajPoint->CreateAttValues(), pointDefs);
          }
        }
      }
    }
  }
 
  G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
  if (hitsModel) {
    // Load G4Atts from hit...
    const G4VHit* hit = hitsModel->GetCurrentHit();
    const std::map<G4String,G4AttDef>* hitsDefs = hit->GetAttDefs();
    if (hitsDefs) {
      holder->AddAtts(hit->CreateAttValues(), hitsDefs);
    }
  }
}

Referenced by G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), and G4OpenInventorSceneHandler::AddPrimitive().

PostAddSolid()

void G4VSceneHandler::PostAddSolid ( )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 158 of file G4VSceneHandler.cc.

                                    {
  fpVisAttribs = 0;
  fProcessingSolid = false;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

Referenced by AddCompound(), and G4Qt3DSceneHandler::PostAddSolid().

PreAddSolid()

void G4VSceneHandler::PreAddSolid ( const G4Transform3D & objectTransformation, const G4VisAttributes & visAttribs )

virtual

Implements G4VGraphicsScene.

Reimplemented in G4OpenGLSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 151 of file G4VSceneHandler.cc.

                                                      {
  fObjectTransformation = objectTransformation;
  fpVisAttribs = &visAttribs;
  fProcessingSolid = true;
}

Referenced by AddCompound(), G4OpenGLSceneHandler::PreAddSolid(), G4OpenInventorSceneHandler::PreAddSolid(), G4Qt3DSceneHandler::PreAddSolid(), and G4VTreeSceneHandler::PreAddSolid().

ProcessScene()

void G4VSceneHandler::ProcessScene ( )

protectedvirtual

Reimplemented in G4OpenGLSceneHandler.

Definition at line 677 of file G4VSceneHandler.cc.

{
  // Assumes graphics database store has already been cleared if
  // relevant for the particular scene handler.
 
  if(!fpScene)
    return;
 
  if(fpScene->GetExtent() == G4VisExtent::GetNullExtent())
  {
    G4Exception("G4VSceneHandler::ProcessScene", "visman0106", JustWarning,
                "The scene has no extent.");
  }
 
  G4VisManager* visManager = G4VisManager::GetInstance();
 
  if(!visManager->GetConcreteInstance())
    return;
 
  G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
 
  fReadyForTransients = false;
 
  // Reset fMarkForClearingTransientStore. (Leaving
  // fMarkForClearingTransientStore true causes problems with
  // recomputing transients below.)  Restore it again at end...
  G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
  fMarkForClearingTransientStore          = false;
 
  // Traverse geometry tree and send drawing primitives to window(s).
 
  const std::vector<G4Scene::Model>& runDurationModelList =
    fpScene->GetRunDurationModelList();
 
  if(runDurationModelList.size())
  {
    if(verbosity >= G4VisManager::confirmations)
    {
      G4cout << "Traversing scene data..." << G4endl;
    }
 
    // Reset visibility of all objects to false - visible objects will then set to true
    fpViewer->AccessSceneTree().ResetVisibility();
    
    BeginModeling();
 
    // Create modeling parameters from view parameters...
    G4ModelingParameters* pMP = CreateModelingParameters();
 
    for(std::size_t i = 0; i < runDurationModelList.size(); ++i)
    {
      if(runDurationModelList[i].fActive)
      {
    fpModel = runDurationModelList[i].fpModel;
    fpModel->SetModelingParameters(pMP);
 
        // Describe to the current scene handler
        fpModel->DescribeYourselfTo(*this);
 
        // To see the extents of each model represented as wireframe boxes,
        // uncomment the next line and DrawExtent in namespace above.
        // DrawExtent(fpModel);
 
        // Enter models in the scene tree, and for PV models, describe
        // the model to the scene tree, i.e., enter all the touchables.
        auto& sceneTreeScene = fpViewer->AccessSceneTreeScene();
        sceneTreeScene.SetViewer(fpViewer);
        sceneTreeScene.SetModel(fpModel);
        if (dynamic_cast<G4PhysicalVolumeModel*>(fpModel)) {
          fpModel->DescribeYourselfTo(sceneTreeScene);
        }
 
        // Reset modeling parameters pointer
    fpModel->SetModelingParameters(0);
      }
    }
 
    fpModel = 0;
    delete pMP;
 
    EndModeling();
  }
 
  fReadyForTransients = true;
 
  // Refresh event from end-of-event model list.
  // Allow only in Idle or GeomClosed state...
  G4StateManager* stateManager = G4StateManager::GetStateManager();
  G4ApplicationState state     = stateManager->GetCurrentState();
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    visManager->SetEventRefreshing(true);
 
    if(visManager->GetRequestedEvent())
    {
      DrawEvent(visManager->GetRequestedEvent());
    }
    else
    {
      G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
      if(runManager)
      {
        const G4Run* run = runManager->GetCurrentRun();
        // Draw a null event in order to pick up models for the scene tree even before a run
        if (run == nullptr) DrawEvent(0);
        const std::vector<const G4Event*>* events =
          run ? run->GetEventVector() : 0;
        std::size_t nKeptEvents = 0;
        if(events)
          nKeptEvents = events->size();
        if(nKeptEvents)
        {
          if(fpScene->GetRefreshAtEndOfEvent())
          {
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing event..." << G4endl;
            }
            const G4Event* event = 0;
            if(events && events->size())
              event = events->back();
            if(event)
              DrawEvent(event);
          }
          else
          {  // Accumulating events.
 
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing events in run..." << G4endl;
            }
            for(const auto& event : *events)
            {
              if(event)
                DrawEvent(event);
            }
 
            if(!fpScene->GetRefreshAtEndOfRun())
            {
              if(verbosity >= G4VisManager::warnings)
              {
                G4warn << "WARNING: Cannot refresh events accumulated over more"
                          "\n  than one runs.  Refreshed just the last run."
                       << G4endl;
              }
            }
          }
        }
      }
    }
    visManager->SetEventRefreshing(false);
  }
 
  // Refresh end-of-run model list.
  // Allow only in Idle or GeomClosed state...
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    DrawEndOfRunModels();
  }
 
  fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
}

Referenced by G4OpenGLSceneHandler::ProcessScene(), and G4VViewer::ProcessView().

RemoveViewerFromList()

void G4VSceneHandler::RemoveViewerFromList

(

G4VViewer *

pView

)

Definition at line 504 of file G4VSceneHandler.cc.

                                                              {
  fViewerList.remove(pViewer);  // Does nothing if already removed
  // And reset current viewer
  auto visManager = G4VisManager::GetInstance();
  visManager->SetCurrentViewer(nullptr);
}

Referenced by G4VViewer::~G4VViewer().

RequestPrimitives()

void G4VSceneHandler::RequestPrimitives ( const G4VSolid & solid )

protectedvirtual

Reimplemented in G4ASCIITreeSceneHandler, and G4RayTracerSceneHandler.

Definition at line 527 of file G4VSceneHandler.cc.

{
  // Sometimes solids that have no substance get requested. They may
  // be part of the geometry tree but have been "spirited away", for
  // example by a Boolean subtraction in which the original volume
  // is entirely inside the subtractor or an intersection in which
  // the original volume is entirely outside the intersector.
  // The problem is that the Boolean Processor still returns a
  // polyhedron in these cases (IMHO it should not), so the
  // workaround is to return before the damage is done.
  // Algorithm by Evgueni Tcherniaev
  auto pSolid = &solid;
  auto pBooleanSolid = dynamic_cast<const G4BooleanSolid*>(pSolid);
  if (pBooleanSolid) {
    G4ThreeVector bmin, bmax;
    pBooleanSolid->BoundingLimits(bmin, bmax);
    G4bool isGood = false;
    if (dynamic_cast<const G4SubtractionSolid*>(pBooleanSolid)) {
      auto ptrB = pBooleanSolid->GetConstituentSolid(1);
      for (G4int i=0; i<10; ++i) {
        G4double x = bmin.x() + (bmax.x() - bmin.x())*G4QuickRand();
        G4double y = bmin.y() + (bmax.y() - bmin.y())*G4QuickRand();
        G4double z = bmin.z() + (bmax.z() - bmin.z())*G4QuickRand();
        if (ptrB->Inside(G4ThreeVector(x,y,bmin.z())) != kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,y,bmax.z())) != kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,bmin.y(),z)) != kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,bmax.y(),z)) != kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(bmin.x(),y,z)) != kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(bmax.x(),y,z)) != kInside) { isGood = true; break; }
      }
    } else if (dynamic_cast<const G4IntersectionSolid*>(pBooleanSolid)) {
      auto ptrB = pBooleanSolid->GetConstituentSolid(1);
      for (G4int i=0; i<10; ++i) {
        G4double x = bmin.x() + (bmax.x() - bmin.x())*G4QuickRand();
        G4double y = bmin.y() + (bmax.y() - bmin.y())*G4QuickRand();
        G4double z = bmin.z() + (bmax.z() - bmin.z())*G4QuickRand();
        if (ptrB->Inside(G4ThreeVector(x,y,bmin.z())) == kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,y,bmax.z())) == kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,bmin.y(),z)) == kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(x,bmax.y(),z)) == kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(bmin.x(),y,z)) == kInside) { isGood = true; break; }
        if (ptrB->Inside(G4ThreeVector(bmax.x(),y,z)) == kInside) { isGood = true; break; }
      }
    }
    if (!isGood)
    {
      for (G4int i=0; i<10000; ++i) {
        G4double x = bmin.x() + (bmax.x() - bmin.x())*G4QuickRand();
        G4double y = bmin.y() + (bmax.y() - bmin.y())*G4QuickRand();
        G4double z = bmin.z() + (bmax.z() - bmin.z())*G4QuickRand();
        if (pBooleanSolid->Inside(G4ThreeVector(x,y,z)) == kInside) { isGood = true; break; }
      }
    }
    if (!isGood) return;
  }
 
  const G4ViewParameters::DrawingStyle style = GetDrawingStyle(fpVisAttribs);
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
 
  switch (style) {
    default:
    case G4ViewParameters::wireframe:
    case G4ViewParameters::hlr:
    case G4ViewParameters::hsr:
    case G4ViewParameters::hlhsr:
    {
      // Use polyhedral representation
      G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
      G4Polyhedron* pPolyhedron = solid.GetPolyhedron ();
      G4Polyhedron::ResetNumberOfRotationSteps ();
      if (pPolyhedron) {
        pPolyhedron -> SetVisAttributes (fpVisAttribs);
        BeginPrimitives (fObjectTransformation);
        AddPrimitive (*pPolyhedron);
        EndPrimitives ();
        break;
      } else {  // Print warnings and drop through to cloud
        G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
        static std::set<const G4VSolid*> problematicSolids;
        if (verbosity >= G4VisManager::errors &&
            problematicSolids.find(&solid) == problematicSolids.end()) {
          problematicSolids.insert(&solid);
          G4warn <<
          "ERROR: G4VSceneHandler::RequestPrimitives"
          "\n  Polyhedron not available for " << solid.GetName ();
          G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
          if (pPVModel) {
            G4warn << "\n  Touchable path: " << pPVModel->GetFullPVPath();
          }
          static G4bool explanation = false;
          if (!explanation) {
            explanation = true;
            G4warn <<
            "\n  This means it cannot be visualized in the usual way on most systems."
            "\n  1) The solid may not have implemented the CreatePolyhedron method."
            "\n  2) For Boolean solids, the BooleanProcessor, which attempts to create"
            "\n     the resultant polyhedron, may have failed."
            "\n  Try RayTracer. It uses Geant4's tracking algorithms instead.";
          }
          G4warn << "\n  Drawing solid with cloud of points.";
          G4warn << G4endl;
        }
      }
    }
      [[fallthrough]];
 
    case G4ViewParameters::cloud:
    {
      // Form solid out of cloud of dots on surface of solid
      G4Polymarker dots;
      // Note: OpenGL has a fast implementation of polymarker so it's better
      // to build a polymarker rather than add a succession of circles.
      // And anyway, in Qt, in the latter case each circle would be a scene-tree
      // entry, something we would want to avoid.
      dots.SetVisAttributes(fpVisAttribs);
      dots.SetMarkerType(G4Polymarker::dots);
      dots.SetSize(G4VMarker::screen,1.);
      G4int numberOfCloudPoints = GetNumberOfCloudPoints(fpVisAttribs);
      if (numberOfCloudPoints <= 0) numberOfCloudPoints = vp.GetNumberOfCloudPoints();
      for (G4int i = 0; i < numberOfCloudPoints; ++i) {
    G4ThreeVector p = solid.GetPointOnSurface();
    dots.push_back(p);
      }
      BeginPrimitives (fObjectTransformation);
      AddPrimitive(dots);
      EndPrimitives ();
      break;
    }
  }
}

Referenced by AddSolidT(), and AddSolidWithAuxiliaryEdges().

SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer

(

G4VViewer *

)

SetMarkForClearingTransientStore()

void G4VSceneHandler::SetMarkForClearingTransientStore

(

G4bool

)

Referenced by G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

SetModel()

void G4VSceneHandler::SetModel

(

G4VModel *

)

SetName()

void G4VSceneHandler::SetName

(

const G4String &

)

SetObjectTransformation()

void G4VSceneHandler::SetObjectTransformation

(

const G4Transform3D &

)

SetScene()

void G4VSceneHandler::SetScene ( G4Scene * pScene )

virtual

Reimplemented in G4OpenGLStoredQtSceneHandler.

Definition at line 518 of file G4VSceneHandler.cc.

                                               {
  fpScene = pScene;
  // Notify all viewers that a kernel visit is required.
  G4ViewerListIterator i;
  for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
    (*i) -> SetNeedKernelVisit (true);
  }
}

Referenced by G4OpenGLStoredQtSceneHandler::SetScene().

SetTransientsDrawnThisEvent()

void G4VSceneHandler::SetTransientsDrawnThisEvent

(

G4bool

)

SetTransientsDrawnThisRun()

void G4VSceneHandler::SetTransientsDrawnThisRun

(

G4bool

)

SetViewerList()

G4ViewerList & G4VSceneHandler::SetViewerList

(

)

StandardSpecialMeshRendering()

void G4VSceneHandler::StandardSpecialMeshRendering ( const G4Mesh & mesh )

protected

Definition at line 1346 of file G4VSceneHandler.cc.

{
  G4bool implemented = false;
  switch (mesh.GetMeshType()) {
    case G4Mesh::rectangle: [[fallthrough]];
    case G4Mesh::nested3DRectangular:
      switch (fpViewer->GetViewParameters().GetSpecialMeshRenderingOption()) {
        case G4ViewParameters::meshAsDefault:
          [[fallthrough]];
        case G4ViewParameters::meshAsDots:
          Draw3DRectMeshAsDots(mesh);  // Rectangular 3-deep mesh as dots
          implemented = true;
          break;
        case G4ViewParameters::meshAsSurfaces:
          Draw3DRectMeshAsSurfaces(mesh);  // Rectangular 3-deep mesh as surfaces
          implemented = true;
          break;
      }
      break;
    case G4Mesh::tetrahedron:
      switch (fpViewer->GetViewParameters().GetSpecialMeshRenderingOption()) {
        case G4ViewParameters::meshAsDefault:
          [[fallthrough]];
        case G4ViewParameters::meshAsDots:
          DrawTetMeshAsDots(mesh);  // Tetrahedron mesh as dots
          implemented = true;
          break;
        case G4ViewParameters::meshAsSurfaces:
          DrawTetMeshAsSurfaces(mesh);  // Tetrahedron mesh as surfaces
          implemented = true;
          break;
      }
      break;
    case G4Mesh::cylinder: [[fallthrough]];
    case G4Mesh::sphere: [[fallthrough]];
    case G4Mesh::invalid: break;
  }
  if (implemented) {
    // Draw container if not marked invisible...
    auto container = mesh.GetContainerVolume();
    auto containerLogical = container->GetLogicalVolume();
    auto containerVisAtts = containerLogical->GetVisAttributes();
    if (containerVisAtts == nullptr || containerVisAtts->IsVisible()) {
      auto solid = containerLogical->GetSolid();
      auto polyhedron = solid->GetPolyhedron();
      // Always draw as wireframe
      G4VisAttributes tmpVisAtts;
      if (containerVisAtts != nullptr) tmpVisAtts = *containerVisAtts;
      tmpVisAtts.SetForceWireframe();
      polyhedron->SetVisAttributes(tmpVisAtts);
      BeginPrimitives(mesh.GetTransform());
      AddPrimitive(*polyhedron);
      EndPrimitives();
    }
  } else {
    // Invoke base class function
    G4VSceneHandler::AddCompound(mesh);
  }
  return;
}

Referenced by G4OpenGLSceneHandler::AddCompound(), G4OpenInventorSceneHandler::AddCompound(), G4Qt3DSceneHandler::AddCompound(), G4ToolsSGSceneHandler::AddCompound(), and G4VtkSceneHandler::AddCompound().

Friends And Related Symbol Documentation

G4VViewer

friend class G4VViewer

friend

Definition at line 54 of file G4VSceneHandler.hh.

operator<<

std::ostream & operator<< ( std::ostream & os, const G4VSceneHandler & s )

friend

Definition at line 1279 of file G4VSceneHandler.cc.

                                                                    {
 
  os << "Scene handler " << sh.fName << " has "
     << sh.fViewerList.size () << " viewer(s):";
  for (std::size_t i = 0; i < sh.fViewerList.size (); ++i) {
    os << "\n  " << *(sh.fViewerList [i]);
  }
 
  if (sh.fpScene) {
    os << "\n  " << *sh.fpScene;
  }
  else {
    os << "\n  This scene handler currently has no scene.";
  }
 
  return os;
}

Member Data Documentation

fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protected

Definition at line 453 of file G4VSceneHandler.hh.

fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protected

Definition at line 441 of file G4VSceneHandler.hh.

Referenced by ProcessScene().

fName

G4String G4VSceneHandler::fName

protected

Definition at line 436 of file G4VSceneHandler.hh.

fNestingDepth

G4int G4VSceneHandler::fNestingDepth

protected

Definition at line 451 of file G4VSceneHandler.hh.

Referenced by BeginPrimitives(), EndPrimitives(), and EndPrimitives2D().

fObjectTransformation

G4Transform3D G4VSceneHandler::fObjectTransformation

protected

Definition at line 449 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), BeginPrimitives(), G4VtkSceneHandler::MakeDefaultVisContext(), PreAddSolid(), and RequestPrimitives().

fpModel

G4VModel* G4VSceneHandler::fpModel

protected

Definition at line 448 of file G4VSceneHandler.hh.

Referenced by G4GMocrenFileSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddCompound(), AddCompound(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkQtSceneHandler::AddPrimitive(), G4VtkQtSceneHandler::AddPrimitive(), G4VtkQtSceneHandler::AddPrimitive(), G4VtkQtSceneHandler::AddPrimitive(), G4VtkQtSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4Qt3DSceneHandler::CreateNewNode(), Draw3DRectMeshAsDots(), Draw3DRectMeshAsSurfaces(), DrawEndOfRunModels(), DrawEvent(), DrawTetMeshAsDots(), DrawTetMeshAsSurfaces(), EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4ToolsSGSceneHandler::GetOrCreateNode(), LoadAtts(), G4VTreeSceneHandler::PreAddSolid(), ProcessScene(), G4ASCIITreeSceneHandler::RequestPrimitives(), RequestPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

fProcessing2D

G4bool G4VSceneHandler::fProcessing2D

protected

Definition at line 447 of file G4VSceneHandler.hh.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), EndPrimitives2D(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenGLStoredQtSceneHandler::ExtraTOProcessing(), and G4VtkSceneHandler::MakeDefaultVisContext().

fProcessingSolid

G4bool G4VSceneHandler::fProcessingSolid

protected

Definition at line 446 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::BeginPrimitives(), PostAddSolid(), and PreAddSolid().

fpScene

G4Scene* G4VSceneHandler::fpScene

protected

Definition at line 440 of file G4VSceneHandler.hh.

Referenced by G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), CreateCutawaySolid(), CreateSectionSolid(), DrawEndOfRunModels(), DrawEvent(), G4ASCIITreeSceneHandler::EndModeling(), G4Qt3DSceneHandler::EstablishG4Qt3DQEntities(), G4RayTracerSceneHandler::G4RayTracerSceneHandler(), GetExtent(), G4Qt3DViewer::mouseMoveEvent(), ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4OpenGLStoredQtSceneHandler::SetScene(), and SetScene().

fpViewer

G4VViewer* G4VSceneHandler::fpViewer

protected

Definition at line 439 of file G4VSceneHandler.hh.

Referenced by AddCompound(), G4VtkSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), AddSolidT(), AddSolidWithAuxiliaryEdges(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredQtSceneHandler::ClearStore(), G4GMocrenFileSceneHandler::ClearTransientStore(), G4HepRepFileSceneHandler::ClearTransientStore(), G4OpenGLImmediateSceneHandler::ClearTransientStore(), G4OpenGLStoredQtSceneHandler::ClearTransientStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), CreateCutawaySolid(), CreateModelingParameters(), CreateSectionSolid(), Draw3DRectMeshAsDots(), DrawEndOfRunModels(), DrawEvent(), DrawTetMeshAsDots(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), GetAuxEdgeVisible(), GetColour(), GetColour(), GetDrawingStyle(), GetLineWidth(), GetMarkerSize(), GetNoOfSides(), GetNumberOfCloudPoints(), GetTextColour(), G4VtkSceneHandler::MakeDefaultVisContext(), ProcessScene(), RequestPrimitives(), G4OpenGLStoredQtSceneHandler::SetScene(), and StandardSpecialMeshRendering().

fpVisAttribs

const G4VisAttributes* G4VSceneHandler::fpVisAttribs

protected

Definition at line 452 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), AddSolidT(), AddSolidWithAuxiliaryEdges(), G4RayTracerSceneHandler::BuildVisAttsMap(), GetColour(), G4VtkSceneHandler::MakeDefaultVisContext(), PostAddSolid(), PreAddSolid(), and RequestPrimitives().

fReadyForTransients

G4bool G4VSceneHandler::fReadyForTransients

protected

Definition at line 442 of file G4VSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddCompound(), G4ToolsSGSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLStoredSceneHandler::BeginPrimitives(), G4OpenGLStoredSceneHandler::BeginPrimitives2D(), G4Qt3DSceneHandler::CreateNewNode(), EndPrimitives(), EndPrimitives2D(), G4ToolsSGSceneHandler::GetOrCreateNode(), PostAddSolid(), ProcessScene(), and G4OpenGLSceneHandler::ScaledFlush().

fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protected

Definition at line 435 of file G4VSceneHandler.hh.

fSystem

G4VGraphicsSystem& G4VSceneHandler::fSystem

protected

Definition at line 434 of file G4VSceneHandler.hh.

Referenced by AddPrimitive().

fTransientsDrawnThisEvent

G4bool G4VSceneHandler::fTransientsDrawnThisEvent

protected

Definition at line 444 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), EndPrimitives2D(), and PostAddSolid().

fTransientsDrawnThisRun

G4bool G4VSceneHandler::fTransientsDrawnThisRun

protected

Definition at line 445 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), EndPrimitives2D(), and PostAddSolid().

fViewCount

G4int G4VSceneHandler::fViewCount

protected

Definition at line 437 of file G4VSceneHandler.hh.

fViewerList

G4ViewerList G4VSceneHandler::fViewerList

protected

Definition at line 438 of file G4VSceneHandler.hh.

Referenced by G4GMocrenFileSceneHandler::AddCompound(), AddViewerToList(), RemoveViewerFromList(), and SetScene().

---

The documentation for this class was generated from the following files:

• G4VSceneHandler.hh
• G4VSceneHandler.cc