{
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->FillCappingAspect());
+ StdPrs_ShadedShape::Add (aPrs, myshape, myDrawer,
+ myDrawer->ShadingAspect()->Aspect()->ToMapTexture()
+ && !myDrawer->ShadingAspect()->Aspect()->TextureMap().IsNull(),
+ myUVOrigin, myUVRepeat, myUVScale);
}
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, 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, 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)
{
- *myAspect = *theOther.CappingAspect();
- *mySectionStyle = *theOther.CappingSectionStyle();
-
makeId();
- init (theOther.myPlane,
- theOther.myEquationRev,
- theOther.myIsOn,
- theOther.myIsCapping,
- theOther.ToOverrideCappingAspect(),
- theOther.CappingSectionStyle());
- updateInversedPlane();
+ *myAspect = *theOther.CappingAspect();
}
// =======================================================================
myIsCapping (Standard_False)
{
thePlane.Coefficients (myEquation[0], myEquation[1], myEquation[2], myEquation[3]);
- makeId();
- init (thePlane);
updateInversedPlane();
+ makeId();
}
// =======================================================================
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;
-//! - Graphic3d_ASPECT_FILL_CAPPING: aspect for filling clipping sections.
+//! - ASPECT_FILL_AREA: aspect for face primitives.
enum Graphic3d_GroupAspect
{
Graphic3d_ASPECT_LINE,
Graphic3d_ASPECT_TEXT,
Graphic3d_ASPECT_MARKER,
-Graphic3d_ASPECT_FILL_AREA,
-Graphic3d_ASPECT_FILL_CAPPING
+Graphic3d_ASPECT_FILL_AREA
};
#endif // _Graphic3d_GroupAspect_HeaderFile
#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 OpenGl_PrimitiveArray* theQuad)
+ const Handle(OpenGl_CappingPlaneResource)& thePlane)
{
const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly);
- const Handle(Graphic3d_ClipPlane)& aPlane = theClipChain;
-
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const Handle(Graphic3d_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();
- 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)
+ // 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()))
{
- 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;
- }
+ 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 (hasHatch)
+ if (aRenderPlane->ToUseObjectProperties())
{
aGroupIter.Value()->Render (theWorkspace);
}
else
{
- // render closed primitives
- if (aRenderPlane->ToUseObjectProperties())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
- else
+ for (; aGroupIter.More(); aGroupIter.Next())
{
- for (; aGroupIter.More(); aGroupIter.Next())
+ if (aGroupIter.Value()->IsClosed())
{
- if (aGroupIter.Value()->IsClosed())
- {
- aGroupIter.Value()->Render (theWorkspace);
- }
+ aGroupIter.Value()->Render (theWorkspace);
}
}
}
glEnable (GL_DEPTH_TEST);
}
- 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);
- }
+ theWorkspace->SetAspects (thePlane->AspectFace());
+ renderPlane (theWorkspace, thePlane);
// turn on the current plane to restore initial state
aContext->ChangeClipping().ResetCappingFilter();
if (theStructure.InstancedStructure() != NULL)
{
- renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane, theQuad);
+ renderCappingForStructure (theStencilSentry, theWorkspace, *theStructure.InstancedStructure(), theClipChain, theSubPlaneIndex, thePlane);
}
}
}
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 = THE_PLANE_STYLE + aSubPlaneIter->GetId();
+ const TCollection_AsciiString& aResId = aSubPlaneIter->GetId();
Handle(OpenGl_CappingPlaneResource) aPlaneRes;
if (!aContext->GetResource (aResId, aPlaneRes))
{
// share and register for release once the resource is no longer used
- aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter, aSubPlaneIter->CappingSectionStyle());
+ aPlaneRes = new OpenGl_CappingPlaneResource (aSubPlaneIter);
aContext->ShareResource (aResId, aPlaneRes);
}
- renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes, aCappingQuad);
+ renderCappingForStructure (aStencilSentry, theWorkspace, theStructure, aClipChain, aSubPlaneIndex, aPlaneRes);
// set delayed resource release
aPlaneRes.Nullify();
- if (!aResId.IsEmpty())
- {
- // schedule release of resource if not used
- aContext->ReleaseResource (aResId, Standard_True);
- }
+ aContext->ReleaseResource (aResId, Standard_True);
}
}
- if (aPrevBlend == GL_TRUE)
- {
- glEnable (GL_BLEND);
- glBlendFunc (aPrevBlendSrc, aPrevBlendDst);
- }
-
// restore rendering aspects
theWorkspace->SetAspects (aFaceAsp);
theWorkspace->SetRenderFilter (aPrevFilter);
{ 0.0f, 0.0f, 0.0f, 1.0f } }
};
- Handle(Graphic3d_Aspects) defaultMaterial()
- {
- Handle(Graphic3d_AspectFillArea3d) anAspect;
- const Graphic3d_MaterialAspect aMaterial (Graphic3d_NOM_DEFAULT);
- anAspect = new Graphic3d_AspectFillArea3d();
- anAspect->SetDistinguishOff();
- anAspect->SetFrontMaterial (aMaterial);
- anAspect->SetInteriorStyle (Aspect_IS_SOLID);
- anAspect->SetInteriorColor (aMaterial.Color());
- anAspect->SetSuppressBackFaces (false);
- return anAspect;
- }
}
// =======================================================================
-// function : BuildInfinitPlaneVertices
+// function : OpenGl_CappingPlaneResource
// purpose :
// =======================================================================
-OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
+OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
+: myPrimitives (NULL),
+ myOrientation (OpenGl_IdentityMatrix),
+ myAspect (NULL),
+ myPlaneRoot (thePlane),
+ myEquationMod ((unsigned int )-1),
+ myAspectMod ((unsigned int )-1)
{
- OpenGl_PrimitiveArray* aPrimitives = NULL;
// Fill primitive array
Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
if (anAttribs->Init (12, anAttribInfo, 3))
{
memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
-
- aPrimitives = new OpenGl_PrimitiveArray (NULL);
- aPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+ myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
}
- return aPrimitives;
-}
-
-// =======================================================================
-// function : OpenGl_CappingPlaneResource
-// purpose :
-// =======================================================================
-OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_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()
{
- 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();
- }
+ Release (NULL);
}
// =======================================================================
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)
{
- 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;
+ OpenGl_Element::Destroy (theContext, myAspect);
+ myPrimitives.Release (theContext);
+ myEquationMod = (unsigned int )-1;
+ myAspectMod = (unsigned int )-1;
}
// =======================================================================
// =======================================================================
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_AspectFillCapping data.
+//! - instance associated to Graphic3d_ClipPlane data by id.
//! - should created and released within context (owns OpenGl elements and resources).
class OpenGl_CappingPlaneResource : public OpenGl_Resource
{
public:
- //! Create and assign style.
- Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane,
- const Handle(Graphic3d_AspectFillCapping)& theAspect);
+ //! Constructor.
+ //! Create capping plane presentation associated to clipping plane data.
+ //! @param thePlane [in] the plane data.
+ Standard_EXPORT OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane);
//! Destroy object.
Standard_EXPORT virtual ~OpenGl_CappingPlaneResource();
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),
-
- myHasOwnFillCappingAspect (Standard_False)
+ myHasOwnDimAngleDisplayUnits (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, theCappingStyle, theVolume);
+ Standard_False, aDummy, aDummy, aDummy, 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, theCappingStyle,
+ shadeFromShape (aClosed, thePrs, theDrawer,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, true);
}
if (anOpened.NbChildren() > 0)
{
- shadeFromShape (anOpened, thePrs, theDrawer, theCappingStyle,
+ shadeFromShape (anOpened, thePrs, theDrawer,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale, false);
}
}
else
{
// if the shape type is not compound, composolid or solid, use autodetection back-facing filled
- shadeFromShape (theShape, thePrs, theDrawer, theCappingStyle,
+ shadeFromShape (theShape, thePrs, theDrawer,
theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
theVolume == StdPrs_Volume_Closed);
}
//! @param theVolumeType defines the way how to interpret input shapes - as Closed volumes (to activate back-face
//! culling and capping plane algorithms), as Open volumes (shells or solids with holes)
//! or to perform Autodetection (would split input shape into two groups)
- Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation,
- const TopoDS_Shape& theShape,
- const Handle(Prs3d_Drawer)& theDrawer,
- const Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
- StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Shades <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 Handle(Graphic3d_AspectFillCapping)& theCappingStyle = Handle(Graphic3d_AspectFillCapping)(),
- const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
+ Standard_EXPORT static void Add (const Handle(Prs3d_Presentation)& thePresentation, const TopoDS_Shape& theShape, const Handle(Prs3d_Drawer)& theDrawer, const Standard_Boolean theHasTexels, const gp_Pnt2d& theUVOrigin, const gp_Pnt2d& theUVRepeat, const gp_Pnt2d& theUVScale, const StdPrs_Volume theVolume = StdPrs_Volume_Autodetection);
//! Searches closed and unclosed subshapes in shape structure and puts them
//! into two compounds for separate processing of closed and unclosed sub-shapes
}
}
-//===============================================================================================
-//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 == "-overrideaspect"
- || aChangeArg == "overrideaspect")
+ else if (aChangeArg == "-useobjectmaterial"
+ || aChangeArg == "-useobjectmat"
+ || aChangeArg == "-useobjmat"
+ || aChangeArg == "-useobjmaterial")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ Message::SendFail ("Syntax error: need more arguments");
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectMaterial (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (aChangeArg == "-useobjecttexture"
+ || aChangeArg == "-useobjecttex"
+ || aChangeArg == "-useobjtexture"
+ || aChangeArg == "-useobjtex")
+ {
+ if (aNbChangeArgs < 2)
+ {
+ Message::SendFail ("Syntax error: need more arguments");
+ return 1;
+ }
+
+ if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
+ {
+ aClipPlane->SetUseObjectTexture (toEnable == Standard_True);
+ anArgIter += 1;
+ }
+ }
+ else if (aChangeArg == "-useobjectshader"
+ || aChangeArg == "-useobjshader")
{
if (aNbChangeArgs < 2)
{
if (ViewerTest::ParseOnOff (aChangeArgs[1], toEnable))
{
- aClipPlane->SetToOverrideCappingAspect (toEnable == Standard_True);
+ aClipPlane->SetUseObjectShader (toEnable == Standard_True);
anArgIter += 1;
}
}
+ else if (aChangeArg == "-color"
+ || aChangeArg == "color")
+ {
+ Quantity_Color aColor;
+ Standard_Integer aNbParsed = ViewerTest::ParseColor (aNbChangeArgs - 1,
+ aChangeArgs + 1,
+ aColor);
+ if (aNbParsed == 0)
+ {
+ Message::SendFail ("Syntax error: need more arguments");
+ return 1;
+ }
+ aClipPlane->SetCappingColor (aColor);
+ anArgIter += aNbParsed;
+ }
else if (aNbChangeArgs >= 1
&& (aChangeArg == "-material"
|| aChangeArg == "material"))
}
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 if (!setCappingParams (aChangeArg, aClipPlane->CappingSectionStyle(), aChangeArgs, aNbChangeArgs, anArgIter))
+ else
{
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} turn on/off hatch style on capping"
- "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
- "\n\t\t: -hatchColor R G B set color for hatch material"
- "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
- "\n\t\t: -hatchScale SX SY set hatch texture scale"
- "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
- "\n\t\t: -hatchRotate Angle set hatch texture rotation"
- "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
- "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
+ "\n\t\t: -hatch {on|off|ID} set capping hatching mask"
"\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
"\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
"\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
__FILE__, VClipPlane, group);
-
- theCommands.Add("vsetcapping",
- "vsetcapping name [{0|1}]"
- "\n\t\t: Sets capping parameters for all, selected or named objects."
- "\n\t\t: Capping options:"
- "\n\t\t: -capping {off|on|0|1} turn capping on/off"
- "\n\t\t: -overrideAspect override presentation aspect (if defined)"
- "\n\t\t: -color R G B set capping color"
- "\n\t\t: -transparency Value set capping transparency 0..1"
- "\n\t\t: -texName Texture set capping texture"
- "\n\t\t: -texScale SX SY set capping tex scale"
- "\n\t\t: -texOrigin TX TY set capping tex origin"
- "\n\t\t: -texRotate Angle set capping tex rotation"
- "\n\t\t: -hatch {on|off} turn on/off hatch style on capping"
- "\n\t\t: -hatchStipple ID set stipple mask for drawing hatch"
- "\n\t\t: -hatchColor R G B set color for hatch material"
- "\n\t\t: -hatchTexture Texture set texture (semi-opaque) for drawing hatch"
- "\n\t\t: -hatchScale SX SY set hatch texture scale"
- "\n\t\t: -hatchOrigin TX TY set hatch texture origin"
- "\n\t\t: -hatchRotate Angle set hatch texture rotation"
- "\n\t\t: -hatchZoomPers allow hatch tetxure mapping to be constant when zooming"
- "\n\t\t: -hatchRotatePers allow hatch tetxure mapping to be constant when rotating"
- "\n\t\t: -useObjMaterial {off|on|0|1} use material of clipped object"
- "\n\t\t: -useObjTexture {off|on|0|1} use texture of clipped object"
- "\n\t\t: -useObjShader {off|on|0|1} use shader program of object",
- __FILE__, VSetCapping, group);
-
theCommands.Add("vdefaults",
"vdefaults [-absDefl value]"
"\n\t\t: [-devCoeff value]"
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 -hatchtexture $aHatch -hatchscale 0.02 -0.02 -useObjMaterial 1
-vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -hatchtexture $aHatch -hatchscale 0.02 -0.02
+vclipplane pln1 -set -equation 0 0 -1 $aPln1Z -capping 1 -color 0.5 0.5 0.5 -texname $aHatch -texscale 0.02 -0.02 -useObjMaterial 1
+vclipplane pln2 -set -equation 0 1 0 [expr -$aPln2Y] -capping 1 -color 0.8 0.8 0.9 -texname $aHatch -texscale 0.02 -0.02
projects / occt-copy.git / commitdiff
