#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_MapOfAsciiString.hxx>
#include <ViewerTest_AutoUpdater.hxx>
+#include <ViewerTest_ContinuousRedrawer.hxx>
#include <ViewerTest_EventManager.hxx>
#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
//purpose :
//==============================================================================
-const Handle(Standard_Transient)& ViewerTest::WClass()
+const Handle(WNT_WClass)& ViewerTest::WClass()
{
- static Handle(Standard_Transient) theWClass;
+ static Handle(WNT_WClass) theWClass;
#if defined(_WIN32)
if (theWClass.IsNull())
{
return ViewerTest_myViews.Find2( ViewerTest::CurrentView());
}
-//! Auxiliary tool performing continuous redraws of specified window.
-class ViewerTest_ContinuousRedrawer
-{
-public:
- //! Return global instance.
- static ViewerTest_ContinuousRedrawer& Instance()
- {
- static ViewerTest_ContinuousRedrawer aRedrawer;
- return aRedrawer;
- }
-public:
-
- //! Destructor.
- ~ViewerTest_ContinuousRedrawer()
- {
- Stop();
- }
-
- //! Start thread.
- void Start (const Handle(Aspect_Window)& theWindow,
- Standard_Real theTargetFps)
- {
- if (myWindow != theWindow
- || myTargetFps != theTargetFps)
- {
- Stop();
- myWindow = theWindow;
- myTargetFps = theTargetFps;
- }
- if (myThread.GetId() == 0)
- {
- myToStop = false;
- myThread.Run (this);
- }
- }
-
- //! Stop thread.
- void Stop (const Handle(Aspect_Window)& theWindow = NULL)
- {
- if (!theWindow.IsNull()
- && myWindow != theWindow)
- {
- return;
- }
-
- {
- Standard_Mutex::Sentry aLock (myMutex);
- myToStop = true;
- }
- myThread.Wait();
- myToStop = false;
- myWindow.Nullify();
- }
-
-private:
-
- //! Thread loop.
- void doThreadLoop()
- {
- Handle(Aspect_DisplayConnection) aDisp = new Aspect_DisplayConnection();
- OSD_Timer aTimer;
- aTimer.Start();
- Standard_Real aTimeOld = 0.0;
- const Standard_Real aTargetDur = myTargetFps > 0.0 ? 1.0 / myTargetFps : -1.0;
- for (;;)
- {
- {
- Standard_Mutex::Sentry aLock (myMutex);
- if (myToStop)
- {
- return;
- }
- }
- if (myTargetFps > 0.0)
- {
- const Standard_Real aTimeNew = aTimer.ElapsedTime();
- const Standard_Real aDuration = aTimeNew - aTimeOld;
- if (aDuration >= aTargetDur)
- {
- myWindow->InvalidateContent (aDisp);
- aTimeOld = aTimeNew;
- }
- }
- else
- {
- myWindow->InvalidateContent (aDisp);
- }
-
- OSD::MilliSecSleep (1);
- }
- }
-
- //! Thread creation callback.
- static Standard_Address doThreadWrapper (Standard_Address theData)
- {
- ViewerTest_ContinuousRedrawer* aThis = (ViewerTest_ContinuousRedrawer* )theData;
- aThis->doThreadLoop();
- return 0;
- }
-
- //! Empty constructor.
- ViewerTest_ContinuousRedrawer()
- : myThread (doThreadWrapper),
- myTargetFps (0.0),
- myToStop (false) {}
-
-private:
- Handle(Aspect_Window) myWindow;
- OSD_Thread myThread;
- Standard_Mutex myMutex;
- Standard_Real myTargetFps;
- volatile bool myToStop;
-};
-
//==============================================================================
//function : ViewerInit
//purpose : Create the window viewer and initialize all the global variable
// Create window
#if defined(_WIN32)
- VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
- Handle(WNT_WClass)::DownCast (WClass()),
+ VT_GetWindow() = new WNT_Window (aTitle.ToCString(), WClass(),
Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
aPxLeft, aPxTop,
aPxWidth, aPxHeight,
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
if (!aDisplayName.IsEmpty())
{
aDisplayName.Clear();
- std::cout << "Warning: display parameter will be ignored.\n";
+ Message::SendWarning() << "Warning: display parameter will be ignored.\n";
}
#endif
const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
if (aView.IsNull())
{
- std::cerr << "Error: No opened viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << argv[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << argv[anArgIter] << "'";
return 1;
}
}
const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
if (aView.IsNull())
{
- std::cerr << "Error: No opened viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
TCollection_AsciiString aName (argv[anArgIter]);
if (!aMap.IsBound2 (aName))
{
- std::cout << "Syntax error: Wrong shape name '" << aName << "'.\n";
+ Message::SendFail() << "Syntax error: Wrong shape name '" << aName << "'";
return 1;
}
Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (aMap.Find2 (aName));
if (aShape.IsNull())
{
- std::cout << "Syntax error: '" << aName << "' is not a shape presentation.\n";
+ Message::SendFail() << "Syntax error: '" << aName << "' is not a shape presentation";
return 1;
}
aListOfShapes.Append (aShape);
}
if (aTypeOfHLR == Prs3d_TOH_NotSet)
{
- std::cout << "Syntax error: wrong number of arguments!\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
{
if (!ViewerTest_myViews.IsBound1(theViewName))
{
- std::cout << "Wrong view name\n";
+ Message::SendFail() << "Wrong view name";
return;
}
ViewerTest_myContexts.UnBind2(aCurrentContext);
}
}
- std::cout << "3D View - " << theViewName << " was deleted.\n";
+ Message::SendInfo() << "3D View - " << theViewName << " was deleted.\n";
if (ViewerTest_EventManager::ToExitOnCloseView())
{
Draw_Interprete ("exit");
ViewerTest_Names aViewName (theArgVec[1]);
if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
{
- std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
+ Message::SendFail() << "Error: the view with name '" << theArgVec[1] << "' does not exist";
return 1;
}
aViewList.Append (aViewName.GetViewName());
// close active view
if (ViewerTest::CurrentView().IsNull())
{
- std::cerr << "No active view!\n";
+ Message::SendFail ("Error: no active view");
return 1;
}
aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
}
else if (aNameString.IsEmpty())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
gp_Dir aRight, anUp;
if (aFrameDef.Value (2) == aFrameDef.Value (4))
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (!isGeneralCmd
&& theNbArgs != 1)
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
return 0;
di << "B : BottomView\n";
di << "R : RightView\n";
di << "L : LeftView\n";
- di << "A : AxonometricView\n";
- di << "D : ResetView\n";
+ di << "Backspace : AxonometricView\n";
+
+ di << "=========================\n";
+ di << "W, S : Fly forward/backward\n";
+ di << "A, D : Slide left/right\n";
+ di << "Q, E : Bank left/right\n";
+ di << "-, + : Change flying speed\n";
+ di << "Arrows : look left/right/up/down\n";
+ di << "Arrows+Shift : slide left/right/up/down\n";
di << "=========================\n";
- di << "S : Shading\n";
- di << "W : Wireframe\n";
+ di << "S + Ctrl : Shading\n";
+ di << "W + Ctrl : Wireframe\n";
di << "H : HiddenLineRemoval\n";
di << "U : Unset display mode\n";
di << "Delete : Remove selection from viewer\n";
}
if (aDispConn.IsNull())
{
- std::cerr << "Error: ViewerTest is unable processing messages for unknown X Display\n";
+ Message::SendFail ("Error: ViewerTest is unable processing messages for unknown X Display");
return;
}
const Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << theArgVec[0] << "Error: No active view.\n";
+ Message::SendFail ("Error: No active viewer");
return 1;
}
}
else
{
- std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
+ Message::SendFail ("Syntax error: Invalid number of arguments");
theDI.PrintHelp(theArgVec[0]);
return 1;
}
if (aDiagonal < Precision::Confusion())
{
- std::cerr << theArgVec[0] << "Error: view area is too small.\n";
+ Message::SendFail ("Error: view area is too small");
return 1;
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
if (theNbArgs < 4)
{
- std::cout << "Syntax error: Invalid number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'";
}
}
else if (aFlag == "-scale")
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
aLabelsColor);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorX);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorY);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
anArrowColorZ);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
}
else
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "No active view!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
hasFlags = Standard_True;
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
hasFlags = Standard_True;
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
else if (theArgNb != 4
&& theArgNb != 7)
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
}
return 0;
}
- std::cout << "Error: Invalid number of arguments\n";
+ Message::SendFail ("Error: Invalid number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << theArgs[0] << "Error: no active view." << std::endl;
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgNb != 3)
{
- std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aContext.IsNull())
{
- std::cout << "Error: no active view!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgNb <= 1)
{
- std::cout << "Error: wrong syntax at command '" << theArgVec[0] << "'!\n";
+ Message::SendFail() << "Error: wrong syntax at command '" << theArgVec[0] << "'";
return 1;
}
aColorScale = Handle(AIS_ColorScale)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
if (aColorScale.IsNull())
{
- std::cout << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale!\n";
+ Message::SendFail() << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale";
return 1;
}
}
{
if (aColorScale.IsNull())
{
- std::cout << "Syntax error: colorscale with a given name does not exist.\n";
+ Message::SendFail() << "Syntax error: colorscale with a given name does not exist";
return 1;
}
{
if (anArgIter + 3 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Error: wrong syntax at argument '" << anArg << "'";
return 1;
}
if (!aRangeMin.IsRealValue()
|| !aRangeMax.IsRealValue())
{
- std::cout << "Error: the range values should be real!\n";
+ Message::SendFail ("Syntax error: the range values should be real");
return 1;
}
else if (!aNbIntervals.IsIntegerValue())
{
- std::cout << "Error: the number of intervals should be integer!\n";
+ Message::SendFail ("Syntax error: the number of intervals should be integer");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
TCollection_AsciiString aFontArg(theArgVec[anArgIter + 1]);
if (!aFontArg.IsIntegerValue())
{
- std::cout << "Error: HeightFont value should be integer!\n";
+ Message::SendFail ("Syntax error: HeightFont value should be integer");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: unknown position '" << aTextPosArg << "'!\n";
+ Message::SendFail() << "Syntax error: unknown position '" << aTextPosArg << "'";
return 1;
}
aColorScale->SetLabelPosition (aLabPosition);
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Synta error at argument '" << anArg << "'";
return 1;
}
Standard_Boolean IsLog;
if (!ViewerTest::ParseOnOff(theArgVec[++anArgIter], IsLog))
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aColorScale->SetLogarithmic (IsLog);
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (aNbParsed1 == 0
|| aNbParsed2 == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (!anX.IsIntegerValue()
|| !anY.IsIntegerValue())
{
- std::cout << "Error: coordinates should be integer values!\n";
+ Message::SendFail ("Syntax error: coordinates should be integer values");
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aBreadth (theArgVec[++anArgIter]);
if (!aBreadth.IsIntegerValue())
{
- std::cout << "Error: a width should be an integer value!\n";
+ Message::SendFail ("Syntax error: a width should be an integer value");
return 1;
}
aColorScale->SetBreadth (aBreadth.IntegerValue());
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aHeight (theArgVec[++anArgIter]);
if (!aHeight.IsIntegerValue())
{
- std::cout << "Error: a width should be an integer value!\n";
+ Message::SendFail ("Syntax error: a width should be an integer value");
return 1;
}
aColorScale->SetHeight (aHeight.IntegerValue());
{
if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
{
- std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
+ Message::SendFail ("Syntax error: wrong color type. Call -colors before to set user-specified colors");
return 1;
}
else if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString anInd (theArgVec[++anArgIter]);
if (!anInd.IsIntegerValue())
{
- std::cout << "Error: Index value should be integer!\n";
+ Message::SendFail ("Syntax error: Index value should be integer");
return 1;
}
const Standard_Integer anIndex = anInd.IntegerValue();
if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals())
{
- std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() <<"!\n";
+ Message::SendFail() << "Syntax error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals();
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Error: wrong syntax at '" << anArg << "'";
return 1;
}
aColorScale->SetIntervalColor (aColor, anIndex);
{
if (aColorScale->GetColorType() != Aspect_TOCSD_USER)
{
- std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
+ Message::SendFail ("Syntax error: wrong label type. Call -labels before to set user-specified labels");
return 1;
}
else if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
if (anIndex <= 0 || anIndex > aColorScale->GetNumberOfIntervals() + 1)
{
- std::cout << "Error: Index value should be within range 1.." << aColorScale->GetNumberOfIntervals() + 1 <<"!\n";
+ Message::SendFail() << "Syntax error: Index value should be within range 1.." << (aColorScale->GetNumberOfIntervals() + 1);
return 1;
}
}
if (aLabAtBorder == -1)
{
- std::cout << "Syntax error at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
toEnable = (aLabAtBorder == 1);
}
if (aSeq.Length() != aColorScale->GetNumberOfIntervals())
{
- std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
- << aColorScale->GetNumberOfIntervals() << " intervals\n";
+ Message::SendFail() << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aColorScale->GetNumberOfIntervals() << " intervals";
return 1;
}
aColorScale->SetColors (aSeq);
aColorScale->SetColorType (Aspect_TOCSD_USER);
}
+ else if (aFlag == "-uniform")
+ {
+ const Standard_Real aLightness = Draw::Atof (theArgVec[++anArgIter]);
+ const Standard_Real aHueStart = Draw::Atof (theArgVec[++anArgIter]);
+ const Standard_Real aHueEnd = Draw::Atof (theArgVec[++anArgIter]);
+ aColorScale->SetUniformColors (aLightness, aHueStart, aHueEnd);
+ aColorScale->SetColorType (Aspect_TOCSD_USER);
+ }
else if (aFlag == "-labels"
|| aFlag == "-freelabels")
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Syntax error at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
if (anArgIter + aNbLabels >= theArgNb)
{
- std::cout << "Error: not enough arguments! " << aNbLabels << " text labels are expected.\n";
+ Message::SendFail() << "Syntax error: not enough arguments. " << aNbLabels << " text labels are expected";
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (anArgIter + 1 >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (!anArg1.IsRealValue())
{
- std::cout << "Error: the value should be real!\n";
+ Message::SendFail ("Syntax error: the value should be real");
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
+ Message::SendFail() << "Syntax error at " << anArg << " - unknown argument";
return 1;
}
}
{
if (theArgNum < 2)
{
- std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
- << theArgs[0] <<"' for more information.\n";
- return 1; //TCL_ERROR
+ Message::SendFail() << "Syntax error: wrong number of parameters. Type 'help"
+ << theArgs[0] <<"' for more information";
+ return 1;
}
NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
aLowerKey = "-";
aLowerKey += aKey;
aLowerKey.LowerCase();
- std::cout << theArgs[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
- std::cout << "Type help for more information.\n";
+ Message::SendFail() << "Syntax error: " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n"
+ << "Type help for more information";
return 1;
}
Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
if (anAISContext.IsNull())
{
- std::cout << theArgs[0] << ": please use 'vinit' command to initialize view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -xnamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -ynamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -znamecolor wrong color name");
return 1;
}
aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -xcolor wrong color name");
return 1;
}
aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -ycolor wrong color name");
return 1;
}
aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
{
if (!GetColor (aValues->Value(1), aColor))
{
- std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
+ Message::SendFail ("Syntax error: -zcolor wrong color name");
return 1;
}
aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
aTile.IsTopDown = (anArg == "-upperleft") == Standard_True;
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
aTile.TotalSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
if (aTile.TotalSize.x() < 1
|| aTile.TotalSize.y() < 1)
{
- std::cerr << "Error: total size is incorrect.\n";
+ Message::SendFail ("Error: total size is incorrect");
return 1;
}
}
{
if (anArgIter + 3 < theArgNb)
{
- std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
if (aTile.TileSize.x() < 1
|| aTile.TileSize.y() < 1)
{
- std::cerr << "Error: tile size is incorrect.\n";
+ Message::SendFail ("Error: tile size is incorrect");
return 1;
}
}
if (aTile.TileSize.x() < 1
|| aTile.TileSize.y() < 1)
{
- std::cerr << "Error: tile size is undefined.\n";
+ Message::SendFail ("Error: tile size is undefined");
return 1;
}
else if (aTile.TotalSize.x() < 1
|| aTile.TotalSize.y() < 1)
{
- std::cerr << "Error: total size is undefined.\n";
+ Message::SendFail ("Error: total size is undefined");
return 1;
}
Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
if (aContextAIS.IsNull())
{
- std::cout << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->AddZLayer (aLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->InsertLayerBefore (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
aLayerId = Graphic3d_ZLayerId_UNKNOWN;
if (!aViewer->InsertLayerAfter (aLayerId, Graphic3d_ZLayerSettings(), anOtherLayerId))
{
- std::cout << "Error: can not add a new z layer!\n";
+ Message::SendFail ("Error: can not add a new z layer");
return 0;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of z layer to remove is missing\n";
+ Message::SendFail ("Syntax error: id of z layer to remove is missing");
return 1;
}
|| aLayerId == Graphic3d_ZLayerId_TopOSD
|| aLayerId == Graphic3d_ZLayerId_BotOSD)
{
- std::cout << "Syntax error: standard Z layer can not be removed\n";
+ Message::SendFail ("Syntax error: standard Z layer can not be removed");
return 1;
}
if (!aViewer->RemoveZLayer (aLayerId))
{
- std::cout << "Z layer can not be removed!\n";
+ Message::SendFail ("Z layer can not be removed");
}
else
{
{
if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: name is missing\n";
+ Message::SendFail ("Syntax error: name is missing");
return 1;
}
{
if (aLayerId == Graphic3d_ZLayerId_UNKNOWN)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Syntax error: origin coordinates are missing\n";
+ Message::SendFail ("Syntax error: origin coordinates are missing");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
|| anArg == "enable";
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: option name is missing\n";
+ Message::SendFail ("Syntax error: option name is missing");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error: id of Z layer is missing\n";
+ Message::SendFail ("Syntax error: id of Z layer is missing");
return 1;
}
{
if (anArgIter + 2 >= theArgNb)
{
- std::cout << "Syntax error: factor and units values for depth offset are missing\n";
+ Message::SendFail ("Syntax error: factor and units values for depth offset are missing");
return 1;
}
}
else
{
- std::cout << "Syntax error: unknown option " << theArgVec[anArgIter] << "\n";
+ Message::SendFail() << "Syntax error: unknown option " << theArgVec[anArgIter];
return 1;
}
}
if (argc > 6
&& !ViewerTest::ParseLineType (argv[6], aLineType))
{
- std::cout << "Syntax error: unknown line type '" << argv[6] << "'\n";
+ Message::SendFail() << "Syntax error: unknown line type '" << argv[6] << "'";
return 1;
}
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
if (aView.IsNull() || aViewer.IsNull())
{
- std::cerr << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArgNext << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgNext << "'";
return 1;
}
}
}
else
{
- std::cout << "Syntax error at '" << anArgNext << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgNext << "'";
return 1;
}
}
if (aNewStepXY.x() <= 0.0
|| aNewStepXY.y() <= 0.0)
{
- std::cout << "Syntax error: wrong step '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
+ Message::SendFail() << "Syntax error: wrong step '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'";
return 1;
}
anArgIter += 2;
aNewSizeXY.SetValues (Draw::Atof (theArgVec[anArgIter]), 0.0);
if (aNewStepXY.x() <= 0.0)
{
- std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error: wrong size '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aNewStepXY.x() <= 0.0
|| aNewStepXY.y() <= 0.0)
{
- std::cout << "Syntax error: wrong size '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'\n";
+ Message::SendFail() << "Syntax error: wrong size '" << theArgVec[anArgIter + 1] << " " << theArgVec[anArgIter + 2] << "'";
return 1;
}
anArgIter += 2;
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
aDivisionNumber = (int )aNewStepXY[1];
if (aDivisionNumber < 1)
{
- std::cout << "Syntax error: invalid division number '" << aNewStepXY[1] << "'\n";
+ Message::SendFail() << "Syntax error: invalid division number '" << aNewStepXY[1] << "'";
return 1;
}
}
aRadius = aNewSizeXY.x();
if (aNewSizeXY.y() != 0.0)
{
- std::cout << "Syntax error: circular size should be specified as radius\n";
+ Message::SendFail ("Syntax error: circular size should be specified as radius");
return 1;
}
}
{
if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
if (aViewer.IsNull())
{
- std::cerr << "Error: no active viewer. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
// non-numeric argument too early
if (aCoord.IsEmpty())
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
else if (anArg == "ray") aMode = Ray;
else
{
- std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
+ Message::SendFail() << "Error: wrong argument " << anArg << "! See usage:";
theDI.PrintHelp (theArgVec[0]);
return 1;
}
(aCoord.Length() == 2 && theArgNb > 4) ||
(aCoord.Length() == 3 && theArgNb > 5))
{
- std::cerr << "Error: wrong number of arguments! See usage:\n";
+ Message::SendFail ("Error: wrong number of arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
case View : theDI << "View Vv: " << aView->Convert ((Standard_Integer)aCoord (1)); return 0;
case Window : theDI << "Window Vp: " << aView->Convert (aCoord (1)); return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
return 0;
default:
- std::cerr << "Error: wrong arguments! See usage:\n";
+ Message::SendFail ("Error: wrong arguments! See usage:");
theDI.PrintHelp (theArgVec[0]);
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
aFramesNb = anArg.IntegerValue();
if (aFramesNb <= 0)
{
- std::cerr << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
}
else
{
- std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
{
if (!toSet)
{
- std::cerr << "No active view!\n";
+ Message::SendFail ("Error: no active viewer");
}
return 1;
}
theDI << "WinBuffer: " << (aCaps->useSystemBuffer ? "1" : "0") << "\n";
theDI << "NoExt:" << (aCaps->contextNoExtensions ? "1" : "0") << "\n";
theDI << "MaxVersion:" << aCaps->contextMajorVersionUpper << "." << aCaps->contextMinorVersionUpper << "\n";
+ theDI << "CompressTextures: " << (aCaps->compressedTexturesDisable ? "0" : "1") << "\n";
return 0;
}
}
aCaps->sRGBDisable = !toEnable;
}
+ else if (anArgCase == "-compressedtextures")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->compressedTexturesDisable = !toEnable;
+ }
else if (anArgCase == "-vbo")
{
Standard_Boolean toEnable = Standard_True;
if (aVer[0] < -1
|| aVer[1] < -1)
{
- std::cout << "Syntax error at '" << anArgCase << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArgCase << "'";
return 1;
}
aCaps->contextMajorVersionUpper = aVer[0];
}
else
{
- std::cout << "Error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Error: unknown argument '" << anArg << "'";
return 1;
}
}
Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
if (aContextAIS.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
if (aDriver.IsNull())
{
- std::cerr << "Graphic driver not available.\n";
+ Message::SendFail ("Error: graphic driver not available");
return 1;
}
TCollection_AsciiString anInfo;
if (!aDriver->MemoryInfo (aFreeBytes, anInfo))
{
- std::cerr << "Information not available.\n";
+ Message::SendFail ("Error: information not available");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theArgNb < 3)
{
- std::cerr << "Usage : " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]\n";
+ Message::SendFail() << "Syntax error: wrong number of arguments.\n"
+ << "Usage: " << theArgVec[0] << " xPixel yPixel [{rgb|rgba|depth|hls|rgbf|rgbaf}=rgba] [name]";
return 1;
}
const Standard_Integer anY = Draw::Atoi (theArgVec[2]);
if (anX < 0 || anX >= aWidth || anY < 0 || anY > aHeight)
{
- std::cerr << "Pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")\n";
+ Message::SendFail() << "Error: pixel coordinates (" << anX << "; " << anY << ") are out of view (" << aWidth << " x " << aHeight << ")";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << aParam << "'\n";
+ Message::SendFail() << "Syntax error at '" << aParam << "'";
return 1;
}
}
Image_PixMap anImage;
if (!anImage.InitTrash (aFormat, aWidth, aHeight))
{
- std::cerr << "Image allocation failed\n";
+ Message::SendFail ("Error: image allocation failed");
return 1;
}
else if (!aView->ToPixMap (anImage, aWidth, aHeight, aBufferType))
{
- std::cerr << "Image dump failed\n";
+ Message::SendFail ("Error: image dump failed");
return 1;
}
{
if (theArgNb < 3)
{
- std::cout << "Syntax error: not enough arguments.\n";
+ Message::SendFail ("Syntax error: not enough arguments");
return 1;
}
aTolColor = Atof (theArgVec[++anArgIter]);
if (aTolColor < 0.0 || aTolColor > 1.0)
{
- std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'";
return 1;
}
}
aTolColor = anArg.RealValue();
if (aTolColor < 0.0 || aTolColor > 1.0)
{
- std::cout << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << " " << theArgVec[anArgIter] << "'";
return 1;
}
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
Handle(Image_AlienPixMap) anImgNew = new Image_AlienPixMap();
if (!anImgRef->Load (anImgPathRef))
{
- std::cout << "Error: image file '" << anImgPathRef << "' cannot be read\n";
+ Message::SendFail() << "Error: image file '" << anImgPathRef << "' cannot be read";
return 1;
}
if (!anImgNew->Load (anImgPathNew))
{
- std::cout << "Error: image file '" << anImgPathNew << "' cannot be read\n";
+ Message::SendFail() << "Error: image file '" << anImgPathNew << "' cannot be read";
return 1;
}
aDiff = new Image_AlienPixMap();
if (!aDiff->InitTrash (Image_Format_Gray, anImgRef->SizeX(), anImgRef->SizeY()))
{
- std::cout << "Error: cannot allocate memory for diff image " << anImgRef->SizeX() << "x" << anImgRef->SizeY() << "\n";
+ Message::SendFail() << "Error: cannot allocate memory for diff image " << anImgRef->SizeX() << "x" << anImgRef->SizeY();
return 1;
}
aComparer.SaveDiffImage (*aDiff);
if (!aDiffImagePath.IsEmpty()
&& !aDiff->Save (aDiffImagePath))
{
- std::cout << "Error: diff image file '" << aDiffImagePath << "' cannot be written\n";
+ Message::SendFail() << "Error: diff image file '" << aDiffImagePath << "' cannot be written";
return 1;
}
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cout << "Error: no active View\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
- if (toAllowOverlap
- && aPnts.Length() != 2)
- {
- std::cout << "Syntax error: -allowoverlap key is applied only for rectangle selection\n";
- return 1;
- }
+
if (toAllowOverlap)
{
aCtx->MainSelector()->AllowOverlapDetection (toAllowOverlap);
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aContext.IsNull())
{
- std::cout << "Error: no active View\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (anArgIter + 1 < theNbArgs)
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter + 1] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter + 1] << "'";
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aMousePos.x() == IntegerLast()
|| aMousePos.y() == IntegerLast())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << theArgVec[0] << ": please initialize or activate view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest::CurrentView());
if (aV3dView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
TCollection_AsciiString aViewName = aViewNames.GetViewName();
if (!ViewerTest_myViews.IsBound1 (aViewName))
{
- std::cout << "Syntax error: unknown view '" << theArgVec[anArgIt - 1] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown view '" << theArgVec[anArgIt - 1] << "'";
return 1;
}
aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest_myViews.Find1 (aViewName));
}
else
{
- std::cout << "Syntax error: unknown argument " << anArg << ".\n";
+ Message::SendFail() << "Syntax error: unknown argument " << anArg;
return 1;
}
}
}
if (aCtx.IsNull())
{
- std::cout << "Error: no active view\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
TCollection_AsciiString aNameArg (theArgVec[anArgIter++]);
if (aNameArg.IsEmpty())
{
- std::cout << "Syntax error: animation name is not defined.\n";
+ Message::SendFail ("Syntax error: animation name is not defined");
return 1;
}
}
else if (aNameArg.Value (1) == '-')
{
- std::cout << "Syntax error: invalid animation name '" << aNameArg << "'.\n";
+ Message::SendFail() << "Syntax error: invalid animation name '" << aNameArg << "'";
return 1;
}
{
if (aSplitPos == aNameArg.Length())
{
- std::cout << "Syntax error: animation name is not defined.\n";
+ Message::SendFail ("Syntax error: animation name is not defined");
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg << "";
return 1;
}
aPlaySpeed = Draw::Atof (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.FpsDen = aDenStr.IntegerValue();
if (aRecParams.FpsDen < 1)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.Format = theArgVec[anArgIter];
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.PixelFormat = theArgVec[anArgIter];
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aRecParams.VideoCodec = theArgVec[anArgIter];
const TCollection_AsciiString aParamName = anArg.SubString (2, anArg.Length());
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
Handle(AIS_InteractiveObject) anObject;
if (!aMapOfAIS.Find2 (anObjName, anObject))
{
- std::cout << "Syntax error: wrong object name at " << anArg << "\n";
+ Message::SendFail() << "Syntax error: wrong object name at " << anArg;
return 1;
}
if (aTrsfArgIter + 4 >= theArgNb
|| !parseQuaternion (theArgVec + aTrsfArgIter + 1, aRotQuats[anIndex]))
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aTrsfArgIter += 4;
if (aTrsfArgIter + 3 >= theArgNb
|| !parseXYZ (theArgVec + aTrsfArgIter + 1, aLocPnts[anIndex]))
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aTrsfArgIter += 3;
isTrsfSet = Standard_True;
if (++aTrsfArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
const TCollection_AsciiString aScaleStr (theArgVec[aTrsfArgIter]);
if (!aScaleStr.IsRealValue())
{
- std::cout << "Syntax error at " << aTrsfArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aTrsfArg;
return 1;
}
aScales[anIndex] = aScaleStr.RealValue();
}
if (!isTrsfSet)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
else if (aTrsfArgIter >= theArgNb)
isTrsfSet = Standard_True;
if (++aViewArgIter >= theArgNb)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
const TCollection_AsciiString aScaleStr (theArgVec[aViewArgIter]);
if (!aScaleStr.IsRealValue())
{
- std::cout << "Syntax error at " << aViewArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aViewArg;
return 1;
}
Standard_Real aScale = aScaleStr.RealValue();
if (aViewArgIter + 3 >= theArgNb
|| !parseXYZ (theArgVec + aViewArgIter + 1, anXYZ))
{
- std::cout << "Syntax error at " << aViewArg << ".\n";
+ Message::SendFail() << "Syntax error at " << aViewArg;
return 1;
}
aViewArgIter += 3;
}
if (!isTrsfSet)
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
else if (aViewArgIter >= theArgNb)
}
else
{
- std::cout << "Syntax error at " << anArg << ".\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
}
aRecorder = new Image_VideoRecorder();
if (!aRecorder->Open (aRecFile.ToCString(), aRecParams))
{
- std::cout << "Error: failed to open video file for recording\n";
+ Message::SendFail ("Error: failed to open video file for recording");
return 0;
}
aDumpParams.ToAdjustAspect = Standard_True;
if (!aView->ToPixMap (aRecorder->ChangeFrame(), aDumpParams))
{
- std::cout << "Error: view dump is failed!\n";
+ Message::SendFail ("Error: view dump is failed");
return 0;
}
aFlipper.FlipY (aRecorder->ChangeFrame());
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (!isOk)
{
- std::cerr << "Usage :" << std::endl;
- std::cerr << theArgVec[0] << " off" << std::endl;
- 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;
+ Message::SendFail() << "Usage:\n"
+ << theArgVec[0] << " off\n"
+ << 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]";
return 1;
}
Handle(Graphic3d_ClipPlane) aClipPlane;
if (!theRegPlanes.Find (theName, aClipPlane))
{
- std::cout << "Warning: no such plane.\n";
+ Message::SendWarning ("Warning: no such plane");
return;
}
const Handle(V3d_View)& anActiveView = ViewerTest::CurrentView();
if (anActiveView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
if (theArgsNb < 3)
{
- std::cout << "Syntax error: plane name is required.\n";
+ Message::SendFail ("Syntax error: plane name is required");
return 1;
}
{
if (!aRegPlanes.IsBound (aPlane))
{
- std::cout << "Error: no such plane.\n";
+ Message::SendFail ("Error: no such plane");
return 1;
}
else if (theArgsNb < 4)
{
- std::cout << "Syntax error: enter name for new plane.\n";
+ Message::SendFail ("Syntax error: enter name for new plane");
return 1;
}
TCollection_AsciiString aClone (theArgVec[3]);
if (aRegPlanes.IsBound (aClone))
{
- std::cout << "Error: plane name is in use.\n";
+ Message::SendFail ("Error: plane name is in use");
return 1;
}
{
if (theArgsNb < 5)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
// old syntax support
if (theArgsNb < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aPlaneName = theArgVec[2];
if (!aRegPlanes.Find (aPlaneName, aClipPlane))
{
- std::cout << "Error: no such plane '" << aPlaneName << "'.\n";
+ Message::SendFail() << "Error: no such plane '" << aPlaneName << "'";
return 1;
}
}
if (theArgsNb - anArgIter < 1)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 5)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
if (!aSubStr.IsIntegerValue()
|| aSubStr.IntegerValue() <= 0)
{
- std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
return 1;
}
aSubIndex = aSubStr.IntegerValue();
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
aClipPlane->SetCappingColor (aColor);
Graphic3d_NameOfMaterial aMatName;
if (!Graphic3d_MaterialAspect::MaterialFromName (aChangeArgs[1], aMatName))
{
- std::cout << "Syntax error: unknown material '" << aChangeArgs[1] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown material '" << aChangeArgs[1] << "'";
return 1;
}
aClipPlane->SetCappingMaterial (aMatName);
}
else
{
- std::cout << "Syntax error at '" << aValStr << "'\n";
+ Message::SendFail() << "Syntax error at '" << aValStr << "'";
return 1;
}
anAspect->SetAlphaMode (aMode);
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 3)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aClipPlane->CappingTexture().IsNull())
{
- std::cout << "Error: no texture is set.\n";
+ Message::SendFail ("Error: no texture is set");
return 1;
}
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
{
if (aNbChangeArgs < 2)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
}
else
{
- std::cout << "Error: object/view '" << anEntityName << "' is not found!\n";
+ Message::SendFail() << "Error: object/view '" << anEntityName << "' is not found";
return 1;
}
}
}
else
{
- std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
return 1;
}
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (aNewZNear >= aNewZFar)
{
- std::cout << theArgVec[0] << ": invalid arguments: znear should be less than zfar.\n";
+ Message::SendFail ("Syntax error: invalid arguments: znear should be less than zfar");
return 1;
}
if (!aCamera->IsOrthographic() && (aNewZNear <= 0.0 || aNewZFar <= 0.0))
{
- std::cout << theArgVec[0] << ": invalid arguments: ";
- std::cout << "znear, zfar should be positive for perspective camera.\n";
+ Message::SendFail ("Syntax error: invalid arguments: znear, zfar should be positive for perspective camera");
return 1;
}
}
else
{
- std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ Message::SendFail ("Syntax error: wrong command arguments");
return 1;
}
if (aCurrentView.IsNull())
{
- std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (theArgsNb > 3)
{
- std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ Message::SendFail ("Syntax error: wrong command arguments");
return 1;
}
}
aCurrentView->SetAutoZFitMode (isOn, aScale);
- aCurrentView->AutoZFit();
aCurrentView->Redraw();
-
return 0;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
{
theDI << "ProjType: " << projTypeName (aCamera->ProjectionType()) << "\n";
theDI << "FOVy: " << aCamera->FOVy() << "\n";
+ theDI << "FOVx: " << aCamera->FOVx() << "\n";
+ theDI << "FOV2d: " << aCamera->FOV2d() << "\n";
theDI << "Distance: " << aCamera->Distance() << "\n";
theDI << "IOD: " << aCamera->IOD() << "\n";
theDI << "IODType: " << (aCamera->GetIODType() == Graphic3d_Camera::IODType_Absolute ? "absolute" : "relative") << "\n";
}
else if (*anArgValue != '-')
{
- std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
+ Message::SendFail() << "Error: unknown IOD type '" << anArgValue << "'";
return 1;
}
switch (aCamera->GetIODType())
}
else if (*anArgValue != '-')
{
- std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
+ Message::SendFail() << "Error: unknown ZFocus type '" << anArgValue << "'";
return 1;
}
switch (aCamera->ZFocusType())
case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
}
}
+ else if (anArgCase == "-lockzup"
+ || anArgCase == "-turntable")
+ {
+ bool toLockUp = true;
+ if (++anArgIter < theArgsNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toLockUp))
+ {
+ --anArgIter;
+ }
+ ViewerTest::CurrentEventManager()->SetLockOrbitZUp (toLockUp);
+ }
else if (anArgCase == "-fov"
- || anArgCase == "-fovy")
+ || anArgCase == "-fovy"
+ || anArgCase == "-fovx"
+ || anArgCase == "-fov2d")
{
Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
if (anArgValue != NULL
&& *anArgValue != '-')
{
++anArgIter;
- aCamera->SetFOVy (Draw::Atof (anArgValue));
+ if (anArgCase == "-fov2d")
+ {
+ aCamera->SetFOV2d (Draw::Atof (anArgValue));
+ }
+ else if (anArgCase == "-fovx")
+ {
+ aCamera->SetFOVy (Draw::Atof (anArgValue) / aCamera->Aspect());///
+ }
+ else
+ {
+ aCamera->SetFOVy (Draw::Atof (anArgValue));
+ }
continue;
}
- theDI << aCamera->FOVy() << " ";
+ if (anArgCase == "-fov2d")
+ {
+ theDI << aCamera->FOV2d() << " ";
+ }
+ else if (anArgCase == "-fovx")
+ {
+ theDI << aCamera->FOVx() << " ";
+ }
+ else
+ {
+ theDI << aCamera->FOVy() << " ";
+ }
+ }
+ else if (anArgIter + 1 < theArgsNb
+ && anArgCase == "-xrpose")
+ {
+ TCollection_AsciiString anXRArg (theArgVec[++anArgIter]);
+ anXRArg.LowerCase();
+ if (anXRArg == "base")
+ {
+ aCamera = aView->View()->BaseXRCamera();
+ }
+ else if (anXRArg == "head")
+ {
+ aCamera = aView->View()->PosedXRCamera();
+ }
+ else
+ {
+ Message::SendFail() << "Syntax error: unknown XR pose '" << anXRArg << "'";
+ return 1;
+ }
+ if (aCamera.IsNull())
+ {
+ Message::SendFail() << "Error: undefined XR pose";
+ return 0;
+ }
+ if (aView->AutoZFitMode())
+ {
+ const Bnd_Box aMinMaxBox = aView->View()->MinMaxValues (false);
+ const Bnd_Box aGraphicBox = aView->View()->MinMaxValues (true);
+ aCamera->ZFitAll (aView->AutoZFitScaleFactor(), aMinMaxBox, aGraphicBox);
+ }
}
else if (aPrsName.IsEmpty()
&& !anArgCase.StartsWith ("-"))
}
else
{
- std::cout << "Error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Error: unknown argument '" << anArg << "'";
return 1;
}
}
if (aPrsName.IsEmpty()
|| theArgsNb > 2)
{
- aView->AutoZFit();
aView->Redraw();
}
aCameraFrustum = Handle(AIS_CameraFrustum)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
if (aCameraFrustum.IsNull())
{
- std::cout << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum!\n";
+ Message::SendFail() << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum";
return 1;
}
}
ViewerTest::GetAISContext()->Erase (aCameraFrustum, false);
aView->ZFitAll();
}
- aCameraFrustum->SetCameraFrustum (aView->Camera());
+ aCameraFrustum->SetCameraFrustum (aCamera);
ViewerTest::Display (aPrsName, aCameraFrustum);
}
{
theMode = Graphic3d_StereoMode_SoftPageFlip;
}
+ else if (aFlag == "openvr"
+ || aFlag == "vr")
+ {
+ theMode = Graphic3d_StereoMode_OpenVR;
+ }
else
{
return Standard_False;
{
if (aView.IsNull())
{
- std::cout << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 0;
}
case Graphic3d_StereoMode_SideBySide : aMode = "sideBySide"; break;
case Graphic3d_StereoMode_OverUnder : aMode = "overUnder"; break;
case Graphic3d_StereoMode_SoftPageFlip : aMode = "softpageflip"; break;
+ case Graphic3d_StereoMode_OpenVR : aMode = "openVR"; break;
case Graphic3d_StereoMode_Anaglyph :
aMode = "anaglyph";
switch (aView->RenderingParams().AnaglyphFilter)
{
if (++anArgIter < theArgNb)
{
- std::cout << "Error: wrong number of arguments!\n";
+ Message::SendFail ("Error: wrong number of arguments");
return 1;
}
{
if (++anArgIter < theArgNb)
{
- std::cout << "Error: wrong number of arguments!\n";
+ Message::SendFail ("Error: wrong number of arguments");
return 1;
}
aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
}
ViewerTest_myDefaultCaps.contextStereo = Standard_True;
- return 0;
+ if (aParams->StereoMode != Graphic3d_StereoMode_OpenVR)
+ {
+ return 0;
+ }
}
else if (aFlag == "-reverse"
|| aFlag == "-reversed"
if (++anArgIter >= theArgNb
|| !parseStereoMode (theArgVec[anArgIter], aMode))
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
if (++anArgIter >= theArgNb
|| !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
ViewerTest_myDefaultCaps.contextStereo = Standard_True;
}
}
+ else if (anArgIter + 1 < theArgNb
+ && aFlag == "-hmdfov2d")
+ {
+ aParams->HmdFov2d = (float )Draw::Atof (theArgVec[++anArgIter]);
+ if (aParams->HmdFov2d < 10.0f
+ || aParams->HmdFov2d > 180.0f)
+ {
+ Message::SendFail() << "Error: FOV is out of range";
+ return 1;
+ }
+ }
+ else if (aFlag == "-mirror"
+ || aFlag == "-mirrorcomposer")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams->ToMirrorComposer = toEnable;
+ }
+ else if (anArgIter + 1 < theArgNb
+ && (aFlag == "-unitfactor"
+ || aFlag == "-unitscale"))
+ {
+ aView->View()->SetUnitFactor (Draw::Atof (theArgVec[++anArgIter]));
+ }
else
{
- std::cout << "Error: syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
{
aParams->StereoMode = aMode;
aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ if (aParams->StereoMode == Graphic3d_StereoMode_OpenVR)
+ {
+ // initiate implicit continuous rendering
+ ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), aView, true);
+ }
}
return 0;
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cout << "Error: no active viewer\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
theDi << "DeflType: absolute\n"
<< "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
}
- theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
+ theDi << "AngularDeflection: " << (180.0 * aDefParams->DeviationAngle() / M_PI) << "\n";
theDi << "AutoTriangulation: " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
return 0;
}
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Error: wrong syntax at " << anArg << "\n";
+ Message::SendFail() << "Syntax error at " << anArg;
return 1;
}
- // currently HLRDeviationAngle is used instead of DeviationAngle in most places
- aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
+ aDefParams->SetDeviationAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
}
else if (anArg == "-AUTOTR"
|| anArg == "-AUTOTRIANG"
if (anArgIter >= theArgsNb
|| !ViewerTest::ParseOnOff (theArgVec[anArgIter], toTurnOn))
{
- std::cout << "Syntax error at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
aDefParams->SetAutoTriangulation (toTurnOn);
}
else
{
- std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << anArg << "'";
return 1;
}
}
if (aView.IsNull()
|| aViewer.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLight->Attenuation (anAtten[0], anAtten[1]);
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
+ theDi << " Range: " << aLight->Range() << "\n";
break;
}
case V3d_SPOT:
theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
theDi << " Angle: " << (aLight->Angle() * 180.0 / M_PI) << "\n";
theDi << " Exponent: " << aLight->Concentration() << "\n";
+ theDi << " Range: " << aLight->Range() << "\n";
break;
}
default:
{
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (!toCreate)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
{
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (aLightOld.IsNull())
{
- std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
+ Message::SendFail() << "Error: Light " << theArgVec[anArgIt] << " is undefined";
return 1;
}
}
Handle(V3d_Light) aLightDel;
if (++anArgIt >= theArgsNb)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_DIRECTIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
if (++anArgIt >= theArgsNb
|| aLightCurr.IsNull())
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| aLightCurr.IsNull()
|| aLightCurr->Type() != Graphic3d_TOLS_SPOT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| (aLightCurr->Type() != Graphic3d_TOLS_POSITIONAL
&& aLightCurr->Type() != Graphic3d_TOLS_SPOT))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
|| aLightCurr.IsNull()
|| aLightCurr->Type() != Graphic3d_TOLS_SPOT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aLightCurr->SetConcentration ((Standard_ShortReal )Atof (theArgVec[anArgIt]));
}
+ else if (anArgCase.IsEqual("RANGE")
+ || anArgCase.IsEqual("-RANGE"))
+ {
+ if (++anArgIt >= theArgsNb
+ || aLightCurr.IsNull()
+ || aLightCurr->Type() == Graphic3d_TOLS_AMBIENT
+ || aLightCurr->Type() == Graphic3d_TOLS_DIRECTIONAL)
+ {
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
+ return 1;
+ }
+
+ aLightCurr->SetRange ((Standard_ShortReal)Atof (theArgVec[anArgIt]));
+ }
else if (anArgCase.IsEqual ("HEAD")
|| anArgCase.IsEqual ("HEADLIGHT")
|| anArgCase.IsEqual ("-HEAD")
if (aLightCurr.IsNull()
|| aLightCurr->Type() == Graphic3d_TOLS_AMBIENT)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cerr << "Warning: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Warning: unknown argument '" << anArg << "'";
}
}
{
if (theArgsNb > 2)
{
- std::cerr << "Error: 'vpbrenv' command has only one argument\n";
+ Message::SendFail ("Syntax error: 'vpbrenv' command has only one argument");
return 1;
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cerr << "Error: unknown argument [" << theArgVec[1] << "] for 'vpbrenv' command\n";
+ Message::SendFail() << "Syntax error: unknown argument [" << theArgVec[1] << "] for 'vpbrenv' command";
return 1;
}
|| aVal == "triangles") aFlag = Graphic3d_RenderingParams::PerfCounters_Triangles;
else if (aVal == "pnts"
|| aVal == "points") aFlag = Graphic3d_RenderingParams::PerfCounters_Points;
+ else if (aVal == "lines") aFlag = Graphic3d_RenderingParams::PerfCounters_Lines;
else if (aVal == "mem"
|| aVal == "gpumem"
|| aVal == "estimmem") aFlag = Graphic3d_RenderingParams::PerfCounters_EstimMem;
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
}
else
{
- std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << theArgVec[1] << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
}
{
theDI << " tris";
}
+ if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Lines) != 0)
+ {
+ theDI << " lines";
+ }
if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_Points) != 0)
{
theDI << " pnts";
}
else
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aNbSamples = Draw::Atoi (theArgVec[anArgIter]);
if (aNbSamples < 0)
{
- std::cerr << "Error: invalid number of MSAA samples " << aNbSamples << ".\n";
+ Message::SendFail() << "Syntax error: invalid number of MSAA samples " << aNbSamples << "";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aFeather = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
if (aFeather <= 0.0f)
{
- std::cerr << "Error: invalid value of line width feather " << aFeather << ". Should be > 0\n";
+ Message::SendFail() << "Syntax error: invalid value of line width feather " << aFeather << ". Should be > 0";
return 1;
}
aParams.LineFeather = aFeather;
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aWeight = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
if (aWeight < 0.f || aWeight > 1.f)
{
- std::cerr << "Error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]\n";
+ Message::SendFail() << "Syntax error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]";
return 1;
}
}
else
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Real aScale = Draw::Atof (theArgVec[anArgIter]);
if (aScale < 0.01)
{
- std::cerr << "Error: invalid rendering resolution scale " << aScale << ".\n";
+ Message::SendFail() << "Syntax error: invalid rendering resolution scale " << aScale << "";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
// We allow RaytracingDepth be more than 10 in case of GI enabled
if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
{
- std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
+ Message::SendFail() << "Syntax error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]";
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const TCollection_AsciiString aMaxRadStr = theArgVec[anArgIter];
if (!aMaxRadStr.IsRealValue())
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Real aMaxRadiance = aMaxRadStr.RealValue();
if (aMaxRadiance <= 0.0)
{
- std::cerr << "Error: invalid radiance clamping value " << aMaxRadiance << ".\n";
+ Message::SendFail() << "Syntax error: invalid radiance clamping value " << aMaxRadiance;
return 1;
}
else
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aTileSize = Draw::Atoi (theArgVec[anArgIter]);
if (aTileSize < 1)
{
- std::cerr << "Error: invalid size of ISS tile " << aTileSize << ".\n";
+ Message::SendFail() << "Syntax error: invalid size of ISS tile " << aTileSize;
return 1;
}
aParams.RayTracingTileSize = aTileSize;
}
else if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aNbTiles = Draw::Atoi (theArgVec[anArgIter]);
if (aNbTiles < -1)
{
- std::cerr << "Error: invalid number of ISS tiles " << aNbTiles << ".\n";
+ Message::SendFail() << "Syntax error: invalid number of ISS tiles " << aNbTiles;
return 1;
}
else if (aNbTiles > 0
&& (aNbTiles < 64
|| aNbTiles > 1024))
{
- std::cerr << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].\n";
+ Message::SendWarning() << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].";
}
aParams.NbRayTracingTiles = aNbTiles;
}
}
aParams.UseEnvironmentMapBackground = toEnable;
}
+ else if (aFlag == "-ignorenormalmap")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.ToIgnoreNormalMapInRayTracing ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.ToIgnoreNormalMapInRayTracing = toEnable;
+ }
else if (aFlag == "-twoside")
{
if (toPrint)
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
}
Graphic3d_TypeOfShadingModel aModel = Graphic3d_TOSM_DEFAULT;
}
else
{
- std::cout << "Error: unknown shading model '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error: unknown shading model '" << theArgVec[anArgIter] << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvPow2Size = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvPow2Size < 1)
{
- std::cout << "Error: 'Pow2Size' of PBR Environment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'Pow2Size' of PBR Environment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvPow2Size = aPbrEnvPow2Size;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvSpecMapNbLevels = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvSpecMapNbLevels < 2)
{
- std::cout << "Error: 'SpecMapLevelsNumber' of PBR Environment has to be greater or equal 2\n";
+ Message::SendFail ("Syntax error: 'SpecMapLevelsNumber' of PBR Environment has to be greater or equal 2");
return 1;
}
aParams.PbrEnvSpecMapNbLevels = aPbrEnvSpecMapNbLevels;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvBakingDiffNbSamples = Draw::Atoi (theArgVec[anArgIter]);
if (aPbrEnvBakingDiffNbSamples < 1)
{
- std::cout << "Error: 'BakingDiffSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'BakingDiffSamplesNumber' of PBR Environtment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvBakingDiffNbSamples = aPbrEnvBakingDiffNbSamples;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_Integer aPbrEnvBakingSpecNbSamples = Draw::Atoi(theArgVec[anArgIter]);
if (aPbrEnvBakingSpecNbSamples < 1)
{
- std::cout << "Error: 'BakingSpecSamplesNumber' of PBR Environtment has to be greater or equal 1\n";
+ Message::SendFail ("Syntax error: 'BakingSpecSamplesNumber' of PBR Environtment has to be greater or equal 1");
return 1;
}
aParams.PbrEnvBakingSpecNbSamples = aPbrEnvBakingSpecNbSamples;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
const Standard_ShortReal aPbrEnvBakingProbability = static_cast<Standard_ShortReal>(Draw::Atof (theArgVec[anArgIter]));
if (aPbrEnvBakingProbability < 0.f
|| aPbrEnvBakingProbability > 1.f)
{
- std::cout << "Error: 'BakingProbability' of PBR Environtment has to be in range of [0, 1]\n";
+ Message::SendFail ("Syntax error: 'BakingProbability' of PBR Environtment has to be in range of [0, 1]");
return 1;
}
aParams.PbrEnvBakingProbability = aPbrEnvBakingProbability;
{
if (++anArgIter >= theArgNb)
{
- std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error: wrong syntax at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
float aFocalDist = static_cast<float> (aParam.RealValue());
if (aFocalDist < 0)
{
- std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
+ Message::SendFail() << "Error: parameter can't be negative at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CameraFocalPlaneDist = aFocalDist;
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
float aApertureSize = static_cast<float> (aParam.RealValue());
if (aApertureSize < 0)
{
- std::cout << "Error: parameter can't be negative at argument '" << anArg << "'.\n";
+ Message::SendFail() << "Error: parameter can't be negative at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CameraApertureRadius = aApertureSize;
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
}
else
{
- std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ Message::SendFail() << "Syntax error at argument'" << anArg << "'";
return 1;
}
}
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
Graphic3d_RenderingParams::PerfCounters aFlags = aView->ChangeRenderingParams().CollectedStats;
if (!convertToPerfStatsFlags (aFlagsStr, aFlags))
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().CollectedStats = aFlags;
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsUpdateInterval = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsNbFrames = Draw::Atoi (theArgVec[anArgIter]);
{
if (++anArgIter >= theArgNb)
{
- std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at argument '" << anArg << "'";
return 1;
}
aView->ChangeRenderingParams().StatsMaxChartTime = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
}
else
{
- std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown flag '" << anArg << "'";
return 1;
}
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "Error: no active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (aFlag == "alllayers"
|| aFlag == "layers") aParam = Graphic3d_RenderingParams::PerfCounters_Layers;
else if (aFlag == "allstructs"
- || aFlag == "structs") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
+ || aFlag == "allstructures"
+ || aFlag == "structs"
+ || aFlag == "structures") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
else if (aFlag == "groups") aParam = Graphic3d_RenderingParams::PerfCounters_Groups;
else if (aFlag == "allarrays"
|| aFlag == "fillarrays"
|| aFlag == "pointarrays"
|| aFlag == "textarrays") aParam = Graphic3d_RenderingParams::PerfCounters_GroupArrays;
else if (aFlag == "triangles") aParam = Graphic3d_RenderingParams::PerfCounters_Triangles;
+ else if (aFlag == "lines") aParam = Graphic3d_RenderingParams::PerfCounters_Lines;
else if (aFlag == "points") aParam = Graphic3d_RenderingParams::PerfCounters_Points;
else if (aFlag == "geommem"
|| aFlag == "texturemem"
|| aFlag == "cpudynmax") aParam = Graphic3d_RenderingParams::PerfCounters_FrameTime;
else
{
- std::cerr << "Unknown argument '" << theArgVec[anArgIter] << "'!\n";
+ Message::SendFail() << "Error: unknown argument '" << theArgVec[anArgIter] << "'";
continue;
}
{
theDI << searchInfo (aDict, "Rendered layers") << " ";
}
- else if (aFlag == "allstructs")
+ else if (aFlag == "allstructs"
+ || aFlag == "allstructures")
{
theDI << searchInfo (aDict, "Structs") << " ";
}
- else if (aFlag == "structs")
+ else if (aFlag == "structs"
+ || aFlag == "structures")
{
- theDI << searchInfo (aDict, "Rendered structs") << " ";
+ TCollection_AsciiString aRend = searchInfo (aDict, "Rendered structs");
+ if (aRend.IsEmpty()) // all structures rendered
+ {
+ aRend = searchInfo (aDict, "Structs");
+ }
+ theDI << aRend << " ";
}
else if (aFlag == "groups")
{
if (aCurrentView.IsNull()
|| aViewer.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
if (aName.IsEmpty())
{
- std::cerr << theArgVec[0] << " error: please specify AIS manipulator's name as the first argument.\n";
+ Message::SendFail ("Syntax error: please specify AIS manipulator's name as the first argument");
return 1;
}
{
if (!aMapAIS.IsBound2 (aName))
{
- std::cerr << theArgVec[0] << " error: could not find \"" << aName << "\" AIS object.\n";
+ Message::SendFail() << "Syntax error: could not find \"" << aName << "\" AIS object";
return 1;
}
Handle(AIS_Manipulator) aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
if (aManipulator.IsNull())
{
- std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ Message::SendFail() << "Syntax error: \"" << aName << "\" is not an AIS manipulator";
return 1;
}
aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
if (aManipulator.IsNull())
{
- std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ Message::SendFail() << "Syntax error: \"" << aName << "\" is not an AIS manipulator";
return 1;
}
}
Standard_Boolean aOnOff = aCmd.ArgBool ("part", 2);
if (aMode < 1 || aMode > 4)
{
- std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
+ Message::SendFail ("Syntax error: mode value should be in range [1, 4]");
return 1;
}
Standard_Boolean aOnOff = aCmd.ArgBool("parts", 1);
if (aMode < 1 || aMode > 4)
{
- std::cerr << theArgVec[0] << " error: mode value should be in range [1, 4].\n";
+ Message::SendFail ("Syntax error: mode value should be in range [1, 4]");
return 1;
}
Handle(AIS_InteractiveObject) anObject;
if (!aMapAIS.Find2 (anObjName, anObject))
{
- std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" does not exist.\n";
+ Message::SendFail() << "Syntax error: AIS object \"" << anObjName << "\" does not exist";
return 1;
}
&& aManip->IsAttached()
&& aManip->Object() == anObject)
{
- std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" already has manipulator.\n";
+ Message::SendFail() << "Syntax error: AIS object \"" << anObjName << "\" already has manipulator";
return 1;
}
}
ViewerTest_Names aViewNames (aViewString);
if (!ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
{
- std::cerr << theArgVec[0] << " error: wrong view name '" << aViewString << "'\n";
+ Message::SendFail() << "Syntax error: wrong view name '" << aViewString << "'";
return 1;
}
aView = ViewerTest_myViews.Find1 (aViewNames.GetViewName());
if (aView.IsNull())
{
- std::cerr << theArgVec[0] << " error: cannot find view with name '" << aViewString << "'\n";
+ Message::SendFail() << "Syntax error: cannot find view with name '" << aViewString << "'";
return 1;
}
}
const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
if (aCtx.IsNull())
{
- std::cerr << "No active viewer!\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theArgsNb != 2
|| !ViewerTest::ParseOnOff (theArgVec[1], toEnable))
{
- std::cout << "Syntax error: wrong number of parameters.";
+ Message::SendFail ("Syntax error: wrong number of parameters");
return 1;
}
if (toEnable != aCtx->ToHilightSelected())
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
}
else
{
- std::cout << "Syntax error: unknwon picking strategy '" << aVal << "'\n";
+ Message::SendFail() << "Syntax error: unknown picking strategy '" << aVal << "'";
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
Graphic3d_ZLayerId aNewLayer = Graphic3d_ZLayerId_UNKNOWN;
if (!ViewerTest::ParseZLayer (theArgVec[anArgIter], aNewLayer))
{
- std::cerr << "Error: wrong syntax at " << theArgVec[anArgIter] << ".\n";
+ Message::SendFail() << "Syntax error at " << theArgVec[anArgIter];
return 1;
}
}
else if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
aColor);
if (aNbParsed == 0)
{
- std::cout << "Syntax error: need more arguments.\n";
+ Message::SendFail ("Syntax error: need more arguments");
return 1;
}
anArgIter += aNbParsed;
}
else if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
{
if (aType == Prs3d_TypeOfHighlight_None)
{
- std::cout << "Syntax error: type of highlighting is undefined\n";
+ Message::SendFail ("Syntax error: type of highlighting is undefined");
return 1;
}
}
else
{
- std::cout << "Syntax error at '" << theArgVec[anArgIter] << "'\n";
+ Message::SendFail() << "Syntax error at '" << theArgVec[anArgIter] << "'";
}
}
{
if (theArgsNb < 2)
{
- std::cout << "Syntax error: wrong number arguments for '" << theArgVec[0] << "'\n";
+ Message::SendFail() << "Syntax error: wrong number arguments for '" << theArgVec[0] << "'";
return 1;
}
const Handle(AIS_InteractiveContext)& aContext = ViewerTest::GetAISContext();
+ const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aContext.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
TCollection_AsciiString aFile;
StdSelect_TypeOfSelectionImage aType = StdSelect_TypeOfSelectionImage_NormalizedDepth;
+ Handle(Graphic3d_Camera) aCustomCam;
Image_Format anImgFormat = Image_Format_BGR;
Standard_Integer aPickedIndex = 1;
for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: wrong number parameters of flag '-depth'.\n";
+ Message::SendFail ("Syntax error: wrong number parameters of flag '-depth'");
return 1;
}
{
if (++anArgIter >= theArgsNb)
{
- std::cout << "Syntax error: wrong number parameters at '" << aParam << "'.\n";
+ Message::SendFail() << "Syntax error: wrong number parameters at '" << aParam << "'";
return 1;
}
aPickedIndex = Draw::Atoi (theArgVec[anArgIter]);
}
+ else if (anArgIter + 1 < theArgsNb
+ && aParam == "-xrpose")
+ {
+ TCollection_AsciiString anXRArg (theArgVec[++anArgIter]);
+ anXRArg.LowerCase();
+ if (anXRArg == "base")
+ {
+ aCustomCam = aView->View()->BaseXRCamera();
+ }
+ else if (anXRArg == "head")
+ {
+ aCustomCam = aView->View()->PosedXRCamera();
+ }
+ else
+ {
+ Message::SendFail() << "Syntax error: unknown XR pose '" << anXRArg << "'";
+ return 1;
+ }
+ if (aCustomCam.IsNull())
+ {
+ Message::SendFail() << "Error: undefined XR pose";
+ return 0;
+ }
+ }
else if (aFile.IsEmpty())
{
aFile = theArgVec[anArgIter];
}
else
{
- std::cout << "Syntax error: unknown argument '" << theArgVec[anArgIter] << "'.\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << theArgVec[anArgIter] << "'";
return 1;
}
}
if (aFile.IsEmpty())
{
- std::cout << "Syntax error: image file name is missing.\n";
+ Message::SendFail ("Syntax error: image file name is missing");
return 1;
}
- const Handle(V3d_View)& aView = ViewerTest::CurrentView();
Standard_Integer aWidth = 0, aHeight = 0;
aView->Window()->Size (aWidth, aHeight);
Image_AlienPixMap aPixMap;
if (!aPixMap.InitZero (anImgFormat, aWidth, aHeight))
{
- std::cout << "Error: can't allocate image.\n";
+ Message::SendFail ("Error: can't allocate image");
return 1;
}
+
+ const bool wasImmUpdate = aView->SetImmediateUpdate (false);
+ Handle(Graphic3d_Camera) aCamBack = aView->Camera();
+ if (!aCustomCam.IsNull())
+ {
+ aView->SetCamera (aCustomCam);
+ }
if (!aContext->MainSelector()->ToPixMap (aPixMap, aView, aType, aPickedIndex))
{
- std::cout << "Error: can't generate selection image.\n";
+ Message::SendFail ("Error: can't generate selection image");
return 1;
}
+ if (!aCustomCam.IsNull())
+ {
+ aView->SetCamera (aCamBack);
+ }
+ aView->SetImmediateUpdate (wasImmUpdate);
+
if (!aPixMap.Save (aFile))
{
- std::cout << "Error: can't save selection image.\n";
+ Message::SendFail ("Error: can't save selection image");
return 0;
}
return 0;
const Handle(V3d_View)& aView = ViewerTest::CurrentView();
if (aContext.IsNull() || aView.IsNull())
{
- std::cout << "Error: no active view.\n";
+ Message::SendFail ("Error: no active viewer");
return 1;
}
else if (theNbArgs < 2)
{
- std::cout << "Syntax error: wrong number arguments\n";
+ Message::SendFail ("Syntax error: wrong number arguments");
return 1;
}
aName = theArgVec[anArgIter];
if (aName.StartsWith ("-"))
{
- std::cout << "Syntax error: object name should be specified.\n";
+ Message::SendFail ("Syntax error: object name should be specified");
return 1;
}
Handle(AIS_InteractiveObject) aPrs;
aColorRgb);
if (aNbParsed == 0)
{
- std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed;
const Standard_Real aValue = Draw::Atof (theArgVec[++anArgIter]);
if (aValue < 0.0 || aValue > 1.0)
{
- std::cout << "Syntax error: invalid transparency value " << theArgVec[anArgIter] << "\n";
+ Message::SendFail() << "Syntax error: invalid transparency value " << theArgVec[anArgIter];
return 1;
}
{
aViewCube->SetDuration (Draw::Atof (theArgVec[++anArgIter]));
}
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axesradius")
+ {
+ aViewCube->SetAxesRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axesconeradius")
+ {
+ aViewCube->SetAxesConeRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
+ else if (anArgIter + 1 < theNbArgs
+ && anArg == "-axessphereradius")
+ {
+ aViewCube->SetAxesSphereRadius (Draw::Atof (theArgVec[++anArgIter]));
+ }
else
{
- std::cout << "Syntax error: unknown argument '" << anArg << "'\n";
+ Message::SendFail() << "Syntax error: unknown argument '" << anArg << "'";
return 1;
}
}
if (aViewCube.IsNull())
{
- std::cout << "Syntax error: wrong number of arguments\n";
+ Message::SendFail ("Syntax error: wrong number of arguments");
return 1;
}
return 0;
}
+//===============================================================================================
+//function : VColorConvert
+//purpose :
+//===============================================================================================
+static int VColorConvert (Draw_Interpretor& theDI, Standard_Integer theNbArgs, const char** theArgVec)
+{
+ if (theNbArgs != 6)
+ {
+ std::cerr << "Error: command syntax is incorrect, see help" << std::endl;
+ return 1;
+ }
+
+ Standard_Boolean convertFrom = (! strcasecmp (theArgVec[1], "from"));
+ if (! convertFrom && strcasecmp (theArgVec[1], "to"))
+ {
+ std::cerr << "Error: first argument must be either \"to\" or \"from\"" << std::endl;
+ return 1;
+ }
+
+ const char* aTypeStr = theArgVec[2];
+ Quantity_TypeOfColor aType = Quantity_TOC_RGB;
+ if (! strcasecmp (aTypeStr, "srgb"))
+ {
+ aType = Quantity_TOC_sRGB;
+ }
+ else if (! strcasecmp (aTypeStr, "hls"))
+ {
+ aType = Quantity_TOC_HLS;
+ }
+ else if (! strcasecmp (aTypeStr, "lab"))
+ {
+ aType = Quantity_TOC_CIELab;
+ }
+ else if (! strcasecmp (aTypeStr, "lch"))
+ {
+ aType = Quantity_TOC_CIELch;
+ }
+ else
+ {
+ std::cerr << "Error: unknown colorspace type: " << aTypeStr << std::endl;
+ return 1;
+ }
+
+ double aC1 = Draw::Atof (theArgVec[3]);
+ double aC2 = Draw::Atof (theArgVec[4]);
+ double aC3 = Draw::Atof (theArgVec[5]);
+
+ Quantity_Color aColor (aC1, aC2, aC3, convertFrom ? aType : Quantity_TOC_RGB);
+ aColor.Values (aC1, aC2, aC3, convertFrom ? Quantity_TOC_RGB : aType);
+
+ // print values with 6 decimal digits
+ char buffer[1024];
+ Sprintf (buffer, "%.6f %.6f %.6f", aC1, aC2, aC3);
+ theDI << buffer;
+
+ return 0;
+}
+
+//===============================================================================================
+//function : VColorDiff
+//purpose :
+//===============================================================================================
+static int VColorDiff (Draw_Interpretor& theDI, Standard_Integer theNbArgs, const char** theArgVec)
+{
+ if (theNbArgs != 7)
+ {
+ std::cerr << "Error: command syntax is incorrect, see help" << std::endl;
+ return 1;
+ }
+
+ double aR1 = Draw::Atof (theArgVec[1]);
+ double aG1 = Draw::Atof (theArgVec[2]);
+ double aB1 = Draw::Atof (theArgVec[3]);
+ double aR2 = Draw::Atof (theArgVec[4]);
+ double aG2 = Draw::Atof (theArgVec[5]);
+ double aB2 = Draw::Atof (theArgVec[6]);
+
+ Quantity_Color aColor1 (aR1, aG1, aB1, Quantity_TOC_RGB);
+ Quantity_Color aColor2 (aR2, aG2, aB2, Quantity_TOC_RGB);
+
+ theDI << aColor1.DeltaE2000 (aColor2);
+
+ return 0;
+}
+
//=======================================================================
//function : ViewerCommands
//purpose :
"\n\t\t: [-labels Label1 Label2 ...] [-label Index Label]"
"\n\t\t: [-freeLabels NbOfLabels Label1 Label2 ...]"
"\n\t\t: [-xy Left=0 Bottom=0]"
+ "\n\t\t: [-uniform lightness hue_from hue_to]"
"\n\t\t: -demo - displays a color scale with demonstratio values"
"\n\t\t: -colors - set colors for all intervals"
"\n\t\t: -color - set color for specific interval"
+ "\n\t\t: -uniform - generate colors with the same lightness"
"\n\t\t: -textpos - horizontal label position relative to color scale bar"
"\n\t\t: -labelAtBorder - vertical label position relative to color interval;"
"\n\t\t: at border means the value inbetween neighbor intervals,"
"\n\t\t: -title - set title"
"\n\t\t: -reversed - setup smooth color transition between intervals"
"\n\t\t: -smoothTransition - swap colorscale direction"
- "\n\t\t: -hueRange - set hue angles corresponding to minimum and maximum values"
+ "\n\t\t: -hueRange - set hue angles corresponding to minimum and maximum values",
__FILE__, VColorScale, group);
theCommands.Add("vgraduatedtrihedron",
"vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
__FILE__, VVbo, group);
theCommands.Add ("vstereo",
"vstereo [0|1] [-mode Mode] [-reverse {0|1}]"
+ "\n\t\t: [-mirrorComposer] [-hmdfov2d AngleDegrees] [-unitFactor MetersFactor]"
"\n\t\t: [-anaglyph Filter]"
- "\n\t\t: Control stereo output mode. Available modes for -mode:"
+ "\n\t\t: Control stereo output mode."
+ "\n\t\t: When -mirrorComposer is specified, VR rendered frame will be mirrored in window (debug)."
+ "\n\t\t: Parameter -unitFactor specifies meters scale factor for mapping VR input."
+ "\n\t\t: Available modes for -mode:"
"\n\t\t: quadBuffer - OpenGL QuadBuffer stereo,"
"\n\t\t: requires driver support."
"\n\t\t: Should be called BEFORE vinit!"
"\n\t\t: chessBoard - chess-board output"
"\n\t\t: sideBySide - horizontal pair"
"\n\t\t: overUnder - vertical pair"
+ "\n\t\t: openVR - OpenVR (HMD)"
"\n\t\t: Available Anaglyph filters for -anaglyph:"
"\n\t\t: redCyan, redCyanSimple, yellowBlue, yellowBlueSimple,"
"\n\t\t: greenMagentaSimple",
__FILE__, VStereo, group);
theCommands.Add ("vcaps",
"vcaps [-sRGB {0|1}] [-vbo {0|1}] [-sprites {0|1}] [-ffp {0|1}] [-polygonMode {0|1}]"
- "\n\t\t: [-compatibleProfile {0|1}]"
+ "\n\t\t: [-compatibleProfile {0|1}] [-compressedTextures {0|1}]"
"\n\t\t: [-vsync {0|1}] [-useWinBuffer {0|1}]"
"\n\t\t: [-quadBuffer {0|1}] [-stereo {0|1}]"
"\n\t\t: [-softMode {0|1}] [-noupdate|-update]"
"\n\t\t: built-in GLSL programs"
"\n\t\t: (requires compatible profile)"
"\n\t\t: polygonMode - use Polygon Mode instead of built-in GLSL programs"
+ "\n\t\t: compressedTexture - allow uploading of GPU-supported compressed texture formats"
"\n\t\t: VBO - use Vertex Buffer Object (copy vertex"
"\n\t\t: arrays to GPU memory)"
"\n\t\t: sprite - use textured sprites instead of bitmaps"
"- 1) single click selection\n"
"- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
"- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
- "- 4) -allowoverlap manages overlap and inclusion detection in rectangular selection.\n"
- " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined rectangle will be detected,\n"
- " otherwise algorithm will chose only fully included sensitives. Default behavior is to detect only full inclusion. "
- " (partial inclusion - overlap - is not allowed by default)\n"
+ "- 4) -allowoverlap manages overlap and inclusion detection in rectangular and polygonal selection.\n"
+ " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined \n"
+ " rectangle or polygon will be detected, otherwise algorithm will chose only fully included sensitives.\n"
+ " Default behavior is to detect only full inclusion. (partial inclusion - overlap - is not allowed by default)\n"
"- 5) any of these selections with shift button pressed",
__FILE__, VSelect, group);
theCommands.Add ("vmoveto",
"\n\t\t: [-stereo] [-leftEye] [-rightEye]"
"\n\t\t: [-iod [Distance]] [-iodType [absolute|relative]]"
"\n\t\t: [-zfocus [Value]] [-zfocusType [absolute|relative]]"
+ "\n\t\t: [-fov2d [Angle]] [-lockZup {0|1}]"
+ "\n\t\t: [-xrPose base|head=base]"
"\n\t\t: Manages camera parameters."
"\n\t\t: Displays frustum when presntation name PrsName is specified."
"\n\t\t: Prints current value when option called without argument."
"\n\t\t: Perspective camera:"
"\n\t\t: -persp activate perspective projection (mono)"
"\n\t\t: -fovy field of view in y axis, in degrees"
+ "\n\t\t: -fov2d field of view limit for 2d on-screen elements"
"\n\t\t: -distance distance of eye from camera center"
+ "\n\t\t: -lockZup lock Z up (tunrtable mode)"
"\n\t\t: Stereoscopic camera:"
"\n\t\t: -stereo perspective projection (stereo)"
"\n\t\t: -leftEye perspective projection (left eye)"
"\n -{linearAtten}uation value"
"\n -angle angleDeg"
"\n -{spotexp}onent value"
+ "\n -range value"
"\n -local|-global"
"\n\n example: vlight -add positional -head 1 -pos 0 1 1 -color red"
"\n example: vlight -change 0 -direction 0 -1 0 -linearAttenuation 0.2",
"\n '-gi on|off' Enables/disables global illumination effects"
"\n '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
"\n '-env on|off' Enables/disables environment map background"
+ "\n '-ignoreNormalMap on|off' Enables/disables normal map ignoring during path tracing"
"\n '-twoside on|off' Enables/disables two-sided BSDF models (PT mode)"
"\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
"\n '-issd on|off' Shows screen sampling distribution in ISS mode"
"\n '-exposure value' Exposure value for tone mapping (0.0 value disables the effect)"
"\n '-whitepoint value' White point value for filmic tone mapping"
"\n '-tonemapping mode' Tone mapping mode (disabled, filmic)"
- "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triagles|points"
+ "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triangles|points"
"\n ' |gpuMem|frameTime|basic|extended|full|nofps|skipImmediate'"
"\n Show/hide performance counters (flags can be combined)"
"\n '-perfUpdateInterval nbSeconds' Performance counters update interval"
theCommands.Add("vstatprofiler",
"\n vstatprofiler [fps|cpu|allLayers|layers|allstructures|structures|groups"
"\n |allArrays|fillArrays|lineArrays|pointArrays|textArrays"
- "\n |triagles|points|geomMem|textureMem|frameMem"
+ "\n |triangles|points|geomMem|textureMem|frameMem"
"\n |elapsedFrame|cpuFrameAverage|cpuPickingAverage|cpuCullingAverage|cpuDynAverage"
"\n |cpuFrameMax|cpuPickingMax|cpuCullingMax|cpuDynMax]"
"\n [-noredraw]"
theCommands.Add ("vseldump",
"vseldump file -type {depth|unnormDepth|object|owner|selMode|entity}=depth -pickedIndex Index=1"
+ "\n\t\t: [-xrPose base|head=base]"
"\n\t\t: Generate an image based on detection results:"
"\n\t\t: depth normalized depth values"
"\n\t\t: unnormDepth unnormalized depth values"
"\n\t\t: -boxCornerMinSize Value minimal box corner size"
"\n\t\t: -axesPadding Value padding between box and arrows"
"\n\t\t: -roundRadius Value relative radius of corners of sides within [0.0, 0.5] range"
+ "\n\t\t: -axesRadius Value radius of axes of the trihedron"
+ "\n\t\t: -axesConeRadius Value radius of the cone (arrow) of the trihedron"
+ "\n\t\t: -axesSphereRadius Value radius of the sphere (central point) of trihedron"
"\n\t\t: -fixedanimation {0|1} uninterruptible animation loop"
"\n\t\t: -duration Seconds animation duration in seconds",
__FILE__, VViewCube, group);
+ theCommands.Add("vcolorconvert" ,
+ "vcolorconvert {from|to} type C1 C2 C2"
+ "\n\t\t: vcolorconvert from type C1 C2 C2: Converts color from specified color space to linear RGB"
+ "\n\t\t: vcolorconvert to type R G B: Converts linear RGB color to specified color space"
+ "\n\t\t: type can be sRGB, HLS, Lab, or Lch",
+ __FILE__,VColorConvert,group);
+ theCommands.Add("vcolordiff" ,
+ "vcolordiff R1 G1 B1 R2 G2 B2: returns CIEDE2000 color difference between two RGB colors",
+ __FILE__,VColorDiff,group);
}
projects / occt.git / blobdiff