#include <AIS_Animation.hxx>
#include <AIS_AnimationCamera.hxx>
#include <AIS_AnimationObject.hxx>
+#include <AIS_CameraFrustum.hxx>
#include <AIS_ColorScale.hxx>
#include <AIS_Manipulator.hxx>
#include <AIS_RubberBand.hxx>
for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anObjIter (GetMapOfAIS());
anObjIter.More(); anObjIter.Next())
{
- Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anObjIter.Key1());
+ const Handle(AIS_InteractiveObject)& aPrs = anObjIter.Key1();
if (aPrs.IsNull()
|| aPrs->ZLayer() != aLayerId)
{
return 0;
}
+//! Auxiliary function for parsing glsl dump level argument.
+static Standard_Boolean parseGlslSourceFlag (Standard_CString theArg,
+ OpenGl_ShaderProgramDumpLevel& theGlslDumpLevel)
+{
+ TCollection_AsciiString aTypeStr (theArg);
+ aTypeStr.LowerCase();
+ if (aTypeStr == "off"
+ || aTypeStr == "0")
+ {
+ theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
+ }
+ else if (aTypeStr == "short")
+ {
+ theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Short;
+ }
+ else if (aTypeStr == "full"
+ || aTypeStr == "1")
+ {
+ theGlslDumpLevel = OpenGl_ShaderProgramDumpLevel_Full;
+ }
+ else
+ {
+ return Standard_False;
+ }
+ return Standard_True;
+}
+
//==============================================================================
//function : VGlDebug
//purpose :
}
}
- 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";
+ TCollection_AsciiString aGlslCodeDebugStatus = TCollection_AsciiString()
+ + "glslSourceCode: "
+ + (aCaps->glslDumpLevel == OpenGl_ShaderProgramDumpLevel_Off
+ ? "Off"
+ : aCaps->glslDumpLevel == OpenGl_ShaderProgramDumpLevel_Short
+ ? "Short"
+ : "Full")
+ + "\n";
+ theDI << "debug: " << (aCaps->contextDebug ? "1" : "0") << aDebActive << "\n"
+ << "sync: " << (aCaps->contextSyncDebug ? "1" : "0") << aSyncActive << "\n"
+ << "glslWarn: " << (aCaps->glslWarnings ? "1" : "0") << "\n"
+ << aGlslCodeDebugStatus
+ << "extraMsg: " << (aCaps->suppressExtraMsg ? "0" : "1") << "\n";
return 0;
}
aDefCaps->contextDebug = Standard_True;
}
}
+ else if (anArgCase == "-glslsourcecode"
+ || anArgCase == "-glslcode")
+ {
+ OpenGl_ShaderProgramDumpLevel aGslsDumpLevel = OpenGl_ShaderProgramDumpLevel_Full;
+ if (++anArgIter < theArgNb
+ && !parseGlslSourceFlag (theArgVec[anArgIter], aGslsDumpLevel))
+ {
+ --anArgIter;
+ }
+ aDefCaps->glslDumpLevel = aGslsDumpLevel;
+ if (aCaps != NULL)
+ {
+ aCaps->glslDumpLevel = aGslsDumpLevel;
+ }
+ }
else if (anArgCase == "-debug")
{
if (++anArgIter < theArgNb
aDefCaps->contextDebug = toEnableDebug;
aDefCaps->contextSyncDebug = toEnableDebug;
aDefCaps->glslWarnings = toEnableDebug;
+ if (!toEnableDebug)
+ {
+ aDefCaps->glslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
+ }
+ aDefCaps->suppressExtraMsg = !toEnableDebug;
+ if (aCaps != NULL)
+ {
+ aCaps->contextDebug = toEnableDebug;
+ aCaps->contextSyncDebug = toEnableDebug;
+ aCaps->glslWarnings = toEnableDebug;
+ if (!toEnableDebug)
+ {
+ aCaps->glslDumpLevel = OpenGl_ShaderProgramDumpLevel_Off;
+ }
+ aCaps->suppressExtraMsg = !toEnableDebug;
+ }
}
else
{
TCollection_AsciiString anObjName (theArgVec[anArgIter]);
const ViewerTest_DoubleMapOfInteractiveAndName& aMapOfAIS = GetMapOfAIS();
- if (!aMapOfAIS.IsBound2 (anObjName))
+ Handle(AIS_InteractiveObject) anObject;
+ if (!aMapOfAIS.Find2 (anObjName, anObject))
{
std::cout << "Syntax error: wrong object name at " << anArg << "\n";
return 1;
}
- Handle(AIS_InteractiveObject) anObject = Handle(AIS_InteractiveObject)::DownCast (aMapOfAIS.Find2 (anObjName));
gp_Trsf aTrsfs [2] = { anObject->LocalTransformation(), anObject->LocalTransformation() };
gp_Quaternion aRotQuats[2] = { aTrsfs[0].GetRotation(), aTrsfs[1].GetRotation() };
gp_XYZ aLocPnts [2] = { aTrsfs[0].TranslationPart(), aTrsfs[1].TranslationPart() };
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))
+ if (!GetMapOfAIS().Find2 (aName, anAISObject)
+ || anAISObject.IsNull())
{
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;
- }
- aContext->AddOrRemoveSelected(anAISObject, Standard_True);
- }
+ ViewerTest::GetAISContext()->AddOrRemoveSelected(anAISObject, Standard_True);
return 0;
}
for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anIObjIt (GetMapOfAIS());
anIObjIt.More(); anIObjIt.Next())
{
- Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anIObjIt.Key1());
+ const Handle(AIS_InteractiveObject)& aPrs = anIObjIt.Key1();
aPrs->RemoveClipPlane (aClipPlane);
}
aClipPlane->SetCappingMaterial (aMat);
anArgIter += aNbParsed;
}
+ else if ((aChangeArg == "-transparency"
+ || aChangeArg == "-transp")
+ && aNbChangeArgs >= 2)
+ {
+ TCollection_AsciiString aValStr (aChangeArgs[1]);
+ Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
+ if (aValStr.IsRealValue())
+ {
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+ aMat.SetTransparency ((float )aValStr.RealValue());
+ anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
+ aClipPlane->SetCappingMaterial (aMat);
+ }
+ else
+ {
+ aValStr.LowerCase();
+ Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto;
+ if (aValStr == "opaque")
+ {
+ aMode = Graphic3d_AlphaMode_Opaque;
+ }
+ else if (aValStr == "mask")
+ {
+ aMode = Graphic3d_AlphaMode_Mask;
+ }
+ else if (aValStr == "blend")
+ {
+ aMode = Graphic3d_AlphaMode_Blend;
+ }
+ else if (aValStr == "blendauto")
+ {
+ aMode = Graphic3d_AlphaMode_BlendAuto;
+ }
+ else
+ {
+ std::cout << "Syntax error at '" << aValStr << "'\n";
+ return 1;
+ }
+ anAspect->SetAlphaMode (aMode);
+ aClipPlane->SetCappingAspect (anAspect);
+ }
+ anArgIter += 1;
+ }
else if (aChangeArg == "-texname"
|| aChangeArg == "texname")
{
}
else if (GetMapOfAIS().IsBound2 (anEntityName))
{
- Handle(AIS_InteractiveObject) aIObj = Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2 (anEntityName));
+ Handle(AIS_InteractiveObject) aIObj = GetMapOfAIS().Find2 (anEntityName);
if (toSet)
{
aIObj->AddClipPlane (aClipPlane);
return 0;
}
+ TCollection_AsciiString aPrsName;
for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
{
Standard_CString anArg = theArgVec[anArgIter];
}
theDI << aCamera->FOVy() << " ";
}
+ else if (aPrsName.IsEmpty()
+ && !anArgCase.StartsWith ("-"))
+ {
+ aPrsName = anArg;
+ }
else
{
std::cout << "Error: unknown argument '" << anArg << "'\n";
}
}
- aView->AutoZFit();
- aView->Redraw();
+ if (aPrsName.IsEmpty()
+ || theArgsNb > 2)
+ {
+ aView->AutoZFit();
+ aView->Redraw();
+ }
+
+ if (!aPrsName.IsEmpty())
+ {
+ Handle(AIS_CameraFrustum) aCameraFrustum;
+ if (GetMapOfAIS().IsBound2 (aPrsName))
+ {
+ // find existing object
+ aCameraFrustum = Handle(AIS_CameraFrustum)::DownCast (GetMapOfAIS().Find2 (theArgVec[1]));
+ if (aCameraFrustum.IsNull())
+ {
+ std::cout << "Error: object '" << aPrsName << "'is already defined and is not a camera frustum!\n";
+ return 1;
+ }
+ }
+
+ if (aCameraFrustum.IsNull())
+ {
+ aCameraFrustum = new AIS_CameraFrustum();
+ }
+ else
+ {
+ // not include displayed object of old camera frustum in the new one.
+ ViewerTest::GetAISContext()->Erase (aCameraFrustum, false);
+ aView->ZFitAll();
+ }
+ aCameraFrustum->SetCameraFrustum (aView->Camera());
+
+ ViewerTest::Display (aPrsName, aCameraFrustum);
+ }
return 0;
}
else if (aVal == "mem"
|| aVal == "gpumem"
|| aVal == "estimmem") aFlag = Graphic3d_RenderingParams::PerfCounters_EstimMem;
+ else if (aVal == "skipimmediate"
+ || aVal == "noimmediate") aFlag = Graphic3d_RenderingParams::PerfCounters_SkipImmediate;
+ else if (aVal == "frametime"
+ || aVal == "frametimers"
+ || aVal == "time") aFlag = Graphic3d_RenderingParams::PerfCounters_FrameTime;
else if (aVal == "basic") aFlag = Graphic3d_RenderingParams::PerfCounters_Basic;
else if (aVal == "extended"
|| aVal == "verbose"
|| aVal == "extra") aFlag = Graphic3d_RenderingParams::PerfCounters_Extended;
+ else if (aVal == "full"
+ || aVal == "all") aFlag = Graphic3d_RenderingParams::PerfCounters_All;
else
{
return Standard_False;
theDI << "two-sided BSDF: " << (aParams.TwoSidedBsdfModels ? "on" : "off") << "\n";
theDI << "max radiance: " << aParams.RadianceClampingValue << "\n";
theDI << "nb tiles (iss): " << aParams.NbRayTracingTiles << "\n";
+ theDI << "tile size (iss):" << aParams.RayTracingTileSize << "x" << aParams.RayTracingTileSize << "\n";
theDI << "shadingModel: ";
switch (aView->ShadingModel())
{
{
theDI << " gpumem";
}
+ if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_FrameTime) != 0)
+ {
+ theDI << " frameTime";
+ }
+ if ((aParams.CollectedStats & Graphic3d_RenderingParams::PerfCounters_SkipImmediate) != 0)
+ {
+ theDI << " skipimmediate";
+ }
if (aParams.CollectedStats == Graphic3d_RenderingParams::PerfCounters_NONE)
{
theDI << " none";
}
theDI << "depth pre-pass: " << (aParams.ToEnableDepthPrepass ? "on" : "off") << "\n";
theDI << "alpha to coverage: " << (aParams.ToEnableAlphaToCoverage ? "on" : "off") << "\n";
+ theDI << "frustum culling: " << (aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_On ? "on" :
+ aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_Off ? "off" :
+ "noUpdate") << "\n";
theDI << "\n";
return 0;
}
}
aParams.ShowSamplingTiles = toEnable;
}
+ else if (aFlag == "-tilesize")
+ {
+ if (toPrint)
+ {
+ theDI << aParams.RayTracingTileSize << " ";
+ continue;
+ }
+ else if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+
+ const Standard_Integer aTileSize = Draw::Atoi (theArgVec[anArgIter]);
+ if (aTileSize < 1)
+ {
+ std::cerr << "Error: invalid size of ISS tile " << aTileSize << ".\n";
+ return 1;
+ }
+ aParams.RayTracingTileSize = aTileSize;
+ }
else if (aFlag == "-nbtiles")
{
if (toPrint)
}
const Standard_Integer aNbTiles = Draw::Atoi (theArgVec[anArgIter]);
-
- if (aNbTiles < 64)
+ if (aNbTiles < -1)
{
std::cerr << "Error: invalid number of ISS tiles " << aNbTiles << ".\n";
- std::cerr << "Specify value in range [64, 1024].\n";
return 1;
}
- else
+ else if (aNbTiles > 0
+ && (aNbTiles < 64
+ || aNbTiles > 1024))
{
- aParams.NbRayTracingTiles = aNbTiles;
+ std::cerr << "Warning: suboptimal number of ISS tiles " << aNbTiles << ". Recommended range: [64, 1024].\n";
}
+ aParams.NbRayTracingTiles = aNbTiles;
}
else if (aFlag == "-env")
{
}
aView->ChangeRenderingParams().StatsUpdateInterval = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
}
+ else if (aFlag == "-perfchart"
+ || aFlag == "-statschart")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+ aView->ChangeRenderingParams().StatsNbFrames = Draw::Atoi (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-perfchartmax"
+ || aFlag == "-statschartmax")
+ {
+ if (++anArgIter >= theArgNb)
+ {
+ std::cout << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+ aView->ChangeRenderingParams().StatsMaxChartTime = (Standard_ShortReal )Draw::Atof (theArgVec[anArgIter]);
+ }
+ else if (aFlag == "-frustumculling"
+ || aFlag == "-culling")
+ {
+ if (toPrint)
+ {
+ theDI << ((aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_On) ? "on" :
+ (aParams.FrustumCullingState == Graphic3d_RenderingParams::FrustumCulling_Off) ? "off" :
+ "noUpdate") << " ";
+ continue;
+ }
+
+ Graphic3d_RenderingParams::FrustumCulling aState = Graphic3d_RenderingParams::FrustumCulling_On;
+ if (++anArgIter < theArgNb)
+ {
+ TCollection_AsciiString aStateStr(theArgVec[anArgIter]);
+ aStateStr.LowerCase();
+ bool toEnable = true;
+ if (ViewerTest::ParseOnOff (aStateStr.ToCString(), toEnable))
+ {
+ aState = toEnable ? Graphic3d_RenderingParams::FrustumCulling_On : Graphic3d_RenderingParams::FrustumCulling_Off;
+ }
+ else if (aStateStr == "noupdate"
+ || aStateStr == "freeze")
+ {
+ aState = Graphic3d_RenderingParams::FrustumCulling_NoUpdate;
+ }
+ else
+ {
+ --anArgIter;
+ }
+ }
+ aParams.FrustumCullingState = aState;
+ }
else
{
std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
}
//=======================================================================
-//function : VProgressiveMode
+//function : searchInfo
//purpose :
//=======================================================================
-#if defined(_WIN32)
-static Standard_Integer VProgressiveMode (Draw_Interpretor& /*theDI*/,
- Standard_Integer /*theNbArgs*/,
- const char** /*theArgs*/)
+inline TCollection_AsciiString searchInfo (const TColStd_IndexedDataMapOfStringString& theDict,
+ const TCollection_AsciiString& theKey)
{
- 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 (;;)
+ for (TColStd_IndexedDataMapOfStringString::Iterator anIter (theDict); anIter.More(); anIter.Next())
{
- aView->Redraw();
-
- Standard_Boolean toExit = Standard_False;
-
- MSG aMsg;
- while (PeekMessageW (&aMsg, NULL, 0, 0, PM_REMOVE))
+ if (TCollection_AsciiString::IsSameString (anIter.Key(), theKey, Standard_False))
{
- if (aMsg.message == WM_KEYDOWN && (aMsg.wParam == 0x0d || aMsg.wParam == 0x1b))
- {
- toExit = Standard_True;
- }
-
- TranslateMessage (&aMsg);
- DispatchMessageW (&aMsg);
- }
-
- if (toExit)
- {
- break;
+ return anIter.Value();
}
}
-
- return 0;
+ return TCollection_AsciiString();
}
-#endif
//=======================================================================
-//function : VFrustumCulling
-//purpose : enables/disables view volume's culling.
+//function : VStatProfiler
+//purpose :
//=======================================================================
-static int VFrustumCulling (Draw_Interpretor& theDI,
- Standard_Integer theArgNb,
- const char** theArgVec)
+static Standard_Integer VStatProfiler (Draw_Interpretor& theDI,
+ Standard_Integer theArgNb,
+ const char** theArgVec)
{
Handle(V3d_View) aView = ViewerTest::CurrentView();
if (aView.IsNull())
{
- std::cout << theArgVec[0] << " Error: Use 'vinit' command before\n";
+ std::cerr << "Error: no active viewer!\n";
return 1;
}
- if (theArgNb < 2)
- {
- theDI << (aView->IsCullingEnabled() ? "on" : "off");
- return 0;
- }
- else if (theArgNb != 2)
+ Standard_Boolean toRedraw = Standard_True;
+ Graphic3d_RenderingParams::PerfCounters aPrevCounters = aView->ChangeRenderingParams().CollectedStats;
+ Standard_ShortReal aPrevUpdInterval = aView->ChangeRenderingParams().StatsUpdateInterval;
+ Graphic3d_RenderingParams::PerfCounters aRenderParams = Graphic3d_RenderingParams::PerfCounters_NONE;
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
- std::cout << theArgVec[0] << " Syntax error: Specify the mode\n";
- return 1;
- }
+ Standard_CString anArg (theArgVec[anArgIter]);
+ TCollection_AsciiString aFlag (anArg);
+ aFlag.LowerCase();
+ if (aFlag == "-noredraw")
+ {
+ toRedraw = Standard_False;
+ }
+ else
+ {
+ Graphic3d_RenderingParams::PerfCounters aParam = Graphic3d_RenderingParams::PerfCounters_NONE;
+ if (aFlag == "fps") aParam = Graphic3d_RenderingParams::PerfCounters_FrameRate;
+ else if (aFlag == "cpu") aParam = Graphic3d_RenderingParams::PerfCounters_CPU;
+ else if (aFlag == "alllayers"
+ || aFlag == "layers") aParam = Graphic3d_RenderingParams::PerfCounters_Layers;
+ else if (aFlag == "allstructs"
+ || aFlag == "structs") aParam = Graphic3d_RenderingParams::PerfCounters_Structures;
+ else if (aFlag == "groups") aParam = Graphic3d_RenderingParams::PerfCounters_Groups;
+ else if (aFlag == "allarrays"
+ || aFlag == "fillarrays"
+ || aFlag == "linearrays"
+ || aFlag == "pointarrays"
+ || aFlag == "textarrays") aParam = Graphic3d_RenderingParams::PerfCounters_GroupArrays;
+ else if (aFlag == "triangles") aParam = Graphic3d_RenderingParams::PerfCounters_Triangles;
+ else if (aFlag == "points") aParam = Graphic3d_RenderingParams::PerfCounters_Points;
+ else if (aFlag == "geommem"
+ || aFlag == "texturemem"
+ || aFlag == "framemem") aParam = Graphic3d_RenderingParams::PerfCounters_EstimMem;
+ else if (aFlag == "elapsedframe"
+ || aFlag == "cpuframeaverage"
+ || aFlag == "cpupickingaverage"
+ || aFlag == "cpucullingaverage"
+ || aFlag == "cpudynaverage"
+ || aFlag == "cpuframemax"
+ || aFlag == "cpupickingmax"
+ || aFlag == "cpucullingmax"
+ || aFlag == "cpudynmax") aParam = Graphic3d_RenderingParams::PerfCounters_FrameTime;
+ else
+ {
+ std::cerr << "Unknown argument '" << theArgVec[anArgIter] << "'!\n";
+ continue;
+ }
- TCollection_AsciiString aModeStr (theArgVec[1]);
- aModeStr.LowerCase();
- Standard_Boolean toEnable = 0;
- if (aModeStr == "on")
- {
- toEnable = 1;
+ aRenderParams = Graphic3d_RenderingParams::PerfCounters (aRenderParams | aParam);
+ }
}
- else if (aModeStr == "off")
+
+ if (aRenderParams != Graphic3d_RenderingParams::PerfCounters_NONE)
{
- toEnable = 0;
+ aView->ChangeRenderingParams().CollectedStats =
+ Graphic3d_RenderingParams::PerfCounters (aView->RenderingParams().CollectedStats | aRenderParams);
+
+ if (toRedraw)
+ {
+ aView->ChangeRenderingParams().StatsUpdateInterval = -1;
+ aView->Redraw();
+ aView->ChangeRenderingParams().StatsUpdateInterval = aPrevUpdInterval;
+ }
+
+ TColStd_IndexedDataMapOfStringString aDict;
+ aView->StatisticInformation (aDict);
+
+ aView->ChangeRenderingParams().CollectedStats = aPrevCounters;
+
+ for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+ {
+ Standard_CString anArg(theArgVec[anArgIter]);
+ TCollection_AsciiString aFlag(anArg);
+ aFlag.LowerCase();
+ if (aFlag == "fps")
+ {
+ theDI << searchInfo (aDict, "FPS") << " ";
+ }
+ else if (aFlag == "cpu")
+ {
+ theDI << searchInfo (aDict, "CPU FPS") << " ";
+ }
+ else if (aFlag == "alllayers")
+ {
+ theDI << searchInfo (aDict, "Layers") << " ";
+ }
+ else if (aFlag == "layers")
+ {
+ theDI << searchInfo (aDict, "Rendered layers") << " ";
+ }
+ else if (aFlag == "allstructs")
+ {
+ theDI << searchInfo (aDict, "Structs") << " ";
+ }
+ else if (aFlag == "structs")
+ {
+ theDI << searchInfo (aDict, "Rendered structs") << " ";
+ }
+ else if (aFlag == "groups")
+ {
+ theDI << searchInfo (aDict, "Rendered groups") << " ";
+ }
+ else if (aFlag == "allarrays")
+ {
+ theDI << searchInfo (aDict, "Rendered arrays") << " ";
+ }
+ else if (aFlag == "fillarrays")
+ {
+ theDI << searchInfo (aDict, "Rendered [fill] arrays") << " ";
+ }
+ else if (aFlag == "linearrays")
+ {
+ theDI << searchInfo (aDict, "Rendered [line] arrays") << " ";
+ }
+ else if (aFlag == "pointarrays")
+ {
+ theDI << searchInfo (aDict, "Rendered [point] arrays") << " ";
+ }
+ else if (aFlag == "textarrays")
+ {
+ theDI << searchInfo (aDict, "Rendered [text] arrays") << " ";
+ }
+ else if (aFlag == "triangles")
+ {
+ theDI << searchInfo (aDict, "Rendered triangles") << " ";
+ }
+ else if (aFlag == "points")
+ {
+ theDI << searchInfo (aDict, "Rendered points") << " ";
+ }
+ else if (aFlag == "geommem")
+ {
+ theDI << searchInfo (aDict, "GPU Memory [geometry]") << " ";
+ }
+ else if (aFlag == "texturemem")
+ {
+ theDI << searchInfo (aDict, "GPU Memory [textures]") << " ";
+ }
+ else if (aFlag == "framemem")
+ {
+ theDI << searchInfo (aDict, "GPU Memory [frames]") << " ";
+ }
+ else if (aFlag == "elapsedframe")
+ {
+ theDI << searchInfo (aDict, "Elapsed Frame (average)") << " ";
+ }
+ else if (aFlag == "cpuframe_average")
+ {
+ theDI << searchInfo (aDict, "CPU Frame (average)") << " ";
+ }
+ else if (aFlag == "cpupicking_average")
+ {
+ theDI << searchInfo (aDict, "CPU Picking (average)") << " ";
+ }
+ else if (aFlag == "cpuculling_average")
+ {
+ theDI << searchInfo (aDict, "CPU Culling (average)") << " ";
+ }
+ else if (aFlag == "cpudyn_average")
+ {
+ theDI << searchInfo (aDict, "CPU Dynamics (average)") << " ";
+ }
+ else if (aFlag == "cpuframe_max")
+ {
+ theDI << searchInfo (aDict, "CPU Frame (max)") << " ";
+ }
+ else if (aFlag == "cpupicking_max")
+ {
+ theDI << searchInfo (aDict, "CPU Picking (max)") << " ";
+ }
+ else if (aFlag == "cpuculling_max")
+ {
+ theDI << searchInfo (aDict, "CPU Culling (max)") << " ";
+ }
+ else if (aFlag == "cpudyn_max")
+ {
+ theDI << searchInfo (aDict, "CPU Dynamics (max)") << " ";
+ }
+ }
}
else
{
- toEnable = Draw::Atoi (theArgVec[1]) != 0;
+ if (toRedraw)
+ {
+ aView->ChangeRenderingParams().StatsUpdateInterval = -1;
+ aView->Redraw();
+ aView->ChangeRenderingParams().StatsUpdateInterval = aPrevUpdInterval;
+ }
+ theDI << "Statistic info:\n" << aView->StatisticInformation();
}
-
- aView->SetFrustumCulling (toEnable);
- aView->Redraw();
return 0;
}
//=======================================================================
-//function : VHighlightSelected
-//purpose :
+//function : VProgressiveMode
+//purpose :
//=======================================================================
-static int VHighlightSelected (Draw_Interpretor& theDI,
- Standard_Integer theArgNb,
- const char** theArgVec)
+#if defined(_WIN32)
+static Standard_Integer VProgressiveMode (Draw_Interpretor& /*theDI*/,
+ Standard_Integer /*theNbArgs*/,
+ const char** /*theArgs*/)
{
- if (ViewerTest::GetAISContext().IsNull())
+ Handle(V3d_View) aView = ViewerTest::CurrentView();
+ if (aView.IsNull())
{
- std::cout << theArgVec[0] << " error : Context is not created. Please call vinit before.\n";
+ std::cerr << "Error: no active viewer!\n";
return 1;
}
- const Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
-
- if (theArgNb < 2)
- {
- theDI << (aContext->ToHilightSelected() ? "on" : "off");
- return 0;
- }
+ std::cout << "Press Enter or Escape key to exit progressive rendering mode" << std::endl;
- if (theArgNb != 2)
+ for (;;)
{
- std::cout << theArgVec[0] << " error : wrong number of parameters."
- << "Type 'help" << theArgVec[0] << "' for more information.";
- return 1;
- }
+ aView->Redraw();
- // Parse parameter
- TCollection_AsciiString aMode (theArgVec[1]);
- aMode.LowerCase();
- Standard_Boolean toEnable = Standard_False;
- if (aMode.IsEqual ("on"))
- {
- toEnable = Standard_True;
- }
- else if (aMode.IsEqual ("off"))
- {
- toEnable = Standard_False;
- }
- else
- {
- toEnable = Draw::Atoi (theArgVec[1]) != 0;
- }
+ Standard_Boolean toExit = Standard_False;
- if (toEnable != aContext->ToHilightSelected())
- {
- aContext->SetToHilightSelected (toEnable);
+ MSG aMsg;
+ while (PeekMessageW (&aMsg, NULL, 0, 0, PM_REMOVE))
+ {
+ if (aMsg.message == WM_KEYDOWN && (aMsg.wParam == 0x0d || aMsg.wParam == 0x1b))
+ {
+ toExit = Standard_True;
+ }
- // Move cursor to null position and back to process updating of detection
- // and highlighting of selected object immediatly.
- Standard_Integer aPixX = 0;
- Standard_Integer aPixY = 0;
- const Handle(ViewerTest_EventManager)& anEventManager = ViewerTest::CurrentEventManager();
+ TranslateMessage (&aMsg);
+ DispatchMessageW (&aMsg);
+ }
- anEventManager->GetCurrentPosition (aPixX, aPixY);
- anEventManager->MoveTo (0, 0);
- anEventManager->MoveTo (aPixX, aPixY);
+ if (toExit)
+ {
+ break;
+ }
}
return 0;
}
+#endif
//=======================================================================
//function : VXRotate
// find object
ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
Handle(AIS_InteractiveObject) anIObj;
- if (!aMap.IsBound2 (aName) )
+ if (!aMap.Find2 (aName, anIObj))
{
di << "Use 'vdisplay' before\n";
return 1;
}
- else
- {
- anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
- gp_Trsf aTransform;
- aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
- aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
-
- aContext->SetLocation (anIObj, aTransform);
- aContext->UpdateCurrentViewer();
- }
+ gp_Trsf aTransform;
+ aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
+ aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
+ aContext->SetLocation (anIObj, aTransform);
+ aContext->UpdateCurrentViewer();
return 0;
}
}
TCollection_AsciiString anObjName (aCmd.Arg ("attach", 0).c_str());
- if (!aMapAIS.IsBound2 (anObjName))
+ Handle(AIS_InteractiveObject) anObject;
+ if (!aMapAIS.Find2 (anObjName, anObject))
{
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())
+ for (ViewerTest_MapOfAISManipulators::Iterator anIt (GetMapOfAISManipulators()); anIt.More(); anIt.Next())
{
if (anIt.Value()->IsAttached()
&& anIt.Value()->Object() == anObject)
return 1;
}
+ if (TCollection_AsciiString (theArgVec[0]) == "vhighlightselected")
+ {
+ // handle obsolete alias
+ bool toEnable = true;
+ if (theArgsNb < 2)
+ {
+ theDi << (aCtx->ToHilightSelected() ? "on" : "off");
+ return 0;
+ }
+ else if (theArgsNb != 2
+ || !ViewerTest::ParseOnOff (theArgVec[1], toEnable))
+ {
+ std::cout << "Syntax error: wrong number of parameters.";
+ return 1;
+ }
+ if (toEnable != aCtx->ToHilightSelected())
+ {
+ aCtx->ClearDetected();
+ aCtx->SetToHilightSelected (toEnable);
+ }
+ return 0;
+ }
+
Standard_Boolean toPrint = theArgsNb == 1;
Standard_Boolean toRedraw = Standard_False;
Standard_Integer anArgIter = 1;
}
aCtx->SetAutoActivateSelection (toEnable);
}
+ else if (anArg == "-automatichighlight"
+ || anArg == "-automatichilight"
+ || anArg == "-autohighlight"
+ || anArg == "-autohilight")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (anArgIter + 1 < theArgsNb
+ && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
+ {
+ ++anArgIter;
+ }
+ aCtx->ClearSelected (false);
+ aCtx->ClearDetected();
+ aCtx->SetAutomaticHilight (toEnable);
+ toRedraw = true;
+ }
+ else if (anArg == "-highlightselected"
+ || anArg == "-hilightselected")
+ {
+ Standard_Boolean toEnable = Standard_True;
+ if (anArgIter + 1 < theArgsNb
+ && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], toEnable))
+ {
+ ++anArgIter;
+ }
+ aCtx->ClearDetected();
+ aCtx->SetToHilightSelected (toEnable);
+ toRedraw = true;
+ }
else if (anArg == "-pickstrategy"
|| anArg == "-pickingstrategy")
{
const Handle(Prs3d_Drawer)& aHiStyle = aCtx->HighlightStyle();
const Handle(Prs3d_Drawer)& aSelStyle = aCtx->SelectionStyle();
theDi << "Auto-activation : " << (aCtx->GetAutoActivateSelection() ? "On" : "Off") << "\n";
+ theDi << "Auto-highlight : " << (aCtx->AutomaticHilight() ? "On" : "Off") << "\n";
+ theDi << "Highlight selected : " << (aCtx->ToHilightSelected() ? "On" : "Off") << "\n";
theDi << "Selection pixel tolerance : " << aCtx->MainSelector()->PixelTolerance() << "\n";
theDi << "Selection color : " << Quantity_Color::StringName (aSelStyle->Color().Name()) << "\n";
theDi << "Dynamic highlight color : " << Quantity_Color::StringName (aHiStyle->Color().Name()) << "\n";
__FILE__, VFps, group);
theCommands.Add ("vgldebug",
"vgldebug [-sync {0|1}] [-debug {0|1}] [-glslWarn {0|1}]"
- "\n\t\t: [-extraMsg {0|1}] [{0|1}]"
+ "\n\t\t: [-glslCode {off|short|full}] [-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: -glslCode - log GLSL program source code,"
+ "\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);
"vnbselected"
"\n\t\t: Returns number of selected objects", __FILE__, VNbSelected, group);
theCommands.Add ("vcamera",
- "vcamera [-ortho] [-projtype]"
+ "vcamera [PrsName] [-ortho] [-projtype]"
"\n\t\t: [-persp]"
"\n\t\t: [-fovy [Angle]] [-distance [Distance]]"
"\n\t\t: [-stereo] [-leftEye] [-rightEye]"
"\n\t\t: [-iod [Distance]] [-iodType [absolute|relative]]"
"\n\t\t: [-zfocus [Value]] [-zfocusType [absolute|relative]]"
- "\n\t\t: Manage camera parameters."
+ "\n\t\t: Manages camera parameters."
+ "\n\t\t: Displays frustum when presntation name PrsName is specified."
"\n\t\t: Prints current value when option called without argument."
"\n\t\t: Orthographic camera:"
"\n\t\t: -ortho activate orthographic projection"
"\n\t\t: [-set|-unset|-setOverrideGlobal [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: [-color R G B] [-transparency Value] [-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: 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: -transparency Value set capping transparency 0..1"
"\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 '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
"\n '-issd on|off' Shows screen sampling distribution in ISS mode"
"\n '-maxrad > 0.0' Value used for clamping radiance estimation (PT mode)"
- "\n '-nbtiles 64..1024' Specifies number of screen tiles in ISS mode"
+ "\n '-tileSize 1..4096' Specifies size of screen tiles in ISS mode (32 by default)"
+ "\n '-nbtiles 64..1024' Specifies number of screen tiles per Redraw in ISS mode (256 by default)"
"\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 '-exposure value' Exposure value for tone mapping (0.0 value disables the effect)"
"\n '-whitepoint value' White point value for filmic tone mapping"
"\n '-tonemapping mode' Tone mapping mode (disabled, filmic)"
- "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triagles|points|gpuMem|basic|extended|nofps'"
+ "\n '-perfCounters none|fps|cpu|layers|structures|groups|arrays|triagles|points"
+ "\n ' |gpuMem|frameTime|basic|extended|full|nofps|skipImmediate'"
"\n Show/hide performance counters (flags can be combined)"
"\n '-perfUpdateInterval nbSeconds' Performance counters update interval"
+ "\n '-perfChart nbFrames' Show frame timers chart limited by specified number of frames"
+ "\n '-perfChartMax seconds' Maximum time in seconds with the chart"
+ "\n '-frustumCulling on|off|noupdate' Enable/disable objects frustum clipping or"
+ "\n set state to check structures culled previously."
"\n Unlike vcaps, these parameters dramatically change visual properties."
"\n Command is intended to control presentation quality depending on"
"\n hardware capabilities and performance.",
__FILE__, VRenderParams, group);
- theCommands.Add("vfrustumculling",
- "vfrustumculling [toEnable]: enables/disables objects clipping",
- __FILE__,VFrustumCulling,group);
- theCommands.Add("vhighlightselected",
- "vhighlightselected [0|1] or vhighlightselected [on|off]: enables/disables highlighting of selected objects.\n"
- "Without arguments it shows if highlighting of selected objects is enabled now.",
- __FILE__,VHighlightSelected,group);
+ theCommands.Add("vstatprofiler",
+ "\n vstatprofiler [fps|cpu|allLayers|layers|allstructures|structures|groups"
+ "\n |allArrays|fillArrays|lineArrays|pointArrays|textArrays"
+ "\n |triagles|points|geomMem|textureMem|frameMem"
+ "\n |elapsedFrame|cpuFrameAverage|cpuPickingAverage|cpuCullingAverage|cpuDynAverage"
+ "\n |cpuFrameMax|cpuPickingMax|cpuCullingMax|cpuDynMax]"
+ "\n [-noredraw]"
+ "\n\t\t: Prints rendering statistics."
+ "\n\t\t: If there are some parameters - print corresponding statistic counters values,"
+ "\n\t\t: else - print all performance counters set previously."
+ "\n\t\t: '-noredraw' Flag to avoid additional redraw call and use already collected values.\n",
+ __FILE__, VStatProfiler, group);
theCommands.Add ("vplace",
"vplace dx dy"
"\n\t\t: Places the point (in pixels) at the center of the window",
"\n vselprops [dynHighlight|localDynHighlight|selHighlight|localSelHighlight] [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 -autoHighlight {0|1} : disables|enables automatic highlighting in 3D Viewer"
+ "\n -highlightSelected {0|1}: disables|enables highlighting of detected object in selected state"
"\n -pickStrategy {first|topmost} : defines picking strategy"
"\n 'first' to pick first acceptable (default)"
"\n 'topmost' to pick only topmost (and nothing, if topmost is rejected by filters)"
"\n -material material : sets highlight material"
"\n -print : prints current state of all mentioned parameters",
__FILE__, VSelectionProperties, group);
+ theCommands.Add ("vhighlightselected",
+ "vhighlightselected [0|1]: alias for vselprops -highlightSelected.\n",
+ __FILE__, VSelectionProperties, group);
theCommands.Add ("vseldump",
"vseldump file -type {depth|unnormDepth|object|owner|selMode|entity}=depth -pickedIndex Index=1"