#include <G4OpenGLStoredQtSceneHandler.hh>

Inheritance diagram for G4OpenGLStoredQtSceneHandler:

Public Types
enum	FlushAction { endOfEvent , endOfRun , eachPrimitive , NthPrimitive , NthEvent , never }

enum	MarkerSizeType { world , screen }

Public Member Functions
void	AddCompound (const G4Mesh &)

void	AddCompound (const G4THitsMap< G4double > &)

void	AddCompound (const G4THitsMap< G4StatDouble > &)

void	AddCompound (const G4VDigi &)

void	AddCompound (const G4VHit &)

void	AddCompound (const G4VTrajectory &)

void	AddPrimitive (const G4Circle &)

virtual void	AddPrimitive (const G4Circle &)=0

virtual void	AddPrimitive (const G4Plotter &)

void	AddPrimitive (const G4Polyhedron &)

virtual void	AddPrimitive (const G4Polyhedron &)=0

void	AddPrimitive (const G4Polyline &)

virtual void	AddPrimitive (const G4Polyline &)=0

virtual void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Square &)

virtual void	AddPrimitive (const G4Square &)=0

void	AddPrimitive (const G4Text &)

virtual void	AddPrimitive (const G4Text &)=0

void	AddPrimitivesCircle (const std::vector< G4VMarker > &)

void	AddPrimitivesSquare (const std::vector< G4VMarker > &)

void	AddSolid (const G4Box &)

void	AddSolid (const G4Cons &)

void	AddSolid (const G4Ellipsoid &)

void	AddSolid (const G4Orb &)

void	AddSolid (const G4Para &)

void	AddSolid (const G4Polycone &)

void	AddSolid (const G4Polyhedra &)

void	AddSolid (const G4Sphere &)

void	AddSolid (const G4TessellatedSolid &)

void	AddSolid (const G4Torus &)

void	AddSolid (const G4Trap &)

void	AddSolid (const G4Trd &)

void	AddSolid (const G4Tubs &)

void	AddSolid (const G4VSolid &)

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

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

void	AddViewerToList (G4VViewer *pView)

void	BeginModeling ()

void	BeginPrimitives (const G4Transform3D &objectTransformation)

void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

void	ClearStore ()

void	ClearTransientStore ()

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEndOfRunModels ()

void	DrawEvent (const G4Event *)

void	EndModeling ()

void	EndPrimitives ()

void	EndPrimitives2D ()

G4bool	ExtraPOProcessing (const G4Visible &, size_t currentPOListIndex)

G4bool	ExtraTOProcessing (const G4Visible &, size_t currentTOListIndex)

	G4OpenGLStoredQtSceneHandler (G4VGraphicsSystem &system, const G4String &name="")

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

const G4Colour &	GetColor ()

const G4Colour &	GetColor (const G4Visible &)

const G4Colour &	GetColour ()

const G4Colour &	GetColour (const G4Visible &)

G4VViewer *	GetCurrentViewer () const

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

virtual const G4VisExtent &	GetExtent () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4double	GetLineWidth (const G4VisAttributes *)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4bool	GetMarkForClearingTransientStore () const

G4VModel *	GetModel () const

const G4String &	GetName () const

G4int	GetNoOfSides (const G4VisAttributes *)

G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const

const G4Transform3D &	GetObjectTransformation () const

G4Scene *	GetScene () const

G4int	GetSceneHandlerId () const

const G4Colour &	GetTextColor (const G4Text &)

const G4Colour &	GetTextColour (const G4Text &)

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

G4int	GetViewCount () const

const G4ViewerList &	GetViewerList () const

G4int	IncrementViewCount ()

G4bool	IsReadyForTransients () const

virtual void	PostAddSolid ()

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

void	RemoveViewerFromList (G4VViewer *pView)

void	SetCurrentViewer (G4VViewer *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetModel (G4VModel *)

void	SetName (const G4String &)

void	SetObjectTransformation (const G4Transform3D &)

void	SetScene (G4Scene *)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

G4ViewerList &	SetViewerList ()

virtual	~G4OpenGLStoredQtSceneHandler ()

Static Public Member Functions
static G4int	GetDisplayListLimit ()

static G4int	GetEntitiesFlushInterval ()

static FlushAction	GetFlushAction ()

static void	SetDisplayListLimit (G4int lim)

static void	SetEntitiesFlushInterval (G4int interval)

static void	SetFlushAction (FlushAction action)

Protected Member Functions
void	AddPrimitivePostamble ()

G4bool	AddPrimitivePreamble (const G4Polyhedron &visible)

G4bool	AddPrimitivePreamble (const G4Polyline &visible)

G4bool	AddPrimitivePreamble (const G4VMarker &visible)

void	ClearAndDestroyAtts ()

G4DisplacedSolid *	CreateCutawaySolid ()

G4DisplacedSolid *	CreateSectionSolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

void	ScaledFlush ()

Protected Attributes
bool	fEdgeFlag

const G4Transform3D	fIdentityTransformation

G4bool	fMarkForClearingTransientStore

G4String	fName

G4int	fNestingDepth

G4Transform3D	fObjectTransformation

std::map< GLuint, G4AttHolder * >	fPickMap

GLuint	fPickName

G4VModel *	fpModel

std::vector< PO >	fPOList

G4bool	fProcessing2D

G4bool	fProcessingSolid

G4Scene *	fpScene

G4VViewer *	fpViewer

const G4VisAttributes *	fpVisAttribs

G4bool	fReadyForTransients

const G4int	fSceneHandlerId

G4bool	fSecondPassForTransparency

G4bool	fSecondPassForTransparencyRequested

std::map< const G4VSolid , G4int, std::less< const G4VSolid > >	fSolidMap

G4VGraphicsSystem &	fSystem

G4bool	fThirdPassForNonHiddenMarkers

G4bool	fThirdPassForNonHiddenMarkersRequested

G4bool	fThreePassCapable

std::vector< TO >	fTOList

GLint	fTopPODL

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4int	fViewCount

G4ViewerList	fViewerList

Static Protected Attributes
static G4int	fDisplayListId = 0

static G4int	fDisplayListLimit = 1e7

static G4int	fEntitiesFlushInterval = 100

static FlushAction	fFlushAction = G4OpenGLSceneHandler::NthEvent

static G4bool	fMemoryForDisplayLists = true

static G4int	fSceneIdCount = 0

static const GLubyte	fStippleMaskHashed [128]

Private Member Functions
bool	AddPrimitivePreambleInternal (const G4Visible &visible, bool isMarker, bool isPolyline)

Detailed Description

Definition at line 36 of file G4OpenGLStoredQtSceneHandler.hh.

Member Enumeration Documentation

◆ FlushAction

enum G4OpenGLSceneHandler::FlushAction

inherited

Enumerator
endOfEvent
endOfRun
eachPrimitive
NthPrimitive
NthEvent
never

Definition at line 89 of file G4OpenGLSceneHandler.hh.

                   {
    endOfEvent,
    endOfRun,
    eachPrimitive,
    NthPrimitive,
    NthEvent,
    never
  };

◆ 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

◆ G4OpenGLStoredQtSceneHandler()

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

Definition at line 41 of file G4OpenGLStoredQtSceneHandler.cc.

                      :
G4OpenGLStoredSceneHandler (system, name)
{}

◆ ~G4OpenGLStoredQtSceneHandler()

G4OpenGLStoredQtSceneHandler::~G4OpenGLStoredQtSceneHandler ( )

virtual

Definition at line 47 of file G4OpenGLStoredQtSceneHandler.cc.

48{}

Member Function Documentation

◆ AddCompound() [1/6]

void G4OpenGLSceneHandler::AddCompound ( const G4Mesh & mesh )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1026 of file G4OpenGLSceneHandler.cc.

{
  // Special mesh rendering for OpenGL drivers
  // Limited to rectangular 3-deep meshes
  if (mesh.GetMeshType() != G4Mesh::rectangle ||
      mesh.GetMeshDepth() != 3) {
    G4VSceneHandler::AddCompound(mesh);
  }
 
  auto container = mesh.GetContainerVolume();
 
  static G4bool firstPrint = true;
  G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
  G4bool print = firstPrint && verbosity >= G4VisManager::confirmations;
 
  if (print) {
    G4cout
    << "Special case drawing of G4VNestedParameterisation in G4OpenGLSceneHandler"
    << '\n' << mesh
    << G4endl;
  }
 
  // Instantiate a temporary G4PhysicalVolumeModel
  G4ModelingParameters tmpMP;
  tmpMP.SetCulling(true);  // This avoids drawing transparent...
  tmpMP.SetCullingInvisible(true);  // ... or invisble volumes.
  const G4bool useFullExtent = true;  // To avoid calculating the extent
  G4PhysicalVolumeModel tmpPVModel
  (container,
   G4PhysicalVolumeModel::UNLIMITED,
   G4Transform3D(),
   &tmpMP,
   useFullExtent);
 
  // Instantiate a pseudo scene so that we can make a "private" descent
  // into the nested parameterisation and fill a multimap...
  std::multimap<const G4Colour,G4ThreeVector> positionByColour;
  G4double halfX = 0., halfY = 0., halfZ = 0.;
  struct PseudoScene: public G4PseudoScene {
    PseudoScene
    (G4PhysicalVolumeModel* pvModel // input...the following are outputs
     , std::multimap<const G4Colour,G4ThreeVector>& positionByColour
     , G4double& halfX, G4double& halfY, G4double& halfZ)
    : fpPVModel(pvModel)
    , fPositionByColour(positionByColour)
    , fHalfX(halfX), fHalfY(halfY), fHalfZ(halfZ)
    {}
    using G4PseudoScene::AddSolid;  // except for...
    void AddSolid(const G4Box& box) {
      const G4Colour& colour = fpPVModel->GetCurrentLV()->GetVisAttributes()->GetColour();
      const G4ThreeVector& position = fpCurrentObjectTransformation->getTranslation();
      fPositionByColour.insert(std::make_pair(colour,position));
      fHalfX = box.GetXHalfLength();
      fHalfY = box.GetYHalfLength();
      fHalfZ = box.GetZHalfLength();
    }
    G4PhysicalVolumeModel* fpPVModel;
    std::multimap<const G4Colour,G4ThreeVector>& fPositionByColour;
    G4double &fHalfX, &fHalfY, &fHalfZ;
  }
  pseudoScene(&tmpPVModel,positionByColour,halfX,halfY,halfZ);
 
  // Make private descent into the nested parameterisation
  tmpPVModel.DescribeYourselfTo(pseudoScene);
 
  // Make list of found colours
  std::set<G4Colour> setOfColours;
  for (const auto& entry: positionByColour) {
    setOfColours.insert(entry.first);
  }
 
  if (print) {
    for (const auto& colour: setOfColours) {
      G4cout << "setOfColours: " << colour << G4endl;
    }
  }
 
  // Draw as dots
  BeginPrimitives (mesh.GetTransform());
  G4int nDotsTotal = 0;
  for (const auto& colour: setOfColours) {
    G4int nDots = 0;
    G4Polymarker dots;
    dots.SetVisAttributes(G4Colour(colour));
    dots.SetMarkerType(G4Polymarker::dots);
    dots.SetSize(G4VMarker::screen,1.);
    dots.SetInfo(container->GetName());
    const auto range = positionByColour.equal_range(colour);
    for (auto posByCol = range.first; posByCol != range.second; ++posByCol) {
      const G4double x = posByCol->second.getX() + (2.*G4UniformRand()-1.)*halfX;
      const G4double y = posByCol->second.getY() + (2.*G4UniformRand()-1.)*halfY;
      const G4double z = posByCol->second.getZ() + (2.*G4UniformRand()-1.)*halfZ;
      dots.push_back(G4ThreeVector(x,y,z));
      ++nDots;
    }
    AddPrimitive(dots);
    if (print) {
      G4cout
      << "Number of dots for colour " << colour
      << ": " << nDots << G4endl;
    }
    nDotsTotal += nDots;
  }
  if (print) {
    G4cout << "Total number of dots: " << nDotsTotal << G4endl;
  }
  EndPrimitives ();
 
  firstPrint = false;
 
  return;
}

References G4VSceneHandler::AddCompound(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLSceneHandler::AddSolid(), G4PseudoScene::AddSolid(), G4OpenGLSceneHandler::BeginPrimitives(), G4VisManager::confirmations, G4PhysicalVolumeModel::DescribeYourselfTo(), G4Polymarker::dots, G4OpenGLSceneHandler::EndPrimitives(), G4cout, G4endl, G4UniformRand, G4Colour::GetColour(), G4Mesh::GetContainerVolume(), G4Mesh::GetMeshDepth(), G4Mesh::GetMeshType(), G4Mesh::GetTransform(), G4VisManager::GetVerbosity(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), print(), G4Mesh::rectangle, G4VMarker::screen, G4ModelingParameters::SetCulling(), G4ModelingParameters::SetCullingInvisible(), G4VMarker::SetInfo(), G4Polymarker::SetMarkerType(), G4VMarker::SetSize(), G4Visible::SetVisAttributes(), and G4PhysicalVolumeModel::UNLIMITED.

◆ AddCompound() [2/6]

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

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1018 of file G4OpenGLSceneHandler.cc.

                                                                       {
  G4VSceneHandler::AddCompound(hits);  // For now.
}

References G4VSceneHandler::AddCompound().

◆ AddCompound() [3/6]

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

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1022 of file G4OpenGLSceneHandler.cc.

                                                                           {
  G4VSceneHandler::AddCompound(hits);  // For now.
}

References G4VSceneHandler::AddCompound().

◆ AddCompound() [4/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VDigi & digi )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1014 of file G4OpenGLSceneHandler.cc.

                                                          {
  G4VSceneHandler::AddCompound(digi);  // For now.
}

References G4VSceneHandler::AddCompound().

◆ AddCompound() [5/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VHit & hit )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1010 of file G4OpenGLSceneHandler.cc.

                                                        {
  G4VSceneHandler::AddCompound(hit);  // For now.
}

References G4VSceneHandler::AddCompound().

◆ AddCompound() [6/6]

void G4OpenGLSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 1006 of file G4OpenGLSceneHandler.cc.

                                                                {
  G4VSceneHandler::AddCompound(traj);  // For now.
}

References G4VSceneHandler::AddCompound().

◆ AddPrimitive() [1/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Circle & circle )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 518 of file G4OpenGLStoredSceneHandler.cc.

{
  G4bool furtherprocessing = AddPrimitivePreamble(circle);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(circle);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [2/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

◆ AddPrimitive() [3/13]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 192 of file G4VSceneHandler.cc.

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

◆ AddPrimitive() [4/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 536 of file G4OpenGLStoredSceneHandler.cc.

{
  // Note: colour is still handled in
  // G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&), so it still
  // gets into the display list
  G4bool furtherprocessing = AddPrimitivePreamble(polyhedron);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(polyhedron);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [5/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

◆ AddPrimitive() [6/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Polyline & polyline )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 488 of file G4OpenGLStoredSceneHandler.cc.

{
  G4bool furtherprocessing = AddPrimitivePreamble(polyline);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(polyline);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [7/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

◆ AddPrimitive() [8/13]

void G4VSceneHandler::AddPrimitive ( const G4Polymarker & polymarker )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 190 of file G4VSceneHandler.cc.

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

◆ AddPrimitive() [9/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Polymarker & polymarker )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 497 of file G4OpenGLStoredSceneHandler.cc.

{
  G4bool furtherprocessing = AddPrimitivePreamble(polymarker);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(polymarker);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [10/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Square & square )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 527 of file G4OpenGLStoredSceneHandler.cc.

{
  G4bool furtherprocessing = AddPrimitivePreamble(square);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(square);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [11/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

◆ AddPrimitive() [12/13]

void G4OpenGLStoredSceneHandler::AddPrimitive ( const G4Text & text )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 506 of file G4OpenGLStoredSceneHandler.cc.

{
  // Note: colour is still handled in
  // G4OpenGLSceneHandler::AddPrimitive(const G4Text&), so it still
  // gets into the display list
  G4bool furtherprocessing = AddPrimitivePreamble(text);
  if (furtherprocessing) {
    G4OpenGLSceneHandler::AddPrimitive(text);
    AddPrimitivePostamble();
  }
}

References G4OpenGLSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), and G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitive() [13/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text & )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

◆ AddPrimitivePostamble()

void G4OpenGLStoredSceneHandler::AddPrimitivePostamble ( )

protectedinherited

Definition at line 457 of file G4OpenGLStoredSceneHandler.cc.

{
  if (fProcessing2D) {
    // Pop current 3D world matrices back again...
    glMatrixMode (GL_PROJECTION);
    glPopMatrix();
    glMatrixMode (GL_MODELVIEW);
    glPopMatrix();
  }
 
  //  if ((glGetError() == GL_TABLE_TOO_LARGE) || (glGetError() == GL_OUT_OF_MEMORY)) {  // Could close?
  if (glGetError() == GL_OUT_OF_MEMORY) {  // Could close?
    G4cerr <<
      "ERROR: G4OpenGLStoredSceneHandler::AddPrimitivePostamble: Failure"
      "  to allocate display List for fTopPODL - try OpenGL Immediated mode."
           << G4endl;
  }
  if (fMemoryForDisplayLists) {
    glEndList();
    if (glGetError() == GL_OUT_OF_MEMORY) {  // Could close?
      G4cerr <<
        "ERROR: G4OpenGLStoredSceneHandler::AddPrimitivePostamble: Failure"
    "  to allocate display List for fTopPODL - try OpenGL Immediated mode."
             << G4endl;
    }
  }
  if (fReadyForTransients || !fMemoryForDisplayLists) {
    glPopMatrix();
  }
}

References G4OpenGLStoredSceneHandler::fMemoryForDisplayLists, G4VSceneHandler::fProcessing2D, G4VSceneHandler::fReadyForTransients, G4cerr, and G4endl.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitive().

◆ AddPrimitivePreamble() [1/3]

G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble ( const G4Polyhedron & visible )

protectedinherited

Definition at line 198 of file G4OpenGLStoredSceneHandler.cc.

{
  return AddPrimitivePreambleInternal(visible, false, false);
}

References G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

◆ AddPrimitivePreamble() [2/3]

G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble ( const G4Polyline & visible )

protectedinherited

Definition at line 194 of file G4OpenGLStoredSceneHandler.cc.

{
  return AddPrimitivePreambleInternal(visible, false, true);
}

References G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

◆ AddPrimitivePreamble() [3/3]

G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble ( const G4VMarker & visible )

protectedinherited

Definition at line 190 of file G4OpenGLStoredSceneHandler.cc.

{
  return AddPrimitivePreambleInternal(visible, true, false);
}

References G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

Referenced by G4OpenGLStoredSceneHandler::AddPrimitive().

◆ AddPrimitivePreambleInternal()

G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal	(	const G4Visible &	visible,
		bool	isMarker,
		bool	isPolyline
	)

privateinherited

Definition at line 203 of file G4OpenGLStoredSceneHandler.cc.

{
// Get applicable vis attributes for all primitives.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
  const G4Colour& c = GetColour ();
  G4double opacity = c.GetAlpha ();
 
  G4bool transparency_enabled = true;
  G4bool isMarkerNotHidden = true;
  G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
  if (pOGLViewer) {
    transparency_enabled = pOGLViewer->transparency_enabled;
    isMarkerNotHidden = pOGLViewer->fVP.IsMarkerNotHidden();
  }
  
  G4bool isTransparent = opacity < 1.;
  G4bool isMarkerOrPolyline = isMarker || isPolyline;
  G4bool treatAsTransparent = transparency_enabled && isTransparent;
  G4bool treatAsNotHidden = isMarkerNotHidden && isMarkerOrPolyline;
  
  if (fProcessing2D) glDisable (GL_DEPTH_TEST);
  else {
    if (isMarkerOrPolyline && isMarkerNotHidden)
      glDisable (GL_DEPTH_TEST);
    else {glEnable (GL_DEPTH_TEST); glDepthFunc (GL_LEQUAL);}
  }
 
  if (fThreePassCapable) {
    
    // Ensure transparent objects are drawn opaque ones and before
    // non-hidden markers.  The problem of blending/transparency/alpha
    // is quite a tricky one - see History of opengl-V07-01-01/2/3.
    if (!(fSecondPassForTransparency || fThirdPassForNonHiddenMarkers)) {
      // First pass...
      if (treatAsTransparent) {  // Request pass for transparent objects...
        fSecondPassForTransparencyRequested = true;
      }
      if (treatAsNotHidden) {    // Request pass for non-hidden markers...
        fThirdPassForNonHiddenMarkersRequested = true;
      }
      // On first pass, transparent objects and non-hidden markers are not drawn...
      if (treatAsTransparent || treatAsNotHidden) {
        return false;  // No further processing.
      }
    }
    
    // On second pass, only transparent objects are drawn...
    if (fSecondPassForTransparency) {
      if (!treatAsTransparent) {
        return false;  // No further processing.
      }
    }
    
    // On third pass, only non-hidden markers are drawn...
    if (fThirdPassForNonHiddenMarkers) {
      if (!treatAsNotHidden) {
        return false;  // No further processing.
      }
    }
  }  // fThreePassCapable
  
  // Loads G4Atts for picking...
  G4bool isPicking = false;
  if (fpViewer->GetViewParameters().IsPicking()) {
    isPicking = true;
    glLoadName(++fPickName);
    G4AttHolder* holder = new G4AttHolder;
    LoadAtts(visible, holder);
    fPickMap[fPickName] = holder;
  }
  
  const G4VSolid* pSolid = 0;
 
  // Can we re-use a display list?
  if (isMarker)
    // It is a marker, which may have its own position relative to fObjectTransformation
    goto end_of_display_list_reuse_test;
  if (fpViewer->GetViewParameters().GetVisAttributesModifiers().size())
    // Touchables have been modified - don't risk re-using display list.
    goto end_of_display_list_reuse_test;
  {  // It is a viable candidate for display list re-use
    G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
    if (pPVModel) {
      // Check that it isn't a G4LogicalVolumeModel (which is a sub-class of
      // G4PhysicalVolumeModel).
      G4LogicalVolumeModel* pLVModel =
      dynamic_cast<G4LogicalVolumeModel*>(pPVModel);
      if (pLVModel)
        // Logical volume model - don't re-use.
        goto end_of_display_list_reuse_test;
      // If part of the geometry hierarchy, i.e., from a
      // G4PhysicalVolumeModel, check if a display list already exists for
      // this solid, re-use it if possible.  We could be smarter, and
      // recognise repeated branches of the geometry hierarchy, for
      // example.  But this algorithm should be secure, I think...
      G4VPhysicalVolume* pPV = pPVModel->GetCurrentPV();
      if (!pPV)
        // It's probably a dummy model, e.g., for a user-drawn hit?
        goto end_of_display_list_reuse_test;
      G4LogicalVolume* pLV = pPV->GetLogicalVolume();
      if (!pLV)
        // Dummy model again?
        goto end_of_display_list_reuse_test;
      pSolid = pLV->GetSolid();
      EAxis axis = kRho;
      G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
      if (pCurrentPV -> IsReplicated ()) {
        G4int nReplicas;
        G4double width;
        G4double offset;
        G4bool consuming;
        pCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
      }
      // Provided it is not parametrised (because if so, the
      // solid's parameters might have been changed)...
      if (!(pCurrentPV -> IsParameterised ()) &&
          // Provided it is not replicated radially (because if so, the
          // solid's parameters will have been changed)...
          !(pCurrentPV -> IsReplicated () && axis == kRho) &&
          // ...and if the solid has already been rendered...
          (fSolidMap.find (pSolid) != fSolidMap.end ())) {
        fDisplayListId = fSolidMap [pSolid];
        PO po(fDisplayListId,fObjectTransformation);
        if (isPicking) po.fPickName = fPickName;
        po.fColour = c;
        po.fMarkerOrPolyline = isMarkerOrPolyline;
        fPOList.push_back(po);
        // No need to test if gl commands are used (result of
        // ExtraPOProcessing) because we have already decided they will
        // not, at least not here.  Also, pass a dummy G4Visible since
        // not relevant for G4PhysicalVolumeModel.
        (void) ExtraPOProcessing(G4Visible(), fPOList.size() - 1);
        return false;  // No further processing.
      }
    }
  }
end_of_display_list_reuse_test:
 
  // Because of our need to control colour of transients (display by
  // time fading), display lists may only cover a single primitive.
  // So display list setup is here.
  
  if (fMemoryForDisplayLists) {
    fDisplayListId = glGenLists (1);
    if (glGetError() == GL_OUT_OF_MEMORY ||
    fDisplayListId > fDisplayListLimit) {
      G4cout <<
      "********************* WARNING! ********************"
      "\n*  Display list limit reached in OpenGL."
      "\n*  Continuing drawing WITHOUT STORING. Scene only partially refreshable."
      "\n*  Current limit: " << fDisplayListLimit << " primitives"
      ".  Change with \"/vis/ogl/set/displayListLimit\"."
      "\n***************************************************"
      << G4endl;
      fMemoryForDisplayLists = false;
    }
  }
  
  if (pSolid) fSolidMap [pSolid] = fDisplayListId;
 
  if (fMemoryForDisplayLists) {
    if (fReadyForTransients) {
      TO to(fDisplayListId, fObjectTransformation);
      if (isPicking) to.fPickName = fPickName;
      to.fColour = c;
      to.fStartTime = fpVisAttribs->GetStartTime();
      to.fEndTime = fpVisAttribs->GetEndTime();
      to.fMarkerOrPolyline = isMarkerOrPolyline;
      fTOList.push_back(to);
      // For transient objects, colour, transformation, are kept in
      // the TO, so should *not* be in the display list.  As mentioned
      // above, in some cases (display-by-time fading) we need to have
      // independent control of colour.  But for now transform and set
      // colour for immediate display.
      glPushMatrix();
      G4OpenGLTransform3D oglt (fObjectTransformation);
      glMultMatrixd (oglt.GetGLMatrix ());
      if (transparency_enabled) {
        glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
      } else {
        glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
      }
      (void) ExtraTOProcessing(visible, fTOList.size() - 1);
      // Ignore return value of the above.  If this visible does not use
      // gl commands, a display list is created that is empty and not
      // used.
      glNewList (fDisplayListId, GL_COMPILE_AND_EXECUTE);
    } else {
      PO po(fDisplayListId, fObjectTransformation);
      if (isPicking) po.fPickName = fPickName;
      po.fColour = c;
      po.fMarkerOrPolyline = isMarkerOrPolyline;
      fPOList.push_back(po);
      // For permanent objects, colour is kept in the PO, so should
      // *not* be in the display list.  This is so that sub-classes
      // may implement colour modifications according to their own
      // criteria, e.g., scene tree slider in Qt.  But for now set
      // colour for immediate display.
      if (transparency_enabled) {
        glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
      } else {
        glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
      }
      G4bool usesGLCommands = ExtraPOProcessing(visible, fPOList.size() - 1);
      // Transients are displayed as they come (GL_COMPILE_AND_EXECUTE
      // above) but persistents are compiled into display lists
      // (GL_COMPILE only) and then drawn from the display lists with
      // their fObjectTransformation as stored in fPOList.  Thus,
      // there is no need to do glMultMatrixd here.  If
      // ExtraPOProcessing says the visible object does not use gl
      // commands, simply return and abandon further processing.  It
      // is assumed that all relevant information is kept in the
      // POList.
      if (!usesGLCommands) return false;
      glNewList (fDisplayListId, GL_COMPILE);
    }
  } else {  // Out of memory (or being used when display lists not required).
    glPushMatrix();
    G4OpenGLTransform3D oglt (fObjectTransformation);
    glMultMatrixd (oglt.GetGLMatrix ());
    if (transparency_enabled) {
      glColor4d(c.GetRed(),c.GetGreen(),c.GetBlue(),c.GetAlpha());
    } else {
      glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
    }
  }
 
  if (fProcessing2D) {
    // Push current 3D world matrices and load identity to define screen
    // coordinates...
    glMatrixMode (GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    if (pOGLViewer) {
      pOGLViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
    }
    glMatrixMode (GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    G4OpenGLTransform3D oglt (fObjectTransformation);
    glMultMatrixd (oglt.GetGLMatrix ());
    glDisable (GL_LIGHTING);
  } else {
    if (isMarker) {
      glDisable (GL_LIGHTING);
    } else {
      glEnable (GL_LIGHTING);
    }
  }
 
  return true;
}

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreamble().

◆ AddPrimitivesCircle()

void G4OpenGLSceneHandler::AddPrimitivesCircle ( const std::vector< G4VMarker > & )

inherited

◆ AddPrimitivesSquare()

void G4OpenGLSceneHandler::AddPrimitivesSquare ( const std::vector< G4VMarker > & )

inherited

◆ AddSolid() [1/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Box & )

virtualinherited

Reimplemented from G4VSceneHandler.

Referenced by G4OpenGLSceneHandler::AddCompound().

◆ AddSolid() [2/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Cons & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [3/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Ellipsoid & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [4/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Orb & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [5/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Para & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [6/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Polycone & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [7/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Polyhedra & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [8/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Sphere & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [9/14]

void G4OpenGLSceneHandler::AddSolid ( const G4TessellatedSolid & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [10/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Torus & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [11/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Trap & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [12/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Trd & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [13/14]

void G4OpenGLSceneHandler::AddSolid ( const G4Tubs & )

virtualinherited

Reimplemented from G4VSceneHandler.

◆ AddSolid() [14/14]

void G4OpenGLSceneHandler::AddSolid ( const G4VSolid & )

virtualinherited

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 G4OpenGLStoredSceneHandler::BeginModeling ( )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 548 of file G4OpenGLStoredSceneHandler.cc.

                                                {
  G4VSceneHandler::BeginModeling();
  /* Debug...
  fDisplayListId = glGenLists (1);
  G4cout << "OGL::fDisplayListId (start): " << fDisplayListId << G4endl;
  */
}

References G4VSceneHandler::BeginModeling().

◆ BeginPrimitives()

void G4OpenGLStoredSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 159 of file G4OpenGLStoredSceneHandler.cc.

{  
  G4OpenGLSceneHandler::BeginPrimitives (objectTransformation);
  if (fReadyForTransients) glDrawBuffer (GL_FRONT);
  // Display list setup moved to AddPrimitivePreamble.  See notes there.
}

References G4OpenGLSceneHandler::BeginPrimitives(), and G4VSceneHandler::fReadyForTransients.

◆ BeginPrimitives2D()

void G4OpenGLStoredSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 175 of file G4OpenGLStoredSceneHandler.cc.

{
  G4OpenGLSceneHandler::BeginPrimitives2D(objectTransformation);
  if (fReadyForTransients) glDrawBuffer (GL_FRONT);
}

References G4OpenGLSceneHandler::BeginPrimitives2D(), and G4VSceneHandler::fReadyForTransients.

◆ ClearAndDestroyAtts()

void G4OpenGLSceneHandler::ClearAndDestroyAtts ( )

protectedinherited

Definition at line 105 of file G4OpenGLSceneHandler.cc.

{
  std::map<GLuint, G4AttHolder*>::iterator i;
  for (i = fPickMap.begin(); i != fPickMap.end(); ++i) delete i->second;
  fPickMap.clear();
}

References G4OpenGLSceneHandler::fPickMap.

Referenced by G4OpenGLStoredSceneHandler::ClearStore().

◆ ClearStore()

void G4OpenGLStoredQtSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4OpenGLStoredQtSceneHandler.cc.

                                               {
 
  //G4cout << "G4OpenGLStoredQtSceneHandler::ClearStore" << G4endl;
 
  G4OpenGLStoredSceneHandler::ClearStore ();  // Sets need kernel visit, etc.
  // Should recreate the tree
  G4OpenGLQtViewer* pGLQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
  if ( pGLQtViewer ) {
    pGLQtViewer->clearTreeWidget();
  }
}

References G4OpenGLStoredSceneHandler::ClearStore(), G4OpenGLQtViewer::clearTreeWidget(), and G4VSceneHandler::fpViewer.

◆ ClearTransientStore()

void G4OpenGLStoredQtSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 145 of file G4OpenGLStoredQtSceneHandler.cc.

                                                        {
 
  //G4cout << "G4OpenGLStoredQtSceneHandler::ClearTransientStore" << G4endl;
 
  G4OpenGLStoredSceneHandler::ClearTransientStore ();
 
  // Should recreate the tree
  // Make sure screen corresponds to graphical database...
  // FIXME : L.Garnier April 2012 : Could cause a infinite loop ?
  if (fpViewer) {
    fpViewer -> SetView ();
    fpViewer -> ClearView ();
    fpViewer -> DrawView ();
  }
}

References G4OpenGLStoredSceneHandler::ClearTransientStore(), and G4VSceneHandler::fpViewer.

◆ CreateCutawaySolid()

G4DisplacedSolid * G4OpenGLSceneHandler::CreateCutawaySolid ( )

protectedvirtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 336 of file G4OpenGLSceneHandler.cc.

{
  // return G4VSceneHandler::CreateCutawaySolid();
  // If cutaway done in G4OpenGLViewer::SetView.
  return 0;
  // Note: if you change this, you must also change
  // G4OpenGLStoredViewer::CompareForKernelVisit
}

◆ 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 * G4OpenGLSceneHandler::CreateSectionSolid ( )

protectedvirtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 327 of file G4OpenGLSceneHandler.cc.

{
  return G4VSceneHandler::CreateSectionSolid();
  // If clipping done in G4OpenGLViewer::SetView
  // return 0;
  // Note: if you change this, you must also change
  // G4OpenGLStoredViewer::CompareForKernelVisit
}

References G4VSceneHandler::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 G4OpenGLStoredSceneHandler::EndModeling ( )

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 556 of file G4OpenGLStoredSceneHandler.cc.

                                              {
  // Make a List which calls the other lists.
  fTopPODL = glGenLists (1);
  if (glGetError() == GL_OUT_OF_MEMORY) {  // Could pre-allocate?
    G4cerr <<
      "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
      "  display List for fTopPODL - try OpenGL Immediated mode."
       << G4endl;
  } else {
 
    glNewList (fTopPODL, GL_COMPILE); {
      for (size_t i = 0; i < fPOList.size (); i++) {
    glPushMatrix();
    G4OpenGLTransform3D oglt (fPOList[i].fTransform);
    glMultMatrixd (oglt.GetGLMatrix ());
    if (fpViewer->GetViewParameters().IsPicking())
      glLoadName(fPOList[i].fPickName);
    glCallList (fPOList[i].fDisplayListId);
    glPopMatrix();
      }
    }
    glEndList ();
 
    if (glGetError() == GL_OUT_OF_MEMORY) {  // Could close?
      G4cerr <<
        "ERROR: G4OpenGLStoredSceneHandler::EndModeling: Failure to allocate"
        "  display List for fTopPODL - try OpenGL Immediated mode."
             << G4endl;
    }
  }
 
  G4VSceneHandler::EndModeling ();
}

References G4VSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::fDisplayListId, G4OpenGLSceneHandler::fPickName, G4OpenGLStoredSceneHandler::fPOList, G4VSceneHandler::fpViewer, G4OpenGLStoredSceneHandler::fTopPODL, G4cerr, G4endl, G4OpenGLTransform3D::GetGLMatrix(), G4VViewer::GetViewParameters(), and G4ViewParameters::IsPicking().

◆ EndPrimitives()

void G4OpenGLStoredSceneHandler::EndPrimitives ( )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 167 of file G4OpenGLStoredSceneHandler.cc.

{
  // See all primitives immediately...  At least soon...
  ScaledFlush();
  glDrawBuffer (GL_BACK);
  G4OpenGLSceneHandler::EndPrimitives ();
}

References G4OpenGLSceneHandler::EndPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

◆ EndPrimitives2D()

void G4OpenGLStoredSceneHandler::EndPrimitives2D ( )

virtualinherited

Reimplemented from G4OpenGLSceneHandler.

Definition at line 182 of file G4OpenGLStoredSceneHandler.cc.

{
  // See all primitives immediately...  At least soon...
  ScaledFlush();
  glDrawBuffer (GL_BACK);
  G4OpenGLSceneHandler::EndPrimitives2D ();
}

References G4OpenGLSceneHandler::EndPrimitives2D(), and G4OpenGLSceneHandler::ScaledFlush().

◆ ExtraPOProcessing()

G4bool G4OpenGLStoredQtSceneHandler::ExtraPOProcessing	(	const G4Visible &	visible,
		size_t	currentPOListIndex
	)

virtual

Reimplemented from G4OpenGLStoredSceneHandler.

Definition at line 50 of file G4OpenGLStoredQtSceneHandler.cc.

{
  G4bool usesGLCommands = true;
 
  try {
    const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
    G4TextPlus* pG4TextPlus = new G4TextPlus(g4Text);
    pG4TextPlus->fProcessing2D = fProcessing2D;
    fPOList[currentPOListIndex].fpG4TextPlus = pG4TextPlus;
    usesGLCommands = false;
  }
  catch (const std::bad_cast&) {}  // No special action if not text.  Just carry on.
 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  G4LogicalVolumeModel* pLVModel =
    dynamic_cast<G4LogicalVolumeModel*>(pPVModel);
  if (pPVModel && !pLVModel) {
 
    // This call comes from a G4PhysicalVolumeModel.  drawnPVPath is
    // the path of the current drawn (non-culled) volume in terms of
    // drawn (non-culled) ancestors.  Each node is identified by a
    // PVNodeID object, which is a physical volume and copy number.  It
    // is a vector of PVNodeIDs corresponding to the geometry hierarchy
    // actually selected, i.e., not culled.
    //    typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
    //    typedef std::vector<PVNodeID> PVPath;
 
    // The simplest algorithm, used by the Open Inventor Driver
    // developers, is to rely on the fact the G4PhysicalVolumeModel
    // traverses the geometry hierarchy in an orderly manner.  The last
    // mother, if any, will be the node to which the volume should be
    // added.  So it is enough to keep a map of scene graph nodes keyed
    // on the volume path ID.  Actually, it is enough to use the logical
    // volume as the key.  (An alternative would be to keep the PVNodeID
    // in the tree and match the PVPath from the root down.)
 
    // BUT IN OPENGL, IF THERE ARE TRANSPARENT OBJECTS, VOLUMES DO NOT
    // ARRIVE IN THE ABOVE ORDER.  (TRANSPARENT OBJECTS ARE DRWAN
    // LAST.)  SO WE MUST BE MORE SOPHISTICATED IN CONSTRUCTING A
    // TREE.
 
    // build a path for tree viewer
    G4OpenGLQtViewer* pGLViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
    if ( pGLViewer ) {
      pGLViewer->addPVSceneTreeElement(fpModel->GetCurrentDescription(),pPVModel,currentPOListIndex);
    }
 
  } else {  // Not from a G4PhysicalVolumeModel.
 
    if (fpModel) {
 
      
      // build a path for tree viewer
      G4OpenGLQtViewer* pGLViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
      if ( pGLViewer ) {
        pGLViewer->addNonPVSceneTreeElement(fpModel->GetType(),currentPOListIndex,fpModel->GetCurrentDescription().data(),visible);
      }
    }
  }
 
  return usesGLCommands;
}

References G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VSceneHandler::fpModel, G4OpenGLStoredSceneHandler::fPOList, G4VSceneHandler::fProcessing2D, G4OpenGLStoredSceneHandler::G4TextPlus::fProcessing2D, G4VSceneHandler::fpViewer, G4VModel::GetCurrentDescription(), and G4VModel::GetType().

◆ ExtraTOProcessing()

G4bool G4OpenGLStoredQtSceneHandler::ExtraTOProcessing	(	const G4Visible &	visible,
		size_t	currentTOListIndex
	)

virtual

Reimplemented from G4OpenGLStoredSceneHandler.

Definition at line 115 of file G4OpenGLStoredQtSceneHandler.cc.

{
 
  G4bool usesGLCommands = true;
 
  try {
    const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
    G4TextPlus* pG4TextPlus = new G4TextPlus(g4Text);
    pG4TextPlus->fProcessing2D = fProcessing2D;
    fTOList[currentTOListIndex].fpG4TextPlus = pG4TextPlus;
    usesGLCommands = false;
  }
  catch (const std::bad_cast&) {}  // Do nothing if not text.
 
  return usesGLCommands;
}

References G4VSceneHandler::fProcessing2D, G4OpenGLStoredSceneHandler::G4TextPlus::fProcessing2D, and G4OpenGLStoredSceneHandler::fTOList.

◆ 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

◆ GetDisplayListLimit()

static G4int G4OpenGLStoredSceneHandler::GetDisplayListLimit ( )

inlinestaticinherited

Definition at line 67 of file G4OpenGLStoredSceneHandler.hh.

67{return fDisplayListLimit;}

References G4OpenGLStoredSceneHandler::fDisplayListLimit.

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

◆ GetEntitiesFlushInterval()

static G4int G4OpenGLSceneHandler::GetEntitiesFlushInterval ( )

inlinestaticinherited

Definition at line 97 of file G4OpenGLSceneHandler.hh.

98 {return fEntitiesFlushInterval;}

G4OpenGLSceneHandler::fEntitiesFlushInterval

static G4int fEntitiesFlushInterval

Definition: G4OpenGLSceneHandler.hh:165

References G4OpenGLSceneHandler::fEntitiesFlushInterval.

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

◆ GetFlushAction()

static FlushAction G4OpenGLSceneHandler::GetFlushAction ( )

inlinestaticinherited

Definition at line 99 of file G4OpenGLSceneHandler.hh.

100 {return fFlushAction;}

G4OpenGLSceneHandler::fFlushAction

static FlushAction fFlushAction

Definition: G4OpenGLSceneHandler.hh:163

References G4OpenGLSceneHandler::fFlushAction.

Referenced by G4OpenGLViewer::printGl2PS().

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

◆ GetTextColor()

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

inherited

◆ GetTextColour()

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

inherited

Definition at line 1006 of file G4VSceneHandler.cc.

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

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

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

◆ GetTransientsDrawnThisEvent()

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

◆ GetTransientsDrawnThisRun()

G4bool G4VSceneHandler::GetTransientsDrawnThisRun ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

◆ GetViewCount()

G4int G4VSceneHandler::GetViewCount ( ) const

inherited

◆ GetViewerList()

const G4ViewerList & G4VSceneHandler::GetViewerList ( ) const

inherited

◆ IncrementViewCount()

G4int G4VSceneHandler::IncrementViewCount ( )

inherited

◆ IsReadyForTransients()

G4bool G4VSceneHandler::IsReadyForTransients ( ) const

inherited

◆ LoadAtts()

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

protectedinherited

Definition at line 934 of file G4VSceneHandler.cc.

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

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

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

◆ PostAddSolid()

void G4VSceneHandler::PostAddSolid ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 151 of file G4VSceneHandler.cc.

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

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

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

◆ PreAddSolid()

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

virtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 298 of file G4OpenGLSceneHandler.cc.

{
  G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
}

References G4VSceneHandler::PreAddSolid().

◆ ProcessScene()

void G4OpenGLSceneHandler::ProcessScene ( )

protectedvirtualinherited

Reimplemented from G4VSceneHandler.

Definition at line 273 of file G4OpenGLSceneHandler.cc.

{
  fThreePassCapable = true;
  
  G4VSceneHandler::ProcessScene();
 
  // Repeat if required...
  if (fSecondPassForTransparencyRequested) {
    fSecondPassForTransparency = true;
    G4VSceneHandler::ProcessScene();
    fSecondPassForTransparency = false;
    fSecondPassForTransparencyRequested = false;
  }
 
  // And again if required...
  if (fThirdPassForNonHiddenMarkersRequested) {
    fThirdPassForNonHiddenMarkers = true;
    G4VSceneHandler::ProcessScene();
    fThirdPassForNonHiddenMarkers = false;
    fThirdPassForNonHiddenMarkersRequested = false;
  }
  
  fThreePassCapable = false;
}

References G4OpenGLSceneHandler::fSecondPassForTransparency, G4OpenGLSceneHandler::fSecondPassForTransparencyRequested, G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkers, G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkersRequested, G4OpenGLSceneHandler::fThreePassCapable, and G4VSceneHandler::ProcessScene().

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

◆ ScaledFlush()

void G4OpenGLSceneHandler::ScaledFlush ( )

protectedinherited

Definition at line 116 of file G4OpenGLSceneHandler.cc.

{
  if (fReadyForTransients) {
 
    // Drawing transients, e.g., trajectories.
 
    if (!fpScene) {
      // No scene - shouldn't happen
      glFlush();
      return;
    }
    // Get event from modeling parameters
    if (!fpModel) {
      // No model - shouldn't happen
      glFlush();
      return;
    }
    const G4ModelingParameters* modelingParameters =
    fpModel->GetModelingParameters();
    if (!modelingParameters) {
      // No modeling parameters - shouldn't happen
      glFlush();
      return;
    }
    const G4Event* thisEvent = modelingParameters->GetEvent();
    if (!thisEvent) {
      // No event, so not in event loop.
      if (fFlushAction == endOfEvent) {
        fFlushAction = endOfRun;
      } else if (fFlushAction == NthEvent) {
        fFlushAction = NthPrimitive;
      }
    }
    G4RunManager* runMan = G4RunManagerFactory::GetMasterRunManager();
    if (!runMan) {
      // No run manager - shouldn't happen
      glFlush();
      return;
    }
    const G4Run* thisRun = runMan->GetCurrentRun();
    if (!thisRun) {
      // No run, so not in event loop.
      if (fFlushAction == endOfRun) {
        fFlushAction = NthPrimitive;
      } else if (fFlushAction == NthEvent) {
        fFlushAction = NthPrimitive;
      }
    }
 
    switch (fFlushAction) {
      case endOfEvent:
        // If "/vis/scene/endOfEventAction refresh", primitives are flushed at
        // end of run anyway, so only scale if false.
        if (!fpScene->GetRefreshAtEndOfEvent()) {
          // But if "/vis/scene/endOfEventAction accumulate", ShowView is not
          // called until end of run, so we have to watch for a new event.
          // Get event from modeling parameters
          G4int thisEventID = thisEvent->GetEventID();
          static G4int lastEventID = 0;
          if (thisEventID != lastEventID) {
            glFlush();
            lastEventID = thisEventID;
          }
        }
        break;
      case endOfRun:
        // If "/vis/scene/endOfRunAction refresh", primitives are flushed at
        // end of run anyway, so only scale if false.
        if (!fpScene->GetRefreshAtEndOfRun()) {
          // If "/vis/scene/endOfRunAction accumulate", ShowView is never called
          // so we have to watch for a new run.
          G4int thisRunID = thisRun->GetRunID();
          static G4int lastRunID = 0;
          if (thisRunID != lastRunID) {
            glFlush();
            lastRunID = thisRunID;
          }
        }
        break;
      case eachPrimitive:
        // This is equivalent to numeric with fEntitiesFlushInterval == 1.
        fEntitiesFlushInterval = 1;
    [[fallthrough]];  // Fall through to NthPrimitive.
      case NthPrimitive:
      { // Encapsulate in scope {} brackets to satisfy Windows.
        static G4int primitivesWaitingToBeFlushed = 0;
        primitivesWaitingToBeFlushed++;
        if (primitivesWaitingToBeFlushed < fEntitiesFlushInterval) return;
        glFlush();
        primitivesWaitingToBeFlushed = 0;
        break;
      }
      case NthEvent:
        // If "/vis/scene/endOfEventAction refresh", primitives are flushed at
        // end of event anyway, so only scale if false.
        if (!fpScene->GetRefreshAtEndOfEvent()) {
          G4int thisEventID = thisEvent->GetEventID();
          static G4int lastEventID = 0;
          if (thisEventID != lastEventID) {
            static G4int eventsWaitingToBeFlushed = 0;
            eventsWaitingToBeFlushed++;
            if (eventsWaitingToBeFlushed < fEntitiesFlushInterval) return;
            glFlush();
            eventsWaitingToBeFlushed = 0;
            lastEventID = thisEventID;
          }
        }
        break;
      case never:
        break;
      default:
        break;
    }
 
  }
 
  else
 
  {
 
    // For run duration model drawing (detector drawing):
    // Immediate mode: a huge speed up is obtained if flushes are scaled.
    // Stored mode: no discernable difference since drawing is done to the
    //   back buffer and then swapped.
    // So eachPrimitive and NthPrimitive make sense.  But endOfEvent and
    // endOfRun are treated as "no action", i.e., a flush will only be issued,
    // as happens anyway, when drawing is complete.
 
    switch (fFlushAction) {
      case endOfEvent:
        break;
      case endOfRun:
        break;
      case eachPrimitive:
        // This is equivalent to NthPrimitive with fEntitiesFlushInterval == 1.
        fEntitiesFlushInterval = 1;
    [[fallthrough]];  // Fall through to NthPrimitive.
      case NthPrimitive:
      { // Encapsulate in scope {} brackets to satisfy Windows.
        static G4int primitivesWaitingToBeFlushed = 0;
        primitivesWaitingToBeFlushed++;
        if (primitivesWaitingToBeFlushed < fEntitiesFlushInterval) return;
        glFlush();
        primitivesWaitingToBeFlushed = 0;
        break;
      }
      case NthEvent:
        break;
      case never:
        break;
      default:
        break;
    }
 
  }
}

Referenced by G4OpenGLImmediateSceneHandler::EndPrimitives(), G4OpenGLStoredSceneHandler::EndPrimitives(), G4OpenGLImmediateSceneHandler::EndPrimitives2D(), and G4OpenGLStoredSceneHandler::EndPrimitives2D().

◆ SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer ( G4VViewer * )

inherited

◆ SetDisplayListLimit()

static void G4OpenGLStoredSceneHandler::SetDisplayListLimit ( G4int lim )

inlinestaticinherited

Definition at line 68 of file G4OpenGLStoredSceneHandler.hh.

68{fDisplayListLimit = lim;}

References G4OpenGLStoredSceneHandler::fDisplayListLimit.

Referenced by G4OpenGLViewerMessenger::SetNewValue().

◆ SetEntitiesFlushInterval()

static void G4OpenGLSceneHandler::SetEntitiesFlushInterval ( G4int interval )

inlinestaticinherited

Definition at line 101 of file G4OpenGLSceneHandler.hh.

102 {fEntitiesFlushInterval = interval;}

References G4OpenGLSceneHandler::fEntitiesFlushInterval.

Referenced by G4OpenGLViewerMessenger::SetNewValue().

◆ SetFlushAction()

static void G4OpenGLSceneHandler::SetFlushAction ( FlushAction action )

inlinestaticinherited

Definition at line 103 of file G4OpenGLSceneHandler.hh.

104 {fFlushAction = action;}

geant4_check_module_cycles.action

action

Definition: geant4_check_module_cycles.py:49

References geant4_check_module_cycles::action, and G4OpenGLSceneHandler::fFlushAction.

Referenced by G4OpenGLViewer::printGl2PS(), and G4OpenGLViewerMessenger::SetNewValue().

◆ 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 G4OpenGLStoredQtSceneHandler::SetScene ( G4Scene * pScene )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 161 of file G4OpenGLStoredQtSceneHandler.cc.

                                                          {
 
  if (pScene != fpScene) {
    G4OpenGLQtViewer* pGLQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
    if ( pGLQtViewer ) {
      pGLQtViewer->clearTreeWidget();
    }
  }
  G4VSceneHandler::SetScene(pScene);
}

References G4OpenGLQtViewer::clearTreeWidget(), G4VSceneHandler::fpScene, G4VSceneHandler::fpViewer, and G4VSceneHandler::SetScene().

◆ SetTransientsDrawnThisEvent()

void G4VSceneHandler::SetTransientsDrawnThisEvent ( G4bool )

inherited

Referenced by G4VisManager::BeginOfEvent().

◆ SetTransientsDrawnThisRun()

void G4VSceneHandler::SetTransientsDrawnThisRun ( G4bool )

inherited

Referenced by G4VisManager::BeginOfRun().

◆ SetViewerList()

G4ViewerList & G4VSceneHandler::SetViewerList ( )

inherited

Field Documentation

◆ fDisplayListId

G4int G4OpenGLStoredSceneHandler::fDisplayListId = 0

staticprotectedinherited

Definition at line 92 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::ClearStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::PO::operator=(), and G4OpenGLStoredSceneHandler::TO::operator=().

◆ fDisplayListLimit

G4int G4OpenGLStoredSceneHandler::fDisplayListLimit = 1e7

staticprotectedinherited

Definition at line 94 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::GetDisplayListLimit(), and G4OpenGLStoredSceneHandler::SetDisplayListLimit().

◆ fEdgeFlag

bool G4OpenGLSceneHandler::fEdgeFlag

protectedinherited

Definition at line 177 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler::AddPrimitive().

◆ fEntitiesFlushInterval

G4int G4OpenGLSceneHandler::fEntitiesFlushInterval = 100

staticprotectedinherited

Definition at line 165 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler::GetEntitiesFlushInterval(), G4OpenGLSceneHandler::ScaledFlush(), and G4OpenGLSceneHandler::SetEntitiesFlushInterval().

◆ fFlushAction

G4OpenGLSceneHandler::FlushAction G4OpenGLSceneHandler::fFlushAction = G4OpenGLSceneHandler::NthEvent

staticprotectedinherited

Definition at line 163 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLSceneHandler::GetFlushAction(), G4OpenGLSceneHandler::ScaledFlush(), and G4OpenGLSceneHandler::SetFlushAction().

◆ fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protectedinherited

Definition at line 364 of file G4VSceneHandler.hh.

◆ fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protectedinherited

Definition at line 352 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::ProcessScene().

◆ fMemoryForDisplayLists

G4bool G4OpenGLStoredSceneHandler::fMemoryForDisplayLists = true

staticprotectedinherited

Definition at line 93 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredViewer::AddPrimitiveForASingleFrame(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::ClearStore(), and G4OpenGLStoredSceneHandler::ClearTransientStore().

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

◆ fPickMap

std::map<GLuint, G4AttHolder*> G4OpenGLSceneHandler::fPickMap

protectedinherited

Definition at line 158 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLSceneHandler::ClearAndDestroyAtts(), and G4OpenGLViewer::GetPickDetails().

◆ fPickName

GLuint G4OpenGLSceneHandler::fPickName

protectedinherited

Definition at line 157 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::EndModeling(), G4OpenGLStoredSceneHandler::PO::operator=(), and G4OpenGLStoredSceneHandler::TO::operator=().

◆ 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(), ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::LoadAtts(), G4VTreeSceneHandler::PreAddSolid(), G4VSceneHandler::ProcessScene(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

◆ fPOList

std::vector<PO> G4OpenGLStoredSceneHandler::fPOList

protectedinherited

Definition at line 123 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::ClearStore(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLStoredSceneHandler::EndModeling(), and ExtraPOProcessing().

◆ 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 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(), ClearStore(), G4GMocrenFileSceneHandler::ClearTransientStore(), G4HepRepFileSceneHandler::ClearTransientStore(), G4OpenGLImmediateSceneHandler::ClearTransientStore(), ClearTransientStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::CreateSectionSolid(), G4OpenGLStoredSceneHandler::EndModeling(), ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetAuxEdgeVisible(), G4VSceneHandler::GetColour(), G4VSceneHandler::GetDrawingStyle(), G4VSceneHandler::GetLineWidth(), G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::GetNoOfSides(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSceneHandler::GetTextColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::RequestPrimitives(), and 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().

◆ fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protectedinherited

Definition at line 346 of file G4VSceneHandler.hh.

◆ fSceneIdCount

G4int G4OpenGLStoredSceneHandler::fSceneIdCount = 0

staticprotectedinherited

Definition at line 90 of file G4OpenGLStoredSceneHandler.hh.

◆ fSecondPassForTransparency

G4bool G4OpenGLSceneHandler::fSecondPassForTransparency

protectedinherited

Definition at line 171 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLSceneHandler::ProcessScene().

◆ fSecondPassForTransparencyRequested

G4bool G4OpenGLSceneHandler::fSecondPassForTransparencyRequested

protectedinherited

Definition at line 170 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLSceneHandler::ProcessScene().

◆ fSolidMap

std::map<const G4VSolid*, G4int, std::less <const G4VSolid*> > G4OpenGLStoredSceneHandler::fSolidMap

protectedinherited

Definition at line 144 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLStoredSceneHandler::ClearStore().

◆ fStippleMaskHashed

const GLubyte G4OpenGLSceneHandler::fStippleMaskHashed

staticprotectedinherited

Initial value:

= {
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,
  0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55
}

Definition at line 176 of file G4OpenGLSceneHandler.hh.

◆ fSystem

G4VGraphicsSystem& G4VSceneHandler::fSystem

protectedinherited

Definition at line 345 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddPrimitive().

◆ fThirdPassForNonHiddenMarkers

G4bool G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkers

protectedinherited

Definition at line 174 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLSceneHandler::ProcessScene().

◆ fThirdPassForNonHiddenMarkersRequested

G4bool G4OpenGLSceneHandler::fThirdPassForNonHiddenMarkersRequested

protectedinherited

Definition at line 173 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLSceneHandler::ProcessScene().

◆ fThreePassCapable

G4bool G4OpenGLSceneHandler::fThreePassCapable

protectedinherited

Definition at line 168 of file G4OpenGLSceneHandler.hh.

Referenced by G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLSceneHandler::ProcessScene().

◆ fTOList

std::vector<TO> G4OpenGLStoredSceneHandler::fTOList

protectedinherited

Definition at line 140 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::ClearStore(), G4OpenGLStoredSceneHandler::ClearTransientStore(), G4OpenGLStoredViewer::DrawDisplayLists(), and ExtraTOProcessing().

◆ fTopPODL

GLint G4OpenGLStoredSceneHandler::fTopPODL

protectedinherited

Definition at line 100 of file G4OpenGLStoredSceneHandler.hh.

Referenced by G4OpenGLStoredSceneHandler::ClearStore(), G4OpenGLStoredSceneHandler::EndModeling(), and G4OpenGLStoredViewer::KernelVisitDecision().

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Member Enumeration Documentation

◆ FlushAction

◆ MarkerSizeType

Constructor & Destructor Documentation

◆ G4OpenGLStoredQtSceneHandler()

◆ ~G4OpenGLStoredQtSceneHandler()

Member Function Documentation

◆ AddCompound() [1/6]

◆ AddCompound() [2/6]

◆ AddCompound() [3/6]

◆ AddCompound() [4/6]

◆ AddCompound() [5/6]

◆ AddCompound() [6/6]

◆ AddPrimitive() [1/13]

◆ AddPrimitive() [2/13]

◆ AddPrimitive() [3/13]

◆ AddPrimitive() [4/13]

◆ AddPrimitive() [5/13]

◆ AddPrimitive() [6/13]

◆ AddPrimitive() [7/13]

◆ AddPrimitive() [8/13]

◆ AddPrimitive() [9/13]

◆ AddPrimitive() [10/13]

◆ AddPrimitive() [11/13]

◆ AddPrimitive() [12/13]

◆ AddPrimitive() [13/13]

◆ AddPrimitivePostamble()

◆ AddPrimitivePreamble() [1/3]

◆ AddPrimitivePreamble() [2/3]

◆ AddPrimitivePreamble() [3/3]

◆ AddPrimitivePreambleInternal()

◆ AddPrimitivesCircle()

◆ AddPrimitivesSquare()

◆ AddSolid() [1/14]

◆ AddSolid() [2/14]

◆ AddSolid() [3/14]

◆ AddSolid() [4/14]

◆ AddSolid() [5/14]

◆ AddSolid() [6/14]

◆ AddSolid() [7/14]

◆ AddSolid() [8/14]

◆ AddSolid() [9/14]

◆ AddSolid() [10/14]

◆ AddSolid() [11/14]

◆ AddSolid() [12/14]

◆ AddSolid() [13/14]

◆ AddSolid() [14/14]

◆ AddSolidT()

◆ AddSolidWithAuxiliaryEdges()

◆ AddViewerToList()

◆ BeginModeling()

◆ BeginPrimitives()

◆ BeginPrimitives2D()

◆ ClearAndDestroyAtts()

◆ ClearStore()

◆ ClearTransientStore()

◆ CreateCutawaySolid()

◆ CreateModelingParameters()

◆ CreateSectionSolid()

◆ DrawEndOfRunModels()

◆ DrawEvent()

◆ EndModeling()

◆ EndPrimitives()

◆ EndPrimitives2D()

◆ ExtraPOProcessing()

◆ ExtraTOProcessing()

◆ GetAuxEdgeVisible()

◆ GetColor() [1/2]

◆ GetColor() [2/2]

◆ GetColour() [1/2]

◆ GetColour() [2/2]

◆ GetCurrentViewer()