{
aShadedGroup = Prs3d_Root::NewGroup (thePrs);
aShadedGroup->SetClosed (isClosed);
+ if (isClosed
+ && !myCappingStyle.IsNull())
+ aShadedGroup->SetGroupPrimitivesAspect (myCappingStyle);
}
aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect());
aShadedGroup->AddPrimitiveArray (aTriangles);
#include <Aspect_PolygonOffsetMode.hxx>
#include <Bnd_Box.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
hasOwnMaterial = Standard_False;
}
+//=======================================================================
+//function : SetCappingStyle
+//purpose :
+//=======================================================================
+void AIS_InteractiveObject::SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+ myCappingStyle = theStyle;
+
+ // Modify existing presentations
+ for (Standard_Integer aPrsIter = 1, n = myPresentations.Length(); aPrsIter <= n; ++aPrsIter)
+ {
+ const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter).Presentation();
+ if (!aPrs3d.IsNull())
+ {
+ const Handle(Graphic3d_Structure)& aStruct = aPrs3d->Presentation();
+ if (!aStruct.IsNull())
+ {
+ const Graphic3d_SequenceOfGroup& aGroups = aStruct->Groups();
+ for (Graphic3d_SequenceOfGroup::Iterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next())
+ {
+ Handle(Graphic3d_Group)& aGrp = aGroupIter.ChangeValue();
+ if (aGrp.IsNull())
+ continue;
+
+ aGrp->SetGroupPrimitivesAspect (theStyle);
+ }
+ }
+ }
+ }
+}
+
//=======================================================================
//function : SetTransparency
//purpose :
continue;
}
- Handle(Graphic3d_AspectLine3d) aLineAspect = aGrp->LineAspect();
- Handle(Graphic3d_AspectFillArea3d) aFaceAspect = aGrp->FillAreaAspect();
- Handle(Graphic3d_AspectMarker3d) aMarkerAspect = aGrp->MarkerAspect();
- Handle(Graphic3d_AspectText3d) aTextAspect = aGrp->TextAspect();
+ Handle(Graphic3d_AspectLine3d) aLineAspect = aGrp->LineAspect();
+ Handle(Graphic3d_AspectFillArea3d) aFaceAspect = aGrp->FillAreaAspect();
+ Handle(Graphic3d_AspectFillCapping) aCappingAspect = aGrp->FillCappingAspect();
+ Handle(Graphic3d_AspectMarker3d) aMarkerAspect = aGrp->MarkerAspect();
+ Handle(Graphic3d_AspectText3d) aTextAspect = aGrp->TextAspect();
if (!aLineAspect.IsNull())
{
aGrp->SetGroupPrimitivesAspect (aLineAspect);
{
aGrp->SetGroupPrimitivesAspect (aFaceAspect);
}
+ if (!aCappingAspect.IsNull())
+ {
+ aGrp->SetGroupPrimitivesAspect (aCappingAspect);
+ }
if (!aMarkerAspect.IsNull())
{
aGrp->SetGroupPrimitivesAspect (aMarkerAspect);
{
aGrp->SetGroupPrimitivesAspect (aTextAspect);
}
+
}
}
}
//! Material aspect determines shading aspect, color and
//! transparency of visible entities.
Standard_EXPORT virtual void SetMaterial (const Graphic3d_MaterialAspect& aName);
-
+
//! Removes the setting for material.
Standard_EXPORT virtual void UnsetMaterial();
-
+
+ //! Set style of filling capping section created by clipping planes.
+ Standard_EXPORT virtual void SetCappingStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+ //! Returns style for filling capping section created by clipping planes.
+ const Handle(Graphic3d_AspectFillCapping)& CappingStyle() const { return myCappingStyle; }
+
//! Attributes a setting aValue for transparency.
//! The transparency value should be between 0.0 and 1.0.
//! At 0.0 an object will be totally opaque, and at 1.0, fully transparent.
Standard_Boolean hasOwnColor;
Standard_Boolean hasOwnMaterial;
Standard_Boolean myRecomputeEveryPrs;
-
+ Handle(Graphic3d_AspectFillCapping) myCappingStyle;
};
DEFINE_STANDARD_HANDLE(AIS_InteractiveObject, SelectMgr_SelectableObject)
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_ArrayOfTriangleStrips.hxx
Graphic3d_AspectFillArea3d.cxx
Graphic3d_AspectFillArea3d.hxx
+Graphic3d_AspectFillCapping.cxx
+Graphic3d_AspectFillCapping.hxx
Graphic3d_AspectLine3d.cxx
Graphic3d_AspectLine3d.hxx
Graphic3d_AspectMarker3d.cxx
Graphic3d_Camera.cxx
Graphic3d_Camera.hxx
Graphic3d_CameraTile.hxx
-Graphic3d_CappingFlags.hxx
Graphic3d_CLight.cxx
Graphic3d_CLight.hxx
Graphic3d_ClipPlane.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_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 Standard_Transient
+{
+public:
+
+ //! Default constructor.
+ Standard_EXPORT Graphic3d_AspectFillCapping();
+
+public:
+
+ //! Sets material for filling section created by clipping.
+ void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; }
+
+ //! Returns material for filling section created by clipping.
+ const Graphic3d_MaterialAspect& Material() const { return myMaterial; }
+
+ //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); }
+
+ //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; }
+
+ //! Sets texture for filling section created by clipping.
+ void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; }
+
+ //! Returns texture for filling section created by clipping.
+ const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; }
+
+ //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); }
+
+ //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; }
+
+ //! Sets OpenGL/GLSL shader program.
+ void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; }
+
+ //! Returns OpenGL/GLSL shader program.
+ const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; }
+
+ //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); }
+
+ //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; }
+
+public:
+
+ //! Sets style of hatch defined by predefined stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle);
+
+ //! Sets style of hatch defined by custom stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle);
+
+ //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used).
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture);
+
+ //! Sets material style for hatch lines (texture).
+ Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial);
+
+ //! Returns material style for hatch lines (texture).
+ const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; }
+
+ //! Sets boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw);
+
+ //! Returns boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on zooming.
+ //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming.
+ Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on zooming.
+ Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; }
+
+ //! Returns true if hatch is defined by texture.
+ Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); }
+
+ //! Returns texture map defining the hatch.
+ const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; }
+
+ //! Returns true if hatch is defined by stipple mask.
+ Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); }
+
+ //! Returns the stipple mask.
+ const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; }
+
+ //! Returns modification counter for hatching state.
+ Standard_Size HatchingState() const { return myHatchingState; }
+
+private:
+
+ enum Flags
+ {
+ Flags_None = 0x00, //!< no flags
+ Flags_UseObjectMaterial = 0x01, //!< use object material
+ Flags_UseObjectTexture = 0x02, //!< use object texture
+ Flags_UseObjectShader = 0x04, //!< use object GLSL program
+ Flags_HatchZoomPersistent = 0x08, //!< zoom-persistent texturing
+ Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing
+ Flags_DrawHatching = 0x20, //!< draw hatching
+ Flags_UseObjectProperties = //!< use entire fill area aspect from object
+ Flags_UseObjectMaterial
+ | Flags_UseObjectTexture
+ | Flags_UseObjectShader
+ };
+
+ void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag)
+ {
+ myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag;
+ }
+
+private:
+
+ Graphic3d_MaterialAspect myMaterial;
+ Handle(Graphic3d_TextureMap) myTexture;
+ Handle(Graphic3d_ShaderProgram) myShader;
+ Handle(Graphic3d_HatchStyle) myStippleHatch;
+ Handle(Graphic3d_TextureMap) myTextureHatch;
+ Graphic3d_MaterialAspect myHatchMaterial;
+ unsigned int myFlags;
+ Standard_Size myHatchingState;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Standard_Transient)
+};
+
+DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Standard_Transient)
+
+#endif // _Graphic3d_AspectFillCapping_HeaderFile
+++ /dev/null
-// Created on: 2016-08-04
-// Copyright (c) 2016 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Graphic3d_CappingFlags_HeaderFile
-#define _Graphic3d_CappingFlags_HeaderFile
-
-//! Enumeration of capping flags.
-enum Graphic3d_CappingFlags
-{
- Graphic3d_CappingFlags_None = 0x0000, //!< no flags
- Graphic3d_CappingFlags_ObjectMaterial = 0x0001, //!< use object material
- Graphic3d_CappingFlags_ObjectTexture = 0x0002, //!< use object texture
- Graphic3d_CappingFlags_ObjectShader = 0x0008, //!< use object GLSL program
- Graphic3d_CappingFlags_ObjectAspect =
- Graphic3d_CappingFlags_ObjectMaterial | Graphic3d_CappingFlags_ObjectTexture | Graphic3d_CappingFlags_ObjectShader //!< use entire fill area aspect from object
-};
-
-#endif // _Graphic3d_CappingFlags_HeaderFile
#include <gp_Pln.hxx>
#include <Standard_Atomic.hxx>
-IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient)
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_ClipPlane, Standard_Transient)
namespace
{
static volatile Standard_Integer THE_CLIP_PLANE_COUNTER = 0;
-
- static Handle(Graphic3d_AspectFillArea3d) defaultAspect()
- {
- const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
- Handle(Graphic3d_AspectFillArea3d) anAspect = new Graphic3d_AspectFillArea3d();
- anAspect->SetDistinguishOff();
- anAspect->SetFrontMaterial (aMaterial);
- anAspect->SetHatchStyle (Aspect_HS_HORIZONTAL);
- anAspect->SetInteriorStyle (Aspect_IS_SOLID);
- anAspect->SetInteriorColor (aMaterial.Color());
- anAspect->SetSuppressBackFaces (false);
- return anAspect;
- }
}
// =======================================================================
// purpose :
// =======================================================================
Graphic3d_ClipPlane::Graphic3d_ClipPlane()
-: myAspect (defaultAspect()),
- myPlane (0.0, 0.0, 1.0, 0.0),
- myEquation (0.0, 0.0, 1.0, 0.0),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
{
- makeId();
+ init();
}
// =======================================================================
// function : Graphic3d_ClipPlane
// purpose :
// =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Equation& theEquation)
-: myAspect (defaultAspect()),
- myPlane (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w()),
- myEquation (theEquation),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Equation& theEquation)
{
- makeId();
+ init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a()));
}
// =======================================================================
// function : Graphic3d_ClipPlane
// purpose :
// =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther)
-: Standard_Transient(theOther),
- myAspect (defaultAspect()),
- myPlane (theOther.myPlane),
- myEquation (theOther.myEquation),
- myFlags (theOther.myFlags),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (theOther.myIsOn),
- myIsCapping (theOther.myIsCapping)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther)
+: Standard_Transient (theOther)
{
- makeId();
- *myAspect = *theOther.CappingAspect();
+ init (theOther.myPlane,
+ theOther.myIsOn,
+ theOther.myIsCapping,
+ theOther.ToOverrideCappingAspect(),
+ theOther.CappingSectionStyle());
}
// =======================================================================
// function : Graphic3d_ClipPlane
// purpose :
// =======================================================================
-Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane)
-: myAspect (defaultAspect()),
- myPlane (thePlane),
- myFlags (Graphic3d_CappingFlags_None),
- myEquationMod(0),
- myAspectMod (0),
- myIsOn (Standard_True),
- myIsCapping (Standard_False)
+Graphic3d_ClipPlane::Graphic3d_ClipPlane (const gp_Pln& thePlane)
{
- thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
- makeId();
+ init (thePlane);
}
// =======================================================================
// =======================================================================
void Graphic3d_ClipPlane::SetEquation (const Equation& theEquation)
{
- myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
- myEquation = theEquation;
- myEquationMod++;
+ myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
+ myEquation = theEquation;
+ myOrientationDirty = Standard_True;
}
// =======================================================================
-// function : SetPlane
+// function : SetEquation
// purpose :
// =======================================================================
void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane)
{
myPlane = thePlane;
- thePlane.Coefficients (myEquation[0],
- myEquation[1],
- myEquation[2],
- myEquation[3]);
- myEquationMod++;
+ thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
+ myOrientationDirty = Standard_True;
}
// =======================================================================
}
// =======================================================================
-// function : SetCappingMaterial
+// function : SetCappingSectionStyle
// purpose :
// =======================================================================
-void Graphic3d_ClipPlane::SetCappingMaterial (const Graphic3d_MaterialAspect& theMat)
+void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
{
- myAspect->SetFrontMaterial (theMat);
- myAspect->SetInteriorColor (theMat.Color());
- ++myAspectMod;
+ mySectionStyle = theStyle;
}
// =======================================================================
-// function : SetCappingTexture
+// function : OrientationMatrix
// purpose :
// =======================================================================
-void Graphic3d_ClipPlane::SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture)
+const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const
{
- if (!theTexture.IsNull())
+ if (myOrientationDirty)
{
- myAspect->SetTextureMapOn();
- Handle(Graphic3d_TextureSet) aTextureSet = myAspect->TextureSet();
- if (aTextureSet.IsNull() || aTextureSet->Size() != 1)
+ const Standard_ShortReal aDirection[] = {
+ static_cast<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 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));
+ 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;
}
#define _Graphic3d_ClipPlane_HeaderFile
#include <Aspect_HatchStyle.hxx>
-#include <gp_Pln.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
-#include <Graphic3d_CappingFlags.hxx>
+#include <Graphic3d_AspectFillCapping.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>
#include <Standard_Transient.hxx>
+#include <Standard_TypeDef.hxx>
+#include <gp_Pln.hxx>
//! Container for properties describing graphic driver clipping planes.
//! It is up to application to create instances of this class and specify its
typedef NCollection_Vec4<Standard_Real> Equation;
+public:
+
//! Default constructor.
//! Initializes clip plane container with the following properties:
//! - Equation (0.0, 0.0, 1.0, 0)
//! Copy constructor.
//! @param theOther [in] the copied plane.
- Standard_EXPORT Graphic3d_ClipPlane(const Graphic3d_ClipPlane& theOther);
+ Standard_EXPORT Graphic3d_ClipPlane (const Graphic3d_ClipPlane& theOther);
//! Construct clip plane for the passed equation.
//! By default the plane is on, capping is turned off.
//! Get 4-component equation vector for clipping plane.
//! @return clipping plane equation vector.
- const Equation& GetEquation() const
- {
- return myEquation;
- }
+ const Equation& GetEquation() const { return myEquation; }
//! Check that the clipping plane is turned on.
//! @return boolean flag indicating whether the plane is in on or off state.
- Standard_Boolean IsOn() const
- {
- return myIsOn;
- }
+ Standard_Boolean IsOn() const { return myIsOn; }
//! Change state of the clipping plane.
//! @param theIsOn [in] the flag specifying whether the graphic driver
//! clipping by this plane should be turned on or off.
Standard_EXPORT void SetOn(const Standard_Boolean theIsOn);
- //! Change state of capping surface rendering.
- //! @param theIsOn [in] the flag specifying whether the graphic driver should
- //! perform rendering of capping surface produced by this plane. The graphic
- //! driver produces this surface for convex graphics by means of stencil-test
- //! and multi-pass rendering.
- Standard_EXPORT void SetCapping(const Standard_Boolean theIsOn);
-
- //! Check state of capping surface rendering.
- //! @return true (turned on) or false depending on the state.
- Standard_Boolean IsCapping() const
- {
- return myIsCapping;
- }
-
//! Get geometrical definition.
//! @return geometrical definition of clipping plane
const gp_Pln& ToPlane() const { return myPlane; }
//! @return new instance of clipping plane with same properties and attributes.
Standard_EXPORT virtual Handle(Graphic3d_ClipPlane) Clone() const;
-public: // @name user-defined graphical attributes
-
- //! Set material for rendering capping surface.
- //! @param theMat [in] the material.
- Standard_EXPORT void SetCappingMaterial (const Graphic3d_MaterialAspect& theMat);
-
- //! @return capping material.
- const Graphic3d_MaterialAspect& CappingMaterial() const { return myAspect->FrontMaterial(); }
-
- //! Set texture to be applied on capping surface.
- //! @param theTexture [in] the texture.
- Standard_EXPORT void SetCappingTexture (const Handle(Graphic3d_TextureMap)& theTexture);
-
- //! @return capping texture map.
- Handle(Graphic3d_TextureMap) CappingTexture() const { return !myAspect->TextureSet().IsNull() && !myAspect->TextureSet()->IsEmpty()
- ? myAspect->TextureSet()->First()
- : Handle(Graphic3d_TextureMap)(); }
-
- //! Set hatch style (stipple) and turn hatching on.
- //! @param theStyle [in] the hatch style.
- Standard_EXPORT void SetCappingHatch (const Aspect_HatchStyle theStyle);
-
- //! @return hatching style.
- Aspect_HatchStyle CappingHatch() const { return (Aspect_HatchStyle)myAspect->HatchStyle()->HatchType(); }
-
- //! Set custom hatch style (stipple) and turn hatching on.
- //! @param theStyle [in] the hatch pattern.
- Standard_EXPORT void SetCappingCustomHatch (const Handle(Graphic3d_HatchStyle)& theStyle);
-
- //! @return hatching style.
- const Handle(Graphic3d_HatchStyle)& CappingCustomHatch() const { return myAspect->HatchStyle(); }
-
- //! Turn on hatching.
- Standard_EXPORT void SetCappingHatchOn();
-
- //! Turn off hatching.
- Standard_EXPORT void SetCappingHatchOff();
-
- //! @return True if hatching mask is turned on.
- Standard_Boolean IsHatchOn() const { return myAspect->InteriorStyle() == Aspect_IS_HATCH; }
-
//! This ID is used for managing associated resources in graphical driver.
//! The clip plane can be assigned within a range of IO which can be
//! displayed in separate OpenGl contexts. For each of the context an associated
//! The resources are stored in graphical driver for each of individual groups
//! of shared context under the clip plane identifier.
//! @return clip plane resource identifier string.
- const TCollection_AsciiString& GetId() const
- {
- return myId;
- }
+ const TCollection_AsciiString& GetId() const { return myEntityUID; }
public:
- //! Return capping aspect.
- //! @return capping surface rendering aspect.
- const Handle(Graphic3d_AspectFillArea3d)& CappingAspect() const { return myAspect; }
-
- //! 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); }
+ //! Change state of capping surface rendering.
+ //! @param theIsOn [in] the flag specifying whether the graphic driver should
+ //! perform rendering of capping surface produced by this plane. The graphic
+ //! driver produces this surface for convex graphics by means of stencil-test
+ //! and multi-pass rendering.
+ Standard_EXPORT void SetCapping(const Standard_Boolean theIsOn);
- //! 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; }
+ //! Check state of capping surface rendering.
+ //! @return true (turned on) or false depending on the state.
+ Standard_Boolean IsCapping() const { return myIsCapping; }
- //! Set flag for controlling the source of capping plane shader program.
- void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); }
+ //! Sets clipping section filling aspect.
+ Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
- //! Return true if some fill area aspect properties should be taken from object.
- bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; }
+ //! Returns style used for drawing capping section.
+ const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; }
-public: // @name modification counters
+ //! 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; }
- //! @return modification counter for equation.
- unsigned int MCountEquation() const
- {
- return myEquationMod;
- }
+ //! Sets flag for controlling the preference of using section style between clip plane and object.
+ void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; }
- //! @return modification counter for aspect.
- unsigned int MCountAspect() const
- {
- return myAspectMod;
- }
+ //! Returns plane's orientation matrix.
+ Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const;
private:
- //! Generate unique object id for OpenGL graphic resource manager.
- void makeId();
-
- //! Set capping flag.
- Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag);
+ //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities.
+ void init (const gp_Pln& thePlane = gp_Pln(),
+ const Standard_Boolean theIsOn = Standard_True,
+ const Standard_Boolean theIsCapping = Standard_False,
+ const Standard_Boolean theOverrideStyle = Standard_False,
+ const Handle(Graphic3d_AspectFillCapping)& theStyle = Handle(Graphic3d_AspectFillCapping)());
private:
- Handle(Graphic3d_AspectFillArea3d) myAspect; //!< fill area aspect
- TCollection_AsciiString myId; //!< resource id
- gp_Pln myPlane; //!< plane definition
- Equation myEquation; //!< plane equation vector
- unsigned int myFlags; //!< capping flags
- unsigned int myEquationMod; //!< modification counter for equation
- unsigned int myAspectMod; //!< modification counter of aspect
- Standard_Boolean myIsOn; //!< state of the clipping plane
- Standard_Boolean myIsCapping; //!< state of graphic driver capping
+ TCollection_AsciiString myEntityUID; //!< Unique identifier for the plane
+ gp_Pln myPlane; //!< Plane definition
+ Equation myEquation; //!< Plane equation vector
+ Standard_Boolean myIsOn; //!< State of the clipping plane
+ Standard_Boolean myIsCapping; //!< State of graphic driver capping
+ Standard_Boolean myOverrideObjectStyle; //!< Flag forcing to use plane's section style rather than section style defined for object
+ Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section.
+ mutable Standard_Boolean myOrientationDirty; //!< Boolean flag indicating whether orientation matrix is dirty or not.
+ mutable Graphic3d_Mat4 myOrientationMat; //!< Plane orientation matrix (for visualization purposes).
public:
- DEFINE_STANDARD_RTTIEXT(Graphic3d_ClipPlane,Standard_Transient)
+ DEFINE_STANDARD_RTTIEXT (Graphic3d_ClipPlane, Standard_Transient)
};
DEFINE_STANDARD_HANDLE (Graphic3d_ClipPlane, Standard_Transient)
// function : GroupPrimitivesAspect
// purpose :
// =======================================================================
-void Graphic3d_Group::GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine,
- const Handle(Graphic3d_AspectText3d)& theAspText,
- const Handle(Graphic3d_AspectMarker3d)& theAspMarker,
- const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const
+void Graphic3d_Group::GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine,
+ const Handle(Graphic3d_AspectText3d)& theAspText,
+ const Handle(Graphic3d_AspectMarker3d)& theAspMarker,
+ const Handle(Graphic3d_AspectFillArea3d)& theAspFill,
+ const Handle(Graphic3d_AspectFillCapping)& theAspCapping) const
{
if (!theAspLine.IsNull())
{
*theAspFill.operator->() = *aFillAspect;
}
}
+
+ if (!theAspCapping.IsNull())
+ {
+ Handle(Graphic3d_AspectFillCapping) aCappingAspect = FillCappingAspect();
+ if (!aCappingAspect.IsNull())
+ {
+ *theAspCapping.operator->() = *aCappingAspect;
+ }
+ }
}
// =======================================================================
#ifndef _Graphic3d_Group_HeaderFile
#define _Graphic3d_Group_HeaderFile
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
-
-#include <Graphic3d_BndBox4f.hxx>
-#include <Standard_Boolean.hxx>
-#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
-#include <Graphic3d_AspectText3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
+#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
-#include <Standard_Transient.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_CString.hxx>
-#include <Graphic3d_Vertex.hxx>
-#include <Graphic3d_TextPath.hxx>
+#include <Graphic3d_AspectText3d.hxx>
+#include <Graphic3d_BndBox4f.hxx>
+#include <Graphic3d_BoundBuffer.hxx>
+#include <Graphic3d_Buffer.hxx>
+#include <Graphic3d_GroupAspect.hxx>
#include <Graphic3d_HorizontalTextAlignment.hxx>
-#include <Graphic3d_VerticalTextAlignment.hxx>
-#include <Graphic3d_TypeOfPrimitiveArray.hxx>
#include <Graphic3d_IndexBuffer.hxx>
-#include <Graphic3d_Buffer.hxx>
-#include <Graphic3d_BoundBuffer.hxx>
+#include <Graphic3d_TextPath.hxx>
+#include <Graphic3d_TypeOfPrimitiveArray.hxx>
+#include <Graphic3d_Vertex.hxx>
+#include <Graphic3d_VerticalTextAlignment.hxx>
+#include <MMgt_TShared.hxx>
+#include <Standard.hxx>
#include <Standard_Address.hxx>
-#include <Graphic3d_GroupAspect.hxx>
-#include <gp_Ax2.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_CString.hxx>
+#include <Standard_Real.hxx>
+#include <Standard_Type.hxx>
#include <TCollection_ExtendedString.hxx>
+#include <gp_Ax2.hxx>
class Graphic3d_Structure;
class Graphic3d_ArrayOfPrimitives;
//! 1) Non-modifiable, or unbounded, group ('black box').
//! Developers can repeat a sequence of
//! SetPrimitivesAspect() with AddPrimitiveArray() methods arbitrary number of times
-//! to define arbitrary number of primitive "blocks" each having individual apect values.
+//! to define arbitrary number of primitive "blocks" each having individual aspect values.
//! Any modification of such a group is forbidden, as aspects and primitives are mixed
//! in memory without any high-level logical structure, and any modification is very likely to result
//! in corruption of the group internal data.
//! with aspects and primitives and choose the group usage model beforehand out of application needs.
//! Note that some Graphic3d_Group class virtual methods contain only base implementation
//! that is extended by the descendant class in OpenGl package.
-class Graphic3d_Group : public Standard_Transient
+class Graphic3d_Group : public MMgt_TShared
{
friend class Graphic3d_Structure;
- DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,Standard_Transient)
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_Group,MMgt_TShared)
public:
- //! Supress all primitives and attributes of <me>.
+ //! Suppress all primitives and attributes of <me>.
//! To clear group without update in Graphic3d_StructureManager
//! pass Standard_False as <theUpdateStructureMgr>. This
//! used on context and viewer destruction, when the pointer
//! cross-reference);
Standard_EXPORT virtual void Clear (const Standard_Boolean theUpdateStructureMgr = Standard_True);
- //! Supress the group <me> in the structure.
+ //! Suppress the group <me> in the structure.
Standard_EXPORT virtual ~Graphic3d_Group();
- //! Supress the group <me> in the structure.
+ //! Suppress the group <me> in the structure.
//! Warning: No more graphic operations in <me> after this call.
- //! Modifies the current modelling transform persistence (pan, zoom or rotate)
- //! Get the current modelling transform persistence (pan, zoom or rotate)
+ //! Modifies the current modeling transform persistence (pan, zoom or rotate)
+ //! Get the current modeling transform persistence (pan, zoom or rotate)
Standard_EXPORT void Remove();
public:
//! Modifies the context for all the marker primitives of the group.
virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& theAspect) = 0;
+ //! Returns style of filling clipping sections on closed shell primitives.
+ virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const = 0;
+
+ //! Modifies the context for filling clipping section for all closed shell primitives of the group.
+ virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) = 0;
+
//! Modifies the current context of the group to give
//! another aspect for all the line primitives created
//! after this call in the group.
Standard_EXPORT void GroupPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine,
const Handle(Graphic3d_AspectText3d)& theAspText,
const Handle(Graphic3d_AspectMarker3d)& theAspMarker,
- const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const;
+ const Handle(Graphic3d_AspectFillArea3d)& theAspFill,
+ const Handle(Graphic3d_AspectFillCapping)& theAspFillCapping) const;
//! Returns the last inserted context in the group for each kind of primitives.
- void PrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine,
- const Handle(Graphic3d_AspectText3d)& theAspText,
- const Handle(Graphic3d_AspectMarker3d)& theAspMarker,
- const Handle(Graphic3d_AspectFillArea3d)& theAspFill) const
+ void PrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspLine,
+ const Handle(Graphic3d_AspectText3d)& theAspText,
+ const Handle(Graphic3d_AspectMarker3d)& theAspMarker,
+ const Handle(Graphic3d_AspectFillArea3d)& theAspFill,
+ const Handle(Graphic3d_AspectFillCapping)& theAspFillCapping) const
{
- GroupPrimitivesAspect (theAspLine, theAspText, theAspMarker, theAspFill);
+ GroupPrimitivesAspect (theAspLine, theAspText, theAspMarker, theAspFill, theAspFillCapping);
}
public:
};
-DEFINE_STANDARD_HANDLE(Graphic3d_Group, Standard_Transient)
+DEFINE_STANDARD_HANDLE(Graphic3d_Group, MMgt_TShared)
#endif // _Graphic3d_Group_HeaderFile
//! - ASPECT_LINE: aspect for line primitives;
//! - ASPECT_TEXT: aspect for text primitives;
//! - ASPECT_MARKER: aspect for marker primitives;
-//! - ASPECT_FILL_AREA: aspect for face primitives.
+//! - ASPECT_FILL_AREA: aspect for face primitives;
+//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections.
enum Graphic3d_GroupAspect
{
-Graphic3d_ASPECT_LINE,
-Graphic3d_ASPECT_TEXT,
-Graphic3d_ASPECT_MARKER,
-Graphic3d_ASPECT_FILL_AREA
+ Graphic3d_ASPECT_LINE,
+ Graphic3d_ASPECT_TEXT,
+ Graphic3d_ASPECT_MARKER,
+ Graphic3d_ASPECT_FILL_AREA,
+ Graphic3d_ASPECT_FILL_CAPPING
};
#endif // _Graphic3d_GroupAspect_HeaderFile
//! Compute per-element multiplication.
//! @param theFactor [in] the scale factor.
- //! @return the result of multiplicaton.
+ //! @return the result of multiplication.
NCollection_Mat4 operator* (const Element_t theFactor) const
{
return Multiplied (theFactor);
//! Compute per-element multiplication.
//! @param theFactor [in] the scale factor.
- //! @return the result of multiplicaton.
+ //! @return the result of multiplication.
NCollection_Mat4 Multiplied (const Element_t theFactor) const
{
NCollection_Mat4 aTempMat (*this);
OpenGl_ArbTexBindless.hxx
OpenGl_AspectFace.cxx
OpenGl_AspectFace.hxx
+OpenGl_AspectFillCapping.cxx
+OpenGl_AspectFillCapping.hxx
OpenGl_AspectLine.cxx
OpenGl_AspectLine.hxx
OpenGl_AspectMarker.cxx
OpenGl_BVHClipPrimitiveTrsfPersSet.hxx
OpenGl_BVHTreeSelector.cxx
OpenGl_BVHTreeSelector.hxx
-OpenGl_CappingAlgo.cxx
-OpenGl_CappingAlgo.hxx
-OpenGl_CappingPlaneResource.cxx
-OpenGl_CappingPlaneResource.hxx
+OpenGl_CappingRenderer.cxx
+OpenGl_CappingRenderer.hxx
OpenGl_Caps.cxx
OpenGl_Caps.hxx
OpenGl_Clipping.cxx
--- /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 <OpenGl_AspectFillCapping.hxx>
+
+#include <OpenGl_AspectFace.hxx>
+#include <OpenGl_Workspace.hxx>
+
+namespace
+{
+ Handle(Graphic3d_AspectFillArea3d) defaultMaterial()
+ {
+ Handle(Graphic3d_AspectFillArea3d) anAspect;
+ const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
+ anAspect = new Graphic3d_AspectFillArea3d();
+ anAspect->SetDistinguishOff();
+ anAspect->SetFrontMaterial (aMaterial);
+ anAspect->SetInteriorStyle (Aspect_IS_SOLID);
+ anAspect->SetInteriorColor (aMaterial.Color());
+ anAspect->SetSuppressBackFaces (false);
+ return anAspect;
+ }
+}
+
+// =======================================================================
+// function : OpenGl_AspectFillCapping
+// purpose :
+// =======================================================================
+OpenGl_AspectFillCapping::OpenGl_AspectFillCapping (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+: myCappingAspect (defaultMaterial()),
+ myHatchingAspect (defaultMaterial()),
+ myHatchingState (0)
+{
+ SetAspect (theAspect);
+}
+
+// =======================================================================
+// function : ~OpenGl_AspectFillCapping
+// purpose :
+// =======================================================================
+OpenGl_AspectFillCapping::~OpenGl_AspectFillCapping()
+{
+ //
+}
+
+// =======================================================================
+// function : SetAspect
+// purpose :
+// =======================================================================
+void OpenGl_AspectFillCapping::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+ myAspect = theAspect;
+
+ if (theAspect.IsNull())
+ {
+ return;
+ }
+
+ if (!theAspect->ToUseObjectMaterial()
+ || !theAspect->ToUseObjectTexture()
+ || !theAspect->ToUseObjectShader())
+ {
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect.Aspect();
+
+ if (!theAspect->ToUseObjectMaterial())
+ {
+ aFillAspect->SetFrontMaterial (theAspect->Material());
+ aFillAspect->SetInteriorColor (theAspect->Material().Color());
+ }
+
+ if (!theAspect->ToUseObjectTexture())
+ {
+ aFillAspect->SetTextureMap (theAspect->Texture());
+
+ if (!theAspect->Texture().IsNull())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+ else
+ {
+ aFillAspect->SetTextureMap (Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetTextureMapOff();
+ }
+
+ if (!theAspect->ToUseObjectShader())
+ {
+ aFillAspect->SetShaderProgram (theAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
+ }
+
+ if (theAspect->ToDrawHatch()
+ && (theAspect->IsTextureHatch()
+ || theAspect->IsStippleHatch()))
+ {
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect.Aspect();
+
+ aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+ aFillAspect->SetHatchStyle (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+ aFillAspect->SetTextureMap (theAspect->IsTextureHatch() ? theAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetFrontMaterial (theAspect->HatchMaterial());
+ aFillAspect->SetInteriorColor (theAspect->HatchMaterial().Color());
+ if (theAspect->IsTextureHatch())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+
+ myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingState = theAspect->HatchingState();
+ }
+}
+
+// =======================================================================
+// function : Release
+// purpose :
+// =======================================================================
+void OpenGl_AspectFillCapping::Release (OpenGl_Context* theContext)
+{
+ myCappingAspect .Release (theContext);
+ myHatchingAspect.Release (theContext);
+}
+
+// =======================================================================
+// function : CappingFaceAspect
+// purpose :
+// =======================================================================
+const OpenGl_AspectFace* OpenGl_AspectFillCapping::CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const
+{
+ if (myAspect.IsNull())
+ {
+ return NULL;
+ }
+
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect.Aspect();
+
+ if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
+ {
+ // only front material currently supported by capping rendering
+ aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
+ aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor());
+ }
+ else
+ {
+ aFillAspect->SetFrontMaterial (myAspect->Material());
+ aFillAspect->SetInteriorColor (myAspect->Material().Color());
+ }
+
+ if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL)
+ {
+ if (theObjectAspect->Aspect()->ToMapTexture())
+ {
+ aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap());
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+ else
+ {
+ aFillAspect->SetTextureMap (myAspect->Texture());
+ if (!myAspect->Texture().IsNull())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+
+ if (myAspect->ToUseObjectShader() && theObjectAspect != NULL)
+ {
+ aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
+ }
+ else
+ {
+ aFillAspect->SetShaderProgram (myAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
+
+ return &myCappingAspect;
+}
+
+// =======================================================================
+// function : HatchingFaceAspect
+// purpose :
+// =======================================================================
+const OpenGl_AspectFace* OpenGl_AspectFillCapping::HatchingFaceAspect() const
+{
+ if (myAspect.IsNull())
+ {
+ return NULL;
+ }
+
+ const Standard_Size aHatchingState = myAspect->HatchingState();
+ if (myHatchingState != aHatchingState)
+ {
+ if (myAspect->ToDrawHatch())
+ {
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect.Aspect();
+
+ aFillAspect->SetInteriorStyle (myAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+ aFillAspect->SetHatchStyle (myAspect->IsStippleHatch() ? myAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+ aFillAspect->SetTextureMap (myAspect->IsTextureHatch() ? myAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetFrontMaterial (myAspect->HatchMaterial());
+ aFillAspect->SetInteriorColor (myAspect->HatchMaterial().Color());
+ if (myAspect->IsTextureHatch())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+
+ myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingState = aHatchingState;
+ }
+ }
+
+ return &myHatchingAspect;
+}
\ No newline at end of file
--- /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 _OpenGl_AspectFillCapping_Header
+#define _OpenGl_AspectFillCapping_Header
+
+#include <Graphic3d_AspectFillCapping.hxx>
+#include <OpenGl_AspectFace.hxx>
+#include <OpenGl_Resource.hxx>
+
+//! Gl resource holding particular aspects for filling capping.
+class OpenGl_AspectFillCapping : public OpenGl_Resource
+{
+public:
+
+ //! Create and assign style.
+ Standard_EXPORT OpenGl_AspectFillCapping (const Handle(Graphic3d_AspectFillCapping)& theAspect);
+
+ //! Destructor.
+ Standard_EXPORT ~OpenGl_AspectFillCapping();
+
+ //! Assign section style.
+ Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect);
+
+ //! Returns section style parameters.
+ const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myAspect; }
+
+ //! Release any allocated GL resources.
+ Standard_EXPORT virtual void Release (OpenGl_Context* theContext);
+
+ //! Returns true if capping should draw hatch layer.
+ Standard_Boolean ToDrawHatch() const
+ {
+ return myAspect->ToDrawHatch()
+ && (myAspect->IsStippleHatch()
+ || myAspect->IsTextureHatch());
+ }
+
+ //! Returns the shading aspect for drawing face of a clipping section itself.
+ //! @param theObjectAspect [in] the aspect of an object if it requires combining.
+ Standard_EXPORT const OpenGl_AspectFace* CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const;
+
+ //! Returns the shading aspect for drawing hatch layer of a section.
+ Standard_EXPORT const OpenGl_AspectFace* HatchingFaceAspect() const;
+
+protected:
+
+ Handle(Graphic3d_AspectFillCapping) myAspect; //!< Section style settings from application's level.
+ mutable OpenGl_AspectFace myCappingAspect; //!< GL aspect for shading base layer of a capping section.
+ mutable OpenGl_AspectFace myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
+ mutable Standard_Size myHatchingState;
+
+public:
+
+ DEFINE_STANDARD_ALLOC
+};
+
+#endif //_OpenGl_AspectFillCapping_Header
#include <Aspect_GradientFillMethod.hxx>
#include <Aspect_FillMethod.hxx>
#include <Graphic3d_TypeOfBackground.hxx>
+#include <Graphic3d_TransformPers.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_Vec.hxx>
+++ /dev/null
-// Created on: 2013-09-05
-// Created by: Anton POLETAEV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <OpenGl_CappingAlgo.hxx>
-
-#include <OpenGl_Workspace.hxx>
-#include <OpenGl_Context.hxx>
-#include <OpenGl_PrimitiveArray.hxx>
-#include <OpenGl_CappingPlaneResource.hxx>
-#include <OpenGl_Vec.hxx>
-#include <OpenGl_Structure.hxx>
-#include <OpenGl_ShaderManager.hxx>
-
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter)
-
-namespace
-{
- //! Render infinite capping plane.
- //! @param theWorkspace [in] the GL workspace, context state.
- //! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
- static void renderPlane (const Handle(OpenGl_Workspace)& theWorkspace,
- const Handle(OpenGl_CappingPlaneResource)& thePlane,
- const OpenGl_AspectFace* theAspectFace)
- {
- const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
- thePlane->Update (aContext, theAspectFace != NULL ? theAspectFace->Aspect() : Handle(Graphic3d_AspectFillArea3d)());
-
- const OpenGl_AspectFace* aFaceAspect = theWorkspace->AspectFace();
- theWorkspace->SetAspectFace (thePlane->AspectFace());
-
- // set identity model matrix
- aContext->ModelWorldState.Push();
- aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat));
- aContext->ApplyModelViewMatrix();
-
- thePlane->Primitives().Render (theWorkspace);
-
- aContext->ModelWorldState.Pop();
- aContext->ApplyModelViewMatrix();
-
- theWorkspace->SetAspectFace (aFaceAspect);
- }
-
- //! Render capping for specific structure.
- static void renderCappingForStructure (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_Structure& theStructure,
- const OpenGl_ClippingIterator& thePlaneIter,
- const Handle(OpenGl_CappingPlaneResource)& thePlane)
- {
- const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
- const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane();
- for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next())
- {
- if (!aGroupIter.Value()->IsClosed())
- {
- continue;
- }
-
- // enable only the rendering plane to generate stencil mask
- aContext->ChangeClipping().DisableAllExcept (aContext, thePlaneIter);
- aContext->ShaderManager()->UpdateClippingState();
-
- glClear (GL_STENCIL_BUFFER_BIT);
- const bool aColorMaskBack = aContext->SetColorMask (false);
-
- // override aspects, disable culling
- theWorkspace->SetAspectFace (&theWorkspace->NoneCulling());
- theWorkspace->ApplyAspectFace();
-
- // evaluate number of pair faces
- if (theWorkspace->UseZBuffer())
- {
- glDisable (GL_DEPTH_TEST);
- }
- if (theWorkspace->UseDepthWrite())
- {
- glDepthMask (GL_FALSE);
- }
- glStencilFunc (GL_ALWAYS, 1, 0x01);
- glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
-
- // render closed primitives
- if (aRenderPlane->ToUseObjectProperties())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
- else
- {
- for (; aGroupIter.More(); aGroupIter.Next())
- {
- if (aGroupIter.Value()->IsClosed())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
- }
- }
-
- // override material, cull back faces
- theWorkspace->SetAspectFace (&theWorkspace->FrontCulling());
- theWorkspace->ApplyAspectFace();
-
- // enable all clip plane except the rendered one
- aContext->ChangeClipping().EnableAllExcept (aContext, thePlaneIter);
- aContext->ShaderManager()->UpdateClippingState();
-
- // render capping plane using the generated stencil mask
- aContext->SetColorMask (aColorMaskBack);
- if (theWorkspace->UseDepthWrite())
- {
- glDepthMask (GL_TRUE);
- }
- glStencilFunc (GL_EQUAL, 1, 0x01);
- glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
- if (theWorkspace->UseZBuffer())
- {
- glEnable (GL_DEPTH_TEST);
- }
-
- renderPlane (theWorkspace, thePlane, aRenderPlane->ToUseObjectProperties()
- ? aGroupIter.Value()->AspectFace()
- : NULL);
-
- // turn on the current plane to restore initial state
- aContext->ChangeClipping().SetEnabled (aContext, thePlaneIter, Standard_True);
- aContext->ShaderManager()->RevertClippingState();
- aContext->ShaderManager()->RevertClippingState();
- }
-
- if (theStructure.InstancedStructure() != NULL)
- {
- renderCappingForStructure (theWorkspace, *theStructure.InstancedStructure(), thePlaneIter, thePlane);
- }
- }
-}
-
-// =======================================================================
-// function : RenderCapping
-// purpose :
-// =======================================================================
-void OpenGl_CappingAlgo::RenderCapping (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_Structure& theStructure)
-{
- const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
- if (!aContext->Clipping().IsCappingOn())
- {
- // do not perform algorithm if there is nothing to render
- return;
- }
-
- // remember current aspect face defined in workspace
- const OpenGl_AspectFace* aFaceAsp = theWorkspace->AspectFace();
-
- // replace primitive groups rendering filter
- Handle(OpenGl_RenderFilter) aRenderFilter = theWorkspace->GetRenderFilter();
- Handle(OpenGl_CappingAlgoFilter) aCappingFilter = theWorkspace->DefaultCappingAlgoFilter();
- aCappingFilter->SetPreviousFilter (aRenderFilter);
- theWorkspace->SetRenderFilter (aCappingFilter);
-
- // prepare for rendering the clip planes
- glEnable (GL_STENCIL_TEST);
-
- // remember current state of depth
- // function and change its value
- GLint aDepthFuncPrev;
- glGetIntegerv (GL_DEPTH_FUNC, &aDepthFuncPrev);
- glDepthFunc (GL_LESS);
-
- // generate capping for every clip plane
- for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next())
- {
- // get plane being rendered
- const Handle(Graphic3d_ClipPlane)& aRenderPlane = aCappingIt.Value();
- if (!aRenderPlane->IsCapping()
- || aCappingIt.IsDisabled())
- {
- continue;
- }
-
- // get resource for the plane
- const TCollection_AsciiString& aResId = aRenderPlane->GetId();
- Handle(OpenGl_CappingPlaneResource) aPlaneRes;
- if (!aContext->GetResource (aResId, aPlaneRes))
- {
- // share and register for release once the resource is no longer used
- aPlaneRes = new OpenGl_CappingPlaneResource (aRenderPlane);
- aContext->ShareResource (aResId, aPlaneRes);
- }
-
- renderCappingForStructure (theWorkspace, theStructure, aCappingIt, aPlaneRes);
-
- // set delayed resource release
- aPlaneRes.Nullify();
- aContext->ReleaseResource (aResId, Standard_True);
- }
-
- // restore previous application state
- glClear (GL_STENCIL_BUFFER_BIT);
- glDepthFunc (aDepthFuncPrev);
- glStencilFunc (GL_ALWAYS, 0, 0xFF);
- glDisable (GL_STENCIL_TEST);
-
- // restore rendering aspects
- theWorkspace->SetAspectFace (aFaceAsp);
- theWorkspace->SetRenderFilter (aRenderFilter);
-}
-
-// =======================================================================
-// function : CanRender
-// purpose :
-// =======================================================================
-Standard_Boolean OpenGl_CappingAlgoFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_Element* theGlElement)
-{
- if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
- {
- return Standard_False;
- }
-
- return theGlElement->IsFillDrawMode();
-}
+++ /dev/null
-// Created on: 2013-09-05
-// Created by: Anton POLETAEV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _OpenGl_CappingAlgo_H__
-#define _OpenGl_CappingAlgo_H__
-
-#include <OpenGl_RenderFilter.hxx>
-#include <OpenGl_Group.hxx>
-
-// Forward declaration
-class OpenGl_CappingAlgoFilter;
-class OpenGl_CappingPlaneResource;
-class OpenGl_Structure;
-
-DEFINE_STANDARD_HANDLE (OpenGl_CappingAlgoFilter, OpenGl_RenderFilter)
-
-//! Capping surface rendering algorithm.
-class OpenGl_CappingAlgo
-{
-public:
-
- //! Draw capping surfaces by OpenGl for the clipping planes enabled in current context state.
- //! Depth buffer must be generated for the passed groups.
- //! @param theWorkspace [in] the GL workspace, context state
- //! @param theStructure [in] the structure to be capped
- Standard_EXPORT static void RenderCapping (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_Structure& theStructure);
-
-};
-
-//! Graphical capping rendering algorithm filter.
-//! Filters out everything except shaded primitives.
-class OpenGl_CappingAlgoFilter : public OpenGl_RenderFilter
-{
-public:
-
- //! Default constructor.
- OpenGl_CappingAlgoFilter() {}
-
- //! Sets the current active filter in workspace.
- //! @param thePrevFilter [in] the previously active filter that should have additive effect.
- void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
-
- //! Checks whether the element can be rendered or not.
- //! @param theElement [in] the element to check.
- //! @return True if element can be rendered.
- virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_Element* theGlElement) Standard_OVERRIDE;
-
-private:
-
- Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
-
-public:
-
- DEFINE_STANDARD_RTTIEXT(OpenGl_CappingAlgoFilter,OpenGl_RenderFilter)
-};
-
-#endif
+++ /dev/null
-// Created on: 2013-08-15
-// Created by: Anton POLETAEV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <NCollection_AlignedAllocator.hxx>
-#include <OpenGl_CappingPlaneResource.hxx>
-#include <OpenGl_Context.hxx>
-#include <OpenGl_Vec.hxx>
-#include <Precision.hxx>
-
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource)
-
-namespace
-{
- //! 12 plane vertices, interleaved:
- //! - 4 floats, position
- //! - 4 floats, normal
- //! - 4 floats, UV texture coordinates
- static const GLfloat THE_CAPPING_PLN_VERTS[12 * (4 + 4 + 4)] =
- {
- 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
- 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f,
-
- 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
- 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f,
- -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-
- 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
- -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
-
- 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
- 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
- 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f
- };
-
- static const OpenGl_Matrix OpenGl_IdentityMatrix =
- {
- // mat[4][4]
- { { 1.0f, 0.0f, 0.0f, 0.0f },
- { 0.0f, 1.0f, 0.0f, 0.0f },
- { 0.0f, 0.0f, 1.0f, 0.0f },
- { 0.0f, 0.0f, 0.0f, 1.0f } }
- };
-
-}
-
-
-// =======================================================================
-// function : OpenGl_CappingPlaneResource
-// purpose :
-// =======================================================================
-OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
-: myPrimitives (NULL),
- myOrientation (OpenGl_IdentityMatrix),
- myAspect (NULL),
- myPlaneRoot (thePlane),
- myEquationMod ((unsigned int )-1),
- myAspectMod ((unsigned int )-1)
-{
- // Fill primitive array
- Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
- Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
- Graphic3d_Attribute anAttribInfo[] =
- {
- { Graphic3d_TOA_POS, Graphic3d_TOD_VEC4 },
- { Graphic3d_TOA_NORM, Graphic3d_TOD_VEC4 },
- { Graphic3d_TOA_UV, Graphic3d_TOD_VEC4 }
- };
- if (anAttribs->Init (12, anAttribInfo, 3))
- {
- memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
- myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
- }
-}
-
-// =======================================================================
-// function : OpenGl_CappingPlaneResource
-// purpose :
-// =======================================================================
-OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
-{
- Release (NULL);
-}
-
-// =======================================================================
-// function : Update
-// purpose :
-// =======================================================================
-void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& ,
- const Handle(Graphic3d_AspectFillArea3d)& theObjAspect)
-{
- updateTransform();
- updateAspect (theObjAspect);
-}
-
-// =======================================================================
-// function : Release
-// purpose :
-// =======================================================================
-void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
-{
- OpenGl_Element::Destroy (theContext, myAspect);
- myPrimitives.Release (theContext);
- myEquationMod = (unsigned int )-1;
- myAspectMod = (unsigned int )-1;
-}
-
-// =======================================================================
-// function : updateAspect
-// purpose :
-// =======================================================================
-void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_AspectFillArea3d)& theObjAspect)
-{
- if (myAspect == NULL)
- {
- myAspect = new OpenGl_AspectFace();
- myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync
- }
-
- if (theObjAspect.IsNull())
- {
- if (myAspectMod != myPlaneRoot->MCountAspect())
- {
- myAspect->SetAspect (myPlaneRoot->CappingAspect());
- myAspectMod = myPlaneRoot->MCountAspect();
- }
- return;
- }
-
- if (myFillAreaAspect.IsNull())
- {
- myFillAreaAspect = new Graphic3d_AspectFillArea3d();
- }
- if (myAspectMod != myPlaneRoot->MCountAspect())
- {
- *myFillAreaAspect = *myPlaneRoot->CappingAspect();
- }
-
- if (myPlaneRoot->ToUseObjectMaterial())
- {
- // only front material currently supported by capping rendering
- myFillAreaAspect->SetFrontMaterial (theObjAspect->FrontMaterial());
- myFillAreaAspect->SetInteriorColor (theObjAspect->InteriorColor());
- }
- if (myPlaneRoot->ToUseObjectTexture())
- {
- myFillAreaAspect->SetTextureSet (theObjAspect->TextureSet());
- if (theObjAspect->ToMapTexture())
- {
- myFillAreaAspect->SetTextureMapOn();
- }
- else
- {
- myFillAreaAspect->SetTextureMapOff();
- }
- }
- if (myPlaneRoot->ToUseObjectShader())
- {
- myFillAreaAspect->SetShaderProgram (theObjAspect->ShaderProgram());
- }
-
- myAspect->SetAspect (myFillAreaAspect);
-}
-
-// =======================================================================
-// function : updateTransform
-// purpose :
-// =======================================================================
-void OpenGl_CappingPlaneResource::updateTransform()
-{
- const Graphic3d_ClipPlane::Equation& anEquation = myPlaneRoot->GetEquation();
- if (myEquationMod == myPlaneRoot->MCountEquation())
- {
- return; // nothing to update
- }
-
- // re-evaluate infinite plane transformation matrix
- Standard_ShortReal N[3] =
- { (Standard_ShortReal)anEquation[0],
- (Standard_ShortReal)anEquation[1],
- (Standard_ShortReal)anEquation[2] };
-
- Standard_ShortReal T[3] =
- { (Standard_ShortReal)(anEquation[0] * -anEquation[3]),
- (Standard_ShortReal)(anEquation[1] * -anEquation[3]),
- (Standard_ShortReal)(anEquation[2] * -anEquation[3]) };
-
- Standard_ShortReal L[3] = { 0.0f, 0.0f, 0.0f };
- Standard_ShortReal F[3] = { 0.0f, 0.0f, 0.0f };
-
- // project plane normal onto OX to find left vector
- Standard_ShortReal aProjLen =
- sqrt ( (Standard_ShortReal)(anEquation[0] * anEquation[0])
- + (Standard_ShortReal)(anEquation[2] * anEquation[2]));
- if (aProjLen < ShortRealSmall())
- {
- L[0] = 1.0f;
- }
- else
- {
- L[0] = N[2] / aProjLen;
- L[2] = -N[0] / aProjLen;
- }
-
- // (-aLeft) x aNorm
- F[0] = (-L[1])*N[2] - (-L[2])*N[1];
- F[1] = (-L[2])*N[0] - (-L[0])*N[2];
- F[2] = (-L[0])*N[1] - (-L[1])*N[0];
-
- myOrientation.mat[0][0] = L[0];
- myOrientation.mat[0][1] = L[1];
- myOrientation.mat[0][2] = L[2];
- myOrientation.mat[0][3] = 0.0f;
-
- myOrientation.mat[1][0] = N[0];
- myOrientation.mat[1][1] = N[1];
- myOrientation.mat[1][2] = N[2];
- myOrientation.mat[1][3] = 0.0f;
-
- myOrientation.mat[2][0] = F[0];
- myOrientation.mat[2][1] = F[1];
- myOrientation.mat[2][2] = F[2];
- myOrientation.mat[2][3] = 0.0f;
-
- myOrientation.mat[3][0] = T[0];
- myOrientation.mat[3][1] = T[1];
- myOrientation.mat[3][2] = T[2];
- myOrientation.mat[3][3] = 1.0f;
-
- myEquationMod = myPlaneRoot->MCountEquation();
-}
+++ /dev/null
-// Created on: 2013-08-15
-// Created by: Anton POLETAEV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _OpenGl_CappingPlaneResource_H__
-#define _OpenGl_CappingPlaneResource_H__
-
-#include <OpenGl_PrimitiveArray.hxx>
-#include <OpenGl_Resource.hxx>
-#include <OpenGl_AspectFace.hxx>
-#include <OpenGl_Matrix.hxx>
-#include <Graphic3d_ClipPlane.hxx>
-
-class OpenGl_CappingPlaneResource;
-DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
-
-//! Container of graphical resources for rendering capping plane
-//! associated to graphical clipping plane.
-//! This resource holds data necessary for OpenGl_CappingAlgo.
-//! This object is implemented as OpenGl resource for the following reasons:
-//! - one instance should be shared between contexts.
-//! - instance associated to Graphic3d_ClipPlane data by id.
-//! - should created and released within context (owns OpenGl elements and resources).
-class OpenGl_CappingPlaneResource : public OpenGl_Resource
-{
-public:
-
- //! Constructor.
- //! Create capping plane presentation associated to clipping plane data.
- //! @param thePlane [in] the plane data.
- Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
-
- //! Destroy object.
- Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
-
- //! Update resource data in the passed context.
- //! @param theContext [in] the context
- //! @param theObjAspect [in] object aspect
- Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext,
- const Handle(Graphic3d_AspectFillArea3d)& theObjAspect);
-
- //! Release associated OpenGl resources.
- //! @param theContext [in] the resource context.
- Standard_EXPORT virtual void Release (OpenGl_Context* theContext) Standard_OVERRIDE;
-
- //! 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 aspect face for rendering capping surface.
- inline const OpenGl_AspectFace* AspectFace() const { return myAspect; }
-
- //! @return evaluated orientation matrix to transform infinite plane.
- inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
-
- //! @return primitive array of vertices to render infinite plane.
- inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
-
-private:
-
- //! Update precomputed plane orientation matrix.
- void updateTransform();
-
- //! Update resources.
- void updateAspect (const Handle(Graphic3d_AspectFillArea3d)& theObjAspect);
-
-private:
-
- OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering
- OpenGl_Matrix myOrientation; //!< plane transformation matrix.
- OpenGl_AspectFace* myAspect; //!< capping face aspect.
- Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure.
- Handle(Graphic3d_AspectFillArea3d) myFillAreaAspect; //!< own capping aspect
- unsigned int myEquationMod; //!< modification counter for plane equation.
- unsigned int myAspectMod; //!< modification counter for aspect.
-
-public:
-
- DEFINE_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource) // Type definition
-
-};
-
-#endif
--- /dev/null
+// Created on: 2013-09-05
+// Created by: Anton POLETAEV
+// Copyright (c) 2013-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <OpenGl_CappingRenderer.hxx>
+
+#include <OpenGl_AspectFace.hxx>
+#include <OpenGl_AspectFillCapping.hxx>
+#include <OpenGl_Context.hxx>
+#include <OpenGl_Element.hxx>
+#include <OpenGl_PrimitiveArray.hxx>
+#include <OpenGl_Resource.hxx>
+#include <OpenGl_ShaderManager.hxx>
+#include <OpenGl_Structure.hxx>
+#include <OpenGl_View.hxx>
+#include <OpenGl_Workspace.hxx>
+
+#include <Graphic3d_Camera.hxx>
+#include <NCollection_AlignedAllocator.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_CappingRenderFilter, OpenGl_RenderFilter)
+
+namespace
+{
+ //! interleaved (4x position, 4x normals, 4x (u,v) coordinates).
+ //! o ----o
+ //! representing | \ / |
+ //! these | o |
+ //! triangles: | / \ |
+ //! o --- o
+ static const GLfloat THE_CAPPING_PLN_VERTS[12 * (4 + 4 + 4)] =
+ {
+ 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+ 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f,
+
+ 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,-1.0f, 0.0f, 0.0f,
+ -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
+
+ 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+ -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
+
+ 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+ 0.0f, 0.0f,-1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f
+ };
+
+ class OpenGl_SharedElement : public OpenGl_Resource
+ {
+ public:
+ OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {}
+ virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE
+ {
+ OpenGl_Element::Destroy (theGlCtx, myGlElement);
+ }
+ OpenGl_Element* GlElement() const { return myGlElement; }
+
+ private:
+ OpenGl_Element* myGlElement;
+
+ public:
+
+ DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource)
+ };
+
+
+ static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingRenderer_Quad";
+ static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingRenderer_CappingStyle_";
+ static const OpenGl_AspectFillCapping THE_DEFAULT_ASPECT = OpenGl_AspectFillCapping (new Graphic3d_AspectFillCapping);
+}
+
+// =======================================================================
+// function : Render
+// purpose : Renders capping surfaces for enabled clipping planes.
+// =======================================================================
+void OpenGl_CappingRenderer::Render (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Structure& theStructure)
+{
+ const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
+ if (!aContext->Clipping().IsCappingOn())
+ {
+ return;
+ }
+
+ const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext);
+ if (!aCappingQuad)
+ {
+ return;
+ }
+
+ const OpenGl_AspectFace* aPrevAspect = theWorkspace->AspectFace();
+ Handle(OpenGl_RenderFilter) aPrevFilter = theWorkspace->GetRenderFilter();
+ Handle(OpenGl_CappingRenderFilter) aCappingFilter = theWorkspace->CappingRenderFilter();
+ aCappingFilter->SetPreviousFilter (aPrevFilter);
+
+ theWorkspace->SetRenderFilter (aCappingFilter);
+
+ GLint aDepthFuncPrev;
+ glGetIntegerv (GL_DEPTH_FUNC, &aDepthFuncPrev);
+ glDepthFunc (GL_LESS);
+ glEnable (GL_STENCIL_TEST);
+
+ GLboolean aPrevBlend = glIsEnabled (GL_BLEND);
+ GLint aPrevBlendSrc = GL_ONE;
+ GLint aPrevBlendDst = GL_ZERO;
+ if (aPrevBlend == GL_TRUE)
+ {
+ glGetIntegerv (GL_BLEND_SRC_ALPHA, &aPrevBlendSrc);
+ glGetIntegerv (GL_BLEND_DST_ALPHA, &aPrevBlendDst);
+ glDisable (GL_BLEND);
+ }
+
+ for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next())
+ {
+ const Handle(Graphic3d_ClipPlane)& aPlane = aCappingIt.Value();
+ if (!aPlane->IsCapping()
+ || aCappingIt.IsDisabled())
+ {
+ continue;
+ }
+
+ Handle(OpenGl_AspectFillCapping) anAspect;
+
+ TCollection_AsciiString aSharedStyleId;
+ if (!aPlane->CappingSectionStyle().IsNull())
+ {
+ aSharedStyleId = THE_PLANE_STYLE + aPlane->GetId();
+
+ if (!aContext->GetResource (aSharedStyleId, anAspect))
+ {
+ anAspect = new OpenGl_AspectFillCapping (aPlane->CappingSectionStyle());
+ aContext->ShareResource (aSharedStyleId, anAspect);
+ }
+ }
+
+ renderOne (theWorkspace, theStructure, aCappingIt, anAspect.get(), aCappingQuad);
+
+ if (!aSharedStyleId.IsEmpty())
+ {
+ // schedule release of resource if not used
+ aContext->ReleaseResource (aSharedStyleId, Standard_True);
+ }
+ }
+
+ glClear (GL_STENCIL_BUFFER_BIT);
+ glDepthFunc (aDepthFuncPrev);
+ glStencilFunc (GL_ALWAYS, 0, 0xFF);
+ glDisable (GL_STENCIL_TEST);
+
+ if (aPrevBlend == GL_TRUE)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (aPrevBlendSrc, aPrevBlendDst);
+ }
+
+ theWorkspace->SetRenderFilter (aPrevFilter);
+ theWorkspace->SetAspectFace (aPrevAspect);
+}
+
+// =======================================================================
+// function : renderOne
+// purpose : method to render capping section of one given plane for a structure.
+// =======================================================================
+void OpenGl_CappingRenderer::renderOne (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Structure& theStructure,
+ const OpenGl_ClippingIterator& thePlaneIter,
+ const OpenGl_AspectFillCapping* thePlaneAspectCapping,
+ const OpenGl_PrimitiveArray* theQuad)
+{
+ const Handle(Graphic3d_ClipPlane)& aPlane = thePlaneIter.Value();
+ const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
+ const Handle(Graphic3d_Camera) aCamera = theWorkspace->View() != NULL
+ ? theWorkspace->View()->Camera()
+ : Handle(Graphic3d_Camera)();
+
+ const OpenGl_Mat4& aPlaneMat = OpenGl_Mat4::Map (aPlane->OrientationMatrix());
+ Standard_ShortReal aRotateAngle = 0.0;
+ Standard_ShortReal aViewScale = ShortRealLast();
+ OpenGl_Mat4 aRotateZoomMat;
+
+ for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next())
+ {
+ if (!aGroupIter.Value()->IsClosed())
+ {
+ continue;
+ }
+
+ // enable only the rendering plane to generate stencil mask
+ aContext->ChangeClipping().DisableAllExcept (aContext, thePlaneIter);
+ aContext->ShaderManager()->UpdateClippingState();
+
+ glClear (GL_STENCIL_BUFFER_BIT);
+ glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+ // override aspects, disable culling
+ theWorkspace->SetAspectFace (&theWorkspace->NoneCulling());
+ theWorkspace->ApplyAspectFace();
+
+ // evaluate number of pair faces
+ if (theWorkspace->UseZBuffer())
+ {
+ glDisable (GL_DEPTH_TEST);
+ }
+ if (theWorkspace->UseDepthWrite())
+ {
+ glDepthMask (GL_FALSE);
+ }
+ glStencilFunc (GL_ALWAYS, 1, 0x01);
+ glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
+
+ aGroupIter.Value()->Render (theWorkspace);
+
+ // override material, cull back faces
+ theWorkspace->SetAspectFace (&theWorkspace->FrontCulling());
+ theWorkspace->ApplyAspectFace();
+
+ // enable all clip plane except the rendered one
+ aContext->ChangeClipping().EnableAllExcept (aContext, thePlaneIter);
+ aContext->ShaderManager()->UpdateClippingState();
+
+ // render capping plane using the generated stencil mask
+ glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+ if (theWorkspace->UseDepthWrite())
+ {
+ glDepthMask (GL_TRUE);
+ }
+ glStencilFunc (GL_EQUAL, 1, 0x01);
+ glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
+ if (theWorkspace->UseZBuffer())
+ {
+ glEnable (GL_DEPTH_TEST);
+ }
+
+ const OpenGl_AspectFace* aGroupAspectFace = aGroupIter.Value()->AspectFace();
+ const OpenGl_AspectFillCapping* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
+ const OpenGl_AspectFillCapping* anAspectCapping =
+ thePlaneAspectCapping && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
+ ? thePlaneAspectCapping
+ : aGroupAspectCapping;
+
+ if (anAspectCapping == NULL)
+ {
+ anAspectCapping = &THE_DEFAULT_ASPECT;
+ }
+
+ const OpenGl_AspectFace* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+ const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch();
+ const OpenGl_AspectFace* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
+ const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull();
+ const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent();
+ const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent();
+
+ Standard_ShortReal aHatchScale = 1.0;
+ Standard_ShortReal aHatchAngle = 0.0;
+
+ if (isRotatePers || isZoomPers)
+ {
+
+ if (isRotatePers)
+ {
+ if (aRotateAngle == 0.0)
+ {
+ const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0));
+ const gp_Dir aPlaneUp (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2));
+ const gp_Dir& aCameraUp = aCamera->Up();
+ const gp_Vec aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp;
+ const gp_Dir& aCameraDir = aCamera->Direction();
+ aRotateAngle = static_cast<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]);
+ }
+
+ aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureRes (aContext)->SizeY());
+ }
+ }
+
+ renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle);
+
+ // turn on the current plane to restore initial state
+ aContext->ChangeClipping().SetEnabled (aContext, thePlaneIter, Standard_True);
+ aContext->ShaderManager()->RevertClippingState();
+ aContext->ShaderManager()->RevertClippingState();
+ }
+
+ if (theStructure.InstancedStructure() != NULL)
+ {
+ renderOne (theWorkspace, *theStructure.InstancedStructure(), thePlaneIter, thePlaneAspectCapping, theQuad);
+ }
+}
+
+// =======================================================================
+// function : renderSection
+// purpose :
+// =======================================================================
+void OpenGl_CappingRenderer::renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_PrimitiveArray* theQuad,
+ const OpenGl_AspectFace* theCappingAspect,
+ const OpenGl_AspectFace* theHatchAspect,
+ const OpenGl_Mat4& theCappingMatrix,
+ const Standard_ShortReal theHatchScale,
+ const Standard_ShortReal theHatchRotate)
+{
+ const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
+
+ const Standard_Boolean isTextureHatch =
+ theHatchAspect != NULL
+ && theHatchAspect->Aspect()->TextureMapState();
+
+ aContext->ModelWorldState.Push();
+ aContext->ModelWorldState.SetCurrent (theCappingMatrix);
+ aContext->ApplyModelViewMatrix();
+
+ theWorkspace->SetAspectFace (theCappingAspect);
+ theWorkspace->ApplyAspectFace();
+
+ theQuad->Render (theWorkspace);
+
+ if (theHatchAspect != NULL)
+ {
+ Graphic3d_Vec2 aPrevScale;
+ Standard_ShortReal aPrevRotate = 0.0;
+
+ if (isTextureHatch)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ if (theHatchScale != 1.0 || theHatchRotate != 0.0)
+ {
+ const Handle(Graphic3d_TextureParams)& aTexParams = theHatchAspect->TextureParams();
+
+ aPrevScale = aTexParams->Scale();
+ aPrevRotate = aTexParams->Rotation();
+
+ const Standard_Boolean isMirror = aPrevScale.x() * aPrevScale.y() < 0.0;
+ aTexParams->SetScale (aPrevScale * theHatchScale);
+ aTexParams->SetRotation (isMirror ? aPrevRotate - theHatchRotate : aPrevRotate + theHatchRotate);
+ }
+ }
+
+ theWorkspace->SetAspectFace (theHatchAspect);
+ theWorkspace->ApplyAspectFace();
+
+ glDepthFunc (GL_LEQUAL);
+
+ theQuad->Render (theWorkspace);
+
+ glDepthFunc (GL_LESS);
+
+ if (isTextureHatch)
+ {
+ glDisable (GL_BLEND);
+
+ if (theHatchScale != 1.0 || theHatchRotate != 0.0)
+ {
+ const Handle(Graphic3d_TextureParams)& aTexParams = theHatchAspect->TextureParams();
+
+ aTexParams->SetScale (aPrevScale);
+ aTexParams->SetRotation (aPrevRotate);
+ }
+ }
+ }
+
+ aContext->ModelWorldState.Pop();
+ aContext->ApplyModelViewMatrix();
+}
+
+// =======================================================================
+// function : initQuad
+// purpose : initializes and returns vertex buffer for plane section
+// =======================================================================
+OpenGl_PrimitiveArray* OpenGl_CappingRenderer::initQuad (const Handle(OpenGl_Context)& theContext)
+{
+ Handle(OpenGl_SharedElement) aSharedResource;
+
+ if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource))
+ {
+ OpenGl_PrimitiveArray* aPArray = NULL;
+
+ Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
+ Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
+ Graphic3d_Attribute anAttribInfo[] =
+ {
+ { Graphic3d_TOA_POS, Graphic3d_TOD_VEC4 },
+ { Graphic3d_TOA_NORM, Graphic3d_TOD_VEC4 },
+ { Graphic3d_TOA_UV, Graphic3d_TOD_VEC4 }
+ };
+ if (anAttribs->Init (12, anAttribInfo, 3))
+ {
+ memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof (THE_CAPPING_PLN_VERTS));
+
+ aPArray = new OpenGl_PrimitiveArray (NULL);
+ aPArray->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+ }
+ aSharedResource = new OpenGl_SharedElement (aPArray);
+
+ theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource);
+ }
+
+ return dynamic_cast<OpenGl_PrimitiveArray*> (aSharedResource->GlElement());
+}
+
+// =======================================================================
+// function : CanRender
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_CappingRenderFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement)
+{
+ if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
+ {
+ return Standard_False;
+ }
+
+ const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
+ return aPArray != NULL
+ && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+ && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO;
+}
--- /dev/null
+// Created on: 2013-09-05
+// Created by: Anton POLETAEV
+// Copyright (c) 2013-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_CappingRenderer_H__
+#define _OpenGl_CappingRenderer_H__
+
+#include <OpenGl_RenderFilter.hxx>
+#include <OpenGl_Vec.hxx>
+
+// Forward declaration
+class OpenGl_AspectFace;
+class OpenGl_AspectFillCapping;
+class OpenGl_AspectSection;
+class OpenGl_CappingStyle;
+class OpenGl_ClippingIterator;
+class OpenGl_Context;
+class OpenGl_Element;
+class OpenGl_PrimitiveArray;
+class OpenGl_Structure;
+class OpenGl_Texture;
+class OpenGl_Workspace;
+
+//! Class implementing an OpenGL rasterization algorithm for drawing capping planes over clipped geometry.
+class OpenGl_CappingRenderer
+{
+public:
+
+ //! Renders capping surfaces for enabled clipping planes.
+ //! @note Depth buffer must be generated for the passed groups.
+ //! @param theWorkspace [in] the GL workspace, context state
+ //! @param theStructure [in] the structure to be capped
+ Standard_EXPORT static void Render (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Structure& theStructure);
+
+private:
+
+ //! Method to render capping section of one given plane for a structure.
+ static void renderOne (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Structure& theStructure,
+ const OpenGl_ClippingIterator& thePlaneIter,
+ const OpenGl_AspectFillCapping* thePlaneAspectCapping,
+ const OpenGl_PrimitiveArray* theQuad);
+
+ //! Render section plane using the given aspects.
+ static void renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_PrimitiveArray* theQuad,
+ const OpenGl_AspectFace* theCappingAspect,
+ const OpenGl_AspectFace* theHatchAspect,
+ const OpenGl_Mat4& theCappingMatrix,
+ const Standard_ShortReal theHatchScale,
+ const Standard_ShortReal theHatchRotate);
+
+ //! Initializes and returns face draw element for rendering section plane.
+ //! @note once initialized, context will hold resource until destroyed.
+ static OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext);
+
+ //! Set rotation persistence components for the matrix to support persistent texturing.
+ //! @param theWorkspace [in] the GL workspace, context state.
+ //! @param thePlane [in] the plane.
+ //! @param theRotateScaleMat [in/out] the matrix combining rotation and scaling persistence components.
+ static void computePersistence (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_ClippingIterator& thePlane,
+ const Handle(OpenGl_Texture)& theTexture,
+ const bool theRotatePers,
+ const bool theZoomPers,
+ OpenGl_Mat4& theRotateScaleMat);
+
+ //! Set zoom persistence components for the matrix to support persistent texturing.
+ //! @param theWorkspace [in] the GL workspace, context state.
+ //! @param thePlane [in] the plane.
+ //! @param theTexture [in] the texture.
+ //! @param theRotateScaleMat [in/out] the matrix combining rotation and scaling persistence components.
+ static void setZoomPersistence (const Handle(OpenGl_Workspace)& theWorkspace,
+ const Handle(OpenGl_Texture)& theTexture,
+ OpenGl_Mat4& theRotateScaleMat);
+};
+
+//! Filters out everything except face primitives of solids.
+class OpenGl_CappingRenderFilter : public OpenGl_RenderFilter
+{
+public:
+
+ //! Default constructor.
+ OpenGl_CappingRenderFilter() {}
+
+ //! Sets the current active filter in workspace.
+ //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+ void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
+ //! Checks whether the element can be rendered or not.
+ //! @param theElement [in] the element to check.
+ //! @return True if element can be rendered.
+ Standard_EXPORT virtual
+ Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement) Standard_OVERRIDE;
+
+private:
+
+ Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT (OpenGl_CappingRenderFilter, OpenGl_RenderFilter)
+};
+
+DEFINE_STANDARD_HANDLE (OpenGl_CappingRenderFilter, OpenGl_RenderFilter)
+
+#endif
//! @param theWorkspace [in] the rendering workspace.
//! @param theFilter [in] the rendering filter to check whether the element
//! should be rendered or not.
- //! @return True if element passes the check and renders,
+ //! @return True if element passes the filtering check and is rendered.
inline Standard_Boolean
RenderFiltered (const Handle(OpenGl_Workspace)& theWorkspace,
const Handle(OpenGl_RenderFilter)& theFilter) const
Update();
}
+// =======================================================================
+// function : SetGroupPrimitivesAspect
+// purpose :
+// =======================================================================
+void OpenGl_Group::SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+ if (IsDeleted())
+ {
+ return;
+ }
+
+ if (myAspectFillCapping == NULL)
+ {
+ myAspectFillCapping = new OpenGl_AspectFillCapping (theAspect);
+ }
+ else
+ {
+ myAspectFillCapping->SetAspect (theAspect);
+ }
+ Update();
+}
+
// =======================================================================
// function : AddPrimitiveArray
// purpose :
#include <NCollection_List.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectFace.hxx>
+#include <OpenGl_AspectFillCapping.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_Element.hxx>
//! Append text aspect as an element.
Standard_EXPORT virtual void SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& theAspect) Standard_OVERRIDE;
+ //! Update section style aspect.
+ Standard_EXPORT virtual void SetGroupPrimitivesAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect) Standard_OVERRIDE;
+
+ //! Returns section style aspect.
+ virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const Standard_OVERRIDE
+ {
+ return myAspectFillCapping != NULL
+ ? myAspectFillCapping->Aspect()
+ : Handle(Graphic3d_AspectFillCapping)();
+ }
+
//! Add primitive array element
Standard_EXPORT virtual void AddPrimitiveArray (const Graphic3d_TypeOfPrimitiveArray theType,
const Handle(Graphic3d_IndexBuffer)& theIndices,
//! Returns OpenGL face aspect.
const OpenGl_AspectFace* AspectFace() const { return myAspectFace; }
+ //! Returns OpenGL capping filling aspect.
+ const OpenGl_AspectFillCapping* AspectFillCapping() const { return myAspectFillCapping; }
+
//! Is the group ray-tracable (contains ray-tracable elements)?
Standard_Boolean IsRaytracable() const { return myIsRaytracable; }
protected:
- OpenGl_AspectLine* myAspectLine;
- OpenGl_AspectFace* myAspectFace;
- OpenGl_AspectMarker* myAspectMarker;
- OpenGl_AspectText* myAspectText;
+ OpenGl_AspectLine* myAspectLine;
+ OpenGl_AspectFace* myAspectFace;
+ OpenGl_AspectMarker* myAspectMarker;
+ OpenGl_AspectText* myAspectText;
+ OpenGl_AspectFillCapping* myAspectFillCapping;
OpenGl_ElementNode* myFirst;
OpenGl_ElementNode* myLast;
EOL"}";
TCollection_AsciiString
- aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
+ aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, TexCoord.st).a; }";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 == NULL)
{
- aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
+ aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, TexCoord.st).r; }";
}
#endif
}
myContext->BindProgram (myBlitProgram);
- myBlitProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
- myBlitProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
+ myBlitProgram->SetSampler (myContext, "uColorSampler", 0);
+ myBlitProgram->SetSampler (myContext, "uDepthSampler", 1);
myContext->BindProgram (NULL);
return Standard_True;
}
}
myContext->BindProgram (aProgram);
- aProgram->SetSampler (myContext, "uAccumTexture", Graphic3d_TextureUnit_0);
- aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
+ aProgram->SetSampler (myContext, "uAccumTexture", 0);
+ aProgram->SetSampler (myContext, "uWeightTexture", 1);
myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
return Standard_True;
}
// =======================================================================
TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (const Standard_Integer theBits)
{
- TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }";
+ TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ").a; }";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core11 == NULL
&& (theBits & OpenGl_PO_TextureA) != 0)
{
- aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }";
+ aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ").r; }";
}
#else
(void )theBits;
if ((theBits & OpenGl_PO_TextureRGB) != 0)
{
aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
+ EOL"vec4 getColor(void) { return occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord "); }";
}
if (textureUsed (theBits))
aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
+ EOL"vec4 getColor(void)"
+ EOL"{"
+ EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * occColor;"
+ EOL"}";
}
else if ((theBits & OpenGl_PO_TextureEnv) != 0)
{
EOL" TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
aSrcFragGetColor =
- EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
+ EOL"vec4 getColor(void) { return occTexture2D (occActiveSampler, TexCoord.st); }";
}
}
if ((theBits & OpenGl_PO_VertColor) != 0)
EOL"vec4 getColor(void)"
EOL"{"
EOL" vec4 aColor = " + theBaseColorSrc + ";"
- EOL" aColor = occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ") * aColor;"
+ EOL" aColor = occTexture2D(occActiveSampler, " THE_VEC2_glPointCoord ") * aColor;"
EOL" if (aColor.a <= 0.1) discard;"
EOL" return aColor;"
EOL"}";
EOL"vec4 getColor(void)"
EOL"{"
EOL" vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
- EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
+ EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;"
EOL"}";
}
}
EOL"vec4 getColor(void)"
EOL"{"
EOL" vec4 aColor = " thePhongCompLight ";"
- EOL" return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
+ EOL" return occTexture2D(occActiveSampler, TexCoord.st / TexCoord.w) * aColor;"
EOL"}";
}
}
}
myContext->BindProgram (theProgram);
- theProgram->SetSampler (myContext, "uLeftSampler", Graphic3d_TextureUnit_0);
- theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
+ theProgram->SetSampler (myContext, "uLeftSampler", 0);
+ theProgram->SetSampler (myContext, "uRightSampler", 1);
myContext->BindProgram (NULL);
return Standard_True;
}
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#include <OpenGl_CappingAlgo.hxx>
+#include <OpenGl_CappingRenderer.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_GraphicDriver.hxx>
}
// Render capping for structure groups
- if (hasClosedPrims
- && aCtx->Clipping().IsCappingOn())
+ if (hasClosedPrims && aCtx->Clipping().IsCappingOn())
{
- OpenGl_CappingAlgo::RenderCapping (theWorkspace, *this);
+ OpenGl_CappingRenderer::Render (theWorkspace, *this);
}
// Revert structure clippings
#include <OpenGl_Workspace.hxx>
#include <OpenGl_ArbFBO.hxx>
-#include <OpenGl_AspectLine.hxx>
-#include <OpenGl_AspectFace.hxx>
-#include <OpenGl_AspectMarker.hxx>
-#include <OpenGl_AspectText.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_GlCore15.hxx>
-#include <OpenGl_SceneGeometry.hxx>
-#include <OpenGl_Structure.hxx>
#include <OpenGl_Sampler.hxx>
+#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_ShaderManager.hxx>
+#include <OpenGl_Structure.hxx>
#include <OpenGl_Texture.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Window.hxx>
#endif
}
- myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter();
+ myCappingRenderFilter = new OpenGl_CappingRenderFilter();
myFontFaceAspect.Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Mask, 0.285f);
myFontFaceAspect.Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
}
//! Prepare shaded presentation for specified shape
- static Standard_Boolean shadeFromShape (const TopoDS_Shape& theShape,
- const Handle(Prs3d_Presentation)& thePrs,
- const Handle(Prs3d_Drawer)& theDrawer,
- const Standard_Boolean theHasTexels,
- const gp_Pnt2d& theUVOrigin,
- const gp_Pnt2d& theUVRepeat,
- const gp_Pnt2d& theUVScale,
- const bool theIsClosed)
+ static Standard_Boolean shadeFromShape (const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Presentation)& thePrs,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
+ const Standard_Boolean theHasTexels,
+ const gp_Pnt2d& theUVOrigin,
+ const gp_Pnt2d& theUVRepeat,
+ const gp_Pnt2d& theUVScale,
+ const bool theIsClosed)
{
Handle(Graphic3d_ArrayOfTriangles) aPArray = fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
if (aPArray.IsNull())
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;
}
// function : Add
// purpose :
// =======================================================================
-void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
- const TopoDS_Shape& theShape,
- const Handle(Prs3d_Drawer)& theDrawer,
- const StdPrs_Volume theVolume)
+void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
+ const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
+ const StdPrs_Volume theVolume)
{
gp_Pnt2d aDummy;
StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
- Standard_False, aDummy, aDummy, aDummy, theVolume);
+ Standard_False, aDummy, aDummy, aDummy, theCappingStyle, theVolume);
}
// =======================================================================
// function : Add
// purpose :
// =======================================================================
-void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
- const TopoDS_Shape& theShape,
- const Handle (Prs3d_Drawer)& theDrawer,
- const Standard_Boolean theHasTexels,
- const gp_Pnt2d& theUVOrigin,
- const gp_Pnt2d& theUVRepeat,
- const gp_Pnt2d& theUVScale,
- const StdPrs_Volume theVolume)
+void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
+ const TopoDS_Shape& theShape,
+ const Handle (Prs3d_Drawer)& theDrawer,
+ const Standard_Boolean theHasTexels,
+ const gp_Pnt2d& theUVOrigin,
+ const gp_Pnt2d& theUVRepeat,
+ const gp_Pnt2d& theUVScale,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
+ const StdPrs_Volume theVolume)
{
if (theShape.IsNull())
{
TopoDS_Iterator aShapeIter (aClosed);
if (aShapeIter.More())
{
- shadeFromShape (aClosed, thePrs, theDrawer,
+ shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
}
aShapeIter.Initialize (anOpened);
if (aShapeIter.More())
{
- shadeFromShape (anOpened, thePrs, theDrawer,
+ shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
}
}
else
{
// if the shape type is not compound, composolid or solid, use autodetection back-facing filled
- shadeFromShape (theShape, thePrs, theDrawer,
+ shadeFromShape (theShape, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
theVolume == StdPrs_Volume_Closed);
}
//! @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->SetCapping (toEnable);
+
anArgIter += 1;
}
else
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;
}
- Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
+ Graphic3d_MaterialAspect aMat = aClipPlane->CappingSectionStyle()->Material();
aMat.SetAmbientColor (aColor);
aMat.SetDiffuseColor (aColor);
- aClipPlane->SetCappingMaterial (aMat);
+ aClipPlane->CappingSectionStyle()->SetMaterial (aMat);
anArgIter += aNbParsed;
}
- else if (aChangeArg == "-texname"
- || aChangeArg == "texname")
+ else if (aChangeArg == "-overrideaspect"
+ || aChangeArg == "overrideaspect")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (aChangeArg == "-texture"
+ || aChangeArg == "texture")
{
if (aNbChangeArgs < 2)
{
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 (aChangeArg == "-hatchtexture"
+ || aChangeArg == "hatchtexture")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return 1;
}
- else if (aHatchStr == "off")
+
+ TCollection_AsciiString aTextureName (aChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
{
- aClipPlane->SetCappingHatchOff();
+ 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: [-set|-unset|-setOverrideGlobal [objects|views]]"
"\n\t\t: [-maxPlanes]"
"\n\t\t: [-capping {0|1}]"
- "\n\t\t: [-color R G B] [-hatch {on|off|ID}]"
- "\n\t\t: [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]"
- "\n\t\t: [-texRotate Angle]"
+ "\n\t\t: [-overrideAspect {0|1}]"
+ "\n\t\t: [-color R G B]"
+ "\n\t\t: [-texture Texture] [-texScale SX SY]"
+ "\n\t\t: [-texOrigin TX TY] [-texRotate Angle]"
+ "\n\t\t: [-hatch {on|off}] [-hatchStipple mask]"
+ "\n\t\t: [-hatchColor R G B] [-hatchTexture texture]"
+ "\n\t\t: [-hatchScale SX SY] [-hatchOrigin TX TY]"
+ "\n\t\t: [-hatchRotate Angle]"
+ "\n\t\t: [-hatchZoomPers {0|1}]"
+ "\n\t\t: [-hatchRotatePers {0|1}]"
"\n\t\t: [-useObjMaterial {0|1}] [-useObjTexture {0|1}]"
- "\n\t\t: [-useObjShader {0|1}]"
+ "\n\t\t: [-useObjShader {0|1}]"
"\n\t\t: Clipping planes management:"
"\n\t\t: -maxPlanes print plane limit for view"
"\n\t\t: -delete delete plane with given name"
"\n\t\t: -clone SourcePlane NewPlane clone the plane definition."
"\n\t\t: Capping options:"
"\n\t\t: -capping {off|on|0|1} turn capping on/off"
+ "\n\t\t: -overrideAspect override presentation aspect (if defined)"
"\n\t\t: -color R G B set capping color"
- "\n\t\t: -texName Texture set capping texture"
+ "\n\t\t: -texture Texture set capping texture"
"\n\t\t: -texScale SX SY set capping tex scale"
"\n\t\t: -texOrigin TX TY set capping tex origin"
"\n\t\t: -texRotate Angle set capping tex rotation"
- "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
+ "\n\t\t: -hatch {on|off} turn on/off hatch style on capping"
+ "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
+ "\n\t\t: -hatchColor R G B set color for hatch material"
+ "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
+ "\n\t\t: -hatchScale SX SY set hatch texture scale"
+ "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
+ "\n\t\t: -hatchRotate Angle set hatch texture rotation"
+ "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
+ "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
"\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
"\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
"\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
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
