#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_StructureShadow.hxx>
-#include <OpenGl_telem_util.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
-IMPLEMENT_STANDARD_HANDLE (OpenGl_Structure, Graphic3d_CStructure)
-IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Structure, Graphic3d_CStructure)
+
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Structure,Graphic3d_CStructure)
//! Auxiliary class for bounding box presentation
class OpenGl_BndBoxPrs : public OpenGl_Element
{
#if !defined(GL_ES_VERSION_2_0)
// Apply line aspect
- const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
glDisable (GL_LIGHTING);
// Use highlight colors
- theWorkspace->GetGlContext()->core11->glColor3fv ((theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) ? theWorkspace->HighlightColor->rgb : anAspectLine->Color().rgb);
+ theWorkspace->GetGlContext()->core11->glColor3fv (theWorkspace->LineColor().GetData());
glEnableClientState (GL_VERTEX_ARRAY);
glVertexPointer (3, GL_FLOAT, 0, (GLfloat* )&myVerts);
{
theWorkspace->EnableTexture (aPrevTexture);
}
+ #else
+ (void )theWorkspace;
#endif
}
// =======================================================================
OpenGl_Structure::OpenGl_Structure (const Handle(Graphic3d_StructureManager)& theManager)
: Graphic3d_CStructure (theManager),
- myTransformation (NULL),
- myTransPers (NULL),
- myAspectLine (NULL),
- myAspectFace (NULL),
- myAspectMarker (NULL),
- myAspectText (NULL),
- myHighlightColor (NULL),
myInstancedStructure (NULL),
myIsRaytracable (Standard_False),
myModificationState (0),
OpenGl_Structure::~OpenGl_Structure()
{
Release (Handle(OpenGl_Context)());
- delete myTransformation; myTransformation = NULL;
- delete myTransPers; myTransPers = NULL;
-}
-
-// =======================================================================
-// function : UpdateAspects
-// purpose :
-// =======================================================================
-void OpenGl_Structure::UpdateAspects()
-{
- SetTransformPersistence (TransformPersistence);
-
- if (ContextLine.IsDef)
- SetAspectLine (ContextLine);
-
- if (ContextFillArea.IsDef)
- SetAspectFace (ContextFillArea);
-
- if (ContextMarker.IsDef)
- SetAspectMarker (ContextMarker);
-
- if (ContextText.IsDef)
- SetAspectText (ContextText);
-}
-
-// =======================================================================
-// function : UpdateTransformation
-// purpose :
-// =======================================================================
-void OpenGl_Structure::UpdateTransformation()
-{
- if (myTransformation == NULL)
- {
- myTransformation = new OpenGl_Matrix();
- }
-
- Standard_ShortReal (*aMat)[4] = Graphic3d_CStructure::Transformation;
-
- Standard_ShortReal aDet =
- aMat[0][0] * (aMat[1][1] * aMat[2][2] - aMat[2][1] * aMat[1][2]) -
- aMat[0][1] * (aMat[1][0] * aMat[2][2] - aMat[2][0] * aMat[1][2]) +
- aMat[0][2] * (aMat[1][0] * aMat[2][1] - aMat[2][0] * aMat[1][1]);
-
- // Determinant of transform matrix less then 0 means that mirror transform applied.
- myIsMirrored = aDet < 0.0f;
-
- matcpy (myTransformation->mat, &Graphic3d_CStructure::Transformation[0][0]);
-
- if (IsRaytracable())
- {
- ++myModificationState;
- }
-}
-
-// =======================================================================
-// function : SetTransformPersistence
-// purpose :
-// =======================================================================
-void OpenGl_Structure::SetTransformPersistence(const CALL_DEF_TRANSFORM_PERSISTENCE &ATransPers)
-{
- if (!myTransPers)
- myTransPers = new TEL_TRANSFORM_PERSISTENCE;
-
- myTransPers->mode = ATransPers.Flag;
- myTransPers->pointX = ATransPers.Point.x;
- myTransPers->pointY = ATransPers.Point.y;
- myTransPers->pointZ = ATransPers.Point.z;
- MarkAsNotCulled();
-}
-
-// =======================================================================
-// function : SetAspectLine
-// purpose :
-// =======================================================================
-void OpenGl_Structure::SetAspectLine (const CALL_DEF_CONTEXTLINE &theAspect)
-{
- if (!myAspectLine)
- {
- myAspectLine = new OpenGl_AspectLine();
- }
- myAspectLine->SetAspect (theAspect);
}
// =======================================================================
-// function : SetAspectFace
+// function : SetTransformation
// purpose :
// =======================================================================
-void OpenGl_Structure::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect)
+void OpenGl_Structure::SetTransformation (const Handle(Geom_Transformation)& theTrsf)
{
- if (!myAspectFace)
+ myTrsf = theTrsf;
+ myIsMirrored = Standard_False;
+ if (!myTrsf.IsNull())
{
- myAspectFace = new OpenGl_AspectFace();
+ // Determinant of transform matrix less then 0 means that mirror transform applied.
+ const Standard_Real aDet = myTrsf->Value(1, 1) * (myTrsf->Value (2, 2) * myTrsf->Value (3, 3) - myTrsf->Value (3, 2) * myTrsf->Value (2, 3))
+ - myTrsf->Value(1, 2) * (myTrsf->Value (2, 1) * myTrsf->Value (3, 3) - myTrsf->Value (3, 1) * myTrsf->Value (2, 3))
+ + myTrsf->Value(1, 3) * (myTrsf->Value (2, 1) * myTrsf->Value (3, 2) - myTrsf->Value (3, 1) * myTrsf->Value (2, 2));
+ myIsMirrored = aDet < 0.0;
}
- myAspectFace->SetAspect (theAspect);
if (IsRaytracable())
{
}
}
-// =======================================================================
-// function : SetAspectMarker
-// purpose :
-// =======================================================================
-void OpenGl_Structure::SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect)
-{
- if (!myAspectMarker)
- {
- myAspectMarker = new OpenGl_AspectMarker();
- }
- myAspectMarker->SetAspect (theAspect);
-}
-
-// =======================================================================
-// function : SetAspectText
-// purpose :
-// =======================================================================
-void OpenGl_Structure::SetAspectText (const CALL_DEF_CONTEXTTEXT &theAspect)
-{
- if (!myAspectText)
- {
- myAspectText = new OpenGl_AspectText();
- }
- myAspectText->SetAspect (theAspect);
-}
-
// =======================================================================
// function : clearHighlightBox
// purpose :
}
}
-// =======================================================================
-// function : HighlightWithColor
-// purpose :
-// =======================================================================
-void OpenGl_Structure::HighlightWithColor (const Graphic3d_Vec3& theColor,
- const Standard_Boolean theToCreate)
-{
- const Handle(OpenGl_Context)& aContext = GlDriver()->GetSharedContext();
- if (theToCreate)
- setHighlightColor (aContext, theColor);
- else
- clearHighlightColor (aContext);
-}
-
// =======================================================================
// function : HighlightWithBndBox
// purpose :
// =======================================================================
-void OpenGl_Structure::HighlightWithBndBox (const Handle(Graphic3d_Structure)& theStruct,
- const Standard_Boolean theToCreate)
+void OpenGl_Structure::highlightWithBndBox (const Handle(Graphic3d_Structure)& theStruct)
{
const Handle(OpenGl_Context)& aContext = GlDriver()->GetSharedContext();
- if (!theToCreate)
- {
- clearHighlightBox (aContext);
- return;
- }
if (!myHighlightBox.IsNull())
{
myHighlightBox = new OpenGl_Group (theStruct);
}
- CALL_DEF_CONTEXTLINE& aContextLine = myHighlightBox->ChangeContextLine();
- aContextLine.IsDef = 1;
- aContextLine.Color = HighlightColor;
- aContextLine.LineType = Aspect_TOL_SOLID;
- aContextLine.Width = 1.0f;
- myHighlightBox->UpdateAspectLine (Standard_True);
+ myHighlightBox->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (myHighlightStyle->Color(), Aspect_TOL_SOLID, 1.0));
OpenGl_BndBoxPrs* aBndBoxPrs = new OpenGl_BndBoxPrs (myBndBox);
myHighlightBox->AddElement (aBndBoxPrs);
}
// =======================================================================
-// function : setHighlightColor
+// function : GraphicHighlight
// purpose :
// =======================================================================
-void OpenGl_Structure::setHighlightColor (const Handle(OpenGl_Context)& theGlCtx,
- const Graphic3d_Vec3& theColor)
+void OpenGl_Structure::GraphicHighlight (const Handle(Graphic3d_HighlightStyle)& theStyle,
+ const Handle(Graphic3d_Structure)& theStruct)
{
- clearHighlightBox (theGlCtx);
- if (myHighlightColor == NULL)
+ myHighlightStyle = theStyle;
+
+ highlight = 1;
+ if (myHighlightStyle->Method() == Aspect_TOHM_BOUNDBOX)
{
- myHighlightColor = new TEL_COLOUR();
+ highlightWithBndBox (theStruct);
}
-
- myHighlightColor->rgb[0] = theColor.r();
- myHighlightColor->rgb[1] = theColor.g();
- myHighlightColor->rgb[2] = theColor.b();
- myHighlightColor->rgb[3] = 1.F;
}
// =======================================================================
-// function : clearHighlightColor
+// function : GraphicUnhighlight
// purpose :
// =======================================================================
-void OpenGl_Structure::clearHighlightColor (const Handle(OpenGl_Context)& theGlCtx)
+void OpenGl_Structure::GraphicUnhighlight()
{
- clearHighlightBox(theGlCtx);
- delete myHighlightColor;
- myHighlightColor = NULL;
+ highlight = 0;
+
+ if (myHighlightStyle->Method() == Aspect_TOHM_BOUNDBOX)
+ {
+ const Handle(OpenGl_Context)& aContext = GlDriver()->GetSharedContext();
+ clearHighlightBox (aContext);
+ }
+
+ myHighlightStyle.Nullify();
}
// =======================================================================
// =======================================================================
Standard_Boolean OpenGl_Structure::IsRaytracable() const
{
- if (!myGroups.IsEmpty())
+ if (!myGroups.IsEmpty()
+ && myIsRaytracable)
{
- return myIsRaytracable; // geometry structure
- }
- else if (myInstancedStructure != NULL)
- {
- return myInstancedStructure->IsRaytracable(); // instance structure
+ return Standard_True;
}
- return Standard_False; // has no any groups or structures
+ return myInstancedStructure != NULL
+ && myInstancedStructure->IsRaytracable();
}
// =======================================================================
// =======================================================================
void OpenGl_Structure::UpdateStateIfRaytracable (const Standard_Boolean toCheck) const
{
- myIsRaytracable = !toCheck || OpenGl_Raytrace::IsRaytracedStructure (this);
+ myIsRaytracable = !toCheck;
+ if (!myIsRaytracable)
+ {
+ for (OpenGl_Structure::GroupIterator anIter (myGroups); anIter.More(); anIter.Next())
+ {
+ if (anIter.Value()->IsRaytracable())
+ {
+ myIsRaytracable = Standard_True;
+ break;
+ }
+ }
+ }
if (IsRaytracable())
{
}
// =======================================================================
-// function : RenderGeometry
+// function : renderGeometry
// purpose :
// =======================================================================
-void OpenGl_Structure::RenderGeometry (const Handle(OpenGl_Workspace) &theWorkspace) const
+void OpenGl_Structure::renderGeometry (const Handle(OpenGl_Workspace)& theWorkspace,
+ bool& theHasClosed) const
{
- // Render groups
- const Graphic3d_SequenceOfGroup& aGroups = DrawGroups();
- for (OpenGl_Structure::GroupIterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next())
+ if (myInstancedStructure != NULL)
{
+ myInstancedStructure->renderGeometry (theWorkspace, theHasClosed);
+ }
+
+ for (OpenGl_Structure::GroupIterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
+ {
+ theHasClosed = theHasClosed || aGroupIter.Value()->IsClosed();
aGroupIter.Value()->Render (theWorkspace);
}
}
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
// Render named status
- const Standard_Integer aNamedStatus = theWorkspace->NamedStatus;
- if (highlight)
+ if (highlight && myHighlightBox.IsNull())
+ {
+ theWorkspace->SetHighlight (true);
+ }
+
+ // Apply local transformation
+ aCtx->ModelWorldState.Push();
+ OpenGl_Mat4& aModelWorld = aCtx->ModelWorldState.ChangeCurrent();
+ if (!myTrsf.IsNull())
{
- theWorkspace->NamedStatus |= OPENGL_NS_HIGHLIGHT;
+ myTrsf->Trsf().GetMat4 (aModelWorld);
+ }
+ else
+ {
+ aModelWorld.InitIdentity();
}
- // Do we need to restore GL_NORMALIZE?
const Standard_Boolean anOldGlNormalize = aCtx->IsGlNormalizeEnabled();
- // Apply local transformation
- if (myTransformation)
- {
- OpenGl_Matrix aModelWorld;
- OpenGl_Transposemat3 (&aModelWorld, myTransformation);
- aCtx->ModelWorldState.Push();
- aCtx->ModelWorldState.SetCurrent (OpenGl_Mat4::Map ((Standard_ShortReal* )aModelWorld.mat));
-
- Standard_ShortReal aScaleX = OpenGl_Vec3 (myTransformation->mat[0][0],
- myTransformation->mat[0][1],
- myTransformation->mat[0][2]).SquareModulus();
- // Scale transform detected.
- if (Abs (aScaleX - 1.f) > Precision::Confusion())
+#if !defined(GL_ES_VERSION_2_0)
+ // detect scale transform
+ if (aCtx->core11 != NULL
+ && !myTrsf.IsNull())
+ {
+ const Standard_Real aScale = myTrsf->ScaleFactor();
+ if (Abs (aScale - 1.0) > Precision::Confusion())
{
aCtx->SetGlNormalizeEnabled (Standard_True);
}
}
+#endif
- // Apply transform persistence
- const TEL_TRANSFORM_PERSISTENCE *aTransPersistence = NULL;
- if ( myTransPers && myTransPers->mode != 0 )
+ if (!myTrsfPers.IsNull())
{
- aTransPersistence = theWorkspace->ActiveView()->BeginTransformPersistence (aCtx, myTransPers, theWorkspace->Width(), theWorkspace->Height());
+ OpenGl_Mat4 aWorldView = aCtx->WorldViewState.Current();
+ myTrsfPers->Apply (theWorkspace->View()->Camera(), aCtx->ProjectionState.Current(), aWorldView,
+ aCtx->Viewport()[2], aCtx->Viewport()[3]);
+
+ aCtx->WorldViewState.Push();
+ aCtx->WorldViewState.SetCurrent (aWorldView);
+
+ #if !defined(GL_ES_VERSION_2_0)
+ if (!aCtx->IsGlNormalizeEnabled()
+ && aCtx->core11 != NULL)
+ {
+ const Standard_Real aScale = Graphic3d_TransformUtils::ScaleFactor<Standard_ShortReal> (aWorldView);
+ if (Abs (aScale - 1.0f) > Precision::Confusion())
+ {
+ aCtx->SetGlNormalizeEnabled (Standard_True);
+ }
+ }
+ #endif
}
// Take into account transform persistence
aCtx->ApplyModelViewMatrix();
- // Apply aspects
- const OpenGl_AspectLine *anAspectLine = theWorkspace->AspectLine (Standard_False);
- const OpenGl_AspectFace *anAspectFace = theWorkspace->AspectFace (Standard_False);
- const OpenGl_AspectMarker *anAspectMarker = theWorkspace->AspectMarker (Standard_False);
- const OpenGl_AspectText *anAspectText = theWorkspace->AspectText (Standard_False);
- if (myAspectLine)
- {
- theWorkspace->SetAspectLine (myAspectLine);
- }
- if (myAspectFace)
- {
- theWorkspace->SetAspectFace (myAspectFace);
- }
- if (myAspectMarker)
- {
- theWorkspace->SetAspectMarker (myAspectMarker);
- }
- if (myAspectText)
- {
- theWorkspace->SetAspectText (myAspectText);
- }
+ // remember aspects
+ const OpenGl_AspectLine* aPrevAspectLine = theWorkspace->AspectLine();
+ const OpenGl_AspectFace* aPrevAspectFace = theWorkspace->AspectFace();
+ const OpenGl_AspectMarker* aPrevAspectMarker = theWorkspace->AspectMarker();
+ const OpenGl_AspectText* aPrevAspectText = theWorkspace->AspectText();
// Apply correction for mirror transform
if (myIsMirrored)
}
// Apply highlight color
- const TEL_COLOUR *aHighlightColor = theWorkspace->HighlightColor;
- if (myHighlightColor)
- theWorkspace->HighlightColor = myHighlightColor;
-
- // Render instanced structure (if exists)
- if (myInstancedStructure != NULL)
- {
- myInstancedStructure->RenderGeometry (theWorkspace);
- }
-
- // Set up plane equations for non-structure transformed global model-view matrix
- // List of planes to be applied to context state
- NCollection_Handle<Graphic3d_SequenceOfHClipPlane> aUserPlanes;
+ const OpenGl_Vec4* aHighlightColor = theWorkspace->HighlightColor;
+ if (!myHighlightStyle.IsNull())
+ theWorkspace->HighlightColor = myHighlightStyle->ColorFltPtr();
// Collect clipping planes of structure scope
- if (!myClipPlanes.IsEmpty())
+ aCtx->ChangeClipping().SetLocalPlanes (aCtx, myClipPlanes);
+
+ // True if structure is fully clipped
+ bool isClipped = false;
+ bool hasDisabled = false;
+ if (aCtx->Clipping().IsClippingOrCappingOn())
{
- Graphic3d_SequenceOfHClipPlane::Iterator aClippingIter (myClipPlanes);
- for (; aClippingIter.More(); aClippingIter.Next())
+ const Graphic3d_BndBox4f& aBBox = BoundingBox();
+ if (!myClipPlanes.IsNull()
+ && myClipPlanes->ToOverrideGlobal())
{
- const Handle(Graphic3d_ClipPlane)& aClipPlane = aClippingIter.Value();
- if (!aClipPlane->IsOn())
+ aCtx->ChangeClipping().DisableGlobal (aCtx);
+ hasDisabled = aCtx->Clipping().HasDisabled();
+ }
+ else if (!myTrsfPers.IsNull())
+ {
+ if (myTrsfPers->IsZoomOrRotate())
{
- continue;
+ // Zoom/rotate persistence object lives in two worlds at the same time.
+ // Global clipping planes can not be trivially applied without being converted
+ // into local space of transformation persistence object.
+ // As more simple alternative - just clip entire object by its anchor point defined in the world space.
+ const gp_Pnt anAnchor = myTrsfPers->AnchorPoint();
+ for (OpenGl_ClippingIterator aPlaneIt (aCtx->Clipping()); aPlaneIt.More() && aPlaneIt.IsGlobal(); aPlaneIt.Next())
+ {
+ const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
+ if (!aPlane->IsOn())
+ {
+ continue;
+ }
+
+ // check for clipping
+ const Graphic3d_Vec4d& aPlaneEquation = aPlane->GetEquation();
+ const Graphic3d_Vec4d aCheckPnt (anAnchor.X(), anAnchor.Y(), anAnchor.Z(), 1.0);
+ if (aPlaneEquation.Dot (aCheckPnt) < 0.0) // vertex is outside the half-space
+ {
+ isClipped = true;
+ break;
+ }
+ }
}
- if (aUserPlanes.IsNull())
+ aCtx->ChangeClipping().DisableGlobal (aCtx);
+ hasDisabled = aCtx->Clipping().HasDisabled();
+ }
+
+ // Set of clipping planes that do not intersect the structure,
+ // and thus can be disabled to improve rendering performance
+ if (aBBox.IsValid()
+ && myTrsfPers.IsNull())
+ {
+ for (OpenGl_ClippingIterator aPlaneIt (aCtx->Clipping()); aPlaneIt.More(); aPlaneIt.Next())
{
- aUserPlanes = new Graphic3d_SequenceOfHClipPlane();
+ const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
+ if (!aPlane->IsOn())
+ {
+ continue;
+ }
+
+ // check for clipping
+ const Graphic3d_Vec4d& aPlaneEquation = aPlane->GetEquation();
+ const Graphic3d_Vec4d aMaxPnt (aPlaneEquation.x() > 0.0 ? aBBox.CornerMax().x() : aBBox.CornerMin().x(),
+ aPlaneEquation.y() > 0.0 ? aBBox.CornerMax().y() : aBBox.CornerMin().y(),
+ aPlaneEquation.z() > 0.0 ? aBBox.CornerMax().z() : aBBox.CornerMin().z(),
+ 1.0);
+ if (aPlaneEquation.Dot (aMaxPnt) < 0.0) // max vertex is outside the half-space
+ {
+ isClipped = true;
+ break;
+ }
+
+ // check for no intersection (e.g. object is "entirely not clipped")
+ const Graphic3d_Vec4d aMinPnt (aPlaneEquation.x() > 0.0 ? aBBox.CornerMin().x() : aBBox.CornerMax().x(),
+ aPlaneEquation.y() > 0.0 ? aBBox.CornerMin().y() : aBBox.CornerMax().y(),
+ aPlaneEquation.z() > 0.0 ? aBBox.CornerMin().z() : aBBox.CornerMax().z(),
+ 1.0);
+ if (aPlaneEquation.Dot (aMinPnt) > 0.0) // min vertex is inside the half-space
+ {
+ aCtx->ChangeClipping().SetEnabled (aCtx, aPlaneIt, Standard_False);
+ hasDisabled = true;
+ }
}
-
- aUserPlanes->Append (aClipPlane);
}
- }
-
- if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
- {
- // add planes at loaded view matrix state
- aCtx->ChangeClipping().AddWorld (*aUserPlanes, theWorkspace);
- // Set OCCT state uniform variables
- if (!aCtx->ShaderManager()->IsEmpty())
+ if ((!myClipPlanes.IsNull() && !myClipPlanes->IsEmpty())
+ || hasDisabled)
{
+ // Set OCCT state uniform variables
aCtx->ShaderManager()->UpdateClippingState();
}
}
// Render groups
- const Graphic3d_SequenceOfGroup& aGroups = DrawGroups();
- for (OpenGl_Structure::GroupIterator aGroupIter (aGroups); aGroupIter.More(); aGroupIter.Next())
+ bool hasClosedPrims = false;
+ if (!isClipped)
{
- aGroupIter.Value()->Render (theWorkspace);
+ renderGeometry (theWorkspace, hasClosedPrims);
}
// Reset correction for mirror transform
}
// Render capping for structure groups
- if (!aCtx->Clipping().Planes().IsEmpty())
+ if (hasClosedPrims
+ && aCtx->Clipping().IsCappingOn())
{
- OpenGl_CappingAlgo::RenderCapping (theWorkspace, aGroups);
+ OpenGl_CappingAlgo::RenderCapping (theWorkspace, *this);
}
// Revert structure clippings
- if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
+ if (hasDisabled)
+ {
+ // enable planes that were previously disabled
+ aCtx->ChangeClipping().RestoreDisabled (aCtx);
+ }
+ aCtx->ChangeClipping().SetLocalPlanes (aCtx, Handle(Graphic3d_SequenceOfHClipPlane)());
+ if ((!myClipPlanes.IsNull() && !myClipPlanes->IsEmpty())
+ || hasDisabled)
{
- aCtx->ChangeClipping().Remove (*aUserPlanes);
-
// Set OCCT state uniform variables
- if (!aCtx->ShaderManager()->IsEmpty())
- {
- aCtx->ShaderManager()->RevertClippingState();
- }
+ aCtx->ShaderManager()->RevertClippingState();
}
- // Apply local transformation
- if (myTransformation)
+ // Restore local transformation
+ aCtx->ModelWorldState.Pop();
+ aCtx->SetGlNormalizeEnabled (anOldGlNormalize);
+ if (!myTrsfPers.IsNull())
{
- aCtx->ModelWorldState.Pop();
- aCtx->SetGlNormalizeEnabled (anOldGlNormalize);
+ aCtx->WorldViewState.Pop();
}
// Restore highlight color
theWorkspace->HighlightColor = aHighlightColor;
// Restore aspects
- theWorkspace->SetAspectLine (anAspectLine);
- theWorkspace->SetAspectFace (anAspectFace);
- theWorkspace->SetAspectMarker (anAspectMarker);
- theWorkspace->SetAspectText (anAspectText);
-
- // Restore transform persistence
- if ( myTransPers && myTransPers->mode != 0 )
- {
- theWorkspace->ActiveView()->BeginTransformPersistence (aCtx, aTransPersistence, theWorkspace->Width(), theWorkspace->Height());
- }
+ theWorkspace->SetAspectLine (aPrevAspectLine);
+ theWorkspace->SetAspectFace (aPrevAspectFace);
+ theWorkspace->SetAspectMarker (aPrevAspectMarker);
+ theWorkspace->SetAspectText (aPrevAspectText);
// Apply highlight box
if (!myHighlightBox.IsNull())
}
// Restore named status
- theWorkspace->NamedStatus = aNamedStatus;
+ theWorkspace->SetHighlight (false);
}
// =======================================================================
{
// Release groups
Clear (theGlCtx);
- OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectLine);
- OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectFace);
- OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectMarker);
- OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectText);
- clearHighlightColor (theGlCtx);
+ clearHighlightBox (theGlCtx);
+ myHighlightStyle.Nullify();
}
// =======================================================================
{
aGroupIter.ChangeValue()->Release (theGlCtx);
}
- if (myAspectLine != NULL)
- {
- myAspectLine->Release (theGlCtx.operator->());
- }
- if (myAspectFace != NULL)
- {
- myAspectFace->Release (theGlCtx.operator->());
- }
- if (myAspectMarker != NULL)
- {
- myAspectMarker->Release (theGlCtx.operator->());
- }
- if (myAspectText != NULL)
- {
- myAspectText->Release (theGlCtx.operator->());
- }
if (!myHighlightBox.IsNull())
{
myHighlightBox->Release (theGlCtx.operator->());