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

Last change on this file since 1340 was 1340, checked in by garnier, 14 years ago

update ti head
  • Property svn:mime-type set to text/cpp
File size: 17.9 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.19 2010/11/05 06:25:23 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
187    ("displayListLimit", omitable = true);
188  fpCommandDisplayListLimit->SetDefaultValue(50000);
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.  Use \"/vis/viewer/select\" or \"/vis/open\"."
283           << G4endl;
284    return;
285  }
286
287  if (command == fpCommandPrintEPS)
288    {
289      pOGLViewer->printEPS();
290      return;
291    }
292
293  if (command == fpCommandPrintSize)
294    {
295      G4int width,height;
296      std::istringstream iss(newValue);
297      iss >> width
298          >> height;
299      pOGLViewer->setPrintSize(width,height);
300    }
301
302  if (command == fpCommandPrintFilename)
303    {
304      G4String name;
305      G4bool inc;
306      std::istringstream iss(newValue);
307      iss >> name
308          >> inc;
309      pOGLViewer->setPrintFilename(name,inc);
310    }
311
312  if (command == fpCommandPrintMode)
313    {
314      if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
315      if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
316      return;
317    }
318
319  if (command == fpCommandTransparency)
320    {
321      pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
322      if (pOGLViewer->fVP.IsAutoRefresh())
323        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
324      return;
325    }
326
327  G4OpenGLStoredViewer* pOGLSViewer =
328    dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
329
330  if (!pOGLSViewer)
331    {
332      G4cout <<
333  "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
334  "\n  This feature is only implemented for OGL Stored viewers."
335  "\n  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
336             << G4endl;
337      return;
338    }
339
340  if (command == fpCommandDisplayHeadTime)
341    {
342      G4String display;
343      G4double screenX, screenY, screenSize, red, green, blue;
344      std::istringstream iss(newValue);
345      iss >> display >> screenX >> screenY
346          >> screenSize >> red >> green >> blue;
347      pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
348      pOGLSViewer->fDisplayHeadTimeX = screenX;
349      pOGLSViewer->fDisplayHeadTimeY = screenY;
350      pOGLSViewer->fDisplayHeadTimeSize = screenSize;
351      pOGLSViewer->fDisplayHeadTimeRed = red;
352      pOGLSViewer->fDisplayHeadTimeGreen = green;
353      pOGLSViewer->fDisplayHeadTimeBlue = blue;
354      return;
355    }
356
357  if (command == fpCommandDisplayLightFront)
358    {
359      G4String display, originX, originY, originZ, unitS, originT, unitT;
360      G4double red, green, blue;
361      std::istringstream iss(newValue);
362      iss >> display
363          >> originX >> originY >> originZ >> unitS
364          >> originT >> unitT
365          >> red >> green >> blue;
366      pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
367      pOGLSViewer->fDisplayLightFrontX =
368        command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
369      pOGLSViewer->fDisplayLightFrontY =
370        command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
371      pOGLSViewer->fDisplayLightFrontZ =
372        command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
373      pOGLSViewer->fDisplayLightFrontT =
374        command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
375      pOGLSViewer->fDisplayLightFrontRed = red;
376      pOGLSViewer->fDisplayLightFrontGreen = green;
377      pOGLSViewer->fDisplayLightFrontBlue = blue;
378      return;
379    }
380
381  if (command == fpCommandEndTime)
382    {
383      G4String end_time_string, end_time_unit,
384        time_range_string, time_range_unit;
385      std::istringstream iss(newValue);
386      iss >> end_time_string >> end_time_unit
387          >> time_range_string >> time_range_unit;
388      pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
389        (G4String(end_time_string + ' ' + end_time_unit));
390      G4double timeRange = command->ConvertToDimensionedDouble
391        (G4String(time_range_string + ' ' + time_range_unit));
392      if (timeRange > 0.) {
393        pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
394      }
395      if (pOGLSViewer->fVP.IsAutoRefresh())
396        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
397      return;
398    }
399
400  if (command == fpCommandFade)
401    {
402      pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
403      if (pOGLSViewer->fVP.IsAutoRefresh())
404        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
405    }
406
407  if (command == fpCommandStartTime)
408    {
409      G4String start_time_string, start_time_unit,
410        time_range_string, time_range_unit;
411      std::istringstream iss(newValue);
412      iss >> start_time_string >> start_time_unit
413          >> time_range_string >> time_range_unit;
414      pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
415        (G4String(start_time_string + ' ' + start_time_unit));
416      G4double timeRange = command->ConvertToDimensionedDouble
417        (G4String(time_range_string + ' ' + time_range_unit));
418      if (timeRange > 0.) {
419        pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
420      }
421      if (pOGLSViewer->fVP.IsAutoRefresh())
422        G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
423      return;
424    }
425
426  G4OpenGLSceneHandler* pOGLSceneHandler =
427    dynamic_cast<G4OpenGLSceneHandler*>(pViewer->GetSceneHandler());
428
429  if (!pOGLSceneHandler) {
430    G4cout <<
431  "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
432  "\n  OGL.  Use \"/vis/sceneHandler/select\" or \"/vis/open\"."
433           << G4endl;
434    return;
435  }
436
437  G4OpenGLStoredSceneHandler* pOGLSSceneHandler =
438    dynamic_cast<G4OpenGLStoredSceneHandler*>(pViewer->GetSceneHandler());
439
440  if (!pOGLSSceneHandler) {
441    G4cout <<
442  "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
443  "\n  OGLS (Stored).  This feature is only implemented for OGL Stored"
444  "\n  scene handlers.  Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
445           << G4endl;
446    return;
447  }
448
449  if (command == fpCommandDisplayListLimit)
450    {
451      G4int displayListLimit =
452        fpCommandDisplayListLimit->GetNewIntValue(newValue);
453      pOGLSSceneHandler->SetDisplayListLimit(displayListLimit);
454    }
455}
456
457#endif
Note: See TracBrowser for help on using the repository browser.