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

(cherry picked from commit 63195be7104e23d0f2fbeab695e85c76bbe59e87)

src/AIS/AIS_ColoredShape.cxx

@@ -637,6 +637,11 @@ void AIS_ColoredShape::addShapesWithCustomProps (const Handle(Prs3d_Presentation
           {
             aShadedGroup = thePrs->NewGroup();
             aShadedGroup->SetClosed (isClosed);
+            if (isClosed)
+            {
+              if (aDrawer->HasOwnFillCappingAspect())
+                aShadedGroup->SetGroupPrimitivesAspect (aDrawer->FillCappingAspect());
+            }
           }
           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>

src/AIS/AIS_Shape.cxx

@@ -176,10 +176,7 @@ void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentat
           try
           {
             OCC_CATCH_SIGNALS
-            StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer,
+           StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myDrawer->FillCappingAspect());
-                                     myDrawer->ShadingAspect()->Aspect()->ToMapTexture()
-                                 && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(),
-                                     myUVOrigin, myUVRepeat, myUVScale);
           }
           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,134 @@
+// 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++;
+}
+
+//=======================================================================
+//function : DumpJson
+//purpose  : 
+//=======================================================================
+void Graphic3d_AspectFillCapping::DumpJson (Standard_OStream& theOStream, const Standard_Integer theDepth) const
+{
+  OCCT_DUMP_CLASS_BEGIN (theOStream, Graphic3d_AspectFillCapping);
+
+  OCCT_DUMP_BASE_CLASS (theOStream, theDepth, Graphic3d_Aspects);
+
+  OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMaterial);
+  OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMaterial);
+
+  OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myTexture);
+  OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myShader);
+  OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myStippleHatch);
+  OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myTextureHatch);
+
+  OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myHatchMaterial);
+
+  OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myFlags);
+  OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myHatchingState);
+}

src/Graphic3d/Graphic3d_AspectFillCapping.hxx

@@ -0,0 +1,167 @@
+// 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; }
+
+  //! Dumps the content of me into the stream
+  Standard_EXPORT void DumpJson (Standard_OStream& theOStream, const Standard_Integer theDepth = -1) const;
+
+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

@@ -57,6 +57,7 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane()
   myIsCapping  (Standard_False)
 {
   makeId();
+  init();
 }
 
 // =======================================================================
@@ -77,6 +78,7 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation)
   myIsCapping  (Standard_False)
 {
   makeId();
+  init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a()));
   updateInversedPlane();
 }
  
@@ -98,8 +100,17 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther)
   myIsOn       (theOther.myIsOn),
   myIsCapping  (theOther.myIsCapping)
 {
-  makeId();
   *myAspect = *theOther.CappingAspect();
+  *mySectionStyle = *theOther.CappingSectionStyle();
+
+  makeId();
+  init (theOther.myPlane,
+        theOther.myEquationRev,
+        theOther.myIsOn,
+        theOther.myIsCapping,
+        theOther.ToOverrideCappingAspect(),
+        theOther.CappingSectionStyle());
+  updateInversedPlane();
 }
 
 // =======================================================================
@@ -118,8 +129,9 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane)
   myIsCapping  (Standard_False)
 {
   thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
-  updateInversedPlane();
   makeId();
+  init (thePlane);
+  updateInversedPlane();
 }
 
 // =======================================================================
@@ -131,6 +143,7 @@ void Graphic3d_ClipPlane::SetEquation (const Graphic3d_Vec4d& theEquation)
   myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
   myEquation = theEquation;
   updateInversedPlane();
+  myOrientationDirty = Standard_True;
   myEquationMod++;
 }
 
@@ -143,6 +156,7 @@ void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane)
   myPlane = thePlane;
   thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
   updateInversedPlane();
+  myOrientationDirty = Standard_True;
   myEquationMod++;
 }
 
@@ -307,6 +321,96 @@ void Graphic3d_ClipPlane::makeId()
        + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
 }
 
+// =======================================================================
+// function : SetCappingSectionStyle
+// purpose  :
+// =======================================================================
+void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+  mySectionStyle = theStyle;
+}
+
+// =======================================================================
+// function : OrientationMatrix
+// purpose  :
+// =======================================================================
+const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const
+{
+  if (myOrientationDirty)
+  {
+    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())
+    {
+      aSide1[0] = 1.0f;
+    }
+    else
+    {
+      aSide1[0] =  aDirection[2] / aMagintude;
+      aSide1[2] = -aDirection[0] / aMagintude;
+    }
+
+    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;
+  }
+
+  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)
+{
+  myOverrideObjectStyle = theOverrideStyle;
+  mySectionStyle        = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle;
+  myOrientationDirty    = Standard_True;
+}
+
 // =======================================================================
 // function : updateChainLen
 // purpose  :
@@ -326,6 +430,7 @@ void Graphic3d_ClipPlane::updateChainLen()
 // =======================================================================
 void Graphic3d_ClipPlane::SetChainNextPlane (const Handle(Graphic3d_ClipPlane)& thePlane)
 {
+  myOrientationDirty = Standard_True;
   ++myEquationMod;
   if (!myNextInChain.IsNull())
   {

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>
@@ -256,6 +259,16 @@ public:
   //! Return true if some fill area aspect properties should be taken from object.
   bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; }
 
+public:
+
+  //! Returns style used for drawing capping section.
+  //! @return capping surface rendering aspect.
+  const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; }
+
+  //! Sets clipping section filling aspect.
+  Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+
 public:
 
   //! Check if the given point is outside / inside / on section.
@@ -402,6 +415,28 @@ private:
   //! Set capping flag.
   Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag);
 
+public:
+
+  //! 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:
+
+  //! 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();
 
@@ -416,6 +451,7 @@ 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
@@ -428,6 +464,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;
 class Graphic3d_Text;
 
 //! This class allows the definition of groups
@@ -105,6 +106,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 = new OpenGl_CappingPlaneResource (NULL, 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,6 +63,120 @@ namespace
     GLint myDepthFuncPrev;
   };
 
+  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);
+
+    const Standard_Boolean isTextureHatch =
+        theHatchAspect != NULL
+    &&  theHatchAspect->Aspect()->TextureMapState();
+
+    aContext->ModelWorldState.Push();
+    aContext->ModelWorldState.SetCurrent (theCappingMatrix);
+    aContext->ApplyModelViewMatrix();
+
+    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();
+
+    theWorkspace->SetAllowFaceCulling (wasCullAllowed);
+  }
+
   //! 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.
@@ -86,13 +205,24 @@ 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,14 +233,33 @@ 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*              aGroupAspectFace    = aGroupIter.Value()->GlAspects();
-      const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
+      const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
-      thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)());
+      const OpenGl_CappingPlaneResource* anAspectCapping =
-      theWorkspace->SetAspects (thePlane->AspectFace());
+          thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
-      theWorkspace->SetRenderFilter (aPrevFilter);
+        ? thePlane.get()
-      if (!theWorkspace->ShouldRender (&thePlane->Primitives()))
+        : aGroupAspectCapping;
+
+      if (anAspectCapping == NULL)
       {
-        continue;
+        anAspectCapping = THE_DEFAULT_ASPECT;
+      }
+
+      const OpenGl_Aspects*  anAspectFace     = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+      const Standard_Boolean hasHatch         = anAspectCapping->Aspect()->ToDrawHatch();
+
+      if (!hasHatch)
+      {
+        // check if capping plane should be rendered within current pass (only opaque / only transparent)
+        const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
+        //const OpenGl_Aspects* anObjAspectFace = aRenderPlane->CappingSectionStyle()->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
@@ -140,17 +289,25 @@ namespace
       glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
 
       // render closed primitives
-      if (aRenderPlane->ToUseObjectProperties())
+      if (hasHatch)
       {
         aGroupIter.Value()->Render (theWorkspace);
       }
       else
       {
-        for (; aGroupIter.More(); aGroupIter.Next())
+        // render closed primitives
+        if (aRenderPlane->ToUseObjectProperties())
         {
-          if (aGroupIter.Value()->IsClosed())
+         aGroupIter.Value()->Render (theWorkspace);
+        }
+        else
+        {
+          for (; aGroupIter.More(); aGroupIter.Next())
           {
-            aGroupIter.Value()->Render (theWorkspace);
+            if (aGroupIter.Value()->IsClosed())
+            {
+              aGroupIter.Value()->Render (theWorkspace);
+            }
           }
         }
       }
@@ -176,8 +333,63 @@ namespace
         glEnable (GL_DEPTH_TEST);
       }
 
-      theWorkspace->SetAspects (thePlane->AspectFace());
+      if (!hasHatch)
-      renderPlane (theWorkspace, thePlane);
+      {
+        theWorkspace->SetAspects (thePlane->AspectFace());
+        renderPlane (theWorkspace, thePlane);
+      }
+      else
+      {
+        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;
+              if (aCameraPln.Magnitude() > Precision::Confusion())
+              {
+                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 +399,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 +418,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 +432,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 +457,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, 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)
+OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
-: myPrimitives  (NULL),
-  myOrientation (OpenGl_IdentityMatrix),
-  myAspect      (NULL),
-  myPlaneRoot   (thePlane),
-  myEquationMod ((unsigned int )-1),
-  myAspectMod   ((unsigned int )-1)
 {
+  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,53 @@ 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_ClipPlane)& thePlane,
+                                                          const Handle(Graphic3d_AspectFillCapping)& theAspect)
+: myPrimitives  (NULL),
+  myPrimitivesUsed (Standard_False),
+  myOrientation (OpenGl_IdentityMatrix),
+  myAspect      (NULL),
+  myPlaneRoot   (thePlane),
+  myEquationMod ((unsigned int )-1),
+  myAspectMod   ((unsigned int )-1),
+  myCappingAspect(),//defaultMaterial()),
+  myHatchingAspect(),//defaultMaterial()),
+  myHatchingState (0)
+{
+  if (theAspect.IsNull() || !theAspect->ToDrawHatch())
+  {
+    // Fill primitive array
+    Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
+    Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
+    Graphic3d_Attribute anAttribInfo[] =
+    {
+      { Graphic3d_TOA_POS,  Graphic3d_TOD_VEC4 },
+      { Graphic3d_TOA_NORM, Graphic3d_TOD_VEC4 },
+      { Graphic3d_TOA_UV,   Graphic3d_TOD_VEC4 }
+    };
+    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);
+      myPrimitivesUsed = Standard_True;
+    }
+  }
+
+  myCappingAspect.SetAspect (defaultMaterial());
+  myHatchingAspect.SetAspect (defaultMaterial());
+
+  SetAspect (theAspect);
 }
 
 // =======================================================================
@@ -93,7 +145,90 @@ OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d
 // =======================================================================
 OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
 {
-  Release (NULL);
+  if (myPrimitivesUsed)
+  {
+    Release (NULL);
+  }
+}
+
+// =======================================================================
+// function : SetAspect
+// purpose  :
+// =======================================================================
+void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+  myGraphicAspect = theAspect;
+
+  if (theAspect.IsNull())
+  {
+    return;
+  }
+
+  if (!theAspect->ToDrawHatch())
+    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();
+  }
 }
 
 // =======================================================================
@@ -103,6 +238,9 @@ OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
 void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
                                           const Handle(Graphic3d_Aspects)& theObjAspect)
 {
+  if (!myPrimitivesUsed)
+    return;
+
   updateTransform (theCtx);
   updateAspect (theObjAspect);
 }
@@ -113,10 +251,118 @@ void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
 // =======================================================================
 void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
 {
-  OpenGl_Element::Destroy (theContext, myAspect);
+  if (myPrimitivesUsed)
-  myPrimitives.Release (theContext);
+  {
-  myEquationMod = (unsigned int )-1;
+    OpenGl_Element::Destroy (theContext, myAspect);
-  myAspectMod   = (unsigned int )-1;
+    myPrimitives.Release (theContext);
+    myEquationMod = (unsigned int )-1;
+    myAspectMod   = (unsigned int )-1;
+  }
+  myCappingAspect .Release (theContext);
+  myHatchingAspect.Release (theContext);
+}
+
+// =======================================================================
+// function : CappingFaceAspect
+// purpose  :
+// =======================================================================
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const
+{
+  if (myGraphicAspect.IsNull())
+  {
+    return NULL;
+  }
+
+  Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
+
+  if (myGraphicAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
+  {
+    // only front material currently supported by capping rendering
+    aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
+    aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor());
+  }
+  else
+  {
+    aFillAspect->SetFrontMaterial (myGraphicAspect->Material());
+    aFillAspect->SetInteriorColor (myGraphicAspect->Material().Color());
+  }
+
+  if (myGraphicAspect->ToUseObjectTexture() && theObjectAspect != NULL)
+  {
+    if (theObjectAspect->Aspect()->ToMapTexture())
+    {
+      aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap());
+      aFillAspect->SetTextureMapOn();
+    }
+    else
+    {
+      aFillAspect->SetTextureMapOff();
+    }
+  }
+  else
+  {
+    aFillAspect->SetTextureMap (myGraphicAspect->Texture());
+    if (!myGraphicAspect->Texture().IsNull())
+    {
+      aFillAspect->SetTextureMapOn();
+    }
+    else
+    {
+      aFillAspect->SetTextureMapOff();
+    }
+  }
+
+  if (myGraphicAspect->ToUseObjectShader() && theObjectAspect != NULL)
+  {
+    aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
+  }
+  else
+  {
+    aFillAspect->SetShaderProgram (myGraphicAspect->Shader());
+  }
+
+  myCappingAspect.SetAspect (aFillAspect);
+
+  return &myCappingAspect;
+}
+
+// =======================================================================
+// function : HatchingFaceAspect
+// purpose  :
+// =======================================================================
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::HatchingFaceAspect() const
+{
+  if (myGraphicAspect.IsNull())
+  {
+    return NULL;
+  }
+
+  const Standard_Size aHatchingState = myGraphicAspect->HatchingState();
+  if (myHatchingState != aHatchingState)
+  {
+    if (myGraphicAspect->ToDrawHatch())
+    {
+      Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+      aFillAspect->SetInteriorStyle (myGraphicAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+      aFillAspect->SetHatchStyle    (myGraphicAspect->IsStippleHatch() ? myGraphicAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+      aFillAspect->SetTextureMap    (myGraphicAspect->IsTextureHatch() ? myGraphicAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+      aFillAspect->SetFrontMaterial (myGraphicAspect->HatchMaterial());
+      aFillAspect->SetInteriorColor (myGraphicAspect->HatchMaterial().Color());
+      if (myGraphicAspect->IsTextureHatch())
+      {
+        aFillAspect->SetTextureMapOn();
+      }
+      else
+      {
+        aFillAspect->SetTextureMapOff();
+      }
+      myHatchingAspect.SetAspect (aFillAspect);
+      myHatchingState = aHatchingState;
+    }
+  }
+
+  return &myHatchingAspect;
 }
 
 // =======================================================================
@@ -125,6 +371,9 @@ void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
 // =======================================================================
 void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& theObjAspect)
 {
+  if (myPlaneRoot.IsNull())
+    return;
+
   if (myAspect == NULL)
   {
     myAspect = new OpenGl_Aspects();
@@ -182,6 +431,9 @@ void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)&
 // =======================================================================
 void OpenGl_CappingPlaneResource::updateTransform (const Handle(OpenGl_Context)& theCtx)
 {
+  if (myPlaneRoot.IsNull())
+    return;
+
   if (myEquationMod == myPlaneRoot->MCountEquation()
    && myLocalOrigin.IsEqual (theCtx->ShaderManager()->LocalOrigin(), gp::Resolution()))
   {

src/OpenGl/OpenGl_CappingPlaneResource.hxx

@@ -20,6 +20,7 @@
 #include <OpenGl_Resource.hxx>
 #include <OpenGl_Aspects.hxx>
 #include <OpenGl_Matrix.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 #include <Graphic3d_ClipPlane.hxx>
 
 class OpenGl_CappingPlaneResource;
@@ -30,16 +31,15 @@ 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 and assign style.
-  //! Create capping plane presentation associated to clipping plane data.
+  Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane,
-  //! @param thePlane [in] the plane data.
+                                               const Handle(Graphic3d_AspectFillCapping)& theAspect);
-  Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
 
   //! Destroy object.
   Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
@@ -50,6 +50,12 @@ public:
   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 myGraphicAspect; }
+
   //! Release associated OpenGl resources.
   //! @param theContext [in] the resource context.
   Standard_EXPORT virtual void Release (OpenGl_Context* theContext) Standard_OVERRIDE;
@@ -60,15 +66,33 @@ public:
   //! Return parent clipping plane structure.
   const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; }
 
+  //! @return primitive array of vertices to render infinite plane.
+  static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices();
+
   //! @return aspect face for rendering capping surface.
   inline const OpenGl_Aspects* AspectFace() const { return myAspect; }
 
+//! Returns true if capping should draw hatch layer.
+  Standard_Boolean ToDrawHatch() const 
+  {
+    return Aspect()->ToDrawHatch() 
+       && (Aspect()->IsStippleHatch()
+        || Aspect()->IsTextureHatch());
+  }
+
   //! @return evaluated orientation matrix to transform infinite plane.
   inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
 
+  //! 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;
+
   //! @return primitive array of vertices to render infinite plane.
   inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
 
+  //! Returns the shading aspect for drawing hatch layer of a section.
+  Standard_EXPORT const OpenGl_Aspects* HatchingFaceAspect() const;
+
 private:
 
   //! Update precomputed plane orientation matrix.
@@ -80,6 +104,7 @@ private:
 private:
 
   OpenGl_PrimitiveArray       myPrimitives;    //!< vertices and texture coordinates for rendering
+  Standard_Boolean            myPrimitivesUsed; //!< boolean flag if primitives are used
   OpenGl_Matrix               myOrientation;   //!< plane transformation matrix.
   OpenGl_Aspects*             myAspect;        //!< capping face aspect.
   Handle(Graphic3d_ClipPlane) myPlaneRoot;     //!< parent clipping plane structure.
@@ -88,6 +113,11 @@ private:
   unsigned int                myEquationMod;   //!< modification counter for plane equation.
   unsigned int                myAspectMod;     //!< modification counter for aspect.
 
+  Handle(Graphic3d_AspectFillCapping) myGraphicAspect;  //!< 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;
+
 public:
 
   DEFINE_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource) // Type definition

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 (NULL, 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;
@@ -99,6 +100,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; }
+
   //! Dumps the content of me into the stream
   Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
 
@@ -109,6 +121,7 @@ protected:
 protected:
 
   OpenGl_Aspects*     myAspects;
+  OpenGl_CappingPlaneResource* myAspectFillCapping;
   OpenGl_ElementNode* myFirst;
   OpenGl_ElementNode* myLast;
   Standard_Boolean    myIsRaytracable;

src/Prs3d/Prs3d_Drawer.cxx

@@ -15,6 +15,7 @@
 #include <Prs3d_Drawer.hxx>
 
 #include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
 #include <Graphic3d_AspectMarker3d.hxx>
 #include <Graphic3d_AspectText3d.hxx>
 #include <Prs3d_ArrowAspect.hxx>
@@ -105,7 +106,9 @@ Prs3d_Drawer::Prs3d_Drawer()
   myHasOwnDimLengthModelUnits   (Standard_False),
   myHasOwnDimAngleModelUnits    (Standard_False),
   myHasOwnDimLengthDisplayUnits (Standard_False),
-  myHasOwnDimAngleDisplayUnits  (Standard_False)
+  myHasOwnDimAngleDisplayUnits  (Standard_False),
+
+  myHasOwnFillCappingAspect     (Standard_False)
 {
   myDimensionModelUnits.SetLengthUnits ("m");
   myDimensionModelUnits.SetAngleUnits ("rad");
@@ -403,6 +406,27 @@ void Prs3d_Drawer::SetDimensionAspect (const Handle(Prs3d_DimensionAspect)& theA
   myHasOwnDimensionAspect = !myDimensionAspect.IsNull();
 }
 
+// =======================================================================
+// function : FillCappingAspect
+// purpose  :
+// =======================================================================
+
+const Handle(Graphic3d_AspectFillCapping)& Prs3d_Drawer::FillCappingAspect()
+{
+  return myFillCappingAspect;
+}
+
+// =======================================================================
+// function : SetFillCappingAspect
+// purpose  :
+// =======================================================================
+
+void Prs3d_Drawer::SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+  myFillCappingAspect = theAspect;
+  myHasOwnFillCappingAspect = !myFillCappingAspect.IsNull();
+}
+
 // =======================================================================
 // function : SetDimLengthModelUnits
 // purpose  :

src/Prs3d/Prs3d_Drawer.hxx

@@ -31,6 +31,7 @@
 #include <Standard_Transient.hxx>
 #include <GeomAbs_Shape.hxx>
 
+class Graphic3d_AspectFillCapping;
 class Prs3d_IsoAspect;
 class Prs3d_LineAspect;
 class Prs3d_TextAspect;
@@ -709,6 +710,16 @@ public:
   //! the appearance of dimensions that overrides the one in the link.
   Standard_Boolean HasOwnDimensionAspect() const { return myHasOwnDimensionAspect; }
 
+  //! Returns style for filling capping section created by clipping planes.
+  Standard_EXPORT const Handle(Graphic3d_AspectFillCapping)& FillCappingAspect();
+
+  //! Set style of filling capping section created by clipping planes.
+  Standard_EXPORT void SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+  //! Returns true if the drawer has its own attribute for
+  //! the appearance of dimensions that overrides the one in the link.
+  Standard_Boolean HasOwnFillCappingAspect() const { return myHasOwnFillCappingAspect; }
+
   //! Sets dimension length model units for computing of dimension presentation.
   //! The method sets value owned by the drawer that will be used during
   //! visualization instead of the one set in link.
@@ -912,6 +923,10 @@ protected:
   Prs3d_DimensionUnits          myDimensionDisplayUnits;
   Standard_Boolean              myHasOwnDimLengthDisplayUnits;
   Standard_Boolean              myHasOwnDimAngleDisplayUnits;
+
+  Handle(Graphic3d_AspectFillCapping) myFillCappingAspect;
+  Standard_Boolean              myHasOwnFillCappingAspect;
+
 };
 
 Standard_DEPRECATED("Class name is deprecated - use Prs3d_Drawer instead")

src/StdPrs/StdPrs_ShadedShape.cxx

@@ -285,6 +285,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,
@@ -300,6 +301,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;
   }
@@ -522,11 +526,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);
 }
 
 // =======================================================================
@@ -540,6 +545,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())
@@ -577,20 +583,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

@@ -9291,6 +9291,371 @@ namespace
   }
 }
 
+//===============================================================================================
+//function : setCappingParams
+//purpose  :
+//===============================================================================================
+static Standard_Boolean setCappingParams (const TCollection_AsciiString& theChangeArg,
+                                          const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
+                                          const char** theChangeArgs,
+                                          Standard_Integer aNbChangeArgs,
+                                          Standard_Integer& anArgIter)
+{
+  if (theCappingStyle.IsNull())
+    return Standard_False;
+
+  Standard_Boolean toEnable = Standard_True;
+  if (theChangeArg == "-useobjectmaterial"
+   || theChangeArg == "-useobjectmat"
+   || theChangeArg == "-useobjmat"
+   || theChangeArg == "-useobjmaterial")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+     {
+      theCappingStyle->SetUseObjectMaterial (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else if (theChangeArg == "-useobjecttexture"
+        || theChangeArg == "-useobjecttex"
+        || theChangeArg == "-useobjtexture"
+        || theChangeArg == "-useobjtex")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+    {
+      theCappingStyle->SetUseObjectTexture (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else if (theChangeArg == "-useobjectshader"
+        || theChangeArg == "-useobjshader")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+    {
+      theCappingStyle->SetUseObjectShader (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else if (theChangeArg == "-color"
+        || theChangeArg == "color")
+  {
+    Quantity_Color aColor;
+    Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+                                                         theChangeArgs + 1,
+                                                         aColor);
+    if (aNbParsed == 0)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Graphic3d_MaterialAspect aMat = theCappingStyle->Material();
+    aMat.SetAmbientColor (aColor);
+    aMat.SetDiffuseColor (aColor);
+    theCappingStyle->SetMaterial (aMat);
+    anArgIter += aNbParsed;
+  }
+  else if ((theChangeArg == "-transparency"
+          || theChangeArg == "-transp")
+        && aNbChangeArgs >= 2)
+  {
+    TCollection_AsciiString aValStr (theChangeArgs[1]);
+    if (aValStr.IsRealValue())
+    {
+      Graphic3d_MaterialAspect aMat = theCappingStyle->Material();
+      aMat.SetTransparency ((float )aValStr.RealValue());
+      theCappingStyle->SetMaterial (aMat);
+    }
+    else
+    {
+      std::cout << "Syntax error at '" << aValStr << "'\n";
+      return Standard_False;
+    }
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-texname"
+        || theChangeArg == "texname")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    TCollection_AsciiString aTextureName (theChangeArgs[1]);
+    Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+    if (!aTexture->IsDone())
+    {
+      theCappingStyle->SetTexture (Handle(Graphic3d_TextureMap)());
+    }
+    else
+    {
+      aTexture->EnableModulate();
+      aTexture->EnableRepeat();
+      theCappingStyle->SetTexture (aTexture.get());
+    }
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-texscale"
+        || theChangeArg == "texscale")
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 3)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+    aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+    anArgIter += 2;
+  }
+  else if (theChangeArg == "-texorigin"
+        || theChangeArg == "texorigin") // texture origin
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 3)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+
+    aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+    anArgIter += 2;
+  }
+  else if (theChangeArg == "-texrotate"
+        || theChangeArg == "texrotate") // texture rotation
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    aHatchTexture->GetParams()->SetRotation (aRot);
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-hatch"
+        || theChangeArg == "hatch")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+    {
+      theCappingStyle->SetToDrawHatch (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else if (theChangeArg == "-hatchtexture"
+        || theChangeArg == "hatchtexture")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    TCollection_AsciiString aTextureName (theChangeArgs[1]);
+    Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+    if (!aTexture->IsDone())
+    {
+      theCappingStyle->SetHatchStyle (Handle(Graphic3d_TextureMap)());
+    }
+    else
+    {
+      aTexture->EnableModulate();
+      aTexture->EnableRepeat();
+      theCappingStyle->SetHatchStyle (aTexture.get());
+      theCappingStyle->SetToDrawHatch (true);
+    }
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-hatchstipple"
+        || theChangeArg == "hatchstipple")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    theCappingStyle->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (theChangeArgs[1]));
+    theCappingStyle->SetToDrawHatch (true);
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-hatchcolor"
+        || theChangeArg == "hatchcolor")
+  {
+    Quantity_Color aColor;
+    Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+                                                          theChangeArgs + 1,
+                                                          aColor);
+    if (aNbParsed == 0)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Graphic3d_MaterialAspect aMat = theCappingStyle->HatchMaterial();
+    aMat.SetAmbientColor (aColor);
+    aMat.SetDiffuseColor (aColor);
+    theCappingStyle->SetHatchMaterial (aMat);
+    anArgIter += aNbParsed;
+  }
+
+  else if (theChangeArg == "-hatchscale"
+        || theChangeArg == "hatchscale")
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 3)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+    aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+    anArgIter += 2;
+  }
+  else if (theChangeArg == "-hatchorigin"
+        || theChangeArg == "hatchorigin") // texture origin
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 3)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+
+    aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+    anArgIter += 2;
+  }
+  else if (theChangeArg == "-hatchrotate"
+        || theChangeArg == "hatchrotate") // texture rotation
+  {
+    const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+    if (aHatchTexture.IsNull())
+    {
+      std::cout << "Error: no texture is set.\n";
+      return Standard_False;
+    }
+
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+    aHatchTexture->GetParams()->SetRotation (aRot);
+    anArgIter += 1;
+  }
+  else if (theChangeArg == "-hatchzoompers"
+        || theChangeArg == "hatchzoompers")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+    {
+      theCappingStyle->SetHatchZoomPeristent (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else if (theChangeArg == "-hatchrotatepers"
+        || theChangeArg == "hatchrotatepers")
+  {
+    if (aNbChangeArgs < 2)
+    {
+      std::cout << "Syntax error: need more arguments.\n";
+      return Standard_False;
+    }
+
+    if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+    {
+      theCappingStyle->SetHatchRotationPeristent (toEnable == Standard_True);
+      anArgIter += 1;
+    }
+  }
+  else
+  {
+    return Standard_False;
+  }
+
+  return Standard_True;
+}
+
 //===============================================================================================
 //function : VClipPlane
 //purpose  :
@@ -9587,10 +9952,8 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
         // just skip otherwise (old syntax)
       }
     }
-    else if (aChangeArg == "-useobjectmaterial"
+    else if (aChangeArg == "-overrideaspect"
-          || aChangeArg == "-useobjectmat"
+          || aChangeArg == "overrideaspect")
-          || aChangeArg == "-useobjmat"
-          || aChangeArg == "-useobjmaterial")
     {
       if (aNbChangeArgs < 2)
       {
@@ -9600,57 +9963,10 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
 
       if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
       {
-        aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+        aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
         anArgIter += 1;
       }
     }
-    else if (aChangeArg == "-useobjecttexture"
-          || aChangeArg == "-useobjecttex"
-          || aChangeArg == "-useobjtexture"
-          || aChangeArg == "-useobjtex")
-    {
-      if (aNbChangeArgs < 2)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
-      {
-        aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
-        anArgIter += 1;
-      }
-    }
-    else if (aChangeArg == "-useobjectshader"
-          || aChangeArg == "-useobjshader")
-    {
-      if (aNbChangeArgs < 2)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
-      {
-        aClipPlane->SetUseObjectShader (toEnable == Standard_True);
-        anArgIter += 1;
-      }
-    }
-    else if (aChangeArg == "-color"
-          || aChangeArg == "color")
-    {
-      Quantity_Color aColor;
-      Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
-                                                           aChangeArgs + 1,
-                                                           aColor);
-      if (aNbParsed == 0)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-      aClipPlane->SetCappingColor (aColor);
-      anArgIter += aNbParsed;
-    }
     else if (aNbChangeArgs >= 1
           && (aChangeArg == "-material"
            || aChangeArg == "material"))
@@ -9664,157 +9980,6 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
       }
       aClipPlane->SetCappingMaterial (aMatName);
     }
-    else if ((aChangeArg == "-transparency"
-           || aChangeArg == "-transp")
-          && aNbChangeArgs >= 2)
-    {
-      TCollection_AsciiString aValStr (aChangeArgs[1]);
-      Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
-      if (aValStr.IsRealValue())
-      {
-        Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
-        aMat.SetTransparency ((float )aValStr.RealValue());
-        anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
-        aClipPlane->SetCappingMaterial (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
-        {
-          Message::SendFail() << "Syntax error at '" << aValStr << "'";
-          return 1;
-        }
-        anAspect->SetAlphaMode (aMode);
-        aClipPlane->SetCappingAspect (anAspect);
-      }
-      anArgIter += 1;
-    }
-    else if (aChangeArg == "-texname"
-          || aChangeArg == "texname")
-    {
-      if (aNbChangeArgs < 2)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      TCollection_AsciiString aTextureName (aChangeArgs[1]);
-      Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
-      if (!aTexture->IsDone())
-      {
-        aClipPlane->SetCappingTexture (NULL);
-      }
-      else
-      {
-        aTexture->EnableModulate();
-        aTexture->EnableRepeat();
-        aClipPlane->SetCappingTexture (aTexture);
-      }
-      anArgIter += 1;
-    }
-    else if (aChangeArg == "-texscale"
-          || aChangeArg == "texscale")
-    {
-      if (aClipPlane->CappingTexture().IsNull())
-      {
-        Message::SendFail ("Error: no texture is set");
-        return 1;
-      }
-
-      if (aNbChangeArgs < 3)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      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));
-      anArgIter += 2;
-    }
-    else if (aChangeArg == "-texorigin"
-          || aChangeArg == "texorigin") // texture origin
-    {
-      if (aClipPlane->CappingTexture().IsNull())
-      {
-        Message::SendFail ("Error: no texture is set");
-        return 1;
-      }
-
-      if (aNbChangeArgs < 3)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      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));
-      anArgIter += 2;
-    }
-    else if (aChangeArg == "-texrotate"
-          || aChangeArg == "texrotate") // texture rotation
-    {
-      if (aClipPlane->CappingTexture().IsNull())
-      {
-        Message::SendFail ("Error: no texture is set");
-        return 1;
-      }
-
-      if (aNbChangeArgs < 2)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
-      aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
-      anArgIter += 1;
-    }
-    else if (aChangeArg == "-hatch"
-          || aChangeArg == "hatch")
-    {
-      if (aNbChangeArgs < 2)
-      {
-        Message::SendFail ("Syntax error: need more arguments");
-        return 1;
-      }
-
-      TCollection_AsciiString aHatchStr (aChangeArgs[1]);
-      aHatchStr.LowerCase();
-      if (aHatchStr == "on")
-      {
-        aClipPlane->SetCappingHatchOn();
-      }
-      else if (aHatchStr == "off")
-      {
-        aClipPlane->SetCappingHatchOff();
-      }
-      else
-      {
-        aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
-      }
-      anArgIter += 1;
-    }
     else if (aChangeArg == "-delete"
           || aChangeArg == "delete")
     {
@@ -9891,7 +10056,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
         anArgIter = anArgIter + anIt - 1;
       }
     }
-    else
+    else if (!setCappingParams (aChangeArg, aClipPlane->CappingSectionStyle(), aChangeArgs, aNbChangeArgs, anArgIter))
     {
       Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
       return 1;
@@ -9902,6 +10067,69 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
   return 0;
 }
 
+//===============================================================================================
+//function : VSetCapping
+//purpose  :
+//===============================================================================================
+static int VSetCapping (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+{
+  if (theArgsNb < 2)
+  {
+    std::cout << "Syntax error: the wrong number of input parameters.\n";
+    return 1;
+  }
+
+  TCollection_AsciiString aName (theArgVec[1]);
+  gp_Pln aWorkingPlane;
+  Standard_Boolean toUpdate = Standard_True;
+
+  NCollection_DataMap<TCollection_AsciiString, Standard_Real> aRealParams;
+  NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString> aStringParams;
+
+  Handle(AIS_InteractiveObject) anObject;
+  if (GetMapOfAIS().Find2 (aName, anObject))
+  {
+    if (anObject.IsNull())
+    {
+      std::cout << "Syntax error: no presentation with this name.\n";
+      return 1;
+    }
+  }
+
+  Handle(Graphic3d_AspectFillCapping) aFillCapping = anObject->Attributes()->FillCappingAspect();
+  for (Standard_Integer anArgIter = 2; anArgIter < theArgsNb; ++anArgIter)
+  {
+    const char** aChangeArgs = theArgVec + anArgIter;
+    Standard_Integer aNbChangeArgs = theArgsNb - anArgIter;
+    TCollection_AsciiString aChangeArg (aChangeArgs[0]);
+    aChangeArg.LowerCase();
+
+    Standard_Boolean toEnable = Standard_True;
+    if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable))
+    {
+      if (!toEnable)
+        anObject->Attributes()->SetFillCappingAspect (NULL);
+      else
+      {
+        if (aFillCapping.IsNull())
+        {
+          aFillCapping = new Graphic3d_AspectFillCapping();
+          anObject->Attributes()->SetFillCappingAspect (aFillCapping);
+        }
+      }
+    }
+    else if (!setCappingParams (aChangeArg, aFillCapping, aChangeArgs, aNbChangeArgs, anArgIter))
+    {
+      std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+      return 1;
+    }
+  }
+  ViewerTest::GetAISContext()->Redisplay (anObject, Standard_False);
+
+  return 0;
+}
+
+
 //===============================================================================================
 //function : VZRange
 //purpose  :
@@ -14634,6 +14862,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:"
@@ -14646,17 +14884,53 @@ 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",
       __FILE__, VClipPlane, group);
+
+  theCommands.Add("vsetcapping",
+                  "vsetcapping name [{0|1}]"
+      "\n\t\t: Sets capping parameters for all, selected or named objects."
+      "\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}       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",
+      __FILE__, VSetCapping, group);
+
   theCommands.Add("vdefaults",
                "vdefaults [-absDefl value]"
        "\n\t\t:           [-devCoeff value]"

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 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 -texname $aHatch -texscale 0.02 -0.02
+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