source: trunk/source/visualization/management/src/G4VSceneHandler.cc@ 1238

Last change on this file since 1238 was 1238, checked in by garnier, 16 years ago

otpimisations
  • Property svn:mime-type set to text/cpp
File size: 30.7 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4VSceneHandler.cc,v 1.91 2009/11/16 13:51:08 lgarnier Exp $
28// GEANT4 tag $Name: $
29//
30//
31// John Allison 19th July 1996
32// Abstract interface class for graphics scenes.
33
34#include "G4VSceneHandler.hh"
35
36#include "G4ios.hh"
37#include <sstream>
38
39#include "G4VisManager.hh"
40#include "G4VGraphicsSystem.hh"
41#include "G4VViewer.hh"
42#include "G4VSolid.hh"
43#include "G4RotationMatrix.hh"
44#include "G4ThreeVector.hh"
45#include "G4VPhysicalVolume.hh"
46#include "G4Material.hh"
47#include "G4Polyline.hh"
48#include "G4Scale.hh"
49#include "G4Text.hh"
50#include "G4Circle.hh"
51#include "G4Square.hh"
52#include "G4Polymarker.hh"
53#include "G4Polyhedron.hh"
54#include "G4NURBS.hh"
55#include "G4Visible.hh"
56#include "G4VisAttributes.hh"
57#include "G4VModel.hh"
58#include "G4TrajectoriesModel.hh"
59#include "G4Box.hh"
60#include "G4Cons.hh"
61#include "G4Tubs.hh"
62#include "G4Trd.hh"
63#include "G4Trap.hh"
64#include "G4Sphere.hh"
65#include "G4Para.hh"
66#include "G4Torus.hh"
67#include "G4Polycone.hh"
68#include "G4Polyhedra.hh"
69#include "G4LogicalVolume.hh"
70#include "G4PhysicalVolumeModel.hh"
71#include "G4ModelingParameters.hh"
72#include "G4VTrajectory.hh"
73#include "G4VTrajectoryPoint.hh"
74#include "G4HitsModel.hh"
75#include "G4VHit.hh"
76#include "G4ScoringManager.hh"
77#include "G4DefaultLinearColorMap.hh"
78#include "Randomize.hh"
79#include "G4StateManager.hh"
80#include "G4RunManager.hh"
81#include "G4Run.hh"
82#include "G4Transform3D.hh"
83#include "G4AttHolder.hh"
84#include "G4AttDef.hh"
85
86G4VSceneHandler::G4VSceneHandler (G4VGraphicsSystem& system, G4int id, const G4String& name):
87 fSystem (system),
88 fSceneHandlerId (id),
89 fViewCount (0),
90 fpViewer (0),
91 fpScene (0),
92 fMarkForClearingTransientStore (true), // Ready for first
93 // ClearTransientStoreIfMarked(),
94 // e.g., at end of run (see
95 // G4VisManager.cc).
96 fReadyForTransients (true), // Only false while processing scene.
97 fProcessingSolid (false),
98 fSecondPassRequested (false),
99 fSecondPass (false),
100 fpModel (0),
101 fpObjectTransformation (0),
102 fNestingDepth (0),
103 fpVisAttribs (0)
104{
105 G4VisManager* pVMan = G4VisManager::GetInstance ();
106 fpScene = pVMan -> GetCurrentScene ();
107 if (name == "") {
108 std::ostringstream ost;
109 ost << fSystem.GetName () << '-' << fSceneHandlerId;
110 fName = ost.str();
111 }
112 else {
113 fName = name;
114 }
115 fTransientsDrawnThisEvent = pVMan->GetTransientsDrawnThisEvent();
116 fTransientsDrawnThisRun = pVMan->GetTransientsDrawnThisRun();
117}
118
119G4VSceneHandler::~G4VSceneHandler () {
120// G4ViewerListIterator i;
121// for (i = fViewerList.begin(); i != fViewerList.end(); ++i) {
122// delete *i;
123// }
124 G4VViewer* last;
125 while( ! fViewerList.empty() ) {
126 last = fViewerList.back();
127 fViewerList.pop_back();
128 delete last;
129 }
130}
131
132void G4VSceneHandler::PreAddSolid (const G4Transform3D& objectTransformation,
133 const G4VisAttributes& visAttribs) {
134 fpObjectTransformation = &objectTransformation;
135 fpVisAttribs = &visAttribs;
136 fProcessingSolid = true;
137}
138
139void G4VSceneHandler::PostAddSolid () {
140 fpObjectTransformation = 0;
141 fpVisAttribs = 0;
142 fProcessingSolid = false;
143 if (fReadyForTransients) {
144 fTransientsDrawnThisEvent = true;
145 fTransientsDrawnThisRun = true;
146 }
147}
148
149void G4VSceneHandler::BeginPrimitives
150(const G4Transform3D& objectTransformation) {
151 fNestingDepth++;
152 if (fNestingDepth > 1)
153 G4Exception("G4VSceneHandler::BeginPrimitives: Nesting detected."
154 "\n It is illegal to nest Begin/EndPrimitives.");
155 fpObjectTransformation = &objectTransformation;
156}
157
158void G4VSceneHandler::EndPrimitives () {
159 if (fNestingDepth <= 0)
160 G4Exception("G4VSceneHandler::EndPrimitives: Nesting error");
161 fNestingDepth--;
162 fpObjectTransformation = 0;
163 if (fReadyForTransients) {
164 fTransientsDrawnThisEvent = true;
165 fTransientsDrawnThisRun = true;
166 }
167}
168
169void G4VSceneHandler::BeginPrimitives2D
170(const G4Transform3D& objectTransformation) {
171 fNestingDepth++;
172 if (fNestingDepth > 1)
173 G4Exception("G4VSceneHandler::BeginPrimitives2D: Nesting detected."
174 "\n It is illegal to nest Begin/EndPrimitives.");
175 fpObjectTransformation = &objectTransformation;
176}
177
178void G4VSceneHandler::EndPrimitives2D () {
179 if (fNestingDepth <= 0)
180 G4Exception("G4VSceneHandler::EndPrimitives2D: Nesting error");
181 fNestingDepth--;
182 fpObjectTransformation = 0;
183 if (fReadyForTransients) {
184 fTransientsDrawnThisEvent = true;
185 fTransientsDrawnThisRun = true;
186 }
187}
188
189void G4VSceneHandler::BeginModeling () {
190}
191
192void G4VSceneHandler::EndModeling ()
193{
194 fpModel = 0;
195}
196
197void G4VSceneHandler::ClearStore () {
198 // if (fpViewer) fpViewer -> NeedKernelVisit (true);
199 // ?? Viewer is supposed to be smart enough to know when to visit
200 // kernel, but a problem in OpenGL Stored seems to require a forced
201 // kernel visit triggered by the above code. John Allison Aug 2001
202 // Feb 2005 - commented out. Let's fix OpenGL if necessary.
203}
204
205void G4VSceneHandler::ClearTransientStore () {
206}
207
208void G4VSceneHandler::AddSolid (const G4Box& box) {
209 RequestPrimitives (box);
210// If your graphics system is sophisticated enough to handle a
211// particular solid shape as a primitive, in your derived class write a
212// function to override this. (Note: some compilers warn that your
213// function "hides" this one. That's OK.)
214// Your function might look like this...
215// void G4MyScene::AddSolid (const G4Box& box) {
216// Get parameters of appropriate object, e.g.:
217// G4double dx = box.GetXHalfLength ();
218// G4double dy = box.GetYHalfLength ();
219// G4double dz = box.GetZHalfLength ();
220// and Draw or Store in your display List.
221}
222
223void G4VSceneHandler::AddSolid (const G4Tubs& tubs) {
224 RequestPrimitives (tubs);
225}
226
227void G4VSceneHandler::AddSolid (const G4Cons& cons) {
228 RequestPrimitives (cons);
229}
230
231void G4VSceneHandler::AddSolid (const G4Trd& trd) {
232 RequestPrimitives (trd);
233}
234
235void G4VSceneHandler::AddSolid (const G4Trap& trap) {
236 RequestPrimitives (trap);
237}
238
239void G4VSceneHandler::AddSolid (const G4Sphere& sphere) {
240 RequestPrimitives (sphere );
241}
242
243void G4VSceneHandler::AddSolid (const G4Para& para) {
244 RequestPrimitives (para);
245}
246
247void G4VSceneHandler::AddSolid (const G4Torus& torus) {
248 RequestPrimitives (torus);
249}
250
251void G4VSceneHandler::AddSolid (const G4Polycone& polycone) {
252 RequestPrimitives (polycone);
253}
254
255void G4VSceneHandler::AddSolid (const G4Polyhedra& polyhedra) {
256 RequestPrimitives (polyhedra);
257}
258
259void G4VSceneHandler::AddSolid (const G4VSolid& solid) {
260 RequestPrimitives (solid);
261}
262
263void G4VSceneHandler::AddCompound (const G4VTrajectory& traj) {
264 G4TrajectoriesModel* pTrModel =
265 dynamic_cast<G4TrajectoriesModel*>(fpModel);
266 if (!pTrModel) G4Exception
267 ("G4VSceneHandler::AddCompound(const G4VTrajectory&): Not a G4TrajectoriesModel.");
268 traj.DrawTrajectory(pTrModel->GetDrawingMode());
269}
270
271void G4VSceneHandler::AddCompound (const G4VHit& hit) {
272 // Cast away const because Draw is non-const!!!!
273 const_cast<G4VHit&>(hit).Draw();
274}
275
276void G4VSceneHandler::AddCompound (const G4THitsMap<G4double>& hits) {
277 //G4cout << "AddCompound: hits: " << &hits << G4endl;
278 G4bool scoreMapHits = false;
279 G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
280 if (scoringManager) {
281 size_t nMeshes = scoringManager->GetNumberOfMesh();
282 for (size_t i = 0; i < nMeshes; ++i) {
283 G4VScoringMesh* mesh = scoringManager->GetMesh(i);
284 if (mesh && mesh->IsActive()) {
285 MeshScoreMap scoreMap = mesh->GetScoreMap();
286 for(MeshScoreMap::const_iterator i = scoreMap.begin();
287 i != scoreMap.end(); ++i) {
288 const G4String& scoreMapName = i->first;
289 const G4THitsMap<G4double>* foundHits = i->second;
290 if (foundHits == &hits) {
291 G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
292 scoreMapHits = true;
293 mesh->DrawMesh(scoreMapName, &colorMap);
294 }
295 }
296 }
297 }
298 }
299 if (scoreMapHits) {
300 static G4bool first = true;
301 if (first) {
302 first = false;
303 G4cout <<
304 "Scoring map drawn with default parameters."
305 "\n To get gMocren file for gMocren browser:"
306 "\n /vis/open gMocrenFile"
307 "\n /vis/viewer/flush"
308 "\n Many other options available with /score/draw... commands."
309 "\n You might want to \"/vis/viewer/set/autoRefresh false\"."
310 << G4endl;
311 }
312 } else { // Not score map hits. Just call DrawAllHits.
313 // Cast away const because DrawAllHits is non-const!!!!
314 const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
315 }
316}
317
318void G4VSceneHandler::AddViewerToList (G4VViewer* pViewer) {
319 fViewerList.push_back (pViewer);
320}
321
322void G4VSceneHandler::AddPrimitive (const G4Scale& scale) {
323
324 const G4double margin(0.01);
325 // Fractional margin - ensures scale is comfortably inside viewing
326 // volume.
327 const G4double oneMinusMargin (1. - margin);
328
329 const G4VisExtent& sceneExtent = fpScene->GetExtent();
330
331 // Useful constants...
332 const G4double length(scale.GetLength());
333 const G4double halfLength(length / 2.);
334 const G4double tickLength(length / 20.);
335 const G4double piBy2(halfpi);
336
337 // Get size of scene...
338 const G4double xmin = sceneExtent.GetXmin();
339 const G4double xmax = sceneExtent.GetXmax();
340 const G4double ymin = sceneExtent.GetYmin();
341 const G4double ymax = sceneExtent.GetYmax();
342 const G4double zmin = sceneExtent.GetZmin();
343 const G4double zmax = sceneExtent.GetZmax();
344
345 // Create (empty) polylines having the same vis attributes...
346 G4Polyline scaleLine, tick11, tick12, tick21, tick22;
347 G4VisAttributes visAtts(*scale.GetVisAttributes()); // Long enough life.
348 scaleLine.SetVisAttributes(&visAtts);
349 tick11.SetVisAttributes(&visAtts);
350 tick12.SetVisAttributes(&visAtts);
351 tick21.SetVisAttributes(&visAtts);
352 tick22.SetVisAttributes(&visAtts);
353
354 // Add points to the polylines to represent an scale parallel to the
355 // x-axis centred on the origin...
356 G4Point3D r1(G4Point3D(-halfLength, 0., 0.));
357 G4Point3D r2(G4Point3D( halfLength, 0., 0.));
358 scaleLine.push_back(r1);
359 scaleLine.push_back(r2);
360 G4Point3D ticky(0., tickLength, 0.);
361 G4Point3D tickz(0., 0., tickLength);
362 tick11.push_back(r1 + ticky);
363 tick11.push_back(r1 - ticky);
364 tick12.push_back(r1 + tickz);
365 tick12.push_back(r1 - tickz);
366 tick21.push_back(r2 + ticky);
367 tick21.push_back(r2 - ticky);
368 tick22.push_back(r2 + tickz);
369 tick22.push_back(r2 - tickz);
370 G4Point3D textPosition(0., tickLength, 0.);
371
372 // Transform appropriately...
373
374 G4Transform3D transformation;
375 if (scale.GetAutoPlacing()) {
376 G4Transform3D rotation;
377 switch (scale.GetDirection()) {
378 case G4Scale::x:
379 break;
380 case G4Scale::y:
381 rotation = G4RotateZ3D(piBy2);
382 break;
383 case G4Scale::z:
384 rotation = G4RotateY3D(piBy2);
385 break;
386 }
387 G4double sxmid(scale.GetXmid());
388 G4double symid(scale.GetYmid());
389 G4double szmid(scale.GetZmid());
390 sxmid = xmin + oneMinusMargin * (xmax - xmin);
391 symid = ymin + margin * (ymax - ymin);
392 szmid = zmin + oneMinusMargin * (zmax - zmin);
393 switch (scale.GetDirection()) {
394 case G4Scale::x:
395 sxmid -= halfLength;
396 break;
397 case G4Scale::y:
398 symid += halfLength;
399 break;
400 case G4Scale::z:
401 szmid -= halfLength;
402 break;
403 }
404 G4Translate3D translation(sxmid, symid, szmid);
405 transformation = translation * rotation;
406 } else {
407 if (fpModel) transformation = fpModel->GetTransformation();
408 }
409
410 // Draw...
411 // We would like to call BeginPrimitives(transformation) here but
412 // calling BeginPrimitives from within an AddPrimitive is not
413 // allowed! So we have to do our own transformation...
414 AddPrimitive(scaleLine.transform(transformation));
415 AddPrimitive(tick11.transform(transformation));
416 AddPrimitive(tick12.transform(transformation));
417 AddPrimitive(tick21.transform(transformation));
418 AddPrimitive(tick22.transform(transformation));
419 G4Text text(scale.GetAnnotation(),textPosition.transform(transformation));
420 text.SetScreenSize(12.);
421 AddPrimitive(text);
422}
423
424void G4VSceneHandler::AddPrimitive (const G4Polymarker& polymarker) {
425 switch (polymarker.GetMarkerType()) {
426 default:
427 case G4Polymarker::dots:
428 {
429 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
430 G4Circle dot (polymarker);
431 dot.SetPosition (polymarker[iPoint]);
432 dot.SetWorldSize (0.);
433 dot.SetScreenSize (0.1); // Very small circle.
434 AddPrimitive (dot);
435 }
436 }
437 break;
438 case G4Polymarker::circles:
439 {
440 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
441 G4Circle circle (polymarker);
442 circle.SetPosition (polymarker[iPoint]);
443 AddPrimitive (circle);
444 }
445 }
446 break;
447 case G4Polymarker::squares:
448 {
449 for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
450 G4Square square (polymarker);
451 square.SetPosition (polymarker[iPoint]);
452 AddPrimitive (square);
453 }
454 }
455 break;
456 }
457}
458
459void G4VSceneHandler::RemoveViewerFromList (G4VViewer* pViewer) {
460 fViewerList.remove(pViewer);
461}
462
463void G4VSceneHandler::SetScene (G4Scene* pScene) {
464 fpScene = pScene;
465 // Notify all viewers that a kernel visit is required.
466 G4ViewerListIterator i;
467 for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
468 (*i) -> SetNeedKernelVisit (true);
469 }
470}
471
472void G4VSceneHandler::RequestPrimitives (const G4VSolid& solid) {
473#ifdef G4DEBUG_VIS_MANAGEMENT
474 printf("G4VSceneHandler::RequestPrimitives\n");
475#endif
476 BeginPrimitives (*fpObjectTransformation);
477 G4NURBS* pNURBS = 0;
478 G4Polyhedron* pPolyhedron = 0;
479 switch (fpViewer -> GetViewParameters () . GetRepStyle ()) {
480 case G4ViewParameters::nurbs:
481 pNURBS = solid.CreateNURBS ();
482 if (pNURBS) {
483 pNURBS -> SetVisAttributes (fpVisAttribs);
484 AddPrimitive (*pNURBS);
485 delete pNURBS;
486 break;
487 }
488 else {
489 G4VisManager::Verbosity verbosity =
490 G4VisManager::GetInstance()->GetVerbosity();
491 if (verbosity >= G4VisManager::errors) {
492 G4cout <<
493 "ERROR: G4VSceneHandler::RequestPrimitives"
494 "\n NURBS not available for "
495 << solid.GetName () << G4endl;
496 G4cout << "Trying polyhedron." << G4endl;
497 }
498 }
499 // Dropping through to polyhedron...
500 case G4ViewParameters::polyhedron:
501 default:
502 G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
503 pPolyhedron = solid.GetPolyhedron ();
504 G4Polyhedron::ResetNumberOfRotationSteps ();
505 if (pPolyhedron) {
506 pPolyhedron -> SetVisAttributes (fpVisAttribs);
507 AddPrimitive (*pPolyhedron);
508 }
509 else {
510 G4VisManager::Verbosity verbosity =
511 G4VisManager::GetInstance()->GetVerbosity();
512 if (verbosity >= G4VisManager::errors) {
513 G4cout <<
514 "ERROR: G4VSceneHandler::RequestPrimitives"
515 "\n Polyhedron not available for " << solid.GetName () <<
516 ".\n This means it cannot be visualized on most systems."
517 "\n Contact the Visualization Coordinator." << G4endl;
518 }
519 }
520 break;
521 }
522#ifdef G4DEBUG_VIS_MANAGEMENT
523 printf("G4VSceneHandler::RequestPrimitives BEFORE END\n");
524#endif
525 EndPrimitives ();
526#ifdef G4DEBUG_VIS_MANAGEMENT
527 printf("G4VSceneHandler::RequestPrimitives END\n");
528#endif
529}
530
531void G4VSceneHandler::ProcessScene (G4VViewer&) {
532#ifdef G4DEBUG_VIS_MANAGEMENT
533 printf("G4VSceneHandler::ProcessScene\n");
534#endif
535
536 if (!fpScene) return;
537
538 G4VisManager* visManager = G4VisManager::GetInstance();
539
540 if (!visManager->GetConcreteInstance()) return;
541
542 G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
543
544 fReadyForTransients = false;
545
546 // Clear stored scene, if any, i.e., display lists, scene graphs.
547 ClearStore ();
548
549 // Reset fMarkForClearingTransientStore. No need to clear transient
550 // store since it has just been cleared above. (Leaving
551 // fMarkForClearingTransientStore true causes problems with
552 // recomputing transients below.) Restore it again at end...
553 G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
554 fMarkForClearingTransientStore = false;
555
556 // Traverse geometry tree and send drawing primitives to window(s).
557
558 const std::vector<G4VModel*>& runDurationModelList =
559 fpScene -> GetRunDurationModelList ();
560
561 if (runDurationModelList.size ()) {
562 if (verbosity >= G4VisManager::confirmations) {
563 G4cout << "Traversing scene data..." << G4endl;
564 }
565
566 BeginModeling ();
567
568 // Create modeling parameters from view parameters...
569 G4ModelingParameters* pMP = CreateModelingParameters ();
570
571 for (size_t i = 0; i < runDurationModelList.size (); i++) {
572 G4VModel* pModel = runDurationModelList[i];
573 // Note: this is not the place to take action on
574 // pModel->GetTransformation(). The model must take care of
575 // this in pModel->DescribeYourselfTo(*this). See, for example,
576 // G4PhysicalVolumeModel and /vis/scene/add/logo.
577 pModel -> SetModelingParameters (pMP);
578 SetModel (pModel); // Store for use by derived class.
579 pModel -> DescribeYourselfTo (*this);
580 pModel -> SetModelingParameters (0);
581 }
582
583 // Repeat if required...
584 if (fSecondPassRequested) {
585 fSecondPass = true;
586 for (size_t i = 0; i < runDurationModelList.size (); i++) {
587 G4VModel* pModel = runDurationModelList[i];
588 pModel -> SetModelingParameters (pMP);
589 SetModel (pModel); // Store for use by derived class.
590 pModel -> DescribeYourselfTo (*this);
591 pModel -> SetModelingParameters (0);
592 }
593 fSecondPass = false;
594 fSecondPassRequested = false;
595 }
596
597 delete pMP;
598 EndModeling ();
599
600 }
601
602 fpViewer->FinishView(); // Flush streams and/or swap buffers.
603
604 fReadyForTransients = true;
605
606 // Refresh event from end-of-event model list.
607 // Allow only in Idle or GeomClosed state...
608 G4StateManager* stateManager = G4StateManager::GetStateManager();
609 G4ApplicationState state = stateManager->GetCurrentState();
610 if (state == G4State_Idle || state == G4State_GeomClosed) {
611
612 visManager->SetEventRefreshing(true);
613
614 if (visManager->GetRequestedEvent()) {
615 DrawEvent(visManager->GetRequestedEvent());
616
617 } else {
618
619 G4RunManager* runManager = G4RunManager::GetRunManager();
620 if (runManager) {
621 const G4Run* run = runManager->GetCurrentRun();
622 const std::vector<const G4Event*>* events =
623 run? run->GetEventVector(): 0;
624 size_t nKeptEvents = 0;
625 if (events) nKeptEvents = events->size();
626 if (nKeptEvents) {
627
628 if (fpScene->GetRefreshAtEndOfEvent()) {
629
630 if (verbosity >= G4VisManager::confirmations) {
631 G4cout << "Refreshing event..." << G4endl;
632 }
633 const G4Event* event = 0;
634 if (events && events->size()) event = events->back();
635 if (event) DrawEvent(event);
636
637 } else { // Accumulating events.
638
639 if (verbosity >= G4VisManager::confirmations) {
640 G4cout << "Refreshing events in run..." << G4endl;
641 }
642 for (size_t i = 0; i < nKeptEvents; ++i) {
643 const G4Event* event = (*events)[i];
644 if (event) DrawEvent(event);
645 }
646
647 if (!fpScene->GetRefreshAtEndOfRun()) {
648 if (verbosity >= G4VisManager::warnings) {
649 G4cout <<
650 "WARNING: Cannot refresh events accumulated over more"
651 "\n than one runs. Refreshed just the last run."
652 << G4endl;
653 }
654 }
655 }
656 }
657 }
658 }
659 visManager->SetEventRefreshing(false);
660 }
661
662 // Refresh end-of-run model list.
663 // Allow only in Idle or GeomClosed state...
664 if (state == G4State_Idle || state == G4State_GeomClosed) {
665 DrawEndOfRunModels();
666 }
667
668 fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
669#ifdef G4DEBUG_VIS_MANAGEMENT
670 printf("G4VSceneHandler::ProcessScene END\n");
671#endif
672}
673
674void G4VSceneHandler::DrawEvent(const G4Event* event)
675{
676 const std::vector<G4VModel*>& EOEModelList =
677 fpScene -> GetEndOfEventModelList ();
678 size_t nModels = EOEModelList.size();
679 if (nModels) {
680 G4ModelingParameters* pMP = CreateModelingParameters();
681 pMP->SetEvent(event);
682 for (size_t i = 0; i < nModels; i++) {
683 G4VModel* pModel = EOEModelList [i];
684 pModel -> SetModelingParameters(pMP);
685 SetModel (pModel);
686 pModel -> DescribeYourselfTo (*this);
687 pModel -> SetModelingParameters(0);
688 }
689 delete pMP;
690 SetModel (0);
691 }
692}
693
694void G4VSceneHandler::DrawEndOfRunModels()
695{
696 const std::vector<G4VModel*>& EORModelList =
697 fpScene -> GetEndOfRunModelList ();
698 size_t nModels = EORModelList.size();
699 if (nModels) {
700 G4ModelingParameters* pMP = CreateModelingParameters();
701 pMP->SetEvent(0);
702 for (size_t i = 0; i < nModels; i++) {
703 G4VModel* pModel = EORModelList [i];
704 pModel -> SetModelingParameters(pMP);
705 SetModel (pModel);
706 pModel -> DescribeYourselfTo (*this);
707 pModel -> SetModelingParameters(0);
708 }
709 delete pMP;
710 SetModel (0);
711 }
712}
713
714G4ModelingParameters* G4VSceneHandler::CreateModelingParameters ()
715{
716 // Create modeling parameters from View Parameters...
717 const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
718
719 // Convert drawing styles...
720 G4ModelingParameters::DrawingStyle modelDrawingStyle =
721 G4ModelingParameters::wf;
722 switch (vp.GetDrawingStyle ()) {
723 default:
724 case G4ViewParameters::wireframe:
725 modelDrawingStyle = G4ModelingParameters::wf;
726 break;
727 case G4ViewParameters::hlr:
728 modelDrawingStyle = G4ModelingParameters::hlr;
729 break;
730 case G4ViewParameters::hsr:
731 modelDrawingStyle = G4ModelingParameters::hsr;
732 break;
733 case G4ViewParameters::hlhsr:
734 modelDrawingStyle = G4ModelingParameters::hlhsr;
735 break;
736 }
737
738 // Decide if covered daughters are really to be culled...
739 G4bool reallyCullCovered =
740 vp.IsCullingCovered() // Culling daughters depends also on...
741 && !vp.IsSection () // Sections (DCUT) not requested.
742 && !vp.IsCutaway () // Cutaways not requested.
743 ;
744
745 G4ModelingParameters* pModelingParams = new G4ModelingParameters
746 (vp.GetDefaultVisAttributes (),
747 modelDrawingStyle,
748 vp.IsCulling (),
749 vp.IsCullingInvisible (),
750 vp.IsDensityCulling (),
751 vp.GetVisibleDensity (),
752 reallyCullCovered,
753 vp.GetNoOfSides ()
754 );
755
756 pModelingParams->SetWarning
757 (G4VisManager::GetInstance()->GetVerbosity() >= G4VisManager::warnings);
758
759 pModelingParams->SetExplodeFactor(vp.GetExplodeFactor());
760 pModelingParams->SetExplodeCentre(vp.GetExplodeCentre());
761
762 pModelingParams->SetSectionPolyhedron(CreateSectionPolyhedron());
763 pModelingParams->SetCutawayPolyhedron(CreateCutawayPolyhedron());
764 // The polyhedron objects are deleted in the modeling parameters destructor.
765
766 return pModelingParams;
767}
768
769const G4Polyhedron* G4VSceneHandler::CreateSectionPolyhedron()
770{
771 /* Disable for now. Boolean processor not up to it.
772 const G4ViewParameters& vp = fpViewer->GetViewParameters();
773 if (vp.IsSection () ) {
774 G4double radius = fpScene->GetExtent().GetExtentRadius();
775 G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
776 G4Box sectionBox("clipper",
777 safe, safe, 1.e-5 * radius); // Thin in z-plane.
778 G4Polyhedron* sectioner = sectionBox.CreatePolyhedron();
779 const G4Plane3D& s = vp.GetSectionPlane ();
780 G4double a = s.a();
781 G4double b = s.b();
782 G4double c = s.c();
783 G4double d = s.d();
784 G4Transform3D transform = G4TranslateZ3D(-d);
785 const G4Normal3D normal(a,b,c);
786 if (normal != G4Normal3D(0,0,1)) {
787 const G4double angle = std::acos(normal.dot(G4Normal3D(0,0,1)));
788 const G4Vector3D axis = G4Normal3D(0,0,1).cross(normal);
789 transform = G4Rotate3D(angle, axis) * transform;
790 }
791 sectioner->Transform(transform);
792 return sectioner;
793 } else {
794 return 0;
795 }
796 */
797 return 0;
798}
799
800const G4Polyhedron* G4VSceneHandler::CreateCutawayPolyhedron()
801{
802 return 0;
803}
804
805void G4VSceneHandler::LoadAtts(const G4Visible& visible, G4AttHolder* holder)
806{
807 // Load G4Atts from G4VisAttributes, if any...
808 const G4VisAttributes* va = visible.GetVisAttributes();
809 if (va) {
810 const std::map<G4String,G4AttDef>* vaDefs =
811 va->GetAttDefs();
812 if (vaDefs) {
813 holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
814 }
815 }
816
817 G4PhysicalVolumeModel* pPVModel =
818 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
819 if (pPVModel) {
820 // Load G4Atts from G4PhysicalVolumeModel...
821 const std::map<G4String,G4AttDef>* defs = pPVModel->GetAttDefs();
822 if (defs) {
823 holder->AddAtts(pPVModel->CreateCurrentAttValues(), defs);
824 }
825 }
826
827 G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
828 if (trajModel) {
829 // Load G4Atts from trajectory...
830 const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
831 const std::map<G4String,G4AttDef>* defs = traj->GetAttDefs();
832 if (defs) {
833 holder->AddAtts(traj->CreateAttValues(), defs);
834 }
835 G4int nPoints = traj->GetPointEntries();
836 for (G4int i = 0; i < nPoints; ++i) {
837 G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
838 const std::map<G4String,G4AttDef>* defs = trajPoint->GetAttDefs();
839 if (defs) {
840 holder->AddAtts(trajPoint->CreateAttValues(), defs);
841 }
842 }
843 }
844
845 G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
846 if (hitsModel) {
847 // Load G4Atts from hit...
848 const G4VHit* hit = hitsModel->GetCurrentHit();
849 const std::map<G4String,G4AttDef>* defs = hit->GetAttDefs();
850 if (defs) {
851 holder->AddAtts(hit->CreateAttValues(), defs);
852 }
853 }
854}
855
856const G4Colour& G4VSceneHandler::GetColour (const G4Visible& visible) {
857 // Colour is determined by the applicable vis attributes.
858 const G4Colour& colour = fpViewer ->
859 GetApplicableVisAttributes (visible.GetVisAttributes ()) -> GetColour ();
860 return colour;
861}
862
863const G4Colour& G4VSceneHandler::GetTextColour (const G4Text& text) {
864 const G4VisAttributes* pVA = text.GetVisAttributes ();
865 if (!pVA) {
866 pVA = fpViewer -> GetViewParameters (). GetDefaultTextVisAttributes ();
867 }
868 const G4Colour& colour = pVA -> GetColour ();
869 return colour;
870}
871
872G4double G4VSceneHandler::GetLineWidth(const G4VisAttributes* pVisAttribs)
873{
874 G4double lineWidth = pVisAttribs->GetLineWidth();
875 if (lineWidth < 1.) lineWidth = 1.;
876 lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
877 if (lineWidth < 1.) lineWidth = 1.;
878 return lineWidth;
879}
880
881G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
882(const G4VisAttributes* pVisAttribs) {
883 // Drawing style is normally determined by the view parameters, but
884 // it can be overriddden by the ForceDrawingStyle flag in the vis
885 // attributes.
886 G4ViewParameters::DrawingStyle style =
887 fpViewer->GetViewParameters().GetDrawingStyle();
888 if (pVisAttribs -> IsForceDrawingStyle ()) {
889 G4VisAttributes::ForcedDrawingStyle forcedStyle =
890 pVisAttribs -> GetForcedDrawingStyle ();
891 // This is complicated because if hidden line and surface removal
892 // has been requested we wish to preserve this sometimes.
893 switch (forcedStyle) {
894 case (G4VisAttributes::solid):
895 switch (style) {
896 case (G4ViewParameters::hlr):
897 style = G4ViewParameters::hlhsr;
898 break;
899 case (G4ViewParameters::wireframe):
900 style = G4ViewParameters::hsr;
901 break;
902 case (G4ViewParameters::hlhsr):
903 case (G4ViewParameters::hsr):
904 default:
905 break;
906 }
907 break;
908 case (G4VisAttributes::wireframe):
909 default:
910 // But if forced style is wireframe, do it, because one of its
911 // main uses is in displaying the consituent solids of a Boolean
912 // solid and their surfaces overlap with the resulting Booean
913 // solid, making a mess if hlr is specified.
914 style = G4ViewParameters::wireframe;
915 break;
916 }
917 }
918 return style;
919}
920
921G4bool G4VSceneHandler::GetAuxEdgeVisible (const G4VisAttributes* pVisAttribs) {
922 G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
923 if (pVisAttribs -> IsForceAuxEdgeVisible()) isAuxEdgeVisible = true;
924 return isAuxEdgeVisible;
925}
926
927G4double G4VSceneHandler::GetMarkerSize
928(const G4VMarker& marker,
929 G4VSceneHandler::MarkerSizeType& markerSizeType)
930{
931 G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
932 const G4VMarker& defaultMarker =
933 fpViewer -> GetViewParameters().GetDefaultMarker();
934 G4double size = userSpecified ?
935 marker.GetWorldSize() : defaultMarker.GetWorldSize();
936 if (size) {
937 // Draw in world coordinates.
938 markerSizeType = world;
939 }
940 else {
941 size = userSpecified ?
942 marker.GetScreenSize() : defaultMarker.GetScreenSize();
943 // Draw in screen coordinates.
944 markerSizeType = screen;
945 }
946 if (size <= 1.) size = 1.;
947 size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
948 if (size <= 1.) size = 1.;
949 return size;
950}
951
952G4int G4VSceneHandler::GetNoOfSides(const G4VisAttributes* pVisAttribs)
953{
954 // No. of sides (lines segments per circle) is normally determined
955 // by the view parameters, but it can be overriddden by the
956 // ForceLineSegmentsPerCircle in the vis attributes.
957 G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
958 if (pVisAttribs) {
959 if (pVisAttribs->IsForceLineSegmentsPerCircle())
960 lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
961 const G4int nSegmentsMin = 12;
962 if (lineSegmentsPerCircle < nSegmentsMin) {
963 lineSegmentsPerCircle = nSegmentsMin;
964 G4cout <<
965 "G4VSceneHandler::GetNoOfSides: attempt to set the"
966 "\nnumber of line segements per circle < " << nSegmentsMin
967 << "; forced to " << lineSegmentsPerCircle << G4endl;
968 }
969 }
970 return lineSegmentsPerCircle;
971}
972
973std::ostream& operator << (std::ostream& os, const G4VSceneHandler& s) {
974
975 os << "Scene handler " << s.fName << " has "
976 << s.fViewerList.size () << " viewer(s):";
977 for (size_t i = 0; i < s.fViewerList.size (); i++) {
978 os << "\n " << *(s.fViewerList [i]);
979 }
980
981 if (s.fpScene) {
982 os << "\n " << *s.fpScene;
983 }
984 else {
985 os << "\n This scene handler currently has no scene.";
986 }
987
988 return os;
989}
Note: See TracBrowser for help on using the repository browser.