{
aShadedGroup = thePrs->NewGroup();
aShadedGroup->SetClosed (isClosed);
+ if (isClosed
+ && !myCappingStyle.IsNull())
+ aShadedGroup->SetGroupPrimitivesAspect (myCappingStyle);
}
aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect());
aShadedGroup->AddPrimitiveArray (aTriangles);
#include <AIS_InteractiveContext.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
}
}
+//=======================================================================
+//function : SetCappingStyle
+//purpose :
+//=======================================================================
+void AIS_InteractiveObject::SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+ myCappingStyle = theStyle;
+
+ // Modify existing presentations
+ for (Standard_Integer aPrsIter = 1, n = myPresentations.Length(); aPrsIter <= n; ++aPrsIter)
+ {
+ const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter);
+ if (!aPrs3d.IsNull())
+ {
+ const Handle(Graphic3d_Structure)& aStruct = aPrs3d->Presentation();
+ if (!aStruct.IsNull())
+ {
+ const Graphic3d_SequenceOfGroup& aGroups = aStruct->Groups();
+ for (Graphic3d_SequenceOfGroup::Iterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next())
+ {
+ Handle(Graphic3d_Group)& aGrp = aGroupIter.ChangeValue();
+ if (aGrp.IsNull())
+ continue;
+
+ aGrp->SetGroupPrimitivesAspect (theStyle);
+ }
+ }
+ }
+ }
+}
+
//=======================================================================
//function : HasPresentation
//purpose :
void ClearOwner() { myOwner.Nullify(); }
public:
+ //! Set style of filling capping section created by clipping planes.
+ Standard_EXPORT virtual void SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+ //! Returns style for filling capping section created by clipping planes.
+ const Handle(Graphic3d_AspectFillCapping)& CappingStyle() const { return myCappingStyle; }
+
//! Returns the context pointer to the interactive context.
Standard_EXPORT Handle(AIS_InteractiveContext) GetContext() const;
AIS_InteractiveContext* myCTXPtr; //!< pointer to Interactive Context, where object is currently displayed; @sa SetContext()
Handle(Standard_Transient) myOwner; //!< application-specific owner object
+ Handle(Graphic3d_AspectFillCapping) myCappingStyle;
};
try
{
OCC_CATCH_SIGNALS
- StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer,
- myDrawer->ShadingAspect()->Aspect()->ToMapTexture()
- && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(),
- myUVOrigin, myUVRepeat, myUVScale);
+ StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myCappingStyle);
}
catch (Standard_Failure const& anException)
{
Graphic3d_Aspects.hxx
Graphic3d_AspectFillArea3d.cxx
Graphic3d_AspectFillArea3d.hxx
+Graphic3d_AspectFillCapping.cxx
+Graphic3d_AspectFillCapping.hxx
Graphic3d_AspectLine3d.cxx
Graphic3d_AspectLine3d.hxx
Graphic3d_AspectMarker3d.cxx
--- /dev/null
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <Graphic3d_AspectFillCapping.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Standard_Transient)
+
+// =======================================================================
+// function : Graphic3d_AspectFillCapping
+// purpose :
+// =======================================================================
+Graphic3d_AspectFillCapping::Graphic3d_AspectFillCapping()
+: myFlags (Flags_None),
+ myHatchingState (0)
+{
+ Graphic3d_MaterialAspect aMaterial;
+ aMaterial.SetColor (Quantity_NOC_BLACK);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
+ aMaterial.SetMaterialType (Graphic3d_MATERIAL_ASPECT);
+ SetHatchStyle (Aspect_HS_HORIZONTAL);
+ SetHatchMaterial (aMaterial);
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Aspect_HatchStyle theStyle)
+{
+ myStippleHatch = new Graphic3d_HatchStyle (theStyle);
+ myTextureHatch.Nullify();
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle)
+{
+ myStippleHatch = theStyle;
+ myTextureHatch.Nullify();
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture)
+{
+ myStippleHatch.Nullify();
+ myTextureHatch = theTexture;
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchMaterial
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial)
+{
+ myHatchMaterial = theMaterial;
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetToDrawHatch
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetToDrawHatch (const Standard_Boolean theToDraw)
+{
+ setFlag (theToDraw, Flags_DrawHatching);
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchZoomPeristent
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchZoomPeristent (const Standard_Boolean theToSet)
+{
+ setFlag (theToSet, Flags_HatchZoomPersistent);
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchRotationPeristent
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchRotationPeristent (const Standard_Boolean theToSet)
+{
+ setFlag (theToSet, Flags_HatchRotationPersistent);
+ myHatchingState++;
+}
--- /dev/null
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Graphic3d_AspectFillCapping_HeaderFile
+#define _Graphic3d_AspectFillCapping_HeaderFile
+
+#include <Aspect_HatchStyle.hxx>
+#include <Graphic3d_Aspects.hxx>
+#include <Graphic3d_HatchStyle.hxx>
+#include <Graphic3d_MaterialAspect.hxx>
+#include <Graphic3d_ShaderProgram.hxx>
+#include <Graphic3d_TextureMap.hxx>
+#include <Standard_Transient.hxx>
+
+//! Defines graphical attributes for drawing section planes on solids resulted from clipping (cutting) planes.
+class Graphic3d_AspectFillCapping : public Graphic3d_Aspects
+{
+public:
+
+ //! Default constructor.
+ Standard_EXPORT Graphic3d_AspectFillCapping();
+
+public:
+
+ //! Sets material for filling section created by clipping.
+ void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; }
+
+ //! Returns material for filling section created by clipping.
+ const Graphic3d_MaterialAspect& Material() const { return myMaterial; }
+
+ //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); }
+
+ //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; }
+
+ //! Sets texture for filling section created by clipping.
+ void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; }
+
+ //! Returns texture for filling section created by clipping.
+ const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; }
+
+ //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); }
+
+ //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; }
+
+ //! Sets OpenGL/GLSL shader program.
+ void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; }
+
+ //! Returns OpenGL/GLSL shader program.
+ const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; }
+
+ //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); }
+
+ //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; }
+
+public:
+
+ //! Sets style of hatch defined by predefined stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle);
+
+ //! Sets style of hatch defined by custom stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle);
+
+ //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used).
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture);
+
+ //! Sets material style for hatch lines (texture).
+ Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial);
+
+ //! Returns material style for hatch lines (texture).
+ const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; }
+
+ //! Sets boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw);
+
+ //! Returns boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on zooming.
+ //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming.
+ Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on zooming.
+ Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; }
+
+ //! Returns true if hatch is defined by texture.
+ Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); }
+
+ //! Returns texture map defining the hatch.
+ const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; }
+
+ //! Returns true if hatch is defined by stipple mask.
+ Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); }
+
+ //! Returns the stipple mask.
+ const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; }
+
+ //! Returns modification counter for hatching state.
+ Standard_Size HatchingState() const { return myHatchingState; }
+
+private:
+
+ enum Flags
+ {
+ Flags_None = 0x00, //!< no flags
+ Flags_UseObjectMaterial = 0x01, //!< use object material
+ Flags_UseObjectTexture = 0x02, //!< use object texture
+ Flags_UseObjectShader = 0x04, //!< use object GLSL program
+ Flags_HatchZoomPersistent = 0x08, //!< zoom-persistent texturing
+ Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing
+ Flags_DrawHatching = 0x20, //!< draw hatching
+ Flags_UseObjectProperties = //!< use entire fill area aspect from object
+ Flags_UseObjectMaterial
+ | Flags_UseObjectTexture
+ | Flags_UseObjectShader
+ };
+
+ void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag)
+ {
+ myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag;
+ }
+
+private:
+
+ Graphic3d_MaterialAspect myMaterial;
+ Handle(Graphic3d_TextureMap) myTexture;
+ Handle(Graphic3d_ShaderProgram) myShader;
+ Handle(Graphic3d_HatchStyle) myStippleHatch;
+ Handle(Graphic3d_TextureMap) myTextureHatch;
+ Graphic3d_MaterialAspect myHatchMaterial;
+ unsigned int myFlags;
+ Standard_Size myHatchingState;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+};
+
+DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+
+#endif // _Graphic3d_AspectFillCapping_HeaderFile
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;
- }
}
// =======================================================================
// purpose :
// =======================================================================
Graphic3d_ClipPlane::Graphic3d_ClipPlane()
-: myAspect (defaultAspect()),
- myPrevInChain(NULL),
- myPlane (0.0, 0.0, 1.0, 0.0),
- myEquation (0.0, 0.0, 1.0, 0.0),
- myEquationRev(0.0, 0.0,-1.0, 0.0),
- myChainLenFwd(1),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
{
- makeId();
+ init();
}
// =======================================================================
// purpose :
// =======================================================================
Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_Vec4d& theEquation)
-: myAspect (defaultAspect()),
- myPrevInChain(NULL),
- myPlane (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()),
- myEquation (theEquation),
- myEquationRev(0.0, 0.0,-1.0, 0.0),
- myChainLenFwd(1),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
{
- makeId();
+ init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a()));
updateInversedPlane();
}
// function : Graphic3d_ClipPlane
// purpose :
// =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther)
-: Standard_Transient(theOther),
- myAspect (defaultAspect()),
- myPrevInChain(NULL),
- myPlane (theOther.myPlane),
- myEquation (theOther.myEquation),
- myEquationRev(theOther.myEquationRev),
- myChainLenFwd(1),
- myFlags (theOther.myFlags),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (theOther.myIsOn),
- myIsCapping (theOther.myIsCapping)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther)
+: Standard_Transient (theOther)
{
- makeId();
- *myAspect = *theOther.CappingAspect();
+ *mySectionStyle = *theOther.CappingSectionStyle();
+ init (theOther.myPlane,
+ theOther.myEquationRev,
+ theOther.myIsOn,
+ theOther.myIsCapping,
+ theOther.ToOverrideCappingAspect(),
+ theOther.CappingSectionStyle());
+ updateInversedPlane();
}
// =======================================================================
// function : Graphic3d_ClipPlane
// purpose :
// =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane)
-: myAspect (defaultAspect()),
- myPrevInChain(NULL),
- myPlane (thePlane),
- myChainLenFwd(1),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const gp_Pln& thePlane)
{
- thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
+ init (thePlane);
updateInversedPlane();
- makeId();
}
// =======================================================================
myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
myEquation = theEquation;
updateInversedPlane();
- myEquationMod++;
+ myOrientationDirty = Standard_True;
}
// =======================================================================
myPlane = thePlane;
thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
updateInversedPlane();
- myEquationMod++;
+ myOrientationDirty = Standard_True;
}
// =======================================================================
}
// =======================================================================
-// function : SetCappingMaterial
// purpose :
// =======================================================================
-void Graphic3d_ClipPlane::SetCappingMaterial (const Graphic3d_MaterialAspect& theMat)
+void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
{
- myAspect->SetFrontMaterial (theMat);
+ mySectionStyle = theStyle;
if (myAspect->FrontMaterial().MaterialType() != Graphic3d_MATERIAL_ASPECT)
{
- myAspect->SetInteriorColor (theMat.Color());
}
- ++myAspectMod;
}
// =======================================================================
-// function : SetCappingTexture
+// function : OrientationMatrix
// purpose :
// =======================================================================
-void Graphic3d_ClipPlane::SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture)
+const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const
{
- if (!theTexture.IsNull())
+ if (myOrientationDirty)
{
- myAspect->SetTextureMapOn();
- Handle(Graphic3d_TextureSet) aTextureSet = myAspect->TextureSet();
- if (aTextureSet.IsNull() || aTextureSet->Size() != 1)
+ const Standard_ShortReal aDirection[] = {
+ static_cast<Standard_ShortReal> (myEquation[0]),
+ static_cast<Standard_ShortReal> (myEquation[1]),
+ static_cast<Standard_ShortReal> (myEquation[2])
+ };
+
+ const Standard_ShortReal aTranslate[] = {
+ static_cast<Standard_ShortReal> (myEquation[0] * -myEquation[3]),
+ static_cast<Standard_ShortReal> (myEquation[1] * -myEquation[3]),
+ static_cast<Standard_ShortReal> (myEquation[2] * -myEquation[3])
+ };
+
+ Standard_ShortReal aSide1[] = { 0.0f, 0.0f, 0.0f };
+ Standard_ShortReal aSide2[] = { 0.0f, 0.0f, 0.0f };
+
+ const Standard_ShortReal aMagintude = static_cast<Standard_ShortReal> (Sqrt (myEquation[0] * myEquation[0] + myEquation[2] * myEquation[2]));
+
+ if (aMagintude < ShortRealSmall())
{
- aTextureSet = new Graphic3d_TextureSet (theTexture);
+ aSide1[0] = 1.0f;
}
else
{
- aTextureSet->SetFirst (theTexture);
+ aSide1[0] = aDirection[2] / aMagintude;
+ aSide1[2] = -aDirection[0] / aMagintude;
}
- myAspect->SetTextureSet (aTextureSet);
- }
- else
- {
- myAspect->SetTextureMapOff();
- myAspect->SetTextureSet (Handle(Graphic3d_TextureSet)());
- }
- ++myAspectMod;
-}
-// =======================================================================
-// function : SetCappingHatch
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatch (const Aspect_HatchStyle theStyle)
-{
- myAspect->SetHatchStyle (theStyle);
- ++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]);
-// =======================================================================
-// function : SetCappingCustomHatch
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle)
-{
- myAspect->SetHatchStyle (theStyle);
- ++myAspectMod;
-}
+ myOrientationMat.SetValue (0, 0, aSide1[0]);
+ myOrientationMat.SetValue (1, 0, aSide1[1]);
+ myOrientationMat.SetValue (2, 0, aSide1[2]);
+ myOrientationMat.SetValue (3, 0, 0.0F);
-// =======================================================================
-// function : SetCappingHatchOn
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatchOn()
-{
- myAspect->SetInteriorStyle (Aspect_IS_HATCH);
- ++myAspectMod;
-}
+ 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 : SetCappingHatchOff
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingHatchOff()
-{
- myAspect->SetInteriorStyle (Aspect_IS_SOLID);
- ++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 : SetCappingAspect
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
-{
- myAspect = theAspect;
- ++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);
+
+ myOrientationDirty = Standard_False;
+ }
+
+ return myOrientationMat;
}
// =======================================================================
-// function : setCappingFlag
+// function : init
// purpose :
// =======================================================================
-void Graphic3d_ClipPlane::setCappingFlag (bool theToUse, int theFlag)
+void Graphic3d_ClipPlane::init (const gp_Pln& thePlane,
+ const Graphic3d_Vec4d& theEquationRev,
+ const Standard_Boolean theIsOn,
+ const Standard_Boolean theIsCapping,
+ const Standard_Boolean theOverrideStyle,
+ const Handle(Graphic3d_AspectFillCapping)& theStyle)
{
- if (theToUse)
- {
- myFlags |= theFlag;
- }
- else
+ if (myEntityUID.IsEmpty())
{
- myFlags &= ~(theFlag);
+ myEntityUID = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name()
+ + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
}
- ++myAspectMod;
-}
-// =======================================================================
-// function : makeId
-// purpose :
-// =======================================================================
-void Graphic3d_ClipPlane::makeId()
-{
- myId = TCollection_AsciiString ("Graphic3d_ClipPlane_") //DynamicType()->Name()
- + TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
+ myPrevInChain = NULL;
+ myEquationRev = theEquationRev;
+ myChainLenFwd = 1;
+ myPlane = thePlane;
+ myPlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
+ myIsOn = theIsOn;
+ myIsCapping = theIsCapping;
+ myOverrideObjectStyle = theOverrideStyle;
+ mySectionStyle = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle;
+ myOrientationDirty = Standard_True;
}
// =======================================================================
// =======================================================================
void Graphic3d_ClipPlane::SetChainNextPlane (const Handle(Graphic3d_ClipPlane)& thePlane)
{
- ++myEquationMod;
+ myOrientationDirty = Standard_True;
if (!myNextInChain.IsNull())
{
myNextInChain->myPrevInChain = NULL;
#include <Aspect_HatchStyle.hxx>
#include <gp_Pln.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_BndBox3d.hxx>
#include <Graphic3d_CappingFlags.hxx>
+#include <Graphic3d_Mat4.hxx>
#include <Graphic3d_TextureMap.hxx>
+#include <NCollection_Handle.hxx>
#include <NCollection_Vec4.hxx>
#include <Standard_Macro.hxx>
#include <Standard_TypeDef.hxx>
//! 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
//! @return clip plane resource identifier string.
const TCollection_AsciiString& GetId() const
{
- return myId;
+ return myEntityUID;
}
public:
- //! Return capping aspect.
+ //! Returns style used for drawing capping section.
//! @return capping surface rendering aspect.
- const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; }
+ const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; }
- //! Assign capping aspect.
- Standard_EXPORT void SetCappingAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect);
+ //! Sets clipping section filling aspect.
+ Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
- //! Flag indicating whether material for capping plane should be taken from object.
- //! Default value: FALSE (use dedicated capping plane material).
- bool ToUseObjectMaterial() const { return (myFlags & Graphic3d_CappingFlags_ObjectMaterial) != 0; }
-
- //! Set flag for controlling the source of capping plane material.
- void SetUseObjectMaterial (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectMaterial); }
-
- //! Flag indicating whether texture for capping plane should be taken from object.
- //! Default value: FALSE.
- bool ToUseObjectTexture() const { return (myFlags & Graphic3d_CappingFlags_ObjectTexture) != 0; }
-
- //! Set flag for controlling the source of capping plane texture.
- void SetUseObjectTexture (bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectTexture); }
-
- //! Flag indicating whether shader program for capping plane should be taken from object.
- //! Default value: FALSE.
- bool ToUseObjectShader() const { return (myFlags & Graphic3d_CappingFlags_ObjectShader) != 0; }
-
- //! Set flag for controlling the source of capping plane shader program.
- void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); }
-
- //! Return true if some fill area aspect properties should be taken from object.
- bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; }
public:
{
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; }
-private:
+ //! Sets flag for controlling the preference of using section style between clip plane and object.
+ void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; }
- //! Generate unique object id for OpenGL graphic resource manager.
- void makeId();
+ //! Returns plane's orientation matrix.
+ Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const;
+
+private:
- //! Set capping flag.
- Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag);
+ //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities.
+ void init (const gp_Pln& thePlane = gp_Pln(),
+ const Graphic3d_Vec4d& theEquationRev = Graphic3d_Vec4d(0.0, 0.0,-1.0, 0.0),
+ const Standard_Boolean theIsOn = Standard_True,
+ const Standard_Boolean theIsCapping = Standard_False,
+ const Standard_Boolean theOverrideStyle = Standard_False,
+ const Handle(Graphic3d_AspectFillCapping)& theStyle = Handle(Graphic3d_AspectFillCapping)());
//! Update chain length in backward direction.
void updateChainLen();
private:
- Handle(Graphic3d_AspectFillArea3d) myAspect; //!< fill area aspect
+ Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section.
Handle(Graphic3d_ClipPlane) myNextInChain; //!< next plane in a chain of planes defining logical AND operation
Graphic3d_ClipPlane* myPrevInChain; //!< previous plane in a chain of planes defining logical AND operation
- TCollection_AsciiString myId; //!< resource id
+ TCollection_AsciiString myEntityUID; //!< Unique identifier for the plane
gp_Pln myPlane; //!< plane definition
Graphic3d_Vec4d myEquation; //!< plane equation vector
Graphic3d_Vec4d myEquationRev; //!< reversed plane equation
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).
};
class Graphic3d_Structure;
class Graphic3d_ArrayOfPrimitives;
+class Graphic3d_AspectFillCapping;
class Graphic3d_Text;
//! This class allows the definition of groups
//! 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;
//! - ASPECT_LINE: aspect for line primitives;
//! - ASPECT_TEXT: aspect for text primitives;
//! - ASPECT_MARKER: aspect for marker primitives;
-//! - ASPECT_FILL_AREA: aspect for face primitives.
+//! - ASPECT_FILL_AREA: aspect for face primitives;
+//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections.
enum Graphic3d_GroupAspect
{
Graphic3d_ASPECT_LINE,
Graphic3d_ASPECT_TEXT,
Graphic3d_ASPECT_MARKER,
-Graphic3d_ASPECT_FILL_AREA
+Graphic3d_ASPECT_FILL_AREA,
+Graphic3d_ASPECT_FILL_CAPPING
};
#endif // _Graphic3d_GroupAspect_HeaderFile
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Vec.hxx>
+#include <OpenGl_View.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_ShaderManager.hxx>
namespace
{
+ static const OpenGl_CappingPlaneResource THE_DEFAULT_ASPECT = OpenGl_CappingPlaneResource (new Graphic3d_AspectFillCapping);
+ static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingAlgo_Quad";
+ static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingAlgo_CappingStyle_";
+
//! Auxiliary sentry object managing stencil test.
struct StencilTestSentry
{
GLint myDepthFuncPrev;
};
- //! Render infinite capping plane.
- //! @param theWorkspace [in] the GL workspace, context state.
- //! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
- static void renderPlane (const Handle(OpenGl_Workspace)& theWorkspace,
- const Handle(OpenGl_CappingPlaneResource)& thePlane)
+ class OpenGl_SharedElement : public OpenGl_Resource
+ {
+ public:
+ OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {}
+ virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE
+ {
+ OpenGl_Element::Destroy (theGlCtx, myGlElement);
+ }
+ OpenGl_Element* GlElement() const { return myGlElement; }
+
+ //! Returns estimated GPU memory usage for holding data without considering overheads and allocation alignment rules.
+ Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
+
+ private:
+ OpenGl_Element* myGlElement;
+
+ public:
+
+ DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource)
+ };
+
+ //! Iitializes and returns vertex buffer for plane section
+ OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext)
+ {
+ Handle(OpenGl_SharedElement) aSharedResource;
+
+ if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource))
+ {
+ aSharedResource = new OpenGl_SharedElement (OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices());
+ theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource);
+ }
+
+ return dynamic_cast<OpenGl_PrimitiveArray*> (aSharedResource->GlElement());
+ }
+
+ //! Render section plane using the given aspects.
+ void renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_PrimitiveArray* theQuad,
+ const OpenGl_Aspects* theCappingAspect,
+ const OpenGl_Aspects* theHatchAspect,
+ const OpenGl_Mat4& theCappingMatrix,
+ const Standard_ShortReal theHatchScale,
+ const Standard_ShortReal theHatchRotate)
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const bool wasCullAllowed = theWorkspace->SetAllowFaceCulling (true);
- // set identity model matrix
+ const Standard_Boolean isTextureHatch =
+ theHatchAspect != NULL
+ && theHatchAspect->Aspect()->TextureMapState();
+
aContext->ModelWorldState.Push();
- aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat));
+ aContext->ModelWorldState.SetCurrent (theCappingMatrix);
aContext->ApplyModelViewMatrix();
- thePlane->Primitives().Render (theWorkspace);
+ theWorkspace->SetAspects (theCappingAspect);
+ theWorkspace->ApplyAspects();
+
+ theQuad->Render (theWorkspace);
+
+ if (theHatchAspect != NULL)
+ {
+ Graphic3d_Vec2 aPrevScale;
+ Standard_ShortReal aPrevRotate = 0.0;
+
+ if (isTextureHatch)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ if ((theHatchScale != 1.0 || theHatchRotate != 0.0) && !theHatchAspect->TextureSet(aContext)->IsEmpty())
+ {
+ Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+ const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+ aPrevScale = aTexParams->Scale();
+ aPrevRotate = aTexParams->Rotation();
+
+ const Standard_Boolean isMirror = aPrevScale.x() * aPrevScale.y() < 0.0;
+ aTexParams->SetScale (aPrevScale * theHatchScale);
+ aTexParams->SetRotation (isMirror ? aPrevRotate - theHatchRotate : aPrevRotate + theHatchRotate);
+ }
+ }
+
+ theWorkspace->SetAspects (theHatchAspect);
+ theWorkspace->ApplyAspects();
+
+ glDepthFunc (GL_LEQUAL);
+
+ theQuad->Render (theWorkspace);
+
+ glDepthFunc (GL_LESS);
+
+ if (isTextureHatch)
+ {
+ glDisable (GL_BLEND);
+
+ if (theHatchScale != 1.0 || theHatchRotate != 0.0)
+ {
+ Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+ const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+ aTexParams->SetScale (aPrevScale);
+ aTexParams->SetRotation (aPrevRotate);
+ }
+ }
+ }
aContext->ModelWorldState.Pop();
aContext->ApplyModelViewMatrix();
const OpenGl_Structure& theStructure,
const Handle(Graphic3d_ClipPlane)& theClipChain,
const Standard_Integer theSubPlaneIndex,
- const Handle(OpenGl_CappingPlaneResource)& thePlane)
+ const Handle(OpenGl_CappingPlaneResource)& thePlane,
+ const OpenGl_PrimitiveArray* theQuad)
{
const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly);
+ const Handle(Graphic3d_ClipPlane)& aPlane = theClipChain;
+
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
- const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane();
+ const Handle(Graphic3d_Camera) aCamera = theWorkspace->View() != NULL
+ ? theWorkspace->View()->Camera()
+ : Handle(Graphic3d_Camera)();
+ const OpenGl_Mat4& aPlaneMat = OpenGl_Mat4::Map (aPlane->OrientationMatrix());
+ Standard_ShortReal aRotateAngle = 0.0;
+ Standard_ShortReal aViewScale = ShortRealLast();
+ OpenGl_Mat4 aRotateZoomMat;
+
for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next())
{
if (!aGroupIter.Value()->IsClosed())
// 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);
aContext->ShaderManager()->UpdateClippingState();
glClear (GL_STENCIL_BUFFER_BIT);
- const bool aColorMaskBack = aContext->SetColorMask (false);
+ glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// override aspects, disable culling
theWorkspace->SetAspects (&theWorkspace->NoneCulling());
glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
// render closed primitives
- if (aRenderPlane->ToUseObjectProperties())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
- else
- {
- for (; aGroupIter.More(); aGroupIter.Next())
- {
- if (aGroupIter.Value()->IsClosed())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
- }
- }
+ aGroupIter.Value()->Render (theWorkspace);
// override material, cull back faces
theWorkspace->SetAspects (&theWorkspace->FrontCulling());
aContext->ShaderManager()->UpdateClippingState();
// render capping plane using the generated stencil mask
- aContext->SetColorMask (aColorMaskBack);
+ glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
if (theWorkspace->UseDepthWrite())
{
glDepthMask (GL_TRUE);
glEnable (GL_DEPTH_TEST);
}
- theWorkspace->SetAspects (thePlane->AspectFace());
- renderPlane (theWorkspace, thePlane);
+ const OpenGl_Aspects* aGroupAspectFace = aGroupIter.Value()->GlAspects();
+ const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
+ const OpenGl_CappingPlaneResource* anAspectCapping =
+ thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
+ ? thePlane.get()
+ : aGroupAspectCapping;
+
+ if (anAspectCapping == NULL)
+ {
+ anAspectCapping = &THE_DEFAULT_ASPECT;
+ }
+
+ const OpenGl_Aspects* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+ const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch();
+ const OpenGl_Aspects* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
+ const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull();
+ const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent();
+ const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent();
+
+ Standard_ShortReal aHatchScale = 1.0;
+ Standard_ShortReal aHatchAngle = 0.0;
+
+ if (isRotatePers || isZoomPers)
+ {
+
+ if (isRotatePers)
+ {
+ if (aRotateAngle == 0.0)
+ {
+ const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0));
+ const gp_Dir aPlaneUp (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2));
+ const gp_Dir& aCameraUp = aCamera->Up();
+ const gp_Vec aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp;
+ const gp_Dir& aCameraDir = aCamera->Direction();
+ aRotateAngle = static_cast<Standard_ShortReal> (aCameraPln.AngleWithRef (aPlaneUp, aCameraDir) / M_PI * 180.0);
+ }
+
+ aHatchAngle = aRotateAngle;
+ }
+
+ if (isZoomPers)
+ {
+ if (aViewScale == ShortRealLast())
+ {
+ const Standard_Real aFocus = aCamera->IsOrthographic()
+ ? aCamera->Distance()
+ : (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative
+ ? Standard_Real(aCamera->ZFocus() * aCamera->Distance())
+ : Standard_Real(aCamera->ZFocus()));
+
+ const gp_XYZ aViewDim = aCamera->ViewDimensions (aFocus);
+ aViewScale = static_cast<Standard_ShortReal> (aViewDim.Y() / aContext->Viewport()[3]);
+ }
+
+ if (!anAspectHatching->TextureSet(aContext)->IsEmpty())
+ aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureSet(aContext)->First()->SizeY());
+ }
+ }
+
+ renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle);
// turn on the current plane to restore initial state
aContext->ChangeClipping().ResetCappingFilter();
if (theStructure.InstancedStructure() != NULL)
{
- renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane);
+ renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad);
}
}
}
return;
}
+ const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext);
+ if (!aCappingQuad)
+ {
+ return;
+ }
+
// remember current aspect face defined in workspace
const OpenGl_Aspects* aFaceAsp = theWorkspace->Aspects();
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())
{
for (const Graphic3d_ClipPlane* aSubPlaneIter = aClipChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
{
// get resource for the plane
- const TCollection_AsciiString& aResId = aSubPlaneIter->GetId();
+ const TCollection_AsciiString& aResId = THE_PLANE_STYLE + aSubPlaneIter->GetId();
Handle(OpenGl_CappingPlaneResource) aPlaneRes;
if (!aContext->GetResource (aResId, aPlaneRes))
{
// share and register for release once the resource is no longer used
- aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter);
+ aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter->CappingSectionStyle());
aContext->ShareResource (aResId, aPlaneRes);
}
- renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes);
+ renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes, aCappingQuad);
// set delayed resource release
aPlaneRes.Nullify();
- aContext->ReleaseResource (aResId, Standard_True);
+ if (!aResId.IsEmpty())
+ {
+ // schedule release of resource if not used
+ aContext->ReleaseResource (aResId, Standard_True);
+ }
}
}
+ if (aPrevBlend == GL_TRUE)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (aPrevBlendSrc, aPrevBlendDst);
+ }
+
// restore rendering aspects
theWorkspace->SetAspects (aFaceAsp);
theWorkspace->SetRenderFilter (aPrevFilter);
{ 0.0f, 0.0f, 0.0f, 1.0f } }
};
+ Handle(Graphic3d_Aspects) defaultMaterial()
+ {
+ Handle(Graphic3d_AspectFillArea3d) anAspect;
+ const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
+ anAspect = new Graphic3d_AspectFillArea3d();
+ anAspect->SetDistinguishOff();
+ anAspect->SetFrontMaterial (aMaterial);
+ anAspect->SetInteriorStyle (Aspect_IS_SOLID);
+ anAspect->SetInteriorColor (aMaterial.Color());
+ anAspect->SetSuppressBackFaces (false);
+ return anAspect;
+ }
}
// =======================================================================
-// function : OpenGl_CappingPlaneResource
+// function : BuildInfinitPlaneVertices
// purpose :
// =======================================================================
-OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
-: myPrimitives (NULL),
- myOrientation (OpenGl_IdentityMatrix),
- myAspect (NULL),
- myPlaneRoot (thePlane),
- myEquationMod ((unsigned int )-1),
- myAspectMod ((unsigned int )-1)
+OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
{
+ OpenGl_PrimitiveArray* aPrimitives = NULL;
// Fill primitive array
Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
if (anAttribs->Init (12, anAttribInfo, 3))
{
memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
- myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+
+ aPrimitives = new OpenGl_PrimitiveArray (NULL);
+ aPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
}
+ return aPrimitives;
+}
+
+// =======================================================================
+// function : OpenGl_CappingPlaneResource
+// purpose :
+// =======================================================================
+OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+: myCappingAspect(),//defaultMaterial()),
+ myHatchingAspect(),//defaultMaterial()),
+ myHatchingState (0)
+{
+ myCappingAspect.SetAspect (defaultMaterial());
+ myHatchingAspect.SetAspect (defaultMaterial());
+
+ SetAspect (theAspect);
}
// =======================================================================
// =======================================================================
OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
{
- Release (NULL);
}
// =======================================================================
-// function : Update
+// function : SetAspect
// purpose :
// =======================================================================
-void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
- const Handle(Graphic3d_Aspects)& theObjAspect)
+void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
{
- updateTransform (theCtx);
- updateAspect (theObjAspect);
+ myAspect = theAspect;
+
+ if (theAspect.IsNull())
+ {
+ return;
+ }
+
+ if (!theAspect->ToUseObjectMaterial()
+ || !theAspect->ToUseObjectTexture()
+ || !theAspect->ToUseObjectShader())
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
+
+ if (!theAspect->ToUseObjectMaterial())
+ {
+ aFillAspect->SetFrontMaterial (theAspect->Material());
+ aFillAspect->SetInteriorColor (theAspect->Material().Color());
+ }
+
+ if (!theAspect->ToUseObjectTexture())
+ {
+ aFillAspect->SetTextureMap (theAspect->Texture());
+
+ if (!theAspect->Texture().IsNull())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+ else
+ {
+ aFillAspect->SetTextureMap (Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetTextureMapOff();
+ }
+
+ if (!theAspect->ToUseObjectShader())
+ {
+ aFillAspect->SetShaderProgram (theAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
+ }
+
+ if (theAspect->ToDrawHatch()
+ && (theAspect->IsTextureHatch()
+ || theAspect->IsStippleHatch()))
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+ aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+ aFillAspect->SetHatchStyle (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+ aFillAspect->SetTextureMap (theAspect->IsTextureHatch() ? theAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetFrontMaterial (theAspect->HatchMaterial());
+ aFillAspect->SetInteriorColor (theAspect->HatchMaterial().Color());
+ if (theAspect->IsTextureHatch())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+
+ myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingState = theAspect->HatchingState();
+ }
}
// =======================================================================
// =======================================================================
void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
{
- OpenGl_Element::Destroy (theContext, myAspect);
- myPrimitives.Release (theContext);
- myEquationMod = (unsigned int )-1;
- myAspectMod = (unsigned int )-1;
+ myCappingAspect .Release (theContext);
+ myHatchingAspect.Release (theContext);
}
// =======================================================================
-// function : updateAspect
+// function : CappingFaceAspect
// purpose :
// =======================================================================
-void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& theObjAspect)
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const
{
- if (myAspect == NULL)
+ if (myAspect.IsNull())
{
- myAspect = new OpenGl_Aspects();
- myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync
+ return NULL;
}
- if (theObjAspect.IsNull())
- {
- if (myAspectMod != myPlaneRoot->MCountAspect())
- {
- myAspect->SetAspect (myPlaneRoot->CappingAspect());
- myAspectMod = myPlaneRoot->MCountAspect();
- }
- return;
- }
+ Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
- if (myFillAreaAspect.IsNull())
+ if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
{
- myFillAreaAspect = new Graphic3d_AspectFillArea3d();
+ // only front material currently supported by capping rendering
+ aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
+ aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor());
}
- if (myAspectMod != myPlaneRoot->MCountAspect())
+ else
{
- *myFillAreaAspect = *myPlaneRoot->CappingAspect();
+ aFillAspect->SetFrontMaterial (myAspect->Material());
+ aFillAspect->SetInteriorColor (myAspect->Material().Color());
}
- if (myPlaneRoot->ToUseObjectMaterial())
+ if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL)
{
- // only front material currently supported by capping rendering
- myFillAreaAspect->SetFrontMaterial (theObjAspect->FrontMaterial());
- myFillAreaAspect->SetInteriorColor (theObjAspect->InteriorColor());
+ if (theObjectAspect->Aspect()->ToMapTexture())
+ {
+ aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap());
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
}
- if (myPlaneRoot->ToUseObjectTexture())
+ else
{
- myFillAreaAspect->SetTextureSet (theObjAspect->TextureSet());
- if (theObjAspect->ToMapTexture())
+ aFillAspect->SetTextureMap (myAspect->Texture());
+ if (!myAspect->Texture().IsNull())
{
- myFillAreaAspect->SetTextureMapOn();
+ aFillAspect->SetTextureMapOn();
}
else
{
- myFillAreaAspect->SetTextureMapOff();
+ aFillAspect->SetTextureMapOff();
}
}
- if (myPlaneRoot->ToUseObjectShader())
+
+ if (myAspect->ToUseObjectShader() && theObjectAspect != NULL)
{
- myFillAreaAspect->SetShaderProgram (theObjAspect->ShaderProgram());
+ aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
}
+ else
+ {
+ aFillAspect->SetShaderProgram (myAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
- myAspect->SetAspect (myFillAreaAspect);
+ return &myCappingAspect;
}
// =======================================================================
-// function : updateTransform
+// function : HatchingFaceAspect
// purpose :
// =======================================================================
-void OpenGl_CappingPlaneResource::updateTransform (const Handle(OpenGl_Context)& theCtx)
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::HatchingFaceAspect() const
{
- if (myEquationMod == myPlaneRoot->MCountEquation()
- && myLocalOrigin.IsEqual (theCtx->ShaderManager()->LocalOrigin(), gp::Resolution()))
+ if (myAspect.IsNull())
{
- return; // nothing to update
+ return NULL;
}
- myEquationMod = myPlaneRoot->MCountEquation();
- myLocalOrigin = theCtx->ShaderManager()->LocalOrigin();
-
- const Graphic3d_ClipPlane::Equation& anEq = myPlaneRoot->GetEquation();
- const Standard_Real anEqW = theCtx->ShaderManager()->LocalClippingPlaneW (*myPlaneRoot);
-
- // re-evaluate infinite plane transformation matrix
- const Graphic3d_Vec3 aNorm (anEq.xyz());
- const Graphic3d_Vec3 T (anEq.xyz() * -anEqW);
-
- // project plane normal onto OX to find left vector
- const Standard_ShortReal aProjLen = sqrt ((Standard_ShortReal)anEq.xz().SquareModulus());
- Graphic3d_Vec3 aLeft;
- if (aProjLen < ShortRealSmall())
- {
- aLeft[0] = 1.0f;
- }
- else
+ const Standard_Size aHatchingState = myAspect->HatchingState();
+ if (myHatchingState != aHatchingState)
{
- aLeft[0] = aNorm[2] / aProjLen;
- aLeft[2] = -aNorm[0] / aProjLen;
- }
-
- 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;
+ if (myAspect->ToDrawHatch())
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
- myOrientation.mat[2][0] = F[0];
- myOrientation.mat[2][1] = F[1];
- myOrientation.mat[2][2] = F[2];
- myOrientation.mat[2][3] = 0.0f;
+ 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;
+ }
+ }
- myOrientation.mat[3][0] = T[0];
- myOrientation.mat[3][1] = T[1];
- myOrientation.mat[3][2] = T[2];
- myOrientation.mat[3][3] = 1.0f;
+ return &myHatchingAspect;
}
#include <OpenGl_Resource.hxx>
#include <OpenGl_Aspects.hxx>
#include <OpenGl_Matrix.hxx>
-#include <Graphic3d_ClipPlane.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
class OpenGl_CappingPlaneResource;
DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
//! This resource holds data necessary for OpenGl_CappingAlgo.
//! This object is implemented as OpenGl resource for the following reasons:
//! - one instance should be shared between contexts.
-//! - instance associated to Graphic3d_ClipPlane data by id.
+//! - instance associated to Graphic3d_AspectFillCapping data.
//! - should created and released within context (owns OpenGl elements and resources).
class OpenGl_CappingPlaneResource : public OpenGl_Resource
{
public:
- //! Constructor.
- //! Create capping plane presentation associated to clipping plane data.
- //! @param thePlane [in] the plane data.
- Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
+ //! Create and assign style.
+ Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect);
//! Destroy object.
Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
- //! Update resource data in the passed context.
- //! @param theContext [in] the context
- //! @param theObjAspect [in] object aspect
- Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext,
- const Handle(Graphic3d_Aspects)& theObjAspect);
+ //! Assign section style.
+ Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect);
+
+ //! Returns section style parameters.
+ const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myAspect; }
//! Release associated OpenGl resources.
//! @param theContext [in] the resource context.
//! Returns estimated GPU memory usage - not implemented.
virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
- //! Return parent clipping plane structure.
- const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; }
+ //! @return primitive array of vertices to render infinite plane.
+ static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices();
- //! @return aspect face for rendering capping surface.
- inline const OpenGl_Aspects* AspectFace() const { return myAspect; }
+ //! Returns true if capping should draw hatch layer.
+ Standard_Boolean ToDrawHatch() const
+ {
+ return myAspect->ToDrawHatch()
+ && (myAspect->IsStippleHatch()
+ || myAspect->IsTextureHatch());
+ }
- //! @return evaluated orientation matrix to transform infinite plane.
- inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
+ //! Returns the shading aspect for drawing face of a clipping section itself.
+ //! @param theObjectAspect [in] the aspect of an object if it requires combining.
+ Standard_EXPORT const OpenGl_Aspects* CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const;
- //! @return primitive array of vertices to render infinite plane.
- inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
+ //! Returns the shading aspect for drawing hatch layer of a section.
+ Standard_EXPORT const OpenGl_Aspects* HatchingFaceAspect() const;
private:
private:
- OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering
- OpenGl_Matrix myOrientation; //!< plane transformation matrix.
- OpenGl_Aspects* myAspect; //!< capping face aspect.
- Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure.
- Handle(Graphic3d_Aspects) myFillAreaAspect;//!< own capping aspect
- gp_XYZ myLocalOrigin; //!< layer origin
- unsigned int myEquationMod; //!< modification counter for plane equation.
- unsigned int myAspectMod; //!< modification counter for aspect.
+ Handle(Graphic3d_AspectFillCapping) myAspect; //!< Section style settings from application's level.
+ mutable OpenGl_Aspects myCappingAspect; //!< GL aspect for shading base layer of a capping section.
+ mutable OpenGl_Aspects myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
+ mutable Standard_Size myHatchingState;
+ gp_XYZ myLocalOrigin; //!< layer origin
public:
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_GroupDefinitionError.hxx>
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Group,Graphic3d_Group)
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);
#include <NCollection_List.hxx>
#include <OpenGl_Aspects.hxx>
+#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_Group;
//! 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, const Standard_Integer theDepth = -1) const Standard_OVERRIDE;
protected:
OpenGl_Aspects* myAspects;
+ OpenGl_CappingPlaneResource* myAspectFillCapping;
OpenGl_ElementNode* myFirst;
OpenGl_ElementNode* myLast;
Standard_Boolean myIsRaytracable;
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,
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;
}
void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
const TopoDS_Shape& theShape,
const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
const StdPrs_Volume theVolume)
{
gp_Pnt2d aDummy;
StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
- Standard_False, aDummy, aDummy, aDummy, theVolume);
+ Standard_False, aDummy, aDummy, aDummy, theCappingStyle, theVolume);
}
// =======================================================================
const gp_Pnt2d& theUVOrigin,
const gp_Pnt2d& theUVRepeat,
const gp_Pnt2d& theUVScale,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
const StdPrs_Volume theVolume)
{
if (theShape.IsNull())
if (aClosed.NbChildren() > 0)
{
- shadeFromShape (aClosed, thePrs, theDrawer,
+ shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
}
if (anOpened.NbChildren() > 0)
{
- shadeFromShape (anOpened, thePrs, theDrawer,
+ shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
}
}
else
{
// if the shape type is not compound, composolid or solid, use autodetection back-facing filled
- shadeFromShape (theShape, thePrs, theDrawer,
+ shadeFromShape (theShape, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
theVolume == StdPrs_Volume_Closed);
}
//! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
//! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
//! or to perform Autodetection (would split input shape into two groups)
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+ const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
+ StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Shades <theShape> with texture coordinates.
//! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
//! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
//! or to perform Autodetection (would split input shape into two groups)
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const Standard_Boolean theHasTexels, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, const gp_Pnt2d& theUVScale, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+ const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Standard_Boolean theHasTexels,
+ const gp_Pnt2d& theUVOrigin,
+ const gp_Pnt2d& theUVRepeat,
+ const gp_Pnt2d& theUVScale,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
+ const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Searches closed and unclosed subshapes in shape structure and puts them
//! into two compounds for separate processing of closed and unclosed sub-shapes
if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+ aClipPlane->CappingSectionStyle()->SetUseObjectMaterial (toEnable == Standard_True);
anArgIter += 1;
}
}
if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
+ aClipPlane->CappingSectionStyle()->SetUseObjectTexture (toEnable == Standard_True);
anArgIter += 1;
}
}
if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetUseObjectShader (toEnable == Standard_True);
+ aClipPlane->CappingSectionStyle()->SetUseObjectShader (toEnable == Standard_True);
anArgIter += 1;
}
}
return 1;
}
aClipPlane->SetCappingColor (aColor);
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material();
+ aClipPlane->CappingSectionStyle()->SetMaterial (aMat);
anArgIter += aNbParsed;
}
else if (aNbChangeArgs >= 1
&& aNbChangeArgs >= 2)
{
TCollection_AsciiString aValStr (aChangeArgs[1]);
- Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
if (aValStr.IsRealValue())
{
- Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material();
aMat.SetTransparency ((float )aValStr.RealValue());
- anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
- aClipPlane->SetCappingMaterial (aMat);
+ aClipPlane->CappingSectionStyle()->SetMaterial (aMat);
}
else
{
- aValStr.LowerCase();
- Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto;
- if (aValStr == "opaque")
- {
- aMode = Graphic3d_AlphaMode_Opaque;
- }
- else if (aValStr == "mask")
- {
- aMode = Graphic3d_AlphaMode_Mask;
- }
- else if (aValStr == "blend")
- {
- aMode = Graphic3d_AlphaMode_Blend;
- }
- else if (aValStr == "blendauto")
- {
- aMode = Graphic3d_AlphaMode_BlendAuto;
- }
- else
- {
- std::cout << "Syntax error at '" << aValStr << "'\n";
- return 1;
- }
- anAspect->SetAlphaMode (aMode);
- aClipPlane->SetCappingAspect (anAspect);
+ std::cout << "Syntax error at '" << aValStr << "'\n";
+ return 1;
}
anArgIter += 1;
}
+ else if (aChangeArg == "-overrideaspect"
+ || aChangeArg == "overrideaspect")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
else if (aChangeArg == "-texname"
|| aChangeArg == "texname")
{
Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
if (!aTexture->IsDone())
{
- aClipPlane->SetCappingTexture (NULL);
+ aClipPlane->CappingSectionStyle()->SetTexture (Handle(Graphic3d_TextureMap)());
}
else
{
aTexture->EnableModulate();
aTexture->EnableRepeat();
- aClipPlane->SetCappingTexture (aTexture);
+ aClipPlane->CappingSectionStyle()->SetTexture (aTexture.get());
}
anArgIter += 1;
}
else if (aChangeArg == "-texscale"
|| aChangeArg == "texscale")
{
- if (aClipPlane->CappingTexture().IsNull())
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+ if (aHatchTexture.IsNull())
{
std::cout << "Error: no texture is set.\n";
return 1;
Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
- aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
anArgIter += 2;
}
else if (aChangeArg == "-texorigin"
|| aChangeArg == "texorigin") // texture origin
{
- if (aClipPlane->CappingTexture().IsNull())
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+ if (aHatchTexture.IsNull())
{
std::cout << "Error: no texture is set.\n";
return 1;
Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
- aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
anArgIter += 2;
}
else if (aChangeArg == "-texrotate"
|| aChangeArg == "texrotate") // texture rotation
{
- if (aClipPlane->CappingTexture().IsNull())
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->Texture();
+
+ if (aHatchTexture.IsNull())
{
std::cout << "Error: no texture is set.\n";
return 1;
}
Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
- aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
+ aHatchTexture->GetParams()->SetRotation (aRot);
anArgIter += 1;
}
else if (aChangeArg == "-hatch"
return 1;
}
- TCollection_AsciiString aHatchStr (aChangeArgs[1]);
- aHatchStr.LowerCase();
- if (aHatchStr == "on")
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetCappingHatchOn();
+ aClipPlane->CappingSectionStyle()->SetToDrawHatch (toEnable == Standard_True);
+ anArgIter += 1;
}
- else if (aHatchStr == "off")
+ }
+ else if (aChangeArg == "-hatchtexture"
+ || aChangeArg == "hatchtexture")
+ {
+ if (aNbChangeArgs < 2)
{
- aClipPlane->SetCappingHatchOff();
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aTextureName (aChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
+ {
+ aClipPlane->CappingSectionStyle()->SetHatchStyle (Handle(Graphic3d_TextureMap)());
}
else
{
- aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
+ aTexture->EnableModulate();
+ aTexture->EnableRepeat();
+ aClipPlane->CappingSectionStyle()->SetHatchStyle (aTexture.get());
+ aClipPlane->CappingSectionStyle()->SetToDrawHatch (true);
+ }
+ anArgIter += 1;
+ }
+ else if (aChangeArg == "-hatchstipple"
+ || aChangeArg == "hatchstipple")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
}
+
+ aClipPlane->CappingSectionStyle()->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
+ aClipPlane->CappingSectionStyle()->SetToDrawHatch (true);
anArgIter += 1;
}
+ else if (aChangeArg == "-hatchcolor"
+ || aChangeArg == "hatchcolor")
+ {
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ aChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->HatchMaterial();
+ aMat.SetAmbientColor (aColor);
+ aMat.SetDiffuseColor (aColor);
+ aClipPlane->CappingSectionStyle()->SetHatchMaterial (aMat);
+ anArgIter += aNbParsed;
+ }
+
+ else if (aChangeArg == "-hatchscale"
+ || aChangeArg == "hatchscale")
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
+ aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ anArgIter += 2;
+ }
+ else if (aChangeArg == "-hatchorigin"
+ || aChangeArg == "hatchorigin") // texture origin
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
+
+ aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ anArgIter += 2;
+ }
+ else if (aChangeArg == "-hatchrotate"
+ || aChangeArg == "hatchrotate") // texture rotation
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = aClipPlane->CappingSectionStyle()->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return 1;
+ }
+
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
+ aHatchTexture->GetParams()->SetRotation (aRot);
+ anArgIter += 1;
+ }
+ else if (aChangeArg == "-hatchzoompers"
+ || aChangeArg == "hatchzoompers")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->CappingSectionStyle()->SetHatchZoomPeristent (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (aChangeArg == "-hatchrotatepers"
+ || aChangeArg == "hatchrotatepers")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->CappingSectionStyle()->SetHatchRotationPeristent (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
else if (aChangeArg == "-delete"
|| aChangeArg == "delete")
{
"\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:"
"\n\t\t: -clone SourcePlane NewPlane clone the plane definition."
"\n\t\t: Capping options:"
"\n\t\t: -capping {off|on|0|1} turn capping on/off"
+ "\n\t\t: -overrideAspect override presentation aspect (if defined)"
"\n\t\t: -color R G B set capping color"
"\n\t\t: -transparency Value set capping transparency 0..1"
"\n\t\t: -texName Texture set capping texture"
"\n\t\t: -texScale SX SY set capping tex scale"
"\n\t\t: -texOrigin TX TY set capping tex origin"
"\n\t\t: -texRotate Angle set capping tex rotation"
- "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
+ "\n\t\t: -hatch {on|off} turn on/off hatch style on capping"
+ "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
+ "\n\t\t: -hatchColor R G B set color for hatch material"
+ "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
+ "\n\t\t: -hatchScale SX SY set hatch texture scale"
+ "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
+ "\n\t\t: -hatchRotate Angle set hatch texture rotation"
+ "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
+ "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
"\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
"\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
"\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
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
vzoom 0.8
puts "Enable capping planes"
-vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -texname $aHatch -texscale 0.02 -0.02 -useObjMaterial 1
-vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -texname $aHatch -texscale 0.02 -0.02
+vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -hatchtexture $aHatch -hatchscale 0.02 -0.02 -useObjMaterial 1
+vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -hatchtexture $aHatch -hatchscale 0.02 -0.02
projects / occt-copy.git / commitdiff
