0030791: Visualization - possibility to display materials by different hatching style for clipping

(cherry picked from commit fafcc26452)

src/AIS/AIS_ColoredShape.cxx

@@ -633,6 +633,9 @@ void AIS_ColoredShape::addShapesWithCustomProps (const Handle(Prs3d_Presentation
           {
             aShadedGroup = thePrs->NewGroup();
             aShadedGroup->SetClosed (isClosed);
+            if (isClosed
+            && !myCappingStyle.IsNull())
+              aShadedGroup->SetGroupPrimitivesAspect (myCappingStyle);
           }
           aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect());
           aShadedGroup->AddPrimitiveArray (aTriangles);

src/AIS/AIS_InteractiveObject.cxx

@@ -18,6 +18,7 @@
 
 #include <AIS_InteractiveContext.hxx>
 #include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 #include <Graphic3d_AspectLine3d.hxx>
 #include <Graphic3d_AspectMarker3d.hxx>
 #include <Graphic3d_AspectText3d.hxx>
@@ -83,6 +84,37 @@ void AIS_InteractiveObject::SetContext (const Handle(AIS_InteractiveContext)& th
   }
 }
 
+//=======================================================================
+//function : SetCappingStyle
+//purpose  : 
+//=======================================================================
+void AIS_InteractiveObject::SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+  myCappingStyle = theStyle;
+
+  // Modify existing presentations 
+  for (Standard_Integer aPrsIter = 1, n = myPresentations.Length(); aPrsIter <= n; ++aPrsIter)
+  {
+    const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter);
+    if (!aPrs3d.IsNull())
+    {
+      const Handle(Graphic3d_Structure)& aStruct = aPrs3d->Presentation();
+      if (!aStruct.IsNull())
+      {
+        const Graphic3d_SequenceOfGroup& aGroups = aStruct->Groups();
+        for (Graphic3d_SequenceOfGroup::Iterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next())
+        {
+          Handle(Graphic3d_Group)& aGrp = aGroupIter.ChangeValue();
+          if (aGrp.IsNull())
+            continue;
+
+          aGrp->SetGroupPrimitivesAspect (theStyle);
+        }
+      }
+    }
+  }
+}
+
 //=======================================================================
 //function : HasPresentation
 //purpose  :

src/AIS/AIS_InteractiveObject.hxx

@@ -104,6 +104,12 @@ public:
   void ClearOwner() { myOwner.Nullify(); }
 
 public:
+  //! Set style of filling capping section created by clipping planes.
+  Standard_EXPORT virtual void SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+  //! Returns style for filling capping section created by clipping planes.
+  const Handle(Graphic3d_AspectFillCapping)& CappingStyle() const { return myCappingStyle; }
+
 
   //! Returns the context pointer to the interactive context.
   Standard_EXPORT Handle(AIS_InteractiveContext) GetContext() const;
@@ -128,6 +134,7 @@ protected:
 
   AIS_InteractiveContext*    myCTXPtr; //!< pointer to Interactive Context, where object is currently displayed; @sa SetContext()
   Handle(Standard_Transient) myOwner;  //!< application-specific owner object
+  Handle(Graphic3d_AspectFillCapping) myCappingStyle;
 
 };
 

src/AIS/AIS_Shape.cxx

@@ -180,10 +180,7 @@ void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentat
           try
           {
             OCC_CATCH_SIGNALS
-            StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer,
-                                     myDrawer->ShadingAspect()->Aspect()->ToMapTexture()
-                                 && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(),
-                                     myUVOrigin, myUVRepeat, myUVScale);
+            StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myCappingStyle);
           }
           catch (Standard_Failure const& anException)
           {

src/Graphic3d/FILES

@@ -15,6 +15,8 @@ Graphic3d_Aspects.cxx
 Graphic3d_Aspects.hxx
 Graphic3d_AspectFillArea3d.cxx
 Graphic3d_AspectFillArea3d.hxx
+Graphic3d_AspectFillCapping.cxx
+Graphic3d_AspectFillCapping.hxx
 Graphic3d_AspectLine3d.cxx
 Graphic3d_AspectLine3d.hxx
 Graphic3d_AspectMarker3d.cxx

src/Graphic3d/Graphic3d_AspectFillCapping.cxx

@@ -0,0 +1,110 @@
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <Graphic3d_AspectFillCapping.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Standard_Transient)
+
+// =======================================================================
+// function : Graphic3d_AspectFillCapping
+// purpose  :
+// =======================================================================
+Graphic3d_AspectFillCapping::Graphic3d_AspectFillCapping()
+: myFlags (Flags_None),
+  myHatchingState (0)
+{
+  Graphic3d_MaterialAspect aMaterial;
+  aMaterial.SetColor             (Quantity_NOC_BLACK);
+  aMaterial.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
+  aMaterial.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
+  aMaterial.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
+  aMaterial.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
+  aMaterial.SetMaterialType      (Graphic3d_MATERIAL_ASPECT);
+  SetHatchStyle    (Aspect_HS_HORIZONTAL);
+  SetHatchMaterial (aMaterial);
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Aspect_HatchStyle theStyle)
+{
+  myStippleHatch = new Graphic3d_HatchStyle (theStyle);
+  myTextureHatch.Nullify();
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle)
+{
+  myStippleHatch = theStyle;
+  myTextureHatch.Nullify();
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture)
+{
+  myStippleHatch.Nullify();
+  myTextureHatch = theTexture;
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchMaterial
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial)
+{
+  myHatchMaterial = theMaterial;
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetToDrawHatch
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetToDrawHatch (const Standard_Boolean theToDraw)
+{
+  setFlag (theToDraw, Flags_DrawHatching);
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchZoomPeristent
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchZoomPeristent (const Standard_Boolean theToSet) 
+{
+  setFlag (theToSet, Flags_HatchZoomPersistent);
+  myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchRotationPeristent
+// purpose  :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchRotationPeristent (const Standard_Boolean theToSet)
+{
+  setFlag (theToSet, Flags_HatchRotationPersistent);
+  myHatchingState++;
+}

src/Graphic3d/Graphic3d_AspectFillCapping.hxx

@@ -0,0 +1,164 @@
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Graphic3d_AspectFillCapping_HeaderFile
+#define _Graphic3d_AspectFillCapping_HeaderFile
+
+#include <Aspect_HatchStyle.hxx>
+#include <Graphic3d_Aspects.hxx>
+#include <Graphic3d_HatchStyle.hxx>
+#include <Graphic3d_MaterialAspect.hxx>
+#include <Graphic3d_ShaderProgram.hxx>
+#include <Graphic3d_TextureMap.hxx>
+#include <Standard_Transient.hxx>
+
+//! Defines graphical attributes for drawing section planes on solids resulted from clipping (cutting) planes.
+class Graphic3d_AspectFillCapping : public Graphic3d_Aspects
+{
+public:
+
+  //! Default constructor.
+  Standard_EXPORT Graphic3d_AspectFillCapping();
+
+public:
+
+  //! Sets material for filling section created by clipping.
+  void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; }
+
+  //! Returns material for filling section created by clipping.
+  const Graphic3d_MaterialAspect& Material() const { return myMaterial; }
+
+  //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+  void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); }
+
+  //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+  Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; }
+
+  //! Sets texture for filling section created by clipping.
+  void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; }
+
+  //! Returns texture for filling section created by clipping.
+  const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; }
+
+  //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+  void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); }
+
+  //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+  Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; }
+
+  //! Sets OpenGL/GLSL shader program.
+  void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; }
+
+  //! Returns OpenGL/GLSL shader program.
+  const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; }
+
+  //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+  void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); }
+
+  //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+  Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; }
+
+public:
+
+  //! Sets style of hatch defined by predefined stipple mask.
+  Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle);
+
+  //! Sets style of hatch defined by custom stipple mask.
+  Standard_EXPORT void SetHatchStyle (const  Handle(Graphic3d_HatchStyle)& theStyle);
+
+  //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used).
+  Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture);
+
+  //! Sets material style for hatch lines (texture).
+  Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial);
+
+  //! Returns material style for hatch lines (texture).
+  const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; }
+
+  //! Sets boolean flag indicating whether the hatch layer should be drawn or not.
+  Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw);
+
+  //! Returns boolean flag indicating whether the hatch layer should be drawn or not.
+  Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; }
+
+  //! Sets flag controlling behavior of hatch texture mapping on zooming.
+  //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming.
+  Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet);
+
+  //! Returns value of flag controlling behavior of hatch texture mapping on zooming.
+  Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; }
+
+  //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+  Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet);
+
+  //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+  Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; }
+
+  //! Returns true if hatch is defined by texture.
+  Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); }
+
+  //! Returns texture map defining the hatch.
+  const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; }
+
+  //! Returns true if hatch is defined by stipple mask.
+  Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); }
+
+  //! Returns the stipple mask.
+  const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; }
+
+  //! Returns modification counter for hatching state.
+  Standard_Size HatchingState() const { return myHatchingState; }
+
+private:
+
+  enum Flags
+  {
+    Flags_None                    = 0x00, //!< no flags
+    Flags_UseObjectMaterial       = 0x01, //!< use object material
+    Flags_UseObjectTexture        = 0x02, //!< use object texture
+    Flags_UseObjectShader         = 0x04, //!< use object GLSL program
+    Flags_HatchZoomPersistent     = 0x08, //!< zoom-persistent texturing
+    Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing
+    Flags_DrawHatching            = 0x20, //!< draw hatching
+    Flags_UseObjectProperties     =       //!< use entire fill area aspect from object
+        Flags_UseObjectMaterial
+      | Flags_UseObjectTexture
+      | Flags_UseObjectShader
+  };
+
+  void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag)
+  {
+    myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag;
+  }
+
+private:
+
+  Graphic3d_MaterialAspect        myMaterial;
+  Handle(Graphic3d_TextureMap)    myTexture;
+  Handle(Graphic3d_ShaderProgram) myShader;
+  Handle(Graphic3d_HatchStyle)    myStippleHatch;
+  Handle(Graphic3d_TextureMap)    myTextureHatch;
+  Graphic3d_MaterialAspect        myHatchMaterial;
+  unsigned int                    myFlags;
+  Standard_Size                   myHatchingState;
+
+public:
+
+  DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+};
+
+DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+
+#endif // _Graphic3d_AspectFillCapping_HeaderFile

src/Graphic3d/Graphic3d_ClipPlane.cxx

@@ -24,19 +24,6 @@ IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient)
 namespace
 {
   static volatile Standard_Integer THE_CLIP_PLANE_COUNTER = 0;
-
-  static Handle(Graphic3d_AspectFillArea3d) defaultAspect()
-  {
-    const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
-    Handle(Graphic3d_AspectFillArea3d) anAspect = new Graphic3d_AspectFillArea3d();
-    anAspect->SetDistinguishOff();
-    anAspect->SetFrontMaterial (aMaterial);
-    anAspect->SetHatchStyle (Aspect_HS_HORIZONTAL);
-    anAspect->SetInteriorStyle (Aspect_IS_SOLID);
-    anAspect->SetInteriorColor (aMaterial.Color());
-    anAspect->SetSuppressBackFaces (false);
-    return anAspect;
-  }
 }
 
 // =======================================================================
@@ -44,19 +31,8 @@ namespace
 // purpose  :
 // =======================================================================
 Graphic3d_ClipPlane::Graphic3d_ClipPlane()
-: myAspect     (defaultAspect()),
-  myPrevInChain(NULL),
-  myPlane      (0.0, 0.0, 1.0, 0.0),
-  myEquation   (0.0, 0.0, 1.0, 0.0),
-  myEquationRev(0.0, 0.0,-1.0, 0.0),
-  myChainLenFwd(1),
-  myFlags      (Graphic3d_CappingFlags_None),
-  myEquationMod(0),
-  myAspectMod  (0),
-  myIsOn       (Standard_True),
-  myIsCapping  (Standard_False)
 {
-  makeId();
+  init();
 }
 
 // =======================================================================
@@ -64,19 +40,8 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane()
 // purpose  :
 // =======================================================================
 Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation)
-: myAspect     (defaultAspect()),
-  myPrevInChain(NULL),
-  myPlane      (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()),
-  myEquation   (theEquation),
-  myEquationRev(0.0, 0.0,-1.0, 0.0),
-  myChainLenFwd(1),
-  myFlags      (Graphic3d_CappingFlags_None),
-  myEquationMod(0),
-  myAspectMod  (0),
-  myIsOn       (Standard_True),
-  myIsCapping  (Standard_False)
 {
-  makeId();
+  init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a()));
   updateInversedPlane();
 }
 
@@ -84,42 +49,27 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation)
 // function : Graphic3d_ClipPlane
 // purpose  :
 // =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther)
-: Standard_Transient(theOther),
-  myAspect     (defaultAspect()),
-  myPrevInChain(NULL),
-  myPlane      (theOther.myPlane),
-  myEquation   (theOther.myEquation),
-  myEquationRev(theOther.myEquationRev),
-  myChainLenFwd(1),
-  myFlags      (theOther.myFlags),
-  myEquationMod(0),
-  myAspectMod  (0),
-  myIsOn       (theOther.myIsOn),
-  myIsCapping  (theOther.myIsCapping)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther)
+: Standard_Transient (theOther)
 {
-  makeId();
-  *myAspect = *theOther.CappingAspect();
+  *mySectionStyle = *theOther.CappingSectionStyle();
+  init (theOther.myPlane,
+        theOther.myEquationRev,
+        theOther.myIsOn,
+        theOther.myIsCapping,
+        theOther.ToOverrideCappingAspect(),
+        theOther.CappingSectionStyle());
+  updateInversedPlane();
 }
 
 // =======================================================================
 // function : Graphic3d_ClipPlane
 // purpose  :
 // =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane)
-: myAspect     (defaultAspect()),
-  myPrevInChain(NULL),
-  myPlane      (thePlane),
-  myChainLenFwd(1),
-  myFlags      (Graphic3d_CappingFlags_None),
-  myEquationMod(0),
-  myAspectMod  (0),
-  myIsOn       (Standard_True),
-  myIsCapping  (Standard_False)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const gp_Pln& thePlane)
 {
-  thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
+  init (thePlane);
   updateInversedPlane();
-  makeId();
 }
 
 // =======================================================================
@@ -131,7 +81,7 @@ void Graphic3d_ClipPlane::SetEquation (const Graphic3d_Vec4d& theEquation)
   myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
   myEquation = theEquation;
   updateInversedPlane();
-  myEquationMod++;
+  myOrientationDirty = Standard_True;
 }
 
 // =======================================================================
@@ -143,7 +93,7 @@ void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane)
   myPlane = thePlane;
   thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
   updateInversedPlane();
-  myEquationMod++;
+  myOrientationDirty = Standard_True;
 }
 
 // =======================================================================
@@ -178,119 +128,106 @@ Handle(Graphic3d_ClipPlane) Graphic3d_ClipPlane::Clone() const
 }
 
 // =======================================================================
-// function : SetCappingMaterial
+// function : SetCappingSectionStyle
 // purpose  :
 // =======================================================================
-void Graphic3d_ClipPlane::SetCappingMaterial (const Graphic3d_MaterialAspect& theMat)
+void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
 {
-  myAspect->SetFrontMaterial (theMat);
-  myAspect->SetInteriorColor (theMat.Color());
-  ++myAspectMod;
+  mySectionStyle = theStyle;
 }
 
 // =======================================================================
-// function : SetCappingTexture
+// function : OrientationMatrix
 // purpose  :
 // =======================================================================
-void Graphic3d_ClipPlane::SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture)
+const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const
 {
-  if (!theTexture.IsNull())
+  if (myOrientationDirty)
   {
-    myAspect->SetTextureMapOn();
-    Handle(Graphic3d_TextureSet) aTextureSet = myAspect->TextureSet();
-    if (aTextureSet.IsNull() || aTextureSet->Size() != 1)
+    const Standard_ShortReal aDirection[] = {
+      static_cast<Standard_ShortReal> (myEquation[0]),
+      static_cast<Standard_ShortReal> (myEquation[1]),
+      static_cast<Standard_ShortReal> (myEquation[2])
+     };
+
+    const Standard_ShortReal aTranslate[] = {
+      static_cast<Standard_ShortReal> (myEquation[0] * -myEquation[3]),
+      static_cast<Standard_ShortReal> (myEquation[1] * -myEquation[3]),
+      static_cast<Standard_ShortReal> (myEquation[2] * -myEquation[3])
+    };
+
+    Standard_ShortReal aSide1[] = { 0.0f, 0.0f, 0.0f };
+    Standard_ShortReal aSide2[] = { 0.0f, 0.0f, 0.0f };
+
+    const Standard_ShortReal aMagintude = static_cast<Standard_ShortReal> (Sqrt (myEquation[0] * myEquation[0] + myEquation[2] * myEquation[2]));
+
+    if (aMagintude < ShortRealSmall())
     {
-      aTextureSet = new Graphic3d_TextureSet (theTexture);
+      aSide1[0] = 1.0f;
     }
     else
     {
-      aTextureSet->SetFirst (theTexture);
+      aSide1[0] =  aDirection[2] / aMagintude;
+      aSide1[2] = -aDirection[0] / aMagintude;
     }
-    myAspect->SetTextureSet (aTextureSet);
+
+    aSide2[0] = (-aSide1[1] * aDirection[2]) - (-aSide1[2] * aDirection[1]);
+    aSide2[1] = (-aSide1[2] * aDirection[0]) - (-aSide1[0] * aDirection[2]);
+    aSide2[2] = (-aSide1[0] * aDirection[1]) - (-aSide1[1] * aDirection[0]);
+
+    myOrientationMat.SetValue (0, 0, aSide1[0]);
+    myOrientationMat.SetValue (1, 0, aSide1[1]);
+    myOrientationMat.SetValue (2, 0, aSide1[2]);
+    myOrientationMat.SetValue (3, 0, 0.0F);
+
+    myOrientationMat.SetValue (0, 1, aDirection[0]);
+    myOrientationMat.SetValue (1, 1, aDirection[1]);
+    myOrientationMat.SetValue (2, 1, aDirection[2]);
+    myOrientationMat.SetValue (3, 1, 0.0F);
+
+    myOrientationMat.SetValue (0, 2, aSide2[0]);
+    myOrientationMat.SetValue (1, 2, aSide2[1]);
+    myOrientationMat.SetValue (2, 2, aSide2[2]);
+    myOrientationMat.SetValue (3, 2, 0.0F);
+
+    myOrientationMat.SetValue (0, 3, aTranslate[0]);
+    myOrientationMat.SetValue (1, 3, aTranslate[1]);
+    myOrientationMat.SetValue (2, 3, aTranslate[2]);
+    myOrientationMat.SetValue (3, 3, 1.0F);
+
+    myOrientationDirty = Standard_False;
   }
-  else
+
+  return myOrientationMat;
+}
+
+// =======================================================================
+// function : init
+// purpose  :
+// =======================================================================
+void Graphic3d_ClipPlane::init (const gp_Pln& thePlane,
+                                const Graphic3d_Vec4d& theEquationRev,
+                                const Standard_Boolean theIsOn,
+                                const Standard_Boolean theIsCapping,
+                                const Standard_Boolean theOverrideStyle,
+                                const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+  if (myEntityUID.IsEmpty())
   {
-    myAspect->SetTextureMapOff();
-    myAspect->SetTextureSet (Handle(Graphic3d_TextureSet)());
+    myEntityUID = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name()
+                + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
   }
-  ++myAspectMod;
-}
 
-// =======================================================================
-// function : SetCappingHatch
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatch (const Aspect_HatchStyle theStyle)
-{
-  myAspect->SetHatchStyle (theStyle);
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : SetCappingCustomHatch
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle)
-{
-  myAspect->SetHatchStyle (theStyle);
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : SetCappingHatchOn
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatchOn()
-{
-  myAspect->SetInteriorStyle (Aspect_IS_HATCH);
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : SetCappingHatchOff
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatchOff()
-{
-  myAspect->SetInteriorStyle (Aspect_IS_SOLID);
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : SetCappingAspect
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
-{
-  myAspect = theAspect;
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : setCappingFlag
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::setCappingFlag (bool theToUse, int theFlag)
-{
-  if (theToUse)
-  {
-    myFlags |= theFlag;
-  }
-  else
-  {
-    myFlags &= ~(theFlag);
-  }
-  ++myAspectMod;
-}
-
-// =======================================================================
-// function : makeId
-// purpose  :
-// =======================================================================
-void Graphic3d_ClipPlane::makeId()
-{
-  myId = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name()
-       + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
+  myPrevInChain         = NULL;
+  myEquationRev         = theEquationRev;
+  myChainLenFwd         = 1;
+  myPlane               = thePlane;
+  myPlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
+  myIsOn                = theIsOn;
+  myIsCapping           = theIsCapping;
+  myOverrideObjectStyle = theOverrideStyle;
+  mySectionStyle        = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle;
+  myOrientationDirty    = Standard_True;
 }
 
 // =======================================================================
@@ -312,7 +249,7 @@ void Graphic3d_ClipPlane::updateChainLen()
 // =======================================================================
 void Graphic3d_ClipPlane::SetChainNextPlane (const Handle(Graphic3d_ClipPlane)& thePlane)
 {
-  ++myEquationMod;
+  myOrientationDirty = Standard_True;
   if (!myNextInChain.IsNull())
   {
     myNextInChain->myPrevInChain = NULL;

src/Graphic3d/Graphic3d_ClipPlane.hxx

@@ -19,9 +19,12 @@
 #include <Aspect_HatchStyle.hxx>
 #include <gp_Pln.hxx>
 #include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 #include <Graphic3d_BndBox3d.hxx>
 #include <Graphic3d_CappingFlags.hxx>
+#include <Graphic3d_Mat4.hxx>
 #include <Graphic3d_TextureMap.hxx>
+#include <NCollection_Handle.hxx>
 #include <NCollection_Vec4.hxx>
 #include <Standard_Macro.hxx>
 #include <Standard_TypeDef.hxx>
@@ -166,44 +169,6 @@ public:
 
 public: // @name user-defined graphical attributes
 
-  //! Set material for rendering capping surface.
-  //! @param theMat [in] the material.
-  Standard_EXPORT void SetCappingMaterial (const Graphic3d_MaterialAspect& theMat);
-
-  //! @return capping material.
-  const Graphic3d_MaterialAspect& CappingMaterial() const { return myAspect->FrontMaterial(); }
-
-  //! Set texture to be applied on capping surface.
-  //! @param theTexture [in] the texture.
-  Standard_EXPORT void SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture);
-
-  //! @return capping texture map.
-  Handle(Graphic3d_TextureMap) CappingTexture() const { return !myAspect->TextureSet().IsNull() && !myAspect->TextureSet()->IsEmpty()
-                                                              ? myAspect->TextureSet()->First()
-                                                              : Handle(Graphic3d_TextureMap)(); }
-
-  //! Set hatch style (stipple) and turn hatching on.
-  //! @param theStyle [in] the hatch style.
-  Standard_EXPORT void SetCappingHatch (const Aspect_HatchStyle theStyle);
-
-  //! @return hatching style.
-  Aspect_HatchStyle CappingHatch() const { return (Aspect_HatchStyle)myAspect->HatchStyle()->HatchType(); }
-
-  //! Set custom hatch style (stipple) and turn hatching on.
-  //! @param theStyle [in] the hatch pattern.
-  Standard_EXPORT void SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle);
-
-  //! @return hatching style.
-  const Handle(Graphic3d_HatchStyle)& CappingCustomHatch() const { return myAspect->HatchStyle(); }
-
-  //! Turn on hatching.
-  Standard_EXPORT void SetCappingHatchOn();
-
-  //! Turn off hatching.
-  Standard_EXPORT void SetCappingHatchOff();
-
-  //! @return True if hatching mask is turned on.
-  Standard_Boolean IsHatchOn() const { return myAspect->InteriorStyle() == Aspect_IS_HATCH; }
 
   //! This ID is used for managing associated resources in graphical driver.
   //! The clip plane can be assigned within a range of IO which can be
@@ -214,41 +179,18 @@ public: // @name user-defined graphical attributes
   //! @return clip plane resource identifier string.
   const TCollection_AsciiString& GetId() const
   {
-    return myId;
+    return myEntityUID;
   }
 
 public:
 
-  //! Return capping aspect.
+  //! Returns style used for drawing capping section.
   //! @return capping surface rendering aspect.
-  const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; }
+  const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; }
 
-  //! Assign capping aspect.
-  Standard_EXPORT void SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect);
+  //! Sets clipping section filling aspect.
+  Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
 
-  //! Flag indicating whether material for capping plane should be taken from object.
-  //! Default value: FALSE (use dedicated capping plane material).
-  bool ToUseObjectMaterial() const { return (myFlags & Graphic3d_CappingFlags_ObjectMaterial) != 0; }
-
-  //! Set flag for controlling the source of capping plane material.
-  void SetUseObjectMaterial (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectMaterial); }
-
-  //! Flag indicating whether texture for capping plane should be taken from object.
-  //! Default value: FALSE.
-  bool ToUseObjectTexture() const { return (myFlags & Graphic3d_CappingFlags_ObjectTexture) != 0; }
-
-  //! Set flag for controlling the source of capping plane texture.
-  void SetUseObjectTexture (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectTexture); }
-
-  //! Flag indicating whether shader program for capping plane should be taken from object.
-  //! Default value: FALSE.
-  bool ToUseObjectShader() const { return (myFlags & Graphic3d_CappingFlags_ObjectShader) != 0; }
-
-  //! Set flag for controlling the source of capping plane shader program.
-  void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); }
-
-  //! Return true if some fill area aspect properties should be taken from object.
-  bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; }
 
 public:
 
@@ -352,14 +294,25 @@ public: // @name modification counters
   {
     return myAspectMod;
   }
+  //! Flag indicating whether section style of the plane should overrides similar property of object presentation.
+  //! Default value: FALSE (use dedicated presentation aspect style).
+  bool ToOverrideCappingAspect() const { return myOverrideObjectStyle; }
+
+  //! Sets flag for controlling the preference of using section style between clip plane and object.
+  void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; }
+
+  //! Returns plane's orientation matrix.
+  Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const;
 
 private:
 
-  //! Generate unique object id for OpenGL graphic resource manager.
-  void makeId();
-
-  //! Set capping flag.
-  Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag);
+  //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities.
+  void init (const gp_Pln& thePlane = gp_Pln(),
+             const Graphic3d_Vec4d& theEquationRev = Graphic3d_Vec4d(0.0, 0.0,-1.0, 0.0),
+             const Standard_Boolean theIsOn = Standard_True,
+             const Standard_Boolean theIsCapping = Standard_False,
+             const Standard_Boolean theOverrideStyle = Standard_False,
+             const Handle(Graphic3d_AspectFillCapping)& theStyle = Handle(Graphic3d_AspectFillCapping)());
 
   //! Update chain length in backward direction.
   void updateChainLen();
@@ -374,10 +327,10 @@ private:
 
 private:
 
-  Handle(Graphic3d_AspectFillArea3d) myAspect;    //!< fill area aspect
+  Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section.
   Handle(Graphic3d_ClipPlane)   myNextInChain;    //!< next     plane in a chain of planes defining logical AND operation
   Graphic3d_ClipPlane*          myPrevInChain;    //!< previous plane in a chain of planes defining logical AND operation
-  TCollection_AsciiString myId;                   //!< resource id
+  TCollection_AsciiString myEntityUID;            //!< Unique identifier for the plane
   gp_Pln                  myPlane;                //!< plane definition
   Graphic3d_Vec4d         myEquation;             //!< plane equation vector
   Graphic3d_Vec4d         myEquationRev;          //!< reversed plane equation
@@ -387,6 +340,9 @@ private:
   unsigned int            myAspectMod;            //!< modification counter of aspect
   Standard_Boolean        myIsOn;                 //!< state of the clipping plane
   Standard_Boolean        myIsCapping;            //!< state of graphic driver capping
+  Standard_Boolean        myOverrideObjectStyle;  //!< Flag forcing to use plane's section style rather than section style defined for object
+  mutable Standard_Boolean myOrientationDirty;     //!< Boolean flag indicating whether orientation matrix is dirty or not.
+  mutable Graphic3d_Mat4  myOrientationMat;       //!< Plane orientation matrix (for visualization purposes).
 
 };
 

src/Graphic3d/Graphic3d_Group.hxx

@@ -37,6 +37,7 @@
 
 class Graphic3d_Structure;
 class Graphic3d_ArrayOfPrimitives;
+class Graphic3d_AspectFillCapping;
 
 //! This class allows the definition of groups
 //! of primitives inside of graphic objects (presentations).
@@ -104,6 +105,9 @@ public:
   //! Modifies the current context of the group to give another aspect for all the primitives created after this call in the group.
   virtual void SetPrimitivesAspect (const Handle(Graphic3d_Aspects)& theAspect) = 0;
 
+  //! Returns style of filling clipping sections on closed shell primitives.
+  virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const = 0;
+
   //! Update presentation aspects after their modification.
   virtual void SynchronizeAspects() = 0;
 

src/Graphic3d/Graphic3d_GroupAspect.hxx

@@ -21,13 +21,15 @@
 //! - ASPECT_LINE: aspect for line primitives;
 //! - ASPECT_TEXT: aspect for text primitives;
 //! - ASPECT_MARKER: aspect for marker primitives;
-//! - ASPECT_FILL_AREA: aspect for face primitives.
+//! - ASPECT_FILL_AREA: aspect for face primitives;
+//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections.
 enum Graphic3d_GroupAspect
 {
 Graphic3d_ASPECT_LINE,
 Graphic3d_ASPECT_TEXT,
 Graphic3d_ASPECT_MARKER,
-Graphic3d_ASPECT_FILL_AREA
+Graphic3d_ASPECT_FILL_AREA,
+Graphic3d_ASPECT_FILL_CAPPING
 };
 
 #endif // _Graphic3d_GroupAspect_HeaderFile

src/OpenGl/OpenGl_CappingAlgo.cxx

@@ -21,11 +21,16 @@
 #include <OpenGl_PrimitiveArray.hxx>
 #include <OpenGl_CappingPlaneResource.hxx>
 #include <OpenGl_Vec.hxx>
+#include <OpenGl_View.hxx>
 #include <OpenGl_Structure.hxx>
 #include <OpenGl_ShaderManager.hxx>
 
 namespace
 {
+  static const OpenGl_CappingPlaneResource THE_DEFAULT_ASPECT = OpenGl_CappingPlaneResource (new Graphic3d_AspectFillCapping);
+  static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingAlgo_Quad";
+  static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingAlgo_CappingStyle_";
+
   //! Auxiliary sentry object managing stencil test.
   struct StencilTestSentry
   {
@@ -58,21 +63,113 @@ namespace
     GLint myDepthFuncPrev;
   };
 
-  //! Render infinite capping plane.
-  //! @param theWorkspace [in] the GL workspace, context state.
-  //! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
-  static void renderPlane (const Handle(OpenGl_Workspace)& theWorkspace,
-                           const Handle(OpenGl_CappingPlaneResource)& thePlane)
+  class OpenGl_SharedElement : public OpenGl_Resource
+  {
+    public:
+      OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {}
+      virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE
+      {
+        OpenGl_Element::Destroy (theGlCtx, myGlElement);
+      }
+      OpenGl_Element* GlElement() const { return myGlElement; }
+
+      //! Returns estimated GPU memory usage for holding data without considering overheads and allocation alignment rules.
+      Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
+
+    private:
+      OpenGl_Element* myGlElement;
+
+    public:
+
+      DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource)
+  };
+
+  //! Iitializes and returns vertex buffer for plane section
+  OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext)
+  {
+    Handle(OpenGl_SharedElement) aSharedResource;
+
+    if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource))
+    {
+      aSharedResource = new OpenGl_SharedElement (OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices());
+      theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource);
+    }
+
+    return dynamic_cast<OpenGl_PrimitiveArray*> (aSharedResource->GlElement());
+  }
+
+  //! Render section plane using the given aspects.
+  void renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
+                      const OpenGl_PrimitiveArray*    theQuad,
+                      const OpenGl_Aspects*           theCappingAspect,
+                      const OpenGl_Aspects*           theHatchAspect,
+                      const OpenGl_Mat4&              theCappingMatrix,
+                      const Standard_ShortReal        theHatchScale,
+                      const Standard_ShortReal        theHatchRotate)
   {
     const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
     const bool wasCullAllowed = theWorkspace->SetAllowFaceCulling (true);
 
-    // set identity model matrix
+    const Standard_Boolean isTextureHatch =
+        theHatchAspect != NULL
+    &&  theHatchAspect->Aspect()->TextureMapState();
+
     aContext->ModelWorldState.Push();
-    aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat));
+    aContext->ModelWorldState.SetCurrent (theCappingMatrix);
     aContext->ApplyModelViewMatrix();
 
-    thePlane->Primitives().Render (theWorkspace);
+    theWorkspace->SetAspects (theCappingAspect);
+    theWorkspace->ApplyAspects();
+
+    theQuad->Render (theWorkspace);
+
+    if (theHatchAspect != NULL)
+    {
+      Graphic3d_Vec2     aPrevScale;
+      Standard_ShortReal aPrevRotate = 0.0;
+
+      if (isTextureHatch)
+      {
+        glEnable (GL_BLEND);
+        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        if ((theHatchScale != 1.0 || theHatchRotate != 0.0) && !theHatchAspect->TextureSet(aContext)->IsEmpty())
+        {
+          Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+          const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+          aPrevScale  = aTexParams->Scale();
+          aPrevRotate = aTexParams->Rotation();
+
+          const Standard_Boolean   isMirror = aPrevScale.x() * aPrevScale.y() < 0.0;
+          aTexParams->SetScale    (aPrevScale * theHatchScale);
+          aTexParams->SetRotation (isMirror ? aPrevRotate - theHatchRotate : aPrevRotate + theHatchRotate);
+        }
+      }
+
+      theWorkspace->SetAspects (theHatchAspect);
+      theWorkspace->ApplyAspects();
+
+      glDepthFunc (GL_LEQUAL);
+
+      theQuad->Render (theWorkspace);
+
+      glDepthFunc (GL_LESS);
+
+      if (isTextureHatch)
+      {
+        glDisable (GL_BLEND);
+
+        if (theHatchScale != 1.0 || theHatchRotate != 0.0)
+        {
+          Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+          const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+          aTexParams->SetScale (aPrevScale);
+          aTexParams->SetRotation (aPrevRotate);
+        }
+      }
+    }
 
     aContext->ModelWorldState.Pop();
     aContext->ApplyModelViewMatrix();
@@ -86,13 +183,23 @@ namespace
                                          const OpenGl_Structure&         theStructure,
                                          const Handle(Graphic3d_ClipPlane)& theClipChain,
                                          const Standard_Integer          theSubPlaneIndex,
-                                         const Handle(OpenGl_CappingPlaneResource)& thePlane)
+                                         const Handle(OpenGl_CappingPlaneResource)& thePlane,
+                                         const OpenGl_PrimitiveArray*    theQuad)
   {
     const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
     const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly);
 
+    const Handle(Graphic3d_ClipPlane)& aPlane = theClipChain;
+
     const Handle(OpenGl_Context)&      aContext     = theWorkspace->GetGlContext();
-    const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane();
+    const Handle(Graphic3d_Camera) aCamera    = theWorkspace->View() != NULL
+                                              ? theWorkspace->View()->Camera()
+                                              : Handle(Graphic3d_Camera)();
+    const OpenGl_Mat4& aPlaneMat    = OpenGl_Mat4::Map (aPlane->OrientationMatrix());
+    Standard_ShortReal aRotateAngle = 0.0;
+    Standard_ShortReal aViewScale   = ShortRealLast();
+    OpenGl_Mat4        aRotateZoomMat;
+
     for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next())
     {
       if (!aGroupIter.Value()->IsClosed())
@@ -103,16 +210,6 @@ namespace
       // clear stencil only if something has been actually drawn
       theStencilSentry.Init();
 
-      // check if capping plane should be rendered within current pass (only opaque / only transparent)
-      const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
-      thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)());
-      theWorkspace->SetAspects (thePlane->AspectFace());
-      theWorkspace->SetRenderFilter (aPrevFilter);
-      if (!theWorkspace->ShouldRender (&thePlane->Primitives()))
-      {
-        continue;
-      }
-
       // suppress only opaque/transparent filter since for filling stencil the whole geometry should be drawn
       theWorkspace->SetRenderFilter (anAnyFilter);
 
@@ -121,7 +218,7 @@ namespace
       aContext->ShaderManager()->UpdateClippingState();
 
       glClear (GL_STENCIL_BUFFER_BIT);
-      const bool aColorMaskBack = aContext->SetColorMask (false);
+      glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
       // override aspects, disable culling
       theWorkspace->SetAspects (&theWorkspace->NoneCulling());
@@ -140,20 +237,7 @@ namespace
       glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
 
       // render closed primitives
-      if (aRenderPlane->ToUseObjectProperties())
-      {
-        aGroupIter.Value()->Render (theWorkspace);
-      }
-      else
-      {
-        for (; aGroupIter.More(); aGroupIter.Next())
-        {
-          if (aGroupIter.Value()->IsClosed())
-          {
-            aGroupIter.Value()->Render (theWorkspace);
-          }
-        }
-      }
+      aGroupIter.Value()->Render (theWorkspace);
 
       // override material, cull back faces
       theWorkspace->SetAspects (&theWorkspace->FrontCulling());
@@ -164,7 +248,7 @@ namespace
       aContext->ShaderManager()->UpdateClippingState();
 
       // render capping plane using the generated stencil mask
-      aContext->SetColorMask (aColorMaskBack);
+      glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       if (theWorkspace->UseDepthWrite())
       {
         glDepthMask (GL_TRUE);
@@ -176,8 +260,66 @@ namespace
         glEnable (GL_DEPTH_TEST);
       }
 
-      theWorkspace->SetAspects (thePlane->AspectFace());
-      renderPlane (theWorkspace, thePlane);
+      const OpenGl_Aspects*              aGroupAspectFace    = aGroupIter.Value()->GlAspects();
+      const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
+      const OpenGl_CappingPlaneResource* anAspectCapping =
+          thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
+        ? thePlane.get()
+        : aGroupAspectCapping;
+
+      if (anAspectCapping == NULL)
+      {
+        anAspectCapping = &THE_DEFAULT_ASPECT;
+      }
+
+      const OpenGl_Aspects*  anAspectFace     = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+      const Standard_Boolean hasHatch         = anAspectCapping->Aspect()->ToDrawHatch();
+      const OpenGl_Aspects*  anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
+      const Standard_Boolean hasTextureHatch  = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull();
+      const Standard_Boolean isRotatePers     = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent();
+      const Standard_Boolean isZoomPers       = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent();
+
+      Standard_ShortReal aHatchScale = 1.0;
+      Standard_ShortReal aHatchAngle = 0.0;
+
+      if (isRotatePers || isZoomPers)
+      {
+
+        if (isRotatePers)
+        {
+          if (aRotateAngle == 0.0)
+          {
+            const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0));
+            const gp_Dir aPlaneUp   (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2));
+            const gp_Dir& aCameraUp  = aCamera->Up();
+            const gp_Vec  aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp;
+            const gp_Dir& aCameraDir   = aCamera->Direction();
+            aRotateAngle = static_cast<Standard_ShortReal> (aCameraPln.AngleWithRef (aPlaneUp, aCameraDir) / M_PI * 180.0);
+          }
+
+          aHatchAngle = aRotateAngle;
+        }
+
+        if (isZoomPers)
+        {
+          if (aViewScale == ShortRealLast())
+          {
+            const Standard_Real aFocus = aCamera->IsOrthographic()
+                                        ? aCamera->Distance()
+                                        : (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative
+                                        ? Standard_Real(aCamera->ZFocus() * aCamera->Distance())
+                                        : Standard_Real(aCamera->ZFocus()));
+
+            const gp_XYZ aViewDim = aCamera->ViewDimensions (aFocus);
+            aViewScale = static_cast<Standard_ShortReal> (aViewDim.Y() / aContext->Viewport()[3]);
+          }
+
+          if (!anAspectHatching->TextureSet(aContext)->IsEmpty())
+            aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureSet(aContext)->First()->SizeY());
+        }
+      }
+    
+      renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle);
 
       // turn on the current plane to restore initial state
       aContext->ChangeClipping().ResetCappingFilter();
@@ -187,7 +329,7 @@ namespace
 
     if (theStructure.InstancedStructure() != NULL)
     {
-      renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane);
+      renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad);
     }
   }
 }
@@ -206,6 +348,12 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
     return;
   }
 
+  const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext);
+  if (!aCappingQuad)
+  {
+    return;
+  }
+
   // remember current aspect face defined in workspace
   const OpenGl_Aspects* aFaceAsp = theWorkspace->Aspects();
 
@@ -214,6 +362,16 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
   theWorkspace->SetRenderFilter (aPrevFilter | OpenGl_RenderFilter_FillModeOnly);
   StencilTestSentry aStencilSentry;
 
+  GLboolean aPrevBlend = glIsEnabled (GL_BLEND);
+  GLint     aPrevBlendSrc = GL_ONE;
+  GLint     aPrevBlendDst = GL_ZERO;
+  if (aPrevBlend == GL_TRUE)
+  {
+    glGetIntegerv (GL_BLEND_SRC_ALPHA, &aPrevBlendSrc);
+    glGetIntegerv (GL_BLEND_DST_ALPHA, &aPrevBlendDst);
+    glDisable (GL_BLEND);
+  }
+
   // generate capping for every clip plane
   for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next())
   {
@@ -229,23 +387,33 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks
     for (const Graphic3d_ClipPlane* aSubPlaneIter = aClipChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
     {
       // get resource for the plane
-      const TCollection_AsciiString& aResId = aSubPlaneIter->GetId();
+      const TCollection_AsciiString& aResId = THE_PLANE_STYLE + aSubPlaneIter->GetId();
       Handle(OpenGl_CappingPlaneResource) aPlaneRes;
       if (!aContext->GetResource (aResId, aPlaneRes))
       {
         // share and register for release once the resource is no longer used
-        aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter);
+        aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter->CappingSectionStyle());
         aContext->ShareResource (aResId, aPlaneRes);
       }
 
-      renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes);
+      renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes, aCappingQuad);
 
       // set delayed resource release
       aPlaneRes.Nullify();
-      aContext->ReleaseResource (aResId, Standard_True);
+      if (!aResId.IsEmpty())
+      {
+        // schedule release of resource if not used
+        aContext->ReleaseResource (aResId, Standard_True);
+      } 
     }
   }
 
+  if (aPrevBlend == GL_TRUE)
+  {
+    glEnable (GL_BLEND);
+    glBlendFunc (aPrevBlendSrc, aPrevBlendDst);
+  }
+
   // restore rendering aspects
   theWorkspace->SetAspects (aFaceAsp);
   theWorkspace->SetRenderFilter (aPrevFilter);

src/OpenGl/OpenGl_CappingPlaneResource.cxx

@@ -56,21 +56,28 @@ namespace
       { 0.0f, 0.0f, 0.0f, 1.0f } }
   };
 
+  Handle(Graphic3d_Aspects) defaultMaterial()
+  {
+    Handle(Graphic3d_AspectFillArea3d) anAspect;
+    const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
+    anAspect = new Graphic3d_AspectFillArea3d();
+    anAspect->SetDistinguishOff();
+    anAspect->SetFrontMaterial (aMaterial);
+    anAspect->SetInteriorStyle (Aspect_IS_SOLID);
+    anAspect->SetInteriorColor (aMaterial.Color());
+    anAspect->SetSuppressBackFaces (false);
+    return anAspect;
+  }
 }
 
 
 // =======================================================================
-// function : OpenGl_CappingPlaneResource
+// function : BuildInfinitPlaneVertices
 // purpose  :
 // =======================================================================
-OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
-: myPrimitives  (NULL),
-  myOrientation (OpenGl_IdentityMatrix),
-  myAspect      (NULL),
-  myPlaneRoot   (thePlane),
-  myEquationMod ((unsigned int )-1),
-  myAspectMod   ((unsigned int )-1)
+OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
 {
+  OpenGl_PrimitiveArray* aPrimitives = NULL;
   // Fill primitive array
   Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
   Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
@@ -83,8 +90,26 @@ OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d
   if (anAttribs->Init (12, anAttribInfo, 3))
   {
     memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
-    myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+
+    aPrimitives = new OpenGl_PrimitiveArray (NULL);
+    aPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
   }
+  return aPrimitives;
+}
+
+// =======================================================================
+// function : OpenGl_CappingPlaneResource
+// purpose  :
+// =======================================================================
+OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+: myCappingAspect(),//defaultMaterial()),
+  myHatchingAspect(),//defaultMaterial()),
+  myHatchingState (0)
+{
+  myCappingAspect.SetAspect (defaultMaterial());
+  myHatchingAspect.SetAspect (defaultMaterial());
+
+  SetAspect (theAspect);
 }
 
 // =======================================================================
@@ -93,18 +118,83 @@ OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d
 // =======================================================================
 OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
 {
-  Release (NULL);
 }
 
 // =======================================================================
-// function : Update
+// function : SetAspect
 // purpose  :
 // =======================================================================
-void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
-                                          const Handle(Graphic3d_Aspects)& theObjAspect)
+void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
 {
-  updateTransform (theCtx);
-  updateAspect (theObjAspect);
+  myAspect = theAspect;
+
+  if (theAspect.IsNull())
+  {
+    return;
+  }
+
+  if (!theAspect->ToUseObjectMaterial()
+   || !theAspect->ToUseObjectTexture()
+   || !theAspect->ToUseObjectShader())
+  {
+    Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
+
+    if (!theAspect->ToUseObjectMaterial())
+    {
+      aFillAspect->SetFrontMaterial (theAspect->Material());
+      aFillAspect->SetInteriorColor (theAspect->Material().Color());
+    }
+
+    if (!theAspect->ToUseObjectTexture())
+    {
+      aFillAspect->SetTextureMap (theAspect->Texture());
+
+      if (!theAspect->Texture().IsNull())
+      {
+        aFillAspect->SetTextureMapOn();
+      }
+      else
+      {
+        aFillAspect->SetTextureMapOff();
+      }
+    }
+    else
+    {
+      aFillAspect->SetTextureMap (Handle(Graphic3d_TextureMap)());
+      aFillAspect->SetTextureMapOff();
+    }
+
+    if (!theAspect->ToUseObjectShader())
+    {
+      aFillAspect->SetShaderProgram (theAspect->Shader());
+    }
+
+    myCappingAspect.SetAspect (aFillAspect);
+  }
+
+  if (theAspect->ToDrawHatch()
+    && (theAspect->IsTextureHatch()
+     || theAspect->IsStippleHatch()))
+  {
+    Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+    aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+    aFillAspect->SetHatchStyle    (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+    aFillAspect->SetTextureMap    (theAspect->IsTextureHatch() ? theAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+    aFillAspect->SetFrontMaterial (theAspect->HatchMaterial());
+    aFillAspect->SetInteriorColor (theAspect->HatchMaterial().Color());
+    if (theAspect->IsTextureHatch())
+    {
+      aFillAspect->SetTextureMapOn();
+    }
+    else
+    {
+      aFillAspect->SetTextureMapOff();
+    }
+
+    myHatchingAspect.SetAspect (aFillAspect);
+    myHatchingState = theAspect->HatchingState();
+  }
 }
 
 // =======================================================================
@@ -113,123 +203,109 @@ void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
 // =======================================================================
 void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
 {
-  OpenGl_Element::Destroy (theContext, myAspect);
-  myPrimitives.Release (theContext);
-  myEquationMod = (unsigned int )-1;
-  myAspectMod   = (unsigned int )-1;
+  myCappingAspect .Release (theContext);
+  myHatchingAspect.Release (theContext);
 }
 
 // =======================================================================
-// function : updateAspect
+// function : CappingFaceAspect
 // purpose  :
 // =======================================================================
-void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& theObjAspect)
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const
 {
-  if (myAspect == NULL)
+  if (myAspect.IsNull())
   {
-    myAspect = new OpenGl_Aspects();
-    myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync
+    return NULL;
   }
 
-  if (theObjAspect.IsNull())
-  {
-    if (myAspectMod != myPlaneRoot->MCountAspect())
-    {
-      myAspect->SetAspect (myPlaneRoot->CappingAspect());
-      myAspectMod = myPlaneRoot->MCountAspect();
-    }
-    return;
-  }
+  Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
 
-  if (myFillAreaAspect.IsNull())
-  {
-    myFillAreaAspect = new Graphic3d_AspectFillArea3d();
-  }
-  if (myAspectMod != myPlaneRoot->MCountAspect())
-  {
-    *myFillAreaAspect = *myPlaneRoot->CappingAspect();
-  }
-
-  if (myPlaneRoot->ToUseObjectMaterial())
+  if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
   {
     // only front material currently supported by capping rendering
-    myFillAreaAspect->SetFrontMaterial (theObjAspect->FrontMaterial());
-    myFillAreaAspect->SetInteriorColor (theObjAspect->InteriorColor());
-  }
-  if (myPlaneRoot->ToUseObjectTexture())
-  {
-    myFillAreaAspect->SetTextureSet (theObjAspect->TextureSet());
-    if (theObjAspect->ToMapTexture())
-    {
-      myFillAreaAspect->SetTextureMapOn();
-    }
-    else
-    {
-      myFillAreaAspect->SetTextureMapOff();
-    }
-  }
-  if (myPlaneRoot->ToUseObjectShader())
-  {
-    myFillAreaAspect->SetShaderProgram (theObjAspect->ShaderProgram());
-  }
-
-  myAspect->SetAspect (myFillAreaAspect);
-}
-
-// =======================================================================
-// function : updateTransform
-// purpose  :
-// =======================================================================
-void OpenGl_CappingPlaneResource::updateTransform (const Handle(OpenGl_Context)& theCtx)
-{
-  if (myEquationMod == myPlaneRoot->MCountEquation()
-   && myLocalOrigin.IsEqual (theCtx->ShaderManager()->LocalOrigin(), gp::Resolution()))
-  {
-    return; // nothing to update
-  }
-
-  myEquationMod = myPlaneRoot->MCountEquation();
-  myLocalOrigin = theCtx->ShaderManager()->LocalOrigin();
-
-  const Graphic3d_ClipPlane::Equation& anEq = myPlaneRoot->GetEquation();
-  const Standard_Real anEqW = theCtx->ShaderManager()->LocalClippingPlaneW (*myPlaneRoot);
-
-  // re-evaluate infinite plane transformation matrix
-  const Graphic3d_Vec3 aNorm (anEq.xyz());
-  const Graphic3d_Vec3 T (anEq.xyz() * -anEqW);
-
-  // project plane normal onto OX to find left vector
-  const Standard_ShortReal aProjLen = sqrt ((Standard_ShortReal)anEq.xz().SquareModulus());
-  Graphic3d_Vec3 aLeft;
-  if (aProjLen < ShortRealSmall())
-  {
-    aLeft[0] = 1.0f;
+    aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
+    aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor());
   }
   else
   {
-    aLeft[0] =  aNorm[2] / aProjLen;
-    aLeft[2] = -aNorm[0] / aProjLen;
+    aFillAspect->SetFrontMaterial (myAspect->Material());
+    aFillAspect->SetInteriorColor (myAspect->Material().Color());
   }
 
-  const Graphic3d_Vec3 F = Graphic3d_Vec3::Cross (-aLeft, aNorm);
+  if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL)
+  {
+    if (theObjectAspect->Aspect()->ToMapTexture())
+    {
+      aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap());
+      aFillAspect->SetTextureMapOn();
+    }
+    else
+    {
+      aFillAspect->SetTextureMapOff();
+    }
+  }
+  else
+  {
+    aFillAspect->SetTextureMap (myAspect->Texture());
+    if (!myAspect->Texture().IsNull())
+    {
+      aFillAspect->SetTextureMapOn();
+    }
+    else
+    {
+      aFillAspect->SetTextureMapOff();
+    }
+  }
 
-  myOrientation.mat[0][0] = aLeft[0];
-  myOrientation.mat[0][1] = aLeft[1];
-  myOrientation.mat[0][2] = aLeft[2];
-  myOrientation.mat[0][3] = 0.0f;
+  if (myAspect->ToUseObjectShader() && theObjectAspect != NULL)
+  {
+    aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
+  }
+  else
+  {
+    aFillAspect->SetShaderProgram (myAspect->Shader());
+  }
 
-  myOrientation.mat[1][0] = aNorm[0];
-  myOrientation.mat[1][1] = aNorm[1];
-  myOrientation.mat[1][2] = aNorm[2];
-  myOrientation.mat[1][3] = 0.0f;
+  myCappingAspect.SetAspect (aFillAspect);
 
-  myOrientation.mat[2][0] = F[0];
-  myOrientation.mat[2][1] = F[1];
-  myOrientation.mat[2][2] = F[2];
-  myOrientation.mat[2][3] = 0.0f;
-
-  myOrientation.mat[3][0] = T[0];
-  myOrientation.mat[3][1] = T[1];
-  myOrientation.mat[3][2] = T[2];
-  myOrientation.mat[3][3] = 1.0f;
+  return &myCappingAspect;
+}
+
+// =======================================================================
+// function : HatchingFaceAspect
+// purpose  :
+// =======================================================================
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::HatchingFaceAspect() const
+{
+  if (myAspect.IsNull())
+  {
+    return NULL;
+  }
+
+  const Standard_Size aHatchingState = myAspect->HatchingState();
+  if (myHatchingState != aHatchingState)
+  {
+    if (myAspect->ToDrawHatch())
+    {
+      Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+      aFillAspect->SetInteriorStyle (myAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+      aFillAspect->SetHatchStyle    (myAspect->IsStippleHatch() ? myAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+      aFillAspect->SetTextureMap    (myAspect->IsTextureHatch() ? myAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+      aFillAspect->SetFrontMaterial (myAspect->HatchMaterial());
+      aFillAspect->SetInteriorColor (myAspect->HatchMaterial().Color());
+      if (myAspect->IsTextureHatch())
+      {
+        aFillAspect->SetTextureMapOn();
+      }
+      else
+      {
+        aFillAspect->SetTextureMapOff();
+      }
+      myHatchingAspect.SetAspect (aFillAspect);
+      myHatchingState = aHatchingState;
+    }
+  }
+
+  return &myHatchingAspect;
 }

src/OpenGl/OpenGl_CappingPlaneResource.hxx

@@ -20,7 +20,7 @@
 #include <OpenGl_Resource.hxx>
 #include <OpenGl_Aspects.hxx>
 #include <OpenGl_Matrix.hxx>
-#include <Graphic3d_ClipPlane.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 
 class OpenGl_CappingPlaneResource;
 DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
@@ -30,25 +30,23 @@ DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
 //! This resource holds data necessary for OpenGl_CappingAlgo.
 //! This object is implemented as OpenGl resource for the following reasons:
 //! - one instance should be shared between contexts.
-//! - instance associated to Graphic3d_ClipPlane data by id.
+//! - instance associated to Graphic3d_AspectFillCapping data.
 //! - should created and released within context (owns OpenGl elements and resources).
 class OpenGl_CappingPlaneResource : public OpenGl_Resource
 {
 public:
 
-  //! Constructor.
-  //! Create capping plane presentation associated to clipping plane data.
-  //! @param thePlane [in] the plane data.
-  Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
+  //! Create and assign style.
+  Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect);
 
   //! Destroy object.
   Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
 
-  //! Update resource data in the passed context.
-  //! @param theContext   [in] the context
-  //! @param theObjAspect [in] object aspect
-  Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext,
-                               const Handle(Graphic3d_Aspects)& theObjAspect);
+  //! Assign section style.
+  Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect);
+
+  //! Returns section style parameters.
+  const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myAspect; }
 
   //! Release associated OpenGl resources.
   //! @param theContext [in] the resource context.
@@ -57,17 +55,23 @@ public:
   //! Returns estimated GPU memory usage - not implemented.
   virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
 
-  //! Return parent clipping plane structure.
-  const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; }
-
-  //! @return aspect face for rendering capping surface.
-  inline const OpenGl_Aspects* AspectFace() const { return myAspect; }
-
-  //! @return evaluated orientation matrix to transform infinite plane.
-  inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
-
   //! @return primitive array of vertices to render infinite plane.
-  inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
+  static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices();
+
+  //! Returns true if capping should draw hatch layer.
+  Standard_Boolean ToDrawHatch() const 
+  {
+    return myAspect->ToDrawHatch() 
+       && (myAspect->IsStippleHatch()
+        || myAspect->IsTextureHatch());
+  }
+
+  //! Returns the shading aspect for drawing face of a clipping section itself.
+  //! @param theObjectAspect [in] the aspect of an object if it requires combining.
+  Standard_EXPORT  const OpenGl_Aspects* CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const;
+
+  //! Returns the shading aspect for drawing hatch layer of a section.
+  Standard_EXPORT const OpenGl_Aspects* HatchingFaceAspect() const;
 
 private:
 
@@ -79,14 +83,11 @@ private:
 
 private:
 
-  OpenGl_PrimitiveArray       myPrimitives;    //!< vertices and texture coordinates for rendering
-  OpenGl_Matrix               myOrientation;   //!< plane transformation matrix.
-  OpenGl_Aspects*             myAspect;        //!< capping face aspect.
-  Handle(Graphic3d_ClipPlane) myPlaneRoot;     //!< parent clipping plane structure.
-  Handle(Graphic3d_Aspects)   myFillAreaAspect;//!< own capping aspect
-  gp_XYZ                      myLocalOrigin;   //!< layer origin
-  unsigned int                myEquationMod;   //!< modification counter for plane equation.
-  unsigned int                myAspectMod;     //!< modification counter for aspect.
+  Handle(Graphic3d_AspectFillCapping) myAspect;         //!< Section style settings from application's level.
+  mutable OpenGl_Aspects              myCappingAspect;  //!< GL aspect for shading base layer of a capping section.
+  mutable OpenGl_Aspects              myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
+  mutable Standard_Size               myHatchingState;
+  gp_XYZ                              myLocalOrigin;   //!< layer origin
 
 public:
 

src/OpenGl/OpenGl_Group.cxx

@@ -25,6 +25,7 @@
 #include <OpenGl_Workspace.hxx>
 
 #include <Graphic3d_ArrayOfPrimitives.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 #include <Graphic3d_GroupDefinitionError.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Group,Graphic3d_Group)
@@ -90,6 +91,20 @@ void OpenGl_Group::SetGroupPrimitivesAspect (const Handle(Graphic3d_Aspects)& th
     return;
   }
 
+  if (!theAspect.IsNull() && theAspect->IsKind (STANDARD_TYPE(Graphic3d_AspectFillCapping)))
+  {
+    Handle(Graphic3d_AspectFillCapping) aFillCappingAspect = Handle(Graphic3d_AspectFillCapping)::DownCast (theAspect);
+    if (myAspectFillCapping == NULL)
+    {
+      myAspectFillCapping = new OpenGl_CappingPlaneResource (aFillCappingAspect);
+    }
+    else
+    {
+      myAspectFillCapping->SetAspect (aFillCappingAspect);
+    }
+    return;
+  }
+
   if (myAspects == NULL)
   {
     myAspects = new OpenGl_Aspects (theAspect);

src/OpenGl/OpenGl_Group.hxx

@@ -21,6 +21,7 @@
 
 #include <NCollection_List.hxx>
 #include <OpenGl_Aspects.hxx>
+#include <OpenGl_CappingPlaneResource.hxx>
 #include <OpenGl_Element.hxx>
 
 class OpenGl_Group;
@@ -117,6 +118,17 @@ public:
   //! Is the group ray-tracable (contains ray-tracable elements)?
   Standard_Boolean IsRaytracable() const { return myIsRaytracable; }
 
+  //! Returns section style aspect.
+  virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const Standard_OVERRIDE
+  {
+    return myAspectFillCapping != NULL
+         ? myAspectFillCapping->Aspect()
+         : Handle(Graphic3d_AspectFillCapping)();
+  }
+
+  //! Returns OpenGL capping filling aspect.
+  const OpenGl_CappingPlaneResource* AspectFillCapping() const { return myAspectFillCapping; }
+
 protected:
 
   Standard_EXPORT virtual ~OpenGl_Group();
@@ -124,6 +136,7 @@ protected:
 protected:
 
   OpenGl_Aspects*     myAspects;
+  OpenGl_CappingPlaneResource* myAspectFillCapping;
   OpenGl_ElementNode* myFirst;
   OpenGl_ElementNode* myLast;
   Standard_Boolean    myIsRaytracable;

src/StdPrs/StdPrs_ShadedShape.cxx

@@ -283,6 +283,7 @@ namespace
   static Standard_Boolean shadeFromShape (const TopoDS_Shape&               theShape,
                                           const Handle(Prs3d_Presentation)& thePrs,
                                           const Handle(Prs3d_Drawer)&       theDrawer,
+                                          const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
                                           const Standard_Boolean            theHasTexels,
                                           const gp_Pnt2d&                   theUVOrigin,
                                           const gp_Pnt2d&                   theUVRepeat,
@@ -298,6 +299,9 @@ namespace
     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePrs);
     aGroup->SetClosed (theIsClosed);
     aGroup->SetGroupPrimitivesAspect (theDrawer->ShadingAspect()->Aspect());
+    if (!theCappingStyle.IsNull())
+      aGroup->SetGroupPrimitivesAspect (theCappingStyle);
+
     aGroup->AddPrimitiveArray (aPArray);
     return Standard_True;
   }
@@ -517,11 +521,12 @@ void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape&    theShape,
 void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
                               const TopoDS_Shape&               theShape,
                               const Handle(Prs3d_Drawer)&       theDrawer,
+                              const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
                               const StdPrs_Volume               theVolume)
 {
   gp_Pnt2d aDummy;
   StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
-                           Standard_False, aDummy, aDummy, aDummy, theVolume);
+                           Standard_False, aDummy, aDummy, aDummy, theCappingStyle, theVolume);
 }
 
 // =======================================================================
@@ -535,6 +540,7 @@ void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
                               const gp_Pnt2d&                    theUVOrigin,
                               const gp_Pnt2d&                    theUVRepeat,
                               const gp_Pnt2d&                    theUVScale,
+                              const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
                               const StdPrs_Volume                theVolume)
 {
   if (theShape.IsNull())
@@ -572,20 +578,20 @@ void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
 
     if (aClosed.NbChildren() > 0)
     {
-      shadeFromShape (aClosed, thePrs, theDrawer,
+      shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle,
                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
     }
 
     if (anOpened.NbChildren() > 0)
     {
-      shadeFromShape (anOpened, thePrs, theDrawer,
+      shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle,
                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
     }
   }
   else
   {
     // if the shape type is not compound, composolid or solid, use autodetection back-facing filled
-    shadeFromShape (theShape, thePrs, theDrawer,
+    shadeFromShape (theShape, thePrs, theDrawer, theCappingStyle,
                     theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
                     theVolume == StdPrs_Volume_Closed);
   }

src/StdPrs/StdPrs_ShadedShape.hxx

@@ -38,13 +38,25 @@ public:
   //! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
   //! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
   //! or to perform Autodetection (would split input shape into two groups)
-  Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+  Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+                                   const TopoDS_Shape& theShape,
+                                   const Handle(Prs3d_Drawer)& theDrawer,
+                                   const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(), 
+                                   StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
   
   //! Shades <theShape> with texture coordinates.
   //! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
   //! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
   //! or to perform Autodetection (would split input shape into two groups)
-  Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const Standard_Boolean theHasTexels, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, const gp_Pnt2d& theUVScale, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+  Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+                                   const TopoDS_Shape& theShape,
+                                   const Handle(Prs3d_Drawer)& theDrawer,
+                                   const Standard_Boolean theHasTexels,
+                                   const gp_Pnt2d& theUVOrigin,
+                                   const gp_Pnt2d& theUVRepeat,
+                                   const gp_Pnt2d& theUVScale,
+                                   const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
+                                   const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
   
   //! Searches closed and unclosed subshapes in shape structure and puts them
   //! into two compounds for separate processing of closed and unclosed sub-shapes

src/ViewerTest/ViewerTest_ViewerCommands.cxx

@@ -9309,7 +9309,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
 
       if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
       {
-        aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+        aClipPlane->CappingSectionStyle()->SetUseObjectMaterial (toEnable == Standard_True);
         anArgIter += 1;
       }
     }
@@ -9326,7 +9326,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
 
       if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
       {
-        aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
+        aClipPlane->CappingSectionStyle()->SetUseObjectTexture (toEnable == Standard_True);
         anArgIter += 1;
       }
     }
@@ -9341,7 +9341,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
 
       if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
       {
-        aClipPlane->SetUseObjectShader (toEnable == Standard_True);
+        aClipPlane->CappingSectionStyle()->SetUseObjectShader (toEnable == Standard_True);
         anArgIter += 1;
       }
     }
@@ -9358,10 +9358,10 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
         return 1;
       }
 
-      Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+      Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material();
       aMat.SetAmbientColor (aColor);
       aMat.SetDiffuseColor (aColor);
-      aClipPlane->SetCappingMaterial (aMat);
+      aClipPlane->CappingSectionStyle()->SetMaterial (aMat);
       anArgIter += aNbParsed;
     }
     else if ((aChangeArg == "-transparency"
@@ -9369,44 +9369,34 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
           && aNbChangeArgs >= 2)
     {
       TCollection_AsciiString aValStr (aChangeArgs[1]);
-      Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
       if (aValStr.IsRealValue())
       {
-        Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+        Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material();
         aMat.SetTransparency ((float )aValStr.RealValue());
-        anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
-        aClipPlane->SetCappingMaterial (aMat);
+        aClipPlane->CappingSectionStyle()->SetMaterial (aMat);
       }
       else
       {
-        aValStr.LowerCase();
-        Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto;
-        if (aValStr == "opaque")
-        {
-          aMode = Graphic3d_AlphaMode_Opaque;
-        }
-        else if (aValStr == "mask")
-        {
-          aMode = Graphic3d_AlphaMode_Mask;
-        }
-        else if (aValStr == "blend")
-        {
-          aMode = Graphic3d_AlphaMode_Blend;
-        }
-        else if (aValStr == "blendauto")
-        {
-          aMode = Graphic3d_AlphaMode_BlendAuto;
-        }
-        else
-        {
-          std::cout << "Syntax error at '" << aValStr << "'\n";
-          return 1;
-        }
-        anAspect->SetAlphaMode (aMode);
-        aClipPlane->SetCappingAspect (anAspect);
+        std::cout << "Syntax error at '" << aValStr << "'\n";
+        return 1;
       }
       anArgIter += 1;
     }
+    else if (aChangeArg == "-overrideaspect"
+          || aChangeArg == "overrideaspect")
+    {
+      if (aNbChangeArgs < 2)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+      {
+        aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
+        anArgIter += 1;
+      }
+    }
     else if (aChangeArg == "-texname"
           || aChangeArg == "texname")
     {
@@ -9420,20 +9410,22 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
       Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
       if (!aTexture->IsDone())
       {
-        aClipPlane->SetCappingTexture (NULL);
+        aClipPlane->CappingSectionStyle()->SetTexture (Handle(Graphic3d_TextureMap)());
       }
       else
       {
         aTexture->EnableModulate();
         aTexture->EnableRepeat();
-        aClipPlane->SetCappingTexture (aTexture);
+        aClipPlane->CappingSectionStyle()->SetTexture (aTexture.get());
       }
       anArgIter += 1;
     }
     else if (aChangeArg == "-texscale"
           || aChangeArg == "texscale")
     {
-      if (aClipPlane->CappingTexture().IsNull())
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+      if (aHatchTexture.IsNull())
       {
         std::cout << "Error: no texture is set.\n";
         return 1;
@@ -9447,13 +9439,15 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
 
       Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
       Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
-      aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+      aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
       anArgIter += 2;
     }
     else if (aChangeArg == "-texorigin"
           || aChangeArg == "texorigin") // texture origin
     {
-      if (aClipPlane->CappingTexture().IsNull())
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+      if (aHatchTexture.IsNull())
       {
         std::cout << "Error: no texture is set.\n";
         return 1;
@@ -9468,13 +9462,15 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
       Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
       Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
 
-      aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+      aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
       anArgIter += 2;
     }
     else if (aChangeArg == "-texrotate"
           || aChangeArg == "texrotate") // texture rotation
     {
-      if (aClipPlane->CappingTexture().IsNull())
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+      if (aHatchTexture.IsNull())
       {
         std::cout << "Error: no texture is set.\n";
         return 1;
@@ -9487,7 +9483,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
       }
 
       Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
-      aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
+      aHatchTexture->GetParams()->SetRotation (aRot);
       anArgIter += 1;
     }
     else if (aChangeArg == "-hatch"
@@ -9499,22 +9495,165 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
         return 1;
       }
 
-      TCollection_AsciiString aHatchStr (aChangeArgs[1]);
-      aHatchStr.LowerCase();
-      if (aHatchStr == "on")
+      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
       {
-        aClipPlane->SetCappingHatchOn();
+        aClipPlane->CappingSectionStyle()->SetToDrawHatch (toEnable == Standard_True);
+        anArgIter += 1;
       }
-      else if (aHatchStr == "off")
+    }
+    else if (aChangeArg == "-hatchtexture"
+          || aChangeArg == "hatchtexture")
+    {
+      if (aNbChangeArgs < 2)
       {
-        aClipPlane->SetCappingHatchOff();
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      TCollection_AsciiString aTextureName (aChangeArgs[1]);
+      Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+      if (!aTexture->IsDone())
+      {
+        aClipPlane->CappingSectionStyle()->SetHatchStyle (Handle(Graphic3d_TextureMap)());
       }
       else
       {
-        aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
+        aTexture->EnableModulate();
+        aTexture->EnableRepeat();
+        aClipPlane->CappingSectionStyle()->SetHatchStyle (aTexture.get());
+        aClipPlane->CappingSectionStyle()->SetToDrawHatch (true);
       }
       anArgIter += 1;
     }
+    else if (aChangeArg == "-hatchstipple"
+          || aChangeArg == "hatchstipple")
+    {
+      if (aNbChangeArgs < 2)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      aClipPlane->CappingSectionStyle()->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
+      aClipPlane->CappingSectionStyle()->SetToDrawHatch (true);
+      anArgIter += 1;
+    }
+    else if (aChangeArg == "-hatchcolor"
+          || aChangeArg == "hatchcolor")
+    {
+      Quantity_Color aColor;
+      Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+                                                           aChangeArgs + 1,
+                                                           aColor);
+      if (aNbParsed == 0)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->HatchMaterial();
+      aMat.SetAmbientColor (aColor);
+      aMat.SetDiffuseColor (aColor);
+      aClipPlane->CappingSectionStyle()->SetHatchMaterial (aMat);
+      anArgIter += aNbParsed;
+    }
+
+    else if (aChangeArg == "-hatchscale"
+          || aChangeArg == "hatchscale")
+    {
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+      if (aHatchTexture.IsNull())
+      {
+        std::cout << "Error: no texture is set.\n";
+        return 1;
+      }
+
+      if (aNbChangeArgs < 3)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+      Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
+      aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+      anArgIter += 2;
+    }
+    else if (aChangeArg == "-hatchorigin"
+          || aChangeArg == "hatchorigin") // texture origin
+    {
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+      if (aHatchTexture.IsNull())
+      {
+        std::cout << "Error: no texture is set.\n";
+        return 1;
+      }
+
+      if (aNbChangeArgs < 3)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+      Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
+
+      aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+      anArgIter += 2;
+    }
+    else if (aChangeArg == "-hatchrotate"
+          || aChangeArg == "hatchrotate") // texture rotation
+    {
+      const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+      if (aHatchTexture.IsNull())
+      {
+        std::cout << "Error: no texture is set.\n";
+        return 1;
+      }
+
+      if (aNbChangeArgs < 2)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+      aHatchTexture->GetParams()->SetRotation (aRot);
+      anArgIter += 1;
+    }
+    else if (aChangeArg == "-hatchzoompers"
+          || aChangeArg == "hatchzoompers")
+    {
+      if (aNbChangeArgs < 2)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+      {
+        aClipPlane->CappingSectionStyle()->SetHatchZoomPeristent (toEnable == Standard_True);
+        anArgIter += 1;
+      }
+    }
+    else if (aChangeArg == "-hatchrotatepers"
+          || aChangeArg == "hatchrotatepers")
+    {
+      if (aNbChangeArgs < 2)
+      {
+        std::cout << "Syntax error: need more arguments.\n";
+        return 1;
+      }
+
+      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+      {
+        aClipPlane->CappingSectionStyle()->SetHatchRotationPeristent (toEnable == Standard_True);
+        anArgIter += 1;
+      }
+    }
     else if (aChangeArg == "-delete"
           || aChangeArg == "delete")
     {
@@ -13661,6 +13800,16 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
       "\n\t\t:     [-color R G B] [-transparency Value] [-hatch {on|off|ID}]"
       "\n\t\t:     [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]"
       "\n\t\t:       [-texRotate Angle]"
+      /*"\n\t\t:     [-overrideAspect {0|1}]"
+      "\n\t\t:     [-color R G B]"
+      "\n\t\t:     [-texture Texture]   [-texScale SX SY]"
+      "\n\t\t:     [-texOrigin TX TY]   [-texRotate Angle]"
+      "\n\t\t:     [-hatch {on|off}]    [-hatchStipple mask]"
+      "\n\t\t:     [-hatchColor R G B]  [-hatchTexture texture]"
+      "\n\t\t:     [-hatchScale  SX SY] [-hatchOrigin TX TY]"
+      "\n\t\t:     [-hatchRotate Angle]"
+      "\n\t\t:     [-hatchZoomPers {0|1}]"
+      "\n\t\t:     [-hatchRotatePers {0|1}]"*/
       "\n\t\t:     [-useObjMaterial {0|1}] [-useObjTexture {0|1}]"
       "\n\t\t:       [-useObjShader {0|1}]"
       "\n\t\t: Clipping planes management:"
@@ -13673,13 +13822,22 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
       "\n\t\t:   -clone SourcePlane NewPlane clone the plane definition."
       "\n\t\t: Capping options:"
       "\n\t\t:   -capping {off|on|0|1} turn capping on/off"
+      "\n\t\t:   -overrideAspect       override presentation aspect (if defined)"
       "\n\t\t:   -color R G B          set capping color"
       "\n\t\t:   -transparency Value   set capping transparency 0..1"
       "\n\t\t:   -texName Texture      set capping texture"
       "\n\t\t:   -texScale SX SY       set capping tex scale"
       "\n\t\t:   -texOrigin TX TY      set capping tex origin"
       "\n\t\t:   -texRotate Angle      set capping tex rotation"
-      "\n\t\t:   -hatch {on|off|ID}    set capping hatching mask"
+      "\n\t\t:   -hatch {on|off}       turn on/off hatch style on capping"
+      "\n\t\t:   -hatchStipple ID      set stipple mask for drawing hatch"
+      "\n\t\t:   -hatchColor R G B     set color for hatch material"
+      "\n\t\t:   -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
+      "\n\t\t:   -hatchScale  SX SY    set hatch texture scale"
+      "\n\t\t:   -hatchOrigin TX TY    set hatch texture origin"
+      "\n\t\t:   -hatchRotate Angle    set hatch texture rotation"
+      "\n\t\t:   -hatchZoomPers        allow hatch tetxure mapping to be constant when zooming"
+      "\n\t\t:   -hatchRotatePers      allow hatch tetxure mapping to be constant when rotating"
       "\n\t\t:   -useObjMaterial {off|on|0|1} use material of clipped object"
       "\n\t\t:   -useObjTexture  {off|on|0|1} use texture of clipped object"
       "\n\t\t:   -useObjShader   {off|on|0|1} use shader program of object",

tests/bugs/vis/bug24224

@@ -46,6 +46,7 @@ vclipplane change pln2 equation -0.707 0.707 0 -25
 vclipplane change pln2 capping on
 vclipplane change pln2 capping color 0.5 0.5 0.9
 vclipplane change pln2 capping hatch on
+vclipplane change pln2 capping hatchStipple 7
 vclipplane set pln2 object b3
 
 checkcolor $x3_coord $y3_coord 0.5 0.5 0.9

tests/bugs/vis/bug27751_capping

@@ -71,5 +71,5 @@ vdisplay pp1 pp2
 vzoom 0.8
 
 puts "Enable capping planes"
-vclipplane pln1 -set -equation 0 0 -1 $aPln1Z        -capping 1 -color 0.5 0.5 0.5 -texname $aHatch -texscale 0.02 -0.02 -useObjMaterial 1
-vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -texname $aHatch -texscale 0.02 -0.02
+vclipplane pln1 -set -equation 0 0 -1 $aPln1Z        -capping 1 -color 0.5 0.5 0.5 -hatchtexture $aHatch -hatchscale 0.02 -0.02 -useObjMaterial 1
+vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -hatchtexture $aHatch -hatchscale 0.02 -0.02