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_AlphaMode.hxx>
  25 #include <Graphic3d_HatchStyle.hxx>
  26 #include <Graphic3d_MaterialAspect.hxx>
  27 #include <Graphic3d_PolygonOffset.hxx>
  28 #include <Graphic3d_ShaderProgram.hxx>
  29 #include <Graphic3d_TextureMap.hxx>
  30 #include <Graphic3d_TextureSet.hxx>
  31 #include <Graphic3d_TypeOfShadingModel.hxx>
  32 #include <Standard.hxx>
  33 #include <Standard_Boolean.hxx>
  34 #include <Standard_Integer.hxx>
  35 #include <Standard_ShortReal.hxx>
  36 #include <Standard_Real.hxx>
  37 #include <Standard_Type.hxx>
  38 #include <Quantity_ColorRGBA.hxx>
  39
  40 //! This class defines graphic attributes for opaque 3d primitives (polygons, triangles, quadrilaterals).
  41 class Graphic3d_AspectFillArea3d : public Standard_Transient
  42 {
  43   DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillArea3d, Standard_Transient)
  44 public:
  45
  46   //! Creates a context table for fill area primitives defined with the following default values:
  47   //!
  48   //! InteriorStyle : Aspect_IS_EMPTY
  49   //! InteriorColor : Quantity_NOC_CYAN1
  50   //! EdgeColor     : Quantity_NOC_WHITE
  51   //! EdgeLineType  : Aspect_TOL_SOLID
  52   //! EdgeWidth     : 1.0
  53   //! FrontMaterial : NOM_BRASS
  54   //! BackMaterial  : NOM_BRASS
  55   //! HatchStyle    : Aspect_HS_SOLID
  56   //!
  57   //! Display of back-facing filled polygons.
  58   //! No distinction between external and internal faces of FillAreas.
  59   //! The edges are not drawn.
  60   //! Polygon offset parameters: mode = Aspect_POM_None, factor = 1., units = 0.
  61   Standard_EXPORT Graphic3d_AspectFillArea3d();
  62
  63   //! Creates a context table for fill area primitives defined with the specified values.
  64   //! Display of back-facing filled polygons.
  65   //! No distinction between external and internal faces of FillAreas.
  66   //! The edges are not drawn.
  67   //! Polygon offset parameters: mode = Aspect_POM_None, factor = 1., units = 0.
  68   Standard_EXPORT Graphic3d_AspectFillArea3d (const Aspect_InteriorStyle theInterior,
  69                                               const Quantity_Color&      theInteriorColor,
  70                                               const Quantity_Color&      theEdgeColor,
  71                                               const Aspect_TypeOfLine    theEdgeLineType,
  72                                               const Standard_Real        theEdgeWidth,
  73                                               const Graphic3d_MaterialAspect& theFrontMaterial,
  74                                               const Graphic3d_MaterialAspect& theBackMaterial);
  75
  76   //! Return interior rendering style (Aspect_IS_EMPTY by default, which means nothing will be rendered!).
  77   Aspect_InteriorStyle InteriorStyle() const { return myInteriorStyle; }
  78
  79   //! Modifies the interior type used for rendering
  80   void SetInteriorStyle (const Aspect_InteriorStyle theStyle) { myInteriorStyle = theStyle; }
  81
  82   //! Returns shading model (Graphic3d_TOSM_DEFAULT by default, which means that Shading Model set as default for entire Viewer will be used)
  83   Graphic3d_TypeOfShadingModel ShadingModel() const { return myShadingModel; }
  84
  85   //! Sets shading model
  86   void SetShadingModel (const Graphic3d_TypeOfShadingModel theShadingModel) { myShadingModel = theShadingModel; }
  87
  88   //! Returns the way how alpha value should be treated (Graphic3d_AlphaMode_BlendAuto by default, for backward compatibility).
  89   Graphic3d_AlphaMode AlphaMode() const { return myAlphaMode; }
  90
  91   //! Returns alpha cutoff threshold, for discarding fragments within Graphic3d_AlphaMode_Mask mode (0.5 by default).
  92   //! 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.
  93   Standard_ShortReal AlphaCutoff() const { return myAlphaCutoff; }
  94
  95   //! Defines the way how alpha value should be treated.
  96   void SetAlphaMode (Graphic3d_AlphaMode theMode, Standard_ShortReal theAlphaCutoff = 0.5f)
  97   {
  98     myAlphaMode = theMode;
  99     myAlphaCutoff = theAlphaCutoff;
 100   }
 101
 102   //! Return interior color.
 103   const Quantity_Color& InteriorColor() const { return myInteriorColor.GetRGB(); }
 104
 105   //! Return interior color.
 106   const Quantity_ColorRGBA& InteriorColorRGBA() const { return myInteriorColor; }
 107
 108   //! Modifies the color of the interior of the face
 109   void SetInteriorColor (const Quantity_Color& theColor) { myInteriorColor.SetRGB (theColor); }
 110
 111   //! Modifies the color of the interior of the face
 112   void SetInteriorColor (const Quantity_ColorRGBA& theColor) { myInteriorColor = theColor; }
 113
 114   //! Return back interior color.
 115   const Quantity_Color& BackInteriorColor() const { return myBackInteriorColor.GetRGB(); }
 116
 117   //! Return back interior color.
 118   const Quantity_ColorRGBA& BackInteriorColorRGBA() const { return myBackInteriorColor; }
 119
 120   //! Modifies the color of the interior of the back face
 121   void SetBackInteriorColor (const Quantity_Color& theColor) { myBackInteriorColor.SetRGB (theColor); }
 122
 123   //! Modifies the color of the interior of the back face
 124   void SetBackInteriorColor (const Quantity_ColorRGBA& theColor) { myBackInteriorColor = theColor; }
 125
 126   //! Returns the surface material of external faces
 127   const Graphic3d_MaterialAspect& FrontMaterial() const { return myFrontMaterial; }
 128
 129   //! Returns the surface material of external faces
 130   Graphic3d_MaterialAspect& ChangeFrontMaterial() { return myFrontMaterial; }
 131
 132   //! Modifies the surface material of external faces
 133   void SetFrontMaterial (const Graphic3d_MaterialAspect& theMaterial) { myFrontMaterial = theMaterial; }
 134
 135   //! Returns the surface material of internal faces
 136   const Graphic3d_MaterialAspect& BackMaterial() const { return myBackMaterial; }
 137
 138   //! Returns the surface material of internal faces
 139   Graphic3d_MaterialAspect& ChangeBackMaterial() { return myBackMaterial; }
 140
 141   //! Modifies the surface material of internal faces
 142   void SetBackMaterial (const Graphic3d_MaterialAspect& theMaterial) { myBackMaterial = theMaterial; }
 143
 144   //! Returns true if back faces should be suppressed (true by default).
 145   bool ToSuppressBackFaces() const { return myToSuppressBackFaces; }
 146
 147   //! Assign back faces culling flag.
 148   void SetSuppressBackFaces (bool theToSuppress) { myToSuppressBackFaces = theToSuppress; }
 149
 150   //! Returns true if back faces should be suppressed (true by default).
 151   bool BackFace() const { return myToSuppressBackFaces; }
 152
 153   //! Allows the display of back-facing filled polygons.
 154   void AllowBackFace() { myToSuppressBackFaces = false; }
 155
 156   //! Suppress the display of back-facing filled polygons.
 157   //! A back-facing polygon is defined as a polygon whose
 158   //! vertices are in a clockwise order with respect to screen coordinates.
 159   void SuppressBackFace() { myToSuppressBackFaces = true; }
 160
 161   //! Returns true if material properties should be distinguished for back and front faces (false by default).
 162   bool Distinguish() const { return myToDistinguishMaterials; }
 163
 164   //! Set material distinction between front and back faces.
 165   void SetDistinguish (bool toDistinguish) { myToDistinguishMaterials = toDistinguish; }
 166
 167   //! Allows material distinction between front and back faces.
 168   void SetDistinguishOn() { myToDistinguishMaterials = true; }
 169
 170   //! Forbids material distinction between front and back faces.
 171   void SetDistinguishOff() { myToDistinguishMaterials = false; }
 172
 173   //! Return shader program.
 174   const Handle(Graphic3d_ShaderProgram)& ShaderProgram() const { return myProgram; }
 175
 176   //! Sets up OpenGL/GLSL shader program.
 177   void SetShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProgram) { myProgram = theProgram; }
 178
 179   //! Return texture array to be mapped.
 180   const Handle(Graphic3d_TextureSet)& TextureSet() const { return myTextureSet; }
 181
 182   //! Setup texture array to be mapped.
 183   void SetTextureSet (const Handle(Graphic3d_TextureSet)& theTextures) { myTextureSet = theTextures; }
 184
 185   //! Return texture to be mapped.
 186   //Standard_DEPRECATED("Deprecated method, TextureSet() should be used instead")
 187   Handle(Graphic3d_TextureMap) TextureMap() const
 188   {
 189     return !myTextureSet.IsNull() && !myTextureSet->IsEmpty()
 190           ? myTextureSet->First()
 191           : Handle(Graphic3d_TextureMap)();
 192   }
 193
 194   //! Assign texture to be mapped.
 195   //! See also SetTextureMapOn() to actually activate texture mapping.
 196   //Standard_DEPRECATED("Deprecated method, SetTextureSet() should be used instead")
 197   Standard_EXPORT void SetTextureMap (const Handle(Graphic3d_TextureMap)& theTexture);
 198
 199   //! Return true if texture mapping is enabled (false by default).
 200   bool ToMapTexture() const { return myToMapTexture; }
 201
 202   //! Return true if texture mapping is enabled (false by default).
 203   bool TextureMapState() const { return myToMapTexture; }
 204
 205   //! Enable or disable texture mapping (has no effect if texture is not set).
 206   void SetTextureMapOn (bool theToMap) { myToMapTexture = theToMap; }
 207
 208   //! Enable texture mapping (has no effect if texture is not set).
 209   void SetTextureMapOn() { myToMapTexture = true; }
 210
 211   //! Disable texture mapping.
 212   void SetTextureMapOff() { myToMapTexture = false; }
 213
 214   //! Returns current polygon offsets settings.
 215   const Graphic3d_PolygonOffset& PolygonOffset() const { return myPolygonOffset; }
 216
 217   //! Sets polygon offsets settings.
 218   void SetPolygonOffset (const Graphic3d_PolygonOffset& theOffset) { myPolygonOffset = theOffset; }
 219
 220   //! Returns current polygon offsets settings.
 221   void PolygonOffsets (Standard_Integer&   theMode,
 222                        Standard_ShortReal& theFactor,
 223                        Standard_ShortReal& theUnits) const
 224   {
 225     theMode   = myPolygonOffset.Mode;
 226     theFactor = myPolygonOffset.Factor;
 227     theUnits  = myPolygonOffset.Units;
 228   }
 229
 230   //! Sets up OpenGL polygon offsets mechanism.
 231   //! <aMode> parameter can contain various combinations of
 232   //! Aspect_PolygonOffsetMode enumeration elements (Aspect_POM_None means
 233   //! that polygon offsets are not changed).
 234   //! If <aMode> is different from Aspect_POM_Off and Aspect_POM_None, then <aFactor> and <aUnits>
 235   //! arguments are used by graphic renderer to calculate a depth offset value:
 236   //!
 237   //! offset = <aFactor> * m + <aUnits> * r, where
 238   //! m - maximum depth slope for the polygon currently being displayed,
 239   //! r - minimum window coordinates depth resolution (implementation-specific)
 240   //!
 241   //! Default settings for OCC 3D viewer: mode = Aspect_POM_Fill, factor = 1., units = 0.
 242   //!
 243   //! Negative offset values move polygons closer to the viewport,
 244   //! while positive values shift polygons away.
 245   //! Consult OpenGL reference for details (glPolygonOffset function description).
 246   void SetPolygonOffsets (const Standard_Integer   theMode,
 247                           const Standard_ShortReal theFactor = 1.0f,
 248                           const Standard_ShortReal theUnits  = 0.0f)
 249   {
 250     myPolygonOffset.Mode   = (Aspect_PolygonOffsetMode )(theMode & Aspect_POM_Mask);
 251     myPolygonOffset.Factor = theFactor;
 252     myPolygonOffset.Units  = theUnits;
 253   }
 254
 255 public:
 256
 257   //! Returns true if edges should be drawn (false by default).
 258   bool ToDrawEdges() const { return myToDrawEdges && myEdgeType != Aspect_TOL_EMPTY; }
 259
 260   //! Set if edges should be drawn or not.
 261   void SetDrawEdges (bool theToDraw)
 262   {
 263     myToDrawEdges = theToDraw;
 264     if (myEdgeType == Aspect_TOL_EMPTY)
 265     {
 266       myEdgeType = Aspect_TOL_SOLID;
 267     }
 268   }
 269
 270   //! Returns true if edges should be drawn.
 271   bool Edge() const { return ToDrawEdges(); }
 272
 273   //! The edges of FillAreas are drawn.
 274   void SetEdgeOn() { SetDrawEdges (true); }
 275
 276   //! The edges of FillAreas are not drawn.
 277   void SetEdgeOff() { SetDrawEdges (false); }
 278
 279   //! Return color of edges.
 280   const Quantity_Color& EdgeColor() const { return myEdgeColor.GetRGB(); }
 281
 282   //! Return color of edges.
 283   const Quantity_ColorRGBA& EdgeColorRGBA() const { return myEdgeColor; }
 284
 285   //! Modifies the color of the edge of the face
 286   void SetEdgeColor (const Quantity_Color& theColor) { myEdgeColor.SetRGB (theColor); }
 287
 288   //! Modifies the color of the edge of the face
 289   void SetEdgeColor (const Quantity_ColorRGBA& theColor) { myEdgeColor = theColor; }
 290
 291   //! Return edges line type.
 292   Aspect_TypeOfLine EdgeLineType() const { return myEdgeType; }
 293
 294   //! Modifies the edge line type
 295   void SetEdgeLineType (const Aspect_TypeOfLine theType) { myEdgeType = theType; }
 296
 297   //! Return width for edges in pixels.
 298   Standard_ShortReal EdgeWidth() const { return myEdgeWidth; }
 299
 300   //! Modifies the edge thickness
 301   //! Warning: Raises AspectFillAreaDefinitionError if the width is a negative value.
 302   void SetEdgeWidth (const Standard_Real theWidth)
 303   {
 304     if (theWidth <= 0.0)
 305     {
 306       throw Aspect_AspectFillAreaDefinitionError("Bad value for EdgeLineWidth");
 307     }
 308     myEdgeWidth = (float )theWidth;
 309   }
 310
 311   //! Returns TRUE if drawing element edges should discard first edge in triangle; FALSE by default.
 312   //! Graphics hardware works mostly with triangles, so that wireframe presentation will draw triangle edges by default.
 313   //! This flag allows rendering wireframe presentation of quad-only array split into triangles.
 314   //! For this, quads should be split in specific order, so that the quad diagonal (to be NOT rendered) goes first:
 315   //!     1------2
 316   //!    /      /   Triangle #1: 2-0-1; Triangle #2: 0-2-3
 317   //!   0------3
 318   bool ToSkipFirstEdge() const { return myToSkipFirstEdge; }
 319
 320   //! Set skip first triangle edge flag for drawing wireframe presentation of quads array split into triangles.
 321   void SetSkipFirstEdge (bool theToSkipFirstEdge) { myToSkipFirstEdge = theToSkipFirstEdge; }
 322
 323 public:
 324
 325   //! Returns the hatch type used when InteriorStyle is IS_HATCH
 326   const Handle(Graphic3d_HatchStyle)& HatchStyle() const { return myHatchStyle; }
 327
 328   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
 329   void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle) { myHatchStyle = theStyle; }
 330
 331   //! Modifies the hatch type used when InteriorStyle is IS_HATCH
 332   //! @warning This method always creates a new handle for a given hatch style
 333   void SetHatchStyle (const Aspect_HatchStyle theStyle)
 334   {
 335     if (theStyle == Aspect_HS_SOLID)
 336     {
 337       myHatchStyle.Nullify();
 338       return;
 339     }
 340
 341     myHatchStyle = new Graphic3d_HatchStyle (theStyle);
 342   }
 343
 344   //! Returns the current values.
 345   Standard_DEPRECATED("Deprecated method Values() should be replaced by individual property getters")
 346   void Values (Aspect_InteriorStyle& theStyle,
 347                Quantity_Color&       theIntColor,
 348                Quantity_Color&       theEdgeColor,
 349                Aspect_TypeOfLine&    theType,
 350                Standard_Real&        theWidth) const
 351   {
 352     theStyle    = myInteriorStyle;
 353     theIntColor = myInteriorColor.GetRGB();
 354     theEdgeColor= myEdgeColor.GetRGB();
 355     theType     = myEdgeType;
 356     theWidth    = myEdgeWidth;
 357   }
 358
 359   //! Returns the current values.
 360   Standard_DEPRECATED("Deprecated method Values() should be replaced by individual property getters")
 361   void Values (Aspect_InteriorStyle& theStyle,
 362                Quantity_Color&       theIntColor,
 363                Quantity_Color&       theBackIntColor,
 364                Quantity_Color&       theEdgeColor,
 365                Aspect_TypeOfLine&    theType,
 366                Standard_Real&        theWidth) const
 367   {
 368     theStyle       = myInteriorStyle;
 369     theIntColor    = myInteriorColor.GetRGB();
 370     theBackIntColor= myBackInteriorColor.GetRGB();
 371     theEdgeColor   = myEdgeColor.GetRGB();
 372     theType        = myEdgeType;
 373     theWidth       = myEdgeWidth;
 374   }
 375
 376 protected:
 377
 378   Handle(Graphic3d_ShaderProgram) myProgram;
 379   Handle(Graphic3d_TextureSet)    myTextureSet;
 380   Graphic3d_MaterialAspect        myFrontMaterial;
 381   Graphic3d_MaterialAspect        myBackMaterial;
 382
 383   Quantity_ColorRGBA           myInteriorColor;
 384   Quantity_ColorRGBA           myBackInteriorColor;
 385   Quantity_ColorRGBA           myEdgeColor;
 386   Aspect_InteriorStyle         myInteriorStyle;
 387   Graphic3d_TypeOfShadingModel myShadingModel;
 388   Graphic3d_AlphaMode          myAlphaMode;
 389   Standard_ShortReal           myAlphaCutoff;
 390   Aspect_TypeOfLine            myEdgeType;
 391   Standard_ShortReal           myEdgeWidth;
 392   Handle(Graphic3d_HatchStyle) myHatchStyle;
 393
 394   Graphic3d_PolygonOffset myPolygonOffset;
 395   bool                    myToSkipFirstEdge;
 396   bool                    myToDistinguishMaterials;
 397   bool                    myToDrawEdges;
 398   bool                    myToSuppressBackFaces;
 399   bool                    myToMapTexture;
 400
 401 };
 402
 403 DEFINE_STANDARD_HANDLE(Graphic3d_AspectFillArea3d, Standard_Transient)
 404
 405 #endif // _Graphic3d_AspectFillArea3d_HeaderFile