source: trunk/source/visualization/OpenInventor/src/G4OpenInventorSceneHandler.cc@ 1346

Last change on this file since 1346 was 1337, checked in by garnier, 15 years ago

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