0029570: Visualization, Graphic3d_Aspect - merge Graphic3d_Group aspects
[occt.git] / src / Graphic3d / Graphic3d_Aspects.hxx
1 // Copyright (c) 2019 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #ifndef _Graphic3d_Aspects_HeaderFile
15 #define _Graphic3d_Aspects_HeaderFile
16
17 #include <Aspect_PolygonOffsetMode.hxx>
18 #include <Aspect_InteriorStyle.hxx>
19 #include <Aspect_TypeOfDisplayText.hxx>
20 #include <Aspect_TypeOfLine.hxx>
21 #include <Aspect_TypeOfMarker.hxx>
22 #include <Aspect_TypeOfStyleText.hxx>
23 #include <Font_FontAspect.hxx>
24 #include <Font_NameOfFont.hxx>
25 #include <Graphic3d_AlphaMode.hxx>
26 #include <Graphic3d_MarkerImage.hxx>
27 #include <Graphic3d_HatchStyle.hxx>
28 #include <Graphic3d_MaterialAspect.hxx>
29 #include <Graphic3d_PolygonOffset.hxx>
30 #include <Graphic3d_ShaderProgram.hxx>
31 #include <Graphic3d_TextureMap.hxx>
32 #include <Graphic3d_TextureSet.hxx>
33 #include <Graphic3d_TypeOfShadingModel.hxx>
34 #include <TCollection_HAsciiString.hxx>
35
36 //! This class defines graphic attributes.
37 class Graphic3d_Aspects : public Standard_Transient
38 {
39   DEFINE_STANDARD_RTTIEXT(Graphic3d_Aspects, Standard_Transient)
40 public:
41
42   //! Creates a context table for drawing primitives defined with the following default values:
43   Standard_EXPORT Graphic3d_Aspects();
44
45   //! Return interior rendering style; Aspect_IS_SOLID by default.
46   Aspect_InteriorStyle InteriorStyle() const { return myInteriorStyle; }
47
48   //! Modifies the interior type used for rendering
49   void SetInteriorStyle (const Aspect_InteriorStyle theStyle) { myInteriorStyle = theStyle; }
50
51   //! Returns shading model; Graphic3d_TOSM_DEFAULT by default.
52   //! Graphic3d_TOSM_DEFAULT means that Shading Model set as default for entire Viewer will be used.
53   Graphic3d_TypeOfShadingModel ShadingModel() const { return myShadingModel; }
54
55   //! Sets shading model
56   void SetShadingModel (const Graphic3d_TypeOfShadingModel theShadingModel) { myShadingModel = theShadingModel; }
57
58   //! Returns the way how alpha value should be treated (Graphic3d_AlphaMode_BlendAuto by default, for backward compatibility).
59   Graphic3d_AlphaMode AlphaMode() const { return myAlphaMode; }
60
61   //! Returns alpha cutoff threshold, for discarding fragments within Graphic3d_AlphaMode_Mask mode (0.5 by default).
62   //! If the alpha value is greater than or equal to this value then it is rendered as fully opaque, otherwise, it is rendered as fully transparent.
63   Standard_ShortReal AlphaCutoff() const { return myAlphaCutoff; }
64
65   //! Defines the way how alpha value should be treated.
66   void SetAlphaMode (Graphic3d_AlphaMode theMode, Standard_ShortReal theAlphaCutoff = 0.5f)
67   {
68     myAlphaMode = theMode;
69     myAlphaCutoff = theAlphaCutoff;
70   }
71
72   //! Return color
73   const Quantity_ColorRGBA& ColorRGBA() const { return myInteriorColor; }
74
75   //! Return the color.
76   const Quantity_Color& Color() const { return myInteriorColor.GetRGB(); }
77
78   //! Modifies the color.
79   void SetColor (const Quantity_Color& theColor) { myInteriorColor.SetRGB(theColor); }
80
81   //! Return interior color.
82   const Quantity_Color& InteriorColor() const { return myInteriorColor.GetRGB(); }
83
84   //! Return interior color.
85   const Quantity_ColorRGBA& InteriorColorRGBA() const { return myInteriorColor; }
86
87   //! Modifies the color of the interior of the face
88   void SetInteriorColor (const Quantity_Color& theColor) { myInteriorColor.SetRGB (theColor); }
89
90   //! Modifies the color of the interior of the face
91   void SetInteriorColor (const Quantity_ColorRGBA& theColor) { myInteriorColor = theColor; }
92
93   //! Return back interior color.
94   const Quantity_Color& BackInteriorColor() const { return myBackInteriorColor.GetRGB(); }
95
96   //! Return back interior color.
97   const Quantity_ColorRGBA& BackInteriorColorRGBA() const { return myBackInteriorColor; }
98
99   //! Modifies the color of the interior of the back face
100   void SetBackInteriorColor (const Quantity_Color& theColor) { myBackInteriorColor.SetRGB (theColor); }
101
102   //! Modifies the color of the interior of the back face
103   void SetBackInteriorColor (const Quantity_ColorRGBA& theColor) { myBackInteriorColor = theColor; }
104
105   //! Returns the surface material of external faces
106   const Graphic3d_MaterialAspect& FrontMaterial() const { return myFrontMaterial; }
107
108   //! Returns the surface material of external faces
109   Graphic3d_MaterialAspect& ChangeFrontMaterial() { return myFrontMaterial; }
110
111   //! Modifies the surface material of external faces
112   void SetFrontMaterial (const Graphic3d_MaterialAspect& theMaterial) { myFrontMaterial = theMaterial; }
113
114   //! Returns the surface material of internal faces
115   const Graphic3d_MaterialAspect& BackMaterial() const { return myBackMaterial; }
116
117   //! Returns the surface material of internal faces
118   Graphic3d_MaterialAspect& ChangeBackMaterial() { return myBackMaterial; }
119
120   //! Modifies the surface material of internal faces
121   void SetBackMaterial (const Graphic3d_MaterialAspect& theMaterial) { myBackMaterial = theMaterial; }
122
123   //! Returns true if back faces should be suppressed (true by default).
124   bool ToSuppressBackFaces() const { return myToSuppressBackFaces; }
125
126   //! Assign back faces culling flag.
127   void SetSuppressBackFaces (bool theToSuppress) { myToSuppressBackFaces = theToSuppress; }
128
129   //! Returns true if back faces should be suppressed (true by default).
130   bool BackFace() const { return myToSuppressBackFaces; }
131
132   //! Allows the display of back-facing filled polygons.
133   void AllowBackFace() { myToSuppressBackFaces = false; }
134
135   //! Suppress the display of back-facing filled polygons.
136   //! A back-facing polygon is defined as a polygon whose
137   //! vertices are in a clockwise order with respect to screen coordinates.
138   void SuppressBackFace() { myToSuppressBackFaces = true; }
139
140   //! Returns true if material properties should be distinguished for back and front faces (false by default).
141   bool Distinguish() const { return myToDistinguishMaterials; }
142
143   //! Set material distinction between front and back faces.
144   void SetDistinguish (bool toDistinguish) { myToDistinguishMaterials = toDistinguish; }
145
146   //! Allows material distinction between front and back faces.
147   void SetDistinguishOn() { myToDistinguishMaterials = true; }
148
149   //! Forbids material distinction between front and back faces.
150   void SetDistinguishOff() { myToDistinguishMaterials = false; }
151
152   //! Return shader program.
153   const Handle(Graphic3d_ShaderProgram)& ShaderProgram() const { return myProgram; }
154
155   //! Sets up OpenGL/GLSL shader program.
156   void SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram) { myProgram = theProgram; }
157
158   //! Return texture array to be mapped.
159   const Handle(Graphic3d_TextureSet)& TextureSet() const { return myTextureSet; }
160
161   //! Setup texture array to be mapped.
162   void SetTextureSet (const Handle(Graphic3d_TextureSet)& theTextures) { myTextureSet = theTextures; }
163
164   //! Return texture to be mapped.
165   //Standard_DEPRECATED("Deprecated method, TextureSet() should be used instead")
166   Handle(Graphic3d_TextureMap) TextureMap() const
167   {
168     return !myTextureSet.IsNull() && !myTextureSet->IsEmpty()
169           ? myTextureSet->First()
170           : Handle(Graphic3d_TextureMap)();
171   }
172
173   //! Assign texture to be mapped.
174   //! See also SetTextureMapOn() to actually activate texture mapping.
175   //Standard_DEPRECATED("Deprecated method, SetTextureSet() should be used instead")
176   Standard_EXPORT void SetTextureMap (const Handle(Graphic3d_TextureMap)& theTexture);
177
178   //! Return true if texture mapping is enabled (false by default).
179   bool ToMapTexture() const { return myToMapTexture; }
180
181   //! Return true if texture mapping is enabled (false by default).
182   bool TextureMapState() const { return myToMapTexture; }
183
184   //! Enable or disable texture mapping (has no effect if texture is not set).
185   void SetTextureMapOn (bool theToMap) { myToMapTexture = theToMap; }
186
187   //! Enable texture mapping (has no effect if texture is not set).
188   void SetTextureMapOn() { myToMapTexture = true; }
189
190   //! Disable texture mapping.
191   void SetTextureMapOff() { myToMapTexture = false; }
192
193   //! Returns current polygon offsets settings.
194   const Graphic3d_PolygonOffset& PolygonOffset() const { return myPolygonOffset; }
195
196   //! Sets polygon offsets settings.
197   void SetPolygonOffset (const Graphic3d_PolygonOffset& theOffset) { myPolygonOffset = theOffset; }
198
199   //! Returns current polygon offsets settings.
200   void PolygonOffsets (Standard_Integer&   theMode,
201                        Standard_ShortReal& theFactor,
202                        Standard_ShortReal& theUnits) const
203   {
204     theMode   = myPolygonOffset.Mode;
205     theFactor = myPolygonOffset.Factor;
206     theUnits  = myPolygonOffset.Units;
207   }
208
209   //! Sets up OpenGL polygon offsets mechanism.
210   //! <aMode> parameter can contain various combinations of
211   //! Aspect_PolygonOffsetMode enumeration elements (Aspect_POM_None means
212   //! that polygon offsets are not changed).
213   //! If <aMode> is different from Aspect_POM_Off and Aspect_POM_None, then <aFactor> and <aUnits>
214   //! arguments are used by graphic renderer to calculate a depth offset value:
215   //!
216   //! offset = <aFactor> * m + <aUnits> * r, where
217   //! m - maximum depth slope for the polygon currently being displayed,
218   //! r - minimum window coordinates depth resolution (implementation-specific)
219   //!
220   //! Default settings for OCC 3D viewer: mode = Aspect_POM_Fill, factor = 1., units = 0.
221   //!
222   //! Negative offset values move polygons closer to the viewport,
223   //! while positive values shift polygons away.
224   //! Consult OpenGL reference for details (glPolygonOffset function description).
225   void SetPolygonOffsets (const Standard_Integer   theMode,
226                           const Standard_ShortReal theFactor = 1.0f,
227                           const Standard_ShortReal theUnits  = 0.0f)
228   {
229     myPolygonOffset.Mode   = (Aspect_PolygonOffsetMode )(theMode & Aspect_POM_Mask);
230     myPolygonOffset.Factor = theFactor;
231     myPolygonOffset.Units  = theUnits;
232   }
233
234 //! @name parameters specific to Line primitive rendering
235 public:
236
237   //! Return line type; Aspect_TOL_SOLID by default.
238   Aspect_TypeOfLine LineType() const { return myLineType; }
239
240   //! Modifies the line type
241   void SetLineType (Aspect_TypeOfLine theType) { myLineType = theType; }
242
243   //! Return width for edges in pixels; 1.0 by default.
244   Standard_ShortReal LineWidth() const { return myLineWidth; }
245
246   //! Modifies the line thickness
247   //! Warning: Raises Standard_OutOfRange if the width is a negative value.
248   void SetLineWidth (Standard_ShortReal theWidth)
249   {
250     if (theWidth <= 0.0f)
251     {
252       throw Standard_OutOfRange ("Bad value for EdgeLineWidth");
253     }
254     myLineWidth = theWidth;
255   }
256
257 //! @name parameters specific to Point (Marker) primitive rendering
258 public:
259
260   //! Return marker type; Aspect_TOM_POINT by default.
261   Aspect_TypeOfMarker MarkerType() const { return myMarkerType; }
262
263   //! Modifies the type of marker.
264   void SetMarkerType (Aspect_TypeOfMarker theType) { myMarkerType = theType; }
265
266   //! Return marker scale factor; 1.0 by default.
267   Standard_ShortReal MarkerScale() const { return myMarkerScale; }
268
269   //! Modifies the scale factor.
270   //! Marker type Aspect_TOM_POINT is not affected by the marker size scale factor.
271   //! It is always the smallest displayable dot.
272   //! Warning: Raises Standard_OutOfRange if the scale is a negative value.
273   void SetMarkerScale (const Standard_ShortReal theScale)
274   {
275     if (theScale <= 0.0f)
276     {
277       throw Standard_OutOfRange ("Bad value for MarkerScale");
278     }
279     myMarkerScale = theScale;
280   }
281
282   //! Returns marker's image texture.
283   //! Could be null handle if marker aspect has been initialized as default type of marker.
284   const Handle(Graphic3d_MarkerImage)& MarkerImage() const { return myMarkerImage; }
285
286   //! Set marker's image texture.
287   void SetMarkerImage (const Handle(Graphic3d_MarkerImage)& theImage) { myMarkerImage = theImage; }
288
289 //! @name parameters specific to text rendering
290 public:
291
292   //! Returns the font; NULL string by default.
293   const Handle(TCollection_HAsciiString)& TextFont() const { return myTextFont; }
294
295   //! Modifies the font.
296   void SetTextFont (const Handle(TCollection_HAsciiString)& theFont) { myTextFont = theFont; }
297
298   //! Returns text FontAspect
299   Font_FontAspect TextFontAspect() const { return myTextFontAspect; }
300
301   //! Turns usage of Aspect text
302   void SetTextFontAspect (Font_FontAspect theFontAspect) { myTextFontAspect = theFontAspect; }
303
304   //! Returns display type; Aspect_TODT_NORMAL by default.
305   Aspect_TypeOfDisplayText TextDisplayType() const { return myTextDisplayType; }
306
307   //! Sets display type.
308   void SetTextDisplayType (Aspect_TypeOfDisplayText theType) { myTextDisplayType = theType; }
309
310   //! Returns text background/shadow color; equals to EdgeColor() property.
311   const Quantity_ColorRGBA& ColorSubTitleRGBA() const { return myEdgeColor; }
312
313   //! Return text background/shadow color; equals to EdgeColor() property.
314   const Quantity_Color& ColorSubTitle() const { return myEdgeColor.GetRGB(); }
315
316   //! Modifies text background/shadow color; equals to EdgeColor() property.
317   void SetColorSubTitle (const Quantity_Color& theColor) { myEdgeColor.SetRGB (theColor); }
318
319   //! Modifies text background/shadow color; equals to EdgeColor() property.
320   void SetColorSubTitle (const Quantity_ColorRGBA& theColor) { myEdgeColor = theColor; }
321
322   //! Returns TRUE when the Text Zoomable is on.
323   bool IsTextZoomable() const { return myIsTextZoomable; }
324
325   //! Turns usage of text zoomable on/off
326   void SetTextZoomable (bool theFlag) { myIsTextZoomable = theFlag; }
327
328   //! Returns the text style; Aspect_TOST_NORMAL by default.
329   Aspect_TypeOfStyleText TextStyle() const { return myTextStyle; }
330
331   //! Modifies the style of the text.
332   void SetTextStyle (Aspect_TypeOfStyleText theStyle) { myTextStyle = theStyle; }
333
334   //! Returns Angle of degree
335   Standard_ShortReal TextAngle() const { return myTextAngle; }
336
337   //! Turns usage of text rotated
338   void SetTextAngle (Standard_ShortReal theAngle) { myTextAngle = (Standard_ShortReal )theAngle; }
339
340 //! @name parameters specific to Mesh Edges (of triangulation primitive) rendering
341 public:
342
343   //! Returns true if mesh edges should be drawn (false by default).
344   bool ToDrawEdges() const { return myToDrawEdges && myLineType != Aspect_TOL_EMPTY; }
345
346   //! Set if mesh edges should be drawn or not.
347   void SetDrawEdges (bool theToDraw)
348   {
349     myToDrawEdges = theToDraw;
350     if (myLineType == Aspect_TOL_EMPTY)
351     {
352       myLineType = Aspect_TOL_SOLID;
353     }
354   }
355
356   //! The edges of FillAreas are drawn.
357   void SetEdgeOn() { SetDrawEdges (true); }
358
359   //! The edges of FillAreas are not drawn.
360   void SetEdgeOff() { SetDrawEdges (false); }
361
362   //! Return color of edges.
363   const Quantity_Color& EdgeColor() const { return myEdgeColor.GetRGB(); }
364
365   //! Return color of edges.
366   const Quantity_ColorRGBA& EdgeColorRGBA() const { return myEdgeColor; }
367
368   //! Modifies the color of the edge of the face
369   void SetEdgeColor (const Quantity_Color& theColor) { myEdgeColor.SetRGB (theColor); }
370
371   //! Modifies the color of the edge of the face
372   void SetEdgeColor (const Quantity_ColorRGBA& theColor) { myEdgeColor = theColor; }
373
374   //! Return edges line type (same as LineType()).
375   Aspect_TypeOfLine EdgeLineType() const { return myLineType; }
376
377   //! Modifies the edge line type (same as SetLineType())
378   void SetEdgeLineType (Aspect_TypeOfLine theType) { myLineType = theType; }
379
380   //! Return width for edges in pixels (same as LineWidth()).
381   Standard_ShortReal EdgeWidth() const { return myLineWidth; }
382
383   //! Modifies the edge thickness (same as SetLineWidth())
384   void SetEdgeWidth (Standard_Real theWidth) { SetLineWidth ((Standard_ShortReal )theWidth); }
385
386   //! Returns TRUE if drawing element edges should discard first edge in triangle; FALSE by default.
387   //! Graphics hardware works mostly with triangles, so that wireframe presentation will draw triangle edges by default.
388   //! This flag allows rendering wireframe presentation of quad-only array split into triangles.
389   //! For this, quads should be split in specific order, so that the quad diagonal (to be NOT rendered) goes first:
390   //!     1------2
391   //!    /      /   Triangle #1: 2-0-1; Triangle #2: 0-2-3
392   //!   0------3
393   bool ToSkipFirstEdge() const { return myToSkipFirstEdge; }
394
395   //! Set skip first triangle edge flag for drawing wireframe presentation of quads array split into triangles.
396   void SetSkipFirstEdge (bool theToSkipFirstEdge) { myToSkipFirstEdge = theToSkipFirstEdge; }
397
398   //! Returns TRUE if silhouette (outline) should be drawn (with edge color and width); FALSE by default.
399   bool ToDrawSilhouette() const { return myToDrawSilhouette; }
400
401   //! Enables/disables drawing silhouette (outline).
402   void SetDrawSilhouette (bool theToDraw) { myToDrawSilhouette = theToDraw; }
403
404 public:
405
406   //! Returns the hatch type used when InteriorStyle is IS_HATCH
407   const Handle(Graphic3d_HatchStyle)& HatchStyle() const { return myHatchStyle; }
408
409   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
410   void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle) { myHatchStyle = theStyle; }
411
412   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
413   //! @warning This method always creates a new handle for a given hatch style
414   void SetHatchStyle (const Aspect_HatchStyle theStyle)
415   {
416     if (theStyle == Aspect_HS_SOLID)
417     {
418       myHatchStyle.Nullify();
419       return;
420     }
421
422     myHatchStyle = new Graphic3d_HatchStyle (theStyle);
423   }
424
425 public:
426
427   //! Check for equality with another aspects.
428   bool IsEqual (const Graphic3d_Aspects& theOther)
429   {
430     if (this == &theOther)
431     {
432       return true;
433     }
434
435     return myProgram == theOther.myProgram
436         && myTextureSet == theOther.myTextureSet
437         && myMarkerImage == theOther.myMarkerImage
438         && myInteriorColor == theOther.myInteriorColor
439         && myBackInteriorColor == theOther.myBackInteriorColor
440         && myFrontMaterial == theOther.myFrontMaterial
441         && myBackMaterial  == theOther.myBackMaterial
442         && myInteriorStyle == theOther.myInteriorStyle
443         && myShadingModel == theOther.myShadingModel
444         && myAlphaMode == theOther.myAlphaMode
445         && myAlphaCutoff == theOther.myAlphaCutoff
446         && myLineType  == theOther.myLineType
447         && myEdgeColor == theOther.myEdgeColor
448         && myLineWidth == theOther.myLineWidth
449         && myMarkerType == theOther.myMarkerType
450         && myMarkerScale == theOther.myMarkerScale
451         && myHatchStyle == theOther.myHatchStyle
452         && myTextFont == theOther.myTextFont
453         && myPolygonOffset == theOther.myPolygonOffset
454         && myTextStyle == theOther.myTextStyle
455         && myTextDisplayType == theOther.myTextDisplayType
456         && myTextFontAspect == theOther.myTextFontAspect
457         && myTextAngle == theOther.myTextAngle
458         && myToSkipFirstEdge == theOther.myToSkipFirstEdge
459         && myToDistinguishMaterials == theOther.myToDistinguishMaterials
460         && myToDrawEdges == theOther.myToDrawEdges
461         && myToDrawSilhouette == theOther.myToDrawSilhouette
462         && myToSuppressBackFaces == theOther.myToSuppressBackFaces
463         && myToMapTexture == theOther.myToMapTexture
464         && myIsTextZoomable == theOther.myIsTextZoomable;
465   }
466
467 protected:
468
469   Handle(Graphic3d_ShaderProgram)  myProgram;
470   Handle(Graphic3d_TextureSet)     myTextureSet;
471   Handle(Graphic3d_MarkerImage)    myMarkerImage;
472   Handle(Graphic3d_HatchStyle)     myHatchStyle;
473   Handle(TCollection_HAsciiString) myTextFont;
474   Graphic3d_MaterialAspect         myFrontMaterial;
475   Graphic3d_MaterialAspect         myBackMaterial;
476
477   Quantity_ColorRGBA           myInteriorColor;
478   Quantity_ColorRGBA           myBackInteriorColor;
479   Quantity_ColorRGBA           myEdgeColor;
480
481   Graphic3d_PolygonOffset      myPolygonOffset;
482   Aspect_InteriorStyle         myInteriorStyle;
483   Graphic3d_TypeOfShadingModel myShadingModel;
484   Graphic3d_AlphaMode          myAlphaMode;
485   Standard_ShortReal           myAlphaCutoff;
486
487   Aspect_TypeOfLine            myLineType;
488   Standard_ShortReal           myLineWidth;
489
490   Aspect_TypeOfMarker          myMarkerType;
491   Standard_ShortReal           myMarkerScale;
492
493   Aspect_TypeOfStyleText   myTextStyle;
494   Aspect_TypeOfDisplayText myTextDisplayType;
495   Font_FontAspect          myTextFontAspect;
496   Standard_ShortReal       myTextAngle;
497
498   bool myToSkipFirstEdge;
499   bool myToDistinguishMaterials;
500   bool myToDrawEdges;
501   bool myToDrawSilhouette;
502   bool myToSuppressBackFaces;
503   bool myToMapTexture;
504   bool myIsTextZoomable;
505
506 };
507
508 DEFINE_STANDARD_HANDLE(Graphic3d_Aspects, Standard_Transient)
509
510 #endif // _Graphic3d_Aspects_HeaderFile