From: nds Date: Mon, 21 Sep 2020 12:43:58 +0000 (+0300) Subject: Revert "0030791: Visualization - possibility to display materials by different hatchi... X-Git-Url: http://git.dev.opencascade.org/gitweb/?a=commitdiff_plain;h=a6022ca6c9f38e5ec09c6f749642d7b7d94290b6;p=occt-copy.git Revert "0030791: Visualization - possibility to display materials by different hatching style for clipping" This reverts commit 1a716308eacb7f107ec2c69998639efb9c4936ff. --- diff --git a/data/images/hatch_1.png b/data/images/hatch_1.png index 83c0be624d..019d721321 100644 Binary files a/data/images/hatch_1.png and b/data/images/hatch_1.png differ diff --git a/data/images/hatch_1_.png b/data/images/hatch_1_.png deleted file mode 100644 index 4f7fc204be..0000000000 Binary files a/data/images/hatch_1_.png and /dev/null differ diff --git a/data/images/hatch_2.png b/data/images/hatch_2.png deleted file mode 100644 index 0bf87b2f73..0000000000 Binary files a/data/images/hatch_2.png and /dev/null differ diff --git a/data/images/hatch_3.png b/data/images/hatch_3.png deleted file mode 100644 index c89101b323..0000000000 Binary files a/data/images/hatch_3.png and /dev/null differ diff --git a/data/images/hatch_4.png b/data/images/hatch_4.png deleted file mode 100644 index 5e5839ac92..0000000000 Binary files a/data/images/hatch_4.png and /dev/null differ diff --git a/data/images/hatch_5.png b/data/images/hatch_5.png deleted file mode 100644 index bf468b6ab0..0000000000 Binary files a/data/images/hatch_5.png and /dev/null differ diff --git a/data/images/hatch_6.png b/data/images/hatch_6.png deleted file mode 100644 index 7624d86e9f..0000000000 Binary files a/data/images/hatch_6.png and /dev/null differ diff --git a/data/images/hatch_7.png b/data/images/hatch_7.png deleted file mode 100644 index 5f395a201b..0000000000 Binary files a/data/images/hatch_7.png and /dev/null differ diff --git a/data/images/hatch_8.png b/data/images/hatch_8.png deleted file mode 100644 index f580b76a6c..0000000000 Binary files a/data/images/hatch_8.png and /dev/null differ diff --git a/src/AIS/AIS_ColoredShape.cxx b/src/AIS/AIS_ColoredShape.cxx index 24444aa598..22b58730a0 100644 --- a/src/AIS/AIS_ColoredShape.cxx +++ b/src/AIS/AIS_ColoredShape.cxx @@ -637,11 +637,6 @@ void AIS_ColoredShape::addShapesWithCustomProps (const Handle(Prs3d_Presentation { aShadedGroup = thePrs->NewGroup(); aShadedGroup->SetClosed (isClosed); - if (isClosed) - { - if (aDrawer->HasOwnFillCappingAspect()) - aShadedGroup->SetGroupPrimitivesAspect (aDrawer->FillCappingAspect()); - } } aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect()); aShadedGroup->AddPrimitiveArray (aTriangles); diff --git a/src/AIS/AIS_InteractiveObject.cxx b/src/AIS/AIS_InteractiveObject.cxx index 784194acd0..52d203eb97 100644 --- a/src/AIS/AIS_InteractiveObject.cxx +++ b/src/AIS/AIS_InteractiveObject.cxx @@ -18,7 +18,6 @@ #include #include -#include #include #include #include diff --git a/src/AIS/AIS_Shape.cxx b/src/AIS/AIS_Shape.cxx index 997b86c1aa..b1afa4ba80 100644 --- a/src/AIS/AIS_Shape.cxx +++ b/src/AIS/AIS_Shape.cxx @@ -176,7 +176,10 @@ void AIS_Shape::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentat try { OCC_CATCH_SIGNALS - StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myDrawer->FillCappingAspect()); + StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, + myDrawer->ShadingAspect()->Aspect()->ToMapTexture() + && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(), + myUVOrigin, myUVRepeat, myUVScale); } catch (Standard_Failure const& anException) { diff --git a/src/Graphic3d/FILES b/src/Graphic3d/FILES index d5b2299846..69e09418f2 100755 --- a/src/Graphic3d/FILES +++ b/src/Graphic3d/FILES @@ -15,8 +15,6 @@ Graphic3d_Aspects.cxx Graphic3d_Aspects.hxx Graphic3d_AspectFillArea3d.cxx Graphic3d_AspectFillArea3d.hxx -Graphic3d_AspectFillCapping.cxx -Graphic3d_AspectFillCapping.hxx Graphic3d_AspectLine3d.cxx Graphic3d_AspectLine3d.hxx Graphic3d_AspectMarker3d.cxx diff --git a/src/Graphic3d/Graphic3d_AspectFillCapping.cxx b/src/Graphic3d/Graphic3d_AspectFillCapping.cxx deleted file mode 100644 index 3f6bff8042..0000000000 --- a/src/Graphic3d/Graphic3d_AspectFillCapping.cxx +++ /dev/null @@ -1,110 +0,0 @@ -// 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 deleted file mode 100644 index 7df72d60a6..0000000000 --- a/src/Graphic3d/Graphic3d_AspectFillCapping.hxx +++ /dev/null @@ -1,164 +0,0 @@ -// Created on: 2017-04-14 -// Created by: Anton POLETAEV -// Copyright (c) 2017 OPEN CASCADE SAS -// -// This file is part of Open CASCADE Technology software library. -// -// This library is free software; you can redistribute it and/or modify it under -// the terms of the GNU Lesser General Public License version 2.1 as published -// by the Free Software Foundation, with special exception defined in the file -// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT -// distribution for complete text of the license and disclaimer of any warranty. -// -// Alternatively, this file may be used under the terms of Open CASCADE -// commercial license or contractual agreement. - -#ifndef _Graphic3d_AspectFillCapping_HeaderFile -#define _Graphic3d_AspectFillCapping_HeaderFile - -#include -#include -#include -#include -#include -#include -#include - -//! Defines graphical attributes for drawing section planes on solids resulted from clipping (cutting) planes. -class Graphic3d_AspectFillCapping : public Graphic3d_Aspects -{ -public: - - //! Default constructor. - Standard_EXPORT Graphic3d_AspectFillCapping(); - -public: - - //! Sets material for filling section created by clipping. - void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; } - - //! Returns material for filling section created by clipping. - const Graphic3d_MaterialAspect& Material() const { return myMaterial; } - - //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section. - void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); } - - //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section. - Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; } - - //! Sets texture for filling section created by clipping. - void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; } - - //! Returns texture for filling section created by clipping. - const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; } - - //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section. - void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); } - - //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section. - Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; } - - //! Sets OpenGL/GLSL shader program. - void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; } - - //! Returns OpenGL/GLSL shader program. - const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; } - - //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section. - void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); } - - //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section. - Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; } - -public: - - //! Sets style of hatch defined by predefined stipple mask. - Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle); - - //! Sets style of hatch defined by custom stipple mask. - Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle); - - //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used). - Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture); - - //! Sets material style for hatch lines (texture). - Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial); - - //! Returns material style for hatch lines (texture). - const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; } - - //! Sets boolean flag indicating whether the hatch layer should be drawn or not. - Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw); - - //! Returns boolean flag indicating whether the hatch layer should be drawn or not. - Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; } - - //! Sets flag controlling behavior of hatch texture mapping on zooming. - //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming. - Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet); - - //! Returns value of flag controlling behavior of hatch texture mapping on zooming. - Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; } - - //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector. - Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet); - - //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector. - Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; } - - //! Returns true if hatch is defined by texture. - Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); } - - //! Returns texture map defining the hatch. - const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; } - - //! Returns true if hatch is defined by stipple mask. - Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); } - - //! Returns the stipple mask. - const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; } - - //! Returns modification counter for hatching state. - Standard_Size HatchingState() const { return myHatchingState; } - -private: - - enum Flags - { - Flags_None = 0x00, //!< no flags - Flags_UseObjectMaterial = 0x01, //!< use object material - Flags_UseObjectTexture = 0x02, //!< use object texture - Flags_UseObjectShader = 0x04, //!< use object GLSL program - Flags_HatchZoomPersistent = 0x08, //!< zoom-persistent texturing - Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing - Flags_DrawHatching = 0x20, //!< draw hatching - Flags_UseObjectProperties = //!< use entire fill area aspect from object - Flags_UseObjectMaterial - | Flags_UseObjectTexture - | Flags_UseObjectShader - }; - - void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag) - { - myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag; - } - -private: - - Graphic3d_MaterialAspect myMaterial; - Handle(Graphic3d_TextureMap) myTexture; - Handle(Graphic3d_ShaderProgram) myShader; - Handle(Graphic3d_HatchStyle) myStippleHatch; - Handle(Graphic3d_TextureMap) myTextureHatch; - Graphic3d_MaterialAspect myHatchMaterial; - unsigned int myFlags; - Standard_Size myHatchingState; - -public: - - DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Graphic3d_Aspects) -}; - -DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Graphic3d_Aspects) - -#endif // _Graphic3d_AspectFillCapping_HeaderFile diff --git a/src/Graphic3d/Graphic3d_ClipPlane.cxx b/src/Graphic3d/Graphic3d_ClipPlane.cxx index 670ed67809..f248f4c523 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.cxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.cxx @@ -24,6 +24,19 @@ IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient) namespace { static volatile Standard_Integer THE_CLIP_PLANE_COUNTER = 0; + + static Handle(Graphic3d_AspectFillArea3d) defaultAspect() + { + 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 (Quantity_NOC_GRAY20); + anAspect->SetSuppressBackFaces (false); + return anAspect; + } } // ======================================================================= @@ -31,8 +44,19 @@ namespace // purpose : // ======================================================================= Graphic3d_ClipPlane::Graphic3d_ClipPlane() +: myAspect (defaultAspect()), + myPrevInChain(NULL), + myPlane (0.0, 0.0, 1.0, 0.0), + myEquation (0.0, 0.0, 1.0, 0.0), + myEquationRev(0.0, 0.0,-1.0, 0.0), + myChainLenFwd(1), + myFlags (Graphic3d_CappingFlags_None), + myEquationMod(0), + myAspectMod (0), + myIsOn (Standard_True), + myIsCapping (Standard_False) { - init(); + makeId(); } // ======================================================================= @@ -40,8 +64,19 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane() // purpose : // ======================================================================= Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation) +: myAspect (defaultAspect()), + myPrevInChain(NULL), + myPlane (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()), + myEquation (theEquation), + myEquationRev(0.0, 0.0,-1.0, 0.0), + myChainLenFwd(1), + myFlags (Graphic3d_CappingFlags_None), + myEquationMod(0), + myAspectMod (0), + myIsOn (Standard_True), + myIsCapping (Standard_False) { - init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a())); + makeId(); updateInversedPlane(); } @@ -49,27 +84,42 @@ Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation) // function : Graphic3d_ClipPlane // purpose : // ======================================================================= -Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther) -: Standard_Transient (theOther) +Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther) +: Standard_Transient(theOther), + myAspect (defaultAspect()), + myPrevInChain(NULL), + myPlane (theOther.myPlane), + myEquation (theOther.myEquation), + myEquationRev(theOther.myEquationRev), + myChainLenFwd(1), + myFlags (theOther.myFlags), + myEquationMod(0), + myAspectMod (0), + myIsOn (theOther.myIsOn), + myIsCapping (theOther.myIsCapping) { - *mySectionStyle = *theOther.CappingSectionStyle(); - init (theOther.myPlane, - theOther.myEquationRev, - theOther.myIsOn, - theOther.myIsCapping, - theOther.ToOverrideCappingAspect(), - theOther.CappingSectionStyle()); - updateInversedPlane(); + makeId(); + *myAspect = *theOther.CappingAspect(); } // ======================================================================= // function : Graphic3d_ClipPlane // purpose : // ======================================================================= -Graphic3d_ClipPlane::Graphic3d_ClipPlane (const gp_Pln& thePlane) +Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane) +: myAspect (defaultAspect()), + myPrevInChain(NULL), + myPlane (thePlane), + myChainLenFwd(1), + myFlags (Graphic3d_CappingFlags_None), + myEquationMod(0), + myAspectMod (0), + myIsOn (Standard_True), + myIsCapping (Standard_False) { - init (thePlane); + thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); updateInversedPlane(); + makeId(); } // ======================================================================= @@ -81,7 +131,7 @@ void Graphic3d_ClipPlane::SetEquation (const Graphic3d_Vec4d& theEquation) myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()); myEquation = theEquation; updateInversedPlane(); - myOrientationDirty = Standard_True; + myEquationMod++; } // ======================================================================= @@ -93,7 +143,7 @@ void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane) myPlane = thePlane; thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); updateInversedPlane(); - myOrientationDirty = Standard_True; + myEquationMod++; } // ======================================================================= @@ -133,114 +183,128 @@ Handle(Graphic3d_ClipPlane) Graphic3d_ClipPlane::Clone() const // ======================================================================= void Graphic3d_ClipPlane::SetCappingColor (const Quantity_Color& theColor) { - mySectionStyle->SetInteriorColor (theColor); - mySectionStyle->ChangeFrontMaterial().SetColor (theColor); + myAspect->SetInteriorColor (theColor); + myAspect->ChangeFrontMaterial().SetColor (theColor); ++myAspectMod; } // ======================================================================= +// function : SetCappingMaterial // purpose : // ======================================================================= -void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle) +void Graphic3d_ClipPlane::SetCappingMaterial (const Graphic3d_MaterialAspect& theMat) { - mySectionStyle = theStyle; - if (mySectionStyle->FrontMaterial().MaterialType() != Graphic3d_MATERIAL_ASPECT) + myAspect->SetFrontMaterial (theMat); + if (myAspect->FrontMaterial().MaterialType() != Graphic3d_MATERIAL_ASPECT) { + myAspect->SetInteriorColor (theMat.Color()); } + ++myAspectMod; } // ======================================================================= -// function : OrientationMatrix +// function : SetCappingTexture // purpose : // ======================================================================= -const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const +void Graphic3d_ClipPlane::SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture) { - if (myOrientationDirty) + if (!theTexture.IsNull()) { - 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()) + myAspect->SetTextureMapOn(); + Handle(Graphic3d_TextureSet) aTextureSet = myAspect->TextureSet(); + if (aTextureSet.IsNull() || aTextureSet->Size() != 1) { - aSide1[0] = 1.0f; + aTextureSet = new Graphic3d_TextureSet (theTexture); } else { - aSide1[0] = aDirection[2] / aMagintude; - aSide1[2] = -aDirection[0] / aMagintude; + aTextureSet->SetFirst (theTexture); } + myAspect->SetTextureSet (aTextureSet); + } + else + { + myAspect->SetTextureMapOff(); + myAspect->SetTextureSet (Handle(Graphic3d_TextureSet)()); + } + ++myAspectMod; +} - 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); +// ======================================================================= +// function : SetCappingHatch +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::SetCappingHatch (const Aspect_HatchStyle theStyle) +{ + myAspect->SetHatchStyle (theStyle); + ++myAspectMod; +} - myOrientationMat.SetValue (0, 2, aSide2[0]); - myOrientationMat.SetValue (1, 2, aSide2[1]); - myOrientationMat.SetValue (2, 2, aSide2[2]); - myOrientationMat.SetValue (3, 2, 0.0F); +// ======================================================================= +// function : SetCappingCustomHatch +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle) +{ + myAspect->SetHatchStyle (theStyle); + ++myAspectMod; +} - myOrientationMat.SetValue (0, 3, aTranslate[0]); - myOrientationMat.SetValue (1, 3, aTranslate[1]); - myOrientationMat.SetValue (2, 3, aTranslate[2]); - myOrientationMat.SetValue (3, 3, 1.0F); +// ======================================================================= +// function : SetCappingHatchOn +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::SetCappingHatchOn() +{ + myAspect->SetInteriorStyle (Aspect_IS_HATCH); + ++myAspectMod; +} - myOrientationDirty = Standard_False; - } +// ======================================================================= +// function : SetCappingHatchOff +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::SetCappingHatchOff() +{ + myAspect->SetInteriorStyle (Aspect_IS_SOLID); + ++myAspectMod; +} - return myOrientationMat; +// ======================================================================= +// function : SetCappingAspect +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect) +{ + myAspect = theAspect; + ++myAspectMod; } // ======================================================================= -// function : init +// function : setCappingFlag // purpose : // ======================================================================= -void Graphic3d_ClipPlane::init (const gp_Pln& thePlane, - const Graphic3d_Vec4d& theEquationRev, - const Standard_Boolean theIsOn, - const Standard_Boolean theIsCapping, - const Standard_Boolean theOverrideStyle, - const Handle(Graphic3d_AspectFillCapping)& theStyle) +void Graphic3d_ClipPlane::setCappingFlag (bool theToUse, int theFlag) { - if (myEntityUID.IsEmpty()) + if (theToUse) + { + myFlags |= theFlag; + } + else { - myEntityUID = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name() - + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER)); + myFlags &= ~(theFlag); } + ++myAspectMod; +} - myPrevInChain = NULL; - myEquationRev = theEquationRev; - myChainLenFwd = 1; - myPlane = thePlane; - myPlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]); - myIsOn = theIsOn; - myIsCapping = theIsCapping; - myOverrideObjectStyle = theOverrideStyle; - mySectionStyle = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle; - myOrientationDirty = Standard_True; +// ======================================================================= +// function : makeId +// purpose : +// ======================================================================= +void Graphic3d_ClipPlane::makeId() +{ + myId = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name() + + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER)); } // ======================================================================= @@ -262,7 +326,7 @@ void Graphic3d_ClipPlane::updateChainLen() // ======================================================================= void Graphic3d_ClipPlane::SetChainNextPlane (const Handle(Graphic3d_ClipPlane)& thePlane) { - myOrientationDirty = Standard_True; + ++myEquationMod; if (!myNextInChain.IsNull()) { myNextInChain->myPrevInChain = NULL; @@ -285,11 +349,11 @@ void Graphic3d_ClipPlane::DumpJson (Standard_OStream& theOStream, Standard_Integ OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, this) - OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, mySectionStyle.get()) + OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myAspect.get()) OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myNextInChain.get()) OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myPrevInChain) - OCCT_DUMP_FIELD_VALUE_STRING (theOStream, myEntityUID) + OCCT_DUMP_FIELD_VALUE_STRING (theOStream, myId) OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myPlane) diff --git a/src/Graphic3d/Graphic3d_ClipPlane.hxx b/src/Graphic3d/Graphic3d_ClipPlane.hxx index 3af83d537c..cf692d11ec 100755 --- a/src/Graphic3d/Graphic3d_ClipPlane.hxx +++ b/src/Graphic3d/Graphic3d_ClipPlane.hxx @@ -19,12 +19,9 @@ #include #include #include -#include #include #include -#include #include -#include #include #include #include @@ -170,11 +167,49 @@ public: public: // @name user-defined graphical attributes //! Return color for rendering capping surface. - Quantity_Color CappingColor() const { return mySectionStyle->FrontMaterial().MaterialType() == Graphic3d_MATERIAL_ASPECT ? mySectionStyle->FrontMaterial().Color() : mySectionStyle->InteriorColor(); } + Quantity_Color CappingColor() const { return myAspect->FrontMaterial().MaterialType() == Graphic3d_MATERIAL_ASPECT ? myAspect->FrontMaterial().Color() : myAspect->InteriorColor(); } //! Set color for rendering capping surface. Standard_EXPORT void SetCappingColor (const Quantity_Color& theColor); + //! 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 @@ -185,18 +220,41 @@ public: // @name user-defined graphical attributes //! @return clip plane resource identifier string. const TCollection_AsciiString& GetId() const { - return myEntityUID; + return myId; } public: - //! Returns style used for drawing capping section. + //! Return capping aspect. //! @return capping surface rendering aspect. - const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; } + const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; } - //! Sets clipping section filling aspect. - Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle); + //! Assign capping aspect. + Standard_EXPORT void SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect); + //! Flag indicating whether material for capping plane should be taken from object. + //! Default value: FALSE (use dedicated capping plane material). + bool ToUseObjectMaterial() const { return (myFlags & Graphic3d_CappingFlags_ObjectMaterial) != 0; } + + //! Set flag for controlling the source of capping plane material. + void SetUseObjectMaterial (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectMaterial); } + + //! Flag indicating whether texture for capping plane should be taken from object. + //! Default value: FALSE. + bool ToUseObjectTexture() const { return (myFlags & Graphic3d_CappingFlags_ObjectTexture) != 0; } + + //! Set flag for controlling the source of capping plane texture. + void SetUseObjectTexture (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectTexture); } + + //! Flag indicating whether shader program for capping plane should be taken from object. + //! Default value: FALSE. + bool ToUseObjectShader() const { return (myFlags & Graphic3d_CappingFlags_ObjectShader) != 0; } + + //! Set flag for controlling the source of capping plane shader program. + void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); } + + //! Return true if some fill area aspect properties should be taken from object. + bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; } public: @@ -335,25 +393,14 @@ public: // @name modification counters { return myAspectMod; } - //! Flag indicating whether section style of the plane should overrides similar property of object presentation. - //! Default value: FALSE (use dedicated presentation aspect style). - bool ToOverrideCappingAspect() const { return myOverrideObjectStyle; } - - //! Sets flag for controlling the preference of using section style between clip plane and object. - void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; } - - //! Returns plane's orientation matrix. - Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const; private: - //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities. - void init (const gp_Pln& thePlane = gp_Pln(), - const Graphic3d_Vec4d& theEquationRev = Graphic3d_Vec4d(0.0, 0.0,-1.0, 0.0), - const Standard_Boolean theIsOn = Standard_True, - const Standard_Boolean theIsCapping = Standard_False, - const Standard_Boolean theOverrideStyle = Standard_False, - const Handle(Graphic3d_AspectFillCapping)& theStyle = Handle(Graphic3d_AspectFillCapping)()); + //! Generate unique object id for OpenGL graphic resource manager. + void makeId(); + + //! Set capping flag. + Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag); //! Update chain length in backward direction. void updateChainLen(); @@ -368,10 +415,10 @@ private: private: - Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section. + Handle(Graphic3d_AspectFillArea3d) myAspect; //!< fill area aspect Handle(Graphic3d_ClipPlane) myNextInChain; //!< next plane in a chain of planes defining logical AND operation Graphic3d_ClipPlane* myPrevInChain; //!< previous plane in a chain of planes defining logical AND operation - TCollection_AsciiString myEntityUID; //!< Unique identifier for the plane + TCollection_AsciiString myId; //!< resource id gp_Pln myPlane; //!< plane definition Graphic3d_Vec4d myEquation; //!< plane equation vector Graphic3d_Vec4d myEquationRev; //!< reversed plane equation @@ -381,9 +428,6 @@ private: unsigned int myAspectMod; //!< modification counter of aspect Standard_Boolean myIsOn; //!< state of the clipping plane Standard_Boolean myIsCapping; //!< state of graphic driver capping - Standard_Boolean myOverrideObjectStyle; //!< Flag forcing to use plane's section style rather than section style defined for object - mutable Standard_Boolean myOrientationDirty; //!< Boolean flag indicating whether orientation matrix is dirty or not. - mutable Graphic3d_Mat4 myOrientationMat; //!< Plane orientation matrix (for visualization purposes). }; diff --git a/src/Graphic3d/Graphic3d_Group.hxx b/src/Graphic3d/Graphic3d_Group.hxx index 022656245d..fb6748302e 100644 --- a/src/Graphic3d/Graphic3d_Group.hxx +++ b/src/Graphic3d/Graphic3d_Group.hxx @@ -37,7 +37,6 @@ class Graphic3d_Structure; class Graphic3d_ArrayOfPrimitives; -class Graphic3d_AspectFillCapping; class Graphic3d_Text; //! This class allows the definition of groups @@ -106,9 +105,6 @@ public: //! Modifies the current context of the group to give another aspect for all the primitives created after this call in the group. virtual void SetPrimitivesAspect (const Handle(Graphic3d_Aspects)& theAspect) = 0; - //! Returns style of filling clipping sections on closed shell primitives. - virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const = 0; - //! Update presentation aspects after their modification. virtual void SynchronizeAspects() = 0; diff --git a/src/Graphic3d/Graphic3d_GroupAspect.hxx b/src/Graphic3d/Graphic3d_GroupAspect.hxx index ca53a75a37..6aff132f41 100644 --- a/src/Graphic3d/Graphic3d_GroupAspect.hxx +++ b/src/Graphic3d/Graphic3d_GroupAspect.hxx @@ -21,15 +21,13 @@ //! - 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; -//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections. +//! - ASPECT_FILL_AREA: aspect for face primitives. enum Graphic3d_GroupAspect { Graphic3d_ASPECT_LINE, Graphic3d_ASPECT_TEXT, Graphic3d_ASPECT_MARKER, -Graphic3d_ASPECT_FILL_AREA, -Graphic3d_ASPECT_FILL_CAPPING +Graphic3d_ASPECT_FILL_AREA }; #endif // _Graphic3d_GroupAspect_HeaderFile diff --git a/src/OpenGl/OpenGl_CappingAlgo.cxx b/src/OpenGl/OpenGl_CappingAlgo.cxx index 42abdf834f..7a8fdec098 100755 --- a/src/OpenGl/OpenGl_CappingAlgo.cxx +++ b/src/OpenGl/OpenGl_CappingAlgo.cxx @@ -21,16 +21,11 @@ #include #include #include -#include #include #include namespace { - static const OpenGl_CappingPlaneResource* THE_DEFAULT_ASPECT = new OpenGl_CappingPlaneResource (new Graphic3d_AspectFillCapping); - static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingAlgo_Quad"; - static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingAlgo_CappingStyle_"; - //! Auxiliary sentry object managing stencil test. struct StencilTestSentry { @@ -63,113 +58,21 @@ namespace GLint myDepthFuncPrev; }; - class OpenGl_SharedElement : public OpenGl_Resource - { - public: - OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {} - virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE - { - OpenGl_Element::Destroy (theGlCtx, myGlElement); - } - OpenGl_Element* GlElement() const { return myGlElement; } - - //! Returns estimated GPU memory usage for holding data without considering overheads and allocation alignment rules. - Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; } - - private: - OpenGl_Element* myGlElement; - - public: - - DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource) - }; - - //! Iitializes and returns vertex buffer for plane section - OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext) - { - Handle(OpenGl_SharedElement) aSharedResource; - - if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource)) - { - aSharedResource = new OpenGl_SharedElement (OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()); - theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource); - } - - return dynamic_cast (aSharedResource->GlElement()); - } - - //! Render section plane using the given aspects. - void renderSection (const Handle(OpenGl_Workspace)& theWorkspace, - const OpenGl_PrimitiveArray* theQuad, - const OpenGl_Aspects* theCappingAspect, - const OpenGl_Aspects* theHatchAspect, - const OpenGl_Mat4& theCappingMatrix, - const Standard_ShortReal theHatchScale, - const Standard_ShortReal theHatchRotate) + //! 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 Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); const bool wasCullAllowed = theWorkspace->SetAllowFaceCulling (true); - const Standard_Boolean isTextureHatch = - theHatchAspect != NULL - && theHatchAspect->Aspect()->TextureMapState(); - + // set identity model matrix aContext->ModelWorldState.Push(); - aContext->ModelWorldState.SetCurrent (theCappingMatrix); + aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat)); aContext->ApplyModelViewMatrix(); - theWorkspace->SetAspects (theCappingAspect); - theWorkspace->ApplyAspects(); - - theQuad->Render (theWorkspace); - - if (theHatchAspect != NULL) - { - Graphic3d_Vec2 aPrevScale; - Standard_ShortReal aPrevRotate = 0.0; - - if (isTextureHatch) - { - glEnable (GL_BLEND); - glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - - if ((theHatchScale != 1.0 || theHatchRotate != 0.0) && !theHatchAspect->TextureSet(aContext)->IsEmpty()) - { - Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First(); - const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters(); - - aPrevScale = aTexParams->Scale(); - aPrevRotate = aTexParams->Rotation(); - - const Standard_Boolean isMirror = aPrevScale.x() * aPrevScale.y() < 0.0; - aTexParams->SetScale (aPrevScale * theHatchScale); - aTexParams->SetRotation (isMirror ? aPrevRotate - theHatchRotate : aPrevRotate + theHatchRotate); - } - } - - theWorkspace->SetAspects (theHatchAspect); - theWorkspace->ApplyAspects(); - - glDepthFunc (GL_LEQUAL); - - theQuad->Render (theWorkspace); - - glDepthFunc (GL_LESS); - - if (isTextureHatch) - { - glDisable (GL_BLEND); - - if (theHatchScale != 1.0 || theHatchRotate != 0.0) - { - Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First(); - const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters(); - - aTexParams->SetScale (aPrevScale); - aTexParams->SetRotation (aPrevRotate); - } - } - } + thePlane->Primitives().Render (theWorkspace); aContext->ModelWorldState.Pop(); aContext->ApplyModelViewMatrix(); @@ -213,23 +116,13 @@ namespace const OpenGl_Structure& theStructure, const Handle(Graphic3d_ClipPlane)& theClipChain, const Standard_Integer theSubPlaneIndex, - const Handle(OpenGl_CappingPlaneResource)& thePlane, - const OpenGl_PrimitiveArray* theQuad) + const Handle(OpenGl_CappingPlaneResource)& thePlane) { const Standard_Integer aPrevFilter = theWorkspace->RenderFilter(); const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly); - const Handle(Graphic3d_ClipPlane)& aPlane = theClipChain; - const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext(); - const Handle(Graphic3d_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; - + const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane(); for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next()) { if (!aGroupIter.Value()->IsClosed()) @@ -245,6 +138,16 @@ namespace // clear stencil only if something has been actually drawn theStencilSentry.Init(); + // check if capping plane should be rendered within current pass (only opaque / only transparent) + const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL; + thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)()); + theWorkspace->SetAspects (thePlane->AspectFace()); + theWorkspace->SetRenderFilter (aPrevFilter); + if (!theWorkspace->ShouldRender (&thePlane->Primitives())) + { + continue; + } + // suppress only opaque/transparent filter since for filling stencil the whole geometry should be drawn theWorkspace->SetRenderFilter (anAnyFilter); @@ -253,7 +156,7 @@ namespace aContext->ShaderManager()->UpdateClippingState(); glClear (GL_STENCIL_BUFFER_BIT); - glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + const bool aColorMaskBack = aContext->SetColorMask (false); // override aspects, disable culling theWorkspace->SetAspects (&theWorkspace->NoneCulling()); @@ -272,7 +175,20 @@ namespace glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT); // render closed primitives - aGroupIter.Value()->Render (theWorkspace); + 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->SetAspects (&theWorkspace->FrontCulling()); @@ -283,7 +199,7 @@ namespace aContext->ShaderManager()->UpdateClippingState(); // render capping plane using the generated stencil mask - glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + aContext->SetColorMask (aColorMaskBack); if (theWorkspace->UseDepthWrite()) { glDepthMask (GL_TRUE); @@ -295,69 +211,8 @@ namespace glEnable (GL_DEPTH_TEST); } - const OpenGl_Aspects* aGroupAspectFace = aGroupIter.Value()->GlAspects(); - const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping(); - const OpenGl_CappingPlaneResource* anAspectCapping = - thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect()) - ? thePlane.get() - : aGroupAspectCapping; - - if (anAspectCapping == NULL) - { - anAspectCapping = THE_DEFAULT_ASPECT; - } - - const OpenGl_Aspects* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace); - const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch(); - const OpenGl_Aspects* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL; - const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull(); - const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent(); - const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent(); - - Standard_ShortReal aHatchScale = 1.0; - Standard_ShortReal aHatchAngle = 0.0; - - if (isRotatePers || isZoomPers) - { - - if (isRotatePers) - { - if (aRotateAngle == 0.0) - { - const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0)); - const gp_Dir aPlaneUp (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2)); - const gp_Dir& aCameraUp = aCamera->Up(); - const gp_Vec aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp; - if (aCameraPln.Magnitude() > Precision::Confusion()) - { - const gp_Dir& aCameraDir = aCamera->Direction(); - aRotateAngle = static_cast (aCameraPln.AngleWithRef (aPlaneUp, aCameraDir) / M_PI * 180.0); - } - } - - aHatchAngle = aRotateAngle; - } - - if (isZoomPers) - { - if (aViewScale == ShortRealLast()) - { - const Standard_Real aFocus = aCamera->IsOrthographic() - ? aCamera->Distance() - : (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative - ? Standard_Real(aCamera->ZFocus() * aCamera->Distance()) - : Standard_Real(aCamera->ZFocus())); - - const gp_XYZ aViewDim = aCamera->ViewDimensions (aFocus); - aViewScale = static_cast (aViewDim.Y() / aContext->Viewport()[3]); - } - - if (!anAspectHatching->TextureSet(aContext)->IsEmpty()) - aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureSet(aContext)->First()->SizeY()); - } - } - - renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle); + theWorkspace->SetAspects (thePlane->AspectFace()); + renderPlane (theWorkspace, thePlane); // turn on the current plane to restore initial state aContext->ChangeClipping().ResetCappingFilter(); @@ -367,7 +222,7 @@ namespace if (theStructure.InstancedStructure() != NULL) { - renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad); + renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane); } } } @@ -386,12 +241,6 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks return; } - const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext); - if (!aCappingQuad) - { - return; - } - // remember current aspect face defined in workspace const OpenGl_Aspects* aFaceAsp = theWorkspace->Aspects(); @@ -400,16 +249,6 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks theWorkspace->SetRenderFilter (aPrevFilter | OpenGl_RenderFilter_FillModeOnly); StencilTestSentry aStencilSentry; - GLboolean aPrevBlend = glIsEnabled (GL_BLEND); - GLint aPrevBlendSrc = GL_ONE; - GLint aPrevBlendDst = GL_ZERO; - if (aPrevBlend == GL_TRUE) - { - glGetIntegerv (GL_BLEND_SRC_ALPHA, &aPrevBlendSrc); - glGetIntegerv (GL_BLEND_DST_ALPHA, &aPrevBlendDst); - glDisable (GL_BLEND); - } - // generate capping for every clip plane for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next()) { @@ -425,33 +264,23 @@ void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorks for (const Graphic3d_ClipPlane* aSubPlaneIter = aClipChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex) { // get resource for the plane - const TCollection_AsciiString& aResId = THE_PLANE_STYLE + aSubPlaneIter->GetId(); + const TCollection_AsciiString& aResId = aSubPlaneIter->GetId(); Handle(OpenGl_CappingPlaneResource) aPlaneRes; if (!aContext->GetResource (aResId, aPlaneRes)) { // share and register for release once the resource is no longer used - aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter->CappingSectionStyle()); + aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter); aContext->ShareResource (aResId, aPlaneRes); } - renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes, aCappingQuad); + renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes); // set delayed resource release aPlaneRes.Nullify(); - if (!aResId.IsEmpty()) - { - // schedule release of resource if not used - aContext->ReleaseResource (aResId, Standard_True); - } + aContext->ReleaseResource (aResId, Standard_True); } } - if (aPrevBlend == GL_TRUE) - { - glEnable (GL_BLEND); - glBlendFunc (aPrevBlendSrc, aPrevBlendDst); - } - // restore rendering aspects theWorkspace->SetAspects (aFaceAsp); theWorkspace->SetRenderFilter (aPrevFilter); diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.cxx b/src/OpenGl/OpenGl_CappingPlaneResource.cxx index eb543f1ea3..6825aefea1 100755 --- a/src/OpenGl/OpenGl_CappingPlaneResource.cxx +++ b/src/OpenGl/OpenGl_CappingPlaneResource.cxx @@ -56,28 +56,21 @@ namespace { 0.0f, 0.0f, 0.0f, 1.0f } } }; - Handle(Graphic3d_Aspects) defaultMaterial() - { - Handle(Graphic3d_AspectFillArea3d) anAspect; - const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT); - anAspect = new Graphic3d_AspectFillArea3d(); - anAspect->SetDistinguishOff(); - anAspect->SetFrontMaterial (aMaterial); - anAspect->SetInteriorStyle (Aspect_IS_SOLID); - anAspect->SetInteriorColor (aMaterial.Color()); - anAspect->SetSuppressBackFaces (false); - return anAspect; - } } // ======================================================================= -// function : BuildInfinitPlaneVertices +// function : OpenGl_CappingPlaneResource // purpose : // ======================================================================= -OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices() +OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane) +: myPrimitives (NULL), + myOrientation (OpenGl_IdentityMatrix), + myAspect (NULL), + myPlaneRoot (thePlane), + myEquationMod ((unsigned int )-1), + myAspectMod ((unsigned int )-1) { - OpenGl_PrimitiveArray* aPrimitives = NULL; // Fill primitive array Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16); Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc); @@ -90,26 +83,8 @@ OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices() if (anAttribs->Init (12, anAttribInfo, 3)) { memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS)); - - aPrimitives = new OpenGl_PrimitiveArray (NULL); - aPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL); + myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL); } - return aPrimitives; -} - -// ======================================================================= -// function : OpenGl_CappingPlaneResource -// purpose : -// ======================================================================= -OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect) -: myCappingAspect(),//defaultMaterial()), - myHatchingAspect(),//defaultMaterial()), - myHatchingState (0) -{ - myCappingAspect.SetAspect (defaultMaterial()); - myHatchingAspect.SetAspect (defaultMaterial()); - - SetAspect (theAspect); } // ======================================================================= @@ -118,83 +93,18 @@ OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d // ======================================================================= OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource() { + Release (NULL); } // ======================================================================= -// function : SetAspect +// function : Update // purpose : // ======================================================================= -void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) +void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx, + const Handle(Graphic3d_Aspects)& theObjAspect) { - myAspect = theAspect; - - if (theAspect.IsNull()) - { - return; - } - - if (!theAspect->ToUseObjectMaterial() - || !theAspect->ToUseObjectTexture() - || !theAspect->ToUseObjectShader()) - { - Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect(); - - if (!theAspect->ToUseObjectMaterial()) - { - aFillAspect->SetFrontMaterial (theAspect->Material()); - aFillAspect->SetInteriorColor (theAspect->Material().Color()); - } - - if (!theAspect->ToUseObjectTexture()) - { - aFillAspect->SetTextureMap (theAspect->Texture()); - - if (!theAspect->Texture().IsNull()) - { - aFillAspect->SetTextureMapOn(); - } - else - { - aFillAspect->SetTextureMapOff(); - } - } - else - { - aFillAspect->SetTextureMap (Handle(Graphic3d_TextureMap)()); - aFillAspect->SetTextureMapOff(); - } - - if (!theAspect->ToUseObjectShader()) - { - aFillAspect->SetShaderProgram (theAspect->Shader()); - } - - myCappingAspect.SetAspect (aFillAspect); - } - - if (theAspect->ToDrawHatch() - && (theAspect->IsTextureHatch() - || theAspect->IsStippleHatch())) - { - Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect(); - - aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID); - aFillAspect->SetHatchStyle (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)()); - aFillAspect->SetTextureMap (theAspect->IsTextureHatch() ? theAspect->TextureHatch() : Handle(Graphic3d_TextureMap)()); - aFillAspect->SetFrontMaterial (theAspect->HatchMaterial()); - aFillAspect->SetInteriorColor (theAspect->HatchMaterial().Color()); - if (theAspect->IsTextureHatch()) - { - aFillAspect->SetTextureMapOn(); - } - else - { - aFillAspect->SetTextureMapOff(); - } - - myHatchingAspect.SetAspect (aFillAspect); - myHatchingState = theAspect->HatchingState(); - } + updateTransform (theCtx); + updateAspect (theObjAspect); } // ======================================================================= @@ -203,109 +113,123 @@ void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCa // ======================================================================= void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext) { - myCappingAspect .Release (theContext); - myHatchingAspect.Release (theContext); + OpenGl_Element::Destroy (theContext, myAspect); + myPrimitives.Release (theContext); + myEquationMod = (unsigned int )-1; + myAspectMod = (unsigned int )-1; } // ======================================================================= -// function : CappingFaceAspect +// function : updateAspect // purpose : // ======================================================================= -const OpenGl_Aspects* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const +void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& theObjAspect) { - if (myAspect.IsNull()) + if (myAspect == NULL) { - return NULL; + myAspect = new OpenGl_Aspects(); + myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync } - Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect(); + if (theObjAspect.IsNull()) + { + if (myAspectMod != myPlaneRoot->MCountAspect()) + { + myAspect->SetAspect (myPlaneRoot->CappingAspect()); + myAspectMod = myPlaneRoot->MCountAspect(); + } + return; + } - if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL) + if (myFillAreaAspect.IsNull()) { - // only front material currently supported by capping rendering - aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial()); - aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor()); + myFillAreaAspect = new Graphic3d_AspectFillArea3d(); } - else + if (myAspectMod != myPlaneRoot->MCountAspect()) { - aFillAspect->SetFrontMaterial (myAspect->Material()); - aFillAspect->SetInteriorColor (myAspect->Material().Color()); + *myFillAreaAspect = *myPlaneRoot->CappingAspect(); } - if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL) + if (myPlaneRoot->ToUseObjectMaterial()) { - if (theObjectAspect->Aspect()->ToMapTexture()) - { - aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap()); - aFillAspect->SetTextureMapOn(); - } - else - { - aFillAspect->SetTextureMapOff(); - } + // only front material currently supported by capping rendering + myFillAreaAspect->SetFrontMaterial (theObjAspect->FrontMaterial()); + myFillAreaAspect->SetInteriorColor (theObjAspect->InteriorColor()); } - else + if (myPlaneRoot->ToUseObjectTexture()) { - aFillAspect->SetTextureMap (myAspect->Texture()); - if (!myAspect->Texture().IsNull()) + myFillAreaAspect->SetTextureSet (theObjAspect->TextureSet()); + if (theObjAspect->ToMapTexture()) { - aFillAspect->SetTextureMapOn(); + myFillAreaAspect->SetTextureMapOn(); } else { - aFillAspect->SetTextureMapOff(); + myFillAreaAspect->SetTextureMapOff(); } } - - if (myAspect->ToUseObjectShader() && theObjectAspect != NULL) + if (myPlaneRoot->ToUseObjectShader()) { - aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram()); + myFillAreaAspect->SetShaderProgram (theObjAspect->ShaderProgram()); } - else - { - aFillAspect->SetShaderProgram (myAspect->Shader()); - } - - myCappingAspect.SetAspect (aFillAspect); - return &myCappingAspect; + myAspect->SetAspect (myFillAreaAspect); } // ======================================================================= -// function : HatchingFaceAspect +// function : updateTransform // purpose : // ======================================================================= -const OpenGl_Aspects* OpenGl_CappingPlaneResource::HatchingFaceAspect() const +void OpenGl_CappingPlaneResource::updateTransform (const Handle(OpenGl_Context)& theCtx) { - if (myAspect.IsNull()) + if (myEquationMod == myPlaneRoot->MCountEquation() + && myLocalOrigin.IsEqual (theCtx->ShaderManager()->LocalOrigin(), gp::Resolution())) { - return NULL; + return; // nothing to update } - const Standard_Size aHatchingState = myAspect->HatchingState(); - if (myHatchingState != aHatchingState) - { - if (myAspect->ToDrawHatch()) - { - Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect(); + myEquationMod = myPlaneRoot->MCountEquation(); + myLocalOrigin = theCtx->ShaderManager()->LocalOrigin(); - 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; - } + const Graphic3d_ClipPlane::Equation& anEq = myPlaneRoot->GetEquation(); + const Standard_Real anEqW = theCtx->ShaderManager()->LocalClippingPlaneW (*myPlaneRoot); + + // re-evaluate infinite plane transformation matrix + const Graphic3d_Vec3 aNorm (anEq.xyz()); + const Graphic3d_Vec3 T (anEq.xyz() * -anEqW); + + // project plane normal onto OX to find left vector + const Standard_ShortReal aProjLen = sqrt ((Standard_ShortReal)anEq.xz().SquareModulus()); + Graphic3d_Vec3 aLeft; + if (aProjLen < ShortRealSmall()) + { + aLeft[0] = 1.0f; + } + else + { + aLeft[0] = aNorm[2] / aProjLen; + aLeft[2] = -aNorm[0] / aProjLen; } - return &myHatchingAspect; + const Graphic3d_Vec3 F = Graphic3d_Vec3::Cross (-aLeft, aNorm); + + myOrientation.mat[0][0] = aLeft[0]; + myOrientation.mat[0][1] = aLeft[1]; + myOrientation.mat[0][2] = aLeft[2]; + myOrientation.mat[0][3] = 0.0f; + + myOrientation.mat[1][0] = aNorm[0]; + myOrientation.mat[1][1] = aNorm[1]; + myOrientation.mat[1][2] = aNorm[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; } diff --git a/src/OpenGl/OpenGl_CappingPlaneResource.hxx b/src/OpenGl/OpenGl_CappingPlaneResource.hxx index 4a07006dc7..9547b82b3e 100755 --- a/src/OpenGl/OpenGl_CappingPlaneResource.hxx +++ b/src/OpenGl/OpenGl_CappingPlaneResource.hxx @@ -20,7 +20,7 @@ #include #include #include -#include +#include class OpenGl_CappingPlaneResource; DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource) @@ -30,23 +30,25 @@ DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource) //! This resource holds data necessary for OpenGl_CappingAlgo. //! This object is implemented as OpenGl resource for the following reasons: //! - one instance should be shared between contexts. -//! - instance associated to Graphic3d_AspectFillCapping data. +//! - 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: - //! Create and assign style. - Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect); + //! 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(); - //! Assign section style. - Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect); - - //! Returns section style parameters. - const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myAspect; } + //! Update resource data in the passed context. + //! @param theContext [in] the context + //! @param theObjAspect [in] object aspect + Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext, + const Handle(Graphic3d_Aspects)& theObjAspect); //! Release associated OpenGl resources. //! @param theContext [in] the resource context. @@ -55,23 +57,17 @@ public: //! Returns estimated GPU memory usage - not implemented. virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; } - //! @return primitive array of vertices to render infinite plane. - static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices(); + //! Return parent clipping plane structure. + const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; } - //! Returns true if capping should draw hatch layer. - Standard_Boolean ToDrawHatch() const - { - return myAspect->ToDrawHatch() - && (myAspect->IsStippleHatch() - || myAspect->IsTextureHatch()); - } + //! @return aspect face for rendering capping surface. + inline const OpenGl_Aspects* AspectFace() const { return myAspect; } - //! Returns the shading aspect for drawing face of a clipping section itself. - //! @param theObjectAspect [in] the aspect of an object if it requires combining. - Standard_EXPORT const OpenGl_Aspects* CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const; + //! @return evaluated orientation matrix to transform infinite plane. + inline const OpenGl_Matrix* Orientation() const { return &myOrientation; } - //! Returns the shading aspect for drawing hatch layer of a section. - Standard_EXPORT const OpenGl_Aspects* HatchingFaceAspect() const; + //! @return primitive array of vertices to render infinite plane. + inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; } private: @@ -83,11 +79,14 @@ private: private: - Handle(Graphic3d_AspectFillCapping) myAspect; //!< Section style settings from application's level. - mutable OpenGl_Aspects myCappingAspect; //!< GL aspect for shading base layer of a capping section. - mutable OpenGl_Aspects myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section. - mutable Standard_Size myHatchingState; - gp_XYZ myLocalOrigin; //!< layer origin + OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering + OpenGl_Matrix myOrientation; //!< plane transformation matrix. + OpenGl_Aspects* myAspect; //!< capping face aspect. + Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure. + Handle(Graphic3d_Aspects) myFillAreaAspect;//!< own capping aspect + gp_XYZ myLocalOrigin; //!< layer origin + unsigned int myEquationMod; //!< modification counter for plane equation. + unsigned int myAspectMod; //!< modification counter for aspect. public: diff --git a/src/OpenGl/OpenGl_Group.cxx b/src/OpenGl/OpenGl_Group.cxx index f8c8cb8691..9cdd80ac11 100644 --- a/src/OpenGl/OpenGl_Group.cxx +++ b/src/OpenGl/OpenGl_Group.cxx @@ -25,7 +25,6 @@ #include #include -#include #include IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Group,Graphic3d_Group) @@ -91,20 +90,6 @@ void OpenGl_Group::SetGroupPrimitivesAspect (const Handle(Graphic3d_Aspects)& th return; } - if (!theAspect.IsNull() && theAspect->IsKind (STANDARD_TYPE(Graphic3d_AspectFillCapping))) - { - Handle(Graphic3d_AspectFillCapping) aFillCappingAspect = Handle(Graphic3d_AspectFillCapping)::DownCast (theAspect); - if (myAspectFillCapping == NULL) - { - myAspectFillCapping = new OpenGl_CappingPlaneResource (aFillCappingAspect); - } - else - { - myAspectFillCapping->SetAspect (aFillCappingAspect); - } - return; - } - if (myAspects == NULL) { myAspects = new OpenGl_Aspects (theAspect); diff --git a/src/OpenGl/OpenGl_Group.hxx b/src/OpenGl/OpenGl_Group.hxx index 98d84384a5..cd76dd2399 100644 --- a/src/OpenGl/OpenGl_Group.hxx +++ b/src/OpenGl/OpenGl_Group.hxx @@ -21,7 +21,6 @@ #include #include -#include #include class OpenGl_Group; @@ -100,17 +99,6 @@ public: //! Is the group ray-tracable (contains ray-tracable elements)? Standard_Boolean IsRaytracable() const { return myIsRaytracable; } - //! Returns section style aspect. - virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const Standard_OVERRIDE - { - return myAspectFillCapping != NULL - ? myAspectFillCapping->Aspect() - : Handle(Graphic3d_AspectFillCapping)(); - } - - //! Returns OpenGL capping filling aspect. - const OpenGl_CappingPlaneResource* AspectFillCapping() const { return myAspectFillCapping; } - //! Dumps the content of me into the stream Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE; @@ -121,7 +109,6 @@ protected: protected: OpenGl_Aspects* myAspects; - OpenGl_CappingPlaneResource* myAspectFillCapping; OpenGl_ElementNode* myFirst; OpenGl_ElementNode* myLast; Standard_Boolean myIsRaytracable; diff --git a/src/Prs3d/Prs3d_Drawer.cxx b/src/Prs3d/Prs3d_Drawer.cxx index ef854d803e..4d5e0a8891 100644 --- a/src/Prs3d/Prs3d_Drawer.cxx +++ b/src/Prs3d/Prs3d_Drawer.cxx @@ -15,7 +15,6 @@ #include #include -#include #include #include #include @@ -106,9 +105,7 @@ Prs3d_Drawer::Prs3d_Drawer() myHasOwnDimLengthModelUnits (Standard_False), myHasOwnDimAngleModelUnits (Standard_False), myHasOwnDimLengthDisplayUnits (Standard_False), - myHasOwnDimAngleDisplayUnits (Standard_False), - - myHasOwnFillCappingAspect (Standard_False) + myHasOwnDimAngleDisplayUnits (Standard_False) { myDimensionModelUnits.SetLengthUnits ("m"); myDimensionModelUnits.SetAngleUnits ("rad"); @@ -406,27 +403,6 @@ void Prs3d_Drawer::SetDimensionAspect (const Handle(Prs3d_DimensionAspect)& theA myHasOwnDimensionAspect = !myDimensionAspect.IsNull(); } -// ======================================================================= -// function : FillCappingAspect -// purpose : -// ======================================================================= - -const Handle(Graphic3d_AspectFillCapping)& Prs3d_Drawer::FillCappingAspect() -{ - return myFillCappingAspect; -} - -// ======================================================================= -// function : SetFillCappingAspect -// purpose : -// ======================================================================= - -void Prs3d_Drawer::SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) -{ - myFillCappingAspect = theAspect; - myHasOwnFillCappingAspect = !myFillCappingAspect.IsNull(); -} - // ======================================================================= // function : SetDimLengthModelUnits // purpose : diff --git a/src/Prs3d/Prs3d_Drawer.hxx b/src/Prs3d/Prs3d_Drawer.hxx index 1c13fa45d2..743b866995 100644 --- a/src/Prs3d/Prs3d_Drawer.hxx +++ b/src/Prs3d/Prs3d_Drawer.hxx @@ -31,7 +31,6 @@ #include #include -class Graphic3d_AspectFillCapping; class Prs3d_IsoAspect; class Prs3d_LineAspect; class Prs3d_TextAspect; @@ -710,16 +709,6 @@ public: //! the appearance of dimensions that overrides the one in the link. Standard_Boolean HasOwnDimensionAspect() const { return myHasOwnDimensionAspect; } - //! Returns style for filling capping section created by clipping planes. - Standard_EXPORT const Handle(Graphic3d_AspectFillCapping)& FillCappingAspect(); - - //! Set style of filling capping section created by clipping planes. - Standard_EXPORT void SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theStyle); - - //! Returns true if the drawer has its own attribute for - //! the appearance of dimensions that overrides the one in the link. - Standard_Boolean HasOwnFillCappingAspect() const { return myHasOwnFillCappingAspect; } - //! Sets dimension length model units for computing of dimension presentation. //! The method sets value owned by the drawer that will be used during //! visualization instead of the one set in link. @@ -923,10 +912,6 @@ protected: Prs3d_DimensionUnits myDimensionDisplayUnits; Standard_Boolean myHasOwnDimLengthDisplayUnits; Standard_Boolean myHasOwnDimAngleDisplayUnits; - - Handle(Graphic3d_AspectFillCapping) myFillCappingAspect; - Standard_Boolean myHasOwnFillCappingAspect; - }; Standard_DEPRECATED("Class name is deprecated - use Prs3d_Drawer instead") diff --git a/src/StdPrs/StdPrs_ShadedShape.cxx b/src/StdPrs/StdPrs_ShadedShape.cxx index 6110878035..ca30cd58ac 100644 --- a/src/StdPrs/StdPrs_ShadedShape.cxx +++ b/src/StdPrs/StdPrs_ShadedShape.cxx @@ -285,7 +285,6 @@ namespace static Standard_Boolean shadeFromShape (const TopoDS_Shape& theShape, const Handle(Prs3d_Presentation)& thePrs, const Handle(Prs3d_Drawer)& theDrawer, - const Handle(Graphic3d_AspectFillCapping)& theCappingStyle, const Standard_Boolean theHasTexels, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, @@ -301,9 +300,6 @@ 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; } @@ -526,12 +522,11 @@ void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape& theShape, void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, - const Handle(Graphic3d_AspectFillCapping)& theCappingStyle, const StdPrs_Volume theVolume) { gp_Pnt2d aDummy; StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer, - Standard_False, aDummy, aDummy, aDummy, theCappingStyle, theVolume); + Standard_False, aDummy, aDummy, aDummy, theVolume); } // ======================================================================= @@ -545,7 +540,6 @@ void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, const gp_Pnt2d& theUVScale, - const Handle(Graphic3d_AspectFillCapping)& theCappingStyle, const StdPrs_Volume theVolume) { if (theShape.IsNull()) @@ -583,20 +577,20 @@ void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs, if (aClosed.NbChildren() > 0) { - shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle, + shadeFromShape (aClosed, thePrs, theDrawer, theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true); } if (anOpened.NbChildren() > 0) { - shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle, + shadeFromShape (anOpened, thePrs, theDrawer, 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, theCappingStyle, + shadeFromShape (theShape, thePrs, theDrawer, theHasTexels, theUVOrigin, theUVRepeat, theUVScale, theVolume == StdPrs_Volume_Closed); } diff --git a/src/StdPrs/StdPrs_ShadedShape.hxx b/src/StdPrs/StdPrs_ShadedShape.hxx index 751dccf18f..f65e762ce2 100644 --- a/src/StdPrs/StdPrs_ShadedShape.hxx +++ b/src/StdPrs/StdPrs_ShadedShape.hxx @@ -38,25 +38,13 @@ 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 Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(), - 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 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 Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(), - 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 StdPrs_Volume theVolume = StdPrs_Volume_Autodetection); //! Searches closed and unclosed subshapes in shape structure and puts them //! into two compounds for separate processing of closed and unclosed sub-shapes diff --git a/src/ViewerTest/ViewerTest_ViewerCommands.cxx b/src/ViewerTest/ViewerTest_ViewerCommands.cxx index 2b0fc94d8e..dcc828f15e 100644 --- a/src/ViewerTest/ViewerTest_ViewerCommands.cxx +++ b/src/ViewerTest/ViewerTest_ViewerCommands.cxx @@ -9280,371 +9280,6 @@ namespace } } -//=============================================================================================== -//function : setCappingParams -//purpose : -//=============================================================================================== -static Standard_Boolean setCappingParams (const TCollection_AsciiString& theChangeArg, - const Handle(Graphic3d_AspectFillCapping)& theCappingStyle, - const char** theChangeArgs, - Standard_Integer aNbChangeArgs, - Standard_Integer& anArgIter) -{ - if (theCappingStyle.IsNull()) - return Standard_False; - - Standard_Boolean toEnable = Standard_True; - if (theChangeArg == "-useobjectmaterial" - || theChangeArg == "-useobjectmat" - || theChangeArg == "-useobjmat" - || theChangeArg == "-useobjmaterial") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetUseObjectMaterial (toEnable == Standard_True); - anArgIter += 1; - } - } - else if (theChangeArg == "-useobjecttexture" - || theChangeArg == "-useobjecttex" - || theChangeArg == "-useobjtexture" - || theChangeArg == "-useobjtex") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetUseObjectTexture (toEnable == Standard_True); - anArgIter += 1; - } - } - else if (theChangeArg == "-useobjectshader" - || theChangeArg == "-useobjshader") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetUseObjectShader (toEnable == Standard_True); - anArgIter += 1; - } - } - else if (theChangeArg == "-color" - || theChangeArg == "color") - { - Quantity_Color aColor; - Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, - theChangeArgs + 1, - aColor); - if (aNbParsed == 0) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Graphic3d_MaterialAspect aMat = theCappingStyle->Material(); - aMat.SetAmbientColor (aColor); - aMat.SetDiffuseColor (aColor); - theCappingStyle->SetMaterial (aMat); - anArgIter += aNbParsed; - } - else if ((theChangeArg == "-transparency" - || theChangeArg == "-transp") - && aNbChangeArgs >= 2) - { - TCollection_AsciiString aValStr (theChangeArgs[1]); - if (aValStr.IsRealValue()) - { - Graphic3d_MaterialAspect aMat = theCappingStyle->Material(); - aMat.SetTransparency ((float )aValStr.RealValue()); - theCappingStyle->SetMaterial (aMat); - } - else - { - std::cout << "Syntax error at '" << aValStr << "'\n"; - return Standard_False; - } - anArgIter += 1; - } - else if (theChangeArg == "-texname" - || theChangeArg == "texname") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - TCollection_AsciiString aTextureName (theChangeArgs[1]); - Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); - if (!aTexture->IsDone()) - { - theCappingStyle->SetTexture (Handle(Graphic3d_TextureMap)()); - } - else - { - aTexture->EnableModulate(); - aTexture->EnableRepeat(); - theCappingStyle->SetTexture (aTexture.get()); - } - anArgIter += 1; - } - else if (theChangeArg == "-texscale" - || theChangeArg == "texscale") - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 3) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]); - aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); - anArgIter += 2; - } - else if (theChangeArg == "-texorigin" - || theChangeArg == "texorigin") // texture origin - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 3) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]); - - aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); - anArgIter += 2; - } - else if (theChangeArg == "-texrotate" - || theChangeArg == "texrotate") // texture rotation - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - aHatchTexture->GetParams()->SetRotation (aRot); - anArgIter += 1; - } - else if (theChangeArg == "-hatch" - || theChangeArg == "hatch") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetToDrawHatch (toEnable == Standard_True); - anArgIter += 1; - } - } - else if (theChangeArg == "-hatchtexture" - || theChangeArg == "hatchtexture") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - TCollection_AsciiString aTextureName (theChangeArgs[1]); - Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); - if (!aTexture->IsDone()) - { - theCappingStyle->SetHatchStyle (Handle(Graphic3d_TextureMap)()); - } - else - { - aTexture->EnableModulate(); - aTexture->EnableRepeat(); - theCappingStyle->SetHatchStyle (aTexture.get()); - theCappingStyle->SetToDrawHatch (true); - } - anArgIter += 1; - } - else if (theChangeArg == "-hatchstipple" - || theChangeArg == "hatchstipple") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - theCappingStyle->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (theChangeArgs[1])); - theCappingStyle->SetToDrawHatch (true); - anArgIter += 1; - } - else if (theChangeArg == "-hatchcolor" - || theChangeArg == "hatchcolor") - { - Quantity_Color aColor; - Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, - theChangeArgs + 1, - aColor); - if (aNbParsed == 0) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Graphic3d_MaterialAspect aMat = theCappingStyle->HatchMaterial(); - aMat.SetAmbientColor (aColor); - aMat.SetDiffuseColor (aColor); - theCappingStyle->SetHatchMaterial (aMat); - anArgIter += aNbParsed; - } - - else if (theChangeArg == "-hatchscale" - || theChangeArg == "hatchscale") - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 3) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]); - aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); - anArgIter += 2; - } - else if (theChangeArg == "-hatchorigin" - || theChangeArg == "hatchorigin") // texture origin - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 3) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]); - - aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); - anArgIter += 2; - } - else if (theChangeArg == "-hatchrotate" - || theChangeArg == "hatchrotate") // texture rotation - { - const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch(); - - if (aHatchTexture.IsNull()) - { - std::cout << "Error: no texture is set.\n"; - return Standard_False; - } - - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]); - aHatchTexture->GetParams()->SetRotation (aRot); - anArgIter += 1; - } - else if (theChangeArg == "-hatchzoompers" - || theChangeArg == "hatchzoompers") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetHatchZoomPeristent (toEnable == Standard_True); - anArgIter += 1; - } - } - else if (theChangeArg == "-hatchrotatepers" - || theChangeArg == "hatchrotatepers") - { - if (aNbChangeArgs < 2) - { - std::cout << "Syntax error: need more arguments.\n"; - return Standard_False; - } - - if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable)) - { - theCappingStyle->SetHatchRotationPeristent (toEnable == Standard_True); - anArgIter += 1; - } - } - else - { - return Standard_False; - } - - return Standard_True; -} - //=============================================================================================== //function : VClipPlane //purpose : @@ -9941,6 +9576,70 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons // just skip otherwise (old syntax) } } + else if (aChangeArg == "-useobjectmaterial" + || aChangeArg == "-useobjectmat" + || aChangeArg == "-useobjmat" + || aChangeArg == "-useobjmaterial") + { + if (aNbChangeArgs < 2) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->SetUseObjectMaterial (toEnable == Standard_True); + anArgIter += 1; + } + } + else if (aChangeArg == "-useobjecttexture" + || aChangeArg == "-useobjecttex" + || aChangeArg == "-useobjtexture" + || aChangeArg == "-useobjtex") + { + if (aNbChangeArgs < 2) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->SetUseObjectTexture (toEnable == Standard_True); + anArgIter += 1; + } + } + else if (aChangeArg == "-useobjectshader" + || aChangeArg == "-useobjshader") + { + if (aNbChangeArgs < 2) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + { + aClipPlane->SetUseObjectShader (toEnable == Standard_True); + anArgIter += 1; + } + } + else if (aChangeArg == "-color" + || aChangeArg == "color") + { + Quantity_Color aColor; + Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1, + aChangeArgs + 1, + aColor); + if (aNbParsed == 0) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + aClipPlane->SetCappingColor (aColor); + anArgIter += aNbParsed; + } else if (aNbChangeArgs >= 1 && (aChangeArg == "-material" || aChangeArg == "material")) @@ -9952,10 +9651,53 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons Message::SendFail() << "Syntax error: unknown material '" << aChangeArgs[1] << "'"; return 1; } - //aClipPlane->SetCappingMaterial (aMatName); + aClipPlane->SetCappingMaterial (aMatName); } - else if (aChangeArg == "-overrideaspect" - || aChangeArg == "overrideaspect") + else if ((aChangeArg == "-transparency" + || aChangeArg == "-transp") + && aNbChangeArgs >= 2) + { + TCollection_AsciiString aValStr (aChangeArgs[1]); + Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect(); + if (aValStr.IsRealValue()) + { + Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial(); + aMat.SetTransparency ((float )aValStr.RealValue()); + anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto); + aClipPlane->SetCappingMaterial (aMat); + } + else + { + aValStr.LowerCase(); + Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto; + if (aValStr == "opaque") + { + aMode = Graphic3d_AlphaMode_Opaque; + } + else if (aValStr == "mask") + { + aMode = Graphic3d_AlphaMode_Mask; + } + else if (aValStr == "blend") + { + aMode = Graphic3d_AlphaMode_Blend; + } + else if (aValStr == "blendauto") + { + aMode = Graphic3d_AlphaMode_BlendAuto; + } + else + { + Message::SendFail() << "Syntax error at '" << aValStr << "'"; + return 1; + } + anAspect->SetAlphaMode (aMode); + aClipPlane->SetCappingAspect (anAspect); + } + anArgIter += 1; + } + else if (aChangeArg == "-texname" + || aChangeArg == "texname") { if (aNbChangeArgs < 2) { @@ -9963,11 +9705,104 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons return 1; } - if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable)) + TCollection_AsciiString aTextureName (aChangeArgs[1]); + Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName); + if (!aTexture->IsDone()) { - aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True); - anArgIter += 1; + aClipPlane->SetCappingTexture (NULL); } + else + { + aTexture->EnableModulate(); + aTexture->EnableRepeat(); + aClipPlane->SetCappingTexture (aTexture); + } + anArgIter += 1; + } + else if (aChangeArg == "-texscale" + || aChangeArg == "texscale") + { + if (aClipPlane->CappingTexture().IsNull()) + { + Message::SendFail ("Error: no texture is set"); + return 1; + } + + if (aNbChangeArgs < 3) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy)); + anArgIter += 2; + } + else if (aChangeArg == "-texorigin" + || aChangeArg == "texorigin") // texture origin + { + if (aClipPlane->CappingTexture().IsNull()) + { + Message::SendFail ("Error: no texture is set"); + return 1; + } + + if (aNbChangeArgs < 3) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]); + + aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy)); + anArgIter += 2; + } + else if (aChangeArg == "-texrotate" + || aChangeArg == "texrotate") // texture rotation + { + if (aClipPlane->CappingTexture().IsNull()) + { + Message::SendFail ("Error: no texture is set"); + return 1; + } + + if (aNbChangeArgs < 2) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]); + aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot); + anArgIter += 1; + } + else if (aChangeArg == "-hatch" + || aChangeArg == "hatch") + { + if (aNbChangeArgs < 2) + { + Message::SendFail ("Syntax error: need more arguments"); + return 1; + } + + TCollection_AsciiString aHatchStr (aChangeArgs[1]); + aHatchStr.LowerCase(); + if (aHatchStr == "on") + { + aClipPlane->SetCappingHatchOn(); + } + else if (aHatchStr == "off") + { + aClipPlane->SetCappingHatchOff(); + } + else + { + aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1])); + } + anArgIter += 1; } else if (aChangeArg == "-delete" || aChangeArg == "delete") @@ -10045,7 +9880,7 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons anArgIter = anArgIter + anIt - 1; } } - else if (!setCappingParams (aChangeArg, aClipPlane->CappingSectionStyle(), aChangeArgs, aNbChangeArgs, anArgIter)) + else { Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'"; return 1; @@ -10056,69 +9891,6 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons return 0; } -//=============================================================================================== -//function : VSetCapping -//purpose : -//=============================================================================================== -static int VSetCapping (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec) -{ - if (theArgsNb < 2) - { - std::cout << "Syntax error: the wrong number of input parameters.\n"; - return 1; - } - - TCollection_AsciiString aName (theArgVec[1]); - gp_Pln aWorkingPlane; - Standard_Boolean toUpdate = Standard_True; - - NCollection_DataMap aRealParams; - NCollection_DataMap aStringParams; - - Handle(AIS_InteractiveObject) anObject; - if (GetMapOfAIS().Find2 (aName, anObject)) - { - if (anObject.IsNull()) - { - std::cout << "Syntax error: no presentation with this name.\n"; - return 1; - } - } - - Handle(Graphic3d_AspectFillCapping) aFillCapping = anObject->Attributes()->FillCappingAspect(); - for (Standard_Integer anArgIter = 2; anArgIter < theArgsNb; ++anArgIter) - { - const char** aChangeArgs = theArgVec + anArgIter; - Standard_Integer aNbChangeArgs = theArgsNb - anArgIter; - TCollection_AsciiString aChangeArg (aChangeArgs[0]); - aChangeArg.LowerCase(); - - Standard_Boolean toEnable = Standard_True; - if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable)) - { - if (!toEnable) - anObject->Attributes()->SetFillCappingAspect (NULL); - else - { - if (aFillCapping.IsNull()) - { - aFillCapping = new Graphic3d_AspectFillCapping(); - anObject->Attributes()->SetFillCappingAspect (aFillCapping); - } - } - } - else if (!setCappingParams (aChangeArg, aFillCapping, aChangeArgs, aNbChangeArgs, anArgIter)) - { - std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n"; - return 1; - } - } - ViewerTest::GetAISContext()->Redisplay (anObject, Standard_False); - - return 0; -} - - //=============================================================================================== //function : VZRange //purpose : @@ -14850,16 +14622,6 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands) "\n\t\t: [-color R G B] [-transparency Value] [-hatch {on|off|ID}]" "\n\t\t: [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]" "\n\t\t: [-texRotate Angle]" - /*"\n\t\t: [-overrideAspect {0|1}]" - "\n\t\t: [-color R G B]" - "\n\t\t: [-texture Texture] [-texScale SX SY]" - "\n\t\t: [-texOrigin TX TY] [-texRotate Angle]" - "\n\t\t: [-hatch {on|off}] [-hatchStipple mask]" - "\n\t\t: [-hatchColor R G B] [-hatchTexture texture]" - "\n\t\t: [-hatchScale SX SY] [-hatchOrigin TX TY]" - "\n\t\t: [-hatchRotate Angle]" - "\n\t\t: [-hatchZoomPers {0|1}]" - "\n\t\t: [-hatchRotatePers {0|1}]"*/ "\n\t\t: [-useObjMaterial {0|1}] [-useObjTexture {0|1}]" "\n\t\t: [-useObjShader {0|1}]" "\n\t\t: Clipping planes management:" @@ -14872,53 +14634,17 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands) "\n\t\t: -clone SourcePlane NewPlane clone the plane definition." "\n\t\t: Capping options:" "\n\t\t: -capping {off|on|0|1} turn capping on/off" - "\n\t\t: -overrideAspect override presentation aspect (if defined)" "\n\t\t: -color R G B set capping color" "\n\t\t: -transparency Value set capping transparency 0..1" "\n\t\t: -texName Texture set capping texture" "\n\t\t: -texScale SX SY set capping tex scale" "\n\t\t: -texOrigin TX TY set capping tex origin" "\n\t\t: -texRotate Angle set capping tex rotation" - "\n\t\t: -hatch {on|off} 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: -hatch {on|off|ID} set capping hatching mask" "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object" "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object" "\n\t\t: -useObjShader {off|on|0|1} use shader program of object", __FILE__, VClipPlane, group); - - theCommands.Add("vsetcapping", - "vsetcapping name [{0|1}]" - "\n\t\t: Sets capping parameters for all, selected or named objects." - "\n\t\t: Capping options:" - "\n\t\t: -capping {off|on|0|1} turn capping on/off" - "\n\t\t: -overrideAspect override presentation aspect (if defined)" - "\n\t\t: -color R G B set capping color" - "\n\t\t: -transparency Value set capping transparency 0..1" - "\n\t\t: -texName Texture set capping texture" - "\n\t\t: -texScale SX SY set capping tex scale" - "\n\t\t: -texOrigin TX TY set capping tex origin" - "\n\t\t: -texRotate Angle set capping tex rotation" - "\n\t\t: -hatch {on|off} turn on/off hatch style on capping" - "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch" - "\n\t\t: -hatchColor R G B set color for hatch material" - "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch" - "\n\t\t: -hatchScale SX SY set hatch texture scale" - "\n\t\t: -hatchOrigin TX TY set hatch texture origin" - "\n\t\t: -hatchRotate Angle set hatch texture rotation" - "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming" - "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating" - "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object" - "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object" - "\n\t\t: -useObjShader {off|on|0|1} use shader program of object", - __FILE__, VSetCapping, group); - theCommands.Add("vdefaults", "vdefaults [-absDefl value]" "\n\t\t: [-devCoeff value]" diff --git a/tests/bugs/vis/bug24224 b/tests/bugs/vis/bug24224 index 17893134e4..8ba33feb3b 100644 --- a/tests/bugs/vis/bug24224 +++ b/tests/bugs/vis/bug24224 @@ -46,7 +46,6 @@ 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 db76f74b6a..b53e55edfd 100644 --- a/tests/bugs/vis/bug27751_capping +++ b/tests/bugs/vis/bug27751_capping @@ -71,5 +71,5 @@ vdisplay pp1 pp2 vzoom 0.8 puts "Enable capping planes" -vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -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 +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