| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id: G4OpenGLStoredSceneHandler.cc,v 1.46 2010-11-10 17:11:20 allison Exp $
27 // 28 //
28 // 29 //
29 // Laurent Garnier 27th October 2011 30 // Laurent Garnier 27th October 2011
30 31
>> 32 #ifdef G4VIS_BUILD_OPENGLQT_DRIVER
>> 33
31 #include "G4OpenGLStoredQtSceneHandler.hh" 34 #include "G4OpenGLStoredQtSceneHandler.hh"
32 35
33 #include "G4PhysicalVolumeModel.hh" 36 #include "G4PhysicalVolumeModel.hh"
34 #include "G4LogicalVolumeModel.hh" 37 #include "G4LogicalVolumeModel.hh"
35 #include "G4Text.hh" 38 #include "G4Text.hh"
36 #include "G4VPhysicalVolume.hh" 39 #include "G4VPhysicalVolume.hh"
37 #include "G4OpenGLQtViewer.hh" 40 #include "G4OpenGLQtViewer.hh"
38 #include <typeinfo> 41 #include <typeinfo>
39 #include <sstream> 42 #include <sstream>
40 43
41 G4OpenGLStoredQtSceneHandler::G4OpenGLStoredQt 44 G4OpenGLStoredQtSceneHandler::G4OpenGLStoredQtSceneHandler
42 (G4VGraphicsSystem& system, 45 (G4VGraphicsSystem& system,
43 const G4String& name): 46 const G4String& name):
44 G4OpenGLStoredSceneHandler (system, name) 47 G4OpenGLStoredSceneHandler (system, name)
45 {} 48 {}
46 49
47 G4OpenGLStoredQtSceneHandler::~G4OpenGLStoredQ 50 G4OpenGLStoredQtSceneHandler::~G4OpenGLStoredQtSceneHandler ()
48 {} 51 {}
49 52
50 G4bool G4OpenGLStoredQtSceneHandler::ExtraPOPr 53 G4bool G4OpenGLStoredQtSceneHandler::ExtraPOProcessing
51 (const G4Visible& visible, size_t currentPOLis 54 (const G4Visible& visible, size_t currentPOListIndex)
52 { 55 {
53 G4bool usesGLCommands = true; 56 G4bool usesGLCommands = true;
54 57
55 try { 58 try {
56 const G4Text& g4Text = dynamic_cast<const 59 const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
57 G4TextPlus* pG4TextPlus = new G4TextPlus(g 60 G4TextPlus* pG4TextPlus = new G4TextPlus(g4Text);
58 pG4TextPlus->fProcessing2D = fProcessing2D 61 pG4TextPlus->fProcessing2D = fProcessing2D;
59 fPOList[currentPOListIndex].fpG4TextPlus = 62 fPOList[currentPOListIndex].fpG4TextPlus = pG4TextPlus;
60 usesGLCommands = false; 63 usesGLCommands = false;
61 } 64 }
62 catch (const std::bad_cast&) {} // No speci << 65 catch (std::bad_cast) {} // No special action if not text. Just carry on.
63 66
64 G4PhysicalVolumeModel* pPVModel = 67 G4PhysicalVolumeModel* pPVModel =
65 dynamic_cast<G4PhysicalVolumeModel*>(fpMod 68 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
66 G4LogicalVolumeModel* pLVModel = 69 G4LogicalVolumeModel* pLVModel =
67 dynamic_cast<G4LogicalVolumeModel*>(pPVMod 70 dynamic_cast<G4LogicalVolumeModel*>(pPVModel);
68 if (pPVModel && !pLVModel) { 71 if (pPVModel && !pLVModel) {
69 72
70 // This call comes from a G4PhysicalVolume 73 // This call comes from a G4PhysicalVolumeModel. drawnPVPath is
71 // the path of the current drawn (non-cull 74 // the path of the current drawn (non-culled) volume in terms of
72 // drawn (non-culled) ancestors. Each nod << 75 // drawn (non-culled) ancesters. Each node is identified by a
73 // PVNodeID object, which is a physical vo 76 // PVNodeID object, which is a physical volume and copy number. It
74 // is a vector of PVNodeIDs corresponding 77 // is a vector of PVNodeIDs corresponding to the geometry hierarchy
75 // actually selected, i.e., not culled. 78 // actually selected, i.e., not culled.
76 // typedef G4PhysicalVolumeModel::G4Phy 79 // typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
77 // typedef std::vector<PVNodeID> PVPath 80 // typedef std::vector<PVNodeID> PVPath;
78 81
79 // The simplest algorithm, used by the Ope 82 // The simplest algorithm, used by the Open Inventor Driver
80 // developers, is to rely on the fact the 83 // developers, is to rely on the fact the G4PhysicalVolumeModel
81 // traverses the geometry hierarchy in an 84 // traverses the geometry hierarchy in an orderly manner. The last
82 // mother, if any, will be the node to whi 85 // mother, if any, will be the node to which the volume should be
83 // added. So it is enough to keep a map o 86 // added. So it is enough to keep a map of scene graph nodes keyed
84 // on the volume path ID. Actually, it is 87 // on the volume path ID. Actually, it is enough to use the logical
85 // volume as the key. (An alternative wou 88 // volume as the key. (An alternative would be to keep the PVNodeID
86 // in the tree and match the PVPath from t 89 // in the tree and match the PVPath from the root down.)
87 90
88 // BUT IN OPENGL, IF THERE ARE TRANSPARENT 91 // BUT IN OPENGL, IF THERE ARE TRANSPARENT OBJECTS, VOLUMES DO NOT
89 // ARRIVE IN THE ABOVE ORDER. (TRANSPAREN 92 // ARRIVE IN THE ABOVE ORDER. (TRANSPARENT OBJECTS ARE DRWAN
90 // LAST.) SO WE MUST BE MORE SOPHISTICATE 93 // LAST.) SO WE MUST BE MORE SOPHISTICATED IN CONSTRUCTING A
91 // TREE. 94 // TREE.
92 95
93 // build a path for tree viewer 96 // build a path for tree viewer
94 G4OpenGLQtViewer* pGLViewer = dynamic_cast 97 G4OpenGLQtViewer* pGLViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
95 if ( pGLViewer ) { 98 if ( pGLViewer ) {
96 pGLViewer->addPVSceneTreeElement(fpModel << 99 pGLViewer->addPVSceneTreeElement(fpModel->GetCurrentDescription(),pPVModel,currentPOListIndex);
97 } 100 }
98 101
99 } else { // Not from a G4PhysicalVolumeMode 102 } else { // Not from a G4PhysicalVolumeModel.
100 103
101 if (fpModel) { 104 if (fpModel) {
102 105
103 106
104 // build a path for tree viewer 107 // build a path for tree viewer
105 G4OpenGLQtViewer* pGLViewer = dynamic_ca 108 G4OpenGLQtViewer* pGLViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
106 if ( pGLViewer ) { 109 if ( pGLViewer ) {
107 pGLViewer->addNonPVSceneTreeElement(fp << 110 pGLViewer->addNonPVSceneTreeElement(fpModel->GetType(),currentPOListIndex,fpModel->GetCurrentDescription().data(),visible);
108 } 111 }
109 } 112 }
110 } 113 }
111 114
112 return usesGLCommands; 115 return usesGLCommands;
113 } 116 }
114 117
115 G4bool G4OpenGLStoredQtSceneHandler::ExtraTOPr 118 G4bool G4OpenGLStoredQtSceneHandler::ExtraTOProcessing
116 (const G4Visible& visible, size_t currentTOLis 119 (const G4Visible& visible, size_t currentTOListIndex)
117 { 120 {
118 121
119 G4bool usesGLCommands = true; 122 G4bool usesGLCommands = true;
120 123
121 try { 124 try {
122 const G4Text& g4Text = dynamic_cast<const 125 const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
123 G4TextPlus* pG4TextPlus = new G4TextPlus(g 126 G4TextPlus* pG4TextPlus = new G4TextPlus(g4Text);
124 pG4TextPlus->fProcessing2D = fProcessing2D 127 pG4TextPlus->fProcessing2D = fProcessing2D;
125 fTOList[currentTOListIndex].fpG4TextPlus = 128 fTOList[currentTOListIndex].fpG4TextPlus = pG4TextPlus;
126 usesGLCommands = false; 129 usesGLCommands = false;
127 } 130 }
128 catch (const std::bad_cast&) {} // Do nothi << 131 catch (std::bad_cast) {} // Do nothing if not text.
129 132
130 return usesGLCommands; 133 return usesGLCommands;
131 } 134 }
132 135
133 void G4OpenGLStoredQtSceneHandler::ClearStore 136 void G4OpenGLStoredQtSceneHandler::ClearStore () {
134 137
135 //G4cout << "G4OpenGLStoredQtSceneHandler::C 138 //G4cout << "G4OpenGLStoredQtSceneHandler::ClearStore" << G4endl;
136 139
137 G4OpenGLStoredSceneHandler::ClearStore (); << 140 G4OpenGLStoredSceneHandler::ClearStore (); // Sets need kernel visit, etc.
138 << 141 // Should recreate the tree
139 // Not needed - the old scene tree is curren << 142 G4OpenGLQtViewer* pGLQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
140 // this code somehow affects the view in rar << 143 if ( pGLQtViewer ) {
141 // the volume does not return to its origina << 144 pGLQtViewer->clearTreeWidget();
142 // this, pending a review of the old scene t << 145 }
143 // // Should recreate the tree <<
144 // G4OpenGLQtViewer* pGLQtViewer = dynamic_ca <<
145 // if ( pGLQtViewer ) { <<
146 // pGLQtViewer->clearTreeWidget(); <<
147 // } <<
148 } 146 }
149 147
150 void G4OpenGLStoredQtSceneHandler::ClearTransi 148 void G4OpenGLStoredQtSceneHandler::ClearTransientStore () {
151 149
152 //G4cout << "G4OpenGLStoredQtSceneHandler::C 150 //G4cout << "G4OpenGLStoredQtSceneHandler::ClearTransientStore" << G4endl;
153 151
154 G4OpenGLStoredSceneHandler::ClearTransientSt 152 G4OpenGLStoredSceneHandler::ClearTransientStore ();
155 153
156 // Should recreate the tree 154 // Should recreate the tree
157 // Make sure screen corresponds to graphical 155 // Make sure screen corresponds to graphical database...
158 // FIXME : L.Garnier April 2012 : Could caus 156 // FIXME : L.Garnier April 2012 : Could cause a infinite loop ?
159 if (fpViewer) { 157 if (fpViewer) {
160 fpViewer -> SetView (); 158 fpViewer -> SetView ();
161 fpViewer -> ClearView (); 159 fpViewer -> ClearView ();
162 fpViewer -> DrawView (); 160 fpViewer -> DrawView ();
163 } 161 }
164 } 162 }
165 163
166 void G4OpenGLStoredQtSceneHandler::SetScene(G4 164 void G4OpenGLStoredQtSceneHandler::SetScene(G4Scene* pScene){
167 165
168 if (pScene != fpScene) { 166 if (pScene != fpScene) {
169 G4OpenGLQtViewer* pGLQtViewer = dynamic_ca 167 G4OpenGLQtViewer* pGLQtViewer = dynamic_cast<G4OpenGLQtViewer*>(fpViewer);
170 if ( pGLQtViewer ) { 168 if ( pGLQtViewer ) {
171 pGLQtViewer->clearTreeWidget(); 169 pGLQtViewer->clearTreeWidget();
172 } 170 }
173 } 171 }
174 G4VSceneHandler::SetScene(pScene); 172 G4VSceneHandler::SetScene(pScene);
175 } 173 }
>> 174
>> 175 #endif
176 176