00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifdef G4VIS_BUILD_OPENGL_DRIVER
00030
00031 #include "G4OpenGLViewerMessenger.hh"
00032
00033 #include "G4OpenGLViewer.hh"
00034 #include "G4OpenGLStoredViewer.hh"
00035 #include "G4OpenGLStoredSceneHandler.hh"
00036 #include "G4UImanager.hh"
00037 #include "G4UIcommand.hh"
00038 #include "G4UIdirectory.hh"
00039 #include "G4UIcmdWithoutParameter.hh"
00040 #include "G4UIcmdWithADouble.hh"
00041 #include "G4UIcmdWithABool.hh"
00042 #include "G4UIcmdWithAString.hh"
00043 #include "G4UIcmdWithAnInteger.hh"
00044 #include "G4VisManager.hh"
00045 #include <sstream>
00046
00047 G4OpenGLViewerMessenger*
00048 G4OpenGLViewerMessenger::fpInstance = 0;
00049
00050 G4OpenGLViewerMessenger*
00051 G4OpenGLViewerMessenger::GetInstance()
00052 {
00053 if (!fpInstance) fpInstance = new G4OpenGLViewerMessenger;
00054 return fpInstance;
00055 }
00056
00057 G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
00058 {
00059 G4bool omitable;
00060
00061 fpDirectory = new G4UIdirectory("/vis/ogl/");
00062 fpDirectory->SetGuidance("G4OpenGLViewer commands.");
00063
00064 fpDirectorySet = new G4UIdirectory ("/vis/ogl/set/");
00065 fpDirectorySet->SetGuidance("G4OpenGLViewer set commands.");
00066
00067 G4UIparameter* parameter;
00068
00069 fpCommandDisplayHeadTime =
00070 new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
00071 fpCommandDisplayHeadTime->SetGuidance
00072 ("Display head time of range in 2D text.");
00073 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
00074 parameter->SetDefaultValue(false);
00075 fpCommandDisplayHeadTime->SetParameter(parameter);
00076 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
00077 parameter->SetGuidance("-1 < screenX < 1");
00078 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
00079 parameter->SetDefaultValue(-0.9);
00080 fpCommandDisplayHeadTime->SetParameter(parameter);
00081 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
00082 parameter->SetGuidance("-1 < screenY < 1");
00083 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
00084 parameter->SetDefaultValue(-0.9);
00085 fpCommandDisplayHeadTime->SetParameter(parameter);
00086 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
00087 parameter->SetDefaultValue(24.);
00088 fpCommandDisplayHeadTime->SetParameter(parameter);
00089 parameter = new G4UIparameter ("red", 'd', omitable = true);
00090 parameter->SetParameterRange("red >= 0. && red <= 1.");
00091 parameter->SetDefaultValue(0.);
00092 fpCommandDisplayHeadTime->SetParameter(parameter);
00093 parameter = new G4UIparameter ("green", 'd', omitable = true);
00094 parameter->SetParameterRange("green >= 0. && green <= 1.");
00095 parameter->SetDefaultValue(1.);
00096 fpCommandDisplayHeadTime->SetParameter(parameter);
00097 parameter = new G4UIparameter ("blue", 'd', omitable = true);
00098 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
00099 parameter->SetDefaultValue(1.);
00100 fpCommandDisplayHeadTime->SetParameter(parameter);
00101
00102 fpCommandDisplayLightFront =
00103 new G4UIcommand("/vis/ogl/set/displayLightFront", this);
00104 fpCommandDisplayLightFront->SetGuidance
00105 ("Display the light front at head time.");
00106 fpCommandDisplayLightFront->SetGuidance
00107 ("Tip: The trajectories can appear of jump ahead of the light front"
00108 "\nbecause their time range overlaps the viewer's time range. To"
00109 "\naverage out this discrete time effect, advance the light front by"
00110 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
00111 "\ninterval is 0.01 ns:"
00112 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.005 ns"
00113 "\nTo prevent them beating the light front at all:"
00114 "\n /vis/ogl/set/displayLightFront true -90 0 0 mm -0.01 ns");
00115 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = false);
00116 parameter->SetDefaultValue(false);
00117 fpCommandDisplayLightFront->SetParameter(parameter);
00118 parameter = new G4UIparameter ("originX", 'd', omitable = true);
00119 parameter->SetDefaultValue(0.);
00120 fpCommandDisplayLightFront->SetParameter(parameter);
00121 parameter = new G4UIparameter ("originY", 'd', omitable = true);
00122 parameter->SetDefaultValue(0.);
00123 fpCommandDisplayLightFront->SetParameter(parameter);
00124 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
00125 parameter->SetDefaultValue(0.);
00126 fpCommandDisplayLightFront->SetParameter(parameter);
00127 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
00128 parameter->SetDefaultValue("m");
00129 fpCommandDisplayLightFront->SetParameter(parameter);
00130 parameter = new G4UIparameter ("originT", 'd', omitable = true);
00131 parameter->SetDefaultValue(0.);
00132 fpCommandDisplayLightFront->SetParameter(parameter);
00133 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
00134 parameter->SetDefaultValue("s");
00135 fpCommandDisplayLightFront->SetParameter(parameter);
00136 parameter = new G4UIparameter ("red", 'd', omitable = true);
00137 parameter->SetParameterRange("red >= 0. && red <= 1.");
00138 parameter->SetDefaultValue(0.);
00139 fpCommandDisplayLightFront->SetParameter(parameter);
00140 parameter = new G4UIparameter ("green", 'd', omitable = true);
00141 parameter->SetParameterRange("green >= 0. && green <= 1.");
00142 parameter->SetDefaultValue(1.);
00143 fpCommandDisplayLightFront->SetParameter(parameter);
00144 parameter = new G4UIparameter ("blue", 'd', omitable = true);
00145 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
00146 parameter->SetDefaultValue(0.);
00147 fpCommandDisplayLightFront->SetParameter(parameter);
00148
00149 fpCommandDisplayListLimit =
00150 new G4UIcmdWithAnInteger("/vis/ogl/set/displayListLimit", this);
00151 fpCommandDisplayListLimit->SetGuidance
00152 ("Set/reset display list limit (to avoid memory exhaustion).");
00153 fpCommandDisplayListLimit->SetParameterName("limit", omitable = true);
00154 fpCommandDisplayListLimit->SetDefaultValue(50000);
00155 fpCommandDisplayListLimit->SetRange("limit>=10000");
00156
00157 fpCommandEndTime =
00158 new G4UIcommand("/vis/ogl/set/endTime", this);
00159 fpCommandEndTime->SetGuidance("Set end and range of track time.");
00160 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
00161 parameter->SetDefaultValue(DBL_MAX);
00162 fpCommandEndTime->SetParameter(parameter);
00163 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
00164 parameter->SetDefaultValue("ns");
00165 fpCommandEndTime->SetParameter(parameter);
00166 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
00167 parameter->SetDefaultValue(-1.);
00168 fpCommandEndTime->SetParameter(parameter);
00169 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
00170 parameter->SetDefaultValue("ns");
00171 fpCommandEndTime->SetParameter(parameter);
00172
00173 fpCommandEventsDrawInterval =
00174 new G4UIcmdWithAnInteger("/vis/ogl/set/eventsDrawInterval", this);
00175 fpCommandEventsDrawInterval->SetGuidance
00176 ("Set number of events allowed in drawing pipeline - speeds drawing");
00177 fpCommandEventsDrawInterval->SetGuidance
00178 ("By default, the screen is updated at the end of every event."
00179 "\nAllowing OpenGL to buffer several events can make a big improvement"
00180 "\nin drawing speed.");
00181 fpCommandEventsDrawInterval->SetParameterName("interval", omitable = true);
00182 fpCommandEventsDrawInterval->SetDefaultValue(1);
00183
00184 fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
00185 fpCommandFade->SetGuidance
00186 ("0: no fade; 1: maximum fade with time within range.");
00187 fpCommandFade->SetParameterName("fadefactor", omitable = false);
00188 fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
00189 fpCommandFade->SetDefaultValue(0.);
00190
00191 fpCommandPrintEPS =
00192 new G4UIcmdWithoutParameter("/vis/ogl/printEPS", this);
00193 fpCommandPrintEPS->SetGuidance("Print Encapsulated PostScript file.");
00194 fpCommandPrintEPS->SetGuidance
00195 ("Generates files with names G4OpenGL_n.eps, where n is a sequence"
00196 "\nnumber, starting at 0."
00197 "\nCan be \"vectored\" or \"pixmap\" - see \"/vis/ogl/set/printMode\".");
00198
00199 fpCommandPrintFilename =
00200 new G4UIcommand("/vis/ogl/set/printFilename", this);
00201 fpCommandPrintFilename->SetGuidance ("Set print filename");
00202 fpCommandPrintFilename->SetGuidance ("Setting 'incremental' will increment filename by one at each new print, starting at 0");
00203 G4UIparameter* parameterPrintFilename;
00204 parameterPrintFilename = new G4UIparameter ("name", 's', omitable = true);
00205 parameterPrintFilename->SetDefaultValue("G4OpenGL");
00206 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
00207 parameterPrintFilename = new G4UIparameter ("incremental", 'b', omitable = true);
00208 parameterPrintFilename->SetDefaultValue(1);
00209 fpCommandPrintFilename->SetParameter(parameterPrintFilename);
00210
00211 fpCommandPrintMode = new G4UIcmdWithAString
00212 ("/vis/ogl/set/printMode",this);
00213 fpCommandPrintMode->SetGuidance("Set print mode");
00214 fpCommandPrintMode->SetParameterName("print_mode",omitable = true);
00215 fpCommandPrintMode->SetCandidates("vectored pixmap");
00216 fpCommandPrintMode->SetDefaultValue("vectored");
00217
00218 fpCommandPrintSize =
00219 new G4UIcommand("/vis/ogl/set/printSize", this);
00220 fpCommandPrintSize->SetGuidance ("Set print size");
00221 fpCommandPrintSize->SetGuidance ("Tip : -1 will mean 'print size' = 'window size'");
00222 fpCommandPrintSize->SetGuidance (" Setting size greatter than your maximum graphic card capacity , will set the size to maximum size.");
00223 G4UIparameter* parameterPrintSize;
00224 parameterPrintSize = new G4UIparameter ("width", 'd', omitable = false);
00225 parameterPrintSize->SetDefaultValue(-1);
00226 fpCommandPrintSize->SetParameter(parameterPrintSize);
00227 parameterPrintSize = new G4UIparameter ("height", 'd', omitable = false);
00228 parameterPrintSize->SetDefaultValue(-1);
00229 fpCommandPrintSize->SetParameter(parameterPrintSize);
00230
00231 fpCommandStartTime =
00232 new G4UIcommand("/vis/ogl/set/startTime", this);
00233 fpCommandStartTime->SetGuidance("Set start and range of track time.");
00234 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
00235 parameter->SetDefaultValue(-DBL_MAX);
00236 fpCommandStartTime->SetParameter(parameter);
00237 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
00238 parameter->SetDefaultValue("ns");
00239 fpCommandStartTime->SetParameter(parameter);
00240 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
00241 parameter->SetDefaultValue(-1.);
00242 fpCommandStartTime->SetParameter(parameter);
00243 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
00244 parameter->SetDefaultValue("ns");
00245 fpCommandStartTime->SetParameter(parameter);
00246
00247 fpCommandTransparency =
00248 new G4UIcmdWithABool("/vis/ogl/set/transparency", this);
00249 fpCommandTransparency->SetGuidance
00250 ("True/false to enable/disable rendering of transparent objects.");
00251 fpCommandTransparency->SetParameterName
00252 ("transparency-enabled", omitable = true);
00253 fpCommandTransparency->SetDefaultValue(true);
00254 }
00255
00256 G4OpenGLViewerMessenger::~G4OpenGLViewerMessenger ()
00257 {
00258 delete fpCommandTransparency;
00259 delete fpCommandStartTime;
00260 delete fpCommandPrintSize;
00261 delete fpCommandPrintMode;
00262 delete fpCommandPrintFilename;
00263 delete fpCommandPrintEPS;
00264 delete fpCommandFade;
00265 delete fpCommandEventsDrawInterval;
00266 delete fpCommandEndTime;
00267 delete fpCommandDisplayListLimit;
00268 delete fpCommandDisplayLightFront;
00269 delete fpCommandDisplayHeadTime;
00270 delete fpDirectorySet;
00271 delete fpDirectory;
00272
00273 delete fpInstance;
00274 }
00275
00276 void G4OpenGLViewerMessenger::SetNewValue
00277 (G4UIcommand* command, G4String newValue)
00278 {
00279 G4VisManager* pVisManager = G4VisManager::GetInstance();
00280
00281 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
00282
00283 if (!pViewer) {
00284 G4cout <<
00285 "G4OpenGLViewerMessenger::SetNewValue: No current viewer."
00286 "\n \"/vis/open\", or similar, to get one."
00287 << G4endl;
00288 return;
00289 }
00290
00291 G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(pViewer);
00292
00293 if (!pOGLViewer) {
00294 G4cout <<
00295 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type"
00296 "\n OGL. (It is \""
00297 << pViewer->GetName() <<
00298 "\".)\n Use \"/vis/viewer/select\" or \"/vis/open\"."
00299 << G4endl;
00300 return;
00301 }
00302
00303 if (command == fpCommandPrintEPS)
00304 {
00305 pOGLViewer->printEPS();
00306 if (pOGLViewer->fVP.IsAutoRefresh())
00307 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
00308 return;
00309 }
00310
00311 if (command == fpCommandPrintSize)
00312 {
00313 G4int width,height;
00314 std::istringstream iss(newValue);
00315 iss >> width
00316 >> height;
00317 pOGLViewer->setPrintSize(width,height);
00318 return;
00319 }
00320
00321 if (command == fpCommandPrintFilename)
00322 {
00323 G4String name;
00324 G4bool inc;
00325 std::istringstream iss(newValue);
00326 iss >> name
00327 >> inc;
00328 pOGLViewer->setPrintFilename(name,inc);
00329 return;
00330 }
00331
00332 if (command == fpCommandPrintMode)
00333 {
00334 if (newValue == "vectored") pOGLViewer->fVectoredPs = true;
00335 if (newValue == "pixmap") pOGLViewer->fVectoredPs = false;
00336 return;
00337 }
00338
00339 if (command == fpCommandTransparency)
00340 {
00341 pOGLViewer->transparency_enabled = command->ConvertToBool(newValue);
00342 if (pOGLViewer->fVP.IsAutoRefresh())
00343 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
00344 return;
00345 }
00346
00347 G4OpenGLStoredViewer* pOGLSViewer =
00348 dynamic_cast<G4OpenGLStoredViewer*>(pViewer);
00349
00350 if (!pOGLSViewer)
00351 {
00352 G4cout <<
00353 "G4OpenGLViewerMessenger::SetNewValue: Current viewer is not of type OGLS."
00354 "\n (It is \"" << pViewer->GetName() << "\".)"
00355 "\n This feature is only implemented for OGL Stored viewers."
00356 "\n Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
00357 << G4endl;
00358 return;
00359 }
00360
00361 if (command == fpCommandDisplayHeadTime)
00362 {
00363 G4String display;
00364 G4double screenX, screenY, screenSize, red, green, blue;
00365 std::istringstream iss(newValue);
00366 iss >> display >> screenX >> screenY
00367 >> screenSize >> red >> green >> blue;
00368 pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
00369 pOGLSViewer->fDisplayHeadTimeX = screenX;
00370 pOGLSViewer->fDisplayHeadTimeY = screenY;
00371 pOGLSViewer->fDisplayHeadTimeSize = screenSize;
00372 pOGLSViewer->fDisplayHeadTimeRed = red;
00373 pOGLSViewer->fDisplayHeadTimeGreen = green;
00374 pOGLSViewer->fDisplayHeadTimeBlue = blue;
00375 return;
00376 }
00377
00378 if (command == fpCommandDisplayLightFront)
00379 {
00380 G4String display, originX, originY, originZ, unitS, originT, unitT;
00381 G4double red, green, blue;
00382 std::istringstream iss(newValue);
00383 iss >> display
00384 >> originX >> originY >> originZ >> unitS
00385 >> originT >> unitT
00386 >> red >> green >> blue;
00387 pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
00388 pOGLSViewer->fDisplayLightFrontX =
00389 command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
00390 pOGLSViewer->fDisplayLightFrontY =
00391 command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
00392 pOGLSViewer->fDisplayLightFrontZ =
00393 command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
00394 pOGLSViewer->fDisplayLightFrontT =
00395 command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
00396 pOGLSViewer->fDisplayLightFrontRed = red;
00397 pOGLSViewer->fDisplayLightFrontGreen = green;
00398 pOGLSViewer->fDisplayLightFrontBlue = blue;
00399 return;
00400 }
00401
00402 if (command == fpCommandEndTime)
00403 {
00404 G4String end_time_string, end_time_unit,
00405 time_range_string, time_range_unit;
00406 std::istringstream iss(newValue);
00407 iss >> end_time_string >> end_time_unit
00408 >> time_range_string >> time_range_unit;
00409 pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
00410 (G4String(end_time_string + ' ' + end_time_unit));
00411 G4double timeRange = command->ConvertToDimensionedDouble
00412 (G4String(time_range_string + ' ' + time_range_unit));
00413 if (timeRange > 0.) {
00414 pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
00415 }
00416 if (pOGLSViewer->fVP.IsAutoRefresh())
00417 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
00418 return;
00419 }
00420
00421 if (command == fpCommandFade)
00422 {
00423 pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
00424 if (pOGLSViewer->fVP.IsAutoRefresh())
00425 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
00426 return;
00427 }
00428
00429 if (command == fpCommandStartTime)
00430 {
00431 G4String start_time_string, start_time_unit,
00432 time_range_string, time_range_unit;
00433 std::istringstream iss(newValue);
00434 iss >> start_time_string >> start_time_unit
00435 >> time_range_string >> time_range_unit;
00436 pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
00437 (G4String(start_time_string + ' ' + start_time_unit));
00438 G4double timeRange = command->ConvertToDimensionedDouble
00439 (G4String(time_range_string + ' ' + time_range_unit));
00440 if (timeRange > 0.) {
00441 pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
00442 }
00443 if (pOGLSViewer->fVP.IsAutoRefresh())
00444 G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
00445 return;
00446 }
00447
00448 G4VSceneHandler* pSceneHandler = pViewer->GetSceneHandler();
00449
00450 if (!pSceneHandler) {
00451 G4cout <<
00452 "G4OpenGLViewerMessenger::SetNewValue: This viewer has no scene handler."
00453 "\n Shouldn't happen - please report circumstances."
00454 "\n (Viewer is \"" << pViewer->GetName() << "\".)"
00455 "\n Try \"/vis/open\", or similar, to get one."
00456 << G4endl;
00457 return;
00458 }
00459
00460 G4OpenGLSceneHandler* pOGLSceneHandler =
00461 dynamic_cast<G4OpenGLSceneHandler*>(pSceneHandler);
00462
00463 if (!pOGLSceneHandler) {
00464 G4cout <<
00465 "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
00466 "\n OGL. (Viewer is \"" << pViewer->GetName() << "\".)"
00467 "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
00468 "\n Use \"/vis/sceneHandler/list\" and \"/vis/sceneHandler/select\""
00469 "\n or \"/vis/open\"."
00470 << G4endl;
00471 return;
00472 }
00473
00474 if (command == fpCommandEventsDrawInterval)
00475 {
00476 G4int eventsDrawInterval =
00477 fpCommandEventsDrawInterval->GetNewIntValue(newValue);
00478 pOGLSceneHandler->SetEventsDrawInterval(eventsDrawInterval);
00479 return;
00480 }
00481
00482 G4OpenGLStoredSceneHandler* pOGLSSceneHandler =
00483 dynamic_cast<G4OpenGLStoredSceneHandler*>(pViewer->GetSceneHandler());
00484
00485 if (!pOGLSSceneHandler) {
00486 G4cout <<
00487 "G4OpenGLViewerMessenger::SetNewValue: Current scene handler is not of type"
00488 "\n OGLS (Stored). (Viewer is \"" << pViewer->GetName() << "\".)"
00489 "\n (Scene handler is \"" << pSceneHandler->GetName() << "\".)"
00490 "\n This feature is only implemented for OGL Stored"
00491 "\n scene handlers. Use \"/vis/viewer/select\" or \"/vis/open OGLS...\"."
00492 << G4endl;
00493 return;
00494 }
00495
00496 if (command == fpCommandDisplayListLimit)
00497 {
00498 G4int displayListLimit =
00499 fpCommandDisplayListLimit->GetNewIntValue(newValue);
00500 pOGLSSceneHandler->SetDisplayListLimit(displayListLimit);
00501 return;
00502 }
00503 }
00504
00505 #endif