G4RayTracerSceneHandler Class Reference

#include <G4RayTracerSceneHandler.hh>

Inheritance diagram for G4RayTracerSceneHandler:

Data Structures
struct	PathLessThan

Public Types
enum	MarkerSizeType { world , screen }

Public Member Functions
virtual void	AddCompound (const G4Mesh &)
virtual void	AddCompound (const G4THitsMap< G4double > &)
virtual void	AddCompound (const G4THitsMap< G4StatDouble > &)
virtual void	AddCompound (const G4VDigi &)
virtual void	AddCompound (const G4VHit &)
virtual void	AddCompound (const G4VTrajectory &)
void	AddPrimitive (const G4Circle &)
virtual void	AddPrimitive (const G4Circle &)=0
virtual void	AddPrimitive (const G4Plotter &)
void	AddPrimitive (const G4Polyhedron &)
virtual void	AddPrimitive (const G4Polyhedron &)=0
void	AddPrimitive (const G4Polyline &)
virtual void	AddPrimitive (const G4Polyline &)=0
virtual void	AddPrimitive (const G4Polymarker &)
void	AddPrimitive (const G4Polymarker &)
void	AddPrimitive (const G4Square &)
virtual void	AddPrimitive (const G4Square &)=0
void	AddPrimitive (const G4Text &)
virtual void	AddPrimitive (const G4Text &)=0
virtual void	AddSolid (const G4Box &)
virtual void	AddSolid (const G4Cons &)
virtual void	AddSolid (const G4Ellipsoid &)
virtual void	AddSolid (const G4Orb &)
virtual void	AddSolid (const G4Para &)
virtual void	AddSolid (const G4Polycone &)
virtual void	AddSolid (const G4Polyhedra &)
virtual void	AddSolid (const G4Sphere &)
virtual void	AddSolid (const G4TessellatedSolid &)
virtual void	AddSolid (const G4Torus &)
virtual void	AddSolid (const G4Trap &)
virtual void	AddSolid (const G4Trd &)
virtual void	AddSolid (const G4Tubs &)
virtual void	AddSolid (const G4VSolid &)
template<class T >
void	AddSolidT (const T &solid)
template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)
void	AddViewerToList (G4VViewer *pView)
virtual void	BeginModeling ()
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())
void	BuildVisAttsMap (const G4VSolid &solid)
void	ClearStore ()
virtual void	ClearTransientStore ()
G4ModelingParameters *	CreateModelingParameters ()
void	DrawEndOfRunModels ()
void	DrawEvent (const G4Event *)
virtual void	EndModeling ()
virtual void	EndPrimitives ()
virtual void	EndPrimitives2D ()
	G4RayTracerSceneHandler (G4VGraphicsSystem &system, const G4String &name="")
G4bool	GetAuxEdgeVisible (const G4VisAttributes *)
const G4Colour &	GetColor ()
const G4Colour &	GetColor (const G4Visible &)
const G4Colour &	GetColour ()
const G4Colour &	GetColour (const G4Visible &)
G4VViewer *	GetCurrentViewer () const
G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)
virtual const G4VisExtent &	GetExtent () const
G4VGraphicsSystem *	GetGraphicsSystem () const
G4double	GetLineWidth (const G4VisAttributes *)
G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)
G4bool	GetMarkForClearingTransientStore () const
G4VModel *	GetModel () const
const G4String &	GetName () const
G4int	GetNoOfSides (const G4VisAttributes *)
G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const
const G4Transform3D &	GetObjectTransformation () const
G4Scene *	GetScene () const
G4int	GetSceneHandlerId () const
const std::map< G4ModelingParameters::PVPointerCopyNoPath, G4VisAttributes, PathLessThan > &	GetSceneVisAttsMap () const
const G4Colour &	GetTextColor (const G4Text &)
const G4Colour &	GetTextColour (const G4Text &)
G4bool	GetTransientsDrawnThisEvent () const
G4bool	GetTransientsDrawnThisRun () const
G4int	GetViewCount () const
const G4ViewerList &	GetViewerList () const
G4int	IncrementViewCount ()
G4bool	IsReadyForTransients () const
virtual void	PostAddSolid ()
virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
void	RemoveViewerFromList (G4VViewer *pView)
void	RequestPrimitives (const G4VSolid &solid)
void	SetCurrentViewer (G4VViewer *)
void	SetMarkForClearingTransientStore (G4bool)
void	SetModel (G4VModel *)
void	SetName (const G4String &)
void	SetObjectTransformation (const G4Transform3D &)
virtual void	SetScene (G4Scene *)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetTransientsDrawnThisRun (G4bool)
G4ViewerList &	SetViewerList ()
virtual	~G4RayTracerSceneHandler ()

Protected Member Functions
virtual G4DisplacedSolid *	CreateCutawaySolid ()
virtual G4DisplacedSolid *	CreateSectionSolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
virtual void	ProcessScene ()

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

Private Attributes
std::map< G4ModelingParameters::PVPointerCopyNoPath, G4VisAttributes, PathLessThan >	fSceneVisAttsMap

Static Private Attributes
static G4int	fSceneIdCount = 0

Detailed Description

Definition at line 38 of file G4RayTracerSceneHandler.hh.

Member Enumeration Documentation

MarkerSizeType

enum G4VSceneHandler::MarkerSizeType

inherited

Enumerator
world
screen

Definition at line 58 of file G4VSceneHandler.hh.

{world, screen};

Constructor & Destructor Documentation

G4RayTracerSceneHandler()

G4RayTracerSceneHandler::G4RayTracerSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name = ""
	)

Definition at line 35 of file G4RayTracerSceneHandler.cc.

: G4VSceneHandler(system, fSceneIdCount++, name)
{
  // Keep vis manager happy when someone opens a ray tracer with "/vis/open
  // RayTracer" but uses the ray tracer with "/vis/rayTracer" commands
  // before creating any scenes, for example, instead of using
  // "/vis/drawVolume"...
  G4VisManager* visManager = G4VisManager::GetInstance();
  if(visManager) {
    G4Scene* pScene = visManager->GetCurrentScene();
    if (!pScene) {
      // Create new scene like /vis/scene/create...
      fpScene = new G4Scene("dummy-ray-tracer-scene");
      // Add dummy run-duration model to avoid world being added and
      // notifyHandler being invoked...
      fpScene->AddWorldIfEmpty();
      // Add to vis manager list; ownership thereby passes to vis manager...
      visManager->SetSceneList().push_back(fpScene);
      // ...and make current...
      visManager->SetCurrentScene(fpScene);
    }
  }
}

References G4Scene::AddWorldIfEmpty(), G4VSceneHandler::fpScene, G4VisManager::GetCurrentScene(), G4VisManager::GetInstance(), G4VisManager::SetCurrentScene(), and G4VisManager::SetSceneList().

~G4RayTracerSceneHandler()

G4RayTracerSceneHandler::~G4RayTracerSceneHandler ( )

virtual

Definition at line 60 of file G4RayTracerSceneHandler.cc.

{}

Member Function Documentation

AddCompound() [1/6]

void G4VSceneHandler::AddCompound ( const G4Mesh &  mesh )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 426 of file G4VSceneHandler.cc.

{
  G4ExceptionDescription ed;
  ed << "There has been an attempt to draw a mesh (a nested parameterisation),"
  "\nbut it is not implemented by the current graphics driver. Here we simply"
  "\ndraw the container, \"" << mesh.GetContainerVolume()->GetName() << "\".";
  G4Exception("G4VSceneHandler::AddCompound(const G4Mesh&)",
          "visman0107", JustWarning, ed);
 
  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
  const auto& saveVisAtts = lv->GetVisAttributes();
  auto 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);
}

References G4Exception(), G4Mesh::GetContainerVolume(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetName(), G4LogicalVolume::GetSolid(), G4Mesh::GetTransform(), JustWarning, G4VSceneHandler::PostAddSolid(), G4VSceneHandler::PreAddSolid(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

AddCompound() [2/6]

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

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 340 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++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();
  }
}

References G4VScoringMesh::DrawMesh(), G4cout, G4endl, G4ScoringManager::GetMesh(), G4VSceneHandler::GetName(), G4ScoringManager::GetNumberOfMesh(), G4VScoringMesh::GetScoreMap(), G4ScoringManager::GetScoringManagerIfExist(), and G4VScoringMesh::IsActive().

AddCompound() [3/6]

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

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 383 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++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();
  }
}

References G4VScoringMesh::DrawMesh(), G4cout, G4endl, G4ScoringManager::GetMesh(), G4ScoringManager::GetNumberOfMesh(), G4VScoringMesh::GetScoreMap(), G4ScoringManager::GetScoringManagerIfExist(), and G4VScoringMesh::IsActive().

AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi &  digi )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 335 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 )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 330 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 )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 318 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.");
  }
}

References G4VTrajectory::DrawTrajectory(), FatalException, G4VSceneHandler::fpModel, and G4Exception().

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

AddPrimitive() [1/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Circle &  )

inlinevirtual

Implements G4VSceneHandler.

Definition at line 56 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [2/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [3/13]

void G4VSceneHandler::AddPrimitive ( const G4Plotter &  )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 192 of file G4VSceneHandler.cc.

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

AddPrimitive() [4/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Polyhedron &  )

inlinevirtual

Implements G4VSceneHandler.

Definition at line 58 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [5/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [6/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Polyline &  )

inlinevirtual

Implements G4VSceneHandler.

Definition at line 54 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [7/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [8/13]

void G4VSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 190 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 (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        dot.SetPosition (polymarker[iPoint]);
        AddPrimitive (dot);
      }
    }
      break;
    case G4Polymarker::circles:
    {
      G4Circle circle (polymarker);  // Default circle
      for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        circle.SetPosition (polymarker[iPoint]);
        AddPrimitive (circle);
      }
    }
      break;
    case G4Polymarker::squares:
    {
      G4Square square (polymarker);  // Default square
      for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        square.SetPosition (polymarker[iPoint]);
        AddPrimitive (square);
      }
    }
      break;
  }
}

AddPrimitive() [9/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Polymarker &  )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 59 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [10/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Square &  )

inlinevirtual

Implements G4VSceneHandler.

Definition at line 57 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [11/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [12/13]

void G4RayTracerSceneHandler::AddPrimitive ( const G4Text &  )

inlinevirtual

Implements G4VSceneHandler.

Definition at line 55 of file G4RayTracerSceneHandler.hh.

{}

AddPrimitive() [13/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text &  )

virtual

Implements G4VSceneHandler.

AddSolid() [1/14]

void G4VSceneHandler::AddSolid ( const G4Box &  box )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 247 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.
}

References G4VSceneHandler::AddSolidT().

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

AddSolid() [2/14]

void G4VSceneHandler::AddSolid ( const G4Cons &  cons )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 266 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (cons);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [3/14]

void G4VSceneHandler::AddSolid ( const G4Ellipsoid &  ellipsoid )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 298 of file G4VSceneHandler.cc.

                                                            {
  AddSolidWithAuxiliaryEdges (ellipsoid);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [4/14]

void G4VSceneHandler::AddSolid ( const G4Orb &  orb )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 270 of file G4VSceneHandler.cc.

                                                {
  AddSolidWithAuxiliaryEdges (orb);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [5/14]

void G4VSceneHandler::AddSolid ( const G4Para &  para )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 274 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (para);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [6/14]

void G4VSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 302 of file G4VSceneHandler.cc.

                                                          {
  AddSolidT (polycone);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [7/14]

void G4VSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 306 of file G4VSceneHandler.cc.

                                                            {
  AddSolidT (polyhedra);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [8/14]

void G4VSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 278 of file G4VSceneHandler.cc.

                                                      {
  AddSolidWithAuxiliaryEdges (sphere);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [9/14]

void G4VSceneHandler::AddSolid ( const G4TessellatedSolid &  tess )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 310 of file G4VSceneHandler.cc.

                                                              {
  AddSolidT (tess);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [10/14]

void G4VSceneHandler::AddSolid ( const G4Torus &  torus )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 282 of file G4VSceneHandler.cc.

                                                    {
  AddSolidWithAuxiliaryEdges (torus);
}

References G4VSceneHandler::AddSolidWithAuxiliaryEdges().

AddSolid() [11/14]

void G4VSceneHandler::AddSolid ( const G4Trap &  trap )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 286 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (trap);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [12/14]

void G4VSceneHandler::AddSolid ( const G4Trd &  trd )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 290 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (trd);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [13/14]

void G4VSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 294 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (tubs);
}

References G4VSceneHandler::AddSolidT().

AddSolid() [14/14]

void G4VSceneHandler::AddSolid ( const G4VSolid &  solid )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 314 of file G4VSceneHandler.cc.

                                                     {
  AddSolidT (solid);
}

References G4VSceneHandler::AddSolidT().

AddSolidT()

template<class T >

void G4VSceneHandler::AddSolidT ( const T &  solid )

inherited

Definition at line 220 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::RequestPrimitives().

Referenced by G4VSceneHandler::AddSolid().

AddSolidWithAuxiliaryEdges()

template<class T >

void G4VSceneHandler::AddSolidWithAuxiliaryEdges ( const T &  solid )

inherited

Definition at line 228 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);
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), G4VisAttributes::IsForceAuxEdgeVisible(), G4VSceneHandler::RequestPrimitives(), and G4VisAttributes::SetForceAuxEdgeVisible().

Referenced by G4VSceneHandler::AddSolid().

AddViewerToList()

void G4VSceneHandler::AddViewerToList ( G4VViewer *  pView )

inherited

Definition at line 454 of file G4VSceneHandler.cc.

                                                         {
  fViewerList.push_back (pViewer);
}

References G4VSceneHandler::fViewerList.

BeginModeling()

void G4VSceneHandler::BeginModeling ( )

virtualinherited

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

Definition at line 208 of file G4VSceneHandler.cc.

                                     {
}

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

BeginPrimitives()

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

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 160 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;
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fObjectTransformation, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::BeginPrimitives(), G4OpenGLSceneHandler::BeginPrimitives(), G4OpenInventorSceneHandler::BeginPrimitives(), G4Qt3DSceneHandler::BeginPrimitives(), and G4VSceneHandler::RequestPrimitives().

BeginPrimitives2D()

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

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 184 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;
}

References G4VSceneHandler::fNestingDepth, and G4Exception().

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

BuildVisAttsMap()

void G4RayTracerSceneHandler::BuildVisAttsMap

(

const G4VSolid &

solid

)

Definition at line 87 of file G4RayTracerSceneHandler.cc.

{
  // Build map of vis attributes
 
  G4PhysicalVolumeModel* fpPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (fpPVModel) {
    G4ModelingParameters::PVPointerCopyNoPath temp;
    for (const auto& nodeID: fpPVModel->GetFullPVPath()) {
      // Build an element from the nodeid.
      temp.push_back(G4ModelingParameters::PVPointerCopyNo(nodeID.GetPhysicalVolume(),nodeID.GetCopyNo()));
    }
    const G4VisAttributes* pVisAtts = fpVisAttribs;
    if (!pVisAtts) {
      // Shouldn't happen.
      if (G4VisManager::GetInstance()->GetVerbosity() >= G4VisManager::warnings) {
        G4cout <<
        "WARNING: G4RayTracerSceneHandler::BuildVisAttsMap: null vis atts pointer."
        "\n  Using a default vis atts."
        << G4endl;
      }
      static const G4VisAttributes defaultVisAtts;
      pVisAtts = &defaultVisAtts;
    }
    // Copy vis atts into the vis atts map
    fSceneVisAttsMap[temp] = *pVisAtts;
  }
}

References G4VSceneHandler::fpModel, G4VSceneHandler::fpVisAttribs, fSceneVisAttsMap, G4cout, G4endl, G4PhysicalVolumeModel::GetFullPVPath(), G4VisManager::GetInstance(), G4VisManager::GetVerbosity(), and G4VisManager::warnings.

Referenced by RequestPrimitives().

ClearStore()

void G4RayTracerSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 63 of file G4RayTracerSceneHandler.cc.

{
  fSceneVisAttsMap.clear();
}

References fSceneVisAttsMap.

ClearTransientStore()

void G4VSceneHandler::ClearTransientStore ( )

virtualinherited

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

Definition at line 218 of file G4VSceneHandler.cc.

{}

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

CreateCutawaySolid()

G4DisplacedSolid * G4VSceneHandler::CreateCutawaySolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 904 of file G4VSceneHandler.cc.

{
  // To be reviewed.
  return 0;
  /*** An alternative way of getting a cutaway is to use
  Command /vis/scene/add/volume
  Guidance :
  Adds a physical volume to current scene, with optional clipping volume.
  If physical-volume-name is "world" (the default), the top of the
  main geometry tree (material world) is added.  If "worlds", the
  top of all worlds - material world and parallel worlds, if any - are
    added.  Otherwise a search of all worlds is made, taking the first
    matching occurrence only.  To see a representation of the geometry
    hierarchy of the worlds, try "/vis/drawTree [worlds]" or one of the
    driver/browser combinations that have the required functionality, e.g., HepRep.
    If clip-volume-type is specified, the subsequent parameters are used to
    to define a clipping volume.  For example,
    "/vis/scene/add/volume ! ! ! -box km 0 1 0 1 0 1" will draw the world
    with the positive octant cut away.  (If the Boolean Processor issues
    warnings try replacing 0 by 0.000000001 or something.)
    If clip-volume-type is prepended with '-', the clip-volume is subtracted
    (cutaway). (This is the default if there is no prepended character.)
    If '*' is prepended, the intersection of the physical-volume and the
    clip-volume is made. (You can make a section/DCUT with a thin box, for
    example).
    For "box", the parameters are xmin,xmax,ymin,ymax,zmin,zmax.
    Only "box" is programmed at present.
   ***/
}

Referenced by G4VSceneHandler::CreateModelingParameters().

CreateModelingParameters()

G4ModelingParameters * G4VSceneHandler::CreateModelingParameters ( )

inherited

Definition at line 798 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());
  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;
}

References G4ViewParameters::cloud, G4ModelingParameters::cloud, G4VSceneHandler::CreateCutawaySolid(), G4VSceneHandler::CreateSectionSolid(), G4VSceneHandler::fpViewer, G4ViewParameters::GetCBDAlgorithmNumber(), G4ViewParameters::GetCBDParameters(), G4ViewParameters::GetDefaultVisAttributes(), G4ViewParameters::GetDrawingStyle(), G4ViewParameters::GetExplodeCentre(), G4ViewParameters::GetExplodeFactor(), G4ViewParameters::GetNoOfSides(), G4ViewParameters::GetNumberOfCloudPoints(), G4ViewParameters::GetSpecialMeshVolumes(), G4VisManager::GetVerbosity(), G4ViewParameters::GetVisAttributesModifiers(), G4ViewParameters::GetVisibleDensity(), G4ViewParameters::hlhsr, G4ModelingParameters::hlhsr, G4ViewParameters::hlr, G4ModelingParameters::hlr, G4ViewParameters::hsr, G4ModelingParameters::hsr, G4ViewParameters::IsCulling(), G4ViewParameters::IsCullingCovered(), G4ViewParameters::IsCullingInvisible(), G4ViewParameters::IsCutaway(), G4ViewParameters::IsDensityCulling(), G4ViewParameters::IsSection(), G4ViewParameters::IsSpecialMeshRendering(), G4ModelingParameters::SetCBDAlgorithmNumber(), G4ModelingParameters::SetCBDParameters(), G4ModelingParameters::SetCutawaySolid(), G4ModelingParameters::SetExplodeCentre(), G4ModelingParameters::SetExplodeFactor(), G4ModelingParameters::SetNumberOfCloudPoints(), G4ModelingParameters::SetSectionSolid(), G4ModelingParameters::SetSpecialMeshRendering(), G4ModelingParameters::SetSpecialMeshVolumes(), G4ModelingParameters::SetVisAttributesModifiers(), G4ModelingParameters::SetWarning(), G4VisManager::warnings, G4ModelingParameters::wf, and G4ViewParameters::wireframe.

Referenced by G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), and G4VSceneHandler::ProcessScene().

CreateSectionSolid()

G4DisplacedSolid * G4VSceneHandler::CreateSectionSolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 867 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 G4Normal3D originalNormal(0,0,1);  // ...so this is original normal.
 
    const G4Plane3D& sp = vp.GetSectionPlane ();
    const G4double& a = sp.a();
    const G4double& b = sp.b();
    const G4double& c = sp.c();
    const G4double& d = sp.d();
    const G4Normal3D newNormal(a,b,c);
 
    G4Transform3D requiredTransform;
    // Rotate
    if (newNormal != originalNormal) {
      const G4double& angle = std::acos(newNormal.dot(originalNormal));
      const G4Vector3D& axis = originalNormal.cross(newNormal);
      requiredTransform = G4Rotate3D(angle, axis);
    }
    // Translate
    requiredTransform = requiredTransform * G4TranslateZ3D(-d);
 
    sectioner = new G4DisplacedSolid
      ("_displaced_sectioning_box", sectionBox, requiredTransform);
  }
  
  return sectioner;
}

References angle, HepGeom::BasicVector3D< T >::cross(), HepGeom::BasicVector3D< T >::dot(), G4VSceneHandler::fpScene, G4VSceneHandler::fpViewer, G4Scene::GetExtent(), G4VisExtent::GetExtentCentre(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetSectionPlane(), G4VViewer::GetViewParameters(), G4ViewParameters::IsSection(), HepGeom::BasicVector3D< T >::mag(), and G4InuclParticleNames::sp.

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

DrawEndOfRunModels()

void G4VSceneHandler::DrawEndOfRunModels ( )

inherited

Definition at line 777 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EORModelList =
    fpScene -> GetEndOfRunModelList ();
  size_t nModels = EORModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(0);
    for (size_t i = 0; i < nModels; i++) {
      if (EORModelList[i].fActive) {
        fpModel = EORModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfRun(), and G4VSceneHandler::ProcessScene().

DrawEvent()

void G4VSceneHandler::DrawEvent ( const G4Event *  event )

inherited

Definition at line 756 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EOEModelList =
    fpScene -> GetEndOfEventModelList ();
  size_t nModels = EOEModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(event);
    for (size_t i = 0; i < nModels; i++) {
      if (EOEModelList[i].fActive) {
    fpModel = EOEModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfEvent(), and G4VSceneHandler::ProcessScene().

EndModeling()

void G4VSceneHandler::EndModeling ( )

virtualinherited

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

Definition at line 211 of file G4VSceneHandler.cc.

{
  fpModel = 0;
}

References G4VSceneHandler::fpModel.

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

EndPrimitives()

void G4VSceneHandler::EndPrimitives ( )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 173 of file G4VSceneHandler.cc.

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

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, G4VSceneHandler::fTransientsDrawnThisRun, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::EndPrimitives(), G4OpenGLSceneHandler::EndPrimitives(), G4Qt3DSceneHandler::EndPrimitives(), and G4VSceneHandler::RequestPrimitives().

EndPrimitives2D()

void G4VSceneHandler::EndPrimitives2D ( )

virtualinherited

Implements G4VGraphicsScene.

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

Definition at line 196 of file G4VSceneHandler.cc.

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

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fProcessing2D, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, G4VSceneHandler::fTransientsDrawnThisRun, and G4Exception().

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

GetAuxEdgeVisible()

G4bool G4VSceneHandler::GetAuxEdgeVisible ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1081 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, G4VViewer::GetViewParameters(), G4ViewParameters::IsAuxEdgeVisible(), and G4VisAttributes::IsForcedAuxEdgeVisible().

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

GetColor() [1/2]

const G4Colour & G4VSceneHandler::GetColor ( )

inherited

GetColor() [2/2]

const G4Colour & G4VSceneHandler::GetColor ( const G4Visible &  )

inherited

GetColour() [1/2]

const G4Colour & G4VSceneHandler::GetColour ( )

inherited

Definition at line 994 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::GetColour().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VSceneHandler::GetColour(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

GetColour() [2/2]

const G4Colour & G4VSceneHandler::GetColour ( const G4Visible &  visible )

inherited

Definition at line 1000 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

GetCurrentViewer()

G4VViewer * G4VSceneHandler::GetCurrentViewer ( ) const

inherited

GetDrawingStyle()

G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1021 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;
}

References G4VisAttributes::cloud, G4ViewParameters::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetDrawingStyle(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4VisAttributes::solid, G4VisAttributes::wireframe, and G4ViewParameters::wireframe.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4OpenInventorSceneHandler::GeneratePrerequisites(), and G4VSceneHandler::RequestPrimitives().

GetExtent()

const G4VisExtent & G4VSceneHandler::GetExtent ( ) const

virtualinherited

Reimplemented from G4VGraphicsScene.

Definition at line 134 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpScene, and G4Scene::GetExtent().

Referenced by G4VtkViewer::SetView().

GetGraphicsSystem()

G4VGraphicsSystem * G4VSceneHandler::GetGraphicsSystem ( ) const

inherited

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

GetLineWidth()

G4double G4VSceneHandler::GetLineWidth ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1012 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, and G4VisAttributes::GetLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

GetMarkerDiameter()

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

inherited

GetMarkerRadius()

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

inherited

GetMarkerSize()

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

inherited

Definition at line 1089 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;
}

References G4VSceneHandler::fpViewer, G4VMarker::GetScreenSize(), G4VMarker::GetWorldSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

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

GetMarkForClearingTransientStore()

G4bool G4VSceneHandler::GetMarkForClearingTransientStore ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetModel()

G4VModel * G4VSceneHandler::GetModel ( ) const

inherited

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

GetName()

const G4String & G4VSceneHandler::GetName ( ) const

inherited

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

GetNoOfSides()

G4int G4VSceneHandler::GetNoOfSides ( const G4VisAttributes *  pVisAttribs )

inherited

Definition at line 1113 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();
      G4cout <<
    "G4VSceneHandler::GetNoOfSides: attempt to set the"
    "\nnumber of line segments per circle < " << lineSegmentsPerCircle
         << "; forced to " << pVisAttribs->GetMinLineSegmentsPerCircle() << G4endl;
    }
  }
  return lineSegmentsPerCircle;
}

References G4VSceneHandler::fpViewer, G4cout, G4endl, G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4VisAttributes::GetMinLineSegmentsPerCircle(), G4ViewParameters::GetNoOfSides(), G4VViewer::GetViewParameters(), and G4VisAttributes::IsForceLineSegmentsPerCircle().

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

GetNumberOfCloudPoints()

G4int G4VSceneHandler::GetNumberOfCloudPoints ( const G4VisAttributes *  pVisAttribs ) const

inherited

Definition at line 1067 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;
}

References G4VisAttributes::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetNumberOfCloudPoints(), and G4VViewer::GetViewParameters().

Referenced by G4VSceneHandler::RequestPrimitives().

GetObjectTransformation()

const G4Transform3D & G4VSceneHandler::GetObjectTransformation ( ) const

inherited

Referenced by G4VisManager::DrawT(), and G4VisManager::DrawT2D().

GetScene()

G4Scene * G4VSceneHandler::GetScene ( ) const

inherited

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(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4DAWNFILEViewer::SendViewParameters(), G4VRML2FileViewer::SendViewParameters(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), 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

inherited

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

GetSceneVisAttsMap()

const std::map< G4ModelingParameters::PVPointerCopyNoPath, G4VisAttributes, PathLessThan > & G4RayTracerSceneHandler::GetSceneVisAttsMap ( ) const

inline

Definition at line 71 of file G4RayTracerSceneHandler.hh.

  {return fSceneVisAttsMap;}

References fSceneVisAttsMap.

Referenced by G4RayTrajectory::AppendStep(), and G4RTSteppingAction::UserSteppingAction().

GetTextColor()

const G4Colour & G4VSceneHandler::GetTextColor ( const G4Text &  )

inherited

GetTextColour()

const G4Colour & G4VSceneHandler::GetTextColour ( const G4Text &  text )

inherited

Definition at line 1006 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultTextVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

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

GetTransientsDrawnThisEvent()

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetTransientsDrawnThisRun()

G4bool G4VSceneHandler::GetTransientsDrawnThisRun ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

GetViewCount()

G4int G4VSceneHandler::GetViewCount ( ) const

inherited

GetViewerList()

const G4ViewerList & G4VSceneHandler::GetViewerList ( ) const

inherited

IncrementViewCount()

G4int G4VSceneHandler::IncrementViewCount ( )

inherited

IsReadyForTransients()

G4bool G4VSceneHandler::IsReadyForTransients ( ) const

inherited

LoadAtts()

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

protectedinherited

Definition at line 934 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);
    }
  }
}

References G4AttHolder::AddAtts(), G4VHit::CreateAttValues(), G4VisAttributes::CreateAttValues(), G4VTrajectory::CreateAttValues(), G4VTrajectoryPoint::CreateAttValues(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4TrajectoriesModel::CreateCurrentAttValues(), G4VSceneHandler::fpModel, G4VHit::GetAttDefs(), G4VisAttributes::GetAttDefs(), G4VTrajectory::GetAttDefs(), G4VTrajectoryPoint::GetAttDefs(), G4PhysicalVolumeModel::GetAttDefs(), G4TrajectoriesModel::GetAttDefs(), G4HitsModel::GetCurrentHit(), G4TrajectoriesModel::GetCurrentTrajectory(), G4VTrajectory::GetPoint(), G4VTrajectory::GetPointEntries(), and G4Visible::GetVisAttributes().

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

PostAddSolid()

void G4VSceneHandler::PostAddSolid ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 151 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fProcessingSolid, G4VSceneHandler::fpVisAttribs, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, and G4VSceneHandler::fTransientsDrawnThisRun.

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

PreAddSolid()

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

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4OpenGLSceneHandler, G4Qt3DSceneHandler, G4VTreeSceneHandler, and G4OpenInventorSceneHandler.

Definition at line 144 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fProcessingSolid, and G4VSceneHandler::fpVisAttribs.

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

ProcessScene()

void G4VSceneHandler::ProcessScene ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 612 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;
    }
 
    BeginModeling();
 
    // Create modeling parameters from view parameters...
    G4ModelingParameters* pMP = CreateModelingParameters();
 
    for(size_t i = 0; i < runDurationModelList.size(); i++)
    {
      if(runDurationModelList[i].fActive)
      {
    fpModel = runDurationModelList[i].fpModel;
    fpModel->SetModelingParameters(pMP);
    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);
    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();
        const std::vector<const G4Event*>* events =
          run ? run->GetEventVector() : 0;
        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)
              {
                G4cout << "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;
}

References G4VSceneHandler::BeginModeling(), G4VisManager::confirmations, G4VSceneHandler::CreateModelingParameters(), G4VModel::DescribeYourselfTo(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4VSceneHandler::fMarkForClearingTransientStore, G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, G4VSceneHandler::fReadyForTransients, G4cout, G4endl, G4Exception(), G4State_GeomClosed, G4State_Idle, G4VVisManager::GetConcreteInstance(), G4RunManager::GetCurrentRun(), G4StateManager::GetCurrentState(), G4Scene::GetExtent(), G4VisManager::GetInstance(), G4RunManagerFactory::GetMasterRunManager(), G4VisExtent::GetNullExtent(), G4Scene::GetRefreshAtEndOfEvent(), G4Scene::GetRefreshAtEndOfRun(), G4VisManager::GetRequestedEvent(), G4Scene::GetRunDurationModelList(), G4StateManager::GetStateManager(), G4VisManager::GetVerbosity(), JustWarning, G4VisManager::SetEventRefreshing(), G4VModel::SetModelingParameters(), and G4VisManager::warnings.

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

RemoveViewerFromList()

void G4VSceneHandler::RemoveViewerFromList ( G4VViewer *  pView )

inherited

Definition at line 493 of file G4VSceneHandler.cc.

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

References G4VSceneHandler::fViewerList, G4VisManager::GetInstance(), and G4ViewerList::remove().

Referenced by G4VViewer::~G4VViewer().

RequestPrimitives()

void G4RayTracerSceneHandler::RequestPrimitives ( const G4VSolid &  solid )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 49 of file G4RayTracerSceneHandler.hh.

  {BuildVisAttsMap(solid);}

References BuildVisAttsMap().

SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer ( G4VViewer *  )

inherited

SetMarkForClearingTransientStore()

void G4VSceneHandler::SetMarkForClearingTransientStore ( G4bool  )

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

SetModel()

void G4VSceneHandler::SetModel ( G4VModel *  )

inherited

SetName()

void G4VSceneHandler::SetName ( const G4String &  )

inherited

SetObjectTransformation()

void G4VSceneHandler::SetObjectTransformation ( const G4Transform3D &  )

inherited

SetScene()

void G4VSceneHandler::SetScene ( G4Scene *  pScene )

virtualinherited

Reimplemented in G4OpenGLStoredQtSceneHandler.

Definition at line 507 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);
  }
}

References G4VSceneHandler::fpScene, and G4VSceneHandler::fViewerList.

Referenced by G4OpenGLStoredQtSceneHandler::SetScene().

SetTransientsDrawnThisEvent()

void G4VSceneHandler::SetTransientsDrawnThisEvent ( G4bool  )

inherited

Referenced by G4VisManager::BeginOfEvent().

SetTransientsDrawnThisRun()

void G4VSceneHandler::SetTransientsDrawnThisRun ( G4bool  )

inherited

Referenced by G4VisManager::BeginOfRun().

SetViewerList()

G4ViewerList & G4VSceneHandler::SetViewerList ( )

inherited

Field Documentation

fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protectedinherited

Definition at line 364 of file G4VSceneHandler.hh.

fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protectedinherited

Definition at line 352 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::ProcessScene().

fName

G4String G4VSceneHandler::fName

protectedinherited

Definition at line 347 of file G4VSceneHandler.hh.

fNestingDepth

G4int G4VSceneHandler::fNestingDepth

protectedinherited

Definition at line 362 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::BeginPrimitives2D(), G4VSceneHandler::EndPrimitives(), and G4VSceneHandler::EndPrimitives2D().

fObjectTransformation

G4Transform3D G4VSceneHandler::fObjectTransformation

protectedinherited

Definition at line 360 of file G4VSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), G4VtkSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4HepRepFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4OpenInventorSceneHandler::AddTransform(), G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

fpModel

G4VModel* G4VSceneHandler::fpModel

protectedinherited

Definition at line 359 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddCompound(), G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), BuildVisAttsMap(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::LoadAtts(), G4VTreeSceneHandler::PreAddSolid(), G4VSceneHandler::ProcessScene(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

fProcessing2D

G4bool G4VSceneHandler::fProcessing2D

protectedinherited

Definition at line 358 of file G4VSceneHandler.hh.

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

fProcessingSolid

G4bool G4VSceneHandler::fProcessingSolid

protectedinherited

Definition at line 357 of file G4VSceneHandler.hh.

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

fpScene

G4Scene* G4VSceneHandler::fpScene

protectedinherited

Definition at line 351 of file G4VSceneHandler.hh.

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

fpViewer

G4VViewer* G4VSceneHandler::fpViewer

protectedinherited

Definition at line 350 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4VtkSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4OpenInventorSceneHandler::AddTransform(), G4OpenGLImmediateSceneHandler::BeginPrimitives2D(), G4OpenGLStoredQtSceneHandler::ClearStore(), G4GMocrenFileSceneHandler::ClearTransientStore(), G4HepRepFileSceneHandler::ClearTransientStore(), G4OpenGLImmediateSceneHandler::ClearTransientStore(), G4OpenGLStoredQtSceneHandler::ClearTransientStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::CreateSectionSolid(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetAuxEdgeVisible(), G4VSceneHandler::GetColour(), G4VSceneHandler::GetDrawingStyle(), G4VSceneHandler::GetLineWidth(), G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::GetNoOfSides(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSceneHandler::GetTextColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLStoredQtSceneHandler::SetScene().

fpVisAttribs

const G4VisAttributes* G4VSceneHandler::fpVisAttribs

protectedinherited

Definition at line 363 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4HepRepFileSceneHandler::AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), BuildVisAttsMap(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

fReadyForTransients

G4bool G4VSceneHandler::fReadyForTransients

protectedinherited

Definition at line 353 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::BeginPrimitives(), G4OpenGLStoredSceneHandler::BeginPrimitives2D(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::ProcessScene(), and G4OpenGLSceneHandler::ScaledFlush().

fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protectedinherited

Definition at line 346 of file G4VSceneHandler.hh.

fSceneIdCount

G4int G4RayTracerSceneHandler::fSceneIdCount = 0

staticprivate

Definition at line 76 of file G4RayTracerSceneHandler.hh.

fSceneVisAttsMap

std::map<G4ModelingParameters::PVPointerCopyNoPath,G4VisAttributes,PathLessThan> G4RayTracerSceneHandler::fSceneVisAttsMap

private

Definition at line 80 of file G4RayTracerSceneHandler.hh.

Referenced by BuildVisAttsMap(), ClearStore(), and GetSceneVisAttsMap().

fSystem

G4VGraphicsSystem& G4VSceneHandler::fSystem

protectedinherited

Definition at line 345 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddPrimitive().

fTransientsDrawnThisEvent

G4bool G4VSceneHandler::fTransientsDrawnThisEvent

protectedinherited

Definition at line 355 of file G4VSceneHandler.hh.

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

fTransientsDrawnThisRun

G4bool G4VSceneHandler::fTransientsDrawnThisRun

protectedinherited

Definition at line 356 of file G4VSceneHandler.hh.

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

fViewCount

G4int G4VSceneHandler::fViewCount

protectedinherited

Definition at line 348 of file G4VSceneHandler.hh.

fViewerList

G4ViewerList G4VSceneHandler::fViewerList

protectedinherited

Definition at line 349 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddViewerToList(), G4VSceneHandler::RemoveViewerFromList(), and G4VSceneHandler::SetScene().

---

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

• source/visualization/RayTracer/include/G4RayTracerSceneHandler.hh
• source/visualization/RayTracer/src/G4RayTracerSceneHandler.cc