#include <algorithm>
-IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector, Standard_Transient)
namespace {
// Comparison operator for sorting selection results
const SelectMgr_IndexedDataMapOfOwnerCriterion& myMapOfCriterion;
};
- //! Compute 3d position for detected entity.
- inline void updatePoint3d (SelectMgr_SortCriterion& theCriterion,
- const gp_GTrsf& theInversedTrsf,
- SelectMgr_SelectingVolumeManager& theMgr)
+ static const Graphic3d_Mat4d SelectMgr_ViewerSelector_THE_IDENTITY_MAT;
+}
+
+//=======================================================================
+// function : updatePoint3d
+// purpose :
+//=======================================================================
+void SelectMgr_ViewerSelector::updatePoint3d (SelectMgr_SortCriterion& theCriterion,
+ const SelectBasics_PickResult& thePickResult,
+ const Handle(SelectBasics_SensitiveEntity)& theEntity,
+ const gp_GTrsf& theInversedTrsf,
+ const SelectMgr_SelectingVolumeManager& theMgr) const
+{
+ if (theMgr.GetActiveSelectionType() != SelectMgr_SelectingVolumeManager::Point)
+ {
+ return;
+ }
+
+ if (thePickResult.HasPickedPoint())
+ {
+ theCriterion.Point = thePickResult.PickedPoint();
+ }
+ else if (!thePickResult.IsValid())
+ {
+ theCriterion.Point = thePickResult.PickedPoint();
+ return;
+ }
+ else
{
theCriterion.Point = theMgr.DetectedPoint (theCriterion.Depth);
- gp_GTrsf anInvTrsf = theInversedTrsf;
- if (theCriterion.Entity->HasInitLocation())
- {
- anInvTrsf = theCriterion.Entity->InvInitLocation() * anInvTrsf;
- }
- if (anInvTrsf.Form() != gp_Identity)
- {
- anInvTrsf.Inverted().Transforms (theCriterion.Point.ChangeCoord());
- }
}
+ gp_GTrsf anInvTrsf = theInversedTrsf;
+ if (theCriterion.Entity->HasInitLocation())
+ {
+ anInvTrsf = theCriterion.Entity->InvInitLocation() * anInvTrsf;
+ }
+ if (anInvTrsf.Form() != gp_Identity)
+ {
+ anInvTrsf.Inverted().Transforms (theCriterion.Point.ChangeCoord());
+ }
+
+ if (mySelectingVolumeMgr.Camera().IsNull())
+ {
+ theCriterion.Tolerance = theEntity->SensitivityFactor() / 33.0;
+ }
+ else if (mySelectingVolumeMgr.Camera()->IsOrthographic())
+ {
+ theCriterion.Tolerance = myCameraScale * theEntity->SensitivityFactor();
+ }
+ else
+ {
+ const Standard_Real aDistFromEye = Abs ((theCriterion.Point.XYZ() - myCameraEye.XYZ()).Dot (myCameraDir.XYZ()));
+ theCriterion.Tolerance = aDistFromEye * myCameraScale * theEntity->SensitivityFactor();
+ }
}
//==================================================
SelectMgr_ViewerSelector::SelectMgr_ViewerSelector():
preferclosest(Standard_True),
myToUpdateTolerance (Standard_True),
+myCameraScale (1.0),
myCurRank (0),
myIsLeftChildQueuedFirst (Standard_False),
myEntityIdx (0)
{
+ myEntitySetBuilder = new BVH_BinnedBuilder<Standard_Real, 3, 4> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth, Standard_True);
}
//==================================================
//==================================================
void SelectMgr_ViewerSelector::Activate (const Handle(SelectMgr_Selection)& theSelection)
{
- for (theSelection->Init(); theSelection->More(); theSelection->Next())
+ for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
{
- theSelection->Sensitive()->SetActiveForSelection();
+ aSelEntIter.Value()->SetActiveForSelection();
}
- theSelection->SetSelectionState (SelectMgr_SOS_Activated);
+ if (theSelection->GetSelectionState() != SelectMgr_SOS_Activated)
+ {
+ theSelection->SetSelectionState (SelectMgr_SOS_Activated);
- myTolerances.Add (theSelection->Sensitivity());
- myToUpdateTolerance = Standard_True;
+ myTolerances.Add (theSelection->Sensitivity());
+ myToUpdateTolerance = Standard_True;
+ }
}
//==================================================
//==================================================
void SelectMgr_ViewerSelector::Deactivate (const Handle(SelectMgr_Selection)& theSelection)
{
- for (theSelection->Init(); theSelection->More(); theSelection->Next())
+ for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
{
- theSelection->Sensitive()->ResetSelectionActiveStatus();
+ aSelEntIter.Value()->ResetSelectionActiveStatus();
}
- theSelection->SetSelectionState (SelectMgr_SOS_Deactivated);
+ if (theSelection->GetSelectionState() == SelectMgr_SOS_Activated)
+ {
+ theSelection->SetSelectionState (SelectMgr_SOS_Deactivated);
- myTolerances.Decrement (theSelection->Sensitivity());
- myToUpdateTolerance = Standard_True;
+ myTolerances.Decrement (theSelection->Sensitivity());
+ myToUpdateTolerance = Standard_True;
+ }
}
//==================================================
SelectMgr_SelectingVolumeManager& theMgr)
{
Handle(SelectMgr_EntityOwner) anOwner (Handle(SelectMgr_EntityOwner)::DownCast (theEntity->OwnerId()));
-
- SelectBasics_PickResult aPickResult;
- if (theEntity->Matches (theMgr, aPickResult))
+ Handle(SelectMgr_SelectableObject) aSelectable;
+ Standard_Boolean toRestoresViewClipEnabled = Standard_False;
+ if (!anOwner.IsNull())
{
- if (!anOwner.IsNull())
+ aSelectable = anOwner->Selectable();
+ }
+ if (!aSelectable.IsNull())
+ {
+ if (!aSelectable->ClipPlanes().IsNull()
+ && aSelectable->ClipPlanes()->ToOverrideGlobal())
{
- Handle(SelectMgr_SelectableObject) aSelectable = anOwner->Selectable();
- if (HasDepthClipping (anOwner) && theMgr.GetActiveSelectionType() == SelectMgr_SelectingVolumeManager::Point)
- {
- Standard_Boolean isClipped = mySelectingVolumeMgr.IsClipped (aSelectable->GetClipPlanes(),
- aPickResult.Depth());
- if (isClipped)
- return;
- }
-
- SelectMgr_SortCriterion aCriterion;
- myZLayerOrderMap.Find (aSelectable->ZLayer(), aCriterion.ZLayerPosition);
- aCriterion.Entity = theEntity;
- aCriterion.Priority = anOwner->Priority();
- aCriterion.Depth = aPickResult.Depth();
- aCriterion.MinDist = aPickResult.DistToGeomCenter();
- aCriterion.Tolerance = theEntity->SensitivityFactor() / 33.0;
- aCriterion.ToPreferClosest = preferclosest;
-
- const Standard_Integer aPrevStoredIndex = mystored.FindIndex (anOwner);
- if (aPrevStoredIndex != 0)
+ theMgr.SetViewClippingEnabled (Standard_False);
+ toRestoresViewClipEnabled = Standard_True;
+ }
+ else if (!aSelectable->TransformPersistence().IsNull())
+ {
+ if (aSelectable->TransformPersistence()->IsZoomOrRotate()
+ && !theMgr.ViewClipping().IsNull())
{
- if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box)
+ // Zoom/rotate persistence object lives in two worlds at the same time.
+ // Global clipping planes can not be trivially applied without being converted
+ // into local space of transformation persistence object.
+ // As more simple alternative - just clip entire object by its anchor point defined in the world space.
+ const Handle(Graphic3d_SequenceOfHClipPlane)& aViewPlanes = theMgr.ViewClipping();
+
+ const gp_Pnt anAnchor = aSelectable->TransformPersistence()->AnchorPoint();
+ for (Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (*aViewPlanes); aPlaneIt.More(); aPlaneIt.Next())
{
- SelectMgr_SortCriterion& aPrevCriterion = mystored.ChangeFromIndex (aPrevStoredIndex);
- if (aCriterion > aPrevCriterion)
+ const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
+ if (!aPlane->IsOn())
+ {
+ continue;
+ }
+
+ const Graphic3d_Vec4d aCheckPnt (anAnchor.X(), anAnchor.Y(), anAnchor.Z(), 1.0);
+ if (aPlane->ProbePoint (aCheckPnt) == Graphic3d_ClipState_Out)
{
- updatePoint3d (aCriterion, theInversedTrsf, theMgr);
- aPrevCriterion = aCriterion;
+ return;
}
}
}
- else
+
+ theMgr.SetViewClippingEnabled (Standard_False);
+ toRestoresViewClipEnabled = Standard_True;
+ }
+ }
+
+ SelectBasics_PickResult aPickResult;
+ const Standard_Boolean isMatched = theEntity->Matches(theMgr, aPickResult);
+ if (toRestoresViewClipEnabled)
+ {
+ theMgr.SetViewClippingEnabled (Standard_True);
+ }
+
+ if (!isMatched
+ || anOwner.IsNull())
+ {
+ return;
+ }
+
+ if (HasDepthClipping (anOwner)
+ && !aSelectable.IsNull()
+ && theMgr.GetActiveSelectionType() == SelectMgr_SelectingVolumeManager::Point)
+ {
+ Standard_Boolean isClipped = mySelectingVolumeMgr.IsClipped (*aSelectable->ClipPlanes(),
+ aPickResult.Depth());
+ if (isClipped)
+ return;
+ }
+
+ SelectMgr_SortCriterion aCriterion;
+ myZLayerOrderMap.Find (!aSelectable.IsNull() ? aSelectable->ZLayer() : Graphic3d_ZLayerId_Default, aCriterion.ZLayerPosition);
+ aCriterion.Entity = theEntity;
+ aCriterion.Priority = anOwner->Priority();
+ aCriterion.Depth = aPickResult.Depth();
+ aCriterion.MinDist = aPickResult.DistToGeomCenter();
+ aCriterion.ToPreferClosest = preferclosest;
+
+ if (SelectMgr_SortCriterion* aPrevCriterion = mystored.ChangeSeek (anOwner))
+ {
+ ++aPrevCriterion->NbOwnerMatches;
+ aCriterion.NbOwnerMatches = aPrevCriterion->NbOwnerMatches;
+ if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box)
+ {
+ if (aCriterion > *aPrevCriterion)
{
- updatePoint3d (aCriterion, theInversedTrsf, theMgr);
- mystored.Add (anOwner, aCriterion);
+ updatePoint3d (aCriterion, aPickResult, theEntity, theInversedTrsf, theMgr);
+ *aPrevCriterion = aCriterion;
}
}
}
+ else
+ {
+ aCriterion.NbOwnerMatches = 1;
+ updatePoint3d (aCriterion, aPickResult, theEntity, theInversedTrsf, theMgr);
+ mystored.Add (anOwner, aCriterion);
+ }
}
//=======================================================================
// necessary calculations
//=======================================================================
void SelectMgr_ViewerSelector::computeFrustum (const Handle(SelectBasics_SensitiveEntity)& theEnt,
+ const SelectMgr_SelectingVolumeManager& theMgr,
const gp_GTrsf& theInvTrsf,
SelectMgr_FrustumCache& theCachedMgrs,
SelectMgr_SelectingVolumeManager& theResMgr)
const Standard_Boolean toTransform = aTrsfMtr.Form() != gp_Identity;
if (toScale && toTransform)
{
- theResMgr = mySelectingVolumeMgr.ScaleAndTransform (aScale, aTrsfMtr);
+ theResMgr = theMgr.ScaleAndTransform (aScale, aTrsfMtr, NULL);
}
else if (toScale)
{
if (!theCachedMgrs.IsBound (aScale))
{
- theCachedMgrs.Bind (aScale, mySelectingVolumeMgr.ScaleAndTransform (aScale, gp_Trsf()));
+ theCachedMgrs.Bind (aScale, theMgr.ScaleAndTransform (aScale, gp_Trsf(), NULL));
}
theResMgr = theCachedMgrs.Find (aScale);
}
else if (toTransform)
{
- theResMgr = mySelectingVolumeMgr.ScaleAndTransform (1, aTrsfMtr);
+ theResMgr = theMgr.ScaleAndTransform (1, aTrsfMtr, NULL);
}
}
// between some entity of selectable object theObject and
// current selecting volume
//=======================================================================
-void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_SelectableObject)& theObject)
+void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_SelectableObject)& theObject,
+ const SelectMgr_SelectingVolumeManager& theMgr,
+ const Handle(Graphic3d_Camera)& theCamera,
+ const Graphic3d_Mat4d& theProjectionMat,
+ const Graphic3d_Mat4d& theWorldViewMat,
+ const Standard_Integer theViewportWidth,
+ const Standard_Integer theViewportHeight)
{
- NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
- myMapOfObjectSensitives.ChangeFind (theObject);
-
+ Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
if (anEntitySet->Size() == 0)
+ {
return;
+ }
- const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aSensitivesTree = anEntitySet->BVH();
-
+ const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aSensitivesTree = anEntitySet->BVH();
gp_GTrsf aInversedTrsf;
-
- if (theObject->HasTransformation() || theObject->TransformPersistence().Flags)
+ if (theObject->HasTransformation() || !theObject->TransformPersistence().IsNull())
{
- if (!theObject->TransformPersistence().Flags)
+ if (theObject->TransformPersistence().IsNull())
{
aInversedTrsf = theObject->InversedTransformation();
}
else
{
- const Graphic3d_Mat4d& aProjection = mySelectingVolumeMgr.ProjectionMatrix();
- const Graphic3d_Mat4d& aWorldView = mySelectingVolumeMgr.WorldViewMatrix();
-
- Standard_Integer aViewportWidth;
- Standard_Integer aViewportHeight;
- mySelectingVolumeMgr.WindowSize (aViewportWidth, aViewportHeight);
-
gp_GTrsf aTPers;
- Graphic3d_Mat4d aMat = theObject->TransformPersistence().Compute (mySelectingVolumeMgr.Camera(), aProjection, aWorldView, aViewportWidth, aViewportHeight);
+ Graphic3d_Mat4d aMat = theObject->TransformPersistence()->Compute (theCamera, theProjectionMat, theWorldViewMat, theViewportWidth, theViewportHeight);
+
aTPers.SetValue (1, 1, aMat.GetValue (0, 0));
aTPers.SetValue (1, 2, aMat.GetValue (0, 1));
aTPers.SetValue (1, 3, aMat.GetValue (0, 2));
}
SelectMgr_SelectingVolumeManager aMgr = aInversedTrsf.Form() != gp_Identity
- ? mySelectingVolumeMgr.ScaleAndTransform (1, aInversedTrsf)
- : mySelectingVolumeMgr;
+ ? theMgr.ScaleAndTransform (1, aInversedTrsf, NULL)
+ : theMgr;
SelectMgr_FrustumCache aScaledTrnsfFrustums;
{
return;
}
- Standard_Integer aStack[32];
+
+ const Standard_Integer aFirstStored = mystored.Extent() + 1;
+
+ Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
Standard_Integer aHead = -1;
for (;;)
{
Standard_Integer anEndIdx = aSensitivesTree->EndPrimitive (aNode);
for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
{
- const Handle(SelectMgr_SensitiveEntity)& aSensitive =
- anEntitySet->GetSensitiveById (anIdx);
+ const Handle(SelectMgr_SensitiveEntity)& aSensitive = anEntitySet->GetSensitiveById (anIdx);
if (aSensitive->IsActiveForSelection())
{
const Handle(SelectBasics_SensitiveEntity)& anEnt = aSensitive->BaseSensitive();
SelectMgr_SelectingVolumeManager aTmpMgr = aMgr;
- computeFrustum (anEnt, aInversedTrsf, aScaledTrnsfFrustums, aTmpMgr);
+ computeFrustum (anEnt, theMgr, aInversedTrsf, aScaledTrnsfFrustums, aTmpMgr);
checkOverlap (anEnt, aInversedTrsf, aTmpMgr);
}
}
--aHead;
}
}
+
+ // in case of Box/Polyline selection - keep only Owners having all Entities detected
+ if (mySelectingVolumeMgr.IsOverlapAllowed()
+ || (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box
+ && theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Polyline))
+ {
+ return;
+ }
+
+ for (Standard_Integer aStoredIter = mystored.Extent(); aStoredIter >= aFirstStored; --aStoredIter)
+ {
+ const SelectMgr_SortCriterion& aCriterion = mystored.FindFromIndex (aStoredIter);
+ const Handle(SelectBasics_EntityOwner)& anOwner = aCriterion.Entity->OwnerId();
+ Standard_Integer aNbOwnerEntities = 0;
+ for (SelectMgr_IndexedMapOfHSensitive::Iterator aSensIter (anEntitySet->Sensitives()); aSensIter.More(); aSensIter.Next())
+ {
+ if (aSensIter.Value()->BaseSensitive()->OwnerId() == anOwner)
+ {
+ if (++aNbOwnerEntities > aCriterion.NbOwnerMatches)
+ {
+ // Remove from index map.
+ // Considering NCollection_IndexedDataMap implementation, the values for lower indexes will not be modified.
+ // Hence, just keep iterating in backward direction.
+ mystored.RemoveFromIndex (aStoredIter);
+ break;
+ }
+ }
+ }
+ }
}
//=======================================================================
{
mystored.Clear();
- NCollection_Handle<BVH_Tree<Standard_Real, 3> > aBVHTree;
- for (Standard_Integer aBVHTreeIdx = 0; aBVHTreeIdx < 2; ++aBVHTreeIdx)
+ Standard_Integer aWidth;
+ Standard_Integer aHeight;
+ mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
+ mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
+ mySelectingVolumeMgr.ProjectionMatrix(),
+ mySelectingVolumeMgr.WorldViewMatrix(),
+ mySelectingVolumeMgr.WorldViewProjState(),
+ aWidth, aHeight);
+ const Handle(Graphic3d_Camera)& aCamera = mySelectingVolumeMgr.Camera();
+ if (!aCamera.IsNull())
{
- const Standard_Boolean isTrsfPers = aBVHTreeIdx == 1;
- if (isTrsfPers)
+ myCameraEye = aCamera->Eye().XYZ();
+ myCameraDir = aCamera->Direction().XYZ();
+ myCameraScale = aCamera->IsOrthographic()
+ ? aCamera->Scale()
+ : 2.0 * Tan (aCamera->FOVy() * M_PI / 360.0);
+ const double aPixelSize = Max (1.0 / aWidth, 1.0 / aHeight);
+ myCameraScale *= aPixelSize;
+ }
+
+ for (Standard_Integer aBVHSetIt = 0; aBVHSetIt < SelectMgr_SelectableObjectSet::BVHSubsetNb; ++aBVHSetIt)
+ {
+ SelectMgr_SelectableObjectSet::BVHSubset aBVHSubset =
+ static_cast<SelectMgr_SelectableObjectSet::BVHSubset> (aBVHSetIt);
+
+ if (mySelectableObjects.IsEmpty (aBVHSubset))
{
- if (mySelectableObjectsTrsfPers.Size() == 0)
- {
- continue;
- }
- const Graphic3d_Mat4d& aProjection = mySelectingVolumeMgr.ProjectionMatrix();
- const Graphic3d_Mat4d& aWorldView = mySelectingVolumeMgr.WorldViewMatrix();
- const Graphic3d_WorldViewProjState& aWVPState = mySelectingVolumeMgr.WorldViewProjState();
- Standard_Integer aViewportWidth;
- Standard_Integer aViewportHeight;
- mySelectingVolumeMgr.WindowSize (aViewportWidth, aViewportHeight);
- aBVHTree = mySelectableObjectsTrsfPers.BVH (mySelectingVolumeMgr.Camera(), aProjection, aWorldView, aViewportWidth, aViewportHeight, aWVPState);
+ continue;
+ }
+
+ gp_GTrsf aTFrustum;
+
+ SelectMgr_SelectingVolumeManager aMgr (Standard_False);
+
+ // for 2D space selection transform selecting volumes to perform overap testing
+ // directly in camera's eye space omitting the camera position, which is not
+ // needed there at all
+ if (aBVHSubset == SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent)
+ {
+ const Graphic3d_Mat4d& aMat = mySelectingVolumeMgr.WorldViewMatrix();
+ aTFrustum.SetValue (1, 1, aMat.GetValue (0, 0));
+ aTFrustum.SetValue (1, 2, aMat.GetValue (0, 1));
+ aTFrustum.SetValue (1, 3, aMat.GetValue (0, 2));
+ aTFrustum.SetValue (2, 1, aMat.GetValue (1, 0));
+ aTFrustum.SetValue (2, 2, aMat.GetValue (1, 1));
+ aTFrustum.SetValue (2, 3, aMat.GetValue (1, 2));
+ aTFrustum.SetValue (3, 1, aMat.GetValue (2, 0));
+ aTFrustum.SetValue (3, 2, aMat.GetValue (2, 1));
+ aTFrustum.SetValue (3, 3, aMat.GetValue (2, 2));
+ aTFrustum.SetTranslationPart (gp_XYZ (aMat.GetValue (0, 3), aMat.GetValue (1, 3), aMat.GetValue (2, 3)));
+
+ // define corresponding frustum builder parameters
+ Handle(SelectMgr_FrustumBuilder) aBuilder = new SelectMgr_FrustumBuilder();
+ aBuilder->SetProjectionMatrix (mySelectingVolumeMgr.ProjectionMatrix());
+ aBuilder->SetWorldViewMatrix (SelectMgr_ViewerSelector_THE_IDENTITY_MAT);
+ aBuilder->SetWindowSize (aWidth, aHeight);
+ aMgr = mySelectingVolumeMgr.ScaleAndTransform (1, aTFrustum, aBuilder);
}
else
{
- if (mySelectableObjects.Size() == 0)
- {
- continue;
- }
- aBVHTree = mySelectableObjects.BVH();
+ aMgr = mySelectingVolumeMgr;
}
+ const Graphic3d_Mat4d& aProjectionMat = mySelectingVolumeMgr.ProjectionMatrix();
+ const Graphic3d_Mat4d& aWorldViewMat = aBVHSubset != SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent
+ ? mySelectingVolumeMgr.WorldViewMatrix()
+ : SelectMgr_ViewerSelector_THE_IDENTITY_MAT;
+
+ const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aBVHTree = mySelectableObjects.BVH (aBVHSubset);
+
Standard_Integer aNode = 0;
- if (!mySelectingVolumeMgr.Overlaps (aBVHTree->MinPoint (0),
- aBVHTree->MaxPoint (0)))
+ if (!aMgr.Overlaps (aBVHTree->MinPoint (0), aBVHTree->MaxPoint (0)))
{
continue;
}
- Standard_Integer aStack[32];
+ Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
Standard_Integer aHead = -1;
for (;;)
{
const Standard_Integer aLeftChildIdx = aBVHTree->Child<0> (aNode);
const Standard_Integer aRightChildIdx = aBVHTree->Child<1> (aNode);
const Standard_Boolean isLeftChildIn =
- mySelectingVolumeMgr.Overlaps (aBVHTree->MinPoint (aLeftChildIdx),
- aBVHTree->MaxPoint (aLeftChildIdx));
+ aMgr.Overlaps (aBVHTree->MinPoint (aLeftChildIdx), aBVHTree->MaxPoint (aLeftChildIdx));
const Standard_Boolean isRightChildIn =
- mySelectingVolumeMgr.Overlaps (aBVHTree->MinPoint (aRightChildIdx),
- aBVHTree->MaxPoint (aRightChildIdx));
+ aMgr.Overlaps (aBVHTree->MinPoint (aRightChildIdx), aBVHTree->MaxPoint (aRightChildIdx));
if (isLeftChildIn
&& isRightChildIn)
{
Standard_Integer anEndIdx = aBVHTree->EndPrimitive (aNode);
for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
{
- Handle(SelectMgr_SelectableObject) aSelectableObject =
- isTrsfPers ? mySelectableObjectsTrsfPers.GetObjectById (anIdx)
- : mySelectableObjects.GetObjectById (anIdx);
+ const Handle(SelectMgr_SelectableObject)& aSelectableObject =
+ mySelectableObjects.GetObjectById (aBVHSubset, anIdx);
- traverseObject (aSelectableObject);
+ traverseObject (aSelectableObject, aMgr, aCamera, aProjectionMat, aWorldViewMat, aWidth, aHeight);
}
if (aHead < 0)
{
SortResult();
}
+//==================================================
+// Function: ClearPicked
+// Purpose :
+//==================================================
+void SelectMgr_ViewerSelector::ClearPicked()
+{
+ mystored.Clear();
+}
+
//==================================================
// Function: Picked
// Purpose :
//
//==================================================
+//==================================================
+// Function: SetEntitySetBuilder
+// Purpose :
+//==================================================
+void SelectMgr_ViewerSelector::SetEntitySetBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder)
+{
+ myEntitySetBuilder = theBuilder;
+ for (SelectMgr_MapOfObjectSensitives::Iterator aSetIter (myMapOfObjectSensitives); aSetIter.More(); aSetIter.Next())
+ {
+ aSetIter.ChangeValue()->SetBuilder (myEntitySetBuilder);
+ }
+}
+
//==================================================
// Function: Contains
// Purpose :
//==================================================
Standard_Boolean SelectMgr_ViewerSelector::Contains (const Handle(SelectMgr_SelectableObject)& theObject) const
{
- return mySelectableObjects.Contains (theObject)
- || mySelectableObjectsTrsfPers.Contains (theObject);
+ return mySelectableObjects.Contains (theObject);
}
//==================================================
const SelectMgr_StateOfSelection theWantedState) const
{
Standard_Boolean hasActivatedStates = Contains (theSelectableObject);
- for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
+ for (SelectMgr_SequenceOfSelection::Iterator aSelIter (theSelectableObject->Selections()); aSelIter.More(); aSelIter.Next())
{
- if (theWantedState == SelectMgr_SOS_Any)
- {
- theModeList.Append (theSelectableObject->CurrentSelection()->Mode());
- }
- else if (theWantedState == theSelectableObject->CurrentSelection()->GetSelectionState())
- {
- theModeList.Append (theSelectableObject->CurrentSelection()->Mode());
- }
+ if (theWantedState == SelectMgr_SOS_Any)
+ {
+ theModeList.Append (aSelIter.Value()->Mode());
+ }
+ else if (theWantedState == aSelIter.Value()->GetSelectionState())
+ {
+ theModeList.Append (aSelIter.Value()->Mode());
+ }
}
return hasActivatedStates;
if (!Contains (theSelectableObject))
return Standard_False;
- for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
- {
- if (theMode == theSelectableObject->CurrentSelection()->Mode())
- {
- return theSelectableObject->CurrentSelection()->GetSelectionState() == SelectMgr_SOS_Activated;
- }
- }
-
- return Standard_False;
+ const Handle(SelectMgr_Selection)& aSel = theSelectableObject->Selection (theMode);
+ return !aSel.IsNull()
+ && aSel->GetSelectionState() == SelectMgr_SOS_Activated;
}
//==================================================
if (!Contains (theSelectableObject))
return Standard_False;
- for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
- {
- if (theMode == theSelectableObject->CurrentSelection()->Mode())
- {
- return theSelectableObject->CurrentSelection()->GetSelectionState() != SelectMgr_SOS_Unknown;
- }
- }
-
- return Standard_False;
+ const Handle(SelectMgr_Selection)& aSel = theSelectableObject->Selection (theMode);
+ return !aSel.IsNull()
+ && aSel->GetSelectionState() != SelectMgr_SOS_Unknown;
}
TCollection_AsciiString SelectMgr_ViewerSelector::Status (const Handle(SelectMgr_SelectableObject)& theSelectableObject) const
{
TCollection_AsciiString aStatus ("Status Object :\n\t");
-
- for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
+ for (SelectMgr_SequenceOfSelection::Iterator aSelIter (theSelectableObject->Selections()); aSelIter.More(); aSelIter.Next())
{
- if (theSelectableObject->CurrentSelection()->GetSelectionState() != SelectMgr_SOS_Unknown)
+ if (aSelIter.Value()->GetSelectionState() != SelectMgr_SOS_Unknown)
{
- aStatus = aStatus + "Mode " +
- TCollection_AsciiString (theSelectableObject->CurrentSelection()->Mode()) +
- " present - ";
- if (theSelectableObject->CurrentSelection()->GetSelectionState() == SelectMgr_SOS_Activated)
- {
- aStatus = aStatus + " Active \n\t";
- }
- else
- {
- aStatus = aStatus + " Inactive \n\t";
- }
+ aStatus = aStatus + "Mode " + TCollection_AsciiString (aSelIter.Value()->Mode()) + " present - "
+ + (aSelIter.Value()->GetSelectionState() == SelectMgr_SOS_Activated ? " Active \n\t" : " Inactive \n\t");
}
}
if(myIndexes.IsNull() || anExtent != myIndexes->Length())
myIndexes = new TColStd_HArray1OfInteger (1, anExtent);
- // to work faster...
- TColStd_Array1OfInteger& thearr = myIndexes->ChangeArray1();
-
- // indices from 1 to N are loaded
- Standard_Integer I ;
- for (I=1; I <= anExtent; I++)
- thearr(I)=I;
-
- std::sort (thearr.begin(), thearr.end(), CompareResults (mystored));
-
+ TColStd_Array1OfInteger& anIndexArray = myIndexes->ChangeArray1();
+ for (Standard_Integer anIndexIter = 1; anIndexIter <= anExtent; ++anIndexIter)
+ {
+ anIndexArray.SetValue (anIndexIter, anIndexIter);
+ }
+ std::sort (anIndexArray.begin(), anIndexArray.end(), CompareResults (mystored));
}
//=======================================================================
{
if (!myMapOfObjectSensitives.IsBound (theObject))
{
- if (!theObject->TransformPersistence().Flags)
- {
- mySelectableObjects.Append (theObject);
- }
- else
- {
- mySelectableObjectsTrsfPers.Append (theObject);
- }
-
- NCollection_Handle<SelectMgr_SensitiveEntitySet> anEntitySet = new SelectMgr_SensitiveEntitySet();
+ mySelectableObjects.Append (theObject);
+ Handle(SelectMgr_SensitiveEntitySet) anEntitySet = new SelectMgr_SensitiveEntitySet (myEntitySetBuilder);
myMapOfObjectSensitives.Bind (theObject, anEntitySet);
}
}
void SelectMgr_ViewerSelector::AddSelectionToObject (const Handle(SelectMgr_SelectableObject)& theObject,
const Handle(SelectMgr_Selection)& theSelection)
{
- if (myMapOfObjectSensitives.IsBound (theObject))
+ if (Handle(SelectMgr_SensitiveEntitySet)* anEntitySet = myMapOfObjectSensitives.ChangeSeek (theObject))
{
- NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
- myMapOfObjectSensitives.ChangeFind (theObject);
- anEntitySet->Append (theSelection);
- anEntitySet->BVH();
+ (*anEntitySet)->Append (theSelection);
+ (*anEntitySet)->BVH();
}
else
{
//=======================================================================
void SelectMgr_ViewerSelector::MoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
{
- if (!mySelectableObjects.Remove (theObject))
- {
- mySelectableObjectsTrsfPers.Remove (theObject);
- }
-
- if (!theObject->TransformPersistence().Flags)
- {
- mySelectableObjects.Append (theObject);
- }
- else
- {
- mySelectableObjectsTrsfPers.Append (theObject);
- }
+ mySelectableObjects.ChangeSubset (theObject);
}
//=======================================================================
//=======================================================================
void SelectMgr_ViewerSelector::RemoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
{
- if (myMapOfObjectSensitives.IsBound (theObject))
+ Handle(SelectMgr_SelectableObject) anObj = theObject;
+ if (myMapOfObjectSensitives.UnBind (theObject))
{
- if (!mySelectableObjects.Remove (theObject))
- {
- mySelectableObjectsTrsfPers.Remove (theObject);
- }
- myMapOfObjectSensitives.UnBind (theObject);
+ mySelectableObjects.Remove (theObject);
}
}
void SelectMgr_ViewerSelector::RemoveSelectionOfObject (const Handle(SelectMgr_SelectableObject)& theObject,
const Handle(SelectMgr_Selection)& theSelection)
{
- if (myMapOfObjectSensitives.IsBound (theObject))
+ if (Handle(SelectMgr_SensitiveEntitySet)* anEntitySet = myMapOfObjectSensitives.ChangeSeek (theObject))
{
- NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
- myMapOfObjectSensitives.ChangeFind (theObject);
- anEntitySet->Remove (theSelection);
+ (*anEntitySet)->Remove (theSelection);
}
}
void SelectMgr_ViewerSelector::RebuildObjectsTree (const Standard_Boolean theIsForce)
{
mySelectableObjects.MarkDirty();
- mySelectableObjectsTrsfPers.MarkDirty();
if (theIsForce)
{
- const Graphic3d_Mat4d& aProjection = mySelectingVolumeMgr.ProjectionMatrix();
- const Graphic3d_Mat4d& aWorldView = mySelectingVolumeMgr.WorldViewMatrix();
- const Graphic3d_WorldViewProjState& aWVPState = mySelectingVolumeMgr.WorldViewProjState();
- Standard_Integer aViewportWidth;
- Standard_Integer aViewportHeight;
+ Standard_Integer aViewportWidth, aViewportHeight;
mySelectingVolumeMgr.WindowSize (aViewportWidth, aViewportHeight);
- mySelectableObjects.BVH();
- mySelectableObjectsTrsfPers.BVH (mySelectingVolumeMgr.Camera(), aProjection, aWorldView, aViewportWidth, aViewportHeight, aWVPState);
+ Standard_Integer aWidth;
+ Standard_Integer aHeight;
+ mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
+ mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
+ mySelectingVolumeMgr.ProjectionMatrix(),
+ mySelectingVolumeMgr.WorldViewMatrix(),
+ mySelectingVolumeMgr.WorldViewProjState(),
+ aWidth, aHeight);
}
}
if (!Contains (theObject))
return;
- NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
+ Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
anEntitySet->MarkDirty();
if (theIsForce)
//=======================================================================
void SelectMgr_ViewerSelector::ResetSelectionActivationStatus()
{
- SelectMgr_MapOfObjectSensitivesIterator aSensitivesIter (myMapOfObjectSensitives);
- for ( ; aSensitivesIter.More(); aSensitivesIter.Next())
+ for (SelectMgr_MapOfObjectSensitivesIterator aSensitivesIter (myMapOfObjectSensitives); aSensitivesIter.More(); aSensitivesIter.Next())
{
- NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
- aSensitivesIter.ChangeValue();
- Standard_Integer anEntitiesNb = anEntitySet->Size();
+ Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = aSensitivesIter.ChangeValue();
+ const Standard_Integer anEntitiesNb = anEntitySet->Size();
for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
{
anEntitySet->GetSensitiveById (anIdx)->ResetSelectionActiveStatus();
{
for (SelectMgr_MapOfObjectSensitivesIterator anIter (myMapOfObjectSensitives); anIter.More(); anIter.Next())
{
- const NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet = anIter.Value();
- Standard_Integer anEntitiesNb = anEntitySet->Size();
+ const Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = anIter.Value();
+ const Standard_Integer anEntitiesNb = anEntitySet->Size();
for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
{
- if (anEntitySet->GetSensitiveById (anIdx)->IsActiveForSelection())
+ const Handle(SelectMgr_SensitiveEntity)& aSensitive = anEntitySet->GetSensitiveById (anIdx);
+ if (aSensitive->IsActiveForSelection())
{
- theOwners.Append (anEntitySet->GetSensitiveById (anIdx)->BaseSensitive()->OwnerId());
+ theOwners.Append (aSensitive->BaseSensitive()->OwnerId());
}
}
}