| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 //
29 // John Allison 24th January 1998.
30
31 #ifndef G4VISEXECUTIVE_ICC
32 #define G4VISEXECUTIVE_ICC
33
34 // Filter/Model Factories
35 #include "G4HitFilterFactories.hh"
36 #include "G4DigiFilterFactories.hh"
37 #include "G4TrajectoryFilterFactories.hh"
38 #include "G4TrajectoryModelFactories.hh"
39
40 // Supported drivers...
41 // Not needing external packages or libraries.
42 #include "G4ASCIITree.hh" // no_geant4_
43 #include "G4DAWNFILE.hh" // no_geant4_
44 #include "G4HepRepFile.hh" // no_geant4_
45 #include "G4RayTracer.hh" // no_geant4_
46 #include "G4VRML2File.hh" // no_geant4_
47 #include "G4GMocrenFile.hh" // no_geant4_
48 #include "G4ToolsSGOffscreen.hh" // no_geant4_
49
50 // Needing external packages or libraries...
51 #ifdef G4VIS_USE_OPENGLX
52 #include "G4OpenGLImmediateX.hh" // no_geant4_
53 #include "G4OpenGLStoredX.hh" // no_geant4_
54 #endif
55
56 #ifdef G4VIS_USE_OPENGLWIN32
57 #include "G4OpenGLImmediateWin32.hh" // no_gea
58 #include "G4OpenGLStoredWin32.hh" // no_gea
59 #endif
60
61 #ifdef G4VIS_USE_OPENGLXM
62 #include "G4OpenGLImmediateXm.hh" // no_geant4
63 #include "G4OpenGLStoredXm.hh" // no_geant4
64 #endif
65
66 #ifdef G4VIS_USE_OPENGLQT
67 #include "G4OpenGLImmediateQt.hh" // no_geant4
68 #include "G4OpenGLStoredQt.hh" // no_geant4
69 #endif
70
71 #ifdef G4VIS_USE_OIX
72 #include "G4OpenInventorX.hh" // no_g
73 #include "G4OpenInventorXtExtended.hh" // no_g
74 #endif
75
76 #ifdef G4VIS_USE_OIQT
77 #include "G4OpenInventorQt.hh" // no_geant4_mo
78 #endif
79
80 #ifdef G4VIS_USE_OIWIN32
81 #include "G4OpenInventorWin32.hh" // no_geant4
82 #endif
83
84 #ifdef G4VIS_USE_RAYTRACERX
85 #include "G4RayTracerX.hh" // no_geant4_module
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
136
137 #ifdef G4VIS_USE_VTK_QT
138 #include "G4VtkQt.hh" // no_geant4_module_chec
139 #endif
140
141 #include "G4UImanager.hh"
142 #include "G4UIsession.hh"
143 #include "G4UIbatch.hh"
144
145 #include <cstdlib>
146 #include <sstream>
147
148 #define G4warn G4cout
149
150 // The inline keyword prevents the compiler ma
151 // reference even though they cannot actually
152 // are virtual functions. This prevents a "mu
153 // if it is included in more than one file. H
154 // the class description in G4VisExecutive.hh,
155 // necessary to #include "G4VisExecutive.hh" i
156 // since after instantiation the object can be
157 // G4VisManager.
158
159 inline
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);
340 RegisterGraphicsSystem (new G4DAWNFILE);
341 RegisterGraphicsSystem (new G4HepRepFile);
342 RegisterGraphicsSystem (new G4RayTracer);
343 RegisterGraphicsSystem (new G4VRML2File);
344 RegisterGraphicsSystem (new G4GMocrenFile);
345 G4VGraphicsSystem* tsg_offscreen = new G4Too
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
353 #ifdef G4VIS_USE_OPENGLQT
354 G4VGraphicsSystem* ogliqt = new G4OpenGLImme
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
362
363 #ifdef G4VIS_USE_OPENGLXM
364 G4VGraphicsSystem* oglixm = new G4OpenGLImme
365 G4VGraphicsSystem* oglsxm = new G4OpenGLStor
366 RegisterGraphicsSystem(oglixm);
367 RegisterGraphicsSystem(oglsxm);
368 # ifdef G4VIS_USE_OPENGLQT
369 oglixm->AddNickname("OGLIQt_FALLBACK");
370 oglsxm->AddNickname("OGLSQt_FALLBACK");
371 # else
372 oglixm->AddNickname("OGLI");
373 oglsxm->AddNickname("OGL");
374 oglsxm->AddNickname("OGLS");
375 # endif
376 #endif
377
378 #ifdef G4VIS_USE_OPENGLX
379 G4VGraphicsSystem* oglix = new G4OpenGLImmed
380 G4VGraphicsSystem* oglsx = new G4OpenGLStore
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
398
399 #ifdef G4VIS_USE_OPENGLWIN32
400 G4VGraphicsSystem* ogliwin32 = new G4OpenGLI
401 G4VGraphicsSystem* oglswin32 = new G4OpenGLS
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
430
431 // The new, extended OI is registered separate
432 #ifdef G4VIS_USE_OIX
433 RegisterGraphicsSystem(new G4OpenInventorXtE
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
443
444 #ifdef G4VIS_USE_TOOLSSG_X11_GLES
445 G4VGraphicsSystem* tsg_x11_gles = new G4Tool
446 RegisterGraphicsSystem(tsg_x11_gles);
447 tsg_x11_gles->AddNickname("TSGX11");
448 #ifdef G4VIS_USE_TOOLSSG_XT_GLES
449 tsg_x11_gles->AddNickname("TSG_XT_GLES_FALLB
450 #endif
451 #ifdef G4VIS_USE_TOOLSSG_QT_GLES
452 #ifndef G4VIS_USE_TOOLSSG_XT_GLES
453 tsg_x11_gles->AddNickname("TSG_QT_GLES_FALLB
454 #endif
455 #endif
456 #endif
457
458 #ifdef G4VIS_USE_TOOLSSG_X11_ZB
459 G4VGraphicsSystem* tsg_x11_zb = new G4ToolsS
460 RegisterGraphicsSystem(tsg_x11_zb);
461 tsg_x11_zb->AddNickname("TSGX11ZB");
462 #endif
463
464 #ifdef G4VIS_USE_TOOLSSG_XT_GLES
465 G4VGraphicsSystem* tsg_xt_gles = new G4Tools
466 RegisterGraphicsSystem(tsg_xt_gles);
467 tsg_xt_gles->AddNickname("TSGXt");
468 #ifdef G4VIS_USE_TOOLSSG_QT_GLES
469 tsg_xt_gles->AddNickname("TSG_QT_GLES_FALLBA
470 #endif
471 #endif
472
473 #ifdef G4VIS_USE_TOOLSSG_XT_ZB
474 G4VGraphicsSystem* tsg_xt_zb = new G4ToolsSG
475 RegisterGraphicsSystem(tsg_xt_zb);
476 tsg_xt_zb->AddNickname("TSGXtZB");
477 #endif
478
479 #ifdef G4VIS_USE_TOOLSSG_QT_GLES
480 G4VGraphicsSystem* tsg_qt_gles = new G4Tools
481 RegisterGraphicsSystem(tsg_qt_gles);
482 tsg_qt_gles->AddNickname("TSGQt");
483 #endif
484
485 #ifdef G4VIS_USE_TOOLSSG_QT_ZB
486 G4VGraphicsSystem* tsg_qt_zb = new G4ToolsSG
487 RegisterGraphicsSystem(tsg_qt_zb);
488 tsg_qt_zb->AddNickname("TSGQtZB");
489 #endif
490
491 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_GLES
492 G4VGraphicsSystem* tsg_windows_gles = new G4
493 RegisterGraphicsSystem(tsg_windows_gles);
494 #endif
495
496 #ifdef G4VIS_USE_TOOLSSG_WINDOWS_ZB
497 G4VGraphicsSystem* tsg_windows_zb = new G4To
498 RegisterGraphicsSystem(tsg_windows_zb);
499 #endif
500
501 #ifdef G4VIS_USE_TOOLSSG_QT_GLES
502 tsg_qt_gles->AddNickname("TSG");
503 #elif defined(G4VIS_USE_TOOLSSG_XT_GLES)
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
518
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 }
548
549 // See comments about inlining above.
550 inline void
551 G4VisExecutive::RegisterModelFactories()
552 {
553 // Trajectory draw models
554 RegisterModelFactory(new G4TrajectoryGeneri
555 RegisterModelFactory(new G4TrajectoryDrawBy
556 RegisterModelFactory(new G4TrajectoryDrawBy
557 RegisterModelFactory(new G4TrajectoryDrawBy
558 RegisterModelFactory(new G4TrajectoryDrawBy
559 RegisterModelFactory(new G4TrajectoryDrawBy
560
561 // Trajectory filter models
562 RegisterModelFactory(new G4TrajectoryAttrib
563 RegisterModelFactory(new G4TrajectoryCharge
564 RegisterModelFactory(new G4TrajectoryOrigin
565 RegisterModelFactory(new G4TrajectoryPartic
566 RegisterModelFactory(new G4TrajectoryEncoun
567
568 // Hit filter models
569 RegisterModelFactory(new G4HitAttributeFilt
570
571 // Digi filter models
572 RegisterModelFactory(new G4DigiAttributeFil
573 }
574
575 #endif
576