{
aShadedGroup = thePrs->NewGroup();
aShadedGroup->SetClosed (isClosed);
+ if (isClosed)
+ {
+ if (aDrawer->HasOwnFillCappingAspect())
+ aShadedGroup->SetGroupPrimitivesAspect (aDrawer->FillCappingAspect());
+ }
}
aShadedGroup->SetPrimitivesAspect (aDrawer->ShadingAspect()->Aspect());
aShadedGroup->AddPrimitiveArray (aTriangles);
#include <AIS_InteractiveContext.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
try
{
OCC_CATCH_SIGNALS
- StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer,
- myDrawer->ShadingAspect()->Aspect()->ToMapTexture()
- && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(),
- myUVOrigin, myUVRepeat, myUVScale);
+ StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer, myDrawer->FillCappingAspect());
}
catch (Standard_Failure const& anException)
{
Graphic3d_Aspects.hxx
Graphic3d_AspectFillArea3d.cxx
Graphic3d_AspectFillArea3d.hxx
+Graphic3d_AspectFillCapping.cxx
+Graphic3d_AspectFillCapping.hxx
Graphic3d_AspectLine3d.cxx
Graphic3d_AspectLine3d.hxx
Graphic3d_AspectMarker3d.cxx
--- /dev/null
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#include <Graphic3d_AspectFillCapping.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Standard_Transient)
+
+// =======================================================================
+// function : Graphic3d_AspectFillCapping
+// purpose :
+// =======================================================================
+Graphic3d_AspectFillCapping::Graphic3d_AspectFillCapping()
+: myFlags (Flags_None),
+ myHatchingState (0)
+{
+ Graphic3d_MaterialAspect aMaterial;
+ aMaterial.SetColor (Quantity_NOC_BLACK);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
+ aMaterial.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
+ aMaterial.SetMaterialType (Graphic3d_MATERIAL_ASPECT);
+ SetHatchStyle (Aspect_HS_HORIZONTAL);
+ SetHatchMaterial (aMaterial);
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Aspect_HatchStyle theStyle)
+{
+ myStippleHatch = new Graphic3d_HatchStyle (theStyle);
+ myTextureHatch.Nullify();
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle)
+{
+ myStippleHatch = theStyle;
+ myTextureHatch.Nullify();
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchStyle
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture)
+{
+ myStippleHatch.Nullify();
+ myTextureHatch = theTexture;
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchMaterial
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial)
+{
+ myHatchMaterial = theMaterial;
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetToDrawHatch
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetToDrawHatch (const Standard_Boolean theToDraw)
+{
+ setFlag (theToDraw, Flags_DrawHatching);
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchZoomPeristent
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchZoomPeristent (const Standard_Boolean theToSet)
+{
+ setFlag (theToSet, Flags_HatchZoomPersistent);
+ myHatchingState++;
+}
+
+// =======================================================================
+// function : SetHatchRotationPeristent
+// purpose :
+// =======================================================================
+void Graphic3d_AspectFillCapping::SetHatchRotationPeristent (const Standard_Boolean theToSet)
+{
+ setFlag (theToSet, Flags_HatchRotationPersistent);
+ myHatchingState++;
+}
+
+//=======================================================================
+//function : DumpJson
+//purpose :
+//=======================================================================
+void Graphic3d_AspectFillCapping::DumpJson (Standard_OStream& theOStream, const Standard_Integer theDepth) const
+{
+ OCCT_DUMP_CLASS_BEGIN (theOStream, Graphic3d_AspectFillCapping);
+
+ OCCT_DUMP_BASE_CLASS (theOStream, theDepth, Graphic3d_Aspects);
+
+ OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMaterial);
+ OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMaterial);
+
+ OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myTexture);
+ OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myShader);
+ OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myStippleHatch);
+ OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myTextureHatch);
+
+ OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myHatchMaterial);
+
+ OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myFlags);
+ OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myHatchingState);
+}
--- /dev/null
+// Created on: 2017-04-14
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Graphic3d_AspectFillCapping_HeaderFile
+#define _Graphic3d_AspectFillCapping_HeaderFile
+
+#include <Aspect_HatchStyle.hxx>
+#include <Graphic3d_Aspects.hxx>
+#include <Graphic3d_HatchStyle.hxx>
+#include <Graphic3d_MaterialAspect.hxx>
+#include <Graphic3d_ShaderProgram.hxx>
+#include <Graphic3d_TextureMap.hxx>
+#include <Standard_Transient.hxx>
+
+//! Defines graphical attributes for drawing section planes on solids resulted from clipping (cutting) planes.
+class Graphic3d_AspectFillCapping : public Graphic3d_Aspects
+{
+public:
+
+ //! Default constructor.
+ Standard_EXPORT Graphic3d_AspectFillCapping();
+
+public:
+
+ //! Sets material for filling section created by clipping.
+ void SetMaterial (const Graphic3d_MaterialAspect& theMaterial) { myMaterial = theMaterial; }
+
+ //! Returns material for filling section created by clipping.
+ const Graphic3d_MaterialAspect& Material() const { return myMaterial; }
+
+ //! Sets flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectMaterial (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectMaterial); }
+
+ //! Returns flag indicating whether object's material (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectMaterial() const { return (myFlags & Flags_UseObjectMaterial) != 0; }
+
+ //! Sets texture for filling section created by clipping.
+ void SetTexture (const Handle(Graphic3d_TextureMap)& theTexture) { myTexture = theTexture; }
+
+ //! Returns texture for filling section created by clipping.
+ const Handle(Graphic3d_TextureMap)& Texture() const { return myTexture; }
+
+ //! Sets flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectTexture (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectTexture); }
+
+ //! Returns flag indicating whether object's texture (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectTexture() const { return (myFlags & Flags_UseObjectTexture) != 0; }
+
+ //! Sets OpenGL/GLSL shader program.
+ void SetShader (const Handle(Graphic3d_ShaderProgram)& theShader) { myShader = theShader; }
+
+ //! Returns OpenGL/GLSL shader program.
+ const Handle(Graphic3d_ShaderProgram)& Shader() const { return myShader; }
+
+ //! Sets flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ void SetUseObjectShader (const Standard_Boolean theToUse) { setFlag (theToUse, Flags_UseObjectShader); }
+
+ //! Returns flag indicating whether object's shader (instead of defined by this aspect) should be used for filling section.
+ Standard_Boolean ToUseObjectShader() const { return (myFlags & Flags_UseObjectShader) != 0; }
+
+public:
+
+ //! Sets style of hatch defined by predefined stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Aspect_HatchStyle theStyle);
+
+ //! Sets style of hatch defined by custom stipple mask.
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_HatchStyle)& theStyle);
+
+ //! Sets style of hatch defined by texture map (decal texture with alpha channel should be used).
+ Standard_EXPORT void SetHatchStyle (const Handle(Graphic3d_TextureMap)& theTexture);
+
+ //! Sets material style for hatch lines (texture).
+ Standard_EXPORT void SetHatchMaterial (const Graphic3d_MaterialAspect& theMaterial);
+
+ //! Returns material style for hatch lines (texture).
+ const Graphic3d_MaterialAspect& HatchMaterial() const { return myHatchMaterial; }
+
+ //! Sets boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_EXPORT void SetToDrawHatch (const Standard_Boolean theToDraw);
+
+ //! Returns boolean flag indicating whether the hatch layer should be drawn or not.
+ Standard_Boolean ToDrawHatch() const { return (myFlags & Flags_DrawHatching) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on zooming.
+ //! @param theToSet [in] if passed TRUE the texture will keep constant screen-scale independent of zooming.
+ Standard_EXPORT void SetHatchZoomPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on zooming.
+ Standard_Boolean IsHatchZoomPersistent() { return (myFlags & Flags_HatchZoomPersistent) != 0; }
+
+ //! Sets flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_EXPORT void SetHatchRotationPeristent (const Standard_Boolean theToSet);
+
+ //! Returns value of flag controlling behavior of hatch texture mapping on camera rotation around heading vector.
+ Standard_Boolean IsHatchRotationPersistent() { return (myFlags & Flags_HatchRotationPersistent) != 0; }
+
+ //! Returns true if hatch is defined by texture.
+ Standard_Boolean IsTextureHatch() const { return !myTextureHatch.IsNull(); }
+
+ //! Returns texture map defining the hatch.
+ const Handle(Graphic3d_TextureMap)& TextureHatch() const { return myTextureHatch; }
+
+ //! Returns true if hatch is defined by stipple mask.
+ Standard_Boolean IsStippleHatch() const { return !myStippleHatch.IsNull(); }
+
+ //! Returns the stipple mask.
+ const Handle(Graphic3d_HatchStyle)& StippleHatch() const { return myStippleHatch; }
+
+ //! Returns modification counter for hatching state.
+ Standard_Size HatchingState() const { return myHatchingState; }
+
+ //! Dumps the content of me into the stream
+ Standard_EXPORT void DumpJson (Standard_OStream& theOStream, const Standard_Integer theDepth = -1) const;
+
+private:
+
+ enum Flags
+ {
+ Flags_None = 0x00, //!< no flags
+ Flags_UseObjectMaterial = 0x01, //!< use object material
+ Flags_UseObjectTexture = 0x02, //!< use object texture
+ Flags_UseObjectShader = 0x04, //!< use object GLSL program
+ Flags_HatchZoomPersistent = 0x08, //!< zoom-persistent texturing
+ Flags_HatchRotationPersistent = 0x10, //!< rotation-persistent texturing
+ Flags_DrawHatching = 0x20, //!< draw hatching
+ Flags_UseObjectProperties = //!< use entire fill area aspect from object
+ Flags_UseObjectMaterial
+ | Flags_UseObjectTexture
+ | Flags_UseObjectShader
+ };
+
+ void setFlag (const Standard_Boolean theToUse, const unsigned int theFlag)
+ {
+ myFlags = theToUse ? myFlags | theFlag : myFlags & ~theFlag;
+ }
+
+private:
+
+ Graphic3d_MaterialAspect myMaterial;
+ Handle(Graphic3d_TextureMap) myTexture;
+ Handle(Graphic3d_ShaderProgram) myShader;
+ Handle(Graphic3d_HatchStyle) myStippleHatch;
+ Handle(Graphic3d_TextureMap) myTextureHatch;
+ Graphic3d_MaterialAspect myHatchMaterial;
+ unsigned int myFlags;
+ Standard_Size myHatchingState;
+
+public:
+
+ DEFINE_STANDARD_RTTIEXT(Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+};
+
+DEFINE_STANDARD_HANDLE (Graphic3d_AspectFillCapping, Graphic3d_Aspects)
+
+#endif // _Graphic3d_AspectFillCapping_HeaderFile
myIsCapping (Standard_False)
{
makeId();
+ init();
}
// =======================================================================
myIsCapping (Standard_False)
{
makeId();
+ init (gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.a()));
updateInversedPlane();
}
-
+
// =======================================================================
// function : Graphic3d_ClipPlane
// purpose :
myIsOn (theOther.myIsOn),
myIsCapping (theOther.myIsCapping)
{
- makeId();
*myAspect = *theOther.CappingAspect();
+ *mySectionStyle = *theOther.CappingSectionStyle();
+
+ makeId();
+ init (theOther.myPlane,
+ theOther.myEquationRev,
+ theOther.myIsOn,
+ theOther.myIsCapping,
+ theOther.ToOverrideCappingAspect(),
+ theOther.CappingSectionStyle());
+ updateInversedPlane();
}
// =======================================================================
myIsCapping (Standard_False)
{
thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
- updateInversedPlane();
makeId();
+ init (thePlane);
+ updateInversedPlane();
}
// =======================================================================
myPlane = gp_Pln (theEquation.x(), theEquation.y(), theEquation.z(), theEquation.w());
myEquation = theEquation;
updateInversedPlane();
+ myOrientationDirty = Standard_True;
myEquationMod++;
}
myPlane = thePlane;
thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
updateInversedPlane();
+ myOrientationDirty = Standard_True;
myEquationMod++;
}
+ TCollection_AsciiString (Standard_Atomic_Increment (&THE_CLIP_PLANE_COUNTER));
}
+// =======================================================================
+// function : SetCappingSectionStyle
+// purpose :
+// =======================================================================
+void Graphic3d_ClipPlane::SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+ mySectionStyle = theStyle;
+}
+
+// =======================================================================
+// function : OrientationMatrix
+// purpose :
+// =======================================================================
+const Graphic3d_Mat4& Graphic3d_ClipPlane::OrientationMatrix() const
+{
+ if (myOrientationDirty)
+ {
+ const Standard_ShortReal aDirection[] = {
+ static_cast<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())
+ {
+ aSide1[0] = 1.0f;
+ }
+ else
+ {
+ aSide1[0] = aDirection[2] / aMagintude;
+ aSide1[2] = -aDirection[0] / aMagintude;
+ }
+
+ aSide2[0] = (-aSide1[1] * aDirection[2]) - (-aSide1[2] * aDirection[1]);
+ aSide2[1] = (-aSide1[2] * aDirection[0]) - (-aSide1[0] * aDirection[2]);
+ aSide2[2] = (-aSide1[0] * aDirection[1]) - (-aSide1[1] * aDirection[0]);
+
+ myOrientationMat.SetValue (0, 0, aSide1[0]);
+ myOrientationMat.SetValue (1, 0, aSide1[1]);
+ myOrientationMat.SetValue (2, 0, aSide1[2]);
+ myOrientationMat.SetValue (3, 0, 0.0F);
+
+ myOrientationMat.SetValue (0, 1, aDirection[0]);
+ myOrientationMat.SetValue (1, 1, aDirection[1]);
+ myOrientationMat.SetValue (2, 1, aDirection[2]);
+ myOrientationMat.SetValue (3, 1, 0.0F);
+
+ myOrientationMat.SetValue (0, 2, aSide2[0]);
+ myOrientationMat.SetValue (1, 2, aSide2[1]);
+ myOrientationMat.SetValue (2, 2, aSide2[2]);
+ myOrientationMat.SetValue (3, 2, 0.0F);
+
+ myOrientationMat.SetValue (0, 3, aTranslate[0]);
+ myOrientationMat.SetValue (1, 3, aTranslate[1]);
+ myOrientationMat.SetValue (2, 3, aTranslate[2]);
+ myOrientationMat.SetValue (3, 3, 1.0F);
+
+ myOrientationDirty = Standard_False;
+ }
+
+ return myOrientationMat;
+}
+
+// =======================================================================
+// function : init
+// purpose :
+// =======================================================================
+void Graphic3d_ClipPlane::init (const gp_Pln& /*thePlane*/,
+ const Graphic3d_Vec4d& /*theEquationRev*/,
+ const Standard_Boolean /*theIsOn*/,
+ const Standard_Boolean /*theIsCapping*/,
+ const Standard_Boolean theOverrideStyle,
+ const Handle(Graphic3d_AspectFillCapping)& theStyle)
+{
+ myOverrideObjectStyle = theOverrideStyle;
+ mySectionStyle = theStyle.IsNull() ? new Graphic3d_AspectFillCapping() : theStyle;
+ myOrientationDirty = Standard_True;
+}
+
// =======================================================================
// function : updateChainLen
// purpose :
// =======================================================================
void Graphic3d_ClipPlane::SetChainNextPlane (const Handle(Graphic3d_ClipPlane)& thePlane)
{
+ myOrientationDirty = Standard_True;
++myEquationMod;
if (!myNextInChain.IsNull())
{
#include <Aspect_HatchStyle.hxx>
#include <gp_Pln.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_BndBox3d.hxx>
#include <Graphic3d_CappingFlags.hxx>
+#include <Graphic3d_Mat4.hxx>
#include <Graphic3d_TextureMap.hxx>
+#include <NCollection_Handle.hxx>
#include <NCollection_Vec4.hxx>
#include <Standard_Macro.hxx>
#include <Standard_TypeDef.hxx>
//! 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 shader program for capping plane should be taken from object.
//! Default value: FALSE.
bool ToUseObjectShader() const { return (myFlags & Graphic3d_CappingFlags_ObjectShader) != 0; }
-
+
//! Set flag for controlling the source of capping plane shader program.
void SetUseObjectShader(bool theToUse) { setCappingFlag (theToUse, Graphic3d_CappingFlags_ObjectShader); }
-
+
//! Return true if some fill area aspect properties should be taken from object.
bool ToUseObjectProperties() const { return myFlags != Graphic3d_CappingFlags_None; }
+public:
+
+ //! Returns style used for drawing capping section.
+ //! @return capping surface rendering aspect.
+ const Handle(Graphic3d_AspectFillCapping)& CappingSectionStyle() const { return mySectionStyle; }
+
+ //! Sets clipping section filling aspect.
+ Standard_EXPORT void SetCappingSectionStyle (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+
public:
//! Check if the given point is outside / inside / on section.
}
private:
-
+
//! Generate unique object id for OpenGL graphic resource manager.
void makeId();
-
+
//! Set capping flag.
Standard_EXPORT void setCappingFlag (bool theToUse, int theFlag);
+public:
+
+ //! Flag indicating whether section style of the plane should overrides similar property of object presentation.
+ //! Default value: FALSE (use dedicated presentation aspect style).
+ bool ToOverrideCappingAspect() const { return myOverrideObjectStyle; }
+
+ //! Sets flag for controlling the preference of using section style between clip plane and object.
+ void SetToOverrideCappingAspect (const bool theToOverride) { myOverrideObjectStyle = theToOverride; }
+
+ //! Returns plane's orientation matrix.
+ Standard_EXPORT const Graphic3d_Mat4& OrientationMatrix() const;
+
+private:
+
+ //! Initializes plane and makes unique identifier (UID) to differentiate clipping plane entities.
+ void init (const gp_Pln& thePlane = gp_Pln(),
+ const Graphic3d_Vec4d& theEquationRev = Graphic3d_Vec4d(0.0, 0.0,-1.0, 0.0),
+ const Standard_Boolean theIsOn = Standard_True,
+ const Standard_Boolean theIsCapping = Standard_False,
+ const Standard_Boolean theOverrideStyle = Standard_False,
+ const Handle(Graphic3d_AspectFillCapping)& theStyle = Handle(Graphic3d_AspectFillCapping)());
+
//! Update chain length in backward direction.
void updateChainLen();
private:
Handle(Graphic3d_AspectFillArea3d) myAspect; //!< fill area aspect
+ Handle(Graphic3d_AspectFillCapping) mySectionStyle; //!< Style set for drawing capped solid section.
Handle(Graphic3d_ClipPlane) myNextInChain; //!< next plane in a chain of planes defining logical AND operation
Graphic3d_ClipPlane* myPrevInChain; //!< previous plane in a chain of planes defining logical AND operation
TCollection_AsciiString myId; //!< resource id
unsigned int myAspectMod; //!< modification counter of aspect
Standard_Boolean myIsOn; //!< state of the clipping plane
Standard_Boolean myIsCapping; //!< state of graphic driver capping
+ Standard_Boolean myOverrideObjectStyle; //!< Flag forcing to use plane's section style rather than section style defined for object
+ mutable Standard_Boolean myOrientationDirty; //!< Boolean flag indicating whether orientation matrix is dirty or not.
+ mutable Graphic3d_Mat4 myOrientationMat; //!< Plane orientation matrix (for visualization purposes).
};
class Graphic3d_Structure;
class Graphic3d_ArrayOfPrimitives;
+class Graphic3d_AspectFillCapping;
class Graphic3d_Text;
//! This class allows the definition of groups
//! Modifies the current context of the group to give another aspect for all the primitives created after this call in the group.
virtual void SetPrimitivesAspect (const Handle(Graphic3d_Aspects)& theAspect) = 0;
+ //! Returns style of filling clipping sections on closed shell primitives.
+ virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const = 0;
+
//! Update presentation aspects after their modification.
virtual void SynchronizeAspects() = 0;
//! - ASPECT_LINE: aspect for line primitives;
//! - ASPECT_TEXT: aspect for text primitives;
//! - ASPECT_MARKER: aspect for marker primitives;
-//! - ASPECT_FILL_AREA: aspect for face primitives.
+//! - ASPECT_FILL_AREA: aspect for face primitives;
+//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections.
enum Graphic3d_GroupAspect
{
Graphic3d_ASPECT_LINE,
Graphic3d_ASPECT_TEXT,
Graphic3d_ASPECT_MARKER,
-Graphic3d_ASPECT_FILL_AREA
+Graphic3d_ASPECT_FILL_AREA,
+Graphic3d_ASPECT_FILL_CAPPING
};
#endif // _Graphic3d_GroupAspect_HeaderFile
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Vec.hxx>
+#include <OpenGl_View.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_ShaderManager.hxx>
namespace
{
+ static const OpenGl_CappingPlaneResource* THE_DEFAULT_ASPECT = new OpenGl_CappingPlaneResource (NULL, new Graphic3d_AspectFillCapping);
+ static const TCollection_AsciiString THE_QUAD_PARRAY = "OpenGl_CappingAlgo_Quad";
+ static const TCollection_AsciiString THE_PLANE_STYLE = "OpenGl_CappingAlgo_CappingStyle_";
+
//! Auxiliary sentry object managing stencil test.
struct StencilTestSentry
{
GLint myDepthFuncPrev;
};
+ class OpenGl_SharedElement : public OpenGl_Resource
+ {
+ public:
+ OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {}
+ virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE
+ {
+ OpenGl_Element::Destroy (theGlCtx, myGlElement);
+ }
+ OpenGl_Element* GlElement() const { return myGlElement; }
+
+ //! Returns estimated GPU memory usage for holding data without considering overheads and allocation alignment rules.
+ Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
+
+ private:
+ OpenGl_Element* myGlElement;
+
+ public:
+
+ DEFINE_STANDARD_RTTI_INLINE (OpenGl_SharedElement, OpenGl_Resource)
+ };
+
+ //! Iitializes and returns vertex buffer for plane section
+ OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext)
+ {
+ Handle(OpenGl_SharedElement) aSharedResource;
+
+ if (!theContext->GetResource (THE_QUAD_PARRAY, aSharedResource))
+ {
+ aSharedResource = new OpenGl_SharedElement (OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices());
+ theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource);
+ }
+
+ return dynamic_cast<OpenGl_PrimitiveArray*> (aSharedResource->GlElement());
+ }
+
+ //! Render section plane using the given aspects.
+ void renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_PrimitiveArray* theQuad,
+ const OpenGl_Aspects* theCappingAspect,
+ const OpenGl_Aspects* theHatchAspect,
+ const OpenGl_Mat4& theCappingMatrix,
+ const Standard_ShortReal theHatchScale,
+ const Standard_ShortReal theHatchRotate)
+ {
+ const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
+ const bool wasCullAllowed = theWorkspace->SetAllowFaceCulling (true);
+
+ const Standard_Boolean isTextureHatch =
+ theHatchAspect != NULL
+ && theHatchAspect->Aspect()->TextureMapState();
+
+ aContext->ModelWorldState.Push();
+ aContext->ModelWorldState.SetCurrent (theCappingMatrix);
+ aContext->ApplyModelViewMatrix();
+
+ theWorkspace->SetAspects (theCappingAspect);
+ theWorkspace->ApplyAspects();
+
+ theQuad->Render (theWorkspace);
+
+ if (theHatchAspect != NULL)
+ {
+ Graphic3d_Vec2 aPrevScale;
+ Standard_ShortReal aPrevRotate = 0.0;
+
+ if (isTextureHatch)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ if ((theHatchScale != 1.0 || theHatchRotate != 0.0) && !theHatchAspect->TextureSet(aContext)->IsEmpty())
+ {
+ Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+ const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+ aPrevScale = aTexParams->Scale();
+ aPrevRotate = aTexParams->Rotation();
+
+ const Standard_Boolean isMirror = aPrevScale.x() * aPrevScale.y() < 0.0;
+ aTexParams->SetScale (aPrevScale * theHatchScale);
+ aTexParams->SetRotation (isMirror ? aPrevRotate - theHatchRotate : aPrevRotate + theHatchRotate);
+ }
+ }
+
+ theWorkspace->SetAspects (theHatchAspect);
+ theWorkspace->ApplyAspects();
+
+ glDepthFunc (GL_LEQUAL);
+
+ theQuad->Render (theWorkspace);
+
+ glDepthFunc (GL_LESS);
+
+ if (isTextureHatch)
+ {
+ glDisable (GL_BLEND);
+
+ if (theHatchScale != 1.0 || theHatchRotate != 0.0)
+ {
+ Handle(OpenGl_Texture) aTexture = theHatchAspect->TextureSet(aContext)->First();
+ const Handle(Graphic3d_TextureParams)& aTexParams = aTexture->Sampler()->Parameters();
+
+ aTexParams->SetScale (aPrevScale);
+ aTexParams->SetRotation (aPrevRotate);
+ }
+ }
+ }
+
+ aContext->ModelWorldState.Pop();
+ aContext->ApplyModelViewMatrix();
+
+ theWorkspace->SetAllowFaceCulling (wasCullAllowed);
+ }
+
//! Render infinite capping plane.
//! @param theWorkspace [in] the GL workspace, context state.
//! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
const OpenGl_Structure& theStructure,
const Handle(Graphic3d_ClipPlane)& theClipChain,
const Standard_Integer theSubPlaneIndex,
- const Handle(OpenGl_CappingPlaneResource)& thePlane)
+ const Handle(OpenGl_CappingPlaneResource)& thePlane,
+ const OpenGl_PrimitiveArray* theQuad)
{
const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly);
+ const Handle(Graphic3d_ClipPlane)& aPlane = theClipChain;
+
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const Handle(Graphic3d_ClipPlane)& aRenderPlane = thePlane->Plane();
+ const Handle(Graphic3d_Camera) aCamera = theWorkspace->View() != NULL
+ ? theWorkspace->View()->Camera()
+ : Handle(Graphic3d_Camera)();
+ const OpenGl_Mat4& aPlaneMat = OpenGl_Mat4::Map (aPlane->OrientationMatrix());
+ Standard_ShortReal aRotateAngle = 0.0;
+ Standard_ShortReal aViewScale = ShortRealLast();
+ OpenGl_Mat4 aRotateZoomMat;
+
for (OpenGl_Structure::GroupIterator aGroupIter (theStructure.Groups()); aGroupIter.More(); aGroupIter.Next())
{
if (!aGroupIter.Value()->IsClosed())
// clear stencil only if something has been actually drawn
theStencilSentry.Init();
- // check if capping plane should be rendered within current pass (only opaque / only transparent)
- const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
- thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)());
- theWorkspace->SetAspects (thePlane->AspectFace());
- theWorkspace->SetRenderFilter (aPrevFilter);
- if (!theWorkspace->ShouldRender (&thePlane->Primitives()))
+ const OpenGl_Aspects* aGroupAspectFace = aGroupIter.Value()->GlAspects();
+ const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
+ const OpenGl_CappingPlaneResource* anAspectCapping =
+ thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
+ ? thePlane.get()
+ : aGroupAspectCapping;
+
+ if (anAspectCapping == NULL)
{
- continue;
+ anAspectCapping = THE_DEFAULT_ASPECT;
+ }
+
+ const OpenGl_Aspects* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+ const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch();
+
+ if (!hasHatch)
+ {
+ // check if capping plane should be rendered within current pass (only opaque / only transparent)
+ const OpenGl_Aspects* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
+ //const OpenGl_Aspects* anObjAspectFace = aRenderPlane->CappingSectionStyle()->ToUseObjectProperties() ? aGroupIter.Value()->GlAspects() : NULL;
+ thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_Aspects)());
+ theWorkspace->SetAspects (thePlane->AspectFace());
+ theWorkspace->SetRenderFilter (aPrevFilter);
+ if (!theWorkspace->ShouldRender (&thePlane->Primitives()))
+ {
+ continue;
+ }
}
// suppress only opaque/transparent filter since for filling stencil the whole geometry should be drawn
glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
// render closed primitives
- if (aRenderPlane->ToUseObjectProperties())
+ if (hasHatch)
{
aGroupIter.Value()->Render (theWorkspace);
}
else
{
- for (; aGroupIter.More(); aGroupIter.Next())
+ // render closed primitives
+ if (aRenderPlane->ToUseObjectProperties())
+ {
+ aGroupIter.Value()->Render (theWorkspace);
+ }
+ else
{
- if (aGroupIter.Value()->IsClosed())
+ for (; aGroupIter.More(); aGroupIter.Next())
{
- aGroupIter.Value()->Render (theWorkspace);
+ if (aGroupIter.Value()->IsClosed())
+ {
+ aGroupIter.Value()->Render (theWorkspace);
+ }
}
}
}
glEnable (GL_DEPTH_TEST);
}
- theWorkspace->SetAspects (thePlane->AspectFace());
- renderPlane (theWorkspace, thePlane);
+ if (!hasHatch)
+ {
+ theWorkspace->SetAspects (thePlane->AspectFace());
+ renderPlane (theWorkspace, thePlane);
+ }
+ else
+ {
+ const OpenGl_Aspects* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
+ const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull();
+ const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent();
+ const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent();
+
+ Standard_ShortReal aHatchScale = 1.0;
+ Standard_ShortReal aHatchAngle = 0.0;
+
+ if (isRotatePers || isZoomPers)
+ {
+
+ if (isRotatePers)
+ {
+ if (aRotateAngle == 0.0)
+ {
+ const gp_Dir aPlaneSide (aPlaneMat.GetValue (0, 0), aPlaneMat.GetValue (1, 0), aPlaneMat.GetValue (2, 0));
+ const gp_Dir aPlaneUp (aPlaneMat.GetValue (0, 2), aPlaneMat.GetValue (1, 2), aPlaneMat.GetValue (2, 2));
+ const gp_Dir& aCameraUp = aCamera->Up();
+ const gp_Vec aCameraPln = aPlaneSide.Dot (aCameraUp) * aPlaneSide + aPlaneUp.Dot (aCameraUp) * aPlaneUp;
+ if (aCameraPln.Magnitude() > Precision::Confusion())
+ {
+ const gp_Dir& aCameraDir = aCamera->Direction();
+ aRotateAngle = static_cast<Standard_ShortReal> (aCameraPln.AngleWithRef (aPlaneUp, aCameraDir) / M_PI * 180.0);
+ }
+ }
+
+ aHatchAngle = aRotateAngle;
+ }
+
+ if (isZoomPers)
+ {
+ if (aViewScale == ShortRealLast())
+ {
+ const Standard_Real aFocus = aCamera->IsOrthographic()
+ ? aCamera->Distance()
+ : (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative
+ ? Standard_Real(aCamera->ZFocus() * aCamera->Distance())
+ : Standard_Real(aCamera->ZFocus()));
+
+ const gp_XYZ aViewDim = aCamera->ViewDimensions (aFocus);
+ aViewScale = static_cast<Standard_ShortReal> (aViewDim.Y() / aContext->Viewport()[3]);
+ }
+
+ if (!anAspectHatching->TextureSet(aContext)->IsEmpty())
+ aHatchScale = 1.0f / (aViewScale * anAspectHatching->TextureSet(aContext)->First()->SizeY());
+ }
+ }
+
+ renderSection (theWorkspace, theQuad, anAspectFace, hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL, aPlaneMat, aHatchScale, aHatchAngle);
+ }
// turn on the current plane to restore initial state
aContext->ChangeClipping().ResetCappingFilter();
if (theStructure.InstancedStructure() != NULL)
{
- renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane);
+ renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad);
}
}
}
return;
}
+ const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext);
+ if (!aCappingQuad)
+ {
+ return;
+ }
+
// remember current aspect face defined in workspace
const OpenGl_Aspects* aFaceAsp = theWorkspace->Aspects();
theWorkspace->SetRenderFilter (aPrevFilter | OpenGl_RenderFilter_FillModeOnly);
StencilTestSentry aStencilSentry;
+ GLboolean aPrevBlend = glIsEnabled (GL_BLEND);
+ GLint aPrevBlendSrc = GL_ONE;
+ GLint aPrevBlendDst = GL_ZERO;
+ if (aPrevBlend == GL_TRUE)
+ {
+ glGetIntegerv (GL_BLEND_SRC_ALPHA, &aPrevBlendSrc);
+ glGetIntegerv (GL_BLEND_DST_ALPHA, &aPrevBlendDst);
+ glDisable (GL_BLEND);
+ }
+
// generate capping for every clip plane
for (OpenGl_ClippingIterator aCappingIt (aContext->Clipping()); aCappingIt.More(); aCappingIt.Next())
{
for (const Graphic3d_ClipPlane* aSubPlaneIter = aClipChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
{
// get resource for the plane
- const TCollection_AsciiString& aResId = aSubPlaneIter->GetId();
+ const TCollection_AsciiString& aResId = THE_PLANE_STYLE + aSubPlaneIter->GetId();
Handle(OpenGl_CappingPlaneResource) aPlaneRes;
if (!aContext->GetResource (aResId, aPlaneRes))
{
// share and register for release once the resource is no longer used
- aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter);
+ aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter, aSubPlaneIter->CappingSectionStyle());
aContext->ShareResource (aResId, aPlaneRes);
}
- renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes);
+ renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes, aCappingQuad);
// set delayed resource release
aPlaneRes.Nullify();
- aContext->ReleaseResource (aResId, Standard_True);
+ if (!aResId.IsEmpty())
+ {
+ // schedule release of resource if not used
+ aContext->ReleaseResource (aResId, Standard_True);
+ }
}
}
+ if (aPrevBlend == GL_TRUE)
+ {
+ glEnable (GL_BLEND);
+ glBlendFunc (aPrevBlendSrc, aPrevBlendDst);
+ }
+
// restore rendering aspects
theWorkspace->SetAspects (aFaceAsp);
theWorkspace->SetRenderFilter (aPrevFilter);
{ 0.0f, 0.0f, 0.0f, 1.0f } }
};
+ Handle(Graphic3d_Aspects) defaultMaterial()
+ {
+ Handle(Graphic3d_AspectFillArea3d) anAspect;
+ const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
+ anAspect = new Graphic3d_AspectFillArea3d();
+ anAspect->SetDistinguishOff();
+ anAspect->SetFrontMaterial (aMaterial);
+ anAspect->SetInteriorStyle (Aspect_IS_SOLID);
+ anAspect->SetInteriorColor (aMaterial.Color());
+ anAspect->SetSuppressBackFaces (false);
+ return anAspect;
+ }
}
// =======================================================================
-// function : OpenGl_CappingPlaneResource
+// function : BuildInfinitPlaneVertices
// purpose :
// =======================================================================
-OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
-: myPrimitives (NULL),
- myOrientation (OpenGl_IdentityMatrix),
- myAspect (NULL),
- myPlaneRoot (thePlane),
- myEquationMod ((unsigned int )-1),
- myAspectMod ((unsigned int )-1)
+OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
{
+ OpenGl_PrimitiveArray* aPrimitives = NULL;
// Fill primitive array
Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
if (anAttribs->Init (12, anAttribInfo, 3))
{
memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
- myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+
+ aPrimitives = new OpenGl_PrimitiveArray (NULL);
+ aPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
}
+ return aPrimitives;
+}
+
+// =======================================================================
+// function : OpenGl_CappingPlaneResource
+// purpose :
+// =======================================================================
+OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane,
+ const Handle(Graphic3d_AspectFillCapping)& theAspect)
+: myPrimitives (NULL),
+ myPrimitivesUsed (Standard_False),
+ myOrientation (OpenGl_IdentityMatrix),
+ myAspect (NULL),
+ myPlaneRoot (thePlane),
+ myEquationMod ((unsigned int )-1),
+ myAspectMod ((unsigned int )-1),
+ myCappingAspect(),//defaultMaterial()),
+ myHatchingAspect(),//defaultMaterial()),
+ myHatchingState (0)
+{
+ if (theAspect.IsNull() || !theAspect->ToDrawHatch())
+ {
+ // Fill primitive array
+ Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
+ Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
+ Graphic3d_Attribute anAttribInfo[] =
+ {
+ { Graphic3d_TOA_POS, Graphic3d_TOD_VEC4 },
+ { Graphic3d_TOA_NORM, Graphic3d_TOD_VEC4 },
+ { Graphic3d_TOA_UV, Graphic3d_TOD_VEC4 }
+ };
+ if (anAttribs->Init (12, anAttribInfo, 3))
+ {
+ memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
+ myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+ myPrimitivesUsed = Standard_True;
+ }
+ }
+
+ myCappingAspect.SetAspect (defaultMaterial());
+ myHatchingAspect.SetAspect (defaultMaterial());
+
+ SetAspect (theAspect);
}
// =======================================================================
// =======================================================================
OpenGl_CappingPlaneResource::~OpenGl_CappingPlaneResource()
{
- Release (NULL);
+ if (myPrimitivesUsed)
+ {
+ Release (NULL);
+ }
+}
+
+// =======================================================================
+// function : SetAspect
+// purpose :
+// =======================================================================
+void OpenGl_CappingPlaneResource::SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+ myGraphicAspect = theAspect;
+
+ if (theAspect.IsNull())
+ {
+ return;
+ }
+
+ if (!theAspect->ToDrawHatch())
+ return;
+
+ if (!theAspect->ToUseObjectMaterial()
+ || !theAspect->ToUseObjectTexture()
+ || !theAspect->ToUseObjectShader())
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
+
+ if (!theAspect->ToUseObjectMaterial())
+ {
+ aFillAspect->SetFrontMaterial (theAspect->Material());
+ aFillAspect->SetInteriorColor (theAspect->Material().Color());
+ }
+
+ if (!theAspect->ToUseObjectTexture())
+ {
+ aFillAspect->SetTextureMap (theAspect->Texture());
+
+ if (!theAspect->Texture().IsNull())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+ else
+ {
+ aFillAspect->SetTextureMap (Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetTextureMapOff();
+ }
+
+ if (!theAspect->ToUseObjectShader())
+ {
+ aFillAspect->SetShaderProgram (theAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
+ }
+
+ if (theAspect->ToDrawHatch()
+ && (theAspect->IsTextureHatch()
+ || theAspect->IsStippleHatch()))
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+ aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+ aFillAspect->SetHatchStyle (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+ aFillAspect->SetTextureMap (theAspect->IsTextureHatch() ? theAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetFrontMaterial (theAspect->HatchMaterial());
+ aFillAspect->SetInteriorColor (theAspect->HatchMaterial().Color());
+ if (theAspect->IsTextureHatch())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+
+ myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingState = theAspect->HatchingState();
+ }
}
// =======================================================================
void OpenGl_CappingPlaneResource::Update (const Handle(OpenGl_Context)& theCtx,
const Handle(Graphic3d_Aspects)& theObjAspect)
{
+ if (!myPrimitivesUsed)
+ return;
+
updateTransform (theCtx);
updateAspect (theObjAspect);
}
// =======================================================================
void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
{
- OpenGl_Element::Destroy (theContext, myAspect);
- myPrimitives.Release (theContext);
- myEquationMod = (unsigned int )-1;
- myAspectMod = (unsigned int )-1;
+ if (myPrimitivesUsed)
+ {
+ OpenGl_Element::Destroy (theContext, myAspect);
+ myPrimitives.Release (theContext);
+ myEquationMod = (unsigned int )-1;
+ myAspectMod = (unsigned int )-1;
+ }
+ myCappingAspect .Release (theContext);
+ myHatchingAspect.Release (theContext);
+}
+
+// =======================================================================
+// function : CappingFaceAspect
+// purpose :
+// =======================================================================
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const
+{
+ if (myGraphicAspect.IsNull())
+ {
+ return NULL;
+ }
+
+ Handle(Graphic3d_Aspects) aFillAspect = myCappingAspect.Aspect();
+
+ if (myGraphicAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
+ {
+ // only front material currently supported by capping rendering
+ aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
+ aFillAspect->SetInteriorColor (theObjectAspect->Aspect()->InteriorColor());
+ }
+ else
+ {
+ aFillAspect->SetFrontMaterial (myGraphicAspect->Material());
+ aFillAspect->SetInteriorColor (myGraphicAspect->Material().Color());
+ }
+
+ if (myGraphicAspect->ToUseObjectTexture() && theObjectAspect != NULL)
+ {
+ if (theObjectAspect->Aspect()->ToMapTexture())
+ {
+ aFillAspect->SetTextureMap (theObjectAspect->Aspect()->TextureMap());
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+ else
+ {
+ aFillAspect->SetTextureMap (myGraphicAspect->Texture());
+ if (!myGraphicAspect->Texture().IsNull())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ }
+
+ if (myGraphicAspect->ToUseObjectShader() && theObjectAspect != NULL)
+ {
+ aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
+ }
+ else
+ {
+ aFillAspect->SetShaderProgram (myGraphicAspect->Shader());
+ }
+
+ myCappingAspect.SetAspect (aFillAspect);
+
+ return &myCappingAspect;
+}
+
+// =======================================================================
+// function : HatchingFaceAspect
+// purpose :
+// =======================================================================
+const OpenGl_Aspects* OpenGl_CappingPlaneResource::HatchingFaceAspect() const
+{
+ if (myGraphicAspect.IsNull())
+ {
+ return NULL;
+ }
+
+ const Standard_Size aHatchingState = myGraphicAspect->HatchingState();
+ if (myHatchingState != aHatchingState)
+ {
+ if (myGraphicAspect->ToDrawHatch())
+ {
+ Handle(Graphic3d_Aspects) aFillAspect = myHatchingAspect.Aspect();
+
+ aFillAspect->SetInteriorStyle (myGraphicAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
+ aFillAspect->SetHatchStyle (myGraphicAspect->IsStippleHatch() ? myGraphicAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
+ aFillAspect->SetTextureMap (myGraphicAspect->IsTextureHatch() ? myGraphicAspect->TextureHatch() : Handle(Graphic3d_TextureMap)());
+ aFillAspect->SetFrontMaterial (myGraphicAspect->HatchMaterial());
+ aFillAspect->SetInteriorColor (myGraphicAspect->HatchMaterial().Color());
+ if (myGraphicAspect->IsTextureHatch())
+ {
+ aFillAspect->SetTextureMapOn();
+ }
+ else
+ {
+ aFillAspect->SetTextureMapOff();
+ }
+ myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingState = aHatchingState;
+ }
+ }
+
+ return &myHatchingAspect;
}
// =======================================================================
// =======================================================================
void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_Aspects)& theObjAspect)
{
+ if (myPlaneRoot.IsNull())
+ return;
+
if (myAspect == NULL)
{
myAspect = new OpenGl_Aspects();
{
myFillAreaAspect = new Graphic3d_AspectFillArea3d();
}
- if (myAspectMod != myPlaneRoot->MCountAspect())
+ if (myAspectMod != myPlaneRoot->MCountAspect())
{
*myFillAreaAspect = *myPlaneRoot->CappingAspect();
}
// =======================================================================
void OpenGl_CappingPlaneResource::updateTransform (const Handle(OpenGl_Context)& theCtx)
{
+ if (myPlaneRoot.IsNull())
+ return;
+
if (myEquationMod == myPlaneRoot->MCountEquation()
&& myLocalOrigin.IsEqual (theCtx->ShaderManager()->LocalOrigin(), gp::Resolution()))
{
#include <OpenGl_Resource.hxx>
#include <OpenGl_Aspects.hxx>
#include <OpenGl_Matrix.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_ClipPlane.hxx>
class OpenGl_CappingPlaneResource;
//! This resource holds data necessary for OpenGl_CappingAlgo.
//! This object is implemented as OpenGl resource for the following reasons:
//! - one instance should be shared between contexts.
-//! - instance associated to Graphic3d_ClipPlane data by id.
+//! - instance associated to Graphic3d_AspectFillCapping data.
//! - should created and released within context (owns OpenGl elements and resources).
class OpenGl_CappingPlaneResource : public OpenGl_Resource
{
public:
- //! Constructor.
- //! Create capping plane presentation associated to clipping plane data.
- //! @param thePlane [in] the plane data.
- Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
+ //! Create and assign style.
+ Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane,
+ const Handle(Graphic3d_AspectFillCapping)& theAspect);
//! Destroy object.
Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
Standard_EXPORT void Update (const Handle(OpenGl_Context)& theContext,
const Handle(Graphic3d_Aspects)& theObjAspect);
+//! Assign section style.
+ Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect);
+
+ //! Returns section style parameters.
+ const Handle(Graphic3d_AspectFillCapping)& Aspect() const { return myGraphicAspect; }
+
//! Release associated OpenGl resources.
//! @param theContext [in] the resource context.
Standard_EXPORT virtual void Release (OpenGl_Context* theContext) Standard_OVERRIDE;
//! Return parent clipping plane structure.
const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; }
+ //! @return primitive array of vertices to render infinite plane.
+ static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices();
+
//! @return aspect face for rendering capping surface.
inline const OpenGl_Aspects* AspectFace() const { return myAspect; }
+//! Returns true if capping should draw hatch layer.
+ Standard_Boolean ToDrawHatch() const
+ {
+ return Aspect()->ToDrawHatch()
+ && (Aspect()->IsStippleHatch()
+ || Aspect()->IsTextureHatch());
+ }
+
//! @return evaluated orientation matrix to transform infinite plane.
inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
+ //! Returns the shading aspect for drawing face of a clipping section itself.
+ //! @param theObjectAspect [in] the aspect of an object if it requires combining.
+ Standard_EXPORT const OpenGl_Aspects* CappingFaceAspect (const OpenGl_Aspects* theObjectAspect) const;
+
//! @return primitive array of vertices to render infinite plane.
inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
+ //! Returns the shading aspect for drawing hatch layer of a section.
+ Standard_EXPORT const OpenGl_Aspects* HatchingFaceAspect() const;
+
private:
//! Update precomputed plane orientation matrix.
private:
OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering
+ Standard_Boolean myPrimitivesUsed; //!< boolean flag if primitives are used
OpenGl_Matrix myOrientation; //!< plane transformation matrix.
OpenGl_Aspects* myAspect; //!< capping face aspect.
Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure.
unsigned int myEquationMod; //!< modification counter for plane equation.
unsigned int myAspectMod; //!< modification counter for aspect.
+ Handle(Graphic3d_AspectFillCapping) myGraphicAspect; //!< Section style settings from application's level.
+ mutable OpenGl_Aspects myCappingAspect; //!< GL aspect for shading base layer of a capping section.
+ mutable OpenGl_Aspects myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
+ mutable Standard_Size myHatchingState;
+
public:
DEFINE_STANDARD_RTTIEXT(OpenGl_CappingPlaneResource,OpenGl_Resource) // Type definition
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_ArrayOfPrimitives.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_GroupDefinitionError.hxx>
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Group,Graphic3d_Group)
return;
}
+ if (!theAspect.IsNull() && theAspect->IsKind (STANDARD_TYPE(Graphic3d_AspectFillCapping)))
+ {
+ Handle(Graphic3d_AspectFillCapping) aFillCappingAspect = Handle(Graphic3d_AspectFillCapping)::DownCast (theAspect);
+ if (myAspectFillCapping == NULL)
+ {
+ myAspectFillCapping = new OpenGl_CappingPlaneResource (NULL, aFillCappingAspect);
+ }
+ else
+ {
+ myAspectFillCapping->SetAspect (aFillCappingAspect);
+ }
+ return;
+ }
+
if (myAspects == NULL)
{
myAspects = new OpenGl_Aspects (theAspect);
#include <NCollection_List.hxx>
#include <OpenGl_Aspects.hxx>
+#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_Group;
//! Is the group ray-tracable (contains ray-tracable elements)?
Standard_Boolean IsRaytracable() const { return myIsRaytracable; }
+ //! Returns section style aspect.
+ virtual Handle(Graphic3d_AspectFillCapping) FillCappingAspect() const Standard_OVERRIDE
+ {
+ return myAspectFillCapping != NULL
+ ? myAspectFillCapping->Aspect()
+ : Handle(Graphic3d_AspectFillCapping)();
+ }
+
+ //! Returns OpenGL capping filling aspect.
+ const OpenGl_CappingPlaneResource* AspectFillCapping() const { return myAspectFillCapping; }
+
//! Dumps the content of me into the stream
Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
protected:
OpenGl_Aspects* myAspects;
+ OpenGl_CappingPlaneResource* myAspectFillCapping;
OpenGl_ElementNode* myFirst;
OpenGl_ElementNode* myLast;
Standard_Boolean myIsRaytracable;
#include <Prs3d_Drawer.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectFillCapping.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_AspectText3d.hxx>
#include <Prs3d_ArrowAspect.hxx>
myHasOwnDimLengthModelUnits (Standard_False),
myHasOwnDimAngleModelUnits (Standard_False),
myHasOwnDimLengthDisplayUnits (Standard_False),
- myHasOwnDimAngleDisplayUnits (Standard_False)
+ myHasOwnDimAngleDisplayUnits (Standard_False),
+
+ myHasOwnFillCappingAspect (Standard_False)
{
myDimensionModelUnits.SetLengthUnits ("m");
myDimensionModelUnits.SetAngleUnits ("rad");
myHasOwnDimensionAspect = !myDimensionAspect.IsNull();
}
+// =======================================================================
+// function : FillCappingAspect
+// purpose :
+// =======================================================================
+
+const Handle(Graphic3d_AspectFillCapping)& Prs3d_Drawer::FillCappingAspect()
+{
+ return myFillCappingAspect;
+}
+
+// =======================================================================
+// function : SetFillCappingAspect
+// purpose :
+// =======================================================================
+
+void Prs3d_Drawer::SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theAspect)
+{
+ myFillCappingAspect = theAspect;
+ myHasOwnFillCappingAspect = !myFillCappingAspect.IsNull();
+}
+
// =======================================================================
// function : SetDimLengthModelUnits
// purpose :
#include <Standard_Transient.hxx>
#include <GeomAbs_Shape.hxx>
+class Graphic3d_AspectFillCapping;
class Prs3d_IsoAspect;
class Prs3d_LineAspect;
class Prs3d_TextAspect;
//! the appearance of dimensions that overrides the one in the link.
Standard_Boolean HasOwnDimensionAspect() const { return myHasOwnDimensionAspect; }
+ //! Returns style for filling capping section created by clipping planes.
+ Standard_EXPORT const Handle(Graphic3d_AspectFillCapping)& FillCappingAspect();
+
+ //! Set style of filling capping section created by clipping planes.
+ Standard_EXPORT void SetFillCappingAspect (const Handle(Graphic3d_AspectFillCapping)& theStyle);
+
+ //! Returns true if the drawer has its own attribute for
+ //! the appearance of dimensions that overrides the one in the link.
+ Standard_Boolean HasOwnFillCappingAspect() const { return myHasOwnFillCappingAspect; }
+
//! Sets dimension length model units for computing of dimension presentation.
//! The method sets value owned by the drawer that will be used during
//! visualization instead of the one set in link.
Prs3d_DimensionUnits myDimensionDisplayUnits;
Standard_Boolean myHasOwnDimLengthDisplayUnits;
Standard_Boolean myHasOwnDimAngleDisplayUnits;
+
+ Handle(Graphic3d_AspectFillCapping) myFillCappingAspect;
+ Standard_Boolean myHasOwnFillCappingAspect;
+
};
Standard_DEPRECATED("Class name is deprecated - use Prs3d_Drawer instead")
static Standard_Boolean shadeFromShape (const TopoDS_Shape& theShape,
const Handle(Prs3d_Presentation)& thePrs,
const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
const Standard_Boolean theHasTexels,
const gp_Pnt2d& theUVOrigin,
const gp_Pnt2d& theUVRepeat,
Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePrs);
aGroup->SetClosed (theIsClosed);
aGroup->SetGroupPrimitivesAspect (theDrawer->ShadingAspect()->Aspect());
+ if (!theCappingStyle.IsNull())
+ aGroup->SetGroupPrimitivesAspect (theCappingStyle);
+
aGroup->AddPrimitiveArray (aPArray);
return Standard_True;
}
void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
const TopoDS_Shape& theShape,
const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
const StdPrs_Volume theVolume)
{
gp_Pnt2d aDummy;
StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
- Standard_False, aDummy, aDummy, aDummy, theVolume);
+ Standard_False, aDummy, aDummy, aDummy, theCappingStyle, theVolume);
}
// =======================================================================
const gp_Pnt2d& theUVOrigin,
const gp_Pnt2d& theUVRepeat,
const gp_Pnt2d& theUVScale,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
const StdPrs_Volume theVolume)
{
if (theShape.IsNull())
if (aClosed.NbChildren() > 0)
{
- shadeFromShape (aClosed, thePrs, theDrawer,
+ shadeFromShape (aClosed, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
}
if (anOpened.NbChildren() > 0)
{
- shadeFromShape (anOpened, thePrs, theDrawer,
+ shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
}
}
else
{
// if the shape type is not compound, composolid or solid, use autodetection back-facing filled
- shadeFromShape (theShape, thePrs, theDrawer,
+ shadeFromShape (theShape, thePrs, theDrawer, theCappingStyle,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
theVolume == StdPrs_Volume_Closed);
}
//! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
//! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
//! or to perform Autodetection (would split input shape into two groups)
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+ const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
+ StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Shades <theShape> with texture coordinates.
//! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
//! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
//! or to perform Autodetection (would split input shape into two groups)
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const Standard_Boolean theHasTexels, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, const gp_Pnt2d& theUVScale, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
+ const TopoDS_Shape& theShape,
+ const Handle(Prs3d_Drawer)& theDrawer,
+ const Standard_Boolean theHasTexels,
+ const gp_Pnt2d& theUVOrigin,
+ const gp_Pnt2d& theUVRepeat,
+ const gp_Pnt2d& theUVScale,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
+ const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Searches closed and unclosed subshapes in shape structure and puts them
//! into two compounds for separate processing of closed and unclosed sub-shapes
}
}
+//===============================================================================================
+//function : setCappingParams
+//purpose :
+//===============================================================================================
+static Standard_Boolean setCappingParams (const TCollection_AsciiString& theChangeArg,
+ const Handle(Graphic3d_AspectFillCapping)& theCappingStyle,
+ const char** theChangeArgs,
+ Standard_Integer aNbChangeArgs,
+ Standard_Integer& anArgIter)
+{
+ if (theCappingStyle.IsNull())
+ return Standard_False;
+
+ Standard_Boolean toEnable = Standard_True;
+ if (theChangeArg == "-useobjectmaterial"
+ || theChangeArg == "-useobjectmat"
+ || theChangeArg == "-useobjmat"
+ || theChangeArg == "-useobjmaterial")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetUseObjectMaterial (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (theChangeArg == "-useobjecttexture"
+ || theChangeArg == "-useobjecttex"
+ || theChangeArg == "-useobjtexture"
+ || theChangeArg == "-useobjtex")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetUseObjectTexture (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (theChangeArg == "-useobjectshader"
+ || theChangeArg == "-useobjshader")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetUseObjectShader (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (theChangeArg == "-color"
+ || theChangeArg == "color")
+ {
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ theChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Graphic3d_MaterialAspect aMat = theCappingStyle->Material();
+ aMat.SetAmbientColor (aColor);
+ aMat.SetDiffuseColor (aColor);
+ theCappingStyle->SetMaterial (aMat);
+ anArgIter += aNbParsed;
+ }
+ else if ((theChangeArg == "-transparency"
+ || theChangeArg == "-transp")
+ && aNbChangeArgs >= 2)
+ {
+ TCollection_AsciiString aValStr (theChangeArgs[1]);
+ if (aValStr.IsRealValue())
+ {
+ Graphic3d_MaterialAspect aMat = theCappingStyle->Material();
+ aMat.SetTransparency ((float )aValStr.RealValue());
+ theCappingStyle->SetMaterial (aMat);
+ }
+ else
+ {
+ std::cout << "Syntax error at '" << aValStr << "'\n";
+ return Standard_False;
+ }
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-texname"
+ || theChangeArg == "texname")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ TCollection_AsciiString aTextureName (theChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
+ {
+ theCappingStyle->SetTexture (Handle(Graphic3d_TextureMap)());
+ }
+ else
+ {
+ aTexture->EnableModulate();
+ aTexture->EnableRepeat();
+ theCappingStyle->SetTexture (aTexture.get());
+ }
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-texscale"
+ || theChangeArg == "texscale")
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+ aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ anArgIter += 2;
+ }
+ else if (theChangeArg == "-texorigin"
+ || theChangeArg == "texorigin") // texture origin
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+
+ aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ anArgIter += 2;
+ }
+ else if (theChangeArg == "-texrotate"
+ || theChangeArg == "texrotate") // texture rotation
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->Texture();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ aHatchTexture->GetParams()->SetRotation (aRot);
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-hatch"
+ || theChangeArg == "hatch")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetToDrawHatch (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (theChangeArg == "-hatchtexture"
+ || theChangeArg == "hatchtexture")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ TCollection_AsciiString aTextureName (theChangeArgs[1]);
+ Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
+ if (!aTexture->IsDone())
+ {
+ theCappingStyle->SetHatchStyle (Handle(Graphic3d_TextureMap)());
+ }
+ else
+ {
+ aTexture->EnableModulate();
+ aTexture->EnableRepeat();
+ theCappingStyle->SetHatchStyle (aTexture.get());
+ theCappingStyle->SetToDrawHatch (true);
+ }
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-hatchstipple"
+ || theChangeArg == "hatchstipple")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ theCappingStyle->SetHatchStyle ((Aspect_HatchStyle)Draw::Atoi (theChangeArgs[1]));
+ theCappingStyle->SetToDrawHatch (true);
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-hatchcolor"
+ || theChangeArg == "hatchcolor")
+ {
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ theChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Graphic3d_MaterialAspect aMat = theCappingStyle->HatchMaterial();
+ aMat.SetAmbientColor (aColor);
+ aMat.SetDiffuseColor (aColor);
+ theCappingStyle->SetHatchMaterial (aMat);
+ anArgIter += aNbParsed;
+ }
+
+ else if (theChangeArg == "-hatchscale"
+ || theChangeArg == "hatchscale")
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+ aHatchTexture->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
+ anArgIter += 2;
+ }
+ else if (theChangeArg == "-hatchorigin"
+ || theChangeArg == "hatchorigin") // texture origin
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 3)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (theChangeArgs[2]);
+
+ aHatchTexture->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
+ anArgIter += 2;
+ }
+ else if (theChangeArg == "-hatchrotate"
+ || theChangeArg == "hatchrotate") // texture rotation
+ {
+ const Handle(Graphic3d_TextureMap)& aHatchTexture = theCappingStyle->TextureHatch();
+
+ if (aHatchTexture.IsNull())
+ {
+ std::cout << "Error: no texture is set.\n";
+ return Standard_False;
+ }
+
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (theChangeArgs[1]);
+ aHatchTexture->GetParams()->SetRotation (aRot);
+ anArgIter += 1;
+ }
+ else if (theChangeArg == "-hatchzoompers"
+ || theChangeArg == "hatchzoompers")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetHatchZoomPeristent (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (theChangeArg == "-hatchrotatepers"
+ || theChangeArg == "hatchrotatepers")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ std::cout << "Syntax error: need more arguments.\n";
+ return Standard_False;
+ }
+
+ if (ViewerTest::ParseOnOff (theChangeArgs[1], toEnable))
+ {
+ theCappingStyle->SetHatchRotationPeristent (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else
+ {
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
//===============================================================================================
//function : VClipPlane
//purpose :
// just skip otherwise (old syntax)
}
}
- else if (aChangeArg == "-useobjectmaterial"
- || aChangeArg == "-useobjectmat"
- || aChangeArg == "-useobjmat"
- || aChangeArg == "-useobjmaterial")
- {
- if (aNbChangeArgs < 2)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
- {
- aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
- anArgIter += 1;
- }
- }
- else if (aChangeArg == "-useobjecttexture"
- || aChangeArg == "-useobjecttex"
- || aChangeArg == "-useobjtexture"
- || aChangeArg == "-useobjtex")
- {
- if (aNbChangeArgs < 2)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
- {
- aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
- anArgIter += 1;
- }
- }
- else if (aChangeArg == "-useobjectshader"
- || aChangeArg == "-useobjshader")
+ else if (aChangeArg == "-overrideaspect"
+ || aChangeArg == "overrideaspect")
{
if (aNbChangeArgs < 2)
{
if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetUseObjectShader (toEnable == Standard_True);
+ aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
anArgIter += 1;
}
}
- else if (aChangeArg == "-color"
- || aChangeArg == "color")
- {
- Quantity_Color aColor;
- Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
- aChangeArgs + 1,
- aColor);
- if (aNbParsed == 0)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
- aClipPlane->SetCappingColor (aColor);
- anArgIter += aNbParsed;
- }
else if (aNbChangeArgs >= 1
&& (aChangeArg == "-material"
|| aChangeArg == "material"))
}
aClipPlane->SetCappingMaterial (aMatName);
}
- else if ((aChangeArg == "-transparency"
- || aChangeArg == "-transp")
- && aNbChangeArgs >= 2)
- {
- TCollection_AsciiString aValStr (aChangeArgs[1]);
- Handle(Graphic3d_AspectFillArea3d) anAspect = aClipPlane->CappingAspect();
- if (aValStr.IsRealValue())
- {
- Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
- aMat.SetTransparency ((float )aValStr.RealValue());
- anAspect->SetAlphaMode (Graphic3d_AlphaMode_BlendAuto);
- aClipPlane->SetCappingMaterial (aMat);
- }
- else
- {
- aValStr.LowerCase();
- Graphic3d_AlphaMode aMode = Graphic3d_AlphaMode_BlendAuto;
- if (aValStr == "opaque")
- {
- aMode = Graphic3d_AlphaMode_Opaque;
- }
- else if (aValStr == "mask")
- {
- aMode = Graphic3d_AlphaMode_Mask;
- }
- else if (aValStr == "blend")
- {
- aMode = Graphic3d_AlphaMode_Blend;
- }
- else if (aValStr == "blendauto")
- {
- aMode = Graphic3d_AlphaMode_BlendAuto;
- }
- else
- {
- Message::SendFail() << "Syntax error at '" << aValStr << "'";
- return 1;
- }
- anAspect->SetAlphaMode (aMode);
- aClipPlane->SetCappingAspect (anAspect);
- }
- anArgIter += 1;
- }
- else if (aChangeArg == "-texname"
- || aChangeArg == "texname")
- {
- if (aNbChangeArgs < 2)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- TCollection_AsciiString aTextureName (aChangeArgs[1]);
- Handle(Graphic3d_Texture2Dmanual) aTexture = new Graphic3d_Texture2Dmanual(aTextureName);
- if (!aTexture->IsDone())
- {
- aClipPlane->SetCappingTexture (NULL);
- }
- else
- {
- aTexture->EnableModulate();
- aTexture->EnableRepeat();
- aClipPlane->SetCappingTexture (aTexture);
- }
- anArgIter += 1;
- }
- else if (aChangeArg == "-texscale"
- || aChangeArg == "texscale")
- {
- if (aClipPlane->CappingTexture().IsNull())
- {
- Message::SendFail ("Error: no texture is set");
- return 1;
- }
-
- if (aNbChangeArgs < 3)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- Standard_ShortReal aSx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
- Standard_ShortReal aSy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
- aClipPlane->CappingTexture()->GetParams()->SetScale (Graphic3d_Vec2 (aSx, aSy));
- anArgIter += 2;
- }
- else if (aChangeArg == "-texorigin"
- || aChangeArg == "texorigin") // texture origin
- {
- if (aClipPlane->CappingTexture().IsNull())
- {
- Message::SendFail ("Error: no texture is set");
- return 1;
- }
-
- if (aNbChangeArgs < 3)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- Standard_ShortReal aTx = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
- Standard_ShortReal aTy = (Standard_ShortReal)Draw::Atof (aChangeArgs[2]);
-
- aClipPlane->CappingTexture()->GetParams()->SetTranslation (Graphic3d_Vec2 (aTx, aTy));
- anArgIter += 2;
- }
- else if (aChangeArg == "-texrotate"
- || aChangeArg == "texrotate") // texture rotation
- {
- if (aClipPlane->CappingTexture().IsNull())
- {
- Message::SendFail ("Error: no texture is set");
- return 1;
- }
-
- if (aNbChangeArgs < 2)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- Standard_ShortReal aRot = (Standard_ShortReal)Draw::Atof (aChangeArgs[1]);
- aClipPlane->CappingTexture()->GetParams()->SetRotation (aRot);
- anArgIter += 1;
- }
- else if (aChangeArg == "-hatch"
- || aChangeArg == "hatch")
- {
- if (aNbChangeArgs < 2)
- {
- Message::SendFail ("Syntax error: need more arguments");
- return 1;
- }
-
- TCollection_AsciiString aHatchStr (aChangeArgs[1]);
- aHatchStr.LowerCase();
- if (aHatchStr == "on")
- {
- aClipPlane->SetCappingHatchOn();
- }
- else if (aHatchStr == "off")
- {
- aClipPlane->SetCappingHatchOff();
- }
- else
- {
- aClipPlane->SetCappingHatch ((Aspect_HatchStyle)Draw::Atoi (aChangeArgs[1]));
- }
- anArgIter += 1;
- }
else if (aChangeArg == "-delete"
|| aChangeArg == "delete")
{
anArgIter = anArgIter + anIt - 1;
}
}
- else
+ else if (!setCappingParams (aChangeArg, aClipPlane->CappingSectionStyle(), aChangeArgs, aNbChangeArgs, anArgIter))
{
Message::SendFail() << "Syntax error: unknown argument '" << aChangeArg << "'";
return 1;
return 0;
}
+//===============================================================================================
+//function : VSetCapping
+//purpose :
+//===============================================================================================
+static int VSetCapping (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+{
+ if (theArgsNb < 2)
+ {
+ std::cout << "Syntax error: the wrong number of input parameters.\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aName (theArgVec[1]);
+ gp_Pln aWorkingPlane;
+ Standard_Boolean toUpdate = Standard_True;
+
+ NCollection_DataMap<TCollection_AsciiString, Standard_Real> aRealParams;
+ NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString> aStringParams;
+
+ Handle(AIS_InteractiveObject) anObject;
+ if (GetMapOfAIS().Find2 (aName, anObject))
+ {
+ if (anObject.IsNull())
+ {
+ std::cout << "Syntax error: no presentation with this name.\n";
+ return 1;
+ }
+ }
+
+ Handle(Graphic3d_AspectFillCapping) aFillCapping = anObject->Attributes()->FillCappingAspect();
+ for (Standard_Integer anArgIter = 2; anArgIter < theArgsNb; ++anArgIter)
+ {
+ const char** aChangeArgs = theArgVec + anArgIter;
+ Standard_Integer aNbChangeArgs = theArgsNb - anArgIter;
+ TCollection_AsciiString aChangeArg (aChangeArgs[0]);
+ aChangeArg.LowerCase();
+
+ Standard_Boolean toEnable = Standard_True;
+ if (ViewerTest::ParseOnOff (aChangeArgs[0], toEnable))
+ {
+ if (!toEnable)
+ anObject->Attributes()->SetFillCappingAspect (NULL);
+ else
+ {
+ if (aFillCapping.IsNull())
+ {
+ aFillCapping = new Graphic3d_AspectFillCapping();
+ anObject->Attributes()->SetFillCappingAspect (aFillCapping);
+ }
+ }
+ }
+ else if (!setCappingParams (aChangeArg, aFillCapping, aChangeArgs, aNbChangeArgs, anArgIter))
+ {
+ std::cout << "Syntax error: unknown argument '" << aChangeArg << "'.\n";
+ return 1;
+ }
+ }
+ ViewerTest::GetAISContext()->Redisplay (anObject, Standard_False);
+
+ return 0;
+}
+
+
//===============================================================================================
//function : VZRange
//purpose :
"\n\t\t: [-color R G B] [-transparency Value] [-hatch {on|off|ID}]"
"\n\t\t: [-texName Texture] [-texScale SX SY] [-texOrigin TX TY]"
"\n\t\t: [-texRotate Angle]"
+ /*"\n\t\t: [-overrideAspect {0|1}]"
+ "\n\t\t: [-color R G B]"
+ "\n\t\t: [-texture Texture] [-texScale SX SY]"
+ "\n\t\t: [-texOrigin TX TY] [-texRotate Angle]"
+ "\n\t\t: [-hatch {on|off}] [-hatchStipple mask]"
+ "\n\t\t: [-hatchColor R G B] [-hatchTexture texture]"
+ "\n\t\t: [-hatchScale SX SY] [-hatchOrigin TX TY]"
+ "\n\t\t: [-hatchRotate Angle]"
+ "\n\t\t: [-hatchZoomPers {0|1}]"
+ "\n\t\t: [-hatchRotatePers {0|1}]"*/
"\n\t\t: [-useObjMaterial {0|1}] [-useObjTexture {0|1}]"
"\n\t\t: [-useObjShader {0|1}]"
"\n\t\t: Clipping planes management:"
"\n\t\t: -clone SourcePlane NewPlane clone the plane definition."
"\n\t\t: Capping options:"
"\n\t\t: -capping {off|on|0|1} turn capping on/off"
+ "\n\t\t: -overrideAspect override presentation aspect (if defined)"
"\n\t\t: -color R G B set capping color"
"\n\t\t: -transparency Value set capping transparency 0..1"
"\n\t\t: -texName Texture set capping texture"
"\n\t\t: -texScale SX SY set capping tex scale"
"\n\t\t: -texOrigin TX TY set capping tex origin"
"\n\t\t: -texRotate Angle set capping tex rotation"
- "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
+ "\n\t\t: -hatch {on|off} turn on/off hatch style on capping"
+ "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
+ "\n\t\t: -hatchColor R G B set color for hatch material"
+ "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
+ "\n\t\t: -hatchScale SX SY set hatch texture scale"
+ "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
+ "\n\t\t: -hatchRotate Angle set hatch texture rotation"
+ "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
+ "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
"\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
"\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
"\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
__FILE__, VClipPlane, group);
+
+ theCommands.Add("vsetcapping",
+ "vsetcapping name [{0|1}]"
+ "\n\t\t: Sets capping parameters for all, selected or named objects."
+ "\n\t\t: Capping options:"
+ "\n\t\t: -capping {off|on|0|1} turn capping on/off"
+ "\n\t\t: -overrideAspect override presentation aspect (if defined)"
+ "\n\t\t: -color R G B set capping color"
+ "\n\t\t: -transparency Value set capping transparency 0..1"
+ "\n\t\t: -texName Texture set capping texture"
+ "\n\t\t: -texScale SX SY set capping tex scale"
+ "\n\t\t: -texOrigin TX TY set capping tex origin"
+ "\n\t\t: -texRotate Angle set capping tex rotation"
+ "\n\t\t: -hatch {on|off} turn on/off hatch style on capping"
+ "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
+ "\n\t\t: -hatchColor R G B set color for hatch material"
+ "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
+ "\n\t\t: -hatchScale SX SY set hatch texture scale"
+ "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
+ "\n\t\t: -hatchRotate Angle set hatch texture rotation"
+ "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
+ "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
+ "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
+ "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
+ "\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
+ __FILE__, VSetCapping, group);
+
theCommands.Add("vdefaults",
"vdefaults [-absDefl value]"
"\n\t\t: [-devCoeff value]"
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
