0029729: Visualization, Graphic3d_ClipPlane - add support of clipping plane chains
[occt.git] / src / OpenGl / OpenGl_Clipping.hxx
index 6e1c5d3..b2fe1f3 100755 (executable)
@@ -20,7 +20,6 @@
 #include <NCollection_Vector.hxx>
 #include <Standard_TypeDef.hxx>
 
-class OpenGl_Context;
 class OpenGl_ClippingIterator;
 
 //! This class contains logics related to tracking and modification of clipping plane
@@ -30,35 +29,51 @@ class OpenGl_ClippingIterator;
 //! class.
 class OpenGl_Clipping
 {
+  friend class OpenGl_ClippingIterator;
 public: //! @name general methods
 
   //! Default constructor.
   Standard_EXPORT OpenGl_Clipping();
 
   //! Initialize.
-  //! @param theMaxPlanes [in] number of clipping planes supported by OpenGl context.
-  Standard_EXPORT void Init (const Standard_Integer theMaxPlanes);
+  Standard_EXPORT void Init();
 
   //! Setup list of global (for entire view) clipping planes
   //! and clears local plane list if it was not released before.
-  Standard_EXPORT void Reset (const Handle(OpenGl_Context)& theGlCtx,
-                              const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
+  Standard_EXPORT void Reset (const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
 
   //! Setup list of local (for current object) clipping planes.
-  Standard_EXPORT void SetLocalPlanes (const Handle(OpenGl_Context)& theGlCtx,
-                                       const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
-
-  //! @return true if there are enabled clipping planes (NOT capping)
-  Standard_Boolean IsClippingOn() const { return myNbClipping > 0; }
+  Standard_EXPORT void SetLocalPlanes (const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
 
   //! @return true if there are enabled capping planes
   Standard_Boolean IsCappingOn() const { return myNbCapping > 0; }
 
   //! @return true if there are enabled clipping or capping planes
-  Standard_Boolean IsClippingOrCappingOn() const { return (myNbClipping + myNbCapping) > 0; }
+  Standard_Boolean IsClippingOrCappingOn() const { return NbClippingOrCappingOn() > 0; }
 
   //! @return number of enabled clipping + capping planes
-  Standard_Integer NbClippingOrCappingOn() const { return myNbClipping + myNbCapping; }
+  Standard_Integer NbClippingOrCappingOn() const
+  {
+    if (IsCappingDisableAllExcept())
+    {
+      return 1; // all Chains are disabled - only single (sub) plane is active
+    }
+    return myNbClipping + myNbCapping
+        + (IsCappingEnableAllExcept() ? -1 : 0); // exclude 1 plane with Capping filter turned ON
+  }
+
+  //! Return TRUE if there are clipping chains in the list (defining more than 1 sub-plane)
+  Standard_Boolean HasClippingChains() const
+  {
+    if (IsCappingDisableAllExcept()                 // all chains are disabled - only single (sub) plane is active;
+     || myNbChains == (myNbClipping + myNbCapping)) // no sub-planes
+    {
+      return Standard_False;
+    }
+    return !IsCappingEnableAllExcept()
+         || myCappedChain->NbChainNextPlanes() == 1
+         || myNbChains > 1; // if capping filter ON - chains counter should be decremented
+  }
 
 public: //! @name advanced method for disabling defined planes
 
@@ -66,26 +81,46 @@ public: //! @name advanced method for disabling defined planes
   Standard_Boolean HasDisabled() const { return myNbDisabled > 0; }
 
   //! Disable plane temporarily.
-  Standard_EXPORT Standard_Boolean SetEnabled (const Handle(OpenGl_Context)&  theGlCtx,
-                                               const OpenGl_ClippingIterator& thePlane,
+  Standard_EXPORT Standard_Boolean SetEnabled (const OpenGl_ClippingIterator& thePlane,
                                                const Standard_Boolean         theIsEnabled);
 
   //! Temporarily disable all planes from the global (view) list, keep only local (object) list.
-  Standard_EXPORT void DisableGlobal (const Handle(OpenGl_Context)& theGlCtx);
+  Standard_EXPORT void DisableGlobal();
 
   //! Restore all temporarily disabled planes.
   //! Does NOT affect constantly disabled planes Graphic3d_ClipPlane::IsOn().
-  Standard_EXPORT void RestoreDisabled (const Handle(OpenGl_Context)& theGlCtx);
+  Standard_EXPORT void RestoreDisabled();
+
+//! @name capping algorithm filter
+public:
+
+  //! Chain which is either temporary disabled or the only one enabled for Capping algorithm.
+  const Handle(Graphic3d_ClipPlane)& CappedChain() const { return myCappedChain; }
+
+  //! Sub-plane index within filtered Chain; positive number for DisableAllExcept and negative for EnableAllExcept.
+  Standard_Integer CappedSubPlane() const { return myCappedSubPlane; }
+
+  //! Return TRUE if capping algorithm is in state, when all clipping planes are temporarily disabled except currently processed one.
+  bool IsCappingFilterOn() const { return !myCappedChain.IsNull(); }
+
+  //! Return TRUE if capping algorithm is in state, when all clipping planes are temporarily disabled except currently processed one.
+  bool IsCappingDisableAllExcept() const { return myCappedSubPlane > 0; }
+
+  //! Return TRUE if capping algorithm is in state, when all clipping planes are enabled except currently rendered one.
+  bool IsCappingEnableAllExcept() const { return myCappedSubPlane < 0; }
 
-  //! Temporarily disable all planes except specified one.
+  //! Temporarily disable all planes except specified one for Capping algorithm.
   //! Does not affect already disabled planes.
-  Standard_EXPORT void DisableAllExcept (const Handle(OpenGl_Context)&  theGlCtx,
-                                         const OpenGl_ClippingIterator& thePlane);
+  Standard_EXPORT void DisableAllExcept (const Handle(Graphic3d_ClipPlane)& theChain,
+                                         const Standard_Integer theSubPlaneIndex);
 
-  //! Enable back planes disabled by ::DisableAllExcept().
+  //! Enable back planes disabled by ::DisableAllExcept() for Capping algorithm.
   //! Keeps only specified plane enabled.
-  Standard_EXPORT void EnableAllExcept (const Handle(OpenGl_Context)&  theGlCtx,
-                                        const OpenGl_ClippingIterator& thePlane);
+  Standard_EXPORT void EnableAllExcept (const Handle(Graphic3d_ClipPlane)& theChain,
+                                        const Standard_Integer theSubPlaneIndex);
+
+  //! Resets chain filter for Capping algorithm.
+  Standard_EXPORT void ResetCappingFilter();
 
 protected: //! @name clipping state modification commands
 
@@ -98,18 +133,15 @@ protected: //! @name clipping state modification commands
   //! Within FFP, method also temporarily resets ModelView matrix before calling glClipPlane().
   //! Otherwise the method just redirects to addLazy().
   //!
-  //! @param theGlCtx [in] context to access the matrices
   //! @param thePlanes [in/out] the list of planes to be added
   //! The list then provides information on which planes were really added to clipping state.
   //! This list then can be used to fall back to previous state.
-  Standard_EXPORT void add (const Handle(OpenGl_Context)& theGlCtx,
-                            const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
+  Standard_EXPORT void add (const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
                             const Standard_Integer theStartIndex);
 
   //! Remove the passed set of clipping planes from the context state.
   //! @param thePlanes [in] the planes to remove from list.
-  Standard_EXPORT void remove (const Handle(OpenGl_Context)& theGlCtx,
-                               const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
+  Standard_EXPORT void remove (const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
                                const Standard_Integer theStartIndex);
 
 private:
@@ -117,70 +149,19 @@ private:
   Handle(Graphic3d_SequenceOfHClipPlane)   myPlanesGlobal;   //!< global clipping planes
   Handle(Graphic3d_SequenceOfHClipPlane)   myPlanesLocal;    //!< object clipping planes
   NCollection_Vector<Standard_Boolean>     myDisabledPlanes; //!< ids of disabled planes
-  NCollection_Vector<Standard_Boolean>     mySkipFilter;     //!< ids of planes that were disabled before calling ::DisableAllExcept()
+
+  Handle(Graphic3d_ClipPlane)              myCappedChain;    //!< chain which is either temporary disabled or the only one enabled for Capping algorithm
+  Standard_Integer                         myCappedSubPlane; //!< sub-plane index within filtered chain; positive number for DisableAllExcept and negative for EnableAllExcept
+
   Standard_Integer                         myNbClipping;     //!< number of enabled clipping-only planes (NOT capping)
   Standard_Integer                         myNbCapping;      //!< number of enabled capping  planes
+  Standard_Integer                         myNbChains;       //!< number of enabled chains
   Standard_Integer                         myNbDisabled;     //!< number of defined but disabled planes
 
 private:
-
   //! Copying allowed only within Handles
   OpenGl_Clipping            (const OpenGl_Clipping& );
   OpenGl_Clipping& operator= (const OpenGl_Clipping& );
-
-  friend class OpenGl_ClippingIterator;
-};
-
-//! The iterator through clipping planes.
-class OpenGl_ClippingIterator
-{
-public:
-
-  //! Main constructor.
-  Standard_EXPORT OpenGl_ClippingIterator(const OpenGl_Clipping& theClipping);
-
-  //! Return true if iterator points to the valid clipping plane.
-  bool More() const { return myIter1.More() || myIter2.More(); }
-
-  //! Go to the next clipping plane.
-  void Next()
-  {
-    ++myCurrIndex;
-    if (myIter1.More())
-    {
-      myIter1.Next();
-    }
-    else
-    {
-      myIter2.Next();
-    }
-  }
-
-  //! Return true if plane has been temporarily disabled
-  //! either by Graphic3d_ClipPlane->IsOn() property or by temporary filter.
-  bool IsDisabled() const { return myDisabled->Value (myCurrIndex) || !Value()->IsOn(); }
-
-  //! Return the plane at current iterator position.
-  const Handle(Graphic3d_ClipPlane)& Value() const
-  {
-    return myIter1.More()
-         ? myIter1.Value()
-         : myIter2.Value();
-  }
-
-  //! Return true if plane from the global (view) list.
-  bool IsGlobal() const { return myIter1.More(); }
-
-  //! Return the plane index.
-  Standard_Integer PlaneIndex() const { return myCurrIndex; }
-
-private:
-
-  Graphic3d_SequenceOfHClipPlane::Iterator myIter1;
-  Graphic3d_SequenceOfHClipPlane::Iterator myIter2;
-  const NCollection_Vector<Standard_Boolean>* myDisabled;
-  Standard_Integer myCurrIndex;
-
 };
 
 #endif