projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0029367: Visualization - simplify interface of V3d_View and V3d_Viewer
[occt.git] / src / ViewerTest / ViewerTest_ViewerCommands.cxx
CommitLineData
b311480e 1// Created on: 1998-09-01
2// Created by: Robert COUBLANC
3// Copyright (c) 1998-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 8// This library is free software; you can redistribute it and/or modify it under
9// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 10// by the Free Software Foundation, with special exception defined in the file
11// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12// distribution for complete text of the license and disclaimer of any warranty.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
b311480e 16
58655684 17#include <OpenGl_GlCore20.hxx>
49582f9d 18#include <ViewerTest.hxx>
1beb58d7 19
1beb58d7 20#include <AIS_AnimationCamera.hxx>
21#include <AIS_AnimationObject.hxx>
30a1b24e 22#include <AIS_CameraFrustum.hxx>
7a324550 23#include <AIS_ColorScale.hxx>
49582f9d 24#include <AIS_InteractiveContext.hxx>
0a768f56 25#include <AIS_ListOfInteractive.hxx>
26#include <AIS_ListIteratorOfListOfInteractive.hxx>
49582f9d 27#include <AIS_Manipulator.hxx>
2108d9a2 28#include <AIS_ViewCube.hxx>
49582f9d 29#include <AIS_Shape.hxx>
30#include <Aspect_DisplayConnection.hxx>
8a590580 31#include <Aspect_Grid.hxx>
49582f9d 32#include <Aspect_TypeOfLine.hxx>
33#include <Draw.hxx>
34#include <Draw_Appli.hxx>
35#include <Draw_Interpretor.hxx>
08f8a185 36#include <Draw_ProgressIndicator.hxx>
49582f9d 37#include <gp_Dir.hxx>
38#include <gp_Pln.hxx>
39#include <gp_Pnt.hxx>
61b0191c 40#include <Graphic3d_ArrayOfPolylines.hxx>
49582f9d 41#include <Graphic3d_AspectFillArea3d.hxx>
2bd4c032 42#include <Graphic3d_AspectMarker3d.hxx>
49582f9d 43#include <Graphic3d_ClipPlane.hxx>
077a220c 44#include <Graphic3d_CubeMapPacked.hxx>
45#include <Graphic3d_CubeMapSeparate.hxx>
a79f67f8 46#include <Graphic3d_GraduatedTrihedron.hxx>
49582f9d 47#include <Graphic3d_NameOfTextureEnv.hxx>
48#include <Graphic3d_Texture2Dmanual.hxx>
269294d6 49#include <Graphic3d_TextureEnv.hxx>
50#include <Graphic3d_TextureParams.hxx>
51#include <Graphic3d_TypeOfTextureFilter.hxx>
49582f9d 52#include <Image_AlienPixMap.hxx>
53#include <Image_Diff.hxx>
54#include <Image_VideoRecorder.hxx>
08f8a185 55#include <Message_ProgressSentry.hxx>
49582f9d 56#include <NCollection_DataMap.hxx>
18d715bd 57#include <NCollection_List.hxx>
58#include <NCollection_Vector.hxx>
8693dfd0 59#include <OSD.hxx>
208e6839 60#include <OSD_Timer.hxx>
49582f9d 61#include <OpenGl_GraphicDriver.hxx>
4269bd1b 62#include <Prs3d_ShadingAspect.hxx>
6262338c 63#include <Prs3d_Drawer.hxx>
61b0191c 64#include <Prs3d_LineAspect.hxx>
65#include <Prs3d_Root.hxx>
fd3f6bd0 66#include <Prs3d_Text.hxx>
67#include <Select3D_SensitivePrimitiveArray.hxx>
49582f9d 68#include <TColStd_HSequenceOfAsciiString.hxx>
69#include <TColStd_SequenceOfInteger.hxx>
70#include <TColStd_HSequenceOfReal.hxx>
71#include <TColgp_Array1OfPnt2d.hxx>
72#include <TColStd_MapOfAsciiString.hxx>
73#include <ViewerTest_AutoUpdater.hxx>
74#include <ViewerTest_EventManager.hxx>
75#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
76#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
77#include <ViewerTest_CmdParser.hxx>
78#include <ViewerTest_V3dView.hxx>
79#include <V3d_AmbientLight.hxx>
80#include <V3d_DirectionalLight.hxx>
81#include <V3d_PositionalLight.hxx>
82#include <V3d_SpotLight.hxx>
7fd59977 83
293211ae 84#include <tcl.h>
85
692613e5 86#include <cstdlib>
25289ec1 87
58655684 88#if defined(_WIN32)
4fe56619 89 #include <WNT_WClass.hxx>
90 #include <WNT_Window.hxx>
4fe56619 91#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
4fe56619 92 #include <Cocoa_Window.hxx>
7fd59977 93#else
4fe56619 94 #include <Xw_Window.hxx>
95 #include <X11/Xlib.h> /* contains some dangerous #defines such as Status, True etc. */
96 #include <X11/Xutil.h>
97 #include <tk.h>
7fd59977 98#endif
99
7fd59977 100//==============================================================================
101// VIEWER GLOBAL VARIABLES
102//==============================================================================
103
104Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
b514beda 105Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
7fd59977 106
107Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
4754e164 108extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
7fd59977 109
58655684 110#if defined(_WIN32)
7fd59977 111static Handle(WNT_Window)& VT_GetWindow() {
112 static Handle(WNT_Window) WNTWin;
113 return WNTWin;
114}
4fe56619 115#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
4fe56619 116static Handle(Cocoa_Window)& VT_GetWindow()
117{
118 static Handle(Cocoa_Window) aWindow;
119 return aWindow;
120}
121extern void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow);
18d715bd 122extern void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight);
123
7fd59977 124#else
7fd59977 125static Handle(Xw_Window)& VT_GetWindow(){
126 static Handle(Xw_Window) XWWin;
127 return XWWin;
128}
7fd59977 129
130static void VProcessEvents(ClientData,int);
131#endif
132
18d715bd 133static Handle(Aspect_DisplayConnection)& GetDisplayConnection()
134{
135 static Handle(Aspect_DisplayConnection) aDisplayConnection;
136 return aDisplayConnection;
137}
138
139static void SetDisplayConnection (const Handle(Aspect_DisplayConnection)& theDisplayConnection)
140{
141 GetDisplayConnection() = theDisplayConnection;
142}
143
18d715bd 144NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
58655684 145static NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)> ViewerTest_myContexts;
18d715bd 146static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
58655684 147static OpenGl_Caps ViewerTest_myDefaultCaps;
18d715bd 148
7fd59977 149static void OSWindowSetup();
150
f42753ed 151static struct
152{
153 Quantity_Color FlatColor;
154 Quantity_Color GradientColor1;
155 Quantity_Color GradientColor2;
156 Aspect_GradientFillMethod FillMethod;
157} ViewerTest_DefaultBackground = { Quantity_NOC_BLACK, Quantity_NOC_BLACK, Quantity_NOC_BLACK, Aspect_GFM_NONE };
158
7fd59977 159//==============================================================================
160// EVENT GLOBAL VARIABLES
161//==============================================================================
162
1beb58d7 163Standard_Boolean TheIsAnimating = Standard_False;
7fd59977 164
293211ae 165namespace
166{
167
168 //! Checks if some set is a subset of other set
169 //! @tparam TheSuperSet the type of the superset
170 //! @tparam TheSubSet the type of the subset
171 //! @param theSuperSet the superset
172 //! @param theSubSet the subset to be checked
173 //! @return true if the superset includes subset, or false otherwise
174 template <typename TheSuperSet, typename TheSubSet>
175 static bool includes (const TheSuperSet& theSuperSet, const TheSubSet& theSubSet)
176 {
177 return std::includes (theSuperSet.begin(), theSuperSet.end(), theSubSet.begin(), theSubSet.end());
178 }
179
180 //! A variable set of keys for command-line options.
181 //! It includes a set of mandatory keys and a set of all possible keys.
182 class CommandOptionKeyVariableSet
183 {
184 public:
185 //! Default constructor
186 CommandOptionKeyVariableSet()
187 {
188 }
189
190 //! Constructor
191 //! @param theMandatoryKeySet the set of the mandatory option keys
192 //! @param theAdditionalKeySet the set of additional options that could be omitted
193 CommandOptionKeyVariableSet (
194 const ViewerTest_CommandOptionKeySet& theMandatoryKeySet,
195 const ViewerTest_CommandOptionKeySet& theAdditionalKeySet = ViewerTest_CommandOptionKeySet())
196 : myMandatoryKeySet (theMandatoryKeySet)
197 {
198 std::set_union (theMandatoryKeySet.begin(),
199 theMandatoryKeySet.end(),
200 theAdditionalKeySet.begin(),
201 theAdditionalKeySet.end(),
202 std::inserter (myFullKeySet, myFullKeySet.begin()));
203 }
204
205 //! Checks if the set of option keys fits to the current variable set (it must contain all mandatory keys
206 //! and be contained in the full key set)
207 //! @param theCheckedKeySet the set of option keys to be checked
208 bool IsInSet (const ViewerTest_CommandOptionKeySet& theCheckedKeySet) const
209 {
210 return includes (theCheckedKeySet, myMandatoryKeySet) && includes (myFullKeySet, theCheckedKeySet);
211 }
212
213 private:
214 //! A set of mandatory command-line option keys
215 ViewerTest_CommandOptionKeySet myMandatoryKeySet;
216
217 //! A full set of command-line option keys (includes mandatory and additional option keys)
218 ViewerTest_CommandOptionKeySet myFullKeySet;
219 };
220
221 //! Gets some code by its name
222 //! @tparam TheCode the type of a code to be found
223 //! @param theCodeNameMap the map from code names to codes
224 //! @param theCodeName the name of a code to be found
225 //! @param theCode the code to be found
226 //! @return true if a code is found, or false otherwise
227 template <typename TheCode>
228 static bool getSomeCodeByName (const std::map<TCollection_AsciiString, TheCode>& theCodeNameMap,
229 TCollection_AsciiString theCodeName,
230 TheCode& theCode)
231 {
232 theCodeName.LowerCase();
233 const typename std::map<TCollection_AsciiString, TheCode>::const_iterator aCodeIterator = theCodeNameMap.find (
234 theCodeName);
235 if (aCodeIterator == theCodeNameMap.end())
236 {
237 return false;
238 }
239 theCode = aCodeIterator->second;
240 return true;
241 }
242
243 // Defines possible commands related to background changing
244 enum BackgroundCommand
245 {
077a220c 246 BackgroundCommand_Main, //!< The main command that manages other commands through options
247 BackgroundCommand_Image, //!< Sets an image as a background
248 BackgroundCommand_ImageMode, //!< Changes a background image mode
249 BackgroundCommand_Gradient, //!< Sets a gradient as a background
250 BackgroundCommand_GradientMode, //!< Changes a background gradient mode
251 BackgroundCommand_Color, //!< Fills background with a specified color
252 BackgroundCommand_Default //!< Sets the background default color or gradient
293211ae 253 };
254
255 //! Map from background command names to its codes
256 typedef std::map<TCollection_AsciiString, BackgroundCommand> BackgroundCommandNameMap;
257
258 //! Creates a map from background command names to its codes
259 //! @return a map from background command names to its codes
260 static BackgroundCommandNameMap createBackgroundCommandNameMap()
261 {
262 BackgroundCommandNameMap aBackgroundCommandNameMap;
077a220c 263 aBackgroundCommandNameMap["vbackground"] = BackgroundCommand_Main;
264 aBackgroundCommandNameMap["vsetbg"] = BackgroundCommand_Image;
265 aBackgroundCommandNameMap["vsetbgmode"] = BackgroundCommand_ImageMode;
266 aBackgroundCommandNameMap["vsetgradientbg"] = BackgroundCommand_Gradient;
267 aBackgroundCommandNameMap["vsetgrbgmode"] = BackgroundCommand_GradientMode;
268 aBackgroundCommandNameMap["vsetcolorbg"] = BackgroundCommand_Color;
269 aBackgroundCommandNameMap["vsetdefaultbg"] = BackgroundCommand_Default;
293211ae 270 return aBackgroundCommandNameMap;
271 }
272
273 //! Gets a background command by its name
274 //! @param theBackgroundCommandName the name of the background command
275 //! @param theBackgroundCommand the background command to be found
276 //! @return true if a background command is found, or false otherwise
277 static bool getBackgroundCommandByName (const TCollection_AsciiString& theBackgroundCommandName,
278 BackgroundCommand& theBackgroundCommand)
279 {
280 static const BackgroundCommandNameMap THE_BACKGROUND_COMMAND_NAME_MAP = createBackgroundCommandNameMap();
281 return getSomeCodeByName (THE_BACKGROUND_COMMAND_NAME_MAP, theBackgroundCommandName, theBackgroundCommand);
282 }
283
284 //! Map from background image fill method names to its codes
285 typedef std::map<TCollection_AsciiString, Aspect_FillMethod> BackgroundImageFillMethodNameMap;
286
287 //! Creates a map from background image fill method names to its codes
288 //! @return a map from background image fill method names to its codes
289 static BackgroundImageFillMethodNameMap createBackgroundImageFillMethodNameMap()
290 {
291 BackgroundImageFillMethodNameMap aBackgroundImageFillMethodNameMap;
292 aBackgroundImageFillMethodNameMap["none"] = Aspect_FM_NONE;
293 aBackgroundImageFillMethodNameMap["centered"] = Aspect_FM_CENTERED;
294 aBackgroundImageFillMethodNameMap["tiled"] = Aspect_FM_TILED;
295 aBackgroundImageFillMethodNameMap["stretch"] = Aspect_FM_STRETCH;
296 return aBackgroundImageFillMethodNameMap;
297 }
298
299 //! Gets a background image fill method by its name
300 //! @param theBackgroundImageFillMethodName the name of the background image fill method
301 //! @param theBackgroundImageFillMethod the background image fill method to be found
302 //! @return true if a background image fill method is found, or false otherwise
303 static bool getBackgroundImageFillMethodByName (const TCollection_AsciiString& theBackgroundImageFillMethodName,
304 Aspect_FillMethod& theBackgroundImageFillMethod)
305 {
306 static const BackgroundImageFillMethodNameMap THE_BACKGROUND_IMAGE_FILL_METHOD_NAME_MAP =
307 createBackgroundImageFillMethodNameMap();
308 return getSomeCodeByName (THE_BACKGROUND_IMAGE_FILL_METHOD_NAME_MAP,
309 theBackgroundImageFillMethodName,
310 theBackgroundImageFillMethod);
311 }
312
313 //! Map from background gradient fill method names to its codes
314 typedef std::map<TCollection_AsciiString, Aspect_GradientFillMethod> BackgroundGradientFillMethodNameMap;
315
316 //! Creates a map from background gradient fill method names to its codes
317 //! @return a map from background gradient fill method names to its codes
318 static BackgroundGradientFillMethodNameMap createBackgroundGradientFillMethodNameMap()
319 {
320 BackgroundGradientFillMethodNameMap aBackgroundGradientFillMethodNameMap;
321 aBackgroundGradientFillMethodNameMap["none"] = Aspect_GFM_NONE;
322 aBackgroundGradientFillMethodNameMap["hor"] = Aspect_GFM_HOR;
323 aBackgroundGradientFillMethodNameMap["horizontal"] = Aspect_GFM_HOR;
324 aBackgroundGradientFillMethodNameMap["ver"] = Aspect_GFM_VER;
325 aBackgroundGradientFillMethodNameMap["vertical"] = Aspect_GFM_VER;
326 aBackgroundGradientFillMethodNameMap["diag1"] = Aspect_GFM_DIAG1;
327 aBackgroundGradientFillMethodNameMap["diagonal1"] = Aspect_GFM_DIAG1;
328 aBackgroundGradientFillMethodNameMap["diag2"] = Aspect_GFM_DIAG2;
329 aBackgroundGradientFillMethodNameMap["diagonal2"] = Aspect_GFM_DIAG2;
330 aBackgroundGradientFillMethodNameMap["corner1"] = Aspect_GFM_CORNER1;
331 aBackgroundGradientFillMethodNameMap["corner2"] = Aspect_GFM_CORNER2;
332 aBackgroundGradientFillMethodNameMap["corner3"] = Aspect_GFM_CORNER3;
333 aBackgroundGradientFillMethodNameMap["corner4"] = Aspect_GFM_CORNER4;
334 return aBackgroundGradientFillMethodNameMap;
335 }
336
337 //! Gets a gradient fill method by its name
338 //! @param theBackgroundGradientFillMethodName the name of the gradient fill method
339 //! @param theBackgroundGradientFillMethod the gradient fill method to be found
340 //! @return true if a gradient fill method is found, or false otherwise
341 static bool getBackgroundGradientFillMethodByName (const TCollection_AsciiString& theBackgroundGradientFillMethodName,
342 Aspect_GradientFillMethod& theBackgroundGradientFillMethod)
343 {
344 static const BackgroundGradientFillMethodNameMap THE_BACKGROUND_GRADIENT_FILL_METHOD_NAME_MAP =
345 createBackgroundGradientFillMethodNameMap();
346 return getSomeCodeByName (THE_BACKGROUND_GRADIENT_FILL_METHOD_NAME_MAP,
347 theBackgroundGradientFillMethodName,
348 theBackgroundGradientFillMethod);
349 }
350
351 //! Changes the background in accordance with passed command line options
352 class BackgroundChanger
353 {
354 public:
355 //! Constructor. Prepares the command parser
356 BackgroundChanger()
357 {
358 prepareCommandParser();
359 }
360
361 //! Processes the command line and changes the background
362 //! @param theDrawInterpretor the interpreter of the Draw Harness application
363 //! @param theNumberOfCommandLineArguments the number of passed command line arguments
364 //! @param theCommandLineArguments the array of command line arguments
365 bool ProcessCommandLine (Draw_Interpretor& theDrawInterpretor,
366 const Standard_Integer theNumberOfCommandLineArguments,
367 const char* const* const theCommandLineArguments)
368 {
369 const char* const aBackgroundCommandName = theCommandLineArguments[0];
370 BackgroundCommand aBackgroundCommand = BackgroundCommand_Main;
371 if (!getBackgroundCommandByName (aBackgroundCommandName, aBackgroundCommand))
372 {
373 return false;
374 }
375 addCommandDescription (aBackgroundCommand);
376 myCommandParser.Parse (theNumberOfCommandLineArguments, theCommandLineArguments);
377 return processCommandOptions (aBackgroundCommandName, aBackgroundCommand, theDrawInterpretor);
378 }
379
380 private:
381 //! The type of functions that are able to set gradient background filling
382 typedef void SetGradientFunction (const Quantity_Color& /* theColor1 */,
383 const Quantity_Color& /* theColor2 */,
384 const Aspect_GradientFillMethod /* theGradientMode */);
385
386 //! The type of functions that are able to fill a background with a specific color
387 typedef void SetColorFunction (const Quantity_Color& /* theColor */);
388
389 //! the command parser used to parse command line options and its arguments
390 ViewerTest_CmdParser myCommandParser;
391
392 //! the option key for the command that sets an image as a background
393 ViewerTest_CommandOptionKey myImageOptionKey;
394
395 //! the option key for the command that sets a background image fill type
396 ViewerTest_CommandOptionKey myImageModeOptionKey;
397
398 //! the option key for the command that sets a gradient filling for the background
399 ViewerTest_CommandOptionKey myGradientOptionKey;
400
401 //! the option key for the command that sets a background gradient filling method
402 ViewerTest_CommandOptionKey myGradientModeOptionKey;
403
404 //! the option key for the command that fills background with a specific color
405 ViewerTest_CommandOptionKey myColorOptionKey;
406
407 //! the option key for the command that sets default background gradient or color
408 ViewerTest_CommandOptionKey myDefaultOptionKey;
409
077a220c 410 //! the option key for the command that sets an environment cubemap as a background
411 ViewerTest_CommandOptionKey myCubeMapOptionKey;
412
413 //! the option key for the command that defines order of tiles in one image packed cubemap
414 ViewerTest_CommandOptionKey myCubeMapOrderOptionKey;
415
416 //! the option key for the command that sets inversion of Z axis for background cubemap
417 ViewerTest_CommandOptionKey myCubeMapInvertedZOptionKey;
418
67312b79 419 //! the option key for the command that allows skip IBL map generation
420 ViewerTest_CommandOptionKey myCubeMapDoNotGenPBREnvOptionKey;
421
293211ae 422 //! the variable set of options that are allowed for the old scenario (without any option passed)
423 CommandOptionKeyVariableSet myUnnamedOptionVariableSet;
424
077a220c 425 //! the variable set of options that are allowed for setting an environment cubemap as background
426 CommandOptionKeyVariableSet myCubeMapOptionVariableSet;
427
293211ae 428 //! the variable set of options that are allowed for setting an image as a background
429 CommandOptionKeyVariableSet myImageOptionVariableSet;
430
431 //! the variable set of options that are allowed for setting a background image fill type
432 CommandOptionKeyVariableSet myImageModeOptionVariableSet;
433
434 //! the variable set of options that are allowed for setting a gradient filling for the background
435 CommandOptionKeyVariableSet myGradientOptionVariableSet;
436
437 //! the variable set of options that are allowed for setting a background gradient filling method
438 CommandOptionKeyVariableSet myGradientModeOptionVariableSet;
439
440 //! the variable set of options that are allowed for filling a background with a specific color
441 CommandOptionKeyVariableSet myColorOptionVariableSet;
442
443 //! the variable set of options that are allowed for setting a default background gradient
444 CommandOptionKeyVariableSet myDefaultGradientOptionVariableSet;
445
446 //! the variable set of options that are allowed for setting a default background color
447 CommandOptionKeyVariableSet myDefaultColorOptionVariableSet;
448
449 //! the variable set of options that are allowed for printing help
450 CommandOptionKeyVariableSet myHelpOptionVariableSet;
451
452 //! Adds options to command parser
453 void addOptionsToCommandParser()
454 {
455 myImageOptionKey = myCommandParser.AddOption ("imageFile|image|imgFile|img",
456 "filename of image used as background");
457 myImageModeOptionKey = myCommandParser.AddOption (
458 "imageMode|imgMode", "image fill type, should be one of CENTERED, TILED, STRETCH, NONE");
459 myGradientOptionKey = myCommandParser.AddOption ("gradient|grad|gr",
460 "sets background gradient starting and ending colors");
461 myGradientModeOptionKey =
462 myCommandParser.AddOption ("gradientMode|gradMode|gradMd|grMode|grMd",
463 "gradient fill method, should be one of NONE, HOR[IZONTAL], VER[TICAL], "
464 "DIAG[ONAL]1, DIAG[ONAL]2, CORNER1, CORNER2, CORNER3, CORNER4");
465 myColorOptionKey = myCommandParser.AddOption ("color|col", "background color");
466 myDefaultOptionKey = myCommandParser.AddOption ("default|def", "sets background default gradient or color");
077a220c 467
468 myCubeMapOptionKey = myCommandParser.AddOption ("cubemap|cmap|cm", "background cubemap");
469 myCubeMapOrderOptionKey = myCommandParser.AddOption ("order|o", "order of sides in one image packed cubemap");
470 myCubeMapInvertedZOptionKey = myCommandParser.AddOption (
471 "invertedz|invz|iz", "whether Z axis is inverted or not during background cubemap rendering");
67312b79 472 myCubeMapDoNotGenPBREnvOptionKey = myCommandParser.AddOption ("nopbrenv", "whether IBL map generation should be skipped");
293211ae 473 }
474
475 //! Creates option sets used to determine if a passed option set is valid or not
476 void createOptionSets()
477 {
478 ViewerTest_CommandOptionKeySet anUnnamedOptionSet;
479 anUnnamedOptionSet.insert (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY);
480 myUnnamedOptionVariableSet = CommandOptionKeyVariableSet (anUnnamedOptionSet);
481
077a220c 482 ViewerTest_CommandOptionKeySet aCubeMapOptionSet;
483 aCubeMapOptionSet.insert (myCubeMapOptionKey);
484 ViewerTest_CommandOptionKeySet aCubeMapAdditionalOptionKeySet;
485 aCubeMapAdditionalOptionKeySet.insert (myCubeMapInvertedZOptionKey);
67312b79 486 aCubeMapAdditionalOptionKeySet.insert (myCubeMapDoNotGenPBREnvOptionKey);
077a220c 487 aCubeMapAdditionalOptionKeySet.insert (myCubeMapOrderOptionKey);
488 myCubeMapOptionVariableSet = CommandOptionKeyVariableSet (aCubeMapOptionSet, aCubeMapAdditionalOptionKeySet);
489
293211ae 490 ViewerTest_CommandOptionKeySet anImageOptionSet;
491 anImageOptionSet.insert (myImageOptionKey);
492 ViewerTest_CommandOptionKeySet anImageModeOptionSet;
493 anImageModeOptionSet.insert (myImageModeOptionKey);
494 myImageOptionVariableSet = CommandOptionKeyVariableSet (anImageOptionSet, anImageModeOptionSet);
495 myImageModeOptionVariableSet = CommandOptionKeyVariableSet (anImageModeOptionSet);
496
497 ViewerTest_CommandOptionKeySet aGradientOptionSet;
498 aGradientOptionSet.insert (myGradientOptionKey);
499 ViewerTest_CommandOptionKeySet aGradientModeOptionSet;
500 aGradientModeOptionSet.insert (myGradientModeOptionKey);
501 myGradientOptionVariableSet = CommandOptionKeyVariableSet (aGradientOptionSet, aGradientModeOptionSet);
502 myGradientModeOptionVariableSet = CommandOptionKeyVariableSet (aGradientModeOptionSet);
503
504 ViewerTest_CommandOptionKeySet aColorOptionSet;
505 aColorOptionSet.insert (myColorOptionKey);
506 myColorOptionVariableSet = CommandOptionKeyVariableSet (aColorOptionSet);
507
508 aGradientOptionSet.insert (myDefaultOptionKey);
509 myDefaultGradientOptionVariableSet = CommandOptionKeyVariableSet (aGradientOptionSet, aGradientModeOptionSet);
510 aColorOptionSet.insert (myDefaultOptionKey);
511 myDefaultColorOptionVariableSet = CommandOptionKeyVariableSet (aColorOptionSet);
512
513 ViewerTest_CommandOptionKeySet aHelpOptionSet;
514 aHelpOptionSet.insert (ViewerTest_CmdParser::THE_HELP_COMMAND_OPTION_KEY);
515 myHelpOptionVariableSet = CommandOptionKeyVariableSet (aHelpOptionSet);
516 }
517
518 //! Prepares the command parser. Adds options and creates option sets used to determine
519 //! if a passed option set is valid or not
520 void prepareCommandParser()
521 {
522 addOptionsToCommandParser();
523 createOptionSets();
524 }
525
526 //! Adds a command description to the command parser
527 //! @param theBackgroundCommand the key of the command which description is added to the command parser
528 void addCommandDescription (const BackgroundCommand theBackgroundCommand)
529 {
530 std::string aDescription;
531 bool isMainCommand = false;
532 switch (theBackgroundCommand)
533 {
534 case BackgroundCommand_Main:
535 aDescription = "Command: vbackground (changes background or some background settings)";
536 isMainCommand = true;
537 break;
538 case BackgroundCommand_Image:
539 aDescription = "Command: vsetbg (loads image as a background)";
540 break;
541 case BackgroundCommand_ImageMode:
542 aDescription = "Command: vsetbgmode (changes background fill type)";
543 break;
544 case BackgroundCommand_Gradient:
545 aDescription = "Command: vsetgradientbg (mounts gradient background)";
546 break;
547 case BackgroundCommand_GradientMode:
548 aDescription = "Command: vsetgradientbgmode (changes gradient background fill method)";
549 break;
550 case BackgroundCommand_Color:
551 aDescription = "Command: vsetcolorbg (sets color background)";
552 break;
553 case BackgroundCommand_Default:
554 aDescription = "Command: vsetdefaultbg (sets default viewer background gradient or fill color)";
555 break;
556 default:
557 return;
558 }
559 if (!isMainCommand)
560 {
561 aDescription += "\nThis command is obsolete. Use vbackground instead.";
562 }
563 myCommandParser.SetDescription (aDescription);
564 }
565
566 //! Check if a viewer is needed to be initialized
567 //! @param theBackgroundCommand the key of the command that changes the background
568 //! @return true if processing was successful, or false otherwise
569 bool checkViewerIsNeeded (const BackgroundCommand theBackgroundCommand) const
570 {
571 const bool isMain = (theBackgroundCommand == BackgroundCommand_Main);
572 const ViewerTest_CommandOptionKeySet aUsedOptions = myCommandParser.GetUsedOptions();
573 const bool aViewerIsNotNeeded =
574 (theBackgroundCommand == BackgroundCommand_Default)
575 || (myDefaultGradientOptionVariableSet.IsInSet (aUsedOptions) && isMain)
576 || (myDefaultColorOptionVariableSet.IsInSet (aUsedOptions) && isMain)
577 || myHelpOptionVariableSet.IsInSet (aUsedOptions);
578 return !aViewerIsNotNeeded;
579 }
580
581 //! Check if a viewer is initialized
582 //! @param theBackgroundCommandName the name of the command that changes the background
583 //! @param theDrawInterpretor the interpreter of the Draw Harness application
584 //! @return true if a viewer is initialized, or false otherwise
585 static bool checkViewerIsInitialized (const char* const theBackgroundCommandName,
586 Draw_Interpretor& theDrawInterpretor)
587 {
588 const Handle (AIS_InteractiveContext)& anAISContext = ViewerTest::GetAISContext();
589 if (anAISContext.IsNull())
590 {
591 theDrawInterpretor << "Use 'vinit' command before executing '" << theBackgroundCommandName << "' command.\n";
592 return false;
593 }
594 return true;
595 }
596
597 //! Processes command options
598 //! @param theBackgroundCommandName the name of the command that changes the background
599 //! @param theBackgroundCommand the key of the command that changes the background
600 //! @param theDrawInterpretor the interpreter of the Draw Harness application
601 //! @return true if processing was successful, or false otherwise
602 bool processCommandOptions (const char* const theBackgroundCommandName,
603 const BackgroundCommand theBackgroundCommand,
604 Draw_Interpretor& theDrawInterpretor) const
605 {
606 if (myCommandParser.HasNoOption())
607 {
608 return printHelp (theBackgroundCommandName, theDrawInterpretor);
609 }
610 if (checkViewerIsNeeded (theBackgroundCommand)
611 && !checkViewerIsInitialized (theBackgroundCommandName, theDrawInterpretor))
612 {
613 return false;
614 }
615 if (myCommandParser.HasOnlyUnnamedOption())
616 {
617 return processUnnamedOption (theBackgroundCommand);
618 }
619 return processNamedOptions (theBackgroundCommandName, theBackgroundCommand, theDrawInterpretor);
620 }
621
622 //! Processes the unnamed option
623 //! @param theBackgroundCommand the key of the command that changes the background
624 //! @return true if processing was successful, or false otherwise
625 bool processUnnamedOption (const BackgroundCommand theBackgroundCommand) const
626 {
627 switch (theBackgroundCommand)
628 {
629 case BackgroundCommand_Main:
630 return false;
631 case BackgroundCommand_Image:
632 return processImageUnnamedOption();
633 case BackgroundCommand_ImageMode:
634 return processImageModeUnnamedOption();
635 case BackgroundCommand_Gradient:
636 return processGradientUnnamedOption();
637 case BackgroundCommand_GradientMode:
638 return processGradientModeUnnamedOption();
639 case BackgroundCommand_Color:
640 return processColorUnnamedOption();
641 case BackgroundCommand_Default:
642 return processDefaultUnnamedOption();
643 default:
644 return false;
645 }
646 }
647
648 //! Processes the image unnamed option
649 //! @return true if processing was successful, or false otherwise
650 bool processImageUnnamedOption() const
651 {
652 const std::size_t aNumberOfImageUnnamedOptionArguments = myCommandParser.GetNumberOfOptionArguments (
653 ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY);
654 if ((aNumberOfImageUnnamedOptionArguments != 1) && (aNumberOfImageUnnamedOptionArguments != 2))
655 {
656 return false;
657 }
658 std::string anImageFileName;
659 if (!myCommandParser.Arg (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, 0, anImageFileName))
660 {
661 return false;
662 }
663 Aspect_FillMethod anImageMode = Aspect_FM_CENTERED;
664 if (aNumberOfImageUnnamedOptionArguments == 2)
665 {
666 std::string anImageModeString;
667 if (!myCommandParser.Arg (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, 1, anImageModeString))
668 {
669 return false;
670 }
671 if (!getBackgroundImageFillMethodByName (anImageModeString.c_str(), anImageMode))
672 {
673 return false;
674 }
675 }
676 setImage (anImageFileName.c_str(), anImageMode);
677 return true;
678 }
679
680 //! Processes the image mode unnamed option
681 //! @return true if processing was successful, or false otherwise
682 bool processImageModeUnnamedOption() const
683 {
684 return processImageModeOptionSet (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY);
685 }
686
687 //! Processes the gradient unnamed option
688 //! @param theSetGradient the function used to set a background gradient filling
689 //! @return true if processing was successful, or false otherwise
690 bool processGradientUnnamedOption (SetGradientFunction* const theSetGradient = setGradient) const
691 {
692 const Standard_Integer aNumberOfGradientUnnamedOptionArguments = myCommandParser.GetNumberOfOptionArguments (
693 ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY);
694 if (aNumberOfGradientUnnamedOptionArguments < 2)
695 {
696 return false;
697 }
698
699 Standard_Integer anArgumentIndex = 0;
700 Quantity_Color aColor1;
701 if (!myCommandParser.ArgColor (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, anArgumentIndex, aColor1))
702 {
703 return false;
704 }
705 if (anArgumentIndex >= aNumberOfGradientUnnamedOptionArguments)
706 {
707 return false;
708 }
709
710 Quantity_Color aColor2;
711 if (!myCommandParser.ArgColor (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, anArgumentIndex, aColor2))
712 {
713 return false;
714 }
715 if (anArgumentIndex > aNumberOfGradientUnnamedOptionArguments)
716 {
717 return false;
718 }
719
720 Aspect_GradientFillMethod aGradientMode = Aspect_GFM_HOR;
721 if (anArgumentIndex == aNumberOfGradientUnnamedOptionArguments - 1)
722 {
723 std::string anGradientModeString;
724
725 if (!myCommandParser.Arg (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY,
726 anArgumentIndex,
727 anGradientModeString))
728 {
729 return false;
730 }
731 if (!getBackgroundGradientFillMethodByName (anGradientModeString.c_str(), aGradientMode))
732 {
733 return false;
734 }
735 ++anArgumentIndex;
736 }
737 if (anArgumentIndex != aNumberOfGradientUnnamedOptionArguments)
738 {
739 return false;
740 }
741 theSetGradient (aColor1, aColor2, aGradientMode);
742 return true;
743 }
744
745 //! Processes the gradient mode unnamed option
746 //! @return true if processing was successful, or false otherwise
747 bool processGradientModeUnnamedOption() const
748 {
749 return processGradientModeOptionSet (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY);
750 }
751
752 //! Processes the color unnamed option
753 //! @param theSetColor the function used to set a background color
754 //! @return true if processing was successful, or false otherwise
755 bool processColorUnnamedOption (SetColorFunction* const theSetColor = setColor) const
756 {
757 return processColorOptionSet (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, theSetColor);
758 }
759
760 //! Processes the default back unnamed option
761 //! @return true if processing was successful, or false otherwise
762 bool processDefaultUnnamedOption() const
763 {
764 if (processGradientUnnamedOption (setDefaultGradient))
765 {
766 return true;
767 }
768 return processColorUnnamedOption (setDefaultColor);
769 }
770
771 //! Processes named options
772 //! @param theBackgroundCommandName the name of the command that changes the background
773 //! @param theBackgroundCommand the key of the command that changes the background
774 //! @param theDrawInterpretor the interpreter of the Draw Harness application
775 //! @return true if processing was successful, or false otherwise
776 bool processNamedOptions (const char* const theBackgroundCommandName,
777 const BackgroundCommand theBackgroundCommand,
778 Draw_Interpretor& theDrawInterpretor) const
779 {
780 const bool isMain = (theBackgroundCommand == BackgroundCommand_Main);
781 const ViewerTest_CommandOptionKeySet aUsedOptions = myCommandParser.GetUsedOptions();
077a220c 782 if (myCubeMapOptionVariableSet.IsInSet (aUsedOptions) && isMain)
783 {
784 return processCubeMapOptionSet();
785 }
293211ae 786 if (myImageOptionVariableSet.IsInSet (aUsedOptions)
787 && (isMain || (theBackgroundCommand == BackgroundCommand_Image)))
788 {
789 return processImageOptionSet();
790 }
791 if (myImageModeOptionVariableSet.IsInSet (aUsedOptions)
792 && (isMain || (theBackgroundCommand == BackgroundCommand_ImageMode)))
793 {
794 return processImageModeOptionSet();
795 }
796 if (myGradientOptionVariableSet.IsInSet (aUsedOptions)
797 && (isMain || (theBackgroundCommand == BackgroundCommand_Gradient)))
798 {
799 return processGradientOptionSet();
800 }
801 if (myGradientModeOptionVariableSet.IsInSet (aUsedOptions)
802 && (isMain || (theBackgroundCommand == BackgroundCommand_GradientMode)))
803 {
804 return processGradientModeOptionSet();
805 }
806 if (myColorOptionVariableSet.IsInSet (aUsedOptions)
807 && (isMain || (theBackgroundCommand == BackgroundCommand_Color)))
808 {
809 return processColorOptionSet();
810 }
811 if ((myDefaultGradientOptionVariableSet.IsInSet (aUsedOptions) && isMain)
812 || (myGradientOptionVariableSet.IsInSet (aUsedOptions)
813 && (theBackgroundCommand == BackgroundCommand_Default)))
814 {
815 return processDefaultGradientOptionSet();
816 }
817 if ((myDefaultColorOptionVariableSet.IsInSet (aUsedOptions) && isMain)
818 || (myColorOptionVariableSet.IsInSet (aUsedOptions) && (theBackgroundCommand == BackgroundCommand_Default)))
819 {
820 return processDefaultColorOptionSet();
821 }
822 if (myHelpOptionVariableSet.IsInSet (aUsedOptions))
823 {
824 return processHelpOptionSet (theBackgroundCommandName, theDrawInterpretor);
825 }
826 return false;
827 }
828
077a220c 829 //! Process the cubemap option set in named and unnamed case.
830 //! @return true if processing was successful, or false otherwise
831 bool processCubeMapOptionSet() const
832 {
833 NCollection_Array1<TCollection_AsciiString> aFilePaths;
834
835 if (!processCubeMapOptions (aFilePaths))
836 {
837 return false;
838 }
839
840 Graphic3d_CubeMapOrder anOrder = Graphic3d_CubeMapOrder::Default();
841
842 if (myCommandParser.HasOption (myCubeMapOrderOptionKey))
843 {
844 if (!processCubeMapOrderOptions (anOrder))
845 {
846 return false;
847 }
848 }
849
850 bool aZIsInverted = false;
851 if (myCommandParser.HasOption (myCubeMapInvertedZOptionKey))
852 {
853 if (!processCubeMapInvertedZOptionSet())
854 {
855 return false;
856 }
857 aZIsInverted = true;
858 }
859
67312b79 860 bool aToGenPBREnv = true;
861 if (myCommandParser.HasOption (myCubeMapDoNotGenPBREnvOptionKey))
862 {
863 if (!processCubeMapDoNotGenPBREnvOptionSet())
864 {
865 return false;
866 }
867 aToGenPBREnv = false;
868 }
869
870 setCubeMap (aFilePaths, anOrder.Validated(), aZIsInverted, aToGenPBREnv);
077a220c 871 return true;
872 }
873
293211ae 874 //! Processes the image option set
875 //! @return true if processing was successful, or false otherwise
876 bool processImageOptionSet() const
877 {
878 std::string anImageFileName;
879 if (!processImageOption (anImageFileName))
880 {
881 return false;
882 }
883 Aspect_FillMethod anImageMode = Aspect_FM_CENTERED;
884 if (myCommandParser.HasOption (myImageModeOptionKey) && !processImageModeOption (anImageMode))
885 {
886 return false;
887 }
888 setImage (anImageFileName.c_str(), anImageMode);
889 return true;
890 }
891
892 //! Processes the image mode option set
893 //! @return true if processing was successful, or false otherwise
894 bool processImageModeOptionSet() const
895 {
896 return processImageModeOptionSet (myImageModeOptionKey);
897 }
898
899 //! Processes the image mode option set
900 //! @param theImageModeOptionKey the key of the option that is interpreted as an image mode option
901 //! @return true if processing was successful, or false otherwise
902 bool processImageModeOptionSet (const ViewerTest_CommandOptionKey theImageModeOptionKey) const
903 {
904 Aspect_FillMethod anImageMode = Aspect_FM_NONE;
905 if (!processImageModeOption (theImageModeOptionKey, anImageMode))
906 {
907 return false;
908 }
909 setImageMode (anImageMode);
910 return true;
911 }
912
913 //! Processes the gradient option set
914 //! @param theSetGradient the function used to set a background gradient filling
915 //! @return true if processing was successful, or false otherwise
916 bool processGradientOptionSet (SetGradientFunction* const theSetGradient = setGradient) const
917 {
918 Quantity_Color aColor1;
919 Quantity_Color aColor2;
920 if (!processGradientOption (aColor1, aColor2))
921 {
922 return false;
923 }
924 Aspect_GradientFillMethod aGradientMode = Aspect_GFM_HOR;
925 if (myCommandParser.HasOption (myGradientModeOptionKey) && !processGradientModeOption (aGradientMode))
926 {
927 return false;
928 }
929 theSetGradient (aColor1, aColor2, aGradientMode);
930 return true;
931 }
932
933 //! Processes the gradient mode option set
934 //! @return true if processing was successful, or false otherwise
935 bool processGradientModeOptionSet() const
936 {
937 return processGradientModeOptionSet (myGradientModeOptionKey);
938 }
939
940 //! Processes the gradient mode option set
941 //! @param theGradientModeOptionKey the key of the option that is interpreted as a gradient mode option
942 //! @return true if processing was successful, or false otherwise
943 bool processGradientModeOptionSet (const ViewerTest_CommandOptionKey theGradientModeOptionKey) const
944 {
945 Aspect_GradientFillMethod aGradientMode = Aspect_GFM_NONE;
946 if (!processGradientModeOption (theGradientModeOptionKey, aGradientMode))
947 {
948 return false;
949 }
950 setGradientMode (aGradientMode);
951 return true;
952 }
953
954 //! Processes the color option set
955 //! @param theSetColor the function used to set a background color
956 //! @return true if processing was successful, or false otherwise
957 bool processColorOptionSet (SetColorFunction* const theSetColor = setColor) const
958 {
959 return processColorOptionSet (myColorOptionKey, theSetColor);
960 }
961
962 //! Processes the default color option set
963 //! @return true if processing was successful, or false otherwise
964 bool processDefaultGradientOptionSet() const
965 {
966 return processGradientOptionSet (setDefaultGradient);
967 }
968
969 //! Processes the default gradient option set
970 //! @return true if processing was successful, or false otherwise
971 bool processDefaultColorOptionSet() const
972 {
973 return processColorOptionSet (setDefaultColor);
974 }
975
976 //! Processes the color option set
977 //! @param theColorOptionKey the key of the option that is interpreted as a color option
978 //! @param theSetColor the function used to set a background color
979 //! @return true if processing was successful, or false otherwise
980 bool processColorOptionSet (const ViewerTest_CommandOptionKey theColorOptionKey,
981 SetColorFunction* const theSetColor = setColor) const
982 {
983 Quantity_Color aColor;
984 if (!processColorOption (theColorOptionKey, aColor))
985 {
986 return false;
987 }
988 theSetColor (aColor);
989 return true;
990 }
991
992 //! Processes the help option set
993 //! @param theBackgroundCommandName the name of the command that changes the background
994 //! @param theDrawInterpretor the interpreter of the Draw Harness application
995 //! @return true if processing was successful, or false otherwise
996 bool processHelpOptionSet (const char* const theBackgroundCommandName, Draw_Interpretor& theDrawInterpretor) const
997 {
998 const Standard_Integer aNumberOfHelpOptionArguments = myCommandParser.GetNumberOfOptionArguments (
999 ViewerTest_CmdParser::THE_HELP_COMMAND_OPTION_KEY);
1000 if (aNumberOfHelpOptionArguments != 0)
1001 {
1002 return false;
1003 }
1004 return printHelp (theBackgroundCommandName, theDrawInterpretor);
1005 }
1006
077a220c 1007 //! Processes the cubemap option
1008 //! @param theFilePaths the array of filenames of cubemap sides
1009 //! @return true if processing was successful, or false otherwise
1010 bool processCubeMapOptions (NCollection_Array1<TCollection_AsciiString> &theFilePaths) const
1011 {
1012 const Standard_Integer aNumberOfCubeMapOptionArguments = myCommandParser.GetNumberOfOptionArguments (myCubeMapOptionKey);
1013
1014 if (aNumberOfCubeMapOptionArguments != 1
1015 && aNumberOfCubeMapOptionArguments != 6)
1016 {
1017 return false;
1018 }
1019
1020 theFilePaths.Resize(0, aNumberOfCubeMapOptionArguments - 1, Standard_False);
1021
1022 for (int i = 0; i < aNumberOfCubeMapOptionArguments; ++i)
1023 {
1024 std::string aCubeMapFileName;
1025 if (!myCommandParser.Arg (myCubeMapOptionKey, i, aCubeMapFileName))
1026 {
1027 return false;
1028 }
1029 theFilePaths[i] = aCubeMapFileName.c_str();
1030 }
1031
1032 return true;
1033 }
1034
67312b79 1035 //! Processes the inverted z cubemap option
077a220c 1036 //! @return true if processing was successful, or false otherwise
1037 bool processCubeMapInvertedZOptionSet () const
1038 {
1039 const Standard_Integer aNumberOfCubeMapZInversionOptionArguments =
1040 myCommandParser.GetNumberOfOptionArguments (myCubeMapInvertedZOptionKey);
1041
1042 if (aNumberOfCubeMapZInversionOptionArguments != 0)
1043 {
1044 return false;
1045 }
1046
1047 return true;
1048 }
1049
67312b79 1050 //! Processes the option allowing to skip IBM maps generation
1051 //! @return true if processing was successful, or false otherwise
1052 bool processCubeMapDoNotGenPBREnvOptionSet() const
1053 {
1054 const Standard_Integer aNumberOfCubeMapDoNotGenPBREnvOptionArguments =
1055 myCommandParser.GetNumberOfOptionArguments(myCubeMapDoNotGenPBREnvOptionKey);
1056
1057 if (aNumberOfCubeMapDoNotGenPBREnvOptionArguments != 0)
1058 {
1059 return false;
1060 }
1061
1062 return true;
1063 }
1064
077a220c 1065 //! Processes the tiles order option
1066 //! @param theOrder the array of indexes if cubemap sides in tile grid
1067 //! @return true if processing was successful, or false otherwise
1068 bool processCubeMapOrderOptions (Graphic3d_CubeMapOrder& theOrder) const
1069 {
1070 const Standard_Integer aNumberOfCubeMapOrderOptionArguments = myCommandParser.GetNumberOfOptionArguments(
1071 myCubeMapOrderOptionKey);
1072
1073 if (aNumberOfCubeMapOrderOptionArguments != 6)
1074 {
1075 return false;
1076 }
1077
1078
1079 for (unsigned int i = 0; i < 6; ++i)
1080 {
1081 std::string anOrderItem;
1082 if (!myCommandParser.Arg (myCubeMapOrderOptionKey, i, anOrderItem))
1083 {
1084 return false;
1085 }
1086
1087 theOrder.Set (Graphic3d_CubeMapSide (i),
1088 static_cast<unsigned char> (Draw::Atoi (anOrderItem.c_str())));
1089 }
1090
1091 return theOrder.IsValid();
1092 }
1093
293211ae 1094 //! Processes the image option
1095 //! @param theImageFileName the filename of the image to be used as a background
1096 //! @return true if processing was successful, or false otherwise
1097 bool processImageOption (std::string& theImageFileName) const
1098 {
1099 const Standard_Integer aNumberOfImageOptionArguments = myCommandParser.GetNumberOfOptionArguments (
1100 myImageOptionKey);
1101 if (aNumberOfImageOptionArguments != 1)
1102 {
1103 return false;
1104 }
1105 std::string anImageFileName;
1106 if (!myCommandParser.Arg (myImageOptionKey, 0, anImageFileName))
1107 {
1108 return false;
1109 }
1110 theImageFileName = anImageFileName;
1111 return true;
1112 }
1113
1114 //! Processes the image mode option
1115 //! @param theImageMode the fill type used for a background image
1116 //! @return true if processing was successful, or false otherwise
1117 bool processImageModeOption (Aspect_FillMethod& theImageMode) const
1118 {
1119 return processImageModeOption (myImageModeOptionKey, theImageMode);
1120 }
1121
1122 //! Processes the image mode option
1123 //! @param theImageModeOptionKey the key of the option that is interpreted as an image mode option
1124 //! @param theImageMode the fill type used for a background image
1125 //! @return true if processing was successful, or false otherwise
1126 bool processImageModeOption (const ViewerTest_CommandOptionKey theImageModeOptionKey,
1127 Aspect_FillMethod& theImageMode) const
1128 {
1129 return processModeOption (theImageModeOptionKey, getBackgroundImageFillMethodByName, theImageMode);
1130 }
1131
1132 //! Processes the gradient option
1133 //! @param theColor1 the gradient starting color
1134 //! @param theColor2 the gradient ending color
1135 //! @return true if processing was successful, or false otherwise
1136 bool processGradientOption (Quantity_Color& theColor1, Quantity_Color& theColor2) const
1137 {
1138 Standard_Integer anArgumentIndex = 0;
1139 Quantity_Color aColor1;
1140 if (!myCommandParser.ArgColor (myGradientOptionKey, anArgumentIndex, aColor1))
1141 {
1142 return false;
1143 }
1144 Quantity_Color aColor2;
1145 if (!myCommandParser.ArgColor (myGradientOptionKey, anArgumentIndex, aColor2))
1146 {
1147 return false;
1148 }
1149 const Standard_Integer aNumberOfGradientOptionArguments = myCommandParser.GetNumberOfOptionArguments (
1150 myGradientOptionKey);
1151 if (anArgumentIndex != aNumberOfGradientOptionArguments)
1152 {
1153 return false;
1154 }
1155 theColor1 = aColor1;
1156 theColor2 = aColor2;
1157 return true;
1158 }
1159
1160 //! Processes the gradient mode option
1161 //! @param theGradientMode the fill method used for a background gradient filling
1162 //! @return true if processing was successful, or false otherwise
1163 bool processGradientModeOption (Aspect_GradientFillMethod& theGradientMode) const
1164 {
1165 return processGradientModeOption (myGradientModeOptionKey, theGradientMode);
1166 }
1167
1168 //! Processes the gradient mode option
1169 //! @param theGradientModeOptionKey the key of the option that is interpreted as a gradient mode option
1170 //! @param theGradientMode the fill method used for a background gradient filling
1171 //! @return true if processing was successful, or false otherwise
1172 bool processGradientModeOption (const ViewerTest_CommandOptionKey theGradientModeOptionKey,
1173 Aspect_GradientFillMethod& theGradientMode) const
1174 {
1175 return processModeOption (theGradientModeOptionKey, getBackgroundGradientFillMethodByName, theGradientMode);
1176 }
1177
1178 //! Processes some mode option
1179 //! @tparam TheMode the type of a mode to be processed
1180 //! @param theModeOptionKey the key of the option that is interpreted as a mode option
1181 //! @param theMode a mode to be processed
1182 //! @return true if processing was successful, or false otherwise
1183 template <typename TheMode>
1184 bool processModeOption (const ViewerTest_CommandOptionKey theModeOptionKey,
1185 bool (*const theGetModeByName) (const TCollection_AsciiString& /* theModeName */,
1186 TheMode& /* theMode */),
1187 TheMode& theMode) const
1188 {
1189 const Standard_Integer aNumberOfModeOptionArguments = myCommandParser.GetNumberOfOptionArguments (
1190 theModeOptionKey);
1191 if (aNumberOfModeOptionArguments != 1)
1192 {
1193 return false;
1194 }
1195 std::string aModeString;
1196 if (!myCommandParser.Arg (theModeOptionKey, 0, aModeString))
1197 {
1198 return false;
1199 }
1200 TheMode aMode = TheMode();
1201 if (!theGetModeByName (aModeString.c_str(), aMode))
1202 {
1203 return false;
1204 }
1205 theMode = aMode;
1206 return true;
1207 }
1208
1209 //! Processes the color option
1210 //! @param theColor a color used for filling a background
1211 //! @return true if processing was successful, or false otherwise
1212 bool processColorOption (Quantity_Color& theColor) const
1213 {
1214 return processColorOption (myColorOptionKey, theColor);
1215 }
1216
1217 //! Processes the color option
1218 //! @param theColorOptionKey the key of the option that is interpreted as a color option
1219 //! @param theColor a color used for filling a background
1220 //! @return true if processing was successful, or false otherwise
1221 bool processColorOption (const ViewerTest_CommandOptionKey theColorOptionKey, Quantity_Color& theColor) const
1222 {
1223 Standard_Integer anArgumentIndex = 0;
1224 Quantity_Color aColor;
1225 if (!myCommandParser.ArgColor (theColorOptionKey, anArgumentIndex, aColor))
1226 {
1227 return false;
1228 }
1229 const Standard_Integer aNumberOfColorOptionArguments = myCommandParser.GetNumberOfOptionArguments (
1230 theColorOptionKey);
1231 if (anArgumentIndex != aNumberOfColorOptionArguments)
1232 {
1233 return false;
1234 }
1235 theColor = aColor;
1236 return true;
1237 }
1238
1239 //! Prints helping message
1240 //! @param theBackgroundCommandName the name of the command that changes the background
1241 //! @param theDrawInterpretor the interpreter of the Draw Harness application
1242 //! @return true if printing was successful, or false otherwise
1243 static bool printHelp (const char* const theBackgroundCommandName, Draw_Interpretor& theDrawInterpretor)
1244 {
1245 return theDrawInterpretor.PrintHelp (theBackgroundCommandName) == TCL_OK;
1246 }
1247
077a220c 1248 //! Sets the cubemap as a background
1249 //! @param theFileNames the array of filenames of packed or multifile cubemap
1250 //! @param theOrder array of cubemap sides indexes mapping them from tiles in packed cubemap
1251 static void setCubeMap (const NCollection_Array1<TCollection_AsciiString>& theFileNames,
1252 const Graphic3d_ValidatedCubeMapOrder theOrder = Graphic3d_CubeMapOrder::Default(),
67312b79 1253 bool theZIsInverted = false,
1254 bool theToGenPBREnv = true)
077a220c 1255 {
1256 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
1257 Handle(Graphic3d_CubeMap) aCubeMap;
1258
1259 if (theFileNames.Size() == 1)
1260 aCubeMap = new Graphic3d_CubeMapPacked(theFileNames[0], theOrder);
1261 else
1262 aCubeMap = new Graphic3d_CubeMapSeparate(theFileNames);
1263
1264 aCubeMap->SetZInversion (theZIsInverted);
1265
1266 aCubeMap->GetParams()->SetFilter(Graphic3d_TOTF_BILINEAR);
1267 aCubeMap->GetParams()->SetRepeat(Standard_False);
1268 aCubeMap->GetParams()->SetTextureUnit(Graphic3d_TextureUnit_EnvMap);
1269
67312b79 1270 aCurrentView->SetBackgroundCubeMap (aCubeMap, theToGenPBREnv, Standard_True);
077a220c 1271 }
1272
293211ae 1273 //! Sets the image as a background
1274 //! @param theImageFileName the filename of the image to be used as a background
1275 //! @param theImageMode the fill type used for a background image
1276 static void setImage (const Standard_CString theImageFileName, const Aspect_FillMethod theImageMode)
1277 {
1278 const Handle (V3d_View)& aCurrentView = ViewerTest::CurrentView();
1279 aCurrentView->SetBackgroundImage (theImageFileName, theImageMode, Standard_True);
1280 }
1281
1282 //! Sets the fill type used for a background image
1283 //! @param theImageMode the fill type used for a background image
1284 static void setImageMode (const Aspect_FillMethod theImageMode)
1285 {
1286 const Handle (V3d_View)& aCurrentView = ViewerTest::CurrentView();
1287 aCurrentView->SetBgImageStyle (theImageMode, Standard_True);
1288 }
1289
1290 //! Sets the gradient filling for a background
1291 //! @param theColor1 the gradient starting color
1292 //! @param theColor2 the gradient ending color
1293 //! @param theGradientMode the fill method used for a background gradient filling
1294 static void setGradient (const Quantity_Color& theColor1,
1295 const Quantity_Color& theColor2,
1296 const Aspect_GradientFillMethod theGradientMode)
1297 {
1298 const Handle (V3d_View)& aCurrentView = ViewerTest::CurrentView();
1299 aCurrentView->SetBgGradientColors (theColor1, theColor2, theGradientMode, Standard_True);
1300 }
1301
1302 //! Sets the fill method used for a background gradient filling
1303 //! @param theGradientMode the fill method used for a background gradient filling
1304 static void setGradientMode (const Aspect_GradientFillMethod theGradientMode)
1305 {
1306 const Handle (V3d_View)& aCurrentView = ViewerTest::CurrentView();
1307 aCurrentView->SetBgGradientStyle (theGradientMode, Standard_True);
1308 }
1309
1310 //! Sets the color used for filling a background
1311 //! @param theColor the color used for filling a background
1312 static void setColor (const Quantity_Color& theColor)
1313 {
1314 const Handle (V3d_View)& aCurrentView = ViewerTest::CurrentView();
1315 aCurrentView->SetBgGradientStyle (Aspect_GFM_NONE);
1316 aCurrentView->SetBackgroundColor (theColor);
1317 aCurrentView->Update();
1318 }
1319
1320 //! Sets the gradient filling for a background in a default viewer
1321 //! @param theColor1 the gradient starting color
1322 //! @param theColor2 the gradient ending color
1323 //! @param theGradientMode the fill method used for a background gradient filling
1324 static void setDefaultGradient (const Quantity_Color& theColor1,
1325 const Quantity_Color& theColor2,
1326 const Aspect_GradientFillMethod theGradientMode)
1327 {
1328 ViewerTest_DefaultBackground.GradientColor1 = theColor1;
1329 ViewerTest_DefaultBackground.GradientColor2 = theColor2;
1330 ViewerTest_DefaultBackground.FillMethod = theGradientMode;
1331 setDefaultGradient();
1332 }
1333
1334 //! Sets the color used for filling a background in a default viewer
1335 //! @param theColor the color used for filling a background
1336 static void setDefaultColor (const Quantity_Color& theColor)
1337 {
1338 ViewerTest_DefaultBackground.GradientColor1 = Quantity_Color();
1339 ViewerTest_DefaultBackground.GradientColor2 = Quantity_Color();
1340 ViewerTest_DefaultBackground.FillMethod = Aspect_GFM_NONE;
1341 ViewerTest_DefaultBackground.FlatColor = theColor;
1342 setDefaultGradient();
1343 setDefaultColor();
1344 }
1345
1346 //! Sets the gradient filling for a background in a default viewer.
1347 //! Gradient settings are taken from ViewerTest_DefaultBackground structure
1348 static void setDefaultGradient()
1349 {
1350 for (NCollection_DoubleMap<TCollection_AsciiString, Handle (AIS_InteractiveContext)>::Iterator
1351 anInteractiveContextIterator (ViewerTest_myContexts);
1352 anInteractiveContextIterator.More();
1353 anInteractiveContextIterator.Next())
1354 {
1355 const Handle (V3d_Viewer)& aViewer = anInteractiveContextIterator.Value()->CurrentViewer();
1356 aViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
1357 ViewerTest_DefaultBackground.GradientColor2,
1358 ViewerTest_DefaultBackground.FillMethod);
1359 }
1360 }
1361
1362 //! Sets the color used for filling a background in a default viewer.
1363 //! The color value is taken from ViewerTest_DefaultBackground structure
1364 static void setDefaultColor()
1365 {
1366 for (NCollection_DoubleMap<TCollection_AsciiString, Handle (AIS_InteractiveContext)>::Iterator
1367 anInteractiveContextIterator (ViewerTest_myContexts);
1368 anInteractiveContextIterator.More();
1369 anInteractiveContextIterator.Next())
1370 {
1371 const Handle (V3d_Viewer)& aViewer = anInteractiveContextIterator.Value()->CurrentViewer();
1372 aViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
1373 }
1374 }
1375 };
1376
1377} // namespace
b12e1c7b 1378
7fd59977 1379//==============================================================================
1380
57c28b61 1381#ifdef _WIN32
7fd59977 1382static LRESULT WINAPI ViewerWindowProc(
1383 HWND hwnd,
1384 UINT uMsg,
1385 WPARAM wParam,
1386 LPARAM lParam );
1387static LRESULT WINAPI AdvViewerWindowProc(
1388 HWND hwnd,
1389 UINT uMsg,
1390 WPARAM wParam,
1391 LPARAM lParam );
1392#endif
1393
1394
1395//==============================================================================
1396//function : WClass
1397//purpose :
1398//==============================================================================
1399
ad03c234 1400const Handle(Standard_Transient)& ViewerTest::WClass()
7fd59977 1401{
ad03c234 1402 static Handle(Standard_Transient) theWClass;
58655684 1403#if defined(_WIN32)
4fe56619 1404 if (theWClass.IsNull())
1405 {
7c65581d 1406 theWClass = new WNT_WClass ("GW3D_Class", (Standard_Address )AdvViewerWindowProc,
ad03c234 1407 CS_VREDRAW | CS_HREDRAW, 0, 0,
c85a994a 1408 ::LoadCursor (NULL, IDC_ARROW));
7fd59977 1409 }
1410#endif
1411 return theWClass;
1412}
1413
18d715bd 1414//==============================================================================
1415//function : CreateName
1416//purpose : Create numerical name for new object in theMap
1417//==============================================================================
1418template <typename ObjectType>
1419TCollection_AsciiString CreateName (const NCollection_DoubleMap <TCollection_AsciiString, ObjectType>& theObjectMap,
1420 const TCollection_AsciiString& theDefaultString)
1421{
1422 if (theObjectMap.IsEmpty())
1423 return theDefaultString + TCollection_AsciiString(1);
1424
1425 Standard_Integer aNextKey = 1;
1426 Standard_Boolean isFound = Standard_False;
1427 while (!isFound)
1428 {
1429 TCollection_AsciiString aStringKey = theDefaultString + TCollection_AsciiString(aNextKey);
1430 // Look for objects with default names
1431 if (theObjectMap.IsBound1(aStringKey))
1432 {
1433 aNextKey++;
1434 }
1435 else
1436 isFound = Standard_True;
1437 }
1438
1439 return theDefaultString + TCollection_AsciiString(aNextKey);
1440}
1441
1442//==============================================================================
1443//structure : ViewerTest_Names
1444//purpose : Allow to operate with full view name: driverName/viewerName/viewName
1445//==============================================================================
1446struct ViewerTest_Names
1447{
1448private:
1449 TCollection_AsciiString myDriverName;
1450 TCollection_AsciiString myViewerName;
1451 TCollection_AsciiString myViewName;
1452
1453public:
1454
1455 const TCollection_AsciiString& GetDriverName () const
1456 {
1457 return myDriverName;
1458 }
1459 void SetDriverName (const TCollection_AsciiString& theDriverName)
1460 {
1461 myDriverName = theDriverName;
1462 }
1463 const TCollection_AsciiString& GetViewerName () const
1464 {
1465 return myViewerName;
1466 }
1467 void SetViewerName (const TCollection_AsciiString& theViewerName)
1468 {
1469 myViewerName = theViewerName;
1470 }
1471 const TCollection_AsciiString& GetViewName () const
1472 {
1473 return myViewName;
1474 }
1475 void SetViewName (const TCollection_AsciiString& theViewName)
1476 {
1477 myViewName = theViewName;
1478 }
1479
1480 //===========================================================================
1481 //function : Constructor for ViewerTest_Names
1482 //purpose : Get view, viewer, driver names from custom string
1483 //===========================================================================
1484
1485 ViewerTest_Names (const TCollection_AsciiString& theInputString)
1486 {
1487 TCollection_AsciiString aName(theInputString);
1488 if (theInputString.IsEmpty())
1489 {
1490 // Get current configuration
1491 if (ViewerTest_myDrivers.IsEmpty())
1492 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
1493 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
1494 else
1495 myDriverName = ViewerTest_myDrivers.Find2
1496 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
1497
1498 if(ViewerTest_myContexts.IsEmpty())
1499 {
1500 myViewerName = CreateName <Handle(AIS_InteractiveContext)>
1501 (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
1502 }
1503 else
c48e2889 1504 {
18d715bd 1505 myViewerName = ViewerTest_myContexts.Find2 (ViewerTest::GetAISContext());
c48e2889 1506 }
18d715bd 1507
c48e2889 1508 myViewName = CreateName <Handle(V3d_View)> (ViewerTest_myViews, TCollection_AsciiString(myViewerName + "/View"));
18d715bd 1509 }
1510 else
1511 {
1512 // There is at least view name
1513 Standard_Integer aParserNumber = 0;
1514 for (Standard_Integer i = 0; i < 3; ++i)
1515 {
1516 Standard_Integer aParserPos = aName.SearchFromEnd("/");
1517 if(aParserPos != -1)
1518 {
1519 aParserNumber++;
1520 aName.Split(aParserPos-1);
1521 }
1522 else
1523 break;
1524 }
1525 if (aParserNumber == 0)
1526 {
1527 // Only view name
1528 if (!ViewerTest::GetAISContext().IsNull())
1529 {
1530 myDriverName = ViewerTest_myDrivers.Find2
1531 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
1532 myViewerName = ViewerTest_myContexts.Find2
1533 (ViewerTest::GetAISContext());
1534 }
1535 else
1536 {
1537 // There is no opened contexts here, need to create names for viewer and driver
1538 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
1539 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
1540
1541 myViewerName = CreateName <Handle(AIS_InteractiveContext)>
1542 (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
1543 }
1544 myViewName = TCollection_AsciiString(myViewerName + "/" + theInputString);
1545 }
1546 else if (aParserNumber == 1)
1547 {
1548 // Here is viewerName/viewName
1549 if (!ViewerTest::GetAISContext().IsNull())
1550 myDriverName = ViewerTest_myDrivers.Find2
1551 (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
1552 else
1553 {
1554 // There is no opened contexts here, need to create name for driver
1555 myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
1556 (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
1557 }
1558 myViewerName = TCollection_AsciiString(myDriverName + "/" + aName);
1559
1560 myViewName = TCollection_AsciiString(myDriverName + "/" + theInputString);
1561 }
1562 else
1563 {
1564 //Here is driverName/viewerName/viewName
1565 myDriverName = TCollection_AsciiString(aName);
1566
1567 TCollection_AsciiString aViewerName(theInputString);
1568 aViewerName.Split(aViewerName.SearchFromEnd("/") - 1);
1569 myViewerName = TCollection_AsciiString(aViewerName);
1570
1571 myViewName = TCollection_AsciiString(theInputString);
1572 }
1573 }
1574 }
1575};
1576
1577//==============================================================================
1578//function : FindContextByView
1579//purpose : Find AIS_InteractiveContext by View
1580//==============================================================================
1581
1582Handle(AIS_InteractiveContext) FindContextByView (const Handle(V3d_View)& theView)
1583{
1584 Handle(AIS_InteractiveContext) anAISContext;
1585
1586 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1587 anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
1588 {
1589 if (anIter.Value()->CurrentViewer() == theView->Viewer())
1590 return anIter.Key2();
1591 }
1592 return anAISContext;
1593}
1594
18d715bd 1595//==============================================================================
1596//function : IsWindowOverlapped
1597//purpose : Check if theWindow overlapp another view
1598//==============================================================================
1599
1600Standard_Boolean IsWindowOverlapped (const Standard_Integer thePxLeft,
1601 const Standard_Integer thePxTop,
1602 const Standard_Integer thePxRight,
1603 const Standard_Integer thePxBottom,
1604 TCollection_AsciiString& theViewId)
1605{
1606 for(NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
1607 anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
1608 {
1609 Standard_Integer aTop = 0,
1610 aLeft = 0,
1611 aRight = 0,
1612 aBottom = 0;
1613 anIter.Value()->Window()->Position(aLeft, aTop, aRight, aBottom);
1614 if ((thePxLeft >= aLeft && thePxLeft <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
1615 (thePxLeft >= aLeft && thePxLeft <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom) ||
1616 (thePxRight >= aLeft && thePxRight <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
1617 (thePxRight >= aLeft && thePxRight <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom))
1618 {
1619 theViewId = anIter.Key1();
1620 return Standard_True;
1621 }
1622 }
1623 return Standard_False;
1624}
1625
1626// Workaround: to create and delete non-orthographic views outside ViewerTest
1627void ViewerTest::RemoveViewName (const TCollection_AsciiString& theName)
1628{
1629 ViewerTest_myViews.UnBind1 (theName);
1630}
1631
1632void ViewerTest::InitViewName (const TCollection_AsciiString& theName,
1633 const Handle(V3d_View)& theView)
1634{
1635 ViewerTest_myViews.Bind (theName, theView);
1636}
1637
1638TCollection_AsciiString ViewerTest::GetCurrentViewName ()
1639{
1640 return ViewerTest_myViews.Find2( ViewerTest::CurrentView());
1641}
8693dfd0 1642
1643//! Auxiliary tool performing continuous redraws of specified window.
1644class ViewerTest_ContinuousRedrawer
1645{
1646public:
1647 //! Return global instance.
1648 static ViewerTest_ContinuousRedrawer& Instance()
1649 {
1650 static ViewerTest_ContinuousRedrawer aRedrawer;
1651 return aRedrawer;
1652 }
1653public:
1654
1655 //! Destructor.
1656 ~ViewerTest_ContinuousRedrawer()
1657 {
1658 Stop();
1659 }
1660
1661 //! Start thread.
1662 void Start (const Handle(Aspect_Window)& theWindow,
1663 Standard_Real theTargetFps)
1664 {
1665 if (myWindow != theWindow
1666 || myTargetFps != theTargetFps)
1667 {
1668 Stop();
1669 myWindow = theWindow;
1670 myTargetFps = theTargetFps;
1671 }
1672 if (myThread.GetId() == 0)
1673 {
1674 myToStop = false;
1675 myThread.Run (this);
1676 }
1677 }
1678
1679 //! Stop thread.
1680 void Stop (const Handle(Aspect_Window)& theWindow = NULL)
1681 {
1682 if (!theWindow.IsNull()
1683 && myWindow != theWindow)
1684 {
1685 return;
1686 }
1687
1688 {
1689 Standard_Mutex::Sentry aLock (myMutex);
1690 myToStop = true;
1691 }
1692 myThread.Wait();
1693 myToStop = false;
1694 myWindow.Nullify();
1695 }
1696
1697private:
1698
1699 //! Thread loop.
1700 void doThreadLoop()
1701 {
1702 Handle(Aspect_DisplayConnection) aDisp = new Aspect_DisplayConnection();
1703 OSD_Timer aTimer;
1704 aTimer.Start();
1705 Standard_Real aTimeOld = 0.0;
1706 const Standard_Real aTargetDur = myTargetFps > 0.0 ? 1.0 / myTargetFps : -1.0;
1707 for (;;)
1708 {
1709 {
1710 Standard_Mutex::Sentry aLock (myMutex);
1711 if (myToStop)
1712 {
1713 return;
1714 }
1715 }
1716 if (myTargetFps > 0.0)
1717 {
1718 const Standard_Real aTimeNew = aTimer.ElapsedTime();
1719 const Standard_Real aDuration = aTimeNew - aTimeOld;
1720 if (aDuration >= aTargetDur)
1721 {
1722 myWindow->InvalidateContent (aDisp);
1723 aTimeOld = aTimeNew;
1724 }
1725 }
1726 else
1727 {
1728 myWindow->InvalidateContent (aDisp);
1729 }
1730
1731 OSD::MilliSecSleep (1);
1732 }
1733 }
1734
1735 //! Thread creation callback.
1736 static Standard_Address doThreadWrapper (Standard_Address theData)
1737 {
1738 ViewerTest_ContinuousRedrawer* aThis = (ViewerTest_ContinuousRedrawer* )theData;
1739 aThis->doThreadLoop();
1740 return 0;
1741 }
1742
1743 //! Empty constructor.
1744 ViewerTest_ContinuousRedrawer()
1745 : myThread (doThreadWrapper),
1746 myTargetFps (0.0),
1747 myToStop (false) {}
1748
1749private:
1750 Handle(Aspect_Window) myWindow;
1751 OSD_Thread myThread;
1752 Standard_Mutex myMutex;
1753 Standard_Real myTargetFps;
1754 volatile bool myToStop;
1755};
1756
7fd59977 1757//==============================================================================
1758//function : ViewerInit
1759//purpose : Create the window viewer and initialize all the global variable
1760//==============================================================================
1761
18d715bd 1762TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft,
1763 const Standard_Integer thePxTop,
1764 const Standard_Integer thePxWidth,
1765 const Standard_Integer thePxHeight,
9e04ccdc 1766 const TCollection_AsciiString& theViewName,
1767 const TCollection_AsciiString& theDisplayName,
1768 const Handle(V3d_View)& theViewToClone)
7fd59977 1769{
8c3c9904 1770 // Default position and dimension of the viewer window.
4fe56619 1771 // Note that left top corner is set to be sufficiently small to have
8c3c9904 1772 // window fit in the small screens (actual for remote desktops, see #23003).
4fe56619 1773 // The position corresponds to the window's client area, thus some
8c3c9904 1774 // gap is added for window frame to be visible.
1775 Standard_Integer aPxLeft = 20;
1776 Standard_Integer aPxTop = 40;
7fd59977 1777 Standard_Integer aPxWidth = 409;
1778 Standard_Integer aPxHeight = 409;
18d715bd 1779 Standard_Boolean toCreateViewer = Standard_False;
9e04ccdc 1780 if (!theViewToClone.IsNull())
1781 {
1782 theViewToClone->Window()->Size (aPxWidth, aPxHeight);
1783 }
18d715bd 1784
58655684 1785 Handle(OpenGl_GraphicDriver) aGraphicDriver;
18d715bd 1786 ViewerTest_Names aViewNames(theViewName);
1787 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName ()))
1788 aViewNames.SetViewName (aViewNames.GetViewerName() + "/" + CreateName<Handle(V3d_View)>(ViewerTest_myViews, "View"));
1789
1790 if (thePxLeft != 0)
1791 aPxLeft = thePxLeft;
1792 if (thePxTop != 0)
1793 aPxTop = thePxTop;
1794 if (thePxWidth != 0)
1795 aPxWidth = thePxWidth;
1796 if (thePxHeight != 0)
7fd59977 1797 aPxHeight = thePxHeight;
4269bd1b 1798
18d715bd 1799 // Get graphic driver (create it or get from another view)
8693dfd0 1800 const bool isNewDriver = !ViewerTest_myDrivers.IsBound1 (aViewNames.GetDriverName());
1801 if (isNewDriver)
18d715bd 1802 {
1803 // Get connection string
58655684 1804 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
8693dfd0 1805 if (!theDisplayName.IsEmpty())
1806 {
1807 SetDisplayConnection (new Aspect_DisplayConnection (theDisplayName));
1808 }
18d715bd 1809 else
8693dfd0 1810 {
1811 ::Display* aDispX = NULL;
1812 // create dedicated display connection instead of reusing Tk connection
1813 // so that to procede events independently through VProcessEvents()/ViewerMainLoop() callbacks
1814 /*Draw_Interpretor& aCommands = Draw::GetInterpretor();
1815 Tcl_Interp* aTclInterp = aCommands.Interp();
1816 Tk_Window aMainWindow = Tk_MainWindow (aTclInterp);
1817 aDispX = aMainWindow != NULL ? Tk_Display (aMainWindow) : NULL;*/
1818 SetDisplayConnection (new Aspect_DisplayConnection (aDispX));
1819 }
18d715bd 1820 #else
498ce76b 1821 (void)theDisplayName; // avoid warning on unused argument
18d715bd 1822 SetDisplayConnection (new Aspect_DisplayConnection ());
1823 #endif
14cb22a1 1824
1825 if (Draw_VirtualWindows)
1826 {
1827 // don't waste the time waiting for VSync when window is not displayed on the screen
1828 ViewerTest_myDefaultCaps.swapInterval = 0;
1829 // alternatively we can disable buffer swap at all, but this might be inappropriate for testing
1830 //ViewerTest_myDefaultCaps.buffersNoSwap = true;
1831 }
59515ca6 1832 aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection(), false);
58655684 1833 aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
59515ca6 1834 aGraphicDriver->InitContext();
14cb22a1 1835
18d715bd 1836 ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
1837 toCreateViewer = Standard_True;
1838 }
1839 else
1840 {
58655684 1841 aGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast (ViewerTest_myDrivers.Find1 (aViewNames.GetDriverName()));
7fd59977 1842 }
1843
18d715bd 1844 //Dispose the window if input parameters are default
1845 if (!ViewerTest_myViews.IsEmpty() && thePxLeft == 0 && thePxTop == 0)
7fd59977 1846 {
18d715bd 1847 Standard_Integer aTop = 0,
1848 aLeft = 0,
1849 aRight = 0,
1850 aBottom = 0,
1851 aScreenWidth = 0,
1852 aScreenHeight = 0;
1853
1854 // Get screen resolution
1855#if defined(_WIN32) || defined(__WIN32__)
1856 RECT aWindowSize;
1857 GetClientRect(GetDesktopWindow(), &aWindowSize);
1858 aScreenHeight = aWindowSize.bottom;
1859 aScreenWidth = aWindowSize.right;
1860#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1861 GetCocoaScreenResolution (aScreenWidth, aScreenHeight);
1862#else
1863 Screen *aScreen = DefaultScreenOfDisplay(GetDisplayConnection()->GetDisplay());
1864 aScreenWidth = WidthOfScreen(aScreen);
1865 aScreenHeight = HeightOfScreen(aScreen);
1866#endif
1867
1868 TCollection_AsciiString anOverlappedViewId("");
773f53f1 1869
1870 while (IsWindowOverlapped (aPxLeft, aPxTop, aPxLeft + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId))
dc3fe572 1871 {
18d715bd 1872 ViewerTest_myViews.Find1(anOverlappedViewId)->Window()->Position (aLeft, aTop, aRight, aBottom);
1873
1874 if (IsWindowOverlapped (aRight + 20, aPxTop, aRight + 20 + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId)
1875 && aRight + 2*aPxWidth + 40 > aScreenWidth)
1876 {
1877 if (aBottom + aPxHeight + 40 > aScreenHeight)
1878 {
1879 aPxLeft = 20;
1880 aPxTop = 40;
1881 break;
1882 }
1883 aPxLeft = 20;
1884 aPxTop = aBottom + 40;
1885 }
1886 else
1887 aPxLeft = aRight + 20;
dc3fe572 1888 }
18d715bd 1889 }
1890
1891 // Get viewer name
1892 TCollection_AsciiString aTitle("3D View - ");
1893 aTitle = aTitle + aViewNames.GetViewName() + "(*)";
1894
1895 // Change name of current active window
49582f9d 1896 if (const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView())
18d715bd 1897 {
49582f9d 1898 aCurrentView->Window()->SetTitle (TCollection_AsciiString ("3D View - ") + ViewerTest_myViews.Find2 (aCurrentView));
18d715bd 1899 }
1900
1901 // Create viewer
eb4320f2 1902 Handle(V3d_Viewer) a3DViewer;
18d715bd 1903 // If it's the single view, we first look for empty context
1904 if (ViewerTest_myViews.IsEmpty() && !ViewerTest_myContexts.IsEmpty())
1905 {
1906 NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1907 anIter(ViewerTest_myContexts);
1908 if (anIter.More())
1909 ViewerTest::SetAISContext (anIter.Value());
1910 a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
18d715bd 1911 }
1912 else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
1913 {
1914 ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
1915 a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
18d715bd 1916 }
eb4320f2 1917 else if (a3DViewer.IsNull())
18d715bd 1918 {
1919 toCreateViewer = Standard_True;
6a24c6de 1920 a3DViewer = new V3d_Viewer(aGraphicDriver);
f42753ed 1921 a3DViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
1922 a3DViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
1923 ViewerTest_DefaultBackground.GradientColor2,
1924 ViewerTest_DefaultBackground.FillMethod);
18d715bd 1925 }
1926
1927 // AIS context setup
1928 if (ViewerTest::GetAISContext().IsNull() ||
1929 !(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
1930 {
e79a94b9 1931 Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
18d715bd 1932 ViewerTest::SetAISContext (aContext);
1933 ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
1934 }
1935 else
e79a94b9 1936 {
18d715bd 1937 ViewerTest::ResetEventManager();
e79a94b9 1938 }
18d715bd 1939
1940 // Create window
e79a94b9 1941#if defined(_WIN32)
1942 VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
1943 Handle(WNT_WClass)::DownCast (WClass()),
62e1beed 1944 Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
e79a94b9 1945 aPxLeft, aPxTop,
1946 aPxWidth, aPxHeight,
1947 Quantity_NOC_BLACK);
4fe56619 1948#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
e79a94b9 1949 VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
1950 aPxLeft, aPxTop,
1951 aPxWidth, aPxHeight);
1952 ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
7fd59977 1953#else
e79a94b9 1954 VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
1955 aTitle.ToCString(),
1956 aPxLeft, aPxTop,
1957 aPxWidth, aPxHeight);
7fd59977 1958#endif
18d715bd 1959 VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
7fd59977 1960
d09dda09 1961 // View setup
9e04ccdc 1962 Handle(V3d_View) aView;
1963 if (!theViewToClone.IsNull())
1964 {
2e93433e 1965 aView = new ViewerTest_V3dView (a3DViewer, theViewToClone);
9e04ccdc 1966 }
1967 else
1968 {
2e93433e 1969 aView = new ViewerTest_V3dView (a3DViewer, a3DViewer->DefaultTypeOfView());
9e04ccdc 1970 }
1971
d09dda09 1972 aView->SetWindow (VT_GetWindow());
c3282ec1 1973 ViewerTest::GetAISContext()->RedrawImmediate (a3DViewer);
4269bd1b 1974
18d715bd 1975 ViewerTest::CurrentView(aView);
1976 ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
7fd59977 1977
18d715bd 1978 // Setup for X11 or NT
1979 OSWindowSetup();
7fd59977 1980
18d715bd 1981 // Set parameters for V3d_View and V3d_Viewer
1982 const Handle (V3d_View) aV3dView = ViewerTest::CurrentView();
1983 aV3dView->SetComputedMode(Standard_False);
7fd59977 1984
18d715bd 1985 a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
1986 if (toCreateViewer)
1987 {
7fd59977 1988 a3DViewer->SetDefaultLights();
1989 a3DViewer->SetLightOn();
18d715bd 1990 }
7fd59977 1991
8693dfd0 1992#if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1993 if (isNewDriver)
1994 {
1995 ::Display* aDispX = GetDisplayConnection()->GetDisplay();
1996 Tcl_CreateFileHandler (XConnectionNumber (aDispX), TCL_READABLE, VProcessEvents, (ClientData )aDispX);
1997 }
1998#endif
7fd59977 1999
7fd59977 2000 VT_GetWindow()->Map();
4269bd1b 2001
18d715bd 2002 // Set the handle of created view in the event manager
2003 ViewerTest::ResetEventManager();
2004
4fe56619 2005 ViewerTest::CurrentView()->Redraw();
18d715bd 2006
2007 aView.Nullify();
2008 a3DViewer.Nullify();
18d715bd 2009
2010 return aViewNames.GetViewName();
2011}
2012
4269bd1b 2013//==============================================================================
2014//function : RedrawAllViews
2015//purpose : Redraw all created views
2016//==============================================================================
2017void ViewerTest::RedrawAllViews()
2018{
2019 NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
2020 for (; aViewIt.More(); aViewIt.Next())
2021 {
2022 const Handle(V3d_View)& aView = aViewIt.Key2();
2023 aView->Redraw();
2024 }
2025}
2026
7fd59977 2027//==============================================================================
2028//function : Vinit
2029//purpose : Create the window viewer and initialize all the global variable
e79a94b9 2030// Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
7fd59977 2031//==============================================================================
2032
18d715bd 2033static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
7fd59977 2034{
e79a94b9 2035 TCollection_AsciiString aViewName, aDisplayName;
2036 Standard_Integer aPxLeft = 0, aPxTop = 0, aPxWidth = 0, aPxHeight = 0;
9e04ccdc 2037 Handle(V3d_View) aCopyFrom;
e79a94b9 2038 TCollection_AsciiString aName, aValue;
2e93433e 2039 int is2dMode = -1;
e79a94b9 2040 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
18d715bd 2041 {
e79a94b9 2042 const TCollection_AsciiString anArg = theArgVec[anArgIt];
2043 TCollection_AsciiString anArgCase = anArg;
fd3f6bd0 2044 anArgCase.LowerCase();
2045 if (anArgIt + 1 < theArgsNb
2046 && anArgCase == "-name")
2047 {
2048 aViewName = theArgVec[++anArgIt];
2049 }
2050 else if (anArgIt + 1 < theArgsNb
2051 && (anArgCase == "-left"
2052 || anArgCase == "-l"))
2053 {
2054 aPxLeft = Draw::Atoi (theArgVec[++anArgIt]);
2055 }
2056 else if (anArgIt + 1 < theArgsNb
2057 && (anArgCase == "-top"
2058 || anArgCase == "-t"))
2059 {
2060 aPxTop = Draw::Atoi (theArgVec[++anArgIt]);
2061 }
2062 else if (anArgIt + 1 < theArgsNb
2063 && (anArgCase == "-width"
2064 || anArgCase == "-w"))
2065 {
2066 aPxWidth = Draw::Atoi (theArgVec[++anArgIt]);
2067 }
2068 else if (anArgIt + 1 < theArgsNb
2069 && (anArgCase == "-height"
2070 || anArgCase == "-h"))
18d715bd 2071 {
fd3f6bd0 2072 aPxHeight = Draw::Atoi (theArgVec[++anArgIt]);
2073 }
2074 else if (anArgCase == "-exitonclose")
2075 {
49582f9d 2076 ViewerTest_EventManager::ToExitOnCloseView() = true;
fd3f6bd0 2077 if (anArgIt + 1 < theArgsNb
49582f9d 2078 && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], ViewerTest_EventManager::ToExitOnCloseView()))
fd3f6bd0 2079 {
2080 ++anArgIt;
2081 }
2082 }
2083 else if (anArgCase == "-closeonescape"
2084 || anArgCase == "-closeonesc")
2085 {
49582f9d 2086 ViewerTest_EventManager::ToCloseViewOnEscape() = true;
fd3f6bd0 2087 if (anArgIt + 1 < theArgsNb
49582f9d 2088 && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], ViewerTest_EventManager::ToCloseViewOnEscape()))
fd3f6bd0 2089 {
2090 ++anArgIt;
2091 }
2092 }
2e93433e 2093 else if (anArgCase == "-2d_mode"
2094 || anArgCase == "-2dmode"
2095 || anArgCase == "-2d")
2096 {
2097 bool toEnable = true;
2098 if (anArgIt + 1 < theArgsNb
2099 && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], toEnable))
2100 {
2101 ++anArgIt;
2102 }
2103 is2dMode = toEnable ? 1 : 0;
2104 }
fd3f6bd0 2105 else if (anArgIt + 1 < theArgsNb
2106 && (anArgCase == "-disp"
2107 || anArgCase == "-display"))
2108 {
2109 aDisplayName = theArgVec[++anArgIt];
2110 }
9e04ccdc 2111 else if (!ViewerTest::CurrentView().IsNull()
2112 && aCopyFrom.IsNull()
2113 && (anArgCase == "-copy"
2114 || anArgCase == "-clone"
2115 || anArgCase == "-cloneactive"
2116 || anArgCase == "-cloneactiveview"))
2117 {
2118 aCopyFrom = ViewerTest::CurrentView();
2119 }
fd3f6bd0 2120 // old syntax
2121 else if (ViewerTest::SplitParameter (anArg, aName, aValue))
2122 {
2123 aName.LowerCase();
2124 if (aName == "name")
18d715bd 2125 {
2126 aViewName = aValue;
2127 }
fd3f6bd0 2128 else if (aName == "l"
2129 || aName == "left")
e79a94b9 2130 {
18d715bd 2131 aPxLeft = aValue.IntegerValue();
e79a94b9 2132 }
fd3f6bd0 2133 else if (aName == "t"
2134 || aName == "top")
e79a94b9 2135 {
18d715bd 2136 aPxTop = aValue.IntegerValue();
e79a94b9 2137 }
fd3f6bd0 2138 else if (aName == "disp"
2139 || aName == "display")
e79a94b9 2140 {
18d715bd 2141 aDisplayName = aValue;
e79a94b9 2142 }
fd3f6bd0 2143 else if (aName == "w"
2144 || aName == "width")
e79a94b9 2145 {
18d715bd 2146 aPxWidth = aValue.IntegerValue();
e79a94b9 2147 }
fd3f6bd0 2148 else if (aName == "h"
2149 || aName == "height")
e79a94b9 2150 {
18d715bd 2151 aPxHeight = aValue.IntegerValue();
e79a94b9 2152 }
18d715bd 2153 else
2154 {
fd3f6bd0 2155 std::cout << "Syntax error: unknown argument " << anArg << ".\n";
2156 return 1;
18d715bd 2157 }
2158 }
e79a94b9 2159 else if (aViewName.IsEmpty())
2160 {
2161 aViewName = anArg;
2162 }
2163 else
2164 {
fd3f6bd0 2165 std::cout << "Syntax error: unknown argument " << anArg << ".\n";
2166 return 1;
e79a94b9 2167 }
18d715bd 2168 }
2169
fd3f6bd0 2170#if defined(_WIN32) || (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
2171 if (!aDisplayName.IsEmpty())
2172 {
2173 aDisplayName.Clear();
2174 std::cout << "Warning: display parameter will be ignored.\n";
2175 }
2176#endif
2177
18d715bd 2178 ViewerTest_Names aViewNames (aViewName);
e79a94b9 2179 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
18d715bd 2180 {
e79a94b9 2181 TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
2182 theDi.Eval (aCommand.ToCString());
2e93433e 2183 if (is2dMode != -1)
2184 {
2185 ViewerTest_V3dView::SetCurrentView2DMode (is2dMode == 1);
2186 }
18d715bd 2187 return 0;
2188 }
2189
2190 TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
9e04ccdc 2191 aViewName, aDisplayName, aCopyFrom);
2e93433e 2192 if (is2dMode != -1)
2193 {
2194 ViewerTest_V3dView::SetCurrentView2DMode (is2dMode == 1);
2195 }
e79a94b9 2196 theDi << aViewId;
7fd59977 2197 return 0;
2198}
2199
1eeef710 2200//! Parse HLR algo type.
2201static Standard_Boolean parseHlrAlgoType (const char* theName,
2202 Prs3d_TypeOfHLR& theType)
2203{
2204 TCollection_AsciiString aName (theName);
2205 aName.LowerCase();
2206 if (aName == "polyalgo")
2207 {
2208 theType = Prs3d_TOH_PolyAlgo;
2209 }
2210 else if (aName == "algo")
2211 {
2212 theType = Prs3d_TOH_Algo;
2213 }
2214 else
2215 {
2216 return Standard_False;
2217 }
2218 return Standard_True;
2219}
2220
0a768f56 2221//==============================================================================
2222//function : VHLR
2223//purpose : hidden lines removal algorithm
2224//==============================================================================
2225
2226static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2227{
1eeef710 2228 const Handle(V3d_View) aView = ViewerTest::CurrentView();
2229 const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
2230 if (aView.IsNull())
0a768f56 2231 {
1eeef710 2232 std::cerr << "Error: No opened viewer!\n";
0a768f56 2233 return 1;
2234 }
2235
1eeef710 2236 Standard_Boolean hasHlrOnArg = Standard_False;
2237 Standard_Boolean hasShowHiddenArg = Standard_False;
2238 Standard_Boolean isHLROn = Standard_False;
2239 Standard_Boolean toShowHidden = aCtx->DefaultDrawer()->DrawHiddenLine();
2240 Prs3d_TypeOfHLR aTypeOfHLR = Prs3d_TOH_NotSet;
2241 ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
2242 for (Standard_Integer anArgIter = 1; anArgIter < argc; ++anArgIter)
0a768f56 2243 {
1eeef710 2244 TCollection_AsciiString anArg (argv[anArgIter]);
2245 anArg.LowerCase();
2246 if (anUpdateTool.parseRedrawMode (anArg))
2247 {
2248 continue;
2249 }
2250 else if (anArg == "-showhidden"
2251 && anArgIter + 1 < argc
2252 && ViewerTest::ParseOnOff (argv[anArgIter + 1], toShowHidden))
2253 {
2254 ++anArgIter;
2255 hasShowHiddenArg = Standard_True;
2256 continue;
2257 }
2258 else if ((anArg == "-type"
2259 || anArg == "-algo"
2260 || anArg == "-algotype")
2261 && anArgIter + 1 < argc
2262 && parseHlrAlgoType (argv[anArgIter + 1], aTypeOfHLR))
2263 {
2264 ++anArgIter;
2265 continue;
2266 }
2267 else if (!hasHlrOnArg
2268 && ViewerTest::ParseOnOff (argv[anArgIter], isHLROn))
2269 {
2270 hasHlrOnArg = Standard_True;
2271 continue;
2272 }
2273 // old syntax
2274 else if (!hasShowHiddenArg
2275 && ViewerTest::ParseOnOff(argv[anArgIter], toShowHidden))
2276 {
2277 hasShowHiddenArg = Standard_True;
2278 continue;
2279 }
2280 else
2281 {
2282 std::cout << "Syntax error at '" << argv[anArgIter] << "'\n";
2283 return 1;
2284 }
0a768f56 2285 }
1eeef710 2286 if (!hasHlrOnArg)
0a768f56 2287 {
1eeef710 2288 di << "HLR: " << aView->ComputedMode() << "\n";
2289 di << "HiddenLine: " << aCtx->DefaultDrawer()->DrawHiddenLine() << "\n";
2290 di << "HlrAlgo: ";
2291 switch (aCtx->DefaultDrawer()->TypeOfHLR())
2292 {
2293 case Prs3d_TOH_NotSet: di << "NotSet\n"; break;
2294 case Prs3d_TOH_PolyAlgo: di << "PolyAlgo\n"; break;
2295 case Prs3d_TOH_Algo: di << "Algo\n"; break;
2296 }
2297 anUpdateTool.Invalidate();
2298 return 0;
0a768f56 2299 }
2300
1eeef710 2301 Standard_Boolean toRecompute = Standard_False;
2302 if (aTypeOfHLR != Prs3d_TOH_NotSet
2303 && aTypeOfHLR != aCtx->DefaultDrawer()->TypeOfHLR())
e9224045 2304 {
1eeef710 2305 toRecompute = Standard_True;
2306 aCtx->DefaultDrawer()->SetTypeOfHLR (aTypeOfHLR);
2307 }
2308 if (toShowHidden != aCtx->DefaultDrawer()->DrawHiddenLine())
2309 {
2310 toRecompute = Standard_True;
2311 if (toShowHidden)
e9224045 2312 {
1eeef710 2313 aCtx->DefaultDrawer()->EnableDrawHiddenLine();
e9224045 2314 }
2315 else
2316 {
1eeef710 2317 aCtx->DefaultDrawer()->DisableDrawHiddenLine();
e9224045 2318 }
1eeef710 2319 }
e9224045 2320
1eeef710 2321 // redisplay shapes
2322 if (aView->ComputedMode() && isHLROn && toRecompute)
2323 {
2324 AIS_ListOfInteractive aListOfShapes;
2325 aCtx->DisplayedObjects (aListOfShapes);
2326 for (AIS_ListIteratorOfListOfInteractive anIter (aListOfShapes); anIter.More(); anIter.Next())
e9224045 2327 {
1eeef710 2328 if (Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value()))
e9224045 2329 {
1eeef710 2330 aCtx->Redisplay (aShape, Standard_False);
e9224045 2331 }
2332 }
2333 }
0a768f56 2334
1eeef710 2335 aView->SetComputedMode (isHLROn);
0a768f56 2336 return 0;
2337}
2338
2339//==============================================================================
2340//function : VHLRType
2341//purpose : change type of using HLR algorithm
2342//==============================================================================
2343
1eeef710 2344static int VHLRType (Draw_Interpretor& , Standard_Integer argc, const char** argv)
0a768f56 2345{
1eeef710 2346 const Handle(V3d_View) aView = ViewerTest::CurrentView();
2347 const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
2348 if (aView.IsNull())
0a768f56 2349 {
1eeef710 2350 std::cerr << "Error: No opened viewer!\n";
0a768f56 2351 return 1;
2352 }
2353
1eeef710 2354 Prs3d_TypeOfHLR aTypeOfHLR = Prs3d_TOH_NotSet;
2355 ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
2356 AIS_ListOfInteractive aListOfShapes;
2357 for (Standard_Integer anArgIter = 1; anArgIter < argc; ++anArgIter)
0a768f56 2358 {
1eeef710 2359 TCollection_AsciiString anArg (argv[anArgIter]);
2360 anArg.LowerCase();
2361 if (anUpdateTool.parseRedrawMode (anArg))
0a768f56 2362 {
1eeef710 2363 continue;
0a768f56 2364 }
1eeef710 2365 else if ((anArg == "-type"
2366 || anArg == "-algo"
2367 || anArg == "-algotype")
2368 && anArgIter + 1 < argc
2369 && parseHlrAlgoType (argv[anArgIter + 1], aTypeOfHLR))
2370 {
2371 ++anArgIter;
2372 continue;
2373 }
2374 // old syntax
2375 else if (aTypeOfHLR == Prs3d_TOH_NotSet
2376 && parseHlrAlgoType (argv[anArgIter], aTypeOfHLR))
2377 {
2378 continue;
2379 }
2380 else
0a768f56 2381 {
2382 ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
1eeef710 2383 TCollection_AsciiString aName (argv[anArgIter]);
0a768f56 2384 if (!aMap.IsBound2 (aName))
2385 {
1eeef710 2386 std::cout << "Syntax error: Wrong shape name '" << aName << "'.\n";
2387 return 1;
0a768f56 2388 }
1eeef710 2389
2390 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (aMap.Find2 (aName));
2391 if (aShape.IsNull())
2392 {
2393 std::cout << "Syntax error: '" << aName << "' is not a shape presentation.\n";
2394 return 1;
2395 }
2396 aListOfShapes.Append (aShape);
2397 continue;
0a768f56 2398 }
1eeef710 2399 }
2400 if (aTypeOfHLR == Prs3d_TOH_NotSet)
2401 {
2402 std::cout << "Syntax error: wrong number of arguments!\n";
2403 return 1;
2404 }
2405
2406 const Standard_Boolean isGlobal = aListOfShapes.IsEmpty();
2407 if (isGlobal)
2408 {
2409 aCtx->DisplayedObjects (aListOfShapes);
2410 aCtx->DefaultDrawer()->SetTypeOfHLR (aTypeOfHLR);
0a768f56 2411 }
2412
1eeef710 2413 for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes); anIter.More(); anIter.Next())
2414 {
2415 Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
2416 if (aShape.IsNull())
2417 {
2418 continue;
2419 }
2420
2421 const bool toUpdateShape = aShape->TypeOfHLR() != aTypeOfHLR
2422 && aView->ComputedMode();
2423 if (!isGlobal
2424 || aShape->TypeOfHLR() != aTypeOfHLR)
2425 {
2426 aShape->SetTypeOfHLR (aTypeOfHLR);
2427 }
2428 if (toUpdateShape)
2429 {
2430 aCtx->Redisplay (aShape, Standard_False);
2431 }
2432 }
0a768f56 2433 return 0;
2434}
2435
18d715bd 2436//==============================================================================
2437//function : FindViewIdByWindowHandle
2438//purpose : Find theView Id in the map of views by window handle
2439//==============================================================================
49582f9d 2440#if defined(_WIN32) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2441TCollection_AsciiString FindViewIdByWindowHandle (Aspect_Drawable theWindowHandle)
18d715bd 2442{
2443 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator
2444 anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
2445 {
49582f9d 2446 Aspect_Drawable aWindowHandle = anIter.Value()->Window()->NativeHandle();
18d715bd 2447 if (aWindowHandle == theWindowHandle)
2448 return anIter.Key1();
2449 }
2450 return TCollection_AsciiString("");
2451}
2452#endif
2453
e084dbbc 2454//! Make the view active
2455void ActivateView (const TCollection_AsciiString& theViewName,
2456 Standard_Boolean theToUpdate = Standard_True)
18d715bd 2457{
2458 const Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
e084dbbc 2459 if (aView.IsNull())
18d715bd 2460 {
e084dbbc 2461 return;
2462 }
18d715bd 2463
e084dbbc 2464 Handle(AIS_InteractiveContext) anAISContext = FindContextByView(aView);
2465 if (!anAISContext.IsNull())
2466 {
49582f9d 2467 if (const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView())
e084dbbc 2468 {
49582f9d 2469 aCurrentView->Window()->SetTitle (TCollection_AsciiString ("3D View - ") + ViewerTest_myViews.Find2 (aCurrentView));
e084dbbc 2470 }
2471
2472 ViewerTest::CurrentView (aView);
2473 ViewerTest::SetAISContext (anAISContext);
49582f9d 2474 aView->Window()->SetTitle (TCollection_AsciiString("3D View - ") + theViewName + "(*)");
1eeef710 2475#if defined(_WIN32)
e084dbbc 2476 VT_GetWindow() = Handle(WNT_Window)::DownCast(ViewerTest::CurrentView()->Window());
18d715bd 2477#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
e084dbbc 2478 VT_GetWindow() = Handle(Cocoa_Window)::DownCast(ViewerTest::CurrentView()->Window());
18d715bd 2479#else
e084dbbc 2480 VT_GetWindow() = Handle(Xw_Window)::DownCast(ViewerTest::CurrentView()->Window());
18d715bd 2481#endif
e084dbbc 2482 SetDisplayConnection(ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
2483 if (theToUpdate)
2484 {
18d715bd 2485 ViewerTest::CurrentView()->Redraw();
2486 }
2487 }
2488}
2489
0e93d9e5 2490//==============================================================================
2491//function : RemoveView
2492//purpose :
2493//==============================================================================
2494void ViewerTest::RemoveView (const Handle(V3d_View)& theView,
2495 const Standard_Boolean theToRemoveContext)
2496{
2497 if (!ViewerTest_myViews.IsBound2 (theView))
2498 {
2499 return;
2500 }
2501
2502 const TCollection_AsciiString aViewName = ViewerTest_myViews.Find2 (theView);
2503 RemoveView (aViewName, theToRemoveContext);
2504}
2505
18d715bd 2506//==============================================================================
2507//function : RemoveView
2508//purpose : Close and remove view from display, clear maps if neccessary
2509//==============================================================================
2510void ViewerTest::RemoveView (const TCollection_AsciiString& theViewName, const Standard_Boolean isContextRemoved)
2511{
2512 if (!ViewerTest_myViews.IsBound1(theViewName))
2513 {
04232180 2514 std::cout << "Wrong view name\n";
18d715bd 2515 return;
2516 }
2517
2518 // Activate another view if it's active now
2519 if (ViewerTest_myViews.Find1(theViewName) == ViewerTest::CurrentView())
2520 {
2521 if (ViewerTest_myViews.Extent() > 1)
2522 {
2523 TCollection_AsciiString aNewViewName;
c48e2889 2524 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
2525 anIter.More(); anIter.Next())
2526 {
18d715bd 2527 if (anIter.Key1() != theViewName)
2528 {
2529 aNewViewName = anIter.Key1();
2530 break;
2531 }
c48e2889 2532 }
2533 ActivateView (aNewViewName);
18d715bd 2534 }
2535 else
2536 {
e084dbbc 2537 VT_GetWindow().Nullify();
2538 ViewerTest::CurrentView (Handle(V3d_View)());
18d715bd 2539 if (isContextRemoved)
2540 {
2541 Handle(AIS_InteractiveContext) anEmptyContext;
2542 ViewerTest::SetAISContext(anEmptyContext);
2543 }
2544 }
2545 }
2546
2547 // Delete view
2548 Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
2549 Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
8693dfd0 2550 ViewerTest_ContinuousRedrawer& aRedrawer = ViewerTest_ContinuousRedrawer::Instance();
2551 aRedrawer.Stop (aView->Window());
18d715bd 2552
2553 // Remove view resources
18d715bd 2554 ViewerTest_myViews.UnBind1(theViewName);
851dacdb 2555 aView->Window()->Unmap();
18d715bd 2556 aView->Remove();
2557
2558#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2559 XFlush (GetDisplayConnection()->GetDisplay());
2560#endif
2561
2562 // Keep context opened only if the closed view is last to avoid
2563 // unused empty contexts
2564 if (!aCurrentContext.IsNull())
2565 {
2566 // Check if there are more difined views in the viewer
f7fc0c03 2567 if ((isContextRemoved || ViewerTest_myContexts.Size() != 1)
2568 && aCurrentContext->CurrentViewer()->DefinedViews().IsEmpty())
18d715bd 2569 {
2570 // Remove driver if there is no viewers that use it
2571 Standard_Boolean isRemoveDriver = Standard_True;
2572 for(NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
2573 anIter(ViewerTest_myContexts); anIter.More(); anIter.Next())
2574 {
2575 if (aCurrentContext != anIter.Key2() &&
2576 aCurrentContext->CurrentViewer()->Driver() == anIter.Value()->CurrentViewer()->Driver())
2577 {
2578 isRemoveDriver = Standard_False;
2579 break;
2580 }
2581 }
2ec85268 2582
2583 aCurrentContext->RemoveAll (Standard_False);
18d715bd 2584 if(isRemoveDriver)
2585 {
2586 ViewerTest_myDrivers.UnBind2 (aCurrentContext->CurrentViewer()->Driver());
2587 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
8693dfd0 2588 Tcl_DeleteFileHandler (XConnectionNumber (aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
18d715bd 2589 #endif
2590 }
2591
2592 ViewerTest_myContexts.UnBind2(aCurrentContext);
2593 }
2594 }
04232180 2595 std::cout << "3D View - " << theViewName << " was deleted.\n";
49582f9d 2596 if (ViewerTest_EventManager::ToExitOnCloseView())
fd3f6bd0 2597 {
2598 Draw_Interprete ("exit");
2599 }
18d715bd 2600}
2601
2602//==============================================================================
2603//function : VClose
2604//purpose : Remove the view defined by its name
2605//==============================================================================
2606
d0cc1cb7 2607static int VClose (Draw_Interpretor& /*theDi*/,
2608 Standard_Integer theArgsNb,
2609 const char** theArgVec)
18d715bd 2610{
18d715bd 2611 NCollection_List<TCollection_AsciiString> aViewList;
d0cc1cb7 2612 if (theArgsNb > 1)
18d715bd 2613 {
d0cc1cb7 2614 TCollection_AsciiString anArg (theArgVec[1]);
2615 anArg.UpperCase();
2616 if (anArg.IsEqual ("ALL")
2617 || anArg.IsEqual ("*"))
2618 {
2619 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
2620 anIter.More(); anIter.Next())
2621 {
2622 aViewList.Append (anIter.Key1());
2623 }
2624 if (aViewList.IsEmpty())
2625 {
2626 std::cout << "No view to close\n";
2627 return 0;
2628 }
2629 }
2630 else
18d715bd 2631 {
d0cc1cb7 2632 ViewerTest_Names aViewName (theArgVec[1]);
2633 if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
2634 {
2635 std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
2636 return 1;
2637 }
2638 aViewList.Append (aViewName.GetViewName());
18d715bd 2639 }
2640 }
2641 else
2642 {
d0cc1cb7 2643 // close active view
2644 if (ViewerTest::CurrentView().IsNull())
2645 {
2646 std::cerr << "No active view!\n";
2647 return 1;
2648 }
2649 aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
18d715bd 2650 }
2651
d0cc1cb7 2652 Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
18d715bd 2653 for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
2654 anIter.More(); anIter.Next())
2655 {
d0cc1cb7 2656 ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
18d715bd 2657 }
2658
2659 return 0;
2660}
2661
2662//==============================================================================
2663//function : VActivate
2664//purpose : Activate the view defined by its ID
2665//==============================================================================
2666
2667static int VActivate (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
2668{
e084dbbc 2669 if (theArgsNb == 1)
18d715bd 2670 {
2671 theDi.Eval("vviewlist");
2672 return 0;
2673 }
2674
e084dbbc 2675 TCollection_AsciiString aNameString;
2676 Standard_Boolean toUpdate = Standard_True;
2677 Standard_Boolean toActivate = Standard_True;
2678 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
18d715bd 2679 {
e084dbbc 2680 TCollection_AsciiString anArg (theArgVec[anArgIter]);
2681 anArg.LowerCase();
2682 if (toUpdate
2683 && anArg == "-noupdate")
2684 {
2685 toUpdate = Standard_False;
2686 }
2687 else if (toActivate
2688 && aNameString.IsEmpty()
2689 && anArg == "none")
2690 {
49582f9d 2691 ViewerTest::CurrentView()->Window()->SetTitle (TCollection_AsciiString ("3D View - ") + ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
e084dbbc 2692 VT_GetWindow().Nullify();
2693 ViewerTest::CurrentView (Handle(V3d_View)());
2694 ViewerTest::ResetEventManager();
2695 theDi << theArgVec[0] << ": all views are inactive\n";
2696 toActivate = Standard_False;
2697 }
2698 else if (toActivate
2699 && aNameString.IsEmpty())
2700 {
2701 aNameString = theArgVec[anArgIter];
2702 }
2703 else
2704 {
2705 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
2706 return 1;
2707 }
18d715bd 2708 }
2709
e084dbbc 2710 if (!toActivate)
2711 {
2712 return 0;
2713 }
2714 else if (aNameString.IsEmpty())
2715 {
2716 std::cout << "Syntax error: wrong number of arguments\n";
2717 return 1;
2718 }
18d715bd 2719
2720 // Check if this view exists in the viewer with the driver
e084dbbc 2721 ViewerTest_Names aViewNames (aNameString);
18d715bd 2722 if (!ViewerTest_myViews.IsBound1(aViewNames.GetViewName()))
2723 {
e084dbbc 2724 theDi << "Syntax error: wrong view name '" << aNameString << "'\n";
18d715bd 2725 return 1;
2726 }
2727
2728 // Check if it is active already
2729 if (ViewerTest::CurrentView() == ViewerTest_myViews.Find1(aViewNames.GetViewName()))
2730 {
2731 theDi << theArgVec[0] << ": the view is active already\n";
2732 return 0;
2733 }
2734
e084dbbc 2735 ActivateView (aViewNames.GetViewName(), toUpdate);
18d715bd 2736 return 0;
2737}
2738
2739//==============================================================================
2740//function : VViewList
2741//purpose : Print current list of views per viewer and graphic driver ID
2742// shared between viewers
2743//==============================================================================
2744
2745static int VViewList (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
2746{
2747 if (theArgsNb > 2)
2748 {
2749 theDi << theArgVec[0] << ": Wrong number of command arguments\n"
29cb310a 2750 << "Usage: " << theArgVec[0] << " name";
18d715bd 2751 return 1;
2752 }
2753 if (ViewerTest_myContexts.Size() < 1)
2754 return 0;
2755
18d715bd 2756 Standard_Boolean isTreeView =
29cb310a 2757 (( theArgsNb==1 ) || ( strcasecmp( theArgVec[1], "long" ) != 0 ));
18d715bd 2758
2759 if (isTreeView)
c48e2889 2760 {
18d715bd 2761 theDi << theArgVec[0] <<":\n";
c48e2889 2762 }
18d715bd 2763
c48e2889 2764 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator aDriverIter (ViewerTest_myDrivers);
2765 aDriverIter.More(); aDriverIter.Next())
2766 {
2767 if (isTreeView)
2768 theDi << aDriverIter.Key1() << ":\n";
18d715bd 2769
c48e2889 2770 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
2771 aContextIter(ViewerTest_myContexts); aContextIter.More(); aContextIter.Next())
2772 {
2773 if (aContextIter.Key1().Search(aDriverIter.Key1()) != -1)
18d715bd 2774 {
c48e2889 2775 if (isTreeView)
18d715bd 2776 {
c48e2889 2777 TCollection_AsciiString aContextName(aContextIter.Key1());
2778 theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":\n";
2779 }
18d715bd 2780
c48e2889 2781 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIter (ViewerTest_myViews);
2782 aViewIter.More(); aViewIter.Next())
2783 {
2784 if (aViewIter.Key1().Search(aContextIter.Key1()) != -1)
18d715bd 2785 {
c48e2889 2786 TCollection_AsciiString aViewName(aViewIter.Key1());
2787 if (isTreeView)
18d715bd 2788 {
c48e2889 2789 if (aViewIter.Value() == ViewerTest::CurrentView())
2790 theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)\n";
18d715bd 2791 else
c48e2889 2792 theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "\n";
2793 }
2794 else
2795 {
2796 theDi << aViewName << " ";
18d715bd 2797 }
2798 }
2799 }
2800 }
2801 }
c48e2889 2802 }
18d715bd 2803 return 0;
2804}
2805
7fd59977 2806//==============================================================================
49582f9d 2807//function : GetMousePosition
2808//purpose :
7fd59977 2809//==============================================================================
49582f9d 2810void ViewerTest::GetMousePosition (Standard_Integer& theX,
2811 Standard_Integer& theY)
7fd59977 2812{
49582f9d 2813 if (Handle(ViewerTest_EventManager) aViewCtrl = ViewerTest::CurrentEventManager())
4fe56619 2814 {
49582f9d 2815 theX = aViewCtrl->LastMousePosition().x();
2816 theY = aViewCtrl->LastMousePosition().y();
4fe56619 2817 }
7fd59977 2818}
2819
44b8f2d6 2820//==============================================================================
fc552d84 2821//function : VViewProj
2822//purpose : Switch view projection
44b8f2d6 2823//==============================================================================
fc552d84 2824static int VViewProj (Draw_Interpretor& ,
2825 Standard_Integer theNbArgs,
2826 const char** theArgVec)
44b8f2d6 2827{
fc552d84 2828 static Standard_Boolean isYup = Standard_False;
2829 const Handle(V3d_View)& aView = ViewerTest::CurrentView();
2830 if (aView.IsNull())
44b8f2d6 2831 {
fc552d84 2832 std::cout << "Error: no active view\n";
44b8f2d6 2833 return 1;
2834 }
2835
fc552d84 2836 TCollection_AsciiString aCmdName (theArgVec[0]);
2837 Standard_Boolean isGeneralCmd = Standard_False;
2838 if (aCmdName == "vfront")
2839 {
2840 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Front : V3d_TypeOfOrientation_Zup_Front, isYup);
2841 }
2842 else if (aCmdName == "vback")
2843 {
2844 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Back : V3d_TypeOfOrientation_Zup_Back, isYup);
2845 }
2846 else if (aCmdName == "vtop")
2847 {
2848 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Top : V3d_TypeOfOrientation_Zup_Top, isYup);
2849 }
2850 else if (aCmdName == "vbottom")
2851 {
2852 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Bottom : V3d_TypeOfOrientation_Zup_Bottom, isYup);
2853 }
2854 else if (aCmdName == "vleft")
2855 {
2856 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Left : V3d_TypeOfOrientation_Zup_Left, isYup);
2857 }
2858 else if (aCmdName == "vright")
2859 {
2860 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Right : V3d_TypeOfOrientation_Zup_Right, isYup);
2861 }
2862 else if (aCmdName == "vaxo")
2863 {
2864 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_AxoRight : V3d_TypeOfOrientation_Zup_AxoRight, isYup);
2865 }
2866 else
2867 {
2868 isGeneralCmd = Standard_True;
2869 for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
2870 {
2871 TCollection_AsciiString anArgCase (theArgVec[anArgIter]);
2872 anArgCase.LowerCase();
2873 if (anArgCase == "-zup")
2874 {
2875 isYup = Standard_False;
2876 }
2877 else if (anArgCase == "-yup")
2878 {
2879 isYup = Standard_True;
2880 }
2881 else if (anArgCase == "-front"
2882 || anArgCase == "front"
2883 || anArgCase == "-f"
2884 || anArgCase == "f")
2885 {
2886 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Front : V3d_TypeOfOrientation_Zup_Front, isYup);
2887 }
2888 else if (anArgCase == "-back"
2889 || anArgCase == "back"
2890 || anArgCase == "-b"
2891 || anArgCase == "b")
2892 {
2893 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Back : V3d_TypeOfOrientation_Zup_Back, isYup);
2894 }
2895 else if (anArgCase == "-top"
2896 || anArgCase == "top"
2897 || anArgCase == "-t"
2898 || anArgCase == "t")
2899 {
2900 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Top : V3d_TypeOfOrientation_Zup_Top, isYup);
2901 }
2902 else if (anArgCase == "-bottom"
2903 || anArgCase == "bottom"
2904 || anArgCase == "-bot"
2905 || anArgCase == "bot"
2906 || anArgCase == "-b"
2907 || anArgCase == "b")
2908 {
2909 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Bottom : V3d_TypeOfOrientation_Zup_Bottom, isYup);
2910 }
2911 else if (anArgCase == "-left"
2912 || anArgCase == "left"
2913 || anArgCase == "-l"
2914 || anArgCase == "l")
2915 {
2916 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Left : V3d_TypeOfOrientation_Zup_Left, isYup);
2917 }
2918 else if (anArgCase == "-right"
2919 || anArgCase == "right"
2920 || anArgCase == "-r"
2921 || anArgCase == "r")
2922 {
2923 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_Right : V3d_TypeOfOrientation_Zup_Right, isYup);
2924 }
2925 else if (anArgCase == "-axoleft"
2926 || anArgCase == "-leftaxo"
2927 || anArgCase == "axoleft"
2928 || anArgCase == "leftaxo")
2929 {
2930 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_AxoLeft : V3d_TypeOfOrientation_Zup_AxoLeft, isYup);
2931 }
2932 else if (anArgCase == "-axo"
2933 || anArgCase == "axo"
2934 || anArgCase == "-a"
2935 || anArgCase == "a"
2936 || anArgCase == "-axoright"
2937 || anArgCase == "-rightaxo"
2938 || anArgCase == "axoright"
2939 || anArgCase == "rightaxo")
2940 {
2941 aView->SetProj (isYup ? V3d_TypeOfOrientation_Yup_AxoRight : V3d_TypeOfOrientation_Zup_AxoRight, isYup);
2942 }
2943 else if (anArgCase == "+x")
2944 {
2945 aView->SetProj (V3d_Xpos, isYup);
2946 }
2947 else if (anArgCase == "-x")
2948 {
2949 aView->SetProj (V3d_Xneg, isYup);
2950 }
2951 else if (anArgCase == "+y")
2952 {
2953 aView->SetProj (V3d_Ypos, isYup);
2954 }
2955 else if (anArgCase == "-y")
2956 {
2957 aView->SetProj (V3d_Yneg, isYup);
2958 }
2959 else if (anArgCase == "+z")
2960 {
2961 aView->SetProj (V3d_Zpos, isYup);
2962 }
2963 else if (anArgCase == "-z")
2964 {
2965 aView->SetProj (V3d_Zneg, isYup);
2966 }
2967 else if (anArgCase == "+x+y+z")
2968 {
2969 aView->SetProj (V3d_XposYposZpos, isYup);
2970 }
2971 else if (anArgCase == "+x+y-z")
2972 {
2973 aView->SetProj (V3d_XposYposZneg, isYup);
2974 }
2975 else if (anArgCase == "+x-y+z")
2976 {
2977 aView->SetProj (V3d_XposYnegZpos, isYup);
2978 }
2979 else if (anArgCase == "+x-y-z")
2980 {
2981 aView->SetProj (V3d_XposYnegZneg, isYup);
2982 }
2983 else if (anArgCase == "-x+y+z")
2984 {
2985 aView->SetProj (V3d_XnegYposZpos, isYup);
2986 }
2987 else if (anArgCase == "-x+y-z")
2988 {
2989 aView->SetProj (V3d_XnegYposZneg, isYup);
2990 }
2991 else if (anArgCase == "-x-y+z")
2992 {
2993 aView->SetProj (V3d_XnegYnegZpos, isYup);
2994 }
2995 else if (anArgCase == "-x-y-z")
2996 {
2997 aView->SetProj (V3d_XnegYnegZneg, isYup);
2998 }
2999 else if (anArgCase == "+x+y")
3000 {
3001 aView->SetProj (V3d_XposYpos, isYup);
3002 }
3003 else if (anArgCase == "+x-y")
3004 {
3005 aView->SetProj (V3d_XposYneg, isYup);
3006 }
3007 else if (anArgCase == "-x+y")
3008 {
3009 aView->SetProj (V3d_XnegYpos, isYup);
3010 }
3011 else if (anArgCase == "-x-y")
3012 {
3013 aView->SetProj (V3d_XnegYneg, isYup);
3014 }
3015 else if (anArgCase == "+x+z")
3016 {
3017 aView->SetProj (V3d_XposZpos, isYup);
3018 }
3019 else if (anArgCase == "+x-z")
3020 {
3021 aView->SetProj (V3d_XposZneg, isYup);
3022 }
3023 else if (anArgCase == "-x+z")
3024 {
3025 aView->SetProj (V3d_XnegZpos, isYup);
3026 }
3027 else if (anArgCase == "-x-z")
3028 {
3029 aView->SetProj (V3d_XnegZneg, isYup);
3030 }
3031 else if (anArgCase == "+y+z")
3032 {
3033 aView->SetProj (V3d_YposZpos, isYup);
3034 }
3035 else if (anArgCase == "+y-z")
3036 {
3037 aView->SetProj (V3d_YposZneg, isYup);
3038 }
3039 else if (anArgCase == "-y+z")
3040 {
3041 aView->SetProj (V3d_YnegZpos, isYup);
3042 }
3043 else if (anArgCase == "-y-z")
3044 {
3045 aView->SetProj (V3d_YnegZneg, isYup);
3046 }
3047 else if (anArgIter + 1 < theNbArgs
3048 && anArgCase == "-frame"
3049 && TCollection_AsciiString (theArgVec[anArgIter + 1]).Length() == 4)
3050 {
3051 TCollection_AsciiString aFrameDef (theArgVec[++anArgIter]);
3052 aFrameDef.LowerCase();
3053 gp_Dir aRight, anUp;
3054 if (aFrameDef.Value (2) == aFrameDef.Value (4))
3055 {
3056 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
3057 return 1;
3058 }
44b8f2d6 3059
fc552d84 3060 if (aFrameDef.Value (2) == 'x')
3061 {
3062 aRight = aFrameDef.Value (1) == '+' ? gp::DX() : -gp::DX();
3063 }
3064 else if (aFrameDef.Value (2) == 'y')
3065 {
3066 aRight = aFrameDef.Value (1) == '+' ? gp::DY() : -gp::DY();
3067 }
3068 else if (aFrameDef.Value (2) == 'z')
3069 {
3070 aRight = aFrameDef.Value (1) == '+' ? gp::DZ() : -gp::DZ();
3071 }
3072 else
3073 {
3074 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
3075 return 1;
3076 }
7fd59977 3077
fc552d84 3078 if (aFrameDef.Value (4) == 'x')
3079 {
3080 anUp = aFrameDef.Value (3) == '+' ? gp::DX() : -gp::DX();
3081 }
3082 else if (aFrameDef.Value (4) == 'y')
3083 {
3084 anUp = aFrameDef.Value (3) == '+' ? gp::DY() : -gp::DY();
3085 }
3086 else if (aFrameDef.Value (4) == 'z')
3087 {
3088 anUp = aFrameDef.Value (3) == '+' ? gp::DZ() : -gp::DZ();
3089 }
3090 else
3091 {
3092 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
3093 return 1;
3094 }
44b8f2d6 3095
fc552d84 3096 const Handle(Graphic3d_Camera)& aCamera = aView->Camera();
3097 const gp_Pnt anOriginVCS = aCamera->ConvertWorld2View (gp::Origin());
3098 const gp_Dir aDir = anUp.Crossed (aRight);
3099 aCamera->SetCenter (gp_Pnt (0, 0, 0));
3100 aCamera->SetDirection (aDir);
3101 aCamera->SetUp (anUp);
3102 aCamera->OrthogonalizeUp();
44b8f2d6 3103
fc552d84 3104 aView->Panning (anOriginVCS.X(), anOriginVCS.Y());
3105 aView->Update();
3106 }
3107 else
3108 {
3109 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
3110 return 1;
3111 }
3112 }
3113 }
44b8f2d6 3114
fc552d84 3115 if (!isGeneralCmd
3116 && theNbArgs != 1)
3117 {
3118 std::cout << "Syntax error: wrong number of arguments\n";
3119 return 1;
3120 }
3121 return 0;
7fd59977 3122}
3123
3124//==============================================================================
3125//function : VHelp
3126//purpose : Dsiplay help on viewer Keyboead and mouse commands
3127//Draw arg : No args
3128//==============================================================================
3129
3130static int VHelp(Draw_Interpretor& di, Standard_Integer , const char** )
3131{
586db386 3132 di << "=========================\n";
3133 di << "F : FitAll\n";
3134 di << "T : TopView\n";
3135 di << "B : BottomView\n";
3136 di << "R : RightView\n";
3137 di << "L : LeftView\n";
3138 di << "A : AxonometricView\n";
3139 di << "D : ResetView\n";
3140
3141 di << "=========================\n";
3142 di << "S : Shading\n";
3143 di << "W : Wireframe\n";
49582f9d 3144 di << "H : HiddenLineRemoval\n";
586db386 3145 di << "U : Unset display mode\n";
3146 di << "Delete : Remove selection from viewer\n";
3147
3148 di << "=========================\n";
3149 di << "Selection mode \n";
3150 di << "0 : Shape\n";
3151 di << "1 : Vertex\n";
3152 di << "2 : Edge\n";
3153 di << "3 : Wire\n";
3154 di << "4 : Face\n";
3155 di << "5 : Shell\n";
3156 di << "6 : Solid\n";
3157 di << "7 : Compound\n";
3158
3159 di << "=========================\n";
49582f9d 3160 di << "< : Hilight next detected\n";
3161 di << "> : Hilight previous detected\n";
7fd59977 3162
3163 return 0;
3164}
3165
57c28b61 3166#ifdef _WIN32
7fd59977 3167
49582f9d 3168static LRESULT WINAPI AdvViewerWindowProc (HWND theWinHandle,
3169 UINT theMsg,
3170 WPARAM wParam,
3171 LPARAM lParam )
7fd59977 3172{
49582f9d 3173 if (ViewerTest_myViews.IsEmpty())
3174 {
3175 return ViewerWindowProc (theWinHandle, theMsg, wParam, lParam);
3176 }
7fd59977 3177
49582f9d 3178 switch (theMsg)
3179 {
18d715bd 3180 case WM_CLOSE:
49582f9d 3181 {
3182 // Delete view from map of views
3183 ViewerTest::RemoveView (FindViewIdByWindowHandle (theWinHandle));
3184 return 0;
3185 }
18d715bd 3186 case WM_ACTIVATE:
49582f9d 3187 {
3188 if (LOWORD(wParam) == WA_CLICKACTIVE
3189 || LOWORD(wParam) == WA_ACTIVE
3190 || ViewerTest::CurrentView().IsNull())
18d715bd 3191 {
3192 // Activate inactive window
49582f9d 3193 if (VT_GetWindow().IsNull()
3194 || (HWND )VT_GetWindow()->HWindow() != theWinHandle)
625e1958 3195 {
49582f9d 3196 ActivateView (FindViewIdByWindowHandle (theWinHandle));
625e1958 3197 }
7fd59977 3198 }
7fd59977 3199 break;
49582f9d 3200 }
7fd59977 3201 default:
49582f9d 3202 {
3203 return ViewerWindowProc (theWinHandle, theMsg, wParam, lParam);
7fd59977 3204 }
7fd59977 3205 }
49582f9d 3206 return 0;
7fd59977 3207}
3208
49582f9d 3209static LRESULT WINAPI ViewerWindowProc (HWND theWinHandle,
3210 UINT theMsg,
3211 WPARAM wParam,
3212 LPARAM lParam)
7fd59977 3213{
f978241f 3214 const Handle(V3d_View)& aView = ViewerTest::CurrentView();
3215 if (aView.IsNull())
3216 {
49582f9d 3217 return DefWindowProcW (theWinHandle, theMsg, wParam, lParam);
f978241f 3218 }
7fd59977 3219
49582f9d 3220 switch (theMsg)
3221 {
7fd59977 3222 case WM_PAINT:
49582f9d 3223 {
3224 PAINTSTRUCT aPaint;
3225 BeginPaint(theWinHandle, &aPaint);
3226 EndPaint (theWinHandle, &aPaint);
3227 ViewerTest::CurrentEventManager()->ProcessExpose();
7fd59977 3228 break;
49582f9d 3229 }
7fd59977 3230 case WM_SIZE:
49582f9d 3231 {
3232 ViewerTest::CurrentEventManager()->ProcessConfigure();
7fd59977 3233 break;
49582f9d 3234 }
f978241f 3235 case WM_MOVE:
3236 case WM_MOVING:
3237 case WM_SIZING:
49582f9d 3238 {
f978241f 3239 switch (aView->RenderingParams().StereoMode)
3240 {
3241 case Graphic3d_StereoMode_RowInterlaced:
3242 case Graphic3d_StereoMode_ColumnInterlaced:
3243 case Graphic3d_StereoMode_ChessBoard:
49582f9d 3244 {
3245 // track window moves to reverse stereo pair
3246 aView->MustBeResized();
3247 aView->Update();
f978241f 3248 break;
49582f9d 3249 }
f978241f 3250 default:
3251 break;
3252 }
3253 break;
49582f9d 3254 }
3255 case WM_KEYUP:
7fd59977 3256 case WM_KEYDOWN:
49582f9d 3257 {
3258 const Aspect_VKey aVKey = WNT_Window::VirtualKeyFromNative ((Standard_Integer )wParam);
3259 if (aVKey != Aspect_VKey_UNKNOWN)
4fe56619 3260 {
49582f9d 3261 const double aTimeStamp = ViewerTest::CurrentEventManager()->EventTime();
3262 if (theMsg == WM_KEYDOWN)
f978241f 3263 {
49582f9d 3264 ViewerTest::CurrentEventManager()->KeyDown (aVKey, aTimeStamp);
f978241f 3265 }
49582f9d 3266 else
f978241f 3267 {
49582f9d 3268 ViewerTest::CurrentEventManager()->KeyUp (aVKey, aTimeStamp);
f978241f 3269 }
49582f9d 3270 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
7fd59977 3271 }
3272 break;
49582f9d 3273 }
7fd59977 3274 case WM_LBUTTONUP:
3275 case WM_MBUTTONUP:
3276 case WM_RBUTTONUP:
7fd59977 3277 case WM_LBUTTONDOWN:
3278 case WM_MBUTTONDOWN:
3279 case WM_RBUTTONDOWN:
49582f9d 3280 {
3281 const Graphic3d_Vec2i aPos (LOWORD(lParam), HIWORD(lParam));
3282 const Aspect_VKeyFlags aFlags = WNT_Window::MouseKeyFlagsFromEvent (wParam);
3283 Aspect_VKeyMouse aButton = Aspect_VKeyMouse_NONE;
3284 switch (theMsg)
7fd59977 3285 {
49582f9d 3286 case WM_LBUTTONUP:
3287 case WM_LBUTTONDOWN:
3288 aButton = Aspect_VKeyMouse_LeftButton;
3289 break;
3290 case WM_MBUTTONUP:
3291 case WM_MBUTTONDOWN:
3292 aButton = Aspect_VKeyMouse_MiddleButton;
3293 break;
3294 case WM_RBUTTONUP:
3295 case WM_RBUTTONDOWN:
3296 aButton = Aspect_VKeyMouse_RightButton;
3297 break;
7fd59977 3298 }
49582f9d 3299 if (theMsg == WM_LBUTTONDOWN
3300 || theMsg == WM_MBUTTONDOWN
3301 || theMsg == WM_RBUTTONDOWN)
f978241f 3302 {
49582f9d 3303 if (aButton == Aspect_VKeyMouse_LeftButton)
f978241f 3304 {
49582f9d 3305 TheIsAnimating = Standard_False;
f978241f 3306 }
49582f9d 3307
3308 SetFocus (theWinHandle);
3309 SetCapture(theWinHandle);
3310 ViewerTest::CurrentEventManager()->PressMouseButton (aPos, aButton, aFlags, false);
f978241f 3311 }
3312 else
3313 {
49582f9d 3314 ReleaseCapture();
3315 ViewerTest::CurrentEventManager()->ReleaseMouseButton (aPos, aButton, aFlags, false);
f978241f 3316 }
49582f9d 3317 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
f978241f 3318 break;
3319 }
49582f9d 3320 case WM_MOUSEWHEEL:
3321 {
3322 const int aDelta = GET_WHEEL_DELTA_WPARAM (wParam);
3323 const Standard_Real aDeltaF = Standard_Real(aDelta) / Standard_Real(WHEEL_DELTA);
3324 const Aspect_VKeyFlags aFlags = WNT_Window::MouseKeyFlagsFromEvent (wParam);
3325 Graphic3d_Vec2i aPos (int(short(LOWORD(lParam))), int(short(HIWORD(lParam))));
3326 POINT aCursorPnt = { aPos.x(), aPos.y() };
3327 if (ScreenToClient (theWinHandle, &aCursorPnt))
7fd59977 3328 {
49582f9d 3329 aPos.SetValues (aCursorPnt.x, aCursorPnt.y);
3330 }
7fd59977 3331
49582f9d 3332 ViewerTest::CurrentEventManager()->UpdateMouseScroll (Aspect_ScrollDelta (aPos, aDeltaF, aFlags));
3333 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
3334 break;
3335 }
3336 case WM_MOUSEMOVE:
3337 {
3338 Graphic3d_Vec2i aPos (LOWORD(lParam), HIWORD(lParam));
3339 Aspect_VKeyMouse aButtons = WNT_Window::MouseButtonsFromEvent (wParam);
3340 Aspect_VKeyFlags aFlags = WNT_Window::MouseKeyFlagsFromEvent(wParam);
7fd59977 3341
49582f9d 3342 // don't make a slide-show from input events - fetch the actual mouse cursor position
3343 CURSORINFO aCursor;
3344 aCursor.cbSize = sizeof(aCursor);
3345 if (::GetCursorInfo (&aCursor) != FALSE)
3346 {
3347 POINT aCursorPnt = { aCursor.ptScreenPos.x, aCursor.ptScreenPos.y };
3348 if (ScreenToClient (theWinHandle, &aCursorPnt))
3349 {
3350 // as we override mouse position, we need overriding also mouse state
3351 aPos.SetValues (aCursorPnt.x, aCursorPnt.y);
3352 aButtons = WNT_Window::MouseButtonsAsync();
3353 aFlags = WNT_Window::MouseKeyFlagsAsync();
3354 }
3355 }
7fd59977 3356
49582f9d 3357 if (VT_GetWindow().IsNull()
3358 || (HWND )VT_GetWindow()->HWindow() != theWinHandle)
3359 {
3360 // mouse move events come also for inactive windows
3361 break;
7fd59977 3362 }
7fd59977 3363
49582f9d 3364 ViewerTest::CurrentEventManager()->UpdateMousePosition (aPos, aButtons, aFlags, false);
3365 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), aView, true);
3366 break;
3367 }
7fd59977 3368 default:
49582f9d 3369 {
3370 return DefWindowProcW (theWinHandle, theMsg, wParam, lParam);
7fd59977 3371 }
49582f9d 3372 }
3373 return 0L;
7fd59977 3374}
3375
7fd59977 3376//==============================================================================
3377//function : ViewerMainLoop
3378//purpose : Get a Event on the view and dispatch it
3379//==============================================================================
3380
49582f9d 3381int ViewerMainLoop (Standard_Integer theNbArgs, const char** theArgVec)
7fd59977 3382{
49582f9d 3383 Handle(ViewerTest_EventManager) aViewCtrl = ViewerTest::CurrentEventManager();
3384 if (aViewCtrl.IsNull()
3385 || theNbArgs < 4)
3386 {
3387 return 0;
3388 }
7fd59977 3389
49582f9d 3390 aViewCtrl->StartPickPoint (theArgVec[1], theArgVec[2], theArgVec[3]);
7fd59977 3391
49582f9d 3392 std::cout << "Start picking\n";
7fd59977 3393
49582f9d 3394 MSG aMsg;
3395 aMsg.wParam = 1;
3396 while (aViewCtrl->ToPickPoint())
3397 {
3398 // Wait for a VT_ProcessButton1Press() to toggle pick to 1 or 0
3399 if (GetMessageW (&aMsg, NULL, 0, 0))
3400 {
3401 TranslateMessage (&aMsg);
3402 DispatchMessageW (&aMsg);
7fd59977 3403 }
7fd59977 3404 }
3405
49582f9d 3406 std::cout << "Picking done\n";
3407 return 0;
7fd59977 3408}
3409
4fe56619 3410#elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
7fd59977 3411
3412int min( int a, int b )
3413{
3414 if( a<b )
3415 return a;
3416 else
3417 return b;
3418}
3419
3420int max( int a, int b )
3421{
3422 if( a>b )
3423 return a;
3424 else
3425 return b;
3426}
3427
49582f9d 3428int ViewerMainLoop (Standard_Integer theNbArgs, const char** theArgVec)
4269bd1b 3429{
18d715bd 3430 static XEvent aReport;
49582f9d 3431 const Standard_Boolean toPick = theNbArgs > 0;
3432 if (theNbArgs > 0)
3433 {
3434 if (ViewerTest::CurrentEventManager().IsNull())
3435 {
3436 return 0;
3437 }
3438 ViewerTest::CurrentEventManager()->StartPickPoint (theArgVec[1], theArgVec[2], theArgVec[3]);
3439 }
3440
8693dfd0 3441 Display* aDisplay = GetDisplayConnection()->GetDisplay();
18d715bd 3442 XNextEvent (aDisplay, &aReport);
7fd59977 3443
18d715bd 3444 // Handle event for the chosen display connection
8693dfd0 3445 switch (aReport.type)
3446 {
3447 case ClientMessage:
3448 {
3449 if ((Atom)aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
3450 {
3451 // Close the window
3452 ViewerTest::RemoveView(FindViewIdByWindowHandle (aReport.xclient.window));
3453 return toPick ? 0 : 1;
3454 }
3455 break;
3456 }
3457 case FocusIn:
3458 {
3459 // Activate inactive view
49582f9d 3460 Window aWindow = !VT_GetWindow().IsNull() ? VT_GetWindow()->XWindow() : 0;
8693dfd0 3461 if (aWindow != aReport.xfocus.window)
3462 {
3463 ActivateView (FindViewIdByWindowHandle (aReport.xfocus.window));
3464 }
3465 break;
3466 }
3467 case Expose:
3468 {
49582f9d 3469 Window anXWindow = !VT_GetWindow().IsNull() ? VT_GetWindow()->XWindow() : 0;
8693dfd0 3470 if (anXWindow == aReport.xexpose.window)
3471 {
49582f9d 3472 ViewerTest::CurrentEventManager()->ProcessExpose();
8693dfd0 3473 }
3474
3475 // remove all the ExposureMask and process them at once
3476 for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
3477 {
3478 if (!XCheckWindowEvent (aDisplay, anXWindow, ExposureMask, &aReport))
18d715bd 3479 {
8693dfd0 3480 break;
18d715bd 3481 }
8693dfd0 3482 }
3483
3484 break;
3485 }
3486 case ConfigureNotify:
3487 {
3488 // remove all the StructureNotifyMask and process them at once
49582f9d 3489 Window anXWindow = !VT_GetWindow().IsNull() ? VT_GetWindow()->XWindow() : 0;
8693dfd0 3490 for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
3491 {
3492 if (!XCheckWindowEvent (aDisplay, anXWindow, StructureNotifyMask, &aReport))
3493 {
3494 break;
3495 }
3496 }
3497
3498 if (anXWindow == aReport.xconfigure.window)
3499 {
49582f9d 3500 ViewerTest::CurrentEventManager()->ProcessConfigure();
8693dfd0 3501 }
3502 break;
3503 }
3504 case KeyPress:
49582f9d 3505 case KeyRelease:
8693dfd0 3506 {
49582f9d 3507 XKeyEvent* aKeyEvent = (XKeyEvent* )&aReport;
3508 const KeySym aKeySym = XLookupKeysym (aKeyEvent, 0);
3509 const Aspect_VKey aVKey = Xw_Window::VirtualKeyFromNative (aKeySym);
3510 if (aVKey != Aspect_VKey_UNKNOWN)
8693dfd0 3511 {
49582f9d 3512 const double aTimeStamp = ViewerTest::CurrentEventManager()->EventTime();
3513 if (aReport.type == KeyPress)
7fd59977 3514 {
49582f9d 3515 ViewerTest::CurrentEventManager()->KeyDown (aVKey, aTimeStamp);
7fd59977 3516 }
8693dfd0 3517 else
7fd59977 3518 {
49582f9d 3519 ViewerTest::CurrentEventManager()->KeyUp (aVKey, aTimeStamp);
7fd59977 3520 }
49582f9d 3521 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
8693dfd0 3522 }
3523 break;
3524 }
49582f9d 3525 case ButtonPress:
8693dfd0 3526 case ButtonRelease:
3527 {
49582f9d 3528 const Graphic3d_Vec2i aPos (aReport.xbutton.x, aReport.xbutton.y);
3529 Aspect_VKeyFlags aFlags = Aspect_VKeyFlags_NONE;
3530 Aspect_VKeyMouse aButton = Aspect_VKeyMouse_NONE;
3531 if (aReport.xbutton.button == Button1)
8693dfd0 3532 {
49582f9d 3533 aButton = Aspect_VKeyMouse_LeftButton;
8693dfd0 3534 }
49582f9d 3535 if (aReport.xbutton.button == Button2)
8693dfd0 3536 {
49582f9d 3537 aButton = Aspect_VKeyMouse_MiddleButton;
8693dfd0 3538 }
49582f9d 3539 if (aReport.xbutton.button == Button3)
8693dfd0 3540 {
49582f9d 3541 aButton = Aspect_VKeyMouse_RightButton;
8693dfd0 3542 }
7fd59977 3543
49582f9d 3544 if (aReport.xbutton.state & ControlMask)
8693dfd0 3545 {
49582f9d 3546 aFlags |= Aspect_VKeyFlags_CTRL;
3547 }
3548 if (aReport.xbutton.state & ShiftMask)
3549 {
3550 aFlags |= Aspect_VKeyFlags_SHIFT;
3551 }
3552 if (ViewerTest::CurrentEventManager()->Keys().IsKeyDown (Aspect_VKey_Alt))
3553 {
3554 aFlags |= Aspect_VKeyFlags_ALT;
8693dfd0 3555 }
7fd59977 3556
49582f9d 3557 if (aReport.xbutton.button == Button4
3558 || aReport.xbutton.button == Button5)
8693dfd0 3559 {
49582f9d 3560 if (aReport.type != ButtonPress)
8693dfd0 3561 {
49582f9d 3562 break;
7fd59977 3563 }
49582f9d 3564
3565 const double aDeltaF = (aReport.xbutton.button == Button4 ? 1.0 : -1.0);
3566 ViewerTest::CurrentEventManager()->UpdateMouseScroll (Aspect_ScrollDelta (aPos, aDeltaF, aFlags));
3567 }
3568 else if (aReport.type == ButtonPress)
3569 {
3570 if (aButton == Aspect_VKeyMouse_LeftButton)
7fd59977 3571 {
49582f9d 3572 TheIsAnimating = Standard_False;
7fd59977 3573 }
49582f9d 3574 ViewerTest::CurrentEventManager()->PressMouseButton (aPos, aButton, aFlags, false);
8693dfd0 3575 }
3576 else
3577 {
49582f9d 3578 ViewerTest::CurrentEventManager()->ReleaseMouseButton (aPos, aButton, aFlags, false);
8693dfd0 3579 }
49582f9d 3580 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
8693dfd0 3581 break;
3582 }
3583 case MotionNotify:
3584 {
49582f9d 3585 Window anXWindow = !VT_GetWindow().IsNull() ? VT_GetWindow()->XWindow() : 0;
8693dfd0 3586 if (anXWindow != aReport.xmotion.window)
3587 {
7fd59977 3588 break;
8693dfd0 3589 }
3590
3591 // remove all the ButtonMotionMask and process them at once
3592 for (int aNbMaxEvents = XPending (aDisplay); aNbMaxEvents > 0; --aNbMaxEvents)
3593 {
3594 if (!XCheckWindowEvent (aDisplay, anXWindow, ButtonMotionMask | PointerMotionMask, &aReport))
7fd59977 3595 {
8693dfd0 3596 break;
3597 }
3598 }
7fd59977 3599
49582f9d 3600 Graphic3d_Vec2i aPos (aReport.xmotion.x, aReport.xmotion.y);
3601 Aspect_VKeyMouse aButtons = Aspect_VKeyMouse_NONE;
3602 Aspect_VKeyFlags aFlags = Aspect_VKeyFlags_NONE;
3603 if ((aReport.xmotion.state & Button1Mask) != 0)
8693dfd0 3604 {
49582f9d 3605 aButtons |= Aspect_VKeyMouse_LeftButton;
3606 }
3607 else if ((aReport.xmotion.state & Button2Mask) != 0)
3608 {
3609 aButtons |= Aspect_VKeyMouse_MiddleButton;
3610 }
3611 else if ((aReport.xmotion.state & Button3Mask) != 0)
3612 {
3613 aButtons |= Aspect_VKeyMouse_RightButton;
3614 }
7fd59977 3615
49582f9d 3616 if (aReport.xmotion.state & ControlMask)
3617 {
3618 aFlags |= Aspect_VKeyFlags_CTRL;
8693dfd0 3619 }
49582f9d 3620 if (aReport.xmotion.state & ShiftMask)
8693dfd0 3621 {
49582f9d 3622 aFlags |= Aspect_VKeyFlags_SHIFT;
8693dfd0 3623 }
49582f9d 3624 if (ViewerTest::CurrentEventManager()->Keys().IsKeyDown (Aspect_VKey_Alt))
3625 {
3626 aFlags |= Aspect_VKeyFlags_ALT;
3627 }
3628
3629 ViewerTest::CurrentEventManager()->UpdateMousePosition (aPos, aButtons, aFlags, false);
3630 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
8693dfd0 3631 break;
3632 }
3633 }
49582f9d 3634 return (!toPick || ViewerTest::CurrentEventManager()->ToPickPoint()) ? 1 : 0;
7fd59977 3635}
3636
3637//==============================================================================
3638//function : VProcessEvents
8693dfd0 3639//purpose : manage the event in the Viewer window (see Tcl_CreateFileHandler())
7fd59977 3640//==============================================================================
8693dfd0 3641static void VProcessEvents (ClientData theDispX, int)
7fd59977 3642{
8693dfd0 3643 Display* aDispX = (Display* )theDispX;
3644 Handle(Aspect_DisplayConnection) aDispConn;
3645 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
3646 aDriverIter (ViewerTest_myDrivers); aDriverIter.More(); aDriverIter.Next())
18d715bd 3647 {
8693dfd0 3648 const Handle(Aspect_DisplayConnection)& aDispConnTmp = aDriverIter.Key2()->GetDisplayConnection();
3649 if (aDispConnTmp->GetDisplay() == aDispX)
3650 {
3651 aDispConn = aDispConnTmp;
3652 break;
3653 }
3654 }
3655 if (aDispConn.IsNull())
3656 {
3657 std::cerr << "Error: ViewerTest is unable processing messages for unknown X Display\n";
3658 return;
4269bd1b 3659 }
8693dfd0 3660
3661 // process new events in queue
3662 SetDisplayConnection (aDispConn);
3663 int aNbRemain = 0;
3664 for (int aNbEventsMax = XPending (aDispX), anEventIter (0);;)
18d715bd 3665 {
8693dfd0 3666 const int anEventResult = ViewerMainLoop (0, NULL);
3667 if (anEventResult == 0)
18d715bd 3668 {
8693dfd0 3669 return;
3670 }
3671
3672 aNbRemain = XPending (aDispX);
3673 if (++anEventIter >= aNbEventsMax
3674 || aNbRemain <= 0)
3675 {
3676 break;
18d715bd 3677 }
7fd59977 3678 }
4269bd1b 3679
8693dfd0 3680 // Listening X events through Tcl_CreateFileHandler() callback is fragile,
3681 // it is possible that new events will arrive to queue before the end of this callback
3682 // so that either this callback should go into an infinite loop (blocking processing of other events)
3683 // or to keep unprocessed events till the next queue update (which can arrive not soon).
3684 // Sending a dummy event in this case is a simple workaround (still, it is possible that new event will be queued in-between).
3685 if (aNbRemain != 0)
3686 {
3687 XEvent aDummyEvent;
3688 memset (&aDummyEvent, 0, sizeof(aDummyEvent));
3689 aDummyEvent.type = ClientMessage;
3690 aDummyEvent.xclient.format = 32;
3691 XSendEvent (aDispX, InputFocus, False, 0, &aDummyEvent);
3692 XFlush (aDispX);
3693 }
4269bd1b 3694
8693dfd0 3695 if (const Handle(AIS_InteractiveContext)& anActiveCtx = ViewerTest::GetAISContext())
3696 {
3697 SetDisplayConnection (anActiveCtx->CurrentViewer()->Driver()->GetDisplayConnection());
3698 }
7fd59977 3699}
3700#endif
3701
3702//==============================================================================
3703//function : OSWindowSetup
3704//purpose : Setup for the X11 window to be able to cath the event
3705//==============================================================================
3706
3707
3708static void OSWindowSetup()
3709{
4fe56619 3710#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
7fd59977 3711 // X11
3712
3713 Window window = VT_GetWindow()->XWindow();
18d715bd 3714 SetDisplayConnection (ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
3715 Display *aDisplay = GetDisplayConnection()->GetDisplay();
3716 XSynchronize(aDisplay, 1);
7fd59977 3717
3718 // X11 : For keyboard on SUN
3719 XWMHints wmhints;
3720 wmhints.flags = InputHint;
3721 wmhints.input = 1;
3722
18d715bd 3723 XSetWMHints( aDisplay, window, &wmhints);
7fd59977 3724
49582f9d 3725 XSelectInput( aDisplay, window, ExposureMask | KeyPressMask | KeyReleaseMask |
7fd59977 3726 ButtonPressMask | ButtonReleaseMask |
3727 StructureNotifyMask |
3728 PointerMotionMask |
3729 Button1MotionMask | Button2MotionMask |
18d715bd 3730 Button3MotionMask | FocusChangeMask
7fd59977 3731 );
18d715bd 3732 Atom aDeleteWindowAtom = GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW);
3733 XSetWMProtocols(aDisplay, window, &aDeleteWindowAtom, 1);
7fd59977 3734
18d715bd 3735 XSynchronize(aDisplay, 0);
7fd59977 3736
3737#else
57c28b61 3738 // _WIN32
7fd59977 3739#endif
3740
3741}
3742
7fd59977 3743//==============================================================================
3744//function : VFit
1beb58d7 3745//purpose :
7fd59977 3746//==============================================================================
3747
1beb58d7 3748static int VFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgv)
7fd59977 3749{
1beb58d7 3750 const Handle(V3d_View) aView = ViewerTest::CurrentView();
3751 if (aView.IsNull())
b586500b 3752 {
1beb58d7 3753 std::cout << "Error: no active viewer!\n";
3754 return 1;
b586500b 3755 }
3756
1beb58d7 3757 Standard_Boolean toFit = Standard_True;
3758 ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
3759 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
b586500b 3760 {
1beb58d7 3761 TCollection_AsciiString anArg (theArgv[anArgIter]);
b586500b 3762 anArg.LowerCase();
1beb58d7 3763 if (anUpdateTool.parseRedrawMode (anArg))
b586500b 3764 {
1beb58d7 3765 continue;
3766 }
3767 else if (anArg == "-selected")
3768 {
3769 ViewerTest::GetAISContext()->FitSelected (aView, 0.01, Standard_False);
3770 toFit = Standard_False;
3771 }
3772 else
3773 {
3774 std::cout << "Syntax error at '" << anArg << "'\n";
b586500b 3775 }
3776 }
3777
1beb58d7 3778 if (toFit)
3779 {
3780 aView->FitAll (0.01, Standard_False);
7fd59977 3781 }
3782 return 0;
3783}
3784
6262a303 3785//=======================================================================
3786//function : VFitArea
3787//purpose : Fit view to show area located between two points
3788// : given in world 2D or 3D coordinates.
3789//=======================================================================
3790static int VFitArea (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
3791{
3792 Handle(V3d_View) aView = ViewerTest::CurrentView();
3793 if (aView.IsNull())
3794 {
3795 std::cerr << theArgVec[0] << "Error: No active view.\n";
3796 return 1;
3797 }
3798
3799 // Parse arguments.
3800 gp_Pnt aWorldPnt1 (0.0, 0.0, 0.0);
3801 gp_Pnt aWorldPnt2 (0.0, 0.0, 0.0);
3802
3803 if (theArgNb == 5)
3804 {
3805 aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
3806 aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
3807 aWorldPnt2.SetX (Draw::Atof (theArgVec[3]));
3808 aWorldPnt2.SetY (Draw::Atof (theArgVec[4]));
3809 }
3810 else if (theArgNb == 7)
3811 {
3812 aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
3813 aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
3814 aWorldPnt1.SetZ (Draw::Atof (theArgVec[3]));
3815 aWorldPnt2.SetX (Draw::Atof (theArgVec[4]));
3816 aWorldPnt2.SetY (Draw::Atof (theArgVec[5]));
3817 aWorldPnt2.SetZ (Draw::Atof (theArgVec[6]));
3818 }
3819 else
3820 {
3821 std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
3822 theDI.PrintHelp(theArgVec[0]);
3823 return 1;
3824 }
3825
3826 // Convert model coordinates to view space
3827 Handle(Graphic3d_Camera) aCamera = aView->Camera();
3828 gp_Pnt aViewPnt1 = aCamera->ConvertWorld2View (aWorldPnt1);
3829 gp_Pnt aViewPnt2 = aCamera->ConvertWorld2View (aWorldPnt2);
3830
3831 // Determine fit area
3832 gp_Pnt2d aMinCorner (Min (aViewPnt1.X(), aViewPnt2.X()), Min (aViewPnt1.Y(), aViewPnt2.Y()));
3833 gp_Pnt2d aMaxCorner (Max (aViewPnt1.X(), aViewPnt2.X()), Max (aViewPnt1.Y(), aViewPnt2.Y()));
3834
3835 Standard_Real aDiagonal = aMinCorner.Distance (aMaxCorner);
3836
3837 if (aDiagonal < Precision::Confusion())
3838 {
3839 std::cerr << theArgVec[0] << "Error: view area is too small.\n";
3840 return 1;
3841 }
3842
3843 aView->FitAll (aMinCorner.X(), aMinCorner.Y(), aMaxCorner.X(), aMaxCorner.Y());
3844 return 0;
3845}
3846
7fd59977 3847//==============================================================================
3848//function : VZFit
3849//purpose : ZFitall, no DRAW arguments
3850//Draw arg : No args
3851//==============================================================================
197ac94e 3852static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
7fd59977 3853{
197ac94e 3854 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
3855
3856 if (aCurrentView.IsNull())
3857 {
3858 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
3859 return 1;
3860 }
3861
3862 if (theArgsNb == 1)
3863 {
c357e426 3864 aCurrentView->ZFitAll();
197ac94e 3865 aCurrentView->Redraw();
3866 return 0;
3867 }
3868
3869 Standard_Real aScale = 1.0;
3870
3871 if (theArgsNb >= 2)
3872 {
3873 aScale = Draw::Atoi (theArgVec[1]);
3874 }
3875
c357e426 3876 aCurrentView->ZFitAll (aScale);
197ac94e 3877 aCurrentView->Redraw();
7fd59977 3878
197ac94e 3879 return 0;
3880}
7fd59977 3881
197ac94e 3882//==============================================================================
3883//function : VRepaint
3884//purpose :
3885//==============================================================================
56689b27 3886static int VRepaint (Draw_Interpretor& , Standard_Integer theArgNb, const char** theArgVec)
7fd59977 3887{
56689b27 3888 Handle(V3d_View) aView = ViewerTest::CurrentView();
3889 if (aView.IsNull())
3890 {
3891 std::cout << "Error: no active viewer!\n";
3892 return 1;
3893 }
3894
3895 Standard_Boolean isImmediateUpdate = Standard_False;
3896 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
3897 {
3898 TCollection_AsciiString anArg (theArgVec[anArgIter]);
3899 anArg.LowerCase();
8693dfd0 3900 if (anArg == "-immediate"
3901 || anArg == "-imm")
56689b27 3902 {
3903 isImmediateUpdate = Standard_True;
3904 if (anArgIter + 1 < theArgNb
3905 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], isImmediateUpdate))
3906 {
3907 ++anArgIter;
3908 }
3909 }
8693dfd0 3910 else if (anArg == "-continuous"
3911 || anArg == "-cont"
3912 || anArg == "-fps"
3913 || anArg == "-framerate")
3914 {
3915 Standard_Real aFps = -1.0;
3916 if (anArgIter + 1 < theArgNb
3917 && TCollection_AsciiString (theArgVec[anArgIter + 1]).IsRealValue())
3918 {
3919 aFps = Draw::Atof (theArgVec[++anArgIter]);
3920 }
3921
3922 ViewerTest_ContinuousRedrawer& aRedrawer = ViewerTest_ContinuousRedrawer::Instance();
3923 if (Abs (aFps) >= 1.0)
3924 {
3925 aRedrawer.Start (aView->Window(), aFps);
3926 }
3927 else
3928 {
3929 aRedrawer.Stop();
3930 }
3931 }
56689b27 3932 else
3933 {
3934 std::cout << "Syntax error at '" << anArg << "'\n";
8693dfd0 3935 return 1;
56689b27 3936 }
3937 }
3938
3939 if (isImmediateUpdate)
3940 {
3941 aView->RedrawImmediate();
3942 }
3943 else
3944 {
3945 aView->Redraw();
3946 }
3947 return 0;
7fd59977 3948}
3949
7fd59977 3950//==============================================================================
3951//function : VClear
3952//purpose : Remove all the object from the viewer
3953//Draw arg : No args
3954//==============================================================================
3955
3956static int VClear(Draw_Interpretor& , Standard_Integer , const char** )
3957{
3958 Handle(V3d_View) V = ViewerTest::CurrentView();
3959 if(!V.IsNull())
3960 ViewerTest::Clear();
3961 return 0;
3962}
3963
3964//==============================================================================
3965//function : VPick
3966//purpose :
3967//==============================================================================
3968
49582f9d 3969static int VPick (Draw_Interpretor& ,
3970 Standard_Integer theNbArgs,
3971 const char** theArgVec)
3972{
3973 if (ViewerTest::CurrentView().IsNull())
3974 {
3975 return 1;
3976 }
7fd59977 3977
49582f9d 3978 if (theNbArgs < 4)
3979 {
3980 std::cout << "Syntax error: Invalid number of arguments\n";
3981 return 1;
3982 }
7fd59977 3983
49582f9d 3984 while (ViewerMainLoop (theNbArgs, theArgVec))
3985 {
3986 //
3987 }
7fd59977 3988
49582f9d 3989 return 0;
7fd59977 3990}
3991
293211ae 3992namespace
7fd59977 3993{
7fd59977 3994
293211ae 3995 //! Changes the background
3996 //! @param theDrawInterpretor the interpreter of the Draw Harness application
3997 //! @param theNumberOfCommandLineArguments the number of passed command line arguments
3998 //! @param theCommandLineArguments the array of command line arguments
3999 //! @return TCL_OK if changing was successful, or TCL_ERROR otherwise
4000 static int vbackground (Draw_Interpretor& theDrawInterpretor,
4001 const Standard_Integer theNumberOfCommandLineArguments,
4002 const char** const theCommandLineArguments)
7fd59977 4003 {
293211ae 4004 if (theNumberOfCommandLineArguments < 1)
7fd59977 4005 {
293211ae 4006 return TCL_ERROR;
7fd59977 4007 }
293211ae 4008 BackgroundChanger aBackgroundChanger;
4009 if (!aBackgroundChanger.ProcessCommandLine (theDrawInterpretor,
4010 theNumberOfCommandLineArguments,
4011 theCommandLineArguments))
f8b2ed36 4012 {
293211ae 4013 theDrawInterpretor << "Wrong command arguments.\n"
4014 "Type 'help "
4015 << theCommandLineArguments[0] << "' for information about command options and its arguments.\n";
4016 return TCL_ERROR;
f8b2ed36 4017 }
293211ae 4018 return TCL_OK;
f8b2ed36 4019 }
4020
293211ae 4021} // namespace
f42753ed 4022
7fd59977 4023//==============================================================================
4024//function : VScale
4025//purpose : View Scaling
4026//==============================================================================
4027
4028static int VScale(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
4029{
4030 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
4031 if ( V3dView.IsNull() ) return 1;
4032
4033 if ( argc != 4 ) {
586db386 4034 di << argv[0] << "Invalid number of arguments\n";
7fd59977 4035 return 1;
4036 }
91322f44 4037 V3dView->SetAxialScale( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
7fd59977 4038 return 0;
4039}
4040//==============================================================================
536d98e2 4041//function : VZBuffTrihedron
4042//purpose :
7fd59977 4043//==============================================================================
4044
536d98e2 4045static int VZBuffTrihedron (Draw_Interpretor& /*theDI*/,
4046 Standard_Integer theArgNb,
4047 const char** theArgVec)
7fd59977 4048{
536d98e2 4049 Handle(V3d_View) aView = ViewerTest::CurrentView();
4050 if (aView.IsNull())
4051 {
4052 std::cout << "Error: no active viewer!\n";
4053 return 1;
4054 }
7fd59977 4055
536d98e2 4056 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
7c8a8fcc 4057
536d98e2 4058 Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
4059 V3d_TypeOfVisualization aVisType = V3d_ZBUFFER;
4060 Quantity_Color aLabelsColor = Quantity_NOC_WHITE;
4061 Quantity_Color anArrowColorX = Quantity_NOC_RED;
4062 Quantity_Color anArrowColorY = Quantity_NOC_GREEN;
4063 Quantity_Color anArrowColorZ = Quantity_NOC_BLUE1;
4064 Standard_Real aScale = 0.1;
4065 Standard_Real aSizeRatio = 0.8;
4066 Standard_Real anArrowDiam = 0.05;
4067 Standard_Integer aNbFacets = 12;
4068 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
7c8a8fcc 4069 {
536d98e2 4070 Standard_CString anArg = theArgVec[anArgIter];
4071 TCollection_AsciiString aFlag (anArg);
4072 aFlag.LowerCase();
4073 if (anUpdateTool.parseRedrawMode (aFlag))
7c8a8fcc 4074 {
536d98e2 4075 continue;
4076 }
4077 else if (aFlag == "-on")
7c8a8fcc 4078 {
536d98e2 4079 continue;
4080 }
4081 else if (aFlag == "-off")
7c8a8fcc 4082 {
536d98e2 4083 aView->TriedronErase();
4084 return 0;
4085 }
4086 else if (aFlag == "-pos"
4087 || aFlag == "-position"
4088 || aFlag == "-corner")
7c8a8fcc 4089 {
536d98e2 4090 if (++anArgIter >= theArgNb)
4091 {
4092 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4093 return 1;
4094 }
4095
4096 TCollection_AsciiString aPosName (theArgVec[anArgIter]);
4097 aPosName.LowerCase();
4098 if (aPosName == "center")
4099 {
4100 aPosition = Aspect_TOTP_CENTER;
4101 }
4102 else if (aPosName == "left_lower"
4103 || aPosName == "lower_left"
4104 || aPosName == "leftlower"
4105 || aPosName == "lowerleft")
4106 {
4107 aPosition = Aspect_TOTP_LEFT_LOWER;
4108 }
4109 else if (aPosName == "left_upper"
4110 || aPosName == "upper_left"
4111 || aPosName == "leftupper"
4112 || aPosName == "upperleft")
4113 {
4114 aPosition = Aspect_TOTP_LEFT_UPPER;
4115 }
4116 else if (aPosName == "right_lower"
4117 || aPosName == "lower_right"
4118 || aPosName == "rightlower"
4119 || aPosName == "lowerright")
4120 {
4121 aPosition = Aspect_TOTP_RIGHT_LOWER;
4122 }
4123 else if (aPosName == "right_upper"
4124 || aPosName == "upper_right"
4125 || aPosName == "rightupper"
4126 || aPosName == "upperright")
4127 {
4128 aPosition = Aspect_TOTP_RIGHT_UPPER;
4129 }
4130 else
4131 {
4132 std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
4133 return 1;
4134 }
4135 }
4136 else if (aFlag == "-type")
7c8a8fcc 4137 {
536d98e2 4138 if (++anArgIter >= theArgNb)
4139 {
4140 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4141 return 1;
4142 }
4143
4144 TCollection_AsciiString aTypeName (theArgVec[anArgIter]);
4145 aTypeName.LowerCase();
4146 if (aTypeName == "wireframe"
4147 || aTypeName == "wire")
4148 {
4149 aVisType = V3d_WIREFRAME;
4150 }
4151 else if (aTypeName == "zbuffer"
4152 || aTypeName == "shaded")
4153 {
4154 aVisType = V3d_ZBUFFER;
4155 }
4156 else
4157 {
4158 std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
4159 }
4160 }
4161 else if (aFlag == "-scale")
7c8a8fcc 4162 {
536d98e2 4163 if (++anArgIter >= theArgNb)
4164 {
4165 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4166 return 1;
4167 }
4168
4169 aScale = Draw::Atof (theArgVec[anArgIter]);
7c8a8fcc 4170 }
536d98e2 4171 else if (aFlag == "-size"
4172 || aFlag == "-sizeratio")
4173 {
4174 if (++anArgIter >= theArgNb)
4175 {
4176 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4177 return 1;
4178 }
7c8a8fcc 4179
536d98e2 4180 aSizeRatio = Draw::Atof (theArgVec[anArgIter]);
4181 }
4182 else if (aFlag == "-arrowdiam"
4183 || aFlag == "-arrowdiameter")
4184 {
4185 if (++anArgIter >= theArgNb)
4186 {
4187 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4188 return 1;
4189 }
7c8a8fcc 4190
536d98e2 4191 anArrowDiam = Draw::Atof (theArgVec[anArgIter]);
4192 }
4193 else if (aFlag == "-nbfacets")
4194 {
4195 if (++anArgIter >= theArgNb)
4196 {
4197 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4198 return 1;
4199 }
7c8a8fcc 4200
536d98e2 4201 aNbFacets = Draw::Atoi (theArgVec[anArgIter]);
4202 }
4203 else if (aFlag == "-colorlabel"
4204 || aFlag == "-colorlabels")
7c8a8fcc 4205 {
536d98e2 4206 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
4207 theArgVec + anArgIter + 1,
4208 aLabelsColor);
4209 if (aNbParsed == 0)
4210 {
4211 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4212 return 1;
4213 }
4214 anArgIter += aNbParsed;
7c8a8fcc 4215 }
536d98e2 4216 else if (aFlag == "-colorarrowx")
7c8a8fcc 4217 {
536d98e2 4218 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
4219 theArgVec + anArgIter + 1,
4220 anArrowColorX);
4221 if (aNbParsed == 0)
4222 {
4223 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4224 return 1;
4225 }
4226 anArgIter += aNbParsed;
4227 }
4228 else if (aFlag == "-colorarrowy")
7c8a8fcc 4229 {
536d98e2 4230 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
4231 theArgVec + anArgIter + 1,
4232 anArrowColorY);
4233 if (aNbParsed == 0)
4234 {
4235 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4236 return 1;
4237 }
4238 anArgIter += aNbParsed;
4239 }
4240 else if (aFlag == "-colorarrowz")
7c8a8fcc 4241 {
536d98e2 4242 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
4243 theArgVec + anArgIter + 1,
4244 anArrowColorZ);
4245 if (aNbParsed == 0)
4246 {
4247 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4248 return 1;
4249 }
4250 anArgIter += aNbParsed;
4251 }
4252 else
4253 {
4254 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
7c8a8fcc 4255 return 1;
4256 }
7c8a8fcc 4257 }
4258
536d98e2 4259 aView->ZBufferTriedronSetup (anArrowColorX.Name(), anArrowColorY.Name(), anArrowColorZ.Name(),
4260 aSizeRatio, anArrowDiam, aNbFacets);
4261 aView->TriedronDisplay (aPosition, aLabelsColor.Name(), aScale, aVisType);
c357e426 4262 aView->ZFitAll();
7fd59977 4263 return 0;
4264}
4265
4266//==============================================================================
4267//function : VRotate
4268//purpose : Camera Rotating
4269//==============================================================================
4270
4af098ba 4271static int VRotate (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
4272{
4273 Handle(V3d_View) aView = ViewerTest::CurrentView();
4274 if (aView.IsNull())
4275 {
4276 std::cout << "No active view!\n";
7fd59977 4277 return 1;
4278 }
4279
4af098ba 4280 Standard_Boolean hasFlags = Standard_False;
4281 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
4282 {
4283 Standard_CString anArg (theArgVec[anArgIter]);
4284 TCollection_AsciiString aFlag (anArg);
4285 aFlag.LowerCase();
4286 if (aFlag == "-mousestart"
4287 || aFlag == "-mousefrom")
4288 {
4289 hasFlags = Standard_True;
4290 if (anArgIter + 2 >= theArgNb)
4291 {
4292 std::cout << "Error: wrong syntax at '" << anArg << "'\n";
4293 return 1;
4294 }
4295
4296 Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
4297 Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
4298 aView->StartRotation (anX, anY);
4299 }
4300 else if (aFlag == "-mousemove")
4301 {
4302 hasFlags = Standard_True;
4303 if (anArgIter + 2 >= theArgNb)
4304 {
4305 std::cout << "Error: wrong syntax at '" << anArg << "'\n";
4306 return 1;
4307 }
4308
4309 Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
4310 Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
4311 aView->Rotation (anX, anY);
4312 }
4313 else if (theArgNb != 4
4314 && theArgNb != 7)
4315 {
4316 std::cout << "Error: wrong syntax at '" << anArg << "'\n";
4317 return 1;
4318 }
4319 }
4320
4321 if (hasFlags)
4322 {
7fd59977 4323 return 0;
4af098ba 4324 }
4325 else if (theArgNb == 4)
4326 {
4327 Standard_Real anAX = Draw::Atof (theArgVec[1]);
4328 Standard_Real anAY = Draw::Atof (theArgVec[2]);
4329 Standard_Real anAZ = Draw::Atof (theArgVec[3]);
4330 aView->Rotate (anAX, anAY, anAZ);
4331 return 0;
4332 }
4333 else if (theArgNb == 7)
4334 {
4335 Standard_Real anAX = Draw::Atof (theArgVec[1]);
4336 Standard_Real anAY = Draw::Atof (theArgVec[2]);
4337 Standard_Real anAZ = Draw::Atof (theArgVec[3]);
4338
4339 Standard_Real anX = Draw::Atof (theArgVec[4]);
4340 Standard_Real anY = Draw::Atof (theArgVec[5]);
4341 Standard_Real anZ = Draw::Atof (theArgVec[6]);
4342
4343 aView->Rotate (anAX, anAY, anAZ, anX, anY, anZ);
7fd59977 4344 return 0;
7fd59977 4345 }
4af098ba 4346
4347 std::cout << "Error: Invalid number of arguments\n";
4348 return 1;
7fd59977 4349}
4350
4351//==============================================================================
4352//function : VZoom
4353//purpose : View zoom in / out (relative to current zoom)
4354//==============================================================================
4355
4356static int VZoom( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
4357 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
4358 if ( V3dView.IsNull() ) {
4359 return 1;
4360 }
4361
4362 if ( argc == 2 ) {
91322f44 4363 Standard_Real coef = Draw::Atof(argv[1]);
7fd59977 4364 if ( coef <= 0.0 ) {
586db386 4365 di << argv[1] << "Invalid value\n";
7fd59977 4366 return 1;
4367 }
91322f44 4368 V3dView->SetZoom( Draw::Atof(argv[1]) );
7fd59977 4369 return 0;
4370 } else {
586db386 4371 di << argv[0] << " Invalid number of arguments\n";
7fd59977 4372 return 1;
4373 }
4374}
4375
4376//==============================================================================
4377//function : VPan
4378//purpose : View panning (in pixels)
4379//==============================================================================
4380
4381static int VPan( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
4382 Handle(V3d_View) V3dView = ViewerTest::CurrentView();
4383 if ( V3dView.IsNull() ) return 1;
4384
4385 if ( argc == 3 ) {
91322f44 4386 V3dView->Pan( Draw::Atoi(argv[1]), Draw::Atoi(argv[2]) );
7fd59977 4387 return 0;
4388 } else {
586db386 4389 di << argv[0] << " Invalid number of arguments\n";
7fd59977 4390 return 1;
4391 }
4392}
4393
49e1a5c7 4394//==============================================================================
4395//function : VPlace
4396//purpose : Place the point (in pixels) at the center of the window
4397//==============================================================================
4398static int VPlace (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgs)
4399{
4400 Handle(V3d_View) aView = ViewerTest::CurrentView();
4401 if (aView.IsNull())
4402 {
4403 std::cerr << theArgs[0] << "Error: no active view." << std::endl;
4404 return 1;
4405 }
4406
4407 if (theArgNb != 3)
4408 {
4409 std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
4410 return 1;
4411 }
4412
4413 aView->Place (Draw::Atoi (theArgs[1]), Draw::Atoi (theArgs[2]), aView->Scale());
4414
4415 return 0;
4416}
7fd59977 4417
71215351 4418static int VColorScale (Draw_Interpretor& theDI,
4419 Standard_Integer theArgNb,
4420 const char** theArgVec)
4421{
7fd59977 4422 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
71215351 4423 Handle(V3d_View) aView = ViewerTest::CurrentView();
4424 if (aContext.IsNull())
4425 {
4426 std::cout << "Error: no active view!\n";
4427 return 1;
7fd59977 4428 }
24a88697 4429 if (theArgNb <= 1)
4430 {
4431 std::cout << "Error: wrong syntax at command '" << theArgVec[0] << "'!\n";
4432 return 1;
4433 }
7fd59977 4434
4b3d6eb1 4435 Handle(AIS_ColorScale) aColorScale;
7a324550 4436 if (GetMapOfAIS().IsBound2 (theArgVec[1]))
71215351 4437 {
4b3d6eb1 4438 // find existing object
4439 aColorScale = Handle(AIS_ColorScale)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
4440 if (aColorScale.IsNull())
7a324550 4441 {
4442 std::cout << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale!\n";
4443 return 1;
4444 }
4445 }
71215351 4446
7a324550 4447 if (theArgNb <= 2)
4448 {
4b3d6eb1 4449 if (aColorScale.IsNull())
4450 {
4451 std::cout << "Syntax error: colorscale with a given name does not exist.\n";
4452 return 1;
4453 }
4454
7a324550 4455 theDI << "Color scale parameters for '"<< theArgVec[1] << "':\n"
4b3d6eb1 4456 << "Min range: " << aColorScale->GetMin() << "\n"
4457 << "Max range: " << aColorScale->GetMax() << "\n"
4458 << "Number of intervals: " << aColorScale->GetNumberOfIntervals() << "\n"
4459 << "Text height: " << aColorScale->GetTextHeight() << "\n"
4460 << "Color scale position: " << aColorScale->GetXPosition() << " " << aColorScale->GetYPosition() << "\n"
4461 << "Color scale title: " << aColorScale->GetTitle() << "\n"
71215351 4462 << "Label position: ";
4b3d6eb1 4463 switch (aColorScale->GetLabelPosition())
71215351 4464 {
4465 case Aspect_TOCSP_NONE:
4466 theDI << "None\n";
4467 break;
4468 case Aspect_TOCSP_LEFT:
4469 theDI << "Left\n";
4470 break;
4471 case Aspect_TOCSP_RIGHT:
4472 theDI << "Right\n";
4473 break;
4474 case Aspect_TOCSP_CENTER:
4475 theDI << "Center\n";
4476 break;
4477 }
4478 return 0;
4479 }
71215351 4480
4b3d6eb1 4481 if (aColorScale.IsNull())
4482 {
4483 aColorScale = new AIS_ColorScale();
4484 aColorScale->SetZLayer (Graphic3d_ZLayerId_TopOSD);
4485 aContext->SetTransformPersistence (aColorScale, new Graphic3d_TransformPers (Graphic3d_TMF_2d, Aspect_TOTP_LEFT_LOWER));
4486 }
4487
4488 ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
7a324550 4489 for (Standard_Integer anArgIter = 2; anArgIter < theArgNb; ++anArgIter)
71215351 4490 {
4491 Standard_CString anArg = theArgVec[anArgIter];
4492 TCollection_AsciiString aFlag (anArg);
4493 aFlag.LowerCase();
4494 if (anUpdateTool.parseRedrawMode (aFlag))
4495 {
4496 continue;
4497 }
4498 else if (aFlag == "-range")
4499 {
4500 if (anArgIter + 3 >= theArgNb)
4501 {
4502 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4503 return 1;
4504 }
4505
4b3d6eb1 4506 const TCollection_AsciiString aRangeMin (theArgVec[++anArgIter]);
4507 const TCollection_AsciiString aRangeMax (theArgVec[++anArgIter]);
4508 const TCollection_AsciiString aNbIntervals (theArgVec[++anArgIter]);
4509 if (!aRangeMin.IsRealValue()
4510 || !aRangeMax.IsRealValue())
71215351 4511 {
4b3d6eb1 4512 std::cout << "Error: the range values should be real!\n";
71215351 4513 return 1;
4514 }
4b3d6eb1 4515 else if (!aNbIntervals.IsIntegerValue())
71215351 4516 {
4517 std::cout << "Error: the number of intervals should be integer!\n";
4518 return 1;
4519 }
4520
4b3d6eb1 4521 aColorScale->SetRange (aRangeMin.RealValue(), aRangeMax.RealValue());
4522 aColorScale->SetNumberOfIntervals (aNbIntervals.IntegerValue());
71215351 4523 }
4524 else if (aFlag == "-font")
4525 {
4526 if (anArgIter + 1 >= theArgNb)
4527 {
4528 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4529 return 1;
4530 }
51740958 4531 TCollection_AsciiString aFontArg(theArgVec[anArgIter + 1]);
4532 if (!aFontArg.IsIntegerValue())
71215351 4533 {
4534 std::cout << "Error: HeightFont value should be integer!\n";
4535 return 1;
4536 }
4537
4b3d6eb1 4538 aColorScale->SetTextHeight (aFontArg.IntegerValue());
71215351 4539 anArgIter += 1;
4540 }
4541 else if (aFlag == "-textpos")
4542 {
4543 if (anArgIter + 1 >= theArgNb)
4544 {
4545 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4546 return 1;
4547 }
4b3d6eb1 4548
51740958 4549 TCollection_AsciiString aTextPosArg(theArgVec[++anArgIter]);
4550 aTextPosArg.LowerCase();
4b3d6eb1 4551 Aspect_TypeOfColorScalePosition aLabPosition = Aspect_TOCSP_NONE;
51740958 4552 if (aTextPosArg == "none")
71215351 4553 {
4554 aLabPosition = Aspect_TOCSP_NONE;
4555 }
51740958 4556 else if (aTextPosArg == "left")
71215351 4557 {
4558 aLabPosition = Aspect_TOCSP_LEFT;
4559 }
51740958 4560 else if (aTextPosArg == "right")
71215351 4561 {
4562 aLabPosition = Aspect_TOCSP_RIGHT;
4563 }
51740958 4564 else if (aTextPosArg == "center")
71215351 4565 {
4566 aLabPosition = Aspect_TOCSP_CENTER;
4567 }
4568 else
4569 {
51740958 4570 std::cout << "Error: unknown position '" << aTextPosArg << "'!\n";
71215351 4571 return 1;
4572 }
4b3d6eb1 4573 aColorScale->SetLabelPosition (aLabPosition);
71215351 4574 }
24a88697 4575 else if (aFlag == "-logarithmic"
4576 || aFlag == "-log")
4577 {
4578 if (anArgIter + 1 >= theArgNb)
4579 {
4580 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4581 return 1;
4582 }
4b3d6eb1 4583
24a88697 4584 Standard_Boolean IsLog;
4585 if (!ViewerTest::ParseOnOff(theArgVec[++anArgIter], IsLog))
4586 {
4587 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4588 return 1;
4589 }
4b3d6eb1 4590 aColorScale->SetLogarithmic (IsLog);
4591 }
4592 else if (aFlag == "-huerange"
4593 || aFlag == "-hue")
4594 {
4595 if (anArgIter + 2 >= theArgNb)
4596 {
4597 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4598 return 1;
4599 }
4600
4601 const Standard_Real aHueMin = Draw::Atof (theArgVec[++anArgIter]);
4602 const Standard_Real aHueMax = Draw::Atof (theArgVec[++anArgIter]);
4603 aColorScale->SetHueRange (aHueMin, aHueMax);
4604 }
4605 else if (aFlag == "-colorrange")
4606 {
4607 Quantity_Color aColorMin, aColorMax;
4608 Standard_Integer aNbParsed1 = ViewerTest::ParseColor (theArgNb - (anArgIter + 1),
4609 theArgVec + (anArgIter + 1),
4610 aColorMin);
4611 anArgIter += aNbParsed1;
4612 Standard_Integer aNbParsed2 = ViewerTest::ParseColor (theArgNb - (anArgIter + 1),
4613 theArgVec + (anArgIter + 1),
4614 aColorMax);
4615 anArgIter += aNbParsed2;
4616 if (aNbParsed1 == 0
4617 || aNbParsed2 == 0)
4618 {
4619 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
4620 return 1;
4621 }
4622
4623 aColorScale->SetColorRange (aColorMin, aColorMax);
4624 }
4625 else if (aFlag == "-reversed"
4626 || aFlag == "-inverted"
4627 || aFlag == "-topdown"
4628 || aFlag == "-bottomup")
4629 {
4630 Standard_Boolean toEnable = Standard_True;
4631 if (anArgIter + 1 < theArgNb
4632 && ViewerTest::ParseOnOff(theArgVec[anArgIter + 1], toEnable))
4633 {
4634 ++anArgIter;
4635 }
4636 aColorScale->SetReversed ((aFlag == "-topdown") ? !toEnable : toEnable);
4637 }
4638 else if (aFlag == "-smooth"
4639 || aFlag == "-smoothtransition")
4640 {
4641 Standard_Boolean toEnable = Standard_True;
4642 if (anArgIter + 1 < theArgNb
4643 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
4644 {
4645 ++anArgIter;
4646 }
4647 aColorScale->SetSmoothTransition (toEnable);
24a88697 4648 }
71215351 4649 else if (aFlag == "-xy")
4650 {
4651 if (anArgIter + 2 >= theArgNb)
4652 {
4653 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4654 return 1;
4655 }
4656
4b3d6eb1 4657 const TCollection_AsciiString anX (theArgVec[++anArgIter]);
4658 const TCollection_AsciiString anY (theArgVec[++anArgIter]);
4659 if (!anX.IsIntegerValue()
4660 || !anY.IsIntegerValue())
71215351 4661 {
b4b2ecca 4662 std::cout << "Error: coordinates should be integer values!\n";
71215351 4663 return 1;
4664 }
4665
4b3d6eb1 4666 aColorScale->SetPosition (anX.IntegerValue(), anY.IntegerValue());
b4b2ecca 4667 }
4668 else if (aFlag == "-width"
4b3d6eb1 4669 || aFlag == "-w"
4670 || aFlag == "-breadth")
b4b2ecca 4671 {
4672 if (anArgIter + 1 >= theArgNb)
4673 {
4674 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4675 return 1;
4676 }
4677
4b3d6eb1 4678 const TCollection_AsciiString aBreadth (theArgVec[++anArgIter]);
4679 if (!aBreadth.IsIntegerValue())
b4b2ecca 4680 {
4681 std::cout << "Error: a width should be an integer value!\n";
4682 return 1;
4683 }
4b3d6eb1 4684 aColorScale->SetBreadth (aBreadth.IntegerValue());
b4b2ecca 4685 }
4686 else if (aFlag == "-height"
4687 || aFlag == "-h")
4688 {
4689 if (anArgIter + 1 >= theArgNb)
4690 {
4691 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4692 return 1;
4693 }
4694
4b3d6eb1 4695 const TCollection_AsciiString aHeight (theArgVec[++anArgIter]);
4696 if (!aHeight.IsIntegerValue())
b4b2ecca 4697 {
4698 std::cout << "Error: a width should be an integer value!\n";
4699 return 1;
4700 }
4b3d6eb1 4701 aColorScale->SetHeight (aHeight.IntegerValue());
71215351 4702 }
4703 else if (aFlag == "-color")
4704 {
4b3d6eb1 4705 if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
71215351 4706 {
4707 std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
4708 return 1;
4709 }
4b3d6eb1 4710 else if (anArgIter + 2 >= theArgNb)
71215351 4711 {
4b3d6eb1 4712 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4713 return 1;
71215351 4714 }
4715
4b3d6eb1 4716 const TCollection_AsciiString anInd (theArgVec[++anArgIter]);
71215351 4717 if (!anInd.IsIntegerValue())
4718 {
4719 std::cout << "Error: Index value should be integer!\n";
4720 return 1;
4721 }
4b3d6eb1 4722 const Standard_Integer anIndex = anInd.IntegerValue();
4723 if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals())
71215351 4724 {
4b3d6eb1 4725 std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() <<"!\n";
71215351 4726 return 1;
4727 }
4728
4b3d6eb1 4729 Quantity_Color aColor;
4730 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - (anArgIter + 1),
4731 theArgVec + (anArgIter + 1),
4732 aColor);
4733 if (aNbParsed == 0)
71215351 4734 {
4b3d6eb1 4735 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
71215351 4736 return 1;
4737 }
4b3d6eb1 4738 aColorScale->SetIntervalColor (aColor, anIndex);
4739 aColorScale->SetColorType (Aspect_TOCSD_USER);
4740 anArgIter += aNbParsed;
71215351 4741 }
4742 else if (aFlag == "-label")
4743 {
4b3d6eb1 4744 if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
71215351 4745 {
4746 std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
4747 return 1;
4748 }
4749 else if (anArgIter + 2 >= theArgNb)
4750 {
4751 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4752 return 1;
4753 }
4754
4755 Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
4b3d6eb1 4756 if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals() + 1)
71215351 4757 {
4b3d6eb1 4758 std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() + 1 <<"!\n";
71215351 4759 return 1;
4760 }
4761
4762 TCollection_ExtendedString aText (theArgVec[anArgIter + 2]);
4b3d6eb1 4763 aColorScale->SetLabel (aText, anIndex);
4764 aColorScale->SetLabelType (Aspect_TOCSD_USER);
71215351 4765 anArgIter += 2;
4766 }
4b3d6eb1 4767 else if (aFlag == "-labelat"
4768 || aFlag == "-labat"
4769 || aFlag == "-labelatborder"
4770 || aFlag == "-labatborder"
4771 || aFlag == "-labelatcenter"
4772 || aFlag == "-labatcenter")
71215351 4773 {
4b3d6eb1 4774 Standard_Boolean toEnable = Standard_True;
4775 if (aFlag == "-labelat"
4776 || aFlag == "-labat")
71215351 4777 {
4b3d6eb1 4778 Standard_Integer aLabAtBorder = -1;
4779 if (++anArgIter >= theArgNb)
71215351 4780 {
4b3d6eb1 4781 TCollection_AsciiString anAtBorder (theArgVec[anArgIter]);
4782 anAtBorder.LowerCase();
4783 if (anAtBorder == "border")
71215351 4784 {
4b3d6eb1 4785 aLabAtBorder = 1;
71215351 4786 }
4b3d6eb1 4787 else if (anAtBorder == "center")
71215351 4788 {
4b3d6eb1 4789 aLabAtBorder = 0;
71215351 4790 }
71215351 4791 }
4b3d6eb1 4792 if (aLabAtBorder == -1)
4793 {
4794 std::cout << "Syntax error at argument '" << anArg << "'!\n";
4795 return 1;
4796 }
4797 toEnable = (aLabAtBorder == 1);
4798 }
4799 else if (anArgIter + 1 < theArgNb
4800 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
4801 {
4802 ++anArgIter;
71215351 4803 }
4b3d6eb1 4804 aColorScale->SetLabelAtBorder (aFlag == "-labelatcenter"
4805 || aFlag == "-labatcenter"
4806 ? !toEnable
4807 : toEnable);
4808 }
4809 else if (aFlag == "-colors")
4810 {
4811 Aspect_SequenceOfColor aSeq;
4812 for (;;)
4813 {
4814 Quantity_Color aColor;
4815 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - (anArgIter + 1),
4816 theArgVec + (anArgIter + 1),
4817 aColor);
4818 if (aNbParsed == 0)
4819 {
4820 break;
4821 }
4822 anArgIter += aNbParsed;
4823 aSeq.Append (aColor);
4824 }
4825 if (aSeq.Length() != aColorScale->GetNumberOfIntervals())
71215351 4826 {
4827 std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
4b3d6eb1 4828 << aColorScale->GetNumberOfIntervals() << " intervals\n";
71215351 4829 return 1;
4830 }
4831
4b3d6eb1 4832 aColorScale->SetColors (aSeq);
4833 aColorScale->SetColorType (Aspect_TOCSD_USER);
71215351 4834 }
4b3d6eb1 4835 else if (aFlag == "-labels"
4836 || aFlag == "-freelabels")
71215351 4837 {
4b3d6eb1 4838 if (anArgIter + 1 >= theArgNb)
4839 {
4840 std::cout << "Syntax error at argument '" << anArg << "'!\n";
4841 return 1;
4842 }
4843
4844 Standard_Integer aNbLabels = aColorScale->IsLabelAtBorder()
4845 ? aColorScale->GetNumberOfIntervals() + 1
4846 : aColorScale->GetNumberOfIntervals();
4847 if (aFlag == "-freelabels")
4848 {
4849 ++anArgIter;
4850 aNbLabels = Draw::Atoi (theArgVec[anArgIter]);
4851 }
4852 if (anArgIter + aNbLabels >= theArgNb)
71215351 4853 {
4b3d6eb1 4854 std::cout << "Error: not enough arguments! " << aNbLabels << " text labels are expected.\n";
71215351 4855 return 1;
4856 }
4857
4858 TColStd_SequenceOfExtendedString aSeq;
4b3d6eb1 4859 for (Standard_Integer aLabelIter = 0; aLabelIter < aNbLabels; ++aLabelIter)
71215351 4860 {
4b3d6eb1 4861 aSeq.Append (TCollection_ExtendedString (theArgVec[++anArgIter]));
71215351 4862 }
4b3d6eb1 4863 aColorScale->SetLabels (aSeq);
4864 aColorScale->SetLabelType (Aspect_TOCSD_USER);
71215351 4865 }
4866 else if (aFlag == "-title")
4867 {
4868 if (anArgIter + 1 >= theArgNb)
4869 {
4870 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4871 return 1;
4872 }
4873
4874 Standard_Boolean isTwoArgs = Standard_False;
4875 if (anArgIter + 2 < theArgNb)
4876 {
4877 TCollection_AsciiString aSecondArg (theArgVec[anArgIter + 2]);
4878 aSecondArg.LowerCase();
4b3d6eb1 4879 Standard_DISABLE_DEPRECATION_WARNINGS
71215351 4880 if (aSecondArg == "none")
4881 {
4b3d6eb1 4882 aColorScale->SetTitlePosition (Aspect_TOCSP_NONE);
71215351 4883 isTwoArgs = Standard_True;
4884 }
4885 else if (aSecondArg == "left")
4886 {
4b3d6eb1 4887 aColorScale->SetTitlePosition (Aspect_TOCSP_LEFT);
71215351 4888 isTwoArgs = Standard_True;
4889 }
4890 else if (aSecondArg == "right")
4891 {
4b3d6eb1 4892 aColorScale->SetTitlePosition (Aspect_TOCSP_RIGHT);
71215351 4893 isTwoArgs = Standard_True;
4894 }
4895 else if (aSecondArg == "center")
4896 {
4b3d6eb1 4897 aColorScale->SetTitlePosition (Aspect_TOCSP_CENTER);
71215351 4898 isTwoArgs = Standard_True;
4899 }
4b3d6eb1 4900 Standard_ENABLE_DEPRECATION_WARNINGS
71215351 4901 }
4902
4b3d6eb1 4903 aColorScale->SetTitle (theArgVec[anArgIter + 1]);
71215351 4904 if (isTwoArgs)
4905 {
4906 anArgIter += 1;
4907 }
4908 anArgIter += 1;
4909 }
4910 else if (aFlag == "-demoversion"
4911 || aFlag == "-demo")
4912 {
4b3d6eb1 4913 aColorScale->SetPosition (0, 0);
4914 aColorScale->SetTextHeight (16);
4915 aColorScale->SetRange (0.0, 100.0);
4916 aColorScale->SetNumberOfIntervals (10);
4917 aColorScale->SetBreadth (0);
4918 aColorScale->SetHeight (0);
4919 aColorScale->SetLabelPosition (Aspect_TOCSP_RIGHT);
4920 aColorScale->SetColorType (Aspect_TOCSD_AUTO);
4921 aColorScale->SetLabelType (Aspect_TOCSD_AUTO);
71215351 4922 }
d5514578 4923 else if (aFlag == "-findcolor")
4924 {
4925 if (anArgIter + 1 >= theArgNb)
4926 {
4927 std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
4928 return 1;
4929 }
4930
4931 TCollection_AsciiString anArg1 (theArgVec[++anArgIter]);
4932
4933 if (!anArg1.IsRealValue())
4934 {
4935 std::cout << "Error: the value should be real!\n";
4936 return 1;
4937 }
4938
4939 Quantity_Color aColor;
4b3d6eb1 4940 aColorScale->FindColor (anArg1.RealValue(), aColor);
d5514578 4941 theDI << Quantity_Color::StringName (aColor.Name());
4942 return 0;
4943 }
71215351 4944 else
4945 {
4946 std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
4947 return 1;
4948 }
4949 }
4b3d6eb1 4950
4951 Standard_Integer aWinWidth = 0, aWinHeight = 0;
4952 aView->Window()->Size (aWinWidth, aWinHeight);
4953 if (aColorScale->GetBreadth() == 0)
b4b2ecca 4954 {
4b3d6eb1 4955 aColorScale->SetBreadth (aWinWidth);
b4b2ecca 4956 }
4b3d6eb1 4957 if (aColorScale->GetHeight() == 0)
4958 {
4959 aColorScale->SetHeight (aWinHeight);
4960 }
4961 aColorScale->SetToUpdate();
4962 ViewerTest::Display (theArgVec[1], aColorScale, Standard_False, Standard_True);
7fd59977 4963 return 0;
4964}
4965
4966//==============================================================================
4967//function : VGraduatedTrihedron
a79f67f8 4968//purpose : Displays or hides a graduated trihedron
7fd59977 4969//==============================================================================
a79f67f8 4970static Standard_Boolean GetColor (const TCollection_AsciiString& theValue,
4971 Quantity_Color& theColor)
13a22457 4972{
a79f67f8 4973 Quantity_NameOfColor aColorName;
4974 TCollection_AsciiString aVal = theValue;
4975 aVal.UpperCase();
4976 if (!Quantity_Color::ColorFromName (aVal.ToCString(), aColorName))
13a22457 4977 {
a79f67f8 4978 return Standard_False;
13a22457 4979 }
a79f67f8 4980 theColor = Quantity_Color (aColorName);
4981 return Standard_True;
13a22457
S		 4982}
4983
a79f67f8 4984static int VGraduatedTrihedron (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNum, const char** theArgs)
7fd59977 4985{
a79f67f8 4986 if (theArgNum < 2)
13a22457 4987 {
a79f67f8 4988 std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
4989 << theArgs[0] <<"' for more information.\n";
4990 return 1; //TCL_ERROR
13a22457 4991 }
7fd59977 4992
a79f67f8 4993 NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
4994 TCollection_AsciiString aParseKey;
4995 for (Standard_Integer anArgIt = 1; anArgIt < theArgNum; ++anArgIt)
4996 {
4997 TCollection_AsciiString anArg (theArgs [anArgIt]);
4998
4999 if (anArg.Value (1) == '-' && !anArg.IsRealValue())
5000 {
5001 aParseKey = anArg;
5002 aParseKey.Remove (1);
5003 aParseKey.LowerCase();
5004 aMapOfArgs.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
5005 continue;
5006 }
13a22457 5007
a79f67f8 5008 if (aParseKey.IsEmpty())
5009 {
5010 continue;
5011 }
5012
5013 aMapOfArgs(aParseKey)->Append (anArg);
5014 }
5015
5016 // Check parameters
5017 for (NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfArgs);
5018 aMapIt.More(); aMapIt.Next())
7fd59977 5019 {
a79f67f8 5020 const TCollection_AsciiString& aKey = aMapIt.Key();
5021 const Handle(TColStd_HSequenceOfAsciiString)& anArgs = aMapIt.Value();
5022
5023 // Bool key, without arguments
5024 if ((aKey.IsEqual ("on") || aKey.IsEqual ("off"))
5025 && anArgs->IsEmpty())
5026 {
5027 continue;
5028 }
5029
5030 // One argument
5031 if ( (aKey.IsEqual ("xname") || aKey.IsEqual ("yname") || aKey.IsEqual ("zname"))
5032 && anArgs->Length() == 1)
5033 {
5034 continue;
5035 }
5036
5037 // On/off arguments
5038 if ((aKey.IsEqual ("xdrawname") || aKey.IsEqual ("ydrawname") || aKey.IsEqual ("zdrawname")
5039 || aKey.IsEqual ("xdrawticks") || aKey.IsEqual ("ydrawticks") || aKey.IsEqual ("zdrawticks")
536d98e2 5040 || aKey.IsEqual ("xdrawvalues") || aKey.IsEqual ("ydrawvalues") || aKey.IsEqual ("zdrawvalues")
5041 || aKey.IsEqual ("drawgrid") || aKey.IsEqual ("drawaxes"))
a79f67f8 5042 && anArgs->Length() == 1 && (anArgs->Value(1).IsEqual ("on") || anArgs->Value(1).IsEqual ("off")))
5043 {
5044 continue;
5045 }
5046
5047 // One string argument
5048 if ( (aKey.IsEqual ("xnamecolor") || aKey.IsEqual ("ynamecolor") || aKey.IsEqual ("znamecolor")
5049 || aKey.IsEqual ("xcolor") || aKey.IsEqual ("ycolor") || aKey.IsEqual ("zcolor"))
5050 && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
5051 {
5052 continue;
5053 }
5054
5055 // One integer argument
5056 if ( (aKey.IsEqual ("xticks") || aKey.IsEqual ("yticks") || aKey.IsEqual ("zticks")
5057 || aKey.IsEqual ("xticklength") || aKey.IsEqual ("yticklength") || aKey.IsEqual ("zticklength")
5058 || aKey.IsEqual ("xnameoffset") || aKey.IsEqual ("ynameoffset") || aKey.IsEqual ("znameoffset")
5059 || aKey.IsEqual ("xvaluesoffset") || aKey.IsEqual ("yvaluesoffset") || aKey.IsEqual ("zvaluesoffset"))
5060 && anArgs->Length() == 1 && anArgs->Value(1).IsIntegerValue())
5061 {
5062 continue;
5063 }
5064
5065 // One real argument
5066 if ( aKey.IsEqual ("arrowlength")
5067 && anArgs->Length() == 1 && (anArgs->Value(1).IsIntegerValue() || anArgs->Value(1).IsRealValue()))
5068 {
5069 continue;
5070 }
5071
5072 // Two string arguments
5073 if ( (aKey.IsEqual ("namefont") || aKey.IsEqual ("valuesfont"))
5074 && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
13a22457 5075 {
a79f67f8 5076 continue;
13a22457 5077 }
a79f67f8 5078
5079 TCollection_AsciiString aLowerKey;
5080 aLowerKey = "-";
5081 aLowerKey += aKey;
5082 aLowerKey.LowerCase();
5083 std::cout << theArgs[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
5084 std::cout << "Type help for more information.\n";
5085 return 1;
7fd59977 5086 }
5087
a79f67f8 5088 Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
5089 if (anAISContext.IsNull())
5090 {
586db386 5091 std::cout << theArgs[0] << ": please use 'vinit' command to initialize view.\n";
a79f67f8 5092 return 1;
5093 }
7fd59977 5094
a79f67f8 5095 Standard_Boolean toDisplay = Standard_True;
5096 Quantity_Color aColor;
5097 Graphic3d_GraduatedTrihedron aTrihedronData;
5098 // Process parameters
5099 Handle(TColStd_HSequenceOfAsciiString) aValues;
5100 if (aMapOfArgs.Find ("off", aValues))
7fd59977 5101 {
a79f67f8 5102 toDisplay = Standard_False;
5103 }
13a22457 5104
a79f67f8 5105 // AXES NAMES
5106 if (aMapOfArgs.Find ("xname", aValues))
5107 {
5108 aTrihedronData.ChangeXAxisAspect().SetName (aValues->Value(1));
5109 }
5110 if (aMapOfArgs.Find ("yname", aValues))
5111 {
5112 aTrihedronData.ChangeYAxisAspect().SetName (aValues->Value(1));
5113 }
5114 if (aMapOfArgs.Find ("zname", aValues))
5115 {
5116 aTrihedronData.ChangeZAxisAspect().SetName (aValues->Value(1));
5117 }
5118 if (aMapOfArgs.Find ("xdrawname", aValues))
5119 {
536d98e2 5120 aTrihedronData.ChangeXAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
a79f67f8 5121 }
5122 if (aMapOfArgs.Find ("ydrawname", aValues))
5123 {
536d98e2 5124 aTrihedronData.ChangeYAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
a79f67f8 5125 }
5126 if (aMapOfArgs.Find ("zdrawname", aValues))
5127 {
536d98e2 5128 aTrihedronData.ChangeZAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
a79f67f8 5129 }
5130 if (aMapOfArgs.Find ("xnameoffset", aValues))
5131 {
5132 aTrihedronData.ChangeXAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
5133 }
5134 if (aMapOfArgs.Find ("ynameoffset", aValues))
5135 {
5136 aTrihedronData.ChangeYAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
5137 }
5138 if (aMapOfArgs.Find ("znameoffset", aValues))
5139 {
5140 aTrihedronData.ChangeZAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
5141 }
13a22457 5142
a79f67f8 5143 // COLORS
5144 if (aMapOfArgs.Find ("xnamecolor", aValues))
5145 {
5146 if (!GetColor (aValues->Value(1), aColor))
13a22457 5147 {
a79f67f8 5148 std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
5149 return 1;
13a22457 5150 }
a79f67f8 5151 aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
5152 }
5153 if (aMapOfArgs.Find ("ynamecolor", aValues))
5154 {
5155 if (!GetColor (aValues->Value(1), aColor))
13a22457 5156 {
a79f67f8 5157 std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
5158 return 1;
5159 }
5160 aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
5161 }
5162 if (aMapOfArgs.Find ("znamecolor", aValues))
5163 {
5164 if (!GetColor (aValues->Value(1), aColor))
5165 {
5166 std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
5167 return 1;
5168 }
5169 aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
5170 }
5171 if (aMapOfArgs.Find ("xcolor", aValues))
5172 {
5173 if (!GetColor (aValues->Value(1), aColor))
5174 {
5175 std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
5176 return 1;
5177 }
5178 aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
5179 }
5180 if (aMapOfArgs.Find ("ycolor", aValues))
5181 {
5182 if (!GetColor (aValues->Value(1), aColor))
5183 {
5184 std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
5185 return 1;
5186 }
5187 aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
5188 }
5189 if (aMapOfArgs.Find ("zcolor", aValues))
5190 {
5191 if (!GetColor (aValues->Value(1), aColor))
5192 {
5193 std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
5194 return 1;
5195 }
5196 aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
5197 }
5198
5199 // TICKMARKS
5200 if (aMapOfArgs.Find ("xticks", aValues))
5201 {
536d98e2 5202 aTrihedronData.ChangeXAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
a79f67f8 5203 }
5204 if (aMapOfArgs.Find ("yticks", aValues))
5205 {
536d98e2 5206 aTrihedronData.ChangeYAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
a79f67f8 5207 }
5208 if (aMapOfArgs.Find ("zticks", aValues))
5209 {
536d98e2 5210 aTrihedronData.ChangeZAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
a79f67f8 5211 }
5212 if (aMapOfArgs.Find ("xticklength", aValues))
5213 {
536d98e2 5214 aTrihedronData.ChangeXAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
a79f67f8 5215 }
5216 if (aMapOfArgs.Find ("yticklength", aValues))
5217 {
536d98e2 5218 aTrihedronData.ChangeYAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
a79f67f8 5219 }
5220 if (aMapOfArgs.Find ("zticklength", aValues))
5221 {
536d98e2 5222 aTrihedronData.ChangeZAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
a79f67f8 5223 }
5224 if (aMapOfArgs.Find ("xdrawticks", aValues))
5225 {
536d98e2 5226 aTrihedronData.ChangeXAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
a79f67f8 5227 }
5228 if (aMapOfArgs.Find ("ydrawticks", aValues))
5229 {
536d98e2 5230 aTrihedronData.ChangeYAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
a79f67f8 5231 }
5232 if (aMapOfArgs.Find ("zdrawticks", aValues))
5233 {
536d98e2 5234 aTrihedronData.ChangeZAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
a79f67f8 5235 }
5236
5237 // VALUES
5238 if (aMapOfArgs.Find ("xdrawvalues", aValues))
5239 {
536d98e2 5240 aTrihedronData.ChangeXAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
a79f67f8 5241 }
5242 if (aMapOfArgs.Find ("ydrawvalues", aValues))
5243 {
536d98e2 5244 aTrihedronData.ChangeYAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
a79f67f8 5245 }
5246 if (aMapOfArgs.Find ("zdrawvalues", aValues))
5247 {
536d98e2 5248 aTrihedronData.ChangeZAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
a79f67f8 5249 }
5250 if (aMapOfArgs.Find ("xvaluesoffset", aValues))
5251 {
5252 aTrihedronData.ChangeXAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
5253 }
5254 if (aMapOfArgs.Find ("yvaluesoffset", aValues))
5255 {
5256 aTrihedronData.ChangeYAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
5257 }
5258 if (aMapOfArgs.Find ("zvaluesoffset", aValues))
5259 {
5260 aTrihedronData.ChangeZAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
5261 }
5262
5263 // ARROWS
5264 if (aMapOfArgs.Find ("arrowlength", aValues))
5265 {
536d98e2 5266 aTrihedronData.SetArrowsLength ((Standard_ShortReal) aValues->Value(1).RealValue());
a79f67f8 5267 }
5268
5269 // FONTS
5270 if (aMapOfArgs.Find ("namefont", aValues))
5271 {
5272 aTrihedronData.SetNamesFont (aValues->Value(1));
5273 }
5274 if (aMapOfArgs.Find ("valuesfont", aValues))
5275 {
5276 aTrihedronData.SetValuesFont (aValues->Value(1));
5277 }
5278
536d98e2 5279 if (aMapOfArgs.Find ("drawgrid", aValues))
5280 {
5281 aTrihedronData.SetDrawGrid (aValues->Value(1).IsEqual ("on"));
5282 }
5283 if (aMapOfArgs.Find ("drawaxes", aValues))
5284 {
5285 aTrihedronData.SetDrawAxes (aValues->Value(1).IsEqual ("on"));
5286 }
5287
a79f67f8 5288 // The final step: display of erase trihedron
5289 if (toDisplay)
5290 {
5291 ViewerTest::CurrentView()->GraduatedTrihedronDisplay (aTrihedronData);
13a22457 5292 }
7fd59977 5293 else
a79f67f8 5294 {
5295 ViewerTest::CurrentView()->GraduatedTrihedronErase();
5296 }
7fd59977 5297
5298 ViewerTest::GetAISContext()->UpdateCurrentViewer();
a79f67f8 5299 ViewerTest::CurrentView()->Redraw();
13a22457 5300
7fd59977 5301 return 0;
5302}
5303
3bffef55 5304//==============================================================================
5305//function : VTile
5306//purpose :
5307//==============================================================================
5308static int VTile (Draw_Interpretor& theDI,
5309 Standard_Integer theArgNb,
5310 const char** theArgVec)
5311{
5312 Handle(V3d_View) aView = ViewerTest::CurrentView();
5313 if (aView.IsNull())
5314 {
5315 std::cerr << "Error: no active viewer.\n";
5316 return 1;
5317 }
5318
5319 Graphic3d_CameraTile aTile = aView->Camera()->Tile();
5320 if (theArgNb < 2)
5321 {
5322 theDI << "Total size: " << aTile.TotalSize.x() << " " << aTile.TotalSize.y() << "\n"
5323 << "Tile size: " << aTile.TileSize.x() << " " << aTile.TileSize.y() << "\n"
5324 << "Lower left: " << aTile.Offset.x() << " " << aTile.Offset.y() << "\n";
5325 return 0;
5326 }
5327
5328 aView->Window()->Size (aTile.TileSize.x(), aTile.TileSize.y());
5329 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
5330 {
5331 TCollection_AsciiString anArg (theArgVec[anArgIter]);
5332 anArg.LowerCase();
5333 if (anArg == "-lowerleft"
5334 || anArg == "-upperleft")
5335 {
5336 if (anArgIter + 3 < theArgNb)
5337 {
5338 std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
5339 return 1;
5340 }
5341 aTile.IsTopDown = (anArg == "-upperleft") == Standard_True;
5342 aTile.Offset.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
5343 aTile.Offset.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
5344 }
5345 else if (anArg == "-total"
5346 || anArg == "-totalsize"
5347 || anArg == "-viewsize")
5348 {
5349 if (anArgIter + 3 < theArgNb)
5350 {
5351 std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
5352 return 1;
5353 }
5354 aTile.TotalSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
5355 aTile.TotalSize.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
5356 if (aTile.TotalSize.x() < 1
5357 || aTile.TotalSize.y() < 1)
5358 {
5359 std::cerr << "Error: total size is incorrect.\n";
5360 return 1;
5361 }
5362 }
5363 else if (anArg == "-tilesize")
5364 {
5365 if (anArgIter + 3 < theArgNb)
5366 {
5367 std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
5368 return 1;
5369 }
5370
5371 aTile.TileSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
5372 aTile.TileSize.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
5373 if (aTile.TileSize.x() < 1
5374 || aTile.TileSize.y() < 1)
5375 {
5376 std::cerr << "Error: tile size is incorrect.\n";
5377 return 1;
5378 }
5379 }
5380 else if (anArg == "-unset")
5381 {
5382 aView->Camera()->SetTile (Graphic3d_CameraTile());
5383 aView->Redraw();
5384 return 0;
5385 }
5386 }
5387
5388 if (aTile.TileSize.x() < 1
5389 || aTile.TileSize.y() < 1)
5390 {
5391 std::cerr << "Error: tile size is undefined.\n";
5392 return 1;
5393 }
5394 else if (aTile.TotalSize.x() < 1
5395 || aTile.TotalSize.y() < 1)
5396 {
5397 std::cerr << "Error: total size is undefined.\n";
5398 return 1;
5399 }
5400
5401 aView->Camera()->SetTile (aTile);
5402 aView->Redraw();
5403 return 0;
5404}
5405
7c3ef2f7 5406//! Format ZLayer ID.
5407inline const char* formZLayerId (const Standard_Integer theLayerId)
5408{
5409 switch (theLayerId)
5410 {
5411 case Graphic3d_ZLayerId_UNKNOWN: return "[INVALID]";
5412 case Graphic3d_ZLayerId_Default: return "[DEFAULT]";
5413 case Graphic3d_ZLayerId_Top: return "[TOP]";
5414 case Graphic3d_ZLayerId_Topmost: return "[TOPMOST]";
5415 case Graphic3d_ZLayerId_TopOSD: return "[OVERLAY]";
5416 case Graphic3d_ZLayerId_BotOSD: return "[UNDERLAY]";
5417 }
5418 return "";
5419}
5420
5421//! Print the ZLayer information.
5422inline void printZLayerInfo (Draw_Interpretor& theDI,
5423 const Graphic3d_ZLayerSettings& theLayer)
5424{
5425 if (!theLayer.Name().IsEmpty())
5426 {
5427 theDI << " Name: " << theLayer.Name() << "\n";
5428 }
5429 if (theLayer.IsImmediate())
5430 {
5431 theDI << " Immediate: TRUE\n";
5432 }
5433 theDI << " Origin: " << theLayer.Origin().X() << " " << theLayer.Origin().Y() << " " << theLayer.Origin().Z() << "\n";
4ecf34cc 5434 theDI << " Culling distance: " << theLayer.CullingDistance() << "\n";
5435 theDI << " Culling size: " << theLayer.CullingSize() << "\n";
7c3ef2f7 5436 theDI << " Depth test: " << (theLayer.ToEnableDepthTest() ? "enabled" : "disabled") << "\n";
5437 theDI << " Depth write: " << (theLayer.ToEnableDepthWrite() ? "enabled" : "disabled") << "\n";
5438 theDI << " Depth buffer clearing: " << (theLayer.ToClearDepth() ? "enabled" : "disabled") << "\n";
5439 if (theLayer.PolygonOffset().Mode != Aspect_POM_None)
5440 {
5441 theDI << " Depth offset: " << theLayer.PolygonOffset().Factor << " " << theLayer.PolygonOffset().Units << "\n";
5442 }
5443}
5444
59f45b7c 5445//==============================================================================
5446//function : VZLayer
5447//purpose : Test z layer operations for v3d viewer
5448//==============================================================================
7c3ef2f7 5449static int VZLayer (Draw_Interpretor& theDI,
5450 Standard_Integer theArgNb,
5451 const char** theArgVec)
59f45b7c 5452{
7c3ef2f7 5453 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
59f45b7c 5454 if (aContextAIS.IsNull())
5455 {
7c3ef2f7 5456 std::cout << "No active viewer!\n";
59f45b7c 5457 return 1;
5458 }
5459
5460 const Handle(V3d_Viewer)& aViewer = aContextAIS->CurrentViewer();
7c3ef2f7 5461 if (theArgNb < 2)
59f45b7c 5462 {
7c3ef2f7 5463 TColStd_SequenceOfInteger aLayers;
5464 aViewer->GetAllZLayers (aLayers);
5465 for (TColStd_SequenceOfInteger::Iterator aLayeriter (aLayers); aLayeriter.More(); aLayeriter.Next())
5466 {
5467 theDI << "ZLayer " << aLayeriter.Value() << " " << formZLayerId (aLayeriter.Value()) << "\n";
5468 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayeriter.Value());
5469 printZLayerInfo (theDI, aSettings);
5470 }
59f45b7c 5471 return 1;
5472 }
5473
7c3ef2f7 5474 Standard_Integer anArgIter = 1;
5475 Standard_Integer aLayerId = Graphic3d_ZLayerId_UNKNOWN;
5476 ViewerTest_AutoUpdater anUpdateTool (aContextAIS, ViewerTest::CurrentView());
5477 if (anUpdateTool.parseRedrawMode (theArgVec[anArgIter]))
59f45b7c 5478 {
7c3ef2f7 5479 ++anArgIter;
5480 }
59f45b7c 5481
7c3ef2f7 5482 {
55c8f0f7
BB		 5483 TCollection_AsciiString aFirstArg (theArgVec[anArgIter]);
5484 if (aFirstArg.IsIntegerValue())
c5751993 5485 {
7c3ef2f7 5486 ++anArgIter;
55c8f0f7 5487 aLayerId = aFirstArg.IntegerValue();
c5751993 5488 }
7c3ef2f7 5489 else
c5751993 5490 {
55c8f0f7 5491 if (ViewerTest::ParseZLayerName (aFirstArg.ToCString(), aLayerId))
7c3ef2f7 5492 {
55c8f0f7 5493 ++anArgIter;
7c3ef2f7 5494 }
c5751993 5495 }
7c3ef2f7 5496 }
c5751993 5497
1c728f2d 5498 Graphic3d_ZLayerId anOtherLayerId = Graphic3d_ZLayerId_UNKNOWN;
7c3ef2f7 5499 for (; anArgIter < theArgNb; ++anArgIter)
5500 {
5501 // perform operation
5502 TCollection_AsciiString anArg (theArgVec[anArgIter]);
5503 anArg.LowerCase();
5504 if (anUpdateTool.parseRedrawMode (anArg))
c5751993 5505 {
7c3ef2f7 5506 //
c5751993 5507 }
7c3ef2f7 5508 else if (anArg == "-add"
5509 || anArg == "add")
c5751993 5510 {
7c3ef2f7 5511 aLayerId = Graphic3d_ZLayerId_UNKNOWN;
5512 if (!aViewer->AddZLayer (aLayerId))
5513 {
5514 std::cout << "Error: can not add a new z layer!\n";
5515 return 0;
5516 }
5517
5518 theDI << aLayerId;
c5751993 5519 }
1c728f2d 5520 else if (anArg == "-insertbefore"
5521 && anArgIter + 1 < theArgNb
5522 && ViewerTest::ParseZLayer (theArgVec[anArgIter + 1], anOtherLayerId))
5523 {
5524 ++anArgIter;
5525 aLayerId = Graphic3d_ZLayerId_UNKNOWN;
5526 if (!aViewer->InsertLayerBefore (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
5527 {
5528 std::cout << "Error: can not add a new z layer!\n";
5529 return 0;
5530 }
5531
5532 theDI << aLayerId;
5533 }
5534 else if (anArg == "-insertafter"
5535 && anArgIter + 1 < theArgNb
5536 && ViewerTest::ParseZLayer (theArgVec[anArgIter + 1], anOtherLayerId))
5537 {
5538 ++anArgIter;
5539 aLayerId = Graphic3d_ZLayerId_UNKNOWN;
5540 if (!aViewer->InsertLayerAfter (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
5541 {
5542 std::cout << "Error: can not add a new z layer!\n";
5543 return 0;
5544 }
5545
5546 theDI << aLayerId;
5547 }
7c3ef2f7 5548 else if (anArg == "-del"
5549 || anArg == "-delete"
5550 || anArg == "del")
c5751993 5551 {
7c3ef2f7 5552 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
5553 {
5554 if (++anArgIter >= theArgNb)
5555 {
5556 std::cout << "Syntax error: id of z layer to remove is missing\n";
5557 return 1;
5558 }
5559
5560 aLayerId = Draw::Atoi (theArgVec[anArgIter]);
5561 }
5562
5563 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN
5564 || aLayerId == Graphic3d_ZLayerId_Default
5565 || aLayerId == Graphic3d_ZLayerId_Top
5566 || aLayerId == Graphic3d_ZLayerId_Topmost
5567 || aLayerId == Graphic3d_ZLayerId_TopOSD
5568 || aLayerId == Graphic3d_ZLayerId_BotOSD)
5569 {
5570 std::cout << "Syntax error: standard Z layer can not be removed\n";
5571 return 1;
5572 }
5573
5574 // move all object displayed in removing layer to default layer
5575 for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anObjIter (GetMapOfAIS());
5576 anObjIter.More(); anObjIter.Next())
5577 {
8f521168 5578 const Handle(AIS_InteractiveObject)& aPrs = anObjIter.Key1();
7c3ef2f7 5579 if (aPrs.IsNull()
5580 || aPrs->ZLayer() != aLayerId)
5581 {
5582 continue;
5583 }
5584 aPrs->SetZLayer (Graphic3d_ZLayerId_Default);
5585 }
5586
5587 if (!aViewer->RemoveZLayer (aLayerId))
5588 {
5589 std::cout << "Z layer can not be removed!\n";
5590 }
5591 else
5592 {
5593 theDI << aLayerId << " ";
5594 }
c5751993 5595 }
7c3ef2f7 5596 else if (anArg == "-get"
5597 || anArg == "get")
c5751993 5598 {
7c3ef2f7 5599 TColStd_SequenceOfInteger aLayers;
5600 aViewer->GetAllZLayers (aLayers);
5601 for (TColStd_SequenceOfInteger::Iterator aLayeriter (aLayers); aLayeriter.More(); aLayeriter.Next())
5602 {
5603 theDI << aLayeriter.Value() << " ";
5604 }
5605
5606 theDI << "\n";
c5751993 5607 }
7c3ef2f7 5608 else if (anArg == "-name")
c5751993 5609 {
7c3ef2f7 5610 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
c5751993 5611 {
7c3ef2f7 5612 std::cout << "Syntax error: id of Z layer is missing\n";
c5751993 5613 return 1;
5614 }
5615
7c3ef2f7 5616 if (++anArgIter >= theArgNb)
5617 {
5618 std::cout << "Syntax error: name is missing\n";
5619 return 1;
5620 }
c5751993 5621
7c3ef2f7 5622 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5623 aSettings.SetName (theArgVec[anArgIter]);
5624 aViewer->SetZLayerSettings (aLayerId, aSettings);
c5751993 5625 }
7c3ef2f7 5626 else if (anArg == "-origin")
c5751993 5627 {
7c3ef2f7 5628 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
5629 {
5630 std::cout << "Syntax error: id of Z layer is missing\n";
5631 return 1;
5632 }
5633
5634 if (anArgIter + 2 >= theArgNb)
5635 {
5636 std::cout << "Syntax error: origin coordinates are missing\n";
5637 return 1;
5638 }
5639
5640 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5641 gp_XYZ anOrigin;
5642 anOrigin.SetX (Draw::Atof (theArgVec[anArgIter + 1]));
5643 anOrigin.SetY (Draw::Atof (theArgVec[anArgIter + 2]));
5644 anOrigin.SetZ (0.0);
5645 if (anArgIter + 3 < theArgNb)
5646 {
5647 anOrigin.SetZ (Draw::Atof (theArgVec[anArgIter + 3]));
5648 anArgIter += 3;
5649 }
5650 else
5651 {
5652 anArgIter += 2;
5653 }
5654 aSettings.SetOrigin (anOrigin);
5655 aViewer->SetZLayerSettings (aLayerId, aSettings);
c5751993 5656 }
4ecf34cc 5657 else if (aLayerId != Graphic3d_ZLayerId_UNKNOWN
5658 && anArgIter + 1 < theArgNb
5659 && (anArg == "-cullingdistance"
5660 || anArg == "-cullingdist"
5661 || anArg == "-culldistance"
5662 || anArg == "-culldist"
5663 || anArg == "-distcull"
5664 || anArg == "-distculling"
5665 || anArg == "-distanceculling"))
5666 {
5667 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5668 const Standard_Real aDist = Draw::Atof (theArgVec[++anArgIter]);
5669 aSettings.SetCullingDistance (aDist);
5670 aViewer->SetZLayerSettings (aLayerId, aSettings);
5671 }
5672 else if (aLayerId != Graphic3d_ZLayerId_UNKNOWN
5673 && anArgIter + 1 < theArgNb
5674 && (anArg == "-cullingsize"
5675 || anArg == "-cullsize"
5676 || anArg == "-sizecull"
5677 || anArg == "-sizeculling"))
5678 {
5679 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5680 const Standard_Real aSize = Draw::Atof (theArgVec[++anArgIter]);
5681 aSettings.SetCullingSize (aSize);
5682 aViewer->SetZLayerSettings (aLayerId, aSettings);
5683 }
7c3ef2f7 5684 else if (anArg == "-settings"
5685 || anArg == "settings")
c5751993 5686 {
7c3ef2f7 5687 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
5688 {
5689 if (++anArgIter >= theArgNb)
5690 {
5691 std::cout << "Syntax error: id of Z layer is missing\n";
5692 return 1;
5693 }
5694
5695 aLayerId = Draw::Atoi (theArgVec[anArgIter]);
5696 }
5697
5698 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5699 printZLayerInfo (theDI, aSettings);
c5751993 5700 }
7c3ef2f7 5701 else if (anArg == "-enable"
5702 || anArg == "enable"
5703 || anArg == "-disable"
5704 || anArg == "disable")
83da37b1 5705 {
7c3ef2f7 5706 const Standard_Boolean toEnable = anArg == "-enable"
5707 || anArg == "enable";
5708 if (++anArgIter >= theArgNb)
5709 {
5710 std::cout << "Syntax error: option name is missing\n";
5711 return 1;
5712 }
c5751993 5713
7c3ef2f7 5714 TCollection_AsciiString aSubOp (theArgVec[anArgIter]);
5715 aSubOp.LowerCase();
5716 if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
5717 {
5718 if (++anArgIter >= theArgNb)
5719 {
5720 std::cout << "Syntax error: id of Z layer is missing\n";
5721 return 1;
5722 }
c5751993 5723
7c3ef2f7 5724 aLayerId = Draw::Atoi (theArgVec[anArgIter]);
5725 }
c5751993 5726
7c3ef2f7 5727 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayerId);
5728 if (aSubOp == "depthtest"
5729 || aSubOp == "test")
5730 {
5731 aSettings.SetEnableDepthTest (toEnable);
5732 }
5733 else if (aSubOp == "depthwrite"
5734 || aSubOp == "write")
5735 {
5736 aSettings.SetEnableDepthWrite (toEnable);
5737 }
5738 else if (aSubOp == "depthclear"
5739 || aSubOp == "clear")
5740 {
5741 aSettings.SetClearDepth (toEnable);
5742 }
5743 else if (aSubOp == "depthoffset"
5744 || aSubOp == "offset")
5745 {
5746 Graphic3d_PolygonOffset aParams;
5747 aParams.Mode = toEnable ? Aspect_POM_Fill : Aspect_POM_None;
5748 if (toEnable)
5749 {
5750 if (anArgIter + 2 >= theArgNb)
5751 {
5752 std::cout << "Syntax error: factor and units values for depth offset are missing\n";
5753 return 1;
5754 }
c5751993 5755
7c3ef2f7 5756 aParams.Factor = static_cast<Standard_ShortReal> (Draw::Atof (theArgVec[++anArgIter]));
5757 aParams.Units = static_cast<Standard_ShortReal> (Draw::Atof (theArgVec[++anArgIter]));
5758 }
5759 aSettings.SetPolygonOffset (aParams);
5760 }
5761 else if (aSubOp == "positiveoffset"
5762 || aSubOp == "poffset")
5763 {
5764 if (toEnable)
5765 {
5766 aSettings.SetDepthOffsetPositive();
5767 }
5768 else
5769 {
5770 aSettings.SetPolygonOffset (Graphic3d_PolygonOffset());
5771 }
5772 }
5773 else if (aSubOp == "negativeoffset"
5774 || aSubOp == "noffset")
5775 {
5776 if (toEnable)
5777 {
5778 aSettings.SetDepthOffsetNegative();
5779 }
5780 else
5781 {
5782 aSettings.SetPolygonOffset(Graphic3d_PolygonOffset());
5783 }
5784 }
5785 else if (aSubOp == "textureenv")
5786 {
5787 aSettings.SetEnvironmentTexture (toEnable);
5788 }
1c728f2d 5789 else if (aSubOp == "raytracing")
5790 {
5791 aSettings.SetRaytracable (toEnable);
5792 }
7c3ef2f7 5793
5794 aViewer->SetZLayerSettings (aLayerId, aSettings);
c5751993 5795 }
7c3ef2f7 5796 else
83da37b1 5797 {
7c3ef2f7 5798 std::cout << "Syntax error: unknown option " << theArgVec[anArgIter] << "\n";
5799 return 1;
83da37b1 5800 }
59f45b7c 5801 }
5802
5803 return 0;
5804}
5805
c357e426 5806// The interactive presentation of 2d layer item
5807// for "vlayerline" command it provides a presentation of
5808// line with user-defined linewidth, linetype and transparency.
61b0191c 5809class V3d_LineItem : public AIS_InteractiveObject
20637bd2 5810{
5811public:
5812 // CASCADE RTTI
92efcf78 5813 DEFINE_STANDARD_RTTI_INLINE(V3d_LineItem,AIS_InteractiveObject)
4fe56619 5814
20637bd2 5815 // constructor
5816 Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
5817 Standard_Real X2, Standard_Real Y2,
20637bd2 5818 Aspect_TypeOfLine theType = Aspect_TOL_SOLID,
5819 Standard_Real theWidth = 0.5,
5820 Standard_Real theTransp = 1.0);
5821
61b0191c 5822 private:
5823
5824 void Compute (const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
5825 const Handle(Prs3d_Presentation)& thePresentation,
79104795 5826 const Standard_Integer theMode) Standard_OVERRIDE;
61b0191c 5827
5828 void ComputeSelection (const Handle(SelectMgr_Selection)& /*aSelection*/,
79104795 5829 const Standard_Integer /*aMode*/) Standard_OVERRIDE
5830 {}
20637bd2 5831
5832private:
5833
5834 Standard_Real myX1, myY1, myX2, myY2;
eafb234b 5835 Aspect_TypeOfLine myType;
20637bd2 5836 Standard_Real myWidth;
20637bd2 5837};
5838
20637bd2 5839// default constructor for line item
4fe56619 5840V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
20637bd2 5841 Standard_Real X2, Standard_Real Y2,
20637bd2 5842 Aspect_TypeOfLine theType,
5843 Standard_Real theWidth,
5844 Standard_Real theTransp) :
61b0191c 5845 myX1(X1), myY1(Y1), myX2(X2), myY2(Y2),
5846 myType(theType), myWidth(theWidth)
20637bd2 5847{
61b0191c 5848 SetTransparency (1-theTransp);
20637bd2 5849}
5850
5851// render line
61b0191c 5852void V3d_LineItem::Compute (const Handle(PrsMgr_PresentationManager3d)& /*thePresentationManager*/,
5853 const Handle(Prs3d_Presentation)& thePresentation,
5854 const Standard_Integer /*theMode*/)
20637bd2 5855{
61b0191c 5856 thePresentation->Clear();
ba00aab7 5857 Quantity_Color aColor (Quantity_NOC_RED);
61b0191c 5858 Standard_Integer aWidth, aHeight;
5859 ViewerTest::CurrentView()->Window()->Size (aWidth, aHeight);
5860 Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (thePresentation);
5861 Handle(Graphic3d_ArrayOfPolylines) aPrim = new Graphic3d_ArrayOfPolylines(5);
5862 aPrim->AddVertex(myX1, aHeight-myY1, 0.);
5863 aPrim->AddVertex(myX2, aHeight-myY2, 0.);
5864 Handle(Prs3d_LineAspect) anAspect = new Prs3d_LineAspect (aColor, (Aspect_TypeOfLine)myType, myWidth);
5865 aGroup->SetPrimitivesAspect (anAspect->Aspect());
5866 aGroup->AddPrimitiveArray (aPrim);
20637bd2 5867}
5868
5869//=============================================================================
5870//function : VLayerLine
5871//purpose : Draws line in the v3d view layer with given attributes: linetype,
5872// : linewidth, transparency coefficient
5873//============================================================================
5874static int VLayerLine(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
5875{
5876 // get the active view
5877 Handle(V3d_View) aView = ViewerTest::CurrentView();
5878 if (aView.IsNull())
5879 {
5880 di << "Call vinit before!\n";
5881 return 1;
5882 }
5883 else if (argc < 5)
5884 {
5885 di << "Use: " << argv[0];
5886 di << " x1 y1 x2 y2 [linewidth = 0.5] [linetype = 0] [transparency = 1]\n";
5887 di << " linetype : { 0 | 1 | 2 | 3 } \n";
5888 di << " 0 - solid \n";
5889 di << " 1 - dashed \n";
5890 di << " 2 - dot \n";
5891 di << " 3 - dashdot\n";
5892 di << " transparency : { 0.0 - 1.0 } \n";
5893 di << " 0.0 - transparent\n";
5894 di << " 1.0 - visible \n";
5895 return 1;
5896 }
5897
61b0191c 5898 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
20637bd2 5899 // get the input params
91322f44 5900 Standard_Real X1 = Draw::Atof(argv[1]);
5901 Standard_Real Y1 = Draw::Atof(argv[2]);
5902 Standard_Real X2 = Draw::Atof(argv[3]);
5903 Standard_Real Y2 = Draw::Atof(argv[4]);
20637bd2 5904
3a4a3962 5905 Standard_Real aWidth = 0.5;
5906 Standard_Real aTransparency = 1.0;
20637bd2 5907
5908 // has width
5909 if (argc > 5)
91322f44 5910 aWidth = Draw::Atof(argv[5]);
20637bd2 5911
3a4a3962 5912 // select appropriate line type
5913 Aspect_TypeOfLine aLineType = Aspect_TOL_SOLID;
5914 if (argc > 6
5915 && !ViewerTest::ParseLineType (argv[6], aLineType))
5916 {
5917 std::cout << "Syntax error: unknown line type '" << argv[6] << "'\n";
5918 return 1;
5919 }
20637bd2 5920
5921 // has transparency
5922 if (argc > 7)
5923 {
91322f44 5924 aTransparency = Draw::Atof(argv[7]);
4fe56619 5925 if (aTransparency < 0 || aTransparency > 1.0)
20637bd2 5926 aTransparency = 1.0;
5927 }
5928
61b0191c 5929 static Handle (V3d_LineItem) aLine;
5930 if (!aLine.IsNull())
25289ec1 5931 {
0577ae8c 5932 aContext->Erase (aLine, Standard_False);
25289ec1 5933 }
61b0191c 5934 aLine = new V3d_LineItem (X1, Y1, X2, Y2,
5935 aLineType, aWidth,
5936 aTransparency);
25289ec1 5937
778cd667 5938 aContext->SetTransformPersistence (aLine, new Graphic3d_TransformPers (Graphic3d_TMF_2d, Aspect_TOTP_LEFT_LOWER));
61b0191c 5939 aLine->SetZLayer (Graphic3d_ZLayerId_TopOSD);
5940 aLine->SetToUpdate();
5941 aContext->Display (aLine, Standard_True);
25289ec1 5942
5943 return 0;
5944}
5945
61b0191c 5946
2bd4c032 5947//==============================================================================
5948//function : VGrid
5949//purpose :
5950//==============================================================================
5951
35e08fe8 5952static int VGrid (Draw_Interpretor& /*theDI*/,
2bd4c032 5953 Standard_Integer theArgNb,
5954 const char** theArgVec)
5955{
2bd4c032 5956 Handle(V3d_View) aView = ViewerTest::CurrentView();
5957 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
5958 if (aView.IsNull() || aViewer.IsNull())
5959 {
79931835 5960 std::cerr << "Error: no active view\n";
2bd4c032 5961 return 1;
5962 }
5963
5964 Aspect_GridType aType = aViewer->GridType();
5965 Aspect_GridDrawMode aMode = aViewer->GridDrawMode();
79931835 5966 Graphic3d_Vec2d aNewOriginXY, aNewStepXY, aNewSizeXY;
5967 Standard_Real aNewRotAngle = 0.0, aNewZOffset = 0.0;
5968 bool hasOrigin = false, hasStep = false, hasRotAngle = false, hasSize = false, hasZOffset = false;
224f48fa 5969 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
79931835 5970 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
2bd4c032 5971 {
79931835 5972 TCollection_AsciiString anArg (theArgVec[anArgIter]);
5973 anArg.LowerCase();
5974 if (anUpdateTool.parseRedrawMode (theArgVec[anArgIter]))
224f48fa 5975 {
5976 continue;
5977 }
79931835 5978 else if (anArgIter + 1 < theArgNb
5979 && anArg == "-type")
5980 {
5981 TCollection_AsciiString anArgNext (theArgVec[++anArgIter]);
5982 anArgNext.LowerCase();
5983 if (anArgNext == "r"
5984 || anArgNext == "rect"
5985 || anArgNext == "rectangular")
5986 {
5987 aType = Aspect_GT_Rectangular;
5988 }
5989 else if (anArgNext == "c"
5990 || anArgNext == "circ"
5991 || anArgNext == "circular")
5992 {
5993 aType = Aspect_GT_Circular;
5994 }
5995 else
5996 {
5997 std::cout << "Syntax error at '" << anArgNext << "'\n";
5998 return 1;
5999 }
6000 }
6001 else if (anArgIter + 1 < theArgNb
6002 && anArg == "-mode")
6003 {
6004 TCollection_AsciiString anArgNext (theArgVec[++anArgIter]);
6005 anArgNext.LowerCase();
6006 if (anArgNext == "l"
6007 || anArgNext == "line"
6008 || anArgNext == "lines")
6009 {
6010 aMode = Aspect_GDM_Lines;
6011 }
6012 else if (anArgNext == "p"
6013 || anArgNext == "point"
6014 || anArgNext == "points")
6015 {
6016 aMode = Aspect_GDM_Points;
6017 }
6018 else
6019 {
6020 std::cout << "Syntax error at '" << anArgNext << "'\n";
6021 return 1;
6022 }
6023 }
6024 else if (anArgIter + 2 < theArgNb
6025 && (anArg == "-origin"
6026 || anArg == "-orig"))
6027 {
6028 hasOrigin = true;
6029 aNewOriginXY.SetValues (Draw::Atof (theArgVec[anArgIter + 1]),
6030 Draw::Atof (theArgVec[anArgIter + 2]));
6031 anArgIter += 2;
6032 }
6033 else if (anArgIter + 2 < theArgNb
6034 && anArg == "-step")
6035 {
6036 hasStep = true;
6037 aNewStepXY.SetValues (Draw::Atof (theArgVec[anArgIter + 1]),
6038 Draw::Atof (theArgVec[anArgIter + 2]));
6039 if (aNewStepXY.x() <= 0.0
6040 || aNewStepXY.y() <= 0.0)
6041 {
6042 std::cout << "Syntax error: wrong step '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
6043 return 1;
6044 }
6045 anArgIter += 2;
6046 }
6047 else if (anArgIter + 1 < theArgNb
6048 && (anArg == "-angle"
6049 || anArg == "-rotangle"
6050 || anArg == "-rotationangle"))
6051 {
6052 hasRotAngle = true;
6053 aNewRotAngle = Draw::Atof (theArgVec[++anArgIter]);
6054 }
6055 else if (anArgIter + 1 < theArgNb
6056 && (anArg == "-zoffset"
6057 || anArg == "-dz"))
6058 {
6059 hasZOffset = true;
6060 aNewZOffset = Draw::Atof (theArgVec[++anArgIter]);
6061 }
6062 else if (anArgIter + 1 < theArgNb
6063 && anArg == "-radius")
6064 {
6065 hasSize = true;
6066 ++anArgIter;
6067 aNewSizeXY.SetValues (Draw::Atof (theArgVec[anArgIter]), 0.0);
6068 if (aNewStepXY.x() <= 0.0)
6069 {
6070 std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter] << "'\n";
6071 return 1;
6072 }
6073 }
6074 else if (anArgIter + 2 < theArgNb
6075 && anArg == "-size")
6076 {
6077 hasSize = true;
6078 aNewSizeXY.SetValues (Draw::Atof (theArgVec[anArgIter + 1]),
6079 Draw::Atof (theArgVec[anArgIter + 2]));
6080 if (aNewStepXY.x() <= 0.0
6081 || aNewStepXY.y() <= 0.0)
6082 {
6083 std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
6084 return 1;
6085 }
6086 anArgIter += 2;
6087 }
6088 else if (anArg == "r"
6089 || anArg == "rect"
6090 || anArg == "rectangular")
2bd4c032 6091 {
6092 aType = Aspect_GT_Rectangular;
6093 }
79931835 6094 else if (anArg == "c"
6095 || anArg == "circ"
6096 || anArg == "circular")
2bd4c032 6097 {
6098 aType = Aspect_GT_Circular;
6099 }
79931835 6100 else if (anArg == "l"
6101 || anArg == "line"
6102 || anArg == "lines")
2bd4c032 6103 {
6104 aMode = Aspect_GDM_Lines;
6105 }
79931835 6106 else if (anArg == "p"
6107 || anArg == "point"
6108 || anArg == "points")
2bd4c032 6109 {
6110 aMode = Aspect_GDM_Points;
6111 }
79931835 6112 else if (anArgIter + 1 >= theArgNb
6113 && anArg == "off")
2bd4c032 6114 {
6115 aViewer->DeactivateGrid();
6116 return 0;
6117 }
6118 else
6119 {
79931835 6120 std::cout << "Syntax error at '" << anArg << "'\n";
6121 return 1;
2bd4c032 6122 }
6123 }
6124
2bd4c032 6125 if (aType == Aspect_GT_Rectangular)
6126 {
79931835 6127 Graphic3d_Vec2d anOrigXY, aStepXY;
6128 Standard_Real aRotAngle = 0.0;
6129 aViewer->RectangularGridValues (anOrigXY.x(), anOrigXY.y(), aStepXY.x(), aStepXY.y(), aRotAngle);
6130 if (hasOrigin)
6131 {
6132 anOrigXY = aNewOriginXY;
6133 }
6134 if (hasStep)
6135 {
6136 aStepXY = aNewStepXY;
6137 }
6138 if (hasRotAngle)
6139 {
6140 aRotAngle = aNewRotAngle;
6141 }
6142 aViewer->SetRectangularGridValues (anOrigXY.x(), anOrigXY.y(), aStepXY.x(), aStepXY.y(), aRotAngle);
6143 if (hasSize || hasZOffset)
2bd4c032 6144 {
79931835 6145 Graphic3d_Vec3d aSize;
6146 aViewer->RectangularGridGraphicValues (aSize.x(), aSize.y(), aSize.z());
6147 if (hasSize)
6148 {
6149 aSize.x() = aNewSizeXY.x();
6150 aSize.y() = aNewSizeXY.y();
6151 }
6152 if (hasZOffset)
6153 {
6154 aSize.z() = aNewZOffset;
6155 }
6156 aViewer->SetRectangularGridGraphicValues (aSize.x(), aSize.y(), aSize.z());
2bd4c032 6157 }
2bd4c032 6158 }
6159 else if (aType == Aspect_GT_Circular)
6160 {
79931835 6161 Graphic3d_Vec2d anOrigXY;
ee2be2a8 6162 Standard_Real aRadiusStep;
2bd4c032 6163 Standard_Integer aDivisionNumber;
79931835 6164 Standard_Real aRotAngle = 0.0;
6165 aViewer->CircularGridValues (anOrigXY.x(), anOrigXY.y(), aRadiusStep, aDivisionNumber, aRotAngle);
6166 if (hasOrigin)
6167 {
6168 anOrigXY = aNewOriginXY;
6169 }
6170 if (hasStep)
6171 {
6172 aRadiusStep = aNewStepXY[0];
6173 aDivisionNumber = (int )aNewStepXY[1];
6174 if (aDivisionNumber < 1)
6175 {
6176 std::cout << "Syntax error: invalid division number '" << aNewStepXY[1] << "'\n";
6177 return 1;
6178 }
6179 }
6180 if (hasRotAngle)
2bd4c032 6181 {
79931835 6182 aRotAngle = aNewRotAngle;
2bd4c032 6183 }
6184
79931835 6185 aViewer->SetCircularGridValues (anOrigXY.x(), anOrigXY.y(), aRadiusStep, aDivisionNumber, aRotAngle);
6186 if (hasSize || hasZOffset)
6187 {
6188 Standard_Real aRadius = 0.0, aZOffset = 0.0;
6189 aViewer->CircularGridGraphicValues (aRadius, aZOffset);
6190 if (hasSize)
6191 {
6192 aRadius = aNewSizeXY.x();
6193 if (aNewSizeXY.y() != 0.0)
6194 {
6195 std::cout << "Syntax error: circular size should be specified as radius\n";
6196 return 1;
6197 }
6198 }
6199 if (hasZOffset)
6200 {
6201 aZOffset = aNewZOffset;
6202 }
6203 aViewer->SetCircularGridGraphicValues (aRadius, aZOffset);
6204 }
2bd4c032 6205 }
79931835 6206 aViewer->ActivateGrid (aType, aMode);
2bd4c032 6207 return 0;
6208}
6209
c40b7d58 6210//==============================================================================
6211//function : VPriviledgedPlane
6212//purpose :
6213//==============================================================================
6214
6215static int VPriviledgedPlane (Draw_Interpretor& theDI,
6216 Standard_Integer theArgNb,
6217 const char** theArgVec)
6218{
6219 if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
6220 {
6221 std::cerr << "Error: wrong number of arguments! See usage:\n";
6222 theDI.PrintHelp (theArgVec[0]);
6223 return 1;
6224 }
6225
6226 // get the active viewer
6227 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
6228 if (aViewer.IsNull())
6229 {
6230 std::cerr << "Error: no active viewer. Please call vinit.\n";
6231 return 1;
6232 }
6233
6234 if (theArgNb == 1)
6235 {
6236 gp_Ax3 aPriviledgedPlane = aViewer->PrivilegedPlane();
6237 const gp_Pnt& anOrig = aPriviledgedPlane.Location();
6238 const gp_Dir& aNorm = aPriviledgedPlane.Direction();
6239 const gp_Dir& aXDir = aPriviledgedPlane.XDirection();
6240 theDI << "Origin: " << anOrig.X() << " " << anOrig.Y() << " " << anOrig.Z() << " "
6241 << "Normal: " << aNorm.X() << " " << aNorm.Y() << " " << aNorm.Z() << " "
6242 << "X-dir: " << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
6243 return 0;
6244 }
6245
6246 Standard_Integer anArgIdx = 1;
6247 Standard_Real anOrigX = Draw::Atof (theArgVec[anArgIdx++]);
6248 Standard_Real anOrigY = Draw::Atof (theArgVec[anArgIdx++]);
6249 Standard_Real anOrigZ = Draw::Atof (theArgVec[anArgIdx++]);
6250 Standard_Real aNormX = Draw::Atof (theArgVec[anArgIdx++]);
6251 Standard_Real aNormY = Draw::Atof (theArgVec[anArgIdx++]);
6252 Standard_Real aNormZ = Draw::Atof (theArgVec[anArgIdx++]);
6253
6254 gp_Ax3 aPriviledgedPlane;
6255 gp_Pnt anOrig (anOrigX, anOrigY, anOrigZ);
6256 gp_Dir aNorm (aNormX, aNormY, aNormZ);
6257 if (theArgNb > 7)
6258 {
6259 Standard_Real aXDirX = Draw::Atof (theArgVec[anArgIdx++]);
6260 Standard_Real aXDirY = Draw::Atof (theArgVec[anArgIdx++]);
6261 Standard_Real aXDirZ = Draw::Atof (theArgVec[anArgIdx++]);
6262 gp_Dir aXDir (aXDirX, aXDirY, aXDirZ);
6263 aPriviledgedPlane = gp_Ax3 (anOrig, aNorm, aXDir);
6264 }
6265 else
6266 {
6267 aPriviledgedPlane = gp_Ax3 (anOrig, aNorm);
6268 }
6269
6270 aViewer->SetPrivilegedPlane (aPriviledgedPlane);
6271
6272 return 0;
6273}
6274
f25b82d6 6275//==============================================================================
6276//function : VConvert
6277//purpose :
6278//==============================================================================
6279
6280static int VConvert (Draw_Interpretor& theDI,
6281 Standard_Integer theArgNb,
6282 const char** theArgVec)
6283{
6284 // get the active view
6285 Handle(V3d_View) aView = ViewerTest::CurrentView();
6286 if (aView.IsNull())
6287 {
c40b7d58 6288 std::cerr << "Error: no active view. Please call vinit.\n";
f25b82d6 6289 return 1;
6290 }
6291
6292 enum { Model, Ray, View, Window, Grid } aMode = Model;
6293
6294 // access coordinate arguments
6295 TColStd_SequenceOfReal aCoord;
6296 Standard_Integer anArgIdx = 1;
6297 for (; anArgIdx < 4 && anArgIdx < theArgNb; ++anArgIdx)
6298 {
6299 TCollection_AsciiString anArg (theArgVec[anArgIdx]);
6300 if (!anArg.IsRealValue())
6301 {
6302 break;
6303 }
6304 aCoord.Append (anArg.RealValue());
6305 }
6306
6307 // non-numeric argument too early
6308 if (aCoord.IsEmpty())
6309 {
6310 std::cerr << "Error: wrong number of arguments! See usage:\n";
6311 theDI.PrintHelp (theArgVec[0]);
6312 return 1;
6313 }
6314
6315 // collect all other arguments and options
6316 for (; anArgIdx < theArgNb; ++anArgIdx)
6317 {
6318 TCollection_AsciiString anArg (theArgVec[anArgIdx]);
6319 anArg.LowerCase();
6320 if (anArg == "window") aMode = Window;
6321 else if (anArg == "view") aMode = View;
6322 else if (anArg == "grid") aMode = Grid;
6323 else if (anArg == "ray") aMode = Ray;
6324 else
6325 {
6326 std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
6327 theDI.PrintHelp (theArgVec[0]);
6328 return 1;
6329 }
6330 }
6331
6332 // complete input checks
6333 if ((aCoord.Length() == 1 && theArgNb > 3) ||
6334 (aCoord.Length() == 2 && theArgNb > 4) ||
6335 (aCoord.Length() == 3 && theArgNb > 5))
6336 {
6337 std::cerr << "Error: wrong number of arguments! See usage:\n";
6338 theDI.PrintHelp (theArgVec[0]);
6339 return 1;
6340 }
6341
6342 Standard_Real aXYZ[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
6343 Standard_Integer aXYp[2] = {0, 0};
6344
6345 // convert one-dimensional coordinate
6346 if (aCoord.Length() == 1)
6347 {
6348 switch (aMode)
6349 {
ee2be2a8 6350 case View : theDI << "View Vv: " << aView->Convert ((Standard_Integer)aCoord (1)); return 0;
6351 case Window : theDI << "Window Vp: " << aView->Convert (aCoord (1)); return 0;
f25b82d6 6352 default:
6353 std::cerr << "Error: wrong arguments! See usage:\n";
6354 theDI.PrintHelp (theArgVec[0]);
6355 return 1;
6356 }
6357 }
6358
6359 // convert 2D coordinates from projection or view reference space
6360 if (aCoord.Length() == 2)
6361 {
6362 switch (aMode)
6363 {
6364 case Model :
6365 aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
6366 theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
6367 return 0;
6368
6369 case View :
6370 aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1]);
6371 theDI << "View Xv,Yv: " << aXYZ[0] << " " << aXYZ[1] << "\n";
6372 return 0;
6373
6374 case Window :
ee2be2a8 6375 aView->Convert (aCoord (1), aCoord (2), aXYp[0], aXYp[1]);
f25b82d6 6376 theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
6377 return 0;
6378
6379 case Grid :
6380 aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
6381 aView->ConvertToGrid (aXYZ[0], aXYZ[1], aXYZ[2], aXYZ[3], aXYZ[4], aXYZ[5]);
6382 theDI << "Model X,Y,Z: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
6383 return 0;
6384
6385 case Ray :
6386 aView->ConvertWithProj ((Standard_Integer) aCoord (1),
6387 (Standard_Integer) aCoord (2),
6388 aXYZ[0], aXYZ[1], aXYZ[2],
6389 aXYZ[3], aXYZ[4], aXYZ[5]);
6390 theDI << "Model DX,DY,DZ: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
6391 return 0;
6392
6393 default:
6394 std::cerr << "Error: wrong arguments! See usage:\n";
6395 theDI.PrintHelp (theArgVec[0]);
6396 return 1;
6397 }
6398 }
6399
6400 // convert 3D coordinates from view reference space
6401 else if (aCoord.Length() == 3)
6402 {
6403 switch (aMode)
6404 {
6405 case Window :
6406 aView->Convert (aCoord (1), aCoord (2), aCoord (3), aXYp[0], aXYp[1]);
6407 theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
6408 return 0;
6409
6410 case Grid :
6411 aView->ConvertToGrid (aCoord (1), aCoord (2), aCoord (3), aXYZ[0], aXYZ[1], aXYZ[2]);
6412 theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
6413 return 0;
6414
6415 default:
6416 std::cerr << "Error: wrong arguments! See usage:\n";
6417 theDI.PrintHelp (theArgVec[0]);
6418 return 1;
6419 }
6420 }
6421
6422 return 0;
6423}
6424
208e6839 6425//==============================================================================
6426//function : VFps
6427//purpose :
6428//==============================================================================
6429
6430static int VFps (Draw_Interpretor& theDI,
6431 Standard_Integer theArgNb,
6432 const char** theArgVec)
6433{
6434 // get the active view
6435 Handle(V3d_View) aView = ViewerTest::CurrentView();
6436 if (aView.IsNull())
6437 {
6438 std::cerr << "No active view. Please call vinit.\n";
6439 return 1;
6440 }
6441
e084dbbc 6442 Standard_Integer aFramesNb = -1;
6443 Standard_Real aDuration = -1.0;
6444 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
208e6839 6445 {
e084dbbc 6446 TCollection_AsciiString anArg (theArgVec[anArgIter]);
6447 anArg.LowerCase();
6448 if (aDuration < 0.0
6449 && anArgIter + 1 < theArgNb
6450 && (anArg == "-duration"
6451 || anArg == "-dur"
6452 || anArg == "-time"))
6453 {
6454 aDuration = Draw::Atof (theArgVec[++anArgIter]);
6455 }
6456 else if (aFramesNb < 0
6457 && anArg.IsIntegerValue())
6458 {
6459 aFramesNb = anArg.IntegerValue();
6460 if (aFramesNb <= 0)
6461 {
6462 std::cerr << "Syntax error at '" << anArg << "'\n";
6463 return 1;
6464 }
6465 }
6466 else
6467 {
6468 std::cerr << "Syntax error at '" << anArg << "'\n";
6469 return 1;
6470 }
6471 }
6472 if (aFramesNb < 0 && aDuration < 0.0)
6473 {
6474 aFramesNb = 100;
208e6839 6475 }
6476
6477 // the time is meaningless for first call
6478 // due to async OpenGl rendering
6479 aView->Redraw();
6480
6481 // redraw view in loop to estimate average values
6482 OSD_Timer aTimer;
6483 aTimer.Start();
e084dbbc 6484 Standard_Integer aFrameIter = 1;
6485 for (;; ++aFrameIter)
208e6839 6486 {
6487 aView->Redraw();
e084dbbc 6488 if ((aFramesNb > 0
6489 && aFrameIter >= aFramesNb)
6490 || (aDuration > 0.0
6491 && aTimer.ElapsedTime() >= aDuration))
6492 {
6493 break;
6494 }
208e6839 6495 }
6496 aTimer.Stop();
6497 Standard_Real aCpu;
6498 const Standard_Real aTime = aTimer.ElapsedTime();
6499 aTimer.OSD_Chronometer::Show (aCpu);
6500
e084dbbc 6501 const Standard_Real aFpsAver = Standard_Real(aFrameIter) / aTime;
6502 const Standard_Real aCpuAver = aCpu / Standard_Real(aFrameIter);
208e6839 6503
6504 // return statistics
6505 theDI << "FPS: " << aFpsAver << "\n"
6506 << "CPU: " << (1000.0 * aCpuAver) << " msec\n";
6507
8c820969 6508 // compute additional statistics in ray-tracing mode
e084dbbc 6509 const Graphic3d_RenderingParams& aParams = aView->RenderingParams();
8c820969 6510 if (aParams.Method == Graphic3d_RM_RAYTRACING)
6511 {
e084dbbc 6512 Graphic3d_Vec2i aWinSize (0, 0);
6513 aView->Window()->Size (aWinSize.x(), aWinSize.y());
8c820969 6514
6515 // 1 shadow ray and 1 secondary ray pew each bounce
e084dbbc 6516 const Standard_Real aMRays = aWinSize.x() * aWinSize.y() * aFpsAver * aParams.RaytracingDepth * 2 / 1.0e6f;
8c820969 6517 theDI << "MRays/sec (upper bound): " << aMRays << "\n";
6518 }
6519
208e6839 6520 return 0;
6521}
6522
84e84755 6523//! Auxiliary function for parsing glsl dump level argument.
6524static Standard_Boolean parseGlslSourceFlag (Standard_CString theArg,
6525 OpenGl_ShaderProgramDumpLevel& theGlslDumpLevel)
6526{
6527 TCollection_AsciiString aTypeStr (theArg);
6528 aTypeStr.LowerCase();
6529 if (aTypeStr == "off"
6530 || aTypeStr == "0")
6531 {
6532 theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
6533 }
6534 else if (aTypeStr == "short")
6535 {
6536 theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Short;
6537 }
6538 else if (aTypeStr == "full"
6539 || aTypeStr == "1")
6540 {
6541 theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Full;
6542 }
6543 else
6544 {
6545 return Standard_False;
6546 }
6547 return Standard_True;
6548}
6549
58655684 6550//==============================================================================
6551//function : VGlDebug
6552//purpose :
6553//==============================================================================
6554
6555static int VGlDebug (Draw_Interpretor& theDI,
6556 Standard_Integer theArgNb,
6557 const char** theArgVec)
6558{
aaf512f1 6559 Handle(OpenGl_GraphicDriver) aDriver;
6560 Handle(V3d_View) aView = ViewerTest::CurrentView();
6561 if (!aView.IsNull())
6562 {
6563 aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aView->Viewer()->Driver());
6564 }
c87535af 6565 OpenGl_Caps* aDefCaps = &ViewerTest_myDefaultCaps;
6566 OpenGl_Caps* aCaps = !aDriver.IsNull() ? &aDriver->ChangeOptions() : NULL;
6567
58655684 6568 if (theArgNb < 2)
6569 {
c87535af 6570 TCollection_AsciiString aDebActive, aSyncActive;
6571 if (aCaps == NULL)
58655684 6572 {
c87535af 6573 aCaps = aDefCaps;
6574 }
6575 else
6576 {
6577 Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )::glGetString (GL_EXTENSIONS),
6578 "GL_ARB_debug_output");
6579 aDebActive = isActive ? " (active)" : " (inactive)";
6580 if (isActive)
6581 {
6582 // GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
6583 aSyncActive = ::glIsEnabled (0x8242) == GL_TRUE ? " (active)" : " (inactive)";
6584 }
58655684 6585 }
6586
84e84755 6587 TCollection_AsciiString aGlslCodeDebugStatus = TCollection_AsciiString()
6588 + "glslSourceCode: "
6589 + (aCaps->glslDumpLevel == OpenGl_ShaderProgramDumpLevel_Off
6590 ? "Off"
6591 : aCaps->glslDumpLevel == OpenGl_ShaderProgramDumpLevel_Short
6592 ? "Short"
6593 : "Full")
6594 + "\n";
6595 theDI << "debug: " << (aCaps->contextDebug ? "1" : "0") << aDebActive << "\n"
6596 << "sync: " << (aCaps->contextSyncDebug ? "1" : "0") << aSyncActive << "\n"
6597 << "glslWarn: " << (aCaps->glslWarnings ? "1" : "0") << "\n"
6598 << aGlslCodeDebugStatus
6599 << "extraMsg: " << (aCaps->suppressExtraMsg ? "0" : "1") << "\n";
58655684 6600 return 0;
6601 }
6602
c87535af 6603 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
aaf512f1 6604 {
c87535af 6605 Standard_CString anArg = theArgVec[anArgIter];
6606 TCollection_AsciiString anArgCase (anArg);
6607 anArgCase.LowerCase();
6608 Standard_Boolean toEnableDebug = Standard_True;
6609 if (anArgCase == "-glsl"
6610 || anArgCase == "-glslwarn"
6611 || anArgCase == "-glslwarns"
6612 || anArgCase == "-glslwarnings")
6613 {
6614 Standard_Boolean toShowWarns = Standard_True;
6615 if (++anArgIter < theArgNb
a5565a3c 6616 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShowWarns))
c87535af 6617 {
6618 --anArgIter;
6619 }
6620 aDefCaps->glslWarnings = toShowWarns;
6621 if (aCaps != NULL)
6622 {
6623 aCaps->glslWarnings = toShowWarns;
6624 }
6625 }
6626 else if (anArgCase == "-extra"
6627 || anArgCase == "-extramsg"
6628 || anArgCase == "-extramessages")
6629 {
6630 Standard_Boolean toShow = Standard_True;
6631 if (++anArgIter < theArgNb
a5565a3c 6632 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShow))
c87535af 6633 {
6634 --anArgIter;
6635 }
6636 aDefCaps->suppressExtraMsg = !toShow;
6637 if (aCaps != NULL)
6638 {
6639 aCaps->suppressExtraMsg = !toShow;
6640 }
6641 }
6642 else if (anArgCase == "-noextra"
6643 || anArgCase == "-noextramsg"
6644 || anArgCase == "-noextramessages")
6645 {
6646 Standard_Boolean toSuppress = Standard_True;
6647 if (++anArgIter < theArgNb
a5565a3c 6648 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSuppress))
c87535af 6649 {
6650 --anArgIter;
6651 }
6652 aDefCaps->suppressExtraMsg = toSuppress;
6653 if (aCaps != NULL)
6654 {
6655 aCaps->suppressExtraMsg = toSuppress;
6656 }
6657 }
6658 else if (anArgCase == "-sync")
6659 {
6660 Standard_Boolean toSync = Standard_True;
6661 if (++anArgIter < theArgNb
a5565a3c 6662 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSync))
c87535af 6663 {
6664 --anArgIter;
6665 }
6666 aDefCaps->contextSyncDebug = toSync;
6667 if (toSync)
6668 {
6669 aDefCaps->contextDebug = Standard_True;
6670 }
6671 }
84e84755 6672 else if (anArgCase == "-glslsourcecode"
6673 || anArgCase == "-glslcode")
6674 {
6675 OpenGl_ShaderProgramDumpLevel aGslsDumpLevel = OpenGl_ShaderProgramDumpLevel_Full;
6676 if (++anArgIter < theArgNb
6677 && !parseGlslSourceFlag (theArgVec[anArgIter], aGslsDumpLevel))
6678 {
6679 --anArgIter;
6680 }
6681 aDefCaps->glslDumpLevel = aGslsDumpLevel;
6682 if (aCaps != NULL)
6683 {
6684 aCaps->glslDumpLevel = aGslsDumpLevel;
6685 }
6686 }
c87535af 6687 else if (anArgCase == "-debug")
6688 {
6689 if (++anArgIter < theArgNb
a5565a3c 6690 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnableDebug))
c87535af 6691 {
6692 --anArgIter;
6693 }
6694 aDefCaps->contextDebug = toEnableDebug;
6695 }
a5565a3c 6696 else if (ViewerTest::ParseOnOff (anArg, toEnableDebug)
c87535af 6697 && (anArgIter + 1 == theArgNb))
6698 {
6699 // simple alias to turn on almost everything
6700 aDefCaps->contextDebug = toEnableDebug;
6701 aDefCaps->contextSyncDebug = toEnableDebug;
6702 aDefCaps->glslWarnings = toEnableDebug;
3b4c6945 6703 if (!toEnableDebug)
6704 {
6705 aDefCaps->glslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
6706 }
84e84755 6707 aDefCaps->suppressExtraMsg = !toEnableDebug;
6708 if (aCaps != NULL)
6709 {
6710 aCaps->contextDebug = toEnableDebug;
6711 aCaps->contextSyncDebug = toEnableDebug;
6712 aCaps->glslWarnings = toEnableDebug;
3b4c6945 6713 if (!toEnableDebug)
6714 {
6715 aCaps->glslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
6716 }
84e84755 6717 aCaps->suppressExtraMsg = !toEnableDebug;
6718 }
c87535af 6719 }
6720 else
6721 {
6722 std::cout << "Error: wrong syntax at '" << anArg << "'\n";
6723 return 1;
6724 }
aaf512f1 6725 }
6726
58655684 6727 return 0;
6728}
208e6839 6729
6730//==============================================================================
6731//function : VVbo
6732//purpose :
6733//==============================================================================
6734
58655684 6735static int VVbo (Draw_Interpretor& theDI,
208e6839 6736 Standard_Integer theArgNb,
6737 const char** theArgVec)
6738{
58655684 6739 const Standard_Boolean toSet = (theArgNb > 1);
6740 const Standard_Boolean toUseVbo = toSet ? (Draw::Atoi (theArgVec[1]) == 0) : 1;
6741 if (toSet)
208e6839 6742 {
58655684 6743 ViewerTest_myDefaultCaps.vboDisable = toUseVbo;
208e6839 6744 }
6745
58655684 6746 // get the context
6747 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
6748 if (aContextAIS.IsNull())
208e6839 6749 {
58655684 6750 if (!toSet)
6751 {
6752 std::cerr << "No active view!\n";
6753 }
208e6839 6754 return 1;
6755 }
58655684 6756 Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
6757 if (!aDriver.IsNull())
208e6839 6758 {
58655684 6759 if (!toSet)
6760 {
6761 theDI << (aDriver->Options().vboDisable ? "0" : "1") << "\n";
6762 }
6763 else
6764 {
6765 aDriver->ChangeOptions().vboDisable = toUseVbo;
6766 }
208e6839 6767 }
6768
208e6839 6769 return 0;
6770}
6771
a577aaab 6772//==============================================================================
6773//function : VCaps
6774//purpose :
6775//==============================================================================
6776
6777static int VCaps (Draw_Interpretor& theDI,
6778 Standard_Integer theArgNb,
6779 const char** theArgVec)
6780{
6781 OpenGl_Caps* aCaps = &ViewerTest_myDefaultCaps;
6782 Handle(OpenGl_GraphicDriver) aDriver;
8625ef7e 6783 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
6784 if (!aContext.IsNull())
a577aaab 6785 {
8625ef7e 6786 aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContext->CurrentViewer()->Driver());
a577aaab 6787 aCaps = &aDriver->ChangeOptions();
6788 }
6789
6790 if (theArgNb < 2)
6791 {
ba00aab7 6792 theDI << "sRGB: " << (aCaps->sRGBDisable ? "0" : "1") << "\n";
a577aaab 6793 theDI << "VBO: " << (aCaps->vboDisable ? "0" : "1") << "\n";
6794 theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
abe46077 6795 theDI << "SoftMode:" << (aCaps->contextNoAccel ? "1" : "0") << "\n";
8625ef7e 6796 theDI << "FFP: " << (aCaps->ffpEnable ? "1" : "0") << "\n";
2a332745 6797 theDI << "PolygonMode: " << (aCaps->usePolygonMode ? "1" : "0") << "\n";
f978241f 6798 theDI << "VSync: " << aCaps->swapInterval << "\n";
4e1523ef 6799 theDI << "Compatible:" << (aCaps->contextCompatible ? "1" : "0") << "\n";
f978241f 6800 theDI << "Stereo: " << (aCaps->contextStereo ? "1" : "0") << "\n";
56689b27 6801 theDI << "WinBuffer: " << (aCaps->useSystemBuffer ? "1" : "0") << "\n";
59515ca6 6802 theDI << "NoExt:" << (aCaps->contextNoExtensions ? "1" : "0") << "\n";
6803 theDI << "MaxVersion:" << aCaps->contextMajorVersionUpper << "." << aCaps->contextMinorVersionUpper << "\n";
a577aaab 6804 return 0;
6805 }
6806
8625ef7e 6807 ViewerTest_AutoUpdater anUpdateTool (aContext, ViewerTest::CurrentView());
a577aaab 6808 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
6809 {
8625ef7e 6810 Standard_CString anArg = theArgVec[anArgIter];
6811 TCollection_AsciiString anArgCase (anArg);
6812 anArgCase.LowerCase();
6813 if (anUpdateTool.parseRedrawMode (anArg))
6814 {
6815 continue;
6816 }
f978241f 6817 else if (anArgCase == "-vsync"
6818 || anArgCase == "-swapinterval")
6819 {
6820 Standard_Boolean toEnable = Standard_True;
6821 if (++anArgIter < theArgNb
a5565a3c 6822 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
f978241f 6823 {
6824 --anArgIter;
6825 }
6826 aCaps->swapInterval = toEnable;
6827 }
8625ef7e 6828 else if (anArgCase == "-ffp")
6829 {
6830 Standard_Boolean toEnable = Standard_True;
6831 if (++anArgIter < theArgNb
a5565a3c 6832 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8625ef7e 6833 {
6834 --anArgIter;
6835 }
6836 aCaps->ffpEnable = toEnable;
6837 }
2a332745 6838 else if (anArgCase == "-polygonmode")
6839 {
6840 Standard_Boolean toEnable = Standard_True;
6841 if (++anArgIter < theArgNb
6842 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
6843 {
6844 --anArgIter;
6845 }
6846 aCaps->usePolygonMode = toEnable;
6847 }
ba00aab7 6848 else if (anArgCase == "-srgb")
6849 {
6850 Standard_Boolean toEnable = Standard_True;
6851 if (++anArgIter < theArgNb
6852 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
6853 {
6854 --anArgIter;
6855 }
6856 aCaps->sRGBDisable = !toEnable;
6857 }
8625ef7e 6858 else if (anArgCase == "-vbo")
a577aaab 6859 {
8625ef7e 6860 Standard_Boolean toEnable = Standard_True;
6861 if (++anArgIter < theArgNb
a5565a3c 6862 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8625ef7e 6863 {
6864 --anArgIter;
6865 }
6866 aCaps->vboDisable = !toEnable;
a577aaab 6867 }
8625ef7e 6868 else if (anArgCase == "-sprite"
6869 || anArgCase == "-sprites")
a577aaab 6870 {
8625ef7e 6871 Standard_Boolean toEnable = Standard_True;
6872 if (++anArgIter < theArgNb
a5565a3c 6873 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8625ef7e 6874 {
6875 --anArgIter;
6876 }
6877 aCaps->pntSpritesDisable = !toEnable;
a577aaab 6878 }
8625ef7e 6879 else if (anArgCase == "-softmode")
abe46077 6880 {
8625ef7e 6881 Standard_Boolean toEnable = Standard_True;
6882 if (++anArgIter < theArgNb
a5565a3c 6883 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8625ef7e 6884 {
6885 --anArgIter;
6886 }
6887 aCaps->contextNoAccel = toEnable;
6888 }
56689b27 6889 else if (anArgCase == "-winbuffer"
6890 || anArgCase == "-windowbuffer"
6891 || anArgCase == "-usewinbuffer"
6892 || anArgCase == "-usewindowbuffer"
6893 || anArgCase == "-usesystembuffer")
6894 {
6895 Standard_Boolean toEnable = Standard_True;
6896 if (++anArgIter < theArgNb
6897 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
6898 {
6899 --anArgIter;
6900 }
6901 aCaps->useSystemBuffer = toEnable;
6902 }
8625ef7e 6903 else if (anArgCase == "-accel"
6904 || anArgCase == "-acceleration")
6905 {
6906 Standard_Boolean toEnable = Standard_True;
6907 if (++anArgIter < theArgNb
a5565a3c 6908 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8625ef7e 6909 {
6910 --anArgIter;
6911 }
6912 aCaps->contextNoAccel = !toEnable;
abe46077 6913 }
4e1523ef 6914 else if (anArgCase == "-compat"
6915 || anArgCase == "-compatprofile"
6916 || anArgCase == "-compatible"
6917 || anArgCase == "-compatibleprofile")
6918 {
6919 Standard_Boolean toEnable = Standard_True;
6920 if (++anArgIter < theArgNb
a5565a3c 6921 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
4e1523ef 6922 {
6923 --anArgIter;
6924 }
6925 aCaps->contextCompatible = toEnable;
6926 if (!aCaps->contextCompatible)
6927 {
6928 aCaps->ffpEnable = Standard_False;
6929 }
6930 }
6931 else if (anArgCase == "-core"
6932 || anArgCase == "-coreprofile")
6933 {
6934 Standard_Boolean toEnable = Standard_True;
6935 if (++anArgIter < theArgNb
a5565a3c 6936 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
4e1523ef 6937 {
6938 --anArgIter;
6939 }
6940 aCaps->contextCompatible = !toEnable;
6941 if (!aCaps->contextCompatible)
6942 {
6943 aCaps->ffpEnable = Standard_False;
6944 }
6945 }
f978241f 6946 else if (anArgCase == "-stereo"
6947 || anArgCase == "-quadbuffer")
6948 {
6949 Standard_Boolean toEnable = Standard_True;
6950 if (++anArgIter < theArgNb
a5565a3c 6951 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
f978241f 6952 {
6953 --anArgIter;
6954 }
6955 aCaps->contextStereo = toEnable;
6956 }
59515ca6 6957 else if (anArgCase == "-noext"
6958 || anArgCase == "-noextensions"
6959 || anArgCase == "-noextension")
6960 {
6961 Standard_Boolean toDisable = Standard_True;
6962 if (++anArgIter < theArgNb
6963 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toDisable))
6964 {
6965 --anArgIter;
6966 }
6967 aCaps->contextNoExtensions = toDisable;
6968 }
6969 else if (anArgCase == "-maxversion"
6970 || anArgCase == "-upperversion"
6971 || anArgCase == "-limitversion")
6972 {
6973 Standard_Integer aVer[2] = { -2, -1 };
6974 for (Standard_Integer aValIter = 0; aValIter < 2; ++aValIter)
6975 {
6976 if (anArgIter + 1 < theArgNb)
6977 {
6978 const TCollection_AsciiString aStr (theArgVec[anArgIter + 1]);
6979 if (aStr.IsIntegerValue())
6980 {
6981 aVer[aValIter] = aStr.IntegerValue();
6982 ++anArgIter;
6983 }
6984 }
6985 }
6986 if (aVer[0] < -1
6987 || aVer[1] < -1)
6988 {
6989 std::cout << "Syntax error at '" << anArgCase << "'\n";
6990 return 1;
6991 }
6992 aCaps->contextMajorVersionUpper = aVer[0];
6993 aCaps->contextMinorVersionUpper = aVer[1];
6994 }
a577aaab 6995 else
6996 {
8625ef7e 6997 std::cout << "Error: unknown argument '" << anArg << "'\n";
6998 return 1;
a577aaab 6999 }
7000 }
7001 if (aCaps != &ViewerTest_myDefaultCaps)
7002 {
7003 ViewerTest_myDefaultCaps = *aCaps;
7004 }
7005 return 0;
7006}
7007
f0430952 7008//==============================================================================
7009//function : VMemGpu
7010//purpose :
7011//==============================================================================
7012
7013static int VMemGpu (Draw_Interpretor& theDI,
7014 Standard_Integer theArgNb,
7015 const char** theArgVec)
7016{
7017 // get the context
7018 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
7019 if (aContextAIS.IsNull())
7020 {
7021 std::cerr << "No active view. Please call vinit.\n";
7022 return 1;
7023 }
7024
dc3fe572 7025 Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
f0430952 7026 if (aDriver.IsNull())
7027 {
7028 std::cerr << "Graphic driver not available.\n";
7029 return 1;
7030 }
7031
7032 Standard_Size aFreeBytes = 0;
7033 TCollection_AsciiString anInfo;
7034 if (!aDriver->MemoryInfo (aFreeBytes, anInfo))
7035 {
7036 std::cerr << "Information not available.\n";
7037 return 1;
7038 }
7039
7040 if (theArgNb > 1 && *theArgVec[1] == 'f')
7041 {
7042 theDI << Standard_Real (aFreeBytes);
7043 }
7044 else
7045 {
7046 theDI << anInfo;
7047 }
7048
7049 return 0;
7050}
7051
85e096c3 7052// ==============================================================================
7053// function : VReadPixel
7054// purpose :
7055// ==============================================================================
7056static int VReadPixel (Draw_Interpretor& theDI,
7057 Standard_Integer theArgNb,
7058 const char** theArgVec)
7059{
7060 // get the active view
7061 Handle(V3d_View) aView = ViewerTest::CurrentView();
7062 if (aView.IsNull())
7063 {
7064 std::cerr << "No active view. Please call vinit.\n";
7065 return 1;
7066 }
7067 else if (theArgNb < 3)
7068 {
7069 std::cerr << "Usage : " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]\n";
7070 return 1;
7071 }
7072
dc858f4c 7073 Image_Format aFormat = Image_Format_RGBA;
7074 Graphic3d_BufferType aBufferType = Graphic3d_BT_RGBA;
692613e5 7075
85e096c3 7076 Standard_Integer aWidth, aHeight;
7077 aView->Window()->Size (aWidth, aHeight);
91322f44 7078 const Standard_Integer anX = Draw::Atoi (theArgVec[1]);
7079 const Standard_Integer anY = Draw::Atoi (theArgVec[2]);
85e096c3 7080 if (anX < 0 || anX >= aWidth || anY < 0 || anY > aHeight)
7081 {
7082 std::cerr << "Pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")\n";
7083 return 1;
7084 }
7085
ba00aab7 7086 bool toShowName = false, toShowHls = false, toShowHex = false, toShow_sRGB = false;
85e096c3 7087 for (Standard_Integer anIter = 3; anIter < theArgNb; ++anIter)
7088 {
dc858f4c 7089 TCollection_AsciiString aParam (theArgVec[anIter]);
7090 aParam.LowerCase();
55c8f0f7 7091 if (aParam == "-rgb"
ba00aab7 7092 || aParam == "rgb"
7093 || aParam == "-srgb"
7094 || aParam == "srgb")
85e096c3 7095 {
dc858f4c 7096 aFormat = Image_Format_RGB;
692613e5 7097 aBufferType = Graphic3d_BT_RGB;
ba00aab7 7098 toShow_sRGB = aParam == "-srgb" || aParam == "srgb";
85e096c3 7099 }
55c8f0f7
BB		 7100 else if (aParam == "-hls"
7101 || aParam == "hls")
85e096c3 7102 {
dc858f4c 7103 aFormat = Image_Format_RGB;
692613e5 7104 aBufferType = Graphic3d_BT_RGB;
85e096c3 7105 toShowHls = Standard_True;
7106 }
55c8f0f7
BB		 7107 else if (aParam == "-rgbf"
7108 || aParam == "rgbf")
85e096c3 7109 {
dc858f4c 7110 aFormat = Image_Format_RGBF;
692613e5 7111 aBufferType = Graphic3d_BT_RGB;
85e096c3 7112 }
55c8f0f7 7113 else if (aParam == "-rgba"
ba00aab7 7114 || aParam == "rgba"
7115 || aParam == "-srgba"
7116 || aParam == "srgba")
85e096c3 7117 {
dc858f4c 7118 aFormat = Image_Format_RGBA;
692613e5 7119 aBufferType = Graphic3d_BT_RGBA;
ba00aab7 7120 toShow_sRGB = aParam == "-srgba" || aParam == "srgba";
85e096c3 7121 }
55c8f0f7
BB		 7122 else if (aParam == "-rgbaf"
7123 || aParam == "rgbaf")
85e096c3 7124 {
dc858f4c 7125 aFormat = Image_Format_RGBAF;
692613e5 7126 aBufferType = Graphic3d_BT_RGBA;
85e096c3 7127 }
55c8f0f7
BB		 7128 else if (aParam == "-depth"
7129 || aParam == "depth")
85e096c3 7130 {
dc858f4c 7131 aFormat = Image_Format_GrayF;
692613e5 7132 aBufferType = Graphic3d_BT_Depth;
85e096c3 7133 }
55c8f0f7
BB		 7134 else if (aParam == "-name"
7135 || aParam == "name")
85e096c3 7136 {
7137 toShowName = Standard_True;
7138 }
9196ea9d 7139 else if (aParam == "-hex"
7140 || aParam == "hex")
7141 {
7142 toShowHex = Standard_True;
7143 }
55c8f0f7
BB		 7144 else
7145 {
7146 std::cout << "Syntax error at '" << aParam << "'\n";
9196ea9d 7147 return 1;
55c8f0f7 7148 }
85e096c3 7149 }
7150
692613e5 7151 Image_PixMap anImage;
7152 if (!anImage.InitTrash (aFormat, aWidth, aHeight))
7153 {
7154 std::cerr << "Image allocation failed\n";
7155 return 1;
7156 }
7157 else if (!aView->ToPixMap (anImage, aWidth, aHeight, aBufferType))
85e096c3 7158 {
7159 std::cerr << "Image dump failed\n";
7160 return 1;
7161 }
7162
68beaa3c 7163 // redirect possible warning messages that could have been added by ToPixMap
7164 // into the Tcl interpretor (via DefaultMessenger) to cout, so that they do not
7165 // contaminate result of the command
7166 Standard_CString aWarnLog = theDI.Result();
7167 if (aWarnLog != NULL && aWarnLog[0] != '\0')
7168 {
7169 std::cout << aWarnLog << std::endl;
7170 }
7171 theDI.Reset();
7172
ba00aab7 7173 Quantity_ColorRGBA aColor = anImage.PixelColor (anX, anY, true);
85e096c3 7174 if (toShowName)
7175 {
692613e5 7176 if (aBufferType == Graphic3d_BT_RGBA)
85e096c3 7177 {
e958a649 7178 theDI << Quantity_Color::StringName (aColor.GetRGB().Name()) << " " << aColor.Alpha();
85e096c3 7179 }
7180 else
7181 {
e958a649 7182 theDI << Quantity_Color::StringName (aColor.GetRGB().Name());
85e096c3 7183 }
7184 }
9196ea9d 7185 else if (toShowHex)
7186 {
7187 if (aBufferType == Graphic3d_BT_RGBA)
7188 {
7189 theDI << Quantity_ColorRGBA::ColorToHex (aColor);
7190 }
7191 else
7192 {
7193 theDI << Quantity_Color::ColorToHex (aColor.GetRGB());
7194 }
7195 }
85e096c3 7196 else
7197 {
7198 switch (aBufferType)
7199 {
7200 default:
692613e5 7201 case Graphic3d_BT_RGB:
85e096c3 7202 {
7203 if (toShowHls)
7204 {
e958a649 7205 theDI << aColor.GetRGB().Hue() << " " << aColor.GetRGB().Light() << " " << aColor.GetRGB().Saturation();
85e096c3 7206 }
ba00aab7 7207 else if (toShow_sRGB)
7208 {
7209 const Graphic3d_Vec4 aColor_sRGB = Quantity_ColorRGBA::Convert_LinearRGB_To_sRGB ((Graphic3d_Vec4 )aColor);
7210 theDI << aColor_sRGB.r() << " " << aColor_sRGB.g() << " " << aColor_sRGB.b();
7211 }
85e096c3 7212 else
7213 {
e958a649 7214 theDI << aColor.GetRGB().Red() << " " << aColor.GetRGB().Green() << " " << aColor.GetRGB().Blue();
85e096c3 7215 }
7216 break;
7217 }
692613e5 7218 case Graphic3d_BT_RGBA:
85e096c3 7219 {
ba00aab7 7220 const Graphic3d_Vec4 aVec4 = toShow_sRGB ? Quantity_ColorRGBA::Convert_LinearRGB_To_sRGB ((Graphic3d_Vec4 )aColor) : (Graphic3d_Vec4 )aColor;
7221 theDI << aVec4.r() << " " << aVec4.g() << " " << aVec4.b() << " " << aVec4.a();
85e096c3 7222 break;
7223 }
692613e5 7224 case Graphic3d_BT_Depth:
85e096c3 7225 {
e958a649 7226 theDI << aColor.GetRGB().Red();
85e096c3 7227 break;
7228 }
7229 }
7230 }
7231
7232 return 0;
7233}
7234
fd3f6bd0 7235//! Auxiliary presentation for an image plane.
7236class ViewerTest_ImagePrs : public AIS_InteractiveObject
7237{
7238public:
7239 //! Main constructor.
7240 ViewerTest_ImagePrs (const Handle(Image_PixMap)& theImage,
7241 const Standard_Real theWidth,
7242 const Standard_Real theHeight,
7243 const TCollection_AsciiString& theLabel)
7244 : myLabel (theLabel), myWidth (theWidth), myHeight(theHeight)
7245 {
7246 SetDisplayMode (0);
7247 SetHilightMode (1);
7248 myDynHilightDrawer->SetZLayer (Graphic3d_ZLayerId_Topmost);
7249 {
7250 myDrawer->SetShadingAspect (new Prs3d_ShadingAspect());
7251 const Handle(Graphic3d_AspectFillArea3d)& aFillAspect = myDrawer->ShadingAspect()->Aspect();
7252 Graphic3d_MaterialAspect aMat;
7253 aMat.SetMaterialType (Graphic3d_MATERIAL_PHYSIC);
61168418 7254 aMat.SetAmbientColor (Quantity_NOC_BLACK);
7255 aMat.SetDiffuseColor (Quantity_NOC_WHITE);
7256 aMat.SetSpecularColor (Quantity_NOC_BLACK);
7257 aMat.SetEmissiveColor (Quantity_NOC_BLACK);
fd3f6bd0 7258 aFillAspect->SetFrontMaterial (aMat);
7259 aFillAspect->SetTextureMap (new Graphic3d_Texture2Dmanual (theImage));
7260 aFillAspect->SetTextureMapOn();
7261 }
7262 {
7263 Handle(Prs3d_TextAspect) aTextAspect = new Prs3d_TextAspect();
7264 aTextAspect->SetHorizontalJustification (Graphic3d_HTA_CENTER);
7265 aTextAspect->SetVerticalJustification (Graphic3d_VTA_CENTER);
7266 myDrawer->SetTextAspect (aTextAspect);
7267 }
7268 {
7269 const gp_Dir aNorm (0.0, 0.0, 1.0);
7270 myTris = new Graphic3d_ArrayOfTriangles (4, 6, true, false, true);
7271 myTris->AddVertex (gp_Pnt(-myWidth * 0.5, -myHeight * 0.5, 0.0), aNorm, gp_Pnt2d (0.0, 0.0));
7272 myTris->AddVertex (gp_Pnt( myWidth * 0.5, -myHeight * 0.5, 0.0), aNorm, gp_Pnt2d (1.0, 0.0));
7273 myTris->AddVertex (gp_Pnt(-myWidth * 0.5, myHeight * 0.5, 0.0), aNorm, gp_Pnt2d (0.0, 1.0));
7274 myTris->AddVertex (gp_Pnt( myWidth * 0.5, myHeight * 0.5, 0.0), aNorm, gp_Pnt2d (1.0, 1.0));
7275 myTris->AddEdge (1);
7276 myTris->AddEdge (2);
7277 myTris->AddEdge (3);
7278 myTris->AddEdge (3);
7279 myTris->AddEdge (2);
7280 myTris->AddEdge (4);
7281
7282 myRect = new Graphic3d_ArrayOfPolylines (4);
7283 myRect->AddVertex (myTris->Vertice (1));
7284 myRect->AddVertex (myTris->Vertice (3));
7285 myRect->AddVertex (myTris->Vertice (4));
7286 myRect->AddVertex (myTris->Vertice (2));
7287 }
7288 }
7289
7290 //! Returns TRUE for accepted display modes.
7291 virtual Standard_Boolean AcceptDisplayMode (const Standard_Integer theMode) const Standard_OVERRIDE { return theMode == 0 || theMode == 1; }
7292
7293 //! Compute presentation.
7294 virtual void Compute (const Handle(PrsMgr_PresentationManager3d)& , const Handle(Prs3d_Presentation)& thePrs, const Standard_Integer theMode) Standard_OVERRIDE
7295 {
7296 switch (theMode)
7297 {
7298 case 0:
7299 {
7300 Handle(Graphic3d_Group) aGroup = thePrs->NewGroup();
7301 aGroup->AddPrimitiveArray (myTris);
7302 aGroup->SetGroupPrimitivesAspect (myDrawer->ShadingAspect()->Aspect());
7303 aGroup->AddPrimitiveArray (myRect);
7304 aGroup->SetGroupPrimitivesAspect (myDrawer->LineAspect()->Aspect());
7305 return;
7306 }
7307 case 1:
7308 {
7309 Prs3d_Text::Draw (thePrs->NewGroup(), myDrawer->TextAspect(), myLabel, gp_Pnt(0.0, 0.0, 0.0));
7310 Handle(Graphic3d_Group) aGroup = thePrs->NewGroup();
7311 aGroup->AddPrimitiveArray (myRect);
7312 aGroup->SetGroupPrimitivesAspect (myDrawer->LineAspect()->Aspect());
7313 return;
7314 }
7315 }
7316 }
7317
7318 //! Compute selection.
7319 virtual void ComputeSelection (const Handle(SelectMgr_Selection)& theSel, const Standard_Integer theMode) Standard_OVERRIDE
7320 {
7321 if (theMode == 0)
7322 {
7323 Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner (this, 5);
7324 Handle(Select3D_SensitivePrimitiveArray) aSensitive = new Select3D_SensitivePrimitiveArray (anEntityOwner);
7325 aSensitive->InitTriangulation (myTris->Attributes(), myTris->Indices(), TopLoc_Location());
7326 theSel->Add (aSensitive);
7327 }
7328 }
7329
7330private:
7331 Handle(Graphic3d_ArrayOfTriangles) myTris;
7332 Handle(Graphic3d_ArrayOfPolylines) myRect;
7333 TCollection_AsciiString myLabel;
7334 Standard_Real myWidth;
7335 Standard_Real myHeight;
7336};
7337
692613e5 7338//==============================================================================
7339//function : VDiffImage
7340//purpose : The draw-command compares two images.
7341//==============================================================================
7342
7343static int VDiffImage (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
7344{
fd3f6bd0 7345 if (theArgNb < 3)
692613e5 7346 {
fd3f6bd0 7347 std::cout << "Syntax error: not enough arguments.\n";
692613e5 7348 return 1;
7349 }
7350
fd3f6bd0 7351 Standard_Integer anArgIter = 1;
7352 TCollection_AsciiString anImgPathRef (theArgVec[anArgIter++]);
7353 TCollection_AsciiString anImgPathNew (theArgVec[anArgIter++]);
7354 TCollection_AsciiString aDiffImagePath;
7355 Standard_Real aTolColor = -1.0;
7356 Standard_Integer toBlackWhite = -1;
7357 Standard_Integer isBorderFilterOn = -1;
7358 Standard_Boolean isOldSyntax = Standard_False;
7359 TCollection_AsciiString aViewName, aPrsNameRef, aPrsNameNew, aPrsNameDiff;
7360 for (; anArgIter < theArgNb; ++anArgIter)
7361 {
7362 TCollection_AsciiString anArg (theArgVec[anArgIter]);
7363 anArg.LowerCase();
7364 if (anArgIter + 1 < theArgNb
7365 && (anArg == "-toleranceofcolor"
7366 || anArg == "-tolerancecolor"
7367 || anArg == "-tolerance"
7368 || anArg == "-toler"))
7369 {
7370 aTolColor = Atof (theArgVec[++anArgIter]);
7371 if (aTolColor < 0.0 || aTolColor > 1.0)
7372 {
7373 std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
7374 return 1;
7375 }
7376 }
7377 else if (anArg == "-blackwhite")
7378 {
7379 Standard_Boolean toEnable = Standard_True;
7380 if (anArgIter + 1 < theArgNb
7381 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
7382 {
7383 ++anArgIter;
7384 }
7385 toBlackWhite = toEnable ? 1 : 0;
7386 }
7387 else if (anArg == "-borderfilter")
7388 {
7389 Standard_Boolean toEnable = Standard_True;
7390 if (anArgIter + 1 < theArgNb
7391 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
7392 {
7393 ++anArgIter;
7394 }
7395 isBorderFilterOn = toEnable ? 1 : 0;
7396 }
7397 else if (anArg == "-exitonclose")
7398 {
49582f9d 7399 ViewerTest_EventManager::ToExitOnCloseView() = true;
fd3f6bd0 7400 if (anArgIter + 1 < theArgNb
49582f9d 7401 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], ViewerTest_EventManager::ToExitOnCloseView()))
fd3f6bd0 7402 {
7403 ++anArgIter;
7404 }
7405 }
7406 else if (anArg == "-closeonescape"
7407 || anArg == "-closeonesc")
7408 {
49582f9d 7409 ViewerTest_EventManager::ToCloseViewOnEscape() = true;
fd3f6bd0 7410 if (anArgIter + 1 < theArgNb
49582f9d 7411 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], ViewerTest_EventManager::ToCloseViewOnEscape()))
fd3f6bd0 7412 {
7413 ++anArgIter;
7414 }
7415 }
7416 else if (anArgIter + 3 < theArgNb
7417 && anArg == "-display")
7418 {
7419 aViewName = theArgVec[++anArgIter];
7420 aPrsNameRef = theArgVec[++anArgIter];
7421 aPrsNameNew = theArgVec[++anArgIter];
7422 if (anArgIter + 1 < theArgNb
7423 && *theArgVec[anArgIter + 1] != '-')
7424 {
7425 aPrsNameDiff = theArgVec[++anArgIter];
7426 }
7427 }
7428 else if (aTolColor < 0.0
7429 && anArg.IsRealValue())
7430 {
7431 isOldSyntax = Standard_True;
7432 aTolColor = anArg.RealValue();
7433 if (aTolColor < 0.0 || aTolColor > 1.0)
7434 {
7435 std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
7436 return 1;
7437 }
7438 }
7439 else if (isOldSyntax
7440 && toBlackWhite == -1
7441 && (anArg == "0" || anArg == "1"))
7442 {
7443 toBlackWhite = anArg == "1" ? 1 : 0;
7444 }
7445 else if (isOldSyntax
7446 && isBorderFilterOn == -1
7447 && (anArg == "0" || anArg == "1"))
7448 {
7449 isBorderFilterOn = anArg == "1" ? 1 : 0;
7450 }
7451 else if (aDiffImagePath.IsEmpty())
7452 {
7453 aDiffImagePath = theArgVec[anArgIter];
7454 }
7455 else
7456 {
7457 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
7458 return 1;
7459 }
7460 }
692613e5 7461
fd3f6bd0 7462 Handle(Image_AlienPixMap) anImgRef = new Image_AlienPixMap();
7463 Handle(Image_AlienPixMap) anImgNew = new Image_AlienPixMap();
7464 if (!anImgRef->Load (anImgPathRef))
7465 {
7466 std::cout << "Error: image file '" << anImgPathRef << "' cannot be read\n";
7467 return 1;
7468 }
7469 if (!anImgNew->Load (anImgPathNew))
7470 {
7471 std::cout << "Error: image file '" << anImgPathNew << "' cannot be read\n";
7472 return 1;
7473 }
692613e5 7474
7475 // compare the images
7476 Image_Diff aComparer;
fd3f6bd0 7477 Standard_Integer aDiffColorsNb = -1;
7478 if (aComparer.Init (anImgRef, anImgNew, toBlackWhite == 1))
692613e5 7479 {
fd3f6bd0 7480 aComparer.SetColorTolerance (aTolColor >= 0.0 ? aTolColor : 0.0);
7481 aComparer.SetBorderFilterOn (isBorderFilterOn == 1);
7482 aDiffColorsNb = aComparer.Compare();
7483 theDI << aDiffColorsNb << "\n";
692613e5 7484 }
7485
692613e5 7486 // save image of difference
fd3f6bd0 7487 Handle(Image_AlienPixMap) aDiff;
7488 if (aDiffColorsNb > 0
7489 && (!aDiffImagePath.IsEmpty() || !aPrsNameDiff.IsEmpty()))
7490 {
7491 aDiff = new Image_AlienPixMap();
7492 if (!aDiff->InitTrash (Image_Format_Gray, anImgRef->SizeX(), anImgRef->SizeY()))
7493 {
7494 std::cout << "Error: cannot allocate memory for diff image " << anImgRef->SizeX() << "x" << anImgRef->SizeY() << "\n";
7495 return 1;
7496 }
7497 aComparer.SaveDiffImage (*aDiff);
7498 if (!aDiffImagePath.IsEmpty()
7499 && !aDiff->Save (aDiffImagePath))
7500 {
7501 std::cout << "Error: diff image file '" << aDiffImagePath << "' cannot be written\n";
7502 return 1;
7503 }
7504 }
7505
7506 if (aViewName.IsEmpty())
7507 {
7508 return 0;
7509 }
7510
7511 ViewerTest_Names aViewNames (aViewName);
7512 if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
7513 {
7514 TCollection_AsciiString aCommand = TCollection_AsciiString ("vclose ") + aViewNames.GetViewName();
7515 theDI.Eval (aCommand.ToCString());
7516 }
7517
7518 Standard_Integer aPxLeft = 0;
7519 Standard_Integer aPxTop = 0;
7520 Standard_Integer aWinSizeX = int(anImgRef->SizeX() * 2);
7521 Standard_Integer aWinSizeY = !aDiff.IsNull() && !aPrsNameDiff.IsEmpty()
7522 ? int(anImgRef->SizeY() * 2)
7523 : int(anImgRef->SizeY());
7524 TCollection_AsciiString aDisplayName;
9e04ccdc 7525 TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aWinSizeX, aWinSizeY,
7526 aViewName, aDisplayName);
fd3f6bd0 7527
7528 Standard_Real aRatio = anImgRef->Ratio();
7529 Standard_Real aSizeX = 1.0;
7530 Standard_Real aSizeY = aSizeX / aRatio;
692613e5 7531 {
fd3f6bd0 7532 OSD_Path aPath (anImgPathRef);
7533 TCollection_AsciiString aLabelRef;
7534 if (!aPath.Name().IsEmpty())
7535 {
7536 aLabelRef = aPath.Name() + aPath.Extension();
7537 }
7538 aLabelRef += TCollection_AsciiString() + "\n" + int(anImgRef->SizeX()) + "x" + int(anImgRef->SizeY());
7539
7540 Handle(ViewerTest_ImagePrs) anImgRefPrs = new ViewerTest_ImagePrs (anImgRef, aSizeX, aSizeY, aLabelRef);
7541 gp_Trsf aTrsfRef;
7542 aTrsfRef.SetTranslationPart (gp_Vec (-aSizeX * 0.5, 0.0, 0.0));
7543 anImgRefPrs->SetLocalTransformation (aTrsfRef);
7544 ViewerTest::Display (aPrsNameRef, anImgRefPrs, false, true);
692613e5 7545 }
fd3f6bd0 7546 {
7547 OSD_Path aPath (anImgPathNew);
7548 TCollection_AsciiString aLabelNew;
7549 if (!aPath.Name().IsEmpty())
7550 {
7551 aLabelNew = aPath.Name() + aPath.Extension();
7552 }
7553 aLabelNew += TCollection_AsciiString() + "\n" + int(anImgNew->SizeX()) + "x" + int(anImgNew->SizeY());
692613e5 7554
fd3f6bd0 7555 Handle(ViewerTest_ImagePrs) anImgNewPrs = new ViewerTest_ImagePrs (anImgNew, aSizeX, aSizeY, aLabelNew);
7556 gp_Trsf aTrsfRef;
7557 aTrsfRef.SetTranslationPart (gp_Vec (aSizeX * 0.5, 0.0, 0.0));
7558 anImgNewPrs->SetLocalTransformation (aTrsfRef);
7559 ViewerTest::Display (aPrsNameNew, anImgNewPrs, false, true);
7560 }
7561 Handle(ViewerTest_ImagePrs) anImgDiffPrs;
7562 if (!aDiff.IsNull())
7563 {
7564 anImgDiffPrs = new ViewerTest_ImagePrs (aDiff, aSizeX, aSizeY, TCollection_AsciiString() + "Difference: " + aDiffColorsNb + " pixels");
7565 gp_Trsf aTrsfDiff;
7566 aTrsfDiff.SetTranslationPart (gp_Vec (0.0, -aSizeY, 0.0));
7567 anImgDiffPrs->SetLocalTransformation (aTrsfDiff);
7568 }
7569 if (!aPrsNameDiff.IsEmpty())
7570 {
7571 ViewerTest::Display (aPrsNameDiff, anImgDiffPrs, false, true);
7572 }
7573 ViewerTest::CurrentView()->SetProj (V3d_Zpos);
7574 ViewerTest::CurrentView()->FitAll();
692613e5 7575 return 0;
7576}
7577
4754e164 7578//=======================================================================
7579//function : VSelect
7580//purpose : Emulates different types of selection by mouse:
7581// 1) single click selection
7582// 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)
7583// 3) selection with polygon having corners at
dc3fe572 7584// pixel positions (x1,y1),...,(xn,yn)
4754e164 7585// 4) any of these selections with shift button pressed
7586//=======================================================================
49582f9d 7587static Standard_Integer VSelect (Draw_Interpretor& ,
7588 Standard_Integer theNbArgs,
7589 const char** theArgVec)
4754e164 7590{
49582f9d 7591 const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
7592 if (aCtx.IsNull())
4754e164 7593 {
49582f9d 7594 std::cout << "Error: no active View\n";
4754e164 7595 return 1;
7596 }
2157d6ac 7597
49582f9d 7598 NCollection_Sequence<Graphic3d_Vec2i> aPnts;
7599 bool isShiftSelection = false, toAllowOverlap = false;
7600 for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
2157d6ac 7601 {
49582f9d 7602 TCollection_AsciiString anArg (theArgVec[anArgIter]);
7603 anArg.LowerCase();
7604 if (anArg == "-allowoverlap")
7605 {
7606 toAllowOverlap = true;
7607 if (anArgIter + 1 < theNbArgs
7608 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toAllowOverlap))
7609 {
7610 ++anArgIter;
7611 }
7612 }
7613 else if (anArgIter + 1 < theNbArgs
7614 && anArg.IsIntegerValue()
7615 && TCollection_AsciiString (theArgVec[anArgIter + 1]).IsIntegerValue())
2157d6ac 7616 {
49582f9d 7617 const TCollection_AsciiString anArgNext (theArgVec[++anArgIter]);
7618 aPnts.Append (Graphic3d_Vec2i (anArg.IntegerValue(), anArgNext.IntegerValue()));
7619 }
7620 else if (anArgIter + 1 == theNbArgs
7621 && anArg.IsIntegerValue())
7622 {
7623 isShiftSelection = anArg.IntegerValue() == 1;
7624 }
7625 else
7626 {
7627 std::cout << "Syntax error at '" << anArg << "'\n";
2157d6ac 7628 return 1;
7629 }
49582f9d 7630 }
7631 if (toAllowOverlap
7632 && aPnts.Length() != 2)
7633 {
7634 std::cout << "Syntax error: -allowoverlap key is applied only for rectangle selection\n";
7635 return 1;
7636 }
7637 if (toAllowOverlap)
7638 {
7639 aCtx->MainSelector()->AllowOverlapDetection (toAllowOverlap);
2157d6ac 7640 }
7641
4754e164 7642 Handle(ViewerTest_EventManager) aCurrentEventManager = ViewerTest::CurrentEventManager();
49582f9d 7643 if (aPnts.IsEmpty())
4754e164 7644 {
49582f9d 7645 if (isShiftSelection)
7646 {
7647 aCtx->ShiftSelect (false);
7648 }
4754e164 7649 else
49582f9d 7650 {
7651 aCtx->Select (false);
7652 }
7653 aCtx->CurrentViewer()->Invalidate();
4754e164 7654 }
49582f9d 7655 else if (aPnts.Length() == 2)
4754e164 7656 {
49582f9d 7657 if (toAllowOverlap
7658 && aPnts.First().y() < aPnts.Last().y())
7659 {
7660 std::swap (aPnts.ChangeFirst(), aPnts.ChangeLast());
7661 }
7662 else if (!toAllowOverlap
7663 && aPnts.First().y() > aPnts.Last().y())
7664 {
7665 std::swap (aPnts.ChangeFirst(), aPnts.ChangeLast());
7666 }
7667 aCurrentEventManager->SelectInViewer (aPnts, isShiftSelection);
4754e164 7668 }
7669 else
7670 {
49582f9d 7671 aCurrentEventManager->SelectInViewer (aPnts, isShiftSelection);
4754e164 7672 }
49582f9d 7673 aCurrentEventManager->FlushViewEvents (aCtx, ViewerTest::CurrentView(), true);
4754e164 7674 return 0;
7675}
7676
7677//=======================================================================
7678//function : VMoveTo
dc3fe572 7679//purpose : Emulates cursor movement to defined pixel position
4754e164 7680//=======================================================================
1e756cb9 7681static Standard_Integer VMoveTo (Draw_Interpretor& theDI,
8a590580 7682 Standard_Integer theNbArgs,
7683 const char** theArgVec)
4754e164 7684{
8a590580 7685 const Handle(AIS_InteractiveContext)& aContext = ViewerTest::GetAISContext();
7686 const Handle(V3d_View)& aView = ViewerTest::CurrentView();
7687 if (aContext.IsNull())
4754e164 7688 {
8a590580 7689 std::cout << "Error: no active View\n";
4754e164 7690 return 1;
7691 }
7692
8a590580 7693 Graphic3d_Vec2i aMousePos (IntegerLast(), IntegerLast());
7694 for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
4754e164 7695 {
8a590580 7696 TCollection_AsciiString anArgStr (theArgVec[anArgIter]);
7697 anArgStr.LowerCase();
7698 if (anArgStr == "-reset"
7699 || anArgStr == "-clear")
7700 {
7701 if (anArgIter + 1 < theNbArgs)
7702 {
7703 std::cout << "Syntax error at '" << theArgVec[anArgIter + 1] << "'\n";
7704 return 1;
7705 }
7706
7707 const Standard_Boolean toEchoGrid = aContext->CurrentViewer()->Grid()->IsActive()
7708 && aContext->CurrentViewer()->GridEcho();
7709 if (toEchoGrid)
7710 {
7711 aContext->CurrentViewer()->HideGridEcho (aView);
7712 }
7713 if (aContext->ClearDetected() || toEchoGrid)
7714 {
7715 aContext->CurrentViewer()->RedrawImmediate();
7716 }
7717 return 0;
7718 }
7719 else if (aMousePos.x() == IntegerLast()
7720 && anArgStr.IsIntegerValue())
7721 {
7722 aMousePos.x() = anArgStr.IntegerValue();
7723 }
7724 else if (aMousePos.y() == IntegerLast()
7725 && anArgStr.IsIntegerValue())
7726 {
7727 aMousePos.y() = anArgStr.IntegerValue();
7728 }
7729 else
7730 {
7731 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
7732 return 1;
7733 }
7734 }
7735
7736 if (aMousePos.x() == IntegerLast()
7737 || aMousePos.y() == IntegerLast())
7738 {
7739 std::cout << "Syntax error: wrong number of arguments\n";
4754e164 7740 return 1;
7741 }
8a590580 7742
49582f9d 7743 ViewerTest::CurrentEventManager()->ResetPreviousMoveTo();
7744 ViewerTest::CurrentEventManager()->UpdateMousePosition (aMousePos, Aspect_VKeyMouse_NONE, Aspect_VKeyFlags_NONE, false);
7745 ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), aView, true);
7746
1e756cb9 7747 gp_Pnt aTopPnt (RealLast(), RealLast(), RealLast());
7748 const Handle(SelectMgr_EntityOwner)& aDetOwner = aContext->DetectedOwner();
7749 for (Standard_Integer aDetIter = 1; aDetIter <= aContext->MainSelector()->NbPicked(); ++aDetIter)
7750 {
7751 if (aContext->MainSelector()->Picked (aDetIter) == aDetOwner)
7752 {
7753 aTopPnt = aContext->MainSelector()->PickedPoint (aDetIter);
7754 break;
7755 }
7756 }
7757 theDI << aTopPnt.X() << " " << aTopPnt.Y() << " " << aTopPnt.Z();
4754e164 7758 return 0;
7759}
7760
1beb58d7 7761namespace
7762{
7763 //! Global map storing all animations registered in ViewerTest.
7764 static NCollection_DataMap<TCollection_AsciiString, Handle(AIS_Animation)> ViewerTest_AnimationTimelineMap;
7765
7766 //! The animation calling the Draw Harness command.
7767 class ViewerTest_AnimationProc : public AIS_Animation
7768 {
7769 public:
7770
7771 //! Main constructor.
7772 ViewerTest_AnimationProc (const TCollection_AsciiString& theAnimationName,
7773 Draw_Interpretor* theDI,
7774 const TCollection_AsciiString& theCommand)
7775 : AIS_Animation (theAnimationName),
7776 myDrawInter(theDI),
7777 myCommand (theCommand)
7778 {
7779 //
7780 }
7781
7782 protected:
7783
7784 //! Evaluate the command.
7785 virtual void update (const AIS_AnimationProgress& theProgress) Standard_OVERRIDE
7786 {
7787 TCollection_AsciiString aCmd = myCommand;
7788 replace (aCmd, "%pts", TCollection_AsciiString(theProgress.Pts));
7789 replace (aCmd, "%localpts", TCollection_AsciiString(theProgress.LocalPts));
7790 replace (aCmd, "%ptslocal", TCollection_AsciiString(theProgress.LocalPts));
7791 replace (aCmd, "%normalized", TCollection_AsciiString(theProgress.LocalNormalized));
7792 replace (aCmd, "%localnormalized", TCollection_AsciiString(theProgress.LocalNormalized));
7793 myDrawInter->Eval (aCmd.ToCString());
7794 }
7795
7796 //! Find the keyword in the command and replace it with value.
7797 //! @return the position of the keyword to pass value
7798 void replace (TCollection_AsciiString& theCmd,
7799 const TCollection_AsciiString& theKey,
7800 const TCollection_AsciiString& theVal)
7801 {
7802 TCollection_AsciiString aCmd (theCmd);
7803 aCmd.LowerCase();
7804 const Standard_Integer aPos = aCmd.Search (theKey);
7805 if (aPos == -1)
7806 {
7807 return;
7808 }
7809
7810 TCollection_AsciiString aPart1, aPart2;
7811 Standard_Integer aPart1To = aPos - 1;
7812 if (aPart1To >= 1
7813 && aPart1To <= theCmd.Length())
7814 {
7815 aPart1 = theCmd.SubString (1, aPart1To);
7816 }
7817
7818 Standard_Integer aPart2From = aPos + theKey.Length();
7819 if (aPart2From >= 1
7820 && aPart2From <= theCmd.Length())
7821 {
7822 aPart2 = theCmd.SubString (aPart2From, theCmd.Length());
7823 }
7824
7825 theCmd = aPart1 + theVal + aPart2;
7826 }
7827
7828 protected:
7829
7830 Draw_Interpretor* myDrawInter;
7831 TCollection_AsciiString myCommand;
7832
7833 };
7834
7835 //! Replace the animation with the new one.
7836 static void replaceAnimation (const Handle(AIS_Animation)& theParentAnimation,
7837 Handle(AIS_Animation)& theAnimation,
7838 const Handle(AIS_Animation)& theAnimationNew)
7839 {
7840 theAnimationNew->CopyFrom (theAnimation);
7841 if (!theParentAnimation.IsNull())
7842 {
7843 theParentAnimation->Replace (theAnimation, theAnimationNew);
7844 }
7845 else
7846 {
7847 ViewerTest_AnimationTimelineMap.UnBind (theAnimationNew->Name());
7848 ViewerTest_AnimationTimelineMap.Bind (theAnimationNew->Name(), theAnimationNew);
7849 }
7850 theAnimation = theAnimationNew;
7851 }
7852
7853 //! Parse the point.
7854 static Standard_Boolean parseXYZ (const char** theArgVec, gp_XYZ& thePnt)
7855 {
7856 const TCollection_AsciiString anXYZ[3] = { theArgVec[0], theArgVec[1], theArgVec[2] };
7857 if (!anXYZ[0].IsRealValue()
7858 || !anXYZ[1].IsRealValue()
7859 || !anXYZ[2].IsRealValue())
7860 {
7861 return Standard_False;
7862 }
7863
7864 thePnt.SetCoord (anXYZ[0].RealValue(), anXYZ[1].RealValue(), anXYZ[2].RealValue());
7865 return Standard_True;
7866 }
7867
7868 //! Parse the quaternion.
7869 static Standard_Boolean parseQuaternion (const char** theArgVec, gp_Quaternion& theQRot)
7870 {
7871 const TCollection_AsciiString anXYZW[4] = {theArgVec[0], theArgVec[1], theArgVec[2], theArgVec[3]};
7872 if (!anXYZW[0].IsRealValue()
7873 || !anXYZW[1].IsRealValue()
7874 || !anXYZW[2].IsRealValue()
7875 || !anXYZW[3].IsRealValue())
7876 {
7877 return Standard_False;
7878 }
7879
7880 theQRot.Set (anXYZW[0].RealValue(), anXYZW[1].RealValue(), anXYZW[2].RealValue(), anXYZW[3].RealValue());
7881 return Standard_True;
7882 }
7883
08f8a185 7884 //! Auxiliary class for flipping image upside-down.
7885 class ImageFlipper
7886 {
7887 public:
7888
7889 //! Empty constructor.
7890 ImageFlipper() : myTmp (NCollection_BaseAllocator::CommonBaseAllocator()) {}
7891
7892 //! Perform flipping.
7893 Standard_Boolean FlipY (Image_PixMap& theImage)
7894 {
7895 if (theImage.IsEmpty()
7896 || theImage.SizeX() == 0
7897 || theImage.SizeY() == 0)
7898 {
7899 return Standard_False;
7900 }
7901
7902 const Standard_Size aRowSize = theImage.SizeRowBytes();
7903 if (myTmp.Size() < aRowSize
7904 && !myTmp.Allocate (aRowSize))
7905 {
7906 return Standard_False;
7907 }
7908
7909 // for odd height middle row should be left as is
7910 Standard_Size aNbRowsHalf = theImage.SizeY() / 2;
7911 for (Standard_Size aRowT = 0, aRowB = theImage.SizeY() - 1; aRowT < aNbRowsHalf; ++aRowT, --aRowB)
7912 {
7913 Standard_Byte* aTop = theImage.ChangeRow (aRowT);
7914 Standard_Byte* aBot = theImage.ChangeRow (aRowB);
7915 memcpy (myTmp.ChangeData(), aTop, aRowSize);
7916 memcpy (aTop, aBot, aRowSize);
7917 memcpy (aBot, myTmp.Data(), aRowSize);
7918 }
7919 return Standard_True;
7920 }
7921
7922 private:
7923 NCollection_Buffer myTmp;
7924 };
7925
1beb58d7 7926}
7927
197ac94e 7928//=================================================================================================
4754e164 7929//function : VViewParams
dc3fe572 7930//purpose : Gets or sets AIS View characteristics
197ac94e 7931//=================================================================================================
7932static int VViewParams (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
4754e164 7933{
1beb58d7 7934 Handle(V3d_View) aView = ViewerTest::CurrentView();
7935 if (aView.IsNull())
4754e164 7936 {
197ac94e 7937 std::cout << theArgVec[0] << ": please initialize or activate view.\n";
4754e164 7938 return 1;
7939 }
197ac94e 7940
1beb58d7 7941 Standard_Boolean toSetProj = Standard_False;
7942 Standard_Boolean toSetUp = Standard_False;
7943 Standard_Boolean toSetAt = Standard_False;
7944 Standard_Boolean toSetEye = Standard_False;
7945 Standard_Boolean toSetScale = Standard_False;
7946 Standard_Boolean toSetSize = Standard_False;
7947 Standard_Boolean toSetCenter2d = Standard_False;
ee2be2a8 7948 Standard_Real aViewScale = aView->Scale();
7949 Standard_Real aViewSize = 1.0;
1beb58d7 7950 Graphic3d_Vec2i aCenter2d;
7951 gp_XYZ aViewProj, aViewUp, aViewAt, aViewEye;
7952 aView->Proj (aViewProj.ChangeCoord (1), aViewProj.ChangeCoord (2), aViewProj.ChangeCoord (3));
7953 aView->Up (aViewUp .ChangeCoord (1), aViewUp .ChangeCoord (2), aViewUp .ChangeCoord (3));
7954 aView->At (aViewAt .ChangeCoord (1), aViewAt .ChangeCoord (2), aViewAt .ChangeCoord (3));
7955 aView->Eye (aViewEye .ChangeCoord (1), aViewEye .ChangeCoord (2), aViewEye .ChangeCoord (3));
197ac94e 7956 if (theArgsNb == 1)
4754e164 7957 {
197ac94e 7958 // print all of the available view parameters
1beb58d7 7959 char aText[4096];
7960 Sprintf (aText,
7961 "Scale: %g\n"
7962 "Proj: %12g %12g %12g\n"
7963 "Up: %12g %12g %12g\n"
7964 "At: %12g %12g %12g\n"
7965 "Eye: %12g %12g %12g\n",
7966 aViewScale,
7967 aViewProj.X(), aViewProj.Y(), aViewProj.Z(),
7968 aViewUp.X(), aViewUp.Y(), aViewUp.Z(),
7969 aViewAt.X(), aViewAt.Y(), aViewAt.Z(),
7970 aViewEye.X(), aViewEye.Y(), aViewEye.Z());
7971 theDi << aText;
197ac94e 7972 return 0;
4754e164 7973 }
197ac94e 7974
1beb58d7 7975 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
7976 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
197ac94e 7977 {
1beb58d7 7978 TCollection_AsciiString anArg (theArgVec[anArgIter]);
7979 anArg.LowerCase();
7980 if (anUpdateTool.parseRedrawMode (anArg))
197ac94e 7981 {
197ac94e 7982 continue;
7983 }
1beb58d7 7984 else if (anArg == "-cmd"
7985 || anArg == "-command"
7986 || anArg == "-args")
7987 {
7988 char aText[4096];
7989 Sprintf (aText,
7990 "-scale %g "
7991 "-proj %g %g %g "
7992 "-up %g %g %g "
7993 "-at %g %g %g\n",
7994 aViewScale,
7995 aViewProj.X(), aViewProj.Y(), aViewProj.Z(),
7996 aViewUp.X(), aViewUp.Y(), aViewUp.Z(),
7997 aViewAt.X(), aViewAt.Y(), aViewAt.Z());
7998 theDi << aText;
7999 }
8000 else if (anArg == "-scale"
8001 || anArg == "-size")
8002 {
8003 if (anArgIter + 1 < theArgsNb
8004 && *theArgVec[anArgIter + 1] != '-')
8005 {
8006 const TCollection_AsciiString aValueArg (theArgVec[anArgIter + 1]);
8007 if (aValueArg.IsRealValue())
8008 {
8009 ++anArgIter;
8010 if (anArg == "-scale")
8011 {
8012 toSetScale = Standard_True;
8013 aViewScale = aValueArg.RealValue();
8014 }
8015 else if (anArg == "-size")
8016 {
8017 toSetSize = Standard_True;
8018 aViewSize = aValueArg.RealValue();
8019 }
8020 continue;
8021 }
8022 }
8023 if (anArg == "-scale")
8024 {
8025 theDi << "Scale: " << aView->Scale() << "\n";
8026 }
8027 else if (anArg == "-size")
8028 {
8029 Graphic3d_Vec2d aSizeXY;
8030 aView->Size (aSizeXY.x(), aSizeXY.y());
8031 theDi << "Size: " << aSizeXY.x() << " " << aSizeXY.y() << "\n";
8032 }
8033 }
8034 else if (anArg == "-eye"
8035 || anArg == "-at"
8036 || anArg == "-up"
8037 || anArg == "-proj")
8038 {
8039 if (anArgIter + 3 < theArgsNb)
8040 {
8041 gp_XYZ anXYZ;
8042 if (parseXYZ (theArgVec + anArgIter + 1, anXYZ))
8043 {
8044 anArgIter += 3;
8045 if (anArg == "-eye")
8046 {
8047 toSetEye = Standard_True;
8048 aViewEye = anXYZ;
8049 }
8050 else if (anArg == "-at")
8051 {
8052 toSetAt = Standard_True;
8053 aViewAt = anXYZ;
8054 }
8055 else if (anArg == "-up")
8056 {
8057 toSetUp = Standard_True;
8058 aViewUp = anXYZ;
8059 }
8060 else if (anArg == "-proj")
8061 {
8062 toSetProj = Standard_True;
8063 aViewProj = anXYZ;
8064 }
8065 continue;
8066 }
8067 }
197ac94e 8068
1beb58d7 8069 if (anArg == "-eye")
8070 {
8071 theDi << "Eye: " << aViewEye.X() << " " << aViewEye.Y() << " " << aViewEye.Z() << "\n";
8072 }
8073 else if (anArg == "-at")
8074 {
8075 theDi << "At: " << aViewAt.X() << " " << aViewAt.Y() << " " << aViewAt.Z() << "\n";
8076 }
8077 else if (anArg == "-up")
8078 {
8079 theDi << "Up: " << aViewUp.X() << " " << aViewUp.Y() << " " << aViewUp.Z() << "\n";
8080 }
8081 else if (anArg == "-proj")
8082 {
8083 theDi << "Proj: " << aViewProj.X() << " " << aViewProj.Y() << " " << aViewProj.Z() << "\n";
8084 }
8085 }
8086 else if (anArg == "-center")
3dfe95cd 8087 {
1beb58d7 8088 if (anArgIter + 2 < theArgsNb)
8089 {
8090 const TCollection_AsciiString anX (theArgVec[anArgIter + 1]);
8091 const TCollection_AsciiString anY (theArgVec[anArgIter + 2]);
8092 if (anX.IsIntegerValue()
8093 && anY.IsIntegerValue())
8094 {
8095 toSetCenter2d = Standard_True;
8096 aCenter2d = Graphic3d_Vec2i (anX.IntegerValue(), anY.IntegerValue());
8097 }
8098 }
8099 }
8100 else
8101 {
8102 std::cout << "Syntax error at '" << anArg << "'\n";
3dfe95cd 8103 return 1;
8104 }
1beb58d7 8105 }
3dfe95cd 8106
1beb58d7 8107 // change view parameters in proper order
8108 if (toSetScale)
8109 {
8110 aView->SetScale (aViewScale);
8111 }
8112 if (toSetSize)
8113 {
8114 aView->SetSize (aViewSize);
8115 }
8116 if (toSetEye)
8117 {
8118 aView->SetEye (aViewEye.X(), aViewEye.Y(), aViewEye.Z());
8119 }
8120 if (toSetAt)
8121 {
8122 aView->SetAt (aViewAt.X(), aViewAt.Y(), aViewAt.Z());
8123 }
8124 if (toSetProj)
8125 {
8126 aView->SetProj (aViewProj.X(), aViewProj.Y(), aViewProj.Z());
8127 }
8128 if (toSetUp)
8129 {
8130 aView->SetUp (aViewUp.X(), aViewUp.Y(), aViewUp.Z());
8131 }
8132 if (toSetCenter2d)
8133 {
8134 aView->SetCenter (aCenter2d.x(), aCenter2d.y());
197ac94e 8135 }
8136
1beb58d7 8137 return 0;
8138}
197ac94e 8139
2e93433e 8140//==============================================================================
8141//function : V2DMode
8142//purpose :
8143//==============================================================================
8144static Standard_Integer V2DMode (Draw_Interpretor&, Standard_Integer theArgsNb, const char** theArgVec)
8145{
8146 bool is2dMode = true;
8147 Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest::CurrentView());
8148 if (aV3dView.IsNull())
8149 {
8150 std::cout << "Error: no active view.\n";
8151 return 1;
8152 }
8153 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
8154 {
8155 const TCollection_AsciiString anArg = theArgVec[anArgIt];
8156 TCollection_AsciiString anArgCase = anArg;
8157 anArgCase.LowerCase();
8158 if (anArgIt + 1 < theArgsNb
8159 && anArgCase == "-name")
8160 {
8161 ViewerTest_Names aViewNames (theArgVec[++anArgIt]);
8162 TCollection_AsciiString aViewName = aViewNames.GetViewName();
8163 if (!ViewerTest_myViews.IsBound1 (aViewName))
8164 {
8165 std::cout << "Syntax error: unknown view '" << theArgVec[anArgIt - 1] << "'.\n";
8166 return 1;
8167 }
8168 aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest_myViews.Find1 (aViewName));
8169 }
8170 else if (anArgCase == "-mode")
8171 {
8172 if (anArgIt + 1 < theArgsNb
8173 && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], is2dMode))
8174 {
8175 ++anArgIt;
8176 }
8177 }
8178 else if (ViewerTest::ParseOnOff (theArgVec[anArgIt], is2dMode))
8179 {
8180 //
8181 }
8182 else
8183 {
8184 std::cout << "Syntax error: unknown argument " << anArg << ".\n";
8185 return 1;
8186 }
8187 }
8188
8189 aV3dView->SetView2DMode (is2dMode);
8190 return 0;
8191}
8192
1beb58d7 8193//==============================================================================
8194//function : VAnimation
8195//purpose :
8196//==============================================================================
8197static Standard_Integer VAnimation (Draw_Interpretor& theDI,
8198 Standard_Integer theArgNb,
8199 const char** theArgVec)
8200{
8201 Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
8202 if (theArgNb < 2)
4754e164 8203 {
1beb58d7 8204 for (NCollection_DataMap<TCollection_AsciiString, Handle(AIS_Animation)>::Iterator
8205 anAnimIter (ViewerTest_AnimationTimelineMap); anAnimIter.More(); anAnimIter.Next())
8206 {
8207 theDI << anAnimIter.Key() << " " << anAnimIter.Value()->Duration() << " sec\n";
197ac94e 8208 }
1beb58d7 8209 return 0;
8210 }
8211 if (aCtx.IsNull())
8212 {
8213 std::cout << "Error: no active view\n";
8214 return 1;
4754e164 8215 }
197ac94e 8216
1beb58d7 8217 Standard_Integer anArgIter = 1;
8218 TCollection_AsciiString aNameArg (theArgVec[anArgIter++]);
8219 if (aNameArg.IsEmpty())
8220 {
8221 std::cout << "Syntax error: animation name is not defined.\n";
8222 return 1;
8223 }
8224
8225 TCollection_AsciiString aNameArgLower = aNameArg;
8226 aNameArgLower.LowerCase();
8227 if (aNameArgLower == "-reset"
8228 || aNameArgLower == "-clear")
8229 {
8230 ViewerTest_AnimationTimelineMap.Clear();
8231 return 0;
8232 }
8233 else if (aNameArg.Value (1) == '-')
8234 {
8235 std::cout << "Syntax error: invalid animation name '" << aNameArg << "'.\n";
8236 return 1;
8237 }
197ac94e 8238
1beb58d7 8239 const char* aNameSplitter = "/";
8240 Standard_Integer aSplitPos = aNameArg.Search (aNameSplitter);
8241 if (aSplitPos == -1)
197ac94e 8242 {
1beb58d7 8243 aNameSplitter = ".";
8244 aSplitPos = aNameArg.Search (aNameSplitter);
8245 }
8246
8247 // find existing or create a new animation by specified name within syntax "parent.child".
8248 Handle(AIS_Animation) aRootAnimation, aParentAnimation, anAnimation;
8249 for (; !aNameArg.IsEmpty();)
8250 {
8251 TCollection_AsciiString aNameParent;
8252 if (aSplitPos != -1)
197ac94e 8253 {
1beb58d7 8254 if (aSplitPos == aNameArg.Length())
8255 {
8256 std::cout << "Syntax error: animation name is not defined.\n";
8257 return 1;
8258 }
8259
8260 aNameParent = aNameArg.SubString ( 1, aSplitPos - 1);
8261 aNameArg = aNameArg.SubString (aSplitPos + 1, aNameArg.Length());
8262
8263 aSplitPos = aNameArg.Search (aNameSplitter);
197ac94e 8264 }
8265 else
8266 {
1beb58d7 8267 aNameParent = aNameArg;
8268 aNameArg.Clear();
197ac94e 8269 }
1beb58d7 8270
8271 if (anAnimation.IsNull())
3dfe95cd 8272 {
1beb58d7 8273 if (!ViewerTest_AnimationTimelineMap.Find (aNameParent, anAnimation))
8274 {
8275 anAnimation = new AIS_Animation (aNameParent);
8276 ViewerTest_AnimationTimelineMap.Bind (aNameParent, anAnimation);
8277 }
8278 aRootAnimation = anAnimation;
3dfe95cd 8279 }
8280 else
8281 {
1beb58d7 8282 aParentAnimation = anAnimation;
8283 anAnimation = aParentAnimation->Find (aNameParent);
8284 if (anAnimation.IsNull())
8285 {
8286 anAnimation = new AIS_Animation (aNameParent);
8287 aParentAnimation->Add (anAnimation);
8288 }
3dfe95cd 8289 }
8290 }
1beb58d7 8291
8292 if (anArgIter >= theArgNb)
197ac94e 8293 {
1beb58d7 8294 // just print the list of children
8295 for (NCollection_Sequence<Handle(AIS_Animation)>::Iterator anAnimIter (anAnimation->Children()); anAnimIter.More(); anAnimIter.Next())
197ac94e 8296 {
1beb58d7 8297 theDI << anAnimIter.Value()->Name() << " " << anAnimIter.Value()->Duration() << " sec\n";
197ac94e 8298 }
1beb58d7 8299 return 0;
197ac94e 8300 }
1beb58d7 8301
bf7b2ceb 8302 // animation parameters
1beb58d7 8303 Standard_Boolean toPlay = Standard_False;
8304 Standard_Real aPlaySpeed = 1.0;
8305 Standard_Real aPlayStartTime = anAnimation->StartPts();
8306 Standard_Real aPlayDuration = anAnimation->Duration();
1beb58d7 8307 Standard_Boolean isFreeCamera = Standard_False;
8308 Standard_Boolean isLockLoop = Standard_False;
08f8a185 8309
8310 // video recording parameters
8311 TCollection_AsciiString aRecFile;
8312 Image_VideoParams aRecParams;
8313
1beb58d7 8314 Handle(V3d_View) aView = ViewerTest::CurrentView();
8315 for (; anArgIter < theArgNb; ++anArgIter)
197ac94e 8316 {
1beb58d7 8317 TCollection_AsciiString anArg (theArgVec[anArgIter]);
8318 anArg.LowerCase();
bf7b2ceb 8319 // general options
1beb58d7 8320 if (anArg == "-reset"
8321 || anArg == "-clear")
197ac94e 8322 {
1beb58d7 8323 anAnimation->Clear();
8324 }
8325 else if (anArg == "-remove"
8326 || anArg == "-del"
8327 || anArg == "-delete")
8328 {
8329 if (!aParentAnimation.IsNull())
8330 {
8331 ViewerTest_AnimationTimelineMap.UnBind (anAnimation->Name());
8332 }
8333 else
8334 {
8335 aParentAnimation->Remove (anAnimation);
8336 }
8337 }
bf7b2ceb 8338 // playback options
1beb58d7 8339 else if (anArg == "-play")
8340 {
8341 toPlay = Standard_True;
8342 if (++anArgIter < theArgNb)
8343 {
8344 if (*theArgVec[anArgIter] == '-')
8345 {
8346 --anArgIter;
8347 continue;
8348 }
8349 aPlayStartTime = Draw::Atof (theArgVec[anArgIter]);
8350
8351 if (++anArgIter < theArgNb)
8352 {
8353 if (*theArgVec[anArgIter] == '-')
8354 {
8355 --anArgIter;
8356 continue;
8357 }
8358 aPlayDuration = Draw::Atof (theArgVec[anArgIter]);
8359 }
8360 }
8361 }
8362 else if (anArg == "-resume")
8363 {
8364 toPlay = Standard_True;
8365 aPlayStartTime = anAnimation->ElapsedTime();
8366 if (++anArgIter < theArgNb)
8367 {
8368 if (*theArgVec[anArgIter] == '-')
8369 {
8370 --anArgIter;
8371 continue;
8372 }
8373
8374 aPlayDuration = Draw::Atof (theArgVec[anArgIter]);
8375 }
8376 }
8377 else if (anArg == "-playspeed"
8378 || anArg == "-speed")
8379 {
8380 if (++anArgIter >= theArgNb)
8381 {
8382 std::cout << "Syntax error at " << anArg << ".\n";
8383 return 1;
8384 }
8385 aPlaySpeed = Draw::Atof (theArgVec[anArgIter]);
8386 }
8387 else if (anArg == "-lock"
8388 || anArg == "-lockloop"
8389 || anArg == "-playlockloop")
8390 {
8391 isLockLoop = Standard_True;
8392 }
8393 else if (anArg == "-freecamera"
8394 || anArg == "-playfreecamera"
8395 || anArg == "-freelook")
8396 {
8397 isFreeCamera = Standard_True;
8398 }
08f8a185 8399 // video recodring options
8400 else if (anArg == "-rec"
8401 || anArg == "-record")
8402 {
8403 if (++anArgIter >= theArgNb)
8404 {
8405 std::cout << "Syntax error at " << anArg << ".\n";
8406 return 1;
8407 }
8408
8409 aRecFile = theArgVec[anArgIter];
8410 if (aRecParams.FpsNum <= 0)
8411 {
8412 aRecParams.FpsNum = 24;
8413 }
8414
8415 if (anArgIter + 2 < theArgNb
8416 && *theArgVec[anArgIter + 1] != '-'
8417 && *theArgVec[anArgIter + 2] != '-')
8418 {
8419 TCollection_AsciiString aWidthArg (theArgVec[anArgIter + 1]);
8420 TCollection_AsciiString aHeightArg (theArgVec[anArgIter + 2]);
8421 if (aWidthArg .IsIntegerValue()
8422 && aHeightArg.IsIntegerValue())
8423 {
8424 aRecParams.Width = aWidthArg .IntegerValue();
8425 aRecParams.Height = aHeightArg.IntegerValue();
8426 anArgIter += 2;
8427 }
8428 }
8429 }
1beb58d7 8430 else if (anArg == "-fps")
8431 {
8432 if (++anArgIter >= theArgNb)
8433 {
8434 std::cout << "Syntax error at " << anArg << ".\n";
8435 return 1;
8436 }
bf7b2ceb 8437
8438 TCollection_AsciiString aFpsArg (theArgVec[anArgIter]);
8439 Standard_Integer aSplitIndex = aFpsArg.FirstLocationInSet ("/", 1, aFpsArg.Length());
8440 if (aSplitIndex == 0)
8441 {
08f8a185 8442 aRecParams.FpsNum = aFpsArg.IntegerValue();
bf7b2ceb 8443 }
8444 else
8445 {
8446 const TCollection_AsciiString aDenStr = aFpsArg.Split (aSplitIndex);
8447 aFpsArg.Split (aFpsArg.Length() - 1);
8448 const TCollection_AsciiString aNumStr = aFpsArg;
08f8a185 8449 aRecParams.FpsNum = aNumStr.IntegerValue();
8450 aRecParams.FpsDen = aDenStr.IntegerValue();
8451 if (aRecParams.FpsDen < 1)
bf7b2ceb 8452 {
8453 std::cout << "Syntax error at " << anArg << ".\n";
8454 return 1;
8455 }
8456 }
1beb58d7 8457 }
08f8a185 8458 else if (anArg == "-format")
8459 {
8460 if (++anArgIter >= theArgNb)
8461 {
8462 std::cout << "Syntax error at " << anArg << ".\n";
8463 return 1;
8464 }
8465 aRecParams.Format = theArgVec[anArgIter];
8466 }
8467 else if (anArg == "-pix_fmt"
8468 || anArg == "-pixfmt"
8469 || anArg == "-pixelformat")
8470 {
8471 if (++anArgIter >= theArgNb)
8472 {
8473 std::cout << "Syntax error at " << anArg << ".\n";
8474 return 1;
8475 }
8476 aRecParams.PixelFormat = theArgVec[anArgIter];
8477 }
8478 else if (anArg == "-codec"
8479 || anArg == "-vcodec"
8480 || anArg == "-videocodec")
8481 {
8482 if (++anArgIter >= theArgNb)
8483 {
8484 std::cout << "Syntax error at " << anArg << ".\n";
8485 return 1;
8486 }
8487 aRecParams.VideoCodec = theArgVec[anArgIter];
8488 }
8489 else if (anArg == "-crf"
8490 || anArg == "-preset"
8491 || anArg == "-qp")
8492 {
8493 const TCollection_AsciiString aParamName = anArg.SubString (2, anArg.Length());
8494 if (++anArgIter >= theArgNb)
8495 {
8496 std::cout << "Syntax error at " << anArg << ".\n";
8497 return 1;
8498 }
8499
8500 aRecParams.VideoCodecParams.Bind (aParamName, theArgVec[anArgIter]);
8501 }
bf7b2ceb 8502 // animation definition options
1beb58d7 8503 else if (anArg == "-start"
8504 || anArg == "-starttime"
8505 || anArg == "-startpts")
8506 {
8507 if (++anArgIter >= theArgNb)
8508 {
8509 std::cout << "Syntax error at " << anArg << ".\n";
8510 return 1;
8511 }
8512
8513 anAnimation->SetStartPts (Draw::Atof (theArgVec[anArgIter]));
8514 aRootAnimation->UpdateTotalDuration();
8515 }
8516 else if (anArg == "-end"
8517 || anArg == "-endtime"
8518 || anArg == "-endpts")
8519 {
8520 if (++anArgIter >= theArgNb)
8521 {
8522 std::cout << "Syntax error at " << anArg << ".\n";
8523 return 1;
8524 }
8525
8526 anAnimation->SetOwnDuration (Draw::Atof (theArgVec[anArgIter]) - anAnimation->StartPts());
8527 aRootAnimation->UpdateTotalDuration();
8528 }
8529 else if (anArg == "-dur"
8530 || anArg == "-duration")
8531 {
8532 if (++anArgIter >= theArgNb)
8533 {
8534 std::cout << "Syntax error at " << anArg << ".\n";
8535 return 1;
8536 }
8537
8538 anAnimation->SetOwnDuration (Draw::Atof (theArgVec[anArgIter]));
8539 aRootAnimation->UpdateTotalDuration();
8540 }
8541 else if (anArg == "-command"
8542 || anArg == "-cmd"
8543 || anArg == "-invoke"
8544 || anArg == "-eval"
8545 || anArg == "-proc")
8546 {
8547 if (++anArgIter >= theArgNb)
8548 {
8549 std::cout << "Syntax error at " << anArg << ".\n";
8550 return 1;
8551 }
8552
8553 Handle(ViewerTest_AnimationProc) aCmdAnimation = new ViewerTest_AnimationProc (anAnimation->Name(), &theDI, theArgVec[anArgIter]);
8554 replaceAnimation (aParentAnimation, anAnimation, aCmdAnimation);
8555 }
8556 else if (anArg == "-objecttrsf"
8557 || anArg == "-objectransformation"
8558 || anArg == "-objtransformation"
8559 || anArg == "-objtrsf"
8560 || anArg == "-object"
8561 || anArg == "-obj")
8562 {
8563 if (++anArgIter >= theArgNb)
8564 {
8565 std::cout << "Syntax error at " << anArg << ".\n";
8566 return 1;
8567 }
8568
8569 TCollection_AsciiString anObjName (theArgVec[anArgIter]);
8570 const ViewerTest_DoubleMapOfInteractiveAndName& aMapOfAIS = GetMapOfAIS();
8f521168 8571 Handle(AIS_InteractiveObject) anObject;
8572 if (!aMapOfAIS.Find2 (anObjName, anObject))
1beb58d7 8573 {
8574 std::cout << "Syntax error: wrong object name at " << anArg << "\n";
8575 return 1;
8576 }
8577
1beb58d7 8578 gp_Trsf aTrsfs [2] = { anObject->LocalTransformation(), anObject->LocalTransformation() };
8579 gp_Quaternion aRotQuats[2] = { aTrsfs[0].GetRotation(), aTrsfs[1].GetRotation() };
8580 gp_XYZ aLocPnts [2] = { aTrsfs[0].TranslationPart(), aTrsfs[1].TranslationPart() };
8581 Standard_Real aScales [2] = { aTrsfs[0].ScaleFactor(), aTrsfs[1].ScaleFactor() };
8582 Standard_Boolean isTrsfSet = Standard_False;
8583 Standard_Integer aTrsfArgIter = anArgIter + 1;
8584 for (; aTrsfArgIter < theArgNb; ++aTrsfArgIter)
8585 {
8586 TCollection_AsciiString aTrsfArg (theArgVec[aTrsfArgIter]);
8587 aTrsfArg.LowerCase();
8588 const Standard_Integer anIndex = aTrsfArg.EndsWith ("1") ? 0 : 1;
8589 if (aTrsfArg.StartsWith ("-rotation")
8590 || aTrsfArg.StartsWith ("-rot"))
8591 {
8592 isTrsfSet = Standard_True;
8593 if (aTrsfArgIter + 4 >= theArgNb
8594 || !parseQuaternion (theArgVec + aTrsfArgIter + 1, aRotQuats[anIndex]))
8595 {
8596 std::cout << "Syntax error at " << aTrsfArg << ".\n";
8597 return 1;
8598 }
8599 aTrsfArgIter += 4;
8600 }
8601 else if (aTrsfArg.StartsWith ("-location")
8602 || aTrsfArg.StartsWith ("-loc"))
8603 {
8604 isTrsfSet = Standard_True;
8605 if (aTrsfArgIter + 3 >= theArgNb
8606 || !parseXYZ (theArgVec + aTrsfArgIter + 1, aLocPnts[anIndex]))
8607 {
8608 std::cout << "Syntax error at " << aTrsfArg << ".\n";
8609 return 1;
8610 }
8611 aTrsfArgIter += 3;
8612 }
8613 else if (aTrsfArg.StartsWith ("-scale"))
8614 {
8615 isTrsfSet = Standard_True;
8616 if (++aTrsfArgIter >= theArgNb)
8617 {
8618 std::cout << "Syntax error at " << aTrsfArg << ".\n";
8619 return 1;
8620 }
8621
8622 const TCollection_AsciiString aScaleStr (theArgVec[aTrsfArgIter]);
8623 if (!aScaleStr.IsRealValue())
8624 {
8625 std::cout << "Syntax error at " << aTrsfArg << ".\n";
8626 return 1;
8627 }
8628 aScales[anIndex] = aScaleStr.RealValue();
8629 }
8630 else
8631 {
8632 anArgIter = aTrsfArgIter - 1;
8633 break;
8634 }
8635 }
8636 if (!isTrsfSet)
8637 {
8638 std::cout << "Syntax error at " << anArg << ".\n";
8639 return 1;
8640 }
8641 else if (aTrsfArgIter >= theArgNb)
8642 {
8643 anArgIter = theArgNb;
8644 }
8645
8646 aTrsfs[0].SetRotation (aRotQuats[0]);
8647 aTrsfs[1].SetRotation (aRotQuats[1]);
8648 aTrsfs[0].SetTranslationPart (aLocPnts[0]);
8649 aTrsfs[1].SetTranslationPart (aLocPnts[1]);
8650 aTrsfs[0].SetScaleFactor (aScales[0]);
8651 aTrsfs[1].SetScaleFactor (aScales[1]);
8652
8653 Handle(AIS_AnimationObject) anObjAnimation = new AIS_AnimationObject (anAnimation->Name(), aCtx, anObject, aTrsfs[0], aTrsfs[1]);
8654 replaceAnimation (aParentAnimation, anAnimation, anObjAnimation);
8655 }
8656 else if (anArg == "-viewtrsf"
8657 || anArg == "-view")
8658 {
8659 Handle(AIS_AnimationCamera) aCamAnimation = Handle(AIS_AnimationCamera)::DownCast (anAnimation);
8660 if (aCamAnimation.IsNull())
8661 {
8662 aCamAnimation = new AIS_AnimationCamera (anAnimation->Name(), aView);
8663 replaceAnimation (aParentAnimation, anAnimation, aCamAnimation);
8664 }
8665
8666 Handle(Graphic3d_Camera) aCams[2] =
8667 {
8668 new Graphic3d_Camera (aCamAnimation->View()->Camera()),
8669 new Graphic3d_Camera (aCamAnimation->View()->Camera())
8670 };
8671
8672 Standard_Boolean isTrsfSet = Standard_False;
8673 Standard_Integer aViewArgIter = anArgIter + 1;
8674 for (; aViewArgIter < theArgNb; ++aViewArgIter)
8675 {
8676 TCollection_AsciiString aViewArg (theArgVec[aViewArgIter]);
8677 aViewArg.LowerCase();
8678 const Standard_Integer anIndex = aViewArg.EndsWith("1") ? 0 : 1;
8679 if (aViewArg.StartsWith ("-scale"))
8680 {
8681 isTrsfSet = Standard_True;
8682 if (++aViewArgIter >= theArgNb)
8683 {
8684 std::cout << "Syntax error at " << anArg << ".\n";
8685 return 1;
8686 }
8687
8688 const TCollection_AsciiString aScaleStr (theArgVec[aViewArgIter]);
8689 if (!aScaleStr.IsRealValue())
8690 {
8691 std::cout << "Syntax error at " << aViewArg << ".\n";
8692 return 1;
8693 }
8694 Standard_Real aScale = aScaleStr.RealValue();
8695 aScale = aCamAnimation->View()->DefaultCamera()->Scale() / aScale;
8696 aCams[anIndex]->SetScale (aScale);
8697 }
8698 else if (aViewArg.StartsWith ("-eye")
8699 || aViewArg.StartsWith ("-center")
8700 || aViewArg.StartsWith ("-at")
8701 || aViewArg.StartsWith ("-up"))
8702 {
8703 isTrsfSet = Standard_True;
8704 gp_XYZ anXYZ;
8705 if (aViewArgIter + 3 >= theArgNb
8706 || !parseXYZ (theArgVec + aViewArgIter + 1, anXYZ))
8707 {
8708 std::cout << "Syntax error at " << aViewArg << ".\n";
8709 return 1;
8710 }
8711 aViewArgIter += 3;
8712
8713 if (aViewArg.StartsWith ("-eye"))
8714 {
8715 aCams[anIndex]->SetEye (anXYZ);
8716 }
8717 else if (aViewArg.StartsWith ("-center")
8718 || aViewArg.StartsWith ("-at"))
8719 {
8720 aCams[anIndex]->SetCenter (anXYZ);
8721 }
8722 else if (aViewArg.StartsWith ("-up"))
8723 {
8724 aCams[anIndex]->SetUp (anXYZ);
8725 }
8726 }
8727 else
8728 {
8729 anArgIter = aViewArgIter - 1;
8730 break;
8731 }
8732 }
8733 if (!isTrsfSet)
8734 {
8735 std::cout << "Syntax error at " << anArg << ".\n";
8736 return 1;
8737 }
8738 else if (aViewArgIter >= theArgNb)
8739 {
8740 anArgIter = theArgNb;
8741 }
8742
8743 aCamAnimation->SetCameraStart(aCams[0]);
8744 aCamAnimation->SetCameraEnd (aCams[1]);
197ac94e 8745 }
8746 else
8747 {
1beb58d7 8748 std::cout << "Syntax error at " << anArg << ".\n";
8749 return 1;
197ac94e 8750 }
8751 }
1beb58d7 8752
08f8a185 8753 if (!toPlay && aRecFile.IsEmpty())
197ac94e 8754 {
1beb58d7 8755 return 0;
8756 }
8757
8758 // Start animation timeline and process frame updating.
8759 TheIsAnimating = Standard_True;
8760 const Standard_Boolean wasImmediateUpdate = aView->SetImmediateUpdate (Standard_False);
8761 Handle(Graphic3d_Camera) aCameraBack = new Graphic3d_Camera (aView->Camera());
bf7b2ceb 8762 anAnimation->StartTimer (aPlayStartTime, aPlaySpeed, Standard_True, aPlayDuration <= 0.0);
1beb58d7 8763 if (isFreeCamera)
8764 {
8765 aView->Camera()->Copy (aCameraBack);
8766 }
8767
8768 const Standard_Real anUpperPts = aPlayStartTime + aPlayDuration;
08f8a185 8769 if (aRecParams.FpsNum <= 0)
1beb58d7 8770 {
8771 while (!anAnimation->IsStopped())
197ac94e 8772 {
1beb58d7 8773 aCameraBack->Copy (aView->Camera());
8774 const Standard_Real aPts = anAnimation->UpdateTimer();
8775 if (isFreeCamera)
8776 {
8777 aView->Camera()->Copy (aCameraBack);
8778 }
8779
8780 if (aPts >= anUpperPts)
8781 {
8782 anAnimation->Pause();
8783 break;
8784 }
8785
8786 if (aView->IsInvalidated())
8787 {
8788 aView->Redraw();
8789 }
8790 else
8791 {
8792 aView->RedrawImmediate();
8793 }
8794
8795 if (!isLockLoop)
8796 {
8797 // handle user events
8798 theDI.Eval ("after 1 set waiter 1");
8799 theDI.Eval ("vwait waiter");
8800 }
8801 if (!TheIsAnimating)
8802 {
8803 anAnimation->Pause();
8804 theDI << aPts;
8805 break;
8806 }
8807 }
8808
8809 if (aView->IsInvalidated())
8810 {
8811 aView->Redraw();
197ac94e 8812 }
8813 else
8814 {
1beb58d7 8815 aView->RedrawImmediate();
197ac94e 8816 }
8817 }
1beb58d7 8818 else
197ac94e 8819 {
bf7b2ceb 8820 OSD_Timer aPerfTimer;
8821 aPerfTimer.Start();
1beb58d7 8822
08f8a185 8823 Handle(Image_VideoRecorder) aRecorder;
8824 ImageFlipper aFlipper;
8825 Handle(Draw_ProgressIndicator) aProgress;
8826 if (!aRecFile.IsEmpty())
8827 {
8828 if (aRecParams.Width <= 0
8829 || aRecParams.Height <= 0)
8830 {
8831 aView->Window()->Size (aRecParams.Width, aRecParams.Height);
8832 }
8833
8834 aRecorder = new Image_VideoRecorder();
8835 if (!aRecorder->Open (aRecFile.ToCString(), aRecParams))
8836 {
8837 std::cout << "Error: failed to open video file for recording\n";
8838 return 0;
8839 }
8840
8841 aProgress = new Draw_ProgressIndicator (theDI, 1);
8842 }
8843
1beb58d7 8844 // Manage frame-rated animation here
8845 Standard_Real aPts = aPlayStartTime;
bf7b2ceb 8846 int64_t aNbFrames = 0;
08f8a185 8847 Message_ProgressSentry aPSentry (aProgress, "Video recording, sec", 0, Max (1, Standard_Integer(aPlayDuration / aPlaySpeed)), 1);
8848 Standard_Integer aSecondsProgress = 0;
8849 for (; aPts <= anUpperPts && aPSentry.More();)
197ac94e 8850 {
08f8a185 8851 const Standard_Real aRecPts = aPlaySpeed * ((Standard_Real(aRecParams.FpsDen) / Standard_Real(aRecParams.FpsNum)) * Standard_Real(aNbFrames));
bf7b2ceb 8852 aPts = aPlayStartTime + aRecPts;
8853 ++aNbFrames;
1beb58d7 8854 if (!anAnimation->Update (aPts))
8855 {
8856 break;
8857 }
8858
08f8a185 8859 if (!aRecorder.IsNull())
8860 {
8861 V3d_ImageDumpOptions aDumpParams;
8862 aDumpParams.Width = aRecParams.Width;
8863 aDumpParams.Height = aRecParams.Height;
8864 aDumpParams.BufferType = Graphic3d_BT_RGBA;
8865 aDumpParams.StereoOptions = V3d_SDO_MONO;
8866 aDumpParams.ToAdjustAspect = Standard_True;
8867 if (!aView->ToPixMap (aRecorder->ChangeFrame(), aDumpParams))
8868 {
8869 std::cout << "Error: view dump is failed!\n";
8870 return 0;
8871 }
8872 aFlipper.FlipY (aRecorder->ChangeFrame());
8873 if (!aRecorder->PushFrame())
8874 {
8875 return 0;
8876 }
8877 }
8878 else
8879 {
8880 aView->Redraw();
8881 }
8882
8883 while (aSecondsProgress < Standard_Integer(aRecPts / aPlaySpeed))
8884 {
8885 aPSentry.Next();
8886 ++aSecondsProgress;
8887 }
197ac94e 8888 }
bf7b2ceb 8889
8890 aPerfTimer.Stop();
1beb58d7 8891 anAnimation->Stop();
bf7b2ceb 8892 const Standard_Real aRecFps = Standard_Real(aNbFrames) / aPerfTimer.ElapsedTime();
8893 theDI << "Average FPS: " << aRecFps << "\n"
8894 << "Nb. Frames: " << Standard_Real(aNbFrames);
8895
8896 aView->Redraw();
197ac94e 8897 }
8898
1beb58d7 8899 aView->SetImmediateUpdate (wasImmediateUpdate);
8900 TheIsAnimating = Standard_False;
4754e164 8901 return 0;
8902}
8903
1beb58d7 8904
4754e164 8905//=======================================================================
8906//function : VChangeSelected
dc3fe572 8907//purpose : Adds the shape to selection or remove one from it
4754e164 8908//=======================================================================
8909static Standard_Integer VChangeSelected (Draw_Interpretor& di,
8910 Standard_Integer argc,
8911 const char ** argv)
8912{
8913 if(argc != 2)
8914 {
8915 di<<"Usage : " << argv[0] << " shape \n";
8916 return 1;
8917 }
8918 //get AIS_Shape:
4754e164 8919 TCollection_AsciiString aName(argv[1]);
8920 Handle(AIS_InteractiveObject) anAISObject;
8f521168 8921 if (!GetMapOfAIS().Find2 (aName, anAISObject)
8922 || anAISObject.IsNull())
4754e164 8923 {
8924 di<<"Use 'vdisplay' before";
8925 return 1;
8926 }
4754e164 8927
8f521168 8928 ViewerTest::GetAISContext()->AddOrRemoveSelected(anAISObject, Standard_True);
4754e164 8929 return 0;
8930}
8931
4754e164 8932//=======================================================================
8933//function : VNbSelected
dc3fe572 8934//purpose : Returns number of selected objects
4754e164 8935//=======================================================================
8936static Standard_Integer VNbSelected (Draw_Interpretor& di,
8937 Standard_Integer argc,
8938 const char ** argv)
8939{
8940 if(argc != 1)
8941 {
8942 di << "Usage : " << argv[0] << "\n";
8943 return 1;
8944 }
8945 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
8946 if(aContext.IsNull())
8947 {
8948 di << "use 'vinit' command before " << argv[0] << "\n";
8949 return 1;
8950 }
8951 di << aContext->NbSelected() << "\n";
8952 return 0;
8953}
8954
4754e164 8955//=======================================================================
8956//function : VPurgeDisplay
dc3fe572 8957//purpose : Switches altialiasing on or off
4754e164 8958//=======================================================================
8959static Standard_Integer VPurgeDisplay (Draw_Interpretor& di,
8960 Standard_Integer argc,
8961 const char ** argv)
8962{
eb4320f2 8963 if (argc > 1)
4754e164 8964 {
eb4320f2 8965 di << "Usage : " << argv[0] << "\n";
4754e164 8966 return 1;
8967 }
4754e164 8968 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
8969 if (aContext.IsNull())
8970 {
8971 di << "use 'vinit' command before " << argv[0] << "\n";
8972 return 1;
8973 }
404c8936 8974
eb4320f2 8975 di << aContext->PurgeDisplay() << "\n";
4754e164 8976 return 0;
8977}
8978
8979//=======================================================================
8980//function : VSetViewSize
8981//purpose :
8982//=======================================================================
8983static Standard_Integer VSetViewSize (Draw_Interpretor& di,
8984 Standard_Integer argc,
8985 const char ** argv)
8986{
8987 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
8988 if(aContext.IsNull())
8989 {
8990 di << "use 'vinit' command before " << argv[0] << "\n";
8991 return 1;
8992 }
8993 if(argc != 2)
8994 {
8995 di<<"Usage : " << argv[0] << " Size\n";
8996 return 1;
8997 }
6b62b2da 8998 Standard_Real aSize = Draw::Atof (argv[1]);
4754e164 8999 if (aSize <= 0.)
9000 {
9001 di<<"Bad Size value : " << aSize << "\n";
9002 return 1;
9003 }
9004
9005 Handle(V3d_View) aView = ViewerTest::CurrentView();
9006 aView->SetSize(aSize);
9007 return 0;
9008}
9009
9010//=======================================================================
9011//function : VMoveView
9012//purpose :
9013//=======================================================================
9014static Standard_Integer VMoveView (Draw_Interpretor& di,
9015 Standard_Integer argc,
9016 const char ** argv)
9017{
9018 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
9019 if(aContext.IsNull())
9020 {
9021 di << "use 'vinit' command before " << argv[0] << "\n";
9022 return 1;
9023 }
9024 if(argc < 4 || argc > 5)
9025 {
9026 di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
9027 return 1;
9028 }
6b62b2da 9029 Standard_Real Dx = Draw::Atof (argv[1]);
9030 Standard_Real Dy = Draw::Atof (argv[2]);
9031 Standard_Real Dz = Draw::Atof (argv[3]);
4754e164 9032 Standard_Boolean aStart = Standard_True;
9033 if (argc == 5)
9034 {
6b62b2da 9035 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 9036 }
9037
9038 Handle(V3d_View) aView = ViewerTest::CurrentView();
9039 aView->Move(Dx,Dy,Dz,aStart);
9040 return 0;
9041}
9042
9043//=======================================================================
9044//function : VTranslateView
9045//purpose :
9046//=======================================================================
9047static Standard_Integer VTranslateView (Draw_Interpretor& di,
9048 Standard_Integer argc,
9049 const char ** argv)
9050{
9051 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
9052 if(aContext.IsNull())
9053 {
9054 di << "use 'vinit' command before " << argv[0] << "\n";
9055 return 1;
9056 }
9057 if(argc < 4 || argc > 5)
9058 {
9059 di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
9060 return 1;
9061 }
6b62b2da 9062 Standard_Real Dx = Draw::Atof (argv[1]);
9063 Standard_Real Dy = Draw::Atof (argv[2]);
9064 Standard_Real Dz = Draw::Atof (argv[3]);
4754e164 9065 Standard_Boolean aStart = Standard_True;
dc3fe572 9066 if (argc == 5)
4754e164 9067 {
6b62b2da 9068 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 9069 }
9070
9071 Handle(V3d_View) aView = ViewerTest::CurrentView();
9072 aView->Translate(Dx,Dy,Dz,aStart);
9073 return 0;
9074}
9075
9076//=======================================================================
9077//function : VTurnView
9078//purpose :
9079//=======================================================================
9080static Standard_Integer VTurnView (Draw_Interpretor& di,
9081 Standard_Integer argc,
9082 const char ** argv)
9083{
9084 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
9085 if(aContext.IsNull()) {
9086 di << "use 'vinit' command before " << argv[0] << "\n";
9087 return 1;
9088 }
9089 if(argc < 4 || argc > 5){
9090 di<<"Usage : " << argv[0] << " Ax Ay Az [Start = 1|0]\n";
9091 return 1;
9092 }
6b62b2da 9093 Standard_Real Ax = Draw::Atof (argv[1]);
9094 Standard_Real Ay = Draw::Atof (argv[2]);
9095 Standard_Real Az = Draw::Atof (argv[3]);
4754e164 9096 Standard_Boolean aStart = Standard_True;
dc3fe572 9097 if (argc == 5)
4754e164 9098 {
6b62b2da 9099 aStart = (Draw::Atoi (argv[4]) > 0);
4754e164 9100 }
9101
9102 Handle(V3d_View) aView = ViewerTest::CurrentView();
9103 aView->Turn(Ax,Ay,Az,aStart);
9104 return 0;
9105}
9106
269294d6 9107//==============================================================================
9108//function : VTextureEnv
9109//purpose : ENables or disables environment mapping
9110//==============================================================================
9111class OCC_TextureEnv : public Graphic3d_TextureEnv
9112{
9113public:
9114 OCC_TextureEnv(const Standard_CString FileName);
9115 OCC_TextureEnv(const Graphic3d_NameOfTextureEnv aName);
9116 void SetTextureParameters(const Standard_Boolean theRepeatFlag,
9117 const Standard_Boolean theModulateFlag,
9118 const Graphic3d_TypeOfTextureFilter theFilter,
9119 const Standard_ShortReal theXScale,
9120 const Standard_ShortReal theYScale,
9121 const Standard_ShortReal theXShift,
9122 const Standard_ShortReal theYShift,
9123 const Standard_ShortReal theAngle);
68858c7d 9124 DEFINE_STANDARD_RTTI_INLINE(OCC_TextureEnv,Graphic3d_TextureEnv)
269294d6 9125};
a3f6f591 9126DEFINE_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv)
ec357c5c 9127
269294d6 9128OCC_TextureEnv::OCC_TextureEnv(const Standard_CString theFileName)
9129 : Graphic3d_TextureEnv(theFileName)
9130{
9131}
9132
9133OCC_TextureEnv::OCC_TextureEnv(const Graphic3d_NameOfTextureEnv theTexId)
9134 : Graphic3d_TextureEnv(theTexId)
9135{
9136}
9137
9138void OCC_TextureEnv::SetTextureParameters(const Standard_Boolean theRepeatFlag,
9139 const Standard_Boolean theModulateFlag,
9140 const Graphic3d_TypeOfTextureFilter theFilter,
9141 const Standard_ShortReal theXScale,
9142 const Standard_ShortReal theYScale,
9143 const Standard_ShortReal theXShift,
9144 const Standard_ShortReal theYShift,
9145 const Standard_ShortReal theAngle)
9146{
9147 myParams->SetRepeat (theRepeatFlag);
9148 myParams->SetModulate (theModulateFlag);
9149 myParams->SetFilter (theFilter);
9150 myParams->SetScale (Graphic3d_Vec2(theXScale, theYScale));
9151 myParams->SetTranslation(Graphic3d_Vec2(theXShift, theYShift));
9152 myParams->SetRotation (theAngle);
9153}
9154
35e08fe8 9155static int VTextureEnv (Draw_Interpretor& /*theDI*/, Standard_Integer theArgNb, const char** theArgVec)
269294d6 9156{
9157 // get the active view
9158 Handle(V3d_View) aView = ViewerTest::CurrentView();
9159 if (aView.IsNull())
9160 {
9161 std::cerr << "No active view. Please call vinit.\n";
9162 return 1;
9163 }
9164
9165 // Checking the input arguments
9166 Standard_Boolean anEnableFlag = Standard_False;
9167 Standard_Boolean isOk = theArgNb >= 2;
9168 if (isOk)
9169 {
9170 TCollection_AsciiString anEnableOpt(theArgVec[1]);
9171 anEnableFlag = anEnableOpt.IsEqual("on");
9172 isOk = anEnableFlag || anEnableOpt.IsEqual("off");
9173 }
9174 if (anEnableFlag)
9175 {
9176 isOk = (theArgNb == 3 || theArgNb == 11);
9177 if (isOk)
9178 {
9179 TCollection_AsciiString aTextureOpt(theArgVec[2]);
9180 isOk = (!aTextureOpt.IsIntegerValue() ||
9181 (aTextureOpt.IntegerValue() >= 0 && aTextureOpt.IntegerValue() < Graphic3d_NOT_ENV_UNKNOWN));
9182
9183 if (isOk && theArgNb == 11)
9184 {
9185 TCollection_AsciiString aRepeatOpt (theArgVec[3]),
9186 aModulateOpt(theArgVec[4]),
9187 aFilterOpt (theArgVec[5]),
9188 aSScaleOpt (theArgVec[6]),
9189 aTScaleOpt (theArgVec[7]),
9190 aSTransOpt (theArgVec[8]),
9191 aTTransOpt (theArgVec[9]),
9192 anAngleOpt (theArgVec[10]);
9193 isOk = ((aRepeatOpt. IsEqual("repeat") || aRepeatOpt. IsEqual("clamp")) &&
9194 (aModulateOpt.IsEqual("modulate") || aModulateOpt.IsEqual("decal")) &&
9195 (aFilterOpt. IsEqual("nearest") || aFilterOpt. IsEqual("bilinear") || aFilterOpt.IsEqual("trilinear")) &&
9196 aSScaleOpt.IsRealValue() && aTScaleOpt.IsRealValue() &&
9197 aSTransOpt.IsRealValue() && aTTransOpt.IsRealValue() &&
9198 anAngleOpt.IsRealValue());
9199 }
9200 }
9201 }
9202
9203 if (!isOk)
9204 {
9205 std::cerr << "Usage :" << std::endl;
9206 std::cerr << theArgVec[0] << " off" << std::endl;
9207 std::cerr << theArgVec[0] << " on {index_of_std_texture(0..7)|texture_file_name} [{clamp|repeat} {decal|modulate} {nearest|bilinear|trilinear} scale_s scale_t translation_s translation_t rotation_degrees]" << std::endl;
9208 return 1;
9209 }
9210
9211 if (anEnableFlag)
9212 {
9213 TCollection_AsciiString aTextureOpt(theArgVec[2]);
9214 Handle(OCC_TextureEnv) aTexEnv = aTextureOpt.IsIntegerValue() ?
9215 new OCC_TextureEnv((Graphic3d_NameOfTextureEnv)aTextureOpt.IntegerValue()) :
9216 new OCC_TextureEnv(theArgVec[2]);
9217
9218 if (theArgNb == 11)
9219 {
9220 TCollection_AsciiString aRepeatOpt(theArgVec[3]), aModulateOpt(theArgVec[4]), aFilterOpt(theArgVec[5]);
9221 aTexEnv->SetTextureParameters(
9222 aRepeatOpt. IsEqual("repeat"),
9223 aModulateOpt.IsEqual("modulate"),
9224 aFilterOpt. IsEqual("nearest") ? Graphic3d_TOTF_NEAREST :
9225 aFilterOpt.IsEqual("bilinear") ? Graphic3d_TOTF_BILINEAR :
9226 Graphic3d_TOTF_TRILINEAR,
9227 (Standard_ShortReal)Draw::Atof(theArgVec[6]),
9228 (Standard_ShortReal)Draw::Atof(theArgVec[7]),
9229 (Standard_ShortReal)Draw::Atof(theArgVec[8]),
9230 (Standard_ShortReal)Draw::Atof(theArgVec[9]),
9231 (Standard_ShortReal)Draw::Atof(theArgVec[10])
9232 );
9233 }
9234 aView->SetTextureEnv(aTexEnv);
269294d6 9235 }
9236 else // Disabling environment mapping
9237 {
269294d6 9238 Handle(Graphic3d_TextureEnv) aTexture;
9239 aView->SetTextureEnv(aTexture); // Passing null handle to clear the texture data
9240 }
9241
9242 aView->Redraw();
9243 return 0;
9244}
9245
3e05329c 9246namespace
9247{
9248 typedef NCollection_DataMap<TCollection_AsciiString, Handle(Graphic3d_ClipPlane)> MapOfPlanes;
9249
9250 //! Remove registered clipping plane from all views and objects.
9251 static void removePlane (MapOfPlanes& theRegPlanes,
9252 const TCollection_AsciiString& theName)
9253 {
9254 Handle(Graphic3d_ClipPlane) aClipPlane;
9255 if (!theRegPlanes.Find (theName, aClipPlane))
9256 {
9257 std::cout << "Warning: no such plane.\n";
9258 return;
9259 }
9260
9261 theRegPlanes.UnBind (theName);
9262 for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIObjIt (GetMapOfAIS());
9263 anIObjIt.More(); anIObjIt.Next())
9264 {
8f521168 9265 const Handle(AIS_InteractiveObject)& aPrs = anIObjIt.Key1();
3e05329c 9266 aPrs->RemoveClipPlane (aClipPlane);
9267 }
9268
9269 for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
9270 aViewIt.More(); aViewIt.Next())
9271 {
9272 const Handle(V3d_View)& aView = aViewIt.Key2();
9273 aView->RemoveClipPlane(aClipPlane);
9274 }
9275
9276 ViewerTest::RedrawAllViews();
9277 }
9278}
9279
4269bd1b 9280//===============================================================================================
9281//function : VClipPlane
9282//purpose :
9283//===============================================================================================
9284static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
9285{
9286 // use short-cut for created clip planes map of created (or "registered by name") clip planes
4269bd1b 9287 static MapOfPlanes aRegPlanes;
9288
9289 if (theArgsNb < 2)
9290 {
3e05329c 9291 for (MapOfPlanes::Iterator aPlaneIter (aRegPlanes); aPlaneIter.More(); aPlaneIter.Next())
9292 {
9293 theDi << aPlaneIter.Key() << " ";
9294 }
9295 return 0;
4269bd1b 9296 }
9297
9298 TCollection_AsciiString aCommand (theArgVec[1]);
3e05329c 9299 aCommand.LowerCase();
9300 const Handle(V3d_View)& anActiveView = ViewerTest::CurrentView();
9301 if (anActiveView.IsNull())
9302 {
9303 std::cout << "Error: no active view.\n";
9304 return 1;
9305 }
4269bd1b 9306
9307 // print maximum number of planes for current viewer
3e05329c 9308 if (aCommand == "-maxplanes"
9309 || aCommand == "maxplanes")
4269bd1b 9310 {
3e05329c 9311 theDi << anActiveView->Viewer()->Driver()->InquirePlaneLimit()
9312 << " plane slots provided by driver.\n";
4269bd1b 9313 return 0;
9314 }
9315
9316 // create / delete plane instance
3e05329c 9317 if (aCommand == "-create"
9318 || aCommand == "create"
9319 || aCommand == "-delete"
9320 || aCommand == "delete"
9321 || aCommand == "-clone"
9322 || aCommand == "clone")
4269bd1b 9323 {
9324 if (theArgsNb < 3)
9325 {
3e05329c 9326 std::cout << "Syntax error: plane name is required.\n";
4269bd1b 9327 return 1;
9328 }
9329
3e05329c 9330 Standard_Boolean toCreate = aCommand == "-create"
9331 || aCommand == "create";
9332 Standard_Boolean toClone = aCommand == "-clone"
9333 || aCommand == "clone";
9334 Standard_Boolean toDelete = aCommand == "-delete"
9335 || aCommand == "delete";
4269bd1b 9336 TCollection_AsciiString aPlane (theArgVec[2]);
9337
9338 if (toCreate)
9339 {
9340 if (aRegPlanes.IsBound (aPlane))
9341 {
3e05329c 9342 std::cout << "Warning: existing plane has been overridden.\n";
9343 toDelete = true;
9344 }
9345 else
9346 {
9347 aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
9348 return 0;
4269bd1b 9349 }
4269bd1b 9350 }
9351 else if (toClone) // toClone
9352 {
9353 if (!aRegPlanes.IsBound (aPlane))
9354 {
3e05329c 9355 std::cout << "Error: no such plane.\n";
4269bd1b 9356 return 1;
9357 }
3e05329c 9358 else if (theArgsNb < 4)
4269bd1b 9359 {
3e05329c 9360 std::cout << "Syntax error: enter name for new plane.\n";
4269bd1b 9361 return 1;
9362 }
9363
9364 TCollection_AsciiString aClone (theArgVec[3]);
9365 if (aRegPlanes.IsBound (aClone))
9366 {
3e05329c 9367 std::cout << "Error: plane name is in use.\n";
4269bd1b 9368 return 1;
9369 }
9370
9371 const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
9372
9373 aRegPlanes.Bind (aClone, aClipPlane->Clone());
3e05329c 9374 return 0;
4269bd1b 9375 }
4269bd1b 9376
3e05329c 9377 if (toDelete)
9378 {
9379 if (aPlane == "ALL"
9380 || aPlane == "all"
9381 || aPlane == "*")
4269bd1b 9382 {
3e05329c 9383 for (MapOfPlanes::Iterator aPlaneIter (aRegPlanes); aPlaneIter.More();)
9384 {
9385 aPlane = aPlaneIter.Key();
9386 removePlane (aRegPlanes, aPlane);
9387 aPlaneIter = MapOfPlanes::Iterator (aRegPlanes);
9388 }
4269bd1b 9389 }
3e05329c 9390 else
4269bd1b 9391 {
3e05329c 9392 removePlane (aRegPlanes, aPlane);
4269bd1b 9393 }
4269bd1b 9394 }
9395
3e05329c 9396 if (toCreate)
9397 {
9398 aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
9399 }
4269bd1b 9400 return 0;
9401 }
9402
9403 // set / unset plane command
3e05329c 9404 if (aCommand == "set"
9405 || aCommand == "unset")
4269bd1b 9406 {
3e05329c 9407 if (theArgsNb < 5)
4269bd1b 9408 {
3e05329c 9409 std::cout << "Syntax error: need more arguments.\n";
4269bd1b 9410 return 1;
9411 }
9412
3e05329c 9413 // redirect to new syntax
9414 NCollection_Array1<const char*> anArgVec (1, theArgsNb - 1);
9415 anArgVec.SetValue (1, theArgVec[0]);
9416 anArgVec.SetValue (2, theArgVec[2]);
9417 anArgVec.SetValue (3, aCommand == "set" ? "-set" : "-unset");
9418 for (Standard_Integer anIt = 4; anIt < theArgsNb; ++anIt)
4269bd1b 9419 {
3e05329c 9420 anArgVec.SetValue (anIt, theArgVec[anIt]);
4269bd1b 9421 }
9422
3e05329c 9423 return VClipPlane (theDi, anArgVec.Length(), &anArgVec.ChangeFirst());
4269bd1b 9424 }
9425
9426 // change plane command
3e05329c 9427 TCollection_AsciiString aPlaneName;
9428 Handle(Graphic3d_ClipPlane) aClipPlane;
9429 Standard_Integer anArgIter = 0;
9430 if (aCommand == "-change"
9431 || aCommand == "change")
4269bd1b 9432 {
3e05329c 9433 // old syntax support
9434 if (theArgsNb < 3)
4269bd1b 9435 {
3e05329c 9436 std::cout << "Syntax error: need more arguments.\n";
4269bd1b 9437 return 1;
9438 }
9439
3e05329c 9440 anArgIter = 3;
9441 aPlaneName = theArgVec[2];
9442 if (!aRegPlanes.Find (aPlaneName, aClipPlane))
4269bd1b 9443 {
3e05329c 9444 std::cout << "Error: no such plane '" << aPlaneName << "'.\n";
4269bd1b 9445 return 1;
9446 }
3e05329c 9447 }
9448 else if (aRegPlanes.Find (theArgVec[1], aClipPlane))
9449 {
9450 anArgIter = 2;
9451 aPlaneName = theArgVec[1];
9452 }
9453 else
9454 {
9455 anArgIter = 2;
9456 aPlaneName = theArgVec[1];
9457 aClipPlane = new Graphic3d_ClipPlane();
9458 aRegPlanes.Bind (aPlaneName, aClipPlane);
9459 theDi << "Created new plane " << aPlaneName << ".\n";
9460 }
4269bd1b 9461
3e05329c 9462 if (theArgsNb - anArgIter < 1)
9463 {
9464 std::cout << "Syntax error: need more arguments.\n";
9465 return 1;
9466 }
4269bd1b 9467
3e05329c 9468 for (; anArgIter < theArgsNb; ++anArgIter)
9469 {
9470 const char** aChangeArgs = theArgVec + anArgIter;
9471 Standard_Integer aNbChangeArgs = theArgsNb - anArgIter;
9472 TCollection_AsciiString aChangeArg (aChangeArgs[0]);
9473 aChangeArg.LowerCase();
4269bd1b 9474
3e05329c 9475 Standard_Boolean toEnable = Standard_True;
9476 if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable))
4269bd1b 9477 {
3e05329c 9478 aClipPlane->SetOn (toEnable);
4269bd1b 9479 }
25c35042 9480 else if (aChangeArg.StartsWith ("-equation")
9481 || aChangeArg.StartsWith ("equation"))
4269bd1b 9482 {
3e05329c 9483 if (aNbChangeArgs < 5)
4269bd1b 9484 {
3e05329c 9485 std::cout << "Syntax error: need more arguments.\n";
4269bd1b 9486 return 1;
9487 }
9488
25c35042 9489 Standard_Integer aSubIndex = 1;
9490 Standard_Integer aPrefixLen = 8 + (aChangeArg.Value (1) == '-' ? 1 : 0);
9491 if (aPrefixLen < aChangeArg.Length())
9492 {
9493 TCollection_AsciiString aSubStr = aChangeArg.SubString (aPrefixLen + 1, aChangeArg.Length());
9494 if (!aSubStr.IsIntegerValue()
9495 || aSubStr.IntegerValue() <= 0)
9496 {
9497 std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
9498 return 1;
9499 }
9500 aSubIndex = aSubStr.IntegerValue();
9501 }
9502
9503 Standard_Real aCoeffA = Draw::Atof (aChangeArgs[1]);
9504 Standard_Real aCoeffB = Draw::Atof (aChangeArgs[2]);
9505 Standard_Real aCoeffC = Draw::Atof (aChangeArgs[3]);
9506 Standard_Real aCoeffD = Draw::Atof (aChangeArgs[4]);
9507 Handle(Graphic3d_ClipPlane) aSubPln = aClipPlane;
9508 for (Standard_Integer aSubPlaneIter = 1; aSubPlaneIter < aSubIndex; ++aSubPlaneIter)
9509 {
9510 if (aSubPln->ChainNextPlane().IsNull())
9511 {
9512 aSubPln->SetChainNextPlane (new Graphic3d_ClipPlane (*aSubPln));
9513 }
9514 aSubPln = aSubPln->ChainNextPlane();
9515 }
9516 aSubPln->SetChainNextPlane (Handle(Graphic3d_ClipPlane)());
9517 aSubPln->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
3e05329c 9518 anArgIter += 4;
4269bd1b 9519 }
25c35042 9520 else if ((aChangeArg == "-boxinterior"
9521 || aChangeArg == "-boxint"
9522 || aChangeArg == "-box")
9523 && aNbChangeArgs >= 7)
9524 {
9525 Graphic3d_BndBox3d aBndBox;
9526 aBndBox.Add (Graphic3d_Vec3d (Draw::Atof (aChangeArgs[1]), Draw::Atof (aChangeArgs[2]), Draw::Atof (aChangeArgs[3])));
9527 aBndBox.Add (Graphic3d_Vec3d (Draw::Atof (aChangeArgs[4]), Draw::Atof (aChangeArgs[5]), Draw::Atof (aChangeArgs[6])));
9528 anArgIter += 6;
9529
9530 Standard_Integer aNbSubPlanes = 6;
9531 const Graphic3d_Vec3d aDirArray[6] =
9532 {
9533 Graphic3d_Vec3d (-1, 0, 0),
9534 Graphic3d_Vec3d ( 1, 0, 0),
9535 Graphic3d_Vec3d ( 0,-1, 0),
9536 Graphic3d_Vec3d ( 0, 1, 0),
9537 Graphic3d_Vec3d ( 0, 0,-1),
9538 Graphic3d_Vec3d ( 0, 0, 1),
9539 };
9540 Handle(Graphic3d_ClipPlane) aSubPln = aClipPlane;
9541 for (Standard_Integer aSubPlaneIter = 0; aSubPlaneIter < aNbSubPlanes; ++aSubPlaneIter)
9542 {
9543 const Graphic3d_Vec3d& aDir = aDirArray[aSubPlaneIter];
9544 const Standard_Real aW = -aDir.Dot ((aSubPlaneIter % 2 == 1) ? aBndBox.CornerMax() : aBndBox.CornerMin());
9545 aSubPln->SetEquation (gp_Pln (aDir.x(), aDir.y(), aDir.z(), aW));
9546 if (aSubPlaneIter + 1 == aNbSubPlanes)
9547 {
9548 aSubPln->SetChainNextPlane (Handle(Graphic3d_ClipPlane)());
9549 }
9550 else
9551 {
9552 aSubPln->SetChainNextPlane (new Graphic3d_ClipPlane (*aSubPln));
9553 }
9554 aSubPln = aSubPln->ChainNextPlane();
9555 }
9556 }
3e05329c 9557 else if (aChangeArg == "-capping"
9558 || aChangeArg == "capping")
4269bd1b 9559 {
3e05329c 9560 if (aNbChangeArgs < 2)
4269bd1b 9561 {
3e05329c 9562 std::cout << "Syntax error: need more arguments.\n";
4269bd1b 9563 return 1;
9564 }
9565
3e05329c 9566 if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
4269bd1b 9567 {
3e05329c 9568 aClipPlane->SetCapping (toEnable);
9569 anArgIter += 1;
9570 }
9571 else
9572 {
9573 // just skip otherwise (old syntax)
9574 }
9575 }
9576 else if (aChangeArg == "-useobjectmaterial"
9577 || aChangeArg == "-useobjectmat"
9578 || aChangeArg == "-useobjmat"
9579 || aChangeArg == "-useobjmaterial")
9580 {
9581 if (aNbChangeArgs < 2)
9582 {
9583 std::cout << "Syntax error: need more arguments.\n";
4269bd1b 9584 return 1;
9585 }
9586
3e05329c 9587 if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
4269bd1b 9588 {
3e05329c 9589 aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
9590 anArgIter += 1;
4269bd1b 9591 }
3e05329c 9592 }
9593 else if (aChangeArg == "-useobjecttexture"
9594 || aChangeArg == "-useobjecttex"
9595 || aChangeArg == "-useobjtexture"
9596 || aChangeArg == "-useobjtex")
9597 {
9598 if (aNbChangeArgs < 2)
4269bd1b 9599 {
3e05329c 9600 std::cout << "Syntax error: need more arguments.\n";
9601 return 1;
9602 }
4269bd1b 9603
3e05329c 9604 if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
9605 {
9606 aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
9607 anArgIter += 1;
9608 }
9609 }
9610 else if (aChangeArg == "-useobjectshader"
9611 || aChangeArg == "-useobjshader")
9612 {
9613 if (aNbChangeArgs < 2)
9614 {
9615 std::cout << "Syntax error: need more arguments.\n";
9616 return 1;
9617 }
4269bd1b 9618
3e05329c 9619 if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
9620 {
9621 aClipPlane->SetUseObjectShader (toEnable == Standard_True);
9622 anArgIter += 1;
4269bd1b 9623 }
3e05329c 9624 }
9625 else if (aChangeArg == "-color"
9626 || aChangeArg == "color")
9627 {
9628 Quantity_Color aColor;
9629 Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
9630 aChangeArgs + 1,
9631 aColor);
9632 if (aNbParsed == 0)
4269bd1b 9633 {
3e05329c 9634 std::cout << "Syntax error: need more arguments.\n";
9635 return 1;
9636 }
61168418 9637 aClipPlane->SetCappingColor (aColor);
3e05329c 9638 anArgIter += aNbParsed;
9639 }
61168418 9640 else if (aNbChangeArgs >= 1
9641 && (aChangeArg == "-material"
9642 || aChangeArg == "material"))
9643 {
9644 ++anArgIter;
9645 Graphic3d_NameOfMaterial aMatName;
9646 if (!Graphic3d_MaterialAspect::MaterialFromName (aChangeArgs[1], aMatName))
9647 {
9648 std::cout << "Syntax error: unknown material '" << aChangeArgs[1] << "'.\n";
9649 return 1;
9650 }
9651 aClipPlane->SetCappingMaterial (aMatName);
9652 }
1b661a81 9653 else if ((aChangeArg == "-transparency"
9654 || aChangeArg == "-transp")
9655 && aNbChangeArgs >= 2)
9656 {
9657 TCollection_AsciiString aValStr (aChangeArgs[1]);
9658 Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
9659 if (aValStr.IsRealValue())
9660 {
9661 Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
9662 aMat.SetTransparency ((float )aValStr.RealValue());
9663 anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
9664 aClipPlane->SetCappingMaterial (aMat);
9665 }
9666 else
9667 {
9668 aValStr.LowerCase();
9669 Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto;
9670 if (aValStr == "opaque")
9671 {
9672 aMode = Graphic3d_AlphaMode_Opaque;
9673 }
9674 else if (aValStr == "mask")
9675 {
9676 aMode = Graphic3d_AlphaMode_Mask;
9677 }
9678 else if (aValStr == "blend")
9679 {
9680 aMode = Graphic3d_AlphaMode_Blend;
9681 }
9682 else if (aValStr == "blendauto")
9683 {
9684 aMode = Graphic3d_AlphaMode_BlendAuto;
9685 }
9686 else
9687 {
9688 std::cout << "Syntax error at '" << aValStr << "'\n";
9689 return 1;
9690 }
9691 anAspect->SetAlphaMode (aMode);
9692 aClipPlane->SetCappingAspect (anAspect);
9693 }
9694 anArgIter += 1;
9695 }
3e05329c 9696 else if (aChangeArg == "-texname"
9697 || aChangeArg == "texname")
9698 {
9699 if (aNbChangeArgs < 2)
9700 {
9701 std::cout << "Syntax error: need more arguments.\n";
9702 return 1;
9703 }
4269bd1b 9704
3e05329c 9705 TCollection_AsciiString aTextureName (aChangeArgs[1]);
9706 Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
9707 if (!aTexture->IsDone())
9708 {
9709 aClipPlane->SetCappingTexture (NULL);
4269bd1b 9710 }
3e05329c 9711 else
4269bd1b 9712 {
3e05329c 9713 aTexture->EnableModulate();
9714 aTexture->EnableRepeat();
9715 aClipPlane->SetCappingTexture (aTexture);
9716 }
9717 anArgIter += 1;
9718 }
9719 else if (aChangeArg == "-texscale"
9720 || aChangeArg == "texscale")
9721 {
9722 if (aClipPlane->CappingTexture().IsNull())
9723 {
9724 std::cout << "Error: no texture is set.\n";
9725 return 1;
9726 }
4269bd1b 9727
3e05329c 9728 if (aNbChangeArgs < 3)
9729 {
9730 std::cout << "Syntax error: need more arguments.\n";
9731 return 1;
9732 }
4269bd1b 9733
3e05329c 9734 Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
9735 Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
9736 aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
9737 anArgIter += 2;
9738 }
9739 else if (aChangeArg == "-texorigin"
9740 || aChangeArg == "texorigin") // texture origin
9741 {
9742 if (aClipPlane->CappingTexture().IsNull())
9743 {
9744 std::cout << "Error: no texture is set.\n";
9745 return 1;
9746 }
4269bd1b 9747
3e05329c 9748 if (aNbChangeArgs < 3)
9749 {
9750 std::cout << "Syntax error: need more arguments.\n";
9751 return 1;
4269bd1b 9752 }
3e05329c 9753
9754 Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
9755 Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
9756
9757 aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
9758 anArgIter += 2;
9759 }
9760 else if (aChangeArg == "-texrotate"
9761 || aChangeArg == "texrotate") // texture rotation
9762 {
9763 if (aClipPlane->CappingTexture().IsNull())
4269bd1b 9764 {
3e05329c 9765 std::cout << "Error: no texture is set.\n";
9766 return 1;
9767 }
4269bd1b 9768
3e05329c 9769 if (aNbChangeArgs < 2)
9770 {
9771 std::cout << "Syntax error: need more arguments.\n";
9772 return 1;
9773 }
4269bd1b 9774
3e05329c 9775 Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
9776 aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
9777 anArgIter += 1;
9778 }
9779 else if (aChangeArg == "-hatch"
9780 || aChangeArg == "hatch")
9781 {
9782 if (aNbChangeArgs < 2)
9783 {
9784 std::cout << "Syntax error: need more arguments.\n";
9785 return 1;
9786 }
4269bd1b 9787
3e05329c 9788 TCollection_AsciiString aHatchStr (aChangeArgs[1]);
9789 aHatchStr.LowerCase();
9790 if (aHatchStr == "on")
9791 {
9792 aClipPlane->SetCappingHatchOn();
9793 }
9794 else if (aHatchStr == "off")
9795 {
9796 aClipPlane->SetCappingHatchOff();
4269bd1b 9797 }
3e05329c 9798 else
4269bd1b 9799 {
3e05329c 9800 aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
9801 }
9802 anArgIter += 1;
9803 }
9804 else if (aChangeArg == "-delete"
9805 || aChangeArg == "delete")
9806 {
9807 removePlane (aRegPlanes, aPlaneName);
9808 return 0;
9809 }
9810 else if (aChangeArg == "-set"
32ca7711 9811 || aChangeArg == "-unset"
9812 || aChangeArg == "-setoverrideglobal")
3e05329c 9813 {
9814 // set / unset plane command
32ca7711 9815 const Standard_Boolean toSet = aChangeArg.StartsWith ("-set");
9816 const Standard_Boolean toOverrideGlobal = aChangeArg == "-setoverrideglobal";
3e05329c 9817 Standard_Integer anIt = 1;
9818 for (; anIt < aNbChangeArgs; ++anIt)
9819 {
9820 TCollection_AsciiString anEntityName (aChangeArgs[anIt]);
9821 if (anEntityName.IsEmpty()
9822 || anEntityName.Value (1) == '-')
4269bd1b 9823 {
3e05329c 9824 break;
4269bd1b 9825 }
32ca7711 9826 else if (!toOverrideGlobal
9827 && ViewerTest_myViews.IsBound1 (anEntityName))
4269bd1b 9828 {
3e05329c 9829 Handle(V3d_View) aView = ViewerTest_myViews.Find1 (anEntityName);
9830 if (toSet)
9831 {
9832 aView->AddClipPlane (aClipPlane);
9833 }
9834 else
9835 {
9836 aView->RemoveClipPlane (aClipPlane);
9837 }
9838 continue;
4269bd1b 9839 }
3e05329c 9840 else if (GetMapOfAIS().IsBound2 (anEntityName))
4269bd1b 9841 {
8f521168 9842 Handle(AIS_InteractiveObject) aIObj = GetMapOfAIS().Find2 (anEntityName);
3e05329c 9843 if (toSet)
9844 {
9845 aIObj->AddClipPlane (aClipPlane);
9846 }
9847 else
9848 {
9849 aIObj->RemoveClipPlane (aClipPlane);
9850 }
32ca7711 9851 if (!aIObj->ClipPlanes().IsNull())
9852 {
9853 aIObj->ClipPlanes()->SetOverrideGlobal (toOverrideGlobal);
9854 }
4269bd1b 9855 }
3e05329c 9856 else
4269bd1b 9857 {
3e05329c 9858 std::cout << "Error: object/view '" << anEntityName << "' is not found!\n";
9859 return 1;
4269bd1b 9860 }
3e05329c 9861 }
9862
9863 if (anIt == 1)
9864 {
9865 // apply to active view
9866 if (toSet)
4269bd1b 9867 {
3e05329c 9868 anActiveView->AddClipPlane (aClipPlane);
4269bd1b 9869 }
9870 else
9871 {
3e05329c 9872 anActiveView->RemoveClipPlane (aClipPlane);
4269bd1b 9873 }
9874 }
3e05329c 9875 else
9876 {
9877 anArgIter = anArgIter + anIt - 1;
9878 }
9879 }
9880 else
9881 {
9882 std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
9883 return 1;
4269bd1b 9884 }
4269bd1b 9885 }
9886
3e05329c 9887 ViewerTest::RedrawAllViews();
9888 return 0;
4269bd1b 9889}
9890
b5ac8292 9891//===============================================================================================
9892//function : VZRange
9893//purpose :
9894//===============================================================================================
9895static int VZRange (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
9896{
197ac94e 9897 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
9898
9899 if (aCurrentView.IsNull())
b5ac8292 9900 {
197ac94e 9901 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
b5ac8292 9902 return 1;
9903 }
9904
197ac94e 9905 Handle(Graphic3d_Camera) aCamera = aCurrentView->Camera();
b5ac8292 9906
9907 if (theArgsNb < 2)
9908 {
9909 theDi << "ZNear: " << aCamera->ZNear() << "\n";
9910 theDi << "ZFar: " << aCamera->ZFar() << "\n";
9911 return 0;
9912 }
9913
9914 if (theArgsNb == 3)
9915 {
6b62b2da 9916 Standard_Real aNewZNear = Draw::Atof (theArgVec[1]);
9917 Standard_Real aNewZFar = Draw::Atof (theArgVec[2]);
197ac94e 9918
9919 if (aNewZNear >= aNewZFar)
9920 {
9921 std::cout << theArgVec[0] << ": invalid arguments: znear should be less than zfar.\n";
9922 return 1;
9923 }
9924
9925 if (!aCamera->IsOrthographic() && (aNewZNear <= 0.0 || aNewZFar <= 0.0))
9926 {
9927 std::cout << theArgVec[0] << ": invalid arguments: ";
9928 std::cout << "znear, zfar should be positive for perspective camera.\n";
9929 return 1;
9930 }
9931
9932 aCamera->SetZRange (aNewZNear, aNewZFar);
b5ac8292 9933 }
9934 else
9935 {
197ac94e 9936 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
b5ac8292 9937 return 1;
9938 }
9939
197ac94e 9940 aCurrentView->Redraw();
9941
b5ac8292 9942 return 0;
9943}
9944
9945//===============================================================================================
9946//function : VAutoZFit
9947//purpose :
9948//===============================================================================================
9949static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
9950{
197ac94e 9951 const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
9952
9953 if (aCurrentView.IsNull())
b5ac8292 9954 {
197ac94e 9955 std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
b5ac8292 9956 return 1;
9957 }
9958
c357e426 9959 Standard_Real aScale = aCurrentView->AutoZFitScaleFactor();
197ac94e 9960
9961 if (theArgsNb > 3)
b5ac8292 9962 {
197ac94e 9963 std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
9964 return 1;
b5ac8292 9965 }
9966
197ac94e 9967 if (theArgsNb < 2)
b5ac8292 9968 {
586db386 9969 theDi << "Auto z-fit mode: \n"
c357e426 9970 << "On: " << (aCurrentView->AutoZFitMode() ? "enabled" : "disabled") << "\n"
197ac94e 9971 << "Scale: " << aScale << "\n";
9972 return 0;
b5ac8292 9973 }
197ac94e 9974
9975 Standard_Boolean isOn = Draw::Atoi (theArgVec[1]) == 1;
9976
9977 if (theArgsNb >= 3)
b5ac8292 9978 {
197ac94e 9979 aScale = Draw::Atoi (theArgVec[2]);
b5ac8292 9980 }
9981
c357e426 9982 aCurrentView->SetAutoZFitMode (isOn, aScale);
9983 aCurrentView->AutoZFit();
197ac94e 9984 aCurrentView->Redraw();
9985
b5ac8292 9986 return 0;
9987}
9988
6b62b2da 9989//! Auxiliary function to print projection type
9990inline const char* projTypeName (Graphic3d_Camera::Projection theProjType)
9991{
9992 switch (theProjType)
9993 {
9994 case Graphic3d_Camera::Projection_Orthographic: return "orthographic";
9995 case Graphic3d_Camera::Projection_Perspective: return "perspective";
9996 case Graphic3d_Camera::Projection_Stereo: return "stereoscopic";
9997 case Graphic3d_Camera::Projection_MonoLeftEye: return "monoLeftEye";
9998 case Graphic3d_Camera::Projection_MonoRightEye: return "monoRightEye";
9999 }
10000 return "UNKNOWN";
10001}
10002
b5ac8292 10003//===============================================================================================
6b62b2da 10004//function : VCamera
b5ac8292 10005//purpose :
10006//===============================================================================================
6b62b2da 10007static int VCamera (Draw_Interpretor& theDI,
10008 Standard_Integer theArgsNb,
10009 const char** theArgVec)
b5ac8292 10010{
6b62b2da 10011 Handle(V3d_View) aView = ViewerTest::CurrentView();
10012 if (aView.IsNull())
b5ac8292 10013 {
6b62b2da 10014 std::cout << "Error: no active view.\n";
b5ac8292 10015 return 1;
10016 }
10017
6b62b2da 10018 Handle(Graphic3d_Camera) aCamera = aView->Camera();
10019 if (theArgsNb < 2)
b5ac8292 10020 {
6b62b2da 10021 theDI << "ProjType: " << projTypeName (aCamera->ProjectionType()) << "\n";
10022 theDI << "FOVy: " << aCamera->FOVy() << "\n";
10023 theDI << "Distance: " << aCamera->Distance() << "\n";
10024 theDI << "IOD: " << aCamera->IOD() << "\n";
10025 theDI << "IODType: " << (aCamera->GetIODType() == Graphic3d_Camera::IODType_Absolute ? "absolute" : "relative") << "\n";
10026 theDI << "ZFocus: " << aCamera->ZFocus() << "\n";
10027 theDI << "ZFocusType: " << (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Absolute ? "absolute" : "relative") << "\n";
10028 return 0;
b5ac8292 10029 }
10030
30a1b24e 10031 TCollection_AsciiString aPrsName;
6b62b2da 10032 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
b5ac8292 10033 {
6b62b2da 10034 Standard_CString anArg = theArgVec[anArgIter];
10035 TCollection_AsciiString anArgCase (anArg);
10036 anArgCase.LowerCase();
10037 if (anArgCase == "-proj"
10038 || anArgCase == "-projection"
10039 || anArgCase == "-projtype"
10040 || anArgCase == "-projectiontype")
10041 {
10042 theDI << projTypeName (aCamera->ProjectionType()) << " ";
10043 }
10044 else if (anArgCase == "-ortho"
10045 || anArgCase == "-orthographic")
b5ac8292 10046 {
10047 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
6b62b2da 10048 }
10049 else if (anArgCase == "-persp"
10050 || anArgCase == "-perspective"
10051 || anArgCase == "-perspmono"
10052 || anArgCase == "-perspectivemono"
10053 || anArgCase == "-mono")
b5ac8292 10054 {
10055 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
10056 }
6b62b2da 10057 else if (anArgCase == "-stereo"
10058 || anArgCase == "-stereoscopic"
10059 || anArgCase == "-perspstereo"
10060 || anArgCase == "-perspectivestereo")
10061 {
10062 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
10063 }
10064 else if (anArgCase == "-left"
10065 || anArgCase == "-lefteye"
10066 || anArgCase == "-monoleft"
10067 || anArgCase == "-monolefteye"
10068 || anArgCase == "-perpsleft"
10069 || anArgCase == "-perpslefteye")
b5ac8292 10070 {
10071 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
10072 }
6b62b2da 10073 else if (anArgCase == "-right"
10074 || anArgCase == "-righteye"
10075 || anArgCase == "-monoright"
10076 || anArgCase == "-monorighteye"
10077 || anArgCase == "-perpsright")
b5ac8292 10078 {
10079 aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
10080 }
6b62b2da 10081 else if (anArgCase == "-dist"
10082 || anArgCase == "-distance")
b5ac8292 10083 {
6b62b2da 10084 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
10085 if (anArgValue != NULL
10086 && *anArgValue != '-')
10087 {
10088 ++anArgIter;
10089 aCamera->SetDistance (Draw::Atof (anArgValue));
10090 continue;
10091 }
10092 theDI << aCamera->Distance() << " ";
b5ac8292 10093 }
6b62b2da 10094 else if (anArgCase == "-iod")
b5ac8292 10095 {
6b62b2da 10096 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
10097 if (anArgValue != NULL
10098 && *anArgValue != '-')
10099 {
10100 ++anArgIter;
10101 aCamera->SetIOD (aCamera->GetIODType(), Draw::Atof (anArgValue));
10102 continue;
10103 }
10104 theDI << aCamera->IOD() << " ";
b5ac8292 10105 }
6b62b2da 10106 else if (anArgCase == "-iodtype")
b5ac8292 10107 {
6b62b2da 10108 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
10109 TCollection_AsciiString anValueCase (anArgValue);
10110 anValueCase.LowerCase();
10111 if (anValueCase == "abs"
10112 || anValueCase == "absolute")
10113 {
10114 ++anArgIter;
10115 aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
10116 continue;
10117 }
10118 else if (anValueCase == "rel"
10119 || anValueCase == "relative")
10120 {
10121 ++anArgIter;
10122 aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
10123 continue;
10124 }
10125 else if (*anArgValue != '-')
10126 {
10127 std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
10128 return 1;
10129 }
10130 switch (aCamera->GetIODType())
10131 {
10132 case Graphic3d_Camera::IODType_Absolute: theDI << "absolute "; break;
10133 case Graphic3d_Camera::IODType_Relative: theDI << "relative "; break;
10134 }
b5ac8292 10135 }
6b62b2da 10136 else if (anArgCase == "-zfocus")
b5ac8292 10137 {
6b62b2da 10138 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
10139 if (anArgValue != NULL
10140 && *anArgValue != '-')
10141 {
10142 ++anArgIter;
10143 aCamera->SetZFocus (aCamera->ZFocusType(), Draw::Atof (anArgValue));
10144 continue;
10145 }
10146 theDI << aCamera->ZFocus() << " ";
b5ac8292 10147 }
6b62b2da 10148 else if (anArgCase == "-zfocustype")
b5ac8292 10149 {
6b62b2da 10150 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
10151 TCollection_AsciiString anValueCase (anArgValue);
10152 anValueCase.LowerCase();
10153 if (anValueCase == "abs"
10154 || anValueCase == "absolute")
10155 {
10156 ++anArgIter;
10157 aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
10158 continue;
10159 }
10160 else if (anValueCase == "rel"
10161 || anValueCase == "relative")
10162 {
10163 ++anArgIter;
10164 aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
10165 continue;
10166 }
10167 else if (*anArgValue != '-')
10168 {
10169 std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
10170 return 1;
10171 }
10172 switch (aCamera->ZFocusType())
10173 {
10174 case Graphic3d_Camera::FocusType_Absolute: theDI << "absolute "; break;
10175 case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
10176 }
10177 }
10178 else if (anArgCase == "-fov"
10179 || anArgCase == "-fovy")
b5ac8292 10180 {
6b62b2da 10181 Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
10182 if (anArgValue != NULL
10183 && *anArgValue != '-')
10184 {
10185 ++anArgIter;
10186 aCamera->SetFOVy (Draw::Atof (anArgValue));
10187 continue;
10188 }
10189 theDI << aCamera->FOVy() << " ";
b5ac8292 10190 }
30a1b24e 10191 else if (aPrsName.IsEmpty()
10192 && !anArgCase.StartsWith ("-"))
10193 {
10194 aPrsName = anArg;
10195 }
b5ac8292 10196 else
10197 {
6b62b2da 10198 std::cout << "Error: unknown argument '" << anArg << "'\n";
b5ac8292 10199 return 1;
10200 }
10201 }
b5ac8292 10202
30a1b24e 10203 if (aPrsName.IsEmpty()
10204 || theArgsNb > 2)
10205 {
10206 aView->AutoZFit();
10207 aView->Redraw();
10208 }
10209
10210 if (!aPrsName.IsEmpty())
10211 {
10212 Handle(AIS_CameraFrustum) aCameraFrustum;
10213 if (GetMapOfAIS().IsBound2 (aPrsName))
10214 {
10215 // find existing object
10216 aCameraFrustum = Handle(AIS_CameraFrustum)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
10217 if (aCameraFrustum.IsNull())
10218 {
10219 std::cout << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum!\n";
10220 return 1;
10221 }
10222 }
10223
10224 if (aCameraFrustum.IsNull())
10225 {
10226 aCameraFrustum = new AIS_CameraFrustum();
10227 }
10228 else
10229 {
10230 // not include displayed object of old camera frustum in the new one.
10231 ViewerTest::GetAISContext()->Erase (aCameraFrustum, false);
10232 aView->ZFitAll();
10233 }
10234 aCameraFrustum->SetCameraFrustum (aView->Camera());
10235
10236 ViewerTest::Display (aPrsName, aCameraFrustum);
10237 }
b5ac8292 10238
10239 return 0;
10240}
10241
f978241f 10242//! Parse stereo output mode
10243inline Standard_Boolean parseStereoMode (Standard_CString theArg,
10244 Graphic3d_StereoMode& theMode)
10245{
10246 TCollection_AsciiString aFlag (theArg);
10247 aFlag.LowerCase();
10248 if (aFlag == "quadbuffer")
10249 {
10250 theMode = Graphic3d_StereoMode_QuadBuffer;
10251 }
10252 else if (aFlag == "anaglyph")
10253 {
10254 theMode = Graphic3d_StereoMode_Anaglyph;
10255 }
10256 else if (aFlag == "row"
10257 || aFlag == "rowinterlaced")
10258 {
10259 theMode = Graphic3d_StereoMode_RowInterlaced;
10260 }
10261 else if (aFlag == "col"
10262 || aFlag == "colinterlaced"
10263 || aFlag == "columninterlaced")
10264 {
10265 theMode = Graphic3d_StereoMode_ColumnInterlaced;
10266 }
10267 else if (aFlag == "chess"
10268 || aFlag == "chessboard")
10269 {
10270 theMode = Graphic3d_StereoMode_ChessBoard;
10271 }
10272 else if (aFlag == "sbs"
10273 || aFlag == "sidebyside")
10274 {
10275 theMode = Graphic3d_StereoMode_SideBySide;
10276 }
10277 else if (aFlag == "ou"
10278 || aFlag == "overunder")
10279 {
10280 theMode = Graphic3d_StereoMode_OverUnder;
10281 }
10282 else if (aFlag == "pageflip"
10283 || aFlag == "softpageflip")
10284 {
10285 theMode = Graphic3d_StereoMode_SoftPageFlip;
10286 }
10287 else
10288 {
10289 return Standard_False;
10290 }
10291 return Standard_True;
10292}
10293
10294//! Parse anaglyph filter
10295inline Standard_Boolean parseAnaglyphFilter (Standard_CString theArg,
10296 Graphic3d_RenderingParams::Anaglyph& theFilter)
10297{
10298 TCollection_AsciiString aFlag (theArg);
10299 aFlag.LowerCase();
10300 if (aFlag == "redcyansimple")
10301 {
10302 theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
10303 }
10304 else if (aFlag == "redcyan"
10305 || aFlag == "redcyanoptimized")
10306 {
10307 theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized;
10308 }
10309 else if (aFlag == "yellowbluesimple")
10310 {
10311 theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Simple;
10312 }
10313 else if (aFlag == "yellowblue"
10314 || aFlag == "yellowblueoptimized")
10315 {
10316 theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized;
10317 }
10318 else if (aFlag == "greenmagenta"
10319 || aFlag == "greenmagentasimple")
10320 {
10321 theFilter = Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple;
10322 }
10323 else
10324 {
10325 return Standard_False;
10326 }
10327 return Standard_True;
10328}
10329
b5ac8292 10330//==============================================================================
10331//function : VStereo
10332//purpose :
10333//==============================================================================
10334
10335static int VStereo (Draw_Interpretor& theDI,
10336 Standard_Integer theArgNb,
10337 const char** theArgVec)
10338{
f978241f 10339 Handle(V3d_View) aView = ViewerTest::CurrentView();
b5ac8292 10340 if (theArgNb < 2)
10341 {
b5ac8292 10342 if (aView.IsNull())
10343 {
f978241f 10344 std::cout << "Error: no active viewer!\n";
b5ac8292 10345 return 0;
10346 }
10347
10348 Standard_Boolean isActive = ViewerTest_myDefaultCaps.contextStereo;
10349 theDI << "Stereo " << (isActive ? "ON" : "OFF") << "\n";
bf02aa7d 10350 if (isActive)
10351 {
10352 TCollection_AsciiString aMode;
10353 switch (aView->RenderingParams().StereoMode)
10354 {
10355 case Graphic3d_StereoMode_QuadBuffer : aMode = "quadBuffer"; break;
10356 case Graphic3d_StereoMode_RowInterlaced : aMode = "rowInterlaced"; break;
10357 case Graphic3d_StereoMode_ColumnInterlaced : aMode = "columnInterlaced"; break;
10358 case Graphic3d_StereoMode_ChessBoard : aMode = "chessBoard"; break;
10359 case Graphic3d_StereoMode_SideBySide : aMode = "sideBySide"; break;
10360 case Graphic3d_StereoMode_OverUnder : aMode = "overUnder"; break;
10361 case Graphic3d_StereoMode_SoftPageFlip : aMode = "softpageflip"; break;
10362 case Graphic3d_StereoMode_Anaglyph :
10363 aMode = "anaglyph";
10364 switch (aView->RenderingParams().AnaglyphFilter)
10365 {
10366 case Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple : aMode.AssignCat (" (redCyanSimple)"); break;
10367 case Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized : aMode.AssignCat (" (redCyan)"); break;
10368 case Graphic3d_RenderingParams::Anaglyph_YellowBlue_Simple : aMode.AssignCat (" (yellowBlueSimple)"); break;
10369 case Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized: aMode.AssignCat (" (yellowBlue)"); break;
10370 case Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple : aMode.AssignCat (" (greenMagentaSimple)"); break;
10371 default: break;
10372 }
10373 default: break;
10374 }
10375 theDI << "Mode " << aMode << "\n";
10376 }
b5ac8292 10377 return 0;
10378 }
10379
f978241f 10380 Handle(Graphic3d_Camera) aCamera;
10381 Graphic3d_RenderingParams* aParams = NULL;
10382 Graphic3d_StereoMode aMode = Graphic3d_StereoMode_QuadBuffer;
10383 if (!aView.IsNull())
10384 {
10385 aParams = &aView->ChangeRenderingParams();
10386 aMode = aParams->StereoMode;
10387 aCamera = aView->Camera();
10388 }
10389
10390 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
10391 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
10392 {
10393 Standard_CString anArg = theArgVec[anArgIter];
10394 TCollection_AsciiString aFlag (anArg);
10395 aFlag.LowerCase();
10396 if (anUpdateTool.parseRedrawMode (aFlag))
10397 {
10398 continue;
10399 }
10400 else if (aFlag == "0"
10401 || aFlag == "off")
10402 {
10403 if (++anArgIter < theArgNb)
10404 {
10405 std::cout << "Error: wrong number of arguments!\n";
10406 return 1;
10407 }
10408
10409 if (!aCamera.IsNull()
10410 && aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
10411 {
10412 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
10413 }
10414 ViewerTest_myDefaultCaps.contextStereo = Standard_False;
10415 return 0;
10416 }
10417 else if (aFlag == "1"
10418 || aFlag == "on")
10419 {
10420 if (++anArgIter < theArgNb)
10421 {
10422 std::cout << "Error: wrong number of arguments!\n";
10423 return 1;
10424 }
10425
10426 if (!aCamera.IsNull())
10427 {
10428 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
10429 }
10430 ViewerTest_myDefaultCaps.contextStereo = Standard_True;
10431 return 0;
10432 }
10433 else if (aFlag == "-reverse"
10434 || aFlag == "-reversed"
10435 || aFlag == "-swap")
10436 {
10437 Standard_Boolean toEnable = Standard_True;
10438 if (++anArgIter < theArgNb
a5565a3c 10439 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
f978241f 10440 {
10441 --anArgIter;
10442 }
10443 aParams->ToReverseStereo = toEnable;
10444 }
10445 else if (aFlag == "-noreverse"
10446 || aFlag == "-noswap")
10447 {
10448 Standard_Boolean toDisable = Standard_True;
10449 if (++anArgIter < theArgNb
a5565a3c 10450 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toDisable))
f978241f 10451 {
10452 --anArgIter;
10453 }
10454 aParams->ToReverseStereo = !toDisable;
10455 }
10456 else if (aFlag == "-mode"
10457 || aFlag == "-stereomode")
10458 {
10459 if (++anArgIter >= theArgNb
10460 || !parseStereoMode (theArgVec[anArgIter], aMode))
10461 {
10462 std::cout << "Error: syntax error at '" << anArg << "'\n";
10463 return 1;
10464 }
10465
10466 if (aMode == Graphic3d_StereoMode_QuadBuffer)
10467 {
10468 ViewerTest_myDefaultCaps.contextStereo = Standard_True;
10469 }
10470 }
10471 else if (aFlag == "-anaglyph"
10472 || aFlag == "-anaglyphfilter")
10473 {
10474 Graphic3d_RenderingParams::Anaglyph aFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
10475 if (++anArgIter >= theArgNb
10476 || !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
10477 {
10478 std::cout << "Error: syntax error at '" << anArg << "'\n";
10479 return 1;
10480 }
10481
10482 aMode = Graphic3d_StereoMode_Anaglyph;
10483 aParams->AnaglyphFilter = aFilter;
10484 }
10485 else if (parseStereoMode (anArg, aMode)) // short syntax
10486 {
10487 if (aMode == Graphic3d_StereoMode_QuadBuffer)
10488 {
10489 ViewerTest_myDefaultCaps.contextStereo = Standard_True;
10490 }
10491 }
10492 else
10493 {
10494 std::cout << "Error: syntax error at '" << anArg << "'\n";
10495 return 1;
10496 }
10497 }
10498
10499 if (!aView.IsNull())
10500 {
10501 aParams->StereoMode = aMode;
10502 aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
10503 }
b5ac8292 10504 return 0;
10505}
10506
392ac980 10507//===============================================================================================
10508//function : VDefaults
10509//purpose :
10510//===============================================================================================
10511static int VDefaults (Draw_Interpretor& theDi,
10512 Standard_Integer theArgsNb,
10513 const char** theArgVec)
10514{
10515 const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
10516 if (aCtx.IsNull())
10517 {
14c7f553 10518 std::cout << "Error: no active viewer\n";
392ac980 10519 return 1;
10520 }
10521
10522 Handle(Prs3d_Drawer) aDefParams = aCtx->DefaultDrawer();
10523 if (theArgsNb < 2)
10524 {
10525 if (aDefParams->TypeOfDeflection() == Aspect_TOD_RELATIVE)
10526 {
10527 theDi << "DeflType: relative\n"
10528 << "DeviationCoeff: " << aDefParams->DeviationCoefficient() << "\n";
10529 }
10530 else
10531 {
10532 theDi << "DeflType: absolute\n"
10533 << "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
10534 }
10535 theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
4c513386 10536 theDi << "AutoTriangulation: " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
392ac980 10537 return 0;
10538 }
10539
10540 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
10541 {
10542 TCollection_AsciiString anArg (theArgVec[anArgIter]);
4c513386 10543 anArg.UpperCase();
10544 if (anArg == "-ABSDEFL"
10545 || anArg == "-ABSOLUTEDEFLECTION"
10546 || anArg == "-DEFL"
10547 || anArg == "-DEFLECTION")
392ac980 10548 {
4c513386 10549 if (++anArgIter >= theArgsNb)
10550 {
10551 std::cout << "Error: wrong syntax at " << anArg << "\n";
10552 return 1;
10553 }
392ac980 10554 aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
4c513386 10555 aDefParams->SetMaximalChordialDeviation (Draw::Atof (theArgVec[anArgIter]));
392ac980 10556 }
4c513386 10557 else if (anArg == "-RELDEFL"
10558 || anArg == "-RELATIVEDEFLECTION"
10559 || anArg == "-DEVCOEFF"
10560 || anArg == "-DEVIATIONCOEFF"
10561 || anArg == "-DEVIATIONCOEFFICIENT")
392ac980 10562 {
4c513386 10563 if (++anArgIter >= theArgsNb)
10564 {
10565 std::cout << "Error: wrong syntax at " << anArg << "\n";
10566 return 1;
10567 }
392ac980 10568 aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
4c513386 10569 aDefParams->SetDeviationCoefficient (Draw::Atof (theArgVec[anArgIter]));
392ac980 10570 }
4c513386 10571 else if (anArg == "-ANGDEFL"
10572 || anArg == "-ANGULARDEFL"
10573 || anArg == "-ANGULARDEFLECTION")
392ac980 10574 {
4c513386 10575 if (++anArgIter >= theArgsNb)
10576 {
10577 std::cout << "Error: wrong syntax at " << anArg << "\n";
10578 return 1;
10579 }
392ac980 10580 // currently HLRDeviationAngle is used instead of DeviationAngle in most places
4c513386 10581 aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
10582 }
385c43e7 10583 else if (anArg == "-AUTOTR"
10584 || anArg == "-AUTOTRIANG"
10585 || anArg == "-AUTOTRIANGULATION")
4c513386 10586 {
14c7f553 10587 ++anArgIter;
10588 bool toTurnOn = true;
10589 if (anArgIter >= theArgsNb
10590 || !ViewerTest::ParseOnOff (theArgVec[anArgIter], toTurnOn))
4c513386 10591 {
14c7f553 10592 std::cout << "Syntax error at '" << anArg << "'\n";
4c513386 10593 return 1;
10594 }
14c7f553 10595 aDefParams->SetAutoTriangulation (toTurnOn);
392ac980 10596 }
10597 else
10598 {
14c7f553 10599 std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
10600 return 1;
392ac980 10601 }
10602 }
10603
10604 return 0;
10605}
10606
12381341 10607//! Auxiliary method
10608inline void addLight (const Handle(V3d_Light)& theLightNew,
992ed6b3 10609 const Graphic3d_ZLayerId theLayer,
12381341 10610 const Standard_Boolean theIsGlobal)
10611{
10612 if (theLightNew.IsNull())
10613 {
10614 return;
10615 }
10616
992ed6b3 10617 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
10618 if (theLayer == Graphic3d_ZLayerId_UNKNOWN)
12381341 10619 {
992ed6b3 10620 aViewer->AddLight (theLightNew);
10621 if (theIsGlobal)
10622 {
10623 aViewer->SetLightOn (theLightNew);
10624 }
10625 else
10626 {
10627 ViewerTest::CurrentView()->SetLightOn (theLightNew);
10628 }
12381341 10629 }
10630 else
10631 {
992ed6b3 10632 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (theLayer);
10633 if (aSettings.Lights().IsNull())
10634 {
10635 aSettings.SetLights (new Graphic3d_LightSet());
10636 }
10637 aSettings.Lights()->Add (theLightNew);
10638 aViewer->SetZLayerSettings (theLayer, aSettings);
12381341 10639 }
10640}
10641
10642//! Auxiliary method
10643inline Standard_Integer getLightId (const TCollection_AsciiString& theArgNext)
10644{
10645 TCollection_AsciiString anArgNextCase (theArgNext);
10646 anArgNextCase.UpperCase();
10647 if (anArgNextCase.Length() > 5
10648 && anArgNextCase.SubString (1, 5).IsEqual ("LIGHT"))
10649 {
10650 return theArgNext.SubString (6, theArgNext.Length()).IntegerValue();
10651 }
10652 else
10653 {
10654 return theArgNext.IntegerValue();
10655 }
10656}
10657
10658//===============================================================================================
10659//function : VLight
10660//purpose :
10661//===============================================================================================
10662static int VLight (Draw_Interpretor& theDi,
10663 Standard_Integer theArgsNb,
10664 const char** theArgVec)
10665{
10666 Handle(V3d_View) aView = ViewerTest::CurrentView();
10667 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
10668 if (aView.IsNull()
10669 || aViewer.IsNull())
10670 {
10671 std::cerr << "No active viewer!\n";
10672 return 1;
10673 }
10674
ee2be2a8 10675 Standard_Real anXYZ[3] = {};
10676 Standard_Real anAtten[2] = {};
12381341 10677 if (theArgsNb < 2)
10678 {
10679 // print lights info
10680 Standard_Integer aLightId = 0;
6a24c6de 10681 for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightId)
12381341 10682 {
6a24c6de 10683 Handle(V3d_Light) aLight = aLightIter.Value();
12381341 10684 const Quantity_Color aColor = aLight->Color();
992ed6b3 10685 theDi << "Light #" << aLightId
10686 << (!aLight->Name().IsEmpty() ? (TCollection_AsciiString(" ") + aLight->Name()) : "")
10687 << " [" << aLight->GetId() << "]" << "\n";
12381341 10688 switch (aLight->Type())
10689 {
10690 case V3d_AMBIENT:
10691 {
189f85a3 10692 theDi << " Type: Ambient\n";
10693 theDi << " Intensity: " << aLight->Intensity() << "\n";
12381341 10694 break;
10695 }
10696 case V3d_DIRECTIONAL:
10697 {
189f85a3 10698 theDi << " Type: Directional\n";
10699 theDi << " Intensity: " << aLight->Intensity() << "\n";
10700 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
10701 theDi << " Smoothness: " << aLight->Smoothness() << "\n";
992ed6b3 10702 aLight->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
10703 theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
12381341 10704 break;
10705 }
10706 case V3d_POSITIONAL:
10707 {
189f85a3 10708 theDi << " Type: Positional\n";
10709 theDi << " Intensity: " << aLight->Intensity() << "\n";
10710 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
10711 theDi << " Smoothness: " << aLight->Smoothness() << "\n";
992ed6b3 10712 aLight->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
10713 theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
10714 aLight->Attenuation (anAtten[0], anAtten[1]);
10715 theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
12381341 10716 break;
10717 }
10718 case V3d_SPOT:
10719 {
189f85a3 10720 theDi << " Type: Spot\n";
10721 theDi << " Intensity: " << aLight->Intensity() << "\n";
10722 theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
992ed6b3 10723 aLight->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
10724 theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
10725 aLight->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
10726 theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
10727 aLight->Attenuation (anAtten[0], anAtten[1]);
10728 theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
10729 theDi << " Angle: " << (aLight->Angle() * 180.0 / M_PI) << "\n";
10730 theDi << " Exponent: " << aLight->Concentration() << "\n";
12381341 10731 break;
10732 }
10733 default:
10734 {
189f85a3 10735 theDi << " Type: UNKNOWN\n";
12381341 10736 break;
10737 }
10738 }
992ed6b3 10739 theDi << " Color: " << aColor.Red() << ", " << aColor.Green() << ", " << aColor.Blue() << " [" << Quantity_Color::StringName (aColor.Name()) << "]\n";
12381341 10740 }
10741 }
10742
10743 Handle(V3d_Light) aLightNew;
10744 Handle(V3d_Light) aLightOld;
992ed6b3 10745 Graphic3d_ZLayerId aLayer = Graphic3d_ZLayerId_UNKNOWN;
12381341 10746 Standard_Boolean isGlobal = Standard_True;
10747 Standard_Boolean toCreate = Standard_False;
761d8807 10748 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
12381341 10749 for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
10750 {
992ed6b3 10751 Handle(V3d_Light) aLightCurr = aLightNew.IsNull() ? aLightOld : aLightNew;
12381341 10752
10753 TCollection_AsciiString aName, aValue;
10754 const TCollection_AsciiString anArg (theArgVec[anArgIt]);
10755 TCollection_AsciiString anArgCase (anArg);
10756 anArgCase.UpperCase();
761d8807 10757 if (anUpdateTool.parseRedrawMode (anArg))
10758 {
10759 continue;
10760 }
10761
12381341 10762 if (anArgCase.IsEqual ("NEW")
10763 || anArgCase.IsEqual ("ADD")
992ed6b3 10764 || anArgCase.IsEqual ("CREATE")
10765 || anArgCase.IsEqual ("-NEW")
10766 || anArgCase.IsEqual ("-ADD")
10767 || anArgCase.IsEqual ("-CREATE"))
12381341 10768 {
10769 toCreate = Standard_True;
10770 }
992ed6b3 10771 else if (anArgCase.IsEqual ("-LAYER")
10772 || anArgCase.IsEqual ("-ZLAYER"))
10773 {
10774 if (++anArgIt >= theArgsNb)
10775 {
10776 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10777 return 1;
10778 }
10779
10780 TCollection_AsciiString aValStr (theArgVec[anArgIt]);
10781 aValStr.LowerCase();
10782 if (aValStr == "default"
10783 || aValStr == "def")
10784 {
10785 aLayer = Graphic3d_ZLayerId_Default;
10786 }
10787 else if (aValStr == "top")
10788 {
10789 aLayer = Graphic3d_ZLayerId_Top;
10790 }
10791 else if (aValStr == "topmost")
10792 {
10793 aLayer = Graphic3d_ZLayerId_Topmost;
10794 }
10795 else if (aValStr == "toposd"
10796 || aValStr == "osd")
10797 {
10798 aLayer = Graphic3d_ZLayerId_TopOSD;
10799 }
10800 else if (aValStr == "botosd"
10801 || aValStr == "bottom")
10802 {
10803 aLayer = Graphic3d_ZLayerId_BotOSD;
10804 }
10805 else if (aValStr.IsIntegerValue())
10806 {
10807 aLayer = Draw::Atoi (theArgVec[anArgIt]);
10808 }
10809 else
10810 {
10811 std::cout << "Wrong syntax at argument '" << anArg << "'!\n";
10812 return 1;
10813 }
10814 }
12381341 10815 else if (anArgCase.IsEqual ("GLOB")
992ed6b3 10816 || anArgCase.IsEqual ("GLOBAL")
10817 || anArgCase.IsEqual ("-GLOB")
10818 || anArgCase.IsEqual ("-GLOBAL"))
12381341 10819 {
10820 isGlobal = Standard_True;
10821 }
10822 else if (anArgCase.IsEqual ("LOC")
992ed6b3 10823 || anArgCase.IsEqual ("LOCAL")
10824 || anArgCase.IsEqual ("-LOC")
10825 || anArgCase.IsEqual ("-LOCAL"))
12381341 10826 {
10827 isGlobal = Standard_False;
10828 }
4fe9ad57 10829 else if (anArgCase.IsEqual ("DEF")
992ed6b3 10830 || anArgCase.IsEqual ("DEFAULTS")
10831 || anArgCase.IsEqual ("-DEF")
10832 || anArgCase.IsEqual ("-DEFAULTS"))
4fe9ad57 10833 {
10834 toCreate = Standard_False;
10835 aViewer->SetDefaultLights();
10836 }
10837 else if (anArgCase.IsEqual ("CLR")
992ed6b3 10838 || anArgCase.IsEqual ("CLEAR")
10839 || anArgCase.IsEqual ("-CLR")
10840 || anArgCase.IsEqual ("-CLEAR"))
4fe9ad57 10841 {
10842 toCreate = Standard_False;
992ed6b3 10843
10844 TColStd_SequenceOfInteger aLayers;
10845 aViewer->GetAllZLayers (aLayers);
10846 for (TColStd_SequenceOfInteger::Iterator aLayeriter (aLayers); aLayeriter.More(); aLayeriter.Next())
4fe9ad57 10847 {
992ed6b3 10848 if (aLayeriter.Value() == aLayer
10849 || aLayer == Graphic3d_ZLayerId_UNKNOWN)
10850 {
10851 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayeriter.Value());
10852 aSettings.SetLights (Handle(Graphic3d_LightSet)());
10853 aViewer->SetZLayerSettings (aLayeriter.Value(), aSettings);
10854 if (aLayer != Graphic3d_ZLayerId_UNKNOWN)
10855 {
10856 break;
10857 }
10858 }
10859 }
10860
10861 if (aLayer == Graphic3d_ZLayerId_UNKNOWN)
10862 {
10863 for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More();)
10864 {
10865 Handle(V3d_Light) aLight = aLightIter.Value();
10866 aViewer->DelLight (aLight);
10867 aLightIter = aView->ActiveLightIterator();
10868 }
4fe9ad57 10869 }
10870 }
12381341 10871 else if (anArgCase.IsEqual ("AMB")
10872 || anArgCase.IsEqual ("AMBIENT")
10873 || anArgCase.IsEqual ("AMBLIGHT"))
10874 {
12381341 10875 if (!toCreate)
10876 {
10877 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10878 return 1;
10879 }
992ed6b3 10880
10881 addLight (aLightNew, aLayer, isGlobal);
12381341 10882 toCreate = Standard_False;
992ed6b3 10883 aLightNew = new V3d_AmbientLight();
12381341 10884 }
10885 else if (anArgCase.IsEqual ("DIRECTIONAL")
10886 || anArgCase.IsEqual ("DIRLIGHT"))
10887 {
12381341 10888 if (!toCreate)
10889 {
10890 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10891 return 1;
10892 }
992ed6b3 10893
10894 addLight (aLightNew, aLayer, isGlobal);
12381341 10895 toCreate = Standard_False;
992ed6b3 10896 aLightNew = new V3d_DirectionalLight();
12381341 10897 }
10898 else if (anArgCase.IsEqual ("SPOT")
10899 || anArgCase.IsEqual ("SPOTLIGHT"))
10900 {
12381341 10901 if (!toCreate)
10902 {
10903 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10904 return 1;
10905 }
992ed6b3 10906
10907 addLight (aLightNew, aLayer, isGlobal);
12381341 10908 toCreate = Standard_False;
992ed6b3 10909 aLightNew = new V3d_SpotLight (gp_Pnt (0.0, 0.0, 0.0));
12381341 10910 }
10911 else if (anArgCase.IsEqual ("POSLIGHT")
10912 || anArgCase.IsEqual ("POSITIONAL"))
10913 {
12381341 10914 if (!toCreate)
10915 {
10916 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10917 return 1;
10918 }
992ed6b3 10919
10920 addLight (aLightNew, aLayer, isGlobal);
12381341 10921 toCreate = Standard_False;
992ed6b3 10922 aLightNew = new V3d_PositionalLight (gp_Pnt (0.0, 0.0, 0.0));
12381341 10923 }
992ed6b3 10924 else if (anArgCase.IsEqual ("CHANGE")
10925 || anArgCase.IsEqual ("-CHANGE"))
12381341 10926 {
12381341 10927 if (++anArgIt >= theArgsNb)
10928 {
10929 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10930 return 1;
10931 }
10932
992ed6b3 10933 addLight (aLightNew, aLayer, isGlobal);
10934 aLightNew.Nullify();
12381341 10935 const Standard_Integer aLightId = getLightId (theArgVec[anArgIt]);
10936 Standard_Integer aLightIt = 0;
6a24c6de 10937 for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightIt)
12381341 10938 {
10939 if (aLightIt == aLightId)
10940 {
6a24c6de 10941 aLightOld = aLightIter.Value();
12381341 10942 break;
10943 }
10944 }
10945
10946 if (aLightOld.IsNull())
10947 {
10948 std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
10949 return 1;
10950 }
10951 }
10952 else if (anArgCase.IsEqual ("DEL")
992ed6b3 10953 || anArgCase.IsEqual ("DELETE")
10954 || anArgCase.IsEqual ("-DEL")
10955 || anArgCase.IsEqual ("-DELETE"))
12381341 10956 {
10957 Handle(V3d_Light) aLightDel;
10958 if (++anArgIt >= theArgsNb)
10959 {
10960 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
10961 return 1;
10962 }
10963
10964 const TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
10965 const Standard_Integer aLightDelId = getLightId (theArgVec[anArgIt]);
10966 Standard_Integer aLightIt = 0;
6a24c6de 10967 for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightIt)
12381341 10968 {
6a24c6de 10969 aLightDel = aLightIter.Value();
12381341 10970 if (aLightIt == aLightDelId)
10971 {
10972 break;
10973 }
10974 }
992ed6b3 10975 if (aLightDel.IsNull())
10976 {
10977 continue;
10978 }
10979
10980 TColStd_SequenceOfInteger aLayers;
10981 aViewer->GetAllZLayers (aLayers);
10982 for (TColStd_SequenceOfInteger::Iterator aLayeriter (aLayers); aLayeriter.More(); aLayeriter.Next())
10983 {
10984 if (aLayeriter.Value() == aLayer
10985 || aLayer == Graphic3d_ZLayerId_UNKNOWN)
10986 {
10987 Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (aLayeriter.Value());
10988 if (!aSettings.Lights().IsNull())
10989 {
10990 aSettings.Lights()->Remove (aLightDel);
10991 if (aSettings.Lights()->IsEmpty())
10992 {
10993 aSettings.SetLights (Handle(Graphic3d_LightSet)());
10994 }
10995 }
10996 aViewer->SetZLayerSettings (aLayeriter.Value(), aSettings);
10997 if (aLayer != Graphic3d_ZLayerId_UNKNOWN)
10998 {
10999 break;
11000 }
11001 }
11002 }
11003
11004 if (aLayer == Graphic3d_ZLayerId_UNKNOWN)
12381341 11005 {
11006 aViewer->DelLight (aLightDel);
11007 }
11008 }
11009 else if (anArgCase.IsEqual ("COLOR")
992ed6b3 11010 || anArgCase.IsEqual ("COLOUR")
11011 || anArgCase.IsEqual ("-COLOR")
11012 || anArgCase.IsEqual ("-COLOUR"))
12381341 11013 {
992ed6b3 11014 if (++anArgIt >= theArgsNb
11015 || aLightCurr.IsNull())
12381341 11016 {
11017 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11018 return 1;
11019 }
11020
11021 TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
11022 anArgNext.UpperCase();
11023 const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
992ed6b3 11024 aLightCurr->SetColor (aColor);
12381341 11025 }
11026 else if (anArgCase.IsEqual ("POS")
992ed6b3 11027 || anArgCase.IsEqual ("POSITION")
11028 || anArgCase.IsEqual ("-POS")
11029 || anArgCase.IsEqual ("-POSITION"))
12381341 11030 {
992ed6b3 11031 if ((anArgIt + 3) >= theArgsNb
11032 || aLightCurr.IsNull()
11033 || (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
11034 && aLightCurr->Type() != Graphic3d_TOLS_SPOT))
12381341 11035 {
11036 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11037 return 1;
11038 }
11039
11040 anXYZ[0] = Atof (theArgVec[++anArgIt]);
11041 anXYZ[1] = Atof (theArgVec[++anArgIt]);
11042 anXYZ[2] = Atof (theArgVec[++anArgIt]);
992ed6b3 11043 aLightCurr->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
12381341 11044 }
11045 else if (anArgCase.IsEqual ("DIR")
992ed6b3 11046 || anArgCase.IsEqual ("DIRECTION")
11047 || anArgCase.IsEqual ("-DIR")
11048 || anArgCase.IsEqual ("-DIRECTION"))
12381341 11049 {
992ed6b3 11050 if ((anArgIt + 3) >= theArgsNb
11051 || aLightCurr.IsNull()
11052 || (aLightCurr->Type() != Graphic3d_TOLS_DIRECTIONAL
11053 && aLightCurr->Type() != Graphic3d_TOLS_SPOT))
12381341 11054 {
11055 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11056 return 1;
11057 }
11058
11059 anXYZ[0] = Atof (theArgVec[++anArgIt]);
11060 anXYZ[1] = Atof (theArgVec[++anArgIt]);
11061 anXYZ[2] = Atof (theArgVec[++anArgIt]);
992ed6b3 11062 aLightCurr->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
12381341 11063 }
189f85a3 11064 else if (anArgCase.IsEqual ("SM")
992ed6b3 11065 || anArgCase.IsEqual ("SMOOTHNESS")
11066 || anArgCase.IsEqual ("-SM")
11067 || anArgCase.IsEqual ("-SMOOTHNESS"))
189f85a3 11068 {
992ed6b3 11069 if (++anArgIt >= theArgsNb
11070 || aLightCurr.IsNull())
189f85a3 11071 {
11072 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11073 return 1;
11074 }
11075
992ed6b3 11076 Standard_ShortReal aSmoothness = (Standard_ShortReal )Atof (theArgVec[anArgIt]);
11077 if (Abs (aSmoothness) <= ShortRealEpsilon())
189f85a3 11078 {
11079 aLightCurr->SetIntensity (1.f);
11080 }
992ed6b3 11081 else if (Abs (aLightCurr->Smoothness()) <= ShortRealEpsilon())
189f85a3 11082 {
11083 aLightCurr->SetIntensity ((aSmoothness * aSmoothness) / 3.f);
11084 }
11085 else
11086 {
11087 Standard_ShortReal aSmoothnessRatio = static_cast<Standard_ShortReal> (aSmoothness / aLightCurr->Smoothness());
11088 aLightCurr->SetIntensity (aLightCurr->Intensity() / (aSmoothnessRatio * aSmoothnessRatio));
11089 }
11090
992ed6b3 11091 if (aLightCurr->Type() == Graphic3d_TOLS_POSITIONAL)
189f85a3 11092 {
992ed6b3 11093 aLightCurr->SetSmoothRadius (aSmoothness);
189f85a3 11094 }
992ed6b3 11095 else if (aLightCurr->Type() == Graphic3d_TOLS_DIRECTIONAL)
189f85a3 11096 {
992ed6b3 11097 aLightCurr->SetSmoothAngle (aSmoothness);
189f85a3 11098 }
11099 }
11100 else if (anArgCase.IsEqual ("INT")
992ed6b3 11101 || anArgCase.IsEqual ("INTENSITY")
11102 || anArgCase.IsEqual ("-INT")
11103 || anArgCase.IsEqual ("-INTENSITY"))
189f85a3 11104 {
992ed6b3 11105 if (++anArgIt >= theArgsNb
11106 || aLightCurr.IsNull())
189f85a3 11107 {
11108 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11109 return 1;
11110 }
11111
992ed6b3 11112 Standard_ShortReal aIntensity = (Standard_ShortReal )Atof (theArgVec[anArgIt]);
11113 aLightCurr->SetIntensity (aIntensity);
189f85a3 11114 }
4fe9ad57 11115 else if (anArgCase.IsEqual ("ANG")
992ed6b3 11116 || anArgCase.IsEqual ("ANGLE")
11117 || anArgCase.IsEqual ("-ANG")
11118 || anArgCase.IsEqual ("-ANGLE"))
4fe9ad57 11119 {
992ed6b3 11120 if (++anArgIt >= theArgsNb
11121 || aLightCurr.IsNull()
11122 || aLightCurr->Type() != Graphic3d_TOLS_SPOT)
4fe9ad57 11123 {
11124 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11125 return 1;
11126 }
11127
992ed6b3 11128 Standard_ShortReal anAngle = (Standard_ShortReal )Atof (theArgVec[anArgIt]);
11129 aLightCurr->SetAngle (Standard_ShortReal (anAngle / 180.0 * M_PI));
4fe9ad57 11130 }
12381341 11131 else if (anArgCase.IsEqual ("CONSTATTEN")
992ed6b3 11132 || anArgCase.IsEqual ("CONSTATTENUATION")
11133 || anArgCase.IsEqual ("-CONSTATTEN")
11134 || anArgCase.IsEqual ("-CONSTATTENUATION"))
12381341 11135 {
992ed6b3 11136 if (++anArgIt >= theArgsNb
11137 || aLightCurr.IsNull()
11138 || (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
11139 && aLightCurr->Type() != Graphic3d_TOLS_SPOT))
12381341 11140 {
11141 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11142 return 1;
11143 }
11144
992ed6b3 11145 aLightCurr->Attenuation (anAtten[0], anAtten[1]);
11146 anAtten[0] = Atof (theArgVec[anArgIt]);
11147 aLightCurr->SetAttenuation ((Standard_ShortReal )anAtten[0], (Standard_ShortReal )anAtten[1]);
12381341 11148 }
11149 else if (anArgCase.IsEqual ("LINATTEN")
11150 || anArgCase.IsEqual ("LINEARATTEN")
992ed6b3 11151 || anArgCase.IsEqual ("LINEARATTENUATION")
11152 || anArgCase.IsEqual ("-LINATTEN")
11153 || anArgCase.IsEqual ("-LINEARATTEN")
11154 || anArgCase.IsEqual ("-LINEARATTENUATION"))
12381341 11155 {
992ed6b3 11156 if (++anArgIt >= theArgsNb
11157 || aLightCurr.IsNull()
11158 || (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
11159 && aLightCurr->Type() != Graphic3d_TOLS_SPOT))
12381341 11160 {
11161 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11162 return 1;
11163 }
11164
992ed6b3 11165 aLightCurr->Attenuation (anAtten[0], anAtten[1]);
11166 anAtten[1] = Atof (theArgVec[anArgIt]);
11167 aLightCurr->SetAttenuation ((Standard_ShortReal )anAtten[0], (Standard_ShortReal )anAtten[1]);
12381341 11168 }
11169 else if (anArgCase.IsEqual ("EXP")
11170 || anArgCase.IsEqual ("EXPONENT")
11171 || anArgCase.IsEqual ("SPOTEXP")
992ed6b3 11172 || anArgCase.IsEqual ("SPOTEXPONENT")
11173 || anArgCase.IsEqual ("-EXP")
11174 || anArgCase.IsEqual ("-EXPONENT")
11175 || anArgCase.IsEqual ("-SPOTEXP")
11176 || anArgCase.IsEqual ("-SPOTEXPONENT"))
12381341 11177 {
992ed6b3 11178 if (++anArgIt >= theArgsNb
11179 || aLightCurr.IsNull()
11180 || aLightCurr->Type() != Graphic3d_TOLS_SPOT)
12381341 11181 {
11182 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11183 return 1;
11184 }
11185
992ed6b3 11186 aLightCurr->SetConcentration ((Standard_ShortReal )Atof (theArgVec[anArgIt]));
12381341 11187 }
11188 else if (anArgCase.IsEqual ("HEAD")
992ed6b3 11189 || anArgCase.IsEqual ("HEADLIGHT")
11190 || anArgCase.IsEqual ("-HEAD")
11191 || anArgCase.IsEqual ("-HEADLIGHT"))
12381341 11192 {
992ed6b3 11193 if (aLightCurr.IsNull()
11194 || aLightCurr->Type() == Graphic3d_TOLS_AMBIENT)
12381341 11195 {
11196 std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
11197 return 1;
11198 }
11199
992ed6b3 11200 Standard_Boolean isHeadLight = Standard_True;
11201 if (anArgIt + 1 < theArgsNb
11202 && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], isHeadLight))
12381341 11203 {
992ed6b3 11204 ++anArgIt;
12381341 11205 }
992ed6b3 11206 aLightCurr->SetHeadlight (isHeadLight);
12381341 11207 }
11208 else
11209 {
11210 std::cerr << "Warning: unknown argument '" << anArg << "'\n";
11211 }
11212 }
11213
992ed6b3 11214 addLight (aLightNew, aLayer, isGlobal);
12381341 11215 return 0;
11216}
11217
67312b79 11218//===============================================================================================
11219//function : VPBREnvironment
11220//purpose :
11221//===============================================================================================
11222static int VPBREnvironment (Draw_Interpretor&,
11223 Standard_Integer theArgsNb,
11224 const char** theArgVec)
11225{
11226 if (theArgsNb > 2)
11227 {
11228 std::cerr << "Error: 'vpbrenv' command has only one argument\n";
11229 return 1;
11230 }
11231
11232 Handle(V3d_View) aView = ViewerTest::CurrentView();
11233 if (aView.IsNull())
11234 {
11235 std::cerr << "Error: no active viewer!\n";
11236 return 1;
11237 }
11238
11239 TCollection_AsciiString anArg = TCollection_AsciiString (theArgVec[1]);
11240 anArg.LowerCase();
11241
11242 if (anArg == "-generate"
11243 || anArg == "-gen")
11244 {
11245 aView->GeneratePBREnvironment (Standard_True);
11246 }
11247 else if (anArg == "-clear")
11248 {
11249 aView->ClearPBREnvironment (Standard_True);
11250 }
11251 else
11252 {
11253 std::cerr << "Error: unknown argument [" << theArgVec[1] << "] for 'vpbrenv' command\n";
11254 return 1;
11255 }
11256
11257 return 0;
11258}
11259
15669413 11260//! Read Graphic3d_RenderingParams::PerfCounters flag.
11261static Standard_Boolean parsePerfStatsFlag (const TCollection_AsciiString& theValue,
11262 Standard_Boolean& theToReset,
11263 Graphic3d_RenderingParams::PerfCounters& theFlagsRem,
11264 Graphic3d_RenderingParams::PerfCounters& theFlagsAdd)
11265{
11266 Graphic3d_RenderingParams::PerfCounters aFlag = Graphic3d_RenderingParams::PerfCounters_NONE;
11267 TCollection_AsciiString aVal = theValue;
11268 Standard_Boolean toReverse = Standard_False;
11269 if (aVal == "none")
11270 {
11271 theToReset = Standard_True;
11272 return Standard_True;
11273 }
11274 else if (aVal.StartsWith ("-"))
11275 {
11276 toReverse = Standard_True;
11277 aVal = aVal.SubString (2, aVal.Length());
11278 }
11279 else if (aVal.StartsWith ("no"))
11280 {
11281 toReverse = Standard_True;
11282 aVal = aVal.SubString (3, aVal.Length());
11283 }
11284 else if (aVal.StartsWith ("+"))
11285 {
11286 aVal = aVal.SubString (2, aVal.Length());
11287 }
11288 else
11289 {
11290 theToReset = Standard_True;
11291 }
11292
11293 if ( aVal == "fps"
11294 || aVal == "framerate") aFlag = Graphic3d_RenderingParams::PerfCounters_FrameRate;
11295 else if (aVal == "cpu") aFlag = Graphic3d_RenderingParams::PerfCounters_CPU;
11296 else if (aVal == "layers") aFlag = Graphic3d_RenderingParams::PerfCounters_Layers;
11297 else if (aVal == "structs"
11298 || aVal == "structures"
11299 || aVal == "objects") aFlag = Graphic3d_RenderingParams::PerfCounters_Structures;
11300 else if (aVal == "groups") aFlag = Graphic3d_RenderingParams::PerfCounters_Groups;
11301 else if (aVal == "arrays") aFlag = Graphic3d_RenderingParams::PerfCounters_GroupArrays;
11302 else if (aVal == "tris"
11303 || aVal == "triangles") aFlag = Graphic3d_RenderingParams::PerfCounters_Triangles;
11304 else if (aVal == "pnts"
11305 || aVal == "points") aFlag = Graphic3d_RenderingParams::PerfCounters_Points;
11306 else if (aVal == "mem"
11307 || aVal == "gpumem"
11308 || aVal == "estimmem") aFlag = Graphic3d_RenderingParams::PerfCounters_EstimMem;
5e30547b 11309 else if (aVal == "skipimmediate"
11310 || aVal == "noimmediate") aFlag = Graphic3d_RenderingParams::PerfCounters_SkipImmediate;
11311 else if (aVal == "frametime"
11312 || aVal == "frametimers"
11313 || aVal == "time") aFlag = Graphic3d_RenderingParams::PerfCounters_FrameTime;
15669413 11314 else if (aVal == "basic") aFlag = Graphic3d_RenderingParams::PerfCounters_Basic;
11315 else if (aVal == "extended"
11316 || aVal == "verbose"
11317 || aVal == "extra") aFlag = Graphic3d_RenderingParams::PerfCounters_Extended;
5e30547b 11318 else if (aVal == "full"
11319 || aVal == "all") aFlag = Graphic3d_RenderingParams::PerfCounters_All;
15669413 11320 else
11321 {
11322 return Standard_False;
11323 }
11324
11325 if (toReverse)
11326 {
11327 theFlagsRem = Graphic3d_RenderingParams::PerfCounters(theFlagsRem | aFlag);
11328 }
11329 else
11330 {
11331 theFlagsAdd = Graphic3d_RenderingParams::PerfCounters(theFlagsAdd | aFlag);
11332 }
11333 return Standard_True;
11334}
11335
11336//! Read Graphic3d_RenderingParams::PerfCounters flags.
11337static Standard_Boolean convertToPerfStatsFlags (const TCollection_AsciiString& theValue,
11338 Graphic3d_RenderingParams::PerfCounters& theFlags)
11339{
11340 TCollection_AsciiString aValue = theValue;
11341 Graphic3d_RenderingParams::PerfCounters aFlagsRem = Graphic3d_RenderingParams::PerfCounters_NONE;
11342 Graphic3d_RenderingParams::PerfCounters aFlagsAdd = Graphic3d_RenderingParams::PerfCounters_NONE;
11343 Standard_Boolean toReset = Standard_False;
11344 for (;;)
11345 {
11346 Standard_Integer aSplitPos = aValue.Search ("|");
11347 if (aSplitPos <= 0)
11348 {
11349 if (!parsePerfStatsFlag (aValue, toReset, aFlagsRem, aFlagsAdd))
11350 {
11351 return Standard_False;
11352 }
11353 if (toReset)
11354 {
11355 theFlags = Graphic3d_RenderingParams::PerfCounters_NONE;
11356 }
11357 theFlags = Graphic3d_RenderingParams::PerfCounters(theFlags | aFlagsAdd);
11358 theFlags = Graphic3d_RenderingParams::PerfCounters(theFlags & ~aFlagsRem);
11359 return Standard_True;
11360 }
11361
11362 if (aSplitPos > 1)
11363 {
11364 TCollection_AsciiString aSubValue = aValue.SubString (1, aSplitPos - 1);
11365 if (!parsePerfStatsFlag (aSubValue, toReset, aFlagsRem, aFlagsAdd))
11366 {
11367 return Standard_False;
11368 }
11369 }
11370 aValue = aValue.SubString (aSplitPos + 1, aValue.Length());
11371 }
11372}
11373
e276548b 11374//=======================================================================
bc8c79bb 11375//function : VRenderParams
11376//purpose : Enables/disables rendering features
e276548b 11377//=======================================================================
11378
bc8c79bb 11379static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
11380 Standard_Integer theArgNb,
11381 const char** theArgVec)
e276548b 11382{
7ae4a307 11383 Handle(V3d_View) aView = ViewerTest::CurrentView();
11384 if (aView.IsNull())
e276548b 11385 {
bc8c79bb 11386 std::cerr << "Error: no active viewer!\n";
e276548b 11387 return 1;
11388 }
bc8c79bb 11389
11390 Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
6b62b2da 11391 TCollection_AsciiString aCmdName (theArgVec[0]);
11392 aCmdName.LowerCase();
11393 if (aCmdName == "vraytrace")
11394 {
11395 if (theArgNb == 1)
11396 {
11397 theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "on" : "off") << " ";
11398 return 0;
11399 }
11400 else if (theArgNb == 2)
11401 {
11402 TCollection_AsciiString aValue (theArgVec[1]);
11403 aValue.LowerCase();
11404 if (aValue == "on"
11405 || aValue == "1")
11406 {
11407 aParams.Method = Graphic3d_RM_RAYTRACING;
11408 aView->Redraw();
11409 return 0;
11410 }
11411 else if (aValue == "off"
11412 || aValue == "0")
11413 {
11414 aParams.Method = Graphic3d_RM_RASTERIZATION;
11415 aView->Redraw();
11416 return 0;
11417 }
11418 else
11419 {
11420 std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
11421 return 1;
11422 }
11423 }
11424 else
11425 {
11426 std::cout << "Error: wrong number of arguments\n";
11427 return 1;
11428 }
11429 }
bc8c79bb 11430
11431 if (theArgNb < 2)
e276548b 11432 {
bc8c79bb 11433 theDI << "renderMode: ";
11434 switch (aParams.Method)
11435 {
11436 case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
11437 case Graphic3d_RM_RAYTRACING: theDI << "raytrace "; break;
11438 }
11439 theDI << "\n";
a1073ae2 11440 theDI << "transparency: ";
11441 switch (aParams.TransparencyMethod)
11442 {
11443 case Graphic3d_RTM_BLEND_UNORDERED: theDI << "Basic blended transparency with non-commuting operator "; break;
11444 case Graphic3d_RTM_BLEND_OIT: theDI << "Weighted Blended Order-Independent Transparency, depth weight factor: "
11445 << TCollection_AsciiString (aParams.OitDepthFactor); break;
11446 }
11447 theDI << "\n";
b4327ba8 11448 theDI << "msaa: " << aParams.NbMsaaSamples << "\n";
56689b27 11449 theDI << "rendScale: " << aParams.RenderResolutionScale << "\n";
b4327ba8 11450 theDI << "rayDepth: " << aParams.RaytracingDepth << "\n";
11451 theDI << "fsaa: " << (aParams.IsAntialiasingEnabled ? "on" : "off") << "\n";
11452 theDI << "shadows: " << (aParams.IsShadowEnabled ? "on" : "off") << "\n";
11453 theDI << "reflections: " << (aParams.IsReflectionEnabled ? "on" : "off") << "\n";
11454 theDI << "gleam: " << (aParams.IsTransparentShadowEnabled ? "on" : "off") << "\n";
11455 theDI << "GI: " << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << "\n";
11456 theDI << "blocked RNG: " << (aParams.CoherentPathTracingMode ? "on" : "off") << "\n";
11457 theDI << "iss: " << (aParams.AdaptiveScreenSampling ? "on" : "off") << "\n";
11458 theDI << "iss debug: " << (aParams.ShowSamplingTiles ? "on" : "off") << "\n";
11459 theDI << "two-sided BSDF: " << (aParams.TwoSidedBsdfModels ? "on" : "off") << "\n";
b09447ed 11460 theDI << "max radiance: " << aParams.RadianceClampingValue << "\n";
4eaaf9d8 11461 theDI << "nb tiles (iss): " << aParams.NbRayTracingTiles << "\n";
66d1cdc6 11462 theDI << "tile size (iss):" << aParams.RayTracingTileSize << "x" << aParams.RayTracingTileSize << "\n";
8625ef7e 11463 theDI << "shadingModel: ";
11464 switch (aView->ShadingModel())
11465 {
67312b79 11466 case Graphic3d_TOSM_DEFAULT: theDI << "default"; break;
11467 case Graphic3d_TOSM_UNLIT: theDI << "unlit"; break;
11468 case Graphic3d_TOSM_FACET: theDI << "flat"; break;
11469 case Graphic3d_TOSM_VERTEX: theDI << "gouraud"; break;
11470 case Graphic3d_TOSM_FRAGMENT: theDI << "phong"; break;
11471 case Graphic3d_TOSM_PBR: theDI << "pbr"; break;
11472 case Graphic3d_TOSM_PBR_FACET: theDI << "pbr_facet"; break;
8625ef7e 11473 }
15669413 11474 {
11475 theDI << "perfCounters:";
11476 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_FrameRate) != 0)
11477 {
11478 theDI << " fps";
11479 }
11480 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_CPU) != 0)
11481 {
11482 theDI << " cpu";
11483 }
11484 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Structures) != 0)
11485 {
11486 theDI << " structs";
11487 }
11488 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Groups) != 0)
11489 {
11490 theDI << " groups";
11491 }
11492 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_GroupArrays) != 0)
11493 {
11494 theDI << " arrays";
11495 }
11496 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Triangles) != 0)
11497 {
11498 theDI << " tris";
11499 }
11500 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Points) != 0)
11501 {
11502 theDI << " pnts";
11503 }
11504 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_EstimMem) != 0)
11505 {
11506 theDI << " gpumem";
11507 }
5e30547b 11508 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_FrameTime) != 0)
11509 {
11510 theDI << " frameTime";
11511 }
11512 if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_SkipImmediate) != 0)
11513 {
11514 theDI << " skipimmediate";
11515 }
15669413 11516 if (aParams.CollectedStats == Graphic3d_RenderingParams::PerfCounters_NONE)
11517 {
11518 theDI << " none";
11519 }
11520 theDI << "\n";
11521 }
f88457e6 11522 theDI << "depth pre-pass: " << (aParams.ToEnableDepthPrepass ? "on" : "off") << "\n";
c40eb6b9 11523 theDI << "alpha to coverage: " << (aParams.ToEnableAlphaToCoverage ? "on" : "off") << "\n";
0e3025bc 11524 theDI << "frustum culling: " << (aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_On ? "on" :
11525 aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_Off ? "off" :
11526 "noUpdate") << "\n";
8625ef7e 11527 theDI << "\n";
bc8c79bb 11528 return 0;
e276548b 11529 }
11530
bc8c79bb 11531 Standard_Boolean toPrint = Standard_False;
8625ef7e 11532 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
e276548b 11533 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
11534 {
bc8c79bb 11535 Standard_CString anArg (theArgVec[anArgIter]);
11536 TCollection_AsciiString aFlag (anArg);
11537 aFlag.LowerCase();
8625ef7e 11538 if (anUpdateTool.parseRedrawMode (aFlag))
11539 {
11540 continue;
11541 }
11542 else if (aFlag == "-echo"
11543 || aFlag == "-print")
e276548b 11544 {
bc8c79bb 11545 toPrint = Standard_True;
8625ef7e 11546 anUpdateTool.Invalidate();
e276548b 11547 }
bc8c79bb 11548 else if (aFlag == "-mode"
11549 || aFlag == "-rendermode"
11550 || aFlag == "-render_mode")
e276548b 11551 {
bc8c79bb 11552 if (toPrint)
11553 {
11554 switch (aParams.Method)
11555 {
11556 case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
11557 case Graphic3d_RM_RAYTRACING: theDI << "ray-tracing "; break;
11558 }
11559 continue;
11560 }
e276548b 11561 else
bc8c79bb 11562 {
11563 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11564 return 1;
11565 }
11566 }
11567 else if (aFlag == "-ray"
11568 || aFlag == "-raytrace")
11569 {
11570 if (toPrint)
11571 {
11572 theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "true" : "false") << " ";
11573 continue;
11574 }
11575
11576 aParams.Method = Graphic3d_RM_RAYTRACING;
e276548b 11577 }
bc8c79bb 11578 else if (aFlag == "-rast"
11579 || aFlag == "-raster"
11580 || aFlag == "-rasterization")
e276548b 11581 {
bc8c79bb 11582 if (toPrint)
11583 {
11584 theDI << (aParams.Method == Graphic3d_RM_RASTERIZATION ? "true" : "false") << " ";
11585 continue;
11586 }
11587
11588 aParams.Method = Graphic3d_RM_RASTERIZATION;
11589 }
3c4b62a4 11590 else if (aFlag == "-msaa")
11591 {
11592 if (toPrint)
11593 {
11594 theDI << aParams.NbMsaaSamples << " ";
11595 continue;
11596 }
11597 else if (++anArgIter >= theArgNb)
11598 {
11599 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11600 return 1;
11601 }
11602
11603 const Standard_Integer aNbSamples = Draw::Atoi (theArgVec[anArgIter]);
11604 if (aNbSamples < 0)
11605 {
11606 std::cerr << "Error: invalid number of MSAA samples " << aNbSamples << ".\n";
11607 return 1;
11608 }
11609 else
11610 {
11611 aParams.NbMsaaSamples = aNbSamples;
11612 }
11613 }
2a332745 11614 else if (aFlag == "-linefeather"
11615 || aFlag == "-edgefeather"
11616 || aFlag == "-feather")
11617 {
11618 if (toPrint)
11619 {
11620 theDI << " " << aParams.LineFeather << " ";
11621 continue;
11622 }
11623 else if (++anArgIter >= theArgNb)
11624 {
11625 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11626 return 1;
11627 }
11628
11629 TCollection_AsciiString aParam = theArgVec[anArgIter];
11630 const Standard_ShortReal aFeather = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
11631 if (aFeather <= 0.0f)
11632 {
11633 std::cerr << "Error: invalid value of line width feather " << aFeather << ". Should be > 0\n";
11634 return 1;
11635 }
11636 aParams.LineFeather = aFeather;
11637 }
a1073ae2 11638 else if (aFlag == "-oit")
11639 {
11640 if (toPrint)
11641 {
11642 if (aParams.TransparencyMethod == Graphic3d_RTM_BLEND_OIT)
11643 {
11644 theDI << "on, depth weight factor: " << TCollection_AsciiString (aParams.OitDepthFactor) << " ";
11645 }
11646 else
11647 {
11648 theDI << "off" << " ";
11649 }
11650 continue;
11651 }
11652 else if (++anArgIter >= theArgNb)
11653 {
11654 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11655 return 1;
11656 }
11657
11658 TCollection_AsciiString aParam = theArgVec[anArgIter];
11659 aParam.LowerCase();
11660 if (aParam.IsRealValue())
11661 {
11662 const Standard_ShortReal aWeight = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
11663 if (aWeight < 0.f || aWeight > 1.f)
11664 {
11665 std::cerr << "Error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]\n";
11666 return 1;
11667 }
11668
11669 aParams.TransparencyMethod = Graphic3d_RTM_BLEND_OIT;
11670 aParams.OitDepthFactor = aWeight;
11671 }
11672 else if (aParam == "off")
11673 {
11674 aParams.TransparencyMethod = Graphic3d_RTM_BLEND_UNORDERED;
11675 }
11676 else
11677 {
11678 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11679 return 1;
11680 }
11681 }
f88457e6 11682 else if (aFlag == "-depthprepass")
11683 {
11684 if (toPrint)
11685 {
11686 theDI << (aParams.ToEnableDepthPrepass ? "on " : "off ");
11687 continue;
11688 }
11689 aParams.ToEnableDepthPrepass = Standard_True;
11690 if (anArgIter + 1 < theArgNb
11691 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], aParams.ToEnableDepthPrepass))
11692 {
11693 ++anArgIter;
11694 }
11695 }
c40eb6b9 11696 else if (aFlag == "-samplealphatocoverage"
11697 || aFlag == "-alphatocoverage")
11698 {
11699 if (toPrint)
11700 {
11701 theDI << (aParams.ToEnableAlphaToCoverage ? "on " : "off ");
11702 continue;
11703 }
11704 aParams.ToEnableAlphaToCoverage = Standard_True;
11705 if (anArgIter + 1 < theArgNb
11706 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], aParams.ToEnableAlphaToCoverage))
11707 {
11708 ++anArgIter;
11709 }
11710 }
56689b27 11711 else if (aFlag == "-rendscale"
11712 || aFlag == "-renderscale"
11713 || aFlag == "-renderresolutionscale")
11714 {
11715 if (toPrint)
11716 {
11717 theDI << aParams.RenderResolutionScale << " ";
11718 continue;
11719 }
11720 else if (++anArgIter >= theArgNb)
11721 {
11722 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11723 return 1;
11724 }
11725
11726 const Standard_Real aScale = Draw::Atof (theArgVec[anArgIter]);
11727 if (aScale < 0.01)
11728 {
11729 std::cerr << "Error: invalid rendering resolution scale " << aScale << ".\n";
11730 return 1;
11731 }
11732 else
11733 {
11734 aParams.RenderResolutionScale = Standard_ShortReal(aScale);
11735 }
11736 }
bc8c79bb 11737 else if (aFlag == "-raydepth"
11738 || aFlag == "-ray_depth")
11739 {
11740 if (toPrint)
11741 {
11742 theDI << aParams.RaytracingDepth << " ";
11743 continue;
11744 }
11745 else if (++anArgIter >= theArgNb)
11746 {
11747 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11748 return 1;
11749 }
11750
11751 const Standard_Integer aDepth = Draw::Atoi (theArgVec[anArgIter]);
189f85a3 11752
11753 // We allow RaytracingDepth be more than 10 in case of GI enabled
11754 if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
bc8c79bb 11755 {
11756 std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
11757 return 1;
11758 }
e276548b 11759 else
bc8c79bb 11760 {
11761 aParams.RaytracingDepth = aDepth;
11762 }
11763 }
11764 else if (aFlag == "-shad"
11765 || aFlag == "-shadows")
11766 {
11767 if (toPrint)
11768 {
11769 theDI << (aParams.IsShadowEnabled ? "on" : "off") << " ";
11770 continue;
11771 }
11772
11773 Standard_Boolean toEnable = Standard_True;
11774 if (++anArgIter < theArgNb
a5565a3c 11775 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
bc8c79bb 11776 {
11777 --anArgIter;
11778 }
11779 aParams.IsShadowEnabled = toEnable;
11780 }
11781 else if (aFlag == "-refl"
11782 || aFlag == "-reflections")
11783 {
11784 if (toPrint)
11785 {
11786 theDI << (aParams.IsReflectionEnabled ? "on" : "off") << " ";
11787 continue;
11788 }
11789
11790 Standard_Boolean toEnable = Standard_True;
11791 if (++anArgIter < theArgNb
a5565a3c 11792 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
bc8c79bb 11793 {
11794 --anArgIter;
11795 }
11796 aParams.IsReflectionEnabled = toEnable;
11797 }
11798 else if (aFlag == "-fsaa")
11799 {
11800 if (toPrint)
11801 {
11802 theDI << (aParams.IsAntialiasingEnabled ? "on" : "off") << " ";
11803 continue;
11804 }
11805
11806 Standard_Boolean toEnable = Standard_True;
11807 if (++anArgIter < theArgNb
a5565a3c 11808 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
bc8c79bb 11809 {
11810 --anArgIter;
11811 }
11812 aParams.IsAntialiasingEnabled = toEnable;
11813 }
11814 else if (aFlag == "-gleam")
11815 {
11816 if (toPrint)
11817 {
11818 theDI << (aParams.IsTransparentShadowEnabled ? "on" : "off") << " ";
11819 continue;
11820 }
11821
11822 Standard_Boolean toEnable = Standard_True;
11823 if (++anArgIter < theArgNb
a5565a3c 11824 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
bc8c79bb 11825 {
11826 --anArgIter;
11827 }
11828 aParams.IsTransparentShadowEnabled = toEnable;
e276548b 11829 }
189f85a3 11830 else if (aFlag == "-gi")
11831 {
11832 if (toPrint)
11833 {
11834 theDI << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << " ";
11835 continue;
11836 }
11837
11838 Standard_Boolean toEnable = Standard_True;
11839 if (++anArgIter < theArgNb
a5565a3c 11840 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
189f85a3 11841 {
11842 --anArgIter;
11843 }
11844 aParams.IsGlobalIlluminationEnabled = toEnable;
11845 if (!toEnable)
11846 {
11847 aParams.RaytracingDepth = Min (aParams.RaytracingDepth, 10);
11848 }
11849 }
8c820969 11850 else if (aFlag == "-blockedrng"
11851 || aFlag == "-brng")
11852 {
11853 if (toPrint)
11854 {
11855 theDI << (aParams.CoherentPathTracingMode ? "on" : "off") << " ";
11856 continue;
11857 }
11858
11859 Standard_Boolean toEnable = Standard_True;
11860 if (++anArgIter < theArgNb
a5565a3c 11861 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
8c820969 11862 {
11863 --anArgIter;
11864 }
11865 aParams.CoherentPathTracingMode = toEnable;
11866 }
b09447ed 11867 else if (aFlag == "-maxrad")
11868 {
11869 if (toPrint)
11870 {
11871 theDI << aParams.RadianceClampingValue << " ";
11872 continue;
11873 }
11874 else if (++anArgIter >= theArgNb)
11875 {
11876 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11877 return 1;
11878 }
11879
11880 const TCollection_AsciiString aMaxRadStr = theArgVec[anArgIter];
11881 if (!aMaxRadStr.IsRealValue())
11882 {
11883 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11884 return 1;
11885 }
11886
11887 const Standard_Real aMaxRadiance = aMaxRadStr.RealValue();
11888 if (aMaxRadiance <= 0.0)
11889 {
11890 std::cerr << "Error: invalid radiance clamping value " << aMaxRadiance << ".\n";
11891 return 1;
11892 }
11893 else
11894 {
11895 aParams.RadianceClampingValue = static_cast<Standard_ShortReal> (aMaxRadiance);
11896 }
11897 }
3a9b5dc8 11898 else if (aFlag == "-iss")
11899 {
11900 if (toPrint)
11901 {
11902 theDI << (aParams.AdaptiveScreenSampling ? "on" : "off") << " ";
11903 continue;
11904 }
11905
11906 Standard_Boolean toEnable = Standard_True;
11907 if (++anArgIter < theArgNb
11908 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
11909 {
11910 --anArgIter;
11911 }
11912 aParams.AdaptiveScreenSampling = toEnable;
11913 }
e084dbbc 11914 else if (aFlag == "-issatomic")
11915 {
11916 if (toPrint)
11917 {
11918 theDI << (aParams.AdaptiveScreenSamplingAtomic ? "on" : "off") << " ";
11919 continue;
11920 }
11921
11922 Standard_Boolean toEnable = Standard_True;
11923 if (++anArgIter < theArgNb
11924 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
11925 {
11926 --anArgIter;
11927 }
11928 aParams.AdaptiveScreenSamplingAtomic = toEnable;
11929 }
3a9b5dc8 11930 else if (aFlag == "-issd")
11931 {
11932 if (toPrint)
11933 {
11934 theDI << (aParams.ShowSamplingTiles ? "on" : "off") << " ";
11935 continue;
11936 }
11937
11938 Standard_Boolean toEnable = Standard_True;
11939 if (++anArgIter < theArgNb
11940 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
11941 {
11942 --anArgIter;
11943 }
11944 aParams.ShowSamplingTiles = toEnable;
11945 }
66d1cdc6 11946 else if (aFlag == "-tilesize")
11947 {
11948 if (toPrint)
11949 {
11950 theDI << aParams.RayTracingTileSize << " ";
11951 continue;
11952 }
11953 else if (++anArgIter >= theArgNb)
11954 {
11955 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11956 return 1;
11957 }
11958
11959 const Standard_Integer aTileSize = Draw::Atoi (theArgVec[anArgIter]);
11960 if (aTileSize < 1)
11961 {
11962 std::cerr << "Error: invalid size of ISS tile " << aTileSize << ".\n";
11963 return 1;
11964 }
11965 aParams.RayTracingTileSize = aTileSize;
11966 }
4eaaf9d8 11967 else if (aFlag == "-nbtiles")
11968 {
11969 if (toPrint)
11970 {
11971 theDI << aParams.NbRayTracingTiles << " ";
11972 continue;
11973 }
11974 else if (++anArgIter >= theArgNb)
11975 {
11976 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
11977 return 1;
11978 }
11979
11980 const Standard_Integer aNbTiles = Draw::Atoi (theArgVec[anArgIter]);
66d1cdc6 11981 if (aNbTiles < -1)
4eaaf9d8 11982 {
11983 std::cerr << "Error: invalid number of ISS tiles " << aNbTiles << ".\n";
4eaaf9d8 11984 return 1;
11985 }
66d1cdc6 11986 else if (aNbTiles > 0
11987 && (aNbTiles < 64
11988 || aNbTiles > 1024))
4eaaf9d8 11989 {
66d1cdc6 11990 std::cerr << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].\n";
4eaaf9d8 11991 }
66d1cdc6 11992 aParams.NbRayTracingTiles = aNbTiles;
4eaaf9d8 11993 }
189f85a3 11994 else if (aFlag == "-env")
11995 {
11996 if (toPrint)
11997 {
11998 theDI << (aParams.UseEnvironmentMapBackground ? "on" : "off") << " ";
11999 continue;
12000 }
12001
12002 Standard_Boolean toEnable = Standard_True;
12003 if (++anArgIter < theArgNb
a5565a3c 12004 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
189f85a3 12005 {
12006 --anArgIter;
12007 }
12008 aParams.UseEnvironmentMapBackground = toEnable;
12009 }
b4327ba8 12010 else if (aFlag == "-twoside")
12011 {
12012 if (toPrint)
12013 {
12014 theDI << (aParams.TwoSidedBsdfModels ? "on" : "off") << " ";
12015 continue;
12016 }
12017
12018 Standard_Boolean toEnable = Standard_True;
12019 if (++anArgIter < theArgNb
12020 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
12021 {
12022 --anArgIter;
12023 }
12024 aParams.TwoSidedBsdfModels = toEnable;
12025 }
8625ef7e 12026 else if (aFlag == "-shademodel"
12027 || aFlag == "-shadingmodel"
12028 || aFlag == "-shading")
12029 {
12030 if (toPrint)
12031 {
12032 switch (aView->ShadingModel())
12033 {
67312b79 12034 case Graphic3d_TOSM_DEFAULT: theDI << "default"; break;
12035 case Graphic3d_TOSM_UNLIT: theDI << "unlit "; break;
12036 case Graphic3d_TOSM_FACET: theDI << "flat "; break;
12037 case Graphic3d_TOSM_VERTEX: theDI << "gouraud "; break;
12038 case Graphic3d_TOSM_FRAGMENT: theDI << "phong "; break;
12039 case Graphic3d_TOSM_PBR: theDI << "pbr"; break;
12040 case Graphic3d_TOSM_PBR_FACET: theDI << "pbr_facet"; break;
8625ef7e 12041 }
12042 continue;
12043 }
12044
12045 if (++anArgIter >= theArgNb)
12046 {
12047 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12048 }
12049
dc89236f 12050 Graphic3d_TypeOfShadingModel aModel = Graphic3d_TOSM_DEFAULT;
12051 if (ViewerTest::ParseShadingModel (theArgVec[anArgIter], aModel)
12052 && aModel != Graphic3d_TOSM_DEFAULT)
8625ef7e 12053 {
dc89236f 12054 aView->SetShadingModel (aModel);
8625ef7e 12055 }
12056 else
12057 {
dc89236f 12058 std::cout << "Error: unknown shading model '" << theArgVec[anArgIter] << "'\n";
8625ef7e 12059 return 1;
12060 }
12061 }
67312b79 12062 else if (aFlag == "-pbrenvpow2size"
12063 || aFlag == "-pbrenvp2s"
12064 || aFlag == "-pep2s")
12065 {
12066 if (++anArgIter >= theArgNb)
12067 {
12068 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12069 return 1;
12070 }
12071
12072 const Standard_Integer aPbrEnvPow2Size = Draw::Atoi (theArgVec[anArgIter]);
12073 if (aPbrEnvPow2Size < 1)
12074 {
12075 std::cout << "Error: 'Pow2Size' of PBR Environment has to be greater or equal 1\n";
12076 return 1;
12077 }
12078 aParams.PbrEnvPow2Size = aPbrEnvPow2Size;
12079 }
12080 else if (aFlag == "-pbrenvspecmaplevelsnumber"
12081 || aFlag == "-pbrenvspecmapnblevels"
12082 || aFlag == "-pbrenvspecmaplevels"
12083 || aFlag == "-pbrenvsmln"
12084 || aFlag == "-pesmln")
12085 {
12086 if (++anArgIter >= theArgNb)
12087 {
12088 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12089 return 1;
12090 }
12091
12092 const Standard_Integer aPbrEnvSpecMapNbLevels = Draw::Atoi (theArgVec[anArgIter]);
12093 if (aPbrEnvSpecMapNbLevels < 2)
12094 {
12095 std::cout << "Error: 'SpecMapLevelsNumber' of PBR Environment has to be greater or equal 2\n";
12096 return 1;
12097 }
12098 aParams.PbrEnvSpecMapNbLevels = aPbrEnvSpecMapNbLevels;
12099 }
12100 else if (aFlag == "-pbrenvbakngdiffsamplesnumber"
12101 || aFlag == "-pbrenvbakingdiffsamples"
12102 || aFlag == "-pbrenvbdsn")
12103 {
12104 if (++anArgIter >= theArgNb)
12105 {
12106 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12107 return 1;
12108 }
12109
12110 const Standard_Integer aPbrEnvBakingDiffNbSamples = Draw::Atoi (theArgVec[anArgIter]);
12111 if (aPbrEnvBakingDiffNbSamples < 1)
12112 {
12113 std::cout << "Error: 'BakingDiffSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
12114 return 1;
12115 }
12116 aParams.PbrEnvBakingDiffNbSamples = aPbrEnvBakingDiffNbSamples;
12117 }
12118 else if (aFlag == "-pbrenvbakngspecsamplesnumber"
12119 || aFlag == "-pbrenvbakingspecsamples"
12120 || aFlag == "-pbrenvbssn")
12121 {
12122 if (++anArgIter >= theArgNb)
12123 {
12124 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12125 return 1;
12126 }
12127
12128 const Standard_Integer aPbrEnvBakingSpecNbSamples = Draw::Atoi(theArgVec[anArgIter]);
12129 if (aPbrEnvBakingSpecNbSamples < 1)
12130 {
12131 std::cout << "Error: 'BakingSpecSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
12132 return 1;
12133 }
12134 aParams.PbrEnvBakingSpecNbSamples = aPbrEnvBakingSpecNbSamples;
12135 }
12136 else if (aFlag == "-pbrenvbakingprobability"
12137 || aFlag == "-pbrenvbp")
12138 {
12139 if (++anArgIter >= theArgNb)
12140 {
12141 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12142 return 1;
12143 }
12144 const Standard_ShortReal aPbrEnvBakingProbability = static_cast<Standard_ShortReal>(Draw::Atof (theArgVec[anArgIter]));
12145 if (aPbrEnvBakingProbability < 0.f
12146 || aPbrEnvBakingProbability > 1.f)
12147 {
12148 std::cout << "Error: 'BakingProbability' of PBR Environtment has to be in range of [0, 1]\n";
12149 return 1;
12150 }
12151 aParams.PbrEnvBakingProbability = aPbrEnvBakingProbability;
12152 }
4b1c8733 12153 else if (aFlag == "-resolution")
12154 {
12155 if (++anArgIter >= theArgNb)
12156 {
12157 std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
12158 return 1;
12159 }
12160
12161 TCollection_AsciiString aResolution (theArgVec[anArgIter]);
12162 if (aResolution.IsIntegerValue())
12163 {
12164 aView->ChangeRenderingParams().Resolution = static_cast<unsigned int> (Draw::Atoi (aResolution.ToCString()));
12165 }
12166 else
12167 {
12168 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12169 return 1;
12170 }
12171 }
d877e610 12172 else if (aFlag == "-rebuildglsl"
12173 || aFlag == "-rebuild")
12174 {
12175 if (toPrint)
12176 {
12177 theDI << (aParams.RebuildRayTracingShaders ? "on" : "off") << " ";
12178 continue;
12179 }
12180
12181 Standard_Boolean toEnable = Standard_True;
12182 if (++anArgIter < theArgNb
12183 && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
12184 {
12185 --anArgIter;
12186 }
12187 aParams.RebuildRayTracingShaders = toEnable;
12188 }
b27ab03d 12189 else if (aFlag == "-focal")
12190 {
12191 if (++anArgIter >= theArgNb)
12192 {
12193 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12194 return 1;
12195 }
12196
12197 TCollection_AsciiString aParam (theArgVec[anArgIter]);
12198 if (aParam.IsRealValue())
12199 {
12200 float aFocalDist = static_cast<float> (aParam.RealValue());
12201 if (aFocalDist < 0)
12202 {
12203 std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
12204 return 1;
12205 }
12206 aView->ChangeRenderingParams().CameraFocalPlaneDist = aFocalDist;
12207 }
12208 else
12209 {
12210 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12211 return 1;
12212 }
12213 }
12214 else if (aFlag == "-aperture")
12215 {
12216 if (++anArgIter >= theArgNb)
12217 {
12218 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12219 return 1;
12220 }
12221
12222 TCollection_AsciiString aParam(theArgVec[anArgIter]);
12223 if (aParam.IsRealValue())
12224 {
12225 float aApertureSize = static_cast<float> (aParam.RealValue());
12226 if (aApertureSize < 0)
12227 {
12228 std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
12229 return 1;
12230 }
12231 aView->ChangeRenderingParams().CameraApertureRadius = aApertureSize;
12232 }
12233 else
12234 {
12235 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12236 return 1;
12237 }
12238 }
eb85ed36 12239 else if (aFlag == "-exposure")
12240 {
12241 if (++anArgIter >= theArgNb)
12242 {
12243 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12244 return 1;
12245 }
12246
12247 TCollection_AsciiString anExposure (theArgVec[anArgIter]);
12248 if (anExposure.IsRealValue())
12249 {
12250 aView->ChangeRenderingParams().Exposure = static_cast<float> (anExposure.RealValue());
12251 }
12252 else
12253 {
12254 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12255 return 1;
12256 }
12257 }
12258 else if (aFlag == "-whitepoint")
12259 {
12260 if (++anArgIter >= theArgNb)
12261 {
12262 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12263 return 1;
12264 }
12265
12266 TCollection_AsciiString aWhitePoint (theArgVec[anArgIter]);
12267 if (aWhitePoint.IsRealValue())
12268 {
12269 aView->ChangeRenderingParams().WhitePoint = static_cast<float> (aWhitePoint.RealValue());
12270 }
12271 else
12272 {
12273 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12274 return 1;
12275 }
12276 }
12277 else if (aFlag == "-tonemapping")
12278 {
12279 if (++anArgIter >= theArgNb)
12280 {
12281 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12282 return 1;
12283 }
12284
12285 TCollection_AsciiString aMode (theArgVec[anArgIter]);
12286 aMode.LowerCase();
12287
12288 if (aMode == "disabled")
12289 {
12290 aView->ChangeRenderingParams().ToneMappingMethod = Graphic3d_ToneMappingMethod_Disabled;
12291 }
12292 else if (aMode == "filmic")
12293 {
12294 aView->ChangeRenderingParams().ToneMappingMethod = Graphic3d_ToneMappingMethod_Filmic;
12295 }
12296 else
12297 {
12298 std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
12299 return 1;
12300 }
12301 }
15669413 12302 else if (aFlag == "-performancestats"
12303 || aFlag == "-performancecounters"
12304 || aFlag == "-perfstats"
12305 || aFlag == "-perfcounters"
12306 || aFlag == "-stats")
12307 {
12308 if (++anArgIter >= theArgNb)
12309 {
12310 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12311 return 1;
12312 }
12313
12314 TCollection_AsciiString aFlagsStr (theArgVec[anArgIter]);
12315 aFlagsStr.LowerCase();
12316 Graphic3d_RenderingParams::PerfCounters aFlags = aView->ChangeRenderingParams().CollectedStats;
12317 if (!convertToPerfStatsFlags (aFlagsStr, aFlags))
12318 {
12319 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12320 return 1;
12321 }
12322 aView->ChangeRenderingParams().CollectedStats = aFlags;
12323 aView->ChangeRenderingParams().ToShowStats = aFlags != Graphic3d_RenderingParams::PerfCounters_NONE;
12324 }
12325 else if (aFlag == "-perfupdateinterval"
12326 || aFlag == "-statsupdateinterval")
12327 {
12328 if (++anArgIter >= theArgNb)
12329 {
12330 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12331 return 1;
12332 }
12333 aView->ChangeRenderingParams().StatsUpdateInterval = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
12334 }
5e30547b 12335 else if (aFlag == "-perfchart"
12336 || aFlag == "-statschart")
12337 {
12338 if (++anArgIter >= theArgNb)
12339 {
12340 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12341 return 1;
12342 }
12343 aView->ChangeRenderingParams().StatsNbFrames = Draw::Atoi (theArgVec[anArgIter]);
12344 }
12345 else if (aFlag == "-perfchartmax"
12346 || aFlag == "-statschartmax")
12347 {
12348 if (++anArgIter >= theArgNb)
12349 {
12350 std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
12351 return 1;
12352 }
12353 aView->ChangeRenderingParams().StatsMaxChartTime = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
12354 }
0e3025bc 12355 else if (aFlag == "-frustumculling"
12356 || aFlag == "-culling")
12357 {
12358 if (toPrint)
12359 {
12360 theDI << ((aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_On) ? "on" :
12361 (aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_Off) ? "off" :
12362 "noUpdate") << " ";
12363 continue;
12364 }
12365
12366 Graphic3d_RenderingParams::FrustumCulling aState = Graphic3d_RenderingParams::FrustumCulling_On;
12367 if (++anArgIter < theArgNb)
12368 {
12369 TCollection_AsciiString aStateStr(theArgVec[anArgIter]);
12370 aStateStr.LowerCase();
12371 bool toEnable = true;
12372 if (ViewerTest::ParseOnOff (aStateStr.ToCString(), toEnable))
12373 {
12374 aState = toEnable ? Graphic3d_RenderingParams::FrustumCulling_On : Graphic3d_RenderingParams::FrustumCulling_Off;
12375 }
12376 else if (aStateStr == "noupdate"
12377 || aStateStr == "freeze")
12378 {
12379 aState = Graphic3d_RenderingParams::FrustumCulling_NoUpdate;
12380 }
12381 else
12382 {
12383 --anArgIter;
12384 }
12385 }
12386 aParams.FrustumCullingState = aState;
12387 }
e276548b 12388 else
12389 {
bc8c79bb 12390 std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
12391 return 1;
e276548b 12392 }
12393 }
189f85a3 12394
12395 return 0;
12396}
12397
79b544e6 12398//=======================================================================
12399//function : searchInfo
12400//purpose :
12401//=======================================================================
12402inline TCollection_AsciiString searchInfo (const TColStd_IndexedDataMapOfStringString& theDict,
12403 const TCollection_AsciiString& theKey)
12404{
12405 for (TColStd_IndexedDataMapOfStringString::Iterator anIter (theDict); anIter.More(); anIter.Next())
12406 {
12407 if (TCollection_AsciiString::IsSameString (anIter.Key(), theKey, Standard_False))
12408 {
12409 return anIter.Value();
12410 }
12411 }
12412 return TCollection_AsciiString();
12413}
12414
12415//=======================================================================
12416//function : VStatProfiler
12417//purpose :
12418//=======================================================================
12419static Standard_Integer VStatProfiler (Draw_Interpretor& theDI,
12420 Standard_Integer theArgNb,
12421 const char** theArgVec)
12422{
12423 Handle(V3d_View) aView = ViewerTest::CurrentView();
12424 if (aView.IsNull())
12425 {
12426 std::cerr << "Error: no active viewer!\n";
12427 return 1;
12428 }
12429
12430 Standard_Boolean toRedraw = Standard_True;
12431 Graphic3d_RenderingParams::PerfCounters aPrevCounters = aView->ChangeRenderingParams().CollectedStats;
12432 Standard_ShortReal aPrevUpdInterval = aView->ChangeRenderingParams().StatsUpdateInterval;
12433 Graphic3d_RenderingParams::PerfCounters aRenderParams = Graphic3d_RenderingParams::PerfCounters_NONE;
12434 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
12435 {
12436 Standard_CString anArg (theArgVec[anArgIter]);
12437 TCollection_AsciiString aFlag (anArg);
12438 aFlag.LowerCase();
12439 if (aFlag == "-noredraw")
12440 {
12441 toRedraw = Standard_False;
12442 }
12443 else
12444 {
12445 Graphic3d_RenderingParams::PerfCounters aParam = Graphic3d_RenderingParams::PerfCounters_NONE;
12446 if (aFlag == "fps") aParam = Graphic3d_RenderingParams::PerfCounters_FrameRate;
12447 else if (aFlag == "cpu") aParam = Graphic3d_RenderingParams::PerfCounters_CPU;
12448 else if (aFlag == "alllayers"
12449 || aFlag == "layers") aParam = Graphic3d_RenderingParams::PerfCounters_Layers;
12450 else if (aFlag == "allstructs"
12451 || aFlag == "structs") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
12452 else if (aFlag == "groups") aParam = Graphic3d_RenderingParams::PerfCounters_Groups;
12453 else if (aFlag == "allarrays"
12454 || aFlag == "fillarrays"
12455 || aFlag == "linearrays"
12456 || aFlag == "pointarrays"
12457 || aFlag == "textarrays") aParam = Graphic3d_RenderingParams::PerfCounters_GroupArrays;
12458 else if (aFlag == "triangles") aParam = Graphic3d_RenderingParams::PerfCounters_Triangles;
12459 else if (aFlag == "points") aParam = Graphic3d_RenderingParams::PerfCounters_Points;
12460 else if (aFlag == "geommem"
12461 || aFlag == "texturemem"
12462 || aFlag == "framemem") aParam = Graphic3d_RenderingParams::PerfCounters_EstimMem;
12463 else if (aFlag == "elapsedframe"
12464 || aFlag == "cpuframeaverage"
12465 || aFlag == "cpupickingaverage"
12466 || aFlag == "cpucullingaverage"
12467 || aFlag == "cpudynaverage"
12468 || aFlag == "cpuframemax"
12469 || aFlag == "cpupickingmax"
12470 || aFlag == "cpucullingmax"
12471 || aFlag == "cpudynmax") aParam = Graphic3d_RenderingParams::PerfCounters_FrameTime;
12472 else
12473 {
12474 std::cerr << "Unknown argument '" << theArgVec[anArgIter] << "'!\n";
12475 continue;
12476 }
12477
12478 aRenderParams = Graphic3d_RenderingParams::PerfCounters (aRenderParams | aParam);
12479 }
12480 }
12481
12482 if (aRenderParams != Graphic3d_RenderingParams::PerfCounters_NONE)
12483 {
12484 aView->ChangeRenderingParams().CollectedStats =
12485 Graphic3d_RenderingParams::PerfCounters (aView->RenderingParams().CollectedStats | aRenderParams);
12486
12487 if (toRedraw)
12488 {
12489 aView->ChangeRenderingParams().StatsUpdateInterval = -1;
12490 aView->Redraw();
12491 aView->ChangeRenderingParams().StatsUpdateInterval = aPrevUpdInterval;
12492 }
12493
12494 TColStd_IndexedDataMapOfStringString aDict;
12495 aView->StatisticInformation (aDict);
12496
12497 aView->ChangeRenderingParams().CollectedStats = aPrevCounters;
12498
12499 for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
12500 {
12501 Standard_CString anArg(theArgVec[anArgIter]);
12502 TCollection_AsciiString aFlag(anArg);
12503 aFlag.LowerCase();
12504 if (aFlag == "fps")
12505 {
12506 theDI << searchInfo (aDict, "FPS") << " ";
12507 }
12508 else if (aFlag == "cpu")
12509 {
12510 theDI << searchInfo (aDict, "CPU FPS") << " ";
12511 }
12512 else if (aFlag == "alllayers")
12513 {
12514 theDI << searchInfo (aDict, "Layers") << " ";
12515 }
12516 else if (aFlag == "layers")
12517 {
12518 theDI << searchInfo (aDict, "Rendered layers") << " ";
12519 }
12520 else if (aFlag == "allstructs")
12521 {
12522 theDI << searchInfo (aDict, "Structs") << " ";
12523 }
12524 else if (aFlag == "structs")
12525 {
12526 theDI << searchInfo (aDict, "Rendered structs") << " ";
12527 }
12528 else if (aFlag == "groups")
12529 {
12530 theDI << searchInfo (aDict, "Rendered groups") << " ";
12531 }
12532 else if (aFlag == "allarrays")
12533 {
12534 theDI << searchInfo (aDict, "Rendered arrays") << " ";
12535 }
12536 else if (aFlag == "fillarrays")
12537 {
12538 theDI << searchInfo (aDict, "Rendered [fill] arrays") << " ";
12539 }
12540 else if (aFlag == "linearrays")
12541 {
12542 theDI << searchInfo (aDict, "Rendered [line] arrays") << " ";
12543 }
12544 else if (aFlag == "pointarrays")
12545 {
12546 theDI << searchInfo (aDict, "Rendered [point] arrays") << " ";
12547 }
12548 else if (aFlag == "textarrays")
12549 {
12550 theDI << searchInfo (aDict, "Rendered [text] arrays") << " ";
12551 }
12552 else if (aFlag == "triangles")
12553 {
12554 theDI << searchInfo (aDict, "Rendered triangles") << " ";
12555 }
12556 else if (aFlag == "points")
12557 {
12558 theDI << searchInfo (aDict, "Rendered points") << " ";
12559 }
12560 else if (aFlag == "geommem")
12561 {
12562 theDI << searchInfo (aDict, "GPU Memory [geometry]") << " ";
12563 }
12564 else if (aFlag == "texturemem")
12565 {
12566 theDI << searchInfo (aDict, "GPU Memory [textures]") << " ";
12567 }
12568 else if (aFlag == "framemem")
12569 {
12570 theDI << searchInfo (aDict, "GPU Memory [frames]") << " ";
12571 }
12572 else if (aFlag == "elapsedframe")
12573 {
12574 theDI << searchInfo (aDict, "Elapsed Frame (average)") << " ";
12575 }
12576 else if (aFlag == "cpuframe_average")
12577 {
12578 theDI << searchInfo (aDict, "CPU Frame (average)") << " ";
12579 }
12580 else if (aFlag == "cpupicking_average")
12581 {
12582 theDI << searchInfo (aDict, "CPU Picking (average)") << " ";
12583 }
12584 else if (aFlag == "cpuculling_average")
12585 {
12586 theDI << searchInfo (aDict, "CPU Culling (average)") << " ";
12587 }
12588 else if (aFlag == "cpudyn_average")
12589 {
12590 theDI << searchInfo (aDict, "CPU Dynamics (average)") << " ";
12591 }
12592 else if (aFlag == "cpuframe_max")
12593 {
12594 theDI << searchInfo (aDict, "CPU Frame (max)") << " ";
12595 }
12596 else if (aFlag == "cpupicking_max")
12597 {
12598 theDI << searchInfo (aDict, "CPU Picking (max)") << " ";
12599 }
12600 else if (aFlag == "cpuculling_max")
12601 {
12602 theDI << searchInfo (aDict, "CPU Culling (max)") << " ";
12603 }
12604 else if (aFlag == "cpudyn_max")
12605 {
12606 theDI << searchInfo (aDict, "CPU Dynamics (max)") << " ";
12607 }
12608 }
12609 }
12610 else
12611 {
12612 if (toRedraw)
12613 {
12614 aView->ChangeRenderingParams().StatsUpdateInterval = -1;
12615 aView->Redraw();
12616 aView->ChangeRenderingParams().StatsUpdateInterval = aPrevUpdInterval;
12617 }
12618 theDI << "Statistic info:\n" << aView->StatisticInformation();
12619 }
12620 return 0;
12621}
12622
0717ddc1 12623//=======================================================================
12624//function : VXRotate
12625//purpose :
12626//=======================================================================
12627static Standard_Integer VXRotate (Draw_Interpretor& di,
12628 Standard_Integer argc,
12629 const char ** argv)
12630{
12631 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
12632 if (aContext.IsNull())
12633 {
586db386 12634 di << argv[0] << "ERROR : use 'vinit' command before \n";
0717ddc1 12635 return 1;
12636 }
8693dfd0 12637
0717ddc1 12638 if (argc != 3)
12639 {
586db386 12640 di << "ERROR : Usage : " << argv[0] << " name angle\n";
0717ddc1 12641 return 1;
12642 }
12643
12644 TCollection_AsciiString aName (argv[1]);
12645 Standard_Real anAngle = Draw::Atof (argv[2]);
12646
12647 // find object
12648 ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
12649 Handle(AIS_InteractiveObject) anIObj;
8f521168 12650 if (!aMap.Find2 (aName, anIObj))
0717ddc1 12651 {
586db386 12652 di << "Use 'vdisplay' before\n";
0717ddc1 12653 return 1;
12654 }
0717ddc1 12655
8f521168 12656 gp_Trsf aTransform;
12657 aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
12658 aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
0717ddc1 12659
8f521168 12660 aContext->SetLocation (anIObj, aTransform);
12661 aContext->UpdateCurrentViewer();
0717ddc1 12662 return 0;
12663}
12664
625e1958 12665//===============================================================================================
12666//function : VManipulator
12667//purpose :
12668//===============================================================================================
12669static int VManipulator (Draw_Interpretor& theDi,
12670 Standard_Integer theArgsNb,
12671 const char** theArgVec)
12672{
bbf3fcde 12673 Handle(V3d_View) aCurrentView = ViewerTest::CurrentView();
625e1958 12674 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
12675 ViewerTest::GetAISContext()->MainSelector()->SetPickClosest (Standard_False);
bbf3fcde 12676 if (aCurrentView.IsNull()
625e1958 12677 || aViewer.IsNull())
12678 {
12679 std::cerr << "No active viewer!\n";
12680 return 1;
12681 }
12682
12683 ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), ViewerTest::CurrentView());
12684 Standard_Integer anArgIter = 1;
12685 for (; anArgIter < theArgsNb; ++anArgIter)
12686 {
12687 anUpdateTool.parseRedrawMode (theArgVec[anArgIter]);
12688 }
12689
12690 ViewerTest_CmdParser aCmd;
293211ae 12691 aCmd.SetDescription ("Manages manipulator for interactive objects:");
625e1958 12692 aCmd.AddOption ("attach", "... object - attach manipulator to an object");
12693 aCmd.AddOption ("adjustPosition", "... {0|1} - adjust position when attaching");
12694 aCmd.AddOption ("adjustSize", "... {0|1} - adjust size when attaching ");
12695 aCmd.AddOption ("enableModes", "... {0|1} - enable modes when attaching ");
bbf3fcde 12696 aCmd.AddOption ("view", "... {active | [view name]} - define view in which manipulator will be displayed, 'all' by default");
625e1958 12697 aCmd.AddOption ("detach", "... - detach manipulator");
12698
12699 aCmd.AddOption ("startTransform", "... mouse_x mouse_y - invoke start transformation");
12700 aCmd.AddOption ("transform", "... mouse_x mouse_y - invoke transformation");
12701 aCmd.AddOption ("stopTransform", "... [abort] - invoke stop transformation");
12702
12703 aCmd.AddOption ("move", "... x y z - move object");
12704 aCmd.AddOption ("rotate", "... x y z dx dy dz angle - rotate object");
12705 aCmd.AddOption ("scale", "... factor - scale object");
12706
12707 aCmd.AddOption ("autoActivate", "... {0|1} - set activation on detection");
12708 aCmd.AddOption ("followTranslation", "... {0|1} - set following translation transform");
12709 aCmd.AddOption ("followRotation", "... {0|1} - set following rotation transform");
f522ce50 12710 aCmd.AddOption ("followDragging", "... {0|1} - set following dragging transform");
625e1958 12711 aCmd.AddOption ("gap", "... value - set gap between sub-parts");
12712 aCmd.AddOption ("part", "... axis mode {0|1} - set visual part");
84b904bc 12713 aCmd.AddOption ("parts", "... all axes mode {0|1} - set visual part");
625e1958 12714 aCmd.AddOption ("pos", "... x y z [nx ny nz [xx xy xz]] - set position of manipulator");
12715 aCmd.AddOption ("size", "... size - set size of manipulator");
12716 aCmd.AddOption ("zoomable", "... {0|1} - set zoom persistence");
12717
12718 aCmd.Parse (theArgsNb, theArgVec);
12719
12720 if (aCmd.HasOption ("help"))
12721 {
12722 theDi.PrintHelp (theArgVec[0]);
12723 return 0;
12724 }
12725
12726 ViewerTest_DoubleMapOfInteractiveAndName& aMapAIS = GetMapOfAIS();
12727
293211ae 12728 TCollection_AsciiString aName (aCmd.Arg (ViewerTest_CmdParser::THE_UNNAMED_COMMAND_OPTION_KEY, 0).c_str());
625e1958 12729
12730 if (aName.IsEmpty())
12731 {
12732 std::cerr << theArgVec[0] << " error: please specify AIS manipulator's name as the first argument.\n";
12733 return 1;
12734 }
12735
12736 // ----------------------------------
12737 // detach existing manipulator object
12738 // ----------------------------------
12739
12740 if (aCmd.HasOption ("detach"))
12741 {
12742 if (!aMapAIS.IsBound2 (aName))
12743 {
12744 std::cerr << theArgVec[0] << " error: could not find \"" << aName << "\" AIS object.\n";
12745 return 1;
12746 }
12747
12748 Handle(AIS_Manipulator) aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
12749 if (aManipulator.IsNull())
12750 {
12751 std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
12752 return 1;
12753 }
12754
12755 aManipulator->Detach();
12756 aMapAIS.UnBind2 (aName);
0577ae8c 12757 ViewerTest::GetAISContext()->Remove (aManipulator, Standard_True);
625e1958 12758
12759 return 0;
12760 }
12761
12762 // -----------------------------------------------
12763 // find or create manipulator if it does not exist
12764 // -----------------------------------------------
12765
12766 Handle(AIS_Manipulator) aManipulator;
12767 if (!aMapAIS.IsBound2 (aName))
12768 {
12769 std::cout << theArgVec[0] << ": AIS object \"" << aName << "\" has been created.\n";
12770
8b037fe4 12771 aManipulator = new AIS_Manipulator();
49582f9d 12772 aManipulator->SetModeActivationOnDetection (true);
625e1958 12773 aMapAIS.Bind (aManipulator, aName);
12774 }
12775 else
12776 {
12777 aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
12778 if (aManipulator.IsNull())
12779 {
12780 std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
12781 return 1;
12782 }
12783 }
12784
12785 // -----------------------------------------
12786 // change properties of manipulator instance
12787 // -----------------------------------------
12788
12789 if (aCmd.HasOption ("autoActivate", 1, Standard_True))
12790 {
12791 aManipulator->SetModeActivationOnDetection (aCmd.ArgBool ("autoActivate"));
12792 }
12793 if (aCmd.HasOption ("followTranslation", 1, Standard_True))
12794 {
12795 aManipulator->ChangeTransformBehavior().SetFollowTranslation (aCmd.ArgBool ("followTranslation"));
12796 }
12797 if (aCmd.HasOption ("followRotation", 1, Standard_True))
12798 {
12799 aManipulator->ChangeTransformBehavior().SetFollowRotation (aCmd.ArgBool ("followRotation"));
12800 }
f522ce50 12801 if (aCmd.HasOption("followDragging", 1, Standard_True))
12802 {
12803 aManipulator->ChangeTransformBehavior().SetFollowDragging(aCmd.ArgBool("followDragging"));
12804 }
625e1958 12805 if (aCmd.HasOption ("gap", 1, Standard_True))
12806 {
12807 aManipulator->SetGap (aCmd.ArgFloat ("gap"));
12808 }
12809 if (aCmd.HasOption ("part", 3, Standard_True))
12810 {
12811 Standard_Integer anAxis = aCmd.ArgInt ("part", 0);
12812 Standard_Integer aMode = aCmd.ArgInt ("part", 1);
12813 Standard_Boolean aOnOff = aCmd.ArgBool ("part", 2);
f522ce50 12814 if (aMode < 1 || aMode > 4)
625e1958 12815 {
f522ce50 12816 std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
625e1958 12817 return 1;
12818 }
12819
12820 aManipulator->SetPart (anAxis, static_cast<AIS_ManipulatorMode> (aMode), aOnOff);
12821 }
84b904bc 12822 if (aCmd.HasOption("parts", 2, Standard_True))
12823 {
12824 Standard_Integer aMode = aCmd.ArgInt("parts", 0);
12825 Standard_Boolean aOnOff = aCmd.ArgBool("parts", 1);
12826 if (aMode < 1 || aMode > 4)
12827 {
12828 std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
12829 return 1;
12830 }
12831
12832 aManipulator->SetPart(static_cast<AIS_ManipulatorMode>(aMode), aOnOff);
12833 }
625e1958 12834 if (aCmd.HasOption ("pos", 3, Standard_True))
12835 {
12836 gp_Pnt aLocation = aCmd.ArgPnt ("pos", 0);
12837 gp_Dir aVDir = aCmd.HasOption ("pos", 6) ? gp_Dir (aCmd.ArgVec ("pos", 3)) : aManipulator->Position().Direction();
12838 gp_Dir aXDir = aCmd.HasOption ("pos", 9) ? gp_Dir (aCmd.ArgVec ("pos", 6)) : aManipulator->Position().XDirection();
12839
12840 aManipulator->SetPosition (gp_Ax2 (aLocation, aVDir, aXDir));
12841 }
12842 if (aCmd.HasOption ("size", 1, Standard_True))
12843 {
12844 aManipulator->SetSize (aCmd.ArgFloat ("size"));
12845 }
12846 if (aCmd.HasOption ("zoomable", 1, Standard_True))
12847 {
12848 aManipulator->SetZoomPersistence (!aCmd.ArgBool ("zoomable"));
12849
12850 if (ViewerTest::GetAISContext()->IsDisplayed (aManipulator))
12851 {
12852 ViewerTest::GetAISContext()->Remove (aManipulator, Standard_False);
12853 ViewerTest::GetAISContext()->Display (aManipulator, Standard_False);
12854 }
12855 }
12856
12857 // ---------------------------------------------------
12858 // attach, detach or access manipulator from an object
12859 // ---------------------------------------------------
12860
12861 if (aCmd.HasOption ("attach"))
12862 {
12863 // Find an object and attach manipulator to it
12864 if (!aCmd.HasOption ("attach", 1, Standard_True))
12865 {
12866 return 1;
12867 }
12868
12869 TCollection_AsciiString anObjName (aCmd.Arg ("attach", 0).c_str());
8f521168 12870 Handle(AIS_InteractiveObject) anObject;
12871 if (!aMapAIS.Find2 (anObjName, anObject))
625e1958 12872 {
12873 std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" does not exist.\n";
12874 return 1;
12875 }
12876
8b037fe4 12877 for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIter (aMapAIS);
12878 anIter.More(); anIter.Next())
625e1958 12879 {
8b037fe4 12880 Handle(AIS_Manipulator) aManip = Handle(AIS_Manipulator)::DownCast (anIter.Key1());
12881 if (!aManip.IsNull()
12882 && aManip->IsAttached()
12883 && aManip->Object() == anObject)
625e1958 12884 {
12885 std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" already has manipulator.\n";
12886 return 1;
12887 }
12888 }
12889
12890 AIS_Manipulator::OptionsForAttach anOptions;
12891 if (aCmd.HasOption ("adjustPosition", 1, Standard_True))
12892 {
12893 anOptions.SetAdjustPosition (aCmd.ArgBool ("adjustPosition"));
12894 }
12895 if (aCmd.HasOption ("adjustSize", 1, Standard_True))
12896 {
12897 anOptions.SetAdjustSize (aCmd.ArgBool ("adjustSize"));
12898 }
12899 if (aCmd.HasOption ("enableModes", 1, Standard_True))
12900 {
12901 anOptions.SetEnableModes (aCmd.ArgBool ("enableModes"));
12902 }
12903
12904 aManipulator->Attach (anObject, anOptions);
bbf3fcde 12905
12906 // Check view option
12907 if (aCmd.HasOption ("view"))
12908 {
12909 if (!aCmd.HasOption ("view", 1, Standard_True))
12910 {
12911 return 1;
12912 }
12913 TCollection_AsciiString aViewString (aCmd.Arg ("view", 0).c_str());
12914 Handle(V3d_View) aView;
12915 if (aViewString.IsEqual ("active"))
12916 {
12917 aView = ViewerTest::CurrentView();
12918 }
12919 else // Check view name
12920 {
12921 ViewerTest_Names aViewNames (aViewString);
12922 if (!ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
12923 {
12924 std::cerr << theArgVec[0] << " error: wrong view name '" << aViewString << "'\n";
12925 return 1;
12926 }
12927 aView = ViewerTest_myViews.Find1 (aViewNames.GetViewName());
12928 if (aView.IsNull())
12929 {
12930 std::cerr << theArgVec[0] << " error: cannot find view with name '" << aViewString << "'\n";
12931 return 1;
12932 }
12933 }
12934 for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
12935 anIter (ViewerTest_myViews); anIter.More(); anIter.Next())
12936 {
12937 ViewerTest::GetAISContext()->SetViewAffinity (aManipulator, anIter.Value(), Standard_False);
12938 }
12939 ViewerTest::GetAISContext()->SetViewAffinity (aManipulator, aView, Standard_True);
12940 }
625e1958 12941 }
12942
12943 // --------------------------------------
12944 // apply transformation using manipulator
12945 // --------------------------------------
12946
12947 if (aCmd.HasOption ("startTransform", 2, Standard_True))
12948 {
12949 aManipulator->StartTransform (aCmd.ArgInt ("startTransform", 0), aCmd.ArgInt ("startTransform", 1), ViewerTest::CurrentView());
12950 }
12951 if (aCmd.HasOption ("transform", 2, Standard_True))
12952 {
12953 aManipulator->Transform (aCmd.ArgInt ("transform", 0), aCmd.ArgInt ("transform", 1), ViewerTest::CurrentView());
12954 }
12955 if (aCmd.HasOption ("stopTransform"))
12956 {
12957 Standard_Boolean toApply = !aCmd.HasOption ("stopTransform", 1) || (aCmd.Arg ("stopTransform", 0) != "abort");
12958
12959 aManipulator->StopTransform (toApply);
12960 }
12961
12962 gp_Trsf aT;
12963 if (aCmd.HasOption ("move", 3, Standard_True))
12964 {
12965 aT.SetTranslationPart (aCmd.ArgVec ("move"));
12966 }
12967 if (aCmd.HasOption ("rotate", 7, Standard_True))
12968 {
12969 aT.SetRotation (gp_Ax1 (aCmd.ArgPnt ("rotate", 0), aCmd.ArgVec ("rotate", 3)), aCmd.ArgDouble ("rotate", 6));
12970 }
12971 if (aCmd.HasOption ("scale", 1))
12972 {
12973 aT.SetScale (gp_Pnt(), aCmd.ArgDouble("scale"));
12974 }
12975
12976 if (aT.Form() != gp_Identity)
12977 {
12978 aManipulator->Transform (aT);
12979 }
12980
0577ae8c 12981 ViewerTest::GetAISContext()->Redisplay (aManipulator, Standard_True);
625e1958 12982
12983 return 0;
12984}
12985
8e5fb5ea 12986//===============================================================================================
12987//function : VSelectionProperties
12988//purpose :
12989//===============================================================================================
12990static int VSelectionProperties (Draw_Interpretor& theDi,
12991 Standard_Integer theArgsNb,
12992 const char** theArgVec)
12993{
12994 const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
12995 if (aCtx.IsNull())
12996 {
12997 std::cerr << "No active viewer!\n";
12998 return 1;
12999 }
13000
be3d8cbc 13001 if (TCollection_AsciiString (theArgVec[0]) == "vhighlightselected")
13002 {
13003 // handle obsolete alias
13004 bool toEnable = true;
13005 if (theArgsNb < 2)
13006 {
13007 theDi << (aCtx->ToHilightSelected() ? "on" : "off");
13008 return 0;
13009 }
13010 else if (theArgsNb != 2
13011 || !ViewerTest::ParseOnOff (theArgVec[1], toEnable))
13012 {
13013 std::cout << "Syntax error: wrong number of parameters.";
13014 return 1;
13015 }
13016 if (toEnable != aCtx->ToHilightSelected())
13017 {
13018 aCtx->ClearDetected();
13019 aCtx->SetToHilightSelected (toEnable);
13020 }
13021 return 0;
13022 }
13023
f838dac4 13024 Standard_Boolean toPrint = theArgsNb == 1;
13025 Standard_Boolean toRedraw = Standard_False;
13026 Standard_Integer anArgIter = 1;
13027 Prs3d_TypeOfHighlight aType = Prs3d_TypeOfHighlight_None;
13028 if (anArgIter < theArgsNb)
13029 {
13030 TCollection_AsciiString anArgFirst (theArgVec[anArgIter]);
13031 anArgFirst.LowerCase();
13032 ++anArgIter;
13033 if (anArgFirst == "dynhighlight"
13034 || anArgFirst == "dynhilight"
13035 || anArgFirst == "dynamichighlight"
13036 || anArgFirst == "dynamichilight")
13037 {
13038 aType = Prs3d_TypeOfHighlight_Dynamic;
13039 }
13040 else if (anArgFirst == "localdynhighlight"
13041 || anArgFirst == "localdynhilight"
13042 || anArgFirst == "localdynamichighlight"
13043 || anArgFirst == "localdynamichilight")
13044 {
13045 aType = Prs3d_TypeOfHighlight_LocalDynamic;
13046 }
13047 else if (anArgFirst == "selhighlight"
13048 || anArgFirst == "selhilight"
13049 || anArgFirst == "selectedhighlight"
13050 || anArgFirst == "selectedhilight")
13051 {
13052 aType = Prs3d_TypeOfHighlight_Selected;
13053 }
13054 else if (anArgFirst == "localselhighlight"
13055 || anArgFirst == "localselhilight"
13056 || anArgFirst == "localselectedhighlight"
13057 || anArgFirst == "localselectedhilight")
13058 {
13059 aType = Prs3d_TypeOfHighlight_LocalSelected;
13060 }
13061 else
13062 {
13063 --anArgIter;
13064 }
13065 }
13066 for (; anArgIter < theArgsNb; ++anArgIter)
13067 {
13068 TCollection_AsciiString anArg (theArgVec[anArgIter]);
13069 anArg.LowerCase();
13070 if (anArg == "-help")
13071 {
13072 theDi.PrintHelp (theArgVec[0]);
13073 return 0;
13074 }
13075 else if (anArg == "-print")
13076 {
13077 toPrint = Standard_True;
13078 }
13079 else if (anArg == "-autoactivate")
13080 {
13081 Standard_Boolean toEnable = Standard_True;
13082 if (anArgIter + 1 < theArgsNb
13083 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
13084 {
13085 ++anArgIter;
13086 }
13087 aCtx->SetAutoActivateSelection (toEnable);
13088 }
be3d8cbc 13089 else if (anArg == "-automatichighlight"
13090 || anArg == "-automatichilight"
13091 || anArg == "-autohighlight"
13092 || anArg == "-autohilight")
13093 {
13094 Standard_Boolean toEnable = Standard_True;
13095 if (anArgIter + 1 < theArgsNb
13096 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
13097 {
13098 ++anArgIter;
13099 }
13100 aCtx->ClearSelected (false);
13101 aCtx->ClearDetected();
13102 aCtx->SetAutomaticHilight (toEnable);
13103 toRedraw = true;
13104 }
13105 else if (anArg == "-highlightselected"
13106 || anArg == "-hilightselected")
13107 {
13108 Standard_Boolean toEnable = Standard_True;
13109 if (anArgIter + 1 < theArgsNb
13110 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
13111 {
13112 ++anArgIter;
13113 }
13114 aCtx->ClearDetected();
13115 aCtx->SetToHilightSelected (toEnable);
13116 toRedraw = true;
13117 }
14c4193d 13118 else if (anArg == "-pickstrategy"
13119 || anArg == "-pickingstrategy")
13120 {
13121 if (++anArgIter >= theArgsNb)
13122 {
13123 std::cout << "Syntax error: type of highlighting is undefined\n";
13124 return 1;
13125 }
13126
13127 SelectMgr_PickingStrategy aStrategy = SelectMgr_PickingStrategy_FirstAcceptable;
13128 TCollection_AsciiString aVal (theArgVec[anArgIter]);
13129 aVal.LowerCase();
13130 if (aVal == "first"
13131 || aVal == "firstaccepted"
13132 || aVal == "firstacceptable")
13133 {
13134 aStrategy = SelectMgr_PickingStrategy_FirstAcceptable;
13135 }
13136 else if (aVal == "topmost"
13137 || aVal == "onlyTopmost")
13138 {
13139 aStrategy = SelectMgr_PickingStrategy_OnlyTopmost;
13140 }
13141 else
13142 {
13143 std::cout << "Syntax error: unknwon picking strategy '" << aVal << "'\n";
13144 return 1;
13145 }
13146
13147 aCtx->SetPickingStrategy (aStrategy);
13148 }
f838dac4 13149 else if (anArg == "-pixtol"
13150 && anArgIter + 1 < theArgsNb)
13151 {
13152 aCtx->SetPixelTolerance (Draw::Atoi (theArgVec[++anArgIter]));
13153 }
13154 else if ((anArg == "-mode"
13155 || anArg == "-dispmode")
13156 && anArgIter + 1 < theArgsNb)
13157 {
13158 if (aType == Prs3d_TypeOfHighlight_None)
13159 {
13160 std::cout << "Syntax error: type of highlighting is undefined\n";
13161 return 1;
13162 }
8e5fb5ea 13163
f838dac4 13164 const Standard_Integer aDispMode = Draw::Atoi (theArgVec[++anArgIter]);
13165 const Handle(Prs3d_Drawer)& aStyle = aCtx->HighlightStyle (aType);
13166 aStyle->SetDisplayMode (aDispMode);
13167 toRedraw = Standard_True;
13168 }
13169 else if (anArg == "-layer"
13170 && anArgIter + 1 < theArgsNb)
13171 {
13172 if (aType == Prs3d_TypeOfHighlight_None)
13173 {
13174 std::cout << "Syntax error: type of highlighting is undefined\n";
13175 return 1;
13176 }
8e5fb5ea 13177
55c8f0f7
BB		 13178 ++anArgIter;
13179 Graphic3d_ZLayerId aNewLayer = Graphic3d_ZLayerId_UNKNOWN;
13180 if (!ViewerTest::ParseZLayer (theArgVec[anArgIter], aNewLayer))
f838dac4 13181 {
55c8f0f7
BB		 13182 std::cerr << "Error: wrong syntax at " << theArgVec[anArgIter] << ".\n";
13183 return 1;
f838dac4 13184 }
8e5fb5ea 13185
f838dac4 13186 const Handle(Prs3d_Drawer)& aStyle = aCtx->HighlightStyle (aType);
13187 aStyle->SetZLayer (aNewLayer);
13188 toRedraw = Standard_True;
13189 }
13190 else if (anArg == "-hicolor"
13191 || anArg == "-selcolor"
13192 || anArg == "-color")
13193 {
13194 if (anArg.StartsWith ("-hi"))
13195 {
13196 aType = Prs3d_TypeOfHighlight_Dynamic;
13197 }
13198 else if (anArg.StartsWith ("-sel"))
13199 {
13200 aType = Prs3d_TypeOfHighlight_Selected;
13201 }
13202 else if (aType == Prs3d_TypeOfHighlight_None)
13203 {
13204 std::cout << "Syntax error: type of highlighting is undefined\n";
13205 return 1;
13206 }
8e5fb5ea 13207
f838dac4 13208 Quantity_Color aColor;
13209 Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgsNb - anArgIter - 1,
13210 theArgVec + anArgIter + 1,
13211 aColor);
13212 if (aNbParsed == 0)
13213 {
13214 std::cout << "Syntax error: need more arguments.\n";
13215 return 1;
13216 }
13217 anArgIter += aNbParsed;
8e5fb5ea 13218
f838dac4 13219 const Handle(Prs3d_Drawer)& aStyle = aCtx->HighlightStyle (aType);
13220 aStyle->SetColor (aColor);
13221 toRedraw = Standard_True;
13222 }
13223 else if ((anArg == "-transp"
13224 || anArg == "-transparency"
13225 || anArg == "-hitransp"
13226 || anArg == "-seltransp"
13227 || anArg == "-hitransplocal"
13228 || anArg == "-seltransplocal")
13229 && anArgIter + 1 < theArgsNb)
13230 {
13231 if (anArg.StartsWith ("-hi"))
13232 {
13233 aType = Prs3d_TypeOfHighlight_Dynamic;
13234 }
13235 else if (anArg.StartsWith ("-sel"))
13236 {
13237 aType = Prs3d_TypeOfHighlight_Selected;
13238 }
13239 else if (aType == Prs3d_TypeOfHighlight_None)
13240 {
13241 std::cout << "Syntax error: type of highlighting is undefined\n";
13242 return 1;
13243 }
8e5fb5ea 13244
f838dac4 13245 const Standard_Real aTransp = Draw::Atof (theArgVec[++anArgIter]);
13246 const Handle(Prs3d_Drawer)& aStyle = aCtx->HighlightStyle (aType);
13247 aStyle->SetTransparency ((Standard_ShortReal )aTransp);
13248 toRedraw = Standard_True;
13249 }
13250 else if ((anArg == "-mat"
13251 || anArg == "-material")
13252 && anArgIter + 1 < theArgsNb)
13253 {
13254 if (aType == Prs3d_TypeOfHighlight_None)
13255 {
13256 std::cout << "Syntax error: type of highlighting is undefined\n";
13257 return 1;
13258 }
8e5fb5ea 13259
f838dac4 13260 const Handle(Prs3d_Drawer)& aStyle = aCtx->HighlightStyle (aType);
13261 Graphic3d_NameOfMaterial aMatName = Graphic3d_MaterialAspect::MaterialFromName (theArgVec[anArgIter + 1]);
13262 if (aMatName != Graphic3d_NOM_DEFAULT)
13263 {
13264 ++anArgIter;
13265 Handle(Graphic3d_AspectFillArea3d) anAspect = new Graphic3d_AspectFillArea3d();
13266 *anAspect = *aCtx->DefaultDrawer()->ShadingAspect()->Aspect();
13267 Graphic3d_MaterialAspect aMat (aMatName);
13268 aMat.SetColor (aStyle->Color());
13269 aMat.SetTransparency (aStyle->Transparency());
13270 anAspect->SetFrontMaterial (aMat);
13271 anAspect->SetInteriorColor (aStyle->Color());
13272 aStyle->SetBasicFillAreaAspect (anAspect);
13273 }
13274 else
13275 {
13276 aStyle->SetBasicFillAreaAspect (Handle(Graphic3d_AspectFillArea3d)());
13277 }
13278 toRedraw = Standard_True;
13279 }
13280 else
13281 {
13282 std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
13283 }
8e5fb5ea 13284 }
13285
f838dac4 13286 if (toPrint)
8e5fb5ea 13287 {
f838dac4 13288 const Handle(Prs3d_Drawer)& aHiStyle = aCtx->HighlightStyle();
13289 const Handle(Prs3d_Drawer)& aSelStyle = aCtx->SelectionStyle();
8e5fb5ea 13290 theDi << "Auto-activation : " << (aCtx->GetAutoActivateSelection() ? "On" : "Off") << "\n";
be3d8cbc 13291 theDi << "Auto-highlight : " << (aCtx->AutomaticHilight() ? "On" : "Off") << "\n";
13292 theDi << "Highlight selected : " << (aCtx->ToHilightSelected() ? "On" : "Off") << "\n";
8e5fb5ea 13293 theDi << "Selection pixel tolerance : " << aCtx->MainSelector()->PixelTolerance() << "\n";
f838dac4 13294 theDi << "Selection color : " << Quantity_Color::StringName (aSelStyle->Color().Name()) << "\n";
13295 theDi << "Dynamic highlight color : " << Quantity_Color::StringName (aHiStyle->Color().Name()) << "\n";
13296 theDi << "Selection transparency : " << aSelStyle->Transparency() << "\n";
13297 theDi << "Dynamic highlight transparency : " << aHiStyle->Transparency() << "\n";
13298 theDi << "Selection mode : " << aSelStyle->DisplayMode() << "\n";
13299 theDi << "Dynamic highlight mode : " << aHiStyle->DisplayMode() << "\n";
13300 theDi << "Selection layer : " << aSelStyle->ZLayer() << "\n";
13301 theDi << "Dynamic layer : " << aHiStyle->ZLayer() << "\n";
8e5fb5ea 13302 }
13303
13304 if (aCtx->NbSelected() != 0 && toRedraw)
13305 {
13306 aCtx->HilightSelected (Standard_True);
13307 }
13308
13309 return 0;
13310}
13311
decdee7d 13312//===============================================================================================
13313//function : VDumpSelectionImage
13314//purpose :
13315//===============================================================================================
13316static int VDumpSelectionImage (Draw_Interpretor& /*theDi*/,
13317 Standard_Integer theArgsNb,
13318 const char** theArgVec)
13319{
13320 if (theArgsNb < 2)
13321 {
13322 std::cout << "Syntax error: wrong number arguments for '" << theArgVec[0] << "'\n";
13323 return 1;
13324 }
13325
13326 const Handle(AIS_InteractiveContext)& aContext = ViewerTest::GetAISContext();
13327 if (aContext.IsNull())
13328 {
13329 std::cout << "Error: no active view.\n";
13330 return 1;
13331 }
13332
13333 TCollection_AsciiString aFile;
13334 StdSelect_TypeOfSelectionImage aType = StdSelect_TypeOfSelectionImage_NormalizedDepth;
dc858f4c 13335 Image_Format anImgFormat = Image_Format_BGR;
decdee7d 13336 Standard_Integer aPickedIndex = 1;
13337 for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
13338 {
13339 TCollection_AsciiString aParam (theArgVec[anArgIter]);
13340 aParam.LowerCase();
13341 if (aParam == "-type")
13342 {
13343 if (++anArgIter >= theArgsNb)
13344 {
13345 std::cout << "Syntax error: wrong number parameters of flag '-depth'.\n";
13346 return 1;
13347 }
13348
13349 TCollection_AsciiString aValue (theArgVec[anArgIter]);
13350 aValue.LowerCase();
13351 if (aValue == "depth"
13352 || aValue == "normdepth"
13353 || aValue == "normalizeddepth")
13354 {
13355 aType = StdSelect_TypeOfSelectionImage_NormalizedDepth;
dc858f4c 13356 anImgFormat = Image_Format_GrayF;
decdee7d 13357 }
13358 if (aValue == "depthinverted"
13359 || aValue == "normdepthinverted"
13360 || aValue == "normalizeddepthinverted"
13361 || aValue == "inverted")
13362 {
13363 aType = StdSelect_TypeOfSelectionImage_NormalizedDepthInverted;
dc858f4c 13364 anImgFormat = Image_Format_GrayF;
decdee7d 13365 }
13366 else if (aValue == "unnormdepth"
13367 || aValue == "unnormalizeddepth")
13368 {
13369 aType = StdSelect_TypeOfSelectionImage_UnnormalizedDepth;
dc858f4c 13370 anImgFormat = Image_Format_GrayF;
decdee7d 13371 }
13372 else if (aValue == "objectcolor"
13373 || aValue == "object"
13374 || aValue == "color")
13375 {
13376 aType = StdSelect_TypeOfSelectionImage_ColoredDetectedObject;
13377 }
13378 else if (aValue == "entitycolor"
13379 || aValue == "entity")
13380 {
13381 aType = StdSelect_TypeOfSelectionImage_ColoredEntity;
13382 }
13383 else if (aValue == "ownercolor"
13384 || aValue == "owner")
13385 {
13386 aType = StdSelect_TypeOfSelectionImage_ColoredOwner;
13387 }
13388 else if (aValue == "selectionmodecolor"
13389 || aValue == "selectionmode"
13390 || aValue == "selmodecolor"
13391 || aValue == "selmode")
13392 {
13393 aType = StdSelect_TypeOfSelectionImage_ColoredSelectionMode;
13394 }
13395 }
13396 else if (aParam == "-picked"
13397 || aParam == "-pickeddepth"
13398 || aParam == "-pickedindex")
13399 {
13400 if (++anArgIter >= theArgsNb)
13401 {
13402 std::cout << "Syntax error: wrong number parameters at '" << aParam << "'.\n";
13403 return 1;
13404 }
13405
13406 aPickedIndex = Draw::Atoi (theArgVec[anArgIter]);
13407 }
13408 else if (aFile.IsEmpty())
13409 {
13410 aFile = theArgVec[anArgIter];
13411 }
13412 else
13413 {
13414 std::cout << "Syntax error: unknown argument '" << theArgVec[anArgIter] << "'.\n";
13415 return 1;
13416 }
13417 }
13418 if (aFile.IsEmpty())
13419 {
13420 std::cout << "Syntax error: image file name is missing.\n";
13421 return 1;
13422 }
13423
13424 const Handle(V3d_View)& aView = ViewerTest::CurrentView();
13425 Standard_Integer aWidth = 0, aHeight = 0;
13426 aView->Window()->Size (aWidth, aHeight);
13427
13428 Image_AlienPixMap aPixMap;
13429 if (!aPixMap.InitZero (anImgFormat, aWidth, aHeight))
13430 {
13431 std::cout << "Error: can't allocate image.\n";
13432 return 1;
13433 }
13434 if (!aContext->MainSelector()->ToPixMap (aPixMap, aView, aType, aPickedIndex))
13435 {
13436 std::cout << "Error: can't generate selection image.\n";
13437 return 1;
13438 }
13439 if (!aPixMap.Save (aFile))
13440 {
13441 std::cout << "Error: can't save selection image.\n";
13442 return 0;
13443 }
13444 return 0;
13445}
13446
2108d9a2 13447//===============================================================================================
13448//function : VViewCube
13449//purpose :
13450//===============================================================================================
13451static int VViewCube (Draw_Interpretor& ,
13452 Standard_Integer theNbArgs,
13453 const char** theArgVec)
13454{
13455 const Handle(AIS_InteractiveContext)& aContext = ViewerTest::GetAISContext();
13456 const Handle(V3d_View)& aView = ViewerTest::CurrentView();
13457 if (aContext.IsNull() || aView.IsNull())
13458 {
13459 std::cout << "Error: no active view.\n";
13460 return 1;
13461 }
13462 else if (theNbArgs < 2)
13463 {
13464 std::cout << "Syntax error: wrong number arguments\n";
13465 return 1;
13466 }
13467
13468 Handle(AIS_ViewCube) aViewCube;
13469 ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
13470 Quantity_Color aColorRgb;
13471 TCollection_AsciiString aName;
13472 for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
13473 {
13474 TCollection_AsciiString anArg (theArgVec[anArgIter]);
13475 anArg.LowerCase();
13476 if (anUpdateTool.parseRedrawMode (anArg))
13477 {
13478 //
13479 }
13480 else if (aViewCube.IsNull())
13481 {
13482 aName = theArgVec[anArgIter];
13483 if (aName.StartsWith ("-"))
13484 {
13485 std::cout << "Syntax error: object name should be specified.\n";
13486 return 1;
13487 }
13488 Handle(AIS_InteractiveObject) aPrs;
13489 GetMapOfAIS().Find2 (aName, aPrs);
13490 aViewCube = Handle(AIS_ViewCube)::DownCast (aPrs);
13491 if (aViewCube.IsNull())
13492 {
13493 aViewCube = new AIS_ViewCube();
13494 aViewCube->SetBoxColor (Quantity_NOC_GRAY50);
13495 aViewCube->SetViewAnimation (ViewerTest::CurrentEventManager()->ViewAnimation());
13496 aViewCube->SetFixedAnimationLoop (false);
13497 }
13498 }
13499 else if (anArg == "-reset")
13500 {
13501 aViewCube->ResetStyles();
13502 }
13503 else if (anArg == "-color"
13504 || anArg == "-boxcolor"
13505 || anArg == "-boxsidecolor"
13506 || anArg == "-sidecolor"
13507 || anArg == "-boxedgecolor"
13508 || anArg == "-edgecolor"
13509 || anArg == "-boxcornercolor"
13510 || anArg == "-cornercolor"
13511 || anArg == "-innercolor"
13512 || anArg == "-textcolor")
13513 {
13514 Standard_Integer aNbParsed = ViewerTest::ParseColor (theNbArgs - anArgIter - 1,
13515 theArgVec + anArgIter + 1,
13516 aColorRgb);
13517 if (aNbParsed == 0)
13518 {
13519 std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
13520 return 1;
13521 }
13522 anArgIter += aNbParsed;
13523 if (anArg == "-boxcolor")
13524 {
13525 aViewCube->SetBoxColor (aColorRgb);
13526 }
13527 else if (anArg == "-boxsidecolor"
13528 || anArg == "-sidecolor")
13529 {
13530 aViewCube->BoxSideStyle()->SetColor (aColorRgb);
13531 aViewCube->SynchronizeAspects();
13532 }
13533 else if (anArg == "-boxedgecolor"
13534 || anArg == "-edgecolor")
13535 {
13536 aViewCube->BoxEdgeStyle()->SetColor (aColorRgb);
13537 aViewCube->SynchronizeAspects();
13538 }
13539 else if (anArg == "-boxcornercolor"
13540 || anArg == "-cornercolor")
13541 {
13542 aViewCube->BoxCornerStyle()->SetColor (aColorRgb);
13543 aViewCube->SynchronizeAspects();
13544 }
13545 else if (anArg == "-innercolor")
13546 {
13547 aViewCube->SetInnerColor (aColorRgb);
13548 }
13549 else if (anArg == "-textcolor")
13550 {
13551 aViewCube->SetTextColor (aColorRgb);
13552 }
13553 else
13554 {
13555 aViewCube->SetColor (aColorRgb);
13556 }
13557 }
13558 else if (anArgIter + 1 < theNbArgs
13559 && (anArg == "-transparency"
13560 || anArg == "-boxtransparency"))
13561 {
13562 const Standard_Real aValue = Draw::Atof (theArgVec[++anArgIter]);
13563 if (aValue < 0.0 || aValue > 1.0)
13564 {
13565 std::cout << "Syntax error: invalid transparency value " << theArgVec[anArgIter] << "\n";
13566 return 1;
13567 }
13568
13569 if (anArg == "-boxtransparency")
13570 {
13571 aViewCube->SetBoxTransparency (aValue);
13572 }
13573 else
13574 {
13575 aViewCube->SetTransparency (aValue);
13576 }
13577 }
13578 else if (anArg == "-axes"
13579 || anArg == "-edges"
13580 || anArg == "-vertices"
13581 || anArg == "-vertexes"
13582 || anArg == "-fixedanimation")
13583 {
13584 bool toShow = true;
13585 if (anArgIter + 1 < theNbArgs
13586 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toShow))
13587 {
13588 ++anArgIter;
13589 }
13590 if (anArg == "-fixedanimation")
13591 {
13592 aViewCube->SetFixedAnimationLoop (toShow);
13593 }
13594 else if (anArg == "-axes")
13595 {
13596 aViewCube->SetDrawAxes (toShow);
13597 }
13598 else if (anArg == "-edges")
13599 {
13600 aViewCube->SetDrawEdges (toShow);
13601 }
13602 else
13603 {
13604 aViewCube->SetDrawVertices (toShow);
13605 }
13606 }
13607 else if (anArg == "-yup"
13608 || anArg == "-zup")
13609 {
13610 bool isOn = true;
13611 if (anArgIter + 1 < theNbArgs
13612 && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], isOn))
13613 {
13614 ++anArgIter;
13615 }
13616 if (anArg == "-yup")
13617 {
13618 aViewCube->SetYup (isOn);
13619 }
13620 else
13621 {
13622 aViewCube->SetYup (!isOn);
13623 }
13624 }
13625 else if (anArgIter + 1 < theNbArgs
13626 && anArg == "-font")
13627 {
13628 aViewCube->SetFont (theArgVec[++anArgIter]);
13629 }
13630 else if (anArgIter + 1 < theNbArgs
13631 && anArg == "-fontheight")
13632 {
13633 aViewCube->SetFontHeight (Draw::Atof (theArgVec[++anArgIter]));
13634 }
13635 else if (anArgIter + 1 < theNbArgs
13636 && (anArg == "-size"
13637 || anArg == "-boxsize"))
13638 {
13639 aViewCube->SetSize (Draw::Atof (theArgVec[++anArgIter]),
13640 anArg != "-boxsize");
13641 }
13642 else if (anArgIter + 1 < theNbArgs
13643 && (anArg == "-boxfacet"
13644 || anArg == "-boxfacetextension"
13645 || anArg == "-facetextension"
13646 || anArg == "-extension"))
13647 {
13648 aViewCube->SetBoxFacetExtension (Draw::Atof (theArgVec[++anArgIter]));
13649 }
13650 else if (anArgIter + 1 < theNbArgs
13651 && (anArg == "-boxedgegap"
13652 || anArg == "-edgegap"))
13653 {
13654 aViewCube->SetBoxEdgeGap (Draw::Atof (theArgVec[++anArgIter]));
13655 }
13656 else if (anArgIter + 1 < theNbArgs
13657 && (anArg == "-boxedgeminsize"
13658 || anArg == "-edgeminsize"))
13659 {
13660 aViewCube->SetBoxEdgeMinSize (Draw::Atof (theArgVec[++anArgIter]));
13661 }
13662 else if (anArgIter + 1 < theNbArgs
13663 && (anArg == "-boxcornerminsize"
13664 || anArg == "-cornerminsize"))
13665 {
13666 aViewCube->SetBoxCornerMinSize (Draw::Atof (theArgVec[++anArgIter]));
13667 }
13668 else if (anArgIter + 1 < theNbArgs
13669 && anArg == "-axespadding")
13670 {
13671 aViewCube->SetAxesPadding (Draw::Atof (theArgVec[++anArgIter]));
13672 }
13673 else if (anArgIter + 1 < theNbArgs
13674 && anArg == "-roundradius")
13675 {
13676 aViewCube->SetRoundRadius (Draw::Atof (theArgVec[++anArgIter]));
13677 }
13678 else if (anArgIter + 1 < theNbArgs
13679 && anArg == "-duration")
13680 {
13681 aViewCube->SetDuration (Draw::Atof (theArgVec[++anArgIter]));
13682 }
13683 else
13684 {
13685 std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
13686 return 1;
13687 }
13688 }
13689 if (aViewCube.IsNull())
13690 {
13691 std::cout << "Syntax error: wrong number of arguments\n";
13692 return 1;
13693 }
13694
13695 ViewerTest::Display (aName, aViewCube, false);
13696 return 0;
13697}
13698
7fd59977 13699//=======================================================================
13700//function : ViewerCommands
13701//purpose :
13702//=======================================================================
13703
13704void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
13705{
13706
13707 const char *group = "ZeViewer";
18d715bd 13708 theCommands.Add("vinit",
fd3f6bd0 13709 "vinit [-name viewName] [-left leftPx] [-top topPx] [-width widthPx] [-height heightPx]"
2e93433e 13710 "\n\t\t: [-exitOnClose] [-closeOnEscape] [-cloneActive] [-2d_mode {on|off}=off]"
fd3f6bd0 13711 #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
13712 "\n\t\t: [-display displayName]"
13713 #endif
13714 "\n\t\t: Creates new View window with specified name viewName."
13715 "\n\t\t: By default the new view is created in the viewer and in"
13716 "\n\t\t: graphic driver shared with active view."
13717 "\n\t\t: -name {driverName/viewerName/viewName | viewerName/viewName | viewName}"
13718 "\n\t\t: If driverName isn't specified the driver will be shared with active view."
13719 "\n\t\t: If viewerName isn't specified the viewer will be shared with active view."
13720#if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
13721 "\n\t\t: -display HostName.DisplayNumber[:ScreenNumber]"
13722 "\n\t\t: Display name will be used within creation of graphic driver, when specified."
18d715bd 13723#endif
fd3f6bd0 13724 "\n\t\t: -left, -top pixel position of left top corner of the window."
13725 "\n\t\t: -width, -height width and heigth of window respectively."
9e04ccdc 13726 "\n\t\t: -cloneActive floag to copy camera and dimensions of active view."
fd3f6bd0 13727 "\n\t\t: -exitOnClose when specified, closing the view will exit application."
13728 "\n\t\t: -closeOnEscape when specified, view will be closed on pressing Escape."
2e93433e 13729 "\n\t\t: -2d_mode when on, view will not react on rotate scene events"
fd3f6bd0 13730 "\n\t\t: Additional commands for operations with views: vclose, vactivate, vviewlist.",
7fd59977 13731 __FILE__,VInit,group);
18d715bd 13732 theCommands.Add("vclose" ,
d0cc1cb7 13733 "[view_id [keep_context=0|1]]\n"
18d715bd 13734 "or vclose ALL - to remove all created views\n"
13735 " - removes view(viewer window) defined by its view_id.\n"
13736 " - keep_context: by default 0; if 1 and the last view is deleted"
13737 " the current context is not removed.",
13738 __FILE__,VClose,group);
13739 theCommands.Add("vactivate" ,
e084dbbc 13740 "vactivate view_id [-noUpdate]"
18d715bd 13741 " - activates view(viewer window) defined by its view_id",
13742 __FILE__,VActivate,group);
13743 theCommands.Add("vviewlist",
13744 "vviewlist [format={tree, long}]"
13745 " - prints current list of views per viewer and graphic_driver ID shared between viewers"
13746 " - format: format of result output, if tree the output is a tree view;"
13747 "otherwise it's a list of full view names. By default format = tree",
13748 __FILE__,VViewList,group);
7fd59977 13749 theCommands.Add("vhelp" ,
13750 "vhelp : display help on the viewer commands",
13751 __FILE__,VHelp,group);
fc552d84 13752 theCommands.Add("vviewproj",
13753 "vviewproj [top|bottom|left|right|front|back|axoLeft|axoRight]"
13754 "\n\t\t: [+-X+-Y+-Z] [-Zup|-Yup] [-frame +-X+-Y]"
13755 "\n\t\t: Setup view direction"
13756 "\n\t\t: -Yup use Y-up convention instead of Zup (which is default)."
13757 "\n\t\t: +-X+-Y+-Z define direction as combination of DX, DY and DZ;"
13758 "\n\t\t: for example '+Z' will show front of the model,"
13759 "\n\t\t: '-X-Y+Z' will define left axonometrical view."
13760 "\n\t\t: -frame define camera Up and Right directions (regardless Up convention);"
13761 "\n\t\t: for example '+X+Z' will show front of the model with Z-up."
13762 __FILE__,VViewProj,group);
7fd59977 13763 theCommands.Add("vtop" ,
27af3052 13764 "vtop or <T> : Top view. Orientation +X+Y" ,
fc552d84 13765 __FILE__,VViewProj,group);
44b8f2d6 13766 theCommands.Add("vbottom" ,
27af3052 13767 "vbottom : Bottom view. Orientation +X-Y" ,
fc552d84 13768 __FILE__,VViewProj,group);
44b8f2d6 13769 theCommands.Add("vleft" ,
27af3052 13770 "vleft : Left view. Orientation -Y+Z" ,
fc552d84 13771 __FILE__,VViewProj,group);
44b8f2d6 13772 theCommands.Add("vright" ,
27af3052 13773 "vright : Right view. Orientation +Y+Z" ,
fc552d84 13774 __FILE__,VViewProj,group);
7fd59977 13775 theCommands.Add("vaxo" ,
27af3052 13776 " vaxo or <A> : Axonometric view. Orientation +X-Y+Z",
fc552d84 13777 __FILE__,VViewProj,group);
44b8f2d6 13778 theCommands.Add("vfront" ,
27af3052 13779 "vfront : Front view. Orientation +X+Z" ,
fc552d84 13780 __FILE__,VViewProj,group);
44b8f2d6 13781 theCommands.Add("vback" ,
27af3052 13782 "vback : Back view. Orientation -X+Z" ,
fc552d84 13783 __FILE__,VViewProj,group);
7fd59977 13784 theCommands.Add("vpick" ,
13785 "vpick : vpick X Y Z [shape subshape] ( all variables as string )",
13786 VPick,group);
1beb58d7 13787 theCommands.Add("vfit",
13788 "vfit or <F> [-selected] [-noupdate]"
b586500b 13789 "\n\t\t: [-selected] fits the scene according to bounding box of currently selected objects",
7fd59977 13790 __FILE__,VFit,group);
6262a303 13791 theCommands.Add ("vfitarea",
13792 "vfitarea x1 y1 x2 y2"
13793 "\n\t\t: vfitarea x1 y1 z1 x2 y2 z2"
13794 "\n\t\t: Fit view to show area located between two points"
13795 "\n\t\t: given in world 2D or 3D corrdinates.",
13796 __FILE__, VFitArea, group);
197ac94e 13797 theCommands.Add ("vzfit", "vzfit [scale]\n"
13798 " Matches Z near, Z far view volume planes to the displayed objects.\n"
13799 " \"scale\" - specifies factor to scale computed z range.\n",
13800 __FILE__, VZFit, group);
7fd59977 13801 theCommands.Add("vrepaint",
8693dfd0 13802 "vrepaint [-immediate] [-continuous FPS]"
13803 "\n\t\t: force redraw of active View"
13804 "\n\t\t: -immediate flag performs redraw of immediate layers only;"
13805 "\n\t\t: -continuous activates/deactivates continuous redraw of active View,"
13806 "\n\t\t: 0 means no continuous rendering,"
13807 "\n\t\t: -1 means non-stop redraws,"
13808 "\n\t\t: >0 specifies target framerate,",
7fd59977 13809 __FILE__,VRepaint,group);
13810 theCommands.Add("vclear",
faea8b40 13811 "vclear : vclear"
13812 "\n\t\t: remove all the object from the viewer",
7fd59977 13813 __FILE__,VClear,group);
293211ae 13814 theCommands.Add (
13815 "vbackground",
13816 "Changes background or some background settings.\n"
13817 "\n"
13818 "Usage:\n"
13819 " vbackground -imageFile ImageFile [-imageMode FillType]\n"
13820 " vbackground -imageMode FillType\n"
13821 " vbackground -gradient Color1 Color2 [-gradientMode FillMethod]\n"
13822 " vbackground -gradientMode FillMethod\n"
077a220c 13823 " vbackground -cubemap CubemapFile1 [CubeMapFiles2-5] [-order TilesIndexes1-6] [-invertedz]\n"
293211ae 13824 " vbackground -color Color\n"
13825 " vbackground -default -gradient Color1 Color2 [-gradientMode FillType]\n"
13826 " vbackground -default -color Color\n"
13827 " vbackground -help\n"
13828 "\n"
13829 "Options:\n"
13830 " -imageFile (-imgFile, -image, -img): sets filename of image used as background\n"
13831 " -imageMode (-imgMode, -imageMd, -imgMd): sets image fill type\n"
13832 " -gradient (-grad, -gr): sets background gradient starting and ending colors\n"
13833 " -gradientMode (-gradMode, -gradMd, -grMode, -grMd): sets gradient fill method\n"
077a220c 13834 " -cubemap (-cmap, -cm): sets environmet cubemap as background\n"
13835 " -invertedz (-invz, -iz): sets inversion of Z axis for background cubemap rendering\n"
13836 " -order (-o): defines order of tiles in one image cubemap\n"
13837 " (has no effect in case of multi image cubemaps)\n"
293211ae 13838 " -color (-col): sets background color\n"
13839 " -default (-def): sets background default gradient or color\n"
13840 " -help (-h): outputs short help message\n"
13841 "\n"
13842 "Arguments:\n"
077a220c 13843 " Color: Red Green Blue - where Red, Green, Blue must be integers within the range [0, 255]\n"
293211ae 13844 " or reals within the range [0.0, 1.0]\n"
077a220c 13845 " ColorName - one of WHITE, BLACK, RED, GREEN, BLUE, etc.\n"
13846 " #HHH, [#]HHHHHH - where H is a hexadecimal digit (0 .. 9, a .. f, or A .. F)\n"
13847 " FillMethod: one of NONE, HOR[IZONTAL], VER[TICAL], DIAG[ONAL]1, DIAG[ONAL]2, CORNER1, CORNER2, CORNER3, "
293211ae 13848 "CORNER4\n"
077a220c 13849 " FillType: one of CENTERED, TILED, STRETCH, NONE\n"
13850 " ImageFile: a name of the file with the image used as a background\n"
13851 " CubemapFilei: a name of the file with one image packed cubemap or names of separate files with every cubemap side\n"
13852 " TileIndexi: a cubemap side index in range [0, 5] for i tile of one image packed cubemap\n",
293211ae 13853 __FILE__,
13854 vbackground,
13855 group);
13856 theCommands.Add ("vsetbg",
13857 "Loads image as background."
13858 "\n\t\t: vsetbg ImageFile [FillType]"
13859 "\n\t\t: vsetbg -imageFile ImageFile [-imageMode FillType]"
13860 "\n\t\t: Alias for 'vbackground -imageFile ImageFile [-imageMode FillType]'.",
13861 __FILE__,
13862 vbackground,
13863 group);
13864 theCommands.Add ("vsetbgmode",
13865 "Changes background image fill type."
13866 "\n\t\t: vsetbgmode [-imageMode] FillType"
13867 "\n\t\t: Alias for 'vbackground -imageMode FillType'.",
13868 __FILE__,
13869 vbackground,
13870 group);
13871 theCommands.Add ("vsetgradientbg",
13872 "Mounts gradient background."
13873 "\n\t\t: vsetgradientbg Color1 Color2 [FillMethod]"
13874 "\n\t\t: vsetgradientbg -gradient Color1 Color2 [-gradientMode FillMethod]"
13875 "\n\t\t: Alias for 'vbackground -gradient Color1 Color2 -gradientMode FillMethod'.",
13876 __FILE__,
13877 vbackground,
13878 group);
13879 theCommands.Add ("vsetgrbgmode",
13880 "Changes gradient background fill method."
13881 "\n\t\t: vsetgrbgmode [-gradientMode] FillMethod"
13882 "\n\t\t: Alias for 'vbackground -gradientMode FillMethod'.",
13883 __FILE__,
13884 vbackground,
13885 group);
13886 theCommands.Add ("vsetcolorbg",
13887 "Sets background color."
13888 "\n\t\t: vsetcolorbg [-color] Color."
13889 "\n\t\t: Alias for 'vbackground -color Color'.",
13890 __FILE__,
13891 vbackground,
13892 group);
13893 theCommands.Add ("vsetdefaultbg",
13894 "Sets default viewer background fill color (flat/gradient)."
13895 "\n\t\t: vsetdefaultbg Color1 Color2 [FillMethod]"
13896 "\n\t\t: vsetdefaultbg -gradient Color1 Color2 [-gradientMode FillMethod]"
13897 "\n\t\t: Alias for 'vbackground -default -gradient Color1 Color2 [-gradientMode FillMethod]'."
13898 "\n\t\t: vsetdefaultbg [-color] Color"
13899 "\n\t\t: Alias for 'vbackground -default -color Color'.",
13900 __FILE__,
13901 vbackground,
13902 group);
7fd59977 13903 theCommands.Add("vscale",
13904 "vscale : vscale X Y Z",
13905 __FILE__,VScale,group);
13906 theCommands.Add("vzbufftrihedron",
536d98e2 13907 "vzbufftrihedron [{-on|-off}=-on] [-type {wireframe|zbuffer}=zbuffer]"
13908 "\n\t\t: [-position center|left_lower|left_upper|right_lower|right_upper]"
13909 "\n\t\t: [-scale value=0.1] [-size value=0.8] [-arrowDiam value=0.05]"
13910 "\n\t\t: [-colorArrowX color=RED] [-colorArrowY color=GREEN] [-colorArrowZ color=BLUE]"
13911 "\n\t\t: [-nbfacets value=12] [-colorLabels color=WHITE]"
13912 "\n\t\t: Displays a trihedron",
13913 __FILE__,VZBuffTrihedron,group);
7fd59977 13914 theCommands.Add("vrotate",
4af098ba 13915 "vrotate [[-mouseStart X Y] [-mouseMove X Y]]|[AX AY AZ [X Y Z]]"
13916 "\n : Option -mouseStart starts rotation according to the mouse position"
13917 "\n : Option -mouseMove continues rotation with angle computed"
13918 "\n : from last and new mouse position."
13919 "\n : vrotate AX AY AZ [X Y Z]",
7fd59977 13920 __FILE__,VRotate,group);
13921 theCommands.Add("vzoom",
13922 "vzoom : vzoom coef",
13923 __FILE__,VZoom,group);
13924 theCommands.Add("vpan",
13925 "vpan : vpan dx dy",
13926 __FILE__,VPan,group);
7fd59977 13927 theCommands.Add("vcolorscale",
4b3d6eb1 13928 "vcolorscale name [-noupdate|-update] [-demo]"
13929 "\n\t\t: [-range RangeMin=0 RangeMax=1 NbIntervals=10]"
13930 "\n\t\t: [-font HeightFont=20]"
13931 "\n\t\t: [-logarithmic {on|off}=off] [-reversed {on|off}=off]"
13932 "\n\t\t: [-smoothTransition {on|off}=off]"
13933 "\n\t\t: [-hueRange MinAngle=230 MaxAngle=0]"
13934 "\n\t\t: [-colorRange MinColor=BLUE1 MaxColor=RED]"
13935 "\n\t\t: [-textpos {left|right|center|none}=right]"
13936 "\n\t\t: [-labelAtBorder {on|off}=on]"
13937 "\n\t\t: [-colors Color1 Color2 ...] [-color Index Color]"
13938 "\n\t\t: [-labels Label1 Label2 ...] [-label Index Label]"
13939 "\n\t\t: [-freeLabels NbOfLabels Label1 Label2 ...]"
13940 "\n\t\t: [-xy Left=0 Bottom=0]"
13941 "\n\t\t: -demo - displays a color scale with demonstratio values"
13942 "\n\t\t: -colors - set colors for all intervals"
13943 "\n\t\t: -color - set color for specific interval"
13944 "\n\t\t: -textpos - horizontal label position relative to color scale bar"
13945 "\n\t\t: -labelAtBorder - vertical label position relative to color interval;"
13946 "\n\t\t: at border means the value inbetween neighbor intervals,"
13947 "\n\t\t: at center means the center value within current interval"
13948 "\n\t\t: -labels - set labels for all intervals"
13949 "\n\t\t: -freeLabels - same as -labels but does not require"
13950 "\n\t\t: matching the number of intervals"
13951 "\n\t\t: -label - set label for specific interval"
13952 "\n\t\t: -title - set title"
13953 "\n\t\t: -reversed - setup smooth color transition between intervals"
13954 "\n\t\t: -smoothTransition - swap colorscale direction"
13955 "\n\t\t: -hueRange - set hue angles corresponding to minimum and maximum values"
13956 __FILE__, VColorScale, group);
7fd59977 13957 theCommands.Add("vgraduatedtrihedron",
a79f67f8 13958 "vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
13959 "\t[-namefont Name] [-valuesfont Name]\n"
13960 "\t[-xdrawname on/off] [-ydrawname on/off] [-zdrawname on/off]\n"
13961 "\t[-xnameoffset IntVal] [-ynameoffset IntVal] [-znameoffset IntVal]"
13962 "\t[-xnamecolor Color] [-ynamecolor Color] [-znamecolor Color]\n"
13963 "\t[-xdrawvalues on/off] [-ydrawvalues on/off] [-zdrawvalues on/off]\n"
13964 "\t[-xvaluesoffset IntVal] [-yvaluesoffset IntVal] [-zvaluesoffset IntVal]"
13965 "\t[-xcolor Color] [-ycolor Color] [-zcolor Color]\n"
13966 "\t[-xdrawticks on/off] [-ydrawticks on/off] [-zdrawticks on/off]\n"
13967 "\t[-xticks Number] [-yticks Number] [-zticks Number]\n"
13968 "\t[-xticklength IntVal] [-yticklength IntVal] [-zticklength IntVal]\n"
536d98e2 13969 "\t[-drawgrid on/off] [-drawaxes on/off]\n"
a79f67f8 13970 " - Displays or erases graduated trihedron"
13971 " - xname, yname, zname - names of axes, default: X, Y, Z\n"
13972 " - namefont - font of axes names. Default: Arial\n"
13973 " - xnameoffset, ynameoffset, znameoffset - offset of name from values or tickmarks or axis. Default: 30\n"
13974 " - xnamecolor, ynamecolor, znamecolor - colors of axes names\n"
13975 " - xvaluesoffset, yvaluesoffset, zvaluesoffset - offset of values from tickmarks or axis. Default: 10\n"
13976 " - valuesfont - font of axes values. Default: Arial\n"
13977 " - xcolor, ycolor, zcolor - color of axis and values\n"
13978 " - xticks, yticks, xzicks - number of tickmark on axes. Default: 5\n"
13979 " - xticklength, yticklength, xzicklength - length of tickmark on axes. Default: 10\n",
7fd59977 13980 __FILE__,VGraduatedTrihedron,group);
3bffef55 13981 theCommands.Add("vtile" ,
13982 "vtile [-totalSize W H] [-lowerLeft X Y] [-upperLeft X Y] [-tileSize W H]"
13983 "\n\t\t: Setup view to draw a tile (a part of virtual bigger viewport)."
13984 "\n\t\t: -totalSize the size of virtual bigger viewport"
13985 "\n\t\t: -tileSize tile size (the view size will be used if omitted)"
13986 "\n\t\t: -lowerLeft tile offset as lower left corner"
13987 "\n\t\t: -upperLeft tile offset as upper left corner",
13988 __FILE__, VTile, group);
59f45b7c 13989 theCommands.Add("vzlayer",
7c3ef2f7 13990 "vzlayer [layerId]"
1c728f2d 13991 "\n\t\t: [-add|-delete|-get|-settings] [-insertBefore AnotherLayer] [-insertAfter AnotherLayer]"
4ecf34cc 13992 "\n\t\t: [-origin X Y Z] [-cullDist Distance] [-cullSize Size]"
7c3ef2f7 13993 "\n\t\t: [-enable|-disable {depthTest|depthWrite|depthClear|depthoffset}]"
1c728f2d 13994 "\n\t\t: [-enable|-disable {positiveOffset|negativeOffset|textureenv|rayTracing}]"
7c3ef2f7 13995 "\n\t\t: ZLayer list management:"
13996 "\n\t\t: -add add new z layer to viewer and print its id"
1c728f2d 13997 "\n\t\t: -insertBefore add new z layer and insert it before existing one"
13998 "\n\t\t: -insertAfter add new z layer and insert it after existing one"
7c3ef2f7 13999 "\n\t\t: -delete delete z layer"
14000 "\n\t\t: -get print sequence of z layers"
14001 "\n\t\t: -settings print status of z layer settings"
14002 "\n\t\t: -disable disables given setting"
14003 "\n\t\t: -enable enables given setting",
59f45b7c 14004 __FILE__,VZLayer,group);
20637bd2 14005 theCommands.Add("vlayerline",
14006 "vlayerline : vlayerline x1 y1 x2 y2 [linewidth=0.5] [linetype=0] [transparency=1.0]",
14007 __FILE__,VLayerLine,group);
79931835 14008 theCommands.Add("vgrid",
14009 "vgrid [off] [-type {rect|circ}] [-mode {line|point}] [-origin X Y] [-rotAngle Angle] [-zoffset DZ]"
14010 "\n\t\t: [-step X Y] [-size DX DY]"
14011 "\n\t\t: [-step StepRadius NbDivisions] [-radius Radius]",
2bd4c032 14012 __FILE__, VGrid, group);
c40b7d58 14013 theCommands.Add ("vpriviledgedplane",
14014 "vpriviledgedplane [Ox Oy Oz Nx Ny Nz [Xx Xy Xz]]"
14015 "\n\t\t: Ox, Oy, Oz - plane origin"
14016 "\n\t\t: Nx, Ny, Nz - plane normal direction"
14017 "\n\t\t: Xx, Xy, Xz - plane x-reference axis direction"
14018 "\n\t\t: Sets or prints viewer's priviledged plane geometry.",
14019 __FILE__, VPriviledgedPlane, group);
f25b82d6 14020 theCommands.Add ("vconvert",
14021 "vconvert v [Mode={window|view}]"
14022 "\n\t\t: vconvert x y [Mode={window|view|grid|ray}]"
14023 "\n\t\t: vconvert x y z [Mode={window|grid}]"
14024 "\n\t\t: window - convert to window coordinates, pixels"
14025 "\n\t\t: view - convert to view projection plane"
14026 "\n\t\t: grid - convert to model coordinates, given on grid"
14027 "\n\t\t: ray - convert projection ray to model coordiantes"
14028 "\n\t\t: - vconvert v window : convert view to window;"
14029 "\n\t\t: - vconvert v view : convert window to view;"
14030 "\n\t\t: - vconvert x y window : convert view to window;"
14031 "\n\t\t: - vconvert x y view : convert window to view;"
14032 "\n\t\t: - vconvert x y : convert window to model;"
14033 "\n\t\t: - vconvert x y grid : convert window to model using grid;"
14034 "\n\t\t: - vconvert x y ray : convert window projection line to model;"
14035 "\n\t\t: - vconvert x y z window : convert model to window;"
14036 "\n\t\t: - vconvert x y z grid : convert view to model using grid;"
14037 "\n\t\t: Converts the given coordinates to window/view/model space.",
14038 __FILE__, VConvert, group);
208e6839 14039 theCommands.Add ("vfps",
e084dbbc 14040 "vfps [framesNb=100] [-duration seconds] : estimate average frame rate for active view",
208e6839 14041 __FILE__, VFps, group);
58655684 14042 theCommands.Add ("vgldebug",
c87535af 14043 "vgldebug [-sync {0|1}] [-debug {0|1}] [-glslWarn {0|1}]"
84e84755 14044 "\n\t\t: [-glslCode {off|short|full}] [-extraMsg {0|1}] [{0|1}]"
c87535af 14045 "\n\t\t: Request debug GL context. Should be called BEFORE vinit."
14046 "\n\t\t: Debug context can be requested only on Windows"
14047 "\n\t\t: with GL_ARB_debug_output extension implemented by GL driver!"
14048 "\n\t\t: -sync - request synchronized debug GL context"
14049 "\n\t\t: -glslWarn - log GLSL compiler/linker warnings,"
14050 "\n\t\t: which are suppressed by default,"
84e84755 14051 "\n\t\t: -glslCode - log GLSL program source code,"
14052 "\n\t\t: which are suppressed by default,"
c87535af 14053 "\n\t\t: -extraMsg - log extra diagnostic messages from GL context,"
14054 "\n\t\t: which are suppressed by default",
58655684 14055 __FILE__, VGlDebug, group);
208e6839 14056 theCommands.Add ("vvbo",
58655684 14057 "vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
208e6839 14058 __FILE__, VVbo, group);
b5ac8292 14059 theCommands.Add ("vstereo",
f978241f 14060 "vstereo [0|1] [-mode Mode] [-reverse {0|1}]"
14061 "\n\t\t: [-anaglyph Filter]"
14062 "\n\t\t: Control stereo output mode. Available modes for -mode:"
14063 "\n\t\t: quadBuffer - OpenGL QuadBuffer stereo,"
14064 "\n\t\t: requires driver support."
14065 "\n\t\t: Should be called BEFORE vinit!"
14066 "\n\t\t: anaglyph - Anaglyph glasses"
14067 "\n\t\t: rowInterlaced - row-interlaced display"
14068 "\n\t\t: columnInterlaced - column-interlaced display"
14069 "\n\t\t: chessBoard - chess-board output"
14070 "\n\t\t: sideBySide - horizontal pair"
14071 "\n\t\t: overUnder - vertical pair"
14072 "\n\t\t: Available Anaglyph filters for -anaglyph:"
14073 "\n\t\t: redCyan, redCyanSimple, yellowBlue, yellowBlueSimple,"
14074 "\n\t\t: greenMagentaSimple",
b5ac8292 14075 __FILE__, VStereo, group);
a577aaab 14076 theCommands.Add ("vcaps",
ba00aab7 14077 "vcaps [-sRGB {0|1}] [-vbo {0|1}] [-sprites {0|1}] [-ffp {0|1}] [-polygonMode {0|1}]"
1dfe71a6 14078 "\n\t\t: [-compatibleProfile {0|1}]"
56689b27 14079 "\n\t\t: [-vsync {0|1}] [-useWinBuffer {0|1}]"
f978241f 14080 "\n\t\t: [-quadBuffer {0|1}] [-stereo {0|1}]"
8625ef7e 14081 "\n\t\t: [-softMode {0|1}] [-noupdate|-update]"
59515ca6 14082 "\n\t\t: [-noExtensions {0|1}] [-maxVersion Major Minor]"
8625ef7e 14083 "\n\t\t: Modify particular graphic driver options:"
ba00aab7 14084 "\n\t\t: sRGB - enable/disable sRGB rendering"
8625ef7e 14085 "\n\t\t: FFP - use fixed-function pipeline instead of"
14086 "\n\t\t: built-in GLSL programs"
4e1523ef 14087 "\n\t\t: (requires compatible profile)"
2a332745 14088 "\n\t\t: polygonMode - use Polygon Mode instead of built-in GLSL programs"
8625ef7e 14089 "\n\t\t: VBO - use Vertex Buffer Object (copy vertex"
14090 "\n\t\t: arrays to GPU memory)"
14091 "\n\t\t: sprite - use textured sprites instead of bitmaps"
f978241f 14092 "\n\t\t: vsync - switch VSync on or off"
56689b27 14093 "\n\t\t: winBuffer - allow using window buffer for rendering"
4e1523ef 14094 "\n\t\t: Context creation options:"
14095 "\n\t\t: softMode - software OpenGL implementation"
14096 "\n\t\t: compatibleProfile - backward-compatible profile"
f978241f 14097 "\n\t\t: quadbuffer - QuadBuffer"
59515ca6 14098 "\n\t\t: noExtensions - disallow usage of extensions"
14099 "\n\t\t: maxVersion - force upper OpenGL version to be used"
8625ef7e 14100 "\n\t\t: Unlike vrenderparams, these parameters control alternative"
14101 "\n\t\t: rendering paths producing the same visual result when"
14102 "\n\t\t: possible."
14103 "\n\t\t: Command is intended for testing old hardware compatibility.",
a577aaab 14104 __FILE__, VCaps, group);
f0430952 14105 theCommands.Add ("vmemgpu",
14106 "vmemgpu [f]: print system-dependent GPU memory information if available;"
14107 " with f option returns free memory in bytes",
14108 __FILE__, VMemGpu, group);
85e096c3 14109 theCommands.Add ("vreadpixel",
ba00aab7 14110 "vreadpixel xPixel yPixel [{rgb|rgba|sRGB|sRGBa|depth|hls|rgbf|rgbaf}=rgba] [-name|-hex]"
85e096c3 14111 " : Read pixel value for active view",
14112 __FILE__, VReadPixel, group);
692613e5 14113 theCommands.Add("diffimage",
fd3f6bd0 14114 "diffimage imageFile1 imageFile2 [diffImageFile]"
14115 "\n\t\t: [-toleranceOfColor {0..1}=0] [-blackWhite {on|off}=off] [-borderFilter {on|off}=off]"
14116 "\n\t\t: [-display viewName prsName1 prsName2 prsNameDiff] [-exitOnClose] [-closeOnEscape]"
14117 "\n\t\t: Compare two images by content and generate difference image."
14118 "\n\t\t: When -exitOnClose is specified, closing the view will exit application."
14119 "\n\t\t: When -closeOnEscape is specified, view will be closed on pressing Escape.",
692613e5 14120 __FILE__, VDiffImage, group);
4754e164 14121 theCommands.Add ("vselect",
2157d6ac 14122 "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [-allowoverlap 0|1] [shift_selection = 0|1]\n"
4754e164 14123 "- emulates different types of selection:\n"
14124 "- 1) single click selection\n"
14125 "- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
14126 "- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
faea8b40 14127 "- 4) -allowoverlap manages overlap and inclusion detection in rectangular selection.\n"
14128 " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined rectangle will be detected,\n"
14129 " otherwise algorithm will chose only fully included sensitives. Default behavior is to detect only full inclusion. "
2157d6ac 14130 " (partial inclusion - overlap - is not allowed by default)\n"
14131 "- 5) any of these selections with shift button pressed",
4754e164 14132 __FILE__, VSelect, group);
14133 theCommands.Add ("vmoveto",
8a590580 14134 "vmoveto [x y] [-reset]"
14135 "\n\t\t: Emulates cursor movement to pixel position (x,y)."
14136 "\n\t\t: -reset resets current highlighting",
4754e164 14137 __FILE__, VMoveTo, group);
1beb58d7 14138 theCommands.Add ("vviewparams",
14139 "vviewparams [-args] [-scale [s]]"
14140 "\n\t\t: [-eye [x y z]] [-at [x y z]] [-up [x y z]]"
14141 "\n\t\t: [-proj [x y z]] [-center x y] [-size sx]"
14142 "\n\t\t: Manage current view parameters or prints all"
14143 "\n\t\t: current values when called without argument."
14144 "\n\t\t: -scale [s] prints or sets viewport relative scale"
14145 "\n\t\t: -eye [x y z] prints or sets eye location"
14146 "\n\t\t: -at [x y z] prints or sets center of look"
14147 "\n\t\t: -up [x y z] prints or sets direction of up vector"
14148 "\n\t\t: -proj [x y z] prints or sets direction of look"
14149 "\n\t\t: -center x y sets location of center of the screen in pixels"
14150 "\n\t\t: -size [sx] prints viewport projection width and height sizes"
14151 "\n\t\t: or changes the size of its maximum dimension"
14152 "\n\t\t: -args prints vviewparams arguments for restoring current view",
197ac94e 14153 __FILE__, VViewParams, group);
1beb58d7 14154
2e93433e 14155 theCommands.Add("v2dmode",
14156 "v2dmode [-name viewName] [-mode {-on|-off}=-on]"
14157 "\n\t\t: name - name of existing view, if not defined, the active view is changed"
14158 "\n\t\t: mode - switches On/Off rotation mode"
14159 "\n\t\t: Set 2D mode of the active viewer manipulating. The following mouse and key actions are disabled:"
14160 "\n\t\t: - rotation of the view by 3rd mouse button with Ctrl active"
14161 "\n\t\t: - set view projection using key buttons: A/D/T/B/L/R for AXO, Reset, Top, Bottom, Left, Right"
14162 "\n\t\t: View camera position might be changed only by commands.",
14163 __FILE__, V2DMode, group);
14164
1beb58d7 14165 theCommands.Add("vanimation", "Alias for vanim",
14166 __FILE__, VAnimation, group);
14167
14168 theCommands.Add("vanim",
14169 "List existing animations:"
14170 "\n\t\t: vanim"
14171 "\n\t\t: Animation playback:"
14172 "\n\t\t: vanim name -play|-resume [playFrom [playDuration]]"
14173 "\n\t\t: [-speed Coeff] [-freeLook] [-lockLoop]"
14174 "\n\t\t: -speed playback speed (1.0 is normal speed)"
14175 "\n\t\t: -freeLook skip camera animations"
14176 "\n\t\t: -lockLoop disable any interactions"
14177 "\n\t\t:"
14178 "\n\t\t: Animation definition:"
14179 "\n\t\t: vanim Name/sub/name [-clear] [-delete]"
14180 "\n\t\t: [start TimeSec] [duration TimeSec]"
14181 "\n\t\t:"
14182 "\n\t\t: Animation name defined in path-style (anim/name or anim.name)"
14183 "\n\t\t: specifies nested animations."
14184 "\n\t\t: There is no syntax to explicitly add new animation,"
14185 "\n\t\t: and all non-existing animations within the name will be"
14186 "\n\t\t: implicitly created on first use (including parents)."
14187 "\n\t\t:"
14188 "\n\t\t: Each animation might define the SINGLE action (see below),"
14189 "\n\t\t: like camera transition, object transformation or custom callback."
14190 "\n\t\t: Child animations can be used for defining concurrent actions."
14191 "\n\t\t:"
14192 "\n\t\t: Camera animation:"
14193 "\n\t\t: vanim name -view [-eye1 X Y Z] [-eye2 X Y Z]"
14194 "\n\t\t: [-at1 X Y Z] [-at2 X Y Z]"
14195 "\n\t\t: [-up1 X Y Z] [-up2 X Y Z]"
14196 "\n\t\t: [-scale1 Scale] [-scale2 Scale]"
14197 "\n\t\t: -eyeX camera Eye positions pair (start and end)"
14198 "\n\t\t: -atX camera Center positions pair"
14199 "\n\t\t: -upX camera Up directions pair"
14200 "\n\t\t: -scaleX camera Scale factors pair"
14201 "\n\t\t: Object animation:"
14202 "\n\t\t: vanim name -object [-loc1 X Y Z] [-loc2 X Y Z]"
14203 "\n\t\t: [-rot1 QX QY QZ QW] [-rot2 QX QY QZ QW]"
14204 "\n\t\t: [-scale1 Scale] [-scale2 Scale]"
14205 "\n\t\t: -locX object Location points pair (translation)"
14206 "\n\t\t: -rotX object Orientations pair (quaternions)"
14207 "\n\t\t: -scaleX object Scale factors pair (quaternions)"
14208 "\n\t\t: Custom callback:"
14209 "\n\t\t: vanim name -invoke \"Command Arg1 Arg2 %Pts %LocalPts %Normalized ArgN\""
14210 "\n\t\t: %Pts overall animation presentation timestamp"
14211 "\n\t\t: %LocalPts local animation timestamp"
14212 "\n\t\t: %Normalized local animation normalized value in range 0..1"
08f8a185 14213 "\n\t\t:"
14214 "\n\t\t: Video recording:"
14215 "\n\t\t: vanim name -record FileName [Width Height] [-fps FrameRate=24]"
14216 "\n\t\t: [-format Format] [-vcodec Codec] [-pix_fmt PixelFormat]"
14217 "\n\t\t: [-crf Value] [-preset Preset]"
14218 "\n\t\t: -fps video framerate"
14219 "\n\t\t: -format file format, container (matroska, etc.)"
14220 "\n\t\t: -vcodec video codec identifier (ffv1, mjpeg, etc.)"
14221 "\n\t\t: -pix_fmt image pixel format (yuv420p, rgb24, etc.)"
14222 "\n\t\t: -crf constant rate factor (specific to codec)"
14223 "\n\t\t: -preset codec parameters preset (specific to codec)"
1beb58d7 14224 __FILE__, VAnimation, group);
14225
4754e164 14226 theCommands.Add("vchangeselected",
dc3fe572 14227 "vchangeselected shape"
4754e164 14228 "- adds to shape to selection or remove one from it",
14229 __FILE__, VChangeSelected, group);
4754e164 14230 theCommands.Add ("vnbselected",
faea8b40 14231 "vnbselected"
14232 "\n\t\t: Returns number of selected objects", __FILE__, VNbSelected, group);
6b62b2da 14233 theCommands.Add ("vcamera",
30a1b24e 14234 "vcamera [PrsName] [-ortho] [-projtype]"
6b62b2da 14235 "\n\t\t: [-persp]"
14236 "\n\t\t: [-fovy [Angle]] [-distance [Distance]]"
14237 "\n\t\t: [-stereo] [-leftEye] [-rightEye]"
14238 "\n\t\t: [-iod [Distance]] [-iodType [absolute|relative]]"
14239 "\n\t\t: [-zfocus [Value]] [-zfocusType [absolute|relative]]"
30a1b24e 14240 "\n\t\t: Manages camera parameters."
14241 "\n\t\t: Displays frustum when presntation name PrsName is specified."
6b62b2da 14242 "\n\t\t: Prints current value when option called without argument."
14243 "\n\t\t: Orthographic camera:"
14244 "\n\t\t: -ortho activate orthographic projection"
14245 "\n\t\t: Perspective camera:"
14246 "\n\t\t: -persp activate perspective projection (mono)"
14247 "\n\t\t: -fovy field of view in y axis, in degrees"
14248 "\n\t\t: -distance distance of eye from camera center"
14249 "\n\t\t: Stereoscopic camera:"
14250 "\n\t\t: -stereo perspective projection (stereo)"
14251 "\n\t\t: -leftEye perspective projection (left eye)"
14252 "\n\t\t: -rightEye perspective projection (right eye)"
14253 "\n\t\t: -iod intraocular distance value"
14254 "\n\t\t: -iodType distance type, absolute or relative"
14255 "\n\t\t: -zfocus stereographic focus value"
14256 "\n\t\t: -zfocusType focus type, absolute or relative",
14257 __FILE__, VCamera, group);
b5ac8292 14258 theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
197ac94e 14259 "- vautozfit [on={1|0}] [scale]\n"
14260 " Prints or changes parameters of automatic z-fit mode:\n"
14261 " \"on\" - turns automatic z-fit on or off\n"
14262 " \"scale\" - specifies factor to scale computed z range.\n",
14263 __FILE__, VAutoZFit, group);
b5ac8292 14264 theCommands.Add ("vzrange", "command to manually access znear and zfar values\n"
14265 " vzrange - without parameters shows current values\n"
14266 " vzrange [znear] [zfar] - applies provided values to view",
14267 __FILE__,VZRange, group);
4754e164 14268 theCommands.Add ("vpurgedisplay",
eb4320f2 14269 "vpurgedisplay"
4754e164 14270 "- removes structures which don't belong to objects displayed in neutral point",
14271 __FILE__, VPurgeDisplay, group);
14272 theCommands.Add("vsetviewsize",
14273 "vsetviewsize size",
14274 __FILE__,VSetViewSize,group);
14275 theCommands.Add("vmoveview",
14276 "vmoveview Dx Dy Dz [Start = 1|0]",
14277 __FILE__,VMoveView,group);
14278 theCommands.Add("vtranslateview",
14279 "vtranslateview Dx Dy Dz [Start = 1|0)]",
14280 __FILE__,VTranslateView,group);
14281 theCommands.Add("vturnview",
14282 "vturnview Ax Ay Az [Start = 1|0]",
14283 __FILE__,VTurnView,group);
269294d6 14284 theCommands.Add("vtextureenv",
14285 "Enables or disables environment mapping in the 3D view, loading the texture from the given standard "
14286 "or user-defined file and optionally applying texture mapping parameters\n"
14287 " Usage:\n"
14288 " vtextureenv off - disables environment mapping\n"
14289 " vtextureenv on {std_texture|texture_file_name} [rep mod flt ss st ts tt rot] - enables environment mapping\n"
14290 " std_texture = (0..7)\n"
14291 " rep = {clamp|repeat}\n"
14292 " mod = {decal|modulate}\n"
14293 " flt = {nearest|bilinear|trilinear}\n"
14294 " ss, st - scale factors for s and t texture coordinates\n"
14295 " ts, tt - translation for s and t texture coordinates\n"
14296 " rot - texture rotation angle in degrees",
14297 __FILE__, VTextureEnv, group);
1eeef710 14298 theCommands.Add("vhlr",
14299 "vhlr {on|off} [-showHidden={1|0}] [-algoType={algo|polyAlgo}] [-noupdate]"
14300 "\n\t\t: Hidden Line Removal algorithm."
14301 "\n\t\t: -showHidden if set ON, hidden lines are drawn as dotted ones"
14302 "\n\t\t: -algoType type of HLR algorithm.\n",
0a768f56 14303 __FILE__,VHLR,group);
1eeef710 14304 theCommands.Add("vhlrtype",
14305 "vhlrtype {algo|polyAlgo} [shape_1 ... shape_n] [-noupdate]"
14306 "\n\t\t: Changes the type of HLR algorithm using for shapes:"
14307 "\n\t\t: 'algo' - exact HLR algorithm is applied"
14308 "\n\t\t: 'polyAlgo' - polygonal HLR algorithm is applied"
14309 "\n\t\t: If shapes are not given - option is applied to all shapes in the view",
0a768f56 14310 __FILE__,VHLRType,group);
3e05329c 14311 theCommands.Add("vclipplane",
14312 "vclipplane planeName [{0|1}]"
25c35042 14313 "\n\t\t: [-equation1 A B C D]"
14314 "\n\t\t: [-equation2 A B C D]"
14315 "\n\t\t: [-boxInterior MinX MinY MinZ MaxX MaxY MaxZ]"
32ca7711 14316 "\n\t\t: [-set|-unset|-setOverrideGlobal [objects|views]]"
3e05329c 14317 "\n\t\t: [-maxPlanes]"
14318 "\n\t\t: [-capping {0|1}]"
1b661a81 14319 "\n\t\t: [-color R G B] [-transparency Value] [-hatch {on|off|ID}]"
3e05329c 14320 "\n\t\t: [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]"
14321 "\n\t\t: [-texRotate Angle]"
14322 "\n\t\t: [-useObjMaterial {0|1}] [-useObjTexture {0|1}]"
14323 "\n\t\t: [-useObjShader {0|1}]"
14324 "\n\t\t: Clipping planes management:"
14325 "\n\t\t: -maxPlanes print plane limit for view"
14326 "\n\t\t: -delete delete plane with given name"
14327 "\n\t\t: {off|on|0|1} turn clipping on/off"
14328 "\n\t\t: -set|-unset set/unset plane for Object or View list;"
14329 "\n\t\t: applied to active View when list is omitted"
14330 "\n\t\t: -equation A B C D change plane equation"
14331 "\n\t\t: -clone SourcePlane NewPlane clone the plane definition."
14332 "\n\t\t: Capping options:"
14333 "\n\t\t: -capping {off|on|0|1} turn capping on/off"
14334 "\n\t\t: -color R G B set capping color"
1b661a81 14335 "\n\t\t: -transparency Value set capping transparency 0..1"
3e05329c 14336 "\n\t\t: -texName Texture set capping texture"
14337 "\n\t\t: -texScale SX SY set capping tex scale"
14338 "\n\t\t: -texOrigin TX TY set capping tex origin"
14339 "\n\t\t: -texRotate Angle set capping tex rotation"
14340 "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
14341 "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
14342 "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
14343 "\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
14344 __FILE__, VClipPlane, group);
392ac980 14345 theCommands.Add("vdefaults",
4c513386 14346 "vdefaults [-absDefl value]"
14347 "\n\t\t: [-devCoeff value]"
14348 "\n\t\t: [-angDefl value]"
14349 "\n\t\t: [-autoTriang {off/on | 0/1}]"
14350 , __FILE__, VDefaults, group);
12381341 14351 theCommands.Add("vlight",
816d03ee 14352 "tool to manage light sources, without arguments shows list of lights."
14353 "\n Main commands: "
992ed6b3 14354 "\n '-clear' to clear lights"
14355 "\n '-{def}aults' to load deafault lights"
14356 "\n '-add' <type> to add any light source"
816d03ee 14357 "\n where <type> is one of {amb}ient|directional|{spot}light|positional"
14358 "\n 'change' <lightId> to edit light source with specified lightId"
14359 "\n\n In addition to 'add' and 'change' commands you can use light parameters:"
992ed6b3 14360 "\n -layer Id"
14361 "\n -{pos}ition X Y Z"
14362 "\n -{dir}ection X Y Z (for directional light or for spotlight)"
14363 "\n -color colorName"
14364 "\n -{head}light 0|1"
14365 "\n -{sm}oothness value"
14366 "\n -{int}ensity value"
14367 "\n -{constAtten}uation value"
14368 "\n -{linearAtten}uation value"
14369 "\n -angle angleDeg"
14370 "\n -{spotexp}onent value"
14371 "\n -local|-global"
14372 "\n\n example: vlight -add positional -head 1 -pos 0 1 1 -color red"
14373 "\n example: vlight -change 0 -direction 0 -1 0 -linearAttenuation 0.2",
12381341 14374 __FILE__, VLight, group);
67312b79 14375 theCommands.Add("vpbrenv",
14376 "vpbrenv -clear|-generate"
14377 "\n\t\t: Clears or generates PBR environment map of active view."
14378 "\n\t\t: -clear clears PBR environment (fills by white color)"
14379 "\n\t\t: -generate generates PBR environment from current background cubemap",
14380 __FILE__, VPBREnvironment, group);
6b62b2da 14381 theCommands.Add("vraytrace",
14382 "vraytrace [0|1]"
189f85a3 14383 "\n\t\t: Turns on/off ray-tracing renderer."
6b62b2da 14384 "\n\t\t: 'vraytrace 0' alias for 'vrenderparams -raster'."
14385 "\n\t\t: 'vraytrace 1' alias for 'vrenderparams -rayTrace'.",
14386 __FILE__, VRenderParams, group);
bc8c79bb 14387 theCommands.Add("vrenderparams",
14388 "\n Manages rendering parameters: "
a1073ae2 14389 "\n '-raster' Disables GPU ray-tracing"
14390 "\n '-msaa 0..4' Specifies number of samples for MSAA"
2a332745 14391 "\n '-lineFeather > 0' Sets line feather factor"
a1073ae2 14392 "\n '-oit off|0.0-1.0' Enables/disables OIT and sets depth weight factor"
f88457e6 14393 "\n '-depthPrePass on|off' Enables/disables depth pre-pass"
c40eb6b9 14394 "\n '-alphatocoverage on|off' Enables/disables alpha to coverage (needs MSAA)"
a1073ae2 14395 "\n '-rendScale value Rendering resolution scale factor"
14396 "\n '-rayTrace' Enables GPU ray-tracing"
14397 "\n '-rayDepth 0..10' Defines maximum ray-tracing depth"
14398 "\n '-shadows on|off' Enables/disables shadows rendering"
14399 "\n '-reflections on|off' Enables/disables specular reflections"
14400 "\n '-fsaa on|off' Enables/disables adaptive anti-aliasing"
14401 "\n '-gleam on|off' Enables/disables transparency shadow effects"
14402 "\n '-gi on|off' Enables/disables global illumination effects"
14403 "\n '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
14404 "\n '-env on|off' Enables/disables environment map background"
14405 "\n '-twoside on|off' Enables/disables two-sided BSDF models (PT mode)"
14406 "\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
14407 "\n '-issd on|off' Shows screen sampling distribution in ISS mode"
14408 "\n '-maxrad > 0.0' Value used for clamping radiance estimation (PT mode)"
66d1cdc6 14409 "\n '-tileSize 1..4096' Specifies size of screen tiles in ISS mode (32 by default)"
14410 "\n '-nbtiles 64..1024' Specifies number of screen tiles per Redraw in ISS mode (256 by default)"
a1073ae2 14411 "\n '-rebuildGlsl on|off' Rebuild Ray-Tracing GLSL programs (for debugging)"
14412 "\n '-shadingModel model' Controls shading model from enumeration"
59ee34ef 14413 "\n unlit, flat, gouraud, phong"
67312b79 14414 "\n '-pbrEnvPow2size > 0' Controls size of IBL maps (real size can be calculates as 2^pbrenvpow2size)"
14415 "\n '-pbrEnvSMLN > 1' Controls number of mipmap levels used in specular IBL map"
14416 "\n '-pbrEnvBDSN > 0' Controls number of samples in Monte-Carlo integration during diffuse IBL map's sherical harmonics calculation"
14417 "\n '-pbrEnvBSSN > 0' Controls maximum number of samples per mipmap level in Monte-Carlo integration during specular IBL maps generation"
14418 "\n '-pbrEnvBP [0, 1]' Controls strength of samples number reducing during specular IBL maps generation (1 disables reducing)"
a1073ae2 14419 "\n '-resolution value' Sets a new pixels density (PPI), defines scaling factor for parameters like text size"
b27ab03d 14420 "\n '-aperture >= 0.0' Aperture size of perspective camera for depth-of-field effect (0 disables DOF)"
14421 "\n '-focal >= 0.0' Focal distance of perspective camera for depth-of-field effect"
eb85ed36 14422 "\n '-exposure value' Exposure value for tone mapping (0.0 value disables the effect)"
14423 "\n '-whitepoint value' White point value for filmic tone mapping"
14424 "\n '-tonemapping mode' Tone mapping mode (disabled, filmic)"
5e30547b 14425 "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triagles|points"
14426 "\n ' |gpuMem|frameTime|basic|extended|full|nofps|skipImmediate'"
15669413 14427 "\n Show/hide performance counters (flags can be combined)"
14428 "\n '-perfUpdateInterval nbSeconds' Performance counters update interval"
5e30547b 14429 "\n '-perfChart nbFrames' Show frame timers chart limited by specified number of frames"
14430 "\n '-perfChartMax seconds' Maximum time in seconds with the chart"
0e3025bc 14431 "\n '-frustumCulling on|off|noupdate' Enable/disable objects frustum clipping or"
14432 "\n set state to check structures culled previously."
8625ef7e 14433 "\n Unlike vcaps, these parameters dramatically change visual properties."
14434 "\n Command is intended to control presentation quality depending on"
14435 "\n hardware capabilities and performance.",
bc8c79bb 14436 __FILE__, VRenderParams, group);
79b544e6 14437 theCommands.Add("vstatprofiler",
14438 "\n vstatprofiler [fps|cpu|allLayers|layers|allstructures|structures|groups"
14439 "\n |allArrays|fillArrays|lineArrays|pointArrays|textArrays"
14440 "\n |triagles|points|geomMem|textureMem|frameMem"
14441 "\n |elapsedFrame|cpuFrameAverage|cpuPickingAverage|cpuCullingAverage|cpuDynAverage"
14442 "\n |cpuFrameMax|cpuPickingMax|cpuCullingMax|cpuDynMax]"
14443 "\n [-noredraw]"
14444 "\n\t\t: Prints rendering statistics."
14445 "\n\t\t: If there are some parameters - print corresponding statistic counters values,"
14446 "\n\t\t: else - print all performance counters set previously."
14447 "\n\t\t: '-noredraw' Flag to avoid additional redraw call and use already collected values.\n",
14448 __FILE__, VStatProfiler, group);
49e1a5c7 14449 theCommands.Add ("vplace",
14450 "vplace dx dy"
14451 "\n\t\t: Places the point (in pixels) at the center of the window",
14452 __FILE__, VPlace, group);
0717ddc1 14453 theCommands.Add("vxrotate",
14454 "vxrotate",
14455 __FILE__,VXRotate,group);
14456
625e1958 14457 theCommands.Add("vmanipulator",
14458 "\n vmanipulator Name [-attach AISObject | -detach | ...]"
14459 "\n tool to create and manage AIS manipulators."
14460 "\n Options: "
14461 "\n '-attach AISObject' attach manipulator to AISObject"
14462 "\n '-adjustPosition {0|1}' adjust position when attaching"
14463 "\n '-adjustSize {0|1}' adjust size when attaching"
14464 "\n '-enableModes {0|1}' enable modes when attaching"
bbf3fcde 14465 "\n '-view {active | [name of view]}' display manipulator only in defined view,"
14466 "\n by default it is displayed in all views of the current viewer"
625e1958 14467 "\n '-detach' detach manipulator"
14468 "\n '-startTransform mouse_x mouse_y' - invoke start of transformation"
14469 "\n '-transform mouse_x mouse_y' - invoke transformation"
14470 "\n '-stopTransform [abort]' - invoke stop of transformation"
14471 "\n '-move x y z' - move attached object"
14472 "\n '-rotate x y z dx dy dz angle' - rotate attached object"
14473 "\n '-scale factor' - scale attached object"
14474 "\n '-autoActivate {0|1}' - set activation on detection"
14475 "\n '-followTranslation {0|1}' - set following translation transform"
14476 "\n '-followRotation {0|1}' - set following rotation transform"
f522ce50 14477 "\n '-followDragging {0|1}' - set following dragging transform"
625e1958 14478 "\n '-gap value' - set gap between sub-parts"
14479 "\n '-part axis mode {0|1}' - set visual part"
84b904bc 14480 "\n '-parts axis mode {0|1}' - set visual part"
625e1958 14481 "\n '-pos x y z [nx ny nz [xx xy xz]' - set position of manipulator"
14482 "\n '-size value' - set size of manipulator"
14483 "\n '-zoomable {0|1}' - set zoom persistence",
14484 __FILE__, VManipulator, group);
14485
8e5fb5ea 14486 theCommands.Add("vselprops",
f838dac4 14487 "\n vselprops [dynHighlight|localDynHighlight|selHighlight|localSelHighlight] [options]"
8e5fb5ea 14488 "\n Customizes selection and dynamic highlight parameters for the whole interactive context:"
14489 "\n -autoActivate {0|1} : disables|enables default computation and activation of global selection mode"
be3d8cbc 14490 "\n -autoHighlight {0|1} : disables|enables automatic highlighting in 3D Viewer"
14491 "\n -highlightSelected {0|1}: disables|enables highlighting of detected object in selected state"
14c4193d 14492 "\n -pickStrategy {first|topmost} : defines picking strategy"
14493 "\n 'first' to pick first acceptable (default)"
14494 "\n 'topmost' to pick only topmost (and nothing, if topmost is rejected by filters)"
8e5fb5ea 14495 "\n -pixTol value : sets up pixel tolerance"
f838dac4 14496 "\n -dispMode dispMode : sets display mode for highlighting"
14497 "\n -layer ZLayer : sets ZLayer for highlighting"
14498 "\n -color {name|r g b} : sets highlight color"
14499 "\n -transp value : sets transparency coefficient for highlight"
14500 "\n -material material : sets highlight material"
8e5fb5ea 14501 "\n -print : prints current state of all mentioned parameters",
14502 __FILE__, VSelectionProperties, group);
be3d8cbc 14503 theCommands.Add ("vhighlightselected",
14504 "vhighlightselected [0|1]: alias for vselprops -highlightSelected.\n",
14505 __FILE__, VSelectionProperties, group);
8e5fb5ea 14506
decdee7d 14507 theCommands.Add ("vseldump",
14508 "vseldump file -type {depth|unnormDepth|object|owner|selMode|entity}=depth -pickedIndex Index=1"
14509 "\n\t\t: Generate an image based on detection results:"
14510 "\n\t\t: depth normalized depth values"
14511 "\n\t\t: unnormDepth unnormalized depth values"
14512 "\n\t\t: object color of detected object"
14513 "\n\t\t: owner color of detected owner"
14514 "\n\t\t: selMode color of selection mode"
14515 "\n\t\t: entity color of etected entity",
14516 __FILE__, VDumpSelectionImage, group);
293211ae 14517
2108d9a2 14518 theCommands.Add ("vviewcube",
14519 "vviewcube name"
14520 "\n\t\t: Displays interactive view manipualtion object."
14521 "\n\t\t: Options: "
14522 "\n\t\t: -reset reset geomertical and visual attributes'"
14523 "\n\t\t: -size Size adapted size of View Cube"
14524 "\n\t\t: -boxSize Size box size"
14525 "\n\t\t: -axes {0|1 } show/hide axes (trihedron)"
14526 "\n\t\t: -edges {0|1} show/hide edges of View Cube"
14527 "\n\t\t: -vertices {0|1} show/hide vertices of View Cube"
14528 "\n\t\t: -Yup {0|1} -Zup {0|1} set Y-up or Z-up view orientation"
14529 "\n\t\t: -color Color color of View Cube"
14530 "\n\t\t: -boxColor Color box color"
14531 "\n\t\t: -boxSideColor Color box sides color"
14532 "\n\t\t: -boxEdgeColor Color box edges color"
14533 "\n\t\t: -boxCornerColor Color box corner color"
14534 "\n\t\t: -textColor Color color of side text of view cube"
14535 "\n\t\t: -innerColor Color inner box color"
14536 "\n\t\t: -transparency Value transparency of object within [0, 1] range"
14537 "\n\t\t: -boxTransparency Value transparency of box within [0, 1] range"
14538 "\n\t\t: -font Name font name"
14539 "\n\t\t: -fontHeight Value font height"
14540 "\n\t\t: -boxFacetExtension Value box facet extension"
14541 "\n\t\t: -boxEdgeGap Value gap between box edges and box sides"
14542 "\n\t\t: -boxEdgeMinSize Value minimal box edge size"
14543 "\n\t\t: -boxCornerMinSize Value minimal box corner size"
14544 "\n\t\t: -axesPadding Value padding between box and arrows"
14545 "\n\t\t: -roundRadius Value relative radius of corners of sides within [0.0, 0.5] range"
14546 "\n\t\t: -fixedanimation {0|1} uninterruptible animation loop"
14547 "\n\t\t: -duration Seconds animation duration in seconds",
14548 __FILE__, VViewCube, group);
14549
14550}
Open CASCADE Technology repository