G4XXXSGSceneHandler Class Reference

#include <G4XXXSGSceneHandler.hh>

Inheritance diagram for G4XXXSGSceneHandler:

G4VSceneHandler G4VGraphicsScene

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

Protected Member Functions

void CreateCurrentItem (const G4String &)

Protected Attributes

SceneGraph fSceneGraph

Static Protected Attributes

static G4int fSceneIdCount = 0

Friends

class G4XXXSGViewer

Detailed Description

Definition at line 66 of file G4XXXSGSceneHandler.hh.

Constructor & Destructor Documentation

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

Definition at line 54 of file G4XXXSGSceneHandler.cc.

00055                                                                   :
00056   G4VSceneHandler(system, fSceneIdCount++, name)
00057 {}

G4XXXSGSceneHandler::~G4XXXSGSceneHandler (  )  [virtual]

Definition at line 59 of file G4XXXSGSceneHandler.cc.

00059 {}

Member Function Documentation

void G4XXXSGSceneHandler::AddPrimitive ( const G4Scale &  scale  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 123 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

00124   {G4VSceneHandler::AddPrimitive (scale);}

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 121 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddPrimitive().

00122   {G4VSceneHandler::AddPrimitive (polymarker);}

void G4XXXSGSceneHandler::AddPrimitive ( const G4NURBS &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 403 of file G4XXXSGSceneHandler.cc.

References G4cout, and G4endl.

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

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polyhedron &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 345 of file G4XXXSGSceneHandler.cc.

References G4VSceneHandler::fpViewer, G4cout, G4endl, G4VSceneHandler::GetDrawingStyle(), G4ViewParameters::hlr, G4ViewParameters::hsr, and G4ViewParameters::wireframe.

00345                                                                      {
00346 #ifdef G4XXXSGDEBUG
00347   G4cout <<
00348  "G4XXXSGSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called.\n"
00349          << polyhedron
00350          << G4endl;
00351 #endif
00352   //?? Process polyhedron.
00353   std::ostringstream oss;
00354   oss << polyhedron;
00355   //*fCurrentItem += oss.str();
00356 
00357   //?? Or... here are some ideas for decomposing into polygons...
00358   //Assume all facets are convex quadrilaterals.
00359   //Draw each G4Facet individually
00360   
00361   //Get colour, etc..
00362   if (polyhedron.GetNoFacets() == 0) return;
00363 
00364   // Get vis attributes - pick up defaults if none.
00365   const G4VisAttributes* pVA =
00366     fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
00367 
00368   // Get view parameters that the user can force through the vis
00369   // attributes, thereby over-riding the current view parameter.
00370   G4ViewParameters::DrawingStyle drawing_style = GetDrawingStyle (pVA);
00371   //G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pVA);
00372   
00373   //Get colour, etc..
00374   //const G4Colour& c = pVA -> GetColour ();
00375   
00376   // Initial action depending on drawing style.
00377   switch (drawing_style) {
00378   case (G4ViewParameters::hsr):
00379     {
00380       break;
00381     }
00382   case (G4ViewParameters::hlr):
00383     {
00384       break;
00385     }
00386   case (G4ViewParameters::wireframe):
00387     {
00388       break;
00389     }
00390   default:
00391     {
00392       break;
00393     }     
00394   }
00395 
00396   // Loop through all the facets...
00397 
00398   // Look at G4OpenGLSceneHandler::AddPrimitive(const G4Polyhedron&)
00399   // for an example of how to get facets out of a G4Polyhedron,
00400   // including how to cope with triangles if that's a problem.
00401 }

void G4XXXSGSceneHandler::AddPrimitive ( const G4Square &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 315 of file G4XXXSGSceneHandler.cc.

References G4cout, G4endl, G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

00315                                                              {
00316 #ifdef G4XXXSGDEBUG
00317   G4cout <<
00318     "G4XXXSGSceneHandler::AddPrimitive(const G4Square& square) called.\n"
00319          << square
00320          << G4endl;
00321   MarkerSizeType sizeType;
00322   G4double size = GetMarkerSize (square, sizeType);
00323   switch (sizeType) {
00324   default:
00325   case screen:
00326     // Draw in screen coordinates.
00327     G4cout << "screen";
00328     break;
00329   case world:
00330     // Draw in world coordinates.
00331     G4cout << "world";
00332     break;
00333   }
00334   G4cout << " size: " << size << G4endl;
00335 #endif
00336   // Get vis attributes - pick up defaults if none.
00337   //const G4VisAttributes* pVA =
00338   //  fpViewer -> GetApplicableVisAttributes (square.GetVisAttributes ());
00339   //?? Process square.
00340   std::ostringstream oss;
00341   oss << square << std::endl;
00342   //*fCurrentItem += oss.str();
00343 }

void G4XXXSGSceneHandler::AddPrimitive ( const G4Circle &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 285 of file G4XXXSGSceneHandler.cc.

References G4cout, G4endl, G4VSceneHandler::GetMarkerSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

00285                                                              {
00286 #ifdef G4XXXSGDEBUG
00287   G4cout <<
00288     "G4XXXSGSceneHandler::AddPrimitive(const G4Circle& circle) called.\n"
00289          << circle
00290          << G4endl; 
00291   MarkerSizeType sizeType;
00292   G4double size = GetMarkerSize (circle, sizeType);
00293   switch (sizeType) {
00294   default:
00295   case screen:
00296     // Draw in screen coordinates.
00297     G4cout << "screen";
00298     break;
00299   case world:
00300     // Draw in world coordinates.
00301     G4cout << "world";
00302     break;
00303   }
00304   G4cout << " size: " << size << G4endl;
00305 #endif
00306   // Get vis attributes - pick up defaults if none.
00307   //const G4VisAttributes* pVA =
00308   //  fpViewer -> GetApplicableVisAttributes (circle.GetVisAttributes ());
00309   //?? Process circle.
00310   std::ostringstream oss;
00311   oss << circle << std::endl;
00312   //*fCurrentItem += oss.str();
00313 }

void G4XXXSGSceneHandler::AddPrimitive ( const G4Text &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 267 of file G4XXXSGSceneHandler.cc.

References G4cout, and G4endl.

00267                                                          {
00268 #ifdef G4XXXSGDEBUG
00269   G4cout <<
00270     "G4XXXSGSceneHandler::AddPrimitive(const G4Text& text) called.\n"
00271          << text
00272          << G4endl;
00273 #endif
00274   // Get text colour - special method since default text colour is
00275   // determined by the default text vis attributes, which may be
00276   // specified independent of default vis attributes of other types of
00277   // visible objects.
00278   //const G4Colour& c = GetTextColour (text);  // Picks up default if none.
00279   //?? Process text.
00280   std::ostringstream oss;
00281   oss << text << std::endl;
00282   //*fCurrentItem += oss.str();
00283 }

void G4XXXSGSceneHandler::AddPrimitive ( const G4Polyline &   )  [virtual]

Implements G4VSceneHandler.

Definition at line 251 of file G4XXXSGSceneHandler.cc.

References G4cout, and G4endl.

00251                                                                  {
00252 #ifdef G4XXXSGDEBUG
00253   G4cout <<
00254     "G4XXXSGSceneHandler::AddPrimitive(const G4Polyline& polyline) called.\n"
00255          << polyline
00256          << G4endl;
00257 #endif
00258   // Get vis attributes - pick up defaults if none.
00259   //const G4VisAttributes* pVA =
00260   //  fpViewer -> GetApplicableVisAttributes (polyline.GetVisAttributes ());
00261   //?? Process polyline.
00262   std::ostringstream oss;
00263   oss << polyline << std::endl;
00264   //*fCurrentItem += oss.str();
00265 }

void G4XXXSGSceneHandler::AddSolid ( const G4VSolid &  solid  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 99 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00100   {G4VSceneHandler::AddSolid(solid);}

void G4XXXSGSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 97 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00098   {G4VSceneHandler::AddSolid(polyhedra);}

void G4XXXSGSceneHandler::AddSolid ( const G4Polycone &  polycone  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 95 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00096   {G4VSceneHandler::AddSolid(polycone);}

void G4XXXSGSceneHandler::AddSolid ( const G4Torus &  torus  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 93 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00094   {G4VSceneHandler::AddSolid(torus);}

void G4XXXSGSceneHandler::AddSolid ( const G4Para &  para  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 91 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00092   {G4VSceneHandler::AddSolid(para);}

void G4XXXSGSceneHandler::AddSolid ( const G4Sphere &  sphere  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 89 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00090   {G4VSceneHandler::AddSolid(sphere);}

void G4XXXSGSceneHandler::AddSolid ( const G4Trap &  trap  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 87 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00088   {G4VSceneHandler::AddSolid(trap);}

void G4XXXSGSceneHandler::AddSolid ( const G4Trd &  trd  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 85 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00086   {G4VSceneHandler::AddSolid(trd);}

void G4XXXSGSceneHandler::AddSolid ( const G4Tubs &  tubs  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 83 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00084   {G4VSceneHandler::AddSolid(tubs);}

void G4XXXSGSceneHandler::AddSolid ( const G4Cons &  cons  )  [inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 81 of file G4XXXSGSceneHandler.hh.

References G4VSceneHandler::AddSolid().

00082   {G4VSceneHandler::AddSolid(cons);}

void G4XXXSGSceneHandler::AddSolid ( const G4Box &   )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 233 of file G4XXXSGSceneHandler.cc.

References G4cout, G4endl, G4VSolid::GetName(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), and G4Box::GetZHalfLength().

00233                                                    {
00234 #ifdef G4XXXSGDEBUG
00235   G4cout <<
00236     "G4XXXSGSceneHandler::AddSolid(const G4Box& box) called for "
00237          << box.GetName()
00238          << G4endl;
00239 #endif
00240   //?? Process your box...
00241   std::ostringstream oss;
00242   oss << "G4Box(" <<
00243     G4String
00244     (G4BestUnit
00245      (G4ThreeVector
00246       (box.GetXHalfLength(), box.GetYHalfLength(), box.GetZHalfLength()),
00247       "Length")).strip() << ')' << std::endl;
00248   //*fCurrentItem += oss.str();
00249 }

void G4XXXSGSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 214 of file G4XXXSGSceneHandler.cc.

References G4VSceneHandler::BeginPrimitives().

00215 {
00216   G4VSceneHandler::BeginPrimitives(objectTransformation);
00217 }

void G4XXXSGSceneHandler::ClearStore (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 412 of file G4XXXSGSceneHandler.cc.

References JA::Clear(), and fSceneGraph.

00413 {
00414   JA::Clear(&fSceneGraph);
00415 }

void G4XXXSGSceneHandler::ClearTransientStore (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 417 of file G4XXXSGSceneHandler.cc.

References JA::Clear(), and fSceneGraph.

00418 {
00419   JA::Clear(&fSceneGraph);
00420 }

void G4XXXSGSceneHandler::CreateCurrentItem ( const G4String &   )  [protected]

Definition at line 90 of file G4XXXSGSceneHandler.cc.

References fSceneGraph, G4PhysicalVolumeModel::GetDrawnPVPath(), and JA::Insert().

00090                                                                       {
00091   // Utility for PreAddSolid and BeginPrimitives.
00092   
00093   G4PhysicalVolumeModel* pPVModel =
00094     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
00095   G4LogicalVolumeModel* pLVModel =
00096     dynamic_cast<G4LogicalVolumeModel*>(pPVModel);
00097   if (pPVModel && !pLVModel) {
00098 
00099     // This call comes from a G4PhysicalVolumeModel.  drawnPVPath is
00100     // the path of the current drawn (non-culled) volume in terms of
00101     // drawn (non-culled) ancesters.  Each node is identified by a
00102     // PVNodeID object, which is a physical volume and copy number.  It
00103     // is a vector of PVNodeIDs corresponding to the geometry hierarchy
00104     // actually selected, i.e., not culled.
00105     typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
00106     typedef std::vector<PVNodeID> PVPath;
00107     const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
00108     //G4int currentDepth = pPVModel->GetCurrentDepth();
00109     //G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
00110     //G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
00111     //G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
00112     // Note: pCurrentMaterial may be zero (parallel world).
00113 
00114     // The simplest algorithm, used by the Open Inventor Driver
00115     // developers, is to rely on the fact the G4PhysicalVolumeModel
00116     // traverses the geometry hierarchy in an orderly manner.  The last
00117     // mother, if any, will be the node to which the volume should be
00118     // added.  So it is enough to keep a map of scene graph nodes keyed
00119     // on the volume path ID.  Actually, it is enough to use the logical
00120     // volume as the key.  (An alternative would be to keep the PVNodeID
00121     // in the tree and match the PVPath from the root down.)
00122 
00123     // BUT IN OPENGL, IF THERE ARE TRANSPARENT OBJECTS, VOLUMES DO NOT
00124     // ARRIVE IN THE ABOVE ORDER.  (TRANSPARENT OBJECTS ARE DRWAN
00125     // LAST.)  SO WE MUST BE MORE SOPHISTICATED IN CONSTRUCTING A
00126     // TREE.
00127 
00128     /* Debug
00129     for (size_t i = 0; i < drawnPVPath.size(); ++i) {
00130       std::cout << drawnPVPath[i].GetPhysicalVolume()->GetName() << ":"
00131             << drawnPVPath[i].GetCopyNo() << " ("
00132             << currentPOListIndex << "), ";
00133     }
00134     std::cout << std::endl;
00135     */
00136 
00137     static G4int index = 0;  // Some index for future reference
00138     JA::Insert(&drawnPVPath[0],drawnPVPath.size(),index++,&fSceneGraph);
00139     //JA::PrintTree(std::cout,&root);
00140 
00141     /***  Old algorithm, left here for historical interest!!
00142     // Find mother.  ri points to drawn mother, if any.
00143     PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin();
00144     if (ri != drawnPVPath.rend()) {
00145       // This volume has a mother.
00146       G4LogicalVolume* drawnMotherLV =
00147         ri->GetPhysicalVolume()->GetLogicalVolume();
00148       LVMapIterator mother = fLVMap.find(drawnMotherLV);
00149       if (mother != fLVMap.end()) {
00150         // This adds a child in Troy's tree...
00151         fCurrentItem = mother->second.push_back(header);
00152       } else {
00153         // Mother not previously encountered.  Shouldn't happen, since
00154         // G4PhysicalVolumeModel sends volumes as it encounters them,
00155         // i.e., mothers before daughters, in its descent of the
00156         // geometry tree.  Error!
00157         G4cout << "ERROR: G4XXXSGSceneHandler::PreAddSolid: Mother "
00158                << ri->GetPhysicalVolume()->GetName()
00159                << ':' << ri->GetCopyNo()
00160                << " not previously encountered."
00161           "\nShouldn't happen!  Please report to visualization coordinator."
00162                << G4endl;
00163         // Continue anyway.  Add to root of scene graph tree...
00164         fCurrentItem = fPermanentsRoot.push_back(header);
00165       }
00166     } else {
00167       // This volume has no mother.  Must be a top level un-culled
00168       // volume.  Add to root of scene graph tree...
00169       fCurrentItem = fPermanentsRoot.push_back(header);
00170     }
00171 
00172     std::ostringstream oss;
00173     oss << "Path of drawn PVs: ";
00174     for (PVPath::const_iterator i = drawnPVPath.begin();
00175          i != drawnPVPath.end(); ++i) {
00176       oss << '/' << i->GetPhysicalVolume()->GetName()
00177           << ':' << i->GetCopyNo();
00178     }
00179     oss << std::endl;
00180     *fCurrentItem += oss.str();
00181 
00182     // Store for future searches.  Overwrites previous entries for this
00183     // LV, so entry is always the *last* LV.
00184     fLVMap[pCurrentLV] = fCurrentItem;
00185     ***/
00186 
00187   } else {  // Not from a G4PhysicalVolumeModel.
00188 
00189     /***
00190     // Create a place for current solid in root...
00191     if (fReadyForTransients) {
00192       fCurrentItem = fTransientsRoot.push_back(header);
00193     } else {
00194       fCurrentItem = fPermanentsRoot.push_back(header);
00195     }
00196     ***/
00197   }
00198 }

void G4XXXSGSceneHandler::EndPrimitives (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 219 of file G4XXXSGSceneHandler.cc.

References G4VSceneHandler::EndPrimitives().

00220 {
00221   G4VSceneHandler::EndPrimitives ();
00222 }

void G4XXXSGSceneHandler::PostAddSolid (  )  [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 208 of file G4XXXSGSceneHandler.cc.

References G4VSceneHandler::PostAddSolid().

00209 {
00210   G4VSceneHandler::PostAddSolid();
00211 }

void G4XXXSGSceneHandler::PreAddSolid ( const G4Transform3D &  objectTransformation,
const G4VisAttributes &   
) [virtual]

Reimplemented from G4VSceneHandler.

Definition at line 201 of file G4XXXSGSceneHandler.cc.

References G4VSceneHandler::PreAddSolid().

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

Friends And Related Function Documentation

friend class G4XXXSGViewer [friend]

Definition at line 68 of file G4XXXSGSceneHandler.hh.

Field Documentation

SceneGraph G4XXXSGSceneHandler::fSceneGraph [protected]

Definition at line 149 of file G4XXXSGSceneHandler.hh.

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

G4int G4XXXSGSceneHandler::fSceneIdCount = 0 [static, protected]

Definition at line 143 of file G4XXXSGSceneHandler.hh.

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:54:01 2013 for Geant4 by  doxygen 1.4.7