// Created on: 1998-09-01
// Created by: Robert COUBLANC
// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2012 OPEN CASCADE SAS
+// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
-// The content of this file is subject to the Open CASCADE Technology Public
-// License Version 6.5 (the "License"). You may not use the content of this file
-// except in compliance with the License. Please obtain a copy of the License
-// at http://www.opencascade.org and read it completely before using this file.
+// This file is part of Open CASCADE Technology software library.
//
-// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
-// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
//
-// The Original Code and all software distributed under the License is
-// distributed on an "AS IS" basis, without warranty of any kind, and the
-// Initial Developer hereby disclaims all such warranties, including without
-// limitation, any warranties of merchantability, fitness for a particular
-// purpose or non-infringement. Please see the License for the specific terms
-// and conditions governing the rights and limitations under the License.
-
-
-// Robert Boehne 30 May 2000 : Dec Osf
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
#ifdef HAVE_CONFIG_H
-# include <config.h>
+ #include <config.h>
#endif
#include <OpenGl_GlCore20.hxx>
#include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.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 <Image_AlienPixMap.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OSD_Timer.hxx>
+#include <TColStd_HSequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <TColStd_HSequenceOfReal.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
+#include <TColStd_MapOfAsciiString.hxx>
#include <Visual3d_LayerItem.hxx>
-#include <V3d_LayerMgr.hxx>
-#include <V3d_LayerMgrPointer.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Image_Diff.hxx>
#include <Aspect_DisplayConnection.hxx>
#endif
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
#include <Cocoa_Window.hxx>
- #include <tk.h>
#else
#include <Xw_Window.hxx>
#include <X11/Xlib.h> /* contains some dangerous #defines such as Status, True etc. */
#include <tk.h>
#endif
-//==============================================================================
+// Auxiliary definitions
+static const char THE_KEY_DELETE = 127;
//==============================================================================
// VIEWER GLOBAL VARIABLES
//==============================================================================
Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
+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,
+ Standard_Integer theArgNb,
+ const char** theArgVec);
+
#if defined(_WIN32)
static Handle(WNT_Window)& VT_GetWindow() {
static Handle(WNT_Window) WNTWin;
int X_ButtonPress = 0; // Last ButtonPress position
int Y_ButtonPress = 0;
Standard_Boolean IsDragged = Standard_False;
-Standard_Boolean DragFirst;
+Standard_Boolean DragFirst = Standard_False;
//==============================================================================
(void)theDisplayName; // avoid warning on unused argument
SetDisplayConnection (new Aspect_DisplayConnection ());
#endif
- aGraphicDriver = new OpenGl_GraphicDriver();
+ aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
- aGraphicDriver->Begin (GetDisplayConnection());
ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
toCreateViewer = Standard_True;
}
}
// Create viewer
- Handle(V3d_Viewer) a3DViewer, a3DCollector;
+ Handle(V3d_Viewer) a3DViewer;
// If it's the single view, we first look for empty context
if (ViewerTest_myViews.IsEmpty() && !ViewerTest_myContexts.IsEmpty())
{
if (anIter.More())
ViewerTest::SetAISContext (anIter.Value());
a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
- a3DCollector= ViewerTest::GetAISContext()->Collector();
}
else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
{
ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
- a3DCollector= ViewerTest::GetAISContext()->Collector();
}
- else if (a3DViewer.IsNull() || a3DCollector.IsNull())
+ else if (a3DViewer.IsNull())
{
toCreateViewer = Standard_True;
TCollection_ExtendedString NameOfWindow("Viewer3D");
a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
NameOfWindow = TCollection_ExtendedString("Collector");
- a3DCollector = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
- a3DCollector->SetDefaultBackgroundColor(Quantity_NOC_STEELBLUE);
}
// AIS context setup
if (ViewerTest::GetAISContext().IsNull() ||
!(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
{
- Handle(AIS_InteractiveContext) aContext =
- new AIS_InteractiveContext(a3DViewer, a3DCollector);
+ Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
ViewerTest::SetAISContext (aContext);
ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
}
else
+ {
ViewerTest::ResetEventManager();
+ }
// Create window
-#if defined(_WIN32) || defined(__WIN32__)
- VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
- Handle(WNT_WClass)::DownCast (WClass()),
- WS_OVERLAPPEDWINDOW,
- aPxLeft, aPxTop,
- aPxWidth, aPxHeight,
- Quantity_NOC_BLACK);
+#if defined(_WIN32)
+ VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
+ Handle(WNT_WClass)::DownCast (WClass()),
+ Draw_VirtualWindows ? WS_POPUPWINDOW : WS_OVERLAPPEDWINDOW,
+ aPxLeft, aPxTop,
+ aPxWidth, aPxHeight,
+ Quantity_NOC_BLACK);
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
- VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
- aPxLeft, aPxTop,
- aPxWidth, aPxHeight);
- ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
+ VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
+ aPxLeft, aPxTop,
+ aPxWidth, aPxHeight);
+ ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
#else
- VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
- aTitle.ToCString(),
- aPxLeft, aPxTop,
- aPxWidth, aPxHeight);
+ VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
+ aTitle.ToCString(),
+ aPxLeft, aPxTop,
+ aPxWidth, aPxHeight);
#endif
VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
a3DViewer->SetLightOn();
}
- #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
+ #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
#if TCL_MAJOR_VERSION < 8
Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
aView.Nullify();
a3DViewer.Nullify();
- a3DCollector.Nullify();
return aViewNames.GetViewName();
}
}
}
-//==============================================================================
-//function : SplitParameter
-//purpose : Split parameter string to parameter name an patameter value
-//==============================================================================
-Standard_Boolean SplitParameter (const TCollection_AsciiString& theString,
- TCollection_AsciiString& theName,
- TCollection_AsciiString& theValue)
-{
- Standard_Integer aParamNameEnd = theString.FirstLocationInSet("=",1, theString.Length());
- if (aParamNameEnd == 0)
- return Standard_False;
- TCollection_AsciiString aString(theString);
- if (aParamNameEnd != 0)
- {
- theValue = aString.Split(aParamNameEnd);
- aString.Split(aString.Length()-1);
- theName = aString;
- }
- return Standard_True;
-}
-
//==============================================================================
//function : Vinit
//purpose : Create the window viewer and initialize all the global variable
-// Use Tk_CreateFileHandler on UNIX to cath the X11 Viewer event
+// Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
//==============================================================================
static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
{
-if (theArgsNb > 9)
+ if (theArgsNb > 9)
{
- theDi << theArgVec[0] << ": incorrect number of command arguments.\n"
- << "Type help for more information.\n";
+ std::cerr << theArgVec[0] << ": incorrect number of command arguments.\n"
+ << "Type help for more information.\n";
return 1;
}
- TCollection_AsciiString aViewName (""),
- aDisplayName ("");
- Standard_Integer aPxLeft = 0,
- aPxTop = 0,
- aPxWidth = 0,
- aPxHeight = 0;
- for (Standard_Integer i = 1; i < theArgsNb; ++i)
+ TCollection_AsciiString aViewName, aDisplayName;
+ Standard_Integer aPxLeft = 0, aPxTop = 0, aPxWidth = 0, aPxHeight = 0;
+ TCollection_AsciiString aName, aValue;
+ for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
{
- TCollection_AsciiString aName = "", aValue = "";
- if(!SplitParameter (TCollection_AsciiString(theArgVec[i]),aName,aValue) && theArgsNb == 2)
+ const TCollection_AsciiString anArg = theArgVec[anArgIt];
+ TCollection_AsciiString anArgCase = anArg;
+ anArgCase.UpperCase();
+ if (ViewerTest::SplitParameter (anArg, aName, aValue))
{
- // In case of syntax: vinit ViewName
- aViewName = theArgVec[1];
- }
- else
- {
- if (aName == "name")
+ aName.UpperCase();
+ if (aName.IsEqual ("NAME"))
{
aViewName = aValue;
}
- else if (aName == "l" || aName == "left")
+ else if (aName.IsEqual ("L")
+ || aName.IsEqual ("LEFT"))
+ {
aPxLeft = aValue.IntegerValue();
- else if (aName == "t" || aName == "top")
+ }
+ else if (aName.IsEqual ("T")
+ || aName.IsEqual ("TOP"))
+ {
aPxTop = aValue.IntegerValue();
-#if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
- else if (aName == "display")
+ }
+ #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
+ else if (aName.IsEqual ("DISP")
+ || aName.IsEqual ("DISPLAY"))
+ {
aDisplayName = aValue;
-#endif
- else if (aName == "w" || aName == "width")
+ }
+ #endif
+ else if (aName.IsEqual ("W")
+ || aName.IsEqual ("WIDTH"))
+ {
aPxWidth = aValue.IntegerValue();
- else if (aName == "h" || aName == "height")
+ }
+ else if (aName.IsEqual ("H")
+ || aName.IsEqual ("HEIGHT"))
+ {
aPxHeight = aValue.IntegerValue();
+ }
else
{
- theDi << theArgVec[0] << ": Warning: unknown parameter " << aName.ToCString() << ".\n";
+ std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
}
}
+ else if (aViewName.IsEmpty())
+ {
+ aViewName = anArg;
+ }
+ else
+ {
+ std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
+ }
}
ViewerTest_Names aViewNames (aViewName);
- if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName ()))
+ if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
{
- TCollection_AsciiString aCommand("vactivate ");
- aCommand = aCommand + aViewNames.GetViewName();
- theDi.Eval(aCommand.ToCString());
+ TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
+ theDi.Eval (aCommand.ToCString());
return 0;
}
TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
aViewName.ToCString(),
aDisplayName.ToCString());
- cout << theArgVec[0] << ": 3D View - " << aViewId << " was created.\n";
+ theDi << aViewId;
return 0;
}
//==============================================================================
//function : VHLR
//purpose : hidden lines removal algorithm
+//draw args: vhlr is_enabled={on|off} [show_hidden={1|0}]
//==============================================================================
static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
return 1;
}
- if (argc != 2)
+ if (argc < 2)
{
di << argv[0] << ": Wrong number of command arguments.\n"
<< "Type help " << argv[0] << " for more information.\n";
return 1;
}
+ // Enable or disable HLR mode.
Standard_Boolean isHLROn =
(!strcasecmp (argv[1], "on")) ? Standard_True : Standard_False;
- if (isHLROn == MyHLRIsOn)
+ if (isHLROn != MyHLRIsOn)
{
- return 0;
+ MyHLRIsOn = isHLROn;
+ ViewerTest::CurrentView()->SetComputedMode (MyHLRIsOn);
}
- MyHLRIsOn = isHLROn;
- ViewerTest::CurrentView()->SetComputedMode (MyHLRIsOn);
+ // Show or hide hidden lines in HLR mode.
+ Standard_Boolean isCurrentShowHidden
+ = ViewerTest::GetAISContext()->DefaultDrawer()->DrawHiddenLine();
+
+ Standard_Boolean isShowHidden =
+ (argc == 3) ? (atoi(argv[2]) == 1 ? Standard_True : Standard_False)
+ : isCurrentShowHidden;
+
+
+ if (isShowHidden != isCurrentShowHidden)
+ {
+ if (isShowHidden)
+ {
+ ViewerTest::GetAISContext()->DefaultDrawer()->EnableDrawHiddenLine();
+ }
+ else
+ {
+ ViewerTest::GetAISContext()->DefaultDrawer()->DisableDrawHiddenLine();
+ }
+
+ // Redisplay shapes.
+ if (MyHLRIsOn)
+ {
+ AIS_ListOfInteractive aListOfShapes;
+ ViewerTest::GetAISContext()->DisplayedObjects (aListOfShapes);
+
+ for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes); anIter.More(); anIter.Next())
+ {
+ Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (anIter.Value());
+ if (aShape.IsNull())
+ {
+ continue;
+ }
+ aShape->Redisplay();
+ }
+ }
+ }
+ ViewerTest::CurrentView()->Update();
return 0;
}
//purpose : Remove the view defined by its name
//==============================================================================
-static int VClose (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+static int VClose (Draw_Interpretor& /*theDi*/,
+ Standard_Integer theArgsNb,
+ const char** theArgVec)
{
- if (theArgsNb < 2)
- {
- theDi << theArgVec[0] << ": incorrect number of command arguments.\n"
- << "Type help " << theArgVec[0] << " for more information.\n";
- return 1;
- }
-
- if (ViewerTest_myViews.IsEmpty())
- {
- theDi << theArgVec[0] <<": there is no views to close.\n";
- return 0;
- }
-
- TCollection_AsciiString anInputString(theArgVec[1]);
-
- // Create list to iterate and remove views from the map of views
NCollection_List<TCollection_AsciiString> aViewList;
- if ( strcasecmp( anInputString.ToCString(), "ALL" ) == 0 )
+ if (theArgsNb > 1)
{
- for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter(ViewerTest_myViews);
- anIter.More(); anIter.Next())
+ TCollection_AsciiString anArg (theArgVec[1]);
+ anArg.UpperCase();
+ if (anArg.IsEqual ("ALL")
+ || anArg.IsEqual ("*"))
+ {
+ for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
+ anIter.More(); anIter.Next())
+ {
+ aViewList.Append (anIter.Key1());
+ }
+ if (aViewList.IsEmpty())
+ {
+ std::cout << "No view to close\n";
+ return 0;
+ }
+ }
+ else
{
- aViewList.Append(anIter.Key1());
+ ViewerTest_Names aViewName (theArgVec[1]);
+ if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
+ {
+ std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
+ return 1;
+ }
+ aViewList.Append (aViewName.GetViewName());
}
}
else
{
- ViewerTest_Names aViewNames(anInputString);
- aViewList.Append(aViewNames.GetViewName());
+ // close active view
+ if (ViewerTest::CurrentView().IsNull())
+ {
+ std::cerr << "No active view!\n";
+ return 1;
+ }
+ aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
}
- Standard_Boolean isContextRemoved = (theArgsNb == 3 && atoi(theArgVec[2])==1) ? Standard_False : Standard_True;
+ Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
anIter.More(); anIter.Next())
{
- ViewerTest::RemoveView(anIter.Value(), isContextRemoved);
+ ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
}
return 0;
const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
// Letter in alphabetic order
- if ( !strcasecmp(buf_ret, "A") ) {
+ if (!strcasecmp (buf_ret, "A"))
+ {
// AXO
aView->SetProj(V3d_XposYnegZpos);
}
- else if ( !strcasecmp(buf_ret, "D") ) {
+ else if (!strcasecmp (buf_ret, "D"))
+ {
// Reset
aView->Reset();
}
- else if ( !strcasecmp(buf_ret, "F") ) {
+ else if (!strcasecmp (buf_ret, "F"))
+ {
// FitAll
if (aNisView.IsNull())
aView->FitAll();
else
aNisView->FitAll3d();
}
- else if ( !strcasecmp(buf_ret, "H") ) {
+ else if (!strcasecmp (buf_ret, "H"))
+ {
// HLR
cout << "HLR" << endl;
aView->SetComputedMode (!aView->ComputedMode());
MyHLRIsOn = aView->ComputedMode();
}
- else if ( !strcasecmp(buf_ret, "P") ) {
+ else if (!strcasecmp (buf_ret, "P"))
+ {
// Type of HLR
Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
if (aContext->DefaultDrawer()->TypeOfHLR() == Prs3d_TOH_Algo)
aContext->UpdateCurrentViewer();
}
- else if ( !strcasecmp(buf_ret, "S") ) {
- // SHADING
- cout << "passage en mode 1 (shading pour les shapes)" << endl;
+ else if (!strcasecmp (buf_ret, "S"))
+ {
+ std::cout << "setup Shaded display mode" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
if(Ctx->NbCurrents()==0 ||
Ctx->UpdateCurrentViewer();
}
}
- else if ( !strcasecmp(buf_ret, "U") ) {
+ else if (!strcasecmp (buf_ret, "U"))
+ {
// Unset display mode
- cout<<"passage au mode par defaut"<<endl;
+ std::cout << "reset display mode to defaults" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
if(Ctx->NbCurrents()==0 ||
}
}
- else if ( !strcasecmp(buf_ret, "T") ) {
+ else if (!strcasecmp (buf_ret, "T"))
+ {
// Top
aView->SetProj(V3d_Zpos);
}
- else if ( !strcasecmp(buf_ret, "B") ) {
+ else if (!strcasecmp (buf_ret, "B"))
+ {
// Bottom
aView->SetProj(V3d_Zneg);
}
- else if ( !strcasecmp(buf_ret, "L") ) {
+ else if (!strcasecmp (buf_ret, "L"))
+ {
// Left
aView->SetProj(V3d_Xneg);
}
- else if ( !strcasecmp(buf_ret, "R") ) {
+ else if (!strcasecmp (buf_ret, "R"))
+ {
// Right
aView->SetProj(V3d_Xpos);
}
-
- else if ( !strcasecmp(buf_ret, "W") ) {
- // WIREFRAME
- cout << "passage en mode 0 (filaire pour les shapes)" << endl;
+ else if (!strcasecmp (buf_ret, "W"))
+ {
+ std::cout << "setup WireFrame display mode" << std::endl;
Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
if(Ctx->NbCurrents()==0 ||
Ctx->NbSelected()==0)
Ctx->UpdateCurrentViewer();
}
}
- else if ( !strcasecmp(buf_ret, "Z") ) {
+ else if (!strcasecmp (buf_ret, "Z"))
+ {
// ZCLIP
-
if ( ZClipIsOn ) {
cout << "ZClipping OFF" << endl;
ZClipIsOn = 0;
aView->Redraw();
}
}
- else if ( !strcasecmp(buf_ret, ",") ) {
+ else if (!strcasecmp (buf_ret, ","))
+ {
ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
-
-
}
- else if ( !strcasecmp(buf_ret, ".") ) {
+ else if (!strcasecmp (buf_ret, "."))
+ {
ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
}
- // Number
- else{
+ 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");
+ }
+ }
+ else
+ {
+ // Number
Standard_Integer Num = Draw::Atoi(buf_ret);
if(Num>=0 && Num<=7)
ViewerTest::StandardModeActivation(Num);
//function : VT_ProcessButton1Press
//purpose : Picking
//==============================================================================
-Standard_Boolean VT_ProcessButton1Press(
- Standard_Integer ,
- const char** argv,
- Standard_Boolean pick,
- Standard_Boolean shift)
+Standard_Boolean VT_ProcessButton1Press (Standard_Integer ,
+ const char** theArgVec,
+ Standard_Boolean theToPick,
+ Standard_Boolean theIsShift)
{
- Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
- if ( pick ) {
+ if (theToPick)
+ {
Standard_Real X, Y, Z;
+ ViewerTest::CurrentView()->Convert (X_Motion, Y_Motion, X, Y, Z);
- ViewerTest::CurrentView()->Convert(X_Motion, Y_Motion, X, Y, Z);
-
- Draw::Set(argv[1], X);
- Draw::Set(argv[2], Y);
- Draw::Set(argv[3], Z);}
+ Draw::Set (theArgVec[1], X);
+ Draw::Set (theArgVec[2], Y);
+ Draw::Set (theArgVec[3], Z);
+ }
- if(shift)
- EM->ShiftSelect();
+ if (theIsShift)
+ {
+ ViewerTest::CurrentEventManager()->ShiftSelect();
+ }
else
- EM->Select();
+ {
+ ViewerTest::CurrentEventManager()->Select();
+ }
- pick = 0;
- return pick;
+ return Standard_False;
}
//==============================================================================
//purpose : Zoom
//==============================================================================
+#if defined(_WIN32) || ! defined(__APPLE__) || defined(MACOSX_USE_GLX)
static void ProcessControlButton1Motion()
{
ViewerTest::CurrentView()->Zoom( X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion);
X_ButtonPress = X_Motion;
Y_ButtonPress = Y_Motion;
}
+#endif
//==============================================================================
//function : VT_ProcessControlButton2Motion
//==============================================================================
void VT_ProcessControlButton2Motion()
{
- Quantity_Length dx = ViewerTest::CurrentView()->Convert(X_Motion - X_ButtonPress);
- Quantity_Length dy = ViewerTest::CurrentView()->Convert(Y_Motion - Y_ButtonPress);
+ Standard_Integer aDx = X_Motion - X_ButtonPress;
+ Standard_Integer aDy = Y_Motion - Y_ButtonPress;
- dy = -dy; // Xwindow Y axis is from top to Bottom
+ aDy = -aDy; // Xwindow Y axis is from top to Bottom
- ViewerTest::CurrentView()->Panning( dx, dy );
+ ViewerTest::CurrentView()->Pan (aDx, aDy);
X_ButtonPress = X_Motion;
Y_ButtonPress = Y_Motion;
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";
}
break;
case WM_LBUTTONUP:
- IsDragged = Standard_False;
- if( !DragFirst )
+ if (!DragFirst)
{
HDC hdc = GetDC( hwnd );
SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
SetROP2( hdc, R2_NOT );
Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
ReleaseDC( hwnd, hdc );
-
- const Handle(ViewerTest_EventManager) EM =
- ViewerTest::CurrentEventManager();
- if ( fwKeys & MK_SHIFT )
- EM->ShiftSelect( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
- max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
- else
- EM->Select( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
- max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
+ VT_ProcessButton1Release (fwKeys & MK_SHIFT);
}
+ IsDragged = Standard_False;
return ViewerWindowProc( hwnd, Msg, wParam, lParam );
case WM_LBUTTONDOWN:
char c[2];
c[0] = (char) wParam;
c[1] = '\0';
+ if (wParam == VK_DELETE)
+ {
+ c[0] = THE_KEY_DELETE;
+ }
VT_ProcessKeyPress (c);
}
break;
//purpose : ZFitall, no DRAW arguments
//Draw arg : No args
//==============================================================================
-
-static int VZFit(Draw_Interpretor& , Standard_Integer , const char** )
+static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
{
- Handle(V3d_View) V = ViewerTest::CurrentView();
- if ( !V.IsNull() ) V->ZFitAll(); return 0; }
+ const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
+
+ if (aCurrentView.IsNull())
+ {
+ std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ return 1;
+ }
+
+ if (theArgsNb == 1)
+ {
+ aCurrentView->ZFitAll();
+ aCurrentView->Redraw();
+ return 0;
+ }
+
+ Standard_Real aScale = 1.0;
+ if (theArgsNb >= 2)
+ {
+ aScale = Draw::Atoi (theArgVec[1]);
+ }
+
+ aCurrentView->ZFitAll (aScale);
+ aCurrentView->Redraw();
+
+ return 0;
+}
-static int VRepaint(Draw_Interpretor& , Standard_Integer , const char** )
+//==============================================================================
+//function : VRepaint
+//purpose :
+//==============================================================================
+static int VRepaint (Draw_Interpretor& , Standard_Integer , const char** )
{
Handle(V3d_View) V = ViewerTest::CurrentView();
if ( !V.IsNull() ) V->Redraw(); return 0;
}
-
//==============================================================================
//function : VClear
//purpose : Remove all the object from the viewer
{
#ifndef WNT
di << "Printing implemented only for wnt!\n";
- return 1;
+ return 0;
#else
Handle(AIS_InteractiveContext) aContextAIS = NULL;
else if (argc < 4)
{
di << "Use: " << argv[0];
- di << " width height filename [print algo=0]\n";
+ di << " width height filename [print algo=0] [tile_width tile_height]\n";
di << "width, height of the intermediate buffer for operation\n";
di << "algo : {0|1}\n";
di << " 0 - stretch algorithm\n";
di << " 1 - tile algorithm\n";
di << "test printing algorithms into an intermediate buffer\n";
+ di << "using specific tile size if provided\n";
di << "with saving output to an image file\n";
return 1;
}
Standard_Integer aHeight = Draw::Atoi (argv[2]);
Standard_Integer aMode = 0;
TCollection_AsciiString aFileName = TCollection_AsciiString (argv[3]);
- if (argc==5)
+ if (argc >= 5)
aMode = Draw::Atoi (argv[4]);
+ Standard_Integer aTileWidth = 0;
+ Standard_Integer aTileHeight = 0;
+ Standard_Boolean isTileSizeProvided = Standard_False;
+ if (argc == 7)
+ {
+ isTileSizeProvided = Standard_True;
+ aTileWidth = Draw::Atoi (argv[5]);
+ aTileHeight = Draw::Atoi (argv[6]);
+ }
+
// check the input parameters
if (aWidth <= 0 || aHeight <= 0)
{
if (aMode == 0)
isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_STRETCH);
else
- isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_TILE);
+ {
+ if (isTileSizeProvided)
+ {
+ 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;
+ }
+ else
+ {
+ isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
+ }
+ }
// succesfully printed into an intermediate buffer
if (isPrinted)
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}, (default=normal)\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;
aTextType = Aspect_TODT_DEKALE;
else if (aDispStr.IsEqual ("blend"))
aTextType = Aspect_TODT_BLEND;
+ else if (aDispStr.IsEqual ("dimension"))
+ aTextType = Aspect_TODT_DIMENSION;
// subtitle color
Quantity_Parameter aSubRed = 1.0;
{
theDI << "VBO: " << (aCaps->vboDisable ? "0" : "1") << "\n";
theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
+ theDI << "SoftMode:" << (aCaps->contextNoAccel ? "1" : "0") << "\n";
return 0;
}
{
aCaps->pntSpritesDisable = anArg.Token ("=", 2).IntegerValue() == 0;
}
+ else if (anArg.Search ("soft=") > -1)
+ {
+ aCaps->contextNoAccel = anArg.Token ("=", 2).IntegerValue() != 0;
+ }
else
{
std::cerr << "Unknown argument: " << anArg << "\n";
{
if (aBufferType == Graphic3d_BT_RGBA)
{
- theDI << Quantity_Color::StringName (aColor.Name()) << " " << anAlpha << "\n";
+ theDI << Quantity_Color::StringName (aColor.Name()) << " " << anAlpha;
}
else
{
- theDI << Quantity_Color::StringName (aColor.Name()) << "\n";
+ theDI << Quantity_Color::StringName (aColor.Name());
}
}
else
{
if (toShowHls)
{
- theDI << aColor.Hue() << " " << aColor.Light() << " " << aColor.Saturation() << "\n";
+ theDI << aColor.Hue() << " " << aColor.Light() << " " << aColor.Saturation();
}
else
{
- theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue() << "\n";
+ theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue();
}
break;
}
case Graphic3d_BT_RGBA:
{
- theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue() << " " << anAlpha << "\n";
+ theDI << aColor.Red() << " " << aColor.Green() << " " << aColor.Blue() << " " << anAlpha;
break;
}
case Graphic3d_BT_Depth:
{
- theDI << aColor.Red() << "\n";
+ theDI << aColor.Red();
break;
}
}
return 0;
}
-//=======================================================================
+//=================================================================================================
//function : VViewParams
//purpose : Gets or sets AIS View characteristics
-//=======================================================================
-static Standard_Integer VViewParams (Draw_Interpretor& di,
- Standard_Integer argc,
- const char ** argv)
+//=================================================================================================
+static int VViewParams (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
{
- if ( argc != 1 && argc != 13)
+ Handle(V3d_View) anAISView = ViewerTest::CurrentView();
+ if (anAISView.IsNull())
{
- di << "Usage : " << argv[0] << "\n";
+ std::cout << theArgVec[0] << ": please initialize or activate view.\n";
return 1;
}
- Handle (V3d_View) anAISView = ViewerTest::CurrentView ();
- if ( anAISView.IsNull () )
+
+ if (theArgsNb == 1)
{
- di << "use 'vinit' command before " << argv[0] << "\n";
- return 1;
- }
- if(argc==1){
- Quantity_Factor anAISViewScale = anAISView -> V3d_View::Scale ();
- Standard_Real anAISViewCenterCoordinateX = 0.0;
- Standard_Real anAISViewCenterCoordinateY = 0.0;
- anAISView -> V3d_View::Center (anAISViewCenterCoordinateX, anAISViewCenterCoordinateY);
+ // print all of the available view parameters
+ Quantity_Factor anAISViewScale = anAISView->Scale();
+
Standard_Real anAISViewProjX = 0.0;
Standard_Real anAISViewProjY = 0.0;
Standard_Real anAISViewProjZ = 0.0;
- anAISView -> V3d_View::Proj (anAISViewProjX, anAISViewProjY, anAISViewProjZ);
+ anAISView->Proj (anAISViewProjX, anAISViewProjY, anAISViewProjZ);
+
Standard_Real anAISViewUpX = 0.0;
Standard_Real anAISViewUpY = 0.0;
Standard_Real anAISViewUpZ = 0.0;
- anAISView -> V3d_View::Up (anAISViewUpX, anAISViewUpY, anAISViewUpZ);
+ anAISView->Up (anAISViewUpX, anAISViewUpY, anAISViewUpZ);
+
Standard_Real anAISViewAtX = 0.0;
Standard_Real anAISViewAtY = 0.0;
Standard_Real anAISViewAtZ = 0.0;
- anAISView -> V3d_View::At (anAISViewAtX, anAISViewAtY, anAISViewAtZ);
- di << "Scale of current view: " << anAISViewScale << "\n";
- di << "Center on X : "<< anAISViewCenterCoordinateX << "; on Y: " << anAISViewCenterCoordinateY << "\n";
- di << "Proj on X : " << anAISViewProjX << "; on Y: " << anAISViewProjY << "; on Z: " << anAISViewProjZ << "\n";
- di << "Up on X : " << anAISViewUpX << "; on Y: " << anAISViewUpY << "; on Z: " << anAISViewUpZ << "\n";
- di << "At on X : " << anAISViewAtX << "; on Y: " << anAISViewAtY << "; on Z: " << anAISViewAtZ << "\n";
+ anAISView->At (anAISViewAtX, anAISViewAtY, anAISViewAtZ);
+
+ Standard_Real anAISViewEyeX = 0.0;
+ Standard_Real anAISViewEyeY = 0.0;
+ Standard_Real anAISViewEyeZ = 0.0;
+ anAISView->Eye (anAISViewEyeX, anAISViewEyeY, anAISViewEyeZ);
+
+ theDi << "Scale of current view: " << anAISViewScale << "\n";
+ theDi << "Proj on X : " << anAISViewProjX << "; on Y: " << anAISViewProjY << "; on Z: " << anAISViewProjZ << "\n";
+ theDi << "Up on X : " << anAISViewUpX << "; on Y: " << anAISViewUpY << "; on Z: " << anAISViewUpZ << "\n";
+ theDi << "At on X : " << anAISViewAtX << "; on Y: " << anAISViewAtY << "; on Z: " << anAISViewAtZ << "\n";
+ theDi << "Eye on X : " << anAISViewEyeX << "; on Y: " << anAISViewEyeY << "; on Z: " << anAISViewEyeZ << "\n";
+ return 0;
}
- else
+
+ // -------------------------
+ // Parse options and values
+ // -------------------------
+
+ NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfKeysByValues;
+ TCollection_AsciiString aParseKey;
+ for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
+ {
+ TCollection_AsciiString anArg (theArgVec [anArgIt]);
+
+ if (anArg.Value (1) == '-' && !anArg.IsRealValue())
+ {
+ aParseKey = anArg;
+ aParseKey.Remove (1);
+ aParseKey.UpperCase();
+ aMapOfKeysByValues.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
+ continue;
+ }
+
+ if (aParseKey.IsEmpty())
+ {
+ std::cout << theArgVec[0] << ": values should be passed with key.\n";
+ std::cout << "Type help for more information.\n";
+ return 1;
+ }
+
+ aMapOfKeysByValues(aParseKey)->Append (anArg);
+ }
+
+ // ---------------------------------------------
+ // Change or print parameters, order plays role
+ // ---------------------------------------------
+
+ // Check arguments for validity
+ NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfKeysByValues);
+ for (; aMapIt.More(); aMapIt.Next())
+ {
+ const TCollection_AsciiString& aKey = aMapIt.Key();
+ const Handle(TColStd_HSequenceOfAsciiString)& aValues = aMapIt.Value();
+
+ if (!(aKey.IsEqual ("SCALE") && (aValues->Length() == 1 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("SIZE") && (aValues->Length() == 1 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("EYE") && (aValues->Length() == 3 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("AT") && (aValues->Length() == 3 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("UP") && (aValues->Length() == 3 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("PROJ") && (aValues->Length() == 3 || aValues->IsEmpty()))
+ && !(aKey.IsEqual ("CENTER") && aValues->Length() == 2))
+ {
+ TCollection_AsciiString aLowerKey;
+ aLowerKey = "-";
+ aLowerKey += aKey;
+ aLowerKey.LowerCase();
+ std::cout << theArgVec[0] << ": " << aLowerKey << " is unknown option, or number of arguments is invalid.\n";
+ std::cout << "Type help for more information.\n";
+ return 1;
+ }
+ }
+
+ Handle(TColStd_HSequenceOfAsciiString) aValues;
+
+ // Change view parameters in proper order
+ if (aMapOfKeysByValues.Find ("SCALE", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ theDi << "Scale: " << anAISView->Scale() << "\n";
+ }
+ else
+ {
+ anAISView->SetScale (aValues->Value(1).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("SIZE", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ Standard_Real aSizeX = 0.0;
+ Standard_Real aSizeY = 0.0;
+ anAISView->Size (aSizeX, aSizeY);
+ theDi << "Size X: " << aSizeX << " Y: " << aSizeY << "\n";
+ }
+ else
+ {
+ anAISView->SetSize (aValues->Value(1).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("EYE", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ Standard_Real anEyeX = 0.0;
+ Standard_Real anEyeY = 0.0;
+ Standard_Real anEyeZ = 0.0;
+ anAISView->Eye (anEyeX, anEyeY, anEyeZ);
+ theDi << "Eye X: " << anEyeX << " Y: " << anEyeY << " Z: " << anEyeZ << "\n";
+ }
+ else
+ {
+ anAISView->SetEye (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("AT", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ Standard_Real anAtX = 0.0;
+ Standard_Real anAtY = 0.0;
+ Standard_Real anAtZ = 0.0;
+ anAISView->At (anAtX, anAtY, anAtZ);
+ theDi << "At X: " << anAtX << " Y: " << anAtY << " Z: " << anAtZ << "\n";
+ }
+ else
+ {
+ anAISView->SetAt (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("PROJ", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ Standard_Real aProjX = 0.0;
+ Standard_Real aProjY = 0.0;
+ Standard_Real aProjZ = 0.0;
+ anAISView->Proj (aProjX, aProjY, aProjZ);
+ theDi << "Proj X: " << aProjX << " Y: " << aProjY << " Z: " << aProjZ << "\n";
+ }
+ else
+ {
+ anAISView->SetProj (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("UP", aValues))
+ {
+ if (aValues->IsEmpty())
+ {
+ Standard_Real anUpX = 0.0;
+ Standard_Real anUpY = 0.0;
+ Standard_Real anUpZ = 0.0;
+ anAISView->Up (anUpX, anUpY, anUpZ);
+ theDi << "Up X: " << anUpX << " Y: " << anUpY << " Z: " << anUpZ << "\n";
+ }
+ else
+ {
+ anAISView->SetUp (aValues->Value(1).RealValue(), aValues->Value(2).RealValue(), aValues->Value(3).RealValue());
+ }
+ }
+ if (aMapOfKeysByValues.Find ("CENTER", aValues))
{
- Quantity_Factor anAISViewScale = atof (argv [1]);
- Standard_Real anAISViewCenterCoordinateX = atof (argv [2]);
- Standard_Real anAISViewCenterCoordinateY = atof (argv [3]);
- Standard_Real anAISViewProjX = atof (argv [4]);
- Standard_Real anAISViewProjY = atof (argv [5]);
- Standard_Real anAISViewProjZ = atof (argv [6]);
- Standard_Real anAISViewUpX = atof (argv [7]);
- Standard_Real anAISViewUpY = atof (argv [8]);
- Standard_Real anAISViewUpZ = atof (argv [9]);
- Standard_Real anAISViewAtX = atof (argv [10]);
- Standard_Real anAISViewAtY = atof (argv [11]);
- Standard_Real anAISViewAtZ = atof (argv [12]);
- anAISView -> V3d_View::SetScale (anAISViewScale);
- anAISView -> V3d_View::SetCenter (anAISViewCenterCoordinateX, anAISViewCenterCoordinateY);
- anAISView -> V3d_View::SetAt (anAISViewAtX, anAISViewAtY, anAISViewAtZ);
- anAISView -> V3d_View::SetProj (anAISViewProjX, anAISViewProjY, anAISViewProjZ);
- anAISView -> V3d_View::SetUp (anAISViewUpX, anAISViewUpY, anAISViewUpZ);
+ anAISView->SetCenter (aValues->Value(1).IntegerValue(), aValues->Value(2).IntegerValue());
}
+
return 0;
}
Standard_Integer argc,
const char ** argv)
{
- if (argc > 2)
+ if (argc > 1)
{
- di << "Usage : " << argv[0] << " [CollectorToo = 0|1]" << "\n";
+ di << "Usage : " << argv[0] << "\n";
return 1;
}
- Standard_Boolean isCollectorToo = Standard_False;
- if (argc == 2)
- {
- isCollectorToo = (atoi(argv [1]) != 0);
- }
Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
if (aContext.IsNull())
{
return 1;
}
aContext->CloseAllContexts(Standard_False);
- di << aContext->PurgeDisplay(isCollectorToo) << "\n";
+ di << aContext->PurgeDisplay() << "\n";
return 0;
}
return 0;
}
+//===============================================================================================
+//function : VZRange
+//purpose :
+//===============================================================================================
+static int VZRange (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+{
+ const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
+
+ if (aCurrentView.IsNull())
+ {
+ std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ return 1;
+ }
+
+ Handle(Graphic3d_Camera) aCamera = aCurrentView->Camera();
+
+ if (theArgsNb < 2)
+ {
+ theDi << "ZNear: " << aCamera->ZNear() << "\n";
+ theDi << "ZFar: " << aCamera->ZFar() << "\n";
+ return 0;
+ }
+
+ if (theArgsNb == 3)
+ {
+ Standard_Real aNewZNear = atof (theArgVec[1]);
+ Standard_Real aNewZFar = atof (theArgVec[2]);
+
+ if (aNewZNear >= aNewZFar)
+ {
+ std::cout << theArgVec[0] << ": invalid arguments: znear should be less than zfar.\n";
+ return 1;
+ }
+
+ if (!aCamera->IsOrthographic() && (aNewZNear <= 0.0 || aNewZFar <= 0.0))
+ {
+ std::cout << theArgVec[0] << ": invalid arguments: ";
+ std::cout << "znear, zfar should be positive for perspective camera.\n";
+ return 1;
+ }
+
+ aCamera->SetZRange (aNewZNear, aNewZFar);
+ }
+ else
+ {
+ std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ return 1;
+ }
+
+ aCurrentView->Redraw();
+
+ return 0;
+}
+
+//===============================================================================================
+//function : VAutoZFit
+//purpose :
+//===============================================================================================
+static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+{
+ const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
+
+ if (aCurrentView.IsNull())
+ {
+ std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
+ return 1;
+ }
+
+ Standard_Real aScale = aCurrentView->AutoZFitScaleFactor();
+
+ if (theArgsNb > 3)
+ {
+ std::cout << theArgVec[0] << ": wrong command arguments. Type help for more information.\n";
+ return 1;
+ }
+
+ if (theArgsNb < 2)
+ {
+ theDi << "Auto z-fit mode: " << "\n"
+ << "On: " << (aCurrentView->AutoZFitMode() ? "enabled" : "disabled") << "\n"
+ << "Scale: " << aScale << "\n";
+ return 0;
+ }
+
+ Standard_Boolean isOn = Draw::Atoi (theArgVec[1]) == 1;
+
+ if (theArgsNb >= 3)
+ {
+ aScale = Draw::Atoi (theArgVec[2]);
+ }
+
+ aCurrentView->SetAutoZFitMode (isOn, aScale);
+ aCurrentView->AutoZFit();
+ aCurrentView->Redraw();
+
+ return 0;
+}
+
+//===============================================================================================
+//function : VChangeCamera
+//purpose :
+//===============================================================================================
+static int VChangeCamera (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+{
+ if (ViewerTest::CurrentView().IsNull())
+ {
+ theDi << theArgVec[0] << ": Call vinit before this command, please.\n";
+ return 1;
+ }
+
+ const char anErrorMessage[] = ": wrong command arguments. Type help for more information.\n";
+ if (theArgsNb < 3)
+ {
+ theDi << theArgVec[0] << anErrorMessage;
+ return 1;
+ }
+
+ Handle(Graphic3d_Camera) aCamera = ViewerTest::CurrentView()->Camera();
+
+ TCollection_AsciiString aCommand (theArgVec[1]);
+ TCollection_AsciiString aValue (theArgVec[2]);
+
+ aCommand.LowerCase();
+ aValue.LowerCase();
+
+ if (aCommand == "proj")
+ {
+ if (aValue == "ortho")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
+ }
+ else if (aValue == "persp")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
+ }
+ else if (aValue == "left")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
+ }
+ else if (aValue == "right")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
+ }
+ else if (aValue == "stereo")
+ {
+ aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+ }
+ else
+ {
+ theDi << theArgVec[0] << anErrorMessage;
+ return 1;
+ }
+ }
+ else if (aCommand == "dist")
+ {
+ aCamera->SetDistance (aValue.RealValue());
+ }
+ else if (aCommand == "iod")
+ {
+ aCamera->SetIOD (aCamera->GetIODType(), aValue.RealValue());
+ }
+ else if (aCommand == "zfocus")
+ {
+ aCamera->SetZFocus (aCamera->ZFocusType(), aValue.RealValue());
+ }
+ else if (aCommand == "fov")
+ {
+ aCamera->SetFOVy (aValue.RealValue());
+ }
+ else if (aCommand == "zfocustype")
+ {
+ if (aValue == "absolute")
+ {
+ aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
+ }
+ else if (aValue == "relative")
+ {
+ aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
+ }
+ else
+ {
+ theDi << theArgVec[0] << anErrorMessage;
+ return 1;
+ }
+ }
+ else if (aCommand == "iodtype")
+ {
+ if (aValue == "absolute")
+ {
+ aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
+ }
+ else if (aValue == "relative")
+ {
+ aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
+ }
+ else
+ {
+ theDi << theArgVec[0] << anErrorMessage;
+ return 1;
+ }
+ }
+ else
+ {
+ theDi << theArgVec[0] << anErrorMessage;
+ return 1;
+ }
+
+ ViewerTest::CurrentView()->AutoZFit();
+ ViewerTest::CurrentView()->Redraw();
+
+ return 0;
+}
+
+//==============================================================================
+//function : VStereo
+//purpose :
+//==============================================================================
+
+static int VStereo (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ if (theArgNb < 2)
+ {
+ 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;
+ }
+
+ ViewerTest_myDefaultCaps.contextStereo = Draw::Atoi (theArgVec[1]) != 0;
+ return 0;
+}
+
+//===============================================================================================
+//function : VDefaults
+//purpose :
+//===============================================================================================
+static int VDefaults (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;
+ }
+
+ Handle(Prs3d_Drawer) aDefParams = aCtx->DefaultDrawer();
+ if (theArgsNb < 2)
+ {
+ if (aDefParams->TypeOfDeflection() == Aspect_TOD_RELATIVE)
+ {
+ theDi << "DeflType: relative\n"
+ << "DeviationCoeff: " << aDefParams->DeviationCoefficient() << "\n";
+ }
+ else
+ {
+ theDi << "DeflType: absolute\n"
+ << "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
+ }
+ theDi << "AngularDeflection: " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\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")
+ {
+ aDefParams->SetTypeOfDeflection (Aspect_TOD_ABSOLUTE);
+ aDefParams->SetMaximalChordialDeviation (aValue.RealValue());
+ }
+ else if (aKey == "RELDEFL"
+ || aKey == "RELATIVEDEFLECTION"
+ || aKey == "DEVCOEFF"
+ || aKey == "DEVIATIONCOEFF"
+ || aKey == "DEVIATIONCOEFFICIENT")
+ {
+ aDefParams->SetTypeOfDeflection (Aspect_TOD_RELATIVE);
+ aDefParams->SetDeviationCoefficient (aValue.RealValue());
+ }
+ else if (aKey == "ANGDEFL"
+ || aKey == "ANGULARDEFL"
+ || aKey == "ANGULARDEFLECTION")
+ {
+ // currently HLRDeviationAngle is used instead of DeviationAngle in most places
+ aDefParams->SetHLRAngle (M_PI * aValue.RealValue() / 180.0);
+ }
+ else
+ {
+ std::cerr << "Warning, unknown argument '" << anArg.ToCString() << "'\n";
+ }
+ }
+
+ return 0;
+}
+
+//! Auxiliary method
+inline void addLight (const Handle(V3d_Light)& theLightNew,
+ const Standard_Boolean theIsGlobal)
+{
+ if (theLightNew.IsNull())
+ {
+ return;
+ }
+
+ if (theIsGlobal)
+ {
+ ViewerTest::GetViewerFromContext()->SetLightOn (theLightNew);
+ }
+ else
+ {
+ ViewerTest::CurrentView()->SetLightOn (theLightNew);
+ }
+}
+
+//! Auxiliary method
+inline Standard_Integer getLightId (const TCollection_AsciiString& theArgNext)
+{
+ TCollection_AsciiString anArgNextCase (theArgNext);
+ anArgNextCase.UpperCase();
+ if (anArgNextCase.Length() > 5
+ && anArgNextCase.SubString (1, 5).IsEqual ("LIGHT"))
+ {
+ return theArgNext.SubString (6, theArgNext.Length()).IntegerValue();
+ }
+ else
+ {
+ return theArgNext.IntegerValue();
+ }
+}
+
+//===============================================================================================
+//function : VLight
+//purpose :
+//===============================================================================================
+static int VLight (Draw_Interpretor& theDi,
+ Standard_Integer theArgsNb,
+ const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+ if (aView.IsNull()
+ || aViewer.IsNull())
+ {
+ std::cerr << "No active viewer!\n";
+ return 1;
+ }
+
+ Standard_Real anXYZ[3];
+ Quantity_Coefficient anAtten[2];
+ if (theArgsNb < 2)
+ {
+ // print lights info
+ Standard_Integer aLightId = 0;
+ for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightId)
+ {
+ Handle(V3d_Light) aLight = aView->ActiveLight();
+ const Quantity_Color aColor = aLight->Color();
+ theDi << "Light" << aLightId << "\n";
+ switch (aLight->Type())
+ {
+ case V3d_AMBIENT:
+ {
+ theDi << " Type: Ambient\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";
+ if (!aLightDir.IsNull())
+ {
+ aLightDir->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
+ 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";
+ }
+ break;
+ }
+ case V3d_POSITIONAL:
+ {
+ Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight)::DownCast (aLight);
+ theDi << " Type: Positional\n";
+ theDi << " Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
+ theDi << " Position: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+ aLightPos->Attenuation (anAtten[0], anAtten[1]);
+ 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";
+ if (!aLightSpot.IsNull())
+ {
+ aLightSpot->Position (anXYZ[0], anXYZ[1], anXYZ[2]);
+ 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";
+ 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";
+ }
+ break;
+ }
+ default:
+ {
+ theDi << " Type: UNKNOWN\n";
+ break;
+ }
+ }
+ theDi << " Color: " << aColor.Red() << ", " << aColor.Green() << ", " << aColor.Blue() << "\n";
+ }
+ }
+
+ Handle(V3d_Light) aLightNew;
+ Handle(V3d_Light) aLightOld;
+ Standard_Boolean isGlobal = Standard_True;
+ Standard_Boolean toCreate = Standard_False;
+ for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
+ {
+ Handle(V3d_Light) aLightCurr = aLightNew.IsNull() ? aLightOld : aLightNew;
+ Handle(V3d_AmbientLight) aLightAmb = Handle(V3d_AmbientLight) ::DownCast (aLightCurr);
+ Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLightCurr);
+ Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight) ::DownCast (aLightCurr);
+ Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight) ::DownCast (aLightCurr);
+
+ TCollection_AsciiString aName, aValue;
+ const TCollection_AsciiString anArg (theArgVec[anArgIt]);
+ TCollection_AsciiString anArgCase (anArg);
+ anArgCase.UpperCase();
+ if (anArgCase.IsEqual ("NEW")
+ || anArgCase.IsEqual ("ADD")
+ || anArgCase.IsEqual ("CREATE"))
+ {
+ toCreate = Standard_True;
+ }
+ else if (anArgCase.IsEqual ("GLOB")
+ || anArgCase.IsEqual ("GLOBAL"))
+ {
+ isGlobal = Standard_True;
+ }
+ else if (anArgCase.IsEqual ("LOC")
+ || anArgCase.IsEqual ("LOCAL"))
+ {
+ isGlobal = Standard_False;
+ }
+ else if (anArgCase.IsEqual ("DEF")
+ || anArgCase.IsEqual ("DEFAULTS"))
+ {
+ toCreate = Standard_False;
+ aViewer->SetDefaultLights();
+ }
+ else if (anArgCase.IsEqual ("CLR")
+ || anArgCase.IsEqual ("CLEAR"))
+ {
+ toCreate = Standard_False;
+ aView->InitActiveLights();
+ while (aView->MoreActiveLights())
+ {
+ aViewer->DelLight (aView->ActiveLight());
+ aView->InitActiveLights();
+ }
+ }
+ else if (anArgCase.IsEqual ("AMB")
+ || anArgCase.IsEqual ("AMBIENT")
+ || anArgCase.IsEqual ("AMBLIGHT"))
+ {
+ addLight (aLightNew, isGlobal);
+ if (!toCreate)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ toCreate = Standard_False;
+ aLightNew = new V3d_AmbientLight (aViewer);
+ }
+ else if (anArgCase.IsEqual ("DIRECTIONAL")
+ || anArgCase.IsEqual ("DIRLIGHT"))
+ {
+ addLight (aLightNew, isGlobal);
+ if (!toCreate)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ toCreate = Standard_False;
+ aLightNew = new V3d_DirectionalLight (aViewer);
+ }
+ else if (anArgCase.IsEqual ("SPOT")
+ || anArgCase.IsEqual ("SPOTLIGHT"))
+ {
+ addLight (aLightNew, isGlobal);
+ if (!toCreate)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ toCreate = Standard_False;
+ aLightNew = new V3d_SpotLight (aViewer, 0.0, 0.0, 0.0);
+ }
+ else if (anArgCase.IsEqual ("POSLIGHT")
+ || anArgCase.IsEqual ("POSITIONAL"))
+ {
+ addLight (aLightNew, isGlobal);
+ if (!toCreate)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ toCreate = Standard_False;
+ aLightNew = new V3d_PositionalLight (aViewer, 0.0, 0.0, 0.0);
+ }
+ else if (anArgCase.IsEqual ("CHANGE"))
+ {
+ addLight (aLightNew, isGlobal);
+ aLightNew.Nullify();
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ const Standard_Integer aLightId = getLightId (theArgVec[anArgIt]);
+ Standard_Integer aLightIt = 0;
+ for (aView->InitActiveLights(); aView->MoreActiveLights(); aView->NextActiveLights(), ++aLightIt)
+ {
+ if (aLightIt == aLightId)
+ {
+ aLightOld = aView->ActiveLight();
+ break;
+ }
+ }
+
+ if (aLightOld.IsNull())
+ {
+ std::cerr << "Light " << theArgVec[anArgIt] << " is undefined!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("DEL")
+ || anArgCase.IsEqual ("DELETE"))
+ {
+ Handle(V3d_Light) aLightDel;
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ 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)
+ {
+ aLightDel = aView->ActiveLight();
+ if (aLightIt == aLightDelId)
+ {
+ break;
+ }
+ }
+ if (!aLightDel.IsNull())
+ {
+ aViewer->DelLight (aLightDel);
+ }
+ }
+ else if (anArgCase.IsEqual ("COLOR")
+ || anArgCase.IsEqual ("COLOUR"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ TCollection_AsciiString anArgNext (theArgVec[anArgIt]);
+ anArgNext.UpperCase();
+ const Quantity_Color aColor = ViewerTest::GetColorFromName (anArgNext.ToCString());
+ if (!aLightCurr.IsNull())
+ {
+ aLightCurr->SetColor (aColor);
+ }
+ }
+ else if (anArgCase.IsEqual ("POS")
+ || anArgCase.IsEqual ("POSITION"))
+ {
+ if ((anArgIt + 3) >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ anXYZ[0] = Atof (theArgVec[++anArgIt]);
+ anXYZ[1] = Atof (theArgVec[++anArgIt]);
+ anXYZ[2] = Atof (theArgVec[++anArgIt]);
+ if (!aLightDir.IsNull())
+ {
+ aLightDir->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightPos.IsNull())
+ {
+ aLightPos->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetPosition (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("DIR")
+ || anArgCase.IsEqual ("DIRECTION"))
+ {
+ if ((anArgIt + 3) >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ anXYZ[0] = Atof (theArgVec[++anArgIt]);
+ anXYZ[1] = Atof (theArgVec[++anArgIt]);
+ anXYZ[2] = Atof (theArgVec[++anArgIt]);
+ if (!aLightDir.IsNull())
+ {
+ aLightDir->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetDirection (anXYZ[0], anXYZ[1], anXYZ[2]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("ANG")
+ || anArgCase.IsEqual ("ANGLE"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ Standard_Real anAngle = Atof (theArgVec[anArgIt]);
+
+ if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetAngle (anAngle / 180.0 * M_PI);
+ }
+ }
+ else if (anArgCase.IsEqual ("CONSTATTEN")
+ || anArgCase.IsEqual ("CONSTATTENUATION"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[0] = Atof (theArgVec[anArgIt]);
+ aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[0] = Atof (theArgVec[anArgIt]);
+ aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("LINATTEN")
+ || anArgCase.IsEqual ("LINEARATTEN")
+ || anArgCase.IsEqual ("LINEARATTENUATION"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightPos.IsNull())
+ {
+ aLightPos->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[1] = Atof (theArgVec[anArgIt]);
+ aLightPos->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else if (!aLightSpot.IsNull())
+ {
+ aLightSpot->Attenuation (anAtten[0], anAtten[1]);
+ anAtten[1] = Atof (theArgVec[anArgIt]);
+ aLightSpot->SetAttenuation (anAtten[0], anAtten[1]);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("EXP")
+ || anArgCase.IsEqual ("EXPONENT")
+ || anArgCase.IsEqual ("SPOTEXP")
+ || anArgCase.IsEqual ("SPOTEXPONENT"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (!aLightSpot.IsNull())
+ {
+ aLightSpot->SetConcentration (Atof (theArgVec[anArgIt]));
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else if (anArgCase.IsEqual ("HEAD")
+ || anArgCase.IsEqual ("HEADLIGHT"))
+ {
+ if (++anArgIt >= theArgsNb)
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+
+ if (aLightAmb.IsNull()
+ && !aLightCurr.IsNull())
+ {
+ aLightCurr->SetHeadlight (Draw::Atoi (theArgVec[anArgIt]) != 0);
+ }
+ else
+ {
+ std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+ return 1;
+ }
+ }
+ else
+ {
+ std::cerr << "Warning: unknown argument '" << anArg << "'\n";
+ }
+ }
+
+ addLight (aLightNew, isGlobal);
+ aViewer->UpdateLights();
+
+ return 0;
+}
+
+//=======================================================================
+//function : VRaytrace
+//purpose : Enables/disables OpenCL-based ray-tracing
+//=======================================================================
+
+static Standard_Integer VRaytrace (Draw_Interpretor& ,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << "Use 'vinit' command before " << theArgVec[0] << "\n";
+ return 1;
+ }
+
+ if (theArgNb < 2
+ || Draw::Atoi (theArgVec[1]))
+ {
+ aView->SetRaytracingMode();
+ }
+ else
+ {
+ aView->SetRasterizationMode();
+ }
+ aView->Redraw();
+ return 0;
+}
+
+//=======================================================================
+//function : VSetRaytraceMode
+//purpose : Enables/disables features of OpenCL-based ray-tracing
+//=======================================================================
+
+static Standard_Integer VSetRaytraceMode (Draw_Interpretor&,
+ Standard_Integer theArgNb,
+ const char ** theArgVec)
+{
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
+ {
+ std::cerr << "Use 'vinit' command before " << theArgVec[0] << "\n";
+ return 1;
+ }
+ else if (theArgNb < 2)
+ {
+ std::cerr << "Usage : " << theArgVec[0] << " [shad=0|1] [refl=0|1] [aa=0|1]\n";
+ return 1;
+ }
+
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ const TCollection_AsciiString anArg (theArgVec[anArgIter]);
+
+ if (anArg.Search ("shad=") > -1)
+ {
+ if (anArg.Token ("=", 2).IntegerValue() != 0)
+ aView->EnableRaytracedShadows();
+ else
+ aView->DisableRaytracedShadows();
+ }
+ else if (anArg.Search ("refl=") > -1)
+ {
+ if (anArg.Token ("=", 2).IntegerValue() != 0)
+ aView->EnableRaytracedReflections();
+ else
+ aView->DisableRaytracedReflections();
+ }
+ else if (anArg.Search ("aa=") > -1)
+ {
+ if (anArg.Token ("=", 2).IntegerValue() != 0)
+ aView->EnableRaytracedAntialiasing();
+ else
+ aView->DisableRaytracedAntialiasing();
+ }
+ else
+ {
+ std::cerr << "Unknown argument: " << anArg << "\n";
+ }
+ }
+
+ aView->Redraw();
+ return 0;
+}
+
//=======================================================================
//function : ViewerCommands
//purpose :
"Additional commands for operations with views: vclose, vactivate, vviewlist.\n",
__FILE__,VInit,group);
theCommands.Add("vclose" ,
- "view_id [keep_context=0|1]\n"
+ "[view_id [keep_context=0|1]]\n"
"or vclose ALL - to remove all created views\n"
" - removes view(viewer window) defined by its view_id.\n"
" - keep_context: by default 0; if 1 and the last view is deleted"
theCommands.Add("vfit" ,
"vfit or <F> : vfit",
__FILE__,VFit,group);
- theCommands.Add("vzfit" ,
- "vzfit",
- __FILE__,VZFit,group);
+ theCommands.Add ("vzfit", "vzfit [scale]\n"
+ " Matches Z near, Z far view volume planes to the displayed objects.\n"
+ " \"scale\" - specifies factor to scale computed z range.\n",
+ __FILE__, VZFit, group);
theCommands.Add("vrepaint",
"vrepaint : vrepaint, force redraw",
__FILE__,VRepaint,group);
"vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
__FILE__,VGraduatedTrihedron,group);
theCommands.Add("vprintview" ,
- "vprintview : width height filename [algo=0] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
+ "vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
__FILE__,VPrintView,group);
theCommands.Add("vzlayer",
"vzlayer : add/del/get [id] : Z layer operations in v3d viewer: add new z layer, delete z layer, get z layer ids",
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",
+ __FILE__, VStereo, group);
theCommands.Add ("vcaps",
- "vcaps [vbo={0|1}] [sprites={0|1}] : modify particular graphic driver options",
+ "vcaps [vbo={0|1}] [sprites={0|1}] [soft={0|1}] : modify particular graphic driver options",
__FILE__, VCaps, group);
theCommands.Add ("vmemgpu",
"vmemgpu [f]: print system-dependent GPU memory information if available;"
"vmoveto x y"
"- emulates cursor movement to pixel postion (x,y)",
__FILE__, VMoveTo, group);
- theCommands.Add("vviewparams",
- "vviewparams [scale center_X center_Y proj_X proj_Y proj_Z up_X up_Y up_Z at_X at_Y at_Z]"
- "- gets or sets current view characteristics",
- __FILE__,VViewParams, group);
+ theCommands.Add ("vviewparams", "vviewparams usage:\n"
+ "- vviewparams\n"
+ "- vviewparams [-scale [s]] [-eye [x y z]] [-at [x y z]] [-up [x y z]]\n"
+ " [-proj [x y z]] [-center x y] [-size sx]\n"
+ "- Gets or sets current view parameters.\n"
+ "- If called without arguments, all view parameters are printed.\n"
+ "- The options are:\n"
+ " -scale [s] : prints or sets viewport relative scale.\n"
+ " -eye [x y z] : prints or sets eye location.\n"
+ " -at [x y z] : prints or sets center of look.\n"
+ " -up [x y z] : prints or sets direction of up vector.\n"
+ " -proj [x y z] : prints or sets direction of look.\n"
+ " -center x y : sets location of center of the screen in pixels.\n"
+ " -size [sx] : prints viewport projection width and height sizes\n"
+ " : or changes the size of its maximum dimension.\n",
+ __FILE__, VViewParams, group);
theCommands.Add("vchangeselected",
"vchangeselected shape"
"- adds to shape to selection or remove one from it",
__FILE__,VZClipping,group);
theCommands.Add ("vnbselected",
"vnbselected", __FILE__, VNbSelected, group);
+ theCommands.Add ("vchangecamera",
+ " changes camera parameters \n"
+ "- vchangecamera [param_type] [value]\n"
+ "- vchangecamera proj {ortho/persp/left/right/stereo}\n"
+ " Projection type including left and right stereo parts.\n"
+ "- vchangecamera dist [real]\n"
+ " Sets distance from target point to camera eye (moving eye).\n"
+ "- vchangecamera iod [real]\n"
+ " Intraocular distance value.\n"
+ "- vchangecamera zfocus [real]\n"
+ " Stereographic focus value.\n"
+ "- vchangecamera fov [real]\n"
+ " Field Of View value (in degrees).\n"
+ "- vchangecamera zfocustype {absolute/relative}\n"
+ " Stereographic focus definition type (absolute value or coefficient).\n"
+ "- vchangecamera iodtype {absolute/relative}\n"
+ " Intraocular distance definition type (absolute value or coefficient).\n",
+ __FILE__, VChangeCamera, group);
+ theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
+ "- vautozfit [on={1|0}] [scale]\n"
+ " Prints or changes parameters of automatic z-fit mode:\n"
+ " \"on\" - turns automatic z-fit on or off\n"
+ " \"scale\" - specifies factor to scale computed z range.\n",
+ __FILE__, VAutoZFit, group);
+ theCommands.Add ("vzrange", "command to manually access znear and zfar values\n"
+ " 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 [CollectorToo = 0|1]"
+ "vpurgedisplay"
"- removes structures which don't belong to objects displayed in neutral point",
__FILE__, VPurgeDisplay, group);
theCommands.Add("vsetviewsize",
" rot - texture rotation angle in degrees",
__FILE__, VTextureEnv, group);
theCommands.Add("vhlr" ,
- "is_enabled={on|off}"
+ "is_enabled={on|off} [show_hidden={1|0}]"
" - Hidden line removal algorithm:"
- " - is_enabled: if is on HLR algorithm is applied\n",
+ " - is_enabled: if is on HLR algorithm is applied\n"
+ " - show_hidden: if equals to 1, hidden lines are drawn as dotted ones.\n",
__FILE__,VHLR,group);
theCommands.Add("vhlrtype" ,
"algo_type={algo|polyalgo} [shape_1 ... shape_n]"
" 2 - all textures enabled.\n"
" this command sets texture details mode for the specified view.\n"
, __FILE__, VSetTextureMode, group);
+ theCommands.Add("vdefaults",
+ "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
+ __FILE__, VDefaults, group);
+ theCommands.Add("vlight",
+ "tool to manage light sources, without arguments shows list of lights."
+ "\n Main commands: "
+ "\n 'clear' to clear lights"
+ "\n '{def}aults' to load deafault lights"
+ "\n 'add' (or 'new') <type> to add any light source"
+ "\n where <type> is one of {amb}ient|directional|{spot}light|positional"
+ "\n 'change' <lightId> to edit light source with specified lightId"
+ "\n\n In addition to 'add' and 'change' commands you can use light parameters:"
+ "\n {pos}ition X Y Z"
+ "\n {dir}ection X Y Z (for directional light or for spotlight)"
+ "\n color colorName"
+ "\n {head}light 0|1"
+ "\n {constAtten}uation value"
+ "\n {linearAtten}uation value"
+ "\n angle angleDeg"
+ "\n {spotexp}onent value"
+ "\n local|global"
+ "\n\n example: vlight add positional head 1 pos 0 1 1 color red"
+ "\n example: vlight change 0 direction 0 -1 0 linearAttenuation 0.2",
+ __FILE__, VLight, group);
+ theCommands.Add("vraytrace",
+ "vraytrace 0|1",
+ __FILE__,VRaytrace,group);
+ theCommands.Add("vsetraytracemode",
+ "vsetraytracemode [shad=0|1] [refl=0|1] [aa=0|1]",
+ __FILE__,VSetRaytraceMode,group);
}
projects / occt.git / blobdiff