Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/OpenInventor/src/G4OpenInventorSceneHandler.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/OpenInventor/src/G4OpenInventorSceneHandler.cc (Version 11.3.0) and /visualization/OpenInventor/src/G4OpenInventorSceneHandler.cc (Version 9.2.p1)


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