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