From: nds Date: Wed, 27 May 2020 20:10:07 +0000 (+0300) Subject: 0030791: Visualization - possibility to display materials by different hatching style... X-Git-Url: http://git.dev.opencascade.org/gitweb/?a=commitdiff_plain;h=73a6e5131157dbf5a9498e8f51b9263c50435752;p=occt-copy.git 0030791: Visualization - possibility to display materials by different hatching style for clipping (cherry picked from commit 63195be7104e23d0f2fbeab695e85c76bbe59e87) (cherry picked from commit 5243bcee98b19df97bc811e1bb5492dffb06cbd5) (cherry picked from commit d206845fcc1180a33783ef78074956c58e026a91) --- diff --git a/data/images/hatch_1.png b/data/images/hatch_1.png index 019d721321..83c0be624d 100644 Binary files a/data/images/hatch_1.png and b/data/images/hatch_1.png differ diff --git a/data/images/hatch_1_.png b/data/images/hatch_1_.png new file mode 100644 index 0000000000..4f7fc204be Binary files /dev/null and b/data/images/hatch_1_.png differ diff --git a/data/images/hatch_2.png b/data/images/hatch_2.png new file mode 100644 index 0000000000..0bf87b2f73 Binary files /dev/null and b/data/images/hatch_2.png differ diff --git a/data/images/hatch_3.png b/data/images/hatch_3.png new file mode 100644 index 0000000000..c89101b323 Binary files /dev/null and b/data/images/hatch_3.png differ diff --git a/data/images/hatch_4.png b/data/images/hatch_4.png new file mode 100644 index 0000000000..5e5839ac92 Binary files /dev/null and b/data/images/hatch_4.png differ diff --git a/data/images/hatch_5.png b/data/images/hatch_5.png new file mode 100644 index 0000000000..bf468b6ab0 Binary files /dev/null and b/data/images/hatch_5.png differ diff --git a/data/images/hatch_6.png b/data/images/hatch_6.png new file mode 100644 index 0000000000..7624d86e9f Binary files /dev/null and b/data/images/hatch_6.png differ diff --git a/data/images/hatch_7.png b/data/images/hatch_7.png new file mode 100644 index 0000000000..5f395a201b Binary files /dev/null and b/data/images/hatch_7.png differ diff --git a/data/images/hatch_8.png b/data/images/hatch_8.png new file mode 100644 index 0000000000..f580b76a6c Binary files /dev/null and b/data/images/hatch_8.png differ diff --git a/src/AIS/AIS_ColoredShape.cxx b/src/AIS/AIS_ColoredShape.cxx index 22b58730a0..24444aa598 100644 --- a/src/AIS/AIS_ColoredShape.cxx +++ b/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); diff --git a/src/AIS/AIS_InteractiveObject.cxx b/src/AIS/AIS_InteractiveObject.cxx index 52d203eb97..784194acd0 100644 --- a/src/AIS/AIS_InteractiveObject.cxx +++ b/src/AIS/AIS_InteractiveObject.cxx @@ -18,6 +18,7 @@ #include #include +#include #include #include #include diff --git a/src/AIS/AIS_Shape.cxx b/src/AIS/AIS_Shape.cxx index b1afa4ba80..997b86c1aa 100644 --- a/src/AIS/AIS_Shape.cxx +++ b/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, - myDrawer->ShadingAspect()->Aspect()->ToMapTexture() - && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(), - myUVOrigin, myUVRepeat, myUVScale); + StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myDrawer->FillCappingAspect()); } catch (Standard_Failure const& anException) { diff --git a/src/Graphic3d/FILES b/src/Graphic3d/FILES index 69e09418f2..d5b2299846 100755 --- a/src/Graphic3d/FILES +++ b/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 diff --git a/src/Graphic3d/Graphic3d_AspectFillCapping.cxx b/src/Graphic3d/Graphic3d_AspectFillCapping.cxx new file mode 100644 index 0000000000..6f0a9619e2 --- /dev/null +++ b/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 + +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, 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); +} diff --git a/src/Graphic3d/Graphic3d_AspectFillCapping.hxx b/src/Graphic3d/Graphic3d_AspectFillCapping.hxx new file mode 100644 index 0000000000..32aa2a7e2e --- /dev/null +++ b/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 +#include +#include +#include +#include +#include +#include + +//! 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, 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 diff --git a/src/Graphic3d/Graphic3d_ClipPlane.cxx b/src/Graphic3d/Graphic3d_ClipPlane.cxx index f248f4c523..2e463ff9cf 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.cxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.cxx @@ -57,6 +57,7 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane() myIsCapping (Standard_False) { makeId(); + init(); } // ======================================================================= @@ -77,9 +78,10 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation) myIsCapping (Standard_False) { makeId(); + init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a())); updateInversedPlane(); } - + // ======================================================================= // function : Graphic3d_ClipPlane // purpose : @@ -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 (myEquation[0]), + static_cast (myEquation[1]), + static_cast (myEquation[2]) + }; + + const Standard_ShortReal aTranslate[] = { + static_cast (myEquation[0] * -myEquation[3]), + static_cast (myEquation[1] * -myEquation[3]), + static_cast (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 (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()) { diff --git a/src/Graphic3d/Graphic3d_ClipPlane.hxx b/src/Graphic3d/Graphic3d_ClipPlane.hxx index cf692d11ec..aa5e1ab4fc 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.hxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.hxx @@ -19,9 +19,12 @@ #include #include #include +#include #include #include +#include #include +#include #include #include #include @@ -228,7 +231,7 @@ public: //! Return capping aspect. //! @return capping surface rendering aspect. const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; } - + //! Assign capping aspect. Standard_EXPORT void SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect); @@ -249,13 +252,23 @@ public: //! Flag indicating whether shader program for capping plane should be taken from object. //! Default value: FALSE. bool ToUseObjectShader() const { return (myFlags & Graphic3d_CappingFlags_ObjectShader) != 0; } - + //! Set flag for controlling the source of capping plane shader program. void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); } - + //! Return true if some fill area aspect properties should be taken from object. bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; } +public: + + //! 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. @@ -395,13 +408,35 @@ public: // @name modification counters } private: - + //! Generate unique object id for OpenGL graphic resource manager. void makeId(); - + //! 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). }; diff --git a/src/Graphic3d/Graphic3d_Group.hxx b/src/Graphic3d/Graphic3d_Group.hxx index fb6748302e..022656245d 100644 --- a/src/Graphic3d/Graphic3d_Group.hxx +++ b/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; diff --git a/src/Graphic3d/Graphic3d_GroupAspect.hxx b/src/Graphic3d/Graphic3d_GroupAspect.hxx index 6aff132f41..ca53a75a37 100644 --- a/src/Graphic3d/Graphic3d_GroupAspect.hxx +++ b/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 diff --git a/src/OpenGl/OpenGl_CappingAlgo.cxx b/src/OpenGl/OpenGl_CappingAlgo.cxx index 7a8fdec098..69d7ed2c92 100755 --- a/src/OpenGl/OpenGl_CappingAlgo.cxx +++ b/src/OpenGl/OpenGl_CappingAlgo.cxx @@ -21,11 +21,16 @@ #include #include #include +#include #include #include 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 (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. @@ -116,13 +235,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()) @@ -138,14 +268,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* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL; - thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)()); - theWorkspace->SetAspects (thePlane->AspectFace()); - theWorkspace->SetRenderFilter (aPrevFilter); - if (!theWorkspace->ShouldRender (&thePlane->Primitives())) + const OpenGl_Aspects* aGroupAspectFace = aGroupIter.Value()->GlAspects(); + const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping(); + const OpenGl_CappingPlaneResource* anAspectCapping = + thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect()) + ? thePlane.get() + : aGroupAspectCapping; + + if (anAspectCapping == NULL) { - 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 @@ -175,17 +324,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()) + { + aGroupIter.Value()->Render (theWorkspace); + } + else { - if (aGroupIter.Value()->IsClosed()) + for (; aGroupIter.More(); aGroupIter.Next()) { - aGroupIter.Value()->Render (theWorkspace); + if (aGroupIter.Value()->IsClosed()) + { + aGroupIter.Value()->Render (theWorkspace); + } } } } @@ -211,8 +368,63 @@ namespace glEnable (GL_DEPTH_TEST); } - theWorkspace->SetAspects (thePlane->AspectFace()); - renderPlane (theWorkspace, thePlane); + if (!hasHatch) + { + 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 (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 (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(); @@ -222,7 +434,7 @@ namespace if (theStructure.InstancedStructure() != NULL) { - renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane); + renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad); } } } @@ -241,6 +453,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(); @@ -249,6 +467,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()) { @@ -264,23 +492,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); diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.cxx b/src/OpenGl/OpenGl_CappingPlaneResource.cxx index 6825aefea1..6921cecf12 100755 --- a/src/OpenGl/OpenGl_CappingPlaneResource.cxx +++ b/src/OpenGl/OpenGl_CappingPlaneResource.cxx @@ -56,21 +56,28 @@ namespace { 0.0f, 0.0f, 0.0f, 1.0f } } }; + Handle(Graphic3d_Aspects) defaultMaterial() + { + Handle(Graphic3d_AspectFillArea3d) anAspect; + const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT); + anAspect = new Graphic3d_AspectFillArea3d(); + anAspect->SetDistinguishOff(); + anAspect->SetFrontMaterial (aMaterial); + anAspect->SetInteriorStyle (Aspect_IS_SOLID); + anAspect->SetInteriorColor (aMaterial.Color()); + anAspect->SetSuppressBackFaces (false); + return anAspect; + } } // ======================================================================= -// function : OpenGl_CappingPlaneResource +// function : BuildInfinitPlaneVertices // purpose : // ======================================================================= -OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane) -: myPrimitives (NULL), - myOrientation (OpenGl_IdentityMatrix), - myAspect (NULL), - myPlaneRoot (thePlane), - myEquationMod ((unsigned int )-1), - myAspectMod ((unsigned int )-1) +OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices() { + OpenGl_PrimitiveArray* aPrimitives = NULL; // Fill primitive array Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16); Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc); @@ -83,8 +90,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); - myPrimitives.Release (theContext); - myEquationMod = (unsigned int )-1; - myAspectMod = (unsigned int )-1; + if (myPrimitivesUsed) + { + OpenGl_Element::Destroy (theContext, myAspect); + 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(); @@ -145,7 +394,7 @@ void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& { myFillAreaAspect = new Graphic3d_AspectFillArea3d(); } - if (myAspectMod != myPlaneRoot->MCountAspect()) + if (myAspectMod != myPlaneRoot->MCountAspect()) { *myFillAreaAspect = *myPlaneRoot->CappingAspect(); } @@ -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())) { diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.hxx b/src/OpenGl/OpenGl_CappingPlaneResource.hxx index 9547b82b3e..0f55d06784 100755 --- a/src/OpenGl/OpenGl_CappingPlaneResource.hxx +++ b/src/OpenGl/OpenGl_CappingPlaneResource.hxx @@ -20,6 +20,7 @@ #include #include #include +#include #include 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 capping plane presentation associated to clipping plane data. - //! @param thePlane [in] the plane data. - Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane); + //! Create and assign style. + Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane, + const Handle(Graphic3d_AspectFillCapping)& theAspect); //! 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 diff --git a/src/OpenGl/OpenGl_Group.cxx b/src/OpenGl/OpenGl_Group.cxx index 9cdd80ac11..13965f5303 100644 --- a/src/OpenGl/OpenGl_Group.cxx +++ b/src/OpenGl/OpenGl_Group.cxx @@ -25,6 +25,7 @@ #include #include +#include #include 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); diff --git a/src/OpenGl/OpenGl_Group.hxx b/src/OpenGl/OpenGl_Group.hxx index cd76dd2399..98d84384a5 100644 --- a/src/OpenGl/OpenGl_Group.hxx +++ b/src/OpenGl/OpenGl_Group.hxx @@ -21,6 +21,7 @@ #include #include +#include #include 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; diff --git a/src/Prs3d/Prs3d_Drawer.cxx b/src/Prs3d/Prs3d_Drawer.cxx index 4d5e0a8891..ef854d803e 100644 --- a/src/Prs3d/Prs3d_Drawer.cxx +++ b/src/Prs3d/Prs3d_Drawer.cxx @@ -15,6 +15,7 @@ #include #include +#include #include #include #include @@ -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 : diff --git a/src/Prs3d/Prs3d_Drawer.hxx b/src/Prs3d/Prs3d_Drawer.hxx index 743b866995..1c13fa45d2 100644 --- a/src/Prs3d/Prs3d_Drawer.hxx +++ b/src/Prs3d/Prs3d_Drawer.hxx @@ -31,6 +31,7 @@ #include #include +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") diff --git a/src/StdPrs/StdPrs_ShadedShape.cxx b/src/StdPrs/StdPrs_ShadedShape.cxx index ca30cd58ac..6110878035 100644 --- a/src/StdPrs/StdPrs_ShadedShape.cxx +++ b/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); } diff --git a/src/StdPrs/StdPrs_ShadedShape.hxx b/src/StdPrs/StdPrs_ShadedShape.hxx index f65e762ce2..751dccf18f 100644 --- a/src/StdPrs/StdPrs_ShadedShape.hxx +++ b/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 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 diff --git a/src/ViewerTest/ViewerTest_ViewerCommands.cxx b/src/ViewerTest/ViewerTest_ViewerCommands.cxx index b6cf50dadc..6a6d7eee8b 100644 --- a/src/ViewerTest/ViewerTest_ViewerCommands.cxx +++ b/src/ViewerTest/ViewerTest_ViewerCommands.cxx @@ -9222,6 +9222,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 : @@ -9518,42 +9883,8 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons // just skip otherwise (old syntax) } } - else if (aChangeArg == "-useobjectmaterial" - || aChangeArg == "-useobjectmat" - || aChangeArg == "-useobjmat" - || aChangeArg == "-useobjmaterial") - { - if (aNbChangeArgs < 2) - { - Message::SendFail ("Syntax error: need more arguments"); - return 1; - } - - if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) - { - aClipPlane->SetUseObjectMaterial (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") + else if (aChangeArg == "-overrideaspect" + || aChangeArg == "overrideaspect") { if (aNbChangeArgs < 2) { @@ -9563,25 +9894,10 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { - aClipPlane->SetUseObjectShader (toEnable == Standard_True); + aClipPlane->SetToOverrideCappingAspect (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")) @@ -9595,157 +9911,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") { @@ -9822,7 +9987,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; @@ -9833,6 +9998,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 aRealParams; + NCollection_DataMap 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 : @@ -14565,6 +14793,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:" @@ -14577,17 +14815,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]" diff --git a/tests/bugs/vis/bug24224 b/tests/bugs/vis/bug24224 index 8ba33feb3b..17893134e4 100644 --- a/tests/bugs/vis/bug24224 +++ b/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 diff --git a/tests/bugs/vis/bug27751_capping b/tests/bugs/vis/bug27751_capping index b53e55edfd..db76f74b6a 100644 --- a/tests/bugs/vis/bug27751_capping +++ b/tests/bugs/vis/bug27751_capping @@ -71,5 +71,5 @@ vdisplay pp1 pp2 vzoom 0.8 puts "Enable capping planes" -vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -texname $aHatch -texscale 0.02 -0.02 -useObjMaterial 1 -vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -texname $aHatch -texscale 0.02 -0.02 +vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -hatchtexture $aHatch -hatchscale 0.02 -0.02 -useObjMaterial 1 +vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -hatchtexture $aHatch -hatchscale 0.02 -0.02