0028738: Data Exchange, XCAFPrs_Style - add transparency property
[occt.git] / src / Graphic3d / Graphic3d_AspectFillArea3d.hxx
1 // Created on: 1991-11-04
2 // Created by: NW,JPB,CAL
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #ifndef _Graphic3d_AspectFillArea3d_HeaderFile
18 #define _Graphic3d_AspectFillArea3d_HeaderFile
19
20 #include <Aspect_AspectFillAreaDefinitionError.hxx>
21 #include <Aspect_PolygonOffsetMode.hxx>
22 #include <Aspect_InteriorStyle.hxx>
23 #include <Aspect_TypeOfLine.hxx>
24 #include <Graphic3d_HatchStyle.hxx>
25 #include <Graphic3d_MaterialAspect.hxx>
26 #include <Graphic3d_PolygonOffset.hxx>
27 #include <Graphic3d_ShaderProgram.hxx>
28 #include <Graphic3d_TextureMap.hxx>
29 #include <Standard.hxx>
30 #include <Standard_Boolean.hxx>
31 #include <Standard_Integer.hxx>
32 #include <Standard_ShortReal.hxx>
33 #include <Standard_Real.hxx>
34 #include <Standard_Type.hxx>
35 #include <Quantity_ColorRGBA.hxx>
36
37 //! This class defines graphic attributes for opaque 3d primitives (polygons, triangles, quadrilaterals).
38 class Graphic3d_AspectFillArea3d : public Standard_Transient
39 {
40   DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillArea3d, Standard_Transient)
41 public:
42
43   //! Creates a context table for fill area primitives defined with the following default values:
44   //!
45   //! InteriorStyle : Aspect_IS_EMPTY
46   //! InteriorColor : Quantity_NOC_CYAN1
47   //! EdgeColor     : Quantity_NOC_WHITE
48   //! EdgeLineType  : Aspect_TOL_SOLID
49   //! EdgeWidth     : 1.0
50   //! FrontMaterial : NOM_BRASS
51   //! BackMaterial  : NOM_BRASS
52   //! HatchStyle    : Aspect_HS_SOLID
53   //!
54   //! Display of back-facing filled polygons.
55   //! No distinction between external and internal faces of FillAreas.
56   //! The edges are not drawn.
57   //! Polygon offset parameters: mode = Aspect_POM_None, factor = 1., units = 0.
58   Standard_EXPORT Graphic3d_AspectFillArea3d();
59   
60   //! Creates a context table for fill area primitives defined with the specified values.
61   //! Display of back-facing filled polygons.
62   //! No distinction between external and internal faces of FillAreas.
63   //! The edges are not drawn.
64   //! Polygon offset parameters: mode = Aspect_POM_None, factor = 1., units = 0.
65   Standard_EXPORT Graphic3d_AspectFillArea3d (const Aspect_InteriorStyle theInterior,
66                                               const Quantity_Color&      theInteriorColor,
67                                               const Quantity_Color&      theEdgeColor,
68                                               const Aspect_TypeOfLine    theEdgeLineType,
69                                               const Standard_Real        theEdgeWidth,
70                                               const Graphic3d_MaterialAspect& theFrontMaterial,
71                                               const Graphic3d_MaterialAspect& theBackMaterial);
72
73   //! Return interior rendering style (Aspect_IS_EMPTY by default, which means nothing will be rendered!).
74   Aspect_InteriorStyle InteriorStyle() const { return myInteriorStyle; }
75
76   //! Modifies the interior type used for rendering
77   void SetInteriorStyle (const Aspect_InteriorStyle theStyle) { myInteriorStyle = theStyle; }
78
79   //! Return interior color.
80   const Quantity_Color& InteriorColor() const { return myInteriorColor.GetRGB(); }
81
82   //! Return interior color.
83   const Quantity_ColorRGBA& InteriorColorRGBA() const { return myInteriorColor; }
84
85   //! Modifies the color of the interior of the face
86   void SetInteriorColor (const Quantity_Color& theColor) { myInteriorColor.SetRGB (theColor); }
87
88   //! Modifies the color of the interior of the face
89   void SetInteriorColor (const Quantity_ColorRGBA& theColor) { myInteriorColor = theColor; }
90
91   //! Return back interior color.
92   const Quantity_Color& BackInteriorColor() const { return myBackInteriorColor.GetRGB(); }
93
94   //! Return back interior color.
95   const Quantity_ColorRGBA& BackInteriorColorRGBA() const { return myBackInteriorColor; }
96
97   //! Modifies the color of the interior of the back face
98   void SetBackInteriorColor (const Quantity_Color& theColor) { myBackInteriorColor.SetRGB (theColor); }
99
100   //! Modifies the color of the interior of the back face
101   void SetBackInteriorColor (const Quantity_ColorRGBA& theColor) { myBackInteriorColor = theColor; }
102
103   //! Returns the surface material of external faces
104   const Graphic3d_MaterialAspect& FrontMaterial() const { return myFrontMaterial; }
105
106   //! Returns the surface material of external faces
107   Graphic3d_MaterialAspect& ChangeFrontMaterial() { return myFrontMaterial; }
108
109   //! Modifies the surface material of external faces
110   void SetFrontMaterial (const Graphic3d_MaterialAspect& theMaterial) { myFrontMaterial = theMaterial; }
111
112   //! Returns the surface material of internal faces
113   const Graphic3d_MaterialAspect& BackMaterial() const { return myBackMaterial; }
114
115   //! Returns the surface material of internal faces
116   Graphic3d_MaterialAspect& ChangeBackMaterial() { return myBackMaterial; }
117
118   //! Modifies the surface material of internal faces
119   void SetBackMaterial (const Graphic3d_MaterialAspect& theMaterial) { myBackMaterial = theMaterial; }
120
121   //! Returns true if back faces should be suppressed (true by default).
122   bool ToSuppressBackFaces() const { return myToSuppressBackFaces; }
123
124   //! Assign back faces culling flag.
125   void SetSuppressBackFaces (bool theToSuppress) { myToSuppressBackFaces = theToSuppress; }
126
127   //! Returns true if back faces should be suppressed (true by default).
128   bool BackFace() const { return myToSuppressBackFaces; }
129
130   //! Allows the display of back-facing filled polygons.
131   void AllowBackFace() { myToSuppressBackFaces = false; }
132
133   //! Suppress the display of back-facing filled polygons.
134   //! A back-facing polygon is defined as a polygon whose
135   //! vertices are in a clockwise order with respect to screen coordinates.
136   void SuppressBackFace() { myToSuppressBackFaces = true; }
137
138   //! Returns true if material properties should be distinguished for back and front faces (false by default).
139   bool Distinguish() const { return myToDistinguishMaterials; }
140
141   //! Set material distinction between front and back faces.
142   void SetDistinguish (bool toDistinguish) { myToDistinguishMaterials = toDistinguish; }
143
144   //! Allows material distinction between front and back faces.
145   void SetDistinguishOn() { myToDistinguishMaterials = true; }
146
147   //! Forbids material distinction between front and back faces.
148   void SetDistinguishOff() { myToDistinguishMaterials = false; }
149
150   //! Return shader program.
151   const Handle(Graphic3d_ShaderProgram)& ShaderProgram() const { return myProgram; }
152
153   //! Sets up OpenGL/GLSL shader program.
154   void SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram) { myProgram = theProgram; }
155
156   //! Return texture to be mapped.
157   const Handle(Graphic3d_TextureMap)& TextureMap() const { return myTextureMap; }
158
159   //! Assign texture to be mapped.
160   //! See also SetTextureMap() to actually activate texture mapping.
161   void SetTextureMap (const Handle(Graphic3d_TextureMap)& theTexture) { myTextureMap = theTexture; }
162
163   //! Return true if texture mapping is enabled (false by default).
164   bool ToMapTexture() const { return myToMapTexture; }
165
166   //! Return true if texture mapping is enabled (false by default).
167   bool TextureMapState() const { return myToMapTexture; }
168
169   //! Enable texture mapping (has no effect if texture is not set).
170   void SetTextureMapOn() { myToMapTexture = true; }
171
172   //! Disable texture mapping.
173   void SetTextureMapOff() { myToMapTexture = false; }
174
175   //! Returns current polygon offsets settings.
176   const Graphic3d_PolygonOffset& PolygonOffset() const { return myPolygonOffset; }
177
178   //! Returns current polygon offsets settings.
179   void PolygonOffsets (Standard_Integer&   theMode,
180                        Standard_ShortReal& theFactor,
181                        Standard_ShortReal& theUnits) const
182   {
183     theMode   = myPolygonOffset.Mode;
184     theFactor = myPolygonOffset.Factor;
185     theUnits  = myPolygonOffset.Units;
186   }
187
188   //! Sets up OpenGL polygon offsets mechanism.
189   //! <aMode> parameter can contain various combinations of
190   //! Aspect_PolygonOffsetMode enumeration elements (Aspect_POM_None means
191   //! that polygon offsets are not changed).
192   //! If <aMode> is different from Aspect_POM_Off and Aspect_POM_None, then <aFactor> and <aUnits>
193   //! arguments are used by graphic renderer to calculate a depth offset value:
194   //!
195   //! offset = <aFactor> * m + <aUnits> * r, where
196   //! m - maximum depth slope for the polygon currently being displayed,
197   //! r - minimum window coordinates depth resolution (implementation-specific)
198   //!
199   //! Default settings for OCC 3D viewer: mode = Aspect_POM_Fill, factor = 1., units = 0.
200   //!
201   //! Negative offset values move polygons closer to the viewport,
202   //! while positive values shift polygons away.
203   //! Consult OpenGL reference for details (glPolygonOffset function description).
204   void SetPolygonOffsets (const Standard_Integer   theMode,
205                           const Standard_ShortReal theFactor = 1.0f,
206                           const Standard_ShortReal theUnits  = 0.0f)
207   {
208     myPolygonOffset.Mode   = (Aspect_PolygonOffsetMode )(theMode & Aspect_POM_Mask);
209     myPolygonOffset.Factor = theFactor;
210     myPolygonOffset.Units  = theUnits;
211   }
212
213 public:
214
215   //! Returns true if edges should be drawn (false by default).
216   bool ToDrawEdges() const { return myToDrawEdges; }
217
218   //! Set if edges should be drawn or not.
219   void SetDrawEdges (bool theToDraw) { myToDrawEdges = theToDraw; }
220
221   //! Returns true if edges should be drawn.
222   bool Edge() const { return myToDrawEdges; }
223
224   //! The edges of FillAreas are drawn.
225   void SetEdgeOn() { myToDrawEdges = true; }
226
227   //! The edges of FillAreas are not drawn.
228   void SetEdgeOff() { myToDrawEdges = false; }
229
230   //! Return color of edges.
231   const Quantity_Color& EdgeColor() const { return myEdgeColor.GetRGB(); }
232
233   //! Return color of edges.
234   const Quantity_ColorRGBA& EdgeColorRGBA() const { return myEdgeColor; }
235
236   //! Modifies the color of the edge of the face
237   void SetEdgeColor (const Quantity_Color& theColor) { myEdgeColor.SetRGB (theColor); }
238
239   //! Return edges line type.
240   Aspect_TypeOfLine EdgeLineType() const { return myEdgeType; }
241
242   //! Modifies the edge line type
243   void SetEdgeLineType (const Aspect_TypeOfLine theType) { myEdgeType = theType; }
244
245   //! Return width for edges in pixels.
246   Standard_ShortReal EdgeWidth() const { return myEdgeWidth; }
247
248   //! Modifies the edge thickness
249   //! Warning: Raises AspectFillAreaDefinitionError if the width is a negative value.
250   void SetEdgeWidth (const Standard_Real theWidth)
251   {
252     if (theWidth <= 0.0)
253     {
254       throw Aspect_AspectFillAreaDefinitionError("Bad value for EdgeLineWidth");
255     }
256     myEdgeWidth = (float )theWidth;
257   }
258
259 public:
260
261   //! Returns the hatch type used when InteriorStyle is IS_HATCH
262   const Handle(Graphic3d_HatchStyle)& HatchStyle() const { return myHatchStyle; }
263
264   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
265   void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle) { myHatchStyle = theStyle; }
266
267   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
268   //! @warning This method always creates a new handle for a given hatch style
269   void SetHatchStyle (const Aspect_HatchStyle theStyle)
270   {
271     if (theStyle == Aspect_HS_SOLID)
272     {
273       myHatchStyle.Nullify();
274       return;
275     }
276
277     myHatchStyle = new Graphic3d_HatchStyle (theStyle);
278   }
279
280   //! Returns the current values.
281   Standard_DEPRECATED("Deprecated method Values() should be replaced by individual property getters")
282   void Values (Aspect_InteriorStyle& theStyle,
283                Quantity_Color&       theIntColor,
284                Quantity_Color&       theEdgeColor,
285                Aspect_TypeOfLine&    theType,
286                Standard_Real&        theWidth) const
287   {
288     theStyle    = myInteriorStyle;
289     theIntColor = myInteriorColor.GetRGB();
290     theEdgeColor= myEdgeColor.GetRGB();
291     theType     = myEdgeType;
292     theWidth    = myEdgeWidth;
293   }
294
295   //! Returns the current values.
296   Standard_DEPRECATED("Deprecated method Values() should be replaced by individual property getters")
297   void Values (Aspect_InteriorStyle& theStyle,
298                Quantity_Color&       theIntColor,
299                Quantity_Color&       theBackIntColor,
300                Quantity_Color&       theEdgeColor,
301                Aspect_TypeOfLine&    theType,
302                Standard_Real&        theWidth) const
303   {
304     theStyle       = myInteriorStyle;
305     theIntColor    = myInteriorColor.GetRGB();
306     theBackIntColor= myBackInteriorColor.GetRGB();
307     theEdgeColor   = myEdgeColor.GetRGB();
308     theType        = myEdgeType;
309     theWidth       = myEdgeWidth;
310   }
311
312 protected:
313
314   Handle(Graphic3d_ShaderProgram) myProgram;
315   Handle(Graphic3d_TextureMap)    myTextureMap;
316   Graphic3d_MaterialAspect        myFrontMaterial;
317   Graphic3d_MaterialAspect        myBackMaterial;
318
319   Quantity_ColorRGBA           myInteriorColor;
320   Quantity_ColorRGBA           myBackInteriorColor;
321   Quantity_ColorRGBA           myEdgeColor;
322   Aspect_InteriorStyle         myInteriorStyle;
323   Aspect_TypeOfLine            myEdgeType;
324   Standard_ShortReal           myEdgeWidth;
325   Handle(Graphic3d_HatchStyle) myHatchStyle;
326
327   Graphic3d_PolygonOffset myPolygonOffset;
328   bool                    myToDistinguishMaterials;
329   bool                    myToDrawEdges;
330   bool                    myToSuppressBackFaces;
331   bool                    myToMapTexture;
332
333 };
334
335 DEFINE_STANDARD_HANDLE(Graphic3d_AspectFillArea3d, Standard_Transient)
336
337 #endif // _Graphic3d_AspectFillArea3d_HeaderFile