Geant4: G4VSceneHandler Class Reference

Enumerator:

world
screen

Definition at line 68 of file G4VSceneHandler.hh.

00068 {world, screen};

G4VSceneHandler::G4VSceneHandler	(	G4VGraphicsSystem &	system,
		G4int	id,
		const G4String &	name = `""`
	)

Definition at line 88 of file G4VSceneHandler.cc.

References fName, fpScene, fSceneHandlerId, fSystem, fTransientsDrawnThisEvent, fTransientsDrawnThisRun, G4VGraphicsSystem::GetName(), G4VisManager::GetTransientsDrawnThisEvent(), and G4VisManager::GetTransientsDrawnThisRun().

00088                                                                                           :
00089   fSystem                (system),
00090   fSceneHandlerId        (id),
00091   fViewCount             (0),
00092   fpViewer               (0),
00093   fpScene                (0),
00094   fMarkForClearingTransientStore (true),  // Ready for first
00095                                           // ClearTransientStoreIfMarked(),
00096                                           // e.g., at end of run (see
00097                                           // G4VisManager.cc).
00098   fReadyForTransients    (true),  // Only false while processing scene.
00099   fProcessingSolid       (false),
00100   fProcessing2D          (false),
00101   fpModel                (0),
00102   fNestingDepth          (0),
00103   fpVisAttribs           (0)
00104 {
00105   G4VisManager* pVMan = G4VisManager::GetInstance ();
00106   fpScene = pVMan -> GetCurrentScene ();
00107   if (name == "") {
00108     std::ostringstream ost;
00109     ost << fSystem.GetName () << '-' << fSceneHandlerId;
00110     fName = ost.str();
00111   }
00112   else {
00113     fName = name;
00114   }
00115   fTransientsDrawnThisEvent = pVMan->GetTransientsDrawnThisEvent();
00116   fTransientsDrawnThisRun = pVMan->GetTransientsDrawnThisRun();
00117 }

G4VSceneHandler::~G4VSceneHandler ( ) [virtual]

Definition at line 119 of file G4VSceneHandler.cc.

References fViewerList.

00119                                    {
00120   G4VViewer* last;
00121   while( ! fViewerList.empty() ) {
00122     last = fViewerList.back();
00123     fViewerList.pop_back();
00124     delete last;
00125   }
00126 }

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4double > & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 284 of file G4VSceneHandler.cc.

References G4cout, G4endl, G4ScoringManager::GetMesh(), G4ScoringManager::GetNumberOfMesh(), and G4ScoringManager::GetScoringManagerIfExist().

00284                                                                    {
00285   //G4cout << "AddCompound: hits: " << &hits << G4endl;
00286   G4bool scoreMapHits = false;
00287   G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
00288   if (scoringManager) {
00289     size_t nMeshes = scoringManager->GetNumberOfMesh();
00290     for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
00291       G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
00292       if (mesh && mesh->IsActive()) {
00293         MeshScoreMap scoreMap = mesh->GetScoreMap();
00294         for(MeshScoreMap::const_iterator i = scoreMap.begin();
00295             i != scoreMap.end(); ++i) {
00296           const G4String& scoreMapName = i->first;
00297           const G4THitsMap<G4double>* foundHits = i->second;
00298           if (foundHits == &hits) {
00299             G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
00300             scoreMapHits = true;
00301             mesh->DrawMesh(scoreMapName, &colorMap);
00302           }
00303         }
00304       }
00305     }
00306   }
00307   if (scoreMapHits) {
00308     static G4bool first = true;
00309     if (first) {
00310       first = false;
00311       G4cout <<
00312         "Scoring map drawn with default parameters."
00313         "\n  To get gMocren file for gMocren browser:"
00314         "\n    /vis/open gMocrenFile"
00315         "\n    /vis/viewer/flush"
00316         "\n  Many other options available with /score/draw... commands."
00317         "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
00318              << G4endl;
00319     }
00320   } else {  // Not score map hits.  Just call DrawAllHits.
00321     // Cast away const because DrawAllHits is non-const!!!!
00322     const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
00323   }
00324 }

void G4VSceneHandler::AddCompound ( const G4VDigi & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 279 of file G4VSceneHandler.cc.

00279                                                       {
00280   // Cast away const because Draw is non-const!!!!
00281   const_cast<G4VDigi&>(digi).Draw();
00282 }

void G4VSceneHandler::AddCompound ( const G4VHit & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 274 of file G4VSceneHandler.cc.

00274                                                     {
00275   // Cast away const because Draw is non-const!!!!
00276   const_cast<G4VHit&>(hit).Draw();
00277 }

void G4VSceneHandler::AddCompound ( const G4VTrajectory & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 259 of file G4VSceneHandler.cc.

References G4VTrajectory::DrawTrajectory(), FatalException, fpModel, G4Exception(), G4TrajectoriesModel::GetDrawingMode(), and G4TrajectoriesModel::IsDrawingModeSet().

Referenced by G4VRML2FileSceneHandler::AddCompound(), G4VRML1FileSceneHandler::AddCompound(), G4HepRepSceneHandler::AddCompound(), G4HepRepFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), and G4DAWNFILESceneHandler::AddCompound().

00259                                                             {
00260   G4TrajectoriesModel* trajectoriesModel =
00261     dynamic_cast<G4TrajectoriesModel*>(fpModel);
00262   if (!trajectoriesModel) G4Exception
00263     ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
00264      "visman0105", FatalException, "Not a G4TrajectoriesModel.");
00265   else {
00266     if (trajectoriesModel->IsDrawingModeSet()) {
00267       traj.DrawTrajectory(trajectoriesModel->GetDrawingMode());
00268     } else {
00269       traj.DrawTrajectory();
00270     }
00271   }
00272 }

virtual void G4VSceneHandler::AddPrimitive ( const G4NURBS & ) [pure virtual]

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron & ) [pure virtual]

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

void G4VSceneHandler::AddPrimitive ( const G4Polymarker & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 432 of file G4VSceneHandler.cc.

References AddPrimitive(), G4Polymarker::circles, G4Polymarker::dots, G4Polymarker::GetMarkerType(), and G4Polymarker::squares.

00432                                                                   {
00433   switch (polymarker.GetMarkerType()) {
00434   default:
00435   case G4Polymarker::dots:
00436     {
00437       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
00438         G4Circle dot (polymarker);
00439         dot.SetPosition (polymarker[iPoint]);
00440         dot.SetWorldSize  (0.);
00441         dot.SetScreenSize (0.1);  // Very small circle.
00442         AddPrimitive (dot);
00443       }
00444     }
00445     break;
00446   case G4Polymarker::circles:
00447     {
00448       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
00449         G4Circle circle (polymarker);
00450         circle.SetPosition (polymarker[iPoint]);
00451         AddPrimitive (circle);
00452       }
00453     }
00454     break;
00455   case G4Polymarker::squares:
00456     {
00457       for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
00458         G4Square square (polymarker);
00459         square.SetPosition (polymarker[iPoint]);
00460         AddPrimitive (square);
00461       }
00462     }
00463     break;
00464   }
00465 }

virtual void G4VSceneHandler::AddPrimitive ( const G4Square & ) [pure virtual]

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle & ) [pure virtual]

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

virtual void G4VSceneHandler::AddPrimitive ( const G4Text & ) [pure virtual]

Implements G4VGraphicsScene.

Implemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

void G4VSceneHandler::AddPrimitive ( const G4Scale & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 330 of file G4VSceneHandler.cc.

References AddPrimitive(), fpModel, fpScene, G4Scale::GetAnnotation(), G4Scale::GetAutoPlacing(), G4Scale::GetDirection(), G4Scene::GetExtent(), G4Scale::GetLength(), G4VModel::GetTransformation(), G4Visible::GetVisAttributes(), G4VisExtent::GetXmax(), G4Scale::GetXmid(), G4VisExtent::GetXmin(), G4VisExtent::GetYmax(), G4Scale::GetYmid(), G4VisExtent::GetYmin(), G4VisExtent::GetZmax(), G4Scale::GetZmid(), G4VisExtent::GetZmin(), G4Visible::SetVisAttributes(), G4Polyline::transform(), G4Scale::x, G4Scale::y, and G4Scale::z.

00330                                                         {
00331 
00332   const G4double margin(0.01);
00333   // Fractional margin - ensures scale is comfortably inside viewing
00334   // volume.
00335   const G4double oneMinusMargin (1. - margin);
00336 
00337   const G4VisExtent& sceneExtent = fpScene->GetExtent();
00338 
00339   // Useful constants...
00340   const G4double length(scale.GetLength());
00341   const G4double halfLength(length / 2.);
00342   const G4double tickLength(length / 20.);
00343   const G4double piBy2(halfpi);
00344 
00345   // Get size of scene...
00346   const G4double xmin = sceneExtent.GetXmin();
00347   const G4double xmax = sceneExtent.GetXmax();
00348   const G4double ymin = sceneExtent.GetYmin();
00349   const G4double ymax = sceneExtent.GetYmax();
00350   const G4double zmin = sceneExtent.GetZmin();
00351   const G4double zmax = sceneExtent.GetZmax();
00352 
00353   // Create (empty) polylines having the same vis attributes...
00354   G4Polyline scaleLine, tick11, tick12, tick21, tick22;
00355   G4VisAttributes visAtts(*scale.GetVisAttributes());  // Long enough life.
00356   scaleLine.SetVisAttributes(&visAtts);
00357   tick11.SetVisAttributes(&visAtts);
00358   tick12.SetVisAttributes(&visAtts);
00359   tick21.SetVisAttributes(&visAtts);
00360   tick22.SetVisAttributes(&visAtts);
00361 
00362   // Add points to the polylines to represent an scale parallel to the
00363   // x-axis centred on the origin...
00364   G4Point3D r1(G4Point3D(-halfLength, 0., 0.));
00365   G4Point3D r2(G4Point3D( halfLength, 0., 0.));
00366   scaleLine.push_back(r1);
00367   scaleLine.push_back(r2);
00368   G4Point3D ticky(0., tickLength, 0.);
00369   G4Point3D tickz(0., 0., tickLength);
00370   tick11.push_back(r1 + ticky);
00371   tick11.push_back(r1 - ticky);
00372   tick12.push_back(r1 + tickz);
00373   tick12.push_back(r1 - tickz);
00374   tick21.push_back(r2 + ticky);
00375   tick21.push_back(r2 - ticky);
00376   tick22.push_back(r2 + tickz);
00377   tick22.push_back(r2 - tickz);
00378   G4Point3D textPosition(0., tickLength, 0.);
00379 
00380   // Transform appropriately...
00381 
00382   G4Transform3D transformation;
00383   if (scale.GetAutoPlacing()) {
00384     G4Transform3D rotation;
00385     switch (scale.GetDirection()) {
00386     case G4Scale::x:
00387       break;
00388     case G4Scale::y:
00389       rotation = G4RotateZ3D(piBy2);
00390       break;
00391     case G4Scale::z:
00392       rotation = G4RotateY3D(piBy2);
00393       break;
00394     }
00395     G4double sxmid(scale.GetXmid());
00396     G4double symid(scale.GetYmid());
00397     G4double szmid(scale.GetZmid());
00398     sxmid = xmin + oneMinusMargin * (xmax - xmin);
00399     symid = ymin + margin * (ymax - ymin);
00400     szmid = zmin + oneMinusMargin * (zmax - zmin);
00401     switch (scale.GetDirection()) {
00402     case G4Scale::x:
00403       sxmid -= halfLength;
00404       break;
00405     case G4Scale::y:
00406       symid += halfLength;
00407       break;
00408     case G4Scale::z:
00409       szmid -= halfLength;
00410       break;
00411     }
00412     G4Translate3D translation(sxmid, symid, szmid);
00413     transformation = translation * rotation;
00414   } else {
00415     if (fpModel) transformation = fpModel->GetTransformation();
00416   }
00417 
00418   // Draw...
00419   // We would like to call BeginPrimitives(transformation) here but
00420   // calling BeginPrimitives from within an AddPrimitive is not
00421   // allowed!  So we have to do our own transformation...
00422   AddPrimitive(scaleLine.transform(transformation));
00423   AddPrimitive(tick11.transform(transformation));
00424   AddPrimitive(tick12.transform(transformation));
00425   AddPrimitive(tick21.transform(transformation));
00426   AddPrimitive(tick22.transform(transformation));
00427   G4Text text(scale.GetAnnotation(),textPosition.transform(transformation));
00428   text.SetScreenSize(12.);
00429   AddPrimitive(text);
00430 }

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline & ) [pure virtual]

void G4VSceneHandler::AddSolid ( const G4VSolid & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 255 of file G4VSceneHandler.cc.

References RequestPrimitives().

00255                                                      {
00256   RequestPrimitives (solid);
00257 }

void G4VSceneHandler::AddSolid ( const G4Polyhedra & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 251 of file G4VSceneHandler.cc.

References RequestPrimitives().

00251                                                             {
00252   RequestPrimitives (polyhedra);
00253 }

void G4VSceneHandler::AddSolid ( const G4Polycone & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 247 of file G4VSceneHandler.cc.

References RequestPrimitives().

00247                                                           {
00248   RequestPrimitives (polycone);
00249 }

void G4VSceneHandler::AddSolid ( const G4Torus & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 243 of file G4VSceneHandler.cc.

References RequestPrimitives().

00243                                                     {
00244   RequestPrimitives (torus);
00245 }

void G4VSceneHandler::AddSolid ( const G4Para & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 239 of file G4VSceneHandler.cc.

References RequestPrimitives().

00239                                                   {
00240   RequestPrimitives (para);
00241 }

void G4VSceneHandler::AddSolid ( const G4Sphere & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 235 of file G4VSceneHandler.cc.

References RequestPrimitives().

00235                                                       {
00236   RequestPrimitives (sphere );
00237 }

void G4VSceneHandler::AddSolid ( const G4Trap & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 231 of file G4VSceneHandler.cc.

References RequestPrimitives().

00231                                                   {
00232   RequestPrimitives (trap);
00233 }

void G4VSceneHandler::AddSolid ( const G4Trd & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 227 of file G4VSceneHandler.cc.

References RequestPrimitives().

00227                                                 {
00228   RequestPrimitives (trd);
00229 }

void G4VSceneHandler::AddSolid ( const G4Tubs & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 219 of file G4VSceneHandler.cc.

References RequestPrimitives().

00219                                                   {
00220   RequestPrimitives (tubs);
00221 }

void G4VSceneHandler::AddSolid ( const G4Cons & ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 223 of file G4VSceneHandler.cc.

References RequestPrimitives().

00223                                                   {
00224   RequestPrimitives (cons);
00225 }

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

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4RayTracerSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXFileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 204 of file G4VSceneHandler.cc.

References RequestPrimitives().

Referenced by G4XXXStoredSceneHandler::AddSolid(), G4XXXSGSceneHandler::AddSolid(), G4XXXFileSceneHandler::AddSolid(), G4VRML2FileSceneHandler::AddSolid(), G4VRML1FileSceneHandler::AddSolid(), G4HepRepSceneHandler::AddSolid(), G4HepRepFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), and G4DAWNFILESceneHandler::AddSolid().

00204                                                 {
00205   RequestPrimitives (box);
00206 // If your graphics system is sophisticated enough to handle a
00207 //  particular solid shape as a primitive, in your derived class write a
00208 //  function to override this.  (Note: some compilers warn that your
00209 //  function "hides" this one.  That's OK.)
00210 // Your function might look like this...
00211 // void G4MyScene::AddSolid (const G4Box& box) {
00212 // Get parameters of appropriate object, e.g.:
00213 //   G4double dx = box.GetXHalfLength ();
00214 //   G4double dy = box.GetYHalfLength ();
00215 //   G4double dz = box.GetZHalfLength ();
00216 // and Draw or Store in your display List.
00217 }

void G4VSceneHandler::AddViewerToList ( G4VViewer * pView )

Definition at line 326 of file G4VSceneHandler.cc.

References fViewerList.

00326                                                          {
00327   fViewerList.push_back (pViewer);
00328 }

void G4VSceneHandler::BeginModeling ( ) [virtual]

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4ASCIITreeSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 192 of file G4VSceneHandler.cc.

Referenced by G4VTreeSceneHandler::BeginModeling(), G4HepRepSceneHandler::BeginModeling(), G4HepRepFileSceneHandler::BeginModeling(), G4GMocrenFileSceneHandler::BeginModeling(), G4DAWNFILESceneHandler::BeginModeling(), G4GMocrenFileSceneHandler::GFBeginModeling(), and ProcessScene().

00192                                      {
00193 }

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

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 145 of file G4VSceneHandler.cc.

References FatalException, and G4Exception().

Referenced by G4XXXStoredSceneHandler::BeginPrimitives(), G4XXXSGSceneHandler::BeginPrimitives(), G4HepRepSceneHandler::BeginPrimitives(), G4GMocrenFileSceneHandler::BeginPrimitives(), and RequestPrimitives().

00145                                             {
00146   //static G4int count = 0;
00147   //G4cout << "G4VSceneHandler::BeginPrimitives: " << count++ << G4endl;
00148   fNestingDepth++;
00149   if (fNestingDepth > 1)
00150     G4Exception
00151       ("G4VSceneHandler::BeginPrimitives",
00152        "visman0101", FatalException,
00153        "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
00154   fObjectTransformation = objectTransformation;
00155 }

void G4VSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler.

Definition at line 169 of file G4VSceneHandler.cc.

References FatalException, and G4Exception().

Referenced by G4HepRepFileSceneHandler::BeginPrimitives2D().

00169                                             {
00170   fNestingDepth++;
00171   if (fNestingDepth > 1)
00172     G4Exception
00173       ("G4VSceneHandler::BeginPrimitives2D",
00174        "visman0103", FatalException,
00175        "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
00176   fObjectTransformation = objectTransformation;
00177   fProcessing2D = true;
00178 }

void G4VSceneHandler::ClearStore ( ) [virtual]

Reimplemented in G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 200 of file G4VSceneHandler.cc.

Referenced by G4VViewer::ProcessView().

00200 {}

void G4VSceneHandler::ClearTransientStore ( ) [virtual]

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 202 of file G4VSceneHandler.cc.

Referenced by G4VisCommandViewerRebuild::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

00202 {}

G4VSolid * G4VSceneHandler::CreateCutawaySolid ( ) [protected, virtual]

Definition at line 786 of file G4VSceneHandler.cc.

Referenced by CreateModelingParameters().

00787 {
00788   return 0;
00789 }

G4ModelingParameters * G4VSceneHandler::CreateModelingParameters ( )

Definition at line 702 of file G4VSceneHandler.cc.

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

00703 {
00704   // Create modeling parameters from View Parameters...
00705   const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
00706 
00707   // Convert drawing styles...
00708   G4ModelingParameters::DrawingStyle modelDrawingStyle =
00709     G4ModelingParameters::wf;
00710   switch (vp.GetDrawingStyle ()) {
00711   default:
00712   case G4ViewParameters::wireframe:
00713     modelDrawingStyle = G4ModelingParameters::wf;
00714     break;
00715   case G4ViewParameters::hlr:
00716     modelDrawingStyle = G4ModelingParameters::hlr;
00717     break;
00718   case G4ViewParameters::hsr:
00719     modelDrawingStyle = G4ModelingParameters::hsr;
00720     break;
00721   case G4ViewParameters::hlhsr:
00722     modelDrawingStyle = G4ModelingParameters::hlhsr;
00723     break;
00724   }
00725 
00726   // Decide if covered daughters are really to be culled...
00727   G4bool reallyCullCovered =
00728     vp.IsCullingCovered()   // Culling daughters depends also on...
00729     && !vp.IsSection ()     // Sections (DCUT) not requested.
00730     && !vp.IsCutaway ()     // Cutaways not requested.
00731     ;
00732 
00733   G4ModelingParameters* pModelingParams = new G4ModelingParameters
00734     (vp.GetDefaultVisAttributes (),
00735      modelDrawingStyle,
00736      vp.IsCulling (),
00737      vp.IsCullingInvisible (),
00738      vp.IsDensityCulling (),
00739      vp.GetVisibleDensity (),
00740      reallyCullCovered,
00741      vp.GetNoOfSides ()
00742      );
00743 
00744   pModelingParams->SetWarning
00745     (G4VisManager::GetVerbosity() >= G4VisManager::warnings);
00746 
00747   pModelingParams->SetExplodeFactor(vp.GetExplodeFactor());
00748   pModelingParams->SetExplodeCentre(vp.GetExplodeCentre());
00749 
00750   pModelingParams->SetSectionSolid(CreateSectionSolid());
00751   pModelingParams->SetCutawaySolid(CreateCutawaySolid());
00752   // The polyhedron objects are deleted in the modeling parameters destructor.
00753   
00754   pModelingParams->SetVisAttributesModifiers(vp.GetVisAttributesModifiers());
00755 
00756   return pModelingParams;
00757 }

G4VSolid * G4VSceneHandler::CreateSectionSolid ( ) [protected, virtual]

Definition at line 759 of file G4VSceneHandler.cc.

References fpScene, fpViewer, G4Scene::GetExtent(), G4VisExtent::GetExtentCentre(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetSectionPlane(), G4VViewer::GetViewParameters(), G4ViewParameters::IsSection(), and G4InuclParticleNames::sp.

Referenced by CreateModelingParameters().

00760 {
00761   G4VSolid* sectioner = 0;
00762   const G4ViewParameters& vp = fpViewer->GetViewParameters();
00763   if (vp.IsSection () ) {
00764     G4double radius = fpScene->GetExtent().GetExtentRadius();
00765     G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
00766     G4VSolid* sectionBox =
00767       new G4Box("_sectioner", safe, safe, 1.e-5 * radius);  // Thin in z-plane.
00768     const G4Plane3D& sp = vp.GetSectionPlane ();
00769     G4double a = sp.a();
00770     G4double b = sp.b();
00771     G4double c = sp.c();
00772     G4double d = sp.d();
00773     G4Transform3D transform = G4TranslateZ3D(-d);
00774     const G4Normal3D normal(a,b,c);
00775     if (normal != G4Normal3D(0,0,1)) {
00776       const G4double angle = std::acos(normal.dot(G4Normal3D(0,0,1)));
00777       const G4Vector3D axis = G4Normal3D(0,0,1).cross(normal);
00778       transform = G4Rotate3D(angle, axis) * transform;
00779     }
00780     sectioner = new G4DisplacedSolid
00781       ("_displaced_sectioning_box", sectionBox, transform);
00782   }
00783   return sectioner;
00784 }

void G4VSceneHandler::DrawEndOfRunModels ( )

Definition at line 680 of file G4VSceneHandler.cc.

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

Referenced by ProcessScene().

00681 {
00682   const std::vector<G4Scene::Model>& EORModelList =
00683     fpScene -> GetEndOfRunModelList ();
00684   size_t nModels = EORModelList.size();
00685   if (nModels) {
00686     G4ModelingParameters* pMP = CreateModelingParameters();
00687     pMP->SetEvent(0);
00688     for (size_t i = 0; i < nModels; i++) {
00689       if (EORModelList[i].fActive) {
00690         G4VModel* pModel = EORModelList[i].fpModel;
00691         pModel -> SetModelingParameters(pMP);
00692         SetModel (pModel);
00693         pModel -> DescribeYourselfTo (*this);
00694         pModel -> SetModelingParameters(0);
00695       }
00696     }
00697     delete pMP;
00698     SetModel (0);
00699   }
00700 }

void G4VSceneHandler::DrawEvent ( const G4Event * )

Definition at line 658 of file G4VSceneHandler.cc.

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

Referenced by ProcessScene().

00659 {
00660   const std::vector<G4Scene::Model>& EOEModelList =
00661     fpScene -> GetEndOfEventModelList ();
00662   size_t nModels = EOEModelList.size();
00663   if (nModels) {
00664     G4ModelingParameters* pMP = CreateModelingParameters();
00665     pMP->SetEvent(event);
00666     for (size_t i = 0; i < nModels; i++) {
00667       if (EOEModelList[i].fActive) {
00668         G4VModel* pModel = EOEModelList[i].fpModel;
00669         pModel -> SetModelingParameters(pMP);
00670         SetModel (pModel);
00671         pModel -> DescribeYourselfTo (*this);
00672         pModel -> SetModelingParameters(0);
00673       }
00674     }
00675     delete pMP;
00676     SetModel (0);
00677   }
00678 }

void G4VSceneHandler::EndModeling ( ) [virtual]

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepFileSceneHandler, G4HepRepSceneHandler, G4ASCIITreeSceneHandler, G4VTreeSceneHandler, G4VRML1FileSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 195 of file G4VSceneHandler.cc.

References fpModel.

Referenced by G4VTreeSceneHandler::EndModeling(), G4HepRepSceneHandler::EndModeling(), G4HepRepFileSceneHandler::EndModeling(), G4GMocrenFileSceneHandler::EndModeling(), G4DAWNFILESceneHandler::EndModeling(), G4GMocrenFileSceneHandler::GFEndModeling(), and ProcessScene().

00196 {
00197   fpModel = 0;
00198 }

void G4VSceneHandler::EndPrimitives ( ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4HepRepSceneHandler, G4VRML1FileSceneHandler, G4VRML2FileSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 157 of file G4VSceneHandler.cc.

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

Referenced by G4XXXStoredSceneHandler::EndPrimitives(), G4XXXSGSceneHandler::EndPrimitives(), G4HepRepSceneHandler::EndPrimitives(), G4GMocrenFileSceneHandler::EndPrimitives(), and RequestPrimitives().

00157                                      {
00158   if (fNestingDepth <= 0)
00159     G4Exception("G4VSceneHandler::EndPrimitives",
00160                 "visman0102", FatalException, "Nesting error.");
00161   fNestingDepth--;
00162   if (fReadyForTransients) {
00163     fTransientsDrawnThisEvent = true;
00164     fTransientsDrawnThisRun = true;
00165   }
00166 }

void G4VSceneHandler::EndPrimitives2D ( ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4HepRepFileSceneHandler.

Definition at line 180 of file G4VSceneHandler.cc.

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

Referenced by G4HepRepFileSceneHandler::EndPrimitives2D().

00180                                        {
00181   if (fNestingDepth <= 0)
00182     G4Exception("G4VSceneHandler::EndPrimitives2D",
00183                 "visman0104", FatalException, "Nesting error.");
00184   fNestingDepth--;
00185   if (fReadyForTransients) {
00186     fTransientsDrawnThisEvent = true;
00187     fTransientsDrawnThisRun = true;
00188   }
00189   fProcessing2D = false;
00190 }

G4bool G4VSceneHandler::GetAuxEdgeVisible ( const G4VisAttributes * )

Definition at line 912 of file G4VSceneHandler.cc.

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

00912                                                                              {
00913   G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
00914   if (pVisAttribs -> IsForceAuxEdgeVisible()) isAuxEdgeVisible = true;
00915   return isAuxEdgeVisible;
00916 }

const G4Colour & G4VSceneHandler::GetColor ( const G4Visible & ) [inline]

Definition at line 134 of file G4VSceneHandler.icc.

References GetColour().

Referenced by G4HepRepSceneHandler::AddPrimitive().

00134                                                                           {
00135   return GetColour (visible);
00136 }

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

Definition at line 847 of file G4VSceneHandler.cc.

References fpViewer, and G4Visible::GetVisAttributes().

Referenced by GetColor(), and GetTextColour().

00847                                                                     {
00848   // Colour is determined by the applicable vis attributes.
00849   const G4Colour& colour = fpViewer ->
00850     GetApplicableVisAttributes (visible.GetVisAttributes ()) -> GetColour ();
00851   return colour;
00852 }

G4VViewer * G4VSceneHandler::GetCurrentViewer ( ) const [inline]

Definition at line 80 of file G4VSceneHandler.icc.

References fpViewer.

Referenced by G4HepRepSceneHandler::closeHepRep().

00080                                                            {
00081   return fpViewer;
00082 }

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

Definition at line 873 of file G4VSceneHandler.cc.

References G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4VisAttributes::solid, G4VisAttributes::wireframe, and G4ViewParameters::wireframe.

Referenced by G4XXXStoredSceneHandler::AddPrimitive(), G4XXXSGSceneHandler::AddPrimitive(), G4XXXSceneHandler::AddPrimitive(), and G4XXXFileSceneHandler::AddPrimitive().

00873                                      {
00874   // Drawing style is normally determined by the view parameters, but
00875   // it can be overriddden by the ForceDrawingStyle flag in the vis
00876   // attributes.
00877   G4ViewParameters::DrawingStyle style = 
00878     fpViewer->GetViewParameters().GetDrawingStyle();
00879   if (pVisAttribs -> IsForceDrawingStyle ()) {
00880     G4VisAttributes::ForcedDrawingStyle forcedStyle =
00881       pVisAttribs -> GetForcedDrawingStyle ();
00882     // This is complicated because if hidden line and surface removal
00883     // has been requested we wish to preserve this sometimes.
00884     switch (forcedStyle) {
00885     case (G4VisAttributes::solid):
00886       switch (style) {
00887       case (G4ViewParameters::hlr):
00888         style = G4ViewParameters::hlhsr;
00889         break;
00890       case (G4ViewParameters::wireframe):
00891         style = G4ViewParameters::hsr;
00892         break;
00893       case (G4ViewParameters::hlhsr):
00894       case (G4ViewParameters::hsr):
00895       default:
00896         break;
00897       } 
00898       break;
00899     case (G4VisAttributes::wireframe):
00900     default:
00901       // But if forced style is wireframe, do it, because one of its
00902       // main uses is in displaying the consituent solids of a Boolean
00903       // solid and their surfaces overlap with the resulting Booean
00904       // solid, making a mess if hlr is specified.
00905       style = G4ViewParameters::wireframe;
00906       break;
00907     }
00908   }
00909   return style;
00910 }

G4VGraphicsSystem * G4VSceneHandler::GetGraphicsSystem ( ) const [inline]

Definition at line 32 of file G4VSceneHandler.icc.

References fSystem.

Referenced by G4ASCIITreeSceneHandler::BeginModeling(), G4ASCIITreeSceneHandler::EndModeling(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4ASCIITreeSceneHandler::WriteHeader(), G4HepRepSceneHandler::~G4HepRepSceneHandler(), and G4HepRepViewer::~G4HepRepViewer().

00032                                                                     {
00033   return &fSystem;
00034 }

G4double G4VSceneHandler::GetLineWidth ( const G4VisAttributes * )

Definition at line 863 of file G4VSceneHandler.cc.

References fpViewer, and G4VisAttributes::GetLineWidth().

00864 {
00865   G4double lineWidth = pVisAttribs->GetLineWidth();
00866   if (lineWidth < 1.) lineWidth = 1.;
00867   lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
00868   if (lineWidth < 1.) lineWidth = 1.;
00869   return lineWidth;
00870 }

G4double G4VSceneHandler::GetMarkerDiameter	(	const G4VMarker &	,
		MarkerSizeType &
	)			`[inline]`

Definition at line 46 of file G4VSceneHandler.icc.

00046                                                                    {
00047   return GetMarkerSize (marker, sizeType);
00048 }

G4double G4VSceneHandler::GetMarkerRadius	(	const G4VMarker &	,
		MarkerSizeType &
	)			`[inline]`

Definition at line 52 of file G4VSceneHandler.icc.

00052                                                                    {
00053   return GetMarkerSize (marker, sizeType) / 2.;
00054 }

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

Definition at line 919 of file G4VSceneHandler.cc.

References G4VMarker::GetScreenSize(), and G4VMarker::GetWorldSize().

Referenced by G4XXXStoredSceneHandler::AddPrimitive(), G4XXXSGSceneHandler::AddPrimitive(), G4XXXSceneHandler::AddPrimitive(), G4XXXFileSceneHandler::AddPrimitive(), and G4HepRepFileSceneHandler::AddPrimitive().

00921 {
00922   G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
00923   const G4VMarker& defaultMarker =
00924     fpViewer -> GetViewParameters().GetDefaultMarker();
00925   G4double size = userSpecified ?
00926     marker.GetWorldSize() : defaultMarker.GetWorldSize();
00927   if (size) {
00928     // Draw in world coordinates.
00929     markerSizeType = world;
00930   }
00931   else {
00932     size = userSpecified ?
00933       marker.GetScreenSize() : defaultMarker.GetScreenSize();
00934     // Draw in screen coordinates.
00935     markerSizeType = screen;
00936   }
00937   size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
00938   if (markerSizeType == screen && size < 1.) size = 1.;
00939   return size;
00940 }

G4bool G4VSceneHandler::GetMarkForClearingTransientStore ( ) const [inline]

Definition at line 84 of file G4VSceneHandler.icc.

References fMarkForClearingTransientStore.

00084                                                                        {
00085   return fMarkForClearingTransientStore;
00086 }

G4VModel * G4VSceneHandler::GetModel ( ) const [inline]

Definition at line 76 of file G4VSceneHandler.icc.

References fpModel.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), and G4VisManager::DispatchToModel().

00076                                                   {
00077   return fpModel;
00078 }

const G4String & G4VSceneHandler::GetName ( ) const [inline]

Definition at line 60 of file G4VSceneHandler.icc.

References fName.

Referenced by G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddSolid(), G4HepRepSceneHandler::closeHepRep(), G4VViewer::G4VViewer(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), and G4VisCommandSceneHandlerList::SetNewValue().

00060                                                        {
00061   return fName;
00062 }

G4int G4VSceneHandler::GetNoOfSides ( const G4VisAttributes * )

Definition at line 942 of file G4VSceneHandler.cc.

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

Referenced by RequestPrimitives().

00943 {
00944   // No. of sides (lines segments per circle) is normally determined
00945   // by the view parameters, but it can be overriddden by the
00946   // ForceLineSegmentsPerCircle in the vis attributes.
00947   G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
00948   if (pVisAttribs) {
00949     if (pVisAttribs->IsForceLineSegmentsPerCircle())
00950       lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
00951     const G4int nSegmentsMin = 12;
00952     if (lineSegmentsPerCircle < nSegmentsMin) {
00953       lineSegmentsPerCircle = nSegmentsMin;
00954       G4cout <<
00955         "G4VSceneHandler::GetNoOfSides: attempt to set the"
00956         "\nnumber of line segements per circle < " << nSegmentsMin
00957              << "; forced to " << lineSegmentsPerCircle << G4endl;
00958     }
00959   }
00960   return lineSegmentsPerCircle;
00961 }

const G4Transform3D & G4VSceneHandler::GetObjectTransformation ( ) const [inline]

Definition at line 100 of file G4VSceneHandler.icc.

References fObjectTransformation.

00100                                                                             {
00101   return fObjectTransformation;
00102 }

G4Scene * G4VSceneHandler::GetScene ( ) const [inline]

Definition at line 68 of file G4VSceneHandler.icc.

References fpScene.

Referenced by G4HepRepSceneHandler::closeHepRep(), G4GMocrenFileSceneHandler::GFBeginModeling(), G4VVisCommandViewer::RefreshIfRequired(), G4DAWNFILEViewer::SendViewParameters(), G4VisCommandsViewerSet::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), and G4RayTracerViewer::SetView().

00068                                                  {
00069   return fpScene;
00070 }

G4int G4VSceneHandler::GetSceneHandlerId ( ) const [inline]

Definition at line 36 of file G4VSceneHandler.icc.

References fSceneHandlerId.

00036                                                        {
00037   return fSceneHandlerId;
00038 }

const G4Colour & G4VSceneHandler::GetTextColor ( const G4Text & ) [inline]

Definition at line 138 of file G4VSceneHandler.icc.

References GetTextColour().

00138                                                                         {
00139   return GetTextColour (text);
00140 }

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

Definition at line 854 of file G4VSceneHandler.cc.

References fpViewer, GetColour(), and G4Visible::GetVisAttributes().

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), and GetTextColor().

00854                                                                   {
00855   const G4VisAttributes* pVA = text.GetVisAttributes ();
00856   if (!pVA) {
00857     pVA = fpViewer -> GetViewParameters (). GetDefaultTextVisAttributes ();
00858   }
00859   const G4Colour& colour = pVA -> GetColour ();
00860   return colour;
00861 }

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent ( ) const [inline]

Definition at line 92 of file G4VSceneHandler.icc.

References fTransientsDrawnThisEvent.

00092                                                                   {
00093   return fTransientsDrawnThisEvent;
00094 }

G4bool G4VSceneHandler::GetTransientsDrawnThisRun ( ) const [inline]

Definition at line 96 of file G4VSceneHandler.icc.

References fTransientsDrawnThisRun.

00096                                                                 {
00097   return fTransientsDrawnThisRun;
00098 }

G4int G4VSceneHandler::GetViewCount ( ) const [inline]

Definition at line 40 of file G4VSceneHandler.icc.

References fViewCount.

00040                                                   {
00041   return fViewCount;
00042 }

const G4ViewerList & G4VSceneHandler::GetViewerList ( ) const [inline]

Definition at line 72 of file G4VSceneHandler.icc.

References fViewerList.

00072                                                                  {
00073   return fViewerList;
00074 }

G4int G4VSceneHandler::IncrementViewCount ( ) [inline]

Definition at line 56 of file G4VSceneHandler.icc.

References fViewCount.

00056                                                   {
00057   return fViewCount++;
00058 }

G4bool G4VSceneHandler::IsReadyForTransients ( ) const [inline]

Definition at line 88 of file G4VSceneHandler.icc.

References fReadyForTransients.

00088                                                            {
00089   return fReadyForTransients;
00090 }

void G4VSceneHandler::LoadAtts	(	const G4Visible &	,
		G4AttHolder *
	)			`[protected]`

Definition at line 791 of file G4VSceneHandler.cc.

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

00792 {
00793   // Load G4Atts from G4VisAttributes, if any...
00794   const G4VisAttributes* va = visible.GetVisAttributes();
00795   if (va) {
00796     const std::map<G4String,G4AttDef>* vaDefs =
00797       va->GetAttDefs();
00798     if (vaDefs) {
00799       holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
00800     }
00801   }
00802 
00803   G4PhysicalVolumeModel* pPVModel =
00804     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
00805   if (pPVModel) {
00806     // Load G4Atts from G4PhysicalVolumeModel...
00807     const std::map<G4String,G4AttDef>* pvDefs = pPVModel->GetAttDefs();
00808     if (pvDefs) {
00809       holder->AddAtts(pPVModel->CreateCurrentAttValues(), pvDefs);
00810     }
00811   }
00812 
00813   G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
00814   if (trajModel) {
00815     // Load G4Atts from trajectory model...
00816     const std::map<G4String,G4AttDef>* trajModelDefs = trajModel->GetAttDefs();
00817     if (trajModelDefs) {
00818       holder->AddAtts(trajModel->CreateCurrentAttValues(), trajModelDefs);
00819     }
00820     // Load G4Atts from trajectory...
00821     const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
00822     const std::map<G4String,G4AttDef>* trajDefs = traj->GetAttDefs();
00823     if (trajDefs) {
00824       holder->AddAtts(traj->CreateAttValues(), trajDefs);
00825     }
00826     G4int nPoints = traj->GetPointEntries();
00827     for (G4int i = 0; i < nPoints; ++i) {
00828       G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
00829       const std::map<G4String,G4AttDef>* pointDefs = trajPoint->GetAttDefs();
00830       if (pointDefs) {
00831         holder->AddAtts(trajPoint->CreateAttValues(), pointDefs);
00832       }
00833     }
00834   }
00835 
00836   G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
00837   if (hitsModel) {
00838     // Load G4Atts from hit...
00839     const G4VHit* hit = hitsModel->GetCurrentHit();
00840     const std::map<G4String,G4AttDef>* hitsDefs = hit->GetAttDefs();
00841     if (hitsDefs) {
00842       holder->AddAtts(hit->CreateAttValues(), hitsDefs);
00843     }
00844   }
00845 }

void G4VSceneHandler::PostAddSolid ( ) [virtual]

Implements G4VGraphicsScene.

Reimplemented in G4HepRepSceneHandler, G4VTreeSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 135 of file G4VSceneHandler.cc.

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

Referenced by G4XXXStoredSceneHandler::PostAddSolid(), G4XXXSGSceneHandler::PostAddSolid(), and G4HepRepSceneHandler::PostAddSolid().

00135                                     {
00136   fpVisAttribs = 0;
00137   fProcessingSolid = false;
00138   if (fReadyForTransients) {
00139     fTransientsDrawnThisEvent = true;
00140     fTransientsDrawnThisRun = true;
00141   }
00142 }

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

Implements G4VGraphicsScene.

Reimplemented in G4HepRepSceneHandler, G4VTreeSceneHandler, G4XXXSGSceneHandler, and G4XXXStoredSceneHandler.

Definition at line 128 of file G4VSceneHandler.cc.

References fObjectTransformation, fProcessingSolid, and fpVisAttribs.

Referenced by G4XXXStoredSceneHandler::PreAddSolid(), G4XXXSGSceneHandler::PreAddSolid(), G4VTreeSceneHandler::PreAddSolid(), and G4HepRepSceneHandler::PreAddSolid().

00129                                                                       {
00130   fObjectTransformation = objectTransformation;
00131   fpVisAttribs = &visAttribs;
00132   fProcessingSolid = true;
00133 }

void G4VSceneHandler::ProcessScene ( ) [protected, virtual]

Definition at line 537 of file G4VSceneHandler.cc.

References BeginModeling(), G4VisManager::confirmations, CreateModelingParameters(), DrawEndOfRunModels(), DrawEvent(), EndModeling(), fMarkForClearingTransientStore, fpScene, fReadyForTransients, G4cout, G4endl, G4State_GeomClosed, G4State_Idle, G4VVisManager::GetConcreteInstance(), G4RunManager::GetCurrentRun(), G4StateManager::GetCurrentState(), G4Run::GetEventVector(), G4Scene::GetRefreshAtEndOfEvent(), G4Scene::GetRefreshAtEndOfRun(), G4VisManager::GetRequestedEvent(), G4RunManager::GetRunManager(), G4StateManager::GetStateManager(), G4VisManager::GetVerbosity(), G4VisManager::SetEventRefreshing(), SetModel(), and G4VisManager::warnings.

Referenced by G4VViewer::ProcessView().

00537                                     {
00538 
00539   // Assumes graphics database store has already been cleared if
00540   // relevant for the particular scene handler.
00541 
00542   if (!fpScene) return;
00543 
00544   G4VisManager* visManager = G4VisManager::GetInstance();
00545 
00546   if (!visManager->GetConcreteInstance()) return;
00547 
00548   G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
00549 
00550   fReadyForTransients = false;
00551 
00552   // Reset fMarkForClearingTransientStore. (Leaving
00553   // fMarkForClearingTransientStore true causes problems with
00554   // recomputing transients below.)  Restore it again at end...
00555   G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
00556   fMarkForClearingTransientStore = false;
00557 
00558   // Traverse geometry tree and send drawing primitives to window(s).
00559 
00560   const std::vector<G4Scene::Model>& runDurationModelList =
00561     fpScene -> GetRunDurationModelList ();
00562 
00563   if (runDurationModelList.size ()) {
00564     if (verbosity >= G4VisManager::confirmations) {
00565       G4cout << "Traversing scene data..." << G4endl;
00566     }
00567 
00568     BeginModeling ();
00569 
00570     // Create modeling parameters from view parameters...
00571     G4ModelingParameters* pMP = CreateModelingParameters ();
00572 
00573     for (size_t i = 0; i < runDurationModelList.size (); i++) {
00574       if (runDurationModelList[i].fActive) {
00575         G4VModel* pModel = runDurationModelList[i].fpModel;
00576         // Note: this is not the place to take action on
00577         // pModel->GetTransformation().  The model must take care of
00578         // this in pModel->DescribeYourselfTo(*this).  See, for example,
00579         // G4PhysicalVolumeModel and /vis/scene/add/logo.
00580         pModel -> SetModelingParameters (pMP);
00581         SetModel (pModel);  // Store for use by derived class.
00582         pModel -> DescribeYourselfTo (*this);
00583         pModel -> SetModelingParameters (0);
00584       }
00585     }
00586 
00587     delete pMP;
00588     EndModeling ();
00589   }
00590 
00591   fReadyForTransients = true;
00592 
00593   // Refresh event from end-of-event model list.
00594   // Allow only in Idle or GeomClosed state...
00595   G4StateManager* stateManager = G4StateManager::GetStateManager();
00596   G4ApplicationState state = stateManager->GetCurrentState();
00597   if (state == G4State_Idle || state == G4State_GeomClosed) {
00598 
00599     visManager->SetEventRefreshing(true);
00600 
00601     if (visManager->GetRequestedEvent()) {
00602       DrawEvent(visManager->GetRequestedEvent());
00603 
00604     } else {
00605 
00606       G4RunManager* runManager = G4RunManager::GetRunManager();
00607       if (runManager) {
00608         const G4Run* run = runManager->GetCurrentRun();
00609         const std::vector<const G4Event*>* events =
00610           run? run->GetEventVector(): 0;
00611         size_t nKeptEvents = 0;
00612         if (events) nKeptEvents = events->size();
00613         if (nKeptEvents) {
00614 
00615           if (fpScene->GetRefreshAtEndOfEvent()) {
00616 
00617             if (verbosity >= G4VisManager::confirmations) {
00618               G4cout << "Refreshing event..." << G4endl;
00619             }
00620             const G4Event* event = 0;
00621             if (events && events->size()) event = events->back();
00622             if (event) DrawEvent(event);
00623 
00624           } else {  // Accumulating events.
00625 
00626             if (verbosity >= G4VisManager::confirmations) {
00627               G4cout << "Refreshing events in run..." << G4endl;
00628             }
00629             for (size_t i = 0; i < nKeptEvents; ++i) {
00630               const G4Event* event = (*events)[i];
00631               if (event) DrawEvent(event);
00632             }
00633 
00634             if (!fpScene->GetRefreshAtEndOfRun()) {
00635               if (verbosity >= G4VisManager::warnings) {
00636                 G4cout <<
00637                   "WARNING: Cannot refresh events accumulated over more"
00638                   "\n  than one runs.  Refreshed just the last run."
00639                        << G4endl;
00640               }
00641             }
00642           }
00643         }
00644       }
00645     }
00646     visManager->SetEventRefreshing(false);
00647   }
00648 
00649   // Refresh end-of-run model list.
00650   // Allow only in Idle or GeomClosed state...
00651   if (state == G4State_Idle || state == G4State_GeomClosed) {
00652     DrawEndOfRunModels();
00653   }
00654 
00655   fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
00656 }

void G4VSceneHandler::RemoveViewerFromList ( G4VViewer * pView )

Definition at line 467 of file G4VSceneHandler.cc.

References fViewerList, and G4ViewerList::remove().

Referenced by G4VViewer::~G4VViewer().

00467                                                               {
00468   fViewerList.remove(pViewer);
00469 }

void G4VSceneHandler::RequestPrimitives ( const G4VSolid & solid ) [protected, virtual]

Reimplemented in G4ASCIITreeSceneHandler.

Definition at line 480 of file G4VSceneHandler.cc.

References AddPrimitive(), BeginPrimitives(), G4VSolid::CreateNURBS(), EndPrimitives(), G4VisManager::errors, fObjectTransformation, fpViewer, fpVisAttribs, G4cout, G4endl, G4VSolid::GetName(), GetNoOfSides(), G4VSolid::GetPolyhedron(), G4VisManager::GetVerbosity(), G4ViewParameters::nurbs, and G4ViewParameters::polyhedron.

Referenced by AddSolid().

00480                                                               {
00481   BeginPrimitives (fObjectTransformation);
00482   G4NURBS* pNURBS = 0;
00483   G4Polyhedron* pPolyhedron = 0;
00484   switch (fpViewer -> GetViewParameters () . GetRepStyle ()) {
00485   case G4ViewParameters::nurbs:
00486     pNURBS = solid.CreateNURBS ();
00487     if (pNURBS) {
00488       static G4bool warned = false;
00489       if (!warned) {
00490         warned = true;
00491         G4cout <<
00492   "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
00493   "!!!!! NURBS are deprecated and will be removed in the next major release."
00494   "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
00495         << G4endl;
00496       }
00497       pNURBS -> SetVisAttributes (fpVisAttribs);
00498       AddPrimitive (*pNURBS);
00499       delete pNURBS;
00500       break;
00501     }
00502     else {
00503       G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
00504       if (verbosity >= G4VisManager::errors) {
00505         G4cout <<
00506           "ERROR: G4VSceneHandler::RequestPrimitives"
00507           "\n  NURBS not available for "
00508                << solid.GetName () << G4endl;
00509         G4cout << "Trying polyhedron." << G4endl;
00510       }
00511     }
00512     // Dropping through to polyhedron...
00513   case G4ViewParameters::polyhedron:
00514   default:
00515     G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
00516     pPolyhedron = solid.GetPolyhedron ();
00517     G4Polyhedron::ResetNumberOfRotationSteps ();
00518     if (pPolyhedron) {
00519       pPolyhedron -> SetVisAttributes (fpVisAttribs);
00520       AddPrimitive (*pPolyhedron);
00521     }
00522     else {
00523       G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
00524       if (verbosity >= G4VisManager::errors) {
00525         G4cout <<
00526           "ERROR: G4VSceneHandler::RequestPrimitives"
00527           "\n  Polyhedron not available for " << solid.GetName () <<
00528           ".\n  This means it cannot be visualized on most systems."
00529           "\n  Contact the Visualization Coordinator." << G4endl;
00530       }
00531     }
00532     break;
00533   }
00534   EndPrimitives ();
00535 }

void G4VSceneHandler::SetCurrentViewer ( G4VViewer * ) [inline]

Definition at line 104 of file G4VSceneHandler.icc.

References fpViewer.

00104                                                                  {
00105   fpViewer = pViewer;
00106 }

void G4VSceneHandler::SetMarkForClearingTransientStore ( G4bool ) [inline]

Definition at line 117 of file G4VSceneHandler.icc.

References fMarkForClearingTransientStore.

Referenced by G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandSceneEndOfEventAction::SetNewValue().

00117                                                                           {
00118   fMarkForClearingTransientStore = mark;
00119 }

void G4VSceneHandler::SetModel ( G4VModel * ) [inline]

Definition at line 113 of file G4VSceneHandler.icc.

References fpModel.

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

00113                                            {
00114   fpModel = pModel;
00115 }

void G4VSceneHandler::SetName ( const G4String & ) [inline]

Definition at line 64 of file G4VSceneHandler.icc.

References fName.

00064                                                           {
00065   fName = name;
00066 }

void G4VSceneHandler::SetObjectTransformation ( const G4Transform3D & ) [inline]

Definition at line 129 of file G4VSceneHandler.icc.

References fObjectTransformation.

00129                                                                             {
00130   fObjectTransformation = t;
00131 }

void G4VSceneHandler::SetScene ( G4Scene * ) [virtual]

Definition at line 471 of file G4VSceneHandler.cc.

References fpScene, and fViewerList.

00471                                                {
00472   fpScene = pScene;
00473   // Notify all viewers that a kernel visit is required.
00474   G4ViewerListIterator i;
00475   for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
00476     (*i) -> SetNeedKernelVisit (true);
00477   }
00478 }

void G4VSceneHandler::SetTransientsDrawnThisEvent ( G4bool ) [inline]

Definition at line 121 of file G4VSceneHandler.icc.

References fTransientsDrawnThisEvent.

00121                                                                       {
00122   fTransientsDrawnThisEvent = drawn;
00123 }

void G4VSceneHandler::SetTransientsDrawnThisRun ( G4bool ) [inline]

Definition at line 125 of file G4VSceneHandler.icc.

References fTransientsDrawnThisRun.

00125                                                                     {
00126   fTransientsDrawnThisRun = drawn;
00127 }

G4ViewerList & G4VSceneHandler::SetViewerList ( ) [inline]

Definition at line 108 of file G4VSceneHandler.icc.

References fViewerList.

00108                                                      {
00109   return fViewerList;
00110 }

friend class G4VViewer [friend]

Definition at line 63 of file G4VSceneHandler.hh.

std::ostream& operator<<	(	std::ostream &	os,
		const G4VSceneHandler &	s
	)			`[friend]`

Definition at line 963 of file G4VSceneHandler.cc.

00963                                                                     {
00964 
00965   os << "Scene handler " << sh.fName << " has "
00966      << sh.fViewerList.size () << " viewer(s):";
00967   for (size_t i = 0; i < sh.fViewerList.size (); i++) {
00968     os << "\n  " << *(sh.fViewerList [i]);
00969   }
00970 
00971   if (sh.fpScene) {
00972     os << "\n  " << *sh.fpScene;
00973   }
00974   else {
00975     os << "\n  This scene handler currently has no scene.";
00976   }
00977 
00978   return os;
00979 }

const G4Transform3D G4VSceneHandler::fIdentityTransformation [protected]

Definition at line 345 of file G4VSceneHandler.hh.

G4bool G4VSceneHandler::fMarkForClearingTransientStore [protected]

Definition at line 333 of file G4VSceneHandler.hh.

Referenced by GetMarkForClearingTransientStore(), ProcessScene(), and SetMarkForClearingTransientStore().

G4String G4VSceneHandler::fName [protected]

Definition at line 328 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler(), GetName(), operator<<(), and SetName().

G4int G4VSceneHandler::fNestingDepth [protected]

Definition at line 343 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), and EndPrimitives2D().

G4Transform3D G4VSceneHandler::fObjectTransformation [protected]

Definition at line 341 of file G4VSceneHandler.hh.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), GetObjectTransformation(), PreAddSolid(), RequestPrimitives(), and SetObjectTransformation().

G4VModel* G4VSceneHandler::fpModel [protected]

Definition at line 340 of file G4VSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), AddPrimitive(), G4HepRepSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4HepRepSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), DrawEndOfRunModels(), DrawEvent(), EndModeling(), GetModel(), LoadAtts(), G4ASCIITreeSceneHandler::RequestPrimitives(), and SetModel().

G4bool G4VSceneHandler::fProcessing2D [protected]

Definition at line 339 of file G4VSceneHandler.hh.

Referenced by G4HepRepSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), and EndPrimitives2D().

G4bool G4VSceneHandler::fProcessingSolid [protected]

Definition at line 338 of file G4VSceneHandler.hh.

Referenced by G4XXXStoredSceneHandler::EndPrimitives(), PostAddSolid(), and PreAddSolid().

G4Scene* G4VSceneHandler::fpScene [protected]

Definition at line 332 of file G4VSceneHandler.hh.

Referenced by AddPrimitive(), CreateSectionSolid(), DrawEndOfRunModels(), DrawEvent(), G4ASCIITreeSceneHandler::EndModeling(), G4RayTracerSceneHandler::G4RayTracerSceneHandler(), G4VSceneHandler(), GetScene(), operator<<(), ProcessScene(), and SetScene().

G4VViewer* G4VSceneHandler::fpViewer [protected]

const G4VisAttributes* G4VSceneHandler::fpVisAttribs [protected]

Definition at line 344 of file G4VSceneHandler.hh.

Referenced by G4HepRepFileSceneHandler::AddPrimitive(), G4HepRepFileSceneHandler::AddSolid(), PostAddSolid(), PreAddSolid(), and RequestPrimitives().

G4bool G4VSceneHandler::fReadyForTransients [protected]

Definition at line 334 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), EndPrimitives2D(), IsReadyForTransients(), PostAddSolid(), and ProcessScene().

const G4int G4VSceneHandler::fSceneHandlerId [protected]

Definition at line 327 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler(), and GetSceneHandlerId().

G4VGraphicsSystem& G4VSceneHandler::fSystem [protected]

Definition at line 326 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler(), and GetGraphicsSystem().

G4bool G4VSceneHandler::fTransientsDrawnThisEvent [protected]

Definition at line 336 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), EndPrimitives2D(), G4VSceneHandler(), GetTransientsDrawnThisEvent(), PostAddSolid(), and SetTransientsDrawnThisEvent().

G4bool G4VSceneHandler::fTransientsDrawnThisRun [protected]

Definition at line 337 of file G4VSceneHandler.hh.

Referenced by EndPrimitives(), EndPrimitives2D(), G4VSceneHandler(), GetTransientsDrawnThisRun(), PostAddSolid(), and SetTransientsDrawnThisRun().

G4int G4VSceneHandler::fViewCount [protected]

Definition at line 329 of file G4VSceneHandler.hh.

Referenced by GetViewCount(), and IncrementViewCount().

G4ViewerList G4VSceneHandler::fViewerList [protected]

Definition at line 330 of file G4VSceneHandler.hh.

Referenced by AddViewerToList(), GetViewerList(), operator<<(), RemoveViewerFromList(), SetScene(), SetViewerList(), and ~G4VSceneHandler().

G4VSceneHandler Class Reference

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation


Public Types
	world
	screen
enum	MarkerSizeType { world, screen }
Public Member Functions
	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)
Protected Member Functions
virtual void	ProcessScene ()
virtual void	RequestPrimitives (const G4VSolid &solid)
virtual G4VSolid *	CreateSectionSolid ()
virtual G4VSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
Protected Attributes
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
Friends
class	G4VViewer
std::ostream &	operator<< (std::ostream &os, const G4VSceneHandler &s)