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