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/src/AIS/AIS_ColoredShape.cxx b/src/AIS/AIS_ColoredShape.cxx index f3396308d0..57f1caa255 100644 --- a/src/AIS/AIS_ColoredShape.cxx +++ b/src/AIS/AIS_ColoredShape.cxx @@ -618,6 +618,9 @@ void AIS_ColoredShape::addShapesWithCustomProps (const Handle(Prs3d_Presentation { aShadedGroup = Prs3d_Root::NewGroup (thePrs); aShadedGroup->SetClosed (isClosed); + if (isClosed + && !myCappingStyle.IsNull()) + aShadedGroup->SetGroupPrimitivesAspect (myCappingStyle); } aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect()); aShadedGroup->AddPrimitiveArray (aTriangles); diff --git a/src/AIS/AIS_InteractiveObject.cxx b/src/AIS/AIS_InteractiveObject.cxx index fba30b6cf0..99ffd16023 100644 --- a/src/AIS/AIS_InteractiveObject.cxx +++ b/src/AIS/AIS_InteractiveObject.cxx @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -277,6 +278,37 @@ void AIS_InteractiveObject::UnsetMaterial() hasOwnMaterial = Standard_False; } +//======================================================================= +//function : SetCappingStyle +//purpose : +//======================================================================= +void AIS_InteractiveObject::SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle) +{ + myCappingStyle = theStyle; + + // Modify existing presentations + for (Standard_Integer aPrsIter = 1, n = myPresentations.Length(); aPrsIter <= n; ++aPrsIter) + { + const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter).Presentation(); + if (!aPrs3d.IsNull()) + { + const Handle(Graphic3d_Structure)& aStruct = aPrs3d->Presentation(); + if (!aStruct.IsNull()) + { + const Graphic3d_SequenceOfGroup& aGroups = aStruct->Groups(); + for (Graphic3d_SequenceOfGroup::Iterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next()) + { + Handle(Graphic3d_Group)& aGrp = aGroupIter.ChangeValue(); + if (aGrp.IsNull()) + continue; + + aGrp->SetGroupPrimitivesAspect (theStyle); + } + } + } + } +} + //======================================================================= //function : SetTransparency //purpose : @@ -621,10 +653,11 @@ void AIS_InteractiveObject::SynchronizeAspects() continue; } - Handle(Graphic3d_AspectLine3d) aLineAspect = aGrp->LineAspect(); - Handle(Graphic3d_AspectFillArea3d) aFaceAspect = aGrp->FillAreaAspect(); - Handle(Graphic3d_AspectMarker3d) aMarkerAspect = aGrp->MarkerAspect(); - Handle(Graphic3d_AspectText3d) aTextAspect = aGrp->TextAspect(); + Handle(Graphic3d_AspectLine3d) aLineAspect = aGrp->LineAspect(); + Handle(Graphic3d_AspectFillArea3d) aFaceAspect = aGrp->FillAreaAspect(); + Handle(Graphic3d_AspectFillCapping) aCappingAspect = aGrp->FillCappingAspect(); + Handle(Graphic3d_AspectMarker3d) aMarkerAspect = aGrp->MarkerAspect(); + Handle(Graphic3d_AspectText3d) aTextAspect = aGrp->TextAspect(); if (!aLineAspect.IsNull()) { aGrp->SetGroupPrimitivesAspect (aLineAspect); @@ -633,6 +666,10 @@ void AIS_InteractiveObject::SynchronizeAspects() { aGrp->SetGroupPrimitivesAspect (aFaceAspect); } + if (!aCappingAspect.IsNull()) + { + aGrp->SetGroupPrimitivesAspect (aCappingAspect); + } if (!aMarkerAspect.IsNull()) { aGrp->SetGroupPrimitivesAspect (aMarkerAspect); @@ -641,6 +678,7 @@ void AIS_InteractiveObject::SynchronizeAspects() { aGrp->SetGroupPrimitivesAspect (aTextAspect); } + } } } diff --git a/src/AIS/AIS_InteractiveObject.hxx b/src/AIS/AIS_InteractiveObject.hxx index 17f7b07530..cf23ad627e 100644 --- a/src/AIS/AIS_InteractiveObject.hxx +++ b/src/AIS/AIS_InteractiveObject.hxx @@ -306,10 +306,16 @@ public: //! Material aspect determines shading aspect, color and //! transparency of visible entities. Standard_EXPORT virtual void SetMaterial (const Graphic3d_MaterialAspect& aName); - + //! Removes the setting for material. Standard_EXPORT virtual void UnsetMaterial(); - + + //! Set style of filling capping section created by clipping planes. + Standard_EXPORT virtual void SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle); + + //! Returns style for filling capping section created by clipping planes. + const Handle(Graphic3d_AspectFillCapping)& CappingStyle() const { return myCappingStyle; } + //! Attributes a setting aValue for transparency. //! The transparency value should be between 0.0 and 1.0. //! At 0.0 an object will be totally opaque, and at 1.0, fully transparent. @@ -416,7 +422,7 @@ protected: Standard_Boolean hasOwnColor; Standard_Boolean hasOwnMaterial; Standard_Boolean myRecomputeEveryPrs; - + Handle(Graphic3d_AspectFillCapping) myCappingStyle; }; DEFINE_STANDARD_HANDLE(AIS_InteractiveObject, SelectMgr_SelectableObject) diff --git a/src/AIS/AIS_Shape.cxx b/src/AIS/AIS_Shape.cxx index 5b6bff4ccf..6b87c358dc 100644 --- a/src/AIS/AIS_Shape.cxx +++ b/src/AIS/AIS_Shape.cxx @@ -186,10 +186,7 @@ void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentat try { OCC_CATCH_SIGNALS - StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, - myDrawer->ShadingAspect()->Aspect()->ToMapTexture() - && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(), - myUVOrigin, myUVRepeat, myUVScale); + StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myCappingStyle); } catch (Standard_Failure) { diff --git a/src/Graphic3d/FILES b/src/Graphic3d/FILES index 7ab013e31c..cd7c88d493 100755 --- a/src/Graphic3d/FILES +++ b/src/Graphic3d/FILES @@ -20,6 +20,8 @@ Graphic3d_ArrayOfTriangleStrips.cxx Graphic3d_ArrayOfTriangleStrips.hxx Graphic3d_AspectFillArea3d.cxx Graphic3d_AspectFillArea3d.hxx +Graphic3d_AspectFillCapping.cxx +Graphic3d_AspectFillCapping.hxx Graphic3d_AspectLine3d.cxx Graphic3d_AspectLine3d.hxx Graphic3d_AspectMarker3d.cxx @@ -38,7 +40,6 @@ Graphic3d_BufferType.hxx Graphic3d_Camera.cxx Graphic3d_Camera.hxx Graphic3d_CameraTile.hxx -Graphic3d_CappingFlags.hxx Graphic3d_CLight.hxx Graphic3d_ClipPlane.cxx Graphic3d_ClipPlane.hxx diff --git a/src/Graphic3d/Graphic3d_AspectFillCapping.cxx b/src/Graphic3d/Graphic3d_AspectFillCapping.cxx new file mode 100644 index 0000000000..3f6bff8042 --- /dev/null +++ b/src/Graphic3d/Graphic3d_AspectFillCapping.cxx @@ -0,0 +1,110 @@ +// Created on: 2017-04-14 +// Created by: Anton POLETAEV +// Copyright (c) 2017 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#include + +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++; +} diff --git a/src/Graphic3d/Graphic3d_AspectFillCapping.hxx b/src/Graphic3d/Graphic3d_AspectFillCapping.hxx new file mode 100644 index 0000000000..59ceb017cf --- /dev/null +++ b/src/Graphic3d/Graphic3d_AspectFillCapping.hxx @@ -0,0 +1,163 @@ +// 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 + +//! Defines graphical attributes for drawing section planes on solids resulted from clipping (cutting) planes. +class Graphic3d_AspectFillCapping : public Standard_Transient +{ +public: + + //! Default constructor. + Standard_EXPORT Graphic3d_AspectFillCapping(); + +public: + + //! Sets material for filling section created by clipping. + void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; } + + //! Returns material for filling section created by clipping. + const Graphic3d_MaterialAspect& Material() const { return myMaterial; } + + //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section. + void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); } + + //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section. + Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; } + + //! Sets texture for filling section created by clipping. + void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; } + + //! Returns texture for filling section created by clipping. + const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; } + + //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section. + void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); } + + //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section. + Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; } + + //! Sets OpenGL/GLSL shader program. + void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; } + + //! Returns OpenGL/GLSL shader program. + const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; } + + //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section. + void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); } + + //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section. + Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; } + +public: + + //! Sets style of hatch defined by predefined stipple mask. + Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle); + + //! Sets style of hatch defined by custom stipple mask. + Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle); + + //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used). + Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture); + + //! Sets material style for hatch lines (texture). + Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial); + + //! Returns material style for hatch lines (texture). + const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; } + + //! Sets boolean flag indicating whether the hatch layer should be drawn or not. + Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw); + + //! Returns boolean flag indicating whether the hatch layer should be drawn or not. + Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; } + + //! Sets flag controlling behavior of hatch texture mapping on zooming. + //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming. + Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet); + + //! Returns value of flag controlling behavior of hatch texture mapping on zooming. + Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; } + + //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector. + Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet); + + //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector. + Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; } + + //! Returns true if hatch is defined by texture. + Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); } + + //! Returns texture map defining the hatch. + const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; } + + //! Returns true if hatch is defined by stipple mask. + Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); } + + //! Returns the stipple mask. + const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; } + + //! Returns modification counter for hatching state. + Standard_Size HatchingState() const { return myHatchingState; } + +private: + + enum Flags + { + Flags_None = 0x00, //!< no flags + Flags_UseObjectMaterial = 0x01, //!< use object material + Flags_UseObjectTexture = 0x02, //!< use object texture + Flags_UseObjectShader = 0x04, //!< use object GLSL program + Flags_HatchZoomPersistent = 0x08, //!< zoom-persistent texturing + Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing + Flags_DrawHatching = 0x20, //!< draw hatching + Flags_UseObjectProperties = //!< use entire fill area aspect from object + Flags_UseObjectMaterial + | Flags_UseObjectTexture + | Flags_UseObjectShader + }; + + void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag) + { + myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag; + } + +private: + + Graphic3d_MaterialAspect myMaterial; + Handle(Graphic3d_TextureMap) myTexture; + Handle(Graphic3d_ShaderProgram) myShader; + Handle(Graphic3d_HatchStyle) myStippleHatch; + Handle(Graphic3d_TextureMap) myTextureHatch; + Graphic3d_MaterialAspect myHatchMaterial; + unsigned int myFlags; + Standard_Size myHatchingState; + +public: + + DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Standard_Transient) +}; + +DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Standard_Transient) + +#endif // _Graphic3d_AspectFillCapping_HeaderFile diff --git a/src/Graphic3d/Graphic3d_CappingFlags.hxx b/src/Graphic3d/Graphic3d_CappingFlags.hxx deleted file mode 100644 index f247b49846..0000000000 --- a/src/Graphic3d/Graphic3d_CappingFlags.hxx +++ /dev/null @@ -1,29 +0,0 @@ -// Created on: 2016-08-04 -// Copyright (c) 2016 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_CappingFlags_HeaderFile -#define _Graphic3d_CappingFlags_HeaderFile - -//! Enumeration of capping flags. -enum Graphic3d_CappingFlags -{ - Graphic3d_CappingFlags_None = 0x0000, //!< no flags - Graphic3d_CappingFlags_ObjectMaterial = 0x0001, //!< use object material - Graphic3d_CappingFlags_ObjectTexture = 0x0002, //!< use object texture - Graphic3d_CappingFlags_ObjectShader = 0x0008, //!< use object GLSL program - Graphic3d_CappingFlags_ObjectAspect = - Graphic3d_CappingFlags_ObjectMaterial | Graphic3d_CappingFlags_ObjectTexture | Graphic3d_CappingFlags_ObjectShader //!< use entire fill area aspect from object -}; - -#endif // _Graphic3d_CappingFlags_HeaderFile diff --git a/src/Graphic3d/Graphic3d_ClipPlane.cxx b/src/Graphic3d/Graphic3d_ClipPlane.cxx index 1524c946fa..96678bc40e 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.cxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.cxx @@ -19,24 +19,11 @@ #include #include -IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient) +IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane, Standard_Transient) namespace { static volatile Standard_Integer THE_CLIP_PLANE_COUNTER = 0; - - static Handle(Graphic3d_AspectFillArea3d) defaultAspect() - { - const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT); - Handle(Graphic3d_AspectFillArea3d) anAspect = new Graphic3d_AspectFillArea3d(); - anAspect->SetDistinguishOff(); - anAspect->SetFrontMaterial (aMaterial); - anAspect->SetHatchStyle (Aspect_HS_HORIZONTAL); - anAspect->SetInteriorStyle (Aspect_IS_SOLID); - anAspect->SetInteriorColor (aMaterial.Color()); - anAspect->SetSuppressBackFaces (false); - return anAspect; - } } // ======================================================================= @@ -44,69 +31,40 @@ namespace // purpose : // ======================================================================= Graphic3d_ClipPlane::Graphic3d_ClipPlane() -: myAspect (defaultAspect()), - myPlane (0.0, 0.0, 1.0, 0.0), - myEquation (0.0, 0.0, 1.0, 0.0), - myFlags (Graphic3d_CappingFlags_None), - myEquationMod(0), - myAspectMod (0), - myIsOn (Standard_True), - myIsCapping (Standard_False) { - makeId(); + init(); } // ======================================================================= // function : Graphic3d_ClipPlane // purpose : // ======================================================================= -Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Equation& theEquation) -: myAspect (defaultAspect()), - myPlane (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()), - myEquation (theEquation), - myFlags (Graphic3d_CappingFlags_None), - myEquationMod(0), - myAspectMod (0), - myIsOn (Standard_True), - myIsCapping (Standard_False) +Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Equation& theEquation) { - makeId(); + init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a())); } // ======================================================================= // function : Graphic3d_ClipPlane // purpose : // ======================================================================= -Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther) -: Standard_Transient(theOther), - myAspect (defaultAspect()), - myPlane (theOther.myPlane), - myEquation (theOther.myEquation), - myFlags (theOther.myFlags), - myEquationMod(0), - myAspectMod (0), - myIsOn (theOther.myIsOn), - myIsCapping (theOther.myIsCapping) +Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther) +: Standard_Transient (theOther) { - makeId(); - *myAspect = *theOther.CappingAspect(); + init (theOther.myPlane, + theOther.myIsOn, + theOther.myIsCapping, + theOther.ToOverrideCappingAspect(), + theOther.CappingSectionStyle()); } // ======================================================================= // function : Graphic3d_ClipPlane // purpose : // ======================================================================= -Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane) -: myAspect (defaultAspect()), - myPlane (thePlane), - myFlags (Graphic3d_CappingFlags_None), - myEquationMod(0), - myAspectMod (0), - myIsOn (Standard_True), - myIsCapping (Standard_False) +Graphic3d_ClipPlane::Graphic3d_ClipPlane (const gp_Pln& thePlane) { - thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); - makeId(); + init (thePlane); } // ======================================================================= @@ -115,23 +73,20 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane) // ======================================================================= void Graphic3d_ClipPlane::SetEquation (const Equation& theEquation) { - myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()); - myEquation = theEquation; - myEquationMod++; + myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()); + myEquation = theEquation; + myOrientationDirty = Standard_True; } // ======================================================================= -// function : SetPlane +// function : SetEquation // purpose : // ======================================================================= void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane) { myPlane = thePlane; - thePlane.Coefficients (myEquation[0], - myEquation[1], - myEquation[2], - myEquation[3]); - myEquationMod++; + thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); + myOrientationDirty = Standard_True; } // ======================================================================= @@ -162,117 +117,100 @@ Handle(Graphic3d_ClipPlane) Graphic3d_ClipPlane::Clone() const } // ======================================================================= -// function : SetCappingMaterial +// function : SetCappingSectionStyle // purpose : // ======================================================================= -void Graphic3d_ClipPlane::SetCappingMaterial (const Graphic3d_MaterialAspect& theMat) +void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle) { - myAspect->SetFrontMaterial (theMat); - myAspect->SetInteriorColor (theMat.Color()); - ++myAspectMod; + mySectionStyle = theStyle; } // ======================================================================= -// function : SetCappingTexture +// function : OrientationMatrix // purpose : // ======================================================================= -void Graphic3d_ClipPlane::SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture) +const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const { - if (!theTexture.IsNull()) + if (myOrientationDirty) { - myAspect->SetTextureMapOn(); - Handle(Graphic3d_TextureSet) aTextureSet = myAspect->TextureSet(); - if (aTextureSet.IsNull() || aTextureSet->Size() != 1) + const Standard_ShortReal aDirection[] = { + static_cast (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()) { - aTextureSet = new Graphic3d_TextureSet (theTexture); + aSide1[0] = 1.0f; } else { - aTextureSet->SetFirst (theTexture); + aSide1[0] = aDirection[2] / aMagintude; + aSide1[2] = -aDirection[0] / aMagintude; } - myAspect->SetTextureSet (aTextureSet); + + aSide2[0] = (-aSide1[1] * aDirection[2]) - (-aSide1[2] * aDirection[1]); + aSide2[1] = (-aSide1[2] * aDirection[0]) - (-aSide1[0] * aDirection[2]); + aSide2[2] = (-aSide1[0] * aDirection[1]) - (-aSide1[1] * aDirection[0]); + + myOrientationMat.SetValue (0, 0, aSide1[0]); + myOrientationMat.SetValue (1, 0, aSide1[1]); + myOrientationMat.SetValue (2, 0, aSide1[2]); + myOrientationMat.SetValue (3, 0, 0.0F); + + myOrientationMat.SetValue (0, 1, aDirection[0]); + myOrientationMat.SetValue (1, 1, aDirection[1]); + myOrientationMat.SetValue (2, 1, aDirection[2]); + myOrientationMat.SetValue (3, 1, 0.0F); + + myOrientationMat.SetValue (0, 2, aSide2[0]); + myOrientationMat.SetValue (1, 2, aSide2[1]); + myOrientationMat.SetValue (2, 2, aSide2[2]); + myOrientationMat.SetValue (3, 2, 0.0F); + + myOrientationMat.SetValue (0, 3, aTranslate[0]); + myOrientationMat.SetValue (1, 3, aTranslate[1]); + myOrientationMat.SetValue (2, 3, aTranslate[2]); + myOrientationMat.SetValue (3, 3, 1.0F); + + myOrientationDirty = Standard_False; } - else + + return myOrientationMat; +} + +// ======================================================================= +// function : init +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::init (const gp_Pln& thePlane, + const Standard_Boolean theIsOn, + const Standard_Boolean theIsCapping, + const Standard_Boolean theOverrideStyle, + const Handle(Graphic3d_AspectFillCapping)& theStyle) +{ + if (myEntityUID.IsEmpty()) { - myAspect->SetTextureMapOff(); - myAspect->SetTextureSet (Handle(Graphic3d_TextureSet)()); + myEntityUID = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name() + + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER)); } - ++myAspectMod; -} -// ======================================================================= -// function : SetCappingHatch -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::SetCappingHatch (const Aspect_HatchStyle theStyle) -{ - myAspect->SetHatchStyle (theStyle); - ++myAspectMod; -} - -// ======================================================================= -// function : SetCappingCustomHatch -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle) -{ - myAspect->SetHatchStyle (theStyle); - ++myAspectMod; -} - -// ======================================================================= -// function : SetCappingHatchOn -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::SetCappingHatchOn() -{ - myAspect->SetInteriorStyle (Aspect_IS_HATCH); - ++myAspectMod; -} - -// ======================================================================= -// function : SetCappingHatchOff -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::SetCappingHatchOff() -{ - myAspect->SetInteriorStyle (Aspect_IS_SOLID); - ++myAspectMod; -} - -// ======================================================================= -// function : SetCappingAspect -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect) -{ - myAspect = theAspect; - ++myAspectMod; -} - -// ======================================================================= -// function : setCappingFlag -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::setCappingFlag (bool theToUse, int theFlag) -{ - if (theToUse) - { - myFlags |= theFlag; - } - else - { - myFlags &= ~(theFlag); - } - ++myAspectMod; -} - -// ======================================================================= -// function : makeId -// purpose : -// ======================================================================= -void Graphic3d_ClipPlane::makeId() -{ - myId = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name() - + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER)); + myPlane = thePlane; + myPlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); + myIsOn = theIsOn; + myIsCapping = theIsCapping; + myOverrideObjectStyle = theOverrideStyle; + mySectionStyle = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle; + myOrientationDirty = Standard_True; } diff --git a/src/Graphic3d/Graphic3d_ClipPlane.hxx b/src/Graphic3d/Graphic3d_ClipPlane.hxx index 11058e3599..8c691bf1c8 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.hxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.hxx @@ -17,14 +17,16 @@ #define _Graphic3d_ClipPlane_HeaderFile #include -#include #include -#include +#include +#include #include +#include #include #include -#include #include +#include +#include //! Container for properties describing graphic driver clipping planes. //! It is up to application to create instances of this class and specify its @@ -45,6 +47,8 @@ public: typedef NCollection_Vec4 Equation; +public: + //! Default constructor. //! Initializes clip plane container with the following properties: //! - Equation (0.0, 0.0, 1.0, 0) @@ -58,7 +62,7 @@ public: //! Copy constructor. //! @param theOther [in] the copied plane. - Standard_EXPORT Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther); + Standard_EXPORT Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther); //! Construct clip plane for the passed equation. //! By default the plane is on, capping is turned off. @@ -82,37 +86,17 @@ public: //! Get 4-component equation vector for clipping plane. //! @return clipping plane equation vector. - const Equation& GetEquation() const - { - return myEquation; - } + const Equation& GetEquation() const { return myEquation; } //! Check that the clipping plane is turned on. //! @return boolean flag indicating whether the plane is in on or off state. - Standard_Boolean IsOn() const - { - return myIsOn; - } + Standard_Boolean IsOn() const { return myIsOn; } //! Change state of the clipping plane. //! @param theIsOn [in] the flag specifying whether the graphic driver //! clipping by this plane should be turned on or off. Standard_EXPORT void SetOn(const Standard_Boolean theIsOn); - //! Change state of capping surface rendering. - //! @param theIsOn [in] the flag specifying whether the graphic driver should - //! perform rendering of capping surface produced by this plane. The graphic - //! driver produces this surface for convex graphics by means of stencil-test - //! and multi-pass rendering. - Standard_EXPORT void SetCapping(const Standard_Boolean theIsOn); - - //! Check state of capping surface rendering. - //! @return true (turned on) or false depending on the state. - Standard_Boolean IsCapping() const - { - return myIsCapping; - } - //! Get geometrical definition. //! @return geometrical definition of clipping plane const gp_Pln& ToPlane() const { return myPlane; } @@ -123,47 +107,6 @@ public: //! @return new instance of clipping plane with same properties and attributes. Standard_EXPORT virtual Handle(Graphic3d_ClipPlane) Clone() const; -public: // @name user-defined graphical attributes - - //! Set material for rendering capping surface. - //! @param theMat [in] the material. - Standard_EXPORT void SetCappingMaterial (const Graphic3d_MaterialAspect& theMat); - - //! @return capping material. - const Graphic3d_MaterialAspect& CappingMaterial() const { return myAspect->FrontMaterial(); } - - //! Set texture to be applied on capping surface. - //! @param theTexture [in] the texture. - Standard_EXPORT void SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture); - - //! @return capping texture map. - Handle(Graphic3d_TextureMap) CappingTexture() const { return !myAspect->TextureSet().IsNull() && !myAspect->TextureSet()->IsEmpty() - ? myAspect->TextureSet()->First() - : Handle(Graphic3d_TextureMap)(); } - - //! Set hatch style (stipple) and turn hatching on. - //! @param theStyle [in] the hatch style. - Standard_EXPORT void SetCappingHatch (const Aspect_HatchStyle theStyle); - - //! @return hatching style. - Aspect_HatchStyle CappingHatch() const { return (Aspect_HatchStyle)myAspect->HatchStyle()->HatchType(); } - - //! Set custom hatch style (stipple) and turn hatching on. - //! @param theStyle [in] the hatch pattern. - Standard_EXPORT void SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle); - - //! @return hatching style. - const Handle(Graphic3d_HatchStyle)& CappingCustomHatch() const { return myAspect->HatchStyle(); } - - //! Turn on hatching. - Standard_EXPORT void SetCappingHatchOn(); - - //! Turn off hatching. - Standard_EXPORT void SetCappingHatchOff(); - - //! @return True if hatching mask is turned on. - Standard_Boolean IsHatchOn() const { return myAspect->InteriorStyle() == Aspect_IS_HATCH; } - //! This ID is used for managing associated resources in graphical driver. //! The clip plane can be assigned within a range of IO which can be //! displayed in separate OpenGl contexts. For each of the context an associated @@ -171,81 +114,61 @@ public: // @name user-defined graphical attributes //! The resources are stored in graphical driver for each of individual groups //! of shared context under the clip plane identifier. //! @return clip plane resource identifier string. - const TCollection_AsciiString& GetId() const - { - return myId; - } + const TCollection_AsciiString& GetId() const { return myEntityUID; } public: - //! Return capping aspect. - //! @return capping surface rendering aspect. - const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; } + //! Change state of capping surface rendering. + //! @param theIsOn [in] the flag specifying whether the graphic driver should + //! perform rendering of capping surface produced by this plane. The graphic + //! driver produces this surface for convex graphics by means of stencil-test + //! and multi-pass rendering. + Standard_EXPORT void SetCapping(const Standard_Boolean theIsOn); - //! Assign capping aspect. - Standard_EXPORT void SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect); + //! Check state of capping surface rendering. + //! @return true (turned on) or false depending on the state. + Standard_Boolean IsCapping() const { return myIsCapping; } - //! Flag indicating whether material for capping plane should be taken from object. - //! Default value: FALSE (use dedicated capping plane material). - bool ToUseObjectMaterial() const { return (myFlags & Graphic3d_CappingFlags_ObjectMaterial) != 0; } + //! Sets clipping section filling aspect. + Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle); - //! Set flag for controlling the source of capping plane material. - void SetUseObjectMaterial (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectMaterial); } + //! Returns style used for drawing capping section. + const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; } - //! Flag indicating whether texture for capping plane should be taken from object. - //! Default value: FALSE. - bool ToUseObjectTexture() const { return (myFlags & Graphic3d_CappingFlags_ObjectTexture) != 0; } + //! 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; } - //! Set flag for controlling the source of capping plane texture. - void SetUseObjectTexture (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectTexture); } + //! Sets flag for controlling the preference of using section style between clip plane and object. + void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; } - //! 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: // @name modification counters - - //! @return modification counter for equation. - unsigned int MCountEquation() const - { - return myEquationMod; - } - - //! @return modification counter for aspect. - unsigned int MCountAspect() const - { - return myAspectMod; - } + //! Returns plane's orientation matrix. + Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const; private: - //! Generate unique object id for OpenGL graphic resource manager. - void makeId(); - - //! Set capping flag. - Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag); + //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities. + void init (const gp_Pln& thePlane = gp_Pln(), + const 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)()); private: - Handle(Graphic3d_AspectFillArea3d) myAspect; //!< fill area aspect - TCollection_AsciiString myId; //!< resource id - gp_Pln myPlane; //!< plane definition - Equation myEquation; //!< plane equation vector - unsigned int myFlags; //!< capping flags - unsigned int myEquationMod; //!< modification counter for equation - unsigned int myAspectMod; //!< modification counter of aspect - Standard_Boolean myIsOn; //!< state of the clipping plane - Standard_Boolean myIsCapping; //!< state of graphic driver capping + TCollection_AsciiString myEntityUID; //!< Unique identifier for the plane + gp_Pln myPlane; //!< Plane definition + Equation myEquation; //!< Plane equation vector + 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 + Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section. + mutable Standard_Boolean myOrientationDirty; //!< Boolean flag indicating whether orientation matrix is dirty or not. + mutable Graphic3d_Mat4 myOrientationMat; //!< Plane orientation matrix (for visualization purposes). public: - DEFINE_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient) + DEFINE_STANDARD_RTTIEXT (Graphic3d_ClipPlane, Standard_Transient) }; DEFINE_STANDARD_HANDLE (Graphic3d_ClipPlane, Standard_Transient) diff --git a/src/Graphic3d/Graphic3d_Group.cxx b/src/Graphic3d/Graphic3d_Group.cxx index f19c62c647..86e0f20e05 100644 --- a/src/Graphic3d/Graphic3d_Group.cxx +++ b/src/Graphic3d/Graphic3d_Group.cxx @@ -231,10 +231,11 @@ Standard_Boolean Graphic3d_Group::IsGroupPrimitivesAspectSet (const Graphic3d_Gr // function : GroupPrimitivesAspect // purpose : // ======================================================================= -void Graphic3d_Group::GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine, - const Handle(Graphic3d_AspectText3d)& theAspText, - const Handle(Graphic3d_AspectMarker3d)& theAspMarker, - const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const +void Graphic3d_Group::GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine, + const Handle(Graphic3d_AspectText3d)& theAspText, + const Handle(Graphic3d_AspectMarker3d)& theAspMarker, + const Handle(Graphic3d_AspectFillArea3d)& theAspFill, + const Handle(Graphic3d_AspectFillCapping)& theAspCapping) const { if (!theAspLine.IsNull()) { @@ -271,6 +272,15 @@ void Graphic3d_Group::GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d *theAspFill.operator->() = *aFillAspect; } } + + if (!theAspCapping.IsNull()) + { + Handle(Graphic3d_AspectFillCapping) aCappingAspect = FillCappingAspect(); + if (!aCappingAspect.IsNull()) + { + *theAspCapping.operator->() = *aCappingAspect; + } + } } // ======================================================================= diff --git a/src/Graphic3d/Graphic3d_Group.hxx b/src/Graphic3d/Graphic3d_Group.hxx index 4e1c26f9de..0b63804174 100644 --- a/src/Graphic3d/Graphic3d_Group.hxx +++ b/src/Graphic3d/Graphic3d_Group.hxx @@ -17,30 +17,30 @@ #ifndef _Graphic3d_Group_HeaderFile #define _Graphic3d_Group_HeaderFile -#include -#include - -#include -#include -#include #include -#include +#include +#include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include #include -#include +#include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include +#include class Graphic3d_Structure; class Graphic3d_ArrayOfPrimitives; @@ -56,7 +56,7 @@ class Graphic3d_ArrayOfPrimitives; //! 1) Non-modifiable, or unbounded, group ('black box'). //! Developers can repeat a sequence of //! SetPrimitivesAspect() with AddPrimitiveArray() methods arbitrary number of times -//! to define arbitrary number of primitive "blocks" each having individual apect values. +//! to define arbitrary number of primitive "blocks" each having individual aspect values. //! Any modification of such a group is forbidden, as aspects and primitives are mixed //! in memory without any high-level logical structure, and any modification is very likely to result //! in corruption of the group internal data. @@ -75,14 +75,14 @@ class Graphic3d_ArrayOfPrimitives; //! with aspects and primitives and choose the group usage model beforehand out of application needs. //! Note that some Graphic3d_Group class virtual methods contain only base implementation //! that is extended by the descendant class in OpenGl package. -class Graphic3d_Group : public Standard_Transient +class Graphic3d_Group : public MMgt_TShared { friend class Graphic3d_Structure; - DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,Standard_Transient) + DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,MMgt_TShared) public: - //! Supress all primitives and attributes of . + //! Suppress all primitives and attributes of . //! To clear group without update in Graphic3d_StructureManager //! pass Standard_False as . This //! used on context and viewer destruction, when the pointer @@ -91,13 +91,13 @@ public: //! cross-reference); Standard_EXPORT virtual void Clear (const Standard_Boolean theUpdateStructureMgr = Standard_True); - //! Supress the group in the structure. + //! Suppress the group in the structure. Standard_EXPORT virtual ~Graphic3d_Group(); - //! Supress the group in the structure. + //! Suppress the group in the structure. //! Warning: No more graphic operations in after this call. - //! Modifies the current modelling transform persistence (pan, zoom or rotate) - //! Get the current modelling transform persistence (pan, zoom or rotate) + //! Modifies the current modeling transform persistence (pan, zoom or rotate) + //! Get the current modeling transform persistence (pan, zoom or rotate) Standard_EXPORT void Remove(); public: @@ -126,6 +126,12 @@ public: //! Modifies the context for all the marker primitives of the group. virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& theAspect) = 0; + //! Returns style of filling clipping sections on closed shell primitives. + virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const = 0; + + //! Modifies the context for filling clipping section for all closed shell primitives of the group. + virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) = 0; + //! Modifies the current context of the group to give //! another aspect for all the line primitives created //! after this call in the group. @@ -153,15 +159,17 @@ public: Standard_EXPORT void GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine, const Handle(Graphic3d_AspectText3d)& theAspText, const Handle(Graphic3d_AspectMarker3d)& theAspMarker, - const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const; + const Handle(Graphic3d_AspectFillArea3d)& theAspFill, + const Handle(Graphic3d_AspectFillCapping)& theAspFillCapping) const; //! Returns the last inserted context in the group for each kind of primitives. - void PrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine, - const Handle(Graphic3d_AspectText3d)& theAspText, - const Handle(Graphic3d_AspectMarker3d)& theAspMarker, - const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const + void PrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine, + const Handle(Graphic3d_AspectText3d)& theAspText, + const Handle(Graphic3d_AspectMarker3d)& theAspMarker, + const Handle(Graphic3d_AspectFillArea3d)& theAspFill, + const Handle(Graphic3d_AspectFillCapping)& theAspFillCapping) const { - GroupPrimitivesAspect (theAspLine, theAspText, theAspMarker, theAspFill); + GroupPrimitivesAspect (theAspLine, theAspText, theAspMarker, theAspFill, theAspFillCapping); } public: @@ -312,6 +320,6 @@ protected: }; -DEFINE_STANDARD_HANDLE(Graphic3d_Group, Standard_Transient) +DEFINE_STANDARD_HANDLE(Graphic3d_Group, MMgt_TShared) #endif // _Graphic3d_Group_HeaderFile diff --git a/src/Graphic3d/Graphic3d_GroupAspect.hxx b/src/Graphic3d/Graphic3d_GroupAspect.hxx index 6aff132f41..0fbe4bf6a3 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_LINE, + Graphic3d_ASPECT_TEXT, + Graphic3d_ASPECT_MARKER, + Graphic3d_ASPECT_FILL_AREA, + Graphic3d_ASPECT_FILL_CAPPING }; #endif // _Graphic3d_GroupAspect_HeaderFile diff --git a/src/NCollection/NCollection_Mat4.hxx b/src/NCollection/NCollection_Mat4.hxx index df74c37ff4..a67de2b94f 100755 --- a/src/NCollection/NCollection_Mat4.hxx +++ b/src/NCollection/NCollection_Mat4.hxx @@ -291,7 +291,7 @@ public: //! Compute per-element multiplication. //! @param theFactor [in] the scale factor. - //! @return the result of multiplicaton. + //! @return the result of multiplication. NCollection_Mat4 operator* (const Element_t theFactor) const { return Multiplied (theFactor); @@ -299,7 +299,7 @@ public: //! Compute per-element multiplication. //! @param theFactor [in] the scale factor. - //! @return the result of multiplicaton. + //! @return the result of multiplication. NCollection_Mat4 Multiplied (const Element_t theFactor) const { NCollection_Mat4 aTempMat (*this); diff --git a/src/OpenGl/FILES b/src/OpenGl/FILES index 61597805cd..9c459c59da 100755 --- a/src/OpenGl/FILES +++ b/src/OpenGl/FILES @@ -7,6 +7,8 @@ OpenGl_ArbTBO.hxx OpenGl_ArbTexBindless.hxx OpenGl_AspectFace.cxx OpenGl_AspectFace.hxx +OpenGl_AspectFillCapping.cxx +OpenGl_AspectFillCapping.hxx OpenGl_AspectLine.cxx OpenGl_AspectLine.hxx OpenGl_AspectMarker.cxx @@ -66,10 +68,8 @@ OpenGl_BVHClipPrimitiveTrsfPersSet.cxx OpenGl_BVHClipPrimitiveTrsfPersSet.hxx OpenGl_BVHTreeSelector.cxx OpenGl_BVHTreeSelector.hxx -OpenGl_CappingAlgo.cxx -OpenGl_CappingAlgo.hxx -OpenGl_CappingPlaneResource.cxx -OpenGl_CappingPlaneResource.hxx +OpenGl_CappingRenderer.cxx +OpenGl_CappingRenderer.hxx OpenGl_Caps.cxx OpenGl_Caps.hxx OpenGl_Clipping.cxx diff --git a/src/OpenGl/OpenGl_AspectFillCapping.cxx b/src/OpenGl/OpenGl_AspectFillCapping.cxx new file mode 100644 index 0000000000..da51650282 --- /dev/null +++ b/src/OpenGl/OpenGl_AspectFillCapping.cxx @@ -0,0 +1,247 @@ +// 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 + +#include +#include + +namespace +{ + Handle(Graphic3d_AspectFillArea3d) 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_AspectFillCapping +// purpose : +// ======================================================================= +OpenGl_AspectFillCapping::OpenGl_AspectFillCapping (const Handle(Graphic3d_AspectFillCapping)& theAspect) +: myCappingAspect (defaultMaterial()), + myHatchingAspect (defaultMaterial()), + myHatchingState (0) +{ + SetAspect (theAspect); +} + +// ======================================================================= +// function : ~OpenGl_AspectFillCapping +// purpose : +// ======================================================================= +OpenGl_AspectFillCapping::~OpenGl_AspectFillCapping() +{ + // +} + +// ======================================================================= +// function : SetAspect +// purpose : +// ======================================================================= +void OpenGl_AspectFillCapping::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) +{ + myAspect = theAspect; + + if (theAspect.IsNull()) + { + return; + } + + if (!theAspect->ToUseObjectMaterial() + || !theAspect->ToUseObjectTexture() + || !theAspect->ToUseObjectShader()) + { + Handle(Graphic3d_AspectFillArea3d) 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_AspectFillArea3d) 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(); + } +} + +// ======================================================================= +// function : Release +// purpose : +// ======================================================================= +void OpenGl_AspectFillCapping::Release (OpenGl_Context* theContext) +{ + myCappingAspect .Release (theContext); + myHatchingAspect.Release (theContext); +} + +// ======================================================================= +// function : CappingFaceAspect +// purpose : +// ======================================================================= +const OpenGl_AspectFace* OpenGl_AspectFillCapping::CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const +{ + if (myAspect.IsNull()) + { + return NULL; + } + + Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect.Aspect(); + + if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL) + { + // only front material currently supported by capping rendering + aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial()); + aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor()); + } + else + { + aFillAspect->SetFrontMaterial (myAspect->Material()); + aFillAspect->SetInteriorColor (myAspect->Material().Color()); + } + + if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL) + { + if (theObjectAspect->Aspect()->ToMapTexture()) + { + aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap()); + aFillAspect->SetTextureMapOn(); + } + else + { + aFillAspect->SetTextureMapOff(); + } + } + else + { + aFillAspect->SetTextureMap (myAspect->Texture()); + if (!myAspect->Texture().IsNull()) + { + aFillAspect->SetTextureMapOn(); + } + else + { + aFillAspect->SetTextureMapOff(); + } + } + + if (myAspect->ToUseObjectShader() && theObjectAspect != NULL) + { + aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram()); + } + else + { + aFillAspect->SetShaderProgram (myAspect->Shader()); + } + + myCappingAspect.SetAspect (aFillAspect); + + return &myCappingAspect; +} + +// ======================================================================= +// function : HatchingFaceAspect +// purpose : +// ======================================================================= +const OpenGl_AspectFace* OpenGl_AspectFillCapping::HatchingFaceAspect() const +{ + if (myAspect.IsNull()) + { + return NULL; + } + + const Standard_Size aHatchingState = myAspect->HatchingState(); + if (myHatchingState != aHatchingState) + { + if (myAspect->ToDrawHatch()) + { + Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect.Aspect(); + + aFillAspect->SetInteriorStyle (myAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID); + aFillAspect->SetHatchStyle (myAspect->IsStippleHatch() ? myAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)()); + aFillAspect->SetTextureMap (myAspect->IsTextureHatch() ? myAspect->TextureHatch() : Handle(Graphic3d_TextureMap)()); + aFillAspect->SetFrontMaterial (myAspect->HatchMaterial()); + aFillAspect->SetInteriorColor (myAspect->HatchMaterial().Color()); + if (myAspect->IsTextureHatch()) + { + aFillAspect->SetTextureMapOn(); + } + else + { + aFillAspect->SetTextureMapOff(); + } + + myHatchingAspect.SetAspect (aFillAspect); + myHatchingState = aHatchingState; + } + } + + return &myHatchingAspect; +} \ No newline at end of file diff --git a/src/OpenGl/OpenGl_AspectFillCapping.hxx b/src/OpenGl/OpenGl_AspectFillCapping.hxx new file mode 100644 index 0000000000..07261676e0 --- /dev/null +++ b/src/OpenGl/OpenGl_AspectFillCapping.hxx @@ -0,0 +1,70 @@ +// 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 _OpenGl_AspectFillCapping_Header +#define _OpenGl_AspectFillCapping_Header + +#include +#include +#include + +//! Gl resource holding particular aspects for filling capping. +class OpenGl_AspectFillCapping : public OpenGl_Resource +{ +public: + + //! Create and assign style. + Standard_EXPORT OpenGl_AspectFillCapping (const Handle(Graphic3d_AspectFillCapping)& theAspect); + + //! Destructor. + Standard_EXPORT ~OpenGl_AspectFillCapping(); + + //! Assign section style. + Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect); + + //! Returns section style parameters. + const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myAspect; } + + //! Release any allocated GL resources. + Standard_EXPORT virtual void Release (OpenGl_Context* theContext); + + //! Returns true if capping should draw hatch layer. + Standard_Boolean ToDrawHatch() const + { + return myAspect->ToDrawHatch() + && (myAspect->IsStippleHatch() + || myAspect->IsTextureHatch()); + } + + //! Returns the shading aspect for drawing face of a clipping section itself. + //! @param theObjectAspect [in] the aspect of an object if it requires combining. + Standard_EXPORT const OpenGl_AspectFace* CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const; + + //! Returns the shading aspect for drawing hatch layer of a section. + Standard_EXPORT const OpenGl_AspectFace* HatchingFaceAspect() const; + +protected: + + Handle(Graphic3d_AspectFillCapping) myAspect; //!< Section style settings from application's level. + mutable OpenGl_AspectFace myCappingAspect; //!< GL aspect for shading base layer of a capping section. + mutable OpenGl_AspectFace myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section. + mutable Standard_Size myHatchingState; + +public: + + DEFINE_STANDARD_ALLOC +}; + +#endif //_OpenGl_AspectFillCapping_Header diff --git a/src/OpenGl/OpenGl_BackgroundArray.hxx b/src/OpenGl/OpenGl_BackgroundArray.hxx index 8458736415..44c1af7530 100644 --- a/src/OpenGl/OpenGl_BackgroundArray.hxx +++ b/src/OpenGl/OpenGl_BackgroundArray.hxx @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include diff --git a/src/OpenGl/OpenGl_CappingAlgo.cxx b/src/OpenGl/OpenGl_CappingAlgo.cxx deleted file mode 100755 index 3ba9545632..0000000000 --- a/src/OpenGl/OpenGl_CappingAlgo.cxx +++ /dev/null @@ -1,235 +0,0 @@ -// Created on: 2013-09-05 -// Created by: Anton POLETAEV -// Copyright (c) 2013-2014 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 - -#include -#include -#include -#include -#include -#include -#include - -IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter) - -namespace -{ - //! Render infinite capping plane. - //! @param theWorkspace [in] the GL workspace, context state. - //! @param thePlane [in] the graphical plane, for which the capping surface is rendered. - static void renderPlane (const Handle(OpenGl_Workspace)& theWorkspace, - const Handle(OpenGl_CappingPlaneResource)& thePlane, - const OpenGl_AspectFace* theAspectFace) - { - const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); - thePlane->Update (aContext, theAspectFace != NULL ? theAspectFace->Aspect() : Handle(Graphic3d_AspectFillArea3d)()); - - const OpenGl_AspectFace* aFaceAspect = theWorkspace->AspectFace(); - theWorkspace->SetAspectFace (thePlane->AspectFace()); - - // set identity model matrix - aContext->ModelWorldState.Push(); - aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat)); - aContext->ApplyModelViewMatrix(); - - thePlane->Primitives().Render (theWorkspace); - - aContext->ModelWorldState.Pop(); - aContext->ApplyModelViewMatrix(); - - theWorkspace->SetAspectFace (aFaceAspect); - } - - //! Render capping for specific structure. - static void renderCappingForStructure (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_Structure& theStructure, - const OpenGl_ClippingIterator& thePlaneIter, - const Handle(OpenGl_CappingPlaneResource)& thePlane) - { - const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); - const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane(); - for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next()) - { - if (!aGroupIter.Value()->IsClosed()) - { - continue; - } - - // enable only the rendering plane to generate stencil mask - aContext->ChangeClipping().DisableAllExcept (aContext, thePlaneIter); - aContext->ShaderManager()->UpdateClippingState(); - - glClear (GL_STENCIL_BUFFER_BIT); - glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); - - // override aspects, disable culling - theWorkspace->SetAspectFace (&theWorkspace->NoneCulling()); - theWorkspace->ApplyAspectFace(); - - // evaluate number of pair faces - if (theWorkspace->UseZBuffer()) - { - glDisable (GL_DEPTH_TEST); - } - if (theWorkspace->UseDepthWrite()) - { - glDepthMask (GL_FALSE); - } - glStencilFunc (GL_ALWAYS, 1, 0x01); - glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT); - - // render closed primitives - if (aRenderPlane->ToUseObjectProperties()) - { - aGroupIter.Value()->Render (theWorkspace); - } - else - { - for (; aGroupIter.More(); aGroupIter.Next()) - { - if (aGroupIter.Value()->IsClosed()) - { - aGroupIter.Value()->Render (theWorkspace); - } - } - } - - // override material, cull back faces - theWorkspace->SetAspectFace (&theWorkspace->FrontCulling()); - theWorkspace->ApplyAspectFace(); - - // enable all clip plane except the rendered one - aContext->ChangeClipping().EnableAllExcept (aContext, thePlaneIter); - aContext->ShaderManager()->UpdateClippingState(); - - // render capping plane using the generated stencil mask - glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); - if (theWorkspace->UseDepthWrite()) - { - glDepthMask (GL_TRUE); - } - glStencilFunc (GL_EQUAL, 1, 0x01); - glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); - if (theWorkspace->UseZBuffer()) - { - glEnable (GL_DEPTH_TEST); - } - - renderPlane (theWorkspace, thePlane, aRenderPlane->ToUseObjectProperties() - ? aGroupIter.Value()->AspectFace() - : NULL); - - // turn on the current plane to restore initial state - aContext->ChangeClipping().SetEnabled (aContext, thePlaneIter, Standard_True); - aContext->ShaderManager()->RevertClippingState(); - aContext->ShaderManager()->RevertClippingState(); - } - - if (theStructure.InstancedStructure() != NULL) - { - renderCappingForStructure (theWorkspace, *theStructure.InstancedStructure(), thePlaneIter, thePlane); - } - } -} - -// ======================================================================= -// function : RenderCapping -// purpose : -// ======================================================================= -void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_Structure& theStructure) -{ - const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); - if (!aContext->Clipping().IsCappingOn()) - { - // do not perform algorithm if there is nothing to render - return; - } - - // remember current aspect face defined in workspace - const OpenGl_AspectFace* aFaceAsp = theWorkspace->AspectFace(); - - // replace primitive groups rendering filter - Handle(OpenGl_RenderFilter) aRenderFilter = theWorkspace->GetRenderFilter(); - Handle(OpenGl_CappingAlgoFilter) aCappingFilter = theWorkspace->DefaultCappingAlgoFilter(); - aCappingFilter->SetPreviousFilter (aRenderFilter); - theWorkspace->SetRenderFilter (aCappingFilter); - - // prepare for rendering the clip planes - glEnable (GL_STENCIL_TEST); - - // remember current state of depth - // function and change its value - GLint aDepthFuncPrev; - glGetIntegerv (GL_DEPTH_FUNC, &aDepthFuncPrev); - glDepthFunc (GL_LESS); - - // generate capping for every clip plane - for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next()) - { - // get plane being rendered - const Handle(Graphic3d_ClipPlane)& aRenderPlane = aCappingIt.Value(); - if (!aRenderPlane->IsCapping() - || aCappingIt.IsDisabled()) - { - continue; - } - - // get resource for the plane - const TCollection_AsciiString& aResId = aRenderPlane->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 (aRenderPlane); - aContext->ShareResource (aResId, aPlaneRes); - } - - renderCappingForStructure (theWorkspace, theStructure, aCappingIt, aPlaneRes); - - // set delayed resource release - aPlaneRes.Nullify(); - aContext->ReleaseResource (aResId, Standard_True); - } - - // restore previous application state - glClear (GL_STENCIL_BUFFER_BIT); - glDepthFunc (aDepthFuncPrev); - glStencilFunc (GL_ALWAYS, 0, 0xFF); - glDisable (GL_STENCIL_TEST); - - // restore rendering aspects - theWorkspace->SetAspectFace (aFaceAsp); - theWorkspace->SetRenderFilter (aRenderFilter); -} - -// ======================================================================= -// function : CanRender -// purpose : -// ======================================================================= -Standard_Boolean OpenGl_CappingAlgoFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_Element* theGlElement) -{ - if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement)) - { - return Standard_False; - } - - const OpenGl_PrimitiveArray* aPArray = dynamic_cast (theGlElement); - return aPArray != NULL - && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM - && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO; -} diff --git a/src/OpenGl/OpenGl_CappingAlgo.hxx b/src/OpenGl/OpenGl_CappingAlgo.hxx deleted file mode 100755 index e936779d8c..0000000000 --- a/src/OpenGl/OpenGl_CappingAlgo.hxx +++ /dev/null @@ -1,71 +0,0 @@ -// Created on: 2013-09-05 -// Created by: Anton POLETAEV -// Copyright (c) 2013-2014 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 _OpenGl_CappingAlgo_H__ -#define _OpenGl_CappingAlgo_H__ - -#include -#include - -// Forward declaration -class OpenGl_CappingAlgoFilter; -class OpenGl_CappingPlaneResource; -class OpenGl_Structure; - -DEFINE_STANDARD_HANDLE (OpenGl_CappingAlgoFilter, OpenGl_RenderFilter) - -//! Capping surface rendering algorithm. -class OpenGl_CappingAlgo -{ -public: - - //! Draw capping surfaces by OpenGl for the clipping planes enabled in current context state. - //! Depth buffer must be generated for the passed groups. - //! @param theWorkspace [in] the GL workspace, context state - //! @param theStructure [in] the structure to be capped - Standard_EXPORT static void RenderCapping (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_Structure& theStructure); - -}; - -//! Graphical capping rendering algorithm filter. -//! Filters out everything except shaded primitives. -class OpenGl_CappingAlgoFilter : public OpenGl_RenderFilter -{ -public: - - //! Default constructor. - OpenGl_CappingAlgoFilter() {} - - //! Sets the current active filter in workspace. - //! @param thePrevFilter [in] the previously active filter that should have additive effect. - void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; } - - //! Checks whether the element can be rendered or not. - //! @param theElement [in] the element to check. - //! @return True if element can be rendered. - virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_Element* theGlElement) Standard_OVERRIDE; - -private: - - Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined. - -public: - - DEFINE_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter) -}; - -#endif diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.cxx b/src/OpenGl/OpenGl_CappingPlaneResource.cxx deleted file mode 100755 index a4b77939d1..0000000000 --- a/src/OpenGl/OpenGl_CappingPlaneResource.cxx +++ /dev/null @@ -1,244 +0,0 @@ -// Created on: 2013-08-15 -// Created by: Anton POLETAEV -// Copyright (c) 2013-2014 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 -#include -#include -#include -#include - -IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource) - -namespace -{ - //! 12 plane vertices, interleaved: - //! - 4 floats, position - //! - 4 floats, normal - //! - 4 floats, UV texture coordinates - static const GLfloat THE_CAPPING_PLN_VERTS[12 * (4 + 4 + 4)] = - { - 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, - 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, - 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, - -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, - -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, - - 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, - 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, - 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f - }; - - static const OpenGl_Matrix OpenGl_IdentityMatrix = - { - // mat[4][4] - { { 1.0f, 0.0f, 0.0f, 0.0f }, - { 0.0f, 1.0f, 0.0f, 0.0f }, - { 0.0f, 0.0f, 1.0f, 0.0f }, - { 0.0f, 0.0f, 0.0f, 1.0f } } - }; - -} - - -// ======================================================================= -// function : OpenGl_CappingPlaneResource -// 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) -{ - // 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); - } -} - -// ======================================================================= -// function : OpenGl_CappingPlaneResource -// purpose : -// ======================================================================= -OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource() -{ - Release (NULL); -} - -// ======================================================================= -// function : Update -// purpose : -// ======================================================================= -void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& , - const Handle(Graphic3d_AspectFillArea3d)& theObjAspect) -{ - updateTransform(); - updateAspect (theObjAspect); -} - -// ======================================================================= -// function : Release -// purpose : -// ======================================================================= -void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext) -{ - OpenGl_Element::Destroy (theContext, myAspect); - myPrimitives.Release (theContext); - myEquationMod = (unsigned int )-1; - myAspectMod = (unsigned int )-1; -} - -// ======================================================================= -// function : updateAspect -// purpose : -// ======================================================================= -void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_AspectFillArea3d)& theObjAspect) -{ - if (myAspect == NULL) - { - myAspect = new OpenGl_AspectFace(); - myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync - } - - if (theObjAspect.IsNull()) - { - if (myAspectMod != myPlaneRoot->MCountAspect()) - { - myAspect->SetAspect (myPlaneRoot->CappingAspect()); - myAspectMod = myPlaneRoot->MCountAspect(); - } - return; - } - - if (myFillAreaAspect.IsNull()) - { - myFillAreaAspect = new Graphic3d_AspectFillArea3d(); - } - if (myAspectMod != myPlaneRoot->MCountAspect()) - { - *myFillAreaAspect = *myPlaneRoot->CappingAspect(); - } - - if (myPlaneRoot->ToUseObjectMaterial()) - { - // only front material currently supported by capping rendering - myFillAreaAspect->SetFrontMaterial (theObjAspect->FrontMaterial()); - myFillAreaAspect->SetInteriorColor (theObjAspect->InteriorColor()); - } - if (myPlaneRoot->ToUseObjectTexture()) - { - myFillAreaAspect->SetTextureSet (theObjAspect->TextureSet()); - if (theObjAspect->ToMapTexture()) - { - myFillAreaAspect->SetTextureMapOn(); - } - else - { - myFillAreaAspect->SetTextureMapOff(); - } - } - if (myPlaneRoot->ToUseObjectShader()) - { - myFillAreaAspect->SetShaderProgram (theObjAspect->ShaderProgram()); - } - - myAspect->SetAspect (myFillAreaAspect); -} - -// ======================================================================= -// function : updateTransform -// purpose : -// ======================================================================= -void OpenGl_CappingPlaneResource::updateTransform() -{ - const Graphic3d_ClipPlane::Equation& anEquation = myPlaneRoot->GetEquation(); - if (myEquationMod == myPlaneRoot->MCountEquation()) - { - return; // nothing to update - } - - // re-evaluate infinite plane transformation matrix - Standard_ShortReal N[3] = - { (Standard_ShortReal)anEquation[0], - (Standard_ShortReal)anEquation[1], - (Standard_ShortReal)anEquation[2] }; - - Standard_ShortReal T[3] = - { (Standard_ShortReal)(anEquation[0] * -anEquation[3]), - (Standard_ShortReal)(anEquation[1] * -anEquation[3]), - (Standard_ShortReal)(anEquation[2] * -anEquation[3]) }; - - Standard_ShortReal L[3] = { 0.0f, 0.0f, 0.0f }; - Standard_ShortReal F[3] = { 0.0f, 0.0f, 0.0f }; - - // project plane normal onto OX to find left vector - Standard_ShortReal aProjLen = - sqrt ( (Standard_ShortReal)(anEquation[0] * anEquation[0]) - + (Standard_ShortReal)(anEquation[2] * anEquation[2])); - if (aProjLen < ShortRealSmall()) - { - L[0] = 1.0f; - } - else - { - L[0] = N[2] / aProjLen; - L[2] = -N[0] / aProjLen; - } - - // (-aLeft) x aNorm - F[0] = (-L[1])*N[2] - (-L[2])*N[1]; - F[1] = (-L[2])*N[0] - (-L[0])*N[2]; - F[2] = (-L[0])*N[1] - (-L[1])*N[0]; - - myOrientation.mat[0][0] = L[0]; - myOrientation.mat[0][1] = L[1]; - myOrientation.mat[0][2] = L[2]; - myOrientation.mat[0][3] = 0.0f; - - myOrientation.mat[1][0] = N[0]; - myOrientation.mat[1][1] = N[1]; - myOrientation.mat[1][2] = N[2]; - myOrientation.mat[1][3] = 0.0f; - - myOrientation.mat[2][0] = F[0]; - myOrientation.mat[2][1] = F[1]; - myOrientation.mat[2][2] = F[2]; - myOrientation.mat[2][3] = 0.0f; - - myOrientation.mat[3][0] = T[0]; - myOrientation.mat[3][1] = T[1]; - myOrientation.mat[3][2] = T[2]; - myOrientation.mat[3][3] = 1.0f; - - myEquationMod = myPlaneRoot->MCountEquation(); -} diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.hxx b/src/OpenGl/OpenGl_CappingPlaneResource.hxx deleted file mode 100755 index 43b4c115b8..0000000000 --- a/src/OpenGl/OpenGl_CappingPlaneResource.hxx +++ /dev/null @@ -1,93 +0,0 @@ -// Created on: 2013-08-15 -// Created by: Anton POLETAEV -// Copyright (c) 2013-2014 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 _OpenGl_CappingPlaneResource_H__ -#define _OpenGl_CappingPlaneResource_H__ - -#include -#include -#include -#include -#include - -class OpenGl_CappingPlaneResource; -DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource) - -//! Container of graphical resources for rendering capping plane -//! associated to graphical clipping plane. -//! 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. -//! - 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); - - //! Destroy object. - Standard_EXPORT virtual ~OpenGl_CappingPlaneResource(); - - //! Update resource data in the passed context. - //! @param theContext [in] the context - //! @param theObjAspect [in] object aspect - Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext, - const Handle(Graphic3d_AspectFillArea3d)& theObjAspect); - - //! Release associated OpenGl resources. - //! @param theContext [in] the resource context. - Standard_EXPORT virtual void Release (OpenGl_Context* theContext) Standard_OVERRIDE; - - //! Return parent clipping plane structure. - const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; } - - //! @return aspect face for rendering capping surface. - inline const OpenGl_AspectFace* AspectFace() const { return myAspect; } - - //! @return evaluated orientation matrix to transform infinite plane. - inline const OpenGl_Matrix* Orientation() const { return &myOrientation; } - - //! @return primitive array of vertices to render infinite plane. - inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; } - -private: - - //! Update precomputed plane orientation matrix. - void updateTransform(); - - //! Update resources. - void updateAspect (const Handle(Graphic3d_AspectFillArea3d)& theObjAspect); - -private: - - OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering - OpenGl_Matrix myOrientation; //!< plane transformation matrix. - OpenGl_AspectFace* myAspect; //!< capping face aspect. - Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure. - Handle(Graphic3d_AspectFillArea3d) myFillAreaAspect; //!< own capping aspect - unsigned int myEquationMod; //!< modification counter for plane equation. - unsigned int myAspectMod; //!< modification counter for aspect. - -public: - - DEFINE_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource) // Type definition - -}; - -#endif diff --git a/src/OpenGl/OpenGl_CappingRenderer.cxx b/src/OpenGl/OpenGl_CappingRenderer.cxx new file mode 100644 index 0000000000..d5e0e65075 --- /dev/null +++ b/src/OpenGl/OpenGl_CappingRenderer.cxx @@ -0,0 +1,447 @@ +// Created on: 2013-09-05 +// Created by: Anton POLETAEV +// Copyright (c) 2013-2014 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingRenderFilter, OpenGl_RenderFilter) + +namespace +{ + //! interleaved (4x position, 4x normals, 4x (u,v) coordinates). + //! o ----o + //! representing | \ / | + //! these | o | + //! triangles: | / \ | + //! o --- o + static const GLfloat THE_CAPPING_PLN_VERTS[12 * (4 + 4 + 4)] = + { + 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, + -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + + 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f + }; + + 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; } + + private: + OpenGl_Element* myGlElement; + + public: + + DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource) + }; + + + static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingRenderer_Quad"; + static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingRenderer_CappingStyle_"; + static const OpenGl_AspectFillCapping THE_DEFAULT_ASPECT = OpenGl_AspectFillCapping (new Graphic3d_AspectFillCapping); +} + +// ======================================================================= +// function : Render +// purpose : Renders capping surfaces for enabled clipping planes. +// ======================================================================= +void OpenGl_CappingRenderer::Render (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Structure& theStructure) +{ + const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); + if (!aContext->Clipping().IsCappingOn()) + { + return; + } + + const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext); + if (!aCappingQuad) + { + return; + } + + const OpenGl_AspectFace* aPrevAspect = theWorkspace->AspectFace(); + Handle(OpenGl_RenderFilter) aPrevFilter = theWorkspace->GetRenderFilter(); + Handle(OpenGl_CappingRenderFilter) aCappingFilter = theWorkspace->CappingRenderFilter(); + aCappingFilter->SetPreviousFilter (aPrevFilter); + + theWorkspace->SetRenderFilter (aCappingFilter); + + GLint aDepthFuncPrev; + glGetIntegerv (GL_DEPTH_FUNC, &aDepthFuncPrev); + glDepthFunc (GL_LESS); + glEnable (GL_STENCIL_TEST); + + 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); + } + + for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next()) + { + const Handle(Graphic3d_ClipPlane)& aPlane = aCappingIt.Value(); + if (!aPlane->IsCapping() + || aCappingIt.IsDisabled()) + { + continue; + } + + Handle(OpenGl_AspectFillCapping) anAspect; + + TCollection_AsciiString aSharedStyleId; + if (!aPlane->CappingSectionStyle().IsNull()) + { + aSharedStyleId = THE_PLANE_STYLE + aPlane->GetId(); + + if (!aContext->GetResource (aSharedStyleId, anAspect)) + { + anAspect = new OpenGl_AspectFillCapping (aPlane->CappingSectionStyle()); + aContext->ShareResource (aSharedStyleId, anAspect); + } + } + + renderOne (theWorkspace, theStructure, aCappingIt, anAspect.get(), aCappingQuad); + + if (!aSharedStyleId.IsEmpty()) + { + // schedule release of resource if not used + aContext->ReleaseResource (aSharedStyleId, Standard_True); + } + } + + glClear (GL_STENCIL_BUFFER_BIT); + glDepthFunc (aDepthFuncPrev); + glStencilFunc (GL_ALWAYS, 0, 0xFF); + glDisable (GL_STENCIL_TEST); + + if (aPrevBlend == GL_TRUE) + { + glEnable (GL_BLEND); + glBlendFunc (aPrevBlendSrc, aPrevBlendDst); + } + + theWorkspace->SetRenderFilter (aPrevFilter); + theWorkspace->SetAspectFace (aPrevAspect); +} + +// ======================================================================= +// function : renderOne +// purpose : method to render capping section of one given plane for a structure. +// ======================================================================= +void OpenGl_CappingRenderer::renderOne (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Structure& theStructure, + const OpenGl_ClippingIterator& thePlaneIter, + const OpenGl_AspectFillCapping* thePlaneAspectCapping, + const OpenGl_PrimitiveArray* theQuad) +{ + const Handle(Graphic3d_ClipPlane)& aPlane = thePlaneIter.Value(); + const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); + 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()) + { + continue; + } + + // enable only the rendering plane to generate stencil mask + aContext->ChangeClipping().DisableAllExcept (aContext, thePlaneIter); + aContext->ShaderManager()->UpdateClippingState(); + + glClear (GL_STENCIL_BUFFER_BIT); + glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + + // override aspects, disable culling + theWorkspace->SetAspectFace (&theWorkspace->NoneCulling()); + theWorkspace->ApplyAspectFace(); + + // evaluate number of pair faces + if (theWorkspace->UseZBuffer()) + { + glDisable (GL_DEPTH_TEST); + } + if (theWorkspace->UseDepthWrite()) + { + glDepthMask (GL_FALSE); + } + glStencilFunc (GL_ALWAYS, 1, 0x01); + glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT); + + aGroupIter.Value()->Render (theWorkspace); + + // override material, cull back faces + theWorkspace->SetAspectFace (&theWorkspace->FrontCulling()); + theWorkspace->ApplyAspectFace(); + + // enable all clip plane except the rendered one + aContext->ChangeClipping().EnableAllExcept (aContext, thePlaneIter); + aContext->ShaderManager()->UpdateClippingState(); + + // render capping plane using the generated stencil mask + glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + if (theWorkspace->UseDepthWrite()) + { + glDepthMask (GL_TRUE); + } + glStencilFunc (GL_EQUAL, 1, 0x01); + glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP); + if (theWorkspace->UseZBuffer()) + { + glEnable (GL_DEPTH_TEST); + } + + const OpenGl_AspectFace* aGroupAspectFace = aGroupIter.Value()->AspectFace(); + const OpenGl_AspectFillCapping* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping(); + const OpenGl_AspectFillCapping* anAspectCapping = + thePlaneAspectCapping && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect()) + ? thePlaneAspectCapping + : aGroupAspectCapping; + + if (anAspectCapping == NULL) + { + anAspectCapping = &THE_DEFAULT_ASPECT; + } + + const OpenGl_AspectFace* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace); + const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch(); + const OpenGl_AspectFace* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL; + const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull(); + const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent(); + const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent(); + + Standard_ShortReal aHatchScale = 1.0; + Standard_ShortReal aHatchAngle = 0.0; + + if (isRotatePers || isZoomPers) + { + + if (isRotatePers) + { + if (aRotateAngle == 0.0) + { + const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0)); + const gp_Dir aPlaneUp (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2)); + const gp_Dir& aCameraUp = aCamera->Up(); + const gp_Vec aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp; + const gp_Dir& aCameraDir = aCamera->Direction(); + aRotateAngle = static_cast (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]); + } + + aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureRes (aContext)->SizeY()); + } + } + + renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle); + + // turn on the current plane to restore initial state + aContext->ChangeClipping().SetEnabled (aContext, thePlaneIter, Standard_True); + aContext->ShaderManager()->RevertClippingState(); + aContext->ShaderManager()->RevertClippingState(); + } + + if (theStructure.InstancedStructure() != NULL) + { + renderOne (theWorkspace, *theStructure.InstancedStructure(), thePlaneIter, thePlaneAspectCapping, theQuad); + } +} + +// ======================================================================= +// function : renderSection +// purpose : +// ======================================================================= +void OpenGl_CappingRenderer::renderSection (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_PrimitiveArray* theQuad, + const OpenGl_AspectFace* theCappingAspect, + const OpenGl_AspectFace* theHatchAspect, + const OpenGl_Mat4& theCappingMatrix, + const Standard_ShortReal theHatchScale, + const Standard_ShortReal theHatchRotate) +{ + const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); + + const Standard_Boolean isTextureHatch = + theHatchAspect != NULL + && theHatchAspect->Aspect()->TextureMapState(); + + aContext->ModelWorldState.Push(); + aContext->ModelWorldState.SetCurrent (theCappingMatrix); + aContext->ApplyModelViewMatrix(); + + theWorkspace->SetAspectFace (theCappingAspect); + theWorkspace->ApplyAspectFace(); + + 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) + { + const Handle(Graphic3d_TextureParams)& aTexParams = theHatchAspect->TextureParams(); + + 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->SetAspectFace (theHatchAspect); + theWorkspace->ApplyAspectFace(); + + glDepthFunc (GL_LEQUAL); + + theQuad->Render (theWorkspace); + + glDepthFunc (GL_LESS); + + if (isTextureHatch) + { + glDisable (GL_BLEND); + + if (theHatchScale != 1.0 || theHatchRotate != 0.0) + { + const Handle(Graphic3d_TextureParams)& aTexParams = theHatchAspect->TextureParams(); + + aTexParams->SetScale (aPrevScale); + aTexParams->SetRotation (aPrevRotate); + } + } + } + + aContext->ModelWorldState.Pop(); + aContext->ApplyModelViewMatrix(); +} + +// ======================================================================= +// function : initQuad +// purpose : initializes and returns vertex buffer for plane section +// ======================================================================= +OpenGl_PrimitiveArray* OpenGl_CappingRenderer::initQuad (const Handle(OpenGl_Context)& theContext) +{ + Handle(OpenGl_SharedElement) aSharedResource; + + if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource)) + { + OpenGl_PrimitiveArray* aPArray = NULL; + + 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)); + + aPArray = new OpenGl_PrimitiveArray (NULL); + aPArray->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL); + } + aSharedResource = new OpenGl_SharedElement (aPArray); + + theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource); + } + + return dynamic_cast (aSharedResource->GlElement()); +} + +// ======================================================================= +// function : CanRender +// purpose : +// ======================================================================= +Standard_Boolean OpenGl_CappingRenderFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Element* theGlElement) +{ + if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement)) + { + return Standard_False; + } + + const OpenGl_PrimitiveArray* aPArray = dynamic_cast (theGlElement); + return aPArray != NULL + && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM + && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO; +} diff --git a/src/OpenGl/OpenGl_CappingRenderer.hxx b/src/OpenGl/OpenGl_CappingRenderer.hxx new file mode 100644 index 0000000000..ab63e97eea --- /dev/null +++ b/src/OpenGl/OpenGl_CappingRenderer.hxx @@ -0,0 +1,120 @@ +// Created on: 2013-09-05 +// Created by: Anton POLETAEV +// Copyright (c) 2013-2014 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 _OpenGl_CappingRenderer_H__ +#define _OpenGl_CappingRenderer_H__ + +#include +#include + +// Forward declaration +class OpenGl_AspectFace; +class OpenGl_AspectFillCapping; +class OpenGl_AspectSection; +class OpenGl_CappingStyle; +class OpenGl_ClippingIterator; +class OpenGl_Context; +class OpenGl_Element; +class OpenGl_PrimitiveArray; +class OpenGl_Structure; +class OpenGl_Texture; +class OpenGl_Workspace; + +//! Class implementing an OpenGL rasterization algorithm for drawing capping planes over clipped geometry. +class OpenGl_CappingRenderer +{ +public: + + //! Renders capping surfaces for enabled clipping planes. + //! @note Depth buffer must be generated for the passed groups. + //! @param theWorkspace [in] the GL workspace, context state + //! @param theStructure [in] the structure to be capped + Standard_EXPORT static void Render (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Structure& theStructure); + +private: + + //! Method to render capping section of one given plane for a structure. + static void renderOne (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Structure& theStructure, + const OpenGl_ClippingIterator& thePlaneIter, + const OpenGl_AspectFillCapping* thePlaneAspectCapping, + const OpenGl_PrimitiveArray* theQuad); + + //! Render section plane using the given aspects. + static void renderSection (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_PrimitiveArray* theQuad, + const OpenGl_AspectFace* theCappingAspect, + const OpenGl_AspectFace* theHatchAspect, + const OpenGl_Mat4& theCappingMatrix, + const Standard_ShortReal theHatchScale, + const Standard_ShortReal theHatchRotate); + + //! Initializes and returns face draw element for rendering section plane. + //! @note once initialized, context will hold resource until destroyed. + static OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext); + + //! Set rotation persistence components for the matrix to support persistent texturing. + //! @param theWorkspace [in] the GL workspace, context state. + //! @param thePlane [in] the plane. + //! @param theRotateScaleMat [in/out] the matrix combining rotation and scaling persistence components. + static void computePersistence (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_ClippingIterator& thePlane, + const Handle(OpenGl_Texture)& theTexture, + const bool theRotatePers, + const bool theZoomPers, + OpenGl_Mat4& theRotateScaleMat); + + //! Set zoom persistence components for the matrix to support persistent texturing. + //! @param theWorkspace [in] the GL workspace, context state. + //! @param thePlane [in] the plane. + //! @param theTexture [in] the texture. + //! @param theRotateScaleMat [in/out] the matrix combining rotation and scaling persistence components. + static void setZoomPersistence (const Handle(OpenGl_Workspace)& theWorkspace, + const Handle(OpenGl_Texture)& theTexture, + OpenGl_Mat4& theRotateScaleMat); +}; + +//! Filters out everything except face primitives of solids. +class OpenGl_CappingRenderFilter : public OpenGl_RenderFilter +{ +public: + + //! Default constructor. + OpenGl_CappingRenderFilter() {} + + //! Sets the current active filter in workspace. + //! @param thePrevFilter [in] the previously active filter that should have additive effect. + void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; } + + //! Checks whether the element can be rendered or not. + //! @param theElement [in] the element to check. + //! @return True if element can be rendered. + Standard_EXPORT virtual + Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, + const OpenGl_Element* theGlElement) Standard_OVERRIDE; + +private: + + Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined. + +public: + + DEFINE_STANDARD_RTTIEXT (OpenGl_CappingRenderFilter, OpenGl_RenderFilter) +}; + +DEFINE_STANDARD_HANDLE (OpenGl_CappingRenderFilter, OpenGl_RenderFilter) + +#endif diff --git a/src/OpenGl/OpenGl_Element.hxx b/src/OpenGl/OpenGl_Element.hxx index 74890eeb94..30d06ce284 100644 --- a/src/OpenGl/OpenGl_Element.hxx +++ b/src/OpenGl/OpenGl_Element.hxx @@ -63,7 +63,7 @@ public: //! @param theWorkspace [in] the rendering workspace. //! @param theFilter [in] the rendering filter to check whether the element //! should be rendered or not. - //! @return True if element passes the check and renders, + //! @return True if element passes the filtering check and is rendered. inline Standard_Boolean RenderFiltered (const Handle(OpenGl_Workspace)& theWorkspace, const Handle(OpenGl_RenderFilter)& theFilter) const diff --git a/src/OpenGl/OpenGl_Group.cxx b/src/OpenGl/OpenGl_Group.cxx index f539a6867e..4cad09ee4f 100644 --- a/src/OpenGl/OpenGl_Group.cxx +++ b/src/OpenGl/OpenGl_Group.cxx @@ -242,6 +242,28 @@ void OpenGl_Group::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& th Update(); } +// ======================================================================= +// function : SetGroupPrimitivesAspect +// purpose : +// ======================================================================= +void OpenGl_Group::SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) +{ + if (IsDeleted()) + { + return; + } + + if (myAspectFillCapping == NULL) + { + myAspectFillCapping = new OpenGl_AspectFillCapping (theAspect); + } + else + { + myAspectFillCapping->SetAspect (theAspect); + } + Update(); +} + // ======================================================================= // function : AddPrimitiveArray // purpose : diff --git a/src/OpenGl/OpenGl_Group.hxx b/src/OpenGl/OpenGl_Group.hxx index c845615d48..5b64c10376 100644 --- a/src/OpenGl/OpenGl_Group.hxx +++ b/src/OpenGl/OpenGl_Group.hxx @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -103,6 +104,17 @@ public: //! Append text aspect as an element. Standard_EXPORT virtual void SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& theAspect) Standard_OVERRIDE; + //! Update section style aspect. + Standard_EXPORT virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) Standard_OVERRIDE; + + //! Returns section style aspect. + virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const Standard_OVERRIDE + { + return myAspectFillCapping != NULL + ? myAspectFillCapping->Aspect() + : Handle(Graphic3d_AspectFillCapping)(); + } + //! Add primitive array element Standard_EXPORT virtual void AddPrimitiveArray (const Graphic3d_TypeOfPrimitiveArray theType, const Handle(Graphic3d_IndexBuffer)& theIndices, @@ -153,6 +165,9 @@ public: //! Returns OpenGL face aspect. const OpenGl_AspectFace* AspectFace() const { return myAspectFace; } + //! Returns OpenGL capping filling aspect. + const OpenGl_AspectFillCapping* AspectFillCapping() const { return myAspectFillCapping; } + //! Is the group ray-tracable (contains ray-tracable elements)? Standard_Boolean IsRaytracable() const { return myIsRaytracable; } @@ -162,10 +177,11 @@ protected: protected: - OpenGl_AspectLine* myAspectLine; - OpenGl_AspectFace* myAspectFace; - OpenGl_AspectMarker* myAspectMarker; - OpenGl_AspectText* myAspectText; + OpenGl_AspectLine* myAspectLine; + OpenGl_AspectFace* myAspectFace; + OpenGl_AspectMarker* myAspectMarker; + OpenGl_AspectText* myAspectText; + OpenGl_AspectFillCapping* myAspectFillCapping; OpenGl_ElementNode* myFirst; OpenGl_ElementNode* myLast; diff --git a/src/OpenGl/OpenGl_ShaderManager.cxx b/src/OpenGl/OpenGl_ShaderManager.cxx index e01e151343..f2d185faff 100644 --- a/src/OpenGl/OpenGl_ShaderManager.cxx +++ b/src/OpenGl/OpenGl_ShaderManager.cxx @@ -1136,11 +1136,11 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont() EOL"}"; TCollection_AsciiString - aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }"; + aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, TexCoord.st).a; }"; #if !defined(GL_ES_VERSION_2_0) if (myContext->core11 == NULL) { - aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }"; + aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, TexCoord.st).r; }"; } #endif @@ -1243,8 +1243,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit() } myContext->BindProgram (myBlitProgram); - myBlitProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0); - myBlitProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1); + myBlitProgram->SetSampler (myContext, "uColorSampler", 0); + myBlitProgram->SetSampler (myContext, "uDepthSampler", 1); myContext->BindProgram (NULL); return Standard_True; } @@ -1331,8 +1331,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const St } myContext->BindProgram (aProgram); - aProgram->SetSampler (myContext, "uAccumTexture", Graphic3d_TextureUnit_0); - aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1); + aProgram->SetSampler (myContext, "uAccumTexture", 0); + aProgram->SetSampler (myContext, "uWeightTexture", 1); myContext->BindProgram (Handle(OpenGl_ShaderProgram)()); return Standard_True; } @@ -1343,12 +1343,12 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const St // ======================================================================= TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (const Standard_Integer theBits) { - TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }"; + TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ").a; }"; #if !defined(GL_ES_VERSION_2_0) if (myContext->core11 == NULL && (theBits & OpenGl_PO_TextureA) != 0) { - aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }"; + aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ").r; }"; } #else (void )theBits; @@ -1391,7 +1391,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad if ((theBits & OpenGl_PO_TextureRGB) != 0) { aSrcFragGetColor = - EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }"; + EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord "); }"; } if (textureUsed (theBits)) @@ -1429,7 +1429,10 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad aSrcVertExtraMain += THE_VARY_TexCoord_Trsf; aSrcFragGetColor = - EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }"; + EOL"vec4 getColor(void)" + EOL"{" + EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * occColor;" + EOL"}"; } else if ((theBits & OpenGl_PO_TextureEnv) != 0) { @@ -1446,7 +1449,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);"; aSrcFragGetColor = - EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }"; + EOL"vec4 getColor(void) { return occTexture2D (occActiveSampler, TexCoord.st); }"; } } if ((theBits & OpenGl_PO_VertColor) != 0) @@ -1605,7 +1608,7 @@ TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TColl EOL"vec4 getColor(void)" EOL"{" EOL" vec4 aColor = " + theBaseColorSrc + ";" - EOL" aColor = occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ") * aColor;" + EOL" aColor = occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ") * aColor;" EOL" if (aColor.a <= 0.1) discard;" EOL" return aColor;" EOL"}"; @@ -1745,7 +1748,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_S EOL"vec4 getColor(void)" EOL"{" EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;" - EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;" + EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;" EOL"}"; } } @@ -1886,7 +1889,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_Sha EOL"vec4 getColor(void)" EOL"{" EOL" vec4 aColor = " thePhongCompLight ";" - EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;" + EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;" EOL"}"; } } @@ -2200,8 +2203,8 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_Sh } myContext->BindProgram (theProgram); - theProgram->SetSampler (myContext, "uLeftSampler", Graphic3d_TextureUnit_0); - theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1); + theProgram->SetSampler (myContext, "uLeftSampler", 0); + theProgram->SetSampler (myContext, "uRightSampler", 1); myContext->BindProgram (NULL); return Standard_True; } diff --git a/src/OpenGl/OpenGl_Structure.cxx b/src/OpenGl/OpenGl_Structure.cxx index bfb99381fd..d42a468984 100644 --- a/src/OpenGl/OpenGl_Structure.cxx +++ b/src/OpenGl/OpenGl_Structure.cxx @@ -13,7 +13,7 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. -#include +#include #include #include #include @@ -657,10 +657,9 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con } // Render capping for structure groups - if (hasClosedPrims - && aCtx->Clipping().IsCappingOn()) + if (hasClosedPrims && aCtx->Clipping().IsCappingOn()) { - OpenGl_CappingAlgo::RenderCapping (theWorkspace, *this); + OpenGl_CappingRenderer::Render (theWorkspace, *this); } // Revert structure clippings diff --git a/src/OpenGl/OpenGl_Workspace.cxx b/src/OpenGl/OpenGl_Workspace.cxx index a8a02385c6..62cec4364d 100644 --- a/src/OpenGl/OpenGl_Workspace.cxx +++ b/src/OpenGl/OpenGl_Workspace.cxx @@ -16,18 +16,14 @@ #include #include -#include -#include -#include -#include #include #include #include #include -#include -#include #include +#include #include +#include #include #include #include @@ -167,7 +163,7 @@ OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Wi #endif } - myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter(); + myCappingRenderFilter = new OpenGl_CappingRenderFilter(); myNoneCulling .Aspect()->SetSuppressBackFaces (false); myNoneCulling .Aspect()->SetDrawEdges (false); diff --git a/src/OpenGl/OpenGl_Workspace.hxx b/src/OpenGl/OpenGl_Workspace.hxx index 7b1648f40a..09d314e42a 100644 --- a/src/OpenGl/OpenGl_Workspace.hxx +++ b/src/OpenGl/OpenGl_Workspace.hxx @@ -17,9 +17,13 @@ #define _OpenGl_Workspace_Header #include +#include #include -#include +#include +#include +#include +#include #include #include #include @@ -264,9 +268,9 @@ public: const Graphic3d_PolygonOffset& AppliedPolygonOffset() { return myPolygonOffsetApplied; } //! Returns capping algorithm rendering filter. - const Handle(OpenGl_CappingAlgoFilter)& DefaultCappingAlgoFilter() const + const Handle(OpenGl_CappingRenderFilter)& CappingRenderFilter() const { - return myDefaultCappingAlgoFilter; + return myCappingRenderFilter; } //! Returns face aspect for none culling mode. @@ -289,14 +293,14 @@ public: protected: //! @name protected fields - OpenGl_View* myView; - Handle(OpenGl_Window) myWindow; - Handle(OpenGl_Context) myGlContext; - Standard_Boolean myUseZBuffer; - Standard_Boolean myUseDepthWrite; - Handle(OpenGl_CappingAlgoFilter) myDefaultCappingAlgoFilter; - OpenGl_AspectFace myNoneCulling; - OpenGl_AspectFace myFrontCulling; + OpenGl_View* myView; + Handle(OpenGl_Window) myWindow; + Handle(OpenGl_Context) myGlContext; + Standard_Boolean myUseZBuffer; + Standard_Boolean myUseDepthWrite; + Handle(OpenGl_CappingRenderFilter) myCappingRenderFilter; + OpenGl_AspectFace myNoneCulling; + OpenGl_AspectFace myFrontCulling; protected: //! @name fields related to status diff --git a/src/StdPrs/StdPrs_ShadedShape.cxx b/src/StdPrs/StdPrs_ShadedShape.cxx index e29b6950c0..b1f95be6d5 100644 --- a/src/StdPrs/StdPrs_ShadedShape.cxx +++ b/src/StdPrs/StdPrs_ShadedShape.cxx @@ -276,14 +276,15 @@ namespace } //! Prepare shaded presentation for specified shape - static Standard_Boolean shadeFromShape (const TopoDS_Shape& theShape, - const Handle(Prs3d_Presentation)& thePrs, - const Handle(Prs3d_Drawer)& theDrawer, - const Standard_Boolean theHasTexels, - const gp_Pnt2d& theUVOrigin, - const gp_Pnt2d& theUVRepeat, - const gp_Pnt2d& theUVScale, - const bool theIsClosed) + 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, + const gp_Pnt2d& theUVScale, + const bool theIsClosed) { Handle(Graphic3d_ArrayOfTriangles) aPArray = fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale); if (aPArray.IsNull()) @@ -294,6 +295,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; } @@ -496,28 +500,30 @@ void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape& theShape, // function : Add // purpose : // ======================================================================= -void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs, - const TopoDS_Shape& theShape, - const Handle(Prs3d_Drawer)& theDrawer, - const StdPrs_Volume theVolume) +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); } // ======================================================================= // function : Add // purpose : // ======================================================================= -void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs, - 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) +void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs, + 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, + const StdPrs_Volume theVolume) { if (theShape.IsNull()) { @@ -555,21 +561,21 @@ void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs, TopoDS_Iterator aShapeIter (aClosed); if (aShapeIter.More()) { - shadeFromShape (aClosed, thePrs, theDrawer, + shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle, theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true); } aShapeIter.Initialize (anOpened); if (aShapeIter.More()) { - 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 cbb2a7df75..d62859041a 100644 --- a/src/StdPrs/StdPrs_ShadedShape.hxx +++ b/src/StdPrs/StdPrs_ShadedShape.hxx @@ -43,13 +43,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.cxx b/src/ViewerTest/ViewerTest.cxx index b61329afbf..47d355eb63 100644 --- a/src/ViewerTest/ViewerTest.cxx +++ b/src/ViewerTest/ViewerTest.cxx @@ -1618,17 +1618,17 @@ static int VSetInteriorStyle (Draw_Interpretor& theDI, //! Auxiliary structure for VAspects struct ViewerTest_AspectsChangeSet { - Standard_Integer ToSetVisibility; - Standard_Integer Visibility; + Standard_Integer ToSetVisibility; + Standard_Integer Visibility; - Standard_Integer ToSetColor; - Quantity_Color Color; + Standard_Integer ToSetColor; + Quantity_Color Color; - Standard_Integer ToSetLineWidth; - Standard_Real LineWidth; + Standard_Integer ToSetLineWidth; + Standard_Real LineWidth; - Standard_Integer ToSetTypeOfLine; - Aspect_TypeOfLine TypeOfLine; + Standard_Integer ToSetTypeOfLine; + Aspect_TypeOfLine TypeOfLine; Standard_Integer ToSetTypeOfMarker; Aspect_TypeOfMarker TypeOfMarker; @@ -1640,30 +1640,60 @@ struct ViewerTest_AspectsChangeSet Standard_Integer ToSetTransparency; Standard_Real Transparency; - Standard_Integer ToSetMaterial; - Graphic3d_NameOfMaterial Material; - TCollection_AsciiString MatName; + Standard_Integer ToSetMaterial; + Graphic3d_NameOfMaterial Material; + TCollection_AsciiString MatName; NCollection_Sequence SubShapes; - Standard_Integer ToSetShowFreeBoundary; - Standard_Integer ToSetFreeBoundaryWidth; - Standard_Real FreeBoundaryWidth; - Standard_Integer ToSetFreeBoundaryColor; - Quantity_Color FreeBoundaryColor; + Standard_Integer ToSetShowFreeBoundary; + Standard_Integer ToSetFreeBoundaryWidth; + Standard_Real FreeBoundaryWidth; + Standard_Integer ToSetFreeBoundaryColor; + Quantity_Color FreeBoundaryColor; - Standard_Integer ToEnableIsoOnTriangulation; + Standard_Integer ToEnableIsoOnTriangulation; - Standard_Integer ToSetMaxParamValue; - Standard_Real MaxParamValue; + Standard_Integer ToSetMaxParamValue; + Standard_Real MaxParamValue; - Standard_Integer ToSetSensitivity; - Standard_Integer SelectionMode; - Standard_Integer Sensitivity; + Standard_Integer ToSetSensitivity; + Standard_Integer SelectionMode; + Standard_Integer Sensitivity; - Standard_Integer ToSetHatch; - Standard_Integer StdHatchStyle; - TCollection_AsciiString PathToHatchPattern; + Standard_Integer ToSetHatch; + Standard_Integer StdHatchStyle; + TCollection_AsciiString PathToHatchPattern; + + Standard_Integer ToSetCappingUseObjMaterial; + Standard_Integer ToSetCappingUseObjTexture; + Standard_Integer ToSetCappingUseObjShader; + Standard_Integer ToSetCappingHatchZoomPers; + Standard_Integer ToSetCappingHatchRotatePers; + Standard_Integer ToSetCappingHatchEnabled; + Standard_Boolean ToSetCappingColor; + Quantity_Color CappingColor; + Standard_Boolean ToSetCappingTexture; + Handle(Graphic3d_TextureMap) CappingTexture; + Standard_Boolean ToSetCappingTexScale; + Graphic3d_Vec2 CappingTexScale; + Standard_Boolean ToSetCappingTexOrigin; + Graphic3d_Vec2 CappingTexOrigin; + Standard_Boolean ToSetCappingTexRotate; + Standard_ShortReal CappingTexRotate; + Standard_Boolean ToSetCappingStippleHatch; + Handle(Graphic3d_HatchStyle) CappingHatchStipple; + Standard_Boolean ToSetCappingHatchColor; + Quantity_Color CappingHatchColor; + Standard_Boolean ToSetCappingTextureHatch; + Handle(Graphic3d_TextureMap) CappingHatchTexture; + Standard_Boolean ToSetCappingHatchTexScale; + Graphic3d_Vec2 CappingHatchTexScale; + Standard_Boolean ToSetCappingHatchTexOrigin; + Graphic3d_Vec2 CappingHatchTexOrigin; + Standard_Boolean ToSetCappingHatchTexRotate; + Standard_ShortReal CappingHatchTexRotate; + Standard_Boolean ToUnsetCapping; //! Empty constructor ViewerTest_AspectsChangeSet() @@ -1695,7 +1725,26 @@ struct ViewerTest_AspectsChangeSet SelectionMode (-1), Sensitivity (-1), ToSetHatch (0), - StdHatchStyle (-1) + StdHatchStyle (-1), + ToSetCappingUseObjMaterial (-1), + ToSetCappingUseObjTexture (-1), + ToSetCappingUseObjShader (-1), + ToSetCappingHatchZoomPers (-1), + ToSetCappingHatchRotatePers (-1), + ToSetCappingHatchEnabled (-1), + ToSetCappingColor (Standard_False), + ToSetCappingTexture (Standard_False), + ToSetCappingTexScale (Standard_False), + ToSetCappingTexOrigin (Standard_False), + ToSetCappingTexRotate (Standard_False), + ToSetCappingStippleHatch (Standard_False), + ToSetCappingHatchColor (Standard_False), + ToSetCappingTextureHatch (Standard_False), + ToSetCappingHatchTexScale (Standard_False), + ToSetCappingHatchTexOrigin (Standard_False), + ToSetCappingHatchTexRotate (Standard_False), + CappingTexRotate (0.F), + ToUnsetCapping (Standard_False) {} //! @return true if no changes have been requested @@ -1711,7 +1760,30 @@ struct ViewerTest_AspectsChangeSet && ToSetFreeBoundaryWidth == 0 && ToSetMaxParamValue == 0 && ToSetSensitivity == 0 - && ToSetHatch == 0; + && ToSetHatch == 0 + && !ToSetCapping(); + } + + Standard_Boolean ToSetCapping() const + { + return ToSetCappingUseObjMaterial != -1 + || ToSetCappingUseObjTexture != -1 + || ToSetCappingUseObjShader != -1 + || ToSetCappingHatchZoomPers != -1 + || ToSetCappingHatchRotatePers != -1 + || ToSetCappingHatchEnabled != -1 + || ToSetCappingColor + || ToSetCappingTexture + || ToSetCappingTexScale + || ToSetCappingTexOrigin + || ToSetCappingTexRotate + || ToSetCappingStippleHatch + || ToSetCappingHatchColor + || ToSetCappingTextureHatch + || ToSetCappingHatchTexScale + || ToSetCappingHatchTexOrigin + || ToSetCappingHatchTexRotate + || ToUnsetCapping; } //! @return true if properties are valid @@ -1768,9 +1840,109 @@ struct ViewerTest_AspectsChangeSet std::cout << "Error: hatch style must be specified\n"; isOk = Standard_False; } + if (ToUnsetCapping && ToSetCapping()) + { + std::cout << "Error: not possible to set capping attribute with -unsetCapping specified\n"; + isOk = Standard_False; + } return isOk; } + void ApplyToCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle) + { + if (ToSetCappingUseObjMaterial != -1) + { + theStyle->SetUseObjectMaterial (ToSetCappingUseObjMaterial != 0); + } + if (ToSetCappingUseObjTexture != -1) + { + theStyle->SetUseObjectTexture (ToSetCappingUseObjTexture != 0); + } + if (ToSetCappingUseObjShader != -1) + { + theStyle->SetUseObjectShader (ToSetCappingUseObjShader != 0); + } + if (ToSetCappingHatchZoomPers != -1) + { + theStyle->SetHatchZoomPeristent (ToSetCappingHatchZoomPers != 0); + } + if (ToSetCappingHatchRotatePers != -1) + { + theStyle->SetHatchRotationPeristent (ToSetCappingHatchRotatePers != 0); + } + if (ToSetCappingHatchEnabled != -1) + { + theStyle->SetToDrawHatch (ToSetCappingHatchEnabled != 0); + } + if (ToSetCappingColor) + { + Graphic3d_MaterialAspect aMat = theStyle->Material(); + aMat.SetAmbientColor (CappingColor); + aMat.SetDiffuseColor (CappingColor); + theStyle->SetMaterial (aMat); + } + if (ToSetCappingTexture) + { + theStyle->SetTexture (CappingTexture); + } + if (ToSetCappingTexScale) + { + if (!theStyle->Texture().IsNull()) + { + theStyle->Texture()->GetParams()->SetScale (CappingTexScale); + } + } + if (ToSetCappingTexOrigin) + { + if (!theStyle->Texture().IsNull()) + { + theStyle->Texture()->GetParams()->SetTranslation (CappingTexOrigin); + } + } + if (ToSetCappingTexRotate) + { + if (!theStyle->Texture().IsNull()) + { + theStyle->Texture()->GetParams()->SetRotation (CappingTexRotate); + } + } + if (ToSetCappingStippleHatch) + { + theStyle->SetHatchStyle (CappingHatchStipple); + } + if (ToSetCappingHatchColor) + { + Graphic3d_MaterialAspect aMat = theStyle->HatchMaterial(); + aMat.SetAmbientColor (CappingHatchColor); + aMat.SetDiffuseColor (CappingHatchColor); + theStyle->SetHatchMaterial (aMat); + } + if (ToSetCappingTextureHatch) + { + theStyle->SetHatchStyle (CappingHatchTexture); + } + if (ToSetCappingHatchTexScale) + { + if (!theStyle->TextureHatch().IsNull()) + { + theStyle->TextureHatch()->GetParams()->SetScale (CappingHatchTexScale); + } + } + if (ToSetCappingHatchTexOrigin) + { + if (!theStyle->TextureHatch().IsNull()) + { + theStyle->TextureHatch()->GetParams()->SetTranslation (CappingHatchTexOrigin); + } + } + if (ToSetCappingHatchTexRotate) + { + if (!theStyle->TextureHatch().IsNull()) + { + theStyle->TextureHatch()->GetParams()->SetRotation (CappingHatchTexRotate); + } + } + } }; //============================================================================== @@ -1825,6 +1997,7 @@ static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/, NCollection_Sequence aChanges; aChanges.Append (ViewerTest_AspectsChangeSet()); ViewerTest_AspectsChangeSet* aChangeSet = &aChanges.ChangeLast(); + Standard_Boolean toEnable = Standard_False; // parse syntax of legacy commands if (aCmdName == "vsetwidth") @@ -1944,6 +2117,8 @@ static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/, } for (; anArgIter < theArgNb; ++anArgIter) { + const char** aChangeArgs = theArgVec + anArgIter; + Standard_Integer aNbChangeArgs = theArgNb - anArgIter; TCollection_AsciiString anArg = theArgVec[anArgIter]; anArg.LowerCase(); if (anArg == "-setwidth" @@ -2389,12 +2564,6 @@ static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/, return 1; } - if (aNames.IsEmpty()) - { - std::cout << "Error: object should be specified explicitly when -setHatch is used!\n"; - return 1; - } - aChangeSet->ToSetHatch = 1; TCollection_AsciiString anArgHatch (theArgVec[++anArgIter]); if (anArgHatch.Length() <= 2) @@ -2413,6 +2582,382 @@ static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/, aChangeSet->PathToHatchPattern = anArgHatch; } } + else if (anArg == "-setcappinguseobjmaterial") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingUseObjMaterial need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingUseObjMaterial = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappinguseobjtexture") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingUseObjTexture need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingUseObjTexture = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappinguseobjshader") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingUseObjShader need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingUseObjShader = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappingcolor") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + Quantity_Color aColor; + Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, + aChangeArgs + 1, + aColor); + if (aNbParsed == 0) + { + std::cout << "Syntax error: -setCappingColor need more arguments.\n"; + return 1; + } + anArgIter += aNbParsed; + aChangeSet->ToSetCappingColor = Standard_True; + aChangeSet->CappingColor = aColor; + } + else if (anArg == "-setcappingtexture") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingTexture need more arguments.\n"; + return 1; + } + + TCollection_AsciiString aTextureName (aChangeArgs[1]); + Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); + if (!aTexture->IsDone()) + { + aChangeSet->CappingTexture = Handle(Graphic3d_TextureMap)(); + } + else + { + aTexture->EnableModulate(); + aTexture->EnableRepeat(); + aChangeSet->CappingTexture = aTexture.get(); + } + aChangeSet->ToSetCappingTexture = Standard_True; + anArgIter += 1; + } + else if (anArg == "-setcappingtexscale") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: -setCappingTexScale need more arguments.\n"; + return 1; + } + + Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aChangeSet->ToSetCappingTexScale = Standard_True; + aChangeSet->CappingTexScale = Graphic3d_Vec2 (aSx, aSy); + anArgIter += 2; + } + else if (anArg == "-setcappingtexorigin") + { + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: -setCappingTexOrigin need more arguments.\n"; + return 1; + } + + Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aChangeSet->ToSetCappingTexOrigin = Standard_True; + aChangeSet->CappingTexOrigin = Graphic3d_Vec2 (aTx, aTy); + anArgIter += 2; + } + else if (anArg == "-setcappingtexrotate") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingTexRotate need more arguments.\n"; + return 1; + } + + aChangeSet->ToSetCappingTexRotate = Standard_True; + aChangeSet->CappingTexRotate = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + anArgIter += 1; + } + else if (anArg == "-setcappinghatchzoompers") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatchZoomPers need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingHatchZoomPers = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappinghatchrotatepers") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatchRotatePers need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingHatchRotatePers = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappinghatch") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatch need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aChangeSet->ToSetCappingHatchEnabled = toEnable ? 1 : 0; + anArgIter += 1; + } + } + else if (anArg == "-setcappinghatchstipple") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatchStipple need more arguments.\n"; + return 1; + } + + TCollection_AsciiString anArg = aChangeArgs[1]; + if (anArg.IsIntegerValue()) + { + aChangeSet->ToSetCappingStippleHatch = Standard_True; + aChangeSet->CappingHatchStipple = new Graphic3d_HatchStyle ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1])); + } + else + { + Handle(Image_AlienPixMap) anImage = new Image_AlienPixMap(); + if (!anImage->Load (anArg)) + { + std::cout << "Syntax error: -setCappingHatchStipple image " << anArg << " could not be loaded.\n"; + return 1; + } + aChangeSet->ToSetCappingStippleHatch = Standard_True; + aChangeSet->CappingHatchStipple = new Graphic3d_HatchStyle (anImage); + } + anArgIter += 1; + } + else if (anArg == "-setcappinghatchcolor") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + Quantity_Color aColor; + Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, + aChangeArgs + 1, + aColor); + if (aNbParsed == 0) + { + std::cout << "Syntax error: -setCappingHatchColor need more arguments.\n"; + return 1; + } + + aChangeSet->ToSetCappingHatchColor = Standard_True; + aChangeSet->CappingHatchColor = aColor; + anArgIter += aNbParsed; + } + else if (anArg == "-setcappinghatchtexture") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatchTexture need more arguments.\n"; + return 1; + } + + TCollection_AsciiString aTextureName (aChangeArgs[1]); + Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); + if (aTexture->IsDone()) + { + aTexture->EnableModulate(); + aTexture->EnableRepeat(); + } + aChangeSet->ToSetCappingTextureHatch = Standard_True; + aChangeSet->CappingHatchTexture = aTexture->IsDone() ? aTexture : Handle(Graphic3d_TextureMap)(); + anArgIter += 1; + } + else if (anArg == "-setcappinghatchtexscale") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: -setCappingHatchTexScale need more arguments.\n"; + return 1; + } + + Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aChangeSet->ToSetCappingHatchTexScale = Standard_True; + aChangeSet->CappingHatchTexScale = Graphic3d_Vec2 (aSx, aSy); + anArgIter += 2; + } + else if (anArg == "-setcappinghatchtexorigin") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: -setCappingHatchTexOrigin need more arguments.\n"; + return 1; + } + + Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aChangeSet->ToSetCappingHatchTexOrigin = Standard_True; + aChangeSet->CappingHatchTexOrigin = Graphic3d_Vec2 (aTx, aTy); + anArgIter += 2; + } + else if (anArg == "-setcappinghatchtexrotate") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: -setCappingHatchTexRotate need more arguments.\n"; + return 1; + } + + aChangeSet->ToSetCappingHatchTexRotate = Standard_True; + aChangeSet->CappingHatchTexRotate = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + anArgIter += 1; + } + else if (anArg == "-unsetcappingstyle") + { + if (isDefaults) + { + std::cout << "Error: wrong syntax. -setHatch can not be used together with -defaults call!\n"; + return 1; + } + + if (isDefaults) + { + std::cout << "Error: wrong syntax. -unsetCappingStyle can not be used together with -defaults call!\n"; + return 1; + } + + aChangeSet->ToUnsetCapping = Standard_True; + } else { std::cout << "Error: wrong syntax at " << anArg << "\n"; @@ -2699,6 +3244,27 @@ static Standard_Integer VAspects (Draw_Interpretor& /*theDI*/, } toRedisplay = Standard_True; } + if (aChangeSet->ToSetCapping()) + { + Handle(Graphic3d_AspectFillCapping) aCappingStyle = aPrs->CappingStyle(); + + if (aCappingStyle.IsNull()) + { + aCappingStyle = new Graphic3d_AspectFillCapping; + } + + aChangeSet->ApplyToCappingStyle (aCappingStyle); + + aPrs->SetCappingStyle (aCappingStyle); + + toRedisplay = Standard_True; + } + if (aChangeSet->ToUnsetCapping != 0) + { + aPrs->SetCappingStyle (Handle(Graphic3d_AspectFillCapping)()); + + toRedisplay = Standard_True; + } } for (aChangesIter.Next(); aChangesIter.More(); aChangesIter.Next()) @@ -6229,6 +6795,24 @@ void ViewerTest::Commands(Draw_Interpretor& theCommands) "\n\t\t: [-setMaxParamValue {value}]" "\n\t\t: [-setSensitivity {selection_mode} {value}]" "\n\t\t: [-setHatch HatchStyle]" + "\n\t\t: [-setCappingUseObjMaterial {off/on | 0/1}]" + "\n\t\t: [-setCappingUseObjTexture {off/on | 0/1}]" + "\n\t\t: [-setCappingUseObjShader {off/on | 0/1}]" + "\n\t\t: [-setCappingColor R G B]" + "\n\t\t: [-setCappingTexture texture]" + "\n\t\t: [-setCappingTexScale SX SY]" + "\n\t\t: [-setCappingTexOrigin TX TY]" + "\n\t\t: [-setCappingTexRotate Angle]" + "\n\t\t: [-setCappingHatch {off/on | 0/1}]" + "\n\t\t: [-setCappingHatchColor R G B]" + "\n\t\t: [-setCappingHatchStipple maskID]" + "\n\t\t: [-setCappingHatchTexture Texture]" + "\n\t\t: [-setCappingHatchTexScale SX SY]" + "\n\t\t: [-setCappingHatchTexOrigin TX TY]" + "\n\t\t: [-setCappingHatchTexRotate Angle]" + "\n\t\t: [-setCappingHatchZoomPers {off/on | 0/1}]" + "\n\t\t: [-setCappingHatchRotatePers {off/on | 0/1}]" + "\n\t\t: [-unsetCappingStyle]" "\n\t\t: Manage presentation properties of all, selected or named objects." "\n\t\t: When -subshapes is specified than following properties will be" "\n\t\t: assigned to specified sub-shapes." diff --git a/src/ViewerTest/ViewerTest_ViewerCommands.cxx b/src/ViewerTest/ViewerTest_ViewerCommands.cxx index e603fea739..8d59c8f4d1 100644 --- a/src/ViewerTest/ViewerTest_ViewerCommands.cxx +++ b/src/ViewerTest/ViewerTest_ViewerCommands.cxx @@ -8225,6 +8225,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { aClipPlane->SetCapping (toEnable); + anArgIter += 1; } else @@ -8245,7 +8246,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { - aClipPlane->SetUseObjectMaterial (toEnable == Standard_True); + aClipPlane->CappingSectionStyle()->SetUseObjectMaterial (toEnable == Standard_True); anArgIter += 1; } } @@ -8262,7 +8263,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { - aClipPlane->SetUseObjectTexture (toEnable == Standard_True); + aClipPlane->CappingSectionStyle()->SetUseObjectTexture (toEnable == Standard_True); anArgIter += 1; } } @@ -8277,7 +8278,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { - aClipPlane->SetUseObjectShader (toEnable == Standard_True); + aClipPlane->CappingSectionStyle()->SetUseObjectShader (toEnable == Standard_True); anArgIter += 1; } } @@ -8294,14 +8295,29 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons return 1; } - Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial(); + Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material(); aMat.SetAmbientColor (aColor); aMat.SetDiffuseColor (aColor); - aClipPlane->SetCappingMaterial (aMat); + aClipPlane->CappingSectionStyle()->SetMaterial (aMat); anArgIter += aNbParsed; } - else if (aChangeArg == "-texname" - || aChangeArg == "texname") + else if (aChangeArg == "-overrideaspect" + || aChangeArg == "overrideaspect") + { + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True); + anArgIter += 1; + } + } + else if (aChangeArg == "-texture" + || aChangeArg == "texture") { if (aNbChangeArgs < 2) { @@ -8313,20 +8329,22 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); if (!aTexture->IsDone()) { - aClipPlane->SetCappingTexture (NULL); + aClipPlane->CappingSectionStyle()->SetTexture (Handle(Graphic3d_TextureMap)()); } else { aTexture->EnableModulate(); aTexture->EnableRepeat(); - aClipPlane->SetCappingTexture (aTexture); + aClipPlane->CappingSectionStyle()->SetTexture (aTexture.get()); } anArgIter += 1; } else if (aChangeArg == "-texscale" || aChangeArg == "texscale") { - if (aClipPlane->CappingTexture().IsNull()) + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture(); + + if (aHatchTexture.IsNull()) { std::cout << "Error: no texture is set.\n"; return 1; @@ -8340,13 +8358,15 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); - aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); + aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); anArgIter += 2; } else if (aChangeArg == "-texorigin" || aChangeArg == "texorigin") // texture origin { - if (aClipPlane->CappingTexture().IsNull()) + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture(); + + if (aHatchTexture.IsNull()) { std::cout << "Error: no texture is set.\n"; return 1; @@ -8361,13 +8381,15 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); - aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); + aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); anArgIter += 2; } else if (aChangeArg == "-texrotate" || aChangeArg == "texrotate") // texture rotation { - if (aClipPlane->CappingTexture().IsNull()) + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture(); + + if (aHatchTexture.IsNull()) { std::cout << "Error: no texture is set.\n"; return 1; @@ -8380,7 +8402,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons } Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); - aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot); + aHatchTexture->GetParams()->SetRotation (aRot); anArgIter += 1; } else if (aChangeArg == "-hatch" @@ -8392,22 +8414,165 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons return 1; } - TCollection_AsciiString aHatchStr (aChangeArgs[1]); - aHatchStr.LowerCase(); - if (aHatchStr == "on") + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) { - aClipPlane->SetCappingHatchOn(); + aClipPlane->CappingSectionStyle()->SetToDrawHatch (toEnable == Standard_True); + anArgIter += 1; } - else if (aHatchStr == "off") + } + else if (aChangeArg == "-hatchtexture" + || aChangeArg == "hatchtexture") + { + if (aNbChangeArgs < 2) { - aClipPlane->SetCappingHatchOff(); + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + TCollection_AsciiString aTextureName (aChangeArgs[1]); + Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); + if (!aTexture->IsDone()) + { + aClipPlane->CappingSectionStyle()->SetHatchStyle (Handle(Graphic3d_TextureMap)()); } else { - aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1])); + aTexture->EnableModulate(); + aTexture->EnableRepeat(); + aClipPlane->CappingSectionStyle()->SetHatchStyle (aTexture.get()); + aClipPlane->CappingSectionStyle()->SetToDrawHatch (true); } anArgIter += 1; } + else if (aChangeArg == "-hatchstipple" + || aChangeArg == "hatchstipple") + { + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + aClipPlane->CappingSectionStyle()->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1])); + aClipPlane->CappingSectionStyle()->SetToDrawHatch (true); + anArgIter += 1; + } + else if (aChangeArg == "-hatchcolor" + || aChangeArg == "hatchcolor") + { + Quantity_Color aColor; + Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, + aChangeArgs + 1, + aColor); + if (aNbParsed == 0) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->HatchMaterial(); + aMat.SetAmbientColor (aColor); + aMat.SetDiffuseColor (aColor); + aClipPlane->CappingSectionStyle()->SetHatchMaterial (aMat); + anArgIter += aNbParsed; + } + + else if (aChangeArg == "-hatchscale" + || aChangeArg == "hatchscale") + { + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch(); + + if (aHatchTexture.IsNull()) + { + std::cout << "Error: no texture is set.\n"; + return 1; + } + + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); + anArgIter += 2; + } + else if (aChangeArg == "-hatchorigin" + || aChangeArg == "hatchorigin") // texture origin + { + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch(); + + if (aHatchTexture.IsNull()) + { + std::cout << "Error: no texture is set.\n"; + return 1; + } + + if (aNbChangeArgs < 3) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + + aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); + anArgIter += 2; + } + else if (aChangeArg == "-hatchrotate" + || aChangeArg == "hatchrotate") // texture rotation + { + const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch(); + + if (aHatchTexture.IsNull()) + { + std::cout << "Error: no texture is set.\n"; + return 1; + } + + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + aHatchTexture->GetParams()->SetRotation (aRot); + anArgIter += 1; + } + else if (aChangeArg == "-hatchzoompers" + || aChangeArg == "hatchzoompers") + { + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->CappingSectionStyle()->SetHatchZoomPeristent (toEnable == Standard_True); + anArgIter += 1; + } + } + else if (aChangeArg == "-hatchrotatepers" + || aChangeArg == "hatchrotatepers") + { + if (aNbChangeArgs < 2) + { + std::cout << "Syntax error: need more arguments.\n"; + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->CappingSectionStyle()->SetHatchRotationPeristent (toEnable == Standard_True); + anArgIter += 1; + } + } else if (aChangeArg == "-delete" || aChangeArg == "delete") { @@ -11835,11 +12000,18 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands) "\n\t\t: [-set|-unset [objects|views]]" "\n\t\t: [-maxPlanes]" "\n\t\t: [-capping {0|1}]" - "\n\t\t: [-color R G B] [-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: [-useObjShader {0|1}]" "\n\t\t: Clipping planes management:" "\n\t\t: -maxPlanes print plane limit for view" "\n\t\t: -delete delete plane with given name" @@ -11850,12 +12022,21 @@ 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: -texName Texture set capping texture" + "\n\t\t: -texture 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", 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 122c566446..10333acdff 100644 --- a/tests/bugs/vis/bug27751_capping +++ b/tests/bugs/vis/bug27751_capping @@ -72,5 +72,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