// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#ifdef HAVE_CONFIG_H
- #include <config.h>
-#endif
-
#include <OpenGl_GlCore20.hxx>
#include <AIS_Shape.hxx>
-#include <AIS_Drawer.hxx>
#include <AIS_InteractiveObject.hxx>
#include <AIS_ListOfInteractive.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_NameOfTextureEnv.hxx>
+#include <Graphic3d_GraduatedTrihedron.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <Graphic3d_TypeOfTextureFilter.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <ViewerTest.hxx>
+#include <ViewerTest_AutoUpdater.hxx>
#include <ViewerTest_EventManager.hxx>
#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx>
#include <V3d_AmbientLight.hxx>
+#include <V3d_ColorScale.hxx>
#include <V3d_DirectionalLight.hxx>
#include <V3d_LayerMgr.hxx>
#include <V3d_LayerMgrPointer.hxx>
#include <NCollection_DoubleMap.hxx>
#include <NCollection_List.hxx>
#include <NCollection_Vector.hxx>
-#include <NIS_View.hxx>
-#include <NIS_Triangulated.hxx>
-#include <NIS_InteractiveContext.hxx>
#include <AIS_InteractiveContext.hxx>
#include <Draw_Interpretor.hxx>
#include <Draw.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Image_Diff.hxx>
#include <Aspect_DisplayConnection.hxx>
-#include <Graphic3d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Dir.hxx>
#include <gp_Pln.hxx>
#include <NCollection_DataMap.hxx>
#include <Graphic3d_Texture2Dmanual.hxx>
#include <Prs3d_ShadingAspect.hxx>
+#include <Prs3d_Drawer.hxx>
#ifdef WNT
#undef DrawText
#include <tk.h>
#endif
+inline Standard_Boolean parseOnOff (Standard_CString theArg,
+ Standard_Boolean& theIsOn)
+{
+ TCollection_AsciiString aFlag (theArg);
+ aFlag.LowerCase();
+ if (aFlag == "on"
+ || aFlag == "1")
+ {
+ theIsOn = Standard_True;
+ return Standard_True;
+ }
+ else if (aFlag == "off"
+ || aFlag == "0")
+ {
+ theIsOn = Standard_False;
+ return Standard_True;
+ }
+ return Standard_False;
+}
+
// Auxiliary definitions
static const char THE_KEY_DELETE = 127;
Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
-extern const Handle(NIS_InteractiveContext)& TheNISContext();
extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
extern int VErase (Draw_Interpretor& theDI,
int X_ButtonPress = 0; // Last ButtonPress position
int Y_ButtonPress = 0;
Standard_Boolean IsDragged = Standard_False;
-Standard_Boolean DragFirst;
+Standard_Boolean DragFirst = Standard_False;
//==============================================================================
#endif
VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
- // NIS setup
- Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
+ // View setup
+ Handle(V3d_View) aView = a3DViewer->CreateView();
+ aView->SetWindow (VT_GetWindow());
ViewerTest::CurrentView(aView);
ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
- TheNISContext()->AttachView (aView);
// Setup for X11 or NT
OSWindowSetup();
{
continue;
}
- aShape->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
}
}
}
if (aShape->TypeOfHLR() != aTypeOfHLR)
aShape->SetTypeOfHLR (aTypeOfHLR);
if (MyHLRIsOn)
- aShape->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
}
ViewerTest::CurrentView()->Update();
return 0;
continue;
anAISObject->SetTypeOfHLR (aTypeOfHLR);
if (MyHLRIsOn)
- anAISObject->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (anAISObject, Standard_False);
}
ViewerTest::CurrentView()->Update();
}
}
}
+//==============================================================================
+//function : RemoveView
+//purpose :
+//==============================================================================
+void ViewerTest::RemoveView (const Handle(V3d_View)& theView,
+ const Standard_Boolean theToRemoveContext)
+{
+ if (!ViewerTest_myViews.IsBound2 (theView))
+ {
+ return;
+ }
+
+ const TCollection_AsciiString aViewName = ViewerTest_myViews.Find2 (theView);
+ RemoveView (aViewName, theToRemoveContext);
+}
+
//==============================================================================
//function : RemoveView
//purpose : Close and remove view from display, clear maps if neccessary
Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
// Remove view resources
- TheNISContext()->DetachView(Handle(NIS_View)::DownCast(aView));
ViewerTest_myViews.UnBind1(theViewName);
aView->Remove();
{
//cout << "KeyPress" << endl;
const Handle(V3d_View) aView = ViewerTest::CurrentView();
- const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
// Letter in alphabetic order
if (!strcasecmp (buf_ret, "A"))
}
else if (!strcasecmp (buf_ret, "F"))
{
- // FitAll
- if (aNisView.IsNull())
- aView->FitAll();
+ if (ViewerTest::GetAISContext()->NbSelected() > 0)
+ {
+ ViewerTest::GetAISContext()->FitSelected (aView);
+ }
else
- aNisView->FitAll3d();
+ {
+ // FitAll
+ aView->FitAll();
+ }
}
else if (!strcasecmp (buf_ret, "H"))
{
aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
else
aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
- aShape->Redisplay();
+ aContext->Redisplay (aShape, Standard_False);
}
}
else
aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
else
aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
- aShape->Redisplay();
+ aContext->Redisplay (aShape, Standard_False);
}
}
{
ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
}
+ else if (!strcasecmp (buf_ret, "/"))
+ {
+ Handle(Graphic3d_Camera) aCamera = aView->Camera();
+ if (aCamera->IsStereo())
+ {
+ aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() - 0.01);
+ aView->Redraw();
+ }
+ }
+ else if (!strcasecmp (buf_ret, "*"))
+ {
+ Handle(Graphic3d_Camera) aCamera = aView->Camera();
+ if (aCamera->IsStereo())
+ {
+ aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() + 0.01);
+ aView->Redraw();
+ }
+ }
else if (*buf_ret == THE_KEY_DELETE)
{
Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
if (theIsShift)
{
- EM->ShiftSelect (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
- Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+ EM->ShiftSelect (X_ButtonPress, Y_ButtonPress,
+ X_Motion, Y_Motion);
}
else
{
- EM->Select (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
- Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+ EM->Select (X_ButtonPress, Y_ButtonPress,
+ X_Motion, Y_Motion);
}
}
}
{
Handle(V3d_View) a3DView = ViewerTest::CurrentView();
if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
- static Standard_Real CurZPos = 0.;
//Quantity_Length VDX, VDY;
//a3DView->Size(VDX,VDY);
//Standard_Real VDZ = a3DView->ZSize();
//printf("View size (%lf,%lf,%lf)\n", VDX, VDY, VDZ);
- Quantity_Length dx = a3DView->Convert(X_Motion - X_ButtonPress);
+ Quantity_Length aDx = a3DView->Convert(X_Motion - X_ButtonPress);
// Front = Depth + width/2.
- Standard_Real D = 0.5;
- Standard_Real W = 0.1;
+ Standard_Real aDepth = 0.5;
+ Standard_Real aWidth = 0.1;
+ a3DView->ZClipping(aDepth,aWidth);
- CurZPos += (dx);
-
- D += CurZPos;
+ aDepth += aDx;
//printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
- a3DView->SetZClippingType(V3d_OFF);
- a3DView->SetZClippingDepth(D);
- a3DView->SetZClippingWidth(W);
- a3DView->SetZClippingType(V3d_FRONT);
+ a3DView->SetZClippingDepth(aDepth);
a3DView->Redraw();
}
break;
case WM_LBUTTONUP:
- IsDragged = Standard_False;
- if( !DragFirst )
+ if (!DragFirst)
{
HDC hdc = GetDC( hwnd );
SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
SetROP2( hdc, R2_NOT );
Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
ReleaseDC( hwnd, hdc );
-
- const Handle(ViewerTest_EventManager) EM =
- ViewerTest::CurrentEventManager();
- if ( fwKeys & MK_SHIFT )
- EM->ShiftSelect( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
- max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
- else
- EM->Select( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
- max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
+ VT_ProcessButton1Release (fwKeys & MK_SHIFT);
}
+ IsDragged = Standard_False;
return ViewerWindowProc( hwnd, Msg, wParam, lParam );
case WM_LBUTTONDOWN:
LPARAM lParam )
{
static int Up = 1;
+ const Handle(V3d_View)& aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ return DefWindowProc( hwnd, Msg, wParam, lParam );
+ }
- if ( !ViewerTest::CurrentView().IsNull() ) {
PAINTSTRUCT ps;
switch( Msg ) {
case WM_SIZE:
VT_ProcessConfigure();
break;
+ case WM_MOVE:
+ case WM_MOVING:
+ case WM_SIZING:
+ switch (aView->RenderingParams().StereoMode)
+ {
+ case Graphic3d_StereoMode_RowInterlaced:
+ case Graphic3d_StereoMode_ColumnInterlaced:
+ case Graphic3d_StereoMode_ChessBoard:
+ VT_ProcessConfigure(); // track window moves to reverse stereo pair
+ break;
+ default:
+ break;
+ }
+ break;
case WM_KEYDOWN:
if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
{
c[0] = THE_KEY_DELETE;
}
+ // comma
+ else if (wParam == VK_OEM_COMMA)
+ {
+ c[0] = ',';
+ }
+ // dot
+ else if (wParam == VK_OEM_PERIOD)
+ {
+ c[0] = '.';
+ }
+ else if (wParam == VK_DIVIDE)
+ {
+ c[0] = '/';
+ }
+ // dot
+ else if (wParam == VK_MULTIPLY)
+ {
+ c[0] = '*';
+ }
VT_ProcessKeyPress (c);
}
break;
}
break;
+ case WM_MOUSEWHEEL:
+ {
+ int aDelta = GET_WHEEL_DELTA_WPARAM (wParam);
+ if (wParam & MK_CONTROL)
+ {
+ if (aView->Camera()->IsStereo())
+ {
+ Standard_Real aFocus = aView->Camera()->ZFocus() + (aDelta > 0 ? 0.05 : -0.05);
+ if (aFocus > 0.2
+ && aFocus < 2.0)
+ {
+ aView->Camera()->SetZFocus (aView->Camera()->ZFocusType(), aFocus);
+ aView->Redraw();
+ }
+ }
+ }
+ else
+ {
+ aView->Zoom (0, 0, aDelta / 40, aDelta / 40);
+ }
+ break;
+ }
+
case WM_MOUSEMOVE:
{
//cout << "\t WM_MOUSEMOVE" << endl;
return( DefWindowProc( hwnd, Msg, wParam, lParam ));
}
return 0L;
- }
-
- return DefWindowProc( hwnd, Msg, wParam, lParam );
}
switch (aReport.type) {
case ClientMessage:
{
- if(aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
+ if((Atom)aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
{
// Close the window
ViewerTest::RemoveView(FindViewIdByWindowHandle (aReport.xclient.window));
}
-
//==============================================================================
//function : VFit
//Draw arg : No args
//==============================================================================
-static int VFit(Draw_Interpretor& , Standard_Integer , const char** )
+static int VFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgc, const char** theArgv)
{
+ if (theArgc > 2)
+ {
+ std::cout << "Wrong number of arguments! Use: vfit [-selected]" << std::endl;
+ }
+
const Handle(V3d_View) aView = ViewerTest::CurrentView();
- Handle(NIS_View) V = Handle(NIS_View)::DownCast(aView);
- if (V.IsNull() == Standard_False) {
- V->FitAll3d();
- } else if (aView.IsNull() == Standard_False) {
+
+ if (theArgc == 2)
+ {
+ TCollection_AsciiString anArg (theArgv[1]);
+ anArg.LowerCase();
+ if (anArg == "-selected")
+ {
+ ViewerTest::GetAISContext()->FitSelected (aView);
+ return 0;
+ }
+ }
+ if (aView.IsNull() == Standard_False) {
+
aView->FitAll();
}
return 0;
}
+//=======================================================================
+//function : VFitArea
+//purpose : Fit view to show area located between two points
+// : given in world 2D or 3D coordinates.
+//=======================================================================
+static int VFitArea (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << theArgVec[0] << "Error: No active view.\n";
+ return 1;
+ }
+
+ // Parse arguments.
+ gp_Pnt aWorldPnt1 (0.0, 0.0, 0.0);
+ gp_Pnt aWorldPnt2 (0.0, 0.0, 0.0);
+
+ if (theArgNb == 5)
+ {
+ aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
+ aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
+ aWorldPnt2.SetX (Draw::Atof (theArgVec[3]));
+ aWorldPnt2.SetY (Draw::Atof (theArgVec[4]));
+ }
+ else if (theArgNb == 7)
+ {
+ aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
+ aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
+ aWorldPnt1.SetZ (Draw::Atof (theArgVec[3]));
+ aWorldPnt2.SetX (Draw::Atof (theArgVec[4]));
+ aWorldPnt2.SetY (Draw::Atof (theArgVec[5]));
+ aWorldPnt2.SetZ (Draw::Atof (theArgVec[6]));
+ }
+ else
+ {
+ std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
+ theDI.PrintHelp(theArgVec[0]);
+ return 1;
+ }
+
+ // Convert model coordinates to view space
+ Handle(Graphic3d_Camera) aCamera = aView->Camera();
+ gp_Pnt aViewPnt1 = aCamera->ConvertWorld2View (aWorldPnt1);
+ gp_Pnt aViewPnt2 = aCamera->ConvertWorld2View (aWorldPnt2);
+
+ // Determine fit area
+ gp_Pnt2d aMinCorner (Min (aViewPnt1.X(), aViewPnt2.X()), Min (aViewPnt1.Y(), aViewPnt2.Y()));
+ gp_Pnt2d aMaxCorner (Max (aViewPnt1.X(), aViewPnt2.X()), Max (aViewPnt1.Y(), aViewPnt2.Y()));
+
+ Standard_Real aDiagonal = aMinCorner.Distance (aMaxCorner);
+
+ if (aDiagonal < Precision::Confusion())
+ {
+ std::cerr << theArgVec[0] << "Error: view area is too small.\n";
+ return 1;
+ }
+
+ aView->FitAll (aMinCorner.X(), aMinCorner.Y(), aMaxCorner.X(), aMaxCorner.Y());
+ return 0;
+}
+
//==============================================================================
//function : VZFit
//purpose : ZFitall, no DRAW arguments
if (theArgsNb == 1)
{
- aCurrentView->ZFitAll();
+ aCurrentView->View()->ZFitAll();
aCurrentView->Redraw();
return 0;
}
aScale = Draw::Atoi (theArgVec[1]);
}
- aCurrentView->ZFitAll (aScale);
+ aCurrentView->View()->ZFitAll (aScale);
aCurrentView->Redraw();
return 0;
return 0;
}
-//==============================================================================
-//function : InitViewerTest
-//purpose : initialisation de toutes les variables static de ViewerTest (dp)
-//==============================================================================
-
-void ViewerTest_InitViewerTest (const Handle(AIS_InteractiveContext)& theContext)
-{
- Handle(V3d_Viewer) aViewer = theContext->CurrentViewer();
- ViewerTest::SetAISContext(theContext);
- aViewer->InitActiveViews();
- Handle(V3d_View) aView = aViewer->ActiveView();
- if (aViewer->MoreActiveViews()) ViewerTest::CurrentView(aView);
- ViewerTest::ResetEventManager();
- Handle(Aspect_Window) aWindow = aView->Window();
-#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
- // X11
- VT_GetWindow() = Handle(Xw_Window)::DownCast(aWindow);
- OSWindowSetup();
- static int aFirst = 1;
- if ( aFirst ) {
-#if TCL_MAJOR_VERSION < 8
- Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
- TK_READABLE, VProcessEvents, (ClientData) 0);
-#else
- Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
- TK_READABLE, VProcessEvents, (ClientData) 0);
-#endif
- aFirst = 0;
- }
-#endif
-}
-
//==============================================================================
//function : VSetBg
//purpose : Load image as background
return 0;
}
//==============================================================================
-//function : VTestZBuffTrihedron
-//purpose : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
+//function : VZBuffTrihedron
+//purpose :
//==============================================================================
-static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+static int VZBuffTrihedron (Draw_Interpretor& /*theDI*/,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
- Handle(V3d_View) V3dView = ViewerTest::CurrentView();
- if ( V3dView.IsNull() ) return 1;
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cout << "Error: no active viewer!\n";
+ return 1;
+ }
- V3dView->ZBufferTriedronSetup();
+ ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
- if ( argc == 1 ) {
- // Set up default trihedron parameters
- V3dView->TriedronDisplay( Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.1, V3d_ZBUFFER );
- } else
- if ( argc == 7 )
+ Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
+ V3d_TypeOfVisualization aVisType = V3d_ZBUFFER;
+ Quantity_Color aLabelsColor = Quantity_NOC_WHITE;
+ Quantity_Color anArrowColorX = Quantity_NOC_RED;
+ Quantity_Color anArrowColorY = Quantity_NOC_GREEN;
+ Quantity_Color anArrowColorZ = Quantity_NOC_BLUE1;
+ Standard_Real aScale = 0.1;
+ Standard_Real aSizeRatio = 0.8;
+ Standard_Real anArrowDiam = 0.05;
+ Standard_Integer aNbFacets = 12;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
- const char* aPosType = argv[1];
-
- if ( strcmp(aPosType, "center") == 0 )
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
{
- aPosition = Aspect_TOTP_CENTER;
- } else
- if (strcmp(aPosType, "left_lower") == 0)
+ continue;
+ }
+ else if (aFlag == "-on")
{
- aPosition = Aspect_TOTP_LEFT_LOWER;
- } else
- if (strcmp(aPosType, "left_upper") == 0)
+ continue;
+ }
+ else if (aFlag == "-off")
{
- aPosition = Aspect_TOTP_LEFT_UPPER;
- } else
- if (strcmp(aPosType, "right_lower") == 0)
+ aView->TriedronErase();
+ return 0;
+ }
+ else if (aFlag == "-pos"
+ || aFlag == "-position"
+ || aFlag == "-corner")
{
- aPosition = Aspect_TOTP_RIGHT_LOWER;
- } else
- if (strcmp(aPosType, "right_upper") == 0)
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aPosName (theArgVec[anArgIter]);
+ aPosName.LowerCase();
+ if (aPosName == "center")
+ {
+ aPosition = Aspect_TOTP_CENTER;
+ }
+ else if (aPosName == "left_lower"
+ || aPosName == "lower_left"
+ || aPosName == "leftlower"
+ || aPosName == "lowerleft")
+ {
+ aPosition = Aspect_TOTP_LEFT_LOWER;
+ }
+ else if (aPosName == "left_upper"
+ || aPosName == "upper_left"
+ || aPosName == "leftupper"
+ || aPosName == "upperleft")
+ {
+ aPosition = Aspect_TOTP_LEFT_UPPER;
+ }
+ else if (aPosName == "right_lower"
+ || aPosName == "lower_right"
+ || aPosName == "rightlower"
+ || aPosName == "lowerright")
+ {
+ aPosition = Aspect_TOTP_RIGHT_LOWER;
+ }
+ else if (aPosName == "right_upper"
+ || aPosName == "upper_right"
+ || aPosName == "rightupper"
+ || aPosName == "upperright")
+ {
+ aPosition = Aspect_TOTP_RIGHT_UPPER;
+ }
+ else
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-type")
{
- aPosition = Aspect_TOTP_RIGHT_UPPER;
- } else
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aTypeName (theArgVec[anArgIter]);
+ aTypeName.LowerCase();
+ if (aTypeName == "wireframe"
+ || aTypeName == "wire")
+ {
+ aVisType = V3d_WIREFRAME;
+ }
+ else if (aTypeName == "zbuffer"
+ || aTypeName == "shaded")
+ {
+ aVisType = V3d_ZBUFFER;
+ }
+ else
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
+ }
+ }
+ else if (aFlag == "-scale")
{
- di << argv[1] << " Invalid type of alignment" << "\n";
- di << "Must be one of [ center, left_lower," << "\n";
- di << "left_upper, right_lower, right_upper ]" << "\n";
- return 1;
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ aScale = Draw::Atof (theArgVec[anArgIter]);
}
+ else if (aFlag == "-size"
+ || aFlag == "-sizeratio")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- Standard_Real R = Draw::Atof(argv[2])/255.;
- Standard_Real G = Draw::Atof(argv[3])/255.;
- Standard_Real B = Draw::Atof(argv[4])/255.;
- Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
+ aSizeRatio = Draw::Atof (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-arrowdiam"
+ || aFlag == "-arrowdiameter")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- Standard_Real aScale = Draw::Atof(argv[5]);
+ anArrowDiam = Draw::Atof (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-nbfacets")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- if( aScale <= 0.0 )
+ aNbFacets = Draw::Atoi (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-colorlabel"
+ || aFlag == "-colorlabels")
{
- di << argv[5] << " Invalid value. Must be > 0" << "\n";
- return 1;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ aLabelsColor);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
}
-
- V3d_TypeOfVisualization aPresentation = V3d_ZBUFFER;
- const char* aPresType = argv[6];
-
- if ( strcmp(aPresType, "wireframe") == 0 )
+ else if (aFlag == "-colorarrowx")
+ {
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorX);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else if (aFlag == "-colorarrowy")
{
- aPresentation = V3d_WIREFRAME;
- } else
- if (strcmp(aPresType, "zbuffer") == 0)
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorY);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else if (aFlag == "-colorarrowz")
{
- aPresentation = V3d_ZBUFFER;
- } else
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorZ);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else
{
- di << argv[6] << " Invalid type of visualization" << "\n";
- di << "Must be one of [ wireframe, zbuffer ]" << "\n";
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
return 1;
}
-
- V3dView->TriedronDisplay( aPosition, aColor.Name(), aScale, aPresentation );
-
- } else
- {
- di << argv[0] << " Invalid number of arguments" << "\n";
- return 1;
}
- V3dView->ZFitAll();
-
+ aView->ZBufferTriedronSetup (anArrowColorX.Name(), anArrowColorY.Name(), anArrowColorZ.Name(),
+ aSizeRatio, anArrowDiam, aNbFacets);
+ aView->TriedronDisplay (aPosition, aLabelsColor.Name(), aScale, aVisType);
+ aView->View()->ZFitAll();
return 0;
}
//purpose : Camera Rotating
//==============================================================================
-static int VRotate( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
- Handle(V3d_View) V3dView = ViewerTest::CurrentView();
- if ( V3dView.IsNull() ) {
+static int VRotate (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cout << "No active view!\n";
return 1;
}
- if ( argc == 4 ) {
- V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
+ Standard_Boolean hasFlags = Standard_False;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg (theArgVec[anArgIter]);
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (aFlag == "-mousestart"
+ || aFlag == "-mousefrom")
+ {
+ hasFlags = Standard_True;
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+ Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+ aView->StartRotation (anX, anY);
+ }
+ else if (aFlag == "-mousemove")
+ {
+ hasFlags = Standard_True;
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+ Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+ aView->Rotation (anX, anY);
+ }
+ else if (theArgNb != 4
+ && theArgNb != 7)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ }
+
+ if (hasFlags)
+ {
return 0;
- } else if ( argc == 7 ) {
- V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]) );
+ }
+ else if (theArgNb == 4)
+ {
+ Standard_Real anAX = Draw::Atof (theArgVec[1]);
+ Standard_Real anAY = Draw::Atof (theArgVec[2]);
+ Standard_Real anAZ = Draw::Atof (theArgVec[3]);
+ aView->Rotate (anAX, anAY, anAZ);
return 0;
- } else {
- di << argv[0] << " Invalid number of arguments" << "\n";
- return 1;
}
-}
+ else if (theArgNb == 7)
+ {
+ Standard_Real anAX = Draw::Atof (theArgVec[1]);
+ Standard_Real anAY = Draw::Atof (theArgVec[2]);
+ Standard_Real anAZ = Draw::Atof (theArgVec[3]);
-//==============================================================================
+ Standard_Real anX = Draw::Atof (theArgVec[4]);
+ Standard_Real anY = Draw::Atof (theArgVec[5]);
+ Standard_Real anZ = Draw::Atof (theArgVec[6]);
+
+ aView->Rotate (anAX, anAY, anAZ, anX, anY, anZ);
+ return 0;
+ }
+
+ std::cout << "Error: Invalid number of arguments\n";
+ return 1;
+}
+
+//==============================================================================
//function : VZoom
//purpose : View zoom in / out (relative to current zoom)
//==============================================================================
}
}
+//==============================================================================
+//function : VPlace
+//purpose : Place the point (in pixels) at the center of the window
+//==============================================================================
+static int VPlace (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgs)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << theArgs[0] << "Error: no active view." << std::endl;
+ return 1;
+ }
+
+ if (theArgNb != 3)
+ {
+ std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
+ return 1;
+ }
+
+ aView->Place (Draw::Atoi (theArgs[1]), Draw::Atoi (theArgs[2]), aView->Scale());
+
+ return 0;
+}
//==============================================================================
//function : VExport
//function : VColorScale
//purpose : representation color scale
//==============================================================================
-#include <V3d_ColorScale.hxx>
-static int VColorScale (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
+static Standard_Boolean checkColor (const TCollection_AsciiString& theRed,
+ const TCollection_AsciiString& theGreen,
+ const TCollection_AsciiString& theBlue,
+ Standard_Real& theRedValue,
+ Standard_Real& theGreenValue,
+ Standard_Real& theBlueValue)
{
- if ( argc != 1 && argc != 4 && argc != 5 && argc != 6 && argc != 8 )
+ if (!theRed.IsRealValue()
+ || !theGreen.IsRealValue()
+ || !theBlue.IsRealValue())
{
- di << "Usage : " << argv[0] << " [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = Right X = 0 Y = 0] " << "\n";
- return 1;
+ std::cout << "Error: RGB color values should be real!\n";
+ return Standard_True;
+ }
+ theRedValue = theRed .RealValue();
+ theGreenValue = theGreen.RealValue();
+ theBlueValue = theBlue .RealValue();
+ if (theRedValue < 0.0 || theRedValue > 1.0
+ || theGreenValue < 0.0 || theGreenValue > 1.0
+ || theBlueValue < 0.0 || theBlueValue > 1.0)
+ {
+ std::cout << "Error: RGB color values should be within range 0..1!\n";
+ return Standard_True;
}
+ return Standard_False;
+}
+static int VColorScale (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- if(aContext.IsNull()) {
- di << argv[0] << " ERROR : use 'vinit' command before " << "\n";
- return -1;
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aContext.IsNull())
+ {
+ std::cout << "Error: no active view!\n";
+ return 1;
}
- Standard_Real minRange = 0. , maxRange = 100. ;
-
- Standard_Integer numIntervals = 10 ;
- Standard_Integer textHeight = 16;
- Aspect_TypeOfColorScalePosition position = Aspect_TOCSP_RIGHT;
- Standard_Real X = 0., Y = 0. ;
-
- if ( argc < 9 )
- {
- if( argc > 3 )
- {
- minRange = Draw::Atof( argv[1] );
- maxRange = Draw::Atof( argv[2] );
- numIntervals = Draw::Atoi( argv[3] );
- }
- if ( argc > 4 )
- textHeight = Draw::Atoi( argv[4] );
- if ( argc > 5 )
- position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
- if ( argc > 7 )
- {
- X = Draw::Atof( argv[6] );
- Y = Draw::Atof( argv[7] );
- }
- }
- Handle(V3d_View) curView = ViewerTest::CurrentView( );
- if ( curView.IsNull( ) )
+ Handle(V3d_ColorScale) aCS = Handle(V3d_ColorScale)::DownCast (aView->ColorScale());
+ if (aCS.IsNull())
+ {
+ std::cout << "Error: color scale is undefined!\n";
return 1;
- Handle(Aspect_ColorScale) aCSV = curView->ColorScale( );
- Handle(V3d_ColorScale) aCS = ( Handle( V3d_ColorScale )::DownCast( aCSV ) );
- if( ! aCS.IsNull( ) )
- {
- aCS->SetPosition( X , Y );
- aCS->SetHeight( 0.95) ;
- aCS->SetTextHeight( textHeight );
- aCS->SetRange( minRange , maxRange );
- aCS->SetNumberOfIntervals( numIntervals );
- aCS->SetLabelPosition( position );
- if( !curView->ColorScaleIsDisplayed() )
- curView->ColorScaleDisplay( );
}
- return 0;
-}
-//==============================================================================
-//function : VGraduatedTrihedron
-//purpose : Displays a graduated trihedron
-//==============================================================================
+ Standard_Real aMinRange = aCS->GetMin();
+ Standard_Real aMaxRange = aCS->GetMax();
+ Standard_Integer aNbIntervals = aCS->GetNumberOfIntervals();
+ Standard_Integer aTextHeight = aCS->GetTextHeight();
+ Aspect_TypeOfColorScalePosition aLabPosition = aCS->GetLabelPosition();
+ gp_XY aPos (aCS->GetXPosition(), aCS->GetYPosition());
-static void AddMultibyteString (TCollection_ExtendedString &name, const char *arg)
-{
- const char *str = arg;
- while (*str)
+ ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
+
+ if (theArgNb <= 1)
{
- unsigned short c1 = *str++;
- unsigned short c2 = *str++;
- if (!c1 || !c2) break;
- name += (Standard_ExtCharacter)((c1 << 8) | c2);
+ theDI << "Current color scale parameters:\n"
+ << "Min range: " << aMinRange << "\n"
+ << "Max range: " << aMaxRange << "\n"
+ << "Number of intervals: " << aNbIntervals << "\n"
+ << "Text height: " << aTextHeight << "\n"
+ << "Color scale position: " << aPos.X() <<" "<< aPos.Y()<< "\n"
+ << "Color scale title: " << aCS->GetTitle() << "\n"
+ << "Label position: ";
+ switch (aLabPosition)
+ {
+ case Aspect_TOCSP_NONE:
+ theDI << "None\n";
+ break;
+ case Aspect_TOCSP_LEFT:
+ theDI << "Left\n";
+ break;
+ case Aspect_TOCSP_RIGHT:
+ theDI << "Right\n";
+ break;
+ case Aspect_TOCSP_CENTER:
+ theDI << "Center\n";
+ break;
+ }
+ return 0;
}
-}
-
-static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
-{
- // Check arguments
- if (argc != 2 && argc < 5)
+ Standard_CString aFirstArg = theArgVec[1];
+ TCollection_AsciiString aFlag (aFirstArg);
+ aFlag.LowerCase();
+ if (aFlag == "-hide" ||
+ aFlag == "-erase")
{
- di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
- di<<"Usage: type help "<<argv[0]<<"\n";
- return 1; //TCL_ERROR
+ if (theArgNb > 2)
+ {
+ std::cout << "Error: wrong syntax at argument '" << theArgVec[1] << "'!\n";
+ return 1;
+ }
+ if (!aView->ColorScaleIsDisplayed())
+ {
+ std::cout << "Error: color scale is not displayed!\n";
+ return 1;
+ }
+ else
+ {
+ aView->ColorScaleErase();
+ return 0;
+ }
}
-
- Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
-
- // Create 3D view if it doesn't exist
- if ( aV3dView.IsNull() )
+ else if (aFlag == "-show" ||
+ aFlag == "-display")
{
- ViewerTest::ViewerInit();
- aV3dView = ViewerTest::CurrentView();
- if( aV3dView.IsNull() )
+ if (theArgNb > 2)
{
- di << "Error: Cannot create a 3D view\n";
- return 1; //TCL_ERROR
+ std::cout << "Error: wrong syntax at argument '" << theArgVec[1] << "'!\n";
+ return 1;
}
+ aView->ColorScaleDisplay();
+ return 0;
}
- // Erase (==0) or display (!=0)
- const int display = Draw::Atoi(argv[1]);
-
- if (display)
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- // Text font
- TCollection_AsciiString font;
- if (argc < 6)
- font.AssignCat("Courier");
- else
- font.AssignCat(argv[5]);
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
+ {
+ continue;
+ }
+ else if (aFlag == "-range")
+ {
+ if (anArgIter + 3 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString anArg1 (theArgVec[++anArgIter]);
+ TCollection_AsciiString anArg2 (theArgVec[++anArgIter]);
+ TCollection_AsciiString anArg3 (theArgVec[++anArgIter]);
+ if (!anArg1.IsRealValue())
+ {
+ std::cout << "Error: the minRange value should be real!\n";
+ return 1;
+ }
+ else if (!anArg2.IsRealValue())
+ {
+ std::cout << "Error: the maxRange value should be real!\n";
+ return 1;
+ }
+ else if (!anArg3.IsIntegerValue())
+ {
+ std::cout << "Error: the number of intervals should be integer!\n";
+ return 1;
+ }
- // Text is multibyte
- const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
+ aMinRange = anArg1.RealValue();
+ aMaxRange = anArg2.RealValue();
+ aNbIntervals = anArg3.IntegerValue();
+ }
+ else if (aFlag == "-font")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ TCollection_AsciiString anArg (theArgVec[anArgIter + 1]);
+ if (!anArg.IsIntegerValue())
+ {
+ std::cout << "Error: HeightFont value should be integer!\n";
+ return 1;
+ }
- // Set axis names
- TCollection_ExtendedString xname, yname, zname;
- if (argc >= 5)
+ aTextHeight = anArg.IntegerValue();
+ anArgIter += 1;
+ }
+ else if (aFlag == "-textpos")
{
- if (isMultibyte)
+ if (anArgIter + 1 >= theArgNb)
{
- AddMultibyteString(xname, argv[2]);
- AddMultibyteString(yname, argv[3]);
- AddMultibyteString(zname, argv[4]);
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ TCollection_AsciiString anArg (theArgVec[++anArgIter]);
+ anArg.LowerCase();
+ if (anArg == "none")
+ {
+ aLabPosition = Aspect_TOCSP_NONE;
+ }
+ else if (anArg == "left")
+ {
+ aLabPosition = Aspect_TOCSP_LEFT;
+ }
+ else if (anArg == "right")
+ {
+ aLabPosition = Aspect_TOCSP_RIGHT;
+ }
+ else if (anArg == "center")
+ {
+ aLabPosition = Aspect_TOCSP_CENTER;
}
else
{
- xname += argv[2];
- yname += argv[3];
- zname += argv[4];
+ std::cout << "Error: unknown position '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-xy")
+ {
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aX (theArgVec[++anArgIter]);
+ TCollection_AsciiString aY (theArgVec[++anArgIter]);
+ if (!aX.IsRealValue()
+ || !aY.IsRealValue())
+ {
+ std::cout << "Error: coordinates should be real values!\n";
+ return 1;
+ }
+
+ aPos.SetCoord (aX.RealValue(), aY.RealValue());
+ }
+ else if (aFlag == "-color")
+ {
+ if (aCS->GetColorType() != Aspect_TOCSD_USER)
+ {
+ std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
+ return 1;
+ }
+
+ Quantity_NameOfColor aColorName;
+ if (anArgIter + 4 >= theArgNb)
+ {
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ else if (!Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+ {
+ std::cout << "Error: wrong color name: '" << theArgVec[anArgIter + 2] << "' !\n";
+ return 1;
+ }
+ }
+
+ TCollection_AsciiString anInd (theArgVec[anArgIter + 1]);
+ if (!anInd.IsIntegerValue())
+ {
+ std::cout << "Error: Index value should be integer!\n";
+ return 1;
+ }
+
+ Standard_Integer anIndex = anInd.IntegerValue();
+ if (anIndex < 0
+ || anIndex > aNbIntervals - 1)
+ {
+ std::cout << "Error: Index value should be within range 0..." << (aNbIntervals - 1) <<"!\n";
+ return 1;
+ }
+
+ if (Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+ {
+ aCS->SetColor (Quantity_Color (aColorName), anIndex);
+ aCS->SetColorType(Aspect_TOCSD_USER);
+ anArgIter += 2;
+ continue;
+ }
+
+ TCollection_AsciiString aRed (theArgVec[anArgIter + 2]);
+ TCollection_AsciiString aGreen (theArgVec[anArgIter + 3]);
+ TCollection_AsciiString aBlue (theArgVec[anArgIter + 4]);
+ Standard_Real aRedValue,aGreenValue, aBlueValue;
+ if(checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+ {
+ return 1;
+ }
+ aCS->SetColor (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB), anIndex);
+ aCS->SetColorType (Aspect_TOCSD_USER);
+ anArgIter += 4;
+ }
+ else if (aFlag == "-label")
+ {
+ if (aCS->GetColorType() != Aspect_TOCSD_USER)
+ {
+ std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
+ return 1;
+ }
+ else if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
+ if (anIndex < 0
+ || anIndex > aNbIntervals)
+ {
+ std::cout << "Error: Index value should be within range 0..." << aNbIntervals <<"!\n";
+ return 1;
+ }
+
+ TCollection_ExtendedString aText (theArgVec[anArgIter + 2]);
+ aCS->SetLabel (aText, anIndex);
+ aCS->SetLabelType (Aspect_TOCSD_USER);
+ anArgIter += 2;
+ }
+ else if (aFlag == "-colors")
+ {
+ Aspect_SequenceOfColor aSeq;
+ if (anArgIter + aNbIntervals + 1 > theArgNb)
+ {
+ std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aNbIntervals << " intervals\n";
+ return 1;
+ }
+
+ Standard_Integer aColorIter = anArgIter + 1;
+ while (aColorIter < theArgNb)
+ {
+ if (theArgVec[aColorIter][0] == '-')
+ {
+ break;
+ }
+
+ else if (theArgVec[aColorIter][0] >= 97
+ && theArgVec[aColorIter][0] <= 122)
+ {
+ Quantity_NameOfColor aColorName;
+ if (!Quantity_Color::ColorFromName (theArgVec[aColorIter], aColorName))
+ {
+ std::cout << "Error: wrong color name: " << theArgVec[aColorIter] << " !\n";
+ return 1;
+ }
+ aSeq.Append (Quantity_Color (aColorName));
+ aColorIter++;
+ anArgIter++;
+ }
+ else
+ {
+ TCollection_AsciiString aRed (theArgVec[aColorIter]);
+ TCollection_AsciiString aGreen (theArgVec[aColorIter + 1]);
+ TCollection_AsciiString aBlue (theArgVec[aColorIter + 2]);
+ Standard_Real aRedValue,aGreenValue, aBlueValue;
+ if (checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+ {
+ return 1;
+ }
+ aSeq.Append (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB));
+ aColorIter += 3;
+ anArgIter += 3;
+ }
+ }
+ if (aSeq.Length() < aNbIntervals)
+ {
+ std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aNbIntervals << " intervals\n";
+ return 1;
+ }
+
+ aCS->SetColors (aSeq);
+ aCS->SetColorType (Aspect_TOCSD_USER);
+ }
+ else if (aFlag == "-labels")
+ {
+ if (anArgIter + aNbIntervals + 1 >= theArgNb)
+ {
+ std::cout << "Error: not enough arguments! You should provide " << (aNbIntervals + 1)
+ << " text labels for " << aNbIntervals << " intervals.\n";
+ return 1;
+ }
+
+ TColStd_SequenceOfExtendedString aSeq;
+ for (int aLabelIter = anArgIter + 1; aLabelIter <= anArgIter + aNbIntervals + 1; aLabelIter += 1)
+ {
+ aSeq.Append (TCollection_ExtendedString (theArgVec[aLabelIter]));
}
+ aCS->SetLabels (aSeq);
+ aCS->SetLabelType (Aspect_TOCSD_USER);
+ anArgIter += aSeq.Length();
+ }
+ else if (aFlag == "-title")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Boolean isTwoArgs = Standard_False;
+ if (anArgIter + 2 < theArgNb)
+ {
+ TCollection_AsciiString aSecondArg (theArgVec[anArgIter + 2]);
+ aSecondArg.LowerCase();
+ if (aSecondArg == "none")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_NONE);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "left")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_LEFT);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "right")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_RIGHT);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "center")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_CENTER);
+ isTwoArgs = Standard_True;
+ }
+ }
+
+ aCS->SetTitle (theArgVec[anArgIter + 1]);
+ if (isTwoArgs)
+ {
+ anArgIter += 1;
+ }
+ anArgIter += 1;
+ }
+ else if (aFlag == "-demoversion"
+ || aFlag == "-demo")
+ {
+ aPos.SetCoord (0.0, 0.0);
+ aTextHeight = 16;
+ aMinRange = 0.0;
+ aMaxRange = 100;
+ aNbIntervals = 10;
+ aLabPosition = Aspect_TOCSP_RIGHT;
+ aCS->SetColorType(Aspect_TOCSD_AUTO);
+ aCS->SetLabelType(Aspect_TOCSD_AUTO);
}
else
{
- xname += "X (mm)";
- yname += "Y (mm)";
- zname += "Z (mm)";
- }
-
- aV3dView->GraduatedTrihedronDisplay(xname, yname, zname,
- Standard_True/*xdrawname*/, Standard_True/*ydrawname*/, Standard_True/*zdrawname*/,
- Standard_True/*xdrawvalues*/, Standard_True/*ydrawvalues*/, Standard_True/*zdrawvalues*/,
- Standard_True/*drawgrid*/,
- Standard_True/*drawaxes*/,
- 5/*nbx*/, 5/*nby*/, 5/*nbz*/,
- 10/*xoffset*/, 10/*yoffset*/, 10/*zoffset*/,
- 30/*xaxisoffset*/, 30/*yaxisoffset*/, 30/*zaxisoffset*/,
- Standard_True/*xdrawtickmarks*/, Standard_True/*ydrawtickmarks*/, Standard_True/*zdrawtickmarks*/,
- 10/*xtickmarklength*/, 10/*ytickmarklength*/, 10/*ztickmarklength*/,
- Quantity_NOC_WHITE/*gridcolor*/,
- Quantity_NOC_RED/*xnamecolor*/,Quantity_NOC_GREEN/*ynamecolor*/,Quantity_NOC_BLUE1/*znamecolor*/,
- Quantity_NOC_RED/*xcolor*/,Quantity_NOC_GREEN/*ycolor*/,Quantity_NOC_BLUE1/*zcolor*/,font);
+ std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
+ return 1;
+ }
}
- else
- aV3dView->GraduatedTrihedronErase();
- ViewerTest::GetAISContext()->UpdateCurrentViewer();
- aV3dView->Redraw();
+ aCS->SetPosition (aPos.X(), aPos.Y());
+ aCS->SetHeight (0.95);
+ aCS->SetTextHeight (aTextHeight);
+ aCS->SetRange (aMinRange, aMaxRange);
+ aCS->SetNumberOfIntervals (aNbIntervals);
+ aCS->SetLabelPosition (aLabPosition);
+
+ if (!aView->ColorScaleIsDisplayed())
+ {
+ aView->ColorScaleDisplay();
+ }
return 0;
}
//==============================================================================
-//function : VPrintView
-//purpose : Test printing algorithm, print the view to image file with given
-// width and height. Printing implemented only for WNT.
+//function : VGraduatedTrihedron
+//purpose : Displays or hides a graduated trihedron
//==============================================================================
-static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
- const char** argv)
+static Standard_Boolean GetColor (const TCollection_AsciiString& theValue,
+ Quantity_Color& theColor)
{
-#ifndef WNT
- di << "Printing implemented only for wnt!\n";
- return 0;
-#else
-
- Handle(AIS_InteractiveContext) aContextAIS = NULL;
- Handle(V3d_View) aView = NULL;
- aContextAIS = ViewerTest::GetAISContext();
- if (!aContextAIS.IsNull())
+ Quantity_NameOfColor aColorName;
+ TCollection_AsciiString aVal = theValue;
+ aVal.UpperCase();
+ if (!Quantity_Color::ColorFromName (aVal.ToCString(), aColorName))
{
- const Handle(V3d_Viewer)& Vwr = aContextAIS->CurrentViewer();
- Vwr->InitActiveViews();
- if(Vwr->MoreActiveViews())
- aView = Vwr->ActiveView();
+ return Standard_False;
}
+ theColor = Quantity_Color (aColorName);
+ return Standard_True;
+}
- // check for errors
- if (aView.IsNull())
+static int VGraduatedTrihedron (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNum, const char** theArgs)
+{
+ if (theArgNum < 2)
{
- di << "Call vinit before!\n";
- return 1;
+ std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
+ << theArgs[0] <<"' for more information.\n";
+ return 1; //TCL_ERROR
}
- else if (argc < 4)
+
+ NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
+ TCollection_AsciiString aParseKey;
+ for (Standard_Integer anArgIt = 1; anArgIt < theArgNum; ++anArgIt)
{
- di << "Use: " << argv[0];
- di << " width height filename [print algo=0] [tile_width tile_height]\n";
- di << "width, height of the intermediate buffer for operation\n";
- di << "algo : {0|1}\n";
- di << " 0 - stretch algorithm\n";
- di << " 1 - tile algorithm\n";
- di << "test printing algorithms into an intermediate buffer\n";
- di << "using specific tile size if provided\n";
+ TCollection_AsciiString anArg (theArgs [anArgIt]);
+
+ if (anArg.Value (1) == '-' && !anArg.IsRealValue())
+ {
+ aParseKey = anArg;
+ aParseKey.Remove (1);
+ aParseKey.LowerCase();
+ aMapOfArgs.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
+ continue;
+ }
+
+ if (aParseKey.IsEmpty())
+ {
+ continue;
+ }
+
+ aMapOfArgs(aParseKey)->Append (anArg);
+ }
+
+ // Check parameters
+ for (NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfArgs);
+ aMapIt.More(); aMapIt.Next())
+ {
+ const TCollection_AsciiString& aKey = aMapIt.Key();
+ const Handle(TColStd_HSequenceOfAsciiString)& anArgs = aMapIt.Value();
+
+ // Bool key, without arguments
+ if ((aKey.IsEqual ("on") || aKey.IsEqual ("off"))
+ && anArgs->IsEmpty())
+ {
+ continue;
+ }
+
+ // One argument
+ if ( (aKey.IsEqual ("xname") || aKey.IsEqual ("yname") || aKey.IsEqual ("zname"))
+ && anArgs->Length() == 1)
+ {
+ continue;
+ }
+
+ // On/off arguments
+ if ((aKey.IsEqual ("xdrawname") || aKey.IsEqual ("ydrawname") || aKey.IsEqual ("zdrawname")
+ || aKey.IsEqual ("xdrawticks") || aKey.IsEqual ("ydrawticks") || aKey.IsEqual ("zdrawticks")
+ || aKey.IsEqual ("xdrawvalues") || aKey.IsEqual ("ydrawvalues") || aKey.IsEqual ("zdrawvalues")
+ || aKey.IsEqual ("drawgrid") || aKey.IsEqual ("drawaxes"))
+ && anArgs->Length() == 1 && (anArgs->Value(1).IsEqual ("on") || anArgs->Value(1).IsEqual ("off")))
+ {
+ continue;
+ }
+
+ // One string argument
+ if ( (aKey.IsEqual ("xnamecolor") || aKey.IsEqual ("ynamecolor") || aKey.IsEqual ("znamecolor")
+ || aKey.IsEqual ("xcolor") || aKey.IsEqual ("ycolor") || aKey.IsEqual ("zcolor"))
+ && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+ {
+ continue;
+ }
+
+ // One integer argument
+ if ( (aKey.IsEqual ("xticks") || aKey.IsEqual ("yticks") || aKey.IsEqual ("zticks")
+ || aKey.IsEqual ("xticklength") || aKey.IsEqual ("yticklength") || aKey.IsEqual ("zticklength")
+ || aKey.IsEqual ("xnameoffset") || aKey.IsEqual ("ynameoffset") || aKey.IsEqual ("znameoffset")
+ || aKey.IsEqual ("xvaluesoffset") || aKey.IsEqual ("yvaluesoffset") || aKey.IsEqual ("zvaluesoffset"))
+ && anArgs->Length() == 1 && anArgs->Value(1).IsIntegerValue())
+ {
+ continue;
+ }
+
+ // One real argument
+ if ( aKey.IsEqual ("arrowlength")
+ && anArgs->Length() == 1 && (anArgs->Value(1).IsIntegerValue() || anArgs->Value(1).IsRealValue()))
+ {
+ continue;
+ }
+
+ // Two string arguments
+ if ( (aKey.IsEqual ("namefont") || aKey.IsEqual ("valuesfont"))
+ && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+ {
+ continue;
+ }
+
+ TCollection_AsciiString aLowerKey;
+ 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";
+ return 1;
+ }
+
+ Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
+ if (anAISContext.IsNull())
+ {
+ std::cout << theArgs[0] << ": " << " please use 'vinit' command to initialize view.\n";
+ return 1;
+ }
+
+ Standard_Boolean toDisplay = Standard_True;
+ Quantity_Color aColor;
+ Graphic3d_GraduatedTrihedron aTrihedronData;
+ // Process parameters
+ Handle(TColStd_HSequenceOfAsciiString) aValues;
+ if (aMapOfArgs.Find ("off", aValues))
+ {
+ toDisplay = Standard_False;
+ }
+
+ // AXES NAMES
+ if (aMapOfArgs.Find ("xname", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("yname", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("zname", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("xdrawname", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawname", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawname", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("xnameoffset", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("ynameoffset", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("znameoffset", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+
+ // COLORS
+ if (aMapOfArgs.Find ("xnamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("ynamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("znamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("xcolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
+ }
+ if (aMapOfArgs.Find ("ycolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
+ }
+ if (aMapOfArgs.Find ("zcolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
+ }
+
+ // TICKMARKS
+ if (aMapOfArgs.Find ("xticks", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yticks", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zticks", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("xticklength", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yticklength", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zticklength", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("xdrawticks", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawticks", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawticks", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+
+ // VALUES
+ if (aMapOfArgs.Find ("xdrawvalues", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawvalues", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawvalues", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("xvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
+
+ // ARROWS
+ if (aMapOfArgs.Find ("arrowlength", aValues))
+ {
+ aTrihedronData.SetArrowsLength ((Standard_ShortReal) aValues->Value(1).RealValue());
+ }
+
+ // FONTS
+ if (aMapOfArgs.Find ("namefont", aValues))
+ {
+ aTrihedronData.SetNamesFont (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("valuesfont", aValues))
+ {
+ aTrihedronData.SetValuesFont (aValues->Value(1));
+ }
+
+ if (aMapOfArgs.Find ("drawgrid", aValues))
+ {
+ aTrihedronData.SetDrawGrid (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("drawaxes", aValues))
+ {
+ aTrihedronData.SetDrawAxes (aValues->Value(1).IsEqual ("on"));
+ }
+
+ // The final step: display of erase trihedron
+ if (toDisplay)
+ {
+ ViewerTest::CurrentView()->GraduatedTrihedronDisplay (aTrihedronData);
+ }
+ else
+ {
+ ViewerTest::CurrentView()->GraduatedTrihedronErase();
+ }
+
+ ViewerTest::GetAISContext()->UpdateCurrentViewer();
+ ViewerTest::CurrentView()->Redraw();
+
+ return 0;
+}
+
+//==============================================================================
+//function : VPrintView
+//purpose : Test printing algorithm, print the view to image file with given
+// width and height. Printing implemented only for WNT.
+//==============================================================================
+static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
+ const char** argv)
+{
+#ifndef WNT
+ di << "Printing implemented only for wnt!\n";
+ return 0;
+#else
+
+ Handle(AIS_InteractiveContext) aContextAIS = NULL;
+ Handle(V3d_View) aView = NULL;
+ aContextAIS = ViewerTest::GetAISContext();
+ if (!aContextAIS.IsNull())
+ {
+ const Handle(V3d_Viewer)& Vwr = aContextAIS->CurrentViewer();
+ Vwr->InitActiveViews();
+ if(Vwr->MoreActiveViews())
+ aView = Vwr->ActiveView();
+ }
+
+ // check for errors
+ if (aView.IsNull())
+ {
+ di << "Call vinit before!\n";
+ return 1;
+ }
+ else if (argc < 4)
+ {
+ di << "Use: " << argv[0];
+ di << " width height filename [print algo=0] [tile_width tile_height]\n";
+ di << "width, height of the intermediate buffer for operation\n";
+ di << "algo : {0|1}\n";
+ di << " 0 - stretch algorithm\n";
+ di << " 1 - tile algorithm\n";
+ di << "test printing algorithms into an intermediate buffer\n";
+ di << "using specific tile size if provided\n";
di << "with saving output to an image file\n";
return 1;
}
}
else if (argc < 2)
{
- di << "Use: vzlayer " << argv[0];
- di << " add/del/get [id]\n";
+ di << "Use: vzlayer ";
+ di << " add/del/get/settings/enable/disable [id]\n";
di << " add - add new z layer to viewer and print its id\n";
di << " del - del z layer by its id\n";
di << " get - print sequence of z layers in increasing order of their overlay level\n";
- di << "id - the layer identificator value defined when removing z layer\n";
+ di << " settings - print status of z layer settings\n";
+ di << " enable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n enables given setting for the z layer\n";
+ di << " enable (p[ositive]offset/n[egative]offset) \n enables given setting for the z layer\n";
+ di << " disable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n disables given setting for the z layer\n";
+ di << "\nWhere id is the layer identificator\n";
+ di << "\nExamples:\n";
+ di << " vzlayer add\n";
+ di << " vzlayer enable poffset 1\n";
+ di << " vzlayer disable depthtest 1\n";
+ di << " vzlayer del 1\n";
return 1;
}
return 1;
}
+ for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anObjIter (GetMapOfAIS());
+ anObjIter.More(); anObjIter.Next())
+ {
+ Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anObjIter.Key1());
+ if (aPrs.IsNull()
+ || aPrs->ZLayer() != aDelId)
+ {
+ continue;
+ }
+ aPrs->SetZLayer (Graphic3d_ZLayerId_Default);
+ }
+
di << "Z layer " << aDelId << " has been removed\n";
}
else if (anOp == "get")
di << "\n";
}
- else
+ else if (anOp == "settings")
{
- di << "Invalid operation, please use { add / del / get }\n";
- return 1;
- }
+ if (argc < 3)
+ {
+ di << "Please also provide an id\n";
+ return 1;
+ }
- return 0;
-}
+ Standard_Integer anId = Draw::Atoi (argv[2]);
+ Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
-DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
+ di << "Depth test - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthTest) ? "enabled" : "disabled") << "\n";
+ di << "Depth write - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthWrite) ? "enabled" : "disabled") << "\n";
+ di << "Depth buffer clearing - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthClear) ? "enabled" : "disabled") << "\n";
+ di << "Depth offset - " << (aSettings.IsSettingEnabled (Graphic3d_ZLayerDepthOffset) ? "enabled" : "disabled") << "\n";
-// this class provides a presentation of text item in v3d view under-/overlayer
-class V3d_TextItem : public Visual3d_LayerItem
-{
-public:
+ }
+ else if (anOp == "enable")
+ {
+ if (argc < 3)
+ {
+ di << "Please also provide an option to enable\n";
+ return 1;
+ }
- // CASCADE RTTI
- DEFINE_STANDARD_RTTI(V3d_TextItem)
+ if (argc < 4)
+ {
+ di << "Please also provide a layer id\n";
+ return 1;
+ }
- // constructor
- Standard_EXPORT V3d_TextItem(const TCollection_AsciiString& theText,
- const Standard_Real theX1,
- const Standard_Real theY1,
- const Standard_Real theHeight,
- const TCollection_AsciiString& theFontName,
- const Quantity_Color& theColor,
- const Quantity_Color& theSubtitleColor,
- const Aspect_TypeOfDisplayText& theTypeOfDisplay,
- const Handle(Visual3d_Layer)& theLayer);
+ TCollection_AsciiString aSubOp = TCollection_AsciiString (argv[2]);
+ Standard_Integer anId = Draw::Atoi (argv[3]);
+ Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
- // redraw method
- Standard_EXPORT void RedrawLayerPrs();
+ if (aSubOp == "depthtest" || aSubOp == "test")
+ {
+ aSettings.EnableSetting (Graphic3d_ZLayerDepthTest);
+ }
+ else if (aSubOp == "depthwrite" || aSubOp == "write")
+ {
+ aSettings.EnableSetting (Graphic3d_ZLayerDepthWrite);
+ }
+ else if (aSubOp == "depthclear" || aSubOp == "clear")
+ {
+ aSettings.EnableSetting (Graphic3d_ZLayerDepthClear);
+ }
+ else if (aSubOp == "depthoffset" || aSubOp == "offset")
+ {
+ if (argc < 6)
+ {
+ di << "Please also provide a factor and units values for depth offset\n";
+ di << "Format is: vzlayer enable offset [factor] [units] [layerId]\n";
+ return 1;
+ }
-private:
+ Standard_ShortReal aFactor = static_cast<Standard_ShortReal> (Draw::Atof (argv[3]));
+ Standard_ShortReal aUnits = static_cast<Standard_ShortReal> (Draw::Atof (argv[4]));
+ anId = Draw::Atoi (argv[5]);
+ aSettings = aViewer->ZLayerSettings (anId);
+
+ aSettings.DepthOffsetFactor = aFactor;
+ aSettings.DepthOffsetUnits = aUnits;
+
+ aSettings.EnableSetting (Graphic3d_ZLayerDepthOffset);
+ }
+ else if (aSubOp == "positiveoffset" || aSubOp == "poffset")
+ {
+ aSettings.SetDepthOffsetPositive();
+ }
+ else if (aSubOp == "negativeoffset" || aSubOp == "noffset")
+ {
+ aSettings.SetDepthOffsetNegative();
+ }
+
+ aViewer->SetZLayerSettings (anId, aSettings);
+ }
+ else if (anOp == "disable")
+ {
+ if (argc < 3)
+ {
+ di << "Please also provide an option to disable\n";
+ return 1;
+ }
+
+ if (argc < 4)
+ {
+ di << "Please also provide a layer id\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aSubOp = TCollection_AsciiString (argv[2]);
+ Standard_Integer anId = Draw::Atoi (argv[3]);
+ Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
+
+ if (aSubOp == "depthtest" || aSubOp == "test")
+ {
+ aSettings.DisableSetting (Graphic3d_ZLayerDepthTest);
+ }
+ else if (aSubOp == "depthwrite" || aSubOp == "write")
+ {
+ aSettings.DisableSetting (Graphic3d_ZLayerDepthWrite);
+ }
+ else if (aSubOp == "depthclear" || aSubOp == "clear")
+ {
+ aSettings.DisableSetting (Graphic3d_ZLayerDepthClear);
+ }
+ else if (aSubOp == "depthoffset" || aSubOp == "offset")
+ {
+ aSettings.DisableSetting (Graphic3d_ZLayerDepthOffset);
+ }
+
+ aViewer->SetZLayerSettings (anId, aSettings);
+ }
+ else
+ {
+ di << "Invalid operation, please use { add / del / get / settings / enable / disable}\n";
+ return 1;
+ }
+
+ return 0;
+}
+
+// this class provides a presentation of text item in v3d view under-/overlayer
+class V3d_TextItem : public Visual3d_LayerItem
+{
+public:
+
+ // CASCADE RTTI
+ DEFINE_STANDARD_RTTI(V3d_TextItem, Visual3d_LayerItem)
+
+ // constructor
+ Standard_EXPORT V3d_TextItem(const TCollection_AsciiString& theText,
+ const Standard_Real theX1,
+ const Standard_Real theY1,
+ const Standard_Real theHeight,
+ const TCollection_AsciiString& theFontName,
+ const Quantity_Color& theColor,
+ const Quantity_Color& theSubtitleColor,
+ const Aspect_TypeOfDisplayText& theTypeOfDisplay,
+ const Handle(Visual3d_Layer)& theLayer);
+
+ // redraw method
+ Standard_EXPORT void RedrawLayerPrs();
+
+private:
Standard_Real myX1;
Standard_Real myY1;
TCollection_AsciiString myFontName;
};
-IMPLEMENT_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
-IMPLEMENT_STANDARD_RTTIEXT(V3d_TextItem, Visual3d_LayerItem)
// create and add to display the text item
V3d_TextItem::V3d_TextItem (const TCollection_AsciiString& theText,
myLayer->DrawText (myText.ToCString (), myX1, myY1, myHeight);
}
-DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
-
// The Visual3d_LayerItem line item for "vlayerline" command
// it provides a presentation of line with user-defined
// linewidth, linetype and transparency.
{
public:
// CASCADE RTTI
- DEFINE_STANDARD_RTTI(V3d_LineItem)
+ DEFINE_STANDARD_RTTI(V3d_LineItem, Visual3d_LayerItem)
// constructor
Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
Standard_Real myTransparency;
};
-IMPLEMENT_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
-IMPLEMENT_STANDARD_RTTIEXT(V3d_LineItem, Visual3d_LayerItem)
// default constructor for line item
V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
return 0;
}
+//==============================================================================
+//function : VPriviledgedPlane
+//purpose :
+//==============================================================================
+
+static int VPriviledgedPlane (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
+ {
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+
+ // get the active viewer
+ Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+ if (aViewer.IsNull())
+ {
+ std::cerr << "Error: no active viewer. Please call vinit.\n";
+ return 1;
+ }
+
+ if (theArgNb == 1)
+ {
+ gp_Ax3 aPriviledgedPlane = aViewer->PrivilegedPlane();
+ const gp_Pnt& anOrig = aPriviledgedPlane.Location();
+ const gp_Dir& aNorm = aPriviledgedPlane.Direction();
+ const gp_Dir& aXDir = aPriviledgedPlane.XDirection();
+ theDI << "Origin: " << anOrig.X() << " " << anOrig.Y() << " " << anOrig.Z() << " "
+ << "Normal: " << aNorm.X() << " " << aNorm.Y() << " " << aNorm.Z() << " "
+ << "X-dir: " << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
+ return 0;
+ }
+
+ Standard_Integer anArgIdx = 1;
+ Standard_Real anOrigX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real anOrigY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real anOrigZ = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormZ = Draw::Atof (theArgVec[anArgIdx++]);
+
+ gp_Ax3 aPriviledgedPlane;
+ gp_Pnt anOrig (anOrigX, anOrigY, anOrigZ);
+ gp_Dir aNorm (aNormX, aNormY, aNormZ);
+ if (theArgNb > 7)
+ {
+ Standard_Real aXDirX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aXDirY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aXDirZ = Draw::Atof (theArgVec[anArgIdx++]);
+ gp_Dir aXDir (aXDirX, aXDirY, aXDirZ);
+ aPriviledgedPlane = gp_Ax3 (anOrig, aNorm, aXDir);
+ }
+ else
+ {
+ aPriviledgedPlane = gp_Ax3 (anOrig, aNorm);
+ }
+
+ aViewer->SetPrivilegedPlane (aPriviledgedPlane);
+
+ return 0;
+}
+
+//==============================================================================
+//function : VConvert
+//purpose :
+//==============================================================================
+
+static int VConvert (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ // get the active view
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << "Error: no active view. Please call vinit.\n";
+ return 1;
+ }
+
+ enum { Model, Ray, View, Window, Grid } aMode = Model;
+
+ // access coordinate arguments
+ TColStd_SequenceOfReal aCoord;
+ Standard_Integer anArgIdx = 1;
+ for (; anArgIdx < 4 && anArgIdx < theArgNb; ++anArgIdx)
+ {
+ TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+ if (!anArg.IsRealValue())
+ {
+ break;
+ }
+ aCoord.Append (anArg.RealValue());
+ }
+
+ // non-numeric argument too early
+ if (aCoord.IsEmpty())
+ {
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+
+ // collect all other arguments and options
+ for (; anArgIdx < theArgNb; ++anArgIdx)
+ {
+ TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+ anArg.LowerCase();
+ if (anArg == "window") aMode = Window;
+ else if (anArg == "view") aMode = View;
+ else if (anArg == "grid") aMode = Grid;
+ else if (anArg == "ray") aMode = Ray;
+ else
+ {
+ std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+ }
+
+ // complete input checks
+ if ((aCoord.Length() == 1 && theArgNb > 3) ||
+ (aCoord.Length() == 2 && theArgNb > 4) ||
+ (aCoord.Length() == 3 && theArgNb > 5))
+ {
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+
+ Standard_Real aXYZ[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+ Standard_Integer aXYp[2] = {0, 0};
+
+ // convert one-dimensional coordinate
+ if (aCoord.Length() == 1)
+ {
+ switch (aMode)
+ {
+ case View : theDI << "View Vv: " << aView->Convert ((Standard_Integer) aCoord (1)); return 0;
+ case Window : theDI << "Window Vp: " << aView->Convert ((Quantity_Length) aCoord (1)); return 0;
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+ }
+
+ // convert 2D coordinates from projection or view reference space
+ if (aCoord.Length() == 2)
+ {
+ switch (aMode)
+ {
+ case Model :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+ theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+ return 0;
+
+ case View :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1]);
+ theDI << "View Xv,Yv: " << aXYZ[0] << " " << aXYZ[1] << "\n";
+ return 0;
+
+ case Window :
+ aView->Convert ((V3d_Coordinate) aCoord (1), (V3d_Coordinate) aCoord (2), aXYp[0], aXYp[1]);
+ theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+ return 0;
+
+ case Grid :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+ aView->ConvertToGrid (aXYZ[0], aXYZ[1], aXYZ[2], aXYZ[3], aXYZ[4], aXYZ[5]);
+ theDI << "Model X,Y,Z: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+ return 0;
+
+ case Ray :
+ aView->ConvertWithProj ((Standard_Integer) aCoord (1),
+ (Standard_Integer) aCoord (2),
+ aXYZ[0], aXYZ[1], aXYZ[2],
+ aXYZ[3], aXYZ[4], aXYZ[5]);
+ theDI << "Model DX,DY,DZ: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+ return 0;
+
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+ }
+
+ // convert 3D coordinates from view reference space
+ else if (aCoord.Length() == 3)
+ {
+ switch (aMode)
+ {
+ case Window :
+ aView->Convert (aCoord (1), aCoord (2), aCoord (3), aXYp[0], aXYp[1]);
+ theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+ return 0;
+
+ case Grid :
+ aView->ConvertToGrid (aCoord (1), aCoord (2), aCoord (3), aXYZ[0], aXYZ[1], aXYZ[2]);
+ theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+ return 0;
+
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
//==============================================================================
//function : VFps
//purpose :
Standard_Integer theArgNb,
const char** theArgVec)
{
+ Handle(OpenGl_GraphicDriver) aDriver;
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (!aView.IsNull())
+ {
+ aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aView->Viewer()->Driver());
+ }
+ OpenGl_Caps* aDefCaps = &ViewerTest_myDefaultCaps;
+ OpenGl_Caps* aCaps = !aDriver.IsNull() ? &aDriver->ChangeOptions() : NULL;
+
if (theArgNb < 2)
{
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
+ TCollection_AsciiString aDebActive, aSyncActive;
+ if (aCaps == NULL)
{
- std::cerr << "No active view. Please call vinit.\n";
- return 0;
+ aCaps = aDefCaps;
+ }
+ else
+ {
+ Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )::glGetString (GL_EXTENSIONS),
+ "GL_ARB_debug_output");
+ aDebActive = isActive ? " (active)" : " (inactive)";
+ if (isActive)
+ {
+ // GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
+ aSyncActive = ::glIsEnabled (0x8242) == GL_TRUE ? " (active)" : " (inactive)";
+ }
}
- Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )glGetString (GL_EXTENSIONS),
- "GL_ARB_debug_output");
- std::cout << "Active graphic driver: debug " << (isActive ? "ON" : "OFF") << "\n";
- theDI << (isActive ? "1" : "0");
+ theDI << "debug: " << (aCaps->contextDebug ? "1" : "0") << aDebActive << "\n"
+ << "sync: " << (aCaps->contextSyncDebug ? "1" : "0") << aSyncActive << "\n"
+ << "glslWarn:" << (aCaps->glslWarnings ? "1" : "0") << "\n"
+ << "extraMsg:" << (aCaps->suppressExtraMsg ? "0" : "1") << "\n";
return 0;
}
- ViewerTest_myDefaultCaps.contextDebug = Draw::Atoi (theArgVec[1]) != 0;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString anArgCase (anArg);
+ anArgCase.LowerCase();
+ Standard_Boolean toEnableDebug = Standard_True;
+ if (anArgCase == "-glsl"
+ || anArgCase == "-glslwarn"
+ || anArgCase == "-glslwarns"
+ || anArgCase == "-glslwarnings")
+ {
+ Standard_Boolean toShowWarns = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toShowWarns))
+ {
+ --anArgIter;
+ }
+ aDefCaps->glslWarnings = toShowWarns;
+ if (aCaps != NULL)
+ {
+ aCaps->glslWarnings = toShowWarns;
+ }
+ }
+ else if (anArgCase == "-extra"
+ || anArgCase == "-extramsg"
+ || anArgCase == "-extramessages")
+ {
+ Standard_Boolean toShow = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toShow))
+ {
+ --anArgIter;
+ }
+ aDefCaps->suppressExtraMsg = !toShow;
+ if (aCaps != NULL)
+ {
+ aCaps->suppressExtraMsg = !toShow;
+ }
+ }
+ else if (anArgCase == "-noextra"
+ || anArgCase == "-noextramsg"
+ || anArgCase == "-noextramessages")
+ {
+ Standard_Boolean toSuppress = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toSuppress))
+ {
+ --anArgIter;
+ }
+ aDefCaps->suppressExtraMsg = toSuppress;
+ if (aCaps != NULL)
+ {
+ aCaps->suppressExtraMsg = toSuppress;
+ }
+ }
+ else if (anArgCase == "-sync")
+ {
+ Standard_Boolean toSync = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toSync))
+ {
+ --anArgIter;
+ }
+ aDefCaps->contextSyncDebug = toSync;
+ if (toSync)
+ {
+ aDefCaps->contextDebug = Standard_True;
+ }
+ }
+ else if (anArgCase == "-debug")
+ {
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnableDebug))
+ {
+ --anArgIter;
+ }
+ aDefCaps->contextDebug = toEnableDebug;
+ }
+ else if (parseOnOff (anArg, toEnableDebug)
+ && (anArgIter + 1 == theArgNb))
+ {
+ // simple alias to turn on almost everything
+ aDefCaps->contextDebug = toEnableDebug;
+ aDefCaps->contextSyncDebug = toEnableDebug;
+ aDefCaps->glslWarnings = toEnableDebug;
+ }
+ else
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ }
+
return 0;
}
{
OpenGl_Caps* aCaps = &ViewerTest_myDefaultCaps;
Handle(OpenGl_GraphicDriver) aDriver;
- Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
- if (!aContextAIS.IsNull())
+ Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+ if (!aContext.IsNull())
{
- aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
+ aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContext->CurrentViewer()->Driver());
aCaps = &aDriver->ChangeOptions();
}
theDI << "VBO: " << (aCaps->vboDisable ? "0" : "1") << "\n";
theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
theDI << "SoftMode:" << (aCaps->contextNoAccel ? "1" : "0") << "\n";
+ theDI << "FFP: " << (aCaps->ffpEnable ? "1" : "0") << "\n";
+ theDI << "VSync: " << aCaps->swapInterval << "\n";
+ theDI << "Compatible:" << (aCaps->contextCompatible ? "1" : "0") << "\n";
+ theDI << "Stereo: " << (aCaps->contextStereo ? "1" : "0") << "\n";
return 0;
}
+ ViewerTest_AutoUpdater anUpdateTool (aContext, ViewerTest::CurrentView());
for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- const TCollection_AsciiString anArg (theArgVec[anArgIter]);
- if (anArg.Search ("vbo=") > -1)
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString anArgCase (anArg);
+ anArgCase.LowerCase();
+ if (anUpdateTool.parseRedrawMode (anArg))
{
- aCaps->vboDisable = anArg.Token ("=", 2).IntegerValue() == 0;
+ continue;
}
- else if (anArg.Search ("sprites=") > -1)
+ else if (anArgCase == "-vsync"
+ || anArgCase == "-swapinterval")
{
- aCaps->pntSpritesDisable = anArg.Token ("=", 2).IntegerValue() == 0;
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->swapInterval = toEnable;
}
- else if (anArg.Search ("soft=") > -1)
+ else if (anArgCase == "-ffp")
{
- aCaps->contextNoAccel = anArg.Token ("=", 2).IntegerValue() != 0;
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->ffpEnable = toEnable;
}
- else
+ else if (anArgCase == "-vbo")
{
- std::cerr << "Unknown argument: " << anArg << "\n";
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->vboDisable = !toEnable;
}
- }
- if (aCaps != &ViewerTest_myDefaultCaps)
- {
- ViewerTest_myDefaultCaps = *aCaps;
- }
- return 0;
-}
-
-//==============================================================================
-//function : VMemGpu
-//purpose :
-//==============================================================================
-
-static int VMemGpu (Draw_Interpretor& theDI,
- Standard_Integer theArgNb,
- const char** theArgVec)
-{
- // get the context
- Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
- if (aContextAIS.IsNull())
- {
- std::cerr << "No active view. Please call vinit.\n";
- return 1;
- }
-
- Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
- if (aDriver.IsNull())
- {
+ else if (anArgCase == "-sprite"
+ || anArgCase == "-sprites")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->pntSpritesDisable = !toEnable;
+ }
+ else if (anArgCase == "-softmode")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextNoAccel = toEnable;
+ }
+ else if (anArgCase == "-accel"
+ || anArgCase == "-acceleration")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextNoAccel = !toEnable;
+ }
+ else if (anArgCase == "-compat"
+ || anArgCase == "-compatprofile"
+ || anArgCase == "-compatible"
+ || anArgCase == "-compatibleprofile")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextCompatible = toEnable;
+ if (!aCaps->contextCompatible)
+ {
+ aCaps->ffpEnable = Standard_False;
+ }
+ }
+ else if (anArgCase == "-core"
+ || anArgCase == "-coreprofile")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextCompatible = !toEnable;
+ if (!aCaps->contextCompatible)
+ {
+ aCaps->ffpEnable = Standard_False;
+ }
+ }
+ else if (anArgCase == "-stereo"
+ || anArgCase == "-quadbuffer")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextStereo = toEnable;
+ }
+ else
+ {
+ std::cout << "Error: unknown argument '" << anArg << "'\n";
+ return 1;
+ }
+ }
+ if (aCaps != &ViewerTest_myDefaultCaps)
+ {
+ ViewerTest_myDefaultCaps = *aCaps;
+ }
+ return 0;
+}
+
+//==============================================================================
+//function : VMemGpu
+//purpose :
+//==============================================================================
+
+static int VMemGpu (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ // get the context
+ Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
+ if (aContextAIS.IsNull())
+ {
+ std::cerr << "No active view. Please call vinit.\n";
+ return 1;
+ }
+
+ Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
+ if (aDriver.IsNull())
+ {
std::cerr << "Graphic driver not available.\n";
return 1;
}
theDI << aDiffColorsNb << "\n";
// save image of difference
- if (aDiffImagePath != NULL)
+ if (aDiffColorsNb >0 && aDiffImagePath != NULL)
{
aComparer.SaveDiffImage (aDiffImagePath);
}
di << "use 'vinit' command before " << argv[0] << "\n";
return 1;
}
- const Standard_Boolean isShiftSelection = (argc>3 && !(argc%2) && (atoi(argv[argc-1])==1));
+
+ const Standard_Boolean isShiftSelection = (argc > 3 && !(argc % 2) && (atoi (argv[argc - 1]) == 1));
+ Standard_Integer aCoordsNb = isShiftSelection ? argc - 2 : argc - 1;
+ TCollection_AsciiString anArg;
+ anArg = isShiftSelection ? argv[argc - 3] : argv[argc - 2];
+ anArg.LowerCase();
+ if (anArg == "-allowoverlap")
+ {
+ Standard_Boolean isValidated = isShiftSelection ? argc == 8
+ : argc == 7;
+ if (!isValidated)
+ {
+ di << "Wrong number of arguments! -allowoverlap key is applied only for rectangle selection";
+ return 1;
+ }
+
+ Standard_Integer isToAllow = isShiftSelection ? Draw::Atoi(argv[argc - 2]) : Draw::Atoi(argv[argc - 1]);
+ myAIScontext->MainSelector()->AllowOverlapDetection((Standard_Boolean)isToAllow);
+ aCoordsNb -= 2;
+ }
+
Handle(ViewerTest_EventManager) aCurrentEventManager = ViewerTest::CurrentEventManager();
aCurrentEventManager->MoveTo(atoi(argv[1]),atoi(argv[2]));
- if(argc <= 4)
+ if(aCoordsNb == 2)
{
if(isShiftSelection)
aCurrentEventManager->ShiftSelect();
else
aCurrentEventManager->Select();
}
- else if(argc <= 6)
+ else if(aCoordsNb == 4)
{
if(isShiftSelection)
- aCurrentEventManager->ShiftSelect(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+ aCurrentEventManager->ShiftSelect (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
else
- aCurrentEventManager->Select(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+ aCurrentEventManager->Select (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
}
else
{
- Standard_Integer anUpper = 0;
+ TColgp_Array1OfPnt2d aPolyline (1,aCoordsNb / 2);
- if(isShiftSelection)
- anUpper = (argc-1)/2;
- else
- anUpper = argc/2;
- TColgp_Array1OfPnt2d aPolyline(1,anUpper);
-
- for(Standard_Integer i=1;i<=anUpper;++i)
+ for(Standard_Integer i=1;i<=aCoordsNb / 2;++i)
aPolyline.SetValue(i,gp_Pnt2d(atoi(argv[2*i-1]),atoi(argv[2*i])));
if(isShiftSelection)
Quantity_Length aDepth = 0., aWidth = 1.;
if(argc == 3)
{
- aDepth = atof(argv[1]);
- aWidth = atof(argv[2]);
+ aDepth = Draw::Atof (argv[1]);
+ aWidth = Draw::Atof (argv[2]);
}
else if(argc == 4)
{
- aDepth = atof(argv[2]);
- aWidth = atof(argv[3]);
+ aDepth = Draw::Atof (argv[2]);
+ aWidth = Draw::Atof (argv[3]);
}
if(aDepth<0. || aDepth>1.)
di<<"Usage : " << argv[0] << " Size\n";
return 1;
}
- Standard_Real aSize = atof(argv[1]);
+ Standard_Real aSize = Draw::Atof (argv[1]);
if (aSize <= 0.)
{
di<<"Bad Size value : " << aSize << "\n";
di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
return 1;
}
- Standard_Real Dx = atof(argv[1]);
- Standard_Real Dy = atof(argv[2]);
- Standard_Real Dz = atof(argv[3]);
+ Standard_Real Dx = Draw::Atof (argv[1]);
+ Standard_Real Dy = Draw::Atof (argv[2]);
+ Standard_Real Dz = Draw::Atof (argv[3]);
Standard_Boolean aStart = Standard_True;
if (argc == 5)
{
- aStart = (atoi(argv[4]) > 0);
+ aStart = (Draw::Atoi (argv[4]) > 0);
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
return 1;
}
- Standard_Real Dx = atof(argv[1]);
- Standard_Real Dy = atof(argv[2]);
- Standard_Real Dz = atof(argv[3]);
+ Standard_Real Dx = Draw::Atof (argv[1]);
+ Standard_Real Dy = Draw::Atof (argv[2]);
+ Standard_Real Dz = Draw::Atof (argv[3]);
Standard_Boolean aStart = Standard_True;
if (argc == 5)
{
- aStart = (atoi(argv[4]) > 0);
+ aStart = (Draw::Atoi (argv[4]) > 0);
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
di<<"Usage : " << argv[0] << " Ax Ay Az [Start = 1|0]\n";
return 1;
}
- Standard_Real Ax = atof(argv[1]);
- Standard_Real Ay = atof(argv[2]);
- Standard_Real Az = atof(argv[3]);
+ Standard_Real Ax = Draw::Atof (argv[1]);
+ Standard_Real Ay = Draw::Atof (argv[2]);
+ Standard_Real Az = Draw::Atof (argv[3]);
Standard_Boolean aStart = Standard_True;
if (argc == 5)
{
- aStart = (atoi(argv[4]) > 0);
+ aStart = (Draw::Atoi (argv[4]) > 0);
}
Handle(V3d_View) aView = ViewerTest::CurrentView();
const Standard_ShortReal theXShift,
const Standard_ShortReal theYShift,
const Standard_ShortReal theAngle);
- DEFINE_STANDARD_RTTI(OCC_TextureEnv);
+ DEFINE_STANDARD_RTTI(OCC_TextureEnv, Graphic3d_TextureEnv);
};
DEFINE_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
-IMPLEMENT_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
-IMPLEMENT_STANDARD_RTTIEXT(OCC_TextureEnv, Graphic3d_TextureEnv);
+
+
+
OCC_TextureEnv::OCC_TextureEnv(const Standard_CString theFileName)
: Graphic3d_TextureEnv(theFileName)
return 1;
}
- Standard_Real aCoeffA = atof (theArgVec [4]);
- Standard_Real aCoeffB = atof (theArgVec [5]);
- Standard_Real aCoeffC = atof (theArgVec [6]);
- Standard_Real aCoeffD = atof (theArgVec [7]);
+ Standard_Real aCoeffA = Draw::Atof (theArgVec [4]);
+ Standard_Real aCoeffB = Draw::Atof (theArgVec [5]);
+ Standard_Real aCoeffC = Draw::Atof (theArgVec [6]);
+ Standard_Real aCoeffD = Draw::Atof (theArgVec [7]);
aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
}
else if (aChangeArg == "capping") // change capping aspects
return 1;
}
- Standard_Real aRed = atof (theArgVec [5]);
- Standard_Real aGrn = atof (theArgVec [6]);
- Standard_Real aBlu = atof (theArgVec [7]);
+ Standard_Real aRed = Draw::Atof (theArgVec [5]);
+ Standard_Real aGrn = Draw::Atof (theArgVec [6]);
+ Standard_Real aBlu = Draw::Atof (theArgVec [7]);
Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
- aMat.SetColor (Quantity_Color (aRed, aGrn, aBlu, Quantity_TOC_RGB));
+ Quantity_Color aColor (aRed, aGrn, aBlu, Quantity_TOC_RGB);
+ aMat.SetAmbientColor (aColor);
+ aMat.SetDiffuseColor (aColor);
aClipPlane->SetCappingMaterial (aMat);
}
else if (aCappingArg == "texname") // texture name
if (theArgsNb == 3)
{
- Standard_Real aNewZNear = atof (theArgVec[1]);
- Standard_Real aNewZFar = atof (theArgVec[2]);
+ Standard_Real aNewZNear = Draw::Atof (theArgVec[1]);
+ Standard_Real aNewZFar = Draw::Atof (theArgVec[2]);
if (aNewZNear >= aNewZFar)
{
return 1;
}
- Standard_Real aScale = aCurrentView->AutoZFitScaleFactor();
+ Standard_Real aScale = aCurrentView->View()->AutoZFitScaleFactor();
if (theArgsNb > 3)
{
if (theArgsNb < 2)
{
theDi << "Auto z-fit mode: " << "\n"
- << "On: " << (aCurrentView->AutoZFitMode() ? "enabled" : "disabled") << "\n"
+ << "On: " << (aCurrentView->View()->AutoZFitMode() ? "enabled" : "disabled") << "\n"
<< "Scale: " << aScale << "\n";
return 0;
}
aScale = Draw::Atoi (theArgVec[2]);
}
- aCurrentView->SetAutoZFitMode (isOn, aScale);
- aCurrentView->AutoZFit();
+ aCurrentView->View()->SetAutoZFitMode (isOn, aScale);
+ aCurrentView->View()->AutoZFit();
aCurrentView->Redraw();
return 0;
}
+//! Auxiliary function to print projection type
+inline const char* projTypeName (Graphic3d_Camera::Projection theProjType)
+{
+ switch (theProjType)
+ {
+ case Graphic3d_Camera::Projection_Orthographic: return "orthographic";
+ case Graphic3d_Camera::Projection_Perspective: return "perspective";
+ case Graphic3d_Camera::Projection_Stereo: return "stereoscopic";
+ case Graphic3d_Camera::Projection_MonoLeftEye: return "monoLeftEye";
+ case Graphic3d_Camera::Projection_MonoRightEye: return "monoRightEye";
+ }
+ return "UNKNOWN";
+}
+
//===============================================================================================
-//function : VChangeCamera
+//function : VCamera
//purpose :
//===============================================================================================
-static int VChangeCamera (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+static int VCamera (Draw_Interpretor& theDI,
+ Standard_Integer theArgsNb,
+ const char** theArgVec)
{
- if (ViewerTest::CurrentView().IsNull())
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
{
- theDi << theArgVec[0] << ": Call vinit before this command, please.\n";
+ std::cout << "Error: no active view.\n";
return 1;
}
- const char anErrorMessage[] = ": wrong command arguments. Type help for more information.\n";
- if (theArgsNb < 3)
+ Handle(Graphic3d_Camera) aCamera = aView->Camera();
+ if (theArgsNb < 2)
{
- theDi << theArgVec[0] << anErrorMessage;
- return 1;
+ theDI << "ProjType: " << projTypeName (aCamera->ProjectionType()) << "\n";
+ theDI << "FOVy: " << aCamera->FOVy() << "\n";
+ theDI << "Distance: " << aCamera->Distance() << "\n";
+ theDI << "IOD: " << aCamera->IOD() << "\n";
+ theDI << "IODType: " << (aCamera->GetIODType() == Graphic3d_Camera::IODType_Absolute ? "absolute" : "relative") << "\n";
+ theDI << "ZFocus: " << aCamera->ZFocus() << "\n";
+ theDI << "ZFocusType: " << (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Absolute ? "absolute" : "relative") << "\n";
+ return 0;
}
- Handle(Graphic3d_Camera) aCamera = ViewerTest::CurrentView()->Camera();
-
- TCollection_AsciiString aCommand (theArgVec[1]);
- TCollection_AsciiString aValue (theArgVec[2]);
-
- aCommand.LowerCase();
- aValue.LowerCase();
-
- if (aCommand == "proj")
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
{
- if (aValue == "ortho")
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString anArgCase (anArg);
+ anArgCase.LowerCase();
+ if (anArgCase == "-proj"
+ || anArgCase == "-projection"
+ || anArgCase == "-projtype"
+ || anArgCase == "-projectiontype")
+ {
+ theDI << projTypeName (aCamera->ProjectionType()) << " ";
+ }
+ else if (anArgCase == "-ortho"
+ || anArgCase == "-orthographic")
{
aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
- }
- else if (aValue == "persp")
+ }
+ else if (anArgCase == "-persp"
+ || anArgCase == "-perspective"
+ || anArgCase == "-perspmono"
+ || anArgCase == "-perspectivemono"
+ || anArgCase == "-mono")
{
aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
}
- else if (aValue == "left")
+ else if (anArgCase == "-stereo"
+ || anArgCase == "-stereoscopic"
+ || anArgCase == "-perspstereo"
+ || anArgCase == "-perspectivestereo")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ }
+ else if (anArgCase == "-left"
+ || anArgCase == "-lefteye"
+ || anArgCase == "-monoleft"
+ || anArgCase == "-monolefteye"
+ || anArgCase == "-perpsleft"
+ || anArgCase == "-perpslefteye")
{
aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
}
- else if (aValue == "right")
+ else if (anArgCase == "-right"
+ || anArgCase == "-righteye"
+ || anArgCase == "-monoright"
+ || anArgCase == "-monorighteye"
+ || anArgCase == "-perpsright")
{
aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
}
- else if (aValue == "stereo")
+ else if (anArgCase == "-dist"
+ || anArgCase == "-distance")
{
- aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+ if (anArgValue != NULL
+ && *anArgValue != '-')
+ {
+ ++anArgIter;
+ aCamera->SetDistance (Draw::Atof (anArgValue));
+ continue;
+ }
+ theDI << aCamera->Distance() << " ";
+ }
+ else if (anArgCase == "-iod")
+ {
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+ if (anArgValue != NULL
+ && *anArgValue != '-')
+ {
+ ++anArgIter;
+ aCamera->SetIOD (aCamera->GetIODType(), Draw::Atof (anArgValue));
+ continue;
+ }
+ theDI << aCamera->IOD() << " ";
+ }
+ else if (anArgCase == "-iodtype")
+ {
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
+ TCollection_AsciiString anValueCase (anArgValue);
+ anValueCase.LowerCase();
+ if (anValueCase == "abs"
+ || anValueCase == "absolute")
+ {
+ ++anArgIter;
+ aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
+ continue;
+ }
+ else if (anValueCase == "rel"
+ || anValueCase == "relative")
+ {
+ ++anArgIter;
+ aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
+ continue;
+ }
+ else if (*anArgValue != '-')
+ {
+ std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
+ return 1;
+ }
+ switch (aCamera->GetIODType())
+ {
+ case Graphic3d_Camera::IODType_Absolute: theDI << "absolute "; break;
+ case Graphic3d_Camera::IODType_Relative: theDI << "relative "; break;
+ }
+ }
+ else if (anArgCase == "-zfocus")
+ {
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+ if (anArgValue != NULL
+ && *anArgValue != '-')
+ {
+ ++anArgIter;
+ aCamera->SetZFocus (aCamera->ZFocusType(), Draw::Atof (anArgValue));
+ continue;
+ }
+ theDI << aCamera->ZFocus() << " ";
+ }
+ else if (anArgCase == "-zfocustype")
+ {
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
+ TCollection_AsciiString anValueCase (anArgValue);
+ anValueCase.LowerCase();
+ if (anValueCase == "abs"
+ || anValueCase == "absolute")
+ {
+ ++anArgIter;
+ aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
+ continue;
+ }
+ else if (anValueCase == "rel"
+ || anValueCase == "relative")
+ {
+ ++anArgIter;
+ aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
+ continue;
+ }
+ else if (*anArgValue != '-')
+ {
+ std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
+ return 1;
+ }
+ switch (aCamera->ZFocusType())
+ {
+ case Graphic3d_Camera::FocusType_Absolute: theDI << "absolute "; break;
+ case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
+ }
+ }
+ else if (anArgCase == "-fov"
+ || anArgCase == "-fovy")
+ {
+ Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+ if (anArgValue != NULL
+ && *anArgValue != '-')
+ {
+ ++anArgIter;
+ aCamera->SetFOVy (Draw::Atof (anArgValue));
+ continue;
+ }
+ theDI << aCamera->FOVy() << " ";
}
else
{
- theDi << theArgVec[0] << anErrorMessage;
+ std::cout << "Error: unknown argument '" << anArg << "'\n";
return 1;
}
}
- else if (aCommand == "dist")
+
+ aView->View()->AutoZFit();
+ aView->Redraw();
+
+ return 0;
+}
+
+//! Parse stereo output mode
+inline Standard_Boolean parseStereoMode (Standard_CString theArg,
+ Graphic3d_StereoMode& theMode)
+{
+ TCollection_AsciiString aFlag (theArg);
+ aFlag.LowerCase();
+ if (aFlag == "quadbuffer")
{
- aCamera->SetDistance (aValue.RealValue());
+ theMode = Graphic3d_StereoMode_QuadBuffer;
}
- else if (aCommand == "iod")
+ else if (aFlag == "anaglyph")
{
- aCamera->SetIOD (aCamera->GetIODType(), aValue.RealValue());
+ theMode = Graphic3d_StereoMode_Anaglyph;
}
- else if (aCommand == "zfocus")
+ else if (aFlag == "row"
+ || aFlag == "rowinterlaced")
{
- aCamera->SetZFocus (aCamera->ZFocusType(), aValue.RealValue());
+ theMode = Graphic3d_StereoMode_RowInterlaced;
}
- else if (aCommand == "fov")
+ else if (aFlag == "col"
+ || aFlag == "colinterlaced"
+ || aFlag == "columninterlaced")
{
- aCamera->SetFOVy (aValue.RealValue());
+ theMode = Graphic3d_StereoMode_ColumnInterlaced;
}
- else if (aCommand == "zfocustype")
+ else if (aFlag == "chess"
+ || aFlag == "chessboard")
{
- if (aValue == "absolute")
- {
- aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
- }
- else if (aValue == "relative")
- {
- aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
- }
- else
- {
- theDi << theArgVec[0] << anErrorMessage;
- return 1;
- }
+ theMode = Graphic3d_StereoMode_ChessBoard;
}
- else if (aCommand == "iodtype")
+ else if (aFlag == "sbs"
+ || aFlag == "sidebyside")
{
- if (aValue == "absolute")
- {
- aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
- }
- else if (aValue == "relative")
- {
- aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
- }
- else
- {
- theDi << theArgVec[0] << anErrorMessage;
- return 1;
- }
+ theMode = Graphic3d_StereoMode_SideBySide;
+ }
+ else if (aFlag == "ou"
+ || aFlag == "overunder")
+ {
+ theMode = Graphic3d_StereoMode_OverUnder;
+ }
+ else if (aFlag == "pageflip"
+ || aFlag == "softpageflip")
+ {
+ theMode = Graphic3d_StereoMode_SoftPageFlip;
}
else
{
- theDi << theArgVec[0] << anErrorMessage;
- return 1;
+ return Standard_False;
}
+ return Standard_True;
+}
- ViewerTest::CurrentView()->AutoZFit();
- ViewerTest::CurrentView()->Redraw();
-
- return 0;
+//! Parse anaglyph filter
+inline Standard_Boolean parseAnaglyphFilter (Standard_CString theArg,
+ Graphic3d_RenderingParams::Anaglyph& theFilter)
+{
+ TCollection_AsciiString aFlag (theArg);
+ aFlag.LowerCase();
+ if (aFlag == "redcyansimple")
+ {
+ theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
+ }
+ else if (aFlag == "redcyan"
+ || aFlag == "redcyanoptimized")
+ {
+ theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized;
+ }
+ else if (aFlag == "yellowbluesimple")
+ {
+ theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Simple;
+ }
+ else if (aFlag == "yellowblue"
+ || aFlag == "yellowblueoptimized")
+ {
+ theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized;
+ }
+ else if (aFlag == "greenmagenta"
+ || aFlag == "greenmagentasimple")
+ {
+ theFilter = Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple;
+ }
+ else
+ {
+ return Standard_False;
+ }
+ return Standard_True;
}
//==============================================================================
Standard_Integer theArgNb,
const char** theArgVec)
{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
if (theArgNb < 2)
{
- Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ std::cout << "Error: no active viewer!\n";
return 0;
}
return 0;
}
- ViewerTest_myDefaultCaps.contextStereo = Draw::Atoi (theArgVec[1]) != 0;
+ Handle(Graphic3d_Camera) aCamera;
+ Graphic3d_RenderingParams* aParams = NULL;
+ Graphic3d_StereoMode aMode = Graphic3d_StereoMode_QuadBuffer;
+ if (!aView.IsNull())
+ {
+ aParams = &aView->ChangeRenderingParams();
+ aMode = aParams->StereoMode;
+ aCamera = aView->Camera();
+ }
+
+ ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
+ {
+ continue;
+ }
+ else if (aFlag == "0"
+ || aFlag == "off")
+ {
+ if (++anArgIter < theArgNb)
+ {
+ std::cout << "Error: wrong number of arguments!\n";
+ return 1;
+ }
+
+ if (!aCamera.IsNull()
+ && aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
+ }
+ ViewerTest_myDefaultCaps.contextStereo = Standard_False;
+ return 0;
+ }
+ else if (aFlag == "1"
+ || aFlag == "on")
+ {
+ if (++anArgIter < theArgNb)
+ {
+ std::cout << "Error: wrong number of arguments!\n";
+ return 1;
+ }
+
+ if (!aCamera.IsNull())
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ }
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+ return 0;
+ }
+ else if (aFlag == "-reverse"
+ || aFlag == "-reversed"
+ || aFlag == "-swap")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams->ToReverseStereo = toEnable;
+ }
+ else if (aFlag == "-noreverse"
+ || aFlag == "-noswap")
+ {
+ Standard_Boolean toDisable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toDisable))
+ {
+ --anArgIter;
+ }
+ aParams->ToReverseStereo = !toDisable;
+ }
+ else if (aFlag == "-mode"
+ || aFlag == "-stereomode")
+ {
+ if (++anArgIter >= theArgNb
+ || !parseStereoMode (theArgVec[anArgIter], aMode))
+ {
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
+ return 1;
+ }
+
+ if (aMode == Graphic3d_StereoMode_QuadBuffer)
+ {
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+ }
+ }
+ else if (aFlag == "-anaglyph"
+ || aFlag == "-anaglyphfilter")
+ {
+ Graphic3d_RenderingParams::Anaglyph aFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
+ if (++anArgIter >= theArgNb
+ || !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
+ {
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
+ return 1;
+ }
+
+ aMode = Graphic3d_StereoMode_Anaglyph;
+ aParams->AnaglyphFilter = aFilter;
+ }
+ else if (parseStereoMode (anArg, aMode)) // short syntax
+ {
+ if (aMode == Graphic3d_StereoMode_QuadBuffer)
+ {
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+ }
+ }
+ else
+ {
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
+ return 1;
+ }
+ }
+
+ if (!aView.IsNull())
+ {
+ aParams->StereoMode = aMode;
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ }
return 0;
}
<< "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
}
theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
+ theDi << "AutoTriangulation: " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
return 0;
}
for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
- TCollection_AsciiString aKey, aValue;
- if (!ViewerTest::SplitParameter (anArg, aKey, aValue)
- || aValue.IsEmpty())
- {
- std::cerr << "Error, wrong syntax at: '" << anArg.ToCString() << "'!\n";
- return 1;
- }
-
- aKey.UpperCase();
- if (aKey == "ABSDEFL"
- || aKey == "ABSOLUTEDEFLECTION"
- || aKey == "DEFL"
- || aKey == "DEFLECTION")
+ anArg.UpperCase();
+ if (anArg == "-ABSDEFL"
+ || anArg == "-ABSOLUTEDEFLECTION"
+ || anArg == "-DEFL"
+ || anArg == "-DEFLECTION")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
- aDefParams->SetMaximalChordialDeviation (aValue.RealValue());
+ aDefParams->SetMaximalChordialDeviation (Draw::Atof (theArgVec[anArgIter]));
}
- else if (aKey == "RELDEFL"
- || aKey == "RELATIVEDEFLECTION"
- || aKey == "DEVCOEFF"
- || aKey == "DEVIATIONCOEFF"
- || aKey == "DEVIATIONCOEFFICIENT")
+ else if (anArg == "-RELDEFL"
+ || anArg == "-RELATIVEDEFLECTION"
+ || anArg == "-DEVCOEFF"
+ || anArg == "-DEVIATIONCOEFF"
+ || anArg == "-DEVIATIONCOEFFICIENT")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
- aDefParams->SetDeviationCoefficient (aValue.RealValue());
+ aDefParams->SetDeviationCoefficient (Draw::Atof (theArgVec[anArgIter]));
}
- else if (aKey == "ANGDEFL"
- || aKey == "ANGULARDEFL"
- || aKey == "ANGULARDEFLECTION")
+ else if (anArg == "-ANGDEFL"
+ || anArg == "-ANGULARDEFL"
+ || anArg == "-ANGULARDEFLECTION")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
// currently HLRDeviationAngle is used instead of DeviationAngle in most places
- aDefParams->SetHLRAngle (M_PI * aValue.RealValue() / 180.0);
+ aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
+ }
+ else if (anArg == "-AUTOTR"
+ || anArg == "-AUTOTRIANG"
+ || anArg == "-AUTOTRIANGULATION")
+ {
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
+ TCollection_AsciiString aValue (theArgVec[anArgIter]);
+ aValue.LowerCase();
+ if (aValue == "on"
+ || aValue == "1")
+ {
+ aDefParams->SetAutoTriangulation (Standard_True);
+ }
+ else if (aValue == "off"
+ || aValue == "0")
+ {
+ aDefParams->SetAutoTriangulation (Standard_False);
+ }
}
else
{
{
case V3d_AMBIENT:
{
- theDi << " Type: Ambient\n";
+ theDi << " Type: Ambient\n";
+ theDi << " Intensity: " << aLight->Intensity() << "\n";
break;
}
case V3d_DIRECTIONAL:
{
Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLight);
- theDi << " Type: Directional\n";
- theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ theDi << " Type: Directional\n";
+ theDi << " Intensity: " << aLight->Intensity() << "\n";
+ theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ theDi << " Smoothness: " << aLight->Smoothness() << "\n";
if (!aLightDir.IsNull())
{
aLightDir->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
- theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightDir->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
- theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
}
break;
}
case V3d_POSITIONAL:
{
Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight)::DownCast (aLight);
- theDi << " Type: Positional\n";
- theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ theDi << " Type: Positional\n";
+ theDi << " Intensity: " << aLight->Intensity() << "\n";
+ theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ theDi << " Smoothness: " << aLight->Smoothness() << "\n";
if (!aLightPos.IsNull())
{
aLightPos->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
- theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightPos->Attenuation (anAtten[0], anAtten[1]);
- theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
+ theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
}
break;
}
case V3d_SPOT:
{
Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight)::DownCast (aLight);
- theDi << " Type: Spot\n";
- theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ theDi << " Type: Spot\n";
+ theDi << " Intensity: " << aLight->Intensity() << "\n";
+ theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
if (!aLightSpot.IsNull())
{
aLightSpot->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
- theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightSpot->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
- theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ theDi << " Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
aLightSpot->Attenuation (anAtten[0], anAtten[1]);
- theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
- theDi << " Angle: " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
- theDi << " Exponent: " << aLightSpot->Concentration() << "\n";
+ theDi << " Atten.: " << anAtten[0] << " " << anAtten[1] << "\n";
+ theDi << " Angle: " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
+ theDi << " Exponent: " << aLightSpot->Concentration() << "\n";
}
break;
}
default:
{
- theDi << " Type: UNKNOWN\n";
+ theDi << " Type: UNKNOWN\n";
break;
}
}
Standard_Integer aLightIt = 0;
for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
{
- aLightDel = aView->ActiveLight();
- if (aLightIt == aLightDelId)
+ aLightDel = aView->ActiveLight();
+ if (aLightIt == aLightDelId)
+ {
+ break;
+ }
+ }
+ if (!aLightDel.IsNull())
+ {
+ aViewer->DelLight (aLightDel);
+ }
+ }
+ else if (anArgCase.IsEqual ("COLOR")
+ || anArgCase.IsEqual ("COLOUR"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
+ anArgNext.UpperCase();
+ const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
+ if (!aLightCurr.IsNull())
+ {
+ aLightCurr->SetColor (aColor);
+ }
+ }
+ else if (anArgCase.IsEqual ("POS")
+ || anArgCase.IsEqual ("POSITION"))
+ {
+ if ((anArgIt + 3) >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ anXYZ[0] = Atof (theArgVec[++anArgIt]);
+ anXYZ[1] = Atof (theArgVec[++anArgIt]);
+ anXYZ[2] = Atof (theArgVec[++anArgIt]);
+ if (!aLightDir.IsNull())
+ {
+ aLightDir->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightPos.IsNull())
+ {
+ aLightPos->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("DIR")
+ || anArgCase.IsEqual ("DIRECTION"))
+ {
+ if ((anArgIt + 3) >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ anXYZ[0] = Atof (theArgVec[++anArgIt]);
+ anXYZ[1] = Atof (theArgVec[++anArgIt]);
+ anXYZ[2] = Atof (theArgVec[++anArgIt]);
+ if (!aLightDir.IsNull())
+ {
+ aLightDir->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("SM")
+ || anArgCase.IsEqual ("SMOOTHNESS"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Real aSmoothness = Atof (theArgVec[anArgIt]);
+
+ if (fabs (aSmoothness) < Precision::Confusion())
+ {
+ aLightCurr->SetIntensity (1.f);
+ }
+ else if (fabs (aLightCurr->Smoothness()) < Precision::Confusion())
+ {
+ aLightCurr->SetIntensity ((aSmoothness * aSmoothness) / 3.f);
+ }
+ else
+ {
+ Standard_ShortReal aSmoothnessRatio = static_cast<Standard_ShortReal> (aSmoothness / aLightCurr->Smoothness());
+ aLightCurr->SetIntensity (aLightCurr->Intensity() / (aSmoothnessRatio * aSmoothnessRatio));
+ }
+
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->SetSmoothRadius (aSmoothness);
+ }
+ else if (!aLightDir.IsNull())
+ {
+ aLightDir->SetSmoothAngle (aSmoothness);
+ }
+ }
+ else if (anArgCase.IsEqual ("INT")
+ || anArgCase.IsEqual ("INTENSITY"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Real aIntensity = Atof (theArgVec[anArgIt]);
+
+ if (!aLightCurr.IsNull())
+ {
+ aLightCurr->SetIntensity (aIntensity);
+ }
+ }
+ else if (anArgCase.IsEqual ("ANG")
+ || anArgCase.IsEqual ("ANGLE"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Real anAngle = Atof (theArgVec[anArgIt]);
+
+ if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetAngle (anAngle / 180.0 * M_PI);
+ }
+ }
+ else if (anArgCase.IsEqual ("CONSTATTEN")
+ || anArgCase.IsEqual ("CONSTATTENUATION"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[0] = Atof (theArgVec[anArgIt]);
+ aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[0] = Atof (theArgVec[anArgIt]);
+ aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("LINATTEN")
+ || anArgCase.IsEqual ("LINEARATTEN")
+ || anArgCase.IsEqual ("LINEARATTENUATION"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[1] = Atof (theArgVec[anArgIt]);
+ aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[1] = Atof (theArgVec[anArgIt]);
+ aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("EXP")
+ || anArgCase.IsEqual ("EXPONENT")
+ || anArgCase.IsEqual ("SPOTEXP")
+ || anArgCase.IsEqual ("SPOTEXPONENT"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetConcentration (Atof (theArgVec[anArgIt]));
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("HEAD")
+ || anArgCase.IsEqual ("HEADLIGHT"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (aLightAmb.IsNull()
+ && !aLightCurr.IsNull())
+ {
+ aLightCurr->SetHeadlight (Draw::Atoi (theArgVec[anArgIt]) != 0);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else
+ {
+ std::cerr << "Warning: unknown argument '" << anArg << "'\n";
+ }
+ }
+
+ addLight (aLightNew, isGlobal);
+ aViewer->UpdateLights();
+
+ return 0;
+}
+
+//=======================================================================
+//function : VRenderParams
+//purpose : Enables/disables rendering features
+//=======================================================================
+
+static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << "Error: no active viewer!\n";
+ return 1;
+ }
+
+ Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
+ TCollection_AsciiString aCmdName (theArgVec[0]);
+ aCmdName.LowerCase();
+ if (aCmdName == "vraytrace")
+ {
+ if (theArgNb == 1)
+ {
+ theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "on" : "off") << " ";
+ return 0;
+ }
+ else if (theArgNb == 2)
+ {
+ TCollection_AsciiString aValue (theArgVec[1]);
+ aValue.LowerCase();
+ if (aValue == "on"
+ || aValue == "1")
+ {
+ aParams.Method = Graphic3d_RM_RAYTRACING;
+ aView->Redraw();
+ return 0;
+ }
+ else if (aValue == "off"
+ || aValue == "0")
+ {
+ aParams.Method = Graphic3d_RM_RASTERIZATION;
+ aView->Redraw();
+ return 0;
+ }
+ else
+ {
+ std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
+ return 1;
+ }
+ }
+ else
+ {
+ std::cout << "Error: wrong number of arguments\n";
+ return 1;
+ }
+ }
+
+ if (theArgNb < 2)
+ {
+ theDI << "renderMode: ";
+ switch (aParams.Method)
+ {
+ case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
+ case Graphic3d_RM_RAYTRACING: theDI << "raytrace "; break;
+ }
+ theDI << "\n";
+ theDI << "fsaa: " << (aParams.IsAntialiasingEnabled ? "on" : "off") << "\n";
+ theDI << "shadows: " << (aParams.IsShadowEnabled ? "on" : "off") << "\n";
+ theDI << "reflections: " << (aParams.IsReflectionEnabled ? "on" : "off") << "\n";
+ theDI << "rayDepth: " << aParams.RaytracingDepth << "\n";
+ theDI << "gleam: " << (aParams.IsTransparentShadowEnabled ? "on" : "off") << "\n";
+ theDI << "GI: " << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << "\n";
+ theDI << "shadingModel: ";
+ switch (aView->ShadingModel())
+ {
+ case V3d_COLOR: theDI << "color"; break;
+ case V3d_FLAT: theDI << "flat"; break;
+ case V3d_GOURAUD: theDI << "gouraud"; break;
+ case V3d_PHONG: theDI << "phong"; break;
+ }
+ theDI << "\n";
+ return 0;
+ }
+
+ Standard_Boolean toPrint = Standard_False;
+ ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg (theArgVec[anArgIter]);
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
+ {
+ continue;
+ }
+ else if (aFlag == "-echo"
+ || aFlag == "-print")
+ {
+ toPrint = Standard_True;
+ anUpdateTool.Invalidate();
+ }
+ else if (aFlag == "-mode"
+ || aFlag == "-rendermode"
+ || aFlag == "-render_mode")
+ {
+ if (toPrint)
+ {
+ switch (aParams.Method)
{
- break;
+ case Graphic3d_RM_RASTERIZATION: theDI << "rasterization "; break;
+ case Graphic3d_RM_RAYTRACING: theDI << "ray-tracing "; break;
}
+ continue;
}
- if (!aLightDel.IsNull())
+ else
{
- aViewer->DelLight (aLightDel);
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
}
}
- else if (anArgCase.IsEqual ("COLOR")
- || anArgCase.IsEqual ("COLOUR"))
+ else if (aFlag == "-ray"
+ || aFlag == "-raytrace")
{
- if (++anArgIt >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "true" : "false") << " ";
+ continue;
}
- TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
- anArgNext.UpperCase();
- const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
- if (!aLightCurr.IsNull())
- {
- aLightCurr->SetColor (aColor);
- }
+ aParams.Method = Graphic3d_RM_RAYTRACING;
}
- else if (anArgCase.IsEqual ("POS")
- || anArgCase.IsEqual ("POSITION"))
+ else if (aFlag == "-rast"
+ || aFlag == "-raster"
+ || aFlag == "-rasterization")
{
- if ((anArgIt + 3) >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.Method == Graphic3d_RM_RASTERIZATION ? "true" : "false") << " ";
+ continue;
}
- anXYZ[0] = Atof (theArgVec[++anArgIt]);
- anXYZ[1] = Atof (theArgVec[++anArgIt]);
- anXYZ[2] = Atof (theArgVec[++anArgIt]);
- if (!aLightDir.IsNull())
+ aParams.Method = Graphic3d_RM_RASTERIZATION;
+ }
+ else if (aFlag == "-raydepth"
+ || aFlag == "-ray_depth")
+ {
+ if (toPrint)
{
- aLightDir->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ theDI << aParams.RaytracingDepth << " ";
+ continue;
}
- else if (!aLightPos.IsNull())
+ else if (++anArgIter >= theArgNb)
{
- aLightPos->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
}
- else if (!aLightSpot.IsNull())
+
+ const Standard_Integer aDepth = Draw::Atoi (theArgVec[anArgIter]);
+
+ // We allow RaytracingDepth be more than 10 in case of GI enabled
+ if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
{
- aLightSpot->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
+ return 1;
}
else
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ aParams.RaytracingDepth = aDepth;
}
}
- else if (anArgCase.IsEqual ("DIR")
- || anArgCase.IsEqual ("DIRECTION"))
+ else if (aFlag == "-shad"
+ || aFlag == "-shadows")
{
- if ((anArgIt + 3) >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.IsShadowEnabled ? "on" : "off") << " ";
+ continue;
}
- anXYZ[0] = Atof (theArgVec[++anArgIt]);
- anXYZ[1] = Atof (theArgVec[++anArgIt]);
- anXYZ[2] = Atof (theArgVec[++anArgIt]);
- if (!aLightDir.IsNull())
- {
- aLightDir->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
- }
- else if (!aLightSpot.IsNull())
- {
- aLightSpot->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
- }
- else
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ --anArgIter;
}
+ aParams.IsShadowEnabled = toEnable;
}
- else if (anArgCase.IsEqual ("ANG")
- || anArgCase.IsEqual ("ANGLE"))
+ else if (aFlag == "-refl"
+ || aFlag == "-reflections")
{
- if (++anArgIt >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.IsReflectionEnabled ? "on" : "off") << " ";
+ continue;
}
- Standard_Real anAngle = Atof (theArgVec[anArgIt]);
-
- if (!aLightSpot.IsNull())
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
{
- aLightSpot->SetAngle (anAngle / 180.0 * M_PI);
+ --anArgIter;
}
+ aParams.IsReflectionEnabled = toEnable;
}
- else if (anArgCase.IsEqual ("CONSTATTEN")
- || anArgCase.IsEqual ("CONSTATTENUATION"))
+ else if (aFlag == "-fsaa")
{
- if (++anArgIt >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.IsAntialiasingEnabled ? "on" : "off") << " ";
+ continue;
}
- if (!aLightPos.IsNull())
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
{
- aLightPos->Attenuation (anAtten[0], anAtten[1]);
- anAtten[0] = Atof (theArgVec[anArgIt]);
- aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ --anArgIter;
}
- else if (!aLightSpot.IsNull())
+ aParams.IsAntialiasingEnabled = toEnable;
+ }
+ else if (aFlag == "-gleam")
+ {
+ if (toPrint)
{
- aLightSpot->Attenuation (anAtten[0], anAtten[1]);
- anAtten[0] = Atof (theArgVec[anArgIt]);
- aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ theDI << (aParams.IsTransparentShadowEnabled ? "on" : "off") << " ";
+ continue;
}
- else
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ --anArgIter;
}
+ aParams.IsTransparentShadowEnabled = toEnable;
}
- else if (anArgCase.IsEqual ("LINATTEN")
- || anArgCase.IsEqual ("LINEARATTEN")
- || anArgCase.IsEqual ("LINEARATTENUATION"))
+ else if (aFlag == "-gi")
{
- if (++anArgIt >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << " ";
+ continue;
}
- if (!aLightPos.IsNull())
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
{
- aLightPos->Attenuation (anAtten[0], anAtten[1]);
- anAtten[1] = Atof (theArgVec[anArgIt]);
- aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ --anArgIter;
}
- else if (!aLightSpot.IsNull())
+ aParams.IsGlobalIlluminationEnabled = toEnable;
+ if (!toEnable)
{
- aLightSpot->Attenuation (anAtten[0], anAtten[1]);
- anAtten[1] = Atof (theArgVec[anArgIt]);
- aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ aParams.RaytracingDepth = Min (aParams.RaytracingDepth, 10);
}
- else
+ }
+ else if (aFlag == "-env")
+ {
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ theDI << (aParams.UseEnvironmentMapBackground ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !parseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
}
+ aParams.UseEnvironmentMapBackground = toEnable;
}
- else if (anArgCase.IsEqual ("EXP")
- || anArgCase.IsEqual ("EXPONENT")
- || anArgCase.IsEqual ("SPOTEXP")
- || anArgCase.IsEqual ("SPOTEXPONENT"))
+ else if (aFlag == "-shademodel"
+ || aFlag == "-shadingmodel"
+ || aFlag == "-shading")
{
- if (++anArgIt >= theArgsNb)
+ if (toPrint)
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ switch (aView->ShadingModel())
+ {
+ case V3d_COLOR: theDI << "color "; break;
+ case V3d_FLAT: theDI << "flat "; break;
+ case V3d_GOURAUD: theDI << "gouraud "; break;
+ case V3d_PHONG: theDI << "phong "; break;
+ }
+ continue;
}
- if (!aLightSpot.IsNull())
+ if (++anArgIter >= theArgNb)
{
- aLightSpot->SetConcentration (Atof (theArgVec[anArgIt]));
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
}
- else
+
+ TCollection_AsciiString aMode (theArgVec[anArgIter]);
+ aMode.LowerCase();
+ if (aMode == "color"
+ || aMode == "none")
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ aView->SetShadingModel (V3d_COLOR);
}
- }
- else if (anArgCase.IsEqual ("HEAD")
- || anArgCase.IsEqual ("HEADLIGHT"))
- {
- if (++anArgIt >= theArgsNb)
+ else if (aMode == "flat"
+ || aMode == "facet")
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
- return 1;
+ aView->SetShadingModel (V3d_FLAT);
}
-
- if (aLightAmb.IsNull()
- && !aLightCurr.IsNull())
+ else if (aMode == "gouraud"
+ || aMode == "vertex"
+ || aMode == "vert")
{
- aLightCurr->SetHeadlight (Draw::Atoi (theArgVec[anArgIt]) != 0);
+ aView->SetShadingModel (V3d_GOURAUD);
+ }
+ else if (aMode == "phong"
+ || aMode == "fragment"
+ || aMode == "frag"
+ || aMode == "pixel")
+ {
+ aView->SetShadingModel (V3d_PHONG);
}
else
{
- std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ std::cout << "Error: unknown shading model '" << aMode << "'\n";
return 1;
}
}
else
{
- std::cerr << "Warning: unknown argument '" << anArg << "'\n";
+ std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
+ return 1;
}
}
- addLight (aLightNew, isGlobal);
- aViewer->UpdateLights();
-
return 0;
}
+//=======================================================================
+//function : VProgressiveMode
+//purpose :
+//=======================================================================
+#if defined(_WIN32)
+static Standard_Integer VProgressiveMode (Draw_Interpretor& /*theDI*/,
+ Standard_Integer /*theNbArgs*/,
+ const char** /*theArgs*/)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << "Error: no active viewer!\n";
+ return 1;
+ }
+
+ std::cout << "Press Enter or Escape key to exit progressive rendering mode" << std::endl;
+
+ for (;;)
+ {
+ aView->Redraw();
+
+ Standard_Boolean toExit = Standard_False;
+ MSG aMsg;
+ while (PeekMessage (&aMsg, NULL, NULL, NULL, PM_REMOVE))
+ {
+ if (aMsg.message == WM_KEYDOWN && (aMsg.wParam == 0x0d || aMsg.wParam == 0x1b))
+ {
+ toExit = Standard_True;
+ }
-//==============================================================================
-//function : VClInfo
-//purpose : Prints info about active OpenCL device
-//==============================================================================
+ TranslateMessage (&aMsg);
+ DispatchMessage (&aMsg);
+ }
-static Standard_Integer VClInfo (Draw_Interpretor& theDi,
- Standard_Integer,
- const char**)
+ if (toExit)
+ {
+ break;
+ }
+ }
+
+ return 0;
+}
+#endif
+
+//=======================================================================
+//function : VFrustumCulling
+//purpose : enables/disables view volume's culling.
+//=======================================================================
+static int VFrustumCulling (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
- Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
- if (aContextAIS.IsNull())
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
{
- std::cerr << "Call vinit before!\n";
+ std::cout << theArgVec[0] << " Error: Use 'vinit' command before\n";
return 1;
}
- Handle(OpenGl_GraphicDriver) aDrv = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
- Graphic3d_CView* aCView = static_cast<Graphic3d_CView*> (ViewerTest::CurrentView()->View()->CView());
- NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString> anInfo;
- if (aDrv.IsNull()
- || aCView == NULL
- || !aDrv->GetOpenClDeviceInfo (*aCView, anInfo))
+ if (theArgNb < 2)
{
- theDi << "OpenCL device info is unavailable!\n";
+ theDI << (aView->IsCullingEnabled() ? "on" : "off");
return 0;
}
+ else if (theArgNb != 2)
+ {
+ std::cout << theArgVec[0] << " Syntax error: Specify the mode\n";
+ return 1;
+ }
- theDi << "OpenCL device info:\n";
- for (NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>::Iterator anIter (anInfo);
- anIter.More(); anIter.Next())
+ TCollection_AsciiString aModeStr (theArgVec[1]);
+ aModeStr.LowerCase();
+ Standard_Boolean toEnable = 0;
+ if (aModeStr == "on")
+ {
+ toEnable = 1;
+ }
+ else if (aModeStr == "off")
+ {
+ toEnable = 0;
+ }
+ else
{
- theDi << anIter.Key() << ": \t" << anIter.Value() << "\n";
+ toEnable = Draw::Atoi (theArgVec[1]) != 0;
}
+
+ aView->SetFrustumCulling (toEnable);
+ aView->Redraw();
return 0;
}
//=======================================================================
-//function : VRaytrace
-//purpose : Enables/disables OpenCL-based ray-tracing
+//function : VHighlightSelected
+//purpose :
//=======================================================================
-
-static Standard_Integer VRaytrace (Draw_Interpretor& ,
- Standard_Integer theArgNb,
- const char** theArgVec)
+static int VHighlightSelected (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
+ if (ViewerTest::GetAISContext().IsNull())
+ {
+ std::cout << theArgVec[0] << " error : Context is not created. Please call vinit before.\n";
+ return 1;
+ }
+
+ const Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+
+ if (theArgNb < 2)
+ {
+ theDI << (aContext->ToHilightSelected() ? "on" : "off");
+ return 0;
+ }
+
+ if (theArgNb != 2)
{
- std::cerr << "Use 'vinit' command before " << theArgVec[0] << "\n";
+ std::cout << theArgVec[0] << " error : wrong number of parameters."
+ << "Type 'help" << theArgVec[0] << "' for more information.";
return 1;
}
- if (theArgNb < 2
- || Draw::Atoi (theArgVec[1]))
+ // Parse parameter
+ TCollection_AsciiString aMode (theArgVec[1]);
+ aMode.LowerCase();
+ Standard_Boolean toEnable = Standard_False;
+ if (aMode.IsEqual ("on"))
{
- aView->SetRaytracingMode();
+ toEnable = Standard_True;
+ }
+ else if (aMode.IsEqual ("off"))
+ {
+ toEnable = Standard_False;
}
else
{
- aView->SetRasterizationMode();
+ toEnable = Draw::Atoi (theArgVec[1]) != 0;
}
- aView->Redraw();
+
+ if (toEnable != aContext->ToHilightSelected())
+ {
+ aContext->SetToHilightSelected (toEnable);
+
+ // Move cursor to null position and back to process updating of detection
+ // and highlighting of selected object immediatly.
+ Standard_Integer aPixX = 0;
+ Standard_Integer aPixY = 0;
+ const Handle(ViewerTest_EventManager)& anEventManager = ViewerTest::CurrentEventManager();
+
+ anEventManager->GetCurrentPosition (aPixX, aPixY);
+ anEventManager->MoveTo (0, 0);
+ anEventManager->MoveTo (aPixX, aPixY);
+ }
+
return 0;
}
//=======================================================================
-//function : VSetRaytraceMode
-//purpose : Enables/disables features of OpenCL-based ray-tracing
+//function : VXRotate
+//purpose :
//=======================================================================
-
-static Standard_Integer VSetRaytraceMode (Draw_Interpretor&,
- Standard_Integer theArgNb,
- const char ** theArgVec)
+static Standard_Integer VXRotate (Draw_Interpretor& di,
+ Standard_Integer argc,
+ const char ** argv)
{
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
+ Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+ if (aContext.IsNull())
{
- std::cerr << "Use 'vinit' command before " << theArgVec[0] << "\n";
+ di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
return 1;
}
- else if (theArgNb < 2)
+
+ if (argc != 3)
{
- std::cerr << "Usage : " << theArgVec[0] << " [shad=0|1] [refl=0|1] [aa=0|1]\n";
+ di << "ERROR : Usage : " << argv[0] << " name angle" << "\n";
return 1;
}
- for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ TCollection_AsciiString aName (argv[1]);
+ Standard_Real anAngle = Draw::Atof (argv[2]);
+
+ // find object
+ ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
+ Handle(AIS_InteractiveObject) anIObj;
+ if (!aMap.IsBound2 (aName) )
+ {
+ di << "Use 'vdisplay' before" << "\n";
+ return 1;
+ }
+ else
{
- const TCollection_AsciiString anArg (theArgVec[anArgIter]);
+ anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
- if (anArg.Search ("shad=") > -1)
- {
- if (anArg.Token ("=", 2).IntegerValue() != 0)
- aView->EnableRaytracedShadows();
- else
- aView->DisableRaytracedShadows();
- }
- else if (anArg.Search ("refl=") > -1)
- {
- if (anArg.Token ("=", 2).IntegerValue() != 0)
- aView->EnableRaytracedReflections();
- else
- aView->DisableRaytracedReflections();
- }
- else if (anArg.Search ("aa=") > -1)
- {
- if (anArg.Token ("=", 2).IntegerValue() != 0)
- aView->EnableRaytracedAntialiasing();
- else
- aView->DisableRaytracedAntialiasing();
- }
- else
- {
- std::cerr << "Unknown argument: " << anArg << "\n";
- }
+ gp_Trsf aTransform;
+ aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
+ aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
+
+ aContext->SetLocation (anIObj, aTransform);
+ aContext->UpdateCurrentViewer();
}
- aView->Redraw();
return 0;
}
"vpick : vpick X Y Z [shape subshape] ( all variables as string )",
VPick,group);
theCommands.Add("vfit" ,
- "vfit or <F> : vfit",
+ "vfit or <F> [-selected]"
+ "\n\t\t: [-selected] fits the scene according to bounding box of currently selected objects",
__FILE__,VFit,group);
+ theCommands.Add ("vfitarea",
+ "vfitarea x1 y1 x2 y2"
+ "\n\t\t: vfitarea x1 y1 z1 x2 y2 z2"
+ "\n\t\t: Fit view to show area located between two points"
+ "\n\t\t: given in world 2D or 3D corrdinates.",
+ __FILE__, VFitArea, group);
theCommands.Add ("vzfit", "vzfit [scale]\n"
" Matches Z near, Z far view volume planes to the displayed objects.\n"
" \"scale\" - specifies factor to scale computed z range.\n",
"vscale : vscale X Y Z",
__FILE__,VScale,group);
theCommands.Add("vzbufftrihedron",
- "vzbufftrihedron [center|left_lower|left_upper|right_lower|right_upper"
- " textR=255 textG=255 textB=255 scale=0.1 wireframe|zbuffer]"
- " : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron",
- __FILE__,VTestZBuffTrihedron,group);
+ "vzbufftrihedron [{-on|-off}=-on] [-type {wireframe|zbuffer}=zbuffer]"
+ "\n\t\t: [-position center|left_lower|left_upper|right_lower|right_upper]"
+ "\n\t\t: [-scale value=0.1] [-size value=0.8] [-arrowDiam value=0.05]"
+ "\n\t\t: [-colorArrowX color=RED] [-colorArrowY color=GREEN] [-colorArrowZ color=BLUE]"
+ "\n\t\t: [-nbfacets value=12] [-colorLabels color=WHITE]"
+ "\n\t\t: Displays a trihedron",
+ __FILE__,VZBuffTrihedron,group);
theCommands.Add("vrotate",
- "vrotate : vrotate AX AY AZ [X Y Z]",
+ "vrotate [[-mouseStart X Y] [-mouseMove X Y]]|[AX AY AZ [X Y Z]]"
+ "\n : Option -mouseStart starts rotation according to the mouse position"
+ "\n : Option -mouseMove continues rotation with angle computed"
+ "\n : from last and new mouse position."
+ "\n : vrotate AX AY AZ [X Y Z]",
__FILE__,VRotate,group);
theCommands.Add("vzoom",
"vzoom : vzoom coef",
" : notice that EMF format requires patched gl2ps",
__FILE__,VExport,group);
theCommands.Add("vcolorscale",
- "vcolorscale : vcolorscale [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = 2 X = 0 Y = 0]: draw color scale",
+ "vcolorscale : vcolorscale [-range RangeMin = 0 RangeMax = 100 Intervals = 10 -font HeightFont = 16 -textpos "
+ "Position = left -xy X = 0 Y = 0] [-noupdate|-update]: draw color scale\n"
+ "-demo/-demoversion draw a demoversion of color scale.\n"
+ "-show/display display color scale.\n"
+ "-hide/erase erase color scale.\n"
+ "Please note that -show/-hide option must be the first argument!\n"
+ "-color Index R G B: set color for indexed interval\n"
+ "-color Index ColorName: set color for indexed interval\n"
+ "-colors R G B R G B ...: set colors for all intervals\n"
+ "-colors ColorName1 ColorName2 ...: set colors for all intervals\n"
+ "-colors supports both color names and rgb values in one call\n"
+ "-label Index Text: set label for indexed interval\n"
+ "-labels Text Text Text ...: set labels for all intervals\n"
+ "-title Title [Position]: set the title for color scale with certain position. Default position = center;\n"
+ "Available text positions: left, right, center, none;\n",
__FILE__,VColorScale,group);
theCommands.Add("vgraduatedtrihedron",
- "vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
+ "vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
+ "\t[-namefont Name] [-valuesfont Name]\n"
+ "\t[-xdrawname on/off] [-ydrawname on/off] [-zdrawname on/off]\n"
+ "\t[-xnameoffset IntVal] [-ynameoffset IntVal] [-znameoffset IntVal]"
+ "\t[-xnamecolor Color] [-ynamecolor Color] [-znamecolor Color]\n"
+ "\t[-xdrawvalues on/off] [-ydrawvalues on/off] [-zdrawvalues on/off]\n"
+ "\t[-xvaluesoffset IntVal] [-yvaluesoffset IntVal] [-zvaluesoffset IntVal]"
+ "\t[-xcolor Color] [-ycolor Color] [-zcolor Color]\n"
+ "\t[-xdrawticks on/off] [-ydrawticks on/off] [-zdrawticks on/off]\n"
+ "\t[-xticks Number] [-yticks Number] [-zticks Number]\n"
+ "\t[-xticklength IntVal] [-yticklength IntVal] [-zticklength IntVal]\n"
+ "\t[-drawgrid on/off] [-drawaxes on/off]\n"
+ " - Displays or erases graduated trihedron"
+ " - xname, yname, zname - names of axes, default: X, Y, Z\n"
+ " - namefont - font of axes names. Default: Arial\n"
+ " - xnameoffset, ynameoffset, znameoffset - offset of name from values or tickmarks or axis. Default: 30\n"
+ " - xnamecolor, ynamecolor, znamecolor - colors of axes names\n"
+ " - xvaluesoffset, yvaluesoffset, zvaluesoffset - offset of values from tickmarks or axis. Default: 10\n"
+ " - valuesfont - font of axes values. Default: Arial\n"
+ " - xcolor, ycolor, zcolor - color of axis and values\n"
+ " - xticks, yticks, xzicks - number of tickmark on axes. Default: 5\n"
+ " - xticklength, yticklength, xzicklength - length of tickmark on axes. Default: 10\n",
__FILE__,VGraduatedTrihedron,group);
theCommands.Add("vprintview" ,
"vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
__FILE__,VPrintView,group);
theCommands.Add("vzlayer",
- "vzlayer : add/del/get [id] : Z layer operations in v3d viewer: add new z layer, delete z layer, get z layer ids",
+ "vzlayer add/del/get/settings/enable/disable [id]\n"
+ " add - add new z layer to viewer and print its id\n"
+ " del - del z layer by its id\n"
+ " get - print sequence of z layers in increasing order of their overlay level\n"
+ " settings - print status of z layer settings\n"
+ " enable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n enables given setting for the z layer\n"
+ " enable (p[ositive]offset/n[egative]offset) \n enables given setting for the z layer\n"
+ " disable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n disables given setting for the z layer\n"
+ "\nWhere id is the layer identificator\n"
+ "\nExamples:\n"
+ " vzlayer add\n"
+ " vzlayer enable poffset 1\n"
+ " vzlayer disable depthtest 1\n"
+ " vzlayer del 1\n",
__FILE__,VZLayer,group);
theCommands.Add("voverlaytext",
"voverlaytext : text x y [height] [font_name] [text_color: R G B] [display_type] [background_color: R G B]"
" : Mode - rectangular or circular"
" : Type - lines or points",
__FILE__, VGrid, group);
+ theCommands.Add ("vpriviledgedplane",
+ "vpriviledgedplane [Ox Oy Oz Nx Ny Nz [Xx Xy Xz]]"
+ "\n\t\t: Ox, Oy, Oz - plane origin"
+ "\n\t\t: Nx, Ny, Nz - plane normal direction"
+ "\n\t\t: Xx, Xy, Xz - plane x-reference axis direction"
+ "\n\t\t: Sets or prints viewer's priviledged plane geometry.",
+ __FILE__, VPriviledgedPlane, group);
+ theCommands.Add ("vconvert",
+ "vconvert v [Mode={window|view}]"
+ "\n\t\t: vconvert x y [Mode={window|view|grid|ray}]"
+ "\n\t\t: vconvert x y z [Mode={window|grid}]"
+ "\n\t\t: window - convert to window coordinates, pixels"
+ "\n\t\t: view - convert to view projection plane"
+ "\n\t\t: grid - convert to model coordinates, given on grid"
+ "\n\t\t: ray - convert projection ray to model coordiantes"
+ "\n\t\t: - vconvert v window : convert view to window;"
+ "\n\t\t: - vconvert v view : convert window to view;"
+ "\n\t\t: - vconvert x y window : convert view to window;"
+ "\n\t\t: - vconvert x y view : convert window to view;"
+ "\n\t\t: - vconvert x y : convert window to model;"
+ "\n\t\t: - vconvert x y grid : convert window to model using grid;"
+ "\n\t\t: - vconvert x y ray : convert window projection line to model;"
+ "\n\t\t: - vconvert x y z window : convert model to window;"
+ "\n\t\t: - vconvert x y z grid : convert view to model using grid;"
+ "\n\t\t: Converts the given coordinates to window/view/model space.",
+ __FILE__, VConvert, group);
theCommands.Add ("vfps",
"vfps [framesNb=100] : estimate average frame rate for active view",
__FILE__, VFps, group);
theCommands.Add ("vgldebug",
- "vgldebug [{0|1}] : request debug GL context, should be called before vinit\n"
- " : this function is implemented only for Windows\n"
- " : GL_ARB_debug_output extension should be exported by OpenGL driver!",
+ "vgldebug [-sync {0|1}] [-debug {0|1}] [-glslWarn {0|1}]"
+ "\n\t\t: [-extraMsg {0|1}] [{0|1}]"
+ "\n\t\t: Request debug GL context. Should be called BEFORE vinit."
+ "\n\t\t: Debug context can be requested only on Windows"
+ "\n\t\t: with GL_ARB_debug_output extension implemented by GL driver!"
+ "\n\t\t: -sync - request synchronized debug GL context"
+ "\n\t\t: -glslWarn - log GLSL compiler/linker warnings,"
+ "\n\t\t: which are suppressed by default,"
+ "\n\t\t: -extraMsg - log extra diagnostic messages from GL context,"
+ "\n\t\t: which are suppressed by default",
__FILE__, VGlDebug, group);
theCommands.Add ("vvbo",
"vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
__FILE__, VVbo, group);
theCommands.Add ("vstereo",
- "\nvstereo [{0|1}] : turn stereo usage On/Off; affects only newly displayed objects",
+ "vstereo [0|1] [-mode Mode] [-reverse {0|1}]"
+ "\n\t\t: [-anaglyph Filter]"
+ "\n\t\t: Control stereo output mode. 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: anaglyph - Anaglyph glasses"
+ "\n\t\t: rowInterlaced - row-interlaced display"
+ "\n\t\t: columnInterlaced - column-interlaced display"
+ "\n\t\t: chessBoard - chess-board output"
+ "\n\t\t: sideBySide - horizontal pair"
+ "\n\t\t: overUnder - vertical pair"
+ "\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 [vbo={0|1}] [sprites={0|1}] [soft={0|1}] : modify particular graphic driver options",
+ "vcaps [-vbo {0|1}] [-sprites {0|1}] [-ffp {0|1}]"
+ "\n\t\t: [-compatibleContext {0|1}]"
+ "\n\t\t: [-vsync {0|1}]"
+ "\n\t\t: [-quadBuffer {0|1}] [-stereo {0|1}]"
+ "\n\t\t: [-softMode {0|1}] [-noupdate|-update]"
+ "\n\t\t: Modify particular graphic driver options:"
+ "\n\t\t: FFP - use fixed-function pipeline instead of"
+ "\n\t\t: built-in GLSL programs"
+ "\n\t\t: (requires compatible profile)"
+ "\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"
+ "\n\t\t: vsync - switch VSync on or off"
+ "\n\t\t: Context creation options:"
+ "\n\t\t: softMode - software OpenGL implementation"
+ "\n\t\t: compatibleProfile - backward-compatible profile"
+ "\n\t\t: quadbuffer - QuadBuffer"
+ "\n\t\t: Unlike vrenderparams, these parameters control alternative"
+ "\n\t\t: rendering paths producing the same visual result when"
+ "\n\t\t: possible."
+ "\n\t\t: Command is intended for testing old hardware compatibility.",
__FILE__, VCaps, group);
theCommands.Add ("vmemgpu",
"vmemgpu [f]: print system-dependent GPU memory information if available;"
"diffimage : diffimage imageFile1 imageFile2 toleranceOfColor(0..1) blackWhite(1|0) borderFilter(1|0) [diffImageFile]",
__FILE__, VDiffImage, group);
theCommands.Add ("vselect",
- "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [shift_selection = 0|1]\n"
+ "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [-allowoverlap 0|1] [shift_selection = 0|1]\n"
"- emulates different types of selection:\n"
"- 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) any of these selections with shift button pressed",
+ "- 4) -allowoverlap determines will partially included objects be selected in rectangular selection"
+ " (partial inclusion - overlap - is not allowed by default)\n"
+ "- 5) any of these selections with shift button pressed",
__FILE__, VSelect, group);
theCommands.Add ("vmoveto",
"vmoveto x y"
__FILE__,VZClipping,group);
theCommands.Add ("vnbselected",
"vnbselected", __FILE__, VNbSelected, group);
- theCommands.Add ("vchangecamera",
- " changes camera parameters \n"
- "- vchangecamera [param_type] [value]\n"
- "- vchangecamera proj {ortho/persp/left/right/stereo}\n"
- " Projection type including left and right stereo parts.\n"
- "- vchangecamera dist [real]\n"
- " Sets distance from target point to camera eye (moving eye).\n"
- "- vchangecamera iod [real]\n"
- " Intraocular distance value.\n"
- "- vchangecamera zfocus [real]\n"
- " Stereographic focus value.\n"
- "- vchangecamera fov [real]\n"
- " Field Of View value (in degrees).\n"
- "- vchangecamera zfocustype {absolute/relative}\n"
- " Stereographic focus definition type (absolute value or coefficient).\n"
- "- vchangecamera iodtype {absolute/relative}\n"
- " Intraocular distance definition type (absolute value or coefficient).\n",
- __FILE__, VChangeCamera, group);
+ theCommands.Add ("vcamera",
+ "vcamera [-ortho] [-projtype]"
+ "\n\t\t: [-persp]"
+ "\n\t\t: [-fovy [Angle]] [-distance [Distance]]"
+ "\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: Manage camera parameters."
+ "\n\t\t: Prints current value when option called without argument."
+ "\n\t\t: Orthographic camera:"
+ "\n\t\t: -ortho activate orthographic projection"
+ "\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: -distance distance of eye from camera center"
+ "\n\t\t: Stereoscopic camera:"
+ "\n\t\t: -stereo perspective projection (stereo)"
+ "\n\t\t: -leftEye perspective projection (left eye)"
+ "\n\t\t: -rightEye perspective projection (right eye)"
+ "\n\t\t: -iod intraocular distance value"
+ "\n\t\t: -iodType distance type, absolute or relative"
+ "\n\t\t: -zfocus stereographic focus value"
+ "\n\t\t: -zfocusType focus type, absolute or relative",
+ __FILE__, VCamera, group);
theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
"- vautozfit [on={1|0}] [scale]\n"
" Prints or changes parameters of automatic z-fit mode:\n"
" this command sets texture details mode for the specified view.\n"
, __FILE__, VSetTextureMode, group);
theCommands.Add("vdefaults",
- "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
- __FILE__, VDefaults, group);
+ "vdefaults [-absDefl value]"
+ "\n\t\t: [-devCoeff value]"
+ "\n\t\t: [-angDefl value]"
+ "\n\t\t: [-autoTriang {off/on | 0/1}]"
+ , __FILE__, VDefaults, group);
theCommands.Add("vlight",
"tool to manage light sources, without arguments shows list of lights."
"\n Main commands: "
"\n {dir}ection X Y Z (for directional light or for spotlight)"
"\n color colorName"
"\n {head}light 0|1"
+ "\n {sm}oothness value"
+ "\n {int}ensity value"
"\n {constAtten}uation value"
"\n {linearAtten}uation value"
"\n angle angleDeg"
"\n example: vlight change 0 direction 0 -1 0 linearAttenuation 0.2",
__FILE__, VLight, group);
theCommands.Add("vraytrace",
- "vraytrace 0|1",
- __FILE__,VRaytrace,group);
- theCommands.Add("vclinfo",
- "vclinfo",
- __FILE__,VClInfo,group);
- theCommands.Add("vsetraytracemode",
- "vsetraytracemode [shad=0|1] [refl=0|1] [aa=0|1]",
- __FILE__,VSetRaytraceMode,group);
+ "vraytrace [0|1]"
+ "\n\t\t: Turns on/off ray-tracing renderer."
+ "\n\t\t: 'vraytrace 0' alias for 'vrenderparams -raster'."
+ "\n\t\t: 'vraytrace 1' alias for 'vrenderparams -rayTrace'.",
+ __FILE__, VRenderParams, group);
+ theCommands.Add("vrenderparams",
+ "\n Manages rendering parameters: "
+ "\n '-rayTrace' Enables GPU ray-tracing"
+ "\n '-raster' Disables GPU ray-tracing"
+ "\n '-rayDepth 0..10' Defines maximum ray-tracing depth"
+ "\n '-shadows on|off' Enables/disables shadows rendering"
+ "\n '-reflections on|off' Enables/disables specular reflections"
+ "\n '-fsaa on|off' Enables/disables adaptive anti-aliasing"
+ "\n '-gleam on|off' Enables/disables transparency shadow effects"
+ "\n '-gi on|off' Enables/disables global illumination effects"
+ "\n '-env on|off' Enables/disables environment map background"
+ "\n '-shadingModel model' Controls shading model from enumeration"
+ "\n color, flat, gouraud, phong"
+ "\n Unlike vcaps, these parameters dramatically change visual properties."
+ "\n Command is intended to control presentation quality depending on"
+ "\n hardware capabilities and performance.",
+ __FILE__, VRenderParams, group);
+ theCommands.Add("vfrustumculling",
+ "vfrustumculling [toEnable]: enables/disables objects clipping",
+ __FILE__,VFrustumCulling,group);
+ theCommands.Add("vhighlightselected",
+ "vhighlightselected [0|1] or vhighlightselected [on|off]: enables/disables highlighting of selected objects.\n"
+ "Without arguments it shows if highlighting of selected objects is enabled now.",
+ __FILE__,VHighlightSelected,group);
+ theCommands.Add ("vplace",
+ "vplace dx dy"
+ "\n\t\t: Places the point (in pixels) at the center of the window",
+ __FILE__, VPlace, group);
+ theCommands.Add("vxrotate",
+ "vxrotate",
+ __FILE__,VXRotate,group);
+
+#if defined(_WIN32)
+ theCommands.Add("vprogressive",
+ "vprogressive",
+ __FILE__, VProgressiveMode, group);
+#endif
}
projects / occt.git / blobdiff