0026122: Visualization, TKOpenGl - clipping and capping is broken when ffp is disable...
[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_ClipPlane.hxx>
21 #include <Graphic3d_SequenceOfHClipPlane.hxx>
22 #include <NCollection_DataMap.hxx>
23 #include <NCollection_Handle.hxx>
24 #include <Standard_TypeDef.hxx>
25 #include <OpenGl_Matrix.hxx>
26
27 class OpenGl_Context;
28 class OpenGl_Workspace;
29
30 //! This class contains logics related to tracking and modification of clipping plane
31 //! state for particular OpenGl context. It contains information about enabled
32 //! clipping planes and provides method to change clippings in context. The methods
33 //! should be executed within OpenGl context associated with instance of this
34 //! class.
35 class OpenGl_Clipping
36 {
37 public:
38
39   //! Enumerates supported equation coordinate spaces.
40   enum EquationCoords
41   {
42     EquationCoords_View,
43     EquationCoords_World
44   };
45
46 public: //! @name general methods
47
48   //! Default constructor.
49   Standard_EXPORT OpenGl_Clipping();
50
51   //! Initialize.
52   //! @param theMaxPlanes [in] number of clipping planes supported by OpenGl context.
53   Standard_EXPORT void Init (const Standard_Integer theMaxPlanes);
54
55 public: //! @name non-modifying getters
56
57   //! Check whether the clipping plane has been added to the current context state.
58   //! @param thePlane [in] the plane to check.
59   //! @return True if plane is set.
60   inline Standard_Boolean Contains (const Handle(Graphic3d_ClipPlane)& thePlane) const
61   {
62     return myPlaneStates.IsBound (thePlane);
63   }
64
65   //! Get clip planes defined for context.
66   //! @return sequence of set clipping planes.
67   inline const Graphic3d_SequenceOfHClipPlane& Planes() const
68   {
69     return myPlanes;
70   }
71
72   //! @return kind of equation coordinate space used for the clip plane.
73   inline EquationCoords GetEquationSpace (const Handle(Graphic3d_ClipPlane)& thePlane) const
74   {
75     return myPlaneStates.Find (thePlane).CoordSpace;
76   }
77
78   //! Check whether the clipping plane has been set and enabled for the current context state.
79   //! @param thePlane [in] the plane to check.
80   //! @return True if plane is enabled.
81   inline Standard_Boolean IsEnabled (const Handle(Graphic3d_ClipPlane)& thePlane) const
82   {
83     return myPlaneStates.Find (thePlane).IsEnabled;
84   }
85
86   //! @return true if there are enabled clipping planes (NOT capping)
87   inline Standard_Boolean IsClippingOn() const
88   {
89     return myNbClipping > 0;
90   }
91
92   //! @return true if there are enabled capping planes
93   inline Standard_Boolean IsCappingOn() const
94   {
95     return myNbCapping > 0;
96   }
97
98   //! @return true if there are enabled clipping or capping planes
99   inline Standard_Boolean IsClippingOrCappingOn() const
100   {
101     return (myNbClipping + myNbCapping) > 0;
102   }
103
104 public: //! @name clipping state modification commands
105
106   //! Add planes to the context clipping at the specified system of coordinates.
107   //! This methods loads appropriate transformation matrix from workspace to
108   //! to transform equation coordinates. The planes become enabled in the context.
109   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
110   //! are simply ignored.
111   //!
112   //! Within FFP, method also temporarily resets ModelView matrix before calling glClipPlane().
113   //! Otherwise the method just redirects to addLazy().
114   //!
115   //! @param theGlCtx [in] context to access the matrices
116   //! @param theCoordSpace [in] the equation definition space
117   //! @param thePlanes [in/out] the list of planes to be added
118   //! The list then provides information on which planes were really added to clipping state.
119   //! This list then can be used to fall back to previous state.
120   Standard_EXPORT void add (const Handle(OpenGl_Context)&   theGlCtx,
121                             const EquationCoords&           theCoordSpace,
122                             Graphic3d_SequenceOfHClipPlane& thePlanes);
123
124   //! Add planes to the context clipping at the specified system of coordinates.
125   //! This method assumes that appropriate matrix is already set in context state.
126   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
127   //! are simply ignored.
128   //! @param thePlanes [in/out] the list of planes to be added.
129   //! The list then provides information on which planes were really added to clipping state.
130   //! This list then can be used to fall back to previous state.
131   //! @param theCoordSpace [in] the equation definition space.
132   Standard_EXPORT void addLazy (const Handle(OpenGl_Context)&   theGlCtx,
133                                 const EquationCoords&           theCoordSpace,
134                                 Graphic3d_SequenceOfHClipPlane& thePlanes);
135
136   //! Remove the passed set of clipping planes from the context state.
137   //! @param thePlanes [in] the planes to remove from list.
138   Standard_EXPORT void Remove (const Handle(OpenGl_Context)&         theGlCtx,
139                                const Graphic3d_SequenceOfHClipPlane& thePlanes);
140
141   //! Enable or disable clipping plane in the OpenGl context.
142   //! @param thePlane [in] the plane to affect.
143   //! @param theIsEnabled [in] the state of the plane.
144   Standard_EXPORT void SetEnabled (const Handle(OpenGl_Context)&      theGlCtx,
145                                    const Handle(Graphic3d_ClipPlane)& thePlane,
146                                    const Standard_Boolean             theIsEnabled);
147
148 public: //! @name Short-cuts
149
150   //! Add planes to the context clipping at the view system of coordinates.
151   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
152   //! are simply ignored.
153   //! @param theGlCtx [in] context to access the matrices
154   //! @param thePlanes [in/out] the list of planes to be added
155   //! The list then provides information on which planes were really added to clipping state.
156   //! This list then can be used to fall back to previous state.
157   inline void AddView (const Handle(OpenGl_Context)&   theGlCtx,
158                        Graphic3d_SequenceOfHClipPlane& thePlanes)
159   {
160     add (theGlCtx, EquationCoords_View, thePlanes);
161   }
162
163   //! Add planes to the context clipping at the world system of coordinates.
164   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
165   //! are simply ignored.
166   //! @param theGlCtx [in] context to access the matrices
167   //! @param thePlanes [in/out] the list of planes to be added
168   //! The list then provides information on which planes were really added to clipping state.
169   //! This list then can be used to fall back to previous state.
170   inline void AddWorld (const Handle(OpenGl_Context)&   theGlCtx,
171                         Graphic3d_SequenceOfHClipPlane& thePlanes)
172   {
173     add (theGlCtx, EquationCoords_World, thePlanes);
174   }
175
176   //! Add planes to the context clipping at the world system of coordinates.
177   //! If the number of the passed planes exceeds capabilities of OpenGl, the last planes
178   //! are simply ignored.
179   //! @param thePlanes [in/out] the list of planes to be added
180   //! The list then provides information on which planes were really added to clipping state.
181   //! This list then can be used to fall back to previous state.
182   inline void AddWorldLazy (const Handle(OpenGl_Context)&   theGlCtx,
183                             Graphic3d_SequenceOfHClipPlane& thePlanes)
184   {
185     addLazy (theGlCtx, EquationCoords_World, thePlanes);
186   }
187
188   //! Remove all of the planes from context state.
189   inline void RemoveAll (const Handle(OpenGl_Context)& theGlCtx)
190   {
191     Remove (theGlCtx, Planes());
192   }
193
194 private:
195
196   struct PlaneProps
197   {
198     // declare default constructor
199     // to allow compilation of template collections
200     PlaneProps() {}
201     PlaneProps (const EquationCoords theCoords,
202                 const Standard_Integer theID,
203                 const Standard_Boolean theIsEnabled)
204     {
205       CoordSpace = theCoords;
206       ContextID  = theID;
207       IsEnabled  = theIsEnabled;
208     }
209
210     EquationCoords   CoordSpace;
211     Standard_Integer ContextID;
212     Standard_Boolean IsEnabled;
213   };
214
215 private:
216
217   typedef NCollection_DataMap<Handle(Graphic3d_ClipPlane), PlaneProps> OpenGl_MapOfPlaneStates;
218   typedef NCollection_Handle<Aspect_GenId> OpenGl_EmptyPlaneIds;
219
220   Graphic3d_SequenceOfHClipPlane myPlanes;        //!< defined clipping planes
221   OpenGl_MapOfPlaneStates        myPlaneStates;   //!< map of clip planes bound for the props
222   OpenGl_EmptyPlaneIds           myEmptyPlaneIds; //!< generator of empty ids
223   Standard_Boolean               myNbClipping;    //!< number of enabled clipping-only planes (NOT capping)
224   Standard_Boolean               myNbCapping;     //!< number of enabled capping  planes
225
226 private:
227
228   //! Copying allowed only within Handles
229   OpenGl_Clipping            (const OpenGl_Clipping& );
230   OpenGl_Clipping& operator= (const OpenGl_Clipping& );
231 };
232
233 #endif