// commercial license or contractual agreement.
#include <OpenGl_GlCore20.hxx>
+#include <AIS_ColorScale.hxx>
+#include <AIS_Manipulator.hxx>
+#include <AIS_RubberBand.hxx>
#include <AIS_Shape.hxx>
#include <AIS_InteractiveObject.hxx>
#include <AIS_ListOfInteractive.hxx>
#include <AIS_ListIteratorOfListOfInteractive.hxx>
#include <DBRep.hxx>
+#include <Graphic3d_ArrayOfPolylines.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_NameOfTextureEnv.hxx>
#include <ViewerTest_EventManager.hxx>
#include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
-#include <Visual3d_View.hxx>
-#include <Visual3d_ViewManager.hxx>
+#include <ViewerTest_CmdParser.hxx>
#include <V3d_AmbientLight.hxx>
-#include <V3d_ColorScale.hxx>
#include <V3d_DirectionalLight.hxx>
-#include <V3d_LayerMgr.hxx>
-#include <V3d_LayerMgrPointer.hxx>
#include <V3d_PositionalLight.hxx>
#include <V3d_SpotLight.hxx>
#include <NCollection_DoubleMap.hxx>
#include <Draw_Interpretor.hxx>
#include <Draw.hxx>
#include <Draw_Appli.hxx>
-#include <Aspect_PrintAlgo.hxx>
#include <Image_AlienPixMap.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OSD_Timer.hxx>
#include <TColStd_HSequenceOfReal.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_MapOfAsciiString.hxx>
-#include <Visual3d_LayerItem.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Image_Diff.hxx>
#include <Aspect_DisplayConnection.hxx>
#include <Graphic3d_Texture2Dmanual.hxx>
#include <Prs3d_ShadingAspect.hxx>
#include <Prs3d_Drawer.hxx>
+#include <Prs3d_LineAspect.hxx>
+#include <Prs3d_Root.hxx>
-#ifdef WNT
+#ifdef _WIN32
#undef DrawText
#endif
-#include <Visual3d_Layer.hxx>
#include <cstdlib>
#if defined(_WIN32)
#include <WNT_WClass.hxx>
#include <WNT_Window.hxx>
-
- #if defined(_MSC_VER)
- #define _CRT_SECURE_NO_DEPRECATE
- #pragma warning (disable:4996)
- #endif
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
#include <Cocoa_Window.hxx>
#else
#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;
static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
static OpenGl_Caps ViewerTest_myDefaultCaps;
-#define ZCLIPWIDTH 1.
-
static void OSWindowSetup();
+static struct
+{
+ Quantity_Color FlatColor;
+ Quantity_Color GradientColor1;
+ Quantity_Color GradientColor2;
+ Aspect_GradientFillMethod FillMethod;
+} ViewerTest_DefaultBackground = { Quantity_NOC_BLACK, Quantity_NOC_BLACK, Quantity_NOC_BLACK, Aspect_GFM_NONE };
+
//==============================================================================
// EVENT GLOBAL VARIABLES
//==============================================================================
static int Start_Rot = 0;
-static int ZClipIsOn = 0;
int X_Motion = 0; // Current cursor position
int Y_Motion = 0;
int X_ButtonPress = 0; // Last ButtonPress position
Standard_Boolean IsDragged = Standard_False;
Standard_Boolean DragFirst = Standard_False;
+
+Standard_EXPORT const Handle(AIS_RubberBand)& GetRubberBand()
+{
+ static Handle(AIS_RubberBand) aBand;
+ if (aBand.IsNull())
+ {
+ aBand = new AIS_RubberBand (Quantity_NOC_LIGHTBLUE, Aspect_TOL_SOLID, Quantity_NOC_LIGHTBLUE, 0.4, 1.0);
+ aBand->SetDisplayMode (0);
+ }
+ return aBand;
+}
+
+typedef NCollection_Map<AIS_Manipulator*> ViewerTest_MapOfAISManipulators;
+
+Standard_EXPORT ViewerTest_MapOfAISManipulators& GetMapOfAISManipulators()
+{
+ static ViewerTest_MapOfAISManipulators aMap;
+ return aMap;
+}
+
+Standard_EXPORT Handle(AIS_Manipulator) GetActiveAISManipulator()
+{
+ ViewerTest_MapOfAISManipulators::Iterator anIt (GetMapOfAISManipulators());
+ for (; anIt.More(); anIt.Next())
+ {
+ if (anIt.Value()->HasActiveMode())
+ {
+ return anIt.Value();
+ }
+ }
+ return NULL;
+}
+
//==============================================================================
-#ifdef WNT
+#ifdef _WIN32
static LRESULT WINAPI ViewerWindowProc(
HWND hwnd,
UINT uMsg,
#if defined(_WIN32)
if (theWClass.IsNull())
{
- theWClass = new WNT_WClass ("GW3D_Class", AdvViewerWindowProc,
+ theWClass = new WNT_WClass ("GW3D_Class", (Standard_Address )AdvViewerWindowProc,
CS_VREDRAW | CS_HREDRAW, 0, 0,
::LoadCursor (NULL, IDC_ARROW));
}
(void)theDisplayName; // avoid warning on unused argument
SetDisplayConnection (new Aspect_DisplayConnection ());
#endif
+
+ if (Draw_VirtualWindows)
+ {
+ // don't waste the time waiting for VSync when window is not displayed on the screen
+ ViewerTest_myDefaultCaps.swapInterval = 0;
+ // alternatively we can disable buffer swap at all, but this might be inappropriate for testing
+ //ViewerTest_myDefaultCaps.buffersNoSwap = true;
+ }
aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
+
ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
toCreateViewer = Standard_True;
}
// Change name of current active window
if (!ViewerTest::CurrentView().IsNull())
{
- TCollection_AsciiString aTitle("3D View - ");
- aTitle = aTitle
+ TCollection_AsciiString anActiveWindowTitle("3D View - ");
+ anActiveWindowTitle = anActiveWindowTitle
+ ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
- SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
+ SetWindowTitle (ViewerTest::CurrentView()->Window(), anActiveWindowTitle.ToCString());
}
// Create viewer
else if (a3DViewer.IsNull())
{
toCreateViewer = Standard_True;
- TCollection_ExtendedString NameOfWindow("Viewer3D");
- a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
-
- NameOfWindow = TCollection_ExtendedString("Collector");
-
- a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
+ a3DViewer = new V3d_Viewer(aGraphicDriver);
+ a3DViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
+ a3DViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
+ ViewerTest_DefaultBackground.GradientColor2,
+ ViewerTest_DefaultBackground.FillMethod);
}
// AIS context setup
#if defined(_WIN32)
VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
Handle(WNT_WClass)::DownCast (WClass()),
- Draw_VirtualWindows ? WS_POPUPWINDOW : WS_OVERLAPPEDWINDOW,
+ Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
aPxLeft, aPxTop,
aPxWidth, aPxHeight,
Quantity_NOC_BLACK);
// View setup
Handle(V3d_View) aView = a3DViewer->CreateView();
aView->SetWindow (VT_GetWindow());
+ ViewerTest::GetAISContext()->RedrawImmediate (a3DViewer);
ViewerTest::CurrentView(aView);
ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
const Handle (V3d_View) aV3dView = ViewerTest::CurrentView();
aV3dView->SetComputedMode(Standard_False);
MyHLRIsOn = aV3dView->ComputedMode();
- aV3dView->SetZClippingDepth(0.5);
- aV3dView->SetZClippingWidth(ZCLIPWIDTH/2.);
a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
if (toCreateViewer)
if (!aMap.IsBound2 (aName))
{
- di << argv[0] << ":" << " Wrong shape name:" << aName.ToCString() << ".\n";
+ di << argv[0] << ": Wrong shape name:" << aName.ToCString() << ".\n";
continue;
}
Handle(AIS_Shape) anAISObject =
break;
}
}
+
+ aCurrentContext->RemoveAll (Standard_False);
if(isRemoveDriver)
{
ViewerTest_myDrivers.UnBind2 (aCurrentContext->CurrentViewer()->Driver());
if (isTreeView)
{
TCollection_AsciiString aContextName(aContextIter.Key1());
- theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":" << "\n";
+ theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":\n";
}
for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
if (isTreeView)
{
if (aViewIter.Value() == ViewerTest::CurrentView())
- theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)" << "\n";
+ theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)\n";
else
theDi << " " << aViewName.Split(aContextIter.Key1().Length() + 1) << "\n";
}
}
else if (!strcasecmp (buf_ret, "F"))
{
- // FitAll
- aView->FitAll();
+ if (ViewerTest::GetAISContext()->NbSelected() > 0)
+ {
+ ViewerTest::GetAISContext()->FitSelected (aView);
+ }
+ else
+ {
+ // FitAll
+ aView->FitAll();
+ }
}
else if (!strcasecmp (buf_ret, "H"))
{
aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_PolyAlgo);
else
aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_Algo);
- if (aContext->NbCurrents()==0 || aContext->NbSelected() == 0)
+ if (aContext->NbSelected()==0)
{
AIS_ListOfInteractive aListOfShapes;
aContext->DisplayedObjects(aListOfShapes);
}
else
{
- for (aContext->InitCurrent();aContext->MoreCurrent();aContext->NextCurrent())
+ for (aContext->InitSelected();aContext->MoreSelected();aContext->NextSelected())
{
- Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aContext->Current());
+ Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aContext->SelectedInteractive());
if (aShape.IsNull())
continue;
if(aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
std::cout << "setup Shaded display mode" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
- if(Ctx->NbCurrents()==0 ||
- Ctx->NbSelected()==0)
+ if(Ctx->NbSelected()==0)
Ctx->SetDisplayMode(AIS_Shaded);
else{
- if(Ctx->HasOpenedContext()){
- for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
- Ctx->SetDisplayMode(Ctx->Interactive(),1,Standard_False);
- }
- else{
- for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
- Ctx->SetDisplayMode(Ctx->Current(),1,Standard_False);
- }
+ for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
+ Ctx->SetDisplayMode(Ctx->SelectedInteractive(),1,Standard_False);
Ctx->UpdateCurrentViewer();
}
}
std::cout << "reset display mode to defaults" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
- if(Ctx->NbCurrents()==0 ||
- Ctx->NbSelected()==0)
+ if(Ctx->NbSelected()==0)
Ctx->SetDisplayMode(AIS_WireFrame);
else{
- if(Ctx->HasOpenedContext()){
- for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
- Ctx->UnsetDisplayMode(Ctx->Interactive(),Standard_False);
- }
- else{
- for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
- Ctx->UnsetDisplayMode(Ctx->Current(),Standard_False);
- }
+ for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
+ Ctx->UnsetDisplayMode(Ctx->SelectedInteractive(),Standard_False);
Ctx->UpdateCurrentViewer();
}
{
std::cout << "setup WireFrame display mode" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
- if(Ctx->NbCurrents()==0 ||
- Ctx->NbSelected()==0)
+ if(Ctx->NbSelected()==0)
Ctx->SetDisplayMode(AIS_WireFrame);
else{
- if(Ctx->HasOpenedContext()){
- for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
- Ctx->SetDisplayMode(Ctx->Interactive(),0,Standard_False);
- }
- else{
- for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
- Ctx->SetDisplayMode(Ctx->Current(),0,Standard_False);
- }
+ for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
+ Ctx->SetDisplayMode(Ctx->SelectedInteractive(),0,Standard_False);
Ctx->UpdateCurrentViewer();
}
}
- else if (!strcasecmp (buf_ret, "Z"))
- {
- // ZCLIP
- if ( ZClipIsOn ) {
- cout << "ZClipping OFF" << endl;
- ZClipIsOn = 0;
-
- aView->SetZClippingType(V3d_OFF);
- aView->Redraw();
- }
- else {
- cout << "ZClipping ON" << endl;
- ZClipIsOn = 1;
-
- aView->SetZClippingType(V3d_FRONT);
- aView->Redraw();
- }
- }
else if (!strcasecmp (buf_ret, ","))
{
ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
{
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();
if (!aCtx.IsNull()
- && aCtx->NbCurrents() > 0
&& aCtx->NbSelected() > 0)
{
Draw_Interprete ("verase");
}
}
-//==============================================================================
-//function : ProcessZClipMotion
-//purpose : Zoom
-//==============================================================================
-
-void ProcessZClipMotion()
-{
- Handle(V3d_View) a3DView = ViewerTest::CurrentView();
- if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
-
- //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 aDx = a3DView->Convert(X_Motion - X_ButtonPress);
-
- // Front = Depth + width/2.
- Standard_Real aDepth = 0.5;
- Standard_Real aWidth = 0.1;
- a3DView->ZClipping(aDepth,aWidth);
-
- aDepth += aDx;
-
- //printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
-
- a3DView->SetZClippingDepth(aDepth);
-
- a3DView->Redraw();
-
- X_ButtonPress = X_Motion;
- Y_ButtonPress = Y_Motion;
- }
-}
-
//==============================================================================
//function : ProcessControlButton1Motion
//purpose : Zoom
{
if ( ViewerTest::CurrentView().IsNull() )
{
- di<<"Call vinit before this command, please"<<"\n";
+ di<<"Call vinit before this command, please\n";
return 1;
}
static int VLeft(Draw_Interpretor& di, Standard_Integer , const char** )
{
- return ViewProject(di, V3d_Ypos);
+ return ViewProject(di, V3d_Xneg);
}
//==============================================================================
static int VRight(Draw_Interpretor& di, Standard_Integer , const char** )
{
- return ViewProject(di, V3d_Yneg);
+ return ViewProject(di, V3d_Xpos);
}
//==============================================================================
static int VFront(Draw_Interpretor& di, Standard_Integer , const char** )
{
- return ViewProject(di, V3d_Xpos);
+ return ViewProject(di, V3d_Yneg);
}
//==============================================================================
static int VBack(Draw_Interpretor& di, Standard_Integer , const char** )
{
- return ViewProject(di, V3d_Xneg);
+ return ViewProject(di, V3d_Ypos);
}
//==============================================================================
static int VHelp(Draw_Interpretor& di, Standard_Integer , const char** )
{
- di << "Q : Quit the application" << "\n";
-
- di << "========================="<<"\n";
- di << "F : FitAll" << "\n";
- di << "T : TopView" << "\n";
- di << "B : BottomView" << "\n";
- di << "R : RightView" << "\n";
- di << "L : LeftView" << "\n";
- di << "A : AxonometricView" << "\n";
- di << "D : ResetView" << "\n";
-
- di << "========================="<<"\n";
- di << "S : Shading" << "\n";
- di << "W : Wireframe" << "\n";
- di << "H : HidelLineRemoval" << "\n";
- di << "U : Unset display mode" << "\n";
- di << "Delete : Remove selection from viewer" << "\n";
-
- di << "========================="<<"\n";
- di << "Selection mode "<<"\n";
- di << "0 : Shape" <<"\n";
- di << "1 : Vertex" <<"\n";
- di << "2 : Edge" <<"\n";
- di << "3 : Wire" <<"\n";
- di << "4 : Face" <<"\n";
- di << "5 : Shell" <<"\n";
- di << "6 : Solid" <<"\n";
- di << "7 : Compound" <<"\n";
-
- di << "========================="<<"\n";
- di << "Z : Switch Z clipping On/Off" << "\n";
- di << ", : Hilight next detected" << "\n";
- di << ". : Hilight previous detected" << "\n";
+ di << "Q : Quit the application\n";
+
+ di << "=========================\n";
+ di << "F : FitAll\n";
+ di << "T : TopView\n";
+ di << "B : BottomView\n";
+ di << "R : RightView\n";
+ di << "L : LeftView\n";
+ di << "A : AxonometricView\n";
+ di << "D : ResetView\n";
+
+ di << "=========================\n";
+ di << "S : Shading\n";
+ di << "W : Wireframe\n";
+ di << "H : HidelLineRemoval\n";
+ di << "U : Unset display mode\n";
+ di << "Delete : Remove selection from viewer\n";
+
+ di << "=========================\n";
+ di << "Selection mode \n";
+ di << "0 : Shape\n";
+ di << "1 : Vertex\n";
+ di << "2 : Edge\n";
+ di << "3 : Wire\n";
+ di << "4 : Face\n";
+ di << "5 : Shell\n";
+ di << "6 : Solid\n";
+ di << "7 : Compound\n";
+
+ di << "=========================\n";
+ di << "Z : Switch Z clipping On/Off\n";
+ di << ", : Hilight next detected\n";
+ di << ". : Hilight previous detected\n";
return 0;
}
-#ifdef WNT
+#ifdef _WIN32
static Standard_Boolean Ppick = 0;
static Standard_Integer Pargc = 0;
}
}
break;
+
case WM_LBUTTONUP:
- if (!DragFirst)
+ if (IsDragged && !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 );
- VT_ProcessButton1Release (fwKeys & MK_SHIFT);
+ if (!GetActiveAISManipulator().IsNull())
+ {
+ GetActiveAISManipulator()->StopTransform();
+ ViewerTest::GetAISContext()->ClearSelected();
+ }
+
+ if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
+ {
+ ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
+ ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
+ }
+
+ VT_ProcessButton1Release ((fwKeys & MK_SHIFT) != 0);
}
IsDragged = Standard_False;
return ViewerWindowProc( hwnd, Msg, wParam, lParam );
+ case WM_RBUTTONUP:
+ if (IsDragged && !DragFirst)
+ {
+ if (!GetActiveAISManipulator().IsNull())
+ {
+ GetActiveAISManipulator()->StopTransform (Standard_False);
+ ViewerTest::GetAISContext()->ClearSelected();
+ }
+ IsDragged = Standard_False;
+ }
+ return ViewerWindowProc (hwnd, Msg, wParam, lParam);
+
case WM_LBUTTONDOWN:
- if( fwKeys == MK_LBUTTON || fwKeys == ( MK_LBUTTON | MK_SHIFT ) )
+ if (!GetActiveAISManipulator().IsNull())
+ {
+ IsDragged = ( fwKeys == MK_LBUTTON );
+ }
+ else
+ {
+ IsDragged = ( fwKeys == MK_LBUTTON || fwKeys == ( MK_LBUTTON | MK_SHIFT ) );
+ }
+
+ if (IsDragged)
{
- IsDragged = Standard_True;
DragFirst = Standard_True;
X_ButtonPress = LOWORD(lParam);
Y_ButtonPress = HIWORD(lParam);
}
return ViewerWindowProc( hwnd, Msg, wParam, lParam );
- break;
-
case WM_MOUSEMOVE:
- if( IsDragged )
+ if (IsDragged)
{
- HDC hdc = GetDC( hwnd );
-
- HGDIOBJ anObj = SelectObject( hdc, GetStockObject( WHITE_PEN ) );
- SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
- SetROP2( hdc, R2_NOT );
+ X_Motion = LOWORD (lParam);
+ Y_Motion = HIWORD (lParam);
+ if (!GetActiveAISManipulator().IsNull())
+ {
+ if (DragFirst)
+ {
+ GetActiveAISManipulator()->StartTransform (X_ButtonPress, Y_ButtonPress, ViewerTest::CurrentView());
+ }
+ else
+ {
+ GetActiveAISManipulator()->Transform (X_Motion, Y_Motion, ViewerTest::CurrentView());
+ ViewerTest::GetAISContext()->CurrentViewer()->Redraw();
+ }
+ }
+ else
+ {
+ bool toRedraw = false;
+ if (!DragFirst && ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
+ {
+ ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
+ toRedraw = true;
+ }
- if( !DragFirst )
- Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
+ RECT aRect;
+ if (GetClientRect (hwnd, &aRect))
+ {
+ int aHeight = aRect.bottom - aRect.top;
+ GetRubberBand()->SetRectangle (X_ButtonPress, aHeight - Y_ButtonPress, X_Motion, aHeight - Y_Motion);
+ ViewerTest::GetAISContext()->Display (GetRubberBand(), 0, -1, Standard_False, Standard_True, AIS_DS_Displayed);
+ toRedraw = true;
+ }
+ if (toRedraw)
+ {
+ ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
+ }
+ }
DragFirst = Standard_False;
- X_Motion = LOWORD(lParam);
- Y_Motion = HIWORD(lParam);
-
- Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
-
- SelectObject( hdc, anObj );
-
- ReleaseDC( hwnd, hdc );
}
else
return ViewerWindowProc( hwnd, Msg, wParam, lParam );
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] = '.';
}
+ else if (wParam == VK_DIVIDE)
+ {
+ c[0] = '/';
+ }
+ // dot
+ else if (wParam == VK_MULTIPLY)
+ {
+ c[0] = '*';
+ }
VT_ProcessKeyPress (c);
}
break;
if (Msg == WM_LBUTTONDOWN)
{
- if (fwKeys & MK_CONTROL)
+ if ((fwKeys & MK_CONTROL) != 0)
{
- Ppick = VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
+ Ppick = VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT) != 0);
}
else
{
- VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
+ VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT) != 0);
}
}
else if (Msg == WM_RBUTTONDOWN)
}
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;
Y_Motion = HIWORD(lParam);
if ( Up &&
- fwKeys & ( MK_LBUTTON|MK_MBUTTON|MK_RBUTTON ) ) {
+ (fwKeys & ( MK_LBUTTON|MK_MBUTTON|MK_RBUTTON )) != 0 )
+ {
Up = 0;
X_ButtonPress = LOWORD(lParam);
Y_ButtonPress = HIWORD(lParam);
- if ( fwKeys & MK_RBUTTON ) {
+ if ((fwKeys & MK_RBUTTON) != 0) {
// Start rotation
VT_ProcessButton3Press();
}
}
- if ( fwKeys & MK_CONTROL ) {
- if ( fwKeys & MK_LBUTTON ) {
+ if ((fwKeys & MK_CONTROL) != 0)
+ {
+ if ((fwKeys & MK_LBUTTON) != 0)
+ {
ProcessControlButton1Motion();
}
- else if ( fwKeys & MK_MBUTTON ||
- ((fwKeys&MK_LBUTTON) &&
- (fwKeys&MK_RBUTTON) ) ){
- VT_ProcessControlButton2Motion();
- }
- else if ( fwKeys & MK_RBUTTON ) {
+ else if ((fwKeys & MK_MBUTTON) != 0
+ || ((fwKeys & MK_LBUTTON) != 0
+ && (fwKeys & MK_RBUTTON) != 0))
+ {
+ VT_ProcessControlButton2Motion();
+ }
+ else if ((fwKeys & MK_RBUTTON) != 0)
+ {
VT_ProcessControlButton3Motion();
}
}
-#ifdef BUG
- else if ( fwKeys & MK_SHIFT ) {
- if ( fwKeys & MK_MBUTTON ||
- ((fwKeys&MK_LBUTTON) &&
- (fwKeys&MK_RBUTTON) ) ) {
- cout << "ProcessZClipMotion()" << endl;
- ProcessZClipMotion();
- }
- }
-#endif
else if (GetWindowHandle (VT_GetWindow()) == hwnd)
{
- if ((fwKeys & MK_MBUTTON
- || ((fwKeys & MK_LBUTTON) && (fwKeys & MK_RBUTTON))))
- {
- ProcessZClipMotion();
- }
- else
- {
- VT_ProcessMotion();
- }
+ VT_ProcessMotion();
}
}
break;
return( DefWindowProc( hwnd, Msg, wParam, lParam ));
}
return 0L;
- }
-
- return DefWindowProc( hwnd, Msg, wParam, lParam );
}
{
if( !DragFirst )
{
- Aspect_Handle aWindow = VT_GetWindow()->XWindow();
- GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
- XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
+ if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
+ {
+ ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
+ ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
+ }
}
Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
}
if( IsDragged )
{
- Aspect_Handle aWindow = VT_GetWindow()->XWindow();
- GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
- XSetFunction( aDisplay, gc, GXinvert );
-
if( !DragFirst )
- XDrawRectangle(aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
+ {
+ if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
+ {
+ ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
+ }
+ }
X_Motion = aReport.xmotion.x;
Y_Motion = aReport.xmotion.y;
DragFirst = Standard_False;
- XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
+ Window aWindow = GetWindowHandle(VT_GetWindow());
+ Window aRoot;
+ int anX, anY;
+ unsigned int aWidth, aHeight, aBorderWidth, aDepth;
+ XGetGeometry (aDisplay, aWindow, &aRoot, &anX, &anY, &aWidth, &aHeight, &aBorderWidth, &aDepth);
+ GetRubberBand()->SetRectangle (X_ButtonPress, aHeight - Y_ButtonPress, X_Motion, aHeight - Y_Motion);
+ ViewerTest::GetAISContext()->Display (GetRubberBand(), 0, -1, Standard_False, Standard_True, AIS_DS_Displayed);
+ ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
}
else
{
// remove all the ButtonMotionMaskr
while( XCheckMaskEvent( aDisplay, ButtonMotionMask, &aReport) ) ;
- if ( ZClipIsOn && aReport.xmotion.state & ShiftMask ) {
- if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
-
- Quantity_Length VDX, VDY;
-
- ViewerTest::CurrentView()->Size(VDX,VDY);
- Standard_Real VDZ =0 ;
- VDZ = ViewerTest::CurrentView()->ZSize();
-
- printf("%f,%f,%f\n", VDX, VDY, VDZ);
-
- Quantity_Length dx = 0 ;
- dx = ViewerTest::CurrentView()->Convert(X_Motion - X_ButtonPress);
-
- cout << dx << endl;
-
- dx = dx / VDX * VDZ;
-
- cout << dx << endl;
-
- ViewerTest::CurrentView()->Redraw();
- }
- }
-
if ( aReport.xmotion.state & ControlMask ) {
if ( aReport.xmotion.state & Button1Mask ) {
ProcessControlButton1Motion();
XSynchronize(aDisplay, 0);
#else
- // WNT
+ // _WIN32
#endif
}
-
//==============================================================================
//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();
- if (!aView.IsNull())
+
+ 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;
if (theArgsNb == 1)
{
- aCurrentView->View()->ZFitAll();
+ aCurrentView->ZFitAll();
aCurrentView->Redraw();
return 0;
}
aScale = Draw::Atoi (theArgVec[1]);
}
- aCurrentView->View()->ZFitAll (aScale);
+ aCurrentView->ZFitAll (aScale);
aCurrentView->Redraw();
return 0;
{ if (ViewerTest::CurrentView().IsNull() ) return 1;
if ( argc < 4 ) {
- di << argv[0] << "Invalid number of arguments" << "\n";
+ di << argv[0] << "Invalid number of arguments\n";
return 1;
}
{
if (argc < 2 || argc > 3)
{
- di << "Usage : " << argv[0] << " imagefile [filltype] : Load image as background" << "\n";
- di << "filltype can be one of CENTERED, TILED, STRETCH, NONE" << "\n";
+ di << "Usage : " << argv[0] << " imagefile [filltype] : Load image as background\n";
+ di << "filltype can be one of CENTERED, TILED, STRETCH, NONE\n";
return 1;
}
else
{
di << "Wrong fill type : " << szType << "\n";
- di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
+ di << "Must be one of CENTERED, TILED, STRETCH, NONE\n";
return 1;
}
}
{
if (argc != 2)
{
- di << "Usage : " << argv[0] << " filltype : Change background image mode" << "\n";
- di << "filltype must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
+ di << "Usage : " << argv[0] << " filltype : Change background image mode\n";
+ di << "filltype must be one of CENTERED, TILED, STRETCH, NONE\n";
return 1;
}
else
{
di << "Wrong fill type : " << szType << "\n";
- di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
+ di << "Must be one of CENTERED, TILED, STRETCH, NONE\n";
return 1;
}
Handle(V3d_View) V3dView = ViewerTest::CurrentView();
{
if (argc != 8 )
{
- di << "Usage : " << argv[0] << " R1 G1 B1 R2 G2 B2 Type : Mount gradient background" << "\n";
- di << "R1,G1,B1,R2,G2,B2 = [0..255]" << "\n";
- di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
- di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
+ di << "Usage : " << argv[0] << " R1 G1 B1 R2 G2 B2 Type : Mount gradient background\n";
+ di << "R1,G1,B1,R2,G2,B2 = [0..255]\n";
+ di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
+ di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
return 1;
}
int aType = Draw::Atoi(argv[7]);
if( aType < 0 || aType > 8 )
{
- di << "Wrong fill type " << "\n";
- di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
- di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
+ di << "Wrong fill type \n";
+ di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
+ di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
return 1;
}
{
if (argc != 2 )
{
- di << "Usage : " << argv[0] << " Type : Change gradient background fill type" << "\n";
- di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
- di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
+ di << "Usage : " << argv[0] << " Type : Change gradient background fill type\n";
+ di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
+ di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
return 1;
}
int aType = Draw::Atoi(argv[1]);
if( aType < 0 || aType > 8 )
{
- di << "Wrong fill type " << "\n";
- di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
- di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
+ di << "Wrong fill type \n";
+ di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
+ di << " 5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
return 1;
}
{
if (argc != 4 )
{
- di << "Usage : " << argv[0] << " R G B : Set color background" << "\n";
- di << "R,G,B = [0..255]" << "\n";
+ di << "Usage : " << argv[0] << " R G B : Set color background\n";
+ di << "R,G,B = [0..255]\n";
return 1;
}
return 0;
}
+//==============================================================================
+//function : VSetDefaultBg
+//purpose : Set default viewer background fill color
+//==============================================================================
+static int VSetDefaultBg (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
+{
+ if (theArgNb != 4
+ && theArgNb != 8)
+ {
+ std::cout << "Error: wrong syntax! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
+
+ ViewerTest_DefaultBackground.FillMethod =
+ theArgNb == 4 ? Aspect_GFM_NONE
+ : (Aspect_GradientFillMethod) Draw::Atoi (theArgVec[7]);
+
+ if (theArgNb == 4)
+ {
+ Standard_Real R = Draw::Atof (theArgVec[1]) / 255.;
+ Standard_Real G = Draw::Atof (theArgVec[2]) / 255.;
+ Standard_Real B = Draw::Atof (theArgVec[3]) / 255.;
+ ViewerTest_DefaultBackground.FlatColor.SetValues (R, G, B, Quantity_TOC_RGB);
+ }
+ else
+ {
+ Standard_Real R1 = Draw::Atof (theArgVec[1]) / 255.;
+ Standard_Real G1 = Draw::Atof (theArgVec[2]) / 255.;
+ Standard_Real B1 = Draw::Atof (theArgVec[3]) / 255.;
+ ViewerTest_DefaultBackground.GradientColor1.SetValues (R1, G1, B1, Quantity_TOC_RGB);
+
+ Standard_Real R2 = Draw::Atof (theArgVec[4]) / 255.;
+ Standard_Real G2 = Draw::Atof (theArgVec[5]) / 255.;
+ Standard_Real B2 = Draw::Atof (theArgVec[6]) / 255.;
+ ViewerTest_DefaultBackground.GradientColor2.SetValues (R2, G2, B2, Quantity_TOC_RGB);
+ }
+
+ for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
+ anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
+ {
+ const Handle(V3d_Viewer)& aViewer = anIter.Value()->CurrentViewer();
+ aViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
+ aViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
+ ViewerTest_DefaultBackground.GradientColor2,
+ ViewerTest_DefaultBackground.FillMethod);
+ }
+
+ return 0;
+}
+
//==============================================================================
//function : VScale
//purpose : View Scaling
if ( V3dView.IsNull() ) return 1;
if ( argc != 4 ) {
- di << argv[0] << "Invalid number of arguments" << "\n";
+ di << argv[0] << "Invalid number of arguments\n";
return 1;
}
V3dView->SetAxialScale( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
aView->ZBufferTriedronSetup (anArrowColorX.Name(), anArrowColorY.Name(), anArrowColorZ.Name(),
aSizeRatio, anArrowDiam, aNbFacets);
aView->TriedronDisplay (aPosition, aLabelsColor.Name(), aScale, aVisType);
- aView->View()->ZFitAll();
+ aView->ZFitAll();
return 0;
}
if ( argc == 2 ) {
Standard_Real coef = Draw::Atof(argv[1]);
if ( coef <= 0.0 ) {
- di << argv[1] << "Invalid value" << "\n";
+ di << argv[1] << "Invalid value\n";
return 1;
}
V3dView->SetZoom( Draw::Atof(argv[1]) );
return 0;
} else {
- di << argv[0] << " Invalid number of arguments" << "\n";
+ di << argv[0] << " Invalid number of arguments\n";
return 1;
}
}
V3dView->Pan( Draw::Atoi(argv[1]), Draw::Atoi(argv[2]) );
return 0;
} else {
- di << argv[0] << " Invalid number of arguments" << "\n";
+ di << argv[0] << " Invalid number of arguments\n";
return 1;
}
}
{
if (aFileName.Value (aLen - 2) == '.')
{
- aFormatStr = aFileName.SubString (aLen - 1, aLen);
+ aFormatStr = aFileName.ToCString() + aLen - 2;
}
else if (aFileName.Value (aLen - 3) == '.')
{
- aFormatStr = aFileName.SubString (aLen - 2, aLen);
+ aFormatStr = aFileName.ToCString() + aLen - 3;
}
else
{
return 1;
}
- try {
- if (!V3dView->View()->Export (argv[1], anExpFormat))
+ try
+ {
+ Standard_DISABLE_DEPRECATION_WARNINGS
+ if (!V3dView->Export (argv[1], anExpFormat))
+ Standard_ENABLE_DEPRECATION_WARNINGS
{
di << "Error: export of image to " << aFormatStr << " failed!\n";
}
std::cout << "Error: no active view!\n";
return 1;
}
-
- Handle(V3d_ColorScale) aCS = Handle(V3d_ColorScale)::DownCast (aView->ColorScale());
- if (aCS.IsNull())
+ if (theArgNb <= 1)
{
- std::cout << "Error: color scale is undefined!\n";
+ std::cout << "Error: wrong syntax at command '" << theArgVec[0] << "'!\n";
return 1;
}
- 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());
-
- ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
-
- if (theArgNb <= 1)
+ Handle(AIS_ColorScale) aCS;
+ // find object
+ Handle(AIS_InteractiveObject) anIObj;
+ if (GetMapOfAIS().IsBound2 (theArgVec[1]))
{
- theDI << "Current color scale parameters:\n"
- << "Min range: " << aMinRange << "\n"
- << "Max range: " << aMaxRange << "\n"
- << "Number of intervals: " << aNbIntervals << "\n"
+ aCS = Handle(AIS_ColorScale)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
+ if (aCS.IsNull())
+ {
+ std::cout << "Error: object '" << theArgVec[1] << "'is already defined and is not a color scale!\n";
+ return 1;
+ }
+ }
+ else
+ {
+ aCS = new AIS_ColorScale();
+ GetMapOfAIS().Bind (aCS,theArgVec[1]);
+ }
+
+ if (aCS->ZLayer() != Graphic3d_ZLayerId_TopOSD)
+ {
+ aCS->SetZLayer (Graphic3d_ZLayerId_TopOSD);
+ }
+ if (aCS->TransformPersistence().IsNull()
+ || aCS->TransformPersistence()->Mode() != Graphic3d_TMF_2d)
+ {
+ aContext->SetTransformPersistence (aCS, new Graphic3d_TransformPers (Graphic3d_TMF_2d, Aspect_TOTP_LEFT_LOWER));
+ }
+
+ Standard_Real aMinRange = aCS->GetMin();
+ Standard_Real aMaxRange = aCS->GetMax();
+ Standard_Integer aBreadth = aCS->GetBreadth();
+ Standard_Integer aHeight = aCS->GetHeight();
+ Standard_Integer aNbIntervals = aCS->GetNumberOfIntervals();
+ Standard_Integer aTextHeight = aCS->GetTextHeight();
+ Aspect_TypeOfColorScalePosition aLabPosition = aCS->GetLabelPosition();
+ Standard_Integer aPosX = aCS->GetXPosition();
+ Standard_Integer aPosY = aCS->GetYPosition();
+
+ ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
+
+ if (theArgNb <= 2)
+ {
+ theDI << "Color scale parameters for '"<< theArgVec[1] << "':\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 position: " << aPosX <<" "<< aPosY<< "\n"
<< "Color scale title: " << aCS->GetTitle() << "\n"
<< "Label position: ";
switch (aLabPosition)
}
return 0;
}
- Standard_CString aFirstArg = theArgVec[1];
- TCollection_AsciiString aFlag (aFirstArg);
- aFlag.LowerCase();
- if (aFlag == "-hide" ||
- aFlag == "-erase")
- {
- 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;
- }
- }
- else if (aFlag == "-show" ||
- aFlag == "-display")
- {
- if (theArgNb > 2)
- {
- std::cout << "Error: wrong syntax at argument '" << theArgVec[1] << "'!\n";
- return 1;
- }
- aView->ColorScaleDisplay();
- return 0;
- }
- for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ for (Standard_Integer anArgIter = 2; anArgIter < theArgNb; ++anArgIter)
{
Standard_CString anArg = theArgVec[anArgIter];
TCollection_AsciiString aFlag (anArg);
std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
- TCollection_AsciiString anArg (theArgVec[anArgIter + 1]);
- if (!anArg.IsIntegerValue())
+ TCollection_AsciiString aFontArg(theArgVec[anArgIter + 1]);
+ if (!aFontArg.IsIntegerValue())
{
std::cout << "Error: HeightFont value should be integer!\n";
return 1;
}
- aTextHeight = anArg.IntegerValue();
+ aTextHeight = aFontArg.IntegerValue();
anArgIter += 1;
}
else if (aFlag == "-textpos")
std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
- TCollection_AsciiString anArg (theArgVec[++anArgIter]);
- anArg.LowerCase();
- if (anArg == "none")
+ TCollection_AsciiString aTextPosArg(theArgVec[++anArgIter]);
+ aTextPosArg.LowerCase();
+ if (aTextPosArg == "none")
{
aLabPosition = Aspect_TOCSP_NONE;
}
- else if (anArg == "left")
+ else if (aTextPosArg == "left")
{
aLabPosition = Aspect_TOCSP_LEFT;
}
- else if (anArg == "right")
+ else if (aTextPosArg == "right")
{
aLabPosition = Aspect_TOCSP_RIGHT;
}
- else if (anArg == "center")
+ else if (aTextPosArg == "center")
{
aLabPosition = Aspect_TOCSP_CENTER;
}
else
{
- std::cout << "Error: unknown position '" << anArg << "'!\n";
+ std::cout << "Error: unknown position '" << aTextPosArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-logarithmic"
+ || aFlag == "-log")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ Standard_Boolean IsLog;
+ if (!ViewerTest::ParseOnOff(theArgVec[++anArgIter], IsLog))
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
return 1;
}
+ aCS->SetLogarithmic (IsLog);
}
else if (aFlag == "-xy")
{
TCollection_AsciiString aX (theArgVec[++anArgIter]);
TCollection_AsciiString aY (theArgVec[++anArgIter]);
- if (!aX.IsRealValue()
- || !aY.IsRealValue())
+ if (!aX.IsIntegerValue()
+ || !aY.IsIntegerValue())
+ {
+ std::cout << "Error: coordinates should be integer values!\n";
+ return 1;
+ }
+
+ aPosX = aX.IntegerValue();
+ aPosY = aY.IntegerValue();
+ }
+ else if (aFlag == "-width"
+ || aFlag == "-w")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aW (theArgVec[++anArgIter]);
+ if (!aW.IsIntegerValue())
+ {
+ std::cout << "Error: a width should be an integer value!\n";
+ return 1;
+ }
+
+ aBreadth = aW.IntegerValue();
+ }
+ else if (aFlag == "-height"
+ || aFlag == "-h")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aH (theArgVec[++anArgIter]);
+ if (!aH.IsIntegerValue())
{
- std::cout << "Error: coordinates should be real values!\n";
+ std::cout << "Error: a width should be an integer value!\n";
return 1;
}
- aPos.SetCoord (aX.RealValue(), aY.RealValue());
+ aHeight = aH.IntegerValue();
}
else if (aFlag == "-color")
{
}
Standard_Integer anIndex = anInd.IntegerValue();
- if (anIndex < 0
- || anIndex > aNbIntervals - 1)
+ if (anIndex <= 0 || anIndex > aNbIntervals)
{
- std::cout << "Error: Index value should be within range 0..." << (aNbIntervals - 1) <<"!\n";
+ std::cout << "Error: Index value should be within range 1.." << aNbIntervals <<"!\n";
return 1;
}
if (Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
{
- aCS->SetColor (Quantity_Color (aColorName), anIndex);
- aCS->SetColorType(Aspect_TOCSD_USER);
+ aCS->SetIntervalColor (Quantity_Color (aColorName), anIndex);
+ aCS->SetColorType (Aspect_TOCSD_USER);
anArgIter += 2;
continue;
}
{
return 1;
}
- aCS->SetColor (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB), anIndex);
+ aCS->SetIntervalColor (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB), anIndex);
aCS->SetColorType (Aspect_TOCSD_USER);
anArgIter += 4;
}
}
Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
- if (anIndex < 0
- || anIndex > aNbIntervals)
+ if (anIndex <= 0 || anIndex > aNbIntervals+1)
{
- std::cout << "Error: Index value should be within range 0..." << aNbIntervals <<"!\n";
+ std::cout << "Error: Index value should be within range 1.." << aNbIntervals+1 <<"!\n";
return 1;
}
else if (aFlag == "-demoversion"
|| aFlag == "-demo")
{
- aPos.SetCoord (0.0, 0.0);
+ aPosX = 0;
+ aPosY = 0;
aTextHeight = 16;
aMinRange = 0.0;
aMaxRange = 100;
aNbIntervals = 10;
+ aBreadth = 0;
+ aHeight = 0;
aLabPosition = Aspect_TOCSP_RIGHT;
- aCS->SetColorType(Aspect_TOCSD_AUTO);
- aCS->SetLabelType(Aspect_TOCSD_AUTO);
+ aCS->SetColorType (Aspect_TOCSD_AUTO);
+ aCS->SetLabelType (Aspect_TOCSD_AUTO);
+ }
+ else if (aFlag == "-findcolor")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString anArg1 (theArgVec[++anArgIter]);
+
+ if (!anArg1.IsRealValue())
+ {
+ std::cout << "Error: the value should be real!\n";
+ return 1;
+ }
+
+ Quantity_Color aColor;
+ aCS->FindColor (anArg1.RealValue(), aColor);
+ theDI << Quantity_Color::StringName (aColor.Name());
+ return 0;
}
else
{
return 1;
}
}
-
- aCS->SetPosition (aPos.X(), aPos.Y());
- aCS->SetHeight (0.95);
+ if (!aBreadth || !aHeight)
+ {
+ Standard_Integer aWinWidth, aWinHeight;
+ aView->Window()->Size (aWinWidth, aWinHeight);
+ if (!aBreadth)
+ {
+ aBreadth = aWinWidth;
+ }
+ if (!aHeight)
+ {
+ aHeight = aWinHeight;
+ }
+ }
+ aCS->SetSize (aBreadth, aHeight);
+ aCS->SetPosition (aPosX, aPosY);
aCS->SetTextHeight (aTextHeight);
aCS->SetRange (aMinRange, aMaxRange);
aCS->SetNumberOfIntervals (aNbIntervals);
aCS->SetLabelPosition (aLabPosition);
-
- if (!aView->ColorScaleIsDisplayed())
- {
- aView->ColorScaleDisplay();
- }
+// aCS->SetColor (aView->BackgroundColor().Invert());
+ aCS->SetToUpdate();
+ aContext->Display (aCS);
return 0;
}
Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
if (anAISContext.IsNull())
{
- std::cout << theArgs[0] << ": " << " please use 'vinit' command to initialize view.\n";
+ std::cout << theArgs[0] << ": please use 'vinit' command to initialize view.\n";
return 1;
}
}
//==============================================================================
-//function : VPrintView
-//purpose : Test printing algorithm, print the view to image file with given
-// width and height. Printing implemented only for WNT.
+//function : VTile
+//purpose :
//==============================================================================
-static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
- const char** argv)
+static int VTile (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
-#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
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
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";
+ std::cerr << "Error: no active viewer.\n";
return 1;
}
- // get the input params
- Standard_Integer aWidth = Draw::Atoi (argv[1]);
- Standard_Integer aHeight = Draw::Atoi (argv[2]);
- Standard_Integer aMode = 0;
- TCollection_AsciiString aFileName = TCollection_AsciiString (argv[3]);
- if (argc >= 5)
- aMode = Draw::Atoi (argv[4]);
-
- Standard_Integer aTileWidth = 0;
- Standard_Integer aTileHeight = 0;
- Standard_Boolean isTileSizeProvided = Standard_False;
- if (argc == 7)
+ Graphic3d_CameraTile aTile = aView->Camera()->Tile();
+ if (theArgNb < 2)
{
- isTileSizeProvided = Standard_True;
- aTileWidth = Draw::Atoi (argv[5]);
- aTileHeight = Draw::Atoi (argv[6]);
+ theDI << "Total size: " << aTile.TotalSize.x() << " " << aTile.TotalSize.y() << "\n"
+ << "Tile size: " << aTile.TileSize.x() << " " << aTile.TileSize.y() << "\n"
+ << "Lower left: " << aTile.Offset.x() << " " << aTile.Offset.y() << "\n";
+ return 0;
}
- // check the input parameters
- if (aWidth <= 0 || aHeight <= 0)
+ aView->Window()->Size (aTile.TileSize.x(), aTile.TileSize.y());
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- di << "Width and height must be positive values!\n";
- return 1;
- }
- if (aMode != 0 && aMode != 1)
- aMode = 0;
-
- // define compatible bitmap
- HDC anDC = CreateCompatibleDC(0);
- BITMAPINFO aBitmapData;
- memset (&aBitmapData, 0, sizeof (BITMAPINFOHEADER));
- aBitmapData.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
- aBitmapData.bmiHeader.biWidth = aWidth ;
- aBitmapData.bmiHeader.biHeight = aHeight;
- aBitmapData.bmiHeader.biPlanes = 1;
- aBitmapData.bmiHeader.biBitCount = 24;
- aBitmapData.bmiHeader.biXPelsPerMeter = 0;
- aBitmapData.bmiHeader.biYPelsPerMeter = 0;
- aBitmapData.bmiHeader.biClrUsed = 0;
- aBitmapData.bmiHeader.biClrImportant = 0;
- aBitmapData.bmiHeader.biCompression = BI_RGB;
- aBitmapData.bmiHeader.biSizeImage = 0;
-
- // Create Device Independent Bitmap
- void* aBitsOut = NULL;
- HBITMAP aMemoryBitmap = CreateDIBSection (anDC, &aBitmapData, DIB_RGB_COLORS,
- &aBitsOut, NULL, 0);
- HGDIOBJ anOldBitmap = SelectObject(anDC, aMemoryBitmap);
-
- Standard_Boolean isSaved = Standard_False, isPrinted = Standard_False;
- if (aBitsOut != NULL)
- {
- if (aMode == 0)
- isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_STRETCH);
- else
+ TCollection_AsciiString anArg (theArgVec[anArgIter]);
+ anArg.LowerCase();
+ if (anArg == "-lowerleft"
+ || anArg == "-upperleft")
{
- if (isTileSizeProvided)
+ if (anArgIter + 3 < theArgNb)
{
- Graphic3d_CView* aCView = static_cast<Graphic3d_CView*> (ViewerTest::CurrentView()->View()->CView());
- Graphic3d_PtrFrameBuffer anOldBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
- aCView->ptrFBO = aView->View()->FBOCreate (aTileWidth, aTileHeight);
-
- isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
-
- Graphic3d_PtrFrameBuffer aNewBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
- aView->View()->FBORelease (aNewBuffer);
- aCView->ptrFBO = anOldBuffer;
+ std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ return 1;
}
- else
+ aTile.IsTopDown = (anArg == "-upperleft") == Standard_True;
+ aTile.Offset.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
+ aTile.Offset.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
+ }
+ else if (anArg == "-total"
+ || anArg == "-totalsize"
+ || anArg == "-viewsize")
+ {
+ if (anArgIter + 3 < theArgNb)
+ {
+ std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ return 1;
+ }
+ aTile.TotalSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
+ aTile.TotalSize.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
+ if (aTile.TotalSize.x() < 1
+ || aTile.TotalSize.y() < 1)
{
- isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
+ std::cerr << "Error: total size is incorrect.\n";
+ return 1;
}
}
-
- // succesfully printed into an intermediate buffer
- if (isPrinted)
+ else if (anArg == "-tilesize")
{
- Image_PixMap aWrapper;
- aWrapper.InitWrapper (Image_PixMap::ImgBGR, (Standard_Byte* )aBitsOut, aWidth, aHeight, aWidth * 3 + aWidth % 4);
- aWrapper.SetTopDown (false);
+ if (anArgIter + 3 < theArgNb)
+ {
+ std::cerr << "Syntax error at '" << theArgVec[anArgIter] << "'.\n";
+ return 1;
+ }
- Image_AlienPixMap anImageBitmap;
- anImageBitmap.InitCopy (aWrapper);
- isSaved = anImageBitmap.Save (aFileName);
+ aTile.TileSize.x() = Draw::Atoi (theArgVec[anArgIter + 1]);
+ aTile.TileSize.y() = Draw::Atoi (theArgVec[anArgIter + 2]);
+ if (aTile.TileSize.x() < 1
+ || aTile.TileSize.y() < 1)
+ {
+ std::cerr << "Error: tile size is incorrect.\n";
+ return 1;
+ }
}
- else
+ else if (anArg == "-unset")
{
- di << "Print operation failed due to printing errors or\n";
- di << "insufficient memory available\n";
- di << "Please, try to use smaller dimensions for this test\n";
- di << "command, as it allocates intermediate buffer for storing\n";
- di << "the result\n";
+ aView->Camera()->SetTile (Graphic3d_CameraTile());
+ aView->Redraw();
+ return 0;
}
}
- else
- {
- di << "Can't allocate memory for intermediate buffer\n";
- di << "Please use smaller dimensions\n";
- }
- if (aMemoryBitmap)
+ if (aTile.TileSize.x() < 1
+ || aTile.TileSize.y() < 1)
{
- SelectObject (anDC, anOldBitmap);
- DeleteObject (aMemoryBitmap);
- DeleteDC(anDC);
+ std::cerr << "Error: tile size is undefined.\n";
+ return 1;
}
-
- if (!isSaved)
+ else if (aTile.TotalSize.x() < 1
+ || aTile.TotalSize.y() < 1)
{
- di << "Save to file operation failed. This operation may fail\n";
- di << "if you don't have enough available memory, then you can\n";
- di << "use smaller dimensions for the output file\n";
+ std::cerr << "Error: total size is undefined.\n";
return 1;
}
+ aView->Camera()->SetTile (aTile);
+ aView->Redraw();
return 0;
-
-#endif
}
//==============================================================================
}
else if (argc < 2)
{
- 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 << " 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";
+ di << di.PrintHelp (argv[0]);
return 1;
}
{
aSettings.SetDepthOffsetNegative();
}
+ else if (aSubOp == "textureenv")
+ {
+ aSettings.UseEnvironmentTexture = true;
+ }
aViewer->SetZLayerSettings (anId, aSettings);
}
{
aSettings.DisableSetting (Graphic3d_ZLayerDepthOffset);
}
+ else if (aSubOp == "textureenv")
+ {
+ aSettings.UseEnvironmentTexture = false;
+ }
aViewer->SetZLayerSettings (anId, aSettings);
}
return 0;
}
-DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
-
-// 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)
-
- // 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 myText;
- Standard_Real myHeight;
- Handle(Visual3d_Layer) myLayer;
- Quantity_Color myColor;
- Quantity_Color mySubtitleColor;
- Aspect_TypeOfDisplayText myType;
- 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,
- 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)
- : myX1 (theX1), myY1 (theY1),
- myText (theText),
- myHeight (theHeight),
- myLayer (theLayer),
- myColor (theColor),
- mySubtitleColor (theSubtitleColor),
- myType (theTypeOfDisplay),
- myFontName (theFontName)
-{
- if (!myLayer.IsNull ())
- myLayer->AddLayerItem (this);
-}
-
-// render item
-void V3d_TextItem::RedrawLayerPrs ()
-{
- if (myLayer.IsNull ())
- return;
-
- myLayer->SetColor (myColor);
- myLayer->SetTextAttributes (myFontName.ToCString (), myType, mySubtitleColor);
- 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.
-class V3d_LineItem : public Visual3d_LayerItem
+// The interactive presentation of 2d layer item
+// for "vlayerline" command it provides a presentation of
+// line with user-defined linewidth, linetype and transparency.
+class V3d_LineItem : public AIS_InteractiveObject
{
public:
// CASCADE RTTI
- DEFINE_STANDARD_RTTI(V3d_LineItem)
+ DEFINE_STANDARD_RTTI_INLINE(V3d_LineItem,AIS_InteractiveObject)
// constructor
Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
Standard_Real X2, Standard_Real Y2,
- V3d_LayerMgrPointer theLayerMgr,
Aspect_TypeOfLine theType = Aspect_TOL_SOLID,
Standard_Real theWidth = 0.5,
Standard_Real theTransp = 1.0);
- // redraw method
- Standard_EXPORT void RedrawLayerPrs();
+ private:
+
+ void Compute (const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
+ const Handle(Prs3d_Presentation)& thePresentation,
+ const Standard_Integer theMode) Standard_OVERRIDE;
+
+ void ComputeSelection (const Handle(SelectMgr_Selection)& /*aSelection*/,
+ const Standard_Integer /*aMode*/) Standard_OVERRIDE
+ {}
private:
Standard_Real myX1, myY1, myX2, myY2;
- V3d_LayerMgrPointer myLayerMgr;
Aspect_TypeOfLine myType;
Standard_Real myWidth;
- 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,
Standard_Real X2, Standard_Real Y2,
- V3d_LayerMgrPointer theLayerMgr,
Aspect_TypeOfLine theType,
Standard_Real theWidth,
Standard_Real theTransp) :
- myX1(X1), myY1(Y1), myX2(X2), myY2(Y2), myLayerMgr(theLayerMgr),
- myType(theType), myWidth(theWidth), myTransparency(theTransp)
+ myX1(X1), myY1(Y1), myX2(X2), myY2(Y2),
+ myType(theType), myWidth(theWidth)
{
- if (myLayerMgr && !myLayerMgr->Overlay().IsNull())
- myLayerMgr->Overlay()->AddLayerItem (this);
+ SetTransparency (1-theTransp);
}
// render line
-void V3d_LineItem::RedrawLayerPrs ()
+void V3d_LineItem::Compute (const Handle(PrsMgr_PresentationManager3d)& /*thePresentationManager*/,
+ const Handle(Prs3d_Presentation)& thePresentation,
+ const Standard_Integer /*theMode*/)
{
- Handle (Visual3d_Layer) aOverlay;
-
- if (myLayerMgr)
- aOverlay = myLayerMgr->Overlay();
-
- if (!aOverlay.IsNull())
- {
- Quantity_Color aColor(1.0, 0, 0, Quantity_TOC_RGB);
- aOverlay->SetColor(aColor);
- aOverlay->SetTransparency((Standard_ShortReal)myTransparency);
- aOverlay->SetLineAttributes((Aspect_TypeOfLine)myType, myWidth);
- aOverlay->BeginPolyline();
- aOverlay->AddVertex(myX1, myY1);
- aOverlay->AddVertex(myX2, myY2);
- aOverlay->ClosePrimitive();
- }
+ thePresentation->Clear();
+ Quantity_Color aColor (1.0, 0, 0, Quantity_TOC_RGB);
+ Standard_Integer aWidth, aHeight;
+ ViewerTest::CurrentView()->Window()->Size (aWidth, aHeight);
+ Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (thePresentation);
+ Handle(Graphic3d_ArrayOfPolylines) aPrim = new Graphic3d_ArrayOfPolylines(5);
+ aPrim->AddVertex(myX1, aHeight-myY1, 0.);
+ aPrim->AddVertex(myX2, aHeight-myY2, 0.);
+ Handle(Prs3d_LineAspect) anAspect = new Prs3d_LineAspect (aColor, (Aspect_TypeOfLine)myType, myWidth);
+ aGroup->SetPrimitivesAspect (anAspect->Aspect());
+ aGroup->AddPrimitiveArray (aPrim);
}
//=============================================================================
return 1;
}
+ Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
// get the input params
Standard_Real X1 = Draw::Atof(argv[1]);
Standard_Real Y1 = Draw::Atof(argv[2]);
aLineType = Aspect_TOL_SOLID;
}
- // replace layer manager
- Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr(aView);
- aView->SetLayerMgr(aMgr);
-
- // add line item
- Handle (V3d_LineItem) anItem = new V3d_LineItem(X1, Y1, X2, Y2,
- aMgr.operator->(),
- aLineType, aWidth,
- aTransparency);
-
- // update view
- aView->MustBeResized();
- aView->Redraw();
-
- return 0;
-}
-
-//=======================================================================
-//function : VOverlayText
-//purpose : Test text displaying in view overlay
-//=======================================================================
-static int VOverlayText (Draw_Interpretor& di, Standard_Integer argc, const char**argv)
-{
- // get the active view
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
- {
- di << "No active view. Please call vinit.\n";
- return 1;
- }
- else if (argc < 4 || argc > 13)
- {
- di << "Use: " << argv[0];
- di << " text x y [height] [font_name] [text_color: R G B] [displayType]\n";
- di << "[background_color: R G B]\n";
- di << " height - pixel height of the text (default=10.0)\n";
- di << " font_name - name of font (default=courier)\n";
- di << " text_color - R G B values of text color (default=255.0 255.0 255.0)\n";
- di << " display_type = {normal/subtitle/decal/blend/dimension}, (default=normal)\n";
- di << " background_color- R G B values used for subtitle and decal text\n";
- di << "(default=255.0 255.0 255.0)\n";
- return 1;
- }
-
- TCollection_AsciiString aText (argv[1]);
- Standard_Real aPosX = Draw::Atof(argv[2]);
- Standard_Real aPosY = Draw::Atof(argv[3]);
- Standard_Real aHeight = (argc >= 5) ? Draw::Atof (argv[4]) : 10.0;
-
- // font name
- TCollection_AsciiString aFontName = "Courier";
- if (argc >= 6)
- aFontName = TCollection_AsciiString (argv[5]);
-
- // text colors
- Quantity_Parameter aColorRed = 1.0;
- Quantity_Parameter aColorGreen = 1.0;
- Quantity_Parameter aColorBlue = 1.0;
- if (argc >= 9)
- {
- aColorRed = Draw::Atof (argv[6])/255.;
- aColorGreen = Draw::Atof (argv[7])/255.;
- aColorBlue = Draw::Atof (argv[8])/255.;
- }
-
- // display type
- TCollection_AsciiString aDispStr;
- if (argc >= 10)
- aDispStr = TCollection_AsciiString (argv[9]);
-
- Aspect_TypeOfDisplayText aTextType = Aspect_TODT_NORMAL;
- if (aDispStr.IsEqual ("subtitle"))
- aTextType = Aspect_TODT_SUBTITLE;
- else if (aDispStr.IsEqual ("decal"))
- aTextType = Aspect_TODT_DEKALE;
- else if (aDispStr.IsEqual ("blend"))
- aTextType = Aspect_TODT_BLEND;
- else if (aDispStr.IsEqual ("dimension"))
- aTextType = Aspect_TODT_DIMENSION;
-
- // subtitle color
- Quantity_Parameter aSubRed = 1.0;
- Quantity_Parameter aSubGreen = 1.0;
- Quantity_Parameter aSubBlue = 1.0;
- if (argc == 13)
- {
- aSubRed = Draw::Atof (argv[10])/255.;
- aSubGreen = Draw::Atof (argv[11])/255.;
- aSubBlue = Draw::Atof (argv[12])/255.;
- }
-
- // check fo current overlay
- Handle(Visual3d_Layer) anOverlay = aView->Viewer()->Viewer()->OverLayer ();
- if (anOverlay.IsNull ())
+ static Handle (V3d_LineItem) aLine;
+ if (!aLine.IsNull())
{
- Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr (aView);
- anOverlay = aMgr->Overlay ();
- aView->SetLayerMgr (aMgr);
+ aContext->Erase (aLine);
}
+ aLine = new V3d_LineItem (X1, Y1, X2, Y2,
+ aLineType, aWidth,
+ aTransparency);
- Quantity_Color aTextColor (aColorRed, aColorGreen,
- aColorBlue, Quantity_TOC_RGB);
- Quantity_Color aSubtColor (aSubRed, aSubGreen,
- aSubBlue, Quantity_TOC_RGB);
-
- // add text item
- Handle(V3d_TextItem) anItem = new V3d_TextItem (aText, aPosX, aPosY,
- aHeight, aFontName, aTextColor, aSubtColor, aTextType, anOverlay);
-
- // update view
- aView->MustBeResized();
- aView->Redraw();
+ aContext->SetTransformPersistence (aLine, new Graphic3d_TransformPers (Graphic3d_TMF_2d, Aspect_TOTP_LEFT_LOWER));
+ aLine->SetZLayer (Graphic3d_ZLayerId_TopOSD);
+ aLine->SetToUpdate();
+ aContext->Display (aLine, Standard_True);
return 0;
}
+
//==============================================================================
//function : VGrid
//purpose :
theDI << "FPS: " << aFpsAver << "\n"
<< "CPU: " << (1000.0 * aCpuAver) << " msec\n";
+ // compute additional statistics in ray-tracing mode
+ Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
+
+ if (aParams.Method == Graphic3d_RM_RAYTRACING)
+ {
+ Standard_Integer aSizeX;
+ Standard_Integer aSizeY;
+
+ aView->Window()->Size (aSizeX, aSizeY);
+
+ // 1 shadow ray and 1 secondary ray pew each bounce
+ const Standard_Real aMRays = aSizeX * aSizeY * aFpsAver * aParams.RaytracingDepth * 2 / 1.0e6f;
+
+ theDI << "MRays/sec (upper bound): " << aMRays << "\n";
+ }
+
return 0;
}
{
Standard_Boolean toShowWarns = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toShowWarns))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShowWarns))
{
--anArgIter;
}
{
Standard_Boolean toShow = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toShow))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShow))
{
--anArgIter;
}
{
Standard_Boolean toSuppress = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toSuppress))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSuppress))
{
--anArgIter;
}
{
Standard_Boolean toSync = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toSync))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSync))
{
--anArgIter;
}
else if (anArgCase == "-debug")
{
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnableDebug))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnableDebug))
{
--anArgIter;
}
aDefCaps->contextDebug = toEnableDebug;
}
- else if (parseOnOff (anArg, toEnableDebug)
+ else if (ViewerTest::ParseOnOff (anArg, toEnableDebug)
&& (anArgIter + 1 == theArgNb))
{
// simple alias to turn on almost everything
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;
}
{
continue;
}
+ else if (anArgCase == "-vsync"
+ || anArgCase == "-swapinterval")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->swapInterval = toEnable;
+ }
else if (anArgCase == "-ffp")
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
{
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
aCaps->ffpEnable = Standard_False;
}
}
+ else if (anArgCase == "-stereo"
+ || anArgCase == "-quadbuffer")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextStereo = toEnable;
+ }
else
{
std::cout << "Error: unknown argument '" << anArg << "'\n";
{
if(argc < 3)
{
- di << "Usage : " << argv[0] << " x1 y1 [x2 y2 [... xn yn]] [shift_selection = 1|0]" << "\n";
+ di << "Usage : " << argv[0] << " x1 y1 [x2 y2 [... xn yn]] [shift_selection = 1|0]\n";
return 1;
}
}
Standard_Integer isToAllow = isShiftSelection ? Draw::Atoi(argv[argc - 2]) : Draw::Atoi(argv[argc - 1]);
- myAIScontext->MainSelector()->AllowOverlapDetection((Standard_Boolean)isToAllow);
+ myAIScontext->MainSelector()->AllowOverlapDetection (isToAllow != 0);
aCoordsNb -= 2;
}
{
if(argc != 3)
{
- di << "Usage : " << argv[0] << " x y" << "\n";
+ di << "Usage : " << argv[0] << " x y\n";
return 1;
}
return 1;
}
- if(aContext->HasOpenedContext())
- {
- aContext->AddOrRemoveSelected(anAISObject);
- }
- else
- {
- aContext->AddOrRemoveCurrentObject(anAISObject);
- }
+ aContext->AddOrRemoveSelected(anAISObject);
}
return 0;
}
//=======================================================================
-//function : VZClipping
-//purpose : Gets or sets ZClipping mode, width and depth
+//function : VNbSelected
+//purpose : Returns number of selected objects
//=======================================================================
-static Standard_Integer VZClipping (Draw_Interpretor& di,
+static Standard_Integer VNbSelected (Draw_Interpretor& di,
Standard_Integer argc,
const char ** argv)
{
- if(argc>4)
- {
- di << "Usage : " << argv[0] << " [mode] [depth width]" << "\n"
- <<"mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
- return -1;
- }
- Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- if(aContext.IsNull())
- {
- di << "use 'vinit' command before " << argv[0] << "\n";
- return 1;
- }
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- V3d_TypeOfZclipping aZClippingMode = V3d_OFF;
- if(argc==1)
- {
- TCollection_AsciiString aZClippingModeString;
- Quantity_Length aDepth, aWidth;
- aZClippingMode = aView->ZClipping(aDepth, aWidth);
- switch (aZClippingMode)
- {
- case V3d_OFF:
- aZClippingModeString.Copy("OFF");
- break;
- case V3d_BACK:
- aZClippingModeString.Copy("BACK");
- break;
- case V3d_FRONT:
- aZClippingModeString.Copy("FRONT");
- break;
- case V3d_SLICE:
- aZClippingModeString.Copy("SLICE");
- break;
- default:
- aZClippingModeString.Copy(TCollection_AsciiString(aZClippingMode));
- break;
- }
- di << "ZClippingMode = " << aZClippingModeString.ToCString() << "\n"
- << "ZClipping depth = " << aDepth << "\n"
- << "ZClipping width = " << aWidth << "\n";
- }
- else
- {
- if(argc !=3)
- {
- Standard_Integer aStatus = 0;
- if ( strcmp (argv [1], "OFF") == 0 ) {
- aStatus = 1;
- aZClippingMode = V3d_OFF;
- }
- if ( strcmp (argv [1], "BACK") == 0 ) {
- aStatus = 1;
- aZClippingMode = V3d_BACK;
- }
- if ( strcmp (argv [1], "FRONT") == 0 ) {
- aStatus = 1;
- aZClippingMode = V3d_FRONT;
- }
- if ( strcmp (argv [1], "SLICE") == 0 ) {
- aStatus = 1;
- aZClippingMode = V3d_SLICE;
- }
- if (aStatus != 1)
- {
- di << "Bad mode; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
- << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
- return 1;
- }
- aView->SetZClippingType(aZClippingMode);
- }
- if(argc >2)
- {
- Quantity_Length aDepth = 0., aWidth = 1.;
- if(argc == 3)
- {
- aDepth = Draw::Atof (argv[1]);
- aWidth = Draw::Atof (argv[2]);
- }
- else if(argc == 4)
- {
- aDepth = Draw::Atof (argv[2]);
- aWidth = Draw::Atof (argv[3]);
- }
-
- if(aDepth<0. || aDepth>1.)
- {
- di << "Bad depth; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
- << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
- return 1;
- }
- if(aWidth<0. || aWidth>1.)
- {
- di << "Bad width; Usage : " << argv[0] << " [mode] [depth width]" << "\n"
- << "mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
- return 1;
- }
-
- aView->SetZClippingDepth(aDepth);
- aView->SetZClippingWidth(aWidth);
- }
- aView->Redraw();
- }
- return 0;
-}
-
-//=======================================================================
-//function : VNbSelected
-//purpose : Returns number of selected objects
-//=======================================================================
-static Standard_Integer VNbSelected (Draw_Interpretor& di,
- Standard_Integer argc,
- const char ** argv)
-{
- if(argc != 1)
+ if(argc != 1)
{
di << "Usage : " << argv[0] << "\n";
return 1;
return 0;
}
-//=======================================================================
-//function : VAntialiasing
-//purpose : Switches altialiasing on or off
-//=======================================================================
-static Standard_Integer VAntialiasing (Draw_Interpretor& di,
- Standard_Integer argc,
- const char ** argv)
-{
- if(argc > 2)
- {
- di << "Usage : " << argv[0] << " [1|0]" << "\n";
- return 1;
- }
-
- Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- if(aContext.IsNull())
- {
- di << "use 'vinit' command before " << argv[0] << "\n";
- return 1;
- }
-
- Handle(V3d_View) aView = ViewerTest::CurrentView();
-
- if((argc == 2) && (atof(argv[1]) == 0))
- aView->SetAntialiasingOff();
- else
- aView->SetAntialiasingOn();
- aView->Update();
- return 0;
-}
-
//=======================================================================
//function : VPurgeDisplay
//purpose : Switches altialiasing on or off
const Standard_ShortReal theXShift,
const Standard_ShortReal theYShift,
const Standard_ShortReal theAngle);
- DEFINE_STANDARD_RTTI(OCC_TextureEnv);
+ DEFINE_STANDARD_RTTI_INLINE(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);
+DEFINE_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv)
OCC_TextureEnv::OCC_TextureEnv(const Standard_CString theFileName)
: Graphic3d_TextureEnv(theFileName)
);
}
aView->SetTextureEnv(aTexEnv);
- aView->SetSurfaceDetail(V3d_TEX_ENVIRONMENT);
}
else // Disabling environment mapping
{
- aView->SetSurfaceDetail(V3d_TEX_NONE);
Handle(Graphic3d_TextureEnv) aTexture;
aView->SetTextureEnv(aTexture); // Passing null handle to clear the texture data
}
return 0;
}
+namespace
+{
+ typedef NCollection_DataMap<TCollection_AsciiString, Handle(Graphic3d_ClipPlane)> MapOfPlanes;
+
+ //! Remove registered clipping plane from all views and objects.
+ static void removePlane (MapOfPlanes& theRegPlanes,
+ const TCollection_AsciiString& theName)
+ {
+ Handle(Graphic3d_ClipPlane) aClipPlane;
+ if (!theRegPlanes.Find (theName, aClipPlane))
+ {
+ std::cout << "Warning: no such plane.\n";
+ return;
+ }
+
+ theRegPlanes.UnBind (theName);
+ for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIObjIt (GetMapOfAIS());
+ anIObjIt.More(); anIObjIt.Next())
+ {
+ Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anIObjIt.Key1());
+ aPrs->RemoveClipPlane (aClipPlane);
+ }
+
+ for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
+ aViewIt.More(); aViewIt.Next())
+ {
+ const Handle(V3d_View)& aView = aViewIt.Key2();
+ aView->RemoveClipPlane(aClipPlane);
+ }
+
+ ViewerTest::RedrawAllViews();
+ }
+}
+
//===============================================================================================
//function : VClipPlane
//purpose :
static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
{
// use short-cut for created clip planes map of created (or "registered by name") clip planes
- typedef NCollection_DataMap<TCollection_AsciiString, Handle(Graphic3d_ClipPlane)> MapOfPlanes;
static MapOfPlanes aRegPlanes;
if (theArgsNb < 2)
{
- theDi << theArgVec[0] << ": command argument is required. Type help for more information.\n";
- return 1;
+ for (MapOfPlanes::Iterator aPlaneIter (aRegPlanes); aPlaneIter.More(); aPlaneIter.Next())
+ {
+ theDi << aPlaneIter.Key() << " ";
+ }
+ return 0;
}
TCollection_AsciiString aCommand (theArgVec[1]);
+ aCommand.LowerCase();
+ const Handle(V3d_View)& anActiveView = ViewerTest::CurrentView();
+ if (anActiveView.IsNull())
+ {
+ std::cout << "Error: no active view.\n";
+ return 1;
+ }
// print maximum number of planes for current viewer
- if (aCommand == "maxplanes")
+ if (aCommand == "-maxplanes"
+ || aCommand == "maxplanes")
{
- if (theArgsNb < 3)
- {
- theDi << theArgVec[0] << ": view name is required. Type help for more information.\n";
- return 1;
- }
-
- TCollection_AsciiString aViewName (theArgVec[2]);
-
- if (!ViewerTest_myViews.IsBound1 (aViewName))
- {
- theDi << theArgVec[0] << ": view is not found.\n";
- return 1;
- }
-
- const Handle(V3d_View)& aView = ViewerTest_myViews.Find1 (aViewName);
-
- theDi << theArgVec[0] << ": "
- << aView->Viewer()->Driver()->InquirePlaneLimit()
- << " plane slots provided by driver."
- << " Note that 2 more planes might be used (reserved for z-clipping).\n";
-
+ theDi << anActiveView->Viewer()->Driver()->InquirePlaneLimit()
+ << " plane slots provided by driver.\n";
return 0;
}
// create / delete plane instance
- if (aCommand == "create" || aCommand == "delete" || aCommand == "clone")
+ if (aCommand == "-create"
+ || aCommand == "create"
+ || aCommand == "-delete"
+ || aCommand == "delete"
+ || aCommand == "-clone"
+ || aCommand == "clone")
{
if (theArgsNb < 3)
{
- theDi << theArgVec[0] << ": plane name is required. Type help for more information.\n";
+ std::cout << "Syntax error: plane name is required.\n";
return 1;
}
- Standard_Boolean toCreate = (aCommand == "create");
- Standard_Boolean toClone = (aCommand == "clone");
+ Standard_Boolean toCreate = aCommand == "-create"
+ || aCommand == "create";
+ Standard_Boolean toClone = aCommand == "-clone"
+ || aCommand == "clone";
+ Standard_Boolean toDelete = aCommand == "-delete"
+ || aCommand == "delete";
TCollection_AsciiString aPlane (theArgVec[2]);
if (toCreate)
{
if (aRegPlanes.IsBound (aPlane))
{
- theDi << theArgVec[0] << ": plane name is in use.\n";
- return 1;
+ std::cout << "Warning: existing plane has been overridden.\n";
+ toDelete = true;
+ }
+ else
+ {
+ aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
+ return 0;
}
-
- aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
}
else if (toClone) // toClone
{
if (!aRegPlanes.IsBound (aPlane))
{
- theDi << theArgVec[0] << ": no such plane.\n";
+ std::cout << "Error: no such plane.\n";
return 1;
}
-
- if (theArgsNb < 4)
+ else if (theArgsNb < 4)
{
- theDi << theArgVec[0] << ": enter name for new plane. Type help for more information.\n";
+ std::cout << "Syntax error: enter name for new plane.\n";
return 1;
}
TCollection_AsciiString aClone (theArgVec[3]);
if (aRegPlanes.IsBound (aClone))
{
- theDi << theArgVec[0] << ": plane name is in use.\n";
+ std::cout << "Error: plane name is in use.\n";
return 1;
}
const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
aRegPlanes.Bind (aClone, aClipPlane->Clone());
+ return 0;
}
- else// toDelete
- {
- if (!aRegPlanes.IsBound (aPlane))
- {
- theDi << theArgVec[0] << ": no such plane.\n";
- return 1;
- }
-
- Handle(Graphic3d_ClipPlane) aClipPlane = aRegPlanes.Find (aPlane);
- aRegPlanes.UnBind (aPlane);
- ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIObjIt (GetMapOfAIS());
- for (; anIObjIt.More(); anIObjIt.Next())
+ if (toDelete)
+ {
+ if (aPlane == "ALL"
+ || aPlane == "all"
+ || aPlane == "*")
{
- Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anIObjIt.Key1());
- aPrs->RemoveClipPlane(aClipPlane);
+ for (MapOfPlanes::Iterator aPlaneIter (aRegPlanes); aPlaneIter.More();)
+ {
+ aPlane = aPlaneIter.Key();
+ removePlane (aRegPlanes, aPlane);
+ aPlaneIter = MapOfPlanes::Iterator (aRegPlanes);
+ }
}
-
- NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
- for (; aViewIt.More(); aViewIt.Next())
+ else
{
- const Handle(V3d_View)& aView = aViewIt.Key2();
- aView->RemoveClipPlane(aClipPlane);
+ removePlane (aRegPlanes, aPlane);
}
-
- ViewerTest::RedrawAllViews();
}
+ if (toCreate)
+ {
+ aRegPlanes.Bind (aPlane, new Graphic3d_ClipPlane());
+ }
return 0;
}
// set / unset plane command
- if (aCommand == "set" || aCommand == "unset")
+ if (aCommand == "set"
+ || aCommand == "unset")
{
- if (theArgsNb < 4)
+ if (theArgsNb < 5)
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- Standard_Boolean toSet = (aCommand == "set");
- TCollection_AsciiString aPlane (theArgVec [2]);
- if (!aRegPlanes.IsBound (aPlane))
+ // redirect to new syntax
+ NCollection_Array1<const char*> anArgVec (1, theArgsNb - 1);
+ anArgVec.SetValue (1, theArgVec[0]);
+ anArgVec.SetValue (2, theArgVec[2]);
+ anArgVec.SetValue (3, aCommand == "set" ? "-set" : "-unset");
+ for (Standard_Integer anIt = 4; anIt < theArgsNb; ++anIt)
{
- theDi << theArgVec[0] << ": no such plane.\n";
- return 1;
- }
-
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
-
- TCollection_AsciiString aTarget (theArgVec [3]);
- if (aTarget != "object" && aTarget != "view")
- {
- theDi << theArgVec[0] << ": invalid target.\n";
- return 1;
- }
-
- if (aTarget == "object" || aTarget == "view")
- {
- if (theArgsNb < 5)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
-
- Standard_Boolean isObject = (aTarget == "object");
-
- for (Standard_Integer anIt = 4; anIt < theArgsNb; ++anIt)
- {
- TCollection_AsciiString anEntityName (theArgVec[anIt]);
- if (isObject) // to object
- {
- if (!GetMapOfAIS().IsBound2 (anEntityName))
- {
- theDi << theArgVec[0] << ": can not find IO with name " << anEntityName << ".\n";
- continue;
- }
-
- Handle(AIS_InteractiveObject) aIObj =
- Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anEntityName));
-
- if (toSet)
- aIObj->AddClipPlane (aClipPlane);
- else
- aIObj->RemoveClipPlane (aClipPlane);
- }
- else // to view
- {
- if (!ViewerTest_myViews.IsBound1 (anEntityName))
- {
- theDi << theArgVec[0] << ": can not find View with name " << anEntityName << ".\n";
- continue;
- }
-
- Handle(V3d_View) aView = ViewerTest_myViews.Find1(anEntityName);
- if (toSet)
- aView->AddClipPlane (aClipPlane);
- else
- aView->RemoveClipPlane (aClipPlane);
- }
- }
-
- ViewerTest::RedrawAllViews();
+ anArgVec.SetValue (anIt, theArgVec[anIt]);
}
- return 0;
+ return VClipPlane (theDi, anArgVec.Length(), &anArgVec.ChangeFirst());
}
// change plane command
- if (aCommand == "change")
+ TCollection_AsciiString aPlaneName;
+ Handle(Graphic3d_ClipPlane) aClipPlane;
+ Standard_Integer anArgIter = 0;
+ if (aCommand == "-change"
+ || aCommand == "change")
{
- if (theArgsNb < 4)
+ // old syntax support
+ if (theArgsNb < 3)
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- TCollection_AsciiString aPlane (theArgVec [2]);
- if (!aRegPlanes.IsBound (aPlane))
+ anArgIter = 3;
+ aPlaneName = theArgVec[2];
+ if (!aRegPlanes.Find (aPlaneName, aClipPlane))
{
- theDi << theArgVec[0] << ": no such plane.\n";
+ std::cout << "Error: no such plane '" << aPlaneName << "'.\n";
return 1;
}
+ }
+ else if (aRegPlanes.Find (theArgVec[1], aClipPlane))
+ {
+ anArgIter = 2;
+ aPlaneName = theArgVec[1];
+ }
+ else
+ {
+ anArgIter = 2;
+ aPlaneName = theArgVec[1];
+ aClipPlane = new Graphic3d_ClipPlane();
+ aRegPlanes.Bind (aPlaneName, aClipPlane);
+ theDi << "Created new plane " << aPlaneName << ".\n";
+ }
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
+ if (theArgsNb - anArgIter < 1)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- TCollection_AsciiString aChangeArg (theArgVec [3]);
- if (aChangeArg != "on" && aChangeArg != "off" && aChangeArg != "capping" && aChangeArg != "equation")
- {
- theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
- return 1;
- }
+ for (; anArgIter < theArgsNb; ++anArgIter)
+ {
+ const char** aChangeArgs = theArgVec + anArgIter;
+ Standard_Integer aNbChangeArgs = theArgsNb - anArgIter;
+ TCollection_AsciiString aChangeArg (aChangeArgs[0]);
+ aChangeArg.LowerCase();
- if (aChangeArg == "on" || aChangeArg == "off") // on / off
+ Standard_Boolean toEnable = Standard_True;
+ if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable))
{
- aClipPlane->SetOn (aChangeArg == "on");
+ aClipPlane->SetOn (toEnable);
}
- else if (aChangeArg == "equation") // change equation
+ else if (aChangeArg == "-equation"
+ || aChangeArg == "equation")
{
- if (theArgsNb < 8)
+ if (aNbChangeArgs < 5)
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- 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]);
+ Standard_Real aCoeffA = Draw::Atof (aChangeArgs [1]);
+ Standard_Real aCoeffB = Draw::Atof (aChangeArgs [2]);
+ Standard_Real aCoeffC = Draw::Atof (aChangeArgs [3]);
+ Standard_Real aCoeffD = Draw::Atof (aChangeArgs [4]);
aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
+ anArgIter += 4;
}
- else if (aChangeArg == "capping") // change capping aspects
+ else if (aChangeArg == "-capping"
+ || aChangeArg == "capping")
{
- if (theArgsNb < 5)
+ if (aNbChangeArgs < 2)
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- TCollection_AsciiString aCappingArg (theArgVec [4]);
- if (aCappingArg != "on" && aCappingArg != "off" &&
- aCappingArg != "color" && aCappingArg != "texname" &&
- aCappingArg != "texscale" && aCappingArg != "texorigin" &&
- aCappingArg != "texrotate" && aCappingArg != "hatch")
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetCapping (toEnable);
+ anArgIter += 1;
+ }
+ else
{
- theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
+ // just skip otherwise (old syntax)
+ }
+ }
+ else if (aChangeArg == "-useobjectmaterial"
+ || aChangeArg == "-useobjectmat"
+ || aChangeArg == "-useobjmat"
+ || aChangeArg == "-useobjmaterial")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- if (aCappingArg == "on" || aCappingArg == "off") // on / off capping
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetCapping (aCappingArg == "on");
+ aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+ anArgIter += 1;
}
- else if (aCappingArg == "color") // color aspect for capping
+ }
+ else if (aChangeArg == "-useobjecttexture"
+ || aChangeArg == "-useobjecttex"
+ || aChangeArg == "-useobjtexture"
+ || aChangeArg == "-useobjtex")
+ {
+ if (aNbChangeArgs < 2)
{
- if (theArgsNb < 8)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
-
- Standard_Real aRed = Draw::Atof (theArgVec [5]);
- Standard_Real aGrn = Draw::Atof (theArgVec [6]);
- Standard_Real aBlu = Draw::Atof (theArgVec [7]);
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
- Quantity_Color aColor (aRed, aGrn, aBlu, Quantity_TOC_RGB);
- aMat.SetAmbientColor (aColor);
- aMat.SetDiffuseColor (aColor);
- aClipPlane->SetCappingMaterial (aMat);
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
+ anArgIter += 1;
}
- else if (aCappingArg == "texname") // texture name
+ }
+ else if (aChangeArg == "-useobjectshader"
+ || aChangeArg == "-useobjshader")
+ {
+ if (aNbChangeArgs < 2)
{
- if (theArgsNb < 6)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
-
- TCollection_AsciiString aTextureName (theArgVec [5]);
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
- if (!aTexture->IsDone ())
- {
- aClipPlane->SetCappingTexture (NULL);
- }
- else
- {
- aTexture->EnableModulate();
- aTexture->EnableRepeat();
- aClipPlane->SetCappingTexture (aTexture);
- }
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectShader (toEnable == Standard_True);
+ anArgIter += 1;
}
- else if (aCappingArg == "texscale") // texture scale
+ }
+ else if (aChangeArg == "-color"
+ || aChangeArg == "color")
+ {
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ aChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
{
- if (aClipPlane->CappingTexture().IsNull())
- {
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
- }
-
- if (theArgsNb < 7)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- Standard_ShortReal aSx = (Standard_ShortReal)atof (theArgVec [5]);
- Standard_ShortReal aSy = (Standard_ShortReal)atof (theArgVec [6]);
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+ aMat.SetAmbientColor (aColor);
+ aMat.SetDiffuseColor (aColor);
+ aClipPlane->SetCappingMaterial (aMat);
+ anArgIter += aNbParsed;
+ }
+ else if (aChangeArg == "-texname"
+ || aChangeArg == "texname")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ TCollection_AsciiString aTextureName (aChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
+ {
+ aClipPlane->SetCappingTexture (NULL);
}
- else if (aCappingArg == "texorigin") // texture origin
+ else
{
- if (aClipPlane->CappingTexture().IsNull())
- {
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
- }
-
- if (theArgsNb < 7)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ aTexture->EnableModulate();
+ aTexture->EnableRepeat();
+ aClipPlane->SetCappingTexture (aTexture);
+ }
+ anArgIter += 1;
+ }
+ else if (aChangeArg == "-texscale"
+ || aChangeArg == "texscale")
+ {
+ if (aClipPlane->CappingTexture().IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
- Standard_ShortReal aTx = (Standard_ShortReal)atof (theArgVec [5]);
- Standard_ShortReal aTy = (Standard_ShortReal)atof (theArgVec [6]);
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
+ aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ anArgIter += 2;
+ }
+ else if (aChangeArg == "-texorigin"
+ || aChangeArg == "texorigin") // texture origin
+ {
+ if (aClipPlane->CappingTexture().IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
}
- else if (aCappingArg == "texrotate") // texture rotation
+
+ if (aNbChangeArgs < 3)
{
- if (aClipPlane->CappingTexture().IsNull())
- {
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
- }
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- if (theArgsNb < 6)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
- Standard_ShortReal aRot = (Standard_ShortReal)atof (theArgVec[5]);
+ aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ anArgIter += 2;
+ }
+ else if (aChangeArg == "-texrotate"
+ || aChangeArg == "texrotate") // texture rotation
+ {
+ if (aClipPlane->CappingTexture().IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
- aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
}
- else if (aCappingArg == "hatch") // hatch style
+
+ Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
+ anArgIter += 1;
+ }
+ else if (aChangeArg == "-hatch"
+ || aChangeArg == "hatch")
+ {
+ if (aNbChangeArgs < 2)
{
- if (theArgsNb < 6)
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aHatchStr (aChangeArgs[1]);
+ aHatchStr.LowerCase();
+ if (aHatchStr == "on")
+ {
+ aClipPlane->SetCappingHatchOn();
+ }
+ else if (aHatchStr == "off")
+ {
+ aClipPlane->SetCappingHatchOff();
+ }
+ else
+ {
+ aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
+ }
+ anArgIter += 1;
+ }
+ else if (aChangeArg == "-delete"
+ || aChangeArg == "delete")
+ {
+ removePlane (aRegPlanes, aPlaneName);
+ return 0;
+ }
+ else if (aChangeArg == "-set"
+ || aChangeArg == "-unset")
+ {
+ // set / unset plane command
+ Standard_Boolean toSet = aChangeArg == "-set";
+ Standard_Integer anIt = 1;
+ for (; anIt < aNbChangeArgs; ++anIt)
+ {
+ TCollection_AsciiString anEntityName (aChangeArgs[anIt]);
+ if (anEntityName.IsEmpty()
+ || anEntityName.Value (1) == '-')
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
+ break;
}
-
- TCollection_AsciiString aHatchStr (theArgVec [5]);
- if (aHatchStr == "on")
+ else if (ViewerTest_myViews.IsBound1 (anEntityName))
+ {
+ Handle(V3d_View) aView = ViewerTest_myViews.Find1 (anEntityName);
+ if (toSet)
+ {
+ aView->AddClipPlane (aClipPlane);
+ }
+ else
+ {
+ aView->RemoveClipPlane (aClipPlane);
+ }
+ continue;
+ }
+ else if (GetMapOfAIS().IsBound2 (anEntityName))
+ {
+ Handle(AIS_InteractiveObject) aIObj = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anEntityName));
+ if (toSet)
+ {
+ aIObj->AddClipPlane (aClipPlane);
+ }
+ else
+ {
+ aIObj->RemoveClipPlane (aClipPlane);
+ }
+ }
+ else
{
- aClipPlane->SetCappingHatchOn();
+ std::cout << "Error: object/view '" << anEntityName << "' is not found!\n";
+ return 1;
}
- else if (aHatchStr == "off")
+ }
+
+ if (anIt == 1)
+ {
+ // apply to active view
+ if (toSet)
{
- aClipPlane->SetCappingHatchOff();
+ anActiveView->AddClipPlane (aClipPlane);
}
else
{
- aClipPlane->SetCappingHatch ((Aspect_HatchStyle)atoi (theArgVec[5]));
+ anActiveView->RemoveClipPlane (aClipPlane);
}
}
+ else
+ {
+ anArgIter = anArgIter + anIt - 1;
+ }
}
-
- ViewerTest::RedrawAllViews();
-
- return 0;
- }
-
- theDi << theArgVec[0] << ": invalid command. Type help for more information.\n";
- return 1;
-}
-
-//===============================================================================================
-//function : VSetTextureMode
-//purpose :
-//===============================================================================================
-static int VSetTextureMode (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
-{
- if (theArgsNb < 3)
- {
- theDi << theArgVec[0] << ": insufficient command arguments. Type help for more information.\n";
- return 1;
- }
-
- TCollection_AsciiString aViewName (theArgVec[1]);
- if (!ViewerTest_myViews.IsBound1 (aViewName))
- {
- theDi << theArgVec[0] << ": view is not found.\n";
- return 1;
- }
-
- const Handle(V3d_View)& aView = ViewerTest_myViews.Find1 (aViewName);
- switch (atoi (theArgVec[2]))
- {
- case 0: aView->SetSurfaceDetail (V3d_TEX_NONE); break;
- case 1: aView->SetSurfaceDetail (V3d_TEX_ENVIRONMENT); break;
- case 2: aView->SetSurfaceDetail (V3d_TEX_ALL); break;
- default:
- theDi << theArgVec[0] << ": invalid mode.\n";
+ else
+ {
+ std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
return 1;
+ }
}
- aView->Redraw();
+ ViewerTest::RedrawAllViews();
return 0;
}
return 1;
}
- Standard_Real aScale = aCurrentView->View()->AutoZFitScaleFactor();
+ Standard_Real aScale = aCurrentView->AutoZFitScaleFactor();
if (theArgsNb > 3)
{
if (theArgsNb < 2)
{
- theDi << "Auto z-fit mode: " << "\n"
- << "On: " << (aCurrentView->View()->AutoZFitMode() ? "enabled" : "disabled") << "\n"
+ theDi << "Auto z-fit mode: \n"
+ << "On: " << (aCurrentView->AutoZFitMode() ? "enabled" : "disabled") << "\n"
<< "Scale: " << aScale << "\n";
return 0;
}
aScale = Draw::Atoi (theArgVec[2]);
}
- aCurrentView->View()->SetAutoZFitMode (isOn, aScale);
- aCurrentView->View()->AutoZFit();
+ aCurrentView->SetAutoZFitMode (isOn, aScale);
+ aCurrentView->AutoZFit();
aCurrentView->Redraw();
return 0;
}
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() << " ";
+ 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
+ {
+ std::cout << "Error: unknown argument '" << anArg << "'\n";
+ return 1;
+ }
+ }
+
+ aView->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")
+ {
+ theMode = Graphic3d_StereoMode_QuadBuffer;
+ }
+ else if (aFlag == "anaglyph")
+ {
+ theMode = Graphic3d_StereoMode_Anaglyph;
+ }
+ else if (aFlag == "row"
+ || aFlag == "rowinterlaced")
+ {
+ theMode = Graphic3d_StereoMode_RowInterlaced;
+ }
+ else if (aFlag == "col"
+ || aFlag == "colinterlaced"
+ || aFlag == "columninterlaced")
+ {
+ theMode = Graphic3d_StereoMode_ColumnInterlaced;
+ }
+ else if (aFlag == "chess"
+ || aFlag == "chessboard")
+ {
+ theMode = Graphic3d_StereoMode_ChessBoard;
+ }
+ else if (aFlag == "sbs"
+ || aFlag == "sidebyside")
+ {
+ 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
+ {
+ return Standard_False;
+ }
+ return Standard_True;
+}
+
+//! 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;
+}
+
+//==============================================================================
+//function : VStereo
+//purpose :
+//==============================================================================
+
+static int VStereo (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (theArgNb < 2)
+ {
+ if (aView.IsNull())
+ {
+ std::cout << "Error: no active viewer!\n";
+ return 0;
+ }
+
+ Standard_Boolean isActive = ViewerTest_myDefaultCaps.contextStereo;
+ theDI << "Stereo " << (isActive ? "ON" : "OFF") << "\n";
+ if (isActive)
+ {
+ TCollection_AsciiString aMode;
+ switch (aView->RenderingParams().StereoMode)
+ {
+ case Graphic3d_StereoMode_QuadBuffer : aMode = "quadBuffer"; break;
+ case Graphic3d_StereoMode_RowInterlaced : aMode = "rowInterlaced"; break;
+ case Graphic3d_StereoMode_ColumnInterlaced : aMode = "columnInterlaced"; break;
+ case Graphic3d_StereoMode_ChessBoard : aMode = "chessBoard"; break;
+ case Graphic3d_StereoMode_SideBySide : aMode = "sideBySide"; break;
+ case Graphic3d_StereoMode_OverUnder : aMode = "overUnder"; break;
+ case Graphic3d_StereoMode_SoftPageFlip : aMode = "softpageflip"; break;
+ case Graphic3d_StereoMode_Anaglyph :
+ aMode = "anaglyph";
+ switch (aView->RenderingParams().AnaglyphFilter)
+ {
+ case Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple : aMode.AssignCat (" (redCyanSimple)"); break;
+ case Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized : aMode.AssignCat (" (redCyan)"); break;
+ case Graphic3d_RenderingParams::Anaglyph_YellowBlue_Simple : aMode.AssignCat (" (yellowBlueSimple)"); break;
+ case Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized: aMode.AssignCat (" (yellowBlue)"); break;
+ case Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple : aMode.AssignCat (" (greenMagentaSimple)"); break;
+ default: break;
+ }
+ default: break;
+ }
+ theDI << "Mode " << aMode << "\n";
+ }
+ return 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 (anArgCase == "-iodtype")
+ else if (aFlag == "0"
+ || aFlag == "off")
{
- Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
- TCollection_AsciiString anValueCase (anArgValue);
- anValueCase.LowerCase();
- if (anValueCase == "abs"
- || anValueCase == "absolute")
+ if (++anArgIter < theArgNb)
{
- ++anArgIter;
- aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
- continue;
+ std::cout << "Error: wrong number of arguments!\n";
+ return 1;
}
- else if (anValueCase == "rel"
- || anValueCase == "relative")
+
+ if (!aCamera.IsNull()
+ && aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
{
- ++anArgIter;
- aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
- continue;
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
}
- else if (*anArgValue != '-')
+ ViewerTest_myDefaultCaps.contextStereo = Standard_False;
+ return 0;
+ }
+ else if (aFlag == "1"
+ || aFlag == "on")
+ {
+ if (++anArgIter < theArgNb)
{
- std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
+ std::cout << "Error: wrong number of arguments!\n";
return 1;
}
- switch (aCamera->GetIODType())
+
+ if (!aCamera.IsNull())
{
- case Graphic3d_Camera::IODType_Absolute: theDI << "absolute "; break;
- case Graphic3d_Camera::IODType_Relative: theDI << "relative "; break;
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
}
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+ return 0;
}
- else if (anArgCase == "-zfocus")
+ else if (aFlag == "-reverse"
+ || aFlag == "-reversed"
+ || aFlag == "-swap")
{
- Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
- if (anArgValue != NULL
- && *anArgValue != '-')
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
- ++anArgIter;
- aCamera->SetZFocus (aCamera->ZFocusType(), Draw::Atof (anArgValue));
- continue;
+ --anArgIter;
}
- theDI << aCamera->ZFocus() << " ";
+ aParams->ToReverseStereo = toEnable;
}
- else if (anArgCase == "-zfocustype")
+ else if (aFlag == "-noreverse"
+ || aFlag == "-noswap")
{
- Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
- TCollection_AsciiString anValueCase (anArgValue);
- anValueCase.LowerCase();
- if (anValueCase == "abs"
- || anValueCase == "absolute")
+ Standard_Boolean toDisable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toDisable))
{
- ++anArgIter;
- aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
- continue;
+ --anArgIter;
}
- else if (anValueCase == "rel"
- || anValueCase == "relative")
+ aParams->ToReverseStereo = !toDisable;
+ }
+ else if (aFlag == "-mode"
+ || aFlag == "-stereomode")
+ {
+ if (++anArgIter >= theArgNb
+ || !parseStereoMode (theArgVec[anArgIter], aMode))
{
- ++anArgIter;
- aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
- continue;
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
+ return 1;
}
- else if (*anArgValue != '-')
+
+ if (aMode == Graphic3d_StereoMode_QuadBuffer)
{
- std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
- return 1;
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
}
- switch (aCamera->ZFocusType())
+ }
+ else if (aFlag == "-anaglyph"
+ || aFlag == "-anaglyphfilter")
+ {
+ Graphic3d_RenderingParams::Anaglyph aFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
+ if (++anArgIter >= theArgNb
+ || !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
{
- case Graphic3d_Camera::FocusType_Absolute: theDI << "absolute "; break;
- case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
+ return 1;
}
+
+ aMode = Graphic3d_StereoMode_Anaglyph;
+ aParams->AnaglyphFilter = aFilter;
}
- else if (anArgCase == "-fov"
- || anArgCase == "-fovy")
+ else if (parseStereoMode (anArg, aMode)) // short syntax
{
- Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
- if (anArgValue != NULL
- && *anArgValue != '-')
+ if (aMode == Graphic3d_StereoMode_QuadBuffer)
{
- ++anArgIter;
- aCamera->SetFOVy (Draw::Atof (anArgValue));
- continue;
+ ViewerTest_myDefaultCaps.contextStereo = Standard_True;
}
- theDI << aCamera->FOVy() << " ";
}
else
{
- std::cout << "Error: unknown argument '" << anArg << "'\n";
+ std::cout << "Error: syntax error at '" << anArg << "'\n";
return 1;
}
}
- aView->View()->AutoZFit();
- aView->Redraw();
-
- return 0;
-}
-
-//==============================================================================
-//function : VStereo
-//purpose :
-//==============================================================================
-
-static int VStereo (Draw_Interpretor& theDI,
- Standard_Integer theArgNb,
- const char** theArgVec)
-{
- if (theArgNb < 2)
+ if (!aView.IsNull())
{
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
- {
- std::cerr << "No active view. Please call vinit.\n";
- return 0;
- }
-
- Standard_Boolean isActive = ViewerTest_myDefaultCaps.contextStereo;
- theDI << "Stereo " << (isActive ? "ON" : "OFF") << "\n";
- return 0;
+ aParams->StereoMode = aMode;
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
}
-
- ViewerTest_myDefaultCaps.contextStereo = Draw::Atoi (theArgVec[1]) != 0;
return 0;
}
// currently HLRDeviationAngle is used instead of DeviationAngle in most places
aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
}
- if (anArg == "-AUTOTR"
- || anArg == "-AUTOTRIANG"
- || anArg == "-AUTOTRIANGULATION")
+ else if (anArg == "-AUTOTR"
+ || anArg == "-AUTOTRIANG"
+ || anArg == "-AUTOTRIANGULATION")
{
if (++anArgIter >= theArgsNb)
{
{
// print lights info
Standard_Integer aLightId = 0;
- for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightId)
+ for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightId)
{
- Handle(V3d_Light) aLight = aView->ActiveLight();
+ Handle(V3d_Light) aLight = aLightIter.Value();
const Quantity_Color aColor = aLight->Color();
theDi << "Light" << aLightId << "\n";
switch (aLight->Type())
{
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;
}
}
|| anArgCase.IsEqual ("CLEAR"))
{
toCreate = Standard_False;
- aView->InitActiveLights();
- while (aView->MoreActiveLights())
+ for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More();)
{
- aViewer->DelLight (aView->ActiveLight());
- aView->InitActiveLights();
+ Handle(V3d_Light) aLight = aLightIter.Value();
+ aViewer->DelLight (aLight);
+ aLightIter = aView->ActiveLightIterator();
}
}
else if (anArgCase.IsEqual ("AMB")
const Standard_Integer aLightId = getLightId (theArgVec[anArgIt]);
Standard_Integer aLightIt = 0;
- for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
+ for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightIt)
{
if (aLightIt == aLightId)
{
- aLightOld = aView->ActiveLight();
+ aLightOld = aLightIter.Value();
break;
}
}
const TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
const Standard_Integer aLightDelId = getLightId (theArgVec[anArgIt]);
Standard_Integer aLightIt = 0;
- for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
+ for (V3d_ListOfLightIterator aLightIter (aView->ActiveLightIterator()); aLightIter.More(); aLightIter.Next(), ++aLightIt)
{
- aLightDel = aView->ActiveLight();
+ aLightDel = aLightIter.Value();
if (aLightIt == aLightDelId)
{
break;
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"))
{
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 << "msaa: " << aParams.NbMsaaSamples << "\n";
+ theDI << "rayDepth: " << aParams.RaytracingDepth << "\n";
+ theDI << "fsaa: " << (aParams.IsAntialiasingEnabled ? "on" : "off") << "\n";
+ theDI << "shadows: " << (aParams.IsShadowEnabled ? "on" : "off") << "\n";
+ theDI << "reflections: " << (aParams.IsReflectionEnabled ? "on" : "off") << "\n";
+ theDI << "gleam: " << (aParams.IsTransparentShadowEnabled ? "on" : "off") << "\n";
+ theDI << "GI: " << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << "\n";
+ theDI << "blocked RNG: " << (aParams.CoherentPathTracingMode ? "on" : "off") << "\n";
+ theDI << "iss: " << (aParams.AdaptiveScreenSampling ? "on" : "off") << "\n";
+ theDI << "iss debug: " << (aParams.ShowSamplingTiles ? "on" : "off") << "\n";
theDI << "shadingModel: ";
switch (aView->ShadingModel())
{
aParams.Method = Graphic3d_RM_RASTERIZATION;
}
+ else if (aFlag == "-msaa")
+ {
+ if (toPrint)
+ {
+ theDI << aParams.NbMsaaSamples << " ";
+ continue;
+ }
+ else if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+
+ const Standard_Integer aNbSamples = Draw::Atoi (theArgVec[anArgIter]);
+ if (aNbSamples < 0)
+ {
+ std::cerr << "Error: invalid number of MSAA samples " << aNbSamples << ".\n";
+ return 1;
+ }
+ else
+ {
+ aParams.NbMsaaSamples = aNbSamples;
+ }
+ }
else if (aFlag == "-raydepth"
|| aFlag == "-ray_depth")
{
}
const Standard_Integer aDepth = Draw::Atoi (theArgVec[anArgIter]);
- if (aDepth < 1 || aDepth > 10)
+
+ // We allow RaytracingDepth be more than 10 in case of GI enabled
+ if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
{
std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
return 1;
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
Standard_Boolean toEnable = Standard_True;
if (++anArgIter < theArgNb
- && !parseOnOff (theArgVec[anArgIter], toEnable))
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
--anArgIter;
}
aParams.IsTransparentShadowEnabled = toEnable;
}
+ else if (aFlag == "-gi")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.IsGlobalIlluminationEnabled = toEnable;
+ if (!toEnable)
+ {
+ aParams.RaytracingDepth = Min (aParams.RaytracingDepth, 10);
+ }
+ }
+ else if (aFlag == "-blockedrng"
+ || aFlag == "-brng")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.CoherentPathTracingMode ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.CoherentPathTracingMode = toEnable;
+ }
+ else if (aFlag == "-iss")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.AdaptiveScreenSampling ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.AdaptiveScreenSampling = toEnable;
+ }
+ else if (aFlag == "-issd")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.ShowSamplingTiles ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.ShowSamplingTiles = toEnable;
+ }
+ else if (aFlag == "-env")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.UseEnvironmentMapBackground ? "on" : "off") << " ";
+ continue;
+ }
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aParams.UseEnvironmentMapBackground = toEnable;
+ }
else if (aFlag == "-shademodel"
|| aFlag == "-shadingmodel"
|| aFlag == "-shading")
|| aMode == "frag"
|| aMode == "pixel")
{
- aView->SetShadingModel (V3d_PHONG);
+ aView->SetShadingModel (V3d_PHONG);
+ }
+ else
+ {
+ std::cout << "Error: unknown shading model '" << aMode << "'\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-resolution")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aResolution (theArgVec[anArgIter]);
+ if (aResolution.IsIntegerValue())
+ {
+ aView->ChangeRenderingParams().Resolution = static_cast<unsigned int> (Draw::Atoi (aResolution.ToCString()));
+ }
+ else
+ {
+ std::cout << "Error: wrong syntax at argument'" << anArg << "'.\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-rebuildglsl"
+ || aFlag == "-rebuild")
+ {
+ if (toPrint)
+ {
+ theDI << (aParams.RebuildRayTracingShaders ? "on" : "off") << " ";
+ continue;
}
- else
+
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
{
- std::cout << "Error: unknown shading model '" << aMode << "'\n";
- return 1;
+ --anArgIter;
}
+ aParams.RebuildRayTracingShaders = toEnable;
}
else
{
return 1;
}
}
+
+ 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, 0, 0, PM_REMOVE))
+ {
+ if (aMsg.message == WM_KEYDOWN && (aMsg.wParam == 0x0d || aMsg.wParam == 0x1b))
+ {
+ toExit = Standard_True;
+ }
+
+ TranslateMessage (&aMsg);
+ DispatchMessage (&aMsg);
+ }
+
+ if (toExit)
+ {
+ break;
+ }
+ }
+
return 0;
}
+#endif
//=======================================================================
//function : VFrustumCulling
Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
if (aContext.IsNull())
{
- di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
+ di << argv[0] << "ERROR : use 'vinit' command before \n";
return 1;
}
if (argc != 3)
{
- di << "ERROR : Usage : " << argv[0] << " name angle" << "\n";
+ di << "ERROR : Usage : " << argv[0] << " name angle\n";
return 1;
}
Handle(AIS_InteractiveObject) anIObj;
if (!aMap.IsBound2 (aName) )
{
- di << "Use 'vdisplay' before" << "\n";
+ di << "Use 'vdisplay' before\n";
return 1;
}
else
return 0;
}
+//===============================================================================================
+//class : ViewerTest_AISManipulator
+//purpose : Proxy class maintaining automated registry map to enlist existing AIS_Manipulator instances
+//===============================================================================================
+DEFINE_STANDARD_HANDLE (ViewerTest_AISManipulator, AIS_Manipulator)
+
+class ViewerTest_AISManipulator : public AIS_Manipulator
+{
+public:
+
+ ViewerTest_AISManipulator() : AIS_Manipulator()
+ {
+ GetMapOfAISManipulators().Add (this);
+ }
+
+ virtual ~ViewerTest_AISManipulator()
+ {
+ GetMapOfAISManipulators().Remove (this);
+ }
+
+ DEFINE_STANDARD_RTTIEXT(ViewerTest_AISManipulator, AIS_Manipulator)
+};
+
+IMPLEMENT_STANDARD_HANDLE (ViewerTest_AISManipulator, AIS_Manipulator)
+IMPLEMENT_STANDARD_RTTIEXT(ViewerTest_AISManipulator, AIS_Manipulator)
+
+//===============================================================================================
+//function : VManipulator
+//purpose :
+//===============================================================================================
+static int VManipulator (Draw_Interpretor& theDi,
+ Standard_Integer theArgsNb,
+ const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+ ViewerTest::GetAISContext()->MainSelector()->SetPickClosest (Standard_False);
+ if (aView.IsNull()
+ || aViewer.IsNull())
+ {
+ std::cerr << "No active viewer!\n";
+ return 1;
+ }
+
+ ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), ViewerTest::CurrentView());
+ Standard_Integer anArgIter = 1;
+ for (; anArgIter < theArgsNb; ++anArgIter)
+ {
+ anUpdateTool.parseRedrawMode (theArgVec[anArgIter]);
+ }
+
+ ViewerTest_CmdParser aCmd;
+ aCmd.AddDescription ("Manages manipulator for interactive objects:");
+ aCmd.AddOption ("attach", "... object - attach manipulator to an object");
+ aCmd.AddOption ("adjustPosition", "... {0|1} - adjust position when attaching");
+ aCmd.AddOption ("adjustSize", "... {0|1} - adjust size when attaching ");
+ aCmd.AddOption ("enableModes", "... {0|1} - enable modes when attaching ");
+ aCmd.AddOption ("detach", "... - detach manipulator");
+
+ aCmd.AddOption ("startTransform", "... mouse_x mouse_y - invoke start transformation");
+ aCmd.AddOption ("transform", "... mouse_x mouse_y - invoke transformation");
+ aCmd.AddOption ("stopTransform", "... [abort] - invoke stop transformation");
+
+ aCmd.AddOption ("move", "... x y z - move object");
+ aCmd.AddOption ("rotate", "... x y z dx dy dz angle - rotate object");
+ aCmd.AddOption ("scale", "... factor - scale object");
+
+ aCmd.AddOption ("autoActivate", "... {0|1} - set activation on detection");
+ aCmd.AddOption ("followTranslation", "... {0|1} - set following translation transform");
+ aCmd.AddOption ("followRotation", "... {0|1} - set following rotation transform");
+ aCmd.AddOption ("gap", "... value - set gap between sub-parts");
+ aCmd.AddOption ("part", "... axis mode {0|1} - set visual part");
+ aCmd.AddOption ("pos", "... x y z [nx ny nz [xx xy xz]] - set position of manipulator");
+ aCmd.AddOption ("size", "... size - set size of manipulator");
+ aCmd.AddOption ("zoomable", "... {0|1} - set zoom persistence");
+
+ aCmd.Parse (theArgsNb, theArgVec);
+
+ if (aCmd.HasOption ("help"))
+ {
+ theDi.PrintHelp (theArgVec[0]);
+ return 0;
+ }
+
+ ViewerTest_DoubleMapOfInteractiveAndName& aMapAIS = GetMapOfAIS();
+
+ TCollection_AsciiString aName (aCmd.Arg ("", 0).c_str());
+
+ if (aName.IsEmpty())
+ {
+ std::cerr << theArgVec[0] << " error: please specify AIS manipulator's name as the first argument.\n";
+ return 1;
+ }
+
+ // ----------------------------------
+ // detach existing manipulator object
+ // ----------------------------------
+
+ if (aCmd.HasOption ("detach"))
+ {
+ if (!aMapAIS.IsBound2 (aName))
+ {
+ std::cerr << theArgVec[0] << " error: could not find \"" << aName << "\" AIS object.\n";
+ return 1;
+ }
+
+ Handle(AIS_Manipulator) aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
+ if (aManipulator.IsNull())
+ {
+ std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ return 1;
+ }
+
+ aManipulator->Detach();
+ aMapAIS.UnBind2 (aName);
+ ViewerTest::GetAISContext()->Remove (aManipulator);
+
+ return 0;
+ }
+
+ // -----------------------------------------------
+ // find or create manipulator if it does not exist
+ // -----------------------------------------------
+
+ Handle(AIS_Manipulator) aManipulator;
+ if (!aMapAIS.IsBound2 (aName))
+ {
+ std::cout << theArgVec[0] << ": AIS object \"" << aName << "\" has been created.\n";
+
+ aManipulator = new ViewerTest_AISManipulator();
+ aMapAIS.Bind (aManipulator, aName);
+ }
+ else
+ {
+ aManipulator = Handle(AIS_Manipulator)::DownCast (aMapAIS.Find2 (aName));
+ if (aManipulator.IsNull())
+ {
+ std::cerr << theArgVec[0] << " error: \"" << aName << "\" is not an AIS manipulator.\n";
+ return 1;
+ }
+ }
+
+ // -----------------------------------------
+ // change properties of manipulator instance
+ // -----------------------------------------
+
+ if (aCmd.HasOption ("autoActivate", 1, Standard_True))
+ {
+ aManipulator->SetModeActivationOnDetection (aCmd.ArgBool ("autoActivate"));
+ }
+ if (aCmd.HasOption ("followTranslation", 1, Standard_True))
+ {
+ aManipulator->ChangeTransformBehavior().SetFollowTranslation (aCmd.ArgBool ("followTranslation"));
+ }
+ if (aCmd.HasOption ("followRotation", 1, Standard_True))
+ {
+ aManipulator->ChangeTransformBehavior().SetFollowRotation (aCmd.ArgBool ("followRotation"));
+ }
+ if (aCmd.HasOption ("gap", 1, Standard_True))
+ {
+ aManipulator->SetGap (aCmd.ArgFloat ("gap"));
+ }
+ if (aCmd.HasOption ("part", 3, Standard_True))
+ {
+ Standard_Integer anAxis = aCmd.ArgInt ("part", 0);
+ Standard_Integer aMode = aCmd.ArgInt ("part", 1);
+ Standard_Boolean aOnOff = aCmd.ArgBool ("part", 2);
+ if (aMode < 1 || aMode > 3)
+ {
+ std::cerr << theArgVec[0] << " error: mode value should be in range [1, 3].\n";
+ return 1;
+ }
+
+ aManipulator->SetPart (anAxis, static_cast<AIS_ManipulatorMode> (aMode), aOnOff);
+ }
+ if (aCmd.HasOption ("pos", 3, Standard_True))
+ {
+ gp_Pnt aLocation = aCmd.ArgPnt ("pos", 0);
+ gp_Dir aVDir = aCmd.HasOption ("pos", 6) ? gp_Dir (aCmd.ArgVec ("pos", 3)) : aManipulator->Position().Direction();
+ gp_Dir aXDir = aCmd.HasOption ("pos", 9) ? gp_Dir (aCmd.ArgVec ("pos", 6)) : aManipulator->Position().XDirection();
+
+ aManipulator->SetPosition (gp_Ax2 (aLocation, aVDir, aXDir));
+ }
+ if (aCmd.HasOption ("size", 1, Standard_True))
+ {
+ aManipulator->SetSize (aCmd.ArgFloat ("size"));
+ }
+ if (aCmd.HasOption ("zoomable", 1, Standard_True))
+ {
+ aManipulator->SetZoomPersistence (!aCmd.ArgBool ("zoomable"));
+
+ if (ViewerTest::GetAISContext()->IsDisplayed (aManipulator))
+ {
+ ViewerTest::GetAISContext()->Remove (aManipulator, Standard_False);
+ ViewerTest::GetAISContext()->Display (aManipulator, Standard_False);
+ }
+ }
+
+ // ---------------------------------------------------
+ // attach, detach or access manipulator from an object
+ // ---------------------------------------------------
+
+ if (aCmd.HasOption ("attach"))
+ {
+ // Find an object and attach manipulator to it
+ if (!aCmd.HasOption ("attach", 1, Standard_True))
+ {
+ return 1;
+ }
+
+ TCollection_AsciiString anObjName (aCmd.Arg ("attach", 0).c_str());
+ if (!aMapAIS.IsBound2 (anObjName))
+ {
+ std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" does not exist.\n";
+ return 1;
+ }
+
+ Handle(AIS_InteractiveObject) anObject = Handle(AIS_InteractiveObject)::DownCast (aMapAIS.Find2 (anObjName));
+ ViewerTest_MapOfAISManipulators::Iterator anIt (GetMapOfAISManipulators());
+ for (; anIt.More(); anIt.Next())
+ {
+ if (anIt.Value()->IsAttached()
+ && anIt.Value()->Object() == anObject)
+ {
+ std::cerr << theArgVec[0] << " error: AIS object \"" << anObjName << "\" already has manipulator.\n";
+ return 1;
+ }
+ }
+
+ AIS_Manipulator::OptionsForAttach anOptions;
+ if (aCmd.HasOption ("adjustPosition", 1, Standard_True))
+ {
+ anOptions.SetAdjustPosition (aCmd.ArgBool ("adjustPosition"));
+ }
+ if (aCmd.HasOption ("adjustSize", 1, Standard_True))
+ {
+ anOptions.SetAdjustSize (aCmd.ArgBool ("adjustSize"));
+ }
+ if (aCmd.HasOption ("enableModes", 1, Standard_True))
+ {
+ anOptions.SetEnableModes (aCmd.ArgBool ("enableModes"));
+ }
+
+ aManipulator->Attach (anObject, anOptions);
+ }
+
+ // --------------------------------------
+ // apply transformation using manipulator
+ // --------------------------------------
+
+ if (aCmd.HasOption ("startTransform", 2, Standard_True))
+ {
+ aManipulator->StartTransform (aCmd.ArgInt ("startTransform", 0), aCmd.ArgInt ("startTransform", 1), ViewerTest::CurrentView());
+ }
+ if (aCmd.HasOption ("transform", 2, Standard_True))
+ {
+ aManipulator->Transform (aCmd.ArgInt ("transform", 0), aCmd.ArgInt ("transform", 1), ViewerTest::CurrentView());
+ }
+ if (aCmd.HasOption ("stopTransform"))
+ {
+ Standard_Boolean toApply = !aCmd.HasOption ("stopTransform", 1) || (aCmd.Arg ("stopTransform", 0) != "abort");
+
+ aManipulator->StopTransform (toApply);
+ }
+
+ gp_Trsf aT;
+ if (aCmd.HasOption ("move", 3, Standard_True))
+ {
+ aT.SetTranslationPart (aCmd.ArgVec ("move"));
+ }
+ if (aCmd.HasOption ("rotate", 7, Standard_True))
+ {
+ aT.SetRotation (gp_Ax1 (aCmd.ArgPnt ("rotate", 0), aCmd.ArgVec ("rotate", 3)), aCmd.ArgDouble ("rotate", 6));
+ }
+ if (aCmd.HasOption ("scale", 1))
+ {
+ aT.SetScale (gp_Pnt(), aCmd.ArgDouble("scale"));
+ }
+
+ if (aT.Form() != gp_Identity)
+ {
+ aManipulator->Transform (aT);
+ }
+
+ ViewerTest::GetAISContext()->Redisplay (aManipulator);
+
+ return 0;
+}
+
+//===============================================================================================
+//function : parseColor
+//purpose :
+//===============================================================================================
+static Standard_Boolean parseColor (ViewerTest_CmdParser& theParser,
+ const std::string& theOptionName,
+ Quantity_Color& theColor)
+{
+ std::string aColorArg = theParser.Arg (theOptionName, 0);
+ if (std::isdigit (aColorArg[0]))
+ {
+ Graphic3d_Vec3d aColor = theParser.ArgVec3d (theOptionName);
+ if (aColor.x() < 0.0 || aColor.x() > 1.0
+ || aColor.y() < 0.0 || aColor.y() > 1.0
+ || aColor.z() < 0.0 || aColor.z() > 1.0)
+ {
+ std::cerr << "Error: RGB color values should be within range 0..1!\n";
+ return Standard_False;
+ }
+ theColor.SetValues (aColor.x(), aColor.y(), aColor.z(), Quantity_TOC_RGB);
+ }
+ else
+ {
+ Quantity_NameOfColor aName = Quantity_NOC_BLACK;
+ if (!Quantity_Color::ColorFromName (aColorArg.c_str(), aName))
+ {
+ std::cerr << "Name: " << theParser.Arg (theOptionName, 0)
+ << " does not correspond to any color in Quantity_NameOfColor!"
+ << std::endl;
+ return Standard_False;
+ }
+ theColor.SetValues (aName);
+ }
+
+ return Standard_True;
+}
+
+//===============================================================================================
+//function : VSelectionProperties
+//purpose :
+//===============================================================================================
+static int VSelectionProperties (Draw_Interpretor& theDi,
+ Standard_Integer theArgsNb,
+ const char** theArgVec)
+{
+ const Handle(AIS_InteractiveContext)& aCtx = ViewerTest::GetAISContext();
+ if (aCtx.IsNull())
+ {
+ std::cerr << "No active viewer!\n";
+ return 1;
+ }
+
+ ViewerTest_CmdParser aCmd;
+
+ aCmd.AddOption ("autoActivate");
+ aCmd.AddOption ("pixTol");
+
+ aCmd.AddOption ("selColor");
+ aCmd.AddOption ("hiColor");
+ aCmd.AddOption ("selTransp");
+ aCmd.AddOption ("hiTransp");
+
+ aCmd.AddOption ("print");
+
+ aCmd.Parse (theArgsNb, theArgVec);
+
+ if (aCmd.HasOption ("help"))
+ {
+ theDi.PrintHelp (theArgVec[0]);
+ return 0;
+ }
+
+ if (aCmd.HasOption ("autoActivate", 1, Standard_False))
+ {
+ aCtx->SetAutoActivateSelection (aCmd.ArgBool ("autoActivate"));
+ }
+ if (aCmd.HasOption ("pixTol", 1, Standard_False))
+ {
+ aCtx->SetPixelTolerance (aCmd.ArgInt ("pixTol"));
+ }
+
+ Handle(Graphic3d_HighlightStyle)& aHiStyle = aCtx->ChangeHighlightStyle();
+ Handle(Graphic3d_HighlightStyle)& aSelStyle = aCtx->ChangeSelectionStyle();
+ Standard_Boolean toRedraw = Standard_False;
+ if (aCmd.HasOption ("selColor"))
+ {
+ Quantity_Color aNewColor;
+ if (!parseColor (aCmd, "selColor", aNewColor))
+ return 1;
+ aSelStyle->SetColor (aNewColor);
+ toRedraw = Standard_True;
+ }
+ if (aCmd.HasOption ("hiColor"))
+ {
+ Quantity_Color aNewColor;
+ if (!parseColor (aCmd, "hiColor", aNewColor))
+ return 1;
+ aHiStyle->SetColor (aNewColor);
+ }
+ if (aCmd.HasOption ("selTransp"))
+ {
+ aSelStyle->SetTransparency (aCmd.ArgFloat ("selTransp"));
+ toRedraw = Standard_True;
+ }
+ if (aCmd.HasOption ("hiTransp"))
+ {
+ aHiStyle->SetTransparency (aCmd.ArgFloat ("hiTransp"));
+ }
+
+ if (aCmd.HasOption ("print") || theArgsNb == 1)
+ {
+ theDi << "Auto-activation : " << (aCtx->GetAutoActivateSelection() ? "On" : "Off") << "\n";
+ theDi << "Selection pixel tolerance : " << aCtx->MainSelector()->PixelTolerance() << "\n";
+ theDi << "Selection color : " << Quantity_Color::StringName (aCtx->SelectionStyle()->Color().Name()) << "\n";
+ theDi << "Dynamic highlight color : " << Quantity_Color::StringName (aCtx->HighlightStyle()->Color().Name()) << "\n";
+ theDi << "Selection transparency : " << aCtx->SelectionStyle()->Transparency() << "\n";
+ theDi << "Dynamic highlight transparency : " << aCtx->HighlightStyle()->Transparency() << "\n";
+ }
+
+ if (aCtx->NbSelected() != 0 && toRedraw)
+ {
+ aCtx->HilightSelected (Standard_True);
+ }
+
+ return 0;
+}
+
//=======================================================================
//function : ViewerCommands
//purpose :
"vhelp : display help on the viewer commands",
__FILE__,VHelp,group);
theCommands.Add("vtop" ,
- "vtop or <T> : Top view" ,
+ "vtop or <T> : Top view. Orientation +X+Y" ,
__FILE__,VTop,group);
theCommands.Add("vbottom" ,
- "vbottom : Bottom view" ,
+ "vbottom : Bottom view. Orientation +X-Y" ,
__FILE__,VBottom,group);
theCommands.Add("vleft" ,
- "vleft : Left view" ,
+ "vleft : Left view. Orientation -Y+Z" ,
__FILE__,VLeft,group);
theCommands.Add("vright" ,
- "vright : Right view" ,
+ "vright : Right view. Orientation +Y+Z" ,
__FILE__,VRight,group);
theCommands.Add("vaxo" ,
- " vaxo or <A> : Axonometric view ",
+ " vaxo or <A> : Axonometric view. Orientation +X-Y+Z",
__FILE__,VAxo,group);
theCommands.Add("vfront" ,
- "vfront : Front view" ,
+ "vfront : Front view. Orientation +X+Z" ,
__FILE__,VFront,group);
theCommands.Add("vback" ,
- "vback : Back view" ,
+ "vback : Back view. Orientation -X+Z" ,
__FILE__,VBack,group);
theCommands.Add("vpick" ,
"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"
"vrepaint : vrepaint, force redraw",
__FILE__,VRepaint,group);
theCommands.Add("vclear",
- "vclear : vclear",
+ "vclear : vclear"
+ "\n\t\t: remove all the object from the viewer",
__FILE__,VClear,group);
theCommands.Add("vsetbg",
"vsetbg : vsetbg imagefile [filltype] : Load image as background",
theCommands.Add("vsetcolorbg",
"vsetcolorbg : vsetcolorbg r g b : Set background color",
__FILE__,VSetColorBg,group);
+ theCommands.Add("vsetdefaultbg",
+ "vsetdefaultbg r g b\n"
+ "\n\t\t: vsetdefaultbg r1 g1 b1 r2 g2 b2 fillmode"
+ "\n\t\t: Set default viewer background fill color (flat/gradient).",
+ __FILE__,VSetDefaultBg,group);
theCommands.Add("vscale",
"vscale : vscale X Y Z",
__FILE__,VScale,group);
" : notice that EMF format requires patched gl2ps",
__FILE__,VExport,group);
theCommands.Add("vcolorscale",
- "vcolorscale : vcolorscale [-range RangeMin = 0 RangeMax = 100 Intervals = 10 -font HeightFont = 16 -textpos "
+ "vcolorscale : vcolorscale name [-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"
" - 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("vtile" ,
+ "vtile [-totalSize W H] [-lowerLeft X Y] [-upperLeft X Y] [-tileSize W H]"
+ "\n\t\t: Setup view to draw a tile (a part of virtual bigger viewport)."
+ "\n\t\t: -totalSize the size of virtual bigger viewport"
+ "\n\t\t: -tileSize tile size (the view size will be used if omitted)"
+ "\n\t\t: -lowerLeft tile offset as lower left corner"
+ "\n\t\t: -upperLeft tile offset as upper left corner",
+ __FILE__, VTile, group);
theCommands.Add("vzlayer",
"vzlayer add/del/get/settings/enable/disable [id]\n"
" add - add new z layer to viewer and print its id\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"
+ " enable textureenv \n enables environment texture mapping\n"
" disable ([depth]test/[depth]write/[depth]clear/[depth]offset) \n disables given setting for the z layer\n"
+ " disable textureenv \n disables environment texture mapping\n"
"\nWhere id is the layer identificator\n"
"\nExamples:\n"
" vzlayer add\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]"
- " : height - pixel height of the text (default=10.0)"
- " : font_name - name of font (default=courier)"
- " : text_color - three values: RedColor GreenColor BlueColor (default = 255.0 255.0 255.0) "
- " : display_type = {normal/subtitle/decal/blend}, (default=normal) "
- " : background_color - three values: RedColor GreenColor BlueColor (default = 255.0 255.0 255.0), the parameter is defined for subtitle and decal display types ",
- __FILE__,VOverlayText,group);
theCommands.Add("vlayerline",
"vlayerline : vlayerline x1 y1 x2 y2 [linewidth=0.5] [linetype=0] [transparency=1.0]",
__FILE__,VLayerLine,group);
"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}] [-ffp {0|1}]"
- "\n\t\t: [-compatibleContext {0|1}]"
+ "\n\t\t: [-compatibleProfile {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: 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."
"- 1) single click selection\n"
"- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
"- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
- "- 4) -allowoverlap determines will partially included objects be selected in rectangular selection"
+ "- 4) -allowoverlap manages overlap and inclusion detection in rectangular selection.\n"
+ " If the flag is set to 1, both sensitives that were included completely and overlapped partially by defined rectangle will be detected,\n"
+ " otherwise algorithm will chose only fully included sensitives. Default behavior is to detect only full inclusion. "
" (partial inclusion - overlap - is not allowed by default)\n"
"- 5) any of these selections with shift button pressed",
__FILE__, VSelect, group);
"vchangeselected shape"
"- adds to shape to selection or remove one from it",
__FILE__, VChangeSelected, group);
- theCommands.Add("vzclipping",
- "vzclipping [mode] [depth width]\n"
- "- mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]\n"
- "- gets or sets ZClipping mode, width and depth",
- __FILE__,VZClipping,group);
theCommands.Add ("vnbselected",
- "vnbselected", __FILE__, VNbSelected, group);
+ "vnbselected"
+ "\n\t\t: Returns number of selected objects", __FILE__, VNbSelected, group);
theCommands.Add ("vcamera",
"vcamera [-ortho] [-projtype]"
"\n\t\t: [-persp]"
" vzrange - without parameters shows current values\n"
" vzrange [znear] [zfar] - applies provided values to view",
__FILE__,VZRange, group);
- theCommands.Add("vantialiasing",
- "vantialiasing 1|0",
- __FILE__,VAntialiasing,group);
theCommands.Add ("vpurgedisplay",
"vpurgedisplay"
"- removes structures which don't belong to objects displayed in neutral point",
"If shapes are not given HLR algoithm of given type is applied"
" to all shapes in the view\n",
__FILE__,VHLRType,group);
- theCommands.Add("vclipplane", "vclipplane usage: \n"
- " maxplanes <view_name> - get plane limit for view.\n"
- " create <plane_name> - create new plane.\n"
- " delete <plane_name> - delete plane.\n"
- " clone <source_plane> <plane_name> - clone the plane definition.\n"
- " set/unset <plane_name> object <object list> - set/unset plane for IO.\n"
- " set/unset <plane_name> view <view list> - set/unset plane for view.\n"
- " change <plane_name> on/off - turn clipping on/off.\n"
- " change <plane_name> equation <a> <b> <c> <d> - change plane equation.\n"
- " change <plane_name> capping on/off - turn capping on/off.\n"
- " change <plane_name> capping color <r> <g> <b> - set color.\n"
- " change <plane name> capping texname <texture> - set texture.\n"
- " change <plane_name> capping texscale <sx> <sy> - set tex scale.\n"
- " change <plane_name> capping texorigin <tx> <ty> - set tex origin.\n"
- " change <plane_name> capping texrotate <angle> - set tex rotation.\n"
- " change <plane_name> capping hatch on/off/<id> - set hatching mask.\n"
- " please use VSetTextureMode command to enable texture rendering in view.\n"
- , __FILE__, VClipPlane, group);
- theCommands.Add("vsettexturemode", "vsettexturemode view_name mode \n"
- " mode can be:\n"
- " 0 - no textures enabled in view.\n"
- " 1 - only environment textures enabled.\n"
- " 2 - all textures enabled.\n"
- " this command sets texture details mode for the specified view.\n"
- , __FILE__, VSetTextureMode, group);
+ theCommands.Add("vclipplane",
+ "vclipplane planeName [{0|1}]"
+ "\n\t\t: [-equation A B C D]"
+ "\n\t\t: [-set|-unset [objects|views]]"
+ "\n\t\t: [-maxPlanes]"
+ "\n\t\t: [-capping {0|1}]"
+ "\n\t\t: [-color R G B] [-hatch {on|off|ID}]"
+ "\n\t\t: [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]"
+ "\n\t\t: [-texRotate Angle]"
+ "\n\t\t: [-useObjMaterial {0|1}] [-useObjTexture {0|1}]"
+ "\n\t\t: [-useObjShader {0|1}]"
+ "\n\t\t: Clipping planes management:"
+ "\n\t\t: -maxPlanes print plane limit for view"
+ "\n\t\t: -delete delete plane with given name"
+ "\n\t\t: {off|on|0|1} turn clipping on/off"
+ "\n\t\t: -set|-unset set/unset plane for Object or View list;"
+ "\n\t\t: applied to active View when list is omitted"
+ "\n\t\t: -equation A B C D change plane equation"
+ "\n\t\t: -clone SourcePlane NewPlane clone the plane definition."
+ "\n\t\t: Capping options:"
+ "\n\t\t: -capping {off|on|0|1} turn capping on/off"
+ "\n\t\t: -color R G B set capping color"
+ "\n\t\t: -texName Texture set capping texture"
+ "\n\t\t: -texScale SX SY set capping tex scale"
+ "\n\t\t: -texOrigin TX TY set capping tex origin"
+ "\n\t\t: -texRotate Angle set capping tex rotation"
+ "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
+ "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
+ "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
+ "\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
+ __FILE__, VClipPlane, group);
theCommands.Add("vdefaults",
"vdefaults [-absDefl value]"
"\n\t\t: [-devCoeff value]"
"\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"
__FILE__, VLight, group);
theCommands.Add("vraytrace",
"vraytrace [0|1]"
- "\n\t\t: Turn on/off raytracing renderer."
+ "\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 '-msaa 0..4' Specifies number of samples for MSAA"
+ "\n '-rayTrace' Enables 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 '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
+ "\n '-env on|off' Enables/disables environment map background"
+ "\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
+ "\n '-issd on|off' Shows screen sampling distribution in ISS mode"
+ "\n '-rebuildGlsl on|off' Rebuild Ray-Tracing GLSL programs (for debugging)"
"\n '-shadingModel model' Controls shading model from enumeration"
"\n color, flat, gouraud, phong"
+ "\n '-resolution value' Sets a new pixels density (PPI), defines scaling factor for parameters like text size"
"\n Unlike vcaps, these parameters dramatically change visual properties."
"\n Command is intended to control presentation quality depending on"
"\n hardware capabilities and performance.",
"vxrotate",
__FILE__,VXRotate,group);
+ theCommands.Add("vmanipulator",
+ "\n vmanipulator Name [-attach AISObject | -detach | ...]"
+ "\n tool to create and manage AIS manipulators."
+ "\n Options: "
+ "\n '-attach AISObject' attach manipulator to AISObject"
+ "\n '-adjustPosition {0|1}' adjust position when attaching"
+ "\n '-adjustSize {0|1}' adjust size when attaching"
+ "\n '-enableModes {0|1}' enable modes when attaching"
+ "\n '-detach' detach manipulator"
+ "\n '-startTransform mouse_x mouse_y' - invoke start of transformation"
+ "\n '-transform mouse_x mouse_y' - invoke transformation"
+ "\n '-stopTransform [abort]' - invoke stop of transformation"
+ "\n '-move x y z' - move attached object"
+ "\n '-rotate x y z dx dy dz angle' - rotate attached object"
+ "\n '-scale factor' - scale attached object"
+ "\n '-autoActivate {0|1}' - set activation on detection"
+ "\n '-followTranslation {0|1}' - set following translation transform"
+ "\n '-followRotation {0|1}' - set following rotation transform"
+ "\n '-gap value' - set gap between sub-parts"
+ "\n '-part axis mode {0|1}' - set visual part"
+ "\n '-pos x y z [nx ny nz [xx xy xz]' - set position of manipulator"
+ "\n '-size value' - set size of manipulator"
+ "\n '-zoomable {0|1}' - set zoom persistence",
+ __FILE__, VManipulator, group);
+
+ theCommands.Add("vselprops",
+ "\n vselprops [options]"
+ "\n Customizes selection and dynamic highlight parameters for the whole interactive context:"
+ "\n -autoActivate {0|1} : disables|enables default computation and activation of global selection mode"
+ "\n -pixTol value : sets up pixel tolerance"
+ "\n -selColor {name|r g b} : sets selection color"
+ "\n -hiColor {name|r g b} : sets dynamic highlight color"
+ "\n -selTransp value : sets transparency coefficient for selection"
+ "\n -hiTransp value : sets transparency coefficient for dynamic highlight"
+ "\n -print : prints current state of all mentioned parameters",
+ __FILE__, VSelectionProperties, group);
+
+#if defined(_WIN32)
+ theCommands.Add("vprogressive",
+ "vprogressive",
+ __FILE__, VProgressiveMode, group);
+#endif
}
projects / occt.git / blobdiff