0030748: Visualization - Marker displayed in immediate layer ruins QT Quick view...

[occt.git] / src / OpenGl / OpenGl_LineAttributes.hxx

diff --git a/src/OpenGl/OpenGl_LineAttributes.hxx b/src/OpenGl/OpenGl_LineAttributes.hxx
index df26892..0b579cf 100644 (file)
--- a/src/OpenGl/OpenGl_LineAttributes.hxx
+++ b/src/OpenGl/OpenGl_LineAttributes.hxx
@@ -21,33 +21,71 @@
 #include <Aspect_TypeOfLine.hxx>
 #include <Aspect_TypeOfMarker.hxx>
 #include <Font_FontAspect.hxx>
+#include <Graphic3d_HatchStyle.hxx>
+#include <NCollection_DataMap.hxx>
+
+typedef NCollection_DataMap<Handle(Graphic3d_HatchStyle), unsigned int> OpenGl_MapOfHatchStylesAndIds;
 
 class OpenGl_Context;
-class Handle(OpenGl_Context);
 
+//! Utility class to manage OpenGL state of polygon hatching rasterization
+//! and keeping its cached state. The hatching rasterization is implemented
+//! using glPolygonStipple function of OpenGL. State of hatching is controlled
+//! by two parameters - type of hatching and IsEnabled parameter.
+//! The hatching rasterization is enabled only if non-zero index pattern type
+//! is selected (zero by default is reserved for solid filling) and if
+//! IsEnabled flag is set to true. The IsEnabled parameter is useful for temporarily
+//! turning on/off the hatching rasterization without making any costly GL calls
+//! for changing the hatch pattern. This is a sharable resource class - it creates
+//! OpenGL context objects for each hatch pattern to achieve quicker switching between
+//! them, thesse GL objects are freed when the resource is released by owner context.
+//! @note The implementation is not supported by Core Profile and by ES version.
 class OpenGl_LineAttributes : public OpenGl_Resource
 {
 public:
 
+  //! Default constructor.
+  //! By default the parameters are:
+  //! - IsEnabled (true),
+  //! - TypeOfHatch (0).
   OpenGl_LineAttributes();
+
+  //! Default destructor.
   virtual ~OpenGl_LineAttributes();
 
-  void Init (const Handle(OpenGl_Context)& theGlCtx);
-  virtual void Release (OpenGl_Context* theGlCtx);
+  //! Release GL resources.
+  virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE;
+
+  //! Returns estimated GPU memory usage - not implemented.
+  virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
+
+  //! Index of currently selected type of hatch.
+  int TypeOfHatch() const { return myTypeOfHatch; }
+
+  //! Sets type of the hatch.
+  int SetTypeOfHatch (const OpenGl_Context*               theGlCtx,
+                      const Handle(Graphic3d_HatchStyle)& theStyle);
 
-  void SetTypeOfLine (const Aspect_TypeOfLine theType) const;
+  //! Current enabled state of the hatching rasterization.
+  bool IsEnabled() const { return myIsEnabled; }
 
-  void SetTypeOfHatch (const int theType) const;
+  //! Turns on/off the hatching rasterization rasterization.
+  bool SetEnabled (const OpenGl_Context* theGlCtx, const bool theToEnable);
 
 protected:
 
-  unsigned int myLinestyleBase;
-  unsigned int myPatternBase;
+  unsigned int init (const OpenGl_Context* theGlCtx,
+                     const Handle(Graphic3d_HatchStyle)& theStyle);
 
-public:
+protected:
 
-  DEFINE_STANDARD_RTTI(OpenGl_LineAttributes)
+  int myTypeOfHatch; //!< Currently activated type of hatch
+  bool myIsEnabled; //!< Current enabled state of hatching rasterization.
+  OpenGl_MapOfHatchStylesAndIds myStyles; //!< Hatch patterns
+
+public:
 
+  DEFINE_STANDARD_RTTIEXT(OpenGl_LineAttributes,OpenGl_Resource)
 };
 
 DEFINE_STANDARD_HANDLE(OpenGl_LineAttributes, OpenGl_Resource)