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