Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4OpenInventorSceneHandler.cc
Go to the documentation of this file.
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//
28//
29// Jeff Kallenbach 01 Aug 1996
30// OpenInventor stored scene - creates OpenInventor display lists.
31
32// this :
34
35#include <Inventor/SoPath.h>
36#include <Inventor/SoNodeKitPath.h>
37#include <Inventor/nodes/SoCoordinate3.h>
38#include <Inventor/nodes/SoCoordinate4.h>
39#include <Inventor/nodes/SoSeparator.h>
40#include <Inventor/nodes/SoDrawStyle.h>
41#include <Inventor/nodes/SoLightModel.h>
42#include <Inventor/nodes/SoMaterial.h>
43#include <Inventor/nodes/SoLineSet.h>
44#include <Inventor/nodes/SoCube.h>
45#include <Inventor/nodes/SoFont.h>
46#include <Inventor/nodes/SoText2.h>
47#include <Inventor/nodes/SoFaceSet.h>
48#include <Inventor/nodes/SoNormal.h>
49#include <Inventor/nodes/SoNormalBinding.h>
50#include <Inventor/nodes/SoComplexity.h>
51#include <Inventor/nodes/SoTranslation.h>
52#include <Inventor/nodes/SoTransform.h>
53#include <Inventor/nodes/SoResetTransform.h>
54#include <Inventor/nodes/SoMatrixTransform.h>
55
56#define USE_SOPOLYHEDRON
57
58#ifndef USE_SOPOLYHEDRON
59#include "HEPVis/nodes/SoBox.h"
60#include "HEPVis/nodes/SoTubs.h"
61#include "HEPVis/nodes/SoCons.h"
62#include "HEPVis/nodes/SoTrd.h"
63#include "HEPVis/nodes/SoTrap.h"
64#endif
66
68
71
72#include "SoG4Polyhedron.h"
73#include "SoG4LineSet.h"
74#include "SoG4MarkerSet.h"
75
76#include "G4Scene.hh"
77#include "G4OpenInventor.hh"
79#include "G4ThreeVector.hh"
80#include "G4Point3D.hh"
81#include "G4Normal3D.hh"
82#include "G4Transform3D.hh"
83#include "G4Polyline.hh"
84#include "G4Text.hh"
85#include "G4Circle.hh"
86#include "G4Square.hh"
87#include "G4Polymarker.hh"
88#include "G4Polyhedron.hh"
89#include "G4Box.hh"
90#include "G4Tubs.hh"
91#include "G4Cons.hh"
92#include "G4Trap.hh"
93#include "G4Trd.hh"
95#include "G4VPhysicalVolume.hh"
96#include "G4LogicalVolume.hh"
97#include "G4Material.hh"
98#include "G4VisAttributes.hh"
99
100#define G4warn G4cout
101
102G4int G4OpenInventorSceneHandler::fSceneIdCount = 0;
103
105 const G4String& name)
106:G4VSceneHandler (system, fSceneIdCount++, name)
107,fRoot(0)
108,fDetectorRoot(0)
109,fTransientRoot(0)
110,fCurrentSeparator(0)
111,fModelingSolid(false)
112,fReducedWireFrame(true)
113,fStyleCache(0)
114,fPreviewAndFull(true)
115{
116 fStyleCache = new SoStyleCache;
117 fStyleCache->ref();
118
119 fRoot = new SoSeparator;
120 fRoot->ref();
121 fRoot->setName("Root");
122
123 fDetectorRoot = new SoSeparator;
124 fDetectorRoot->setName("StaticRoot");
125 fRoot->addChild(fDetectorRoot);
126
127 fTransientRoot = new SoSeparator;
128 fTransientRoot->setName("TransientRoot");
129 fRoot->addChild(fTransientRoot);
130
131 fCurrentSeparator = fTransientRoot;
132}
133
135{
136 fRoot->unref();
137 fStyleCache->unref();
138}
139
141{
142 fDetectorRoot->removeAllChildren();
143 fSeparatorMap.clear();
144
145 fTransientRoot->removeAllChildren();
146}
147
149{
150 fTransientRoot->removeAllChildren();
151}
152
153//
154// Generates prerequisites for solids
155//
157(const G4Transform3D& objectTransformation,
158 const G4VisAttributes& visAttribs)
159{
160 G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
161 // Stores arguments away for future use, e.g., AddPrimitives.
162
163 GeneratePrerequisites();
164}
165
166//
167// Generates prerequisites for primitives
168//
170(const G4Transform3D& objectTransformation) {
171
172 G4VSceneHandler::BeginPrimitives (objectTransformation);
173
174 // If thread of control has already passed through PreAddSolid,
175 // avoid opening a graphical data base component again.
176 if (!fProcessingSolid) {
177 GeneratePrerequisites();
178 }
179}
180
181//
182// Method for handling G4Polyline objects (from tracking).
183//
185{
186 if (fProcessing2D) {
187 static G4bool warned = false;
188 if (!warned) {
189 warned = true;
191 ("G4OpenInventorSceneHandler::AddPrimitive (const G4Polyline&)",
192 "OpenInventor-0001", JustWarning,
193 "2D polylines not implemented. Ignored.");
194 }
195 return;
196 }
197
198 // Get vis attributes - pick up defaults if none.
199 const G4VisAttributes* pVA =
200 fpViewer -> GetApplicableVisAttributes (line.GetVisAttributes ());
201
202 AddProperties(pVA); // Colour, etc.
203 AddTransform(); // Transformation
204
205 G4int nPoints = (G4int)line.size();
206 SbVec3f* pCoords = new SbVec3f[nPoints];
207
208 for (G4int iPoint = 0; iPoint < nPoints ; ++iPoint) {
209 pCoords[iPoint].setValue((G4float)line[iPoint].x(),
210 (G4float)line[iPoint].y(),
211 (G4float)line[iPoint].z());
212 }
213
214 //
215 // Point Set
216 //
217 SoCoordinate3 *polyCoords = new SoCoordinate3;
218 polyCoords->point.setValues(0,nPoints,pCoords);
219 fCurrentSeparator->addChild(polyCoords);
220
221 //
222 // Wireframe
223 //
224 SoDrawStyle* drawStyle = fStyleCache->getLineStyle();
225 fCurrentSeparator->addChild(drawStyle);
226
227 SoG4LineSet *pLine = new SoG4LineSet;
228
229 // Loads G4Atts for picking...
230 if (fpViewer->GetViewParameters().IsPicking()) LoadAtts(line, pLine);
231
232#ifdef INVENTOR2_0
233 pLine->numVertices.setValues(0,1,(const G4long *)&nPoints);
234#else
235 pLine->numVertices.setValues(0,1,&nPoints);
236#endif
237
238 fCurrentSeparator->addChild(pLine);
239
240 delete [] pCoords;
241}
242
244{
245 if (fProcessing2D) {
246 static G4bool warned = false;
247 if (!warned) {
248 warned = true;
250 ("G4OpenInventorSceneHandler::AddPrimitive (const G4Polymarker&)",
251 "OpenInventor-0002", JustWarning,
252 "2D polymarkers not implemented. Ignored.");
253 }
254 return;
255 }
256
257 // Get vis attributes - pick up defaults if none.
258 const G4VisAttributes* pVA =
259 fpViewer -> GetApplicableVisAttributes (polymarker.GetVisAttributes ());
260
261 AddProperties(pVA); // Colour, etc.
262 AddTransform(); // Transformation
263
264 G4int pointn = (G4int)polymarker.size();
265 if(pointn<=0) return;
266
267 SbVec3f* points = new SbVec3f[pointn];
268 for (G4int iPoint = 0; iPoint < pointn ; ++iPoint) {
269 points[iPoint].setValue((G4float)polymarker[iPoint].x(),
270 (G4float)polymarker[iPoint].y(),
271 (G4float)polymarker[iPoint].z());
272 }
273
274 SoCoordinate3* coordinate3 = new SoCoordinate3;
275 coordinate3->point.setValues(0,pointn,points);
276 fCurrentSeparator->addChild(coordinate3);
277
278 MarkerSizeType sizeType;
279 G4double screenSize = GetMarkerSize (polymarker, sizeType);
280 switch (sizeType) {
281 default:
282 case screen:
283 // Draw in screen coordinates. OK.
284 break;
285 case world:
286 // Draw in world coordinates. Not implemented. Use screenSize = 10.
287 screenSize = 10.;
288 break;
289 }
290
291 SoG4MarkerSet* markerSet = new SoG4MarkerSet;
292 markerSet->numPoints = pointn;
293
294 // Loads G4Atts for picking...
296 LoadAtts(polymarker, markerSet);
297
298 G4VMarker::FillStyle style = polymarker.GetFillStyle();
299 switch (polymarker.GetMarkerType()) {
300 default:
301 // Are available 5_5, 7_7 and 9_9
303 if (screenSize <= 5.) {
305 } else if (screenSize <= 7.) {
307 } else {
309 }
310 break;
312 if (screenSize <= 5.) {
313 if (style == G4VMarker::filled) {
315 } else {
317 }
318 } else if (screenSize <= 7.) {
319 if (style == G4VMarker::filled) {
321 } else {
323 }
324 } else {
325 if (style == G4VMarker::filled) {
327 } else {
329 }
330 }
331 break;
333 if (screenSize <= 5.) {
334 if (style == G4VMarker::filled) {
336 } else {
338 }
339 } else if (screenSize <= 7.) {
340 if (style == G4VMarker::filled) {
342 } else {
344 }
345 } else {
346 if (style == G4VMarker::filled) {
348 } else {
350 }
351 }
352 }
353 fCurrentSeparator->addChild(markerSet);
354
355 delete [] points;
356}
357
358// Method for handling G4Text objects
359//
361{
362 if (fProcessing2D) {
363 static G4bool warned = false;
364 if (!warned) {
365 warned = true;
367 ("G4OpenInventorSceneHandler::AddPrimitive (const G4Text&)",
368 "OpenInventor-0003", JustWarning,
369 "2D text not implemented. Ignored.");
370 }
371 return;
372 }
373
374 AddProperties(text.GetVisAttributes()); // Colour, etc.
375 AddTransform(text.GetPosition()); // Transformation
376
377 //
378 // Color. Note: text colour is worked out differently. This
379 // over-rides the colour added in AddProperties...
380 //
381 const G4Colour& c = GetTextColour (text);
382 SoMaterial* material =
383 fStyleCache->getMaterial((G4float)c.GetRed(),
384 (G4float)c.GetGreen(),
385 (G4float)c.GetBlue(),
386 (G4float)(1-c.GetAlpha()));
387 fCurrentSeparator->addChild(material);
388
389 MarkerSizeType sizeType;
390 G4double size = GetMarkerSize (text, sizeType);
391 switch (sizeType) {
392 default:
393 case screen:
394 // Draw in screen coordinates. OK.
395 break;
396 case world:
397 // Draw in world coordinates. Not implemented. Use size = 20.
398 size = 20.;
399 break;
400 }
401
402 //
403 // Font
404 //
405 SoFont *g4Font = new SoFont();
406 g4Font->size = size;
407 fCurrentSeparator->addChild(g4Font);
408
409 //
410 // Text
411 //
412 SoText2 *g4String = new SoText2();
413 g4String->string.setValue(text.GetText());
414 g4String->spacing = 2.0;
415 switch (text.GetLayout()) {
416 default:
417 case G4Text::left:
418 g4String->justification = SoText2::LEFT; break;
419 case G4Text::centre:
420 g4String->justification = SoText2::CENTER; break;
421 case G4Text::right:
422 g4String->justification = SoText2::RIGHT; break;
423 }
424 fCurrentSeparator->addChild(g4String);
425}
426
427//
428// Method for handling G4Circle objects
429//
431 AddCircleSquare(G4OICircle, circle);
432}
433
434//
435// Method for handling G4Square objects - defaults to wireframe
436//
438 AddCircleSquare(G4OISquare, square);
439}
440
441void G4OpenInventorSceneHandler::AddCircleSquare
442(G4OIMarker markerType, const G4VMarker& marker)
443{
444 if (fProcessing2D) {
445 static G4bool warned = false;
446 if (!warned) {
447 warned = true;
449 ("G4OpenInventorSceneHandler::AddCircleSquare",
450 "OpenInventor-0004", JustWarning,
451 "2D circles and squares not implemented. Ignored.");
452 }
453 return;
454 }
455
456 // Get vis attributes - pick up defaults if none.
457 const G4VisAttributes* pVA =
458 fpViewer -> GetApplicableVisAttributes (marker.GetVisAttributes ());
459
460 AddProperties(pVA); // Colour, etc.
461 AddTransform(); // Transformation
462
463 MarkerSizeType sizeType;
464 G4double screenSize = GetMarkerSize (marker, sizeType);
465 switch (sizeType) {
466 default:
467 case screen:
468 // Draw in screen coordinates. OK.
469 break;
470 case world:
471 // Draw in world coordinates. Not implemented. Use size = 10.
472 screenSize = 10.;
473 break;
474 }
475
476 G4Point3D centre = marker.GetPosition();
477
478 // Borrowed from AddPrimitive(G4Polymarker) - inefficient? JA
479 SbVec3f* points = new SbVec3f[1];
480 points[0].setValue((G4float)centre.x(),
481 (G4float)centre.y(),
482 (G4float)centre.z());
483 SoCoordinate3* coordinate3 = new SoCoordinate3;
484 coordinate3->point.setValues(0,1,points);
485 fCurrentSeparator->addChild(coordinate3);
486
487 SoG4MarkerSet* markerSet = new SoG4MarkerSet;
488 markerSet->numPoints = 1;
489
490 // Loads G4Atts for picking...
491 if (fpViewer->GetViewParameters().IsPicking()) LoadAtts(marker, markerSet);
492
493 G4VMarker::FillStyle style = marker.GetFillStyle();
494 switch (markerType) {
495 case G4OICircle:
496 if (screenSize <= 5.) {
497 if (style == G4VMarker::filled) {
499 } else {
501 }
502 } else if (screenSize <= 7.) {
503 if (style == G4VMarker::filled) {
505 } else {
507 }
508 } else {
509 if (style == G4VMarker::filled) {
511 } else {
513 }
514 }
515 break;
516 case G4OISquare:
517 if (screenSize <= 5.) {
518 if (style == G4VMarker::filled) {
520 } else {
522 }
523 } else if (screenSize <= 7.) {
524 if (style == G4VMarker::filled) {
526 } else {
528 }
529 } else {
530 if (style == G4VMarker::filled) {
532 } else {
534 }
535 }
536 break;
537 }
538 fCurrentSeparator->addChild(markerSet);
539
540 delete [] points;
541}
542
543//
544// Method for handling G4Polyhedron objects for drawing solids.
545//
547{
548 if (polyhedron.GetNoFacets() == 0) return;
549
550 if (fProcessing2D) {
551 static G4bool warned = false;
552 if (!warned) {
553 warned = true;
555 ("G4OpenInventorSceneHandler::AddPrimitive (const G4Polyhedron&)",
556 "OpenInventor-0005", JustWarning,
557 "2D polyhedra not implemented. Ignored.");
558 }
559 return;
560 }
561
562 // Get vis attributes - pick up defaults if none.
563 const G4VisAttributes* pVA =
564 fpViewer -> GetApplicableVisAttributes (polyhedron.GetVisAttributes ());
565
566 AddProperties(pVA); // Colour, etc.
567 AddTransform(); // Transformation
568
569 SoG4Polyhedron* soPolyhedron = new SoG4Polyhedron(polyhedron);
570
571 // Loads G4Atts for picking...
573 LoadAtts(polyhedron, soPolyhedron);
574
575 SbString name = "Non-geometry";
576 G4PhysicalVolumeModel* pPVModel =
577 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
578 if (pPVModel) {
579 name = pPVModel->GetCurrentLV()->GetName().c_str();
580 }
581 SbName sbName(name);
582 soPolyhedron->setName(sbName);
583 soPolyhedron->solid.setValue(fModelingSolid);
584 soPolyhedron->reducedWireFrame.setValue(fReducedWireFrame?TRUE:FALSE);
585 fCurrentSeparator->addChild(soPolyhedron);
586}
587
590}
591
592void G4OpenInventorSceneHandler::GeneratePrerequisites()
593{
594 // Utility for PreAddSolid and BeginPrimitives.
595
596 // This routines prepares for adding items to the scene database. We
597 // are expecting two kinds of solids: leaf parts and non-leaf parts.
598 // For non-leaf parts, we create a detector tree kit. This has two
599 // separators. The solid itself goes in the preview separator, the
600 // full separator is forseen for daughters. This separator is not
601 // only created--it is also put in a dictionary for future use by
602 // the leaf part.
603
604 // For leaf parts, we first locate the mother volume and find its
605 // separator through the dictionary.
606
607 // The private member fCurrentSeparator is set to the proper
608 // location on in the scene database so that when the solid is
609 // actually added (in addthis), it is put in the right place.
610
611 G4PhysicalVolumeModel* pPVModel =
612 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
613
614 if (pPVModel) {
615
616 // This call comes from a G4PhysicalVolumeModel. drawnPVPath is
617 // the path of the current drawn (non-culled) volume in terms of
618 // drawn (non-culled) ancestors. Each node is identified by a
619 // PVNodeID object, which is a physical volume and copy number. It
620 // is a vector of PVNodeIDs corresponding to the geometry hierarchy
621 // actually selected, i.e., not culled.
623 using PVPath = std::vector<PVNodeID>;
624 const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
625 //G4int currentDepth = pPVModel->GetCurrentDepth();
626 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
627 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
628 //G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
629 // Note: pCurrentMaterial may be zero (parallel world).
630
631 // The simplest algorithm, used by the Open Inventor Driver
632 // developers, is to rely on the fact the G4PhysicalVolumeModel
633 // traverses the geometry hierarchy in an orderly manner. The last
634 // mother, if any, will be the node to which the volume should be
635 // added. So it is enough to keep a map of scene graph nodes keyed
636 // on the volume path ID. Actually, it is enough to use the logical
637 // volume as the key. (An alternative would be to keep the PVNodeID
638 // in the tree and match the PVPath from the root down.)
639
640 // Find mother. ri points to mother, if any...
641 PVPath::const_reverse_iterator ri;
642 G4LogicalVolume* MotherVolume = 0;
643 ri = ++drawnPVPath.rbegin();
644 if (ri != drawnPVPath.rend()) {
645 // This volume has a mother.
646 MotherVolume = ri->GetPhysicalVolume()->GetLogicalVolume();
647 }
648
649 if (pCurrentLV->GetNoDaughters()!=0 ||
650 pCurrentPV->IsReplicated()) { //????Don't understand this???? JA
651 // This block of code is executed for non-leaf parts:
652
653 // Make the detector tree kit:
654 SoDetectorTreeKit* detectorTreeKit = new SoDetectorTreeKit();
655
656 SoSeparator* previewSeparator =
657 (SoSeparator*) detectorTreeKit->getPart("previewSeparator",TRUE);
658 previewSeparator->renderCaching = SoSeparator::OFF;
659
660 SoSeparator* fullSeparator =
661 (SoSeparator*) detectorTreeKit->getPart("fullSeparator", TRUE);
662 fullSeparator->renderCaching = SoSeparator::OFF;
663
664 if(fPreviewAndFull) detectorTreeKit->setPreviewAndFull();
665 else detectorTreeKit->setPreview(TRUE);
666
667 // Colour, etc., for SoDetectorTreeKit. Treated differently to
668 // othere SoNodes(?). Use fpVisAttribs stored away in
669 // PreAddSolid...
670 const G4VisAttributes* pApplicableVisAttribs =
672
673 // First find the color attributes...
674 const G4Colour& g4Col = pApplicableVisAttribs->GetColour ();
675 const G4double red = g4Col.GetRed ();
676 const G4double green = g4Col.GetGreen ();
677 const G4double blue = g4Col.GetBlue ();
678 G4double transparency = 1 - g4Col.GetAlpha();
679
680 // Drawing style...
681 G4ViewParameters::DrawingStyle drawing_style =
682 GetDrawingStyle(pApplicableVisAttribs);
683 switch (drawing_style) {
685 fModelingSolid = false;
686 break;
690 fModelingSolid = true;
691 break;
693 fModelingSolid = false;
694 break;
695 }
696
697 SoMaterial* material =
698 fStyleCache->getMaterial((G4float)red,
699 (G4float)green,
700 (G4float)blue,
701 (G4float)transparency);
702 detectorTreeKit->setPart("appearance.material",material);
703
704 SoLightModel* lightModel =
705 fModelingSolid ? fStyleCache->getLightModelPhong() :
706 fStyleCache->getLightModelBaseColor();
707 detectorTreeKit->setPart("appearance.lightModel",lightModel);
708
709 // Add the full separator to the dictionary; it is indexed by the
710 // address of the logical volume!
711 fSeparatorMap[pCurrentLV] = fullSeparator;
712
713 // Find out where to add this volume.
714 // If no mother can be found, it goes under root.
715 if (MotherVolume) {
716 if (fSeparatorMap.find(MotherVolume) != fSeparatorMap.end()) {
717 //printf("debug : PreAddSolid : mother %s found in map\n",
718 // MotherVolume->GetName().c_str());
719 fSeparatorMap[MotherVolume]->addChild(detectorTreeKit);
720 } else {
721 // Mother not previously encountered. Shouldn't happen, since
722 // G4PhysicalVolumeModel sends volumes as it encounters them,
723 // i.e., mothers before daughters, in its descent of the
724 // geometry tree. Error!
725 G4warn <<
726 "ERROR: G4OpenInventorSceneHandler::GeneratePrerequisites: Mother "
727 << ri->GetPhysicalVolume()->GetName()
728 << ':' << ri->GetCopyNo()
729 << " not previously encountered."
730 "\nShouldn't happen! Please report to visualization coordinator."
731 << G4endl;
732 // Continue anyway. Add to root of scene graph tree...
733 //printf("debug : PreAddSolid : mother %s not found in map !!!\n",
734 // MotherVolume->GetName().c_str());
735 fDetectorRoot->addChild(detectorTreeKit);
736 }
737 } else {
738 //printf("debug : PreAddSolid : has no mother\n");
739 fDetectorRoot->addChild(detectorTreeKit);
740 }
741
742 fCurrentSeparator = previewSeparator;
743
744 } else {
745 // This block of code is executed for leaf parts.
746
747 if (MotherVolume) {
748 if (fSeparatorMap.find(MotherVolume) != fSeparatorMap.end()) {
749 fCurrentSeparator = fSeparatorMap[MotherVolume];
750 } else {
751 // Mother not previously encountered. Shouldn't happen, since
752 // G4PhysicalVolumeModel sends volumes as it encounters them,
753 // i.e., mothers before daughters, in its descent of the
754 // geometry tree. Error!
755 G4warn << "ERROR: G4OpenInventorSceneHandler::PreAddSolid: Mother "
756 << ri->GetPhysicalVolume()->GetName()
757 << ':' << ri->GetCopyNo()
758 << " not previously encountered."
759 "\nShouldn't happen! Please report to visualization coordinator."
760 << G4endl;
761 // Continue anyway. Add to root of scene graph tree...
762 fCurrentSeparator = fDetectorRoot;
763 }
764 } else {
765 fCurrentSeparator = fDetectorRoot;
766 }
767 }
768
769 } else {
770 // Not from G4PhysicalVolumeModel, so add to root as leaf part...
771
773 fCurrentSeparator = fTransientRoot;
774 } else {
775 fCurrentSeparator = fDetectorRoot;
776 }
777 }
778}
779
780void G4OpenInventorSceneHandler::AddProperties(const G4VisAttributes* visAtts)
781{
782 // Use the applicable vis attributes...
783 const G4VisAttributes* pApplicableVisAttribs =
785
786 // First find the color attributes...
787 const G4Colour& g4Col = pApplicableVisAttribs->GetColour ();
788 const G4double red = g4Col.GetRed ();
789 const G4double green = g4Col.GetGreen ();
790 const G4double blue = g4Col.GetBlue ();
791 G4double transparency = 1 - g4Col.GetAlpha();
792
793 // Drawing style...
794 G4ViewParameters::DrawingStyle drawing_style =
795 GetDrawingStyle(pApplicableVisAttribs);
796 switch (drawing_style) {
798 fModelingSolid = false;
799 break;
803 fModelingSolid = true;
804 break;
806 fModelingSolid = false;
807 break;
808 }
809
810 // Edge visibility...
811 G4bool isAuxEdgeVisible = GetAuxEdgeVisible (pApplicableVisAttribs);
812 fReducedWireFrame = !isAuxEdgeVisible;
813
814 SoMaterial* material =
815 fStyleCache->getMaterial((G4float)red,
816 (G4float)green,
817 (G4float)blue,
818 (G4float)transparency);
819 fCurrentSeparator->addChild(material);
820
821 SoLightModel* lightModel =
822 fModelingSolid ? fStyleCache->getLightModelPhong() :
823 fStyleCache->getLightModelBaseColor();
824 fCurrentSeparator->addChild(lightModel);
825}
826
827void G4OpenInventorSceneHandler::AddTransform(const G4Point3D& translation)
828{
829 // AddTransform takes fObjectTransformation and "adds" a translation.
830 // Set up the geometrical transformation for the coming
831 fCurrentSeparator->addChild(fStyleCache->getResetTransform());
832
833 SoMatrixTransform* matrixTransform = new SoMatrixTransform;
835 (fObjectTransformation * G4Translate3D(translation));
836 SbMatrix* sbMatrix = oiTran.GetSbMatrix();
837
839 SbMatrix sbScale;
840 sbScale.setScale
841 (SbVec3f((G4float)scale.x(),(G4float)scale.y(),(G4float)scale.z()));
842 sbMatrix->multRight(sbScale);
843
844 matrixTransform->matrix.setValue(*sbMatrix);
845 delete sbMatrix;
846 fCurrentSeparator->addChild(matrixTransform);
847}
@ JustWarning
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
#define G4warn
Definition: G4Scene.cc:41
HepGeom::Translate3D G4Translate3D
float G4float
Definition: G4Types.hh:84
double G4double
Definition: G4Types.hh:83
long G4long
Definition: G4Types.hh:87
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
#define G4endl
Definition: G4ios.hh:57
#define SoDetectorTreeKit
#define HEPVis_SoMarkerSet
Definition: SoMarkerSet.h:33
#define SoStyleCache
Definition: SoStyleCache.h:41
G4double GetBlue() const
Definition: G4Colour.hh:154
G4double GetAlpha() const
Definition: G4Colour.hh:155
G4double GetRed() const
Definition: G4Colour.hh:152
G4double GetGreen() const
Definition: G4Colour.hh:153
std::size_t GetNoDaughters() const
const G4String & GetName() const
Definition: G4Mesh.hh:48
void AddPrimitive(const G4Polyline &line)
void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)
G4OpenInventorSceneHandler(G4OpenInventor &system, const G4String &name="")
void BeginPrimitives(const G4Transform3D &objectTransformation)
const std::vector< G4PhysicalVolumeNodeID > & GetDrawnPVPath() const
G4VPhysicalVolume * GetCurrentPV() const
G4LogicalVolume * GetCurrentLV() const
MarkerType GetMarkerType() const
Definition: G4Text.hh:72
Layout GetLayout() const
G4String GetText() const
@ centre
Definition: G4Text.hh:76
@ right
Definition: G4Text.hh:76
@ left
Definition: G4Text.hh:76
FillStyle GetFillStyle() const
G4Point3D GetPosition() const
virtual G4bool IsReplicated() const =0
void LoadAtts(const G4Visible &, G4AttHolder *)
const G4Colour & GetTextColour(const G4Text &)
G4Transform3D fObjectTransformation
G4double GetMarkerSize(const G4VMarker &, MarkerSizeType &)
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)
G4VViewer * fpViewer
const G4VisAttributes * fpVisAttribs
G4ViewParameters::DrawingStyle GetDrawingStyle(const G4VisAttributes *)
virtual void BeginPrimitives(const G4Transform3D &objectTransformation=G4Transform3D())
G4bool GetAuxEdgeVisible(const G4VisAttributes *)
void StandardSpecialMeshRendering(const G4Mesh &)
const G4VisAttributes * GetApplicableVisAttributes(const G4VisAttributes *) const
const G4ViewParameters & GetViewParameters() const
const G4Vector3D & GetScaleFactor() const
G4bool IsPicking() const
const G4Colour & GetColour() const
const G4VisAttributes * GetVisAttributes() const
SoMFInt32 markerIndex
Definition: SoMarkerSet.h:38
G4int GetNoFacets() const
virtual void setPreview(SbBool Flag)
#define TRUE
Definition: globals.hh:41
#define FALSE
Definition: globals.hh:38