// 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_Drawer.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 <Graphic3d_GraduatedTrihedron.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <Graphic3d_TypeOfTextureFilter.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_DirectionalLight.hxx>
-#include <V3d_LayerMgr.hxx>
-#include <V3d_LayerMgrPointer.hxx>
#include <V3d_PositionalLight.hxx>
#include <V3d_SpotLight.hxx>
#include <NCollection_DoubleMap.hxx>
#include <NCollection_List.hxx>
#include <NCollection_Vector.hxx>
-#include <NIS_View.hxx>
-#include <NIS_Triangulated.hxx>
-#include <NIS_InteractiveContext.hxx>
#include <AIS_InteractiveContext.hxx>
#include <Draw_Interpretor.hxx>
#include <Draw.hxx>
#include <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 <NCollection_DataMap.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;
Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
-extern const Handle(NIS_InteractiveContext)& TheNISContext();
extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
extern int VErase (Draw_Interpretor& theDI,
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);
#endif
VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
- // NIS setup
- Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
+ // View setup
+ Handle(V3d_View) aView = a3DViewer->CreateView();
+ aView->SetWindow (VT_GetWindow());
+ ViewerTest::GetAISContext()->RedrawImmediate (a3DViewer);
ViewerTest::CurrentView(aView);
ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
- TheNISContext()->AttachView (aView);
// Setup for X11 or NT
OSWindowSetup();
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)
{
continue;
}
- aShape->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
}
}
}
if (aShape->TypeOfHLR() != aTypeOfHLR)
aShape->SetTypeOfHLR (aTypeOfHLR);
if (MyHLRIsOn)
- aShape->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
}
ViewerTest::CurrentView()->Update();
return 0;
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 =
continue;
anAISObject->SetTypeOfHLR (aTypeOfHLR);
if (MyHLRIsOn)
- anAISObject->Redisplay();
+ ViewerTest::GetAISContext()->Redisplay (anAISObject, Standard_False);
}
ViewerTest::CurrentView()->Update();
}
Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
// Remove view resources
- TheNISContext()->DetachView(Handle(NIS_View)::DownCast(aView));
ViewerTest_myViews.UnBind1(theViewName);
aView->Remove();
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";
}
{
//cout << "KeyPress" << endl;
const Handle(V3d_View) aView = ViewerTest::CurrentView();
- const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
// Letter in alphabetic order
if (!strcasecmp (buf_ret, "A"))
}
else if (!strcasecmp (buf_ret, "F"))
{
- // FitAll
- if (aNisView.IsNull())
- aView->FitAll();
+ if (ViewerTest::GetAISContext()->NbSelected() > 0)
+ {
+ ViewerTest::GetAISContext()->FitSelected (aView);
+ }
else
- aNisView->FitAll3d();
+ {
+ // FitAll
+ aView->FitAll();
+ }
}
else if (!strcasecmp (buf_ret, "H"))
{
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);
aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
else
aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
- aShape->Redisplay();
+ aContext->Redisplay (aShape, Standard_False);
}
}
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)
aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
else
aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
- aShape->Redisplay();
+ aContext->Redisplay (aShape, Standard_False);
}
}
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");
Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
if (theIsShift)
{
- EM->ShiftSelect (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
- Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+ EM->ShiftSelect (X_ButtonPress, Y_ButtonPress,
+ X_Motion, Y_Motion);
}
else
{
- EM->Select (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
- Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+ EM->Select (X_ButtonPress, Y_ButtonPress,
+ X_Motion, Y_Motion);
}
}
}
}
}
-//==============================================================================
-//function : ProcessZClipMotion
-//purpose : Zoom
-//==============================================================================
-
-void ProcessZClipMotion()
-{
- Handle(V3d_View) a3DView = ViewerTest::CurrentView();
- if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
- static Standard_Real CurZPos = 0.;
-
- //Quantity_Length VDX, VDY;
- //a3DView->Size(VDX,VDY);
- //Standard_Real VDZ = a3DView->ZSize();
- //printf("View size (%lf,%lf,%lf)\n", VDX, VDY, VDZ);
-
- Quantity_Length dx = a3DView->Convert(X_Motion - X_ButtonPress);
-
- // Front = Depth + width/2.
- Standard_Real D = 0.5;
- Standard_Real W = 0.1;
-
- CurZPos += (dx);
-
- D += CurZPos;
-
- //printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
-
- a3DView->SetZClippingType(V3d_OFF);
- a3DView->SetZClippingDepth(D);
- a3DView->SetZClippingWidth(W);
- a3DView->SetZClippingType(V3d_FRONT);
-
- a3DView->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] = THE_KEY_DELETE;
}
+ // comma
+ else if (wParam == VK_OEM_COMMA)
+ {
+ c[0] = ',';
+ }
+ // dot
+ else if (wParam == VK_OEM_PERIOD)
+ {
+ c[0] = '.';
+ }
+ else if (wParam == VK_DIVIDE)
+ {
+ c[0] = '/';
+ }
+ // dot
+ else if (wParam == VK_MULTIPLY)
+ {
+ c[0] = '*';
+ }
VT_ProcessKeyPress (c);
}
break;
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();
- Handle(NIS_View) V = Handle(NIS_View)::DownCast(aView);
- if (V.IsNull() == Standard_False) {
- V->FitAll3d();
- } else if (aView.IsNull() == Standard_False) {
+
+ if (theArgc == 2)
+ {
+ TCollection_AsciiString anArg (theArgv[1]);
+ anArg.LowerCase();
+ if (anArg == "-selected")
+ {
+ ViewerTest::GetAISContext()->FitSelected (aView);
+ return 0;
+ }
+ }
+ if (aView.IsNull() == Standard_False) {
+
aView->FitAll();
}
return 0;
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]) );
return 0;
}
//==============================================================================
-//function : VTestZBuffTrihedron
-//purpose : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
+//function : VZBuffTrihedron
+//purpose :
//==============================================================================
-static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+static int VZBuffTrihedron (Draw_Interpretor& /*theDI*/,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
- Handle(V3d_View) V3dView = ViewerTest::CurrentView();
- if ( V3dView.IsNull() ) return 1;
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cout << "Error: no active viewer!\n";
+ return 1;
+ }
- V3dView->ZBufferTriedronSetup();
+ ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
- if ( argc == 1 ) {
- // Set up default trihedron parameters
- V3dView->TriedronDisplay( Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.1, V3d_ZBUFFER );
- } else
- if ( argc == 7 )
+ Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
+ V3d_TypeOfVisualization aVisType = V3d_ZBUFFER;
+ Quantity_Color aLabelsColor = Quantity_NOC_WHITE;
+ Quantity_Color anArrowColorX = Quantity_NOC_RED;
+ Quantity_Color anArrowColorY = Quantity_NOC_GREEN;
+ Quantity_Color anArrowColorZ = Quantity_NOC_BLUE1;
+ Standard_Real aScale = 0.1;
+ Standard_Real aSizeRatio = 0.8;
+ Standard_Real anArrowDiam = 0.05;
+ Standard_Integer aNbFacets = 12;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
- const char* aPosType = argv[1];
-
- if ( strcmp(aPosType, "center") == 0 )
- {
- aPosition = Aspect_TOTP_CENTER;
- } else
- if (strcmp(aPosType, "left_lower") == 0)
- {
- aPosition = Aspect_TOTP_LEFT_LOWER;
- } else
- if (strcmp(aPosType, "left_upper") == 0)
- {
- aPosition = Aspect_TOTP_LEFT_UPPER;
- } else
- if (strcmp(aPosType, "right_lower") == 0)
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
{
- aPosition = Aspect_TOTP_RIGHT_LOWER;
- } else
- if (strcmp(aPosType, "right_upper") == 0)
+ continue;
+ }
+ else if (aFlag == "-on")
{
- aPosition = Aspect_TOTP_RIGHT_UPPER;
- } else
+ continue;
+ }
+ else if (aFlag == "-off")
{
- di << argv[1] << " Invalid type of alignment" << "\n";
- di << "Must be one of [ center, left_lower," << "\n";
- di << "left_upper, right_lower, right_upper ]" << "\n";
- return 1;
+ aView->TriedronErase();
+ return 0;
}
+ else if (aFlag == "-pos"
+ || aFlag == "-position"
+ || aFlag == "-corner")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- Standard_Real R = Draw::Atof(argv[2])/255.;
- Standard_Real G = Draw::Atof(argv[3])/255.;
- Standard_Real B = Draw::Atof(argv[4])/255.;
- Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
+ TCollection_AsciiString aPosName (theArgVec[anArgIter]);
+ aPosName.LowerCase();
+ if (aPosName == "center")
+ {
+ aPosition = Aspect_TOTP_CENTER;
+ }
+ else if (aPosName == "left_lower"
+ || aPosName == "lower_left"
+ || aPosName == "leftlower"
+ || aPosName == "lowerleft")
+ {
+ aPosition = Aspect_TOTP_LEFT_LOWER;
+ }
+ else if (aPosName == "left_upper"
+ || aPosName == "upper_left"
+ || aPosName == "leftupper"
+ || aPosName == "upperleft")
+ {
+ aPosition = Aspect_TOTP_LEFT_UPPER;
+ }
+ else if (aPosName == "right_lower"
+ || aPosName == "lower_right"
+ || aPosName == "rightlower"
+ || aPosName == "lowerright")
+ {
+ aPosition = Aspect_TOTP_RIGHT_LOWER;
+ }
+ else if (aPosName == "right_upper"
+ || aPosName == "upper_right"
+ || aPosName == "rightupper"
+ || aPosName == "upperright")
+ {
+ aPosition = Aspect_TOTP_RIGHT_UPPER;
+ }
+ else
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
+ return 1;
+ }
+ }
+ else if (aFlag == "-type")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- Standard_Real aScale = Draw::Atof(argv[5]);
+ TCollection_AsciiString aTypeName (theArgVec[anArgIter]);
+ aTypeName.LowerCase();
+ if (aTypeName == "wireframe"
+ || aTypeName == "wire")
+ {
+ aVisType = V3d_WIREFRAME;
+ }
+ else if (aTypeName == "zbuffer"
+ || aTypeName == "shaded")
+ {
+ aVisType = V3d_ZBUFFER;
+ }
+ else
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
+ }
+ }
+ else if (aFlag == "-scale")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- if( aScale <= 0.0 )
+ aScale = Draw::Atof (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-size"
+ || aFlag == "-sizeratio")
{
- di << argv[5] << " Invalid value. Must be > 0" << "\n";
- return 1;
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ aSizeRatio = Draw::Atof (theArgVec[anArgIter]);
}
+ else if (aFlag == "-arrowdiam"
+ || aFlag == "-arrowdiameter")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- V3d_TypeOfVisualization aPresentation = V3d_ZBUFFER;
- const char* aPresType = argv[6];
+ anArrowDiam = Draw::Atof (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-nbfacets")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
- if ( strcmp(aPresType, "wireframe") == 0 )
+ aNbFacets = Draw::Atoi (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-colorlabel"
+ || aFlag == "-colorlabels")
+ {
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ aLabelsColor);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else if (aFlag == "-colorarrowx")
+ {
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorX);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else if (aFlag == "-colorarrowy")
{
- aPresentation = V3d_WIREFRAME;
- } else
- if (strcmp(aPresType, "zbuffer") == 0)
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorY);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else if (aFlag == "-colorarrowz")
{
- aPresentation = V3d_ZBUFFER;
- } else
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb - anArgIter - 1,
+ theArgVec + anArgIter + 1,
+ anArrowColorZ);
+ if (aNbParsed == 0)
+ {
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ anArgIter += aNbParsed;
+ }
+ else
{
- di << argv[6] << " Invalid type of visualization" << "\n";
- di << "Must be one of [ wireframe, zbuffer ]" << "\n";
+ std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
return 1;
}
-
- V3dView->TriedronDisplay( aPosition, aColor.Name(), aScale, aPresentation );
-
- } else
- {
- di << argv[0] << " Invalid number of arguments" << "\n";
- return 1;
}
- V3dView->View()->ZFitAll();
-
+ aView->ZBufferTriedronSetup (anArrowColorX.Name(), anArrowColorY.Name(), anArrowColorZ.Name(),
+ aSizeRatio, anArrowDiam, aNbFacets);
+ aView->TriedronDisplay (aPosition, aLabelsColor.Name(), aScale, aVisType);
+ aView->ZFitAll();
return 0;
}
//purpose : Camera Rotating
//==============================================================================
-static int VRotate( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
- Handle(V3d_View) V3dView = ViewerTest::CurrentView();
- if ( V3dView.IsNull() ) {
+static int VRotate (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cout << "No active view!\n";
return 1;
}
- if ( argc == 4 ) {
- V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
+ Standard_Boolean hasFlags = Standard_False;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg (theArgVec[anArgIter]);
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (aFlag == "-mousestart"
+ || aFlag == "-mousefrom")
+ {
+ hasFlags = Standard_True;
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+ Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+ aView->StartRotation (anX, anY);
+ }
+ else if (aFlag == "-mousemove")
+ {
+ hasFlags = Standard_True;
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+
+ Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+ Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+ aView->Rotation (anX, anY);
+ }
+ else if (theArgNb != 4
+ && theArgNb != 7)
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
+ }
+
+ if (hasFlags)
+ {
return 0;
- } else if ( argc == 7 ) {
- V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]) );
+ }
+ else if (theArgNb == 4)
+ {
+ Standard_Real anAX = Draw::Atof (theArgVec[1]);
+ Standard_Real anAY = Draw::Atof (theArgVec[2]);
+ Standard_Real anAZ = Draw::Atof (theArgVec[3]);
+ aView->Rotate (anAX, anAY, anAZ);
+ return 0;
+ }
+ else if (theArgNb == 7)
+ {
+ Standard_Real anAX = Draw::Atof (theArgVec[1]);
+ Standard_Real anAY = Draw::Atof (theArgVec[2]);
+ Standard_Real anAZ = Draw::Atof (theArgVec[3]);
+
+ Standard_Real anX = Draw::Atof (theArgVec[4]);
+ Standard_Real anY = Draw::Atof (theArgVec[5]);
+ Standard_Real anZ = Draw::Atof (theArgVec[6]);
+
+ aView->Rotate (anAX, anAY, anAZ, anX, anY, anZ);
return 0;
- } else {
- di << argv[0] << " Invalid number of arguments" << "\n";
- return 1;
}
+
+ std::cout << "Error: Invalid number of arguments\n";
+ return 1;
}
//==============================================================================
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;
}
}
+//==============================================================================
+//function : VPlace
+//purpose : Place the point (in pixels) at the center of the window
+//==============================================================================
+static int VPlace (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgs)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << theArgs[0] << "Error: no active view." << std::endl;
+ return 1;
+ }
+
+ if (theArgNb != 3)
+ {
+ std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
+ return 1;
+ }
+
+ aView->Place (Draw::Atoi (theArgs[1]), Draw::Atoi (theArgs[2]), aView->Scale());
+
+ return 0;
+}
//==============================================================================
//function : VExport
{
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";
}
di << "Error: export of image to " << aFormatStr << " failed";
di << " (exception: " << Standard_Failure::Caught()->GetMessageString() << ")";
}
- return 0;
-}
-
-//==============================================================================
-//function : VColorScale
-//purpose : representation color scale
-//==============================================================================
-#include <V3d_ColorScale.hxx>
+ return 0;
+}
+
+//==============================================================================
+//function : VColorScale
+//purpose : representation color scale
+//==============================================================================
+
+static Standard_Boolean checkColor (const TCollection_AsciiString& theRed,
+ const TCollection_AsciiString& theGreen,
+ const TCollection_AsciiString& theBlue,
+ Standard_Real& theRedValue,
+ Standard_Real& theGreenValue,
+ Standard_Real& theBlueValue)
+{
+ if (!theRed.IsRealValue()
+ || !theGreen.IsRealValue()
+ || !theBlue.IsRealValue())
+ {
+ std::cout << "Error: RGB color values should be real!\n";
+ return Standard_True;
+ }
+ theRedValue = theRed .RealValue();
+ theGreenValue = theGreen.RealValue();
+ theBlueValue = theBlue .RealValue();
+ if (theRedValue < 0.0 || theRedValue > 1.0
+ || theGreenValue < 0.0 || theGreenValue > 1.0
+ || theBlueValue < 0.0 || theBlueValue > 1.0)
+ {
+ std::cout << "Error: RGB color values should be within range 0..1!\n";
+ return Standard_True;
+ }
+ return Standard_False;
+}
+
+static int VColorScale (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aContext.IsNull())
+ {
+ std::cout << "Error: no active view!\n";
+ return 1;
+ }
+ if (theArgNb <= 1)
+ {
+ std::cout << "Error: wrong syntax at command '" << theArgVec[0] << "'!\n";
+ return 1;
+ }
+
+ Handle(AIS_ColorScale) aCS;
+ // find object
+ Handle(AIS_InteractiveObject) anIObj;
+ if (GetMapOfAIS().IsBound2 (theArgVec[1]))
+ {
+ 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: " << aPosX <<" "<< aPosY<< "\n"
+ << "Color scale title: " << aCS->GetTitle() << "\n"
+ << "Label position: ";
+ switch (aLabPosition)
+ {
+ case Aspect_TOCSP_NONE:
+ theDI << "None\n";
+ break;
+ case Aspect_TOCSP_LEFT:
+ theDI << "Left\n";
+ break;
+ case Aspect_TOCSP_RIGHT:
+ theDI << "Right\n";
+ break;
+ case Aspect_TOCSP_CENTER:
+ theDI << "Center\n";
+ break;
+ }
+ return 0;
+ }
+
+ for (Standard_Integer anArgIter = 2; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (anUpdateTool.parseRedrawMode (aFlag))
+ {
+ continue;
+ }
+ else if (aFlag == "-range")
+ {
+ if (anArgIter + 3 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString anArg1 (theArgVec[++anArgIter]);
+ TCollection_AsciiString anArg2 (theArgVec[++anArgIter]);
+ TCollection_AsciiString anArg3 (theArgVec[++anArgIter]);
+ if (!anArg1.IsRealValue())
+ {
+ std::cout << "Error: the minRange value should be real!\n";
+ return 1;
+ }
+ else if (!anArg2.IsRealValue())
+ {
+ std::cout << "Error: the maxRange value should be real!\n";
+ return 1;
+ }
+ else if (!anArg3.IsIntegerValue())
+ {
+ std::cout << "Error: the number of intervals should be integer!\n";
+ return 1;
+ }
+
+ aMinRange = anArg1.RealValue();
+ aMaxRange = anArg2.RealValue();
+ aNbIntervals = anArg3.IntegerValue();
+ }
+ else if (aFlag == "-font")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ TCollection_AsciiString aFontArg(theArgVec[anArgIter + 1]);
+ if (!aFontArg.IsIntegerValue())
+ {
+ std::cout << "Error: HeightFont value should be integer!\n";
+ return 1;
+ }
+
+ aTextHeight = aFontArg.IntegerValue();
+ anArgIter += 1;
+ }
+ else if (aFlag == "-textpos")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ TCollection_AsciiString aTextPosArg(theArgVec[++anArgIter]);
+ aTextPosArg.LowerCase();
+ if (aTextPosArg == "none")
+ {
+ aLabPosition = Aspect_TOCSP_NONE;
+ }
+ else if (aTextPosArg == "left")
+ {
+ aLabPosition = Aspect_TOCSP_LEFT;
+ }
+ else if (aTextPosArg == "right")
+ {
+ aLabPosition = Aspect_TOCSP_RIGHT;
+ }
+ else if (aTextPosArg == "center")
+ {
+ aLabPosition = Aspect_TOCSP_CENTER;
+ }
+ else
+ {
+ 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")
+ {
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aX (theArgVec[++anArgIter]);
+ TCollection_AsciiString aY (theArgVec[++anArgIter]);
+ if (!aX.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: a width should be an integer value!\n";
+ return 1;
+ }
+
+ aHeight = aH.IntegerValue();
+ }
+ else if (aFlag == "-color")
+ {
+ if (aCS->GetColorType() != Aspect_TOCSD_USER)
+ {
+ std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
+ return 1;
+ }
+
+ Quantity_NameOfColor aColorName;
+ if (anArgIter + 4 >= theArgNb)
+ {
+ if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ else if (!Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+ {
+ std::cout << "Error: wrong color name: '" << theArgVec[anArgIter + 2] << "' !\n";
+ return 1;
+ }
+ }
+
+ TCollection_AsciiString anInd (theArgVec[anArgIter + 1]);
+ if (!anInd.IsIntegerValue())
+ {
+ std::cout << "Error: Index value should be integer!\n";
+ return 1;
+ }
+
+ Standard_Integer anIndex = anInd.IntegerValue();
+ if (anIndex <= 0 || anIndex > aNbIntervals)
+ {
+ std::cout << "Error: Index value should be within range 1.." << aNbIntervals <<"!\n";
+ return 1;
+ }
+
+ if (Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+ {
+ aCS->SetIntervalColor (Quantity_Color (aColorName), anIndex);
+ aCS->SetColorType (Aspect_TOCSD_USER);
+ anArgIter += 2;
+ continue;
+ }
+
+ TCollection_AsciiString aRed (theArgVec[anArgIter + 2]);
+ TCollection_AsciiString aGreen (theArgVec[anArgIter + 3]);
+ TCollection_AsciiString aBlue (theArgVec[anArgIter + 4]);
+ Standard_Real aRedValue,aGreenValue, aBlueValue;
+ if(checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+ {
+ return 1;
+ }
+ aCS->SetIntervalColor (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB), anIndex);
+ aCS->SetColorType (Aspect_TOCSD_USER);
+ anArgIter += 4;
+ }
+ else if (aFlag == "-label")
+ {
+ if (aCS->GetColorType() != Aspect_TOCSD_USER)
+ {
+ std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
+ return 1;
+ }
+ else if (anArgIter + 2 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
+ if (anIndex <= 0 || anIndex > aNbIntervals+1)
+ {
+ std::cout << "Error: Index value should be within range 1.." << aNbIntervals+1 <<"!\n";
+ return 1;
+ }
+
+ TCollection_ExtendedString aText (theArgVec[anArgIter + 2]);
+ aCS->SetLabel (aText, anIndex);
+ aCS->SetLabelType (Aspect_TOCSD_USER);
+ anArgIter += 2;
+ }
+ else if (aFlag == "-colors")
+ {
+ Aspect_SequenceOfColor aSeq;
+ if (anArgIter + aNbIntervals + 1 > theArgNb)
+ {
+ std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aNbIntervals << " intervals\n";
+ return 1;
+ }
+
+ Standard_Integer aColorIter = anArgIter + 1;
+ while (aColorIter < theArgNb)
+ {
+ if (theArgVec[aColorIter][0] == '-')
+ {
+ break;
+ }
+
+ else if (theArgVec[aColorIter][0] >= 97
+ && theArgVec[aColorIter][0] <= 122)
+ {
+ Quantity_NameOfColor aColorName;
+ if (!Quantity_Color::ColorFromName (theArgVec[aColorIter], aColorName))
+ {
+ std::cout << "Error: wrong color name: " << theArgVec[aColorIter] << " !\n";
+ return 1;
+ }
+ aSeq.Append (Quantity_Color (aColorName));
+ aColorIter++;
+ anArgIter++;
+ }
+ else
+ {
+ TCollection_AsciiString aRed (theArgVec[aColorIter]);
+ TCollection_AsciiString aGreen (theArgVec[aColorIter + 1]);
+ TCollection_AsciiString aBlue (theArgVec[aColorIter + 2]);
+ Standard_Real aRedValue,aGreenValue, aBlueValue;
+ if (checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+ {
+ return 1;
+ }
+ aSeq.Append (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB));
+ aColorIter += 3;
+ anArgIter += 3;
+ }
+ }
+ if (aSeq.Length() < aNbIntervals)
+ {
+ std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+ << aNbIntervals << " intervals\n";
+ return 1;
+ }
+
+ aCS->SetColors (aSeq);
+ aCS->SetColorType (Aspect_TOCSD_USER);
+ }
+ else if (aFlag == "-labels")
+ {
+ if (anArgIter + aNbIntervals + 1 >= theArgNb)
+ {
+ std::cout << "Error: not enough arguments! You should provide " << (aNbIntervals + 1)
+ << " text labels for " << aNbIntervals << " intervals.\n";
+ return 1;
+ }
+
+ TColStd_SequenceOfExtendedString aSeq;
+ for (int aLabelIter = anArgIter + 1; aLabelIter <= anArgIter + aNbIntervals + 1; aLabelIter += 1)
+ {
+ aSeq.Append (TCollection_ExtendedString (theArgVec[aLabelIter]));
+ }
+ aCS->SetLabels (aSeq);
+ aCS->SetLabelType (Aspect_TOCSD_USER);
+ anArgIter += aSeq.Length();
+ }
+ else if (aFlag == "-title")
+ {
+ if (anArgIter + 1 >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Boolean isTwoArgs = Standard_False;
+ if (anArgIter + 2 < theArgNb)
+ {
+ TCollection_AsciiString aSecondArg (theArgVec[anArgIter + 2]);
+ aSecondArg.LowerCase();
+ if (aSecondArg == "none")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_NONE);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "left")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_LEFT);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "right")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_RIGHT);
+ isTwoArgs = Standard_True;
+ }
+ else if (aSecondArg == "center")
+ {
+ aCS->SetTitlePosition (Aspect_TOCSP_CENTER);
+ isTwoArgs = Standard_True;
+ }
+ }
+
+ aCS->SetTitle (theArgVec[anArgIter + 1]);
+ if (isTwoArgs)
+ {
+ anArgIter += 1;
+ }
+ anArgIter += 1;
+ }
+ else if (aFlag == "-demoversion"
+ || aFlag == "-demo")
+ {
+ 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);
+ }
+ 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
+ {
+ std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
+ return 1;
+ }
+ }
+ 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);
+// aCS->SetColor (aView->BackgroundColor().Invert());
+ aCS->SetToUpdate();
+ aContext->Display (aCS);
+
+ return 0;
+}
+
+//==============================================================================
+//function : VGraduatedTrihedron
+//purpose : Displays or hides a graduated trihedron
+//==============================================================================
+static Standard_Boolean GetColor (const TCollection_AsciiString& theValue,
+ Quantity_Color& theColor)
+{
+ Quantity_NameOfColor aColorName;
+ TCollection_AsciiString aVal = theValue;
+ aVal.UpperCase();
+ if (!Quantity_Color::ColorFromName (aVal.ToCString(), aColorName))
+ {
+ return Standard_False;
+ }
+ theColor = Quantity_Color (aColorName);
+ return Standard_True;
+}
+
+static int VGraduatedTrihedron (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNum, const char** theArgs)
+{
+ if (theArgNum < 2)
+ {
+ std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
+ << theArgs[0] <<"' for more information.\n";
+ return 1; //TCL_ERROR
+ }
+
+ NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
+ TCollection_AsciiString aParseKey;
+ for (Standard_Integer anArgIt = 1; anArgIt < theArgNum; ++anArgIt)
+ {
+ TCollection_AsciiString anArg (theArgs [anArgIt]);
+
+ if (anArg.Value (1) == '-' && !anArg.IsRealValue())
+ {
+ aParseKey = anArg;
+ aParseKey.Remove (1);
+ aParseKey.LowerCase();
+ aMapOfArgs.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
+ continue;
+ }
+
+ if (aParseKey.IsEmpty())
+ {
+ continue;
+ }
+
+ aMapOfArgs(aParseKey)->Append (anArg);
+ }
+
+ // Check parameters
+ for (NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfArgs);
+ aMapIt.More(); aMapIt.Next())
+ {
+ const TCollection_AsciiString& aKey = aMapIt.Key();
+ const Handle(TColStd_HSequenceOfAsciiString)& anArgs = aMapIt.Value();
+
+ // Bool key, without arguments
+ if ((aKey.IsEqual ("on") || aKey.IsEqual ("off"))
+ && anArgs->IsEmpty())
+ {
+ continue;
+ }
+
+ // One argument
+ if ( (aKey.IsEqual ("xname") || aKey.IsEqual ("yname") || aKey.IsEqual ("zname"))
+ && anArgs->Length() == 1)
+ {
+ continue;
+ }
+
+ // On/off arguments
+ if ((aKey.IsEqual ("xdrawname") || aKey.IsEqual ("ydrawname") || aKey.IsEqual ("zdrawname")
+ || aKey.IsEqual ("xdrawticks") || aKey.IsEqual ("ydrawticks") || aKey.IsEqual ("zdrawticks")
+ || aKey.IsEqual ("xdrawvalues") || aKey.IsEqual ("ydrawvalues") || aKey.IsEqual ("zdrawvalues")
+ || aKey.IsEqual ("drawgrid") || aKey.IsEqual ("drawaxes"))
+ && anArgs->Length() == 1 && (anArgs->Value(1).IsEqual ("on") || anArgs->Value(1).IsEqual ("off")))
+ {
+ continue;
+ }
+
+ // One string argument
+ if ( (aKey.IsEqual ("xnamecolor") || aKey.IsEqual ("ynamecolor") || aKey.IsEqual ("znamecolor")
+ || aKey.IsEqual ("xcolor") || aKey.IsEqual ("ycolor") || aKey.IsEqual ("zcolor"))
+ && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+ {
+ continue;
+ }
+
+ // One integer argument
+ if ( (aKey.IsEqual ("xticks") || aKey.IsEqual ("yticks") || aKey.IsEqual ("zticks")
+ || aKey.IsEqual ("xticklength") || aKey.IsEqual ("yticklength") || aKey.IsEqual ("zticklength")
+ || aKey.IsEqual ("xnameoffset") || aKey.IsEqual ("ynameoffset") || aKey.IsEqual ("znameoffset")
+ || aKey.IsEqual ("xvaluesoffset") || aKey.IsEqual ("yvaluesoffset") || aKey.IsEqual ("zvaluesoffset"))
+ && anArgs->Length() == 1 && anArgs->Value(1).IsIntegerValue())
+ {
+ continue;
+ }
+
+ // One real argument
+ if ( aKey.IsEqual ("arrowlength")
+ && anArgs->Length() == 1 && (anArgs->Value(1).IsIntegerValue() || anArgs->Value(1).IsRealValue()))
+ {
+ continue;
+ }
+
+ // Two string arguments
+ if ( (aKey.IsEqual ("namefont") || aKey.IsEqual ("valuesfont"))
+ && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+ {
+ continue;
+ }
+
+ TCollection_AsciiString aLowerKey;
+ aLowerKey = "-";
+ aLowerKey += aKey;
+ aLowerKey.LowerCase();
+ std::cout << theArgs[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
+ std::cout << "Type help for more information.\n";
+ return 1;
+ }
+
+ Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
+ if (anAISContext.IsNull())
+ {
+ std::cout << theArgs[0] << ": please use 'vinit' command to initialize view.\n";
+ return 1;
+ }
+
+ Standard_Boolean toDisplay = Standard_True;
+ Quantity_Color aColor;
+ Graphic3d_GraduatedTrihedron aTrihedronData;
+ // Process parameters
+ Handle(TColStd_HSequenceOfAsciiString) aValues;
+ if (aMapOfArgs.Find ("off", aValues))
+ {
+ toDisplay = Standard_False;
+ }
+
+ // AXES NAMES
+ if (aMapOfArgs.Find ("xname", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("yname", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("zname", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetName (aValues->Value(1));
+ }
+ if (aMapOfArgs.Find ("xdrawname", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawname", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawname", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("xnameoffset", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("ynameoffset", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("znameoffset", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+ }
+
+ // COLORS
+ if (aMapOfArgs.Find ("xnamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("ynamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("znamecolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
+ }
+ if (aMapOfArgs.Find ("xcolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
+ }
+ if (aMapOfArgs.Find ("ycolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
+ }
+ if (aMapOfArgs.Find ("zcolor", aValues))
+ {
+ if (!GetColor (aValues->Value(1), aColor))
+ {
+ std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
+ return 1;
+ }
+ aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
+ }
+
+ // TICKMARKS
+ if (aMapOfArgs.Find ("xticks", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yticks", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zticks", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("xticklength", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yticklength", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zticklength", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("xdrawticks", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawticks", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawticks", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+ }
+
+ // VALUES
+ if (aMapOfArgs.Find ("xdrawvalues", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("ydrawvalues", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("zdrawvalues", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+ }
+ if (aMapOfArgs.Find ("xvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeXAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("yvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeYAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
+ if (aMapOfArgs.Find ("zvaluesoffset", aValues))
+ {
+ aTrihedronData.ChangeZAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
+ }
-static int VColorScale (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
-{
- if ( argc != 1 && argc != 4 && argc != 5 && argc != 6 && argc != 8 )
+ // ARROWS
+ if (aMapOfArgs.Find ("arrowlength", aValues))
{
- di << "Usage : " << argv[0] << " [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = Right X = 0 Y = 0] " << "\n";
- return 1;
+ aTrihedronData.SetArrowsLength ((Standard_ShortReal) aValues->Value(1).RealValue());
}
- Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- if(aContext.IsNull()) {
- di << argv[0] << " ERROR : use 'vinit' command before " << "\n";
- return -1;
- }
-
- Standard_Real minRange = 0. , maxRange = 100. ;
-
- Standard_Integer numIntervals = 10 ;
- Standard_Integer textHeight = 16;
- Aspect_TypeOfColorScalePosition position = Aspect_TOCSP_RIGHT;
- Standard_Real X = 0., Y = 0. ;
-
- if ( argc < 9 )
- {
- if( argc > 3 )
- {
- minRange = Draw::Atof( argv[1] );
- maxRange = Draw::Atof( argv[2] );
- numIntervals = Draw::Atoi( argv[3] );
- }
- if ( argc > 4 )
- textHeight = Draw::Atoi( argv[4] );
- if ( argc > 5 )
- position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
- if ( argc > 7 )
- {
- X = Draw::Atof( argv[6] );
- Y = Draw::Atof( argv[7] );
- }
- }
- Handle(V3d_View) curView = ViewerTest::CurrentView( );
- if ( curView.IsNull( ) )
- return 1;
- Handle(Aspect_ColorScale) aCSV = curView->ColorScale( );
- Handle(V3d_ColorScale) aCS = ( Handle( V3d_ColorScale )::DownCast( aCSV ) );
- if( ! aCS.IsNull( ) )
- {
- aCS->SetPosition( X , Y );
- aCS->SetHeight( 0.95) ;
- aCS->SetTextHeight( textHeight );
- aCS->SetRange( minRange , maxRange );
- aCS->SetNumberOfIntervals( numIntervals );
- aCS->SetLabelPosition( position );
- if( !curView->ColorScaleIsDisplayed() )
- curView->ColorScaleDisplay( );
+ // FONTS
+ if (aMapOfArgs.Find ("namefont", aValues))
+ {
+ aTrihedronData.SetNamesFont (aValues->Value(1));
}
- return 0;
-}
-
-//==============================================================================
-//function : VGraduatedTrihedron
-//purpose : Displays a graduated trihedron
-//==============================================================================
-
-static void AddMultibyteString (TCollection_ExtendedString &name, const char *arg)
-{
- const char *str = arg;
- while (*str)
+ if (aMapOfArgs.Find ("valuesfont", aValues))
{
- unsigned short c1 = *str++;
- unsigned short c2 = *str++;
- if (!c1 || !c2) break;
- name += (Standard_ExtCharacter)((c1 << 8) | c2);
+ aTrihedronData.SetValuesFont (aValues->Value(1));
}
-}
-static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
-{
- // Check arguments
- if (argc != 2 && argc < 5)
+ if (aMapOfArgs.Find ("drawgrid", aValues))
{
- di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
- di<<"Usage: type help "<<argv[0]<<"\n";
- return 1; //TCL_ERROR
+ aTrihedronData.SetDrawGrid (aValues->Value(1).IsEqual ("on"));
}
-
- Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
-
- // Create 3D view if it doesn't exist
- if ( aV3dView.IsNull() )
+ if (aMapOfArgs.Find ("drawaxes", aValues))
{
- ViewerTest::ViewerInit();
- aV3dView = ViewerTest::CurrentView();
- if( aV3dView.IsNull() )
- {
- di << "Error: Cannot create a 3D view\n";
- return 1; //TCL_ERROR
- }
+ aTrihedronData.SetDrawAxes (aValues->Value(1).IsEqual ("on"));
}
- // Erase (==0) or display (!=0)
- const int display = Draw::Atoi(argv[1]);
-
- if (display)
+ // The final step: display of erase trihedron
+ if (toDisplay)
{
- // Text font
- TCollection_AsciiString font;
- if (argc < 6)
- font.AssignCat("Courier");
- else
- font.AssignCat(argv[5]);
-
- // Text is multibyte
- const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
-
- // Set axis names
- TCollection_ExtendedString xname, yname, zname;
- if (argc >= 5)
- {
- if (isMultibyte)
- {
- AddMultibyteString(xname, argv[2]);
- AddMultibyteString(yname, argv[3]);
- AddMultibyteString(zname, argv[4]);
- }
- else
- {
- xname += argv[2];
- yname += argv[3];
- zname += argv[4];
- }
- }
- else
- {
- xname += "X (mm)";
- yname += "Y (mm)";
- zname += "Z (mm)";
- }
-
- aV3dView->GraduatedTrihedronDisplay(xname, yname, zname,
- Standard_True/*xdrawname*/, Standard_True/*ydrawname*/, Standard_True/*zdrawname*/,
- Standard_True/*xdrawvalues*/, Standard_True/*ydrawvalues*/, Standard_True/*zdrawvalues*/,
- Standard_True/*drawgrid*/,
- Standard_True/*drawaxes*/,
- 5/*nbx*/, 5/*nby*/, 5/*nbz*/,
- 10/*xoffset*/, 10/*yoffset*/, 10/*zoffset*/,
- 30/*xaxisoffset*/, 30/*yaxisoffset*/, 30/*zaxisoffset*/,
- Standard_True/*xdrawtickmarks*/, Standard_True/*ydrawtickmarks*/, Standard_True/*zdrawtickmarks*/,
- 10/*xtickmarklength*/, 10/*ytickmarklength*/, 10/*ztickmarklength*/,
- Quantity_NOC_WHITE/*gridcolor*/,
- Quantity_NOC_RED/*xnamecolor*/,Quantity_NOC_GREEN/*ynamecolor*/,Quantity_NOC_BLUE1/*znamecolor*/,
- Quantity_NOC_RED/*xcolor*/,Quantity_NOC_GREEN/*ycolor*/,Quantity_NOC_BLUE1/*zcolor*/,font);
+ ViewerTest::CurrentView()->GraduatedTrihedronDisplay (aTrihedronData);
}
else
- aV3dView->GraduatedTrihedronErase();
+ {
+ ViewerTest::CurrentView()->GraduatedTrihedronErase();
+ }
ViewerTest::GetAISContext()->UpdateCurrentViewer();
- aV3dView->Redraw();
+ ViewerTest::CurrentView()->Redraw();
return 0;
}
//==============================================================================
-//function : VPrintView
-//purpose : Test printing algorithm, print the view to image file with given
-// width and height. Printing implemented only for WNT.
+//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;
}
return 1;
}
+ for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anObjIter (GetMapOfAIS());
+ anObjIter.More(); anObjIter.Next())
+ {
+ Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anObjIter.Key1());
+ if (aPrs.IsNull()
+ || aPrs->ZLayer() != aDelId)
+ {
+ continue;
+ }
+ aPrs->SetZLayer (Graphic3d_ZLayerId_Default);
+ }
+
di << "Z layer " << aDelId << " has been removed\n";
}
else if (anOp == "get")
{
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);
+ static Handle (V3d_LineItem) aLine;
+ if (!aLine.IsNull())
+ {
+ aContext->Erase (aLine);
+ }
+ aLine = new V3d_LineItem (X1, Y1, X2, Y2,
+ aLineType, aWidth,
+ aTransparency);
- // 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 : VOverlayText
-//purpose : Test text displaying in view overlay
-//=======================================================================
-static int VOverlayText (Draw_Interpretor& di, Standard_Integer argc, const char**argv)
+
+//==============================================================================
+//function : VGrid
+//purpose :
+//==============================================================================
+
+static int VGrid (Draw_Interpretor& /*theDI*/,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
// get the active view
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- if (aView.IsNull())
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+ if (aView.IsNull() || aViewer.IsNull())
{
- di << "No active view. Please call vinit.\n";
+ std::cerr << "No active view. Please call vinit.\n";
return 1;
}
- else if (argc < 4 || argc > 13)
+
+ Aspect_GridType aType = aViewer->GridType();
+ Aspect_GridDrawMode aMode = aViewer->GridDrawMode();
+
+ Standard_Integer anIter = 1;
+ for (; anIter < theArgNb; ++anIter)
{
- 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;
+ const char* aValue = theArgVec[anIter];
+ if (*aValue == 'r')
+ {
+ aType = Aspect_GT_Rectangular;
+ }
+ else if (*aValue == 'c')
+ {
+ aType = Aspect_GT_Circular;
+ }
+ else if (*aValue == 'l')
+ {
+ aMode = Aspect_GDM_Lines;
+ }
+ else if (*aValue == 'p')
+ {
+ aMode = Aspect_GDM_Points;
+ }
+ else if (strcmp (aValue, "off" ) == 0)
+ {
+ aViewer->DeactivateGrid();
+ return 0;
+ }
+ else
+ {
+ break;
+ }
}
- 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;
+ Standard_Integer aTail = (theArgNb - anIter);
+ if (aTail == 0)
+ {
+ aViewer->ActivateGrid (aType, aMode);
+ return 0;
+ }
+ else if (aTail != 2 && aTail != 5)
+ {
+ std::cerr << "Incorrect arguments number! Usage:\n"
+ << "vgrid [off] [Mode={r|c}] [Type={l|p}] [OriginX OriginY [StepX/StepRadius StepY/DivNb RotAngle]]\n";
+ return 1;
+ }
- // font name
- TCollection_AsciiString aFontName = "Courier";
- if (argc >= 6)
- aFontName = TCollection_AsciiString (argv[5]);
+ Quantity_Length anOriginX, anOriginY;
+ Quantity_PlaneAngle aRotAngle;
+ if (aType == Aspect_GT_Rectangular)
+ {
+ Quantity_Length aRStepX, aRStepY;
+ aViewer->RectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
- // text colors
- Quantity_Parameter aColorRed = 1.0;
- Quantity_Parameter aColorGreen = 1.0;
- Quantity_Parameter aColorBlue = 1.0;
- if (argc >= 9)
+ anOriginX = Draw::Atof (theArgVec[anIter++]);
+ anOriginY = Draw::Atof (theArgVec[anIter++]);
+ if (aTail == 5)
+ {
+ aRStepX = Draw::Atof (theArgVec[anIter++]);
+ aRStepY = Draw::Atof (theArgVec[anIter++]);
+ aRotAngle = Draw::Atof (theArgVec[anIter++]);
+ }
+ aViewer->SetRectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
+ aViewer->ActivateGrid (aType, aMode);
+ }
+ else if (aType == Aspect_GT_Circular)
{
- aColorRed = Draw::Atof (argv[6])/255.;
- aColorGreen = Draw::Atof (argv[7])/255.;
- aColorBlue = Draw::Atof (argv[8])/255.;
+ Quantity_Length aRadiusStep;
+ Standard_Integer aDivisionNumber;
+ aViewer->CircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
+
+ anOriginX = Draw::Atof (theArgVec[anIter++]);
+ anOriginY = Draw::Atof (theArgVec[anIter++]);
+ if (aTail == 5)
+ {
+ aRadiusStep = Draw::Atof (theArgVec[anIter++]);
+ aDivisionNumber = Draw::Atoi (theArgVec[anIter++]);
+ aRotAngle = Draw::Atof (theArgVec[anIter++]);
+ }
+
+ aViewer->SetCircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
+ aViewer->ActivateGrid (aType, aMode);
}
- // display type
- TCollection_AsciiString aDispStr;
- if (argc >= 10)
- aDispStr = TCollection_AsciiString (argv[9]);
+ return 0;
+}
+
+//==============================================================================
+//function : VPriviledgedPlane
+//purpose :
+//==============================================================================
- 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;
+static int VPriviledgedPlane (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
+ {
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
- // subtitle color
- Quantity_Parameter aSubRed = 1.0;
- Quantity_Parameter aSubGreen = 1.0;
- Quantity_Parameter aSubBlue = 1.0;
- if (argc == 13)
+ // get the active viewer
+ Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+ if (aViewer.IsNull())
{
- aSubRed = Draw::Atof (argv[10])/255.;
- aSubGreen = Draw::Atof (argv[11])/255.;
- aSubBlue = Draw::Atof (argv[12])/255.;
+ std::cerr << "Error: no active viewer. Please call vinit.\n";
+ return 1;
}
- // check fo current overlay
- Handle(Visual3d_Layer) anOverlay = aView->Viewer()->Viewer()->OverLayer ();
- if (anOverlay.IsNull ())
+ if (theArgNb == 1)
{
- Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr (aView);
- anOverlay = aMgr->Overlay ();
- aView->SetLayerMgr (aMgr);
+ gp_Ax3 aPriviledgedPlane = aViewer->PrivilegedPlane();
+ const gp_Pnt& anOrig = aPriviledgedPlane.Location();
+ const gp_Dir& aNorm = aPriviledgedPlane.Direction();
+ const gp_Dir& aXDir = aPriviledgedPlane.XDirection();
+ theDI << "Origin: " << anOrig.X() << " " << anOrig.Y() << " " << anOrig.Z() << " "
+ << "Normal: " << aNorm.X() << " " << aNorm.Y() << " " << aNorm.Z() << " "
+ << "X-dir: " << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
+ return 0;
}
- Quantity_Color aTextColor (aColorRed, aColorGreen,
- aColorBlue, Quantity_TOC_RGB);
- Quantity_Color aSubtColor (aSubRed, aSubGreen,
- aSubBlue, Quantity_TOC_RGB);
+ Standard_Integer anArgIdx = 1;
+ Standard_Real anOrigX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real anOrigY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real anOrigZ = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aNormZ = Draw::Atof (theArgVec[anArgIdx++]);
- // add text item
- Handle(V3d_TextItem) anItem = new V3d_TextItem (aText, aPosX, aPosY,
- aHeight, aFontName, aTextColor, aSubtColor, aTextType, anOverlay);
+ gp_Ax3 aPriviledgedPlane;
+ gp_Pnt anOrig (anOrigX, anOrigY, anOrigZ);
+ gp_Dir aNorm (aNormX, aNormY, aNormZ);
+ if (theArgNb > 7)
+ {
+ Standard_Real aXDirX = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aXDirY = Draw::Atof (theArgVec[anArgIdx++]);
+ Standard_Real aXDirZ = Draw::Atof (theArgVec[anArgIdx++]);
+ gp_Dir aXDir (aXDirX, aXDirY, aXDirZ);
+ aPriviledgedPlane = gp_Ax3 (anOrig, aNorm, aXDir);
+ }
+ else
+ {
+ aPriviledgedPlane = gp_Ax3 (anOrig, aNorm);
+ }
- // update view
- aView->MustBeResized();
- aView->Redraw();
+ aViewer->SetPrivilegedPlane (aPriviledgedPlane);
return 0;
}
//==============================================================================
-//function : VGrid
+//function : VConvert
//purpose :
//==============================================================================
-static int VGrid (Draw_Interpretor& /*theDI*/,
- Standard_Integer theArgNb,
- const char** theArgVec)
+static int VConvert (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
// get the active view
- Handle(V3d_View) aView = ViewerTest::CurrentView();
- Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
- if (aView.IsNull() || aViewer.IsNull())
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
{
- std::cerr << "No active view. Please call vinit.\n";
+ std::cerr << "Error: no active view. Please call vinit.\n";
return 1;
}
- Aspect_GridType aType = aViewer->GridType();
- Aspect_GridDrawMode aMode = aViewer->GridDrawMode();
+ enum { Model, Ray, View, Window, Grid } aMode = Model;
- Standard_Integer anIter = 1;
- for (; anIter < theArgNb; ++anIter)
+ // access coordinate arguments
+ TColStd_SequenceOfReal aCoord;
+ Standard_Integer anArgIdx = 1;
+ for (; anArgIdx < 4 && anArgIdx < theArgNb; ++anArgIdx)
{
- const char* aValue = theArgVec[anIter];
- if (*aValue == 'r')
- {
- aType = Aspect_GT_Rectangular;
- }
- else if (*aValue == 'c')
- {
- aType = Aspect_GT_Circular;
- }
- else if (*aValue == 'l')
- {
- aMode = Aspect_GDM_Lines;
- }
- else if (*aValue == 'p')
- {
- aMode = Aspect_GDM_Points;
- }
- else if (strcmp (aValue, "off" ) == 0)
- {
- aViewer->DeactivateGrid();
- return 0;
- }
- else
+ TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+ if (!anArg.IsRealValue())
{
break;
}
+ aCoord.Append (anArg.RealValue());
}
- Standard_Integer aTail = (theArgNb - anIter);
- if (aTail == 0)
+ // non-numeric argument too early
+ if (aCoord.IsEmpty())
{
- aViewer->ActivateGrid (aType, aMode);
- return 0;
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
}
- else if (aTail != 2 && aTail != 5)
+
+ // collect all other arguments and options
+ for (; anArgIdx < theArgNb; ++anArgIdx)
{
- std::cerr << "Incorrect arguments number! Usage:\n"
- << "vgrid [off] [Mode={r|c}] [Type={l|p}] [OriginX OriginY [StepX/StepRadius StepY/DivNb RotAngle]]\n";
- return 1;
+ TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+ anArg.LowerCase();
+ if (anArg == "window") aMode = Window;
+ else if (anArg == "view") aMode = View;
+ else if (anArg == "grid") aMode = Grid;
+ else if (anArg == "ray") aMode = Ray;
+ else
+ {
+ std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
}
- Quantity_Length anOriginX, anOriginY;
- Quantity_PlaneAngle aRotAngle;
- if (aType == Aspect_GT_Rectangular)
+ // complete input checks
+ if ((aCoord.Length() == 1 && theArgNb > 3) ||
+ (aCoord.Length() == 2 && theArgNb > 4) ||
+ (aCoord.Length() == 3 && theArgNb > 5))
{
- Quantity_Length aRStepX, aRStepY;
- aViewer->RectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
+ std::cerr << "Error: wrong number of arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
- anOriginX = Draw::Atof (theArgVec[anIter++]);
- anOriginY = Draw::Atof (theArgVec[anIter++]);
- if (aTail == 5)
+ Standard_Real aXYZ[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+ Standard_Integer aXYp[2] = {0, 0};
+
+ // convert one-dimensional coordinate
+ if (aCoord.Length() == 1)
+ {
+ switch (aMode)
{
- aRStepX = Draw::Atof (theArgVec[anIter++]);
- aRStepY = Draw::Atof (theArgVec[anIter++]);
- aRotAngle = Draw::Atof (theArgVec[anIter++]);
+ case View : theDI << "View Vv: " << aView->Convert ((Standard_Integer) aCoord (1)); return 0;
+ case Window : theDI << "Window Vp: " << aView->Convert ((Quantity_Length) aCoord (1)); return 0;
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
}
- aViewer->SetRectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
- aViewer->ActivateGrid (aType, aMode);
}
- else if (aType == Aspect_GT_Circular)
- {
- Quantity_Length aRadiusStep;
- Standard_Integer aDivisionNumber;
- aViewer->CircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
- anOriginX = Draw::Atof (theArgVec[anIter++]);
- anOriginY = Draw::Atof (theArgVec[anIter++]);
- if (aTail == 5)
+ // convert 2D coordinates from projection or view reference space
+ if (aCoord.Length() == 2)
+ {
+ switch (aMode)
{
- aRadiusStep = Draw::Atof (theArgVec[anIter++]);
- aDivisionNumber = Draw::Atoi (theArgVec[anIter++]);
- aRotAngle = Draw::Atof (theArgVec[anIter++]);
+ case Model :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+ theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+ return 0;
+
+ case View :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1]);
+ theDI << "View Xv,Yv: " << aXYZ[0] << " " << aXYZ[1] << "\n";
+ return 0;
+
+ case Window :
+ aView->Convert ((V3d_Coordinate) aCoord (1), (V3d_Coordinate) aCoord (2), aXYp[0], aXYp[1]);
+ theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+ return 0;
+
+ case Grid :
+ aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+ aView->ConvertToGrid (aXYZ[0], aXYZ[1], aXYZ[2], aXYZ[3], aXYZ[4], aXYZ[5]);
+ theDI << "Model X,Y,Z: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+ return 0;
+
+ case Ray :
+ aView->ConvertWithProj ((Standard_Integer) aCoord (1),
+ (Standard_Integer) aCoord (2),
+ aXYZ[0], aXYZ[1], aXYZ[2],
+ aXYZ[3], aXYZ[4], aXYZ[5]);
+ theDI << "Model DX,DY,DZ: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+ return 0;
+
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
}
+ }
- aViewer->SetCircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
- aViewer->ActivateGrid (aType, aMode);
+ // convert 3D coordinates from view reference space
+ else if (aCoord.Length() == 3)
+ {
+ switch (aMode)
+ {
+ case Window :
+ aView->Convert (aCoord (1), aCoord (2), aCoord (3), aXYp[0], aXYp[1]);
+ theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+ return 0;
+
+ case Grid :
+ aView->ConvertToGrid (aCoord (1), aCoord (2), aCoord (3), aXYZ[0], aXYZ[1], aXYZ[2]);
+ theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+ return 0;
+
+ default:
+ std::cerr << "Error: wrong arguments! See usage:\n";
+ theDI.PrintHelp (theArgVec[0]);
+ return 1;
+ }
}
return 0;
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;
}
{
aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aView->Viewer()->Driver());
}
+ OpenGl_Caps* aDefCaps = &ViewerTest_myDefaultCaps;
+ OpenGl_Caps* aCaps = !aDriver.IsNull() ? &aDriver->ChangeOptions() : NULL;
+
if (theArgNb < 2)
{
- if (aDriver.IsNull())
+ TCollection_AsciiString aDebActive, aSyncActive;
+ if (aCaps == NULL)
{
- std::cerr << "No active view. Please call vinit.\n";
- return 0;
+ aCaps = aDefCaps;
+ }
+ else
+ {
+ Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )::glGetString (GL_EXTENSIONS),
+ "GL_ARB_debug_output");
+ aDebActive = isActive ? " (active)" : " (inactive)";
+ if (isActive)
+ {
+ // GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
+ aSyncActive = ::glIsEnabled (0x8242) == GL_TRUE ? " (active)" : " (inactive)";
+ }
}
- Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )glGetString (GL_EXTENSIONS),
- "GL_ARB_debug_output");
- std::cout << "Active graphic driver: debug " << (isActive ? "ON" : "OFF") << "\n";
- theDI << (isActive ? "1" : "0");
+ theDI << "debug: " << (aCaps->contextDebug ? "1" : "0") << aDebActive << "\n"
+ << "sync: " << (aCaps->contextSyncDebug ? "1" : "0") << aSyncActive << "\n"
+ << "glslWarn:" << (aCaps->glslWarnings ? "1" : "0") << "\n"
+ << "extraMsg:" << (aCaps->suppressExtraMsg ? "0" : "1") << "\n";
return 0;
}
- const Standard_Boolean toEnableDebug = Draw::Atoi (theArgVec[1]) != 0;
- ViewerTest_myDefaultCaps.contextDebug = toEnableDebug;
- ViewerTest_myDefaultCaps.glslWarnings = toEnableDebug;
- if (aDriver.IsNull())
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- return 0;
+ Standard_CString anArg = theArgVec[anArgIter];
+ TCollection_AsciiString anArgCase (anArg);
+ anArgCase.LowerCase();
+ Standard_Boolean toEnableDebug = Standard_True;
+ if (anArgCase == "-glsl"
+ || anArgCase == "-glslwarn"
+ || anArgCase == "-glslwarns"
+ || anArgCase == "-glslwarnings")
+ {
+ Standard_Boolean toShowWarns = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShowWarns))
+ {
+ --anArgIter;
+ }
+ aDefCaps->glslWarnings = toShowWarns;
+ if (aCaps != NULL)
+ {
+ aCaps->glslWarnings = toShowWarns;
+ }
+ }
+ else if (anArgCase == "-extra"
+ || anArgCase == "-extramsg"
+ || anArgCase == "-extramessages")
+ {
+ Standard_Boolean toShow = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toShow))
+ {
+ --anArgIter;
+ }
+ aDefCaps->suppressExtraMsg = !toShow;
+ if (aCaps != NULL)
+ {
+ aCaps->suppressExtraMsg = !toShow;
+ }
+ }
+ else if (anArgCase == "-noextra"
+ || anArgCase == "-noextramsg"
+ || anArgCase == "-noextramessages")
+ {
+ Standard_Boolean toSuppress = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSuppress))
+ {
+ --anArgIter;
+ }
+ aDefCaps->suppressExtraMsg = toSuppress;
+ if (aCaps != NULL)
+ {
+ aCaps->suppressExtraMsg = toSuppress;
+ }
+ }
+ else if (anArgCase == "-sync")
+ {
+ Standard_Boolean toSync = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toSync))
+ {
+ --anArgIter;
+ }
+ aDefCaps->contextSyncDebug = toSync;
+ if (toSync)
+ {
+ aDefCaps->contextDebug = Standard_True;
+ }
+ }
+ else if (anArgCase == "-debug")
+ {
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnableDebug))
+ {
+ --anArgIter;
+ }
+ aDefCaps->contextDebug = toEnableDebug;
+ }
+ else if (ViewerTest::ParseOnOff (anArg, toEnableDebug)
+ && (anArgIter + 1 == theArgNb))
+ {
+ // simple alias to turn on almost everything
+ aDefCaps->contextDebug = toEnableDebug;
+ aDefCaps->contextSyncDebug = toEnableDebug;
+ aDefCaps->glslWarnings = toEnableDebug;
+ }
+ else
+ {
+ std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+ return 1;
+ }
}
- aDriver->ChangeOptions().glslWarnings = toEnableDebug;
return 0;
}
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;
}
aCaps->contextNoAccel = !toEnable;
}
+ else if (anArgCase == "-compat"
+ || anArgCase == "-compatprofile"
+ || anArgCase == "-compatible"
+ || anArgCase == "-compatibleprofile")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextCompatible = toEnable;
+ if (!aCaps->contextCompatible)
+ {
+ aCaps->ffpEnable = Standard_False;
+ }
+ }
+ else if (anArgCase == "-core"
+ || anArgCase == "-coreprofile")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextCompatible = !toEnable;
+ if (!aCaps->contextCompatible)
+ {
+ aCaps->ffpEnable = Standard_False;
+ }
+ }
+ else if (anArgCase == "-stereo"
+ || anArgCase == "-quadbuffer")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (++anArgIter < theArgNb
+ && !ViewerTest::ParseOnOff (theArgVec[anArgIter], toEnable))
+ {
+ --anArgIter;
+ }
+ aCaps->contextStereo = toEnable;
+ }
else
{
std::cout << "Error: unknown argument '" << anArg << "'\n";
theDI << aDiffColorsNb << "\n";
// save image of difference
- if (aDiffImagePath != NULL)
+ if (aDiffColorsNb >0 && aDiffImagePath != NULL)
{
aComparer.SaveDiffImage (aDiffImagePath);
}
{
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;
}
di << "use 'vinit' command before " << argv[0] << "\n";
return 1;
}
- const Standard_Boolean isShiftSelection = (argc>3 && !(argc%2) && (atoi(argv[argc-1])==1));
+
+ const Standard_Boolean isShiftSelection = (argc > 3 && !(argc % 2) && (atoi (argv[argc - 1]) == 1));
+ Standard_Integer aCoordsNb = isShiftSelection ? argc - 2 : argc - 1;
+ TCollection_AsciiString anArg;
+ anArg = isShiftSelection ? argv[argc - 3] : argv[argc - 2];
+ anArg.LowerCase();
+ if (anArg == "-allowoverlap")
+ {
+ Standard_Boolean isValidated = isShiftSelection ? argc == 8
+ : argc == 7;
+ if (!isValidated)
+ {
+ di << "Wrong number of arguments! -allowoverlap key is applied only for rectangle selection";
+ return 1;
+ }
+
+ Standard_Integer isToAllow = isShiftSelection ? Draw::Atoi(argv[argc - 2]) : Draw::Atoi(argv[argc - 1]);
+ myAIScontext->MainSelector()->AllowOverlapDetection (isToAllow != 0);
+ aCoordsNb -= 2;
+ }
+
Handle(ViewerTest_EventManager) aCurrentEventManager = ViewerTest::CurrentEventManager();
aCurrentEventManager->MoveTo(atoi(argv[1]),atoi(argv[2]));
- if(argc <= 4)
+ if(aCoordsNb == 2)
{
if(isShiftSelection)
aCurrentEventManager->ShiftSelect();
else
aCurrentEventManager->Select();
}
- else if(argc <= 6)
+ else if(aCoordsNb == 4)
{
if(isShiftSelection)
- aCurrentEventManager->ShiftSelect(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+ aCurrentEventManager->ShiftSelect (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
else
- aCurrentEventManager->Select(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+ aCurrentEventManager->Select (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
}
else
{
- Standard_Integer anUpper = 0;
-
- if(isShiftSelection)
- anUpper = (argc-1)/2;
- else
- anUpper = argc/2;
- TColgp_Array1OfPnt2d aPolyline(1,anUpper);
+ TColgp_Array1OfPnt2d aPolyline (1,aCoordsNb / 2);
- for(Standard_Integer i=1;i<=anUpper;++i)
+ for(Standard_Integer i=1;i<=aCoordsNb / 2;++i)
aPolyline.SetValue(i,gp_Pnt2d(atoi(argv[2*i-1]),atoi(argv[2*i])));
if(isShiftSelection)
{
if(argc != 3)
{
- di << "Usage : " << argv[0] << " x y" << "\n";
+ di << "Usage : " << argv[0] << " x y\n";
return 1;
}
}
if (aMapOfKeysByValues.Find ("CENTER", aValues))
{
- anAISView->SetCenter (aValues->Value(1).IntegerValue(), aValues->Value(2).IntegerValue());
- }
-
- return 0;
-}
-
-//=======================================================================
-//function : VChangeSelected
-//purpose : Adds the shape to selection or remove one from it
-//=======================================================================
-static Standard_Integer VChangeSelected (Draw_Interpretor& di,
- Standard_Integer argc,
- const char ** argv)
-{
- if(argc != 2)
- {
- di<<"Usage : " << argv[0] << " shape \n";
- return 1;
- }
- //get AIS_Shape:
- Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
- TCollection_AsciiString aName(argv[1]);
- Handle(AIS_InteractiveObject) anAISObject;
-
- if(!aMap.IsBound2(aName))
- {
- di<<"Use 'vdisplay' before";
- return 1;
- }
- else
- {
- anAISObject = Handle(AIS_InteractiveObject)::DownCast(aMap.Find2(aName));
- if(anAISObject.IsNull()){
- di<<"No interactive object \n";
- return 1;
- }
-
- if(aContext->HasOpenedContext())
- {
- aContext->AddOrRemoveSelected(anAISObject);
- }
- else
- {
- aContext->AddOrRemoveCurrentObject(anAISObject);
- }
+ anAISView->SetCenter (aValues->Value(1).IntegerValue(), aValues->Value(2).IntegerValue());
}
+
return 0;
}
//=======================================================================
-//function : VZClipping
-//purpose : Gets or sets ZClipping mode, width and depth
+//function : VChangeSelected
+//purpose : Adds the shape to selection or remove one from it
//=======================================================================
-static Standard_Integer VZClipping (Draw_Interpretor& di,
+static Standard_Integer VChangeSelected (Draw_Interpretor& di,
Standard_Integer argc,
const char ** argv)
{
- if(argc>4)
+ if(argc != 2)
{
- di << "Usage : " << argv[0] << " [mode] [depth width]" << "\n"
- <<"mode = OFF|BACK|FRONT|SLICE depth = [0..1] width = [0..1]" << "\n";
- return -1;
+ di<<"Usage : " << argv[0] << " shape \n";
+ return 1;
}
+ //get AIS_Shape:
Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
- if(aContext.IsNull())
+ ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
+ TCollection_AsciiString aName(argv[1]);
+ Handle(AIS_InteractiveObject) anAISObject;
+
+ if(!aMap.IsBound2(aName))
{
- di << "use 'vinit' command before " << argv[0] << "\n";
+ di<<"Use 'vdisplay' before";
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);
+ anAISObject = Handle(AIS_InteractiveObject)::DownCast(aMap.Find2(aName));
+ if(anAISObject.IsNull()){
+ di<<"No interactive object \n";
+ return 1;
}
- 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();
+ aContext->AddOrRemoveSelected(anAISObject);
}
return 0;
}
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;
+ anArgVec.SetValue (anIt, theArgVec[anIt]);
}
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
+ return VClipPlane (theDi, anArgVec.Length(), &anArgVec.ChangeFirst());
+ }
- TCollection_AsciiString aTarget (theArgVec [3]);
- if (aTarget != "object" && aTarget != "view")
+ // change plane command
+ TCollection_AsciiString aPlaneName;
+ Handle(Graphic3d_ClipPlane) aClipPlane;
+ Standard_Integer anArgIter = 0;
+ if (aCommand == "-change"
+ || aCommand == "change")
+ {
+ // old syntax support
+ if (theArgsNb < 3)
{
- theDi << theArgVec[0] << ": invalid target.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- if (aTarget == "object" || aTarget == "view")
+ anArgIter = 3;
+ aPlaneName = theArgVec[2];
+ if (!aRegPlanes.Find (aPlaneName, aClipPlane))
{
- 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();
+ 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";
+ }
- return 0;
+ if (theArgsNb - anArgIter < 1)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
}
- // change plane command
- if (aCommand == "change")
+ for (; anArgIter < theArgsNb; ++anArgIter)
{
- if (theArgsNb < 4)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ const char** aChangeArgs = theArgVec + anArgIter;
+ Standard_Integer aNbChangeArgs = theArgsNb - anArgIter;
+ TCollection_AsciiString aChangeArg (aChangeArgs[0]);
+ aChangeArg.LowerCase();
- TCollection_AsciiString aPlane (theArgVec [2]);
- if (!aRegPlanes.IsBound (aPlane))
+ Standard_Boolean toEnable = Standard_True;
+ if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable))
{
- theDi << theArgVec[0] << ": no such plane.\n";
- return 1;
+ aClipPlane->SetOn (toEnable);
}
+ else if (aChangeArg == "-equation"
+ || aChangeArg == "equation")
+ {
+ if (aNbChangeArgs < 5)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aRegPlanes.Find (aPlane);
-
- TCollection_AsciiString aChangeArg (theArgVec [3]);
- if (aChangeArg != "on" && aChangeArg != "off" && aChangeArg != "capping" && aChangeArg != "equation")
+ 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"
+ || aChangeArg == "capping")
{
- theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
- return 1;
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetCapping (toEnable);
+ anArgIter += 1;
+ }
+ else
+ {
+ // 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 (aChangeArg == "on" || aChangeArg == "off") // on / off
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (aChangeArg == "-useobjecttexture"
+ || aChangeArg == "-useobjecttex"
+ || aChangeArg == "-useobjtexture"
+ || aChangeArg == "-useobjtex")
{
- aClipPlane->SetOn (aChangeArg == "on");
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
+ anArgIter += 1;
+ }
}
- else if (aChangeArg == "equation") // change equation
+ else if (aChangeArg == "-useobjectshader"
+ || aChangeArg == "-useobjshader")
{
- if (theArgsNb < 8)
+ 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;
}
- Standard_Real aCoeffA = Draw::Atof (theArgVec [4]);
- Standard_Real aCoeffB = Draw::Atof (theArgVec [5]);
- Standard_Real aCoeffC = Draw::Atof (theArgVec [6]);
- Standard_Real aCoeffD = Draw::Atof (theArgVec [7]);
- aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectShader (toEnable == Standard_True);
+ anArgIter += 1;
+ }
}
- else if (aChangeArg == "capping") // change capping aspects
+ else if (aChangeArg == "-color"
+ || aChangeArg == "color")
{
- if (theArgsNb < 5)
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ aChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
{
- 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")
+ 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)
{
- theDi << theArgVec[0] << ": invalid arguments. Type help for more information.\n";
+ std::cout << "Syntax error: need more arguments.\n";
return 1;
}
- if (aCappingArg == "on" || aCappingArg == "off") // on / off capping
+ TCollection_AsciiString aTextureName (aChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
{
- aClipPlane->SetCapping (aCappingArg == "on");
+ aClipPlane->SetCappingTexture (NULL);
}
- else if (aCappingArg == "color") // color aspect for capping
+ else
{
- if (theArgsNb < 8)
- {
- 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_Real aRed = Draw::Atof (theArgVec [5]);
- Standard_Real aGrn = Draw::Atof (theArgVec [6]);
- Standard_Real aBlu = Draw::Atof (theArgVec [7]);
+ if (aNbChangeArgs < 3)
+ {
+ 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);
+ 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 == "texname") // texture name
+
+ if (aNbChangeArgs < 3)
{
- if (theArgsNb < 6)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- TCollection_AsciiString aTextureName (theArgVec [5]);
+ Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
- Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
- if (!aTexture->IsDone ())
- {
- aClipPlane->SetCappingTexture (NULL);
- }
- else
- {
- aTexture->EnableModulate();
- aTexture->EnableRepeat();
- aClipPlane->SetCappingTexture (aTexture);
- }
- }
- else if (aCappingArg == "texscale") // texture scale
+ aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ anArgIter += 2;
+ }
+ else if (aChangeArg == "-texrotate"
+ || aChangeArg == "texrotate") // texture rotation
+ {
+ if (aClipPlane->CappingTexture().IsNull())
{
- if (aClipPlane->CappingTexture().IsNull())
- {
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
- }
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
- if (theArgsNb < 7)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
+ if (aNbChangeArgs < 2)
+ {
+ 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]);
+ 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)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
- aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ TCollection_AsciiString aHatchStr (aChangeArgs[1]);
+ aHatchStr.LowerCase();
+ if (aHatchStr == "on")
+ {
+ aClipPlane->SetCappingHatchOn();
+ }
+ else if (aHatchStr == "off")
+ {
+ aClipPlane->SetCappingHatchOff();
}
- else if (aCappingArg == "texorigin") // texture origin
+ 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)
{
- if (aClipPlane->CappingTexture().IsNull())
+ TCollection_AsciiString anEntityName (aChangeArgs[anIt]);
+ if (anEntityName.IsEmpty()
+ || anEntityName.Value (1) == '-')
{
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
+ break;
}
-
- if (theArgsNb < 7)
+ else if (ViewerTest_myViews.IsBound1 (anEntityName))
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
+ Handle(V3d_View) aView = ViewerTest_myViews.Find1 (anEntityName);
+ if (toSet)
+ {
+ aView->AddClipPlane (aClipPlane);
+ }
+ else
+ {
+ aView->RemoveClipPlane (aClipPlane);
+ }
+ continue;
}
-
- Standard_ShortReal aTx = (Standard_ShortReal)atof (theArgVec [5]);
- Standard_ShortReal aTy = (Standard_ShortReal)atof (theArgVec [6]);
-
- aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
- }
- else if (aCappingArg == "texrotate") // texture rotation
- {
- if (aClipPlane->CappingTexture().IsNull())
+ else if (GetMapOfAIS().IsBound2 (anEntityName))
{
- theDi << theArgVec[0] << ": no texture is set.\n";
- return 1;
+ Handle(AIS_InteractiveObject) aIObj = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anEntityName));
+ if (toSet)
+ {
+ aIObj->AddClipPlane (aClipPlane);
+ }
+ else
+ {
+ aIObj->RemoveClipPlane (aClipPlane);
+ }
}
-
- if (theArgsNb < 6)
+ else
{
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
+ std::cout << "Error: object/view '" << anEntityName << "' is not found!\n";
return 1;
}
-
- Standard_ShortReal aRot = (Standard_ShortReal)atof (theArgVec[5]);
-
- aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
}
- else if (aCappingArg == "hatch") // hatch style
- {
- if (theArgsNb < 6)
- {
- theDi << theArgVec[0] << ": need more arguments. Type help for more information.\n";
- return 1;
- }
- TCollection_AsciiString aHatchStr (theArgVec [5]);
- if (aHatchStr == "on")
- {
- aClipPlane->SetCappingHatchOn();
- }
- 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;
aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
continue;
}
- else if (*anArgValue != '-')
+ 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 (aFlag == "0"
+ || aFlag == "off")
+ {
+ if (++anArgIter < theArgNb)
+ {
+ std::cout << "Error: wrong number of arguments!\n";
+ return 1;
+ }
+
+ if (!aCamera.IsNull()
+ && aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
+ }
+ ViewerTest_myDefaultCaps.contextStereo = Standard_False;
+ return 0;
+ }
+ else if (aFlag == "1"
+ || aFlag == "on")
+ {
+ if (++anArgIter < theArgNb)
{
- std::cout << "Error: 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;
}
<< "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
}
theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
+ theDi << "AutoTriangulation: " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
return 0;
}
for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
- TCollection_AsciiString aKey, aValue;
- if (!ViewerTest::SplitParameter (anArg, aKey, aValue)
- || aValue.IsEmpty())
- {
- std::cerr << "Error, wrong syntax at: '" << anArg.ToCString() << "'!\n";
- return 1;
- }
-
- aKey.UpperCase();
- if (aKey == "ABSDEFL"
- || aKey == "ABSOLUTEDEFLECTION"
- || aKey == "DEFL"
- || aKey == "DEFLECTION")
+ anArg.UpperCase();
+ if (anArg == "-ABSDEFL"
+ || anArg == "-ABSOLUTEDEFLECTION"
+ || anArg == "-DEFL"
+ || anArg == "-DEFLECTION")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
- aDefParams->SetMaximalChordialDeviation (aValue.RealValue());
+ aDefParams->SetMaximalChordialDeviation (Draw::Atof (theArgVec[anArgIter]));
}
- else if (aKey == "RELDEFL"
- || aKey == "RELATIVEDEFLECTION"
- || aKey == "DEVCOEFF"
- || aKey == "DEVIATIONCOEFF"
- || aKey == "DEVIATIONCOEFFICIENT")
+ else if (anArg == "-RELDEFL"
+ || anArg == "-RELATIVEDEFLECTION"
+ || anArg == "-DEVCOEFF"
+ || anArg == "-DEVIATIONCOEFF"
+ || anArg == "-DEVIATIONCOEFFICIENT")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
- aDefParams->SetDeviationCoefficient (aValue.RealValue());
+ aDefParams->SetDeviationCoefficient (Draw::Atof (theArgVec[anArgIter]));
}
- else if (aKey == "ANGDEFL"
- || aKey == "ANGULARDEFL"
- || aKey == "ANGULARDEFLECTION")
+ else if (anArg == "-ANGDEFL"
+ || anArg == "-ANGULARDEFL"
+ || anArg == "-ANGULARDEFLECTION")
{
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
// currently HLRDeviationAngle is used instead of DeviationAngle in most places
- aDefParams->SetHLRAngle (M_PI * aValue.RealValue() / 180.0);
+ aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
+ }
+ else if (anArg == "-AUTOTR"
+ || anArg == "-AUTOTRIANG"
+ || anArg == "-AUTOTRIANGULATION")
+ {
+ if (++anArgIter >= theArgsNb)
+ {
+ std::cout << "Error: wrong syntax at " << anArg << "\n";
+ return 1;
+ }
+ TCollection_AsciiString aValue (theArgVec[anArgIter]);
+ aValue.LowerCase();
+ if (aValue == "on"
+ || aValue == "1")
+ {
+ aDefParams->SetAutoTriangulation (Standard_True);
+ }
+ else if (aValue == "off"
+ || aValue == "0")
+ {
+ aDefParams->SetAutoTriangulation (Standard_False);
+ }
}
else
{
{
// 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);
theCommands.Add("vzbufftrihedron",
- "vzbufftrihedron [center|left_lower|left_upper|right_lower|right_upper"
- " textR=255 textG=255 textB=255 scale=0.1 wireframe|zbuffer]"
- " : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron",
- __FILE__,VTestZBuffTrihedron,group);
+ "vzbufftrihedron [{-on|-off}=-on] [-type {wireframe|zbuffer}=zbuffer]"
+ "\n\t\t: [-position center|left_lower|left_upper|right_lower|right_upper]"
+ "\n\t\t: [-scale value=0.1] [-size value=0.8] [-arrowDiam value=0.05]"
+ "\n\t\t: [-colorArrowX color=RED] [-colorArrowY color=GREEN] [-colorArrowZ color=BLUE]"
+ "\n\t\t: [-nbfacets value=12] [-colorLabels color=WHITE]"
+ "\n\t\t: Displays a trihedron",
+ __FILE__,VZBuffTrihedron,group);
theCommands.Add("vrotate",
- "vrotate : vrotate AX AY AZ [X Y Z]",
+ "vrotate [[-mouseStart X Y] [-mouseMove X Y]]|[AX AY AZ [X Y Z]]"
+ "\n : Option -mouseStart starts rotation according to the mouse position"
+ "\n : Option -mouseMove continues rotation with angle computed"
+ "\n : from last and new mouse position."
+ "\n : vrotate AX AY AZ [X Y Z]",
__FILE__,VRotate,group);
theCommands.Add("vzoom",
"vzoom : vzoom coef",
" : notice that EMF format requires patched gl2ps",
__FILE__,VExport,group);
theCommands.Add("vcolorscale",
- "vcolorscale : vcolorscale [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = 2 X = 0 Y = 0]: draw color scale",
+ "vcolorscale : vcolorscale 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"
+ "-hide/erase erase color scale.\n"
+ "Please note that -show/-hide option must be the first argument!\n"
+ "-color Index R G B: set color for indexed interval\n"
+ "-color Index ColorName: set color for indexed interval\n"
+ "-colors R G B R G B ...: set colors for all intervals\n"
+ "-colors ColorName1 ColorName2 ...: set colors for all intervals\n"
+ "-colors supports both color names and rgb values in one call\n"
+ "-label Index Text: set label for indexed interval\n"
+ "-labels Text Text Text ...: set labels for all intervals\n"
+ "-title Title [Position]: set the title for color scale with certain position. Default position = center;\n"
+ "Available text positions: left, right, center, none;\n",
__FILE__,VColorScale,group);
theCommands.Add("vgraduatedtrihedron",
- "vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
+ "vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
+ "\t[-namefont Name] [-valuesfont Name]\n"
+ "\t[-xdrawname on/off] [-ydrawname on/off] [-zdrawname on/off]\n"
+ "\t[-xnameoffset IntVal] [-ynameoffset IntVal] [-znameoffset IntVal]"
+ "\t[-xnamecolor Color] [-ynamecolor Color] [-znamecolor Color]\n"
+ "\t[-xdrawvalues on/off] [-ydrawvalues on/off] [-zdrawvalues on/off]\n"
+ "\t[-xvaluesoffset IntVal] [-yvaluesoffset IntVal] [-zvaluesoffset IntVal]"
+ "\t[-xcolor Color] [-ycolor Color] [-zcolor Color]\n"
+ "\t[-xdrawticks on/off] [-ydrawticks on/off] [-zdrawticks on/off]\n"
+ "\t[-xticks Number] [-yticks Number] [-zticks Number]\n"
+ "\t[-xticklength IntVal] [-yticklength IntVal] [-zticklength IntVal]\n"
+ "\t[-drawgrid on/off] [-drawaxes on/off]\n"
+ " - Displays or erases graduated trihedron"
+ " - xname, yname, zname - names of axes, default: X, Y, Z\n"
+ " - namefont - font of axes names. Default: Arial\n"
+ " - xnameoffset, ynameoffset, znameoffset - offset of name from values or tickmarks or axis. Default: 30\n"
+ " - xnamecolor, ynamecolor, znamecolor - colors of axes names\n"
+ " - xvaluesoffset, yvaluesoffset, zvaluesoffset - offset of values from tickmarks or axis. Default: 10\n"
+ " - valuesfont - font of axes values. Default: Arial\n"
+ " - xcolor, ycolor, zcolor - color of axis and values\n"
+ " - xticks, yticks, xzicks - number of tickmark on axes. Default: 5\n"
+ " - xticklength, yticklength, xzicklength - length of tickmark on axes. Default: 10\n",
__FILE__,VGraduatedTrihedron,group);
- theCommands.Add("vprintview" ,
- "vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
- __FILE__,VPrintView,group);
+ theCommands.Add("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);
" : Mode - rectangular or circular"
" : Type - lines or points",
__FILE__, VGrid, group);
+ theCommands.Add ("vpriviledgedplane",
+ "vpriviledgedplane [Ox Oy Oz Nx Ny Nz [Xx Xy Xz]]"
+ "\n\t\t: Ox, Oy, Oz - plane origin"
+ "\n\t\t: Nx, Ny, Nz - plane normal direction"
+ "\n\t\t: Xx, Xy, Xz - plane x-reference axis direction"
+ "\n\t\t: Sets or prints viewer's priviledged plane geometry.",
+ __FILE__, VPriviledgedPlane, group);
+ theCommands.Add ("vconvert",
+ "vconvert v [Mode={window|view}]"
+ "\n\t\t: vconvert x y [Mode={window|view|grid|ray}]"
+ "\n\t\t: vconvert x y z [Mode={window|grid}]"
+ "\n\t\t: window - convert to window coordinates, pixels"
+ "\n\t\t: view - convert to view projection plane"
+ "\n\t\t: grid - convert to model coordinates, given on grid"
+ "\n\t\t: ray - convert projection ray to model coordiantes"
+ "\n\t\t: - vconvert v window : convert view to window;"
+ "\n\t\t: - vconvert v view : convert window to view;"
+ "\n\t\t: - vconvert x y window : convert view to window;"
+ "\n\t\t: - vconvert x y view : convert window to view;"
+ "\n\t\t: - vconvert x y : convert window to model;"
+ "\n\t\t: - vconvert x y grid : convert window to model using grid;"
+ "\n\t\t: - vconvert x y ray : convert window projection line to model;"
+ "\n\t\t: - vconvert x y z window : convert model to window;"
+ "\n\t\t: - vconvert x y z grid : convert view to model using grid;"
+ "\n\t\t: Converts the given coordinates to window/view/model space.",
+ __FILE__, VConvert, group);
theCommands.Add ("vfps",
"vfps [framesNb=100] : estimate average frame rate for active view",
__FILE__, VFps, group);
theCommands.Add ("vgldebug",
- "vgldebug [{0|1}] : request debug GL context, should be called before vinit\n"
- " : this function is implemented only for Windows\n"
- " : GL_ARB_debug_output extension should be exported by OpenGL driver!",
+ "vgldebug [-sync {0|1}] [-debug {0|1}] [-glslWarn {0|1}]"
+ "\n\t\t: [-extraMsg {0|1}] [{0|1}]"
+ "\n\t\t: Request debug GL context. Should be called BEFORE vinit."
+ "\n\t\t: Debug context can be requested only on Windows"
+ "\n\t\t: with GL_ARB_debug_output extension implemented by GL driver!"
+ "\n\t\t: -sync - request synchronized debug GL context"
+ "\n\t\t: -glslWarn - log GLSL compiler/linker warnings,"
+ "\n\t\t: which are suppressed by default,"
+ "\n\t\t: -extraMsg - log extra diagnostic messages from GL context,"
+ "\n\t\t: which are suppressed by default",
__FILE__, VGlDebug, group);
theCommands.Add ("vvbo",
"vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
__FILE__, VVbo, group);
theCommands.Add ("vstereo",
- "\nvstereo [{0|1}] : turn stereo usage On/Off; affects only newly displayed objects",
+ "vstereo [0|1] [-mode Mode] [-reverse {0|1}]"
+ "\n\t\t: [-anaglyph Filter]"
+ "\n\t\t: Control stereo output mode. Available modes for -mode:"
+ "\n\t\t: quadBuffer - OpenGL QuadBuffer stereo,"
+ "\n\t\t: requires driver support."
+ "\n\t\t: Should be called BEFORE vinit!"
+ "\n\t\t: anaglyph - Anaglyph glasses"
+ "\n\t\t: rowInterlaced - row-interlaced display"
+ "\n\t\t: columnInterlaced - column-interlaced display"
+ "\n\t\t: chessBoard - chess-board output"
+ "\n\t\t: sideBySide - horizontal pair"
+ "\n\t\t: overUnder - vertical pair"
+ "\n\t\t: Available Anaglyph filters for -anaglyph:"
+ "\n\t\t: redCyan, redCyanSimple, yellowBlue, yellowBlueSimple,"
+ "\n\t\t: greenMagentaSimple",
__FILE__, VStereo, group);
theCommands.Add ("vcaps",
"vcaps [-vbo {0|1}] [-sprites {0|1}] [-ffp {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: built-in GLSL programs"
+ "\n\t\t: (requires compatible profile)"
"\n\t\t: VBO - use Vertex Buffer Object (copy vertex"
"\n\t\t: arrays to GPU memory)"
"\n\t\t: sprite - use textured sprites instead of bitmaps"
- "\n\t\t: softMode - use software OpenGL implementation,"
- "\n\t\t: should be set BEFORE viewer creation"
+ "\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."
"diffimage : diffimage imageFile1 imageFile2 toleranceOfColor(0..1) blackWhite(1|0) borderFilter(1|0) [diffImageFile]",
__FILE__, VDiffImage, group);
theCommands.Add ("vselect",
- "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [shift_selection = 0|1]\n"
+ "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [-allowoverlap 0|1] [shift_selection = 0|1]\n"
"- emulates different types of selection:\n"
"- 1) single click selection\n"
"- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
"- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
- "- 4) any of these selections with shift button pressed",
+ "- 4) -allowoverlap 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);
theCommands.Add ("vmoveto",
"vmoveto x y"
"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] [devCoeff=value] [angDefl=value]",
- __FILE__, VDefaults, group);
+ "vdefaults [-absDefl value]"
+ "\n\t\t: [-devCoeff value]"
+ "\n\t\t: [-angDefl value]"
+ "\n\t\t: [-autoTriang {off/on | 0/1}]"
+ , __FILE__, VDefaults, group);
theCommands.Add("vlight",
"tool to manage light sources, without arguments shows list of lights."
"\n Main commands: "
"\n {dir}ection X Y Z (for directional light or for spotlight)"
"\n color colorName"
"\n {head}light 0|1"
+ "\n {sm}oothness value"
+ "\n {int}ensity value"
"\n {constAtten}uation value"
"\n {linearAtten}uation value"
"\n angle angleDeg"
__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.",
"vhighlightselected [0|1] or vhighlightselected [on|off]: enables/disables highlighting of selected objects.\n"
"Without arguments it shows if highlighting of selected objects is enabled now.",
__FILE__,VHighlightSelected,group);
-
-
+ theCommands.Add ("vplace",
+ "vplace dx dy"
+ "\n\t\t: Places the point (in pixels) at the center of the window",
+ __FILE__, VPlace, group);
theCommands.Add("vxrotate",
"vxrotate",
__FILE__,VXRotate,group);
+ 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