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

Last change on this file since 1343 was 1343, checked in by garnier, 14 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.