source: trunk/source/visualization/OpenGL/src/G4OpenGLViewerMessenger.cc@ 1347

Last change on this file since 1347 was 1343, checked in by garnier, 15 years ago

HEAD
  • Property svn:mime-type set to text/cpp
File size: 18.7 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4OpenGLViewerMessenger.cc,v 1.21 2010/11/07 10:31:26 allison Exp $
28// GEANT4 tag $Name: $
29
30#ifdef G4VIS_BUILD_OPENGL_DRIVER
31
32#include "G4OpenGLViewerMessenger.hh"
33
34#include "G4OpenGLViewer.hh"
35#include "G4OpenGLStoredViewer.hh"
36#include "G4UImanager.hh"
37#include "G4UIcommand.hh"
38#include "G4UIdirectory.hh"
39#include "G4UIcmdWithoutParameter.hh"
40#include "G4UIcmdWithADouble.hh"
41#include "G4UIcmdWithABool.hh"
42#include "G4UIcmdWithAString.hh"
43#include "G4UIcmdWithAnInteger.hh"
44#include "G4VisManager.hh"
45#include <sstream>
46
47G4OpenGLViewerMessenger*
48G4OpenGLViewerMessenger::fpInstance = 0;
49
50G4OpenGLViewerMessenger*
51G4OpenGLViewerMessenger::GetInstance()
52{
53 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
54 return fpInstance;
55}
56
57G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
58{
59 G4bool omitable;
60
61 fpDirectory = new G4UIdirectory("/vis/ogl/");
62 fpDirectory->SetGuidance("G4OpenGLViewer commands.");
63
64 fpCommandPrintEPS =
65 new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
66 fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
67 fpCommandPrintEPS->SetGuidance
68 ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
69 "\nnumber, starting at 0."
70 "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
71
72 fpCommandPrintSize =
73 new G4UIcommand("/vis/ogl/set/printSize", this);
74 fpCommandPrintSize->SetGuidance ("Set print size");
75 fpCommandPrintSize->SetGuidance ("Tip : -1 will mean 'print size' = 'window size'");
76 fpCommandPrintSize->SetGuidance (" Setting size greatter than your maximum graphic card capacity , will set the size to maximum size.");
77 G4UIparameter* parameterPrintSize;
78 parameterPrintSize = new G4UIparameter ("width", 'd', omitable = false);
79 parameterPrintSize->SetDefaultValue(-1);
80 fpCommandPrintSize->SetParameter(parameterPrintSize);
81 parameterPrintSize = new G4UIparameter ("height", 'd', omitable = false);
82 parameterPrintSize->SetDefaultValue(-1);
83 fpCommandPrintSize->SetParameter(parameterPrintSize);
84
85 fpCommandPrintFilename =
86 new G4UIcommand("/vis/ogl/set/printFilename", this);
87 fpCommandPrintFilename->SetGuidance ("Set print filename");
88 fpCommandPrintFilename->SetGuidance ("Setting 'incremental' will increment filename by one at each new print, starting at 0");
89 G4UIparameter* parameterPrintFilename;
90 parameterPrintFilename = new G4UIparameter ("name", 's', omitable = true);
91 parameterPrintFilename->SetDefaultValue("G4OpenGL");
92 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
93 parameterPrintFilename = new G4UIparameter ("incremental", 'b', omitable = true);
94 parameterPrintFilename->SetDefaultValue(1);
95 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
96
97 fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
98 fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
99
100 G4UIparameter* parameter;
101
102 fpCommandDisplayHeadTime =
103 new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
104 fpCommandDisplayHeadTime->SetGuidance
105 ("Display head time of range in 2D text.");
106 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
107 parameter->SetDefaultValue(false);
108 fpCommandDisplayHeadTime->SetParameter(parameter);
109 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
110 parameter->SetGuidance("-1 < screenX < 1");
111 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
112 parameter->SetDefaultValue(-0.9);
113 fpCommandDisplayHeadTime->SetParameter(parameter);
114 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
115 parameter->SetGuidance("-1 < screenY < 1");
116 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
117 parameter->SetDefaultValue(-0.9);
118 fpCommandDisplayHeadTime->SetParameter(parameter);
119 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
120 parameter->SetDefaultValue(24.);
121 fpCommandDisplayHeadTime->SetParameter(parameter);
122 parameter = new G4UIparameter ("red", 'd', omitable = true);
123 parameter->SetParameterRange("red >= 0. && red <= 1.");
124 parameter->SetDefaultValue(0.);
125 fpCommandDisplayHeadTime->SetParameter(parameter);
126 parameter = new G4UIparameter ("green", 'd', omitable = true);
127 parameter->SetParameterRange("green >= 0. && green <= 1.");
128 parameter->SetDefaultValue(1.);
129 fpCommandDisplayHeadTime->SetParameter(parameter);
130 parameter = new G4UIparameter ("blue", 'd', omitable = true);
131 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
132 parameter->SetDefaultValue(1.);
133 fpCommandDisplayHeadTime->SetParameter(parameter);
134
135 fpCommandDisplayLightFront =
136 new G4UIcommand("/vis/ogl/set/displayLightFront", this);
137 fpCommandDisplayLightFront->SetGuidance
138 ("Display the light front at head time.");
139 fpCommandDisplayLightFront->SetGuidance
140 ("Tip: The trajectories can appear of jump ahead of the light front"
141 "\nbecause their time range overlaps the viewer's time range. To"
142 "\naverage out this discrete time effect, advance the light front by"
143 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
144 "\ninterval is 0.01 ns:"
145 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
146 "\nTo prevent them beating the light front at all:"
147 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
148 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
149 parameter->SetDefaultValue(false);
150 fpCommandDisplayLightFront->SetParameter(parameter);
151 parameter = new G4UIparameter ("originX", 'd', omitable = true);
152 parameter->SetDefaultValue(0.);
153 fpCommandDisplayLightFront->SetParameter(parameter);
154 parameter = new G4UIparameter ("originY", 'd', omitable = true);
155 parameter->SetDefaultValue(0.);
156 fpCommandDisplayLightFront->SetParameter(parameter);
157 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
158 parameter->SetDefaultValue(0.);
159 fpCommandDisplayLightFront->SetParameter(parameter);
160 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
161 parameter->SetDefaultValue("m");
162 fpCommandDisplayLightFront->SetParameter(parameter);
163 parameter = new G4UIparameter ("originT", 'd', omitable = true);
164 parameter->SetDefaultValue(0.);
165 fpCommandDisplayLightFront->SetParameter(parameter);
166 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
167 parameter->SetDefaultValue("s");
168 fpCommandDisplayLightFront->SetParameter(parameter);
169 parameter = new G4UIparameter ("red", 'd', omitable = true);
170 parameter->SetParameterRange("red >= 0. && red <= 1.");
171 parameter->SetDefaultValue(0.);
172 fpCommandDisplayLightFront->SetParameter(parameter);
173 parameter = new G4UIparameter ("green", 'd', omitable = true);
174 parameter->SetParameterRange("green >= 0. && green <= 1.");
175 parameter->SetDefaultValue(1.);
176 fpCommandDisplayLightFront->SetParameter(parameter);
177 parameter = new G4UIparameter ("blue", 'd', omitable = true);
178 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
179 parameter->SetDefaultValue(0.);
180 fpCommandDisplayLightFront->SetParameter(parameter);
181
182 fpCommandDisplayListLimit =
183 new G4UIcmdWithAnInteger("/vis/ogl/set/displayListLimit", this);
184 fpCommandDisplayListLimit->SetGuidance
185 ("Set/reset display list limit (to avoid memory exhaustion).");
186 fpCommandDisplayListLimit->SetParameterName("limit", omitable = true);
187 fpCommandDisplayListLimit->SetDefaultValue(50000);
188 fpCommandDisplayListLimit->SetRange("limit>=10000");
189
190 fpCommandEndTime =
191 new G4UIcommand("/vis/ogl/set/endTime", this);
192 fpCommandEndTime->SetGuidance("Set end and range of track time.");
193 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
194 parameter->SetDefaultValue(DBL_MAX);
195 fpCommandEndTime->SetParameter(parameter);
196 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
197 parameter->SetDefaultValue("ns");
198 fpCommandEndTime->SetParameter(parameter);
199 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
200 parameter->SetDefaultValue(-1.);
201 fpCommandEndTime->SetParameter(parameter);
202 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
203 parameter->SetDefaultValue("ns");
204 fpCommandEndTime->SetParameter(parameter);
205
206 fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
207 fpCommandFade->SetGuidance
208 ("0: no fade; 1: maximum fade with time within range.");
209 fpCommandFade->SetParameterName("fadefactor", omitable = false);
210 fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
211 fpCommandFade->SetDefaultValue(0.);
212
213 fpCommandPrintMode = new G4UIcmdWithAString
214 ("/vis/ogl/set/printMode",this);
215 fpCommandPrintMode->SetGuidance("Set print mode");
216 fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
217 fpCommandPrintMode->SetCandidates("vectored pixmap");
218 fpCommandPrintMode->SetDefaultValue("vectored");
219
220 fpCommandStartTime =
221 new G4UIcommand("/vis/ogl/set/startTime", this);
222 fpCommandStartTime->SetGuidance("Set start and range of track time.");
223 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
224 parameter->SetDefaultValue(-DBL_MAX);
225 fpCommandStartTime->SetParameter(parameter);
226 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
227 parameter->SetDefaultValue("ns");
228 fpCommandStartTime->SetParameter(parameter);
229 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
230 parameter->SetDefaultValue(-1.);
231 fpCommandStartTime->SetParameter(parameter);
232 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
233 parameter->SetDefaultValue("ns");
234 fpCommandStartTime->SetParameter(parameter);
235
236 fpCommandTransparency =
237 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
238 fpCommandTransparency->SetGuidance
239 ("True/false to enable/disable rendering of transparent objects.");
240 fpCommandTransparency->SetParameterName
241 ("transparency-enabled", omitable = true);
242 fpCommandTransparency->SetDefaultValue(true);
243}
244
245G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
246{
247 delete fpCommandPrintMode;
248 delete fpCommandTransparency;
249 delete fpCommandStartTime;
250 delete fpCommandFade;
251 delete fpCommandEndTime;
252 delete fpCommandDisplayListLimit;
253 delete fpCommandDisplayLightFront;
254 delete fpCommandDisplayHeadTime;
255 delete fpDirectorySet;
256 delete fpCommandPrintEPS;
257 delete fpDirectory;
258
259 delete fpInstance;
260}
261
262void G4OpenGLViewerMessenger::SetNewValue
263(G4UIcommand* command, G4String newValue)
264{
265 G4VisManager* pVisManager = G4VisManager::GetInstance();
266
267 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
268
269 if (!pViewer) {
270 G4cout <<
271 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
272 "\n \"/vis/open\", or similar, to get one."
273 << G4endl;
274 return;
275 }
276
277 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
278
279 if (!pOGLViewer) {
280 G4cout <<
281 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
282 "\n OGL. (It is \""
283 << pViewer->GetName() <<
284 "\".)\n Use \"/vis/viewer/select\" or \"/vis/open\"."
285 << G4endl;
286 return;
287 }
288
289 if (command == fpCommandPrintEPS)
290 {
291 pOGLViewer->printEPS();
292 return;
293 }
294
295 if (command == fpCommandPrintSize)
296 {
297 G4int width,height;
298 std::istringstream iss(newValue);
299 iss >> width
300 >> height;
301 pOGLViewer->setPrintSize(width,height);
302 }
303
304 if (command == fpCommandPrintFilename)
305 {
306 G4String name;
307 G4bool inc;
308 std::istringstream iss(newValue);
309 iss >> name
310 >> inc;
311 pOGLViewer->setPrintFilename(name,inc);
312 }
313
314 if (command == fpCommandPrintMode)
315 {
316 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
317 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
318 return;
319 }
320
321 if (command == fpCommandTransparency)
322 {
323 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
324 if (pOGLViewer->fVP.IsAutoRefresh())
325 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
326 return;
327 }
328
329 G4OpenGLStoredViewer* pOGLSViewer =
330 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
331
332 if (!pOGLSViewer)
333 {
334 G4cout <<
335 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
336 "\n (It is \"" << pViewer->GetName() << "\".)"
337 "\n This feature is only implemented for OGL Stored viewers."
338 "\n Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
339 << G4endl;
340 return;
341 }
342
343 if (command == fpCommandDisplayHeadTime)
344 {
345 G4String display;
346 G4double screenX, screenY, screenSize, red, green, blue;
347 std::istringstream iss(newValue);
348 iss >> display >> screenX >> screenY
349 >> screenSize >> red >> green >> blue;
350 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
351 pOGLSViewer->fDisplayHeadTimeX = screenX;
352 pOGLSViewer->fDisplayHeadTimeY = screenY;
353 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
354 pOGLSViewer->fDisplayHeadTimeRed = red;
355 pOGLSViewer->fDisplayHeadTimeGreen = green;
356 pOGLSViewer->fDisplayHeadTimeBlue = blue;
357 return;
358 }
359
360 if (command == fpCommandDisplayLightFront)
361 {
362 G4String display, originX, originY, originZ, unitS, originT, unitT;
363 G4double red, green, blue;
364 std::istringstream iss(newValue);
365 iss >> display
366 >> originX >> originY >> originZ >> unitS
367 >> originT >> unitT
368 >> red >> green >> blue;
369 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
370 pOGLSViewer->fDisplayLightFrontX =
371 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
372 pOGLSViewer->fDisplayLightFrontY =
373 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
374 pOGLSViewer->fDisplayLightFrontZ =
375 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
376 pOGLSViewer->fDisplayLightFrontT =
377 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
378 pOGLSViewer->fDisplayLightFrontRed = red;
379 pOGLSViewer->fDisplayLightFrontGreen = green;
380 pOGLSViewer->fDisplayLightFrontBlue = blue;
381 return;
382 }
383
384 if (command == fpCommandEndTime)
385 {
386 G4String end_time_string, end_time_unit,
387 time_range_string, time_range_unit;
388 std::istringstream iss(newValue);
389 iss >> end_time_string >> end_time_unit
390 >> time_range_string >> time_range_unit;
391 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
392 (G4String(end_time_string + ' ' + end_time_unit));
393 G4double timeRange = command->ConvertToDimensionedDouble
394 (G4String(time_range_string + ' ' + time_range_unit));
395 if (timeRange > 0.) {
396 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
397 }
398 if (pOGLSViewer->fVP.IsAutoRefresh())
399 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
400 return;
401 }
402
403 if (command == fpCommandFade)
404 {
405 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
406 if (pOGLSViewer->fVP.IsAutoRefresh())
407 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
408 }
409
410 if (command == fpCommandStartTime)
411 {
412 G4String start_time_string, start_time_unit,
413 time_range_string, time_range_unit;
414 std::istringstream iss(newValue);
415 iss >> start_time_string >> start_time_unit
416 >> time_range_string >> time_range_unit;
417 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
418 (G4String(start_time_string + ' ' + start_time_unit));
419 G4double timeRange = command->ConvertToDimensionedDouble
420 (G4String(time_range_string + ' ' + time_range_unit));
421 if (timeRange > 0.) {
422 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
423 }
424 if (pOGLSViewer->fVP.IsAutoRefresh())
425 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
426 return;
427 }
428
429 G4VSceneHandler* pSceneHandler = pViewer->GetSceneHandler();
430
431 if (!pSceneHandler) {
432 G4cout <<
433 "G4OpenGLViewerMessenger::SetNewValue: This viewer has no scene handler."
434 "\n Shouldn't happen - please report circumstances."
435 "\n (Viewer is \"" << pViewer->GetName() << "\".)"
436 "\n Try \"/vis/open\", or similar, to get one."
437 << G4endl;
438 return;
439 }
440
441 G4OpenGLSceneHandler* pOGLSceneHandler =
442 dynamic_cast<G4OpenGLSceneHandler*>(pSceneHandler);
443
444 if (!pOGLSceneHandler) {
445 G4cout <<
446 "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
447 "\n OGL. (Viewer is \"" << pViewer->GetName() << "\".)"
448 "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
449 "\n Use \"/vis/sceneHandler/list\" and \"/vis/sceneHandler/select\""
450 "\n or \"/vis/open\"."
451 << G4endl;
452 return;
453 }
454
455 G4OpenGLStoredSceneHandler* pOGLSSceneHandler =
456 dynamic_cast<G4OpenGLStoredSceneHandler*>(pViewer->GetSceneHandler());
457
458 if (!pOGLSSceneHandler) {
459 G4cout <<
460 "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
461 "\n OGLS (Stored). (Viewer is \"" << pViewer->GetName() << "\".)"
462 "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
463 "\n This feature is only implemented for OGL Stored"
464 "\n scene handlers. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
465 << G4endl;
466 return;
467 }
468
469 if (command == fpCommandDisplayListLimit)
470 {
471 G4int displayListLimit =
472 fpCommandDisplayListLimit->GetNewIntValue(newValue);
473 pOGLSSceneHandler->SetDisplayListLimit(displayListLimit);
474 }
475}
476
477#endif
Note: See TracBrowser for help on using the repository browser.