source: trunk/geant4/visualization/OpenInventor/src/G4OpenInventorSceneHandler.cc@ 597

Last change on this file since 597 was 593, checked in by garnier, 18 years ago

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