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

Last change on this file since 1148 was 1046, checked in by garnier, 17 years ago

update
  • Property svn:mime-type set to text/cpp
File size: 16.6 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.18 2009/05/14 16:38:23 lgarnier 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 "G4VisManager.hh"
44#include <sstream>
45
46G4OpenGLViewerMessenger*
47G4OpenGLViewerMessenger::fpInstance = 0;
48
49G4OpenGLViewerMessenger*
50G4OpenGLViewerMessenger::GetInstance()
51{
52 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
53 return fpInstance;
54}
55
56G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
57{
58 G4bool omitable;
59
60 fpDirectory = new G4UIdirectory("/vis/ogl/");
61 fpDirectory->SetGuidance("G4OpenGLViewer commands.");
62
63 fpCommandPrintEPS =
64 new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
65 fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
66 fpCommandPrintEPS->SetGuidance
67 ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
68 "\nnumber, starting at 0."
69 "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
70
71 fpCommandPrintSize =
72 new G4UIcommand("/vis/ogl/set/printSize", this);
73 fpCommandPrintSize->SetGuidance ("Set print size");
74 fpCommandPrintSize->SetGuidance ("Tip : -1 will mean 'print size' = 'window size'");
75 fpCommandPrintSize->SetGuidance (" Setting size greatter than your maximum graphic card capacity , will set the size to maximum size.");
76 G4UIparameter* parameterPrintSize;
77 parameterPrintSize = new G4UIparameter ("width", 'd', omitable = false);
78 parameterPrintSize->SetDefaultValue(-1);
79 fpCommandPrintSize->SetParameter(parameterPrintSize);
80 parameterPrintSize = new G4UIparameter ("height", 'd', omitable = false);
81 parameterPrintSize->SetDefaultValue(-1);
82 fpCommandPrintSize->SetParameter(parameterPrintSize);
83
84 fpCommandPrintFilename =
85 new G4UIcommand("/vis/ogl/set/printFilename", this);
86 fpCommandPrintFilename->SetGuidance ("Set print filename");
87 fpCommandPrintFilename->SetGuidance ("Setting 'incremental' will increment filename by one at each new print, starting at 0");
88 G4UIparameter* parameterPrintFilename;
89 parameterPrintFilename = new G4UIparameter ("name", 's', omitable = true);
90 parameterPrintFilename->SetDefaultValue("G4OpenGL");
91 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
92 parameterPrintFilename = new G4UIparameter ("incremental", 'b', omitable = true);
93 parameterPrintFilename->SetDefaultValue(1);
94 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
95
96 fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
97 fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
98
99 G4UIparameter* parameter;
100
101 fpCommandDisplayHeadTime =
102 new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
103 fpCommandDisplayHeadTime->SetGuidance
104 ("Display head time of range in 2D text.");
105 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
106 parameter->SetDefaultValue(false);
107 fpCommandDisplayHeadTime->SetParameter(parameter);
108 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
109 parameter->SetGuidance("-1 < screenX < 1");
110 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
111 parameter->SetDefaultValue(-0.9);
112 fpCommandDisplayHeadTime->SetParameter(parameter);
113 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
114 parameter->SetGuidance("-1 < screenY < 1");
115 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
116 parameter->SetDefaultValue(-0.9);
117 fpCommandDisplayHeadTime->SetParameter(parameter);
118 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
119 parameter->SetDefaultValue(24.);
120 fpCommandDisplayHeadTime->SetParameter(parameter);
121 parameter = new G4UIparameter ("red", 'd', omitable = true);
122 parameter->SetParameterRange("red >= 0. && red <= 1.");
123 parameter->SetDefaultValue(0.);
124 fpCommandDisplayHeadTime->SetParameter(parameter);
125 parameter = new G4UIparameter ("green", 'd', omitable = true);
126 parameter->SetParameterRange("green >= 0. && green <= 1.");
127 parameter->SetDefaultValue(1.);
128 fpCommandDisplayHeadTime->SetParameter(parameter);
129 parameter = new G4UIparameter ("blue", 'd', omitable = true);
130 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
131 parameter->SetDefaultValue(1.);
132 fpCommandDisplayHeadTime->SetParameter(parameter);
133
134 fpCommandDisplayLightFront =
135 new G4UIcommand("/vis/ogl/set/displayLightFront", this);
136 fpCommandDisplayLightFront->SetGuidance
137 ("Display the light front at head time.");
138 fpCommandDisplayLightFront->SetGuidance
139 ("Tip: The trajectories can appear of jump ahead of the light front"
140 "\nbecause their time range overlaps the viewer's time range. To"
141 "\naverage out this discrete time effect, advance the light front by"
142 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
143 "\ninterval is 0.01 ns:"
144 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
145 "\nTo prevent them beating the light front at all:"
146 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
147 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
148 parameter->SetDefaultValue(false);
149 fpCommandDisplayLightFront->SetParameter(parameter);
150 parameter = new G4UIparameter ("originX", 'd', omitable = true);
151 parameter->SetDefaultValue(0.);
152 fpCommandDisplayLightFront->SetParameter(parameter);
153 parameter = new G4UIparameter ("originY", 'd', omitable = true);
154 parameter->SetDefaultValue(0.);
155 fpCommandDisplayLightFront->SetParameter(parameter);
156 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
157 parameter->SetDefaultValue(0.);
158 fpCommandDisplayLightFront->SetParameter(parameter);
159 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
160 parameter->SetDefaultValue("m");
161 fpCommandDisplayLightFront->SetParameter(parameter);
162 parameter = new G4UIparameter ("originT", 'd', omitable = true);
163 parameter->SetDefaultValue(0.);
164 fpCommandDisplayLightFront->SetParameter(parameter);
165 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
166 parameter->SetDefaultValue("s");
167 fpCommandDisplayLightFront->SetParameter(parameter);
168 parameter = new G4UIparameter ("red", 'd', omitable = true);
169 parameter->SetParameterRange("red >= 0. && red <= 1.");
170 parameter->SetDefaultValue(0.);
171 fpCommandDisplayLightFront->SetParameter(parameter);
172 parameter = new G4UIparameter ("green", 'd', omitable = true);
173 parameter->SetParameterRange("green >= 0. && green <= 1.");
174 parameter->SetDefaultValue(1.);
175 fpCommandDisplayLightFront->SetParameter(parameter);
176 parameter = new G4UIparameter ("blue", 'd', omitable = true);
177 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
178 parameter->SetDefaultValue(0.);
179 fpCommandDisplayLightFront->SetParameter(parameter);
180
181 fpCommandEndTime =
182 new G4UIcommand("/vis/ogl/set/endTime", this);
183 fpCommandEndTime->SetGuidance("Set end and range of track time.");
184 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
185 parameter->SetDefaultValue(DBL_MAX);
186 fpCommandEndTime->SetParameter(parameter);
187 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
188 parameter->SetDefaultValue("ns");
189 fpCommandEndTime->SetParameter(parameter);
190 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
191 parameter->SetDefaultValue(-1.);
192 fpCommandEndTime->SetParameter(parameter);
193 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
194 parameter->SetDefaultValue("ns");
195 fpCommandEndTime->SetParameter(parameter);
196
197 fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
198 fpCommandFade->SetGuidance
199 ("0: no fade; 1: maximum fade with time within range.");
200 fpCommandFade->SetParameterName("fadefactor", omitable = false);
201 fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
202 fpCommandFade->SetDefaultValue(0.);
203
204 fpCommandPrintMode = new G4UIcmdWithAString
205 ("/vis/ogl/set/printMode",this);
206 fpCommandPrintMode->SetGuidance("Set print mode");
207 fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
208 fpCommandPrintMode->SetCandidates("vectored pixmap");
209 fpCommandPrintMode->SetDefaultValue("vectored");
210
211 fpCommandStartTime =
212 new G4UIcommand("/vis/ogl/set/startTime", this);
213 fpCommandStartTime->SetGuidance("Set start and range of track time.");
214 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
215 parameter->SetDefaultValue(-DBL_MAX);
216 fpCommandStartTime->SetParameter(parameter);
217 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
218 parameter->SetDefaultValue("ns");
219 fpCommandStartTime->SetParameter(parameter);
220 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
221 parameter->SetDefaultValue(-1.);
222 fpCommandStartTime->SetParameter(parameter);
223 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
224 parameter->SetDefaultValue("ns");
225 fpCommandStartTime->SetParameter(parameter);
226
227 fpCommandTransparency =
228 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
229 fpCommandTransparency->SetGuidance
230 ("True/false to enable/disable rendering of transparent objects.");
231 fpCommandTransparency->SetParameterName
232 ("transparency-enabled", omitable = true);
233 fpCommandTransparency->SetDefaultValue(true);
234}
235
236G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
237{
238 delete fpCommandPrintMode;
239 delete fpCommandTransparency;
240 delete fpCommandStartTime;
241 delete fpCommandFade;
242 delete fpCommandEndTime;
243 delete fpCommandDisplayLightFront;
244 delete fpCommandDisplayHeadTime;
245 delete fpDirectorySet;
246 delete fpCommandPrintEPS;
247 delete fpDirectory;
248
249 delete fpInstance;
250}
251
252void G4OpenGLViewerMessenger::SetNewValue
253(G4UIcommand* command, G4String newValue)
254{
255 G4VisManager* pVisManager = G4VisManager::GetInstance();
256
257 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
258
259 if (!pViewer) {
260 G4cout <<
261 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
262 "\n \"/vis/open\", or similar, to get one."
263 << G4endl;
264 return;
265 }
266
267 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
268
269 if (!pOGLViewer) {
270 G4cout <<
271 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
272 "\n OGL. Use \"/vis/viewer/select\" or \"/vis/open\"."
273 << G4endl;
274 return;
275 }
276
277 if (command == fpCommandPrintEPS)
278 {
279 pOGLViewer->printEPS();
280 return;
281 }
282
283 if (command == fpCommandPrintSize)
284 {
285 G4int width,height;
286 std::istringstream iss(newValue);
287 iss >> width
288 >> height;
289 pOGLViewer->setPrintSize(width,height);
290 }
291
292 if (command == fpCommandPrintFilename)
293 {
294 G4String name;
295 G4bool inc;
296 std::istringstream iss(newValue);
297 iss >> name
298 >> inc;
299 pOGLViewer->setPrintFilename(name,inc);
300 }
301
302 if (command == fpCommandPrintMode)
303 {
304 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
305 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
306 return;
307 }
308
309 if (command == fpCommandTransparency)
310 {
311 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
312 if (pOGLViewer->fVP.IsAutoRefresh())
313 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
314 return;
315 }
316
317 G4OpenGLStoredViewer* pOGLSViewer =
318 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
319
320 if (!pOGLSViewer)
321 {
322 G4cout <<
323 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
324 "\n The time slice viewing feature is only implemented for OGL Stored"
325 "\n viewers at present. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
326 << G4endl;
327 return;
328 }
329
330 if (command == fpCommandDisplayHeadTime)
331 {
332 G4String display;
333 G4double screenX, screenY, screenSize, red, green, blue;
334 std::istringstream iss(newValue);
335 iss >> display >> screenX >> screenY
336 >> screenSize >> red >> green >> blue;
337 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
338 pOGLSViewer->fDisplayHeadTimeX = screenX;
339 pOGLSViewer->fDisplayHeadTimeY = screenY;
340 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
341 pOGLSViewer->fDisplayHeadTimeRed = red;
342 pOGLSViewer->fDisplayHeadTimeGreen = green;
343 pOGLSViewer->fDisplayHeadTimeBlue = blue;
344 return;
345 }
346
347 if (command == fpCommandDisplayLightFront)
348 {
349 G4String display, originX, originY, originZ, unitS, originT, unitT;
350 G4double red, green, blue;
351 std::istringstream iss(newValue);
352 iss >> display
353 >> originX >> originY >> originZ >> unitS
354 >> originT >> unitT
355 >> red >> green >> blue;
356 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
357 pOGLSViewer->fDisplayLightFrontX =
358 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
359 pOGLSViewer->fDisplayLightFrontY =
360 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
361 pOGLSViewer->fDisplayLightFrontZ =
362 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
363 pOGLSViewer->fDisplayLightFrontT =
364 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
365 pOGLSViewer->fDisplayLightFrontRed = red;
366 pOGLSViewer->fDisplayLightFrontGreen = green;
367 pOGLSViewer->fDisplayLightFrontBlue = blue;
368 return;
369 }
370
371 if (command == fpCommandEndTime)
372 {
373 G4String end_time_string, end_time_unit,
374 time_range_string, time_range_unit;
375 std::istringstream iss(newValue);
376 iss >> end_time_string >> end_time_unit
377 >> time_range_string >> time_range_unit;
378 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
379 (G4String(end_time_string + ' ' + end_time_unit));
380 G4double timeRange = command->ConvertToDimensionedDouble
381 (G4String(time_range_string + ' ' + time_range_unit));
382 if (timeRange > 0.) {
383 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
384 }
385 if (pOGLSViewer->fVP.IsAutoRefresh())
386 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
387 return;
388 }
389
390 if (command == fpCommandFade)
391 {
392 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
393 if (pOGLSViewer->fVP.IsAutoRefresh())
394 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
395 }
396
397 if (command == fpCommandStartTime)
398 {
399 G4String start_time_string, start_time_unit,
400 time_range_string, time_range_unit;
401 std::istringstream iss(newValue);
402 iss >> start_time_string >> start_time_unit
403 >> time_range_string >> time_range_unit;
404 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
405 (G4String(start_time_string + ' ' + start_time_unit));
406 G4double timeRange = command->ConvertToDimensionedDouble
407 (G4String(time_range_string + ' ' + time_range_unit));
408 if (timeRange > 0.) {
409 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
410 }
411 if (pOGLSViewer->fVP.IsAutoRefresh())
412 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
413 return;
414 }
415
416}
417
418#endif
Note: See TracBrowser for help on using the repository browser.