[529] | 1 | // |
---|
| 2 | // ******************************************************************** |
---|
| 3 | // * License and Disclaimer * |
---|
| 4 | // * * |
---|
| 5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
| 6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
| 7 | // * conditions of the Geant4 Software License, included in the file * |
---|
| 8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
| 9 | // * include a list of copyright holders. * |
---|
| 10 | // * * |
---|
| 11 | // * Neither the authors of this software system, nor their employing * |
---|
| 12 | // * institutes,nor the agencies providing financial support for this * |
---|
| 13 | // * work make any representation or warranty, express or implied, * |
---|
| 14 | // * regarding this software system or assume any liability for its * |
---|
| 15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
| 16 | // * for the full disclaimer and the limitation of liability. * |
---|
| 17 | // * * |
---|
| 18 | // * This code implementation is the result of the scientific and * |
---|
| 19 | // * technical work of the GEANT4 collaboration. * |
---|
| 20 | // * By using, copying, modifying or distributing the software (or * |
---|
| 21 | // * any work based on the software) you agree to acknowledge its * |
---|
| 22 | // * use in resulting scientific publications, and indicate your * |
---|
| 23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
| 24 | // ******************************************************************** |
---|
| 25 | // |
---|
| 26 | // $Id: G4OpenInventorViewer.cc,v 1.57 2006/11/01 11:06:07 allison Exp $ |
---|
| 27 | // GEANT4 tag $Name: geant4-08-02-patch-01 $ |
---|
| 28 | |
---|
| 29 | #ifdef G4VIS_BUILD_OI_DRIVER |
---|
| 30 | |
---|
| 31 | // this : |
---|
| 32 | #include "G4OpenInventorViewer.hh" |
---|
| 33 | |
---|
| 34 | #include <Inventor/nodes/SoSelection.h> |
---|
| 35 | #include <Inventor/nodes/SoShape.h> |
---|
| 36 | #include <Inventor/nodes/SoOrthographicCamera.h> |
---|
| 37 | #include <Inventor/nodes/SoPerspectiveCamera.h> |
---|
| 38 | #include <Inventor/actions/SoCallbackAction.h> |
---|
| 39 | #include <Inventor/actions/SoWriteAction.h> |
---|
| 40 | #include <Inventor/sensors/SoNodeSensor.h> |
---|
| 41 | |
---|
| 42 | #include "HEPVis/nodes/SoImageWriter.h" |
---|
| 43 | #include "HEPVis/actions/SoGL2PSAction.h" |
---|
| 44 | #include "HEPVis/actions/SoCounterAction.h" |
---|
| 45 | #include "HEPVis/actions/SoAlternateRepAction.h" |
---|
| 46 | |
---|
| 47 | #include "G4OpenInventor.hh" |
---|
| 48 | #include "G4OpenInventorSceneHandler.hh" |
---|
| 49 | #include "G4VInteractorManager.hh" |
---|
| 50 | #include "G4Scene.hh" |
---|
| 51 | #include "Geant4_SoPolyhedron.h" |
---|
| 52 | #include "G4AttValue.hh" |
---|
| 53 | #include "G4AttDef.hh" |
---|
| 54 | #include "G4AttCheck.hh" |
---|
| 55 | #include "G4AttHolder.hh" |
---|
| 56 | |
---|
| 57 | G4OpenInventorViewer::G4OpenInventorViewer( |
---|
| 58 | G4OpenInventorSceneHandler& sceneHandler |
---|
| 59 | ,const G4String& name) |
---|
| 60 | :G4VViewer(sceneHandler, sceneHandler.IncrementViewCount(), name) |
---|
| 61 | ,fG4OpenInventorSceneHandler(sceneHandler) |
---|
| 62 | ,fInteractorManager(0) |
---|
| 63 | ,fSoSelection(0) |
---|
| 64 | ,fSoImageWriter(0) |
---|
| 65 | ,fGL2PSAction(0) //To be set be suclass. |
---|
| 66 | ,fGroupCameraSensor(0) |
---|
| 67 | ,fCameraSensor(0) |
---|
| 68 | { |
---|
| 69 | fNeedKernelVisit = true; //?? Temporary, until KernelVisitDecision fixed. |
---|
| 70 | |
---|
| 71 | fDefaultVP.SetAutoRefresh(true); |
---|
| 72 | fVP.SetAutoRefresh(true); |
---|
| 73 | |
---|
| 74 | //FIXME : G.Barrand : not convinced that we have to rm culling. |
---|
| 75 | // For viewing of all objects by default : |
---|
| 76 | //fDefaultVP.SetCulling(false); |
---|
| 77 | //fVP.SetCulling(false); |
---|
| 78 | |
---|
| 79 | fInteractorManager = |
---|
| 80 | ((G4OpenInventor*)fG4OpenInventorSceneHandler.GetGraphicsSystem())-> |
---|
| 81 | GetInteractorManager(); |
---|
| 82 | |
---|
| 83 | // Main user scene graph root sent to the viewers. |
---|
| 84 | fSoSelection = new SoSelection; |
---|
| 85 | fSoSelection->ref(); |
---|
| 86 | fSoSelection->addSelectionCallback(SelectionCB,this); |
---|
| 87 | //fSoSelection->addDeselectionCallback(DeselectionCB,this); |
---|
| 88 | fSoSelection->policy = SoSelection::SINGLE; |
---|
| 89 | |
---|
| 90 | SoGroup* group = new SoGroup; |
---|
| 91 | fSoSelection->addChild(group); |
---|
| 92 | |
---|
| 93 | // Have a camera under fSoSelection in order |
---|
| 94 | // that the below SceneGraphSensor be notifed |
---|
| 95 | // when the viewer changes the camera type. |
---|
| 96 | // But we put the camera under a SoGroup so that |
---|
| 97 | // the SceneGraphSensor be not triggered at each change |
---|
| 98 | // under the fG4OpenInventorSceneHandler.fRoot. |
---|
| 99 | SoOrthographicCamera* camera = new SoOrthographicCamera; |
---|
| 100 | camera->viewportMapping.setValue(SoCamera::ADJUST_CAMERA); |
---|
| 101 | //camera->aspectRatio.setValue(10); |
---|
| 102 | camera->position.setValue(0,0,10); |
---|
| 103 | camera->orientation.setValue(SbRotation(SbVec3f(0,1,0),0)); |
---|
| 104 | camera->height.setValue(10); |
---|
| 105 | camera->nearDistance.setValue(1); |
---|
| 106 | camera->farDistance.setValue(100); |
---|
| 107 | camera->focalDistance.setValue(10); |
---|
| 108 | group->addChild(camera); |
---|
| 109 | |
---|
| 110 | {SoInput soInput; |
---|
| 111 | if(soInput.openFile("g4view.iv",TRUE)) { |
---|
| 112 | SoSeparator* separator = SoDB::readAll(&soInput); |
---|
| 113 | if(separator) fSoSelection->addChild(separator); |
---|
| 114 | }} |
---|
| 115 | |
---|
| 116 | fSoSelection->addChild(fG4OpenInventorSceneHandler.fRoot); |
---|
| 117 | |
---|
| 118 | // SoImageWriter should be the last. |
---|
| 119 | fSoImageWriter = new SoImageWriter(); |
---|
| 120 | fSoImageWriter->fileName.setValue("g4out.ps"); |
---|
| 121 | fSoSelection->addChild(fSoImageWriter); |
---|
| 122 | |
---|
| 123 | // Sensors : |
---|
| 124 | // To detect that the viewer had changed the camera type : |
---|
| 125 | fGroupCameraSensor = new SoNodeSensor(GroupCameraSensorCB,this); |
---|
| 126 | fGroupCameraSensor->setPriority(0);//Needed in order to do getTriggerNode() |
---|
| 127 | fGroupCameraSensor->attach(group); |
---|
| 128 | |
---|
| 129 | fCameraSensor = new SoNodeSensor(CameraSensorCB,this); |
---|
| 130 | fCameraSensor->setPriority(0);//Needed in order to do getTriggerNode() |
---|
| 131 | } |
---|
| 132 | |
---|
| 133 | G4OpenInventorViewer::~G4OpenInventorViewer () { |
---|
| 134 | fCameraSensor->detach(); |
---|
| 135 | delete fCameraSensor; |
---|
| 136 | fGroupCameraSensor->detach(); |
---|
| 137 | delete fGroupCameraSensor; |
---|
| 138 | fSoSelection->unref(); |
---|
| 139 | } |
---|
| 140 | |
---|
| 141 | void G4OpenInventorViewer::KernelVisitDecision () { |
---|
| 142 | |
---|
| 143 | // If there's a significant difference with the last view parameters |
---|
| 144 | // of either the scene handler or this viewer, trigger a rebuild. |
---|
| 145 | |
---|
| 146 | if ( |
---|
| 147 | //??fG4OpenInventorSceneHandler.fPODLList.size() == 0 || |
---|
| 148 | // We need a test for empty scene graph, such as |
---|
| 149 | // staticRoot.size() or something?????????? See temporary fix |
---|
| 150 | // in contructor. (John Allison Aug 2001) |
---|
| 151 | CompareForKernelVisit(fLastVP)) { |
---|
| 152 | NeedKernelVisit (); |
---|
| 153 | } |
---|
| 154 | fLastVP = fVP; |
---|
| 155 | } |
---|
| 156 | |
---|
| 157 | G4bool G4OpenInventorViewer::CompareForKernelVisit(G4ViewParameters& vp) { |
---|
| 158 | |
---|
| 159 | if ( |
---|
| 160 | (vp.GetDrawingStyle () != fVP.GetDrawingStyle ()) || |
---|
| 161 | (vp.IsAuxEdgeVisible () != fVP.IsAuxEdgeVisible ()) || |
---|
| 162 | (vp.GetRepStyle () != fVP.GetRepStyle ()) || |
---|
| 163 | (vp.IsCulling () != fVP.IsCulling ()) || |
---|
| 164 | (vp.IsCullingInvisible () != fVP.IsCullingInvisible ()) || |
---|
| 165 | (vp.IsDensityCulling () != fVP.IsDensityCulling ()) || |
---|
| 166 | (vp.IsCullingCovered () != fVP.IsCullingCovered ()) || |
---|
| 167 | (vp.IsSection () != fVP.IsSection ()) || |
---|
| 168 | (vp.IsCutaway () != fVP.IsCutaway ()) || |
---|
| 169 | // This assumes use of generic clipping (sectioning, slicing, |
---|
| 170 | // DCUT, cutaway). If a decision is made to implement locally, |
---|
| 171 | // this will need changing. See G4OpenGLViewer::SetView, |
---|
| 172 | // G4OpenGLStoredViewer.cc::CompareForKernelVisit and |
---|
| 173 | // G4OpenGLStoredSceneHander::CreateSection/CutawayPolyhedron. |
---|
| 174 | (vp.IsExplode () != fVP.IsExplode ()) || |
---|
| 175 | (vp.GetNoOfSides () != fVP.GetNoOfSides ()) || |
---|
| 176 | (vp.IsMarkerNotHidden () != fVP.IsMarkerNotHidden ()) || |
---|
| 177 | (vp.GetBackgroundColour ()!= fVP.GetBackgroundColour ()) |
---|
| 178 | ) { |
---|
| 179 | return true;; |
---|
| 180 | } |
---|
| 181 | if (vp.IsDensityCulling () && |
---|
| 182 | (vp.GetVisibleDensity () != fVP.GetVisibleDensity ())) |
---|
| 183 | return true; |
---|
| 184 | |
---|
| 185 | if (vp.IsSection () && |
---|
| 186 | (vp.GetSectionPlane () != fVP.GetSectionPlane ())) |
---|
| 187 | return true; |
---|
| 188 | |
---|
| 189 | if (vp.IsCutaway ()) { |
---|
| 190 | if (vp.GetCutawayPlanes ().size () != |
---|
| 191 | fVP.GetCutawayPlanes ().size ()) return true; |
---|
| 192 | for (size_t i = 0; i < vp.GetCutawayPlanes().size(); ++i) |
---|
| 193 | if (vp.GetCutawayPlanes()[i] != fVP.GetCutawayPlanes()[i]) |
---|
| 194 | return true; |
---|
| 195 | } |
---|
| 196 | |
---|
| 197 | if (vp.IsExplode () && |
---|
| 198 | (vp.GetExplodeFactor () != fVP.GetExplodeFactor ())) |
---|
| 199 | return true; |
---|
| 200 | |
---|
| 201 | return false; |
---|
| 202 | } |
---|
| 203 | |
---|
| 204 | void G4OpenInventorViewer::ClearView () { |
---|
| 205 | } |
---|
| 206 | |
---|
| 207 | void G4OpenInventorViewer::SetView () { |
---|
| 208 | |
---|
| 209 | // Get G4 camera infos : |
---|
| 210 | const G4Point3D target |
---|
| 211 | = fSceneHandler.GetScene()->GetStandardTargetPoint() |
---|
| 212 | + fVP.GetCurrentTargetPoint (); |
---|
| 213 | G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius(); |
---|
| 214 | if(radius<=0.) radius = 1.; |
---|
| 215 | const G4double cameraDistance = fVP.GetCameraDistance (radius); |
---|
| 216 | const G4Vector3D& direction = fVP.GetViewpointDirection().unit(); |
---|
| 217 | const G4Point3D cameraPosition = target + cameraDistance * direction; |
---|
| 218 | //const G4double pnear = fVP.GetNearDistance (cameraDistance, radius); |
---|
| 219 | //const G4double pfar = fVP.GetFarDistance (cameraDistance, pnear, radius); |
---|
| 220 | const G4Normal3D& up = fVP.GetUpVector (); |
---|
| 221 | |
---|
| 222 | /* |
---|
| 223 | printf("debug : target : %g %g %g\n",target.x(), |
---|
| 224 | target.y(), |
---|
| 225 | target.z()); |
---|
| 226 | printf("debug : dir : %g %g %g\n",direction.x(), |
---|
| 227 | direction.y(), |
---|
| 228 | direction.z()); |
---|
| 229 | printf("debug : pos : %g %g %g\n",cameraPosition.x(), |
---|
| 230 | cameraPosition.y(), |
---|
| 231 | cameraPosition.z()); |
---|
| 232 | //printf("debug : near %g far %g\n",pnear,pfar); |
---|
| 233 | */ |
---|
| 234 | |
---|
| 235 | SoCamera* camera = GetCamera(); |
---|
| 236 | if(!camera) return; |
---|
| 237 | |
---|
| 238 | // viewer camera setup : |
---|
| 239 | camera->position.setValue((float)cameraPosition.x(), |
---|
| 240 | (float)cameraPosition.y(), |
---|
| 241 | (float)cameraPosition.z()); |
---|
| 242 | |
---|
| 243 | SbVec3f sbTarget((float)target.x(), |
---|
| 244 | (float)target.y(), |
---|
| 245 | (float)target.z()); |
---|
| 246 | SbVec3f sbUp((float)up.x(), |
---|
| 247 | (float)up.y(), |
---|
| 248 | (float)up.z()); |
---|
| 249 | sbUp.normalize(); |
---|
| 250 | // Need Coin's camera->pointAt(sbTarget,sbUp); not in the SGI API |
---|
| 251 | // Stole Coin's code... |
---|
| 252 | pointAt(camera,sbTarget,sbUp); |
---|
| 253 | |
---|
| 254 | //camera->height.setValue(10); |
---|
| 255 | //camera->nearDistance.setValue((float)pnear); |
---|
| 256 | //camera->farDistance.setValue((float)pfar); |
---|
| 257 | //camera->focalDistance.setValue((float)cameraDistance); |
---|
| 258 | |
---|
| 259 | if(camera->isOfType(SoOrthographicCamera::getClassTypeId())) { |
---|
| 260 | if (fVP.GetFieldHalfAngle() == 0.) { |
---|
| 261 | //FIXME : ((SoOrthographicCamera*)camera)->height.setValue(); |
---|
| 262 | //FIXME : (Don't think we have to do that.) |
---|
| 263 | } else { |
---|
| 264 | //FIXME : Have to set a perspective camera ! |
---|
| 265 | //FIXME : viewer->setCameraType(SoPerspectiveCamera::getClassTypeId()) |
---|
| 266 | //FIXME : ((SoPerspectiveCamera*)camera)->heightAngle.setValue |
---|
| 267 | //FIXME : (2.*fVP.GetFieldHalfAngle()); |
---|
| 268 | } |
---|
| 269 | } else if(camera->isOfType(SoPerspectiveCamera::getClassTypeId())) { |
---|
| 270 | if (fVP.GetFieldHalfAngle() == 0.) { |
---|
| 271 | //FIXME : Have to set an orthographic camera ! |
---|
| 272 | //FIXME : viewer->setCameraType(SoOrthographicCamera::getClassTypeId()) |
---|
| 273 | } else { |
---|
| 274 | //FIXME : ((SoPerspectiveCamera*)camera)->heightAngle.setValue |
---|
| 275 | //FIXME : (2.*fVP.GetFieldHalfAngle()); |
---|
| 276 | } |
---|
| 277 | } |
---|
| 278 | } |
---|
| 279 | |
---|
| 280 | //COIN_FUNCTION_EXTENSION |
---|
| 281 | void |
---|
| 282 | G4OpenInventorViewer::pointAt(SoCamera* camera,const SbVec3f & targetpoint, const SbVec3f & upvector) |
---|
| 283 | { |
---|
| 284 | SbVec3f dir = targetpoint - camera->position.getValue(); |
---|
| 285 | if (dir.normalize() == 0.0f) return; |
---|
| 286 | lookAt(camera,dir, upvector); |
---|
| 287 | } |
---|
| 288 | |
---|
| 289 | //COIN_FUNCTION |
---|
| 290 | // Private method that calculates a new orientation based on camera |
---|
| 291 | // direction and camera up vector. Vectors must be unit length. |
---|
| 292 | void |
---|
| 293 | G4OpenInventorViewer::lookAt(SoCamera* camera,const SbVec3f & dir, const SbVec3f & up) |
---|
| 294 | { |
---|
| 295 | SbVec3f z = -dir; |
---|
| 296 | SbVec3f y = up; |
---|
| 297 | SbVec3f x = y.cross(z); |
---|
| 298 | |
---|
| 299 | // recompute y to create a valid coordinate system |
---|
| 300 | y = z.cross(x); |
---|
| 301 | |
---|
| 302 | // normalize x and y to create an orthonormal coord system |
---|
| 303 | y.normalize(); |
---|
| 304 | x.normalize(); |
---|
| 305 | |
---|
| 306 | // create a rotation matrix |
---|
| 307 | SbMatrix rot = SbMatrix::identity(); |
---|
| 308 | rot[0][0] = x[0]; |
---|
| 309 | rot[0][1] = x[1]; |
---|
| 310 | rot[0][2] = x[2]; |
---|
| 311 | |
---|
| 312 | rot[1][0] = y[0]; |
---|
| 313 | rot[1][1] = y[1]; |
---|
| 314 | rot[1][2] = y[2]; |
---|
| 315 | |
---|
| 316 | rot[2][0] = z[0]; |
---|
| 317 | rot[2][1] = z[1]; |
---|
| 318 | rot[2][2] = z[2]; |
---|
| 319 | |
---|
| 320 | camera->orientation.setValue(SbRotation(rot)); |
---|
| 321 | } |
---|
| 322 | |
---|
| 323 | void |
---|
| 324 | G4OpenInventorViewer::lookedAt(SoCamera* camera,SbVec3f & dir, SbVec3f & up) |
---|
| 325 | { |
---|
| 326 | SbRotation rot = camera->orientation.getValue(); |
---|
| 327 | SbMatrix mrot; rot.getValue(mrot); |
---|
| 328 | |
---|
| 329 | SbVec3f x, y, z; |
---|
| 330 | |
---|
| 331 | // create a rotation matrix |
---|
| 332 | x[0] = mrot[0][0]; |
---|
| 333 | x[1] = mrot[0][1]; |
---|
| 334 | x[2] = mrot[0][2]; |
---|
| 335 | |
---|
| 336 | y[0] = mrot[1][0]; |
---|
| 337 | y[1] = mrot[1][1]; |
---|
| 338 | y[2] = mrot[1][2]; |
---|
| 339 | |
---|
| 340 | z[0] = mrot[2][0]; |
---|
| 341 | z[1] = mrot[2][1]; |
---|
| 342 | z[2] = mrot[2][2]; |
---|
| 343 | |
---|
| 344 | dir = -z; |
---|
| 345 | dir.normalize(); |
---|
| 346 | up = SbVec3f(0.f,1.f,0.f); // Choose y-axis if possible. |
---|
| 347 | if (std::abs(up.dot(z)) > 1.e-6) { |
---|
| 348 | up = y; |
---|
| 349 | up.normalize(); |
---|
| 350 | } |
---|
| 351 | } |
---|
| 352 | |
---|
| 353 | void G4OpenInventorViewer::DrawView () { |
---|
| 354 | //G4cout << "debug Iv::DrawViewer " <<G4endl; |
---|
| 355 | if (!fNeedKernelVisit) KernelVisitDecision(); |
---|
| 356 | ProcessView(); |
---|
| 357 | FinishView(); |
---|
| 358 | } |
---|
| 359 | |
---|
| 360 | void G4OpenInventorViewer::ShowView () { |
---|
| 361 | fInteractorManager -> SecondaryLoop (); |
---|
| 362 | } |
---|
| 363 | |
---|
| 364 | void G4OpenInventorViewer::GroupCameraSensorCB(void* aThis,SoSensor* aSensor){ |
---|
| 365 | G4OpenInventorViewer* This = (G4OpenInventorViewer*)aThis; |
---|
| 366 | |
---|
| 367 | SoNode* node = ((SoNodeSensor*)aSensor)->getTriggerNode(); |
---|
| 368 | //printf("debug : GroupCameraSensorCB %s\n", |
---|
| 369 | //node->getTypeId().getName().getString()); |
---|
| 370 | |
---|
| 371 | if(node->isOfType(SoCamera::getClassTypeId())) { |
---|
| 372 | // Viewer had changed the camera type, |
---|
| 373 | // attach the fCameraSensor to the new camera. |
---|
| 374 | SoCamera* camera = (SoCamera*)node; |
---|
| 375 | This->fCameraSensor->detach(); |
---|
| 376 | This->fCameraSensor->attach(camera); |
---|
| 377 | } |
---|
| 378 | |
---|
| 379 | } |
---|
| 380 | |
---|
| 381 | void G4OpenInventorViewer::CameraSensorCB(void* aThis,SoSensor* aSensor) { |
---|
| 382 | G4OpenInventorViewer* This = (G4OpenInventorViewer*)aThis; |
---|
| 383 | |
---|
| 384 | //printf("debug : CameraSensorCB\n"); |
---|
| 385 | |
---|
| 386 | SoNode* node = ((SoNodeSensor*)aSensor)->getTriggerNode(); |
---|
| 387 | |
---|
| 388 | if(node->isOfType(SoCamera::getClassTypeId())) { |
---|
| 389 | SoCamera* camera = (SoCamera*)node; |
---|
| 390 | |
---|
| 391 | SbVec3f direction, up; |
---|
| 392 | lookedAt(camera,direction, up); |
---|
| 393 | This->fVP.SetViewpointDirection |
---|
| 394 | (G4Vector3D(-direction[0],-direction[1],-direction[2])); |
---|
| 395 | This->fVP.SetUpVector(G4Vector3D(up[0],up[1],up[2])); |
---|
| 396 | |
---|
| 397 | SbVec3f pos = camera->position.getValue(); |
---|
| 398 | SbVec3f target = pos + direction * camera->focalDistance.getValue(); |
---|
| 399 | |
---|
| 400 | This->fVP.SetCurrentTargetPoint(G4Point3D(target[0],target[1],target[2])); |
---|
| 401 | } |
---|
| 402 | } |
---|
| 403 | |
---|
| 404 | void G4OpenInventorViewer::SelectionCB( |
---|
| 405 | void* aThis |
---|
| 406 | ,SoPath* aPath |
---|
| 407 | ) |
---|
| 408 | { |
---|
| 409 | G4OpenInventorViewer* This = (G4OpenInventorViewer*)aThis; |
---|
| 410 | SoNode* node = ((SoFullPath*)aPath)->getTail(); |
---|
| 411 | G4AttHolder* attHolder = dynamic_cast<G4AttHolder*>(node); |
---|
| 412 | if(attHolder && attHolder->GetAttDefs().size()) { |
---|
| 413 | for (size_t i = 0; i < attHolder->GetAttDefs().size(); ++i) { |
---|
| 414 | G4cout << G4AttCheck(attHolder->GetAttValues()[i], |
---|
| 415 | attHolder->GetAttDefs()[i]); |
---|
| 416 | } |
---|
| 417 | } else { |
---|
| 418 | G4String name((char*)node->getName().getString()); |
---|
| 419 | G4String cls((char*)node->getTypeId().getName().getString()); |
---|
| 420 | G4cout << "SoNode : " << node |
---|
| 421 | << " SoType : " << cls |
---|
| 422 | << " name : " << name |
---|
| 423 | << G4endl; |
---|
| 424 | G4cout << "No attributes attached." << G4endl; |
---|
| 425 | } |
---|
| 426 | /*FIXME : to explore (need different button - this is used for picking. |
---|
| 427 | if(node->isOfType(Geant4_SoPolyhedron::getClassTypeId())) { |
---|
| 428 | Geant4_SoPolyhedron* polyhedron = (Geant4_SoPolyhedron*)node; |
---|
| 429 | if(polyhedron->solid.getValue()==FALSE) |
---|
| 430 | polyhedron->solid.setValue(TRUE); |
---|
| 431 | else |
---|
| 432 | polyhedron->solid.setValue(FALSE); |
---|
| 433 | }*/ |
---|
| 434 | This->fSoSelection->deselectAll(); |
---|
| 435 | } |
---|
| 436 | /* |
---|
| 437 | void G4OpenInventorViewer::DeselectionCB( |
---|
| 438 | void* aThis |
---|
| 439 | ,SoPath* aPath |
---|
| 440 | ) |
---|
| 441 | { |
---|
| 442 | //G4OpenInventorViewer* This = (G4OpenInventorViewer*)aThis; |
---|
| 443 | G4String name((char*)aPath->getTail()->getTypeId().getName().getString()); |
---|
| 444 | G4cout << "Deselect : " << name << G4endl; |
---|
| 445 | } |
---|
| 446 | */ |
---|
| 447 | |
---|
| 448 | void G4OpenInventorViewer::DrawDetector() { |
---|
| 449 | /* Replace this... - JA |
---|
| 450 | // DrawView does a ClearStore. Do not clear the transient store : |
---|
| 451 | SoSeparator* tmp = fG4OpenInventorSceneHandler.fTransientRoot; |
---|
| 452 | fG4OpenInventorSceneHandler.fTransientRoot = new SoSeparator; |
---|
| 453 | if (!fNeedKernelVisit) KernelVisitDecision(); |
---|
| 454 | ProcessView(); |
---|
| 455 | fG4OpenInventorSceneHandler.fTransientRoot->unref(); |
---|
| 456 | fG4OpenInventorSceneHandler.fTransientRoot = tmp; |
---|
| 457 | */ |
---|
| 458 | // ...by this... - JA |
---|
| 459 | DrawView(); |
---|
| 460 | } |
---|
| 461 | |
---|
| 462 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 463 | /// Menu items callbacks ///////////////////////////////////////////////////// |
---|
| 464 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 465 | |
---|
| 466 | void G4OpenInventorViewer::Escape(){ |
---|
| 467 | G4cout << "Escape..." <<G4endl; |
---|
| 468 | fInteractorManager->RequireExitSecondaryLoop (OIV_EXIT_CODE); |
---|
| 469 | } |
---|
| 470 | |
---|
| 471 | void G4OpenInventorViewer::WritePostScript(const G4String& aFile) { |
---|
| 472 | if(!fGL2PSAction) return; |
---|
| 473 | fGL2PSAction->setFileName(aFile.c_str()); |
---|
| 474 | G4cout << "Produce " << aFile << "..." << G4endl; |
---|
| 475 | fGL2PSAction->enableFileWriting(); |
---|
| 476 | ViewerRender(); |
---|
| 477 | fGL2PSAction->disableFileWriting(); |
---|
| 478 | } |
---|
| 479 | |
---|
| 480 | void G4OpenInventorViewer::WritePixmapPostScript(const G4String& aFile) { |
---|
| 481 | fSoImageWriter->fileName.setValue(aFile.c_str()); |
---|
| 482 | //imageWriter->format.setValue(SoImageWriter::POST_SCRIPT); |
---|
| 483 | fSoImageWriter->enable(); |
---|
| 484 | ViewerRender(); |
---|
| 485 | fSoImageWriter->disable(); |
---|
| 486 | if(fSoImageWriter->getStatus()) { |
---|
| 487 | G4cout << G4String(fSoImageWriter->fileName.getValue().getString()) |
---|
| 488 | << " produced." |
---|
| 489 | << G4endl; |
---|
| 490 | } else { |
---|
| 491 | G4cout << G4String(fSoImageWriter->fileName.getValue().getString()) |
---|
| 492 | << " not produced." |
---|
| 493 | << G4endl; |
---|
| 494 | } |
---|
| 495 | } |
---|
| 496 | |
---|
| 497 | void G4OpenInventorViewer::WriteInventor(const G4String& aFile) { |
---|
| 498 | G4cout << "Produce " << aFile << "..." << G4endl; |
---|
| 499 | |
---|
| 500 | SbBool genAlternateRep = TRUE; |
---|
| 501 | //SbBool binary = FALSE; |
---|
| 502 | SbBool binary = TRUE; |
---|
| 503 | SoAlternateRepAction alternateRepAction; |
---|
| 504 | if(genAlternateRep==TRUE) { |
---|
| 505 | alternateRepAction.setGenerate(TRUE); //Clear alternate reps. |
---|
| 506 | alternateRepAction.apply(fSoSelection); |
---|
| 507 | } |
---|
| 508 | |
---|
| 509 | SoWriteAction writeAction; |
---|
| 510 | writeAction.getOutput()->openFile(aFile.c_str()); |
---|
| 511 | writeAction.getOutput()->setBinary(binary); |
---|
| 512 | writeAction.apply(fSoSelection); |
---|
| 513 | writeAction.getOutput()->closeFile(); |
---|
| 514 | |
---|
| 515 | if(genAlternateRep==TRUE) { |
---|
| 516 | alternateRepAction.setGenerate(FALSE); //Clear alternate reps. |
---|
| 517 | alternateRepAction.apply(fSoSelection); |
---|
| 518 | } |
---|
| 519 | |
---|
| 520 | |
---|
| 521 | |
---|
| 522 | } |
---|
| 523 | |
---|
| 524 | struct Counter { |
---|
| 525 | int fTriangles; |
---|
| 526 | int fLineSegments; |
---|
| 527 | int fPoints; |
---|
| 528 | }; |
---|
| 529 | |
---|
| 530 | static void CountTrianglesCB( |
---|
| 531 | void* userData |
---|
| 532 | ,SoCallbackAction* |
---|
| 533 | ,const SoPrimitiveVertex* |
---|
| 534 | ,const SoPrimitiveVertex*, |
---|
| 535 | const SoPrimitiveVertex*) |
---|
| 536 | { |
---|
| 537 | Counter* counter = (Counter*)userData; |
---|
| 538 | counter->fTriangles++; |
---|
| 539 | } |
---|
| 540 | |
---|
| 541 | static void CountLineSegmentsCB( |
---|
| 542 | void* userData |
---|
| 543 | ,SoCallbackAction* |
---|
| 544 | ,const SoPrimitiveVertex* |
---|
| 545 | ,const SoPrimitiveVertex*) |
---|
| 546 | { |
---|
| 547 | Counter* counter = (Counter*)userData; |
---|
| 548 | counter->fLineSegments++; |
---|
| 549 | } |
---|
| 550 | |
---|
| 551 | static void CountPointsCB( |
---|
| 552 | void* userData |
---|
| 553 | ,SoCallbackAction* |
---|
| 554 | ,const SoPrimitiveVertex*) |
---|
| 555 | { |
---|
| 556 | Counter* counter = (Counter*)userData; |
---|
| 557 | counter->fPoints++; |
---|
| 558 | } |
---|
| 559 | |
---|
| 560 | void G4OpenInventorViewer::SceneGraphStatistics() { |
---|
| 561 | Counter counter; |
---|
| 562 | counter.fTriangles = 0; |
---|
| 563 | counter.fLineSegments = 0; |
---|
| 564 | counter.fPoints = 0; |
---|
| 565 | |
---|
| 566 | SoCallbackAction callbackAction; |
---|
| 567 | callbackAction.addTriangleCallback |
---|
| 568 | (SoShape::getClassTypeId(),CountTrianglesCB,(void*)&counter); |
---|
| 569 | callbackAction.addLineSegmentCallback |
---|
| 570 | (SoShape::getClassTypeId(),CountLineSegmentsCB,(void*)&counter); |
---|
| 571 | callbackAction.addPointCallback |
---|
| 572 | (SoShape::getClassTypeId(),CountPointsCB,(void*)&counter); |
---|
| 573 | callbackAction.apply(fSoSelection); |
---|
| 574 | |
---|
| 575 | SoCounterAction counterAction; |
---|
| 576 | counterAction.apply(fSoSelection); |
---|
| 577 | int nodes = counterAction.getCount(); |
---|
| 578 | |
---|
| 579 | counterAction.setLookFor(SoCounterAction::TYPE); |
---|
| 580 | counterAction.setType(SoShape::getClassTypeId()); |
---|
| 581 | counterAction.apply(fSoSelection); |
---|
| 582 | int shapes = counterAction.getCount(); |
---|
| 583 | |
---|
| 584 | G4cout << "Number of triangles : " << counter.fTriangles << G4endl; |
---|
| 585 | G4cout << "Number of line segments : " << counter.fLineSegments << G4endl; |
---|
| 586 | G4cout << "Number of points : " << counter.fPoints << G4endl; |
---|
| 587 | G4cout << "Number of nodes : " << nodes << G4endl; |
---|
| 588 | G4cout << "Number of shapes : " << shapes << G4endl; |
---|
| 589 | } |
---|
| 590 | |
---|
| 591 | void G4OpenInventorViewer::EraseDetector() { |
---|
| 592 | fG4OpenInventorSceneHandler.fDetectorRoot->removeAllChildren(); |
---|
| 593 | } |
---|
| 594 | void G4OpenInventorViewer::EraseEvent() { |
---|
| 595 | fG4OpenInventorSceneHandler.fTransientRoot->removeAllChildren(); |
---|
| 596 | } |
---|
| 597 | |
---|
| 598 | void G4OpenInventorViewer::SetPreviewAndFull() { |
---|
| 599 | fG4OpenInventorSceneHandler.fPreviewAndFull = true; |
---|
| 600 | |
---|
| 601 | NeedKernelVisit(); |
---|
| 602 | DrawDetector(); |
---|
| 603 | } |
---|
| 604 | |
---|
| 605 | void G4OpenInventorViewer::SetPreview() { |
---|
| 606 | fG4OpenInventorSceneHandler.fPreviewAndFull = false; |
---|
| 607 | |
---|
| 608 | NeedKernelVisit(); |
---|
| 609 | DrawDetector(); |
---|
| 610 | } |
---|
| 611 | |
---|
| 612 | // When ViewParameter <-> SoCamera mapping ready |
---|
| 613 | // uncomment the below |
---|
| 614 | //#define USE_SET_VIEW |
---|
| 615 | |
---|
| 616 | void G4OpenInventorViewer::SetSolid() { |
---|
| 617 | G4ViewParameters vp = GetViewParameters(); |
---|
| 618 | G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); |
---|
| 619 | //From G4VisCommandsViewerSet : /vis/viewer/set/style solid. |
---|
| 620 | switch (existingStyle) { |
---|
| 621 | case G4ViewParameters::wireframe: |
---|
| 622 | vp.SetDrawingStyle(G4ViewParameters::hsr); |
---|
| 623 | break; |
---|
| 624 | case G4ViewParameters::hlr: |
---|
| 625 | vp.SetDrawingStyle(G4ViewParameters::hlhsr); |
---|
| 626 | break; |
---|
| 627 | case G4ViewParameters::hsr: |
---|
| 628 | break; |
---|
| 629 | case G4ViewParameters::hlhsr: |
---|
| 630 | break; |
---|
| 631 | } |
---|
| 632 | SetViewParameters(vp); |
---|
| 633 | DrawDetector(); |
---|
| 634 | } |
---|
| 635 | void G4OpenInventorViewer::SetWireFrame() { |
---|
| 636 | G4ViewParameters vp = GetViewParameters(); |
---|
| 637 | G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); |
---|
| 638 | switch (existingStyle) { |
---|
| 639 | case G4ViewParameters::wireframe: |
---|
| 640 | break; |
---|
| 641 | case G4ViewParameters::hlr: |
---|
| 642 | break; |
---|
| 643 | case G4ViewParameters::hsr: |
---|
| 644 | vp.SetDrawingStyle(G4ViewParameters::wireframe); |
---|
| 645 | break; |
---|
| 646 | case G4ViewParameters::hlhsr: |
---|
| 647 | vp.SetDrawingStyle(G4ViewParameters::hlr); |
---|
| 648 | break; |
---|
| 649 | } |
---|
| 650 | SetViewParameters(vp); |
---|
| 651 | DrawDetector(); |
---|
| 652 | } |
---|
| 653 | |
---|
| 654 | |
---|
| 655 | void G4OpenInventorViewer::SetReducedWireFrame(bool aValue) { |
---|
| 656 | G4ViewParameters vp = GetViewParameters(); |
---|
| 657 | |
---|
| 658 | // Set the wire frame kind : |
---|
| 659 | vp.SetAuxEdgeVisible(!aValue); |
---|
| 660 | |
---|
| 661 | // Set wire frame : |
---|
| 662 | G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle(); |
---|
| 663 | switch (existingStyle) { |
---|
| 664 | case G4ViewParameters::wireframe: |
---|
| 665 | break; |
---|
| 666 | case G4ViewParameters::hlr: |
---|
| 667 | break; |
---|
| 668 | case G4ViewParameters::hsr: |
---|
| 669 | vp.SetDrawingStyle(G4ViewParameters::wireframe); |
---|
| 670 | break; |
---|
| 671 | case G4ViewParameters::hlhsr: |
---|
| 672 | vp.SetDrawingStyle(G4ViewParameters::hlr); |
---|
| 673 | break; |
---|
| 674 | } |
---|
| 675 | SetViewParameters(vp); |
---|
| 676 | NeedKernelVisit(); // Just in case it was alread in wire framw. |
---|
| 677 | DrawDetector(); |
---|
| 678 | } |
---|
| 679 | |
---|
| 680 | void G4OpenInventorViewer::UpdateScene() { |
---|
| 681 | /* Replace this... - JA |
---|
| 682 | fG4OpenInventorSceneHandler.ClearStore(); |
---|
| 683 | ClearView(); |
---|
| 684 | if (!fNeedKernelVisit) KernelVisitDecision(); |
---|
| 685 | ProcessView(); |
---|
| 686 | ShowView(); |
---|
| 687 | */ |
---|
| 688 | // ...by this - JA |
---|
| 689 | NeedKernelVisit(); |
---|
| 690 | DrawView(); |
---|
| 691 | } |
---|
| 692 | G4String G4OpenInventorViewer::Help(const G4String& aTopic) { |
---|
| 693 | if(aTopic=="controls") { |
---|
| 694 | return G4String("\ |
---|
| 695 | Controls on an Inventor examiner viewer are :\n\ |
---|
| 696 | - in picking mode (cursor is the upper left arrow)\n\ |
---|
| 697 | Ctrl + pick a volume : see daughters.\n\ |
---|
| 698 | Shift + pick a volume : see mother.\n\ |
---|
| 699 | - in viewing mode (cursor is the hand)\n\ |
---|
| 700 | Left-button + pointer move : rotate.\n\ |
---|
| 701 | Ctrl+Left-button + pointer move : pan.\n\ |
---|
| 702 | Ctrl+Shift+Left-button + pointer move : scale.\n\ |
---|
| 703 | Middle-button + pointer move : pan.\n\ |
---|
| 704 | Right-button : popup menu.\n"); |
---|
| 705 | } else { |
---|
| 706 | return ""; |
---|
| 707 | } |
---|
| 708 | } |
---|
| 709 | |
---|
| 710 | #endif |
---|