G4XXXSGSceneHandler Class Reference

#include <G4XXXSGSceneHandler.hh>

Inheritance diagram for G4XXXSGSceneHandler:

Public Member Functions
	G4XXXSGSceneHandler (G4VGraphicsSystem &system, const G4String &name)
virtual	~G4XXXSGSceneHandler ()
void	AddSolid (const G4Box &)
void	AddSolid (const G4Cons &cons)
void	AddSolid (const G4Tubs &tubs)
void	AddSolid (const G4Trd &trd)
void	AddSolid (const G4Trap &trap)
void	AddSolid (const G4Sphere &sphere)
void	AddSolid (const G4Para &para)
void	AddSolid (const G4Torus &torus)
void	AddSolid (const G4Polycone &polycone)
void	AddSolid (const G4Polyhedra &polyhedra)
void	AddSolid (const G4VSolid &solid)
void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
void	PostAddSolid ()
void	AddPrimitive (const G4Polyline &)
void	AddPrimitive (const G4Text &)
void	AddPrimitive (const G4Circle &)
void	AddPrimitive (const G4Square &)
void	AddPrimitive (const G4Polyhedron &)
void	AddPrimitive (const G4NURBS &)
void	AddPrimitive (const G4Polymarker &polymarker)
void	AddPrimitive (const G4Scale &scale)
void	BeginPrimitives (const G4Transform3D &objectTransformation)
void	EndPrimitives ()
void	ClearStore ()
void	ClearTransientStore ()
Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
virtual	~G4VSceneHandler ()
virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
virtual void	PostAddSolid ()
virtual void	AddSolid (const G4Box &)
virtual void	AddSolid (const G4Cons &)
virtual void	AddSolid (const G4Tubs &)
virtual void	AddSolid (const G4Trd &)
virtual void	AddSolid (const G4Trap &)
virtual void	AddSolid (const G4Sphere &)
virtual void	AddSolid (const G4Para &)
virtual void	AddSolid (const G4Torus &)
virtual void	AddSolid (const G4Polycone &)
virtual void	AddSolid (const G4Polyhedra &)
virtual void	AddSolid (const G4VSolid &)
virtual void	AddCompound (const G4VTrajectory &)
virtual void	AddCompound (const G4VHit &)
virtual void	AddCompound (const G4VDigi &)
virtual void	AddCompound (const G4THitsMap< G4double > &)
virtual void	BeginModeling ()
virtual void	EndModeling ()
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation)
virtual void	EndPrimitives ()
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation)
virtual void	EndPrimitives2D ()
virtual void	AddPrimitive (const G4Polyline &)=0
virtual void	AddPrimitive (const G4Scale &)
virtual void	AddPrimitive (const G4Text &)=0
virtual void	AddPrimitive (const G4Circle &)=0
virtual void	AddPrimitive (const G4Square &)=0
virtual void	AddPrimitive (const G4Polymarker &)
virtual void	AddPrimitive (const G4Polyhedron &)=0
virtual void	AddPrimitive (const G4NURBS &)=0
const G4String &	GetName () const
G4int	GetSceneHandlerId () const
G4int	GetViewCount () const
G4VGraphicsSystem *	GetGraphicsSystem () const
G4Scene *	GetScene () const
const G4ViewerList &	GetViewerList () const
G4VModel *	GetModel () const
G4VViewer *	GetCurrentViewer () const
G4bool	GetMarkForClearingTransientStore () const
G4bool	IsReadyForTransients () const
G4bool	GetTransientsDrawnThisEvent () const
G4bool	GetTransientsDrawnThisRun () const
const G4Transform3D &	GetObjectTransformation () const
void	SetName (const G4String &)
void	SetCurrentViewer (G4VViewer *)
virtual void	SetScene (G4Scene *)
G4ViewerList &	SetViewerList ()
void	SetModel (G4VModel *)
void	SetMarkForClearingTransientStore (G4bool)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetTransientsDrawnThisRun (G4bool)
void	SetObjectTransformation (const G4Transform3D &)
const G4Colour &	GetColour (const G4Visible &)
const G4Colour &	GetColor (const G4Visible &)
const G4Colour &	GetTextColour (const G4Text &)
const G4Colour &	GetTextColor (const G4Text &)
G4double	GetLineWidth (const G4VisAttributes *)
G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)
G4bool	GetAuxEdgeVisible (const G4VisAttributes *)
G4int	GetNoOfSides (const G4VisAttributes *)
G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
G4ModelingParameters *	CreateModelingParameters ()
void	DrawEvent (const G4Event *)
void	DrawEndOfRunModels ()
G4int	IncrementViewCount ()
virtual void	ClearStore ()
virtual void	ClearTransientStore ()
void	AddViewerToList (G4VViewer *pView)
void	RemoveViewerFromList (G4VViewer *pView)
Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()
virtual	~G4VGraphicsScene ()
virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)=0
virtual void	PostAddSolid ()=0
virtual void	AddSolid (const G4Box &)=0
virtual void	AddSolid (const G4Cons &)=0
virtual void	AddSolid (const G4Tubs &)=0
virtual void	AddSolid (const G4Trd &)=0
virtual void	AddSolid (const G4Trap &)=0
virtual void	AddSolid (const G4Sphere &)=0
virtual void	AddSolid (const G4Para &)=0
virtual void	AddSolid (const G4Torus &)=0
virtual void	AddSolid (const G4Polycone &)=0
virtual void	AddSolid (const G4Polyhedra &)=0
virtual void	AddSolid (const G4VSolid &)=0
virtual void	AddCompound (const G4VTrajectory &)=0
virtual void	AddCompound (const G4VHit &)=0
virtual void	AddCompound (const G4VDigi &)=0
virtual void	AddCompound (const G4THitsMap< G4double > &)=0
virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())=0
virtual void	EndPrimitives ()=0
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())=0
virtual void	EndPrimitives2D ()=0
virtual void	AddPrimitive (const G4Polyline &)=0
virtual void	AddPrimitive (const G4Scale &)=0
virtual void	AddPrimitive (const G4Text &)=0
virtual void	AddPrimitive (const G4Circle &)=0
virtual void	AddPrimitive (const G4Square &)=0
virtual void	AddPrimitive (const G4Polymarker &)=0
virtual void	AddPrimitive (const G4Polyhedron &)=0
virtual void	AddPrimitive (const G4NURBS &)=0

Protected Member Functions
void	CreateCurrentItem (const G4String &)
Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()
virtual void	RequestPrimitives (const G4VSolid &solid)
virtual G4VSolid *	CreateSectionSolid ()
virtual G4VSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)

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

Static Protected Attributes
static G4int	fSceneIdCount = 0

Friends
class	G4XXXSGViewer

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world , screen }

Detailed Description

Definition at line 66 of file G4XXXSGSceneHandler.hh.

Constructor & Destructor Documentation

G4XXXSGSceneHandler()

G4XXXSGSceneHandler::G4XXXSGSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name
	)

Definition at line 54 of file G4XXXSGSceneHandler.cc.

                                              :
  G4VSceneHandler(system, fSceneIdCount++, name)
{}

~G4XXXSGSceneHandler()

G4XXXSGSceneHandler::~G4XXXSGSceneHandler ( )

virtual

Definition at line 59 of file G4XXXSGSceneHandler.cc.

{}

Member Function Documentation

AddPrimitive() [1/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Circle &  circle )

virtual

Implements G4VSceneHandler.

Definition at line 285 of file G4XXXSGSceneHandler.cc.

                                                             {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddPrimitive(const G4Circle& circle) called.\n"
     << circle
     << G4endl; 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize (circle, sizeType);
  switch (sizeType) {
  default:
  case screen:
    // Draw in screen coordinates.
    G4cout << "screen";
    break;
  case world:
    // Draw in world coordinates.
    G4cout << "world";
    break;
  }
  G4cout << " size: " << size << G4endl;
#endif
  // Get vis attributes - pick up defaults if none.
  //const G4VisAttributes* pVA =
  //  fpViewer -> GetApplicableVisAttributes (circle.GetVisAttributes ());
  //?? Process circle.
  std::ostringstream oss;
  oss << circle << std::endl;
  //*fCurrentItem += oss.str();
}

AddPrimitive() [2/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4NURBS &  )

virtual

Implements G4VSceneHandler.

Definition at line 403 of file G4XXXSGSceneHandler.cc.

                                                     {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddPrimitive(const G4NURBS& nurbs) called."
     << G4endl;
#endif
  //?? Don't bother implementing this.  NURBS are not functional.
}

AddPrimitive() [3/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 345 of file G4XXXSGSceneHandler.cc.

                                                                     {
#ifdef G4XXXSGDEBUG
  G4cout <<
 "G4XXXSGSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called.\n"
     << polyhedron
     << G4endl;
#endif
  //?? Process polyhedron.
  std::ostringstream oss;
  oss << polyhedron;
  //*fCurrentItem += oss.str();
 
  //?? Or... here are some ideas for decomposing into polygons...
  //Assume all facets are convex quadrilaterals.
  //Draw each G4Facet individually
  
  //Get colour, etc..
  if (polyhedron.GetNoFacets() == 0) return;
 
  // Get vis attributes - pick up defaults if none.
  const G4VisAttributes* pVA =
    fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
 
  // Get view parameters that the user can force through the vis
  // attributes, thereby over-riding the current view parameter.
  G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
  //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
  
  //Get colour, etc..
  //const G4Colour& c = pVA -> GetColour ();
  
  // Initial action depending on drawing style.
  switch (drawing_style) {
  case (G4ViewParameters::hsr):
    {
      break;
    }
  case (G4ViewParameters::hlr):
    {
      break;
    }
  case (G4ViewParameters::wireframe):
    {
      break;
    }
  default:
    {
      break;
    }     
  }
 
  // Loop through all the facets...
 
  // Look at G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&)
  // for an example of how to get facets out of a G4Polyhedron,
  // including how to cope with triangles if that's a problem.
}

AddPrimitive() [4/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polyline &  polyline )

virtual

Implements G4VSceneHandler.

Definition at line 251 of file G4XXXSGSceneHandler.cc.

                                                                 {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddPrimitive(const G4Polyline& polyline) called.\n"
     << polyline
     << G4endl;
#endif
  // Get vis attributes - pick up defaults if none.
  //const G4VisAttributes* pVA =
  //  fpViewer -> GetApplicableVisAttributes (polyline.GetVisAttributes ());
  //?? Process polyline.
  std::ostringstream oss;
  oss << polyline << std::endl;
  //*fCurrentItem += oss.str();
}

AddPrimitive() [5/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 121 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddPrimitive (polymarker);}

AddPrimitive() [6/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Scale &  scale )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 123 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddPrimitive (scale);}

AddPrimitive() [7/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Square &  square )

virtual

Implements G4VSceneHandler.

Definition at line 315 of file G4XXXSGSceneHandler.cc.

                                                             {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddPrimitive(const G4Square& square) called.\n"
     << square
     << G4endl;
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize (square, sizeType);
  switch (sizeType) {
  default:
  case screen:
    // Draw in screen coordinates.
    G4cout << "screen";
    break;
  case world:
    // Draw in world coordinates.
    G4cout << "world";
    break;
  }
  G4cout << " size: " << size << G4endl;
#endif
  // Get vis attributes - pick up defaults if none.
  //const G4VisAttributes* pVA =
  //  fpViewer -> GetApplicableVisAttributes (square.GetVisAttributes ());
  //?? Process square.
  std::ostringstream oss;
  oss << square << std::endl;
  //*fCurrentItem += oss.str();
}

AddPrimitive() [8/8]

void G4XXXSGSceneHandler::AddPrimitive ( const G4Text &  text )

virtual

Implements G4VSceneHandler.

Definition at line 267 of file G4XXXSGSceneHandler.cc.

                                                         {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddPrimitive(const G4Text& text) called.\n"
     << text
     << G4endl;
#endif
  // Get text colour - special method since default text colour is
  // determined by the default text vis attributes, which may be
  // specified independent of default vis attributes of other types of
  // visible objects.
  //const G4Colour& c = GetTextColour (text);  // Picks up default if none.
  //?? Process text.
  std::ostringstream oss;
  oss << text << std::endl;
  //*fCurrentItem += oss.str();
}

AddSolid() [1/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Box &  box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 233 of file G4XXXSGSceneHandler.cc.

                                                   {
#ifdef G4XXXSGDEBUG
  G4cout <<
    "G4XXXSGSceneHandler::AddSolid(const G4Box& box) called for "
     << box.GetName()
     << G4endl;
#endif
  //?? Process your box...
  std::ostringstream oss;
  oss << "G4Box(" <<
    G4String
    (G4BestUnit
     (G4ThreeVector
      (box.GetXHalfLength(), box.GetYHalfLength(), box.GetZHalfLength()),
      "Length")).strip() << ')' << std::endl;
  //*fCurrentItem += oss.str();
}

AddSolid() [2/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Cons &  cons )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 81 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(cons);}

AddSolid() [3/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Para &  para )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 91 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(para);}

AddSolid() [4/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Polycone &  polycone )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 95 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(polycone);}

AddSolid() [5/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 97 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(polyhedra);}

AddSolid() [6/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Sphere &  sphere )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 89 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(sphere);}

AddSolid() [7/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Torus &  torus )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 93 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(torus);}

AddSolid() [8/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Trap &  trap )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 87 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(trap);}

AddSolid() [9/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Trd &  trd )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 85 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(trd);}

AddSolid() [10/11]

void G4XXXSGSceneHandler::AddSolid ( const G4Tubs &  tubs )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 83 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(tubs);}

AddSolid() [11/11]

void G4XXXSGSceneHandler::AddSolid ( const G4VSolid &  solid )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 99 of file G4XXXSGSceneHandler.hh.

  {G4VSceneHandler::AddSolid(solid);}

BeginPrimitives()

void G4XXXSGSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 213 of file G4XXXSGSceneHandler.cc.

{
  G4VSceneHandler::BeginPrimitives(objectTransformation);
}

ClearStore()

void G4XXXSGSceneHandler::ClearStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 412 of file G4XXXSGSceneHandler.cc.

{
  JA::Clear(&fSceneGraph);
}

ClearTransientStore()

void G4XXXSGSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 417 of file G4XXXSGSceneHandler.cc.

{
  JA::Clear(&fSceneGraph);
}

CreateCurrentItem()

void G4XXXSGSceneHandler::CreateCurrentItem ( const G4String &  )

protected

Definition at line 90 of file G4XXXSGSceneHandler.cc.

                                                             {
  // Utility for PreAddSolid and BeginPrimitives.
  
  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) ancesters.  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;
    const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
    //G4int currentDepth = pPVModel->GetCurrentDepth();
    //G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
    //G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
    //G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
    // Note: pCurrentMaterial may be zero (parallel world).
 
    // 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.
 
    /* Debug
    for (size_t i = 0; i < drawnPVPath.size(); ++i) {
      std::cout << drawnPVPath[i].GetPhysicalVolume()->GetName() << ":"
        << drawnPVPath[i].GetCopyNo() << " ("
        << currentPOListIndex << "), ";
    }
    std::cout << std::endl;
    */
 
    static G4int index = 0;  // Some index for future reference
    JA::Insert(&drawnPVPath[0],drawnPVPath.size(),index++,&fSceneGraph);
    //JA::PrintTree(std::cout,&root);
 
    /***  Old algorithm, left here for historical interest!!
    // Find mother.  ri points to drawn mother, if any.
    PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin();
    if (ri != drawnPVPath.rend()) {
      // This volume has a mother.
      G4LogicalVolume* drawnMotherLV =
    ri->GetPhysicalVolume()->GetLogicalVolume();
      LVMapIterator mother = fLVMap.find(drawnMotherLV);
      if (mother != fLVMap.end()) {
    // This adds a child in Troy's tree...
    fCurrentItem = mother->second.push_back(header);
      } else {
    // Mother not previously encountered.  Shouldn't happen, since
    // G4PhysicalVolumeModel sends volumes as it encounters them,
    // i.e., mothers before daughters, in its descent of the
    // geometry tree.  Error!
    G4cout << "ERROR: G4XXXSGSceneHandler::PreAddSolid: Mother "
           << ri->GetPhysicalVolume()->GetName()
           << ':' << ri->GetCopyNo()
           << " not previously encountered."
      "\nShouldn't happen!  Please report to visualization coordinator."
           << G4endl;
    // Continue anyway.  Add to root of scene graph tree...
    fCurrentItem = fPermanentsRoot.push_back(header);
      }
    } else {
      // This volume has no mother.  Must be a top level un-culled
      // volume.  Add to root of scene graph tree...
      fCurrentItem = fPermanentsRoot.push_back(header);
    }
 
    std::ostringstream oss;
    oss << "Path of drawn PVs: ";
    for (PVPath::const_iterator i = drawnPVPath.begin();
     i != drawnPVPath.end(); ++i) {
      oss << '/' << i->GetPhysicalVolume()->GetName()
      << ':' << i->GetCopyNo();
    }
    oss << std::endl;
    *fCurrentItem += oss.str();
 
    // Store for future searches.  Overwrites previous entries for this
    // LV, so entry is always the *last* LV.
    fLVMap[pCurrentLV] = fCurrentItem;
    ***/
 
  } else {  // Not from a G4PhysicalVolumeModel.
 
    /***
    // Create a place for current solid in root...
    if (fReadyForTransients) {
      fCurrentItem = fTransientsRoot.push_back(header);
    } else {
      fCurrentItem = fPermanentsRoot.push_back(header);
    }
    ***/
  }
}

Referenced by PreAddSolid().

EndPrimitives()

void G4XXXSGSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 219 of file G4XXXSGSceneHandler.cc.

{
  G4VSceneHandler::EndPrimitives ();
}

PostAddSolid()

void G4XXXSGSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 208 of file G4XXXSGSceneHandler.cc.

{
  G4VSceneHandler::PostAddSolid();
}

PreAddSolid()

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 200 of file G4XXXSGSceneHandler.cc.

{  
  G4VSceneHandler::PreAddSolid(objectTransformation, visAttribs);
  CreateCurrentItem(G4String("\nPreAddSolid:\n"));
}

Friends And Related Function Documentation

G4XXXSGViewer

friend class G4XXXSGViewer

friend

Definition at line 68 of file G4XXXSGSceneHandler.hh.

Member Data Documentation

fSceneGraph

SceneGraph G4XXXSGSceneHandler::fSceneGraph

protected

Definition at line 149 of file G4XXXSGSceneHandler.hh.

Referenced by ClearStore(), ClearTransientStore(), and CreateCurrentItem().

fSceneIdCount

G4int G4XXXSGSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 143 of file G4XXXSGSceneHandler.hh.

---

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

• G4XXXSGSceneHandler.hh
• G4XXXSGSceneHandler.cc