#include <Image_PixMap.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_AspectFace, OpenGl_Element)
+
namespace
{
//! Initialize default material in this way for backward compatibility.
THE_DEFAULT_MATERIAL, THE_DEFAULT_MATERIAL)),
myShadingModel (Graphic3d_TOSM_UNLIT)
{
+ myAspectEdge = new OpenGl_AspectLine();
myAspect->SetShadingModel (myShadingModel);
myAspect->SetHatchStyle (Handle(Graphic3d_HatchStyle)());
}
OpenGl_AspectFace::OpenGl_AspectFace (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
: myShadingModel (Graphic3d_TOSM_DEFAULT)
{
+ myAspectEdge = new OpenGl_AspectLine();
+
SetAspect (theAspect);
}
? theAspect->ShadingModel()
: Graphic3d_TOSM_UNLIT;
- myAspectEdge.Aspect()->SetColor (theAspect->EdgeColor());
- myAspectEdge.Aspect()->SetType (theAspect->EdgeLineType());
- myAspectEdge.Aspect()->SetWidth (theAspect->EdgeWidth());
+ myAspectEdge->Aspect()->SetColor (theAspect->EdgeColor());
+ myAspectEdge->Aspect()->SetType (theAspect->EdgeLineType());
+ myAspectEdge->Aspect()->SetWidth (theAspect->EdgeWidth());
// update texture binding
myResources.UpdateTexturesRediness (myAspect->TextureSet());
//! The element holding Graphic3d_AspectFillArea3d.
class OpenGl_AspectFace : public OpenGl_Element
{
-
+ DEFINE_STANDARD_RTTIEXT(OpenGl_AspectFace, OpenGl_Element)
public:
//! Empty constructor.
Standard_EXPORT void SetAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect);
//! Set edge aspect.
- void SetAspectEdge (const OpenGl_AspectLine* theAspectEdge) { myAspectEdge = *theAspectEdge; }
+ void SetAspectEdge (const Handle(OpenGl_AspectLine)& theAspectEdge) { myAspectEdge = theAspectEdge; }
//! @return edge aspect.
- const OpenGl_AspectLine* AspectEdge() const { return &myAspectEdge; }
+ const Handle(OpenGl_AspectLine)& AspectEdge() const { return myAspectEdge; }
//! Returns Shading Model.
Graphic3d_TypeOfShadingModel ShadingModel() const { return myShadingModel; }
} myResources;
Handle(Graphic3d_AspectFillArea3d) myAspect;
- OpenGl_AspectLine myAspectEdge;
+ Handle(OpenGl_AspectLine) myAspectEdge;
Graphic3d_TypeOfShadingModel myShadingModel;
public:
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_Workspace.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_AspectLine, OpenGl_Element)
+
namespace
{
static const TCollection_AsciiString THE_EMPTY_KEY;
//! The element holding Graphic3d_AspectLine3d.
class OpenGl_AspectLine : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_AspectLine, OpenGl_Element)
public:
//! Empty constructor.
#include <NCollection_Vec4.hxx>
#include <TColStd_HArray1OfByte.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_AspectMarker, OpenGl_Element)
+
namespace
{
static const TCollection_AsciiString THE_EMPTY_KEY;
//! The element holding Graphic3d_AspectMarker3d.
class OpenGl_AspectMarker : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_AspectMarker, OpenGl_Element)
public:
//! Empty constructor.
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_ShaderProgram.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_AspectText, OpenGl_Element)
+
namespace
{
static const TCollection_AsciiString THE_EMPTY_KEY;
//! Text representation parameters
class OpenGl_AspectText : public OpenGl_Element
{
-
+ DEFINE_STANDARD_RTTIEXT(OpenGl_AspectText, OpenGl_Element)
public:
//! Empty constructor.
#include <OpenGl_View.hxx>
#include <Graphic3d_TextureParams.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_BackgroundArray, OpenGl_PrimitiveArray)
+
// =======================================================================
// method : Constructor
// purpose :
// Get texture parameters
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
- const OpenGl_AspectFace* anAspectFace = theWorkspace->AspectFace();
+ const Handle(OpenGl_AspectFace)& anAspectFace = theWorkspace->AspectFace();
GLfloat aTextureWidth = (GLfloat )anAspectFace->TextureSet (aCtx)->First()->SizeX();
GLfloat aTextureHeight = (GLfloat )anAspectFace->TextureSet (aCtx)->First()->SizeY();
//! gradient or texture background rendering.
class OpenGl_BackgroundArray : public OpenGl_PrimitiveArray
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_BackgroundArray, OpenGl_PrimitiveArray)
public:
//! Main constructor.
class OpenGl_SharedElement : public OpenGl_Resource
{
public:
- OpenGl_SharedElement (OpenGl_Element* theGlElement) : myGlElement (theGlElement) {}
+ OpenGl_SharedElement (Handle(OpenGl_Element) theGlElement) : myGlElement (theGlElement) {}
virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE
{
OpenGl_Element::Destroy (theGlCtx, myGlElement);
}
- OpenGl_Element* GlElement() const { return myGlElement; }
+ Handle(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;
+ Handle(OpenGl_Element) myGlElement;
public:
};
//! Iitializes and returns vertex buffer for plane section
- OpenGl_PrimitiveArray* initQuad (const Handle(OpenGl_Context)& theContext)
+ Handle(OpenGl_PrimitiveArray) initQuad (const Handle(OpenGl_Context)& theContext)
{
Handle(OpenGl_SharedElement) aSharedResource;
theContext->ShareResource (THE_QUAD_PARRAY, aSharedResource);
}
- return dynamic_cast<OpenGl_PrimitiveArray*> (aSharedResource->GlElement());
+ return Handle(OpenGl_PrimitiveArray)::DownCast (aSharedResource->GlElement());
}
//! Render section plane using the given aspects.
void renderSection (const Handle(OpenGl_Workspace)& theWorkspace,
- const OpenGl_PrimitiveArray* theQuad,
- const OpenGl_AspectFace* theCappingAspect,
- const OpenGl_AspectFace* theHatchAspect,
+ const Handle(OpenGl_PrimitiveArray)& theQuad,
+ const Handle(OpenGl_AspectFace)& theCappingAspect,
+ const Handle(OpenGl_AspectFace)& theHatchAspect,
const OpenGl_Mat4& theCappingMatrix,
const Standard_ShortReal theHatchScale,
const Standard_ShortReal theHatchRotate)
const bool wasCullAllowed = theWorkspace->SetAllowFaceCulling (true);
const Standard_Boolean isTextureHatch =
- theHatchAspect != NULL
+ !theHatchAspect.IsNull()
&& theHatchAspect->Aspect()->TextureMapState();
aContext->ModelWorldState.Push();
theQuad->Render (theWorkspace);
- if (theHatchAspect != NULL)
+ if (!theHatchAspect.IsNull())
{
Graphic3d_Vec2 aPrevScale;
Standard_ShortReal aPrevRotate = 0.0;
const Handle(Graphic3d_ClipPlane)& theClipChain,
const Standard_Integer theSubPlaneIndex,
const Handle(OpenGl_CappingPlaneResource)& thePlane,
- const OpenGl_PrimitiveArray* theQuad)
+ const Handle(OpenGl_PrimitiveArray) theQuad)
{
const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
const Standard_Integer anAnyFilter = aPrevFilter & ~(Standard_Integer )(OpenGl_RenderFilter_OpaqueOnly | OpenGl_RenderFilter_TransparentOnly);
glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// override aspects, disable culling
- theWorkspace->SetAspectFace (&theWorkspace->NoneCulling());
+ theWorkspace->SetAspectFace (theWorkspace->NoneCulling());
theWorkspace->ApplyAspectFace();
// evaluate number of pair faces
aGroupIter.Value()->Render (theWorkspace);
// override material, cull back faces
- theWorkspace->SetAspectFace (&theWorkspace->FrontCulling());
+ theWorkspace->SetAspectFace (theWorkspace->FrontCulling());
theWorkspace->ApplyAspectFace();
// enable all clip plane except the rendered one
glEnable (GL_DEPTH_TEST);
}
- const OpenGl_AspectFace* aGroupAspectFace = aGroupIter.Value()->AspectFace();
+ const Handle(OpenGl_AspectFace)& aGroupAspectFace = aGroupIter.Value()->AspectFace();
const OpenGl_CappingPlaneResource* aGroupAspectCapping = aGroupIter.Value()->AspectFillCapping();
const OpenGl_CappingPlaneResource* anAspectCapping =
thePlane && (!aGroupAspectCapping || aGroupAspectCapping->Aspect().IsNull() || aPlane->ToOverrideCappingAspect())
anAspectCapping = &THE_DEFAULT_ASPECT;
}
- const OpenGl_AspectFace* anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
+ Handle(OpenGl_AspectFace) anAspectFace = anAspectCapping->CappingFaceAspect (aGroupAspectFace);
const Standard_Boolean hasHatch = anAspectCapping->Aspect()->ToDrawHatch();
- const OpenGl_AspectFace* anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
+ const Handle(OpenGl_AspectFace)& anAspectHatching = hasHatch ? anAspectCapping->HatchingFaceAspect() : NULL;
const Standard_Boolean hasTextureHatch = hasHatch && !anAspectCapping->Aspect()->TextureHatch().IsNull();
const Standard_Boolean isRotatePers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchRotationPersistent();
const Standard_Boolean isZoomPers = hasTextureHatch && !aCamera.IsNull() && anAspectCapping->Aspect()->IsHatchZoomPersistent();
return;
}
- const OpenGl_PrimitiveArray* aCappingQuad = initQuad (aContext);
- if (!aCappingQuad)
+ Handle(OpenGl_PrimitiveArray) aCappingQuad = initQuad (aContext);
+ if (aCappingQuad.IsNull())
{
return;
}
// remember current aspect face defined in workspace
- const OpenGl_AspectFace* aFaceAsp = theWorkspace->AspectFace();
+ const Handle(OpenGl_AspectFace)& aFaceAsp = theWorkspace->AspectFace();
// only filled primitives should be rendered
const Standard_Integer aPrevFilter = theWorkspace->RenderFilter();
// function : BuildInfinitPlaneVertices
// purpose :
// =======================================================================
-OpenGl_PrimitiveArray* OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
+Handle(OpenGl_PrimitiveArray) OpenGl_CappingPlaneResource::BuildInfinitPlaneVertices()
{
- OpenGl_PrimitiveArray* aPrimitives = NULL;
+ Handle(OpenGl_PrimitiveArray) aPrimitives;
// Fill primitive array
Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (anAlloc);
// purpose :
// =======================================================================
OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_AspectFillCapping)& theAspect)
-: myCappingAspect (defaultMaterial()),
- myHatchingAspect (defaultMaterial()),
+: myCappingAspect (new OpenGl_AspectFace (defaultMaterial())),
+ myHatchingAspect (new OpenGl_AspectFace (defaultMaterial())),
myHatchingState (0)
{
SetAspect (theAspect);
|| !theAspect->ToUseObjectTexture()
|| !theAspect->ToUseObjectShader())
{
- Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect.Aspect();
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect->Aspect();
if (!theAspect->ToUseObjectMaterial())
{
aFillAspect->SetShaderProgram (theAspect->Shader());
}
- myCappingAspect.SetAspect (aFillAspect);
+ myCappingAspect->SetAspect (aFillAspect);
}
if (theAspect->ToDrawHatch()
&& (theAspect->IsTextureHatch()
|| theAspect->IsStippleHatch()))
{
- Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect.Aspect();
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect->Aspect();
aFillAspect->SetInteriorStyle (theAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
aFillAspect->SetHatchStyle (theAspect->IsStippleHatch() ? theAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
aFillAspect->SetTextureMapOff();
}
- myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingAspect->SetAspect (aFillAspect);
myHatchingState = theAspect->HatchingState();
}
}
// =======================================================================
void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
{
- myCappingAspect .Release (theContext);
- myHatchingAspect.Release (theContext);
+ myCappingAspect->Release (theContext);
+ myHatchingAspect->Release (theContext);
}
// =======================================================================
// function : CappingFaceAspect
// purpose :
// =======================================================================
-const OpenGl_AspectFace* OpenGl_CappingPlaneResource::CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const
+Handle(OpenGl_AspectFace) OpenGl_CappingPlaneResource::CappingFaceAspect (const Handle(OpenGl_AspectFace)& theObjectAspect) const
{
if (myAspect.IsNull())
{
return NULL;
}
- Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect.Aspect();
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myCappingAspect->Aspect();
- if (myAspect->ToUseObjectMaterial() && theObjectAspect != NULL)
+ if (myAspect->ToUseObjectMaterial() && !theObjectAspect.IsNull())
{
// only front material currently supported by capping rendering
aFillAspect->SetFrontMaterial (theObjectAspect->Aspect()->FrontMaterial());
aFillAspect->SetInteriorColor (myAspect->Material().Color());
}
- if (myAspect->ToUseObjectTexture() && theObjectAspect != NULL)
+ if (myAspect->ToUseObjectTexture() && !theObjectAspect.IsNull())
{
if (theObjectAspect->Aspect()->ToMapTexture())
{
}
}
- if (myAspect->ToUseObjectShader() && theObjectAspect != NULL)
+ if (myAspect->ToUseObjectShader() && !theObjectAspect.IsNull())
{
aFillAspect->SetShaderProgram (theObjectAspect->Aspect()->ShaderProgram());
}
aFillAspect->SetShaderProgram (myAspect->Shader());
}
- myCappingAspect.SetAspect (aFillAspect);
+ myCappingAspect->SetAspect (aFillAspect);
- return &myCappingAspect;
+ return myCappingAspect;
}
// =======================================================================
// function : HatchingFaceAspect
// purpose :
// =======================================================================
-const OpenGl_AspectFace* OpenGl_CappingPlaneResource::HatchingFaceAspect() const
+Handle(OpenGl_AspectFace) OpenGl_CappingPlaneResource::HatchingFaceAspect() const
{
if (myAspect.IsNull())
{
{
if (myAspect->ToDrawHatch())
{
- Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect.Aspect();
+ Handle(Graphic3d_AspectFillArea3d) aFillAspect = myHatchingAspect->Aspect();
aFillAspect->SetInteriorStyle (myAspect->IsStippleHatch() ? Aspect_IS_HATCH : Aspect_IS_SOLID);
aFillAspect->SetHatchStyle (myAspect->IsStippleHatch() ? myAspect->StippleHatch() : Handle(Graphic3d_HatchStyle)());
aFillAspect->SetTextureMapOff();
}
- myHatchingAspect.SetAspect (aFillAspect);
+ myHatchingAspect->SetAspect (aFillAspect);
myHatchingState = aHatchingState;
}
}
- return &myHatchingAspect;
+ return myHatchingAspect;
}
virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE { return 0; }
//! @return primitive array of vertices to render infinite plane.
- static OpenGl_PrimitiveArray* BuildInfinitPlaneVertices();
+ static Handle(OpenGl_PrimitiveArray) BuildInfinitPlaneVertices();
//! Returns true if capping should draw hatch layer.
Standard_Boolean ToDrawHatch() const
//! Returns the shading aspect for drawing face of a clipping section itself.
//! @param theObjectAspect [in] the aspect of an object if it requires combining.
- Standard_EXPORT const OpenGl_AspectFace* CappingFaceAspect (const OpenGl_AspectFace* theObjectAspect) const;
+ Standard_EXPORT Handle(OpenGl_AspectFace) CappingFaceAspect (const Handle(OpenGl_AspectFace)& theObjectAspect) const;
//! Returns the shading aspect for drawing hatch layer of a section.
- Standard_EXPORT const OpenGl_AspectFace* HatchingFaceAspect() const;
+ Standard_EXPORT Handle(OpenGl_AspectFace) HatchingFaceAspect() const;
private:
private:
Handle(Graphic3d_AspectFillCapping) myAspect; //!< Section style settings from application's level.
- mutable OpenGl_AspectFace myCappingAspect; //!< GL aspect for shading base layer of a capping section.
- mutable OpenGl_AspectFace myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
+ mutable Handle(OpenGl_AspectFace) myCappingAspect; //!< GL aspect for shading base layer of a capping section.
+ mutable Handle(OpenGl_AspectFace) myHatchingAspect; //!< GL aspect for shading hatching layer (additional to base) of a capping section.
mutable Standard_Size myHatchingState;
public:
// function : SetShadingMaterial
// purpose :
// =======================================================================
-void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect,
+void OpenGl_Context::SetShadingMaterial (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(Graphic3d_PresentationAttributes)& theHighlight)
{
const Handle(Graphic3d_AspectFillArea3d)& anAspect = (!theHighlight.IsNull() && !theHighlight->BasicFillAreaAspect().IsNull())
// function : CheckIsTransparent
// purpose :
// =======================================================================
-Standard_Boolean OpenGl_Context::CheckIsTransparent (const OpenGl_AspectFace* theAspect,
+Standard_Boolean OpenGl_Context::CheckIsTransparent (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(Graphic3d_PresentationAttributes)& theHighlight,
Standard_ShortReal& theAlphaFront,
Standard_ShortReal& theAlphaBack)
Standard_EXPORT Standard_Boolean BindProgram (const Handle(OpenGl_ShaderProgram)& theProgram);
//! Setup current shading material.
- Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect,
+ Standard_EXPORT void SetShadingMaterial (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(Graphic3d_PresentationAttributes)& theHighlight);
//! Checks if transparency is required for the given aspect and highlight style.
- Standard_EXPORT static Standard_Boolean CheckIsTransparent (const OpenGl_AspectFace* theAspect,
+ Standard_EXPORT static Standard_Boolean CheckIsTransparent (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(Graphic3d_PresentationAttributes)& theHighlight,
Standard_ShortReal& theAlphaFront,
Standard_ShortReal& theAlphaBack);
//! Checks if transparency is required for the given aspect and highlight style.
- static Standard_Boolean CheckIsTransparent (const OpenGl_AspectFace* theAspect,
+ static Standard_Boolean CheckIsTransparent (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(Graphic3d_PresentationAttributes)& theHighlight)
{
Standard_ShortReal anAlphaFront = 1.0f, anAlphaBack = 1.0f;
#include <OpenGl_Element.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Element, Standard_Transient)
+
// =======================================================================
// function : OpenGl_Element
// purpose :
class OpenGl_Context;
//! Base interface for drawable elements.
-class OpenGl_Element
+class OpenGl_Element : public Standard_Transient
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_Element, Standard_Transient)
public:
Standard_EXPORT OpenGl_Element();
//! Pointer to the context is used because this method might be called
//! when the context is already being destroyed and usage of a handle
//! would be unsafe
- template <typename theResource_t>
static void Destroy (OpenGl_Context* theContext,
- theResource_t*& theElement)
+ Handle(OpenGl_Element)& theElement)
{
- if (theElement == NULL)
+ if (theElement.IsNull())
{
return;
}
-
theElement->Release (theContext);
- OpenGl_Element* anElement = theElement;
- delete anElement;
theElement = NULL;
}
#include <gp_Ax2.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Flipper, OpenGl_Element)
+
// =======================================================================
// function : Constructor
// purpose :
//! Originally, this element serves for need of flipping the 3D text of dimension presentations.
class OpenGl_Flipper : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_Flipper, OpenGl_Element)
public:
//! Construct rendering element to flip model-view matrix
for (OpenGl_Structure::GroupIterator aGroupIter (aStruct->Groups()); aGroupIter.More(); aGroupIter.Next())
{
const OpenGl_Group* aGroup = aGroupIter.Value();
- for (const OpenGl_ElementNode* aNodeIter = aGroup->FirstNode(); aNodeIter != NULL; aNodeIter = aNodeIter->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator (aGroup->GetElements()); anElemIterator.More(); anElemIterator.Next())
{
- if (const OpenGl_PrimitiveArray* aPrim = dynamic_cast<const OpenGl_PrimitiveArray*> (aNodeIter->elem))
+ Handle(OpenGl_PrimitiveArray) aPrim = Handle(OpenGl_PrimitiveArray)::DownCast (anElemIterator.Value());
+ if (!aPrim.IsNull())
{
myCountersTmp[Graphic3d_FrameStatsCounter_EstimatedBytesGeom] += estimatedDataSize (aPrim->AttributesVbo());
myCountersTmp[Graphic3d_FrameStatsCounter_EstimatedBytesGeom] += estimatedDataSize (aPrim->IndexVbo());
for (OpenGl_Structure::GroupIterator aGroupIter (aStruct->Groups()); aGroupIter.More(); aGroupIter.Next())
{
const OpenGl_Group* aGroup = aGroupIter.Value();
- for (const OpenGl_ElementNode* aNodeIter = aGroup->FirstNode(); aNodeIter != NULL; aNodeIter = aNodeIter->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator (aGroup->GetElements()); anElemIterator.More(); anElemIterator.Next())
{
- if (const OpenGl_PrimitiveArray* aPrim = dynamic_cast<const OpenGl_PrimitiveArray*> (aNodeIter->elem))
+ Handle(OpenGl_PrimitiveArray) aPrim = Handle(OpenGl_PrimitiveArray)::DownCast (anElemIterator.Value());
+ if (!aPrim.IsNull())
{
++myCountersTmp[Graphic3d_FrameStatsCounter_NbElemsNotCulled];
if (theToCountMem)
++myCountersTmp[Graphic3d_FrameStatsCounter_NbElemsLineNotCulled];
}
}
- else if (const OpenGl_Text* aText = dynamic_cast<const OpenGl_Text*> (aNodeIter->elem))
+ else if (!Handle(OpenGl_Text)::DownCast(anElemIterator.Value()).IsNull())
{
- (void )aText;
++myCountersTmp[Graphic3d_FrameStatsCounter_NbElemsNotCulled];
++myCountersTmp[Graphic3d_FrameStatsCounter_NbElemsTextNotCulled];
}
#include <Graphic3d_ArrayOfTriangles.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_FrameStatsPrs, OpenGl_Element)
+
namespace
{
//! Auxiliary structure defining vertex with two attributes.
myChartIndices (new OpenGl_IndexBuffer()),
myChartLines (new OpenGl_VertexBuffer())
{
- //
+ myCountersText = new OpenGl_Text();
+ myTextAspect = new OpenGl_AspectText();
+ myChartLabels[0] = new OpenGl_Text();
+ myChartLabels[1] = new OpenGl_Text();
+ myChartLabels[2] = new OpenGl_Text();
}
// =======================================================================
// =======================================================================
void OpenGl_FrameStatsPrs::Release (OpenGl_Context* theCtx)
{
- myCountersText.Release (theCtx);
- myChartLabels[0].Release (theCtx);
- myChartLabels[1].Release (theCtx);
- myChartLabels[2].Release (theCtx);
+ myCountersText->Release (theCtx);
+ myChartLabels[0]->Release (theCtx);
+ myChartLabels[1]->Release (theCtx);
+ myChartLabels[2]->Release (theCtx);
myChartVertices->Release (theCtx);
myChartIndices->Release (theCtx);
myChartLines->Release (theCtx);
const Graphic3d_RenderingParams& aRendParams = theWorkspace->View()->RenderingParams();
myCountersTrsfPers = theWorkspace->View()->RenderingParams().StatsPosition;
myChartTrsfPers = theWorkspace->View()->RenderingParams().ChartPosition;
- myTextAspect.SetAspect (aRendParams.StatsTextAspect);
+ myTextAspect->SetAspect (aRendParams.StatsTextAspect);
// adjust text alignment depending on corner
OpenGl_TextParam aParams;
{
aParams.VAlign = Graphic3d_VTA_BOTTOM;
}
- if (aParams.Height != myCountersText.FormatParams().Height
- || aParams.HAlign != myCountersText.FormatParams().HAlign
- || aParams.VAlign != myCountersText.FormatParams().VAlign)
+ if (aParams.Height != myCountersText->FormatParams().Height
+ || aParams.HAlign != myCountersText->FormatParams().HAlign
+ || aParams.VAlign != myCountersText->FormatParams().VAlign)
{
- myCountersText.Release (aCtx.operator->());
+ myCountersText->Release (aCtx.operator->());
}
if (!aStats->IsFrameUpdated (myStatsPrev)
- && !myCountersText.Text().IsEmpty())
+ && !myCountersText->Text().IsEmpty())
{
return;
}
TCollection_AsciiString aText = aStats->FormatStats (aRendParams.CollectedStats);
- myCountersText.Init (aCtx, aText.ToCString(), OpenGl_Vec3 (0.0f, 0.0f, 0.0f), aParams);
+ myCountersText->Init (aCtx, aText.ToCString(), OpenGl_Vec3 (0.0f, 0.0f, 0.0f), aParams);
updateChart (theWorkspace);
}
const float aLabX = aParams.HAlign == Graphic3d_HTA_RIGHT
? float(anOffset.x())
: float(anOffset.x() + aCharSize.x());
- myChartLabels[0].Init (aCtx, aLabels[isTopDown ? 0 : 2].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y()), 0.0f), aParams);
- myChartLabels[1].Init (aCtx, aLabels[isTopDown ? 1 : 1].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y() - aBinSize.y() / 2), 0.0f), aParams);
- myChartLabels[2].Init (aCtx, aLabels[isTopDown ? 2 : 0].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y() - aBinSize.y()), 0.0f), aParams);
+ myChartLabels[0]->Init (aCtx, aLabels[isTopDown ? 0 : 2].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y()), 0.0f), aParams);
+ myChartLabels[1]->Init (aCtx, aLabels[isTopDown ? 1 : 1].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y() - aBinSize.y() / 2), 0.0f), aParams);
+ myChartLabels[2]->Init (aCtx, aLabels[isTopDown ? 2 : 0].ToCString(), OpenGl_Vec3 (aLabX, float(anOffset.y() - aBinSize.y()), 0.0f), aParams);
}
}
glDepthMask (GL_FALSE);
}
- const OpenGl_AspectText* aTextAspectBack = theWorkspace->SetAspectText (&myTextAspect);
+ const Handle(OpenGl_AspectText)& aTextAspectBack = theWorkspace->AspectText();
+ theWorkspace->SetAspectText (myTextAspect);
aCtx->ModelWorldState.Push();
aCtx->ModelWorldState.ChangeCurrent().InitIdentity();
aCtx->VirtualViewport()[2], aCtx->VirtualViewport()[3]);
}
aCtx->ApplyModelViewMatrix();
- myCountersText.Render (theWorkspace);
+ myCountersText->Render (theWorkspace);
aCtx->WorldViewState.Pop();
}
myChartLines->unbindAttribute (aCtx, Graphic3d_TOA_COLOR);
myChartLines->unbindAttribute (aCtx, Graphic3d_TOA_POS);
- myChartLabels[0].Render (theWorkspace);
- myChartLabels[1].Render (theWorkspace);
- myChartLabels[2].Render (theWorkspace);
+ myChartLabels[0]->Render (theWorkspace);
+ myChartLabels[1]->Render (theWorkspace);
+ myChartLabels[2]->Render (theWorkspace);
aCtx->WorldViewState.Pop();
}
//! Element rendering frame statistics.
class OpenGl_FrameStatsPrs : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_FrameStatsPrs, OpenGl_Element)
public:
//! Default constructor.
Standard_EXPORT void Update (const Handle(OpenGl_Workspace)& theWorkspace);
//! Assign text aspect.
- void SetTextAspect (const Handle(Graphic3d_AspectText3d)& theAspect) { myTextAspect.SetAspect (theAspect); }
+ void SetTextAspect (const Handle(Graphic3d_AspectText3d)& theAspect) { myTextAspect->SetAspect (theAspect); }
protected:
Handle(OpenGl_FrameStats) myStatsPrev; //!< currently displayed stats
Handle(Graphic3d_TransformPers) myCountersTrsfPers; //!< transformation persistence for counters presentation
- OpenGl_Text myCountersText; //!< counters presentation
- OpenGl_AspectText myTextAspect; //!< text aspect
+ Handle(OpenGl_Text) myCountersText; //!< counters presentation
+ Handle(OpenGl_AspectText) myTextAspect; //!< text aspect
Handle(Graphic3d_TransformPers) myChartTrsfPers; //!< transformation persistence for chart presentation
Handle(Graphic3d_ArrayOfTriangles) myChartArray; //!< array of chart triangles
Handle(OpenGl_VertexBuffer) myChartVertices; //!< VBO with chart triangles
Handle(OpenGl_IndexBuffer) myChartIndices; //!< VBO with chart triangle indexes
Handle(OpenGl_VertexBuffer) myChartLines; //!< array of chart lines
- OpenGl_Text myChartLabels[3]; //!< chart labels
+ Handle(OpenGl_Text) myChartLabels[3]; //!< chart labels
};
#include <string.h>
#endif
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_GraduatedTrihedron, OpenGl_Element)
+
namespace
{
static const OpenGl_TextParam THE_LABEL_PARAMS =
myMax (100.0f, 100.0f, 100.0f),
myIsInitialized (Standard_False)
{
- //
+ myGridLineAspect = new OpenGl_AspectLine();
+
+ myLabelValues = new OpenGl_Text();
+ myAspectLabels = new OpenGl_AspectText();
+ myAspectValues = new OpenGl_AspectText();
}
// =======================================================================
myAxes[0].Release (theCtx);
myAxes[1].Release (theCtx);
myAxes[2].Release (theCtx);
- myLabelValues.Release (theCtx);
+ myLabelValues->Release (theCtx);
}
// =======================================================================
myAxes[0].Release (theCtx.operator->());
myAxes[1].Release (theCtx.operator->());
myAxes[2].Release (theCtx.operator->());
- myLabelValues.Release (theCtx.operator->());
+ myLabelValues->Release (theCtx.operator->());
// Initialize text label parameters for x, y, and z axes
myAxes[0] = Axis (myData.XAxisAspect(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
myAxes[2].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
{
- myAxes[anIt].Label.SetFontSize (theCtx, myData.NamesSize());
+ myAxes[anIt].Label->SetFontSize (theCtx, myData.NamesSize());
}
- myLabelValues.SetFontSize (theCtx, myData.ValuesSize());
+ myLabelValues->SetFontSize (theCtx, myData.ValuesSize());
- myAspectLabels.Aspect()->SetTextFontAspect (myData.NamesFontAspect());
- myAspectLabels.Aspect()->SetFont (myData.NamesFont());
+ myAspectLabels->Aspect()->SetTextFontAspect (myData.NamesFontAspect());
+ myAspectLabels->Aspect()->SetFont (myData.NamesFont());
- myAspectValues.Aspect()->SetTextFontAspect (myData.ValuesFontAspect());
- myAspectValues.Aspect()->SetFont (myData.ValuesFont());
+ myAspectValues->Aspect()->SetTextFontAspect (myData.ValuesFontAspect());
+ myAspectValues->Aspect()->SetFont (myData.ValuesFont());
// Grid aspect
- myGridLineAspect.Aspect()->SetColor (myData.GridColor());
+ myGridLineAspect->Aspect()->SetColor (myData.GridColor());
}
// =======================================================================
// function : renderLine
// purpose :
// =======================================================================
-void OpenGl_GraduatedTrihedron::renderLine (const OpenGl_PrimitiveArray& theLine,
+void OpenGl_GraduatedTrihedron::renderLine (const Handle(OpenGl_PrimitiveArray)& theLine,
const Handle(OpenGl_Workspace)& theWorkspace,
const OpenGl_Mat4& theMat,
const Standard_ShortReal theXt,
Graphic3d_TransformUtils::Translate (aMat, theXt, theYt, theZt);
aContext->WorldViewState.SetCurrent (aMat);
aContext->ApplyWorldViewMatrix();
- theLine.Render (theWorkspace);
+ theLine->Render (theWorkspace);
}
// =======================================================================
Graphic3d_TransformUtils::Translate (aMat, aStepVec.x(), aStepVec.y(), aStepVec.z());
aContext->WorldViewState.SetCurrent (aMat);
aContext->ApplyWorldViewMatrix();
- anAxis.Line.Render (theWorkspace);
+ anAxis.Line->Render (theWorkspace);
}
}
}
{
const Axis& anAxis = myAxes[theIndex];
- theWorkspace->SetAspectLine (&anAxis.LineAspect);
+ theWorkspace->SetAspectLine (anAxis.LineAspect);
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
// Reset transformations
aContext->ModelWorldState.SetCurrent (aTransMode.Compute (theWorkspace->View()->Camera(), aProjection, aWorldView, aWidth, aHeight));
aContext->ApplyModelViewMatrix();
- anAxis.Arrow.Render (theWorkspace);
+ anAxis.Arrow->Render (theWorkspace);
// Get current Model-View and Projection states
OpenGl_Mat4 aModelMat;
aContext->WorldViewState.SetCurrent (aModelMat);
aContext->ApplyWorldViewMatrix();
- anAxis.Line.Render (theWorkspace);
+ anAxis.Line->Render (theWorkspace);
}
// =======================================================================
if (aCurAspect.ToDrawTickmarks() && aCurAspect.TickmarksNumber() > 0)
{
- theWorkspace->SetAspectLine (&myGridLineAspect);
+ theWorkspace->SetAspectLine (myGridLineAspect);
OpenGl_Mat4 aModelMat (theMat);
OpenGl_Vec3 aStepVec = anAxis.Direction * aStep;
for (Standard_Integer anIter = 0; anIter <= aCurAspect.TickmarksNumber(); ++anIter)
{
- anAxis.Tickmark.Render (theWorkspace);
+ anAxis.Tickmark->Render (theWorkspace);
Graphic3d_TransformUtils::Translate (aModelMat, aStepVec.x(), aStepVec.y(), aStepVec.z());
aContext->WorldViewState.SetCurrent (aModelMat);
aContext->ApplyWorldViewMatrix();
OpenGl_Vec3 aMiddle (theGridAxes.Ticks[theIndex] + aSizeVec * theGridAxes.Axes[theIndex] * 0.5f + aDir * (Standard_ShortReal)(theDpix * anOffset));
- myAspectLabels.Aspect()->SetColor (anAxis.NameColor);
- theWorkspace->SetAspectText (&myAspectLabels);
- anAxis.Label.SetPosition (aMiddle);
- anAxis.Label.Render (theWorkspace);
+ myAspectLabels->Aspect()->SetColor (anAxis.NameColor);
+ theWorkspace->SetAspectText (myAspectLabels);
+ anAxis.Label->SetPosition (aMiddle);
+ anAxis.Label->Render (theWorkspace);
}
if (aCurAspect.ToDrawValues() && aCurAspect.TickmarksNumber() > 0)
{
- myAspectValues.Aspect()->SetColor (anAxis.LineAspect.Aspect()->Color());
- theWorkspace->SetAspectText (&myAspectValues);
+ myAspectValues->Aspect()->SetColor (anAxis.LineAspect->Aspect()->Color());
+ theWorkspace->SetAspectText (myAspectValues);
Standard_Real anOffset = aCurAspect.ValuesOffset() + aCurAspect.TickmarksLength();
for (Standard_Integer anIt = 0; anIt <= aCurAspect.TickmarksNumber(); ++anIt)
{
sprintf (aTextValue, "%g", theGridAxes.Ticks[theIndex].GetData()[theIndex] + anIt * aStep);
OpenGl_Vec3 aPos (theGridAxes.Ticks[theIndex] + anAxis.Direction* (Standard_ShortReal) (anIt * aStep) + aDir * (Standard_ShortReal) (theDpix * anOffset));
- myLabelValues.Init (theWorkspace->GetGlContext(), aTextValue, aPos);
- myLabelValues.Render (theWorkspace);
+ myLabelValues->Init (theWorkspace->GetGlContext(), aTextValue, aPos);
+ myLabelValues->Render (theWorkspace);
}
}
}
if (myData.CubicAxesCallback)
{
myData.CubicAxesCallback (myData.PtrView);
- if (!myAxes[0].Line.IsInitialized()
- || !myAxes[1].Line.IsInitialized()
- || !myAxes[2].Line.IsInitialized()
+ if (!myAxes[0].Line->IsInitialized()
+ || !myAxes[1].Line->IsInitialized()
+ || !myAxes[2].Line->IsInitialized()
|| OpenGl_Vec3 (anOldMin - myMin).Modulus() > Precision::Confusion()
|| OpenGl_Vec3 (anOldMax - myMax).Modulus() > Precision::Confusion())
{
Standard_ExtCharacter anAxesState = getGridAxes (aCorners, aGridAxes);
// Remember current aspects
- const OpenGl_AspectLine* anOldAspectLine = theWorkspace->AspectLine();
- const OpenGl_AspectText* anOldAspectText = theWorkspace->AspectText();
+ const Handle(OpenGl_AspectLine)& anOldAspectLine = theWorkspace->AspectLine();
+ const Handle(OpenGl_AspectText)& anOldAspectText = theWorkspace->AspectText();
OpenGl_Mat4 aModelMatrix;
aModelMatrix.Convert (aContext->WorldViewState.Current());
if (myData.ToDrawGrid())
{
- theWorkspace->SetAspectLine (&myGridLineAspect);
+ theWorkspace->SetAspectLine (myGridLineAspect);
// render grid edges
if (anAxesState & XOO_XYO)
OpenGl_GraduatedTrihedron::Axis::Axis (const Graphic3d_AxisAspect& theAspect,
const OpenGl_Vec3& theDirection)
: Direction (theDirection),
- Label (NCollection_String ((Standard_Utf16Char* )theAspect.Name().ToExtString()).ToCString(), theDirection, THE_LABEL_PARAMS),
- Tickmark (NULL),
- Line (NULL),
- Arrow (NULL)
+ Label (new OpenGl_Text(NCollection_String ((Standard_Utf16Char* )theAspect.Name().ToExtString()).ToCString(), theDirection, THE_LABEL_PARAMS)),
+ Tickmark (new OpenGl_PrimitiveArray (NULL)),
+ Line (new OpenGl_PrimitiveArray (NULL)),
+ Arrow (new OpenGl_PrimitiveArray (NULL))
{
NameColor = theAspect.NameColor();
- LineAspect.Aspect()->SetColor (theAspect.Color());
+ LineAspect = new OpenGl_AspectLine();
+ LineAspect->Aspect()->SetColor (theAspect.Color());
}
// =======================================================================
LineAspect = theOther.LineAspect;
Label = theOther.Label;
- Line .InitBuffers (NULL, Graphic3d_TOPA_SEGMENTS, theOther.Line.Indices(), theOther.Line.Attributes(), theOther.Line.Bounds());
- Tickmark.InitBuffers (NULL, Graphic3d_TOPA_SEGMENTS, theOther.Tickmark.Indices(), theOther.Tickmark.Attributes(), theOther.Tickmark.Bounds());
- Arrow .InitBuffers (NULL, Graphic3d_TOPA_POLYLINES, theOther.Arrow.Indices(), theOther.Arrow.Attributes(), theOther.Arrow.Bounds());
+ Line ->InitBuffers (NULL, Graphic3d_TOPA_SEGMENTS, theOther.Line->Indices(), theOther.Line->Attributes(), theOther.Line->Bounds());
+ Tickmark->InitBuffers (NULL, Graphic3d_TOPA_SEGMENTS, theOther.Tickmark->Indices(), theOther.Tickmark->Attributes(), theOther.Tickmark->Bounds());
+ Arrow ->InitBuffers (NULL, Graphic3d_TOPA_POLYLINES, theOther.Arrow->Indices(), theOther.Arrow->Attributes(), theOther.Arrow->Bounds());
return *this;
}
anArray->AddVertex (aPoint3);
anArray->AddVertex (aPoint1);
- Arrow.InitBuffers (theContext, Graphic3d_TOPA_POLYLINES,
- anArray->Indices(), anArray->Attributes(), anArray->Bounds());
+ Arrow->InitBuffers (theContext, Graphic3d_TOPA_POLYLINES,
+ anArray->Indices(), anArray->Attributes(), anArray->Bounds());
}
// =======================================================================
Handle(Graphic3d_ArrayOfSegments) anArray = new Graphic3d_ArrayOfSegments (2);
anArray->AddVertex (0.0f, 0.0f, 0.0f);
anArray->AddVertex (theDir);
- Tickmark.InitBuffers (theContext, Graphic3d_TOPA_SEGMENTS,
- anArray->Indices(), anArray->Attributes(), anArray->Bounds());
+ Tickmark->InitBuffers (theContext, Graphic3d_TOPA_SEGMENTS,
+ anArray->Indices(), anArray->Attributes(), anArray->Bounds());
}
anArray->AddVertex (0.0f, 0.0f, 0.0f);
anArray->AddVertex (theDir);
- Line.InitBuffers (theContext, Graphic3d_TOPA_SEGMENTS,
- anArray->Indices(), anArray->Attributes(), anArray->Bounds());
+ Line->InitBuffers (theContext, Graphic3d_TOPA_SEGMENTS,
+ anArray->Indices(), anArray->Attributes(), anArray->Bounds());
}
// =======================================================================
// =======================================================================
void OpenGl_GraduatedTrihedron::Axis::Release (OpenGl_Context* theCtx)
{
- Label .Release (theCtx);
- Tickmark.Release (theCtx);
- Line .Release (theCtx);
- Arrow .Release (theCtx);
+ Label ->Release (theCtx);
+ Tickmark->Release (theCtx);
+ Line ->Release (theCtx);
+ Arrow ->Release (theCtx);
}
//! @sa Graphic3d_GraduatedTrihedron
class OpenGl_GraduatedTrihedron : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_GraduatedTrihedron, OpenGl_Element)
public:
DEFINE_STANDARD_ALLOC
OpenGl_Vec3 Direction;
Quantity_Color NameColor;
- OpenGl_AspectLine LineAspect;
- mutable OpenGl_Text Label;
- mutable OpenGl_PrimitiveArray Tickmark;
- mutable OpenGl_PrimitiveArray Line;
- mutable OpenGl_PrimitiveArray Arrow;
+ Handle(OpenGl_AspectLine) LineAspect;
+ mutable Handle(OpenGl_Text) Label;
+ mutable Handle(OpenGl_PrimitiveArray) Tickmark;
+ mutable Handle(OpenGl_PrimitiveArray) Line;
+ mutable Handle(OpenGl_PrimitiveArray) Arrow;
public:
//! @param thaTx the X for vector of translation
//! @param thaTy the Y for vector of translation
//! @param thaTz the Z for vector of translation
- void renderLine (const OpenGl_PrimitiveArray& theLine,
+ void renderLine (const Handle(OpenGl_PrimitiveArray)& theLine,
const Handle(OpenGl_Workspace)& theWorkspace,
const OpenGl_Mat4& theMat,
const Standard_ShortReal theXt,
mutable Axis myAxes[3]; //!< Axes for trihedron
mutable Graphic3d_GraduatedTrihedron myData;
- mutable OpenGl_AspectLine myGridLineAspect; //!< Color grid properties
+ mutable Handle(OpenGl_AspectLine) myGridLineAspect; //!< Color grid properties
protected: //! @name Labels properties
- mutable OpenGl_Text myLabelValues;
- mutable OpenGl_AspectText myAspectLabels;
- mutable OpenGl_AspectText myAspectValues;
+ mutable Handle(OpenGl_Text) myLabelValues;
+ mutable Handle(OpenGl_AspectText) myAspectLabels;
+ mutable Handle(OpenGl_AspectText) myAspectValues;
private:
const Standard_ShortReal aHeight = (theHeight < 2.0f) ? DefaultTextHeight() : theHeight;
OpenGl_TextParam aTextParam;
aTextParam.Height = (int )aHeight;
- OpenGl_AspectText aTextAspect;
- aTextAspect.Aspect()->SetSpace (0.3);
+ Handle(OpenGl_AspectText) aTextAspect = new OpenGl_AspectText();
+ aTextAspect->Aspect()->SetSpace (0.3);
TCollection_ExtendedString anExtText = theText;
NCollection_String aText (anExtText.ToExtString());
OpenGl_Text::StringSize(aCtx, aText, aTextAspect, aTextParam, theView->RenderingParams().Resolution, theWidth, theAscent, theDescent);
//! should be rendered or not.
//! @return True if element passes the check and renders,
static bool renderFiltered (const Handle(OpenGl_Workspace)& theWorkspace,
- OpenGl_Element* theElement)
+ const Handle(OpenGl_Element)& theElement)
{
if (!theWorkspace->ShouldRender (theElement))
{
// =======================================================================
OpenGl_Group::OpenGl_Group (const Handle(Graphic3d_Structure)& theStruct)
: Graphic3d_Group (theStruct),
- myAspectLine(NULL),
- myAspectFace(NULL),
- myAspectMarker(NULL),
- myAspectText(NULL),
- myFirst(NULL),
- myLast(NULL),
myIsRaytracable (Standard_False),
myIsDestroyElements (Standard_True)
{
return;
}
- if (myAspectLine == NULL)
+ if (myAspectLine.IsNull())
{
myAspectLine = new OpenGl_AspectLine (theAspect);
}
// =======================================================================
void OpenGl_Group::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& theAspect)
{
- if (myAspectLine == NULL)
+ if (myAspectLine.IsNull())
{
SetGroupPrimitivesAspect (theAspect);
return;
return;
}
- OpenGl_AspectLine* anAspectLine = new OpenGl_AspectLine (theAspect);
+ Handle(OpenGl_AspectLine) anAspectLine = new OpenGl_AspectLine (theAspect);
AddElement (anAspectLine);
Update();
}
return;
}
- if (myAspectFace == NULL)
+ if (myAspectFace.IsNull())
{
myAspectFace = new OpenGl_AspectFace (theAspect);
}
// =======================================================================
void OpenGl_Group::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& theAspect)
{
- if (myAspectFace == NULL)
+ if (myAspectFace.IsNull())
{
SetGroupPrimitivesAspect (theAspect);
return;
return;
}
- OpenGl_AspectFace* anAspectFace = new OpenGl_AspectFace (theAspect);
+ Handle(OpenGl_AspectFace) anAspectFace = new OpenGl_AspectFace (theAspect);
AddElement (anAspectFace);
Update();
}
return;
}
- if (myAspectMarker == NULL)
+ if (myAspectMarker.IsNull())
{
myAspectMarker = new OpenGl_AspectMarker (theAspMarker);
}
// =======================================================================
void OpenGl_Group::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& theAspMarker)
{
- if (myAspectMarker == NULL)
+ if (myAspectMarker.IsNull())
{
SetGroupPrimitivesAspect (theAspMarker);
return;
return;
}
- OpenGl_AspectMarker* anAspectMarker = new OpenGl_AspectMarker (theAspMarker);
+ Handle(OpenGl_AspectMarker) anAspectMarker = new OpenGl_AspectMarker (theAspMarker);
AddElement (anAspectMarker);
Update();
}
return;
}
- if (myAspectText == NULL)
+ if (myAspectText.IsNull())
{
myAspectText = new OpenGl_AspectText (theAspText);
}
// =======================================================================
void OpenGl_Group::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& theAspText)
{
- if (myAspectText == NULL)
+ if (myAspectText.IsNull())
{
SetGroupPrimitivesAspect (theAspText);
return;
return;
}
- OpenGl_AspectText* anAspectText = new OpenGl_AspectText (theAspText);
+ Handle(OpenGl_AspectText) anAspectText = new OpenGl_AspectText (theAspText);
AddElement (anAspectText);
Update();
}
// =======================================================================
void OpenGl_Group::SynchronizeAspects()
{
- if (myAspectFace != NULL)
+ if (!myAspectFace.IsNull())
{
myAspectFace->SynchronizeAspects();
}
- if (myAspectLine != NULL)
+ if (!myAspectLine.IsNull())
{
myAspectLine->SynchronizeAspects();
}
- if (myAspectMarker != NULL)
+ if (!myAspectMarker.IsNull())
{
myAspectMarker->SynchronizeAspects();
}
- if (myAspectText != NULL)
+ if (!myAspectText.IsNull())
{
myAspectText->SynchronizeAspects();
}
- for (OpenGl_ElementNode* aNode = myFirst; aNode != NULL; aNode = aNode->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator(myElements); anElemIterator.More(); anElemIterator.Next())
{
- aNode->elem->SynchronizeAspects();
+ anElemIterator.ChangeValue()->SynchronizeAspects();
}
}
OpenGl_Structure* aStruct = GlStruct();
const OpenGl_GraphicDriver* aDriver = aStruct->GlDriver();
- OpenGl_PrimitiveArray* anArray = new OpenGl_PrimitiveArray (aDriver, theType, theIndices, theAttribs, theBounds);
+ Handle(OpenGl_PrimitiveArray) anArray = new OpenGl_PrimitiveArray (aDriver, theType, theIndices, theAttribs, theBounds);
AddElement (anArray);
Graphic3d_Group::AddPrimitiveArray (theType, theIndices, theAttribs, theBounds, theToEvalMinMax);
aParams.HAlign = theHta;
aParams.VAlign = theVta;
const OpenGl_Vec3 aPoint (thePoint.X(), thePoint.Y(), thePoint.Z());
- OpenGl_Text* aText = new OpenGl_Text (theTextUtf, aPoint, aParams);
+ Handle(OpenGl_Text) aText = new OpenGl_Text (theTextUtf, aPoint, aParams);
AddElement (aText);
Graphic3d_Group::Text (theTextUtf, thePoint, theHeight, theAngle,
theTp, theHta, theVta, theToEvalMinMax);
aParams.HAlign = theHTA;
aParams.VAlign = theVTA;
- OpenGl_Text* aText = new OpenGl_Text (theTextUtf, theOrientation, aParams, theHasOwnAnchor != Standard_False);
+ Handle(OpenGl_Text) aText = new OpenGl_Text (theTextUtf, theOrientation, aParams, theHasOwnAnchor != Standard_False);
AddElement (aText);
void OpenGl_Group::SetFlippingOptions (const Standard_Boolean theIsEnabled,
const gp_Ax2& theRefPlane)
{
- OpenGl_Flipper* aFlipper = new OpenGl_Flipper (theRefPlane);
+ Handle(OpenGl_Flipper) aFlipper = new OpenGl_Flipper (theRefPlane);
aFlipper->SetOptions (theIsEnabled);
AddElement (aFlipper);
}
// =======================================================================
void OpenGl_Group::SetStencilTestOptions (const Standard_Boolean theIsEnabled)
{
- OpenGl_StencilTest* aStencilTest = new OpenGl_StencilTest();
+ Handle(OpenGl_StencilTest) aStencilTest = new OpenGl_StencilTest();
aStencilTest->SetOptions (theIsEnabled);
AddElement (aStencilTest);
}
// function : AddElement
// purpose :
// =======================================================================
-void OpenGl_Group::AddElement (OpenGl_Element* theElem)
+void OpenGl_Group::AddElement (Handle(OpenGl_Element) theElem)
{
- OpenGl_ElementNode *aNode = new OpenGl_ElementNode();
+ myElements.Append (theElem);
- aNode->elem = theElem;
- aNode->next = NULL;
- (myLast? myLast->next : myFirst) = aNode;
- myLast = aNode;
-
- if (OpenGl_Raytrace::IsRaytracedElement (aNode))
+ if (OpenGl_Raytrace::IsRaytracedElement (theElem))
{
myIsRaytracable = Standard_True;
// Setup aspects
theWorkspace->SetAllowFaceCulling (myIsClosed
&& !theWorkspace->GetGlContext()->Clipping().IsClippingOrCappingOn());
- const OpenGl_AspectLine* aBackAspectLine = theWorkspace->AspectLine();
- const OpenGl_AspectFace* aBackAspectFace = theWorkspace->AspectFace();
- const OpenGl_AspectMarker* aBackAspectMarker = theWorkspace->AspectMarker();
- const OpenGl_AspectText* aBackAspectText = theWorkspace->AspectText();
- const bool isLineSet = myAspectLine && renderFiltered (theWorkspace, myAspectLine);
- const bool isFaceSet = myAspectFace && renderFiltered (theWorkspace, myAspectFace);
- const bool isMarkerSet = myAspectMarker && renderFiltered (theWorkspace, myAspectMarker);
- const bool isTextSet = myAspectText && renderFiltered (theWorkspace, myAspectText);
+ const Handle(OpenGl_AspectLine)& aBackAspectLine = theWorkspace->AspectLine();
+ const Handle(OpenGl_AspectFace)& aBackAspectFace = theWorkspace->AspectFace();
+ const Handle(OpenGl_AspectMarker)& aBackAspectMarker = theWorkspace->AspectMarker();
+ const Handle(OpenGl_AspectText)& aBackAspectText = theWorkspace->AspectText();
+ const bool isLineSet = !myAspectLine.IsNull() && renderFiltered (theWorkspace, myAspectLine);
+ const bool isFaceSet = !myAspectFace.IsNull() && renderFiltered (theWorkspace, myAspectFace);
+ const bool isMarkerSet = !myAspectMarker.IsNull() && renderFiltered (theWorkspace, myAspectMarker);
+ const bool isTextSet = !myAspectText.IsNull() && renderFiltered (theWorkspace, myAspectText);
// Render group elements
- for (OpenGl_ElementNode* aNodeIter = myFirst; aNodeIter != NULL; aNodeIter = aNodeIter->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator(myElements); anElemIterator.More(); anElemIterator.Next())
{
- renderFiltered (theWorkspace, aNodeIter->elem);
+ renderFiltered (theWorkspace, anElemIterator.Value());
}
// Restore aspects
// Delete elements
if (myIsDestroyElements)
{
- while (myFirst != NULL)
+ for (OpenGl_ElementNodes::Iterator anElemIterator(myElements); anElemIterator.More(); anElemIterator.Next())
{
- OpenGl_ElementNode* aNext = myFirst->next;
- OpenGl_Element::Destroy (theGlCtx.operator->(), myFirst->elem);
- delete myFirst;
- myFirst = aNext;
+ OpenGl_Element::Destroy (theGlCtx.operator->(), anElemIterator.ChangeValue());
}
}
- myLast = NULL;
+ myElements.Clear();
OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectLine);
OpenGl_Element::Destroy (theGlCtx.operator->(), myAspectFace);
class OpenGl_CappingPlaneResource;
class OpenGl_Structure;
-struct OpenGl_ElementNode
-{
- OpenGl_Element* elem;
- OpenGl_ElementNode* next;
- DEFINE_STANDARD_ALLOC
-};
+typedef NCollection_List<Handle(OpenGl_Element)> OpenGl_ElementNodes;
//! Implementation of low-level graphic group.
class OpenGl_Group : public Graphic3d_Group
//! Return line aspect.
virtual Handle(Graphic3d_AspectLine3d) LineAspect() const Standard_OVERRIDE
{
- return myAspectLine != NULL
- ? myAspectLine->Aspect()
- : Handle(Graphic3d_AspectLine3d)();
+ return !myAspectLine.IsNull()
+ ? myAspectLine->Aspect()
+ : Handle(Graphic3d_AspectLine3d)();
}
//! Update line aspect.
//! Return marker aspect.
virtual Handle(Graphic3d_AspectMarker3d) MarkerAspect() const Standard_OVERRIDE
{
- return myAspectMarker != NULL
- ? myAspectMarker->Aspect()
- : Handle(Graphic3d_AspectMarker3d)();
+ return !myAspectMarker.IsNull()
+ ? myAspectMarker->Aspect()
+ : Handle(Graphic3d_AspectMarker3d)();
}
//! Update marker aspect.
//! Return fill area aspect.
virtual Handle(Graphic3d_AspectFillArea3d) FillAreaAspect() const Standard_OVERRIDE
{
- return myAspectFace != NULL
+ return !myAspectFace.IsNull()
? myAspectFace->Aspect()
: Handle(Graphic3d_AspectFillArea3d)();
}
//! Return marker aspect.
virtual Handle(Graphic3d_AspectText3d) TextAspect() const Standard_OVERRIDE
{
- return myAspectText != NULL
+ return !myAspectText.IsNull()
? myAspectText->Aspect()
: Handle(Graphic3d_AspectText3d)();
}
OpenGl_Structure* GlStruct() const { return (OpenGl_Structure* )(myStructure->CStructure().operator->()); }
- Standard_EXPORT void AddElement (OpenGl_Element* theElem);
+ Standard_EXPORT void AddElement (Handle(OpenGl_Element) theElem);
Standard_EXPORT virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const;
Standard_EXPORT virtual void Release (const Handle(OpenGl_Context)& theGlCtx);
- //! Returns first OpenGL element node of the group.
- const OpenGl_ElementNode* FirstNode() const { return myFirst; }
+ //! Returns OpenGl elements of the group
+ const OpenGl_ElementNodes& GetElements() const { return myElements; }
//! Returns OpenGL face aspect.
- const OpenGl_AspectFace* AspectFace() const { return myAspectFace; }
+ const Handle(OpenGl_AspectFace)& AspectFace() const { return myAspectFace; }
//! Returns OpenGL capping filling aspect.
const OpenGl_CappingPlaneResource* AspectFillCapping() const { return myAspectFillCapping; }
protected:
- OpenGl_AspectLine* myAspectLine;
- OpenGl_AspectFace* myAspectFace;
- OpenGl_AspectMarker* myAspectMarker;
- OpenGl_AspectText* myAspectText;
+ Handle(OpenGl_AspectLine) myAspectLine;
+ Handle(OpenGl_AspectFace) myAspectFace;
+ Handle(OpenGl_AspectMarker) myAspectMarker;
+ Handle(OpenGl_AspectText) myAspectText;
OpenGl_CappingPlaneResource* myAspectFillCapping;
- OpenGl_ElementNode* myFirst;
- OpenGl_ElementNode* myLast;
+ OpenGl_ElementNodes myElements;
Standard_Boolean myIsRaytracable;
Standard_Boolean myIsDestroyElements;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
+#include <OpenGl_PrimitiveArray.hxx>
+
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_IndexBuffer.hxx>
#include <OpenGl_PointSprite.hxx>
-#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_Sampler.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <NCollection_AlignedAllocator.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_PrimitiveArray, OpenGl_Element)
+
namespace
{
//! Convert data type to GL info
return;
}
- const OpenGl_AspectLine* anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace()->AspectEdge());
- const OpenGl_AspectLine* anAspect = theWorkspace->ApplyAspectLine();
+ const Handle(OpenGl_AspectLine) anAspectLineOld = theWorkspace->AspectLine();
+ theWorkspace->SetAspectLine (theWorkspace->AspectFace()->AspectEdge());
+
+ const Handle(OpenGl_AspectLine)& anAspect = theWorkspace->ApplyAspectLine();
#if !defined(GL_ES_VERSION_2_0)
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
// =======================================================================
void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const
{
- const OpenGl_AspectMarker* anAspectMarker = theWorkspace->ApplyAspectMarker();
- const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
+ const Handle(OpenGl_AspectMarker)& anAspectMarker = theWorkspace->ApplyAspectMarker();
+ const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const GLenum aDrawMode = !aCtx->ActiveProgram().IsNull()
&& aCtx->ActiveProgram()->HasTessellationStage()
? GL_PATCHES
return;
}
- const OpenGl_AspectFace* anAspectFace = theWorkspace->ApplyAspectFace();
- const OpenGl_AspectLine* anAspectLine = theWorkspace->ApplyAspectLine();
- const OpenGl_AspectMarker* anAspectMarker = myDrawMode == GL_POINTS
+ const Handle(OpenGl_AspectFace)& anAspectFace = theWorkspace->ApplyAspectFace();
+ const Handle(OpenGl_AspectLine)& anAspectLine = theWorkspace->ApplyAspectLine();
+ const Handle(OpenGl_AspectMarker)& anAspectMarker = myDrawMode == GL_POINTS
? theWorkspace->ApplyAspectMarker()
: theWorkspace->AspectMarker();
return Standard_True;
}
- if (myAttribs->NbElements > std::numeric_limits<GLushort>::max())
+ if (myAttribs->NbElements > IntegerLast()/*std::numeric_limits<GLushort>::max()*/)
{
Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (new NCollection_AlignedAllocator (16));
if (!anAttribs->Init (myIndices->NbElements, myAttribs->AttributesArray(), myAttribs->NbAttributes))
//! Class for rendering of arbitrary primitive array.
class OpenGl_PrimitiveArray : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_PrimitiveArray, OpenGl_Element)
public:
//! OpenGL does not provide a constant for "none" draw mode.
//! So we define our own one that does not conflict with GL constants and utilizes common GL invalid value.
// function : IsRaytracedElement
// purpose : Checks to see if the element contains ray-trace geometry
// =======================================================================
- Standard_Boolean IsRaytracedElement (const OpenGl_ElementNode* theNode)
+ Standard_Boolean IsRaytracedElement (const Handle(OpenGl_Element) theElement)
{
- OpenGl_PrimitiveArray* anArray = dynamic_cast<OpenGl_PrimitiveArray*> (theNode->elem);
- return anArray != NULL
- && anArray->DrawMode() >= GL_TRIANGLES;
- }
-
- // =======================================================================
- // function : IsRaytracedElement
- // purpose : Checks to see if the element contains ray-trace geometry
- // =======================================================================
- Standard_Boolean IsRaytracedElement (const OpenGl_Element* theElement)
- {
- const OpenGl_PrimitiveArray* anArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theElement);
- return anArray != NULL
+ Handle(OpenGl_PrimitiveArray) anArray = Handle(OpenGl_PrimitiveArray)::DownCast (theElement);
+ return !anArray.IsNull()
&& anArray->DrawMode() >= GL_TRIANGLES;
}
// =======================================================================
Standard_Boolean IsRaytracedGroup (const OpenGl_Group* theGroup)
{
- for (const OpenGl_ElementNode* aNode = theGroup->FirstNode(); aNode != NULL; aNode = aNode->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator (theGroup->GetElements()); anElemIterator.More(); anElemIterator.Next())
{
- if (IsRaytracedElement (aNode))
+ if (IsRaytracedElement (anElemIterator.Value()))
{
return Standard_True;
}
Standard_Boolean IsRaytracedGroup (const OpenGl_Group* theGroup);
//! Checks to see if the element contains ray-trace geometry.
- Standard_Boolean IsRaytracedElement (const OpenGl_ElementNode* theNode);
-
- //! Checks to see if the element contains ray-trace geometry.
- Standard_Boolean IsRaytracedElement (const OpenGl_Element* theElement);
+ Standard_Boolean IsRaytracedElement (const Handle(OpenGl_Element) theElement);
}
//! Stores properties of surface material.
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_StencilTest.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_StencilTest, OpenGl_Element)
+
OpenGl_StencilTest::OpenGl_StencilTest()
{
//
class OpenGl_StencilTest : public OpenGl_Element
{
+ DEFINE_STANDARD_RTTIEXT(OpenGl_StencilTest, OpenGl_Element)
public:
//! Default constructor
aCtx->ApplyModelViewMatrix();
// 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();
+ const Handle(OpenGl_AspectLine)& aPrevAspectLine = theWorkspace->AspectLine();
+ const Handle(OpenGl_AspectFace)& aPrevAspectFace = theWorkspace->AspectFace();
+ const Handle(OpenGl_AspectMarker)& aPrevAspectMarker = theWorkspace->AspectMarker();
+ const Handle(OpenGl_AspectText)& aPrevAspectText = theWorkspace->AspectText();
// Apply correction for mirror transform
if (myIsMirrored)
#include <Graphic3d_TransformUtils.hxx>
#include <TCollection_HAsciiString.hxx>
+IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Text, OpenGl_Element)
+
namespace
{
static const GLdouble THE_IDENTITY_MATRIX[16] =
// =======================================================================
void OpenGl_Text::StringSize (const Handle(OpenGl_Context)& theCtx,
const NCollection_String& theText,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_TextParam& theParams,
const unsigned int theResolution,
Standard_ShortReal& theWidth,
// =======================================================================
void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
- theWorkspace->SetAspectFace (&theWorkspace->FontFaceAspect());
+ theWorkspace->SetAspectFace (theWorkspace->FontFaceAspect());
theWorkspace->ApplyAspectFace();
- const OpenGl_AspectText* aTextAspect = theWorkspace->ApplyAspectText();
- const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
+ const Handle(OpenGl_AspectText)& aTextAspect = theWorkspace->ApplyAspectText();
+ const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
const Handle(OpenGl_TextureSet) aPrevTexture = aCtx->BindTextures (Handle(OpenGl_TextureSet)());
// Bind custom shader program or generate default version
// use highlight color or colors from aspect
render (aCtx,
- *aTextAspect,
+ aTextAspect,
theWorkspace->TextColor(),
theWorkspace->TextSubtitleColor(),
aCtx->Resolution());
// purpose :
// =======================================================================
void OpenGl_Text::Render (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const unsigned int theResolution) const
{
render (theCtx, theTextAspect,
- theTextAspect.Aspect()->ColorRGBA(),
- theTextAspect.Aspect()->ColorSubTitleRGBA(),
+ theTextAspect->Aspect()->ColorRGBA(),
+ theTextAspect->Aspect()->ColorSubTitleRGBA(),
theResolution);
}
// purpose :
// =======================================================================
void OpenGl_Text::setupMatrix (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec3 theDVec) const
{
OpenGl_Mat4d aModViewMat;
{
Graphic3d_TransformUtils::Translate<GLdouble> (aModViewMat, myPoint.x() + theDVec.x(), myPoint.y() + theDVec.y(), 0.f);
Graphic3d_TransformUtils::Scale<GLdouble> (aModViewMat, 1.f, -1.f, 1.f);
- Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect.Aspect()->GetTextAngle(), 0.f, 0.f, 1.f);
+ Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect->Aspect()->GetTextAngle(), 0.f, 0.f, 1.f);
}
else
{
else
{
Graphic3d_TransformUtils::Translate<GLdouble> (aModViewMat, anObjX, anObjY, anObjZ);
- Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect.Aspect()->GetTextAngle(), 0.0, 0.0, 1.0);
+ Graphic3d_TransformUtils::Rotate<GLdouble> (aModViewMat, theTextAspect->Aspect()->GetTextAngle(), 0.0, 0.0, 1.0);
}
- if (!theTextAspect.Aspect()->GetTextZoomable())
+ if (!theTextAspect->Aspect()->GetTextZoomable())
{
Graphic3d_TransformUtils::Scale<GLdouble> (aModViewMat, myScaleHeight, myScaleHeight, myScaleHeight);
}
// purpose :
// =======================================================================
void OpenGl_Text::drawText (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect) const
+ const Handle(OpenGl_AspectText)& theTextAspect) const
{
(void )theTextAspect;
if (myVertsVbo.Length() != myTextures.Length()
// function : FontKey
// purpose :
// =======================================================================
-TCollection_AsciiString OpenGl_Text::FontKey (const OpenGl_AspectText& theAspect,
+TCollection_AsciiString OpenGl_Text::FontKey (const Handle(OpenGl_AspectText)& theAspect,
const Standard_Integer theHeight,
const unsigned int theResolution)
{
- const Font_FontAspect anAspect = theAspect.Aspect()->GetTextFontAspect() != Font_FA_Undefined
- ? theAspect.Aspect()->GetTextFontAspect()
+ const Font_FontAspect anAspect = theAspect->Aspect()->GetTextFontAspect() != Font_FA_Undefined
+ ? theAspect->Aspect()->GetTextFontAspect()
: Font_FA_Regular;
- return theAspect.Aspect()->Font()
+ return theAspect->Aspect()->Font()
+ TCollection_AsciiString(":") + Standard_Integer(anAspect)
+ TCollection_AsciiString(":") + Standard_Integer(theResolution)
+ TCollection_AsciiString(":") + theHeight;
// purpose :
// =======================================================================
Handle(OpenGl_Font) OpenGl_Text::FindFont (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theAspect,
+ const Handle(OpenGl_AspectText)& theAspect,
const Standard_Integer theHeight,
const unsigned int theResolution,
const TCollection_AsciiString theKey)
if (!theCtx->GetResource (theKey, aFont))
{
Handle(Font_FontMgr) aFontMgr = Font_FontMgr::GetInstance();
- const Handle(TCollection_HAsciiString) aFontName = new TCollection_HAsciiString (theAspect.Aspect()->Font());
- const Font_FontAspect anAspect = theAspect.Aspect()->GetTextFontAspect() != Font_FA_Undefined
- ? theAspect.Aspect()->GetTextFontAspect()
+ const Handle(TCollection_HAsciiString) aFontName = new TCollection_HAsciiString (theAspect->Aspect()->Font());
+ const Font_FontAspect anAspect = theAspect->Aspect()->GetTextFontAspect() != Font_FA_Undefined
+ ? theAspect->Aspect()->GetTextFontAspect()
: Font_FA_Regular;
Handle(Font_SystemFont) aRequestedFont = aFontMgr->FindFont (aFontName, anAspect, theHeight);
Handle(Font_FTFont) aFontFt;
{
TCollection_ExtendedString aMsg;
aMsg += "Font '";
- aMsg += theAspect.Aspect()->Font();
+ aMsg += theAspect->Aspect()->Font();
aMsg += "' - initialization of GL resources has failed!";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
aFontFt.Nullify();
{
TCollection_ExtendedString aMsg;
aMsg += "Font '";
- aMsg += theAspect.Aspect()->Font();
+ aMsg += theAspect->Aspect()->Font();
aMsg += "' is broken or has incompatible format! File path: ";
aMsg += aRequestedFont->FontPath()->ToCString();
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
{
TCollection_ExtendedString aMsg;
aMsg += "Font '";
- aMsg += theAspect.Aspect()->Font();
+ aMsg += theAspect->Aspect()->Font();
aMsg += "' is not found in the system!";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
aFont = new OpenGl_Font (aFontFt, theKey);
// purpose :
// =======================================================================
void OpenGl_Text::drawRect (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec4& theColorSubs) const
{
Handle(OpenGl_ShaderProgram) aPrevProgram = theCtx->ActiveProgram();
// purpose :
// =======================================================================
void OpenGl_Text::render (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec4& theColorText,
const OpenGl_Vec4& theColorSubs,
const unsigned int theResolution) const
myWinX, myWinY, myWinZ);
// compute scale factor for constant text height
- if (theTextAspect.Aspect()->GetTextZoomable())
+ if (theTextAspect->Aspect()->GetTextZoomable())
{
myExportHeight = aPointSize;
}
// setup depth test
const bool hasDepthTest = !myIs2d
- && theTextAspect.Aspect()->Style() != Aspect_TOST_ANNOTATION;
+ && theTextAspect->Aspect()->Style() != Aspect_TOST_ANNOTATION;
if (!hasDepthTest)
{
glDisable (GL_DEPTH_TEST);
const bool anAlphaToCoverageOld = theCtx->SetSampleAlphaToCoverage (false);
// extra drawings
- switch (theTextAspect.Aspect()->DisplayType())
+ switch (theTextAspect->Aspect()->DisplayType())
{
case Aspect_TODT_BLEND:
{
}
#endif
- if (theTextAspect.Aspect()->DisplayType() == Aspect_TODT_DIMENSION)
+ if (theTextAspect->Aspect()->DisplayType() == Aspect_TODT_DIMENSION)
{
glDisable (GL_BLEND);
if (!myIs2d)
//! Text rendering
class OpenGl_Text : public OpenGl_Element
{
-
+ DEFINE_STANDARD_RTTIEXT(OpenGl_Text, OpenGl_Element)
public:
//! Main constructor
Standard_EXPORT OpenGl_Text();
//! Create key for shared resource
- Standard_EXPORT static TCollection_AsciiString FontKey (const OpenGl_AspectText& theAspect,
+ Standard_EXPORT static TCollection_AsciiString FontKey (const Handle(OpenGl_AspectText)& theAspect,
const Standard_Integer theHeight,
const unsigned int theResolution);
//! Find shared resource for specified font or initialize new one
Standard_EXPORT static Handle(OpenGl_Font) FindFont (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theAspect,
+ const Handle(OpenGl_AspectText)& theAspect,
const Standard_Integer theHeight,
const unsigned int theResolution,
const TCollection_AsciiString theKey);
//! Compute text width
Standard_EXPORT static void StringSize (const Handle(OpenGl_Context)& theCtx,
const NCollection_String& theText,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_TextParam& theParams,
const unsigned int theResolution,
Standard_ShortReal& theWidth,
//! Perform rendering
Standard_EXPORT void Render (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
- const unsigned int theResolution = Graphic3d_RenderingParams::THE_DEFAULT_RESOLUTION) const;
+ const Handle(OpenGl_AspectText)& theTextAspect,
+ const unsigned int theResolution = Graphic3d_RenderingParams::THE_DEFAULT_RESOLUTION) const;
protected:
//! Setup matrix.
void setupMatrix (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec3 theDVec) const;
//! Draw arrays of vertices.
void drawText (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect) const;
+ const Handle(OpenGl_AspectText)& theTextAspect) const;
//! Draw rectangle from bounding text box.
void drawRect (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec4& theColorSubs) const;
//! Main rendering code
void render (const Handle(OpenGl_Context)& theCtx,
- const OpenGl_AspectText& theTextAspect,
+ const Handle(OpenGl_AspectText)& theTextAspect,
const OpenGl_Vec4& theColorText,
const OpenGl_Vec4& theColorSubs,
const unsigned int theResolution) const;
myRaytraceFBO1[1] = new OpenGl_FrameBuffer();
myRaytraceFBO2[0] = new OpenGl_FrameBuffer();
myRaytraceFBO2[1] = new OpenGl_FrameBuffer();
+
+ myGraduatedTrihedron = new OpenGl_GraduatedTrihedron();
+ myFrameStatsPrs = new OpenGl_FrameStatsPrs();
}
// =======================================================================
// =======================================================================
void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
{
- myGraduatedTrihedron.Release (theCtx.operator->());
- myFrameStatsPrs.Release (theCtx.operator->());
+ myGraduatedTrihedron->Release (theCtx.operator->());
+ myFrameStatsPrs->Release (theCtx.operator->());
if (!myTextureEnv.IsNull())
{
myTextureEnv.Nullify();
}
- if (myTextureParams != NULL)
+ if (!myTextureParams.IsNull())
{
myTextureParams->Release (theCtx.operator->());
}
- if (myBgGradientArray != NULL)
+ if (!myBgGradientArray.IsNull())
{
myBgGradientArray->Release (theCtx.operator->());
}
- if (myBgTextureArray != NULL)
+ if (!myBgTextureArray.IsNull())
{
myBgTextureArray->Release (theCtx.operator->());
}
myGTrihedronData = theTrihedronData;
myGTrihedronData.PtrView = this;
myGTrihedronData.CubicAxesCallback = SetMinMaxValuesCallback;
- myGraduatedTrihedron.SetValues (myGTrihedronData);
+ myGraduatedTrihedron->SetValues (myGTrihedronData);
myToShowGradTrihedron = true;
}
void OpenGl_View::GraduatedTrihedronErase()
{
myGTrihedronData.PtrView = NULL;
- myGraduatedTrihedron.Release (myWorkspace->GetGlContext().operator->());
+ myGraduatedTrihedron->Release (myWorkspace->GetGlContext().operator->());
myToShowGradTrihedron = false;
}
// =======================================================================
void OpenGl_View::GraduatedTrihedronMinMaxValues (const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax)
{
- myGraduatedTrihedron.SetMinMax (theMin, theMax);
+ myGraduatedTrihedron->SetMinMax (theMin, theMax);
}
// =======================================================================
const Quantity_ColorRGBA& BackgroundColor() const { return myBgColor; }
//! Change graduated trihedron.
- OpenGl_GraduatedTrihedron& ChangeGraduatedTrihedron() { return myGraduatedTrihedron; }
+ const Handle(OpenGl_GraduatedTrihedron)& ChangeGraduatedTrihedron() { return myGraduatedTrihedron; }
void SetTextureEnv (const Handle(OpenGl_Context)& theCtx,
const Handle(Graphic3d_TextureEnv)& theTexture);
//! Is needed for selection of overlapping objects and storage of the current view volume
OpenGl_BVHTreeSelector myBVHSelector;
- OpenGl_GraduatedTrihedron myGraduatedTrihedron;
- OpenGl_FrameStatsPrs myFrameStatsPrs;
+ Handle(OpenGl_GraduatedTrihedron) myGraduatedTrihedron;
+ Handle(OpenGl_FrameStatsPrs) myFrameStatsPrs;
Handle(OpenGl_TextureSet) myTextureEnv;
protected: //! @name Background parameters
- OpenGl_AspectFace* myTextureParams; //!< Stores texture and its parameters for textured background
- OpenGl_BackgroundArray* myBgGradientArray; //!< Primitive array for gradient background
- OpenGl_BackgroundArray* myBgTextureArray; //!< Primitive array for texture background
+ Handle(OpenGl_AspectFace) myTextureParams; //!< Stores texture and its parameters for textured background
+ Handle(OpenGl_BackgroundArray) myBgGradientArray; //!< Primitive array for gradient background
+ Handle(OpenGl_BackgroundArray) myBgTextureArray; //!< Primitive array for texture background
protected: //! @name data types related to ray-tracing
const Handle(OpenGl_Context)& theGlContext);
//! Creates ray-tracing material properties.
- OpenGl_RaytraceMaterial convertMaterial (const OpenGl_AspectFace* theAspect,
+ OpenGl_RaytraceMaterial convertMaterial (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(OpenGl_Context)& theGlContext);
//! Adds OpenGL primitive array to ray-traced scene geometry.
- Handle(OpenGl_TriangleSet) addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
+ Handle(OpenGl_TriangleSet) addRaytracePrimitiveArray (const Handle(OpenGl_PrimitiveArray)& theArray,
const Standard_Integer theMatID,
const OpenGl_Mat4* theTrans);
const Standard_Integer theMatID,
const Standard_Integer theCount,
const Standard_Integer theOffset,
- const OpenGl_PrimitiveArray& theArray);
+ const Handle(OpenGl_PrimitiveArray)& theArray);
//! Adds OpenGL triangle array to ray-traced scene geometry.
Standard_Boolean addRaytraceTriangleArray (OpenGl_TriangleSet& theSet,
for (OpenGl_Structure::GroupIterator aGroupIter (aStructure->Groups()); aGroupIter.More(); aGroupIter.Next())
{
// Extract OpenGL elements from the group (primitives arrays)
- for (const OpenGl_ElementNode* aNode = aGroupIter.Value()->FirstNode(); aNode != NULL; aNode = aNode->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator (aGroupIter.Value()->GetElements()); anElemIterator.More(); anElemIterator.Next())
{
- OpenGl_PrimitiveArray* aPrimArray = dynamic_cast<OpenGl_PrimitiveArray*> (aNode->elem);
-
- if (aPrimArray != NULL)
+ Handle(OpenGl_PrimitiveArray) aPrimArray = Handle(OpenGl_PrimitiveArray)::DownCast (anElemIterator.Value());
+ if (!aPrimArray.IsNull())
{
anArrayIDs.insert (aPrimArray->GetUID());
}
// function : convertMaterial
// purpose : Creates ray-tracing material properties
// =======================================================================
-OpenGl_RaytraceMaterial OpenGl_View::convertMaterial (const OpenGl_AspectFace* theAspect,
+OpenGl_RaytraceMaterial OpenGl_View::convertMaterial (const Handle(OpenGl_AspectFace)& theAspect,
const Handle(OpenGl_Context)& theGlContext)
{
OpenGl_RaytraceMaterial theMaterial;
{
// Get group material
OpenGl_RaytraceMaterial aGroupMaterial;
- if (aGroupIter.Value()->AspectFace() != NULL)
+ if (!aGroupIter.Value()->AspectFace().IsNull())
{
aGroupMaterial = convertMaterial (
aGroupIter.Value()->AspectFace(), theGlContext);
// Use group material if available, otherwise use structure material
myRaytraceGeometry.Materials.push_back (
- aGroupIter.Value()->AspectFace() != NULL ? aGroupMaterial : theStructMat);
+ !aGroupIter.Value()->AspectFace().IsNull() ? aGroupMaterial : theStructMat);
// Add OpenGL elements from group (extract primitives arrays and aspects)
- for (const OpenGl_ElementNode* aNode = aGroupIter.Value()->FirstNode(); aNode != NULL; aNode = aNode->next)
+ for (OpenGl_ElementNodes::Iterator anElemIterator (aGroupIter.Value()->GetElements()); anElemIterator.More(); anElemIterator.Next())
{
- OpenGl_AspectFace* anAspect = dynamic_cast<OpenGl_AspectFace*> (aNode->elem);
+ Handle(OpenGl_AspectFace) anAspect = Handle(OpenGl_AspectFace)::DownCast (anElemIterator.Value());
- if (anAspect != NULL)
+ if (!anAspect.IsNull())
{
aMatID = static_cast<Standard_Integer> (myRaytraceGeometry.Materials.size());
}
else
{
- OpenGl_PrimitiveArray* aPrimArray = dynamic_cast<OpenGl_PrimitiveArray*> (aNode->elem);
+ Handle(OpenGl_PrimitiveArray) aPrimArray = Handle(OpenGl_PrimitiveArray)::DownCast (anElemIterator.Value());
- if (aPrimArray != NULL)
+ if (!aPrimArray.IsNull())
{
std::map<Standard_Size, OpenGl_TriangleSet*>::iterator aSetIter = myArrayToTrianglesMap.find (aPrimArray->GetUID());
// function : addRaytracePrimitiveArray
// purpose : Adds OpenGL primitive array to ray-traced scene geometry
// =======================================================================
-Handle(OpenGl_TriangleSet) OpenGl_View::addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
+Handle(OpenGl_TriangleSet) OpenGl_View::addRaytracePrimitiveArray (const Handle(OpenGl_PrimitiveArray)& theArray,
const Standard_Integer theMaterial,
const OpenGl_Mat4* theTransform)
{
{
const Standard_Integer aVertNum = aBounds->Bounds[aBound];
- if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, aBoundStart, *theArray))
+ if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, aBoundStart, theArray))
{
aSet.Nullify();
return Handle(OpenGl_TriangleSet)();
{
const Standard_Integer aVertNum = !anIndices.IsNull() ? anIndices->NbElements : anAttribs->NbElements;
- if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, 0, *theArray))
+ if (!addRaytraceVertexIndices (*aSet, theMaterial, aVertNum, 0, theArray))
{
aSet.Nullify();
return Handle(OpenGl_TriangleSet)();
const Standard_Integer theMatID,
const Standard_Integer theCount,
const Standard_Integer theOffset,
- const OpenGl_PrimitiveArray& theArray)
+ const Handle(OpenGl_PrimitiveArray)& theArray)
{
- switch (theArray.DrawMode())
+ switch (theArray->DrawMode())
{
- case GL_TRIANGLES: return addRaytraceTriangleArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
- case GL_TRIANGLE_FAN: return addRaytraceTriangleFanArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
- case GL_TRIANGLE_STRIP: return addRaytraceTriangleStripArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
+ case GL_TRIANGLES: return addRaytraceTriangleArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
+ case GL_TRIANGLE_FAN: return addRaytraceTriangleFanArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
+ case GL_TRIANGLE_STRIP: return addRaytraceTriangleStripArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
#if !defined(GL_ES_VERSION_2_0)
- case GL_QUAD_STRIP: return addRaytraceQuadrangleStripArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
- case GL_QUADS: return addRaytraceQuadrangleArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
- case GL_POLYGON: return addRaytracePolygonArray (theSet, theMatID, theCount, theOffset, theArray.Indices());
+ case GL_QUAD_STRIP: return addRaytraceQuadrangleStripArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
+ case GL_QUADS: return addRaytraceQuadrangleArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
+ case GL_POLYGON: return addRaytracePolygonArray (theSet, theMatID, theCount, theOffset, theArray->Indices());
#endif
}
}
// Set background colors (only gradient background supported)
- if (myBgGradientArray != NULL && myBgGradientArray->IsDefined())
+ if (!myBgGradientArray.IsNull() && myBgGradientArray->IsDefined())
{
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uBackColorTop], myBgGradientArray->GradientColor (0));
{
aCtx->core11fwd->glDisable (GL_BLEND);
- const OpenGl_AspectFace* anOldAspectFace = theWorkspace->SetAspectFace (myTextureParams);
+ const Handle(OpenGl_AspectFace) anOldAspectFace = theWorkspace->AspectFace();
+ theWorkspace->SetAspectFace (myTextureParams);
+
myBgTextureArray->Render (theWorkspace);
theWorkspace->SetAspectFace (anOldAspectFace);
}
{
if (myToShowGradTrihedron)
{
- myGraduatedTrihedron.Render (theWorkspace);
+ myGraduatedTrihedron->Render (theWorkspace);
}
}
if (myRenderParams.ToShowStats
&& myRenderParams.CollectedStats != Graphic3d_RenderingParams::PerfCounters_NONE)
{
- myFrameStatsPrs.Update (myWorkspace);
- myFrameStatsPrs.Render (myWorkspace);
+ myFrameStatsPrs->Update (myWorkspace);
+ myFrameStatsPrs->Render (myWorkspace);
}
}
myNbSkippedTranspElems (0),
myRenderFilter (OpenGl_RenderFilter_Empty),
//
- myAspectLineSet (&myDefaultAspectLine),
- myAspectFaceSet (&myDefaultAspectFace),
- myAspectMarkerSet (&myDefaultAspectMarker),
- myAspectTextSet (&myDefaultAspectText),
- //
ViewMatrix_applied (&myDefaultMatrix),
StructureMatrix_applied (&myDefaultMatrix),
myToAllowFaceCulling (false),
myModelViewMatrix (myDefaultMatrix)
{
+ myDefaultAspectLine = new OpenGl_AspectLine();
+ myDefaultAspectFace = new OpenGl_AspectFace();
+ myDefaultAspectMarker = new OpenGl_AspectMarker();
+ myDefaultAspectText = new OpenGl_AspectText();
+
+ myNoneCulling = new OpenGl_AspectFace();
+ myFrontCulling = new OpenGl_AspectFace();
+ myFontFaceAspect = new OpenGl_AspectFace();
+
+ myAspectLineSet = myDefaultAspectLine;
+ myAspectFaceSet = myDefaultAspectFace;
+ myAspectMarkerSet = myDefaultAspectMarker;
+ myAspectTextSet = myDefaultAspectText;
+
if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
{
myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
#endif
}
- myFontFaceAspect.Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Mask, 0.285f);
- myFontFaceAspect.Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
+ myFontFaceAspect->Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Mask, 0.285f);
+ myFontFaceAspect->Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
- myNoneCulling .Aspect()->SetSuppressBackFaces (false);
- myNoneCulling .Aspect()->SetDrawEdges (false);
- myNoneCulling .Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Opaque);
+ myNoneCulling->Aspect()->SetSuppressBackFaces (false);
+ myNoneCulling->Aspect()->SetDrawEdges (false);
+ myNoneCulling->Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Opaque);
- myFrontCulling.Aspect()->SetSuppressBackFaces (true);
- myFrontCulling.Aspect()->SetDrawEdges (false);
- myFrontCulling.Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Opaque);
+ myFrontCulling->Aspect()->SetSuppressBackFaces (true);
+ myFrontCulling->Aspect()->SetDrawEdges (false);
+ myFrontCulling->Aspect()->SetAlphaMode (Graphic3d_AlphaMode_Opaque);
}
// =======================================================================
myHighlightStyle.Nullify();
myToAllowFaceCulling = false;
- myAspectLineSet = &myDefaultAspectLine;
- myAspectFaceSet = &myDefaultAspectFace;
+ myAspectLineSet = myDefaultAspectLine;
+ myAspectFaceSet = myDefaultAspectFace;
myAspectFaceApplied.Nullify();
- myAspectMarkerSet = &myDefaultAspectMarker;
+ myAspectMarkerSet = myDefaultAspectMarker;
myAspectMarkerApplied.Nullify();
- myAspectTextSet = &myDefaultAspectText;
+ myAspectTextSet = myDefaultAspectText;
myGlContext->SetPolygonOffset (Graphic3d_PolygonOffset());
ApplyAspectLine();
ApplyAspectMarker();
ApplyAspectText();
- myGlContext->SetTypeOfLine (myDefaultAspectLine.Aspect()->Type());
- myGlContext->SetLineWidth (myDefaultAspectLine.Aspect()->Width());
+ myGlContext->SetTypeOfLine (myDefaultAspectLine->Aspect()->Type());
+ myGlContext->SetLineWidth (myDefaultAspectLine->Aspect()->Width());
}
// =======================================================================
// =======================================================================
Graphic3d_PolygonOffset OpenGl_Workspace::SetDefaultPolygonOffset (const Graphic3d_PolygonOffset& theOffset)
{
- Graphic3d_PolygonOffset aPrev = myDefaultAspectFace.Aspect()->PolygonOffset();
- myDefaultAspectFace.Aspect()->SetPolygonOffset (theOffset);
- if (myAspectFaceApplied == myDefaultAspectFace.Aspect()
+ Graphic3d_PolygonOffset aPrev = myDefaultAspectFace->Aspect()->PolygonOffset();
+ myDefaultAspectFace->Aspect()->SetPolygonOffset (theOffset);
+ if (myAspectFaceApplied == myDefaultAspectFace->Aspect()
|| myAspectFaceApplied.IsNull()
|| (myAspectFaceApplied->PolygonOffset().Mode & Aspect_POM_None) == Aspect_POM_None)
{
// function : SetAspectLine
// purpose :
// =======================================================================
-const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
+void OpenGl_Workspace::SetAspectLine (const Handle(OpenGl_AspectLine)& theAspect)
{
- const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
myAspectLineSet = theAspect;
- return aPrevAspectLine;
}
// =======================================================================
// function : SetAspectFace
// purpose :
// =======================================================================
-const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
+void OpenGl_Workspace::SetAspectFace (const Handle(OpenGl_AspectFace)& theAspect)
{
- const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
myAspectFaceSet = theAspect;
- return aPrevAspectFace;
}
// =======================================================================
// function : SetAspectMarker
// purpose :
// =======================================================================
-const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
+void OpenGl_Workspace::SetAspectMarker (const Handle(OpenGl_AspectMarker)& theAspect)
{
- const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
myAspectMarkerSet = theAspect;
- return aPrevAspectMarker;
}
// =======================================================================
// function : SetAspectText
// purpose :
// =======================================================================
-const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
+void OpenGl_Workspace::SetAspectText (const Handle(OpenGl_AspectText)& theAspect)
{
- const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
myAspectTextSet = theAspect;
- return aPrevAspectText;
}
// =======================================================================
// function : ApplyAspectFace
// purpose :
// =======================================================================
-const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
+const Handle(OpenGl_AspectFace)& OpenGl_Workspace::ApplyAspectFace()
{
if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
{
if (myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HIDDENLINE)
{
// copy all values including line edge aspect
- *myAspectFaceHl.Aspect() = *myAspectFaceSet->Aspect();
- myAspectFaceHl.SetAspectEdge (myAspectFaceSet->AspectEdge());
- myAspectFaceHl.Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
- myAspectFaceHl.Aspect()->SetInteriorColor (myView->BackgroundColor().GetRGB());
- myAspectFaceHl.SetNoLighting();
- myAspectFaceSet = &myAspectFaceHl;
+ myAspectFaceHl->SetAspect (myAspectFaceSet->Aspect());
+ myAspectFaceHl->SetAspectEdge (myAspectFaceSet->AspectEdge());
+ myAspectFaceHl->Aspect()->SetShadingModel (Graphic3d_TOSM_UNLIT);
+ myAspectFaceHl->Aspect()->SetInteriorColor (myView->BackgroundColor().GetRGB());
+ myAspectFaceHl->SetNoLighting();
+ myAspectFaceSet = myAspectFaceHl;
}
else
{
// function : ApplyAspectMarker
// purpose :
// =======================================================================
-const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
+const Handle(OpenGl_AspectMarker)& OpenGl_Workspace::ApplyAspectMarker()
{
if (myAspectMarkerSet->Aspect() != myAspectMarkerApplied)
{
// function : ShouldRender
// purpose :
// =======================================================================
-bool OpenGl_Workspace::ShouldRender (const OpenGl_Element* theElement)
+bool OpenGl_Workspace::ShouldRender (const Handle(OpenGl_Element)& theElement)
{
// render only non-raytracable elements when RayTracing is enabled
if ((myRenderFilter & OpenGl_RenderFilter_NonRaytraceableOnly) != 0)
{
if (!theElement->IsFillDrawMode())
{
- if (dynamic_cast<const OpenGl_AspectFace*> (theElement) == NULL)
+ if (Handle(OpenGl_AspectFace)::DownCast(theElement).IsNull())
{
return false;
}
}
//! Currently set line aspect (can differ from applied).
- const OpenGl_AspectLine* AspectLine() const { return myAspectLineSet; }
+ const Handle(OpenGl_AspectLine)& AspectLine() const { return myAspectLineSet; }
//! Currently set face aspect (can differ from applied).
- const OpenGl_AspectFace* AspectFace() const { return myAspectFaceSet; }
+ const Handle(OpenGl_AspectFace)& AspectFace() const { return myAspectFaceSet; }
//! Currently set marker aspect (can differ from applied).
- const OpenGl_AspectMarker* AspectMarker() const { return myAspectMarkerSet; }
+ const Handle(OpenGl_AspectMarker)& AspectMarker() const { return myAspectMarkerSet; }
//! Currently set text aspect (can differ from applied).
- const OpenGl_AspectText* AspectText() const { return myAspectTextSet; }
+ const Handle(OpenGl_AspectText)& AspectText() const { return myAspectTextSet; }
//! Assign new line aspect (will be applied within ApplyAspectLine()).
- Standard_EXPORT const OpenGl_AspectLine* SetAspectLine (const OpenGl_AspectLine* theAspect);
+ Standard_EXPORT void SetAspectLine (const Handle(OpenGl_AspectLine)& theAspect);
//! Assign new face aspect (will be applied within ApplyAspectFace()).
- Standard_EXPORT const OpenGl_AspectFace* SetAspectFace (const OpenGl_AspectFace* theAspect);
+ Standard_EXPORT void SetAspectFace (const Handle(OpenGl_AspectFace)& theAspect);
//! Assign new marker aspect (will be applied within ApplyAspectMarker()).
- Standard_EXPORT const OpenGl_AspectMarker* SetAspectMarker (const OpenGl_AspectMarker* theAspect);
+ Standard_EXPORT void SetAspectMarker (const Handle(OpenGl_AspectMarker)& theAspect);
//! Assign new text aspect (will be applied within ApplyAspectText()).
- Standard_EXPORT const OpenGl_AspectText* SetAspectText (const OpenGl_AspectText* theAspect);
+ Standard_EXPORT void SetAspectText (const Handle(OpenGl_AspectText)& theAspect);
//! Apply line aspect.
//! @return aspect set by SetAspectLine()
- const OpenGl_AspectLine* ApplyAspectLine() { return myAspectLineSet; }
+ const Handle(OpenGl_AspectLine)& ApplyAspectLine() { return myAspectLineSet; }
//! Apply face aspect.
//! @return aspect set by SetAspectFace()
- Standard_EXPORT const OpenGl_AspectFace* ApplyAspectFace();
+ Standard_EXPORT const Handle(OpenGl_AspectFace)& ApplyAspectFace();
//! Apply marker aspect.
//! @return aspect set by SetAspectMarker()
- Standard_EXPORT const OpenGl_AspectMarker* ApplyAspectMarker();
+ Standard_EXPORT const Handle(OpenGl_AspectMarker)& ApplyAspectMarker();
//! Apply text aspect.
//! @return aspect set by SetAspectText()
- const OpenGl_AspectText* ApplyAspectText() { return myAspectTextSet; }
+ const Handle(OpenGl_AspectText)& ApplyAspectText() { return myAspectTextSet; }
//! Clear the applied aspect state to default values.
void ResetAppliedAspect();
//! Checks whether the element can be rendered or not.
//! @param theElement [in] the element to check
//! @return True if element can be rendered
- bool ShouldRender (const OpenGl_Element* theElement);
+ bool ShouldRender (const Handle(OpenGl_Element)& theElement);
//! Return the number of skipped transparent elements within active OpenGl_RenderFilter_OpaqueOnly filter.
//! @sa OpenGl_LayerList::Render()
inline const OpenGl_Matrix* ModelMatrix() const { return StructureMatrix_applied; }
//! Returns face aspect for textured font rendering.
- const OpenGl_AspectFace& FontFaceAspect() const { return myFontFaceAspect; }
+ const Handle(OpenGl_AspectFace)& FontFaceAspect() const { return myFontFaceAspect; }
//! Returns face aspect for none culling mode.
- const OpenGl_AspectFace& NoneCulling() const { return myNoneCulling; }
+ const Handle(OpenGl_AspectFace)& NoneCulling() const { return myNoneCulling; }
//! Returns face aspect for front face culling mode.
- const OpenGl_AspectFace& FrontCulling() const { return myFrontCulling; }
+ const Handle(OpenGl_AspectFace)& FrontCulling() const { return myFrontCulling; }
//! Sets a new environment texture.
void SetEnvironmentTexture (const Handle(OpenGl_TextureSet)& theTexture) { myEnvironmentTexture = theTexture; }
Handle(OpenGl_Context) myGlContext;
Standard_Boolean myUseZBuffer;
Standard_Boolean myUseDepthWrite;
- OpenGl_AspectFace myNoneCulling;
- OpenGl_AspectFace myFrontCulling;
- OpenGl_AspectFace myFontFaceAspect;
+ Handle(OpenGl_AspectFace) myNoneCulling;
+ Handle(OpenGl_AspectFace) myFrontCulling;
+ Handle(OpenGl_AspectFace) myFontFaceAspect;
protected: //! @name fields related to status
Standard_Integer myNbSkippedTranspElems; //!< counter of skipped transparent elements for OpenGl_LayerList two rendering passes method
Standard_Integer myRenderFilter; //!< active filter for skipping rendering of elements by some criteria (multiple render passes)
- OpenGl_AspectLine myDefaultAspectLine;
- OpenGl_AspectFace myDefaultAspectFace;
- OpenGl_AspectMarker myDefaultAspectMarker;
- OpenGl_AspectText myDefaultAspectText;
+ Handle(OpenGl_AspectLine) myDefaultAspectLine;
+ Handle(OpenGl_AspectFace) myDefaultAspectFace;
+ Handle(OpenGl_AspectMarker) myDefaultAspectMarker;
+ Handle(OpenGl_AspectText) myDefaultAspectText;
- const OpenGl_AspectLine* myAspectLineSet;
- const OpenGl_AspectFace* myAspectFaceSet;
+ Handle(OpenGl_AspectLine) myAspectLineSet;
+ Handle(OpenGl_AspectFace) myAspectFaceSet;
Handle(Graphic3d_AspectFillArea3d) myAspectFaceApplied;
- const OpenGl_AspectMarker* myAspectMarkerSet;
+ Handle(OpenGl_AspectMarker) myAspectMarkerSet;
Handle(Graphic3d_AspectMarker3d) myAspectMarkerApplied;
- const OpenGl_AspectText* myAspectTextSet;
+ Handle(OpenGl_AspectText) myAspectTextSet;
Handle(Graphic3d_PresentationAttributes) myAspectFaceAppliedWithHL;
const OpenGl_Matrix* ViewMatrix_applied;
OpenGl_Matrix myModelViewMatrix; //!< Model matrix with applied structure transformations
- OpenGl_AspectFace myAspectFaceHl; //!< Hiddenline aspect
+ Handle(OpenGl_AspectFace) myAspectFaceHl; //!< Hiddenline aspect
Handle(OpenGl_TextureSet) myEnvironmentTexture;
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
// To test linking against OpenGl_Workspace and all aspect classes
- const OpenGl_AspectMarker* aMA = theWorkspace->AspectMarker();
+ const Handle(OpenGl_AspectMarker)& aMA = theWorkspace->AspectMarker();
aMA->Aspect()->Type();
- const OpenGl_AspectText* aTA = theWorkspace->AspectText();
+ const Handle(OpenGl_AspectText)& aTA = theWorkspace->AspectText();
aTA->Aspect()->Font();
OpenGl_Vec4 aColor = theWorkspace->LineColor();
return 0;
int aNbElements = 0;
- for (const OpenGl_ElementNode* aNodeIter = anOpenGlGroup->FirstNode(); aNodeIter != NULL; aNodeIter = aNodeIter->next)
+ for (OpenGl_ElementNodes::Iterator anElemIter (anOpenGlGroup->GetElements()); anElemIter.More(); anElemIter.Next())
{
aNbElements++;
}
{
case 0: return theItemRole == Qt::DisplayRole ? aGroup->DynamicType()->Name()
: STANDARD_TYPE (Graphic3d_Group)->Name();
- case 1:
- return rowCount();
- case 2:
- return ViewControl_Tools::GetPointerInfo (aGroup, true).ToCString();
default:
break;
}
// function : GetElementNode
// purpose :
// =======================================================================
-OpenGl_Element* VInspector_ItemGraphic3dGroup::GetElementNode (const int theRowId) const
+Handle(OpenGl_Element) VInspector_ItemGraphic3dGroup::GetElementNode (const int theRowId) const
{
int aCurrentIndex = 0;
Handle(Graphic3d_Group) aGroup = GetGroup();
Handle(OpenGl_Group) anOpenGlGroup = Handle(OpenGl_Group)::DownCast(aGroup);
if (anOpenGlGroup.IsNull())
- return 0;
- for (const OpenGl_ElementNode* aNodeIter = anOpenGlGroup->FirstNode(); aNodeIter != NULL; aNodeIter = aNodeIter->next)
+ return NULL;
+ for (OpenGl_ElementNodes::Iterator anElemIter (anOpenGlGroup->GetElements()); anElemIter.More(); anElemIter.Next())
{
if (theRowId == aCurrentIndex)
- return aNodeIter->elem;
+ return anElemIter.Value();
aCurrentIndex++;
}
- return 0;
+ return NULL;
}
// =======================================================================
//! Returns element node or NULL
//! \param theRowId row index
//! \return element node
- OpenGl_Element* GetElementNode(const int theRowId) const;
+ Standard_EXPORT Handle(OpenGl_Element) GetElementNode(const int theRowId) const;
//! Returns number of table rows
//! \return an integer value
#include <QStringList>
#include <Standard_WarningsRestore.hxx>
-// =======================================================================
-// function : GetGroup
-// purpose :
-// =======================================================================
-OpenGl_Element* VInspector_ItemOpenGlElement::GetElement() const
-{
- initItem();
- return myElement;
-}
-
// =======================================================================
// function : Init
// purpose :
void VInspector_ItemOpenGlElement::Reset()
{
VInspector_ItemBase::Reset();
- myElement = 0;
+ myElement = NULL;
}
// =======================================================================
if (theItemRole != Qt::DisplayRole && theItemRole != Qt::EditRole && theItemRole != Qt::ToolTipRole)
return QVariant();
- OpenGl_Element* anElement = GetElement();
- if (anElement == 0)
+ Handle(OpenGl_Element) anElement = GetElement();
+ if (anElement.IsNull())
return Column() == 0 ? "Empty element" : "";
switch (Column())
{
case 0:
{
- if (theItemRole != Qt::ToolTipRole)
- return "OpenGl_Element";
-
- VInspector_ElementKind aKind = GetElementKind();
- if (aKind == VInspector_ElementKind_PrimitiveArray) return "OpenGl_PrimitiveArray";
- else if (aKind == VInspector_ElementKind_Text) return "OpenGl_Text";
- else return "OpenGl_Element";
+ return theItemRole == Qt::ToolTipRole ? QVariant ("")
+ : QVariant (anElement->DynamicType()->Name());
}
- case 1:
- return rowCount();
- case 2:
- return ViewControl_Tools::GetPointerInfo (anElement, true).ToCString();
default:
break;
}
if (theRole != Qt::DisplayRole)
return QVariant();
- OpenGl_Element* anElement = GetElement();
- if (anElement == 0)
+ Handle(OpenGl_Element) anElement = GetElement();
+ if (anElement.IsNull())
return QVariant();
bool isFirstColumn = theColumn == 0;
- VInspector_ElementKind aKind = GetElementKind();
- if (aKind == VInspector_ElementKind_PrimitiveArray)
+ if (!Handle(OpenGl_PrimitiveArray)::DownCast (anElement).IsNull())
{
- OpenGl_PrimitiveArray* aCElement = dynamic_cast<OpenGl_PrimitiveArray*>(anElement);
+ Handle(OpenGl_PrimitiveArray) aCElement = Handle(OpenGl_PrimitiveArray)::DownCast (anElement);
switch (theRow)
{
case 0: return isFirstColumn ? QVariant ("IsInitialized") : QVariant (aCElement->IsInitialized());
: !aCElement->AttributesVbo().IsNull() ? QVariant (ViewControl_Tools::GetPointerInfo (aCElement->AttributesVbo()).ToCString()) : QVariant();
case 6: return isFirstColumn ? QVariant ("Indices") : VInspector_Tools::ToVariant (aCElement->Indices());
- case 7:
- {
- const Handle(Graphic3d_Buffer)& anAttributes = aCElement->Attributes();
- return isFirstColumn ? QVariant ("Attributes") : VInspector_Tools::ToVariant (aCElement->Attributes());
- }
+ case 7: return isFirstColumn ? QVariant ("Attributes") : VInspector_Tools::ToVariant (aCElement->Attributes());
case 8: return isFirstColumn ? QVariant ("Bounds") : VInspector_Tools::ToVariant (aCElement->Bounds());
default: return QVariant();
}
}
- else if (aKind == VInspector_ElementKind_Text)
+ else if (!Handle(OpenGl_Text)::DownCast (anElement).IsNull())
{
- OpenGl_Text* aCmElement = dynamic_cast<OpenGl_Text*>(anElement);
+ Handle(OpenGl_Text) aCmElement = Handle(OpenGl_Text)::DownCast (anElement);
switch (theRow)
{
case 0:
// =======================================================================
TreeModel_ItemBasePtr VInspector_ItemOpenGlElement::createChild (int theRow, int theColumn)
{
+ (void)theRow;
+ (void)theColumn;
//if (theRow == 0)
// return VInspector_ItemFolderObject::CreateItem (currentItem(), theRow, theColumn);
//else
return TreeModel_ItemBasePtr();
}
-
-// =======================================================================
-// function : GetElementKind
-// purpose :
-// =======================================================================
-VInspector_ItemOpenGlElement::VInspector_ElementKind VInspector_ItemOpenGlElement::GetElementKind() const
-{
- OpenGl_Element* anElement = GetElement();
- if (anElement == 0)
- return VInspector_ElementKind_Undefined;
-
- if (dynamic_cast<OpenGl_PrimitiveArray*>(anElement))
- return VInspector_ElementKind_PrimitiveArray;
- else if (dynamic_cast<OpenGl_Text*>(anElement))
- return VInspector_ElementKind_Text;
-
- return VInspector_ElementKind_Undefined;
-}
#include <Standard.hxx>
#include <inspector/VInspector_ItemBase.hxx>
+#include <OpenGl_Element.hxx>
+
class Graphic3d_Group;
-class OpenGl_Element;
class VInspector_ItemOpenGlElement;
typedef QExplicitlySharedDataPointer<VInspector_ItemOpenGlElement> VInspector_ItemOpenGlElementPtr;
//! Destructor
virtual ~VInspector_ItemOpenGlElement() Standard_OVERRIDE {};
+ //! Returns data object of the item.
+ //! \return object
+ virtual Handle(Standard_Transient) GetObject() const { initItem(); return myElement; }
+
//! Returns the current graphic3d group, init item if it was not initialized yet
//! \return graphic group
- Standard_EXPORT OpenGl_Element* GetElement() const;
+ Handle(OpenGl_Element) GetElement() const { return Handle(OpenGl_Element)::DownCast (GetObject());}
//! Inits the item, fills internal containers
Standard_EXPORT virtual void Init() Standard_OVERRIDE;
virtual TreeModel_ItemBasePtr createChild (int theRow, int theColumn) Standard_OVERRIDE;
private:
- enum VInspector_ElementKind
- {
- VInspector_ElementKind_PrimitiveArray, //!< OpenGl_PrimitiveArray
- VInspector_ElementKind_Text, //!< OpenGl_Text
- VInspector_ElementKind_Undefined //!< another OpenGl_Element kind
- };
-
- //! Returns kind of the current element
- //! \return kind
- VInspector_ElementKind GetElementKind() const;
//! Constructor
//! param theParent a parent item
//! \param theRow the item row positition in the parent item
//! \param theColumn the item column positition in the parent item
VInspector_ItemOpenGlElement(TreeModel_ItemBasePtr theParent, const int theRow, const int theColumn)
- : VInspector_ItemBase(theParent, theRow, theColumn), myElement (0) {}
+ : VInspector_ItemBase(theParent, theRow, theColumn) {}
private:
- OpenGl_Element* myElement; //! current element
+ Handle(OpenGl_Element) myElement; //! current element
};
#endif
Handle(OpenGl_Group) aGroup = Handle(OpenGl_Group)::DownCast (thePrs->NewGroup());
aGroup->SetDestroyElements (Standard_False);
- for (NCollection_List<OpenGl_Element*>::Iterator anElementsIt (myElements); anElementsIt.More(); anElementsIt.Next())
+
+ for (NCollection_List<Handle(OpenGl_Element)>::Iterator anElementsIt (myElements); anElementsIt.More(); anElementsIt.Next())
{
- OpenGl_Element* anElement = anElementsIt.Value();
+ Handle(OpenGl_Element) anElement = anElementsIt.Value();
aGroup->AddElement (anElement);
}
// invalidate bounding box of the scene
//! Fills internal container of elements
//! \param theElements elements to be displayed
- void Set (const NCollection_List<OpenGl_Element*>& theElements) { myElements = theElements; }
+ void Set (const NCollection_List<Handle(OpenGl_Element)>& theElements) { myElements = theElements; }
private:
//! Calculates the 3D view aPresentation and its updates.
DEFINE_STANDARD_RTTIEXT(VInspector_PrsOpenGlElement, AIS_InteractiveObject)
private:
- NCollection_List<OpenGl_Element*> myElements;
+ NCollection_List<Handle(OpenGl_Element)> myElements;
};
#endif
// function : GetSelectedElements
// purpose :
// =======================================================================
-NCollection_List<OpenGl_Element*> VInspector_Window::GetSelectedElements (QItemSelectionModel* theModel)
+NCollection_List<Handle(OpenGl_Element)> VInspector_Window::GetSelectedElements (QItemSelectionModel* theModel)
{
- NCollection_List<OpenGl_Element*> anElements;
+ NCollection_List<Handle(OpenGl_Element)> anElements;
QList<TreeModel_ItemBasePtr> anItems;
QModelIndexList anIndices = theModel->selectedIndexes();
for (QModelIndexList::const_iterator anIndicesIt = anIndices.begin(); anIndicesIt != anIndices.end(); anIndicesIt++)
if (!aVItem)
continue;
- OpenGl_Element* anElement = aVItem->GetElement();
+ Handle(OpenGl_Element) anElement = aVItem->GetElement();
if (!anElement)
continue;
if (myPropertyPanelWidget->toggleViewAction()->isChecked())
updatePropertyPanelBySelection();
+ Handle(Graphic3d_TransformPers) aSelectedPersistent = GetSelectedTransformPers();
NCollection_List<TopoDS_Shape> aSelectedShapes = GetSelectedShapes (myTreeView->selectionModel()->selectedIndexes());
- updatePreviewPresentation(aSelectedShapes, GetSelectedTransformPers());
+ updatePreviewPresentation(aSelectedShapes, aSelectedPersistent);
- NCollection_List<OpenGl_Element*> aSelectedElements = GetSelectedElements (myTreeView->selectionModel());
- updatePreviewPresentation(aSelectedElements);
+ NCollection_List<Handle(OpenGl_Element)> aSelectedElements = GetSelectedElements (myTreeView->selectionModel());
+ updatePreviewPresentation(aSelectedElements, aSelectedPersistent);
QApplication::restoreOverrideCursor();
}
// function : updatePreviewPresentation
// purpose :
// =======================================================================
-void VInspector_Window::updatePreviewPresentation (const NCollection_List<OpenGl_Element*>& theElements)
+void VInspector_Window::updatePreviewPresentation (const NCollection_List<Handle(OpenGl_Element)>& theElements,
+ const Handle(Graphic3d_TransformPers)& thePersistent)
{
Handle(AIS_InteractiveContext) aContext;
VInspector_ViewModel* aViewModel = dynamic_cast<VInspector_ViewModel*> (myTreeView->model());
myOpenGlPreviewPresentation->SetColor (Quantity_Color (Quantity_NOC_BLUE1));
myOpenGlPreviewPresentation->SetZLayer (Graphic3d_ZLayerId_Topmost);
+ myOpenGlPreviewPresentation->SetTransformPersistence(thePersistent);
if (!aContext.IsNull())
aContext->Display (myOpenGlPreviewPresentation, Standard_True);
}
else
{
myOpenGlPreviewPresentation->Set (theElements);
+ myOpenGlPreviewPresentation->SetTransformPersistence(thePersistent);
if (!aContext.IsNull())
aContext->Redisplay (myOpenGlPreviewPresentation, Standard_True);
}
//! Returns selected elements
//! \param theModel selection model
//! \return container of OpenGl elements
- NCollection_List<OpenGl_Element*> GetSelectedElements (QItemSelectionModel* theModel);
+ NCollection_List<Handle(OpenGl_Element)> GetSelectedElements (QItemSelectionModel* theModel);
//! Returns the first not zero transform persistent of selected elements
Handle(Graphic3d_TransformPers) GetSelectedTransformPers();
//!< Updates presentation of preview for OpenGl elements.
//!< \param theElements container of elements
- void updatePreviewPresentation (const NCollection_List<OpenGl_Element*>& theElements);
+ void updatePreviewPresentation (const NCollection_List<Handle(OpenGl_Element)>& theElements,
+ const Handle(Graphic3d_TransformPers)& thePersistent);
private:
projects / occt-copy.git / commitdiff