#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.
aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*thePlane->Orientation()->mat));
aContext->ApplyModelViewMatrix();
- thePlane->Primitives().Render (theWorkspace);
+ thePlane->Primitives()->Render (theWorkspace);
aContext->ModelWorldState.Pop();
aContext->ApplyModelViewMatrix();
theStencilSentry.Init();
// check if capping plane should be rendered within current pass (only opaque / only transparent)
- const OpenGl_AspectFace* anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->AspectFace() : NULL;
- thePlane->Update (aContext, anObjAspectFace != NULL ? anObjAspectFace->Aspect() : Handle(Graphic3d_AspectFillArea3d)());
+ const Handle(OpenGl_AspectFace) anObjAspectFace = aRenderPlane->ToUseObjectProperties() ? aGroupIter.Value()->AspectFace() : NULL;
+ thePlane->Update (aContext, !anObjAspectFace.IsNull() ? anObjAspectFace->Aspect() : Handle(Graphic3d_AspectFillArea3d)());
theWorkspace->SetAspectFace (thePlane->AspectFace());
theWorkspace->SetRenderFilter (aPrevFilter);
- if (!theWorkspace->ShouldRender (&thePlane->Primitives()))
+ if (!theWorkspace->ShouldRender (thePlane->Primitives()))
{
continue;
}
const bool aColorMaskBack = aContext->SetColorMask (false);
// override aspects, disable culling
- theWorkspace->SetAspectFace (&theWorkspace->NoneCulling());
+ theWorkspace->SetAspectFace (theWorkspace->NoneCulling());
theWorkspace->ApplyAspectFace();
// evaluate number of pair faces
}
// override material, cull back faces
- theWorkspace->SetAspectFace (&theWorkspace->FrontCulling());
+ theWorkspace->SetAspectFace (theWorkspace->FrontCulling());
theWorkspace->ApplyAspectFace();
// enable all clip plane except the rendered one
}
// 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();
// purpose :
// =======================================================================
OpenGl_CappingPlaneResource::OpenGl_CappingPlaneResource (const Handle(Graphic3d_ClipPlane)& thePlane)
-: myPrimitives (NULL),
+: myPrimitives (new OpenGl_PrimitiveArray(NULL)),
myOrientation (OpenGl_IdentityMatrix),
myAspect (NULL),
myPlaneRoot (thePlane),
if (anAttribs->Init (12, anAttribInfo, 3))
{
memcpy (anAttribs->ChangeData(), THE_CAPPING_PLN_VERTS, sizeof(THE_CAPPING_PLN_VERTS));
- myPrimitives.InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
+ myPrimitives->InitBuffers (NULL, Graphic3d_TOPA_TRIANGLES, NULL, anAttribs, NULL);
}
}
void OpenGl_CappingPlaneResource::Release (OpenGl_Context* theContext)
{
OpenGl_Element::Destroy (theContext, myAspect);
- myPrimitives.Release (theContext);
+ myPrimitives->Release (theContext);
myEquationMod = (unsigned int )-1;
myAspectMod = (unsigned int )-1;
}
// =======================================================================
void OpenGl_CappingPlaneResource::updateAspect (const Handle(Graphic3d_AspectFillArea3d)& theObjAspect)
{
- if (myAspect == NULL)
+ if (myAspect.IsNull())
{
myAspect = new OpenGl_AspectFace();
myAspectMod = myPlaneRoot->MCountAspect() - 1; // mark out of sync
const Handle(Graphic3d_ClipPlane)& Plane() const { return myPlaneRoot; }
//! @return aspect face for rendering capping surface.
- inline const OpenGl_AspectFace* AspectFace() const { return myAspect; }
+ inline const Handle(OpenGl_AspectFace)& AspectFace() const { return myAspect; }
//! @return evaluated orientation matrix to transform infinite plane.
inline const OpenGl_Matrix* Orientation() const { return &myOrientation; }
//! @return primitive array of vertices to render infinite plane.
- inline const OpenGl_PrimitiveArray& Primitives() const { return myPrimitives; }
+ inline const Handle(OpenGl_PrimitiveArray)& Primitives() const { return myPrimitives; }
private:
private:
- OpenGl_PrimitiveArray myPrimitives; //!< vertices and texture coordinates for rendering
+ Handle(OpenGl_PrimitiveArray) myPrimitives; //!< vertices and texture coordinates for rendering
OpenGl_Matrix myOrientation; //!< plane transformation matrix.
- OpenGl_AspectFace* myAspect; //!< capping face aspect.
+ Handle(OpenGl_AspectFace) myAspect; //!< capping face aspect.
Handle(Graphic3d_ClipPlane) myPlaneRoot; //!< parent clipping plane structure.
Handle(Graphic3d_AspectFillArea3d) myFillAreaAspect; //!< own capping aspect
unsigned int myEquationMod; //!< modification counter for plane equation.
// 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)
{
Handle(OpenGl_Structure) aStruct = Handle(OpenGl_Structure)::DownCast (myStructure->CStructure());
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
void OpenGl_Group::Release (const Handle(OpenGl_Context)& theGlCtx)
{
// Delete elements
- 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_Group;
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; }
//! Is the group ray-tracable (contains ray-tracable elements)?
Standard_Boolean IsRaytracable() const { return myIsRaytracable; }
protected:
- OpenGl_AspectLine* myAspectLine;
- OpenGl_AspectFace* myAspectFace;
- OpenGl_AspectMarker* myAspectMarker;
- OpenGl_AspectText* myAspectText;
+ Handle(OpenGl_AspectLine) myAspectLine;
+ Handle(OpenGl_AspectFace) myAspectFace;
+ Handle(OpenGl_AspectMarker) myAspectMarker;
+ Handle(OpenGl_AspectText) myAspectText;
- OpenGl_ElementNode* myFirst;
- OpenGl_ElementNode* myLast;
+ OpenGl_ElementNodes myElements;
Standard_Boolean myIsRaytracable;
// 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 TCollection_AsciiString& aFontName = theAspect.Aspect()->Font();
- Font_FontAspect anAspect = theAspect.Aspect()->GetTextFontAspect() != Font_FA_Undefined
- ? theAspect.Aspect()->GetTextFontAspect()
+ const TCollection_AsciiString& aFontName = theAspect->Aspect()->Font();
+ Font_FontAspect anAspect = theAspect->Aspect()->GetTextFontAspect() != Font_FA_Undefined
+ ? theAspect->Aspect()->GetTextFontAspect()
: Font_FA_Regular;
Handle(Font_FTFont) aFontFt;
if (Handle(Font_SystemFont) aRequestedFont = aFontMgr->FindFont (aFontName, anAspect))
{
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->FontPathAny (anAspect);
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)
{
// 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;
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();
projects / occt-copy.git / commitdiff