#include <G4DAWNFILESceneHandler.hh>

Inheritance diagram for G4DAWNFILESceneHandler:

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

virtual void	AddPrimitive (const G4Polyhedron &)=0

void	AddPrimitive (const G4Polyhedron &p)

virtual void	AddPrimitive (const G4Polyline &)=0

void	AddPrimitive (const G4Polyline &line)

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

void	AddSolid (const G4Box &box)

virtual void	AddSolid (const G4Cons &)

void	AddSolid (const G4Cons &cons)

virtual void	AddSolid (const G4Ellipsoid &)

virtual void	AddSolid (const G4Orb &)

virtual void	AddSolid (const G4Para &)

void	AddSolid (const G4Para &para)

virtual void	AddSolid (const G4Polycone &)

virtual void	AddSolid (const G4Polyhedra &)

virtual void	AddSolid (const G4Sphere &)

void	AddSolid (const G4Sphere &sphere)

virtual void	AddSolid (const G4TessellatedSolid &)

virtual void	AddSolid (const G4Torus &)

void	AddSolid (const G4Torus &torus)

virtual void	AddSolid (const G4Trap &)

void	AddSolid (const G4Trap &trap)

virtual void	AddSolid (const G4Trd &)

void	AddSolid (const G4Trd &trd)

virtual void	AddSolid (const G4Tubs &)

void	AddSolid (const G4Tubs &tubs)

virtual void	AddSolid (const G4VSolid &)

void	AddSolid (const G4VSolid &solid)

template<class T >
void	AddSolidT (const T &solid)

template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)

void	AddViewerToList (G4VViewer *pView)

virtual void	BeginModeling ()

void	BeginPrimitives (const G4Transform3D &objectTransformation)

virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())

void	BeginSavingG4Prim (void)

virtual void	ClearStore ()

void	ClearTransientStore ()

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEndOfRunModels ()

void	DrawEvent (const G4Event *)

virtual void	EndModeling ()

void	EndPrimitives ()

virtual void	EndPrimitives2D ()

void	EndSavingG4Prim (void)

void	FRBeginModeling ()

void	FREndModeling ()

G4bool	FRIsInModeling ()

	G4DAWNFILESceneHandler (G4DAWNFILE &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

const char *	GetG4PrimFileName ()

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

G4DAWNFILE &	GetSystem ()

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

G4bool	IsSavingG4Prim (void)

virtual void	PostAddSolid ()

virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)

void	RemoveViewerFromList (G4VViewer *pView)

void	SendBoundingBox (void)

void	SendDouble (G4double val)

void	SendInt (G4int val)

void	SendInt3Str (G4int ival1, G4int ival2, G4int ival3, const char *char_string)

void	SendInt4Str (G4int ival1, G4int ival2, G4int ival3, G4int ival4, const char *char_string)

void	SendIntDouble3 (G4int ival, G4double dval1, G4double dval2, G4double dval3)

void	SendStr (const char *char_string)

void	SendStrDouble (const char *char_string, G4double dval)

void	SendStrDouble11 (const char *char_string, G4double dval1, G4double dval2, G4double dval3, G4double dval4, G4double dval5, G4double dval6, G4double dval7, G4double dval8, G4double dval9, G4double dval10, G4double dval11)

void	SendStrDouble2 (const char *char_string, G4double dval1, G4double dval2)

void	SendStrDouble3 (const char *char_string, G4double dval1, G4double dval2, G4double dval3)

void	SendStrDouble3Str (const char char_string1, G4double dval1, G4double dval2, G4double dval3, const char char_string2)

void	SendStrDouble4 (const char *char_string, G4double dval1, G4double dval2, G4double dval3, G4double dval4)

void	SendStrDouble5 (const char *char_string, G4double dval1, G4double dval2, G4double dval3, G4double dval4, G4double dval5)

void	SendStrDouble6 (const char *char_string, G4double dval1, G4double dval2, G4double dval3, G4double dval4, G4double dval5, G4double dval6)

void	SendStrDouble6Str (const char char_string1, G4double dval1, G4double dval2, G4double dval3, G4double dval4, G4double dval5, G4double dval6, const char char_string2)

void	SendStrDouble7 (const char *char_string, G4double dval1, G4double dval2, G4double dval3, G4double dval4, G4double dval5, G4double dval6, G4double dval7)

void	SendStrInt (const char *char_string, G4int ival)

void	SendStrInt3 (const char *char_string, G4int ival1, G4int ival2, G4int ival3)

void	SendStrInt4 (const char *char_string, G4int ival1, G4int ival2, G4int ival3, G4int ival4)

void	SetCurrentViewer (G4VViewer *)

void	SetG4PrimFileName ()

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	~G4DAWNFILESceneHandler ()

Protected Member Functions
virtual G4DisplacedSolid *	CreateCutawaySolid ()

virtual G4DisplacedSolid *	CreateSectionSolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

virtual void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

Private Member Functions
G4bool	IsVisible (void)

void	SendNdiv (void)

void	SendPhysVolName (void)

void	SendTransformedCoordinates (void)

G4bool	SendVisAttributes (const G4VisAttributes *pAV)

Private Attributes
const int	COMMAND_BUF_SIZE

char	fG4PrimDestDir [256]

char	fG4PrimFileName [256]

G4bool	flag_saving_g4_prim

G4int	fMaxFileNum

G4int	fPrec

G4int	fPrec2

G4FRofstream	fPrimDest

G4bool	FRflag_in_modeling

G4DAWNFILE &	fSystem

Static Private Attributes
static G4int	fSceneIdCount = 0

Friends
class	G4DAWNFILEViewer

Detailed Description

Definition at line 44 of file G4DAWNFILESceneHandler.hh.

Member Enumeration Documentation

◆ MarkerSizeType

enum G4VSceneHandler::MarkerSizeType

inherited

Enumerator
world
screen

Definition at line 58 of file G4VSceneHandler.hh.

58{world, screen};

G4VSceneHandler::screen

@ screen

Definition: G4VSceneHandler.hh:58

G4VSceneHandler::world

@ world

Definition: G4VSceneHandler.hh:58

Constructor & Destructor Documentation

◆ G4DAWNFILESceneHandler()

G4DAWNFILESceneHandler::G4DAWNFILESceneHandler	(	G4DAWNFILE &	system,
		const G4String &	name = `""`
	)

Definition at line 77 of file G4DAWNFILESceneHandler.cc.

  : G4VSceneHandler(system, fSceneIdCount++, name)
  , fSystem(system)
  , fPrimDest()
  , FRflag_in_modeling(false)
  , flag_saving_g4_prim(false)
  , COMMAND_BUF_SIZE(G4FRofstream::SEND_BUFMAX)
  , fPrec(9)
  , fPrec2(16)
{
  // g4.prim filename and its directory
  if(std::getenv("G4DAWNFILE_DEST_DIR") == NULL)
  {
    strcpy(fG4PrimDestDir, "");                         // output dir
    strcpy(fG4PrimFileName, DEFAULT_G4PRIM_FILE_NAME);  // filename
  }
  else
  {
    strcpy(fG4PrimDestDir, std::getenv("G4DAWNFILE_DEST_DIR"));  // output dir
    strcpy(fG4PrimFileName, DEFAULT_G4PRIM_FILE_NAME);           // filename
  }
 
  // maximum number of g4.prim files in the dest directory
  fMaxFileNum = FR_MAX_FILE_NUM;  // initialization
  if(std::getenv("G4DAWNFILE_MAX_FILE_NUM") != NULL)
  {
    sscanf(std::getenv("G4DAWNFILE_MAX_FILE_NUM"), "%d", &fMaxFileNum);
  }
  else
  {
    fMaxFileNum = FR_MAX_FILE_NUM;
  }
  if(fMaxFileNum < 1)
  {
    fMaxFileNum = 1;
  }
 
  //----- precision control
  if(std::getenv("G4DAWNFILE_PRECISION") != NULL)
  {
    sscanf(std::getenv("G4DAWNFILE_PRECISION"), "%d", &fPrec);
  }
  else
  {
    fPrec = 9;
  }
  fPrec2 = fPrec + 7;
}

References DEFAULT_G4PRIM_FILE_NAME, fG4PrimDestDir, fG4PrimFileName, fMaxFileNum, fPrec, fPrec2, and FR_MAX_FILE_NUM.

◆ ~G4DAWNFILESceneHandler()

G4DAWNFILESceneHandler::~G4DAWNFILESceneHandler ( )

virtual

Definition at line 128 of file G4DAWNFILESceneHandler.cc.

{
#if defined DEBUG_FR_SCENE
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** ~G4DAWNFILESceneHandler" << G4endl;
#endif
  if(fPrimDest.IsOpen())
  {
    //----- End of modeling
    // !EndModeling, !DrawAll, !CloseDevice,
    // close g4.prim
    FREndModeling();
  }
}

References G4VisManager::errors, fPrimDest, FREndModeling(), G4cout, G4endl, G4VisManager::GetVerbosity(), and G4FRofstream::IsOpen().

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/12]

void G4DAWNFILESceneHandler::AddPrimitive ( const G4Circle & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [2/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [3/12]

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/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [5/12]

void G4DAWNFILESceneHandler::AddPrimitive ( const G4Polyhedron & p )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [6/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [7/12]

void G4DAWNFILESceneHandler::AddPrimitive ( const G4Polyline & line )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [8/12]

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/12]

void G4DAWNFILESceneHandler::AddPrimitive ( const G4Square & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [10/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [11/12]

void G4DAWNFILESceneHandler::AddPrimitive ( const G4Text & )

virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [12/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text & )

virtual

Implements G4VSceneHandler.

◆ AddSolid() [1/23]

void G4VSceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

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

◆ AddSolid() [2/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [3/23]

void G4VSceneHandler::AddSolid ( const G4Cons & cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 99 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (cons);
}

◆ AddSolid() [4/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Cons & cons )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [5/23]

void G4VSceneHandler::AddSolid ( const G4Ellipsoid & ellipsoid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 109 of file G4VSceneHandler.cc.

                                                            {
  AddSolidWithAuxiliaryEdges (ellipsoid);
}

◆ AddSolid() [6/23]

void G4VSceneHandler::AddSolid ( const G4Orb & orb )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 100 of file G4VSceneHandler.cc.

                                                {
  AddSolidWithAuxiliaryEdges (orb);
}

◆ AddSolid() [7/23]

void G4VSceneHandler::AddSolid ( const G4Para & para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 101 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (para);
}

◆ AddSolid() [8/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Para & para )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [9/23]

void G4VSceneHandler::AddSolid ( const G4Polycone & polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 110 of file G4VSceneHandler.cc.

                                                          {
  AddSolidT (polycone);
}

◆ AddSolid() [10/23]

void G4VSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 111 of file G4VSceneHandler.cc.

                                                            {
  AddSolidT (polyhedra);
}

◆ AddSolid() [11/23]

void G4VSceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 102 of file G4VSceneHandler.cc.

                                                      {
  AddSolidWithAuxiliaryEdges (sphere);
}

◆ AddSolid() [12/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [13/23]

void G4VSceneHandler::AddSolid ( const G4TessellatedSolid & tess )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 112 of file G4VSceneHandler.cc.

                                                              {
  AddSolidT (tess);
}

◆ AddSolid() [14/23]

void G4VSceneHandler::AddSolid ( const G4Torus & torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 103 of file G4VSceneHandler.cc.

                                                    {
  AddSolidWithAuxiliaryEdges (torus);
}

◆ AddSolid() [15/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Torus & torus )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [16/23]

void G4VSceneHandler::AddSolid ( const G4Trap & trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 104 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (trap);
}

◆ AddSolid() [17/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Trap & trap )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [18/23]

void G4VSceneHandler::AddSolid ( const G4Trd & trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 105 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (trd);
}

◆ AddSolid() [19/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Trd & trd )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [20/23]

void G4VSceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 106 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (tubs);
}

◆ AddSolid() [21/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Reimplemented from G4VSceneHandler.

◆ AddSolid() [22/23]

void G4VSceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 115 of file G4VSceneHandler.cc.

                                                     {
  AddSolidT (solid);
}

◆ AddSolid() [23/23]

void G4DAWNFILESceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Reimplemented from G4VSceneHandler.

◆ 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.

208 {

209}

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

◆ BeginPrimitives()

void G4DAWNFILESceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

◆ 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().

◆ BeginSavingG4Prim()

void G4DAWNFILESceneHandler::BeginSavingG4Prim ( void )

Definition at line 216 of file G4DAWNFILESceneHandler.cc.

{
#if defined DEBUG_FR_SCENE
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** BeginSavingG4Prim (called)\n";
#endif
 
  if(!IsSavingG4Prim())
  {
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    {
      G4cout << "*****                   (started) ";
      G4cout << "(open g4.prim, ##)" << G4endl;
    }
#endif
    SetG4PrimFileName();  // result set to fG4PrimFileName
    fPrimDest.Open(fG4PrimFileName);
 
    SendStr(FR_G4_PRIM_HEADER);
    flag_saving_g4_prim = true;
  }
}

References G4VisManager::errors, fG4PrimFileName, flag_saving_g4_prim, fPrimDest, FR_G4_PRIM_HEADER, G4cout, G4endl, G4VisManager::GetVerbosity(), IsSavingG4Prim(), G4FRofstream::Open(), SendStr(), and SetG4PrimFileName().

Referenced by FRBeginModeling().

◆ ClearStore()

void G4VSceneHandler::ClearStore ( )

virtualinherited

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

Definition at line 216 of file G4VSceneHandler.cc.

216{}

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

◆ ClearTransientStore()

void G4DAWNFILESceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

◆ 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;
}

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 G4DAWNFILESceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

◆ 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().

◆ EndSavingG4Prim()

void G4DAWNFILESceneHandler::EndSavingG4Prim ( void )

Definition at line 240 of file G4DAWNFILESceneHandler.cc.

{
#if defined DEBUG_FR_SCENE
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** EndSavingG4Prim (called)\n";
#endif
 
  if(IsSavingG4Prim())
  {
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "*****                 (started) (close g4.prim)" << G4endl;
#endif
    fPrimDest.Close();
    flag_saving_g4_prim = false;
  }
}

References G4FRofstream::Close(), G4VisManager::errors, flag_saving_g4_prim, fPrimDest, G4cout, G4endl, G4VisManager::GetVerbosity(), and IsSavingG4Prim().

◆ FRBeginModeling()

void G4DAWNFILESceneHandler::FRBeginModeling ( void )

Definition at line 259 of file G4DAWNFILESceneHandler.cc.

{
  if(!FRIsInModeling())
  {
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout
        << "***** G4DAWNFILESceneHandler::FRBeginModeling (called & started)"
        << G4endl;
#endif
 
    //----- Send saving command and heading comment
    BeginSavingG4Prim();
 
    //----- Send bounding box command
    SendBoundingBox();
 
    //----- send SET_CAMERA command
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "*****   (!SetCamera in FRBeginModeling())" << G4endl;
#endif
    SendStr(FR_SET_CAMERA);
 
    //----- open device
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "*****   (!OpenDevice in FRBeginModeling())" << G4endl;
#endif
    SendStr(FR_OPEN_DEVICE);
 
    //----- begin sending primitives
#if defined DEBUG_FR_SCENE
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      G4cout << "*****   (!BeginModeling in FRBeginModeling())" << G4endl;
#endif
    SendStr(FR_BEGIN_MODELING);
    FRflag_in_modeling = true;
 
  }  // if
}

References BeginSavingG4Prim(), G4VisManager::errors, FR_BEGIN_MODELING, FR_OPEN_DEVICE, FR_SET_CAMERA, FRflag_in_modeling, FRIsInModeling(), G4cout, G4endl, G4VisManager::GetVerbosity(), SendBoundingBox(), and SendStr().

Referenced by G4DAWNFILEViewer::ClearView(), and G4DAWNFILEViewer::DrawView().

◆ FREndModeling()

void G4DAWNFILESceneHandler::FREndModeling ( )

Referenced by G4DAWNFILEViewer::ShowView(), and ~G4DAWNFILESceneHandler().

◆ FRIsInModeling()

G4bool G4DAWNFILESceneHandler::FRIsInModeling ( )

inline

Definition at line 80 of file G4DAWNFILESceneHandler.hh.

80{ return FRflag_in_modeling; }

References FRflag_in_modeling.

Referenced by FRBeginModeling(), and G4DAWNFILEViewer::ShowView().

◆ 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().

◆ GetG4PrimFileName()

const char * G4DAWNFILESceneHandler::GetG4PrimFileName ( )

inline

Definition at line 89 of file G4DAWNFILESceneHandler.hh.

89{ return fG4PrimFileName; }

References fG4PrimFileName.

Referenced by G4DAWNFILEViewer::G4DAWNFILEViewer(), and G4DAWNFILEViewer::ShowView().

◆ 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().

◆ GetSystem()

G4DAWNFILE & G4DAWNFILESceneHandler::GetSystem ( )

inline

Definition at line 87 of file G4DAWNFILESceneHandler.hh.

87{ return fSystem; }

References fSystem.

◆ 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

◆ IsSavingG4Prim()

G4bool G4DAWNFILESceneHandler::IsSavingG4Prim ( void )

inline

Definition at line 82 of file G4DAWNFILESceneHandler.hh.

82{ return flag_saving_g4_prim; }

References flag_saving_g4_prim.

Referenced by BeginSavingG4Prim(), and EndSavingG4Prim().

◆ IsVisible()

G4bool G4DAWNFILESceneHandler::IsVisible ( void )

private

◆ 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 G4VSceneHandler::RequestPrimitives ( const G4VSolid & solid )

protectedvirtualinherited

Reimplemented in G4ASCIITreeSceneHandler, and G4RayTracerSceneHandler.

Definition at line 516 of file G4VSceneHandler.cc.

{
  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);
          G4cerr <<
          "ERROR: G4VSceneHandler::RequestPrimitives"
          "\n  Polyhedron not available for " << solid.GetName ();
          G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
          if (pPVModel) {
            G4cerr << "\n  Touchable path: " << pPVModel->GetFullPVPath();
          }
          static G4bool explanation = false;
          if (!explanation) {
            explanation = true;
            G4cerr <<
            "\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.";
          }
          G4cerr << "\n  Drawing solid with cloud of points.";
          G4cerr << 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;
    }
  }
}

References G4VSceneHandler::AddPrimitive(), G4VSceneHandler::BeginPrimitives(), G4ViewParameters::cloud, G4Polymarker::dots, G4VSceneHandler::EndPrimitives(), G4VisManager::errors, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpModel, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cerr, G4endl, G4VSceneHandler::GetDrawingStyle(), G4PhysicalVolumeModel::GetFullPVPath(), G4VSolid::GetName(), G4VSceneHandler::GetNoOfSides(), G4ViewParameters::GetNumberOfCloudPoints(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSolid::GetPointOnSurface(), G4VSolid::GetPolyhedron(), G4VisManager::GetVerbosity(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, HepPolyhedron::ResetNumberOfRotationSteps(), G4VMarker::screen, G4Polymarker::SetMarkerType(), HepPolyhedron::SetNumberOfRotationSteps(), G4VMarker::SetSize(), G4Visible::SetVisAttributes(), and G4ViewParameters::wireframe.

Referenced by G4VSceneHandler::AddSolidT(), and G4VSceneHandler::AddSolidWithAuxiliaryEdges().

◆ SendBoundingBox()

void G4DAWNFILESceneHandler::SendBoundingBox ( void )

Referenced by FRBeginModeling().

◆ SendDouble()

void G4DAWNFILESceneHandler::SendDouble ( G4double val )

◆ SendInt()

void G4DAWNFILESceneHandler::SendInt ( G4int val )

◆ SendInt3Str()

void G4DAWNFILESceneHandler::SendInt3Str	(	G4int	ival1,
		G4int	ival2,
		G4int	ival3,
		const char *	char_string
	)

◆ SendInt4Str()

void G4DAWNFILESceneHandler::SendInt4Str	(	G4int	ival1,
		G4int	ival2,
		G4int	ival3,
		G4int	ival4,
		const char *	char_string
	)

◆ SendIntDouble3()

void G4DAWNFILESceneHandler::SendIntDouble3	(	G4int	ival,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3
	)

◆ SendNdiv()

void G4DAWNFILESceneHandler::SendNdiv ( void )

private

◆ SendPhysVolName()

void G4DAWNFILESceneHandler::SendPhysVolName ( void )

private

◆ SendStr()

void G4DAWNFILESceneHandler::SendStr ( const char * char_string )

Referenced by BeginSavingG4Prim(), G4DAWNFILEViewer::ClearView(), and FRBeginModeling().

◆ SendStrDouble()

void G4DAWNFILESceneHandler::SendStrDouble	(	const char *	char_string,
		G4double	dval
	)

◆ SendStrDouble11()

void G4DAWNFILESceneHandler::SendStrDouble11	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4,
		G4double	dval5,
		G4double	dval6,
		G4double	dval7,
		G4double	dval8,
		G4double	dval9,
		G4double	dval10,
		G4double	dval11
	)

◆ SendStrDouble2()

void G4DAWNFILESceneHandler::SendStrDouble2	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2
	)

◆ SendStrDouble3()

void G4DAWNFILESceneHandler::SendStrDouble3	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3
	)

◆ SendStrDouble3Str()

void G4DAWNFILESceneHandler::SendStrDouble3Str	(	const char *	char_string1,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		const char *	char_string2
	)

◆ SendStrDouble4()

void G4DAWNFILESceneHandler::SendStrDouble4	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4
	)

◆ SendStrDouble5()

void G4DAWNFILESceneHandler::SendStrDouble5	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4,
		G4double	dval5
	)

◆ SendStrDouble6()

void G4DAWNFILESceneHandler::SendStrDouble6	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4,
		G4double	dval5,
		G4double	dval6
	)

◆ SendStrDouble6Str()

void G4DAWNFILESceneHandler::SendStrDouble6Str	(	const char *	char_string1,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4,
		G4double	dval5,
		G4double	dval6,
		const char *	char_string2
	)

◆ SendStrDouble7()

void G4DAWNFILESceneHandler::SendStrDouble7	(	const char *	char_string,
		G4double	dval1,
		G4double	dval2,
		G4double	dval3,
		G4double	dval4,
		G4double	dval5,
		G4double	dval6,
		G4double	dval7
	)

◆ SendStrInt()

void G4DAWNFILESceneHandler::SendStrInt	(	const char *	char_string,
		G4int	ival
	)

◆ SendStrInt3()

void G4DAWNFILESceneHandler::SendStrInt3	(	const char *	char_string,
		G4int	ival1,
		G4int	ival2,
		G4int	ival3
	)

◆ SendStrInt4()

void G4DAWNFILESceneHandler::SendStrInt4	(	const char *	char_string,
		G4int	ival1,
		G4int	ival2,
		G4int	ival3,
		G4int	ival4
	)

◆ SendTransformedCoordinates()

void G4DAWNFILESceneHandler::SendTransformedCoordinates ( void )

private

◆ SendVisAttributes()

G4bool G4DAWNFILESceneHandler::SendVisAttributes ( const G4VisAttributes * pAV )

private

◆ SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer ( G4VViewer * )

inherited

◆ SetG4PrimFileName()

void G4DAWNFILESceneHandler::SetG4PrimFileName ( )

Definition at line 144 of file G4DAWNFILESceneHandler.cc.

{
  // g4_0000.prim, g4_0001.prim, ..., g4_MAX_FILE_INDEX.prim
  const int MAX_FILE_INDEX = fMaxFileNum - 1;
 
  // dest directory (null if no environmental variables is set)
  strcpy(fG4PrimFileName, fG4PrimDestDir);
 
  // create full path name (default)
  strcat(fG4PrimFileName, DEFAULT_G4PRIM_FILE_NAME);
 
  // Automatic updation of file names
  for(int i = 0; i < fMaxFileNum; i++)
  {
    // Message in the final execution
    if(i == MAX_FILE_INDEX)
    {
      if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
      {
        G4cout << "===========================================" << G4endl;
        G4cout << "WARNING MESSAGE from DAWNFILE driver:      " << G4endl;
        G4cout << "  This file name is the final one in the   " << G4endl;
        G4cout << "  automatic updation of the output file name." << G4endl;
        G4cout << "  You may overwrite existing files, i.e.   " << G4endl;
        G4cout << "  g4_XXXX.prim and g4_XXXX.eps             " << G4endl;
        G4cout << "===========================================" << G4endl;
      }
    }
 
    // re-determine file name as G4DAWNFILE_DEST_DIR/g4_XXXX.prim
    std::ostringstream filename;
    filename << fG4PrimDestDir << G4PRIM_FILE_HEADER << std::setw(4)
             << std::setfill('0') << i << ".prim";
    strncpy(fG4PrimFileName, filename.str().c_str(),
            sizeof(fG4PrimFileName) - 1);
    fG4PrimFileName[sizeof(fG4PrimFileName) - 1] = '\0';
 
    // check validity of the file name
    std::ifstream fin;
    fin.open(fG4PrimFileName);
    if(!fin)
    {
      // new file
      fin.close();
      break;
    }
    else
    {
      // already exists (try next)
      fin.close();
    }
 
  }  // for
 
  G4cout << "===========================================    " << G4endl;
  G4cout << "Output file: " << fG4PrimFileName << G4endl;
  G4cout << "Destination directory (current dir if NULL): " << fG4PrimDestDir
         << G4endl;
  G4cout << "Maximal number of files in the destination directory: "
         << fMaxFileNum << G4endl;
  G4cout << "Note:                                                " << G4endl;
  G4cout << "  * The maximal number is customizable as:           " << G4endl;
  G4cout << "       % setenv  G4DAWNFILE_MAX_FILE_NUM  number " << G4endl;
  G4cout << "  * The destination directory is customizable as:" << G4endl;
  G4cout << "       % setenv  G4DAWNFILE_DEST_DIR  dir_name/  " << G4endl;
  G4cout << "     ** Do not forget \"/\" at the end of the    " << G4endl;
  G4cout << "        dir_name, e.g. \"./tmp/\".  " << G4endl;
  G4cout << "===========================================      " << G4endl;
 
}  // G4DAWNFILESceneHandler::SetG4PrimFileName()

References DEFAULT_G4PRIM_FILE_NAME, G4VisManager::errors, fG4PrimDestDir, fG4PrimFileName, fMaxFileNum, G4cout, G4endl, G4PRIM_FILE_HEADER, and G4VisManager::GetVerbosity().

Referenced by BeginSavingG4Prim().

◆ 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

Friends And Related Function Documentation

◆ G4DAWNFILEViewer

friend class G4DAWNFILEViewer

friend

Definition at line 46 of file G4DAWNFILESceneHandler.hh.

Field Documentation

◆ COMMAND_BUF_SIZE

const int G4DAWNFILESceneHandler::COMMAND_BUF_SIZE

private

Definition at line 166 of file G4DAWNFILESceneHandler.hh.

◆ fG4PrimDestDir

char G4DAWNFILESceneHandler::fG4PrimDestDir[256]

private

Definition at line 168 of file G4DAWNFILESceneHandler.hh.

Referenced by G4DAWNFILESceneHandler(), and SetG4PrimFileName().

◆ fG4PrimFileName

char G4DAWNFILESceneHandler::fG4PrimFileName[256]

private

Definition at line 169 of file G4DAWNFILESceneHandler.hh.

Referenced by BeginSavingG4Prim(), G4DAWNFILEViewer::ClearView(), G4DAWNFILESceneHandler(), GetG4PrimFileName(), and SetG4PrimFileName().

◆ fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protectedinherited

Definition at line 364 of file G4VSceneHandler.hh.

◆ flag_saving_g4_prim

G4bool G4DAWNFILESceneHandler::flag_saving_g4_prim

private

Definition at line 164 of file G4DAWNFILESceneHandler.hh.

Referenced by BeginSavingG4Prim(), EndSavingG4Prim(), and IsSavingG4Prim().

◆ fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protectedinherited

Definition at line 352 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::ProcessScene().

◆ fMaxFileNum

G4int G4DAWNFILESceneHandler::fMaxFileNum

private

Definition at line 170 of file G4DAWNFILESceneHandler.hh.

Referenced by G4DAWNFILESceneHandler(), and SetG4PrimFileName().

◆ 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(), G4RayTracerSceneHandler::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().

◆ fPrec

G4int G4DAWNFILESceneHandler::fPrec

private

Definition at line 172 of file G4DAWNFILESceneHandler.hh.

Referenced by G4DAWNFILESceneHandler().

◆ fPrec2

G4int G4DAWNFILESceneHandler::fPrec2

private

Definition at line 172 of file G4DAWNFILESceneHandler.hh.

Referenced by G4DAWNFILESceneHandler().

◆ fPrimDest

G4FRofstream G4DAWNFILESceneHandler::fPrimDest

private

Definition at line 154 of file G4DAWNFILESceneHandler.hh.

Referenced by BeginSavingG4Prim(), G4DAWNFILEViewer::ClearView(), EndSavingG4Prim(), and ~G4DAWNFILESceneHandler().

◆ fProcessing2D

G4bool G4VSceneHandler::fProcessing2D

protectedinherited

Definition at line 358 of file G4VSceneHandler.hh.

◆ 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::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(), G4RayTracerSceneHandler::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().

◆ FRflag_in_modeling

G4bool G4DAWNFILESceneHandler::FRflag_in_modeling

private

Definition at line 155 of file G4DAWNFILESceneHandler.hh.

Referenced by G4DAWNFILEViewer::ClearView(), FRBeginModeling(), and FRIsInModeling().

◆ fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protectedinherited

Definition at line 346 of file G4VSceneHandler.hh.

◆ fSceneIdCount

G4int G4DAWNFILESceneHandler::fSceneIdCount = 0

staticprivate

Definition at line 152 of file G4DAWNFILESceneHandler.hh.

◆ fSystem

G4DAWNFILE& G4DAWNFILESceneHandler::fSystem

private

Definition at line 151 of file G4DAWNFILESceneHandler.hh.

Referenced by GetSystem().

◆ 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/FukuiRenderer/include/G4DAWNFILESceneHandler.hh
source/visualization/FukuiRenderer/src/G4DAWNFILESceneHandler.cc

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

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4int	fViewCount

G4ViewerList	fViewerList

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ MarkerSizeType

Constructor & Destructor Documentation

◆ G4DAWNFILESceneHandler()

◆ ~G4DAWNFILESceneHandler()

Member Function Documentation

◆ AddCompound() [1/6]

◆ AddCompound() [2/6]

◆ AddCompound() [3/6]

◆ AddCompound() [4/6]

◆ AddCompound() [5/6]

◆ AddCompound() [6/6]

◆ AddPrimitive() [1/12]

◆ AddPrimitive() [2/12]

◆ AddPrimitive() [3/12]

◆ AddPrimitive() [4/12]

◆ AddPrimitive() [5/12]

◆ AddPrimitive() [6/12]

◆ AddPrimitive() [7/12]

◆ AddPrimitive() [8/12]

◆ AddPrimitive() [9/12]

◆ AddPrimitive() [10/12]

◆ AddPrimitive() [11/12]

◆ AddPrimitive() [12/12]

◆ AddSolid() [1/23]

◆ AddSolid() [2/23]

◆ AddSolid() [3/23]

◆ AddSolid() [4/23]

◆ AddSolid() [5/23]

◆ AddSolid() [6/23]

◆ AddSolid() [7/23]

◆ AddSolid() [8/23]

◆ AddSolid() [9/23]

◆ AddSolid() [10/23]

◆ AddSolid() [11/23]

◆ AddSolid() [12/23]

◆ AddSolid() [13/23]

◆ AddSolid() [14/23]

◆ AddSolid() [15/23]

◆ AddSolid() [16/23]

◆ AddSolid() [17/23]

◆ AddSolid() [18/23]

◆ AddSolid() [19/23]

◆ AddSolid() [20/23]

◆ AddSolid() [21/23]

◆ AddSolid() [22/23]

◆ AddSolid() [23/23]

◆ AddSolidT()

◆ AddSolidWithAuxiliaryEdges()

◆ AddViewerToList()

◆ BeginModeling()

◆ BeginPrimitives()

◆ BeginPrimitives2D()

◆ BeginSavingG4Prim()

◆ ClearStore()

◆ ClearTransientStore()

◆ CreateCutawaySolid()

◆ CreateModelingParameters()

◆ CreateSectionSolid()

◆ DrawEndOfRunModels()

◆ DrawEvent()

◆ EndModeling()

◆ EndPrimitives()

◆ EndPrimitives2D()

◆ EndSavingG4Prim()

◆ FRBeginModeling()

◆ FREndModeling()

◆ FRIsInModeling()

◆ GetAuxEdgeVisible()

◆ GetColor() [1/2]

◆ GetColor() [2/2]