| 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: G4VisExecutive.icc 75567 2013-11-04 11:35:11Z gcosmo $
27 // 28 //
28 // << 29 //
29 // John Allison 24th January 1998. 30 // John Allison 24th January 1998.
30 31
31 #ifndef G4VISEXECUTIVE_ICC 32 #ifndef G4VISEXECUTIVE_ICC
32 #define G4VISEXECUTIVE_ICC 33 #define G4VISEXECUTIVE_ICC
33 34
34 // Filter/Model Factories << 35 // Supported drivers...
>> 36
>> 37 // Not needing external packages or libraries...
>> 38 #include "G4ASCIITree.hh"
>> 39 #include "G4DAWNFILE.hh"
>> 40 #include "G4HepRep.hh"
>> 41 #include "G4HepRepFile.hh"
>> 42 #include "G4RayTracer.hh"
35 #include "G4HitFilterFactories.hh" 43 #include "G4HitFilterFactories.hh"
36 #include "G4DigiFilterFactories.hh" 44 #include "G4DigiFilterFactories.hh"
37 #include "G4TrajectoryFilterFactories.hh" 45 #include "G4TrajectoryFilterFactories.hh"
38 #include "G4TrajectoryModelFactories.hh" 46 #include "G4TrajectoryModelFactories.hh"
39 << 47 #include "G4VRML1File.hh"
40 // Supported drivers... << 48 #include "G4VRML2File.hh"
41 // Not needing external packages or libraries. << 49 #include "G4GMocrenFile.hh"
42 #include "G4ASCIITree.hh" // no_geant4_ << 50
43 #include "G4DAWNFILE.hh" // no_geant4_ << 51 // FIXME : avoid mix with QT/WT driver (should be done by cmake??)
44 #include "G4HepRepFile.hh" // no_geant4_ << 52 #if defined(G4VIS_USE_OPENGLWT)
45 #include "G4RayTracer.hh" // no_geant4_ << 53 // do not want GL2P2 in WT case
46 #include "G4VRML2File.hh" // no_geant4_ << 54 #undef G4VIS_BUILD_OPENGL_GL2PS
47 #include "G4GMocrenFile.hh" // no_geant4_ << 55 #endif
48 #include "G4ToolsSGOffscreen.hh" // no_geant4_ <<
49 56
50 // Needing external packages or libraries... 57 // Needing external packages or libraries...
>> 58
>> 59 #ifdef G4VIS_USE_DAWN
>> 60 #include "G4FukuiRenderer.hh"
>> 61 #endif
>> 62
51 #ifdef G4VIS_USE_OPENGLX 63 #ifdef G4VIS_USE_OPENGLX
52 #include "G4OpenGLImmediateX.hh" // no_geant4_ << 64 #include "G4OpenGLImmediateX.hh"
53 #include "G4OpenGLStoredX.hh" // no_geant4_ << 65 #include "G4OpenGLStoredX.hh"
54 #endif 66 #endif
55 67
56 #ifdef G4VIS_USE_OPENGLWIN32 68 #ifdef G4VIS_USE_OPENGLWIN32
57 #include "G4OpenGLImmediateWin32.hh" // no_gea << 69 #include "G4OpenGLImmediateWin32.hh"
58 #include "G4OpenGLStoredWin32.hh" // no_gea << 70 #include "G4OpenGLStoredWin32.hh"
59 #endif 71 #endif
60 72
61 #ifdef G4VIS_USE_OPENGLXM 73 #ifdef G4VIS_USE_OPENGLXM
62 #include "G4OpenGLImmediateXm.hh" // no_geant4 << 74 #include "G4OpenGLImmediateXm.hh"
63 #include "G4OpenGLStoredXm.hh" // no_geant4 << 75 #include "G4OpenGLStoredXm.hh"
64 #endif 76 #endif
65 77
66 #ifdef G4VIS_USE_OPENGLQT 78 #ifdef G4VIS_USE_OPENGLQT
67 #include "G4OpenGLImmediateQt.hh" // no_geant4 << 79 #include "G4OpenGLImmediateQt.hh"
68 #include "G4OpenGLStoredQt.hh" // no_geant4 << 80 #include "G4OpenGLStoredQt.hh"
69 #endif 81 #endif
70 82
71 #ifdef G4VIS_USE_OIX << 83 #ifdef G4VIS_USE_OPENGLWT
72 #include "G4OpenInventorX.hh" // no_g << 84 #include "G4OpenGLImmediateWt.hh"
73 #include "G4OpenInventorXtExtended.hh" // no_g <<
74 #endif 85 #endif
75 86
76 #ifdef G4VIS_USE_OIQT << 87 #ifdef G4VIS_USE_OIX
77 #include "G4OpenInventorQt.hh" // no_geant4_mo << 88 #include "G4OpenInventorX.hh"
>> 89 #include "G4OpenInventorXtExtended.hh"
78 #endif 90 #endif
79 91
80 #ifdef G4VIS_USE_OIWIN32 92 #ifdef G4VIS_USE_OIWIN32
81 #include "G4OpenInventorWin32.hh" // no_geant4 << 93 #include "G4OpenInventorWin32.hh"
82 #endif 94 #endif
83 95
84 #ifdef G4VIS_USE_RAYTRACERX 96 #ifdef G4VIS_USE_RAYTRACERX
85 #include "G4RayTracerX.hh" // no_geant4_module << 97 #include "G4RayTracerX.hh"
86 #endif <<
87 <<
88 #ifdef G4VIS_USE_QT3D <<
89 #include "G4Qt3D.hh" // no_geant4_module_check <<
90 #endif <<
91 <<
92 #ifdef G4VIS_USE_TOOLSSG_X11_GLES <<
93 #include "G4ToolsSGX11GLES.hh" // no_geant4_mo <<
94 #endif <<
95 <<
96 #ifdef G4VIS_USE_TOOLSSG_X11_ZB <<
97 #include "G4ToolsSGX11ZB.hh" // no_geant4_modu <<
98 #endif <<
99 <<
100 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_GLES <<
101 #include "G4ToolsSGWindowsGLES.hh" // no_geant <<
102 #endif <<
103 <<
104 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_ZB <<
105 #include "G4ToolsSGWindowsZB.hh" // no_geant4_ <<
106 #endif <<
107 <<
108 #ifdef G4VIS_USE_TOOLSSG_XT_GLES <<
109 #include "G4ToolsSGXtGLES.hh" // no_geant4_mod <<
110 #endif <<
111 <<
112 #ifdef G4VIS_USE_TOOLSSG_XT_ZB <<
113 #include "G4ToolsSGXtZB.hh" // no_geant4_modul <<
114 #endif <<
115 <<
116 #ifdef G4VIS_USE_TOOLSSG_QT_GLES <<
117 #include "G4ToolsSGQtGLES.hh" // no_geant4_mod <<
118 #endif <<
119 <<
120 #ifdef G4VIS_USE_TOOLSSG_QT_ZB <<
121 #include "G4ToolsSGQtZB.hh" // no_geant4_modul <<
122 #endif <<
123 <<
124 #ifdef G4VIS_USE_VTK <<
125 #include "G4Vtk.hh" // no_geant4_module_check <<
126 #include "G4VtkOffscreen.hh" // no_geant4_modu <<
127 #undef G4VIS_USE_TOOLSSG_X11_GLES <<
128 #undef G4VIS_USE_TOOLSSG_XT_GLES <<
129 #undef G4VIS_USE_TOOLSSG_QT_GLES <<
130 #undef G4VIS_USE_TOOLSSG_WINDOWS_GLES <<
131 #undef G4VIS_USE_OPENGLQT <<
132 #undef G4VIS_USE_OPENGLXM <<
133 #undef G4VIS_USE_OPENGLX <<
134 #undef G4VIS_USE_OPENGLWIN32 <<
135 #endif 98 #endif
136 99
137 #ifdef G4VIS_USE_VTK_QT << 100 #ifdef G4VIS_USE_VRML
138 #include "G4VtkQt.hh" // no_geant4_module_chec << 101 #include "G4VRML1.hh"
>> 102 #include "G4VRML2.hh"
139 #endif 103 #endif
140 104
141 #include "G4UImanager.hh" << 105 inline
142 #include "G4UIsession.hh" << 106 G4VisExecutive::G4VisExecutive (const G4String& verbosityString):
143 #include "G4UIbatch.hh" << 107 G4VisManager(verbosityString)
144 << 108 {}
145 #include <cstdlib> <<
146 #include <sstream> <<
147 <<
148 #define G4warn G4cout <<
149 109
150 // The inline keyword prevents the compiler ma 110 // The inline keyword prevents the compiler making an external
151 // reference even though they cannot actually 111 // reference even though they cannot actually be inlined since they
152 // are virtual functions. This prevents a "mu 112 // are virtual functions. This prevents a "multiple definition" error
153 // if it is included in more than one file. H 113 // if it is included in more than one file. However, as explained in
154 // the class description in G4VisExecutive.hh, 114 // the class description in G4VisExecutive.hh, it should never be
155 // necessary to #include "G4VisExecutive.hh" i 115 // necessary to #include "G4VisExecutive.hh" in more than one file
156 // since after instantiation the object can be 116 // since after instantiation the object can be treated as a
157 // G4VisManager. 117 // G4VisManager.
>> 118 inline void
>> 119 G4VisExecutive::RegisterGraphicsSystems () {
158 120
159 inline << 121 // Graphics Systems not needing external packages or libraries...
160 G4VisExecutive::G4VisExecutive(int argc, char* <<
161 const G4String& verbosityString): <<
162 G4VisManager(verbosityString), <<
163 fSelected(false) <<
164 { <<
165 fUserArgc = argc; <<
166 fUserArgv = argv; <<
167 fUserSpecifiedSystem = system; <<
168 } <<
169 <<
170 inline <<
171 G4VisExecutive::G4VisExecutive (const G4String <<
172 G4VisManager(verbosityString) <<
173 , fUserArgc(0) // >0 if argc is provided by t <<
174 , fUserArgv(nullptr) <<
175 , fSelected(false) <<
176 {} <<
177 <<
178 inline <<
179 const G4String& G4VisExecutive::GetDefaultGrap <<
180 { <<
181 if (fSelected) return fDefaultGraphicsSystem <<
182 if (fUserArgc > 0) SetDefaults <<
183 if (!fSelected) SetDefaults <<
184 if (!fSelected && fUserArgc > 0) SetDefaults <<
185 if (!fSelected) { SetDefaults <<
186 if (fSelected) { // No UI session <<
187 // Deal with this later - the user may h <<
188 // on the command line - see G4VisComman <<
189 return fDefaultGraphicsSystemName; <<
190 } <<
191 } <<
192 if (!fSelected) SetDefaults <<
193 if (GetVerbosity() >= warnings) { <<
194 G4warn << "Default graphics system is: " < <<
195 << " (based on " << fDefaultGraphicsSystem <<
196 << "\nDefault window size hint is: " << fD <<
197 << " (based on " << fDefaultXGeometryStrin <<
198 << "\nNote: Parameters specified on the co <<
199 << "\n Use \"vis/open\" without param <<
200 << G4endl; <<
201 } <<
202 return fDefaultGraphicsSystemName; <<
203 } <<
204 <<
205 inline <<
206 void G4VisExecutive::SetDefaultsByArgument(con <<
207 { <<
208 // 1st priority: selection by G4VisExecutive <<
209 if (!system.empty()) { <<
210 fDefaultGraphicsSystemName = system; <<
211 fDefaultGraphicsSystemBasis = "G4VisExecui <<
212 fSelected = true; <<
213 } <<
214 } <<
215 <<
216 inline <<
217 void G4VisExecutive::SetDefaultsByEnvironment( <<
218 { <<
219 // 2nd priority: by environment variable <<
220 if (auto g4env = std::getenv("G4VIS_DEFAULT_ <<
221 G4String graphicsSystem, windowSizeHint; <<
222 std::istringstream iss(g4env); <<
223 iss >> graphicsSystem >> windowSizeHint; <<
224 if (!graphicsSystem.empty()) { <<
225 fDefaultGraphicsSystemName = graphicsSys <<
226 fDefaultGraphicsSystemBasis = "environme <<
227 fSelected = true; <<
228 } <<
229 if (!windowSizeHint.empty()) { <<
230 fDefaultXGeometryString = windowSizeHint <<
231 fDefaultXGeometryStringBasis = "environ <<
232 } <<
233 } <<
234 } <<
235 <<
236 inline <<
237 void G4VisExecutive::SetDefaultsByFile(int arg <<
238 { <<
239 // 3rd priority: in $HOME/.g4session <<
240 <<
241 // Find ~/.g4session - simply return if it d <<
242 const char* home = std::getenv("HOME"); <<
243 if (home == nullptr) return; <<
244 G4String homedir = home; <<
245 #ifndef WIN32 <<
246 G4String filename = homedir + "/.g4session"; <<
247 #else <<
248 G4String filename = homedir + "\\.g4session" <<
249 #endif <<
250 std::ifstream g4session(filename); <<
251 if (g4session.fail()) return; <<
252 <<
253 // Find app name <<
254 if (argc < 1) return; <<
255 G4String appInput = argv[0]; <<
256 G4String appName = ""; <<
257 size_t islash = appInput.find_last_of("/\\") <<
258 if (islash == G4String::npos) appName = appI <<
259 else appName = appInput.substr(islash + 1, a <<
260 <<
261 // Scan ~/.g4session <<
262 G4String line; <<
263 // First line is the user-chosen default: se <<
264 G4String applicableSession, applicableGraphi <<
265 std::getline(g4session,line); <<
266 auto hash = line.find_first_of('#'); line = <<
267 std::istringstream iss(line); <<
268 iss >> applicableSession >> applicableGraphi <<
269 // Read subsequent lines <<
270 while (g4session.good()) { <<
271 G4String app, session, graphicsSystem, win <<
272 std::getline(g4session,line); <<
273 hash = line.find_first_of('#'); line = lin <<
274 std::istringstream iss1(line); <<
275 iss1 >> app >> session >> graphicsSystem > <<
276 if (app == appName) { <<
277 if (!session.empty()) applicableS <<
278 if (!graphicsSystem.empty()) applicableG <<
279 if (!windowSizeHint.empty()) applicableW <<
280 } <<
281 } <<
282 <<
283 if (!applicableGraphicsSystem.empty()) { <<
284 fDefaultGraphicsSystemName = applicableGra <<
285 fDefaultGraphicsSystemBasis = "~/.g4sessio <<
286 fSelected = true; <<
287 } <<
288 if (!applicableWindowSizeHint.empty()) { <<
289 fDefaultXGeometryString = applicableWindow <<
290 fDefaultXGeometryStringBasis = "~/.g4sessi <<
291 } <<
292 } <<
293 <<
294 inline <<
295 void G4VisExecutive::SetDefaultsByBatch() <<
296 { <<
297 // 4th, special case for batch session <<
298 G4UIsession* session = G4UImanager::GetUIpoi <<
299 if (session == nullptr // <<
300 || dynamic_cast<G4UIbatch*>(session)) { // <<
301 // Actually, in this case, we wish to forc <<
302 fDefaultGraphicsSystemName = "NO_UI_SESSIO <<
303 fDefaultGraphicsSystemBasis = "no UI sessi <<
304 fSelected = true; // To prevent any furth <<
305 } <<
306 } <<
307 <<
308 inline <<
309 void G4VisExecutive::SetDefaultsByBuildFlags() <<
310 { <<
311 // 5th, by cpp flags <<
312 #if defined G4VIS_USE_OPENGLQT || G4VIS_USE_OP <<
313 G4VIS_USE_OPENGLX || G4VIS_USE_OP <<
314 fDefaultGraphicsSystemName = "OGL"; <<
315 #elif defined G4VIS_USE_OI || G4VIS_USE_OIX <<
316 fDefaultGraphicsSystemName = "OI"; <<
317 #elif defined G4VIS_USE_TOOLSSG_QT_GLES || G4V <<
318 G4VIS_USE_TOOLSSG_XT_GLES || G4V <<
319 fDefaultGraphicsSystemName = "TSG"; <<
320 #elif defined G4VIS_USE_VTK || G4VIS_USE_VTK_Q <<
321 fDefaultGraphicsSystemName = "Vtk"; <<
322 #elif defined G4VIS_USE_TOOLSSG_QT_ZB || G4VIS <<
323 G4VIS_USE_TOOLSSG_XT_ZB || G4VIS <<
324 fDefaultGraphicsSystemName = "TSG"; <<
325 #elif defined G4VIS_USE_QT3D <<
326 fDefaultGraphicsSystemName = "Qt3D"; <<
327 #else <<
328 // Choose a graphics system not needing exte <<
329 fDefaultGraphicsSystemName = "TSG_OFFSCREEN" <<
330 #endif <<
331 fDefaultGraphicsSystemBasis = "build flags"; <<
332 fSelected = true; <<
333 } <<
334 <<
335 inline <<
336 void G4VisExecutive::RegisterGraphicsSystems ( <<
337 <<
338 // Graphics Systems not needing external pack <<
339 RegisterGraphicsSystem (new G4ASCIITree); 122 RegisterGraphicsSystem (new G4ASCIITree);
340 RegisterGraphicsSystem (new G4DAWNFILE); 123 RegisterGraphicsSystem (new G4DAWNFILE);
>> 124 RegisterGraphicsSystem (new G4HepRep);
341 RegisterGraphicsSystem (new G4HepRepFile); 125 RegisterGraphicsSystem (new G4HepRepFile);
342 RegisterGraphicsSystem (new G4RayTracer); 126 RegisterGraphicsSystem (new G4RayTracer);
>> 127 RegisterGraphicsSystem (new G4VRML1File);
343 RegisterGraphicsSystem (new G4VRML2File); 128 RegisterGraphicsSystem (new G4VRML2File);
344 RegisterGraphicsSystem (new G4GMocrenFile); 129 RegisterGraphicsSystem (new G4GMocrenFile);
345 G4VGraphicsSystem* tsg_offscreen = new G4Too << 130 // Graphics systems needing external packages or libraries...
346 RegisterGraphicsSystem(tsg_offscreen); <<
347 tsg_offscreen->AddNickname("TSG_FILE"); <<
348 <<
349 // Graphics systems needing external packages <<
350 // Register OGL family of drivers with their n <<
351 // super-abbreviated names and fallback names <<
352 131
353 #ifdef G4VIS_USE_OPENGLQT << 132 #ifdef G4VIS_USE_DAWN
354 G4VGraphicsSystem* ogliqt = new G4OpenGLImme << 133 RegisterGraphicsSystem (new G4FukuiRenderer);
355 G4VGraphicsSystem* oglsqt = new G4OpenGLStor <<
356 RegisterGraphicsSystem(ogliqt); <<
357 RegisterGraphicsSystem(oglsqt); <<
358 ogliqt->AddNickname("OGLI"); <<
359 oglsqt->AddNickname("OGL"); <<
360 oglsqt->AddNickname("OGLS"); <<
361 #endif 134 #endif
362 135
363 #ifdef G4VIS_USE_OPENGLXM << 136 // Register OGL graphics system with generic nicknames.
364 G4VGraphicsSystem* oglixm = new G4OpenGLImme << 137 // Note: Any graphics system can be used with any UI session except
365 G4VGraphicsSystem* oglsxm = new G4OpenGLStor << 138 // OPENGLQT - this must have a UI Qt session unless in batch mode. This
366 RegisterGraphicsSystem(oglixm); << 139 // is handled in /vis/sceneHandler/create but a potential fallback is
367 RegisterGraphicsSystem(oglsxm); << 140 // defined here.
368 # ifdef G4VIS_USE_OPENGLQT << 141 #ifdef G4VIS_USE_OPENGL
369 oglixm->AddNickname("OGLIQt_FALLBACK"); << 142 G4VGraphicsSystem* ogl = 0;
370 oglsxm->AddNickname("OGLSQt_FALLBACK"); << 143 G4VGraphicsSystem* ogli = 0;
371 # else << 144 G4VGraphicsSystem* ogls = 0;
372 oglixm->AddNickname("OGLI"); << 145 G4VGraphicsSystem* ogl_fallback = 0;
373 oglsxm->AddNickname("OGL"); << 146 G4VGraphicsSystem* ogli_fallback = 0;
374 oglsxm->AddNickname("OGLS"); << 147 G4VGraphicsSystem* ogls_fallback = 0;
375 # endif << 148 #ifdef G4VIS_USE_OPENGLQT
>> 149 ogl = new G4OpenGLStoredQt;
>> 150 ogli = new G4OpenGLImmediateQt;
>> 151 ogls = new G4OpenGLStoredQt;
>> 152 #if defined G4VIS_USE_OPENGLXM
>> 153 ogl_fallback = new G4OpenGLStoredXm;
>> 154 ogli_fallback = new G4OpenGLImmediateXm;
>> 155 ogls_fallback = new G4OpenGLStoredXm;
>> 156 #elif defined G4VIS_USE_OPENGLX
>> 157 ogl_fallback = new G4OpenGLStoredX;
>> 158 ogli_fallback = new G4OpenGLImmediateX;
>> 159 ogls_fallback = new G4OpenGLStoredX;
>> 160 #elif defined G4VIS_USE_OPENGLWIN32
>> 161 ogl_fallback = new G4OpenGLStoredWin32;
>> 162 ogli_fallback = new G4OpenGLImmediateWin32;
>> 163 ogls_fallback = new G4OpenGLStoredWin32;
>> 164 #endif
>> 165 #elif defined G4VIS_USE_OPENGLWT
>> 166 ogl = new G4OpenGLImmediateWt;
>> 167 ogli = new G4OpenGLImmediateWt;
>> 168 ogls = new G4OpenGLImmediateWt;
>> 169 #elif defined G4VIS_USE_OPENGLXM
>> 170 ogl = new G4OpenGLStoredXm;
>> 171 ogli = new G4OpenGLImmediateXm;
>> 172 ogls = new G4OpenGLStoredXm;
>> 173 #elif defined G4VIS_USE_OPENGLWIN32
>> 174 ogl = new G4OpenGLStoredWin32;
>> 175 ogli = new G4OpenGLImmediateWin32;
>> 176 ogls = new G4OpenGLStoredWin32;
>> 177 #elif defined G4VIS_USE_OPENGLX
>> 178 ogl = new G4OpenGLStoredX;
>> 179 ogli = new G4OpenGLImmediateX;
>> 180 ogls = new G4OpenGLStoredX;
>> 181 #endif
>> 182 if (ogl) {
>> 183 ogl->SetNickname("OGL");
>> 184 RegisterGraphicsSystem (ogl);
>> 185 }
>> 186 if (ogli) {
>> 187 ogli->SetNickname("OGLI");
>> 188 RegisterGraphicsSystem (ogli);
>> 189 }
>> 190 if (ogls) {
>> 191 ogls->SetNickname("OGLS");
>> 192 RegisterGraphicsSystem (ogls);
>> 193 }
>> 194 if (ogl_fallback) {
>> 195 ogl_fallback->SetNickname("OGL_FALLBACK");
>> 196 RegisterGraphicsSystem (ogl_fallback);
>> 197 }
>> 198 if (ogli_fallback) {
>> 199 ogli_fallback->SetNickname("OGLI_FALLBACK");
>> 200 RegisterGraphicsSystem (ogli_fallback);
>> 201 }
>> 202 if (ogls_fallback) {
>> 203 ogls_fallback->SetNickname("OGLS_FALLBACK");
>> 204 RegisterGraphicsSystem (ogls_fallback);
>> 205 }
376 #endif 206 #endif
377 207
378 #ifdef G4VIS_USE_OPENGLX 208 #ifdef G4VIS_USE_OPENGLX
379 G4VGraphicsSystem* oglix = new G4OpenGLImmed << 209 RegisterGraphicsSystem (new G4OpenGLImmediateX);
380 G4VGraphicsSystem* oglsx = new G4OpenGLStore << 210 RegisterGraphicsSystem (new G4OpenGLStoredX);
381 RegisterGraphicsSystem(oglix); <<
382 RegisterGraphicsSystem(oglsx); <<
383 # ifdef G4VIS_USE_OPENGLQT <<
384 oglix->AddNickname("OGLIQt_FALLBACK"); <<
385 oglsx->AddNickname("OGLSQt_FALLBACK"); <<
386 # endif <<
387 # ifdef G4VIS_USE_OPENGLXM <<
388 oglix->AddNickname("OGLIXm_FALLBACK"); <<
389 oglsx->AddNickname("OGLSXm_FALLBACK"); <<
390 # endif <<
391 # if defined(G4VIS_USE_OPENGLQT) || (G4VIS_US <<
392 # else <<
393 oglix->AddNickname("OGLI"); <<
394 oglsx->AddNickname("OGL"); <<
395 oglsx->AddNickname("OGLS"); <<
396 # endif <<
397 #endif 211 #endif
398 212
399 #ifdef G4VIS_USE_OPENGLWIN32 213 #ifdef G4VIS_USE_OPENGLWIN32
400 G4VGraphicsSystem* ogliwin32 = new G4OpenGLI << 214 RegisterGraphicsSystem (new G4OpenGLImmediateWin32);
401 G4VGraphicsSystem* oglswin32 = new G4OpenGLS << 215 RegisterGraphicsSystem (new G4OpenGLStoredWin32);
402 RegisterGraphicsSystem(ogliwin32); <<
403 RegisterGraphicsSystem(oglswin32); <<
404 # ifdef G4VIS_USE_OPENGLQT <<
405 ogliwin32->AddNickname("OGLIQt_FALLBACK"); <<
406 oglswin32->AddNickname("OGLSQt_FALLBACK"); <<
407 # else <<
408 ogliwin32->AddNickname("OGLI"); <<
409 oglswin32->AddNickname("OGL"); <<
410 oglswin32->AddNickname("OGLS"); <<
411 # endif <<
412 #endif <<
413 <<
414 // Register OI graphics system with super-abbr <<
415 #ifdef G4VIS_USE_OI <<
416 G4VGraphicsSystem* oi = 0; <<
417 # ifdef G4VIS_USE_OIX <<
418 oi = new G4OpenInventorX; <<
419 # elif defined(G4VIS_USE_OIQT) <<
420 oi = new G4OpenInventorQt; <<
421 # elif defined(G4VIS_USE_OIWIN32) <<
422 oi = new G4OpenInventorWin32; <<
423 # endif <<
424 if(oi) <<
425 { <<
426 RegisterGraphicsSystem(oi); <<
427 oi->AddNickname("OI"); <<
428 } <<
429 #endif 216 #endif
430 217
431 // The new, extended OI is registered separate << 218 #ifdef G4VIS_USE_OPENGLXM
432 #ifdef G4VIS_USE_OIX << 219 RegisterGraphicsSystem (new G4OpenGLImmediateXm);
433 RegisterGraphicsSystem(new G4OpenInventorXtE << 220 RegisterGraphicsSystem (new G4OpenGLStoredXm);
434 #endif <<
435 <<
436 #ifdef G4VIS_USE_RAYTRACERX <<
437 RegisterGraphicsSystem(new G4RayTracerX); <<
438 #endif <<
439 <<
440 #ifdef G4VIS_USE_QT3D <<
441 RegisterGraphicsSystem(new G4Qt3D); <<
442 #endif 221 #endif
443 222
444 #ifdef G4VIS_USE_TOOLSSG_X11_GLES << 223 #ifdef G4VIS_USE_OPENGLQT
445 G4VGraphicsSystem* tsg_x11_gles = new G4Tool << 224 G4VGraphicsSystem* gsi = new G4OpenGLImmediateQt;
446 RegisterGraphicsSystem(tsg_x11_gles); << 225 G4VGraphicsSystem* gss = new G4OpenGLStoredQt;
447 tsg_x11_gles->AddNickname("TSGX11"); << 226 RegisterGraphicsSystem (gsi);
448 #ifdef G4VIS_USE_TOOLSSG_XT_GLES << 227 RegisterGraphicsSystem (gss);
449 tsg_x11_gles->AddNickname("TSG_XT_GLES_FALLB << 228 G4VGraphicsSystem* gsi_fallback = 0;
450 #endif << 229 G4VGraphicsSystem* gss_fallback = 0;
451 #ifdef G4VIS_USE_TOOLSSG_QT_GLES << 230 #if defined G4VIS_USE_OPENGLXM
452 #ifndef G4VIS_USE_TOOLSSG_XT_GLES << 231 gsi_fallback = new G4OpenGLImmediateXm;
453 tsg_x11_gles->AddNickname("TSG_QT_GLES_FALLB << 232 gss_fallback = new G4OpenGLStoredXm;
454 #endif << 233 #elif defined G4VIS_USE_OPENGLX
455 #endif << 234 gsi_fallback = new G4OpenGLImmediateX;
>> 235 gss_fallback = new G4OpenGLStoredX;
>> 236 #elif defined G4VIS_USE_OPENGLWIN32
>> 237 gsi_fallback = new G4OpenGLImmediateWin32;
>> 238 gss_fallback = new G4OpenGLStoredWin32;
>> 239 #endif
>> 240 if (gsi_fallback) {
>> 241 gsi_fallback->SetNickname(gsi->GetNickname()+"_FALLBACK");
>> 242 RegisterGraphicsSystem (gsi_fallback);
>> 243 }
>> 244 if (gss_fallback) {
>> 245 gss_fallback->SetNickname(gss->GetNickname()+"_FALLBACK");
>> 246 RegisterGraphicsSystem (gss_fallback);
>> 247 }
456 #endif 248 #endif
457 249
458 #ifdef G4VIS_USE_TOOLSSG_X11_ZB << 250 #ifdef G4VIS_USE_OPENGLWT
459 G4VGraphicsSystem* tsg_x11_zb = new G4ToolsS << 251 RegisterGraphicsSystem (new G4OpenGLImmediateWt);
460 RegisterGraphicsSystem(tsg_x11_zb); <<
461 tsg_x11_zb->AddNickname("TSGX11ZB"); <<
462 #endif 252 #endif
463 253
464 #ifdef G4VIS_USE_TOOLSSG_XT_GLES << 254 // Register OI graphics system with generic nickname
465 G4VGraphicsSystem* tsg_xt_gles = new G4Tools << 255 #ifdef G4VIS_USE_OI
466 RegisterGraphicsSystem(tsg_xt_gles); << 256 G4VGraphicsSystem* oi = 0;
467 tsg_xt_gles->AddNickname("TSGXt"); << 257 #ifdef G4VIS_USE_OIX
468 #ifdef G4VIS_USE_TOOLSSG_QT_GLES << 258 oi = new G4OpenInventorX;
469 tsg_xt_gles->AddNickname("TSG_QT_GLES_FALLBA <<
470 #endif <<
471 #endif 259 #endif
472 << 260 #ifdef G4VIS_USE_OIWIN32
473 #ifdef G4VIS_USE_TOOLSSG_XT_ZB << 261 oi = new G4OpenInventorWin32;
474 G4VGraphicsSystem* tsg_xt_zb = new G4ToolsSG <<
475 RegisterGraphicsSystem(tsg_xt_zb); <<
476 tsg_xt_zb->AddNickname("TSGXtZB"); <<
477 #endif 262 #endif
478 << 263 if (oi) {
479 #ifdef G4VIS_USE_TOOLSSG_QT_GLES << 264 oi->SetNickname("OI");
480 G4VGraphicsSystem* tsg_qt_gles = new G4Tools << 265 RegisterGraphicsSystem (oi);
481 RegisterGraphicsSystem(tsg_qt_gles); << 266 }
482 tsg_qt_gles->AddNickname("TSGQt"); <<
483 #endif 267 #endif
484 268
485 #ifdef G4VIS_USE_TOOLSSG_QT_ZB << 269 #ifdef G4VIS_USE_OIX
486 G4VGraphicsSystem* tsg_qt_zb = new G4ToolsSG << 270 RegisterGraphicsSystem (new G4OpenInventorX);
487 RegisterGraphicsSystem(tsg_qt_zb); << 271 RegisterGraphicsSystem (new G4OpenInventorXtExtended);
488 tsg_qt_zb->AddNickname("TSGQtZB"); <<
489 #endif 272 #endif
490 273
491 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_GLES << 274 #ifdef G4VIS_USE_OIWIN32
492 G4VGraphicsSystem* tsg_windows_gles = new G4 << 275 RegisterGraphicsSystem (new G4OpenInventorWin32);
493 RegisterGraphicsSystem(tsg_windows_gles); <<
494 #endif 276 #endif
495 277
496 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_ZB << 278 #ifdef G4VIS_USE_RAYTRACERX
497 G4VGraphicsSystem* tsg_windows_zb = new G4To << 279 RegisterGraphicsSystem (new G4RayTracerX);
498 RegisterGraphicsSystem(tsg_windows_zb); <<
499 #endif 280 #endif
500 281
501 #ifdef G4VIS_USE_TOOLSSG_QT_GLES << 282 #ifdef G4VIS_USE_VRML
502 tsg_qt_gles->AddNickname("TSG"); << 283 RegisterGraphicsSystem (new G4VRML1);
503 #elif defined(G4VIS_USE_TOOLSSG_XT_GLES) << 284 RegisterGraphicsSystem (new G4VRML2);
504 tsg_xt_gles->AddNickname("TSG"); <<
505 #elif defined(G4VIS_USE_TOOLSSG_X11_GLES) <<
506 tsg_x11_gles->AddNickname("TSG"); <<
507 #elif defined(G4VIS_USE_TOOLSSG_WINDOWS_GLES) <<
508 tsg_windows_gles->AddNickname("TSG"); <<
509 #else <<
510 #ifdef G4VIS_USE_TOOLSSG_QT_ZB <<
511 tsg_qt_zb->AddNickname("TSG"); <<
512 #elif G4VIS_USE_TOOLSSG_WINDOWS_ZB <<
513 tsg_windows_zb->AddNickname("TSG"); <<
514 #else <<
515 tsg_offscreen->AddNickname("TSG"); <<
516 #endif <<
517 #endif 285 #endif
518 286
519 #ifdef G4VIS_USE_VTK <<
520 if (GetVerbosity() >= startup) { <<
521 G4cout <<
522 << " VTK: OpenGL-based drivers suppressed <<
523 << G4endl; <<
524 } <<
525 G4Vtk* vtkN = new G4Vtk(); <<
526 G4VtkOffscreen* vtkOS = new G4VtkOffscreen() <<
527 RegisterGraphicsSystem(vtkN); <<
528 RegisterGraphicsSystem(vtkOS); <<
529 # ifdef G4VIS_USE_VTK_QT <<
530 vtkN->AddNickname("VTKQt_FALLBACK"); <<
531 # endif <<
532 #endif <<
533 <<
534 #ifdef G4VIS_USE_VTK_QT <<
535 G4VtkQt* vtkQt = new G4VtkQt(); <<
536 RegisterGraphicsSystem(vtkQt); <<
537 vtkQt->AddNickname("VTKQt"); <<
538 #endif <<
539 <<
540 #ifdef G4VIS_USE_VTK_QT <<
541 vtkQt->AddNickname("Vtk"); <<
542 vtkQt->AddNickname("VTK"); <<
543 #elif defined(G4VIS_USE_VTK) <<
544 vtkN->AddNickname("Vtk"); <<
545 vtkN->AddNickname("VTK"); <<
546 #endif <<
547 } 287 }
548 288
549 // See comments about inlining above. 289 // See comments about inlining above.
550 inline void << 290 inline void
551 G4VisExecutive::RegisterModelFactories() 291 G4VisExecutive::RegisterModelFactories()
552 { 292 {
553 // Trajectory draw models 293 // Trajectory draw models
554 RegisterModelFactory(new G4TrajectoryGeneri << 294 RegisterModelFactory(new G4TrajectoryGenericDrawerFactory());
555 RegisterModelFactory(new G4TrajectoryDrawBy <<
556 RegisterModelFactory(new G4TrajectoryDrawBy 295 RegisterModelFactory(new G4TrajectoryDrawByChargeFactory());
557 RegisterModelFactory(new G4TrajectoryDrawBy <<
558 RegisterModelFactory(new G4TrajectoryDrawBy 296 RegisterModelFactory(new G4TrajectoryDrawByParticleIDFactory());
559 RegisterModelFactory(new G4TrajectoryDrawBy << 297 RegisterModelFactory(new G4TrajectoryDrawByOriginVolumeFactory());
>> 298 RegisterModelFactory(new G4TrajectoryDrawByAttributeFactory());
560 299
561 // Trajectory filter models 300 // Trajectory filter models
562 RegisterModelFactory(new G4TrajectoryAttrib <<
563 RegisterModelFactory(new G4TrajectoryCharge 301 RegisterModelFactory(new G4TrajectoryChargeFilterFactory());
564 RegisterModelFactory(new G4TrajectoryOrigin <<
565 RegisterModelFactory(new G4TrajectoryPartic 302 RegisterModelFactory(new G4TrajectoryParticleFilterFactory());
566 RegisterModelFactory(new G4TrajectoryEncoun << 303 RegisterModelFactory(new G4TrajectoryOriginVolumeFilterFactory());
>> 304 RegisterModelFactory(new G4TrajectoryAttributeFilterFactory());
567 305
568 // Hit filter models 306 // Hit filter models
569 RegisterModelFactory(new G4HitAttributeFilt 307 RegisterModelFactory(new G4HitAttributeFilterFactory());
570 308
571 // Digi filter models 309 // Digi filter models
572 RegisterModelFactory(new G4DigiAttributeFil 310 RegisterModelFactory(new G4DigiAttributeFilterFactory());
573 } 311 }
574 312
575 #endif 313 #endif
576 314