0028789: Visualization, TKV3d - extend API for accessing and assigning BVH builders
authorkgv <kgv@opencascade.com>
Fri, 26 May 2017 07:45:22 +0000 (10:45 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 9 Jun 2017 09:59:11 +0000 (12:59 +0300)
Several methods in Selection classes have been moved to header files for better inlining.

BVH_Constants - added new enumeration defining common constant values used with BVH trees.
BVH - replaced NCollection_Handle with Standard_Transient handle
in classes BVH_Properties, BVH_Builder, BVH_Tree, BVH_Object.

Defined global BVH-builders instead of allocating a new one for each object set.
SelectMgr_ViewerSelector - added new method ::SetEntitySetBuilder() defining
default BVH Tree builder for SelectMgr_SensitiveEntitySet.

Added new method SelectMgr_SensitiveEntitySet::SetBuilder()
for overriding default BVH tree builder.

54 files changed:
dox/dev_guides/upgrade/upgrade.md
src/BRepExtrema/BRepExtrema_OverlapTool.cxx
src/BRepExtrema/BRepExtrema_TriangleSet.cxx
src/BRepExtrema/BRepExtrema_TriangleSet.hxx
src/BVH/BVH.cxx
src/BVH/BVH_BinnedBuilder.hxx
src/BVH/BVH_Box.hxx
src/BVH/BVH_Builder.hxx
src/BVH/BVH_Constants.hxx [new file with mode: 0644]
src/BVH/BVH_DistanceField.lxx
src/BVH/BVH_Geometry.hxx
src/BVH/BVH_LinearBuilder.hxx
src/BVH/BVH_Object.hxx
src/BVH/BVH_ObjectSet.hxx
src/BVH/BVH_PrimitiveSet.hxx
src/BVH/BVH_PrimitiveSet3d.hxx [new file with mode: 0644]
src/BVH/BVH_Properties.cxx
src/BVH/BVH_Properties.hxx
src/BVH/BVH_RadixSorter.hxx
src/BVH/BVH_SpatialMedianBuilder.hxx
src/BVH/BVH_SweepPlaneBuilder.hxx
src/BVH/BVH_Tree.hxx
src/BVH/BVH_Triangulation.hxx
src/BVH/BVH_Types.hxx
src/BVH/FILES
src/OpenGl/OpenGl_BVHClipPrimitiveSet.cxx
src/OpenGl/OpenGl_BVHClipPrimitiveSet.hxx
src/OpenGl/OpenGl_BVHClipPrimitiveTrsfPersSet.cxx
src/OpenGl/OpenGl_BVHClipPrimitiveTrsfPersSet.hxx
src/OpenGl/OpenGl_Layer.cxx
src/OpenGl/OpenGl_Layer.hxx
src/OpenGl/OpenGl_LayerList.cxx
src/OpenGl/OpenGl_LayerList.hxx
src/OpenGl/OpenGl_SceneGeometry.cxx [changed mode: 0755->0644]
src/OpenGl/OpenGl_SceneGeometry.hxx [changed mode: 0755->0644]
src/OpenGl/OpenGl_View.cxx
src/OpenGl/OpenGl_View.hxx
src/OpenGl/OpenGl_View_Raytrace.cxx
src/Select3D/FILES
src/Select3D/Select3D_BVHBuilder3d.hxx [new file with mode: 0644]
src/Select3D/Select3D_SensitiveSet.cxx
src/Select3D/Select3D_SensitiveSet.hxx
src/SelectBasics/SelectBasics_SensitiveEntity.cxx
src/SelectBasics/SelectBasics_SensitiveEntity.hxx
src/SelectMgr/SelectMgr_SelectableObjectSet.cxx
src/SelectMgr/SelectMgr_SelectableObjectSet.hxx
src/SelectMgr/SelectMgr_Selection.cxx
src/SelectMgr/SelectMgr_SensitiveEntity.cxx
src/SelectMgr/SelectMgr_SensitiveEntity.hxx
src/SelectMgr/SelectMgr_SensitiveEntitySet.cxx
src/SelectMgr/SelectMgr_SensitiveEntitySet.hxx
src/SelectMgr/SelectMgr_ViewerSelector.cxx
src/SelectMgr/SelectMgr_ViewerSelector.hxx
src/StdSelect/StdSelect_BRepSelectionTool.cxx

index f26694e..6c317a4 100644 (file)
@@ -1246,15 +1246,13 @@ In most cases this change should be transparent, however applications implementi
 * Types GeomPlate_Array1OfHCurveOnSurface and GeomPlate_HArray1OfHCurveOnSurface have been replaced with GeomPlate_Array1OfHCurve and GeomPlate_HArray1OfHCurve correspondingly (accept base class Adaptor3d_HCurve instead of Adaptor3d_HCurveOnSurface).
 * Enumeration *Image_PixMap::ImgFormat*, previously declared as nested enumeration within class *Image_PixMap*, has been moved to global namespace as *Image_Format* following OCCT coding rules.
   The enumeration values have suffix Image_Format_ and preserve previous name scheme for easy renaming of old values - e.g. Image_PixMap::ImgGray become Image_Format_Gray.
-<<<<<<< HEAD
   Old definitions are preserved as depreacated aliases to the new ones;
 * The method BOPAlgo_Builder::Origins() returns BOPCol_DataMapOfShapeListOfShape instead of BOPCol_DataMapOfShapeShape.
-=======
-  Old definitions are preserved as depreacated aliases to the new ones.
 * The methods BOPDS_DS::IsToSort(const Handle(BOPDS_CommonBlock)&, Standard_Integer&) and BOPDS_DS::SortPaveBlocks(const Handle(BOPDS_CommonBlock)&) have been removed. The sorting is now performed during the addition of the Pave Blocks into Common Block.
 * The methods BOPAlgo_Tools::MakeBlocks() and BOPAlgo_Tools::MakeBlocksCnx() have been replaced with the single template method BOPAlgo_Tools::MakeBlocks(). The chains of connected elements are now stored into the list of list instead of data map.
 * The methods BOPAlgo_Tools::FillMap() have been replaced with the single template method BOPAlgo_Tools::FillMap().
->>>>>>> 648fab3... 0028259: Method MakeBlocksCnx is duplicated in two different places in BOPAlgo
+* Package BVH now uses opencascade::handle instead of NCollection_Handle (for classes BVH_Properties, BVH_Builder, BVH_Tree, BVH_Object).
+  Application code using BVH package directly should be updated accordingly.
 
 @subsection upgrade_720_BOP_DataStructure BOP - Pairs of interfering indices
 
index 464e1e8..f2600de 100644 (file)
@@ -703,8 +703,8 @@ void BRepExtrema_OverlapTool::Perform (const Standard_Real theTolerance)
 
   BRepExtrema_StackItem aStack[96];
 
-  const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aBVH1 = mySet1->BVH();
-  const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aBVH2 = mySet2->BVH();
+  const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aBVH1 = mySet1->BVH();
+  const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aBVH2 = mySet2->BVH();
 
   if (aBVH1.IsNull() || aBVH2.IsNull())
   {
index ff4b538..bf97180 100644 (file)
 #include <Poly_Triangulation.hxx>
 #include <TColgp_Array1OfPnt2d.hxx>
 
-
-IMPLEMENT_STANDARD_RTTIEXT(BRepExtrema_TriangleSet,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)
 
 //=======================================================================
 //function : BRepExtrema_TriangleSet
 //purpose  : Creates empty triangle set
 //=======================================================================
 BRepExtrema_TriangleSet::BRepExtrema_TriangleSet()
-: BVH_PrimitiveSet<Standard_Real, 3>()
 {
   // Set default builder - linear BVH (LBVH)
-  myBuilder = new BVH_LinearBuilder<Standard_Real, 3> (5, 32);
+  myBuilder = new BVH_LinearBuilder<Standard_Real, 3> (BVH_Constants_LeafNodeSizeDefault, BVH_Constants_MaxTreeDepth);
 }
 
 //=======================================================================
@@ -40,10 +38,9 @@ BRepExtrema_TriangleSet::BRepExtrema_TriangleSet()
 //purpose  : Creates triangle set from the given face
 //=======================================================================
 BRepExtrema_TriangleSet::BRepExtrema_TriangleSet (const BRepExtrema_ShapeList& theFaces)
-: BVH_PrimitiveSet<Standard_Real, 3>()
 {
   // Set default builder - linear BVH (LBVH)
-  myBuilder = new BVH_LinearBuilder<Standard_Real, 3> (5, 32);
+  myBuilder = new BVH_LinearBuilder<Standard_Real, 3> (BVH_Constants_LeafNodeSizeDefault, BVH_Constants_MaxTreeDepth);
 
   Init (theFaces);
 }
index a8b073f..ff43a2e 100644 (file)
 #define _BRepExtrema_TriangleSet_HeaderFile
 
 #include <TopoDS_Face.hxx>
-#include <BVH_PrimitiveSet.hxx>
+#include <BVH_PrimitiveSet3d.hxx>
 
 //! List of shapes and their IDs for collision detection.
 typedef NCollection_Vector<TopoDS_Face> BRepExtrema_ShapeList;
 
 //! Triangle set corresponding to specific face.
-class BRepExtrema_TriangleSet : public BVH_PrimitiveSet<Standard_Real, 3>, public Standard_Transient
+class BRepExtrema_TriangleSet : public BVH_PrimitiveSet3d
 {
 public:
 
@@ -45,7 +45,7 @@ public: //! @name methods implementing BVH set interface
   BVH_Box<Standard_Real, 3> Box (const Standard_Integer theIndex) const Standard_OVERRIDE;
 
   //! Make inherited method Box() visible to avoid CLang warning
-  using BVH_PrimitiveSet<Standard_Real, 3>::Box;
+  using BVH_PrimitiveSet3d::Box;
 
   //! Returns centroid position along specified axis.
   Standard_Real Center (const Standard_Integer theIndex, const Standard_Integer theAxis) const Standard_OVERRIDE;
@@ -83,10 +83,10 @@ protected:
 
 public:
 
-  DEFINE_STANDARD_RTTIEXT(BRepExtrema_TriangleSet,Standard_Transient)
+  DEFINE_STANDARD_RTTIEXT(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)
 
 };
 
-DEFINE_STANDARD_HANDLE (BRepExtrema_TriangleSet, Standard_Transient)
+DEFINE_STANDARD_HANDLE(BRepExtrema_TriangleSet, BVH_PrimitiveSet3d)
 
 #endif // _BRepExtrema_TriangleSet_HeaderFile
index 2301f3f..451fd0c 100644 (file)
 
 #include <Standard_Real.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(BVH_BuilderTransient,  Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BVH_TreeBaseTransient, Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(BVH_ObjectTransient,   Standard_Transient)
+
 // Specific instantiations of struct templates to avoid compilation warnings
 
 template class NCollection_Vec2<Standard_Real>;
index eb21a8d..e8cf2fe 100644 (file)
@@ -43,7 +43,7 @@ struct BVH_Bin
 //! performance is provided even for 4 - 8 bins (it is only 10-20% lower
 //! in comparison with optimal settings). Note that multiple threads can
 //! be used only with thread safe BVH primitive sets.
-template<class T, int N, int Bins = 32>
+template<class T, int N, int Bins = BVH_Constants_NbBinsOptimal>
 class BVH_BinnedBuilder : public BVH_QueueBuilder<T, N>
 {
 public:
@@ -64,9 +64,9 @@ public:
 public:
 
   //! Creates binned SAH BVH builder.
-  BVH_BinnedBuilder (const Standard_Integer theLeafNodeSize = 5,
-                     const Standard_Integer theMaxTreeDepth = 32,
-                     const Standard_Boolean theDoMainSplits = 0,
+  BVH_BinnedBuilder (const Standard_Integer theLeafNodeSize = BVH_Constants_LeafNodeSizeDefault,
+                     const Standard_Integer theMaxTreeDepth = BVH_Constants_MaxTreeDepth,
+                     const Standard_Boolean theDoMainSplits = Standard_False,
                      const Standard_Integer theNumOfThreads = 1)
   : BVH_QueueBuilder<T, N> (theLeafNodeSize, theMaxTreeDepth, theNumOfThreads),
     myUseMainAxis (theDoMainSplits)
index 537b4f7..8210aa3 100644 (file)
@@ -16,6 +16,7 @@
 #ifndef _BVH_Box_Header
 #define _BVH_Box_Header
 
+#include <BVH_Constants.hxx>
 #include <BVH_Types.hxx>
 #include <Standard_ShortReal.hxx>
 
index 571767e..a45d599 100644 (file)
 #include <BVH_Set.hxx>
 #include <BVH_BinaryTree.hxx>
 
-namespace BVH
+//! A non-template class for using as base for BVH_Builder
+//! (just to have a named base class).
+class BVH_BuilderTransient : public Standard_Transient
 {
-  //! Minimum node size to split.
-  const Standard_Real THE_NODE_MIN_SIZE = 1e-5;
-}
+  DEFINE_STANDARD_RTTIEXT(BVH_BuilderTransient, Standard_Transient)
+public:
+
+  //! Returns the maximum depth of constructed BVH.
+  Standard_Integer MaxTreeDepth() const { return myMaxTreeDepth; }
+
+  //! Returns the maximum number of sub-elements in the leaf.
+  Standard_Integer LeafNodeSize() const { return myLeafNodeSize; }
+
+protected:
+
+  //! Creates new abstract BVH builder.
+  BVH_BuilderTransient (const Standard_Integer theLeafNodeSize,
+                        const Standard_Integer theMaxTreeDepth)
+  : myMaxTreeDepth (theMaxTreeDepth),
+    myLeafNodeSize (theLeafNodeSize) {}
+
+protected:
+
+  Standard_Integer myMaxTreeDepth; //!< Maximum depth of constructed BVH
+  Standard_Integer myLeafNodeSize; //!< Maximum number of objects per leaf
+
+};
 
 //! Performs construction of BVH tree using bounding
 //! boxes (AABBs) of abstract objects.
 //! \tparam T Numeric data type
 //! \tparam N Vector dimension
 template<class T, int N>
-class BVH_Builder
+class BVH_Builder : public BVH_BuilderTransient
 {
 public:
 
-  //! Creates new abstract BVH builder.
-  BVH_Builder (const Standard_Integer theLeafNodeSize,
-               const Standard_Integer theMaxTreeDepth)
-  : myMaxTreeDepth (theMaxTreeDepth),
-    myLeafNodeSize (theLeafNodeSize) {}
-
-  //! Releases resources of BVH builder.
-  virtual ~BVH_Builder() {}
-
   //! Builds BVH using specific algorithm.
   virtual void Build (BVH_Set<T, N>*       theSet,
                       BVH_Tree<T, N>*      theBVH,
@@ -50,6 +63,11 @@ public:
 
 protected:
 
+  //! Creates new abstract BVH builder.
+  BVH_Builder (const Standard_Integer theLeafNodeSize,
+               const Standard_Integer theMaxTreeDepth)
+  : BVH_BuilderTransient (theLeafNodeSize, theMaxTreeDepth) {}
+
   //! Updates depth of constructed BVH tree.
   void updateDepth (BVH_Tree<T, N>*        theBVH,
                     const Standard_Integer theLevel) const
@@ -60,11 +78,6 @@ protected:
     }
   }
 
-protected:
-
-  Standard_Integer myMaxTreeDepth; //!< Maximum depth of constructed BVH
-  Standard_Integer myLeafNodeSize; //!< Maximum number of objects per leaf
-
 };
 
 #endif // _BVH_Builder_Header
diff --git a/src/BVH/BVH_Constants.hxx b/src/BVH/BVH_Constants.hxx
new file mode 100644 (file)
index 0000000..db5e170
--- /dev/null
@@ -0,0 +1,45 @@
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// 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.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BVH_Constants_Header
+#define _BVH_Constants_Header
+
+enum
+{
+  //! The optimal tree depth.
+  //! Should be in sync with maximum stack size while traversing the tree - don't pass the trees of greater depth to OCCT algorithms!
+  BVH_Constants_MaxTreeDepth       = 32,
+
+  //! Leaf node size optimal for complex nodes,
+  //! e.g. for upper-level BVH trees within multi-level structure (nodes point to another BVH trees).
+  BVH_Constants_LeafNodeSizeSingle  = 1,
+  //! Average leaf node size (4 primitive per leaf), optimal for average tree nodes.
+  BVH_Constants_LeafNodeSizeAverage = 4,
+  //! Default leaf node size (5 primitives per leaf).
+  BVH_Constants_LeafNodeSizeDefault = 5,
+  //! Leaf node size (8 primitives per leaf), optimal for small tree nodes (e.g. triangles).
+  BVH_Constants_LeafNodeSizeSmall   = 8,
+
+  //! The optimal number of bins for binned builder.
+  BVH_Constants_NbBinsOptimal       = 32,
+  //! The maximum number of bins for binned builder (giving the best traversal time at cost of longer tree construction time).
+  BVH_Constants_NbBinsBest          = 48,
+};
+
+namespace BVH
+{
+  //! Minimum node size to split.
+  const double THE_NODE_MIN_SIZE = 1e-5;
+}
+
+#endif // _BVH_Constants_Header
index c3678bc..f4ddd36 100644 (file)
@@ -190,14 +190,13 @@ namespace BVH
     Standard_ASSERT_RETURN (aTriangulation != NULL,
       "Error: Unsupported BVH object (non triangulation)", aMinDistance);
 
-    const NCollection_Handle<BVH_Tree<T, N> >& aBVH = aTriangulation->BVH();
-
+    const opencascade::handle<BVH_Tree<T, N> >& aBVH = aTriangulation->BVH();
     if (aBVH.IsNull())
     {
       return Standard_False;
     }
 
-    std::pair<Standard_Integer, T> aStack[32];
+    std::pair<Standard_Integer, T> aStack[BVH_Constants_MaxTreeDepth];
 
     Standard_Integer aHead = -1;
     Standard_Integer aNode =  0; // root node
@@ -318,7 +317,7 @@ namespace BVH
       return Standard_False;
     }
 
-    std::pair<Standard_Integer, T> aStack[32];
+    std::pair<Standard_Integer, T> aStack[BVH_Constants_MaxTreeDepth];
 
     Standard_Integer aHead = -1;
     Standard_Integer aNode =  0; // root node
index 8cf2162..b7d8064 100644 (file)
@@ -32,10 +32,20 @@ public:
   //! Creates uninitialized BVH geometry.
   BVH_Geometry()
   : myIsDirty (Standard_False),
-    myBVH (new BVH_Tree<T, N>())
+    myBVH (new BVH_Tree<T, N>()),
+    // set default builder - binned SAH split
+    myBuilder (new BVH_BinnedBuilder<T, N, BVH_Constants_NbBinsOptimal> (BVH_Constants_LeafNodeSizeSingle))
   {
-    // Set default builder - binned SAH split
-    myBuilder = new BVH_BinnedBuilder<T, N, 32> (1 /* primitive per leaf */);
+    //
+  }
+
+  //! Creates uninitialized BVH geometry.
+  BVH_Geometry (const opencascade::handle<BVH_Builder<T, N> >& theBuilder)
+  : myIsDirty (Standard_False),
+    myBVH (new BVH_Tree<T, N>()),
+    myBuilder (theBuilder)
+  {
+    //
   }
 
   //! Releases resources of BVH geometry.
@@ -64,7 +74,7 @@ public:
   }
 
   //! Returns BVH tree (and builds it if necessary).
-  virtual const NCollection_Handle<BVH_Tree<T, N> >& BVH()
+  virtual const opencascade::handle<BVH_Tree<T, N> >& BVH()
   {
     if (myIsDirty)
     {
@@ -74,10 +84,10 @@ public:
   }
 
   //! Returns the method (builder) used to construct BVH.
-  virtual const NCollection_Handle<BVH_Builder<T, N> >& Builder() const { return myBuilder; }
+  virtual const opencascade::handle<BVH_Builder<T, N> >& Builder() const { return myBuilder; }
 
   //! Sets the method (builder) used to construct BVH.
-  virtual void SetBuilder (const NCollection_Handle<BVH_Builder<T, N> >& theBuilder) { myBuilder = theBuilder; }
+  virtual void SetBuilder (const opencascade::handle<BVH_Builder<T, N> >& theBuilder) { myBuilder = theBuilder; }
 
 protected:
 
@@ -93,9 +103,9 @@ protected:
 
 protected:
 
-  Standard_Boolean                       myIsDirty; //!< Is geometry state outdated?
-  NCollection_Handle<BVH_Tree<T, N> >    myBVH;     //!< Constructed hight-level BVH
-  NCollection_Handle<BVH_Builder<T, N> > myBuilder; //!< Builder for hight-level BVH
+  Standard_Boolean                        myIsDirty; //!< Is geometry state outdated?
+  opencascade::handle<BVH_Tree<T, N> >    myBVH;     //!< Constructed hight-level BVH
+  opencascade::handle<BVH_Builder<T, N> > myBuilder; //!< Builder for hight-level BVH
 
   mutable BVH_Box<T, N> myBox; //!< Cached bounding box of geometric objects
 
index 3dd7c4f..c2aee79 100644 (file)
@@ -39,8 +39,8 @@ public:
 public:
 
   //! Creates binned LBVH builder.
-  BVH_LinearBuilder (const Standard_Integer theLeafNodeSize = 5,
-                     const Standard_Integer theMaxTreeDepth = 32);
+  BVH_LinearBuilder (const Standard_Integer theLeafNodeSize = BVH_Constants_LeafNodeSizeDefault,
+                     const Standard_Integer theMaxTreeDepth = BVH_Constants_MaxTreeDepth);
 
   //! Releases resources of LBVH builder.
   virtual ~BVH_LinearBuilder();
index 0a265ff..22b317f 100644 (file)
 #include <BVH_Box.hxx>
 #include <BVH_Properties.hxx>
 
-#include <NCollection_Handle.hxx>
+//! A non-template class for using as base for BVH_Object
+//! (just to have a named base class).
+class BVH_ObjectTransient : public Standard_Transient
+{
+  DEFINE_STANDARD_RTTIEXT(BVH_ObjectTransient, Standard_Transient)
+public:
+
+  //! Returns properties of the geometric object.
+  virtual const Handle(BVH_Properties)& Properties() const { return myProperties; }
+
+  //! Sets properties of the geometric object.
+  virtual void SetProperties (const Handle(BVH_Properties)& theProperties) { myProperties = theProperties; }
+
+  //! Marks object state as outdated (needs BVH rebuilding).
+  virtual void MarkDirty() { myIsDirty = Standard_True; }
+
+protected:
+
+  //! Creates new abstract geometric object.
+  BVH_ObjectTransient() : myIsDirty (Standard_False) {}
+
+protected:
+
+  Standard_Boolean       myIsDirty;    //!< Marks internal object state as outdated
+  Handle(BVH_Properties) myProperties; //!< Generic properties assigned to the object
+
+};
 
 //! Abstract geometric object bounded by BVH box.
 //! \tparam T Numeric data type
 //! \tparam N Vector dimension
 template<class T, int N>
-class BVH_Object
+class BVH_Object : public BVH_ObjectTransient
 {
 public:
 
   //! Creates new abstract geometric object.
-  BVH_Object() : myIsDirty (Standard_False) {}
+  BVH_Object() {}
 
   //! Releases resources of geometric object.
   virtual ~BVH_Object() = 0;
@@ -40,20 +66,6 @@ public:
   //! Returns AABB of the geometric object.
   virtual BVH_Box<T, N> Box() const = 0;
 
-  //! Returns properties of the geometric object.
-  virtual const NCollection_Handle<BVH_Properties>& Properties() const { return myProperties; }
-
-  //! Sets properties of the geometric object.
-  virtual void SetProperties (const NCollection_Handle<BVH_Properties>& theProperties) { myProperties = theProperties; }
-
-  //! Marks object state as outdated (needs BVH rebuilding).
-  virtual void MarkDirty() { myIsDirty = Standard_True; }
-
-protected:
-
-  Standard_Boolean                   myIsDirty;    //!< Marks internal object state as outdated
-  NCollection_Handle<BVH_Properties> myProperties; //!< Generic properties assigned to the object
-
 };
 
 // =======================================================================
index 9cbd9ae..9a89fcf 100644 (file)
@@ -28,7 +28,7 @@ class BVH_ObjectSet : public BVH_Set<T, N>
 public:
 
   //! Type of array of geometric objects.
-  typedef NCollection_Vector<NCollection_Handle<BVH_Object<T, N> > > BVH_ObjectList;
+  typedef NCollection_Vector<opencascade::handle<BVH_Object<T, N> > > BVH_ObjectList;
 
 public:
 
index 3ed9b57..728d946 100644 (file)
@@ -36,14 +36,23 @@ protected:
   using BVH_Set<T, N>::Box;
 
 public:
-  static const Standard_Integer MaxTreeDepth = 32;
+  static const Standard_Integer MaxTreeDepth = BVH_Constants_MaxTreeDepth;
 
   //! Creates set of abstract primitives.
   BVH_PrimitiveSet()
-  : myBVH (new BVH_Tree<T, N>())
+  : myBVH (new BVH_Tree<T, N>()),
+    // set default builder - binned SAH split
+    myBuilder (new BVH_BinnedBuilder<T, N, BVH_Constants_NbBinsBest> (BVH_Constants_LeafNodeSizeDefault, BVH_Constants_MaxTreeDepth))
   {
-    // Set default builder - binned SAH split
-    myBuilder = new BVH_BinnedBuilder<T, N, 48> (5, MaxTreeDepth);
+    //
+  }
+
+  //! Creates set of abstract primitives.
+  BVH_PrimitiveSet (const opencascade::handle<BVH_Builder<T, N> >& theBuilder)
+  : myBVH (new BVH_Tree<T, N>()),
+    myBuilder (theBuilder)
+  {
+    //
   }
 
   //! Releases resources of set of abstract primitives.
@@ -66,7 +75,7 @@ public:
   }
 
   //! Returns BVH tree (and builds it if necessary).
-  virtual const NCollection_Handle<BVH_Tree<T, N> >& BVH()
+  virtual const opencascade::handle<BVH_Tree<T, N> >& BVH()
   {
     if (BVH_Object<T, N>::myIsDirty)
     {
@@ -76,10 +85,10 @@ public:
   }
 
   //! Returns the method (builder) used to construct BVH.
-  virtual const NCollection_Handle<BVH_Builder<T, N> >& Builder() const { return myBuilder; }
+  virtual const opencascade::handle<BVH_Builder<T, N> >& Builder() const { return myBuilder; }
 
   //! Sets the method (builder) used to construct BVH.
-  virtual void SetBuilder (const NCollection_Handle<BVH_Builder<T, N> >& theBuilder) { myBuilder = theBuilder; }
+  virtual void SetBuilder (const opencascade::handle<BVH_Builder<T, N> >& theBuilder) { myBuilder = theBuilder; }
 
 protected:
 
@@ -95,8 +104,8 @@ protected:
 
 protected:
 
-  NCollection_Handle<BVH_Tree<T, N> >    myBVH;     //!< Constructed bottom-level BVH
-  NCollection_Handle<BVH_Builder<T, N> > myBuilder; //!< Builder for bottom-level BVH
+  opencascade::handle<BVH_Tree<T, N> >    myBVH;     //!< Constructed bottom-level BVH
+  opencascade::handle<BVH_Builder<T, N> > myBuilder; //!< Builder for bottom-level BVH
 
   mutable BVH_Box<T, N> myBox; //!< Cached bounding box of geometric primitives
 
diff --git a/src/BVH/BVH_PrimitiveSet3d.hxx b/src/BVH/BVH_PrimitiveSet3d.hxx
new file mode 100644 (file)
index 0000000..5623808
--- /dev/null
@@ -0,0 +1,21 @@
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// 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.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _BVH_PrimitiveSet3d_Header
+#define _BVH_PrimitiveSet3d_Header
+
+#include <BVH_PrimitiveSet.hxx>
+
+typedef BVH_PrimitiveSet<Standard_Real, 3> BVH_PrimitiveSet3d;
+
+#endif // _BVH_PrimitiveSet3d_Header
index 33d7a2c..ff84b40 100644 (file)
 
 #include <BVH_Properties.hxx>
 
-//! Abstract properties of geometric object.
+IMPLEMENT_STANDARD_RTTIEXT(BVH_Properties, Standard_Transient)
+
+// =======================================================================
+// function : ~BVH_Properties
+// purpose  :
+// =======================================================================
 BVH_Properties::~BVH_Properties()
 {
   //
-}
\ No newline at end of file
+}
index 9a0e923..2c09d97 100644 (file)
@@ -21,8 +21,9 @@
 #include <Standard_Macro.hxx>
 
 //! Abstract properties of geometric object.
-class BVH_Properties
+class BVH_Properties : public Standard_Transient
 {
+  DEFINE_STANDARD_RTTIEXT(BVH_Properties, Standard_Transient)
 public:
 
   //! Releases resources of object properties.
index a3cec78..83acb45 100644 (file)
@@ -18,8 +18,8 @@
 
 #include <BVH_Sorter.hxx>
 #include <BVH_Builder.hxx>
-#include <NCollection_Handle.hxx>
 #include <NCollection_Array1.hxx>
+#include <NCollection_Shared.hxx>
 
 #include <algorithm>
 
@@ -67,7 +67,7 @@ protected:
   BVH_Box<T, N> myBox;
 
   //! Morton codes assigned to BVH primitives.
-  NCollection_Handle<NCollection_Array1<BVH_EncodedLink> > myEncodedLinks;
+  Handle(NCollection_Shared<NCollection_Array1<BVH_EncodedLink> >) myEncodedLinks;
 
 };
 
@@ -186,7 +186,7 @@ void BVH_RadixSorter<T, N>::Perform (BVH_Set<T, N>* theSet, const Standard_Integ
   const T aReverseSizeY = static_cast<T> (aDimensionY) / Max (static_cast<T> (BVH::THE_NODE_MIN_SIZE), aSceneMax.y() - aSceneMin.y());
   const T aReverseSizeZ = static_cast<T> (aDimensionZ) / Max (static_cast<T> (BVH::THE_NODE_MIN_SIZE), aSceneMax.z() - aSceneMin.z());
 
-  myEncodedLinks = new NCollection_Array1<BVH_EncodedLink> (theStart, theFinal);
+  myEncodedLinks = new NCollection_Shared<NCollection_Array1<BVH_EncodedLink> >(theStart, theFinal);
 
   // Step 1 -- Assign Morton code to each primitive
   for (Standard_Integer aPrimIdx = theStart; aPrimIdx <= theFinal; ++aPrimIdx)
index 503c357..57b3f54 100644 (file)
@@ -26,8 +26,8 @@ class BVH_SpatialMedianBuilder : public BVH_BinnedBuilder<T, N, 2>
 public:
 
   //! Creates spatial median split builder.
-  BVH_SpatialMedianBuilder (const Standard_Integer theLeafNodeSize = 5,
-                            const Standard_Integer theMaxTreeDepth = 32,
+  BVH_SpatialMedianBuilder (const Standard_Integer theLeafNodeSize = BVH_Constants_LeafNodeSizeDefault,
+                            const Standard_Integer theMaxTreeDepth = BVH_Constants_MaxTreeDepth,
                             const Standard_Boolean theToUseMainAxis = Standard_False)
   : BVH_BinnedBuilder<T, N, 2> (theLeafNodeSize,
                                 theMaxTreeDepth,
index 63921a8..4b4f3a0 100644 (file)
@@ -27,8 +27,8 @@ class BVH_SweepPlaneBuilder : public BVH_QueueBuilder<T, N>
 public:
 
   //! Creates sweep plane SAH BVH builder.
-  BVH_SweepPlaneBuilder (const Standard_Integer theLeafNodeSize = 5,
-                         const Standard_Integer theMaxTreeDepth = 32,
+  BVH_SweepPlaneBuilder (const Standard_Integer theLeafNodeSize = BVH_Constants_LeafNodeSizeDefault,
+                         const Standard_Integer theMaxTreeDepth = BVH_Constants_MaxTreeDepth,
                          const Standard_Integer theNumOfThreads = 1)
   : BVH_QueueBuilder<T, N> (theLeafNodeSize,
                             theMaxTreeDepth,
index 076b9f0..a223d14 100644 (file)
 
 template<class T, int N> class BVH_Builder;
 
+//! A non-template class for using as base for BVH_TreeBase
+//! (just to have a named base class).
+class BVH_TreeBaseTransient : public Standard_Transient
+{
+  DEFINE_STANDARD_RTTIEXT(BVH_TreeBaseTransient, Standard_Transient)
+protected:
+  BVH_TreeBaseTransient() {}
+};
+
 //! Stores parameters of bounding volume hierarchy (BVH).
 //! Bounding volume hierarchy (BVH) organizes geometric objects in
 //! the tree based on spatial relationships. Each node in the tree
@@ -29,7 +38,7 @@ template<class T, int N> class BVH_Builder;
 //! such as collision detection, ray-tracing, searching of nearest
 //! objects, and view frustum culling.
 template<class T, int N>
-class BVH_TreeBase
+class BVH_TreeBase : public BVH_TreeBaseTransient
 {
   friend class BVH_Builder<T, N>;
 
index 9a33e03..d4e3dc3 100644 (file)
@@ -33,6 +33,13 @@ public:
   //! Creates empty triangulation.
   BVH_Triangulation() {}
 
+  //! Creates empty triangulation.
+  BVH_Triangulation (const opencascade::handle<BVH_Builder<T, N> >& theBuilder)
+  : BVH_PrimitiveSet<T, N> (theBuilder)
+  {
+    //
+  }
+
   //! Releases resources of triangulation.
   virtual ~BVH_Triangulation() {}
 
index a556672..70dc9bf 100644 (file)
@@ -25,6 +25,7 @@
 #include <NCollection_Vec2.hxx>
 #include <NCollection_Vec3.hxx>
 #include <NCollection_Vector.hxx>
+#include <Standard_Type.hxx>
 
 // GCC supports shrink function only in C++11 mode
 #if defined(_BVH_USE_STD_VECTOR_) && defined(_MSC_VER) && !defined(__INTEL_COMPILER)
index 0bab64b..a563d1f 100644 (file)
@@ -6,6 +6,7 @@ BVH_BuildQueue.hxx
 BVH_BuildQueue.cxx
 BVH_BuildThread.hxx
 BVH_BuildThread.cxx
+BVH_Constants.hxx
 BVH_DistanceField.hxx
 BVH_DistanceField.lxx
 BVH_Geometry.hxx
@@ -13,6 +14,7 @@ BVH_LinearBuilder.hxx
 BVH_Object.hxx
 BVH_ObjectSet.hxx
 BVH_PrimitiveSet.hxx
+BVH_PrimitiveSet3d.hxx
 BVH_Properties.cxx
 BVH_Properties.hxx
 BVH_QueueBuilder.hxx
index 0339b5f..1fe7c08 100644 (file)
 #include <BVH_BinnedBuilder.hxx>
 #include <Graphic3d_GraphicDriver.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_BVHClipPrimitiveSet, BVH_PrimitiveSet3d)
+
 // =======================================================================
 // function : OpenGl_BVHClipPrimitiveSet
 // purpose  :
 // =======================================================================
 OpenGl_BVHClipPrimitiveSet::OpenGl_BVHClipPrimitiveSet()
 {
-  myBuilder = new BVH_BinnedBuilder<Standard_Real, 3> (1, 32);
+  myBuilder = new BVH_BinnedBuilder<Standard_Real, 3> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth);
 }
 
 // =======================================================================
index 03a710f..64cd4ca 100644 (file)
 #ifndef _OpenGl_BVHClipPrimitiveSet_HeaderFile
 #define _OpenGl_BVHClipPrimitiveSet_HeaderFile
 
-#include <BVH_PrimitiveSet.hxx>
+#include <BVH_PrimitiveSet3d.hxx>
 #include <NCollection_Array1.hxx>
 #include <NCollection_IndexedMap.hxx>
 
 #include <OpenGl_Structure.hxx>
 
 //! Set of OpenGl_Structures for building BVH tree.
-class OpenGl_BVHClipPrimitiveSet : public BVH_PrimitiveSet<Standard_Real, 3>
+class OpenGl_BVHClipPrimitiveSet : public BVH_PrimitiveSet3d
 {
+  DEFINE_STANDARD_RTTIEXT(OpenGl_BVHClipPrimitiveSet, BVH_PrimitiveSet3d)
 protected:
 
-  using BVH_PrimitiveSet<Standard_Real, 3>::Box;
+  using BVH_PrimitiveSet3d::Box;
 
 public:
 
index 1798a54..82576bf 100644 (file)
 // commercial license or contractual agreement.
 
 #include <OpenGl_BVHClipPrimitiveTrsfPersSet.hxx>
-#include <BVH_LinearBuilder.hxx>
 
 // =======================================================================
 // function : OpenGl_BVHClipPrimitiveTrsfPersSet
 // purpose  :
 // =======================================================================
-OpenGl_BVHClipPrimitiveTrsfPersSet::OpenGl_BVHClipPrimitiveTrsfPersSet()
+OpenGl_BVHClipPrimitiveTrsfPersSet::OpenGl_BVHClipPrimitiveTrsfPersSet (const Handle(Select3D_BVHBuilder3d)& theBuilder)
 : myIsDirty (Standard_False),
-  myBVH (new BVH_Tree<Standard_Real, 3>())
+  myBVH (new BVH_Tree<Standard_Real, 3>()),
+  myBuilder (theBuilder)
 {
-  myBuilder = new BVH_LinearBuilder<Standard_Real, 3> (1, 32);
+  //
 }
 
 // =======================================================================
@@ -131,7 +131,7 @@ const OpenGl_Structure* OpenGl_BVHClipPrimitiveTrsfPersSet::GetStructureById (St
 // function : BVH
 // purpose  :
 //=======================================================================
-const NCollection_Handle<BVH_Tree<Standard_Real, 3> >&
+const opencascade::handle<BVH_Tree<Standard_Real, 3> >&
   OpenGl_BVHClipPrimitiveTrsfPersSet::BVH (const Handle(Graphic3d_Camera)& theCamera,
                                            const OpenGl_Mat4d& theProjectionMatrix,
                                            const OpenGl_Mat4d& theWorldViewMatrix,
index 4ddf92c..aa73e30 100644 (file)
@@ -16,7 +16,6 @@
 #ifndef _OpenGl_BVHClipPrimitiveTrsfPersSet_HeaderFile
 #define _OpenGl_BVHClipPrimitiveTrsfPersSet_HeaderFile
 
-#include <BVH_Builder.hxx>
 #include <BVH_Set.hxx>
 #include <BVH_Tree.hxx>
 #include <Graphic3d_BndBox4f.hxx>
@@ -25,6 +24,7 @@
 #include <NCollection_IndexedMap.hxx>
 #include <OpenGl_Structure.hxx>
 #include <OpenGl_Vec.hxx>
+#include <Select3D_BVHBuilder3d.hxx>
 
 //! Set of transformation persistent OpenGl_Structure for building BVH tree.
 //! Provides built-in mechanism to invalidate tree when world view projection state changes.
@@ -39,7 +39,7 @@ private:
 public:
 
   //! Creates an empty primitive set for BVH clipping.
-  OpenGl_BVHClipPrimitiveTrsfPersSet();
+  OpenGl_BVHClipPrimitiveTrsfPersSet (const Handle(Select3D_BVHBuilder3d)& theBuilder);
 
   //! Returns total number of structures.
   virtual Standard_Integer Size() const Standard_OVERRIDE;
@@ -76,12 +76,18 @@ public:
   }
 
   //! Returns BVH tree for the given world view projection (builds it if necessary).
-  const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& BVH (const Handle(Graphic3d_Camera)& theCamera,
-                                                              const OpenGl_Mat4d& theProjectionMatrix,
-                                                              const OpenGl_Mat4d& theWorldViewMatrix,
-                                                              const Standard_Integer theViewportWidth,
-                                                              const Standard_Integer theViewportHeight,
-                                                              const Graphic3d_WorldViewProjState& theWVPState);
+  const opencascade::handle<BVH_Tree<Standard_Real, 3> >& BVH (const Handle(Graphic3d_Camera)& theCamera,
+                                                               const OpenGl_Mat4d& theProjectionMatrix,
+                                                               const OpenGl_Mat4d& theWorldViewMatrix,
+                                                               const Standard_Integer theViewportWidth,
+                                                               const Standard_Integer theViewportHeight,
+                                                               const Graphic3d_WorldViewProjState& theWVPState);
+
+  //! Returns builder for bottom-level BVH.
+  const Handle(Select3D_BVHBuilder3d)& Builder() const { return myBuilder; }
+
+  //! Assigns builder for bottom-level BVH.
+  void SetBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder) { myBuilder = theBuilder; }
 
 private:
 
@@ -89,10 +95,10 @@ private:
   Standard_Boolean myIsDirty;
 
   //! Constructed bottom-level BVH.
-  NCollection_Handle<BVH_Tree<Standard_Real, 3> > myBVH;
+  opencascade::handle<BVH_Tree<Standard_Real, 3> > myBVH;
 
   //! Builder for bottom-level BVH.
-  NCollection_Handle<BVH_Builder<Standard_Real, 3> > myBuilder;
+  Handle(Select3D_BVHBuilder3d) myBuilder;
 
   //! Indexed map of structures.
   NCollection_IndexedMap<const OpenGl_Structure*> myStructs;
index d1487d1..1c82e6b 100644 (file)
 #include <OpenGl_Workspace.hxx>
 #include <Graphic3d_GraphicDriver.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Layer, Standard_Transient)
+
 // =======================================================================
 // function : OpenGl_Layer
 // purpose  :
 // =======================================================================
-OpenGl_Layer::OpenGl_Layer (const Standard_Integer theNbPriorities)
+OpenGl_Layer::OpenGl_Layer (const Standard_Integer theNbPriorities,
+                            const Handle(Select3D_BVHBuilder3d)& theBuilder)
 : myArray                     (0, theNbPriorities - 1),
   myNbStructures              (0),
+  myBVHPrimitivesTrsfPers     (theBuilder),
   myBVHIsLeftChildQueuedFirst (Standard_True),
   myIsBVHPrimitivesNeedsReset (Standard_False)
 {
@@ -521,8 +525,7 @@ void OpenGl_Layer::traverse (OpenGl_BVHTreeSelector& theSelector) const
 
   theSelector.CacheClipPtsProjections();
 
-  NCollection_Handle<BVH_Tree<Standard_Real, 3> > aBVHTree;
-
+  opencascade::handle<BVH_Tree<Standard_Real, 3> > aBVHTree;
   for (Standard_Integer aBVHTreeIdx = 0; aBVHTreeIdx < 2; ++aBVHTreeIdx)
   {
     const Standard_Boolean isTrsfPers = aBVHTreeIdx == 1;
@@ -555,7 +558,7 @@ void OpenGl_Layer::traverse (OpenGl_BVHTreeSelector& theSelector) const
       continue;
     }
 
-    Standard_Integer aStack[32];
+    Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
     Standard_Integer aHead = -1;
     for (;;)
     {
index 57edf25..f04a3a8 100644 (file)
@@ -41,16 +41,24 @@ typedef NCollection_IndexedMap<const OpenGl_Structure*> OpenGl_IndexedMapOfStruc
 typedef NCollection_Array1<OpenGl_IndexedMapOfStructure> OpenGl_ArrayOfIndexedMapOfStructure;
 
 //! Presentations list sorted within priorities.
-class OpenGl_Layer
+class OpenGl_Layer : public Standard_Transient
 {
+  DEFINE_STANDARD_RTTIEXT(OpenGl_Layer, Standard_Transient)
 public:
 
   //! Initializes associated priority list and layer properties
-  OpenGl_Layer (const Standard_Integer theNbPriorities = 11);
+  OpenGl_Layer (const Standard_Integer theNbPriorities,
+                const Handle(Select3D_BVHBuilder3d)& theBuilder);
 
   //! Destructor.
   virtual ~OpenGl_Layer();
 
+  //! Returns BVH tree builder for frustom culling.
+  const Handle(Select3D_BVHBuilder3d)& FrustumCullingBVHBuilder() const { return myBVHPrimitivesTrsfPers.Builder(); }
+
+  //! Assigns BVH tree builder for frustom culling.
+  void SetFrustumCullingBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder) { myBVHPrimitivesTrsfPers.SetBuilder (theBuilder); }
+
   //! Return true if layer was marked with immediate flag.
   Standard_Boolean IsImmediate() const  { return myLayerSettings.IsImmediate(); }
 
index 40dc81f..d7bf035 100644 (file)
@@ -15,6 +15,7 @@
 
 #include <OpenGl_GlCore15.hxx>
 
+#include <BVH_LinearBuilder.hxx>
 #include <OpenGl_FrameBuffer.hxx>
 #include <OpenGl_LayerList.hxx>
 #include <OpenGl_ShaderManager.hxx>
@@ -31,7 +32,8 @@
 //=======================================================================
 
 OpenGl_LayerList::OpenGl_LayerList (const Standard_Integer theNbPriorities)
-: myDefaultLayerIndex (0),
+: myBVHBuilder (new BVH_LinearBuilder<Standard_Real, 3> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth)),
+  myDefaultLayerIndex (0),
   myNbPriorities (theNbPriorities),
   myNbStructures (0),
   myImmediateNbStructures (0),
@@ -40,19 +42,19 @@ OpenGl_LayerList::OpenGl_LayerList (const Standard_Integer theNbPriorities)
   myRenderTranspFilter (new OpenGl_TransparentFilter())
 {
   // insert default priority layers
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (Graphic3d_ZLayerId_BotOSD,  myLayers.Upper());
 
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (Graphic3d_ZLayerId_Default, myLayers.Upper());
 
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (Graphic3d_ZLayerId_Top,     myLayers.Upper());
 
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (Graphic3d_ZLayerId_Topmost, myLayers.Upper());
 
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (Graphic3d_ZLayerId_TopOSD,  myLayers.Upper());
 
   myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
@@ -70,6 +72,19 @@ OpenGl_LayerList::~OpenGl_LayerList()
 }
 
 //=======================================================================
+//function : SetFrustumCullingBVHBuilder
+//purpose  :
+//=======================================================================
+void OpenGl_LayerList::SetFrustumCullingBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder)
+{
+  myBVHBuilder = theBuilder;
+  for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next())
+  {
+    anIts.ChangeValue()->SetFrustumCullingBVHBuilder (theBuilder);
+  }
+}
+
+//=======================================================================
 //function : AddLayer
 //purpose  : 
 //=======================================================================
@@ -82,7 +97,7 @@ void OpenGl_LayerList::AddLayer (const Graphic3d_ZLayerId theLayerId)
   }
 
   // add the new layer
-  myLayers.Append (OpenGl_Layer (myNbPriorities));
+  myLayers.Append (new OpenGl_Layer (myNbPriorities, myBVHBuilder));
   myLayerIds.Bind (theLayerId, myLayers.Length());
 
   myTransparentToProcess.Allocate (myLayers.Length());
@@ -94,7 +109,7 @@ void OpenGl_LayerList::AddLayer (const Graphic3d_ZLayerId theLayerId)
 //=======================================================================
 OpenGl_Layer& OpenGl_LayerList::Layer (const Graphic3d_ZLayerId theLayerId)
 {
-  return myLayers.ChangeValue (myLayerIds.Find (theLayerId));
+  return *myLayers.ChangeValue (myLayerIds.Find (theLayerId));
 }
 
 //=======================================================================
@@ -103,7 +118,7 @@ OpenGl_Layer& OpenGl_LayerList::Layer (const Graphic3d_ZLayerId theLayerId)
 //=======================================================================
 const OpenGl_Layer& OpenGl_LayerList::Layer (const Graphic3d_ZLayerId theLayerId) const
 {
-  return myLayers.Value (myLayerIds.Find (theLayerId));
+  return *myLayers.Value (myLayerIds.Find (theLayerId));
 }
 
 //=======================================================================
@@ -122,8 +137,10 @@ void OpenGl_LayerList::RemoveLayer (const Graphic3d_ZLayerId theLayerId)
   const Standard_Integer aRemovePos = myLayerIds.Find (theLayerId);
   
   // move all displayed structures to first layer
-  const OpenGl_Layer& aLayerToMove = myLayers.Value (aRemovePos);
-  myLayers.ChangeFirst().Append (aLayerToMove);
+  {
+    const OpenGl_Layer& aLayerToMove = *myLayers.Value (aRemovePos);
+    myLayers.ChangeFirst()->Append (aLayerToMove);
+  }
 
   // remove layer
   myLayers.Remove (aRemovePos);
@@ -157,7 +174,7 @@ void OpenGl_LayerList::AddStructure (const OpenGl_Structure*  theStruct,
   Standard_Integer aSeqPos = myLayers.Lower();
   myLayerIds.Find (theLayerId, aSeqPos);
 
-  OpenGl_Layer& aLayer = myLayers.ChangeValue (aSeqPos);
+  OpenGl_Layer& aLayer = *myLayers.ChangeValue (aSeqPos);
   aLayer.Add (theStruct, thePriority, isForChangePriority);
   ++myNbStructures;
   if (aLayer.IsImmediate())
@@ -182,7 +199,7 @@ void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure* theStructure)
   Standard_Integer aSeqPos = myLayers.Lower();
   myLayerIds.Find (aLayerId, aSeqPos);
 
-  OpenGl_Layer&    aLayer    = myLayers.ChangeValue (aSeqPos);
+  OpenGl_Layer&    aLayer    = *myLayers.ChangeValue (aSeqPos);
   Standard_Integer aPriority = -1;
 
   // remove structure from associated list
@@ -209,7 +226,7 @@ void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure* theStructure)
   Standard_Integer aSeqId = 1;
   for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
   {
-    OpenGl_Layer& aLayerEx = anIts.ChangeValue();
+    OpenGl_Layer& aLayerEx = *anIts.ChangeValue();
     if (aSeqPos == aSeqId)
     {
       continue;
@@ -241,7 +258,7 @@ void OpenGl_LayerList::InvalidateBVHData (const Graphic3d_ZLayerId theLayerId)
 {
   Standard_Integer aSeqPos = myLayers.Lower();
   myLayerIds.Find (theLayerId, aSeqPos);
-  OpenGl_Layer& aLayer = myLayers.ChangeValue (aSeqPos);
+  OpenGl_Layer& aLayer = *myLayers.ChangeValue (aSeqPos);
   aLayer.InvalidateBVHData();
 }
 
@@ -256,7 +273,7 @@ void OpenGl_LayerList::ChangeLayer (const OpenGl_Structure*  theStructure,
 {
   Standard_Integer aSeqPos = myLayers.Lower();
   myLayerIds.Find (theOldLayerId, aSeqPos);
-  OpenGl_Layer&    aLayer    = myLayers.ChangeValue (aSeqPos);
+  OpenGl_Layer&    aLayer    = *myLayers.ChangeValue (aSeqPos);
   Standard_Integer aPriority = -1;
 
   // take priority and remove structure from list found by <theOldLayerId>
@@ -291,7 +308,7 @@ void OpenGl_LayerList::ChangeLayer (const OpenGl_Structure*  theStructure,
     }
   
     // try to remove structure and get priority value from this layer
-    OpenGl_Layer& aLayerEx = anIts.ChangeValue();
+    OpenGl_Layer& aLayerEx = *anIts.ChangeValue();
     if (aLayerEx.Remove (theStructure, aPriority, Standard_True))
     {
       if (aSeqId == myDefaultLayerIndex
@@ -324,7 +341,7 @@ void OpenGl_LayerList::ChangePriority (const OpenGl_Structure*  theStructure,
 {
   Standard_Integer aSeqPos = myLayers.Lower();
   myLayerIds.Find (theLayerId, aSeqPos);
-  OpenGl_Layer&    aLayer        = myLayers.ChangeValue (aSeqPos);
+  OpenGl_Layer&    aLayer        = *myLayers.ChangeValue (aSeqPos);
   Standard_Integer anOldPriority = -1;
 
   if (aLayer.Remove (theStructure, anOldPriority, Standard_True))
@@ -347,7 +364,7 @@ void OpenGl_LayerList::ChangePriority (const OpenGl_Structure*  theStructure,
       continue;
     }
 
-    OpenGl_Layer& aLayerEx = anIts.ChangeValue();
+    OpenGl_Layer& aLayerEx = *anIts.ChangeValue();
     if (aLayerEx.Remove (theStructure, anOldPriority, Standard_True))
     {
       --myNbStructures;
@@ -436,7 +453,7 @@ void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
       if (aSeqId != myDefaultLayerIndex) continue;
     }
 
-    const OpenGl_Layer& aLayer = aLayerIter.Value();
+    const OpenGl_Layer& aLayer = *aLayerIter.Value();
     if (aLayer.IsImmediate() != theToDrawImmediate)
     {
       continue;
index 25d0ca0..1e7848c 100644 (file)
@@ -26,7 +26,7 @@
 
 class OpenGl_Structure;
 
-typedef NCollection_Sequence<OpenGl_Layer> OpenGl_SequenceOfLayers;
+typedef NCollection_Sequence<Handle(OpenGl_Layer)> OpenGl_SequenceOfLayers;
 typedef NCollection_DataMap<int, int> OpenGl_LayerSeqIds;
 
 //! Class defining the list of layers.
@@ -35,7 +35,7 @@ class OpenGl_LayerList
 public:
 
   //! Constructor
-  OpenGl_LayerList (const Standard_Integer theNbPriorities = 11);
+  OpenGl_LayerList (const Standard_Integer theNbPriorities);
 
   //! Destructor
   virtual ~OpenGl_LayerList();
@@ -108,6 +108,12 @@ public:
   //! Returns structure modification state (for ray-tracing).
   Standard_Size ModificationStateOfRaytracable() const { return myModifStateOfRaytraceable; }
 
+  //! Returns BVH tree builder for frustom culling.
+  const Handle(Select3D_BVHBuilder3d)& FrustumCullingBVHBuilder() const { return myBVHBuilder; }
+
+  //! Assigns BVH tree builder for frustom culling.
+  void SetFrustumCullingBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder);
+
 protected:
 
   //! Filter of TKOpenGl elements for processing only shading geometry and
@@ -239,6 +245,7 @@ protected:
   // number of structures temporary put to default layer
   OpenGl_SequenceOfLayers myLayers;
   OpenGl_LayerSeqIds      myLayerIds;
+  Handle(Select3D_BVHBuilder3d) myBVHBuilder;      //!< BVH tree builder for frustom culling
   Standard_Integer        myDefaultLayerIndex;     //!< index of Graphic3d_ZLayerId_Default layer in myLayers sequence
 
   Standard_Integer        myNbPriorities;
old mode 100755 (executable)
new mode 100644 (file)
index 59a59b2..6f92d70
@@ -31,6 +31,8 @@ namespace
   static const BVH_Vec4f ZERO_VEC_4F;
 }
 
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_TriangleSet, OpenGl_BVHTriangulation3f)
+
 // =======================================================================
 // function : OpenGl_RaytraceMaterial
 // purpose  : Creates new default material
@@ -166,48 +168,43 @@ Standard_ShortReal OpenGl_TriangleSet::Center (
 // =======================================================================
 OpenGl_TriangleSet::BVH_BoxNt OpenGl_TriangleSet::Box() const
 {
-  const BVH_Transform<Standard_ShortReal, 4>* aTransform =
-    dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (Properties().operator->());
-
   BVH_BoxNt aBox = BVH_PrimitiveSet<Standard_ShortReal, 3>::Box();
-
-  if (aTransform != NULL)
+  const BVH_Transform<Standard_ShortReal, 4>* aTransform = dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (Properties().get());
+  if (aTransform == NULL)
   {
-    BVH_BoxNt aTransformedBox;
+    return aBox;
+  }
 
-    for (Standard_Integer aX = 0; aX <= 1; ++aX)
+  BVH_BoxNt aTransformedBox;
+  for (Standard_Integer aX = 0; aX <= 1; ++aX)
+  {
+    for (Standard_Integer aY = 0; aY <= 1; ++aY)
     {
-      for (Standard_Integer aY = 0; aY <= 1; ++aY)
+      for (Standard_Integer aZ = 0; aZ <= 1; ++aZ)
       {
-        for (Standard_Integer aZ = 0; aZ <= 1; ++aZ)
-        {
-          BVH_Vec4f aCorner = aTransform->Transform() * BVH_Vec4f (
-            aX == 0 ? aBox.CornerMin().x() : aBox.CornerMax().x(),
-            aY == 0 ? aBox.CornerMin().y() : aBox.CornerMax().y(),
-            aZ == 0 ? aBox.CornerMin().z() : aBox.CornerMax().z(),
-            1.f);
-
-          aTransformedBox.Add (aCorner.xyz());
-        }
+        BVH_Vec4f aCorner = aTransform->Transform() * BVH_Vec4f (
+          aX == 0 ? aBox.CornerMin().x() : aBox.CornerMax().x(),
+          aY == 0 ? aBox.CornerMin().y() : aBox.CornerMax().y(),
+          aZ == 0 ? aBox.CornerMin().z() : aBox.CornerMax().z(),
+          1.f);
+
+        aTransformedBox.Add (aCorner.xyz());
       }
     }
-
-    return aTransformedBox;
   }
-
-  return aBox;
+  return aTransformedBox;
 }
 
 // =======================================================================
 // function : OpenGl_TriangleSet
 // purpose  : Creates new OpenGL element triangulation
 // =======================================================================
-OpenGl_TriangleSet::OpenGl_TriangleSet (const Standard_Size theArrayID)
-: BVH_Triangulation<Standard_ShortReal, 3>(),
+OpenGl_TriangleSet::OpenGl_TriangleSet (const Standard_Size theArrayID,
+                                        const opencascade::handle<BVH_Builder<Standard_ShortReal, 3> >& theBuilder)
+: BVH_Triangulation<Standard_ShortReal, 3> (theBuilder),
   myArrayID (theArrayID)
 {
-  myBuilder = new BVH_BinnedBuilder<Standard_ShortReal, 3 /* dim */, 48 /* bins */>
-    (4 /* leaf size */, 32 /* max height */, Standard_False, OSD_Parallel::NbLogicalProcessors() + 1 /* threads */);
+  //
 }
 
 // =======================================================================
old mode 100755 (executable)
new mode 100644 (file)
index e467030..d79f6d5
@@ -161,11 +161,13 @@ public:
 };
 
 //! Shared pointer to quad BVH (QBVH) tree.
-typedef NCollection_Handle<BVH_Tree<Standard_ShortReal, 3, BVH_QuadTree> > QuadBvhHandle;
+typedef opencascade::handle<BVH_Tree<Standard_ShortReal, 3, BVH_QuadTree> > QuadBvhHandle;
+typedef BVH_Triangulation<Standard_ShortReal, 3> OpenGl_BVHTriangulation3f;
 
 //! Triangulation of single OpenGL primitive array.
-class OpenGl_TriangleSet : public BVH_Triangulation<Standard_ShortReal, 3>
+class OpenGl_TriangleSet : public OpenGl_BVHTriangulation3f
 {
+  DEFINE_STANDARD_RTTIEXT(OpenGl_TriangleSet, OpenGl_BVHTriangulation3f)
 public:
 
   //! Value of invalid material index to return in case of errors.
@@ -174,7 +176,8 @@ public:
 public:
 
   //! Creates new OpenGL element triangulation.
-  OpenGl_TriangleSet (const Standard_Size theArrayID);
+  OpenGl_TriangleSet (const Standard_Size theArrayID,
+                      const opencascade::handle<BVH_Builder<Standard_ShortReal, 3> >& theBuilder);
 
   //! Returns ID of associated primitive array.
   Standard_Size AssociatedPArrayID() const
@@ -203,13 +206,13 @@ public:
   }
 
   //! Returns AABB of primitive set.
-  BVH_BoxNt Box() const;
+  virtual BVH_BoxNt Box() const Standard_OVERRIDE;
 
   //! Returns AABB of the given object.
   using BVH_Triangulation<Standard_ShortReal, 3>::Box;
 
   //! Returns centroid position along the given axis.
-  Standard_ShortReal Center (const Standard_Integer theIndex, const Standard_Integer theAxis) const;
+  virtual Standard_ShortReal Center (const Standard_Integer theIndex, const Standard_Integer theAxis) const Standard_OVERRIDE;
 
   //! Returns quad BVH (QBVH) tree produced from binary BVH.
   const QuadBvhHandle& QuadBVH();
index fd181f8..99fbd51 100644 (file)
 #include <OpenGl_Texture.hxx>
 #include <OpenGl_Window.hxx>
 #include <OpenGl_Workspace.hxx>
+#include <OSD_Parallel.hxx>
 #include <Standard_CLocaleSentry.hxx>
 
+#include "../Graphic3d/Graphic3d_Structure.pxx"
+
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_View,Graphic3d_CView)
 
 #ifdef HAVE_GL2PS
@@ -59,6 +62,7 @@ OpenGl_View::OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
   myBgColor        (Quantity_NOC_BLACK),
   myCamera         (new Graphic3d_Camera()),
   myToShowGradTrihedron  (false),
+  myZLayers        (Structure_MAX_PRIORITY - Structure_MIN_PRIORITY + 1),
   myStateCounter         (theCounter),
   myLastLightSourceState (0, 0),
 #if !defined(GL_ES_VERSION_2_0)
@@ -83,6 +87,12 @@ OpenGl_View::OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
   myRaytraceInitStatus     (OpenGl_RT_NONE),
   myIsRaytraceDataValid    (Standard_False),
   myIsRaytraceWarnTextures (Standard_False),
+  myRaytraceBVHBuilder (new BVH_BinnedBuilder<Standard_ShortReal, 3, BVH_Constants_NbBinsBest> (BVH_Constants_LeafNodeSizeAverage,
+                                                                                                BVH_Constants_MaxTreeDepth,
+                                                                                                Standard_False,
+                                                                                                OSD_Parallel::NbLogicalProcessors() + 1)),
+  myRaytraceSceneRadius  (0.0f),
+  myRaytraceSceneEpsilon (1.0e-6f),
   myToUpdateEnvironmentMap (Standard_False),
   myRaytraceLayerListState (0)
 {
index 9b98aa9..4f4a393 100644 (file)
@@ -814,9 +814,9 @@ protected: //! @name methods related to ray-tracing
                                            const Handle(OpenGl_Context)& theGlContext);
 
   //! Adds OpenGL primitive array to ray-traced scene geometry.
-  OpenGl_TriangleSet* addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
-                                                 const Standard_Integer       theMatID,
-                                                 const OpenGl_Mat4*           theTrans);
+  Handle(OpenGl_TriangleSet) addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
+                                                        const Standard_Integer       theMatID,
+                                                        const OpenGl_Mat4*           theTrans);
 
   //! Adds vertex indices from OpenGL primitive array to ray-traced scene geometry.
   Standard_Boolean addRaytraceVertexIndices (OpenGl_TriangleSet&                  theSet,
@@ -961,6 +961,9 @@ protected: //! @name fields related to ray-tracing
   //! 3D scene geometry data for ray-tracing.
   OpenGl_RaytraceGeometry myRaytraceGeometry;
 
+  //! Builder for triangle set.
+  opencascade::handle<BVH_Builder<Standard_ShortReal, 3> > myRaytraceBVHBuilder;
+
   //! Compile-time ray-tracing parameters.
   RaytracingParams myRaytraceParameters;
 
index 88c7682..aac555f 100644 (file)
@@ -525,9 +525,7 @@ Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*
           if (aSetIter != myArrayToTrianglesMap.end())
           {
             OpenGl_TriangleSet* aSet = aSetIter->second;
-
-            BVH_Transform<Standard_ShortReal, 4>* aTransform = new BVH_Transform<Standard_ShortReal, 4>();
-
+            opencascade::handle<BVH_Transform<Standard_ShortReal, 4> > aTransform = new BVH_Transform<Standard_ShortReal, 4>();
             if (!theTrsf.IsNull())
             {
               theTrsf->Trsf().GetMat4 (aMat4);
@@ -535,7 +533,6 @@ Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*
             }
 
             aSet->SetProperties (aTransform);
-
             if (aSet->MaterialIndex() != OpenGl_TriangleSet::INVALID_MATERIAL && aSet->MaterialIndex() != aMatID)
             {
               aSet->SetMaterialIndex (aMatID);
@@ -543,13 +540,9 @@ Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*
           }
           else
           {
-            NCollection_Handle<BVH_Object<Standard_ShortReal, 3> > aSet =
-              addRaytracePrimitiveArray (aPrimArray, aMatID, 0);
-
-            if (!aSet.IsNull())
+            if (Handle(OpenGl_TriangleSet) aSet = addRaytracePrimitiveArray (aPrimArray, aMatID, 0))
             {
-              BVH_Transform<Standard_ShortReal, 4>* aTransform = new BVH_Transform<Standard_ShortReal, 4>;
-
+              opencascade::handle<BVH_Transform<Standard_ShortReal, 4> > aTransform = new BVH_Transform<Standard_ShortReal, 4>();
               if (!theTrsf.IsNull())
               {
                 theTrsf->Trsf().GetMat4 (aMat4);
@@ -557,7 +550,6 @@ Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*
               }
 
               aSet->SetProperties (aTransform);
-
               myRaytraceGeometry.Objects().Append (aSet);
             }
           }
@@ -573,9 +565,9 @@ Standard_Boolean OpenGl_View::addRaytraceGroups (const OpenGl_Structure*
 // function : addRaytracePrimitiveArray
 // purpose  : Adds OpenGL primitive array to ray-traced scene geometry
 // =======================================================================
-OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
-                                                            const Standard_Integer       theMaterial,
-                                                            const OpenGl_Mat4*           theTransform)
+Handle(OpenGl_TriangleSet) OpenGl_View::addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
+                                                                   const Standard_Integer       theMaterial,
+                                                                   const OpenGl_Mat4*           theTransform)
 {
   const Handle(Graphic3d_BoundBuffer)& aBounds   = theArray->Bounds();
   const Handle(Graphic3d_IndexBuffer)& anIndices = theArray->Indices();
@@ -589,11 +581,10 @@ OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_Primiti
   #endif
    || anAttribs.IsNull())
   {
-    return NULL;
+    return Handle(OpenGl_TriangleSet)();
   }
 
   OpenGl_Mat4 aNormalMatrix;
-
   if (theTransform != NULL)
   {
     Standard_ASSERT_RETURN (theTransform->Inverted (aNormalMatrix),
@@ -602,14 +593,13 @@ OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_Primiti
     aNormalMatrix.Transpose();
   }
 
-  OpenGl_TriangleSet* aSet = new OpenGl_TriangleSet (theArray->GetUID());
+  Handle(OpenGl_TriangleSet) aSet = new OpenGl_TriangleSet (theArray->GetUID(), myRaytraceBVHBuilder);
   {
     aSet->Vertices.reserve (anAttribs->NbElements);
     aSet->Normals.reserve  (anAttribs->NbElements);
     aSet->TexCrds.reserve  (anAttribs->NbElements);
 
     const size_t aVertFrom = aSet->Vertices.size();
-
     for (Standard_Integer anAttribIter = 0; anAttribIter < anAttribs->NbAttributes; ++anAttribIter)
     {
       const Graphic3d_Attribute& anAttrib = anAttribs->Attribute       (anAttribIter);
@@ -707,8 +697,8 @@ OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_Primiti
 
         if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, aBoundStart, *theArray))
         {
-          delete aSet;
-          return NULL;
+          aSet.Nullify();
+          return Handle(OpenGl_TriangleSet)();
         }
 
         aBoundStart += aVertNum;
@@ -720,8 +710,8 @@ OpenGl_TriangleSet* OpenGl_View::addRaytracePrimitiveArray (const OpenGl_Primiti
 
       if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, 0, *theArray))
       {
-        delete aSet;
-        return NULL;
+        aSet.Nullify();
+        return Handle(OpenGl_TriangleSet)();
       }
     }
   }
@@ -2135,9 +2125,7 @@ Standard_Boolean OpenGl_View::uploadRaytraceData (const Handle(OpenGl_Context)&
     OpenGl_TriangleSet* aTriangleSet = dynamic_cast<OpenGl_TriangleSet*> (
       myRaytraceGeometry.Objects().ChangeValue (anElemIndex).operator->());
 
-    const BVH_Transform<Standard_ShortReal, 4>* aTransform = 
-      dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (aTriangleSet->Properties().operator->());
-
+    const BVH_Transform<Standard_ShortReal, 4>* aTransform = dynamic_cast<const BVH_Transform<Standard_ShortReal, 4>* > (aTriangleSet->Properties().get());
     Standard_ASSERT_RETURN (aTransform != NULL,
       "OpenGl_TriangleSet does not contain transform", Standard_False);
 
index 1246953..43bee8b 100755 (executable)
@@ -1,4 +1,5 @@
 Select3D_BndBox3d.hxx
+Select3D_BVHBuilder3d.hxx
 Select3D_BVHIndexBuffer.hxx
 Select3D_EntitySequence.hxx
 Select3D_InteriorSensitivePointSet.cxx
diff --git a/src/Select3D/Select3D_BVHBuilder3d.hxx b/src/Select3D/Select3D_BVHBuilder3d.hxx
new file mode 100644 (file)
index 0000000..254481e
--- /dev/null
@@ -0,0 +1,22 @@
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// 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.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Select3D_BVHBuilder3d_Header
+#define _Select3D_BVHBuilder3d_Header
+
+#include <BVH_Builder.hxx>
+#include <Standard_Real.hxx>
+
+typedef BVH_Builder<Standard_Real, 3> Select3D_BVHBuilder3d;
+
+#endif // _Select3D_BVHBuilder3d_Header
index a6b8a8e..be810f0 100644 (file)
 
 IMPLEMENT_STANDARD_RTTIEXT(Select3D_SensitiveSet,Select3D_SensitiveEntity)
 
+namespace
+{
+  //! Default BVH tree builder for sensitive set (optimal for large set of small primitives - for not too long construction time).
+  static Handle(Select3D_BVHBuilder3d) THE_SENS_SET_BUILDER = new BVH_LinearBuilder<Standard_Real, 3> (BVH_Constants_LeafNodeSizeSmall, BVH_Constants_MaxTreeDepth);
+}
+
+//=======================================================================
+// function : DefaultBVHBuilder
+// purpose  :
+//=======================================================================
+const Handle(Select3D_BVHBuilder3d)& Select3D_SensitiveSet::DefaultBVHBuilder()
+{
+  return THE_SENS_SET_BUILDER;
+}
+
+//=======================================================================
+// function : SetDefaultBVHBuilder
+// purpose  :
+//=======================================================================
+void Select3D_SensitiveSet::SetDefaultBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder)
+{
+  THE_SENS_SET_BUILDER = theBuilder;
+}
+
 //=======================================================================
 // function : Select3D_SensitiveSet
 // purpose  : Creates new empty sensitive set and its content
@@ -27,9 +51,8 @@ Select3D_SensitiveSet::Select3D_SensitiveSet (const Handle(SelectBasics_EntityOw
 : Select3D_SensitiveEntity (theOwnerId),
   myDetectedIdx (-1)
 {
-  NCollection_Handle< BVH_Builder<Standard_Real, 3> > aBuilder = new BVH_LinearBuilder<Standard_Real, 3> (myLeafNodeSize, 32);
   myContent.SetSensitiveSet (this);
-  myContent.SetBuilder (aBuilder);
+  myContent.SetBuilder (THE_SENS_SET_BUILDER);
   myContent.MarkDirty();
 }
 
@@ -61,7 +84,7 @@ Standard_Boolean Select3D_SensitiveSet::Matches (SelectBasics_SelectingVolumeMan
     return Standard_False;
   }
 
-  Standard_Integer aStack[32];
+  Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
   Standard_Integer aNode =  0;
   Standard_Integer aHead = -1;
 
index 94c202c..c64c84c 100644 (file)
@@ -16,8 +16,9 @@
 #ifndef _Select3D_SensitiveSet_Header
 #define _Select3D_SensitiveSet_Header
 
-#include <BVH_PrimitiveSet.hxx>
+#include <BVH_PrimitiveSet3d.hxx>
 #include <Select3D_BndBox3d.hxx>
+#include <Select3D_BVHBuilder3d.hxx>
 #include <Select3D_SensitiveEntity.hxx>
 #include <SelectBasics_EntityOwner.hxx>
 
 //! For example of usage see Select3D_SensitiveTriangulation.
 class Select3D_SensitiveSet : public Select3D_SensitiveEntity
 {
-  static const Standard_Integer myLeafNodeSize = 8; //!< Number of sub-elements in the leaf
   DEFINE_STANDARD_RTTIEXT(Select3D_SensitiveSet, Select3D_SensitiveEntity)
 public:
 
+  //! Return global instance to default BVH builder.
+  Standard_EXPORT static const Handle(Select3D_BVHBuilder3d)& DefaultBVHBuilder();
+
+  //! Assign new BVH builder to be used by default for new sensitive sets (assigning is NOT thread-safe!).
+  Standard_EXPORT static void SetDefaultBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder);
+
+public:
+
   //! Creates new empty sensitive set and its content
   Standard_EXPORT Select3D_SensitiveSet (const Handle(SelectBasics_EntityOwner)& theOwnerId);
 
-  ~Select3D_SensitiveSet() {}
-
 public:
 
   //! Returns the amount of sub-entities of the complex entity
@@ -67,6 +73,9 @@ public:
   //! but element by element
   Standard_EXPORT virtual void BVH() Standard_OVERRIDE;
 
+  //! Sets the method (builder) used to construct BVH.
+  void SetBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder) { myContent.SetBuilder (theBuilder); }
+
   //! Marks BVH tree of the set as outdated. It will be rebuild
   //! at the next call of BVH()
   void MarkDirty() { myContent.MarkDirty(); }
@@ -83,7 +92,7 @@ public:
   Standard_EXPORT virtual void Clear() Standard_OVERRIDE;
 
   //! Returns a number of nodes in 1 BVH leaf
-  Standard_Integer GetLeafNodeSize() const { return myLeafNodeSize; }
+  Standard_Integer GetLeafNodeSize() const { return myContent.Builder()->LeafNodeSize(); }
 
 protected:
 
@@ -104,12 +113,12 @@ protected:
 
   //! The purpose of this class is to provide a link between BVH_PrimitiveSet
   //! and Select3D_SensitiveSet instance to build BVH tree for set of sensitives.
-  class BvhPrimitiveSet : public BVH_PrimitiveSet<Standard_Real, 3>
+  class BvhPrimitiveSet : public BVH_PrimitiveSet3d
   {
   public:
 
     //! Empty constructor.
-    BvhPrimitiveSet() {}
+    BvhPrimitiveSet() : BVH_PrimitiveSet3d (Handle(Select3D_BVHBuilder3d)()) {}
 
     //! Destructor.
     ~BvhPrimitiveSet() {}
@@ -128,7 +137,7 @@ protected:
     virtual Select3D_BndBox3d Box (const Standard_Integer theIdx) const Standard_OVERRIDE { return mySensitiveSet->Box (theIdx); }
 
     //! Make inherited method Box() visible to avoid CLang warning
-    using BVH_PrimitiveSet<Standard_Real, 3>::Box;
+    using BVH_PrimitiveSet3d::Box;
 
     //! Returns center of sensitive with index theIdx in the set along the given axis theAxis
     virtual Standard_Real Center (const Standard_Integer theIdx,
@@ -139,7 +148,7 @@ protected:
                        const Standard_Integer theIdx2) Standard_OVERRIDE { mySensitiveSet->Swap (theIdx1, theIdx2); }
 
     //! Returns the tree built for set of sensitives
-    const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& GetBVH() { return BVH(); }
+    const opencascade::handle<BVH_Tree<Standard_Real, 3> >& GetBVH() { return BVH(); }
 
   protected:
     Select3D_SensitiveSet* mySensitiveSet; //!< Set of sensitive entities
index e852d30..99fc2a4 100644 (file)
@@ -37,15 +37,3 @@ void SelectBasics_SensitiveEntity::Set (const Handle(SelectBasics_EntityOwner)&
 {
   myOwnerId = theOwnerId;
 }
-
-//=======================================================================
-// function : SetSensitivityFactor
-// purpose  : Allows to manage sensitivity of a particular entity
-//=======================================================================
-void SelectBasics_SensitiveEntity::SetSensitivityFactor (const Standard_Integer theNewSens)
-{
-  Standard_ASSERT_RAISE (theNewSens > 0,
-    "Error! Selection sensitivity have positive value.");
-
-  mySFactor = theNewSens;
-}
index 633fed8..70a7926 100644 (file)
@@ -49,7 +49,11 @@ public:
   Standard_Integer SensitivityFactor() const { return mySFactor; }
 
   //! Allows to manage sensitivity of a particular sensitive entity
-  Standard_EXPORT void SetSensitivityFactor (const Standard_Integer theNewSens);
+  void SetSensitivityFactor (const Standard_Integer theNewSens)
+  {
+    Standard_ASSERT_RAISE (theNewSens > 0, "Error! Selection sensitivity have positive value.");
+    mySFactor = theNewSens;
+  }
 
   //! Returns the number of sub-entities or elements in
   //! sensitive entity. Is used to determine if entity is
index 763980c..226d0ac 100644 (file)
@@ -212,9 +212,9 @@ SelectMgr_SelectableObjectSet::SelectMgr_SelectableObjectSet()
   myBVH[BVHSubset_3dPersistent] = new BVH_Tree<Standard_Real, 3>();
   myBVH[BVHSubset_3d]           = new BVH_Tree<Standard_Real, 3>();
 
-  myBuilder[BVHSubset_2dPersistent] = new BVH_LinearBuilder<Standard_Real, 3> (1, 32);
-  myBuilder[BVHSubset_3dPersistent] = new BVH_LinearBuilder<Standard_Real, 3> (1, 32);
-  myBuilder[BVHSubset_3d]           = new BVH_BinnedBuilder<Standard_Real, 3, 4> (1, 32, Standard_True);
+  myBuilder[BVHSubset_2dPersistent] = new BVH_LinearBuilder<Standard_Real, 3>    (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth);
+  myBuilder[BVHSubset_3dPersistent] = new BVH_LinearBuilder<Standard_Real, 3>    (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth);
+  myBuilder[BVHSubset_3d]           = new BVH_BinnedBuilder<Standard_Real, 3, 4> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth, Standard_True);
 
   myIsDirty[BVHSubset_2dPersistent] = Standard_False;
   myIsDirty[BVHSubset_3dPersistent] = Standard_False;
@@ -327,7 +327,7 @@ void SelectMgr_SelectableObjectSet::UpdateBVH (const Handle(Graphic3d_Camera)& t
     BVHBuilderAdaptorRegular anAdaptor (myObjects[BVHSubset_3d]);
 
     // update corresponding BVH tree data structure
-    myBuilder[BVHSubset_3d]->Build (&anAdaptor, myBVH[BVHSubset_3d].operator->(), anAdaptor.Box());
+    myBuilder[BVHSubset_3d]->Build (&anAdaptor, myBVH[BVHSubset_3d].get(), anAdaptor.Box());
 
     // release dirty state
     myIsDirty[BVHSubset_3d] = Standard_False;
@@ -349,7 +349,7 @@ void SelectMgr_SelectableObjectSet::UpdateBVH (const Handle(Graphic3d_Camera)& t
         theCamera, theProjectionMat, theWorldViewMat, theViewportWidth, theViewportHeight);
 
       // update corresponding BVH tree data structure
-      myBuilder[BVHSubset_3dPersistent]->Build (&anAdaptor, myBVH[BVHSubset_3dPersistent].operator->(), anAdaptor.Box());
+      myBuilder[BVHSubset_3dPersistent]->Build (&anAdaptor, myBVH[BVHSubset_3dPersistent].get(), anAdaptor.Box());
     }
 
     // -----------------------------------------------------
@@ -363,7 +363,7 @@ void SelectMgr_SelectableObjectSet::UpdateBVH (const Handle(Graphic3d_Camera)& t
         theCamera, theProjectionMat, THE_IDENTITY_MAT, theViewportWidth, theViewportHeight);
 
       // update corresponding BVH tree data structure
-      myBuilder[BVHSubset_2dPersistent]->Build (&anAdaptor, myBVH[BVHSubset_2dPersistent].operator->(), anAdaptor.Box());
+      myBuilder[BVHSubset_2dPersistent]->Build (&anAdaptor, myBVH[BVHSubset_2dPersistent].get(), anAdaptor.Box());
     }
 
     // release dirty state for every subset
index 978337c..242abdc 100644 (file)
 #ifndef _SelectMgr_SelectableObjectSet_HeaderFile
 #define _SelectMgr_SelectableObjectSet_HeaderFile
 
-#include <BVH_PrimitiveSet.hxx>
+#include <BVH_Builder.hxx>
 #include <BVH_Tree.hxx>
 #include <Graphic3d_Mat4d.hxx>
 #include <Graphic3d_WorldViewProjState.hxx>
 #include <NCollection_Handle.hxx>
 #include <NCollection_IndexedMap.hxx>
+#include <Select3D_BVHBuilder3d.hxx>
 #include <SelectMgr_SelectableObject.hxx>
 
 //! The purpose of this class is to organize all selectable objects into data structure, allowing to build 
@@ -174,7 +175,7 @@ public:
   }
 
   //! Returns computed BVH for the theSubset given.
-  const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& BVH(const BVHSubset theSubset) const
+  const opencascade::handle<BVH_Tree<Standard_Real, 3> >& BVH(const BVHSubset theSubset) const
   {
     return myBVH[theSubset];
   }
@@ -214,8 +215,8 @@ private:
 private:
 
   NCollection_IndexedMap<Handle(SelectMgr_SelectableObject)> myObjects[BVHSubsetNb]; //!< Map of objects for each subset
-  NCollection_Handle<BVH_Tree<Standard_Real, 3> >            myBVH[BVHSubsetNb];     //!< BVH tree computed for each subset
-  NCollection_Handle<BVH_Builder<Standard_Real, 3> >         myBuilder[BVHSubsetNb]; //!< Builder allocated for each subset
+  opencascade::handle<BVH_Tree<Standard_Real, 3> >           myBVH[BVHSubsetNb];     //!< BVH tree computed for each subset
+  Handle(Select3D_BVHBuilder3d)                              myBuilder[BVHSubsetNb]; //!< Builder allocated for each subset
   Standard_Boolean                                           myIsDirty[BVHSubsetNb]; //!< Dirty flag for each subset
   Graphic3d_WorldViewProjState                               myLastViewState; //!< Last view-projection state used for construction of BVH
   Standard_Integer                                           myLastWidth; //!< Last viewport's (window's) width used for construction of BVH
index 1619347..2604841 100644 (file)
@@ -44,9 +44,9 @@ SelectMgr_Selection::~SelectMgr_Selection()
 //==================================================
 void SelectMgr_Selection::Destroy()
 {
-  for (Standard_Integer anEntityIdx = 0; anEntityIdx < myEntities.Size(); ++anEntityIdx)
+  for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator anEntityIter (myEntities); anEntityIter.More(); anEntityIter.Next())
   {
-    Handle(SelectMgr_SensitiveEntity)& anEntity = myEntities.ChangeValue (anEntityIdx);
+    Handle(SelectMgr_SensitiveEntity)& anEntity = anEntityIter.ChangeValue();
     anEntity->BaseSensitive()->Set (NULL);
   }
   mySensFactor = 2;
@@ -92,9 +92,9 @@ void SelectMgr_Selection::Add (const Handle(SelectBasics_SensitiveEntity)& theSe
 //==================================================
 void SelectMgr_Selection::Clear()
 {
-  for (Standard_Integer anIdx = 0; anIdx < myEntities.Size(); ++anIdx)
+  for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator anEntityIter (myEntities); anEntityIter.More(); anEntityIter.Next())
   {
-    Handle(SelectMgr_SensitiveEntity)& anEntity = myEntities.ChangeValue (anIdx);
+    Handle(SelectMgr_SensitiveEntity)& anEntity = anEntityIter.ChangeValue();
     anEntity->Clear();
   }
 
@@ -157,9 +157,9 @@ void SelectMgr_Selection::SetSensitivity (const Standard_Integer theNewSens)
 {
   mySensFactor = theNewSens;
   myIsCustomSens = Standard_True;
-  for (Standard_Integer anIdx = 0; anIdx < myEntities.Size(); ++anIdx)
+  for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator anEntityIter (myEntities); anEntityIter.More(); anEntityIter.Next())
   {
-    Handle(SelectMgr_SensitiveEntity)& anEntity = myEntities.ChangeValue (anIdx);
+    Handle(SelectMgr_SensitiveEntity)& anEntity = anEntityIter.ChangeValue();
     anEntity->BaseSensitive()->SetSensitivityFactor (theNewSens);
   }
 }
index 06cf933..f172df2 100644 (file)
@@ -24,9 +24,10 @@ IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_SensitiveEntity,Standard_Transient)
 //            theEntity
 //=======================================================================
 SelectMgr_SensitiveEntity::SelectMgr_SensitiveEntity (const Handle(SelectBasics_SensitiveEntity)& theEntity)
+: mySensitive (theEntity),
+  myIsActiveForSelection (Standard_False)
 {
-  mySensitive = theEntity;
-  myIsActiveForSelection = Standard_False;
+  //
 }
 
 //=======================================================================
@@ -38,40 +39,3 @@ void SelectMgr_SensitiveEntity::Clear()
   mySensitive->Clear();
   mySensitive.Nullify();
 }
-
-//=======================================================================
-// function : BaseSensitive
-// purpose  : Returns related instance of SelectBasics class
-//=======================================================================
-const Handle(SelectBasics_SensitiveEntity)& SelectMgr_SensitiveEntity::BaseSensitive() const
-{
-  return mySensitive;
-}
-
-//=======================================================================
-// function : IsActiveForSelection
-// purpose  : Returns true if this entity belongs to the active selection
-//            mode of parent object
-//=======================================================================
-Standard_Boolean SelectMgr_SensitiveEntity::IsActiveForSelection() const
-{
-  return myIsActiveForSelection;
-}
-
-//=======================================================================
-// function : ResetSelectionActiveStatus
-// purpose  : Marks entity as inactive for selection
-//=======================================================================
-void SelectMgr_SensitiveEntity::ResetSelectionActiveStatus() const
-{
-  myIsActiveForSelection = Standard_False;
-}
-
-//=======================================================================
-// function : SetActiveForSelection
-// purpose  : Marks entity as active for selection
-//=======================================================================
-void SelectMgr_SensitiveEntity::SetActiveForSelection() const
-{
-  myIsActiveForSelection = Standard_True;
-}
index 893115b..ad6fed2 100644 (file)
@@ -35,17 +35,17 @@ public:
   Standard_EXPORT void Clear();
 
   //! Returns related instance of SelectBasics class
-  Standard_EXPORT const Handle(SelectBasics_SensitiveEntity)& BaseSensitive() const;
+  const Handle(SelectBasics_SensitiveEntity)& BaseSensitive() const { return mySensitive; }
 
   //! Returns true if this entity belongs to the active selection
   //! mode of parent object
-  Standard_EXPORT Standard_Boolean IsActiveForSelection() const;
+  Standard_Boolean IsActiveForSelection() const { return myIsActiveForSelection; }
 
   //! Marks entity as inactive for selection
-  Standard_EXPORT void ResetSelectionActiveStatus() const;
+  void ResetSelectionActiveStatus() const { myIsActiveForSelection = Standard_False; }
 
   //! Marks entity as active for selection
-  Standard_EXPORT void SetActiveForSelection() const;
+  void SetActiveForSelection() const { myIsActiveForSelection = Standard_True; }
 
   DEFINE_STANDARD_RTTIEXT(SelectMgr_SensitiveEntity,Standard_Transient) // Type definition
 
index 26f186a..7bb41a6 100644 (file)
 
 #include <SelectMgr_SensitiveEntitySet.hxx>
 
-#include <BVH_BinnedBuilder.hxx>
-
 #include <Select3D_SensitiveEntity.hxx>
 #include <SelectMgr_SensitiveEntity.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_SensitiveEntitySet, BVH_PrimitiveSet3d)
+
 //=======================================================================
 // function : SelectMgr_SensitiveEntitySet
 // purpose  :
 //=======================================================================
-SelectMgr_SensitiveEntitySet::SelectMgr_SensitiveEntitySet()
+SelectMgr_SensitiveEntitySet::SelectMgr_SensitiveEntitySet (const Handle(Select3D_BVHBuilder3d)& theBuilder)
+: BVH_PrimitiveSet3d (theBuilder)
 {
-  myBuilder = new BVH_BinnedBuilder<Standard_Real, 3, 4> (1, 32, Standard_True);
+  //
 }
 
 //=======================================================================
@@ -35,7 +36,7 @@ SelectMgr_SensitiveEntitySet::SelectMgr_SensitiveEntitySet()
 //=======================================================================
 void SelectMgr_SensitiveEntitySet::Append (const Handle(SelectMgr_SensitiveEntity)& theEntity)
 {
-  if (!theEntity->BaseSensitive()->IsKind ("Select3D_SensitiveEntity"))
+  if (!theEntity->BaseSensitive()->IsKind (STANDARD_TYPE(Select3D_SensitiveEntity)))
   {
     theEntity->ResetSelectionActiveStatus();
     return;
@@ -53,7 +54,7 @@ void SelectMgr_SensitiveEntitySet::Append (const Handle(SelectMgr_Selection)& th
 {
   for (theSelection->Init(); theSelection->More(); theSelection->Next())
   {
-    if (!theSelection->Sensitive()->BaseSensitive()->IsKind ("Select3D_SensitiveEntity"))
+    if (!theSelection->Sensitive()->BaseSensitive()->IsKind (STANDARD_TYPE(Select3D_SensitiveEntity)))
     {
       theSelection->Sensitive()->ResetSelectionActiveStatus();
       continue;
index 40a0ec9..0b1ce16 100644 (file)
 #ifndef _SelectMgr_SensitiveEntitySet_HeaderFile
 #define _SelectMgr_SensitiveEntitySet_HeaderFile
 
-#include <BVH_PrimitiveSet.hxx>
-
+#include <BVH_PrimitiveSet3d.hxx>
 #include <NCollection_IndexedMap.hxx>
-#include <NCollection_Handle.hxx>
-
 #include <Select3D_BndBox3d.hxx>
-
+#include <Select3D_BVHBuilder3d.hxx>
 #include <SelectMgr_SensitiveEntity.hxx>
 #include <SelectMgr_Selection.hxx>
 
@@ -31,11 +28,13 @@ typedef NCollection_IndexedMap<Handle(SelectMgr_SensitiveEntity)> SelectMgr_Inde
 //! This class is used to store all calculated sensitive entites of one selectable
 //! object. It provides an interface for building BVH tree which is used to speed-up
 //! the performance of searching for overlap among sensitives of one selectable object
-class SelectMgr_SensitiveEntitySet : public BVH_PrimitiveSet<Standard_Real, 3>
+class SelectMgr_SensitiveEntitySet : public BVH_PrimitiveSet3d
 {
+  DEFINE_STANDARD_RTTIEXT(SelectMgr_SensitiveEntitySet, BVH_PrimitiveSet3d)
 public:
 
-  Standard_EXPORT SelectMgr_SensitiveEntitySet();
+  //! Empty constructor.
+  Standard_EXPORT SelectMgr_SensitiveEntitySet (const Handle(Select3D_BVHBuilder3d)& theBuilder);
 
   virtual ~SelectMgr_SensitiveEntitySet() {};
 
@@ -54,7 +53,7 @@ public:
   Standard_EXPORT virtual Select3D_BndBox3d Box (const Standard_Integer theIndex) const Standard_OVERRIDE;
 
   //! Make inherited method Box() visible to avoid CLang warning
-  using BVH_PrimitiveSet<Standard_Real, 3>::Box;
+  using BVH_PrimitiveSet3d::Box;
 
   //! Returns geometry center of sensitive entity index theIdx
   //! along the given axis theAxis
index bb95574..9bdaafb 100644 (file)
@@ -34,7 +34,7 @@
 
 #include <algorithm>
 
-IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector, Standard_Transient)
 
 namespace {
   // Comparison operator for sorting selection results
@@ -95,6 +95,7 @@ myCurRank (0),
 myIsLeftChildQueuedFirst (Standard_False),
 myEntityIdx (0)
 {
+  myEntitySetBuilder = new BVH_BinnedBuilder<Standard_Real, 3, 4> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth, Standard_True);
 }
 
 //==================================================
@@ -315,16 +316,14 @@ void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_Selectable
                                                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().IsNull())
   {
     if (theObject->TransformPersistence().IsNull())
@@ -363,7 +362,7 @@ void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_Selectable
   {
     return;
   }
-  Standard_Integer aStack[32];
+  Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
   Standard_Integer aHead = -1;
   for (;;)
   {
@@ -492,7 +491,7 @@ void SelectMgr_ViewerSelector::TraverseSensitives()
                                             ? mySelectingVolumeMgr.WorldViewMatrix()
                                             : THE_IDENTITY_MAT;
 
-    const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aBVHTree = mySelectableObjects.BVH (aBVHSubset);
+    const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aBVHTree = mySelectableObjects.BVH (aBVHSubset);
 
     Standard_Integer aNode = 0;
     if (!aMgr.Overlaps (aBVHTree->MinPoint (0), aBVHTree->MaxPoint (0)))
@@ -500,7 +499,7 @@ void SelectMgr_ViewerSelector::TraverseSensitives()
       continue;
     }
 
-    Standard_Integer aStack[32];
+    Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
     Standard_Integer aHead = -1;
     for (;;)
     {
@@ -609,6 +608,19 @@ const SelectMgr_SortCriterion& SelectMgr_ViewerSelector::PickedData(const Standa
 //==================================================
 
 //==================================================
+// 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 :
 //==================================================
@@ -747,16 +759,12 @@ void SelectMgr_ViewerSelector::SortResult()
   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));
 }
 
 //=======================================================================
@@ -777,7 +785,7 @@ void SelectMgr_ViewerSelector::AddSelectableObject (const Handle(SelectMgr_Selec
   if (!myMapOfObjectSensitives.IsBound (theObject))
   {
     mySelectableObjects.Append (theObject);
-    NCollection_Handle<SelectMgr_SensitiveEntitySet> anEntitySet = new SelectMgr_SensitiveEntitySet();
+    Handle(SelectMgr_SensitiveEntitySet) anEntitySet = new SelectMgr_SensitiveEntitySet (myEntitySetBuilder);
     myMapOfObjectSensitives.Bind (theObject, anEntitySet);
   }
 }
@@ -789,12 +797,10 @@ void SelectMgr_ViewerSelector::AddSelectableObject (const Handle(SelectMgr_Selec
 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
   {
@@ -818,10 +824,10 @@ void SelectMgr_ViewerSelector::MoveSelectableObject (const Handle(SelectMgr_Sele
 //=======================================================================
 void SelectMgr_ViewerSelector::RemoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
 {
-  if (myMapOfObjectSensitives.IsBound (theObject))
+  Handle(SelectMgr_SelectableObject) anObj = theObject;
+  if (myMapOfObjectSensitives.UnBind (theObject))
   {
     mySelectableObjects.Remove (theObject);
-    myMapOfObjectSensitives.UnBind (theObject);
   }
 }
 
@@ -833,11 +839,9 @@ void SelectMgr_ViewerSelector::RemoveSelectableObject (const Handle(SelectMgr_Se
 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);
   }
 }
 
@@ -876,7 +880,7 @@ void SelectMgr_ViewerSelector::RebuildSensitivesTree (const Handle(SelectMgr_Sel
   if (!Contains (theObject))
     return;
 
-  NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
+  Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
   anEntitySet->MarkDirty();
 
   if (theIsForce)
@@ -892,12 +896,10 @@ void SelectMgr_ViewerSelector::RebuildSensitivesTree (const Handle(SelectMgr_Sel
 //=======================================================================
 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();
@@ -924,13 +926,14 @@ void SelectMgr_ViewerSelector::ActiveOwners (NCollection_List<Handle(SelectBasic
 {
   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());
       }
     }
   }
index 17c7ddc..42b07ed 100644 (file)
 #ifndef _SelectMgr_ViewerSelector_HeaderFile
 #define _SelectMgr_ViewerSelector_HeaderFile
 
-#include <MMgt_TShared.hxx>
-#include <NCollection_Handle.hxx>
+#include <Standard_Transient.hxx>
 #include <NCollection_DataMap.hxx>
 #include <OSD_Chronometer.hxx>
 #include <TColStd_SequenceOfInteger.hxx>
 #include <TColStd_HArray1OfInteger.hxx>
+#include <Select3D_BVHBuilder3d.hxx>
 #include <SelectMgr_IndexedDataMapOfOwnerCriterion.hxx>
 #include <SelectMgr_SelectingVolumeManager.hxx>
 #include <SelectMgr_Selection.hxx>
@@ -37,8 +37,8 @@ class SelectMgr_SensitiveEntitySet;
 class SelectMgr_EntityOwner;
 class SelectBasics_SensitiveEntity;
 
-typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), NCollection_Handle<SelectMgr_SensitiveEntitySet> > SelectMgr_MapOfObjectSensitives;
-typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), NCollection_Handle<SelectMgr_SensitiveEntitySet> >::Iterator SelectMgr_MapOfObjectSensitivesIterator;
+typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_SensitiveEntitySet) > SelectMgr_MapOfObjectSensitives;
+typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_SensitiveEntitySet) >::Iterator SelectMgr_MapOfObjectSensitivesIterator;
 
 typedef NCollection_DataMap<Standard_Integer, SelectMgr_SelectingVolumeManager> SelectMgr_FrustumCache;
 
@@ -127,6 +127,13 @@ public:
 
   Standard_EXPORT Standard_Boolean Contains (const Handle(SelectMgr_SelectableObject)& theObject) const;
 
+  //! Returns the default builder used to construct BVH of entity set.
+  const Handle(Select3D_BVHBuilder3d) EntitySetBuilder() { return myEntitySetBuilder; }
+
+  //! Sets the default builder used to construct BVH of entity set.
+  //! The new builder will be also assigned for already defined objects, but computed BVH trees will not be invalidated.
+  Standard_EXPORT void SetEntitySetBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder);
+
   //! Returns the list of selection modes ModeList found in
   //! this selector for the selectable object aSelectableObject.
   //! Returns true if aSelectableObject is referenced inside
@@ -319,6 +326,7 @@ protected:
   mutable SelectMgr_SelectableObjectSet         mySelectableObjects;
   SelectMgr_ToleranceMap                        myTolerances;
   NCollection_DataMap<Graphic3d_ZLayerId, Standard_Integer> myZLayerOrderMap;
+  Handle(Select3D_BVHBuilder3d)                 myEntitySetBuilder;
 
 private:
 
@@ -330,6 +338,6 @@ private:
 
 };
 
-DEFINE_STANDARD_HANDLE(SelectMgr_ViewerSelector, MMgt_TShared)
+DEFINE_STANDARD_HANDLE(SelectMgr_ViewerSelector, Standard_Transient)
 
 #endif
index 0d8ddf0..c863465 100644 (file)
@@ -81,17 +81,19 @@ void StdSelect_BRepSelectionTool::PreBuildBVH (const Handle(SelectMgr_Selection)
       aSensitive->BVH();
     }
 
-    if (aSensitive->IsInstance ("Select3D_SensitiveGroup"))
+    if (!aSensitive->IsInstance (STANDARD_TYPE(Select3D_SensitiveGroup)))
     {
-      Handle(Select3D_SensitiveGroup) aGroup (Handle(Select3D_SensitiveGroup)::DownCast (aSensitive));
-      const Select3D_EntitySequence& aSubEntities = aGroup->GetEntities();
-      for (Select3D_EntitySequenceIter aSubEntitiesIter (aSubEntities); aSubEntitiesIter.More(); aSubEntitiesIter.Next())
+      continue;
+    }
+
+    Handle(Select3D_SensitiveGroup) aGroup = Handle(Select3D_SensitiveGroup)::DownCast (aSensitive);
+    const Select3D_EntitySequence& aSubEntities = aGroup->GetEntities();
+    for (Select3D_EntitySequenceIter aSubEntitiesIter (aSubEntities); aSubEntitiesIter.More(); aSubEntitiesIter.Next())
+    {
+      const Handle(Select3D_SensitiveEntity)& aSubEntity = aSubEntitiesIter.Value();
+      if (aSubEntity->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
       {
-        const Handle(Select3D_SensitiveEntity)& aSubEntity = aSubEntitiesIter.Value();
-        if (aSubEntity->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
-        {
-          aSubEntity->BVH();
-        }
+        aSubEntity->BVH();
       }
     }
   }