0027816: Visualization - provide an API for overriding clipping planes list
[occt.git] / src / OpenGl / OpenGl_Clipping.hxx
1 // Created on: 2013-09-05
2 // Created by: Anton POLETAEV
3 // Copyright (c) 2013-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _OpenGl_Clipping_H__
17 #define _OpenGl_Clipping_H__
18
19 #include <Aspect_GenId.hxx>
20 #include <Graphic3d_SequenceOfHClipPlane.hxx>
21 #include <NCollection_Vector.hxx>
22 #include <Standard_TypeDef.hxx>
23
24 class OpenGl_Context;
25 class OpenGl_ClippingIterator;
26
27 //! This class contains logics related to tracking and modification of clipping plane
28 //! state for particular OpenGl context. It contains information about enabled
29 //! clipping planes and provides method to change clippings in context. The methods
30 //! should be executed within OpenGl context associated with instance of this
31 //! class.
32 class OpenGl_Clipping
33 {
34 public: //! @name general methods
35
36   //! Default constructor.
37   Standard_EXPORT OpenGl_Clipping();
38
39   //! Initialize.
40   //! @param theMaxPlanes [in] number of clipping planes supported by OpenGl context.
41   Standard_EXPORT void Init (const Standard_Integer theMaxPlanes);
42
43   //! Setup list of global (for entire view) clipping planes
44   //! and clears local plane list if it was not released before.
45   Standard_EXPORT void Reset (const Handle(OpenGl_Context)& theGlCtx,
46                               const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
47
48   //! Setup list of local (for current object) clipping planes.
49   Standard_EXPORT void SetLocalPlanes (const Handle(OpenGl_Context)& theGlCtx,
50                                        const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes);
51
52   //! @return true if there are enabled clipping planes (NOT capping)
53   Standard_Boolean IsClippingOn() const { return myNbClipping > 0; }
54
55   //! @return true if there are enabled capping planes
56   Standard_Boolean IsCappingOn() const { return myNbCapping > 0; }
57
58   //! @return true if there are enabled clipping or capping planes
59   Standard_Boolean IsClippingOrCappingOn() const { return (myNbClipping + myNbCapping) > 0; }
60
61   //! @return number of enabled clipping + capping planes
62   Standard_Integer NbClippingOrCappingOn() const { return myNbClipping + myNbCapping; }
63
64 public: //! @name advanced method for disabling defined planes
65
66   //! Return true if some clipping planes have been temporarily disabled.
67   Standard_Boolean HasDisabled() const { return myNbDisabled > 0; }
68
69   //! Disable plane temporarily.
70   Standard_EXPORT Standard_Boolean SetEnabled (const Handle(OpenGl_Context)&  theGlCtx,
71                                                const OpenGl_ClippingIterator& thePlane,
72                                                const Standard_Boolean         theIsEnabled);
73
74   //! Temporarily disable all planes from the global (view) list, keep only local (object) list.
75   Standard_EXPORT void DisableGlobal (const Handle(OpenGl_Context)& theGlCtx);
76
77   //! Restore all temporarily disabled planes.
78   //! Does NOT affect constantly disabled planes Graphic3d_ClipPlane::IsOn().
79   Standard_EXPORT void RestoreDisabled (const Handle(OpenGl_Context)& theGlCtx);
80
81   //! Temporarily disable all planes except specified one.
82   //! Does not affect already disabled planes.
83   Standard_EXPORT void DisableAllExcept (const Handle(OpenGl_Context)&  theGlCtx,
84                                          const OpenGl_ClippingIterator& thePlane);
85
86   //! Enable back planes disabled by ::DisableAllExcept().
87   //! Keeps only specified plane enabled.
88   Standard_EXPORT void EnableAllExcept (const Handle(OpenGl_Context)&  theGlCtx,
89                                         const OpenGl_ClippingIterator& thePlane);
90
91 protected: //! @name clipping state modification commands
92
93   //! Add planes to the context clipping at the specified system of coordinates.
94   //! This methods loads appropriate transformation matrix from workspace to
95   //! to transform equation coordinates. The planes become enabled in the context.
96   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
97   //! are simply ignored.
98   //!
99   //! Within FFP, method also temporarily resets ModelView matrix before calling glClipPlane().
100   //! Otherwise the method just redirects to addLazy().
101   //!
102   //! @param theGlCtx [in] context to access the matrices
103   //! @param thePlanes [in/out] the list of planes to be added
104   //! The list then provides information on which planes were really added to clipping state.
105   //! This list then can be used to fall back to previous state.
106   Standard_EXPORT void add (const Handle(OpenGl_Context)& theGlCtx,
107                             const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
108                             const Standard_Integer theStartIndex);
109
110   //! Remove the passed set of clipping planes from the context state.
111   //! @param thePlanes [in] the planes to remove from list.
112   Standard_EXPORT void remove (const Handle(OpenGl_Context)& theGlCtx,
113                                const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes,
114                                const Standard_Integer theStartIndex);
115
116 private:
117
118   Handle(Graphic3d_SequenceOfHClipPlane)   myPlanesGlobal;   //!< global clipping planes
119   Handle(Graphic3d_SequenceOfHClipPlane)   myPlanesLocal;    //!< object clipping planes
120   NCollection_Vector<Standard_Boolean>     myDisabledPlanes; //!< ids of disabled planes
121   NCollection_Vector<Standard_Boolean>     mySkipFilter;     //!< ids of planes that were disabled before calling ::DisableAllExcept()
122   Handle(NCollection_Shared<Aspect_GenId>) myEmptyPlaneIds;  //!< generator of empty ids for FFP clipping planes
123   Standard_Integer                         myNbClipping;     //!< number of enabled clipping-only planes (NOT capping)
124   Standard_Integer                         myNbCapping;      //!< number of enabled capping  planes
125   Standard_Integer                         myNbDisabled;     //!< number of defined but disabled planes
126
127 private:
128
129   //! Copying allowed only within Handles
130   OpenGl_Clipping            (const OpenGl_Clipping& );
131   OpenGl_Clipping& operator= (const OpenGl_Clipping& );
132
133   friend class OpenGl_ClippingIterator;
134 };
135
136 //! The iterator through clipping planes.
137 class OpenGl_ClippingIterator
138 {
139 public:
140
141   //! Main constructor.
142   Standard_EXPORT OpenGl_ClippingIterator(const OpenGl_Clipping& theClipping);
143
144   //! Return true if iterator points to the valid clipping plane.
145   bool More() const { return myIter1.More() || myIter2.More(); }
146
147   //! Go to the next clipping plane.
148   void Next()
149   {
150     ++myCurrIndex;
151     if (myIter1.More())
152     {
153       myIter1.Next();
154     }
155     else
156     {
157       myIter2.Next();
158     }
159   }
160
161   //! Return true if plane has been temporarily disabled
162   //! either by Graphic3d_ClipPlane->IsOn() property or by temporary filter.
163   bool IsDisabled() const { return myDisabled->Value (myCurrIndex) || !Value()->IsOn(); }
164
165   //! Return the plane at current iterator position.
166   const Handle(Graphic3d_ClipPlane)& Value() const
167   {
168     return myIter1.More()
169          ? myIter1.Value()
170          : myIter2.Value();
171   }
172
173   //! Return true if plane from the global (view) list.
174   bool IsGlobal() const { return myIter1.More(); }
175
176   //! Return the plane index.
177   Standard_Integer PlaneIndex() const { return myCurrIndex; }
178
179 private:
180
181   Graphic3d_SequenceOfHClipPlane::Iterator myIter1;
182   Graphic3d_SequenceOfHClipPlane::Iterator myIter2;
183   const NCollection_Vector<Standard_Boolean>* myDisabled;
184   Standard_Integer myCurrIndex;
185
186 };
187
188 #endif