====== CRenderData ======

**//Inherited from//**  [[class::cobserver|CObserver]],

**//Inherited by//**  NULL

**//Friend class//**  NULL

**//Description//**

**//Members//**
  * unordered_set<TCursor>& [[crenderdata#targetbodies|targetBodies]]
**//Public interface//**
  * [[crenderdata#crenderdata1|CRenderData]](CDBSession* pDBSession)
  * virtual [[crenderdata#~crenderdata|~CRenderData]](void)
  * void [[crenderdata#clear|Clear]]()
  * void [[crenderdata#onupdatedb|OnUpdateDB]](CDBSession* pDBSession)
  * void [[crenderdata#updatevbo|UpdateVBO]](CDBSession* pDBSession, CMapDataFaceTo2DProp* faceTo2DProp)
  * void [[crenderdata#updatevboformeshlayer|UpdateVBOForMeshLayer]](CDBSession* pDBSession)
  * void [[crenderdata#updatevboonnormaldisplay|UpdateVBOOnNormalDisplay]](CDBSession* pDBSession)
  * void [[crenderdata#updatevboforfaces|UpdateVBOForFaces]](vector<const DFace*> faces)
  * void [[crenderdata#rebuildvbo|RebuildVBO]](CDBSession* pDBSession)
  * void [[crenderdata#rebuildvboforbody|RebuildVBOForBody]](CDBSession* pDBSession, const DBody* pBody)
  * void [[crenderdata#rebuildvboforbody|RebuildVBOForBody]](CDBSession* pDBSession, vector<const DBody*> &updatedVBOBodies)
  * void [[crenderdata#updatelbcmarkup|UpdateLBCMarkup]]( CDBSession* pDBSession )
  * void [[crenderdata#updatedelayedvbo|UpdateDelayedVBO]]()
  * void [[crenderdata#updatemarkup|UpdateMarkup]]()
  * void [[crenderdata#setglactivator|setGLActivator]](IGLActivator* val)
  * void [[crenderdata#glactivate|GLActivate]]()
  * void [[crenderdata#gldeactivate|GLDeactivate]]()
  * CDBSession* [[crenderdata#getdbsession|GetDBSession]]()
  * CModelRenderData* [[crenderdata#getmodelrenderdata|GetModelRenderData]]()
  * CMeshLayer* [[crenderdata#getmeshlayer|GetMeshLayer]]()
  * CUXDraw* [[crenderdata#getuxdraw|GetUXDraw]]()
  * CMarkupHandler* [[crenderdata#getmarkuphandler|GetMarkupHandler]]()
  * CRenderMapData* [[crenderdata#getrendermapdata|GetRenderMapData]]()
  * CLegendManager* [[crenderdata#getlegendmanager|GetLegendManager]]()
  * void [[crenderdata#setrendermapdata|SetRenderMapData]](CRenderMapData* pRenderMapData)
  * CModelVBOManager* [[crenderdata#getmodelvbomanager|GetModelVBOManager]]()
  * void [[crenderdata#updateshowhide|UpdateShowHide]](const TArray<TCursor>& crUpdates)
  * void [[crenderdata#updateshowhideref|UpdateShowHideRef]](TArray<TCursor>& crUpdates)
  * void [[crenderdata#updateshowhidebodies|UpdateShowHideBodies]](vector<const DBody*>& bodies)
  * void [[crenderdata#updateshowhidefaces|UpdateShowHideFaces]](vector<const DFace*>& faces)
  * void [[crenderdata#updateshowhideedges|UpdateShowHideEdges]](vector<const DEdge*>& edges)
  * void [[crenderdata#updateshowhidesolid|UpdateShowHideSolid]](vector<const DSolid*>& Solid)
  * void [[crenderdata#updateshowhidelbc|UpdateShowHideLBC]](const array<unordered_set<TCursor>, num_ux_lbc_support>& LBCs)
  * void [[crenderdata#updateshowhidepostfreqandtrans|UpdateShowHidePostFreqAndTrans]](const vector<unordered_set<TCursor>> &crItems)
  * void [[crenderdata#updatetransparency|UpdateTransparency]](vector<const DBody*>& bodies)
  * void [[crenderdata#updatebodydispinfo|UpdateBodyDispInfo]](vector<const DBody*>& bodies, BodyDispUpdateInfo& bodyDispInfo)
  * void [[crenderdata#updatereftransparency|UpdateRefTransparency]](vector<const DRefBody*>& bodies)
  * void [[crenderdata#updaterefbodydispinfo|UpdateRefBodyDispInfo]](vector<const DRefBody*>& bodies, BodyDispUpdateInfo& bodyDispInfo)
  * void [[crenderdata#updateshowhidebodiedatas|UpdateShowHideBodieDatas]](vector<const DBody*>& bodies, BOOL bDisplay = FALSE)
  * void [[crenderdata#resetshowhidebodiedatas|ResetShowHideBodieDatas]](vector<const DBody*>& bodies)
  * void [[crenderdata#resetshowhidebodiedatas|ResetShowHideBodieDatas]]()
  * void [[crenderdata#showallgroupmarker|ShowAllGroupMarker]]()
  * bool [[crenderdata#updatetexcoordvbo|UpdateTexCoordVBO]]()
  * bool [[crenderdata#updatetexcoordvboforisovol|UpdateTexCoordVBOForIsoVol]]()
  * bool [[crenderdata#updatevbotranparency|UpdateVBOTranparency]](const unordered_set<TCursor>& ShowOnlyElems, double dTranparencyVal = 0.2)
  * bool [[crenderdata#resetvbotranparency|ResetVBOTranparency]]()
  * bool [[crenderdata#updatevbobyoffsetvector|UpdateVBObyOffsetVector]](bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)
  * bool [[crenderdata#updatevbobyoffsetvector|UpdateVBObyOffsetVector]](const DBody* pBody, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)
  * bool [[crenderdata#updatevbobyoffsetvector|UpdateVBObyOffsetVector]](vector<const DBody*>& updatedBodies, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)
  * bool [[crenderdata#resetvbooffsetvector|ResetVBOOffsetVector]](const DBody* pBody, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)
  * bool [[crenderdata#resetvbooffsetvector|ResetVBOOffsetVector]](vector<const DBody*>& updatedBodies, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)
  * bool [[crenderdata#updatevbodeformation|UpdateVBODeformation]]()
  * bool [[crenderdata#updatediagramvbodata|UpdateDiagramVBOData]]()
  * bool [[crenderdata#updatediagramvbodata|UpdateDiagramVBOData]](const unordered_set<TCursor>& ShowOnlyElems, double dTrans = 1.0)
  * void [[crenderdata#updatevbocontourtransparency|UpdateVBOContourTransparency]](bool bShowBeamDiagram)
  * void [[crenderdata#updatevbohidecontour|UpdateVBOHideContour]](bool bShowBeamDiagram, vector<const DBody*>& updatedContourBodies)
  * void [[crenderdata#updateadjacentshowpreviewvbodata|UpdateAdjacentShowPreviewVBOData]]()
  * void [[crenderdata#updateadjacentshowpreviewelementvbodata|UpdateAdjacentShowPreviewElementVBOData]]()
  * void [[crenderdata#updatevbodataforshrinkmode|UpdateVBODataForShrinkMode]]()
  * void [[crenderdata#updateclosedfaceedgeboundary|UpdateClosedFaceEdgeBoundary]]()
  * void [[crenderdata#updateclosedfaceedgeselected|UpdateClosedFaceEdgeSelected]]()
  * void [[crenderdata#updateclosedface|UpdateClosedFace]]()
  * void [[crenderdata#updatecustomizeddata|UpdateCustomizedData]]()
  * void [[crenderdata#addupdatedbody|AddUpdatedBody]](TCursor cr)
  * ARROW* [[crenderdata#getarrowdata|GetArrowData]]()
  * TVector3f [[crenderdata#getnodedisplayposition|GetNodeDisplayPosition]](TCursor crNode)
  * TVector3d [[crenderdata#getnodedeformcoordinate|GetNodeDeformCoordinate]](TCursor crNode)
  * bool [[crenderdata#ismeshcleanupmode|IsMeshCleanupMode]]() const
  * void [[crenderdata#setmeshcleanupmode|SetMeshCleanupMode]](bool val)
  * void [[crenderdata#addfacetoshownormal|AddFaceToShowNormal]](const DFace* pFace)
  * unordered_set<const DFace*>& [[crenderdata#getfacestoshownormal|GetFacesToShowNormal]]()
  * void [[crenderdata#clearfacestoshownormal|ClearFacesToShowNormal]]()
  * void [[crenderdata#updatefacestoshownormal|UpdateFacesToShowNormal]](CDBSession* pDBSession)
  * void [[crenderdata#updatetransparentbodies|UpdateTransparentBodies]](CDBSession* pDBSession)
  * void [[crenderdata#updatetransparentrefbodies|UpdateTransparentRefBodies]](CDBSession * pDBSession)
  * unordered_set<const DBody*>& [[crenderdata#gettransparentbodies|GetTransparentBodies]]()
  * unordered_set<const DRefBody*>& [[crenderdata#gettransparentrefbodies|GetTransparentRefBodies]]()
  * void [[crenderdata#addtransparentbody|AddTransparentBody]](const DBody* pBody)
  * void [[crenderdata#removetransparentbody|RemoveTransparentBody]](const DBody* pBody)
  * void [[crenderdata#addtransparentrefbody|AddTransparentRefBody]](const DRefBody* pBody)
  * void [[crenderdata#removetransparentrefbody|RemoveTransparentRefBody]](const DRefBody* pBody)
  * void [[crenderdata#hideelements|HideElements]]( TArray<TCursor>& crElements )
  * void [[crenderdata#showelements|ShowElements]]( TArray<TCursor>& crElements )
  * void [[crenderdata#inversehideelements|InverseHideElements]]( TArray<TCursor>& crElements )
  * virtual int [[crenderdata#updateobserver|UpdateObserver]](CSubject* pSubject, UINT Msg, WPARAM wParam, LPARAM lParam)
  * void [[crenderdata#onupdateselecteditems|OnUpdateSelectedItems]](CTargetSet* pTargetSet)
  * CSelectVBO& [[crenderdata#getselectvbo|GetSelectVBO]]()
  * CBeamDiagramVBO& [[crenderdata#getbeamdiagramvbo|GetBeamDiagramVBO]]()
  * void [[crenderdata#glupdatesharedface|GLUpdateSharedFace]]()
  * unordered_set<TCursor>& [[crenderdata#getsharedfaces|GetSharedFaces]] ()
  * void [[crenderdata#glupdatesharednodevbo|GLUpdateSharedNodeVBO]]()
  * VBO<GLfloat>& [[crenderdata#getsharednodevbo|GetSharedNodeVBO]] ()
  * void [[crenderdata#glupdatesharedelemvbo|GLUpdateSharedElemVBO]]()
  * static void [[crenderdata#findsharedelemsbysharednode|FindSharedElemsBySharedNode]](
  * unordered_set<TCursor>& [[crenderdata#getsharednodeelems|GetSharedNodeElems]] ()
  * unordered_set<TCursor>& [[crenderdata#getsharedelemfaces|GetSharedElemFaces]] ()
  * VBO<GLfloat>& [[crenderdata#getsharedelemnodesvbo|GetSharedElemNodesVBO]] ()
  * void [[crenderdata#invalidatesharedelem|InvalidateSharedElem]]()
  * void [[crenderdata#settargetofsharedelem|SetTargetOfSharedElem]](TArray<TCursor>& targets)
  * void [[crenderdata#setsolidmode|SetSolidMode]](bool val)
  * void [[crenderdata#buildvboforsolidmode|BuildVBOforSolidMode]](CDBSession* pDBSession, const unordered_set<const DBody*> &Bodies,
  * CSolidVBOManager* [[crenderdata#getsolidvbomanager|GetSolidVBOManager]]()
  * CRenderSectionData* [[crenderdata#getsectiondata|GetSectionData]]()
  * CGroupRenderSectionData* [[crenderdata#getgroupsectiondata|GetGroupSectionData]]()
  * CGroupVBOManager* [[crenderdata#getgrouprenderdata|GetGroupRenderData]]()

----

{{anchor:targetbodies}}
**unordered_set<TCursor>& targetBodies**

----

{{anchor:crenderdata1}}
**CRenderData(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:~crenderdata}}
**virtual ~CRenderData(void)**
  *function: 
  *parameters: 
    - [i] void: 
  *return value: 

{{anchor:clear}}
**void Clear()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:onupdatedb}}
**void OnUpdateDB(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:updatevbo}}
**void UpdateVBO(CDBSession* pDBSession, CMapDataFaceTo2DProp* faceTo2DProp)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
    - [i] CMapDataFaceTo2DProp* faceTo2DProp: 
  *return value: 

{{anchor:updatevboformeshlayer}}
**void UpdateVBOForMeshLayer(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:updatevboonnormaldisplay}}
**void UpdateVBOOnNormalDisplay(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:updatevboforfaces}}
**void UpdateVBOForFaces(vector<const DFace*> faces)**
  *function: 
  *parameters: 
    - [i] vector<const DFace*> faces: 
  *return value: 

{{anchor:rebuildvbo}}
**void RebuildVBO(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:rebuildvboforbody}}
**void RebuildVBOForBody(CDBSession* pDBSession, const DBody* pBody)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
    - [i] const DBody* pBody: 
  *return value: 

{{anchor:rebuildvboforbody}}
**void RebuildVBOForBody(CDBSession* pDBSession, vector<const DBody*> &updatedVBOBodies)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
    - [i] vector<const DBody*> &updatedVBOBodies: 
  *return value: 

{{anchor:updatelbcmarkup}}
**void UpdateLBCMarkup( CDBSession* pDBSession )**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession : 
  *return value: 

{{anchor:updatedelayedvbo}}
**void UpdateDelayedVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatemarkup}}
**void UpdateMarkup()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:setglactivator}}
**void setGLActivator(IGLActivator* val)**
  *function: 
  *parameters: 
    - [i] IGLActivator* val: 
  *return value: 

{{anchor:glactivate}}
**void GLActivate()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldeactivate}}
**void GLDeactivate()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getdbsession}}
**CDBSession* GetDBSession()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getmodelrenderdata}}
**CModelRenderData* GetModelRenderData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getmeshlayer}}
**CMeshLayer* GetMeshLayer()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getuxdraw}}
**CUXDraw* GetUXDraw()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getmarkuphandler}}
**CMarkupHandler* GetMarkupHandler()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getrendermapdata}}
**CRenderMapData* GetRenderMapData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getlegendmanager}}
**CLegendManager* GetLegendManager()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:setrendermapdata}}
**void SetRenderMapData(CRenderMapData* pRenderMapData)**
  *function: 
  *parameters: 
    - [i] CRenderMapData* pRenderMapData: 
  *return value: 

{{anchor:getmodelvbomanager}}
**CModelVBOManager* GetModelVBOManager()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updateshowhide}}
**void UpdateShowHide(const TArray<TCursor>& crUpdates)**
  *function: 
  *parameters: 
    - [i] const TArray<TCursor>& crUpdates: 
  *return value: 

{{anchor:updateshowhideref}}
**void UpdateShowHideRef(TArray<TCursor>& crUpdates)**
  *function: 
  *parameters: 
    - [i] TArray<TCursor>& crUpdates: 
  *return value: 

{{anchor:updateshowhidebodies}}
**void UpdateShowHideBodies(vector<const DBody*>& bodies)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& bodies: 
  *return value: 

{{anchor:updateshowhidefaces}}
**void UpdateShowHideFaces(vector<const DFace*>& faces)**
  *function: 
  *parameters: 
    - [i] vector<const DFace*>& faces: 
  *return value: 

{{anchor:updateshowhideedges}}
**void UpdateShowHideEdges(vector<const DEdge*>& edges)**
  *function: 
  *parameters: 
    - [i] vector<const DEdge*>& edges: 
  *return value: 

{{anchor:updateshowhidesolid}}
**void UpdateShowHideSolid(vector<const DSolid*>& Solid)**
  *function: 
  *parameters: 
    - [i] vector<const DSolid*>& Solid: 
  *return value: 

{{anchor:updateshowhidelbc}}
**void UpdateShowHideLBC(const array<unordered_set<TCursor>, num_ux_lbc_support>& LBCs)**
  *function: 
  *parameters: 
    - [i] const array<unordered_set<TCursor>: 
    - [i] num_ux_lbc_support>& LBCs: 
  *return value: 

{{anchor:updateshowhidepostfreqandtrans}}
**void UpdateShowHidePostFreqAndTrans(const vector<unordered_set<TCursor>> &crItems)**
  *function: 
  *parameters: 
    - [i] const vector<unordered_set<TCursor>> &crItems: 
  *return value: 

{{anchor:updatetransparency}}
**void UpdateTransparency(vector<const DBody*>& bodies)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& bodies: 
  *return value: 

{{anchor:updatebodydispinfo}}
**void UpdateBodyDispInfo(vector<const DBody*>& bodies, BodyDispUpdateInfo& bodyDispInfo)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& bodies: 
    - [i] BodyDispUpdateInfo& bodyDispInfo: 
  *return value: 

{{anchor:updatereftransparency}}
**void UpdateRefTransparency(vector<const DRefBody*>& bodies)**
  *function: 
  *parameters: 
    - [i] vector<const DRefBody*>& bodies: 
  *return value: 

{{anchor:updaterefbodydispinfo}}
**void UpdateRefBodyDispInfo(vector<const DRefBody*>& bodies, BodyDispUpdateInfo& bodyDispInfo)**
  *function: 
  *parameters: 
    - [i] vector<const DRefBody*>& bodies: 
    - [i] BodyDispUpdateInfo& bodyDispInfo: 
  *return value: 

{{anchor:updateshowhidebodiedatas}}
**void UpdateShowHideBodieDatas(vector<const DBody*>& bodies, BOOL bDisplay = FALSE)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& bodies: 
    - [i] BOOL bDisplay = FALSE: 
  *return value: 

{{anchor:resetshowhidebodiedatas}}
**void ResetShowHideBodieDatas(vector<const DBody*>& bodies)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& bodies: 
  *return value: 

{{anchor:resetshowhidebodiedatas}}
**void ResetShowHideBodieDatas()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:showallgroupmarker}}
**void ShowAllGroupMarker()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatetexcoordvbo}}
**bool UpdateTexCoordVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatetexcoordvboforisovol}}
**bool UpdateTexCoordVBOForIsoVol()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatevbotranparency}}
**bool UpdateVBOTranparency(const unordered_set<TCursor>& ShowOnlyElems, double dTranparencyVal = 0.2)**
  *function: 
  *parameters: 
    - [i] const unordered_set<TCursor>& ShowOnlyElems: 
    - [i] double dTranparencyVal = 0.2: 
  *return value: 

{{anchor:resetvbotranparency}}
**bool ResetVBOTranparency()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatevbobyoffsetvector}}
**bool UpdateVBObyOffsetVector(bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)**
  *function: 
  *parameters: 
    - [i] bool bUpdateSurface = true: 
    - [i] bool bUpdateMeshLine = true: 
    - [i] bool bUpdateEdgeLine = true: 
    - [i] bool bUpdateNode = true: 
  *return value: 

{{anchor:updatevbobyoffsetvector}}
**bool UpdateVBObyOffsetVector(const DBody* pBody, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] bool bUpdateSurface = true: 
    - [i] bool bUpdateMeshLine = true: 
    - [i] bool bUpdateEdgeLine = true: 
    - [i] bool bUpdateNode = true: 
  *return value: 

{{anchor:updatevbobyoffsetvector}}
**bool UpdateVBObyOffsetVector(vector<const DBody*>& updatedBodies, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& updatedBodies: 
    - [i] bool bUpdateSurface = true: 
    - [i] bool bUpdateMeshLine = true: 
    - [i] bool bUpdateEdgeLine = true: 
    - [i] bool bUpdateNode = true: 
  *return value: 

{{anchor:resetvbooffsetvector}}
**bool ResetVBOOffsetVector(const DBody* pBody, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] bool bUpdateSurface = true: 
    - [i] bool bUpdateMeshLine = true: 
    - [i] bool bUpdateEdgeLine = true: 
    - [i] bool bUpdateNode = true: 
  *return value: 

{{anchor:resetvbooffsetvector}}
**bool ResetVBOOffsetVector(vector<const DBody*>& updatedBodies, bool bUpdateSurface = true, bool bUpdateMeshLine = true, bool bUpdateEdgeLine = true, bool bUpdateNode = true)**
  *function: 
  *parameters: 
    - [i] vector<const DBody*>& updatedBodies: 
    - [i] bool bUpdateSurface = true: 
    - [i] bool bUpdateMeshLine = true: 
    - [i] bool bUpdateEdgeLine = true: 
    - [i] bool bUpdateNode = true: 
  *return value: 

{{anchor:updatevbodeformation}}
**bool UpdateVBODeformation()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatediagramvbodata}}
**bool UpdateDiagramVBOData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatediagramvbodata}}
**bool UpdateDiagramVBOData(const unordered_set<TCursor>& ShowOnlyElems, double dTrans = 1.0)**
  *function: 
  *parameters: 
    - [i] const unordered_set<TCursor>& ShowOnlyElems: 
    - [i] double dTrans = 1.0: 
  *return value: 

{{anchor:updatevbocontourtransparency}}
**void UpdateVBOContourTransparency(bool bShowBeamDiagram)**
  *function: 
  *parameters: 
    - [i] bool bShowBeamDiagram: 
  *return value: 

{{anchor:updatevbohidecontour}}
**void UpdateVBOHideContour(bool bShowBeamDiagram, vector<const DBody*>& updatedContourBodies)**
  *function: 
  *parameters: 
    - [i] bool bShowBeamDiagram: 
    - [i] vector<const DBody*>& updatedContourBodies: 
  *return value: 

{{anchor:updateadjacentshowpreviewvbodata}}
**void UpdateAdjacentShowPreviewVBOData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updateadjacentshowpreviewelementvbodata}}
**void UpdateAdjacentShowPreviewElementVBOData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatevbodataforshrinkmode}}
**void UpdateVBODataForShrinkMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updateclosedfaceedgeboundary}}
**void UpdateClosedFaceEdgeBoundary()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updateclosedfaceedgeselected}}
**void UpdateClosedFaceEdgeSelected()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updateclosedface}}
**void UpdateClosedFace()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatecustomizeddata}}
**void UpdateCustomizedData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:addupdatedbody}}
**void AddUpdatedBody(TCursor cr)**
  *function: 
  *parameters: 
    - [i] TCursor cr: 
  *return value: 

{{anchor:getarrowdata}}
**ARROW* GetArrowData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getnodedisplayposition}}
**TVector3f GetNodeDisplayPosition(TCursor crNode)**
  *function: 
  *parameters: 
    - [i] TCursor crNode: 
  *return value: 

{{anchor:getnodedeformcoordinate}}
**TVector3d GetNodeDeformCoordinate(TCursor crNode)**
  *function: 
  *parameters: 
    - [i] TCursor crNode: 
  *return value: 

{{anchor:ismeshcleanupmode}}
**bool IsMeshCleanupMode() const**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:setmeshcleanupmode}}
**void SetMeshCleanupMode(bool val)**
  *function: 
  *parameters: 
    - [i] bool val: 
  *return value: 

{{anchor:addfacetoshownormal}}
**void AddFaceToShowNormal(const DFace* pFace)**
  *function: 
  *parameters: 
    - [i] const DFace* pFace: 
  *return value: 

{{anchor:getfacestoshownormal}}
**unordered_set<const DFace*>& GetFacesToShowNormal()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:clearfacestoshownormal}}
**void ClearFacesToShowNormal()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:updatefacestoshownormal}}
**void UpdateFacesToShowNormal(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:updatetransparentbodies}}
**void UpdateTransparentBodies(CDBSession* pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
  *return value: 

{{anchor:updatetransparentrefbodies}}
**void UpdateTransparentRefBodies(CDBSession * pDBSession)**
  *function: 
  *parameters: 
    - [i] CDBSession * pDBSession: 
  *return value: 

{{anchor:gettransparentbodies}}
**unordered_set<const DBody*>& GetTransparentBodies()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gettransparentrefbodies}}
**unordered_set<const DRefBody*>& GetTransparentRefBodies()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:addtransparentbody}}
**void AddTransparentBody(const DBody* pBody)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
  *return value: 

{{anchor:removetransparentbody}}
**void RemoveTransparentBody(const DBody* pBody)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
  *return value: 

{{anchor:addtransparentrefbody}}
**void AddTransparentRefBody(const DRefBody* pBody)**
  *function: 
  *parameters: 
    - [i] const DRefBody* pBody: 
  *return value: 

{{anchor:removetransparentrefbody}}
**void RemoveTransparentRefBody(const DRefBody* pBody)**
  *function: 
  *parameters: 
    - [i] const DRefBody* pBody: 
  *return value: 

{{anchor:hideelements}}
**void HideElements( TArray<TCursor>& crElements )**
  *function: 
  *parameters: 
    - [i] TArray<TCursor>& crElements : 
  *return value: 

{{anchor:showelements}}
**void ShowElements( TArray<TCursor>& crElements )**
  *function: 
  *parameters: 
    - [i] TArray<TCursor>& crElements : 
  *return value: 

{{anchor:inversehideelements}}
**void InverseHideElements( TArray<TCursor>& crElements )**
  *function: 
  *parameters: 
    - [i] TArray<TCursor>& crElements : 
  *return value: 

{{anchor:updateobserver}}
**virtual int UpdateObserver(CSubject* pSubject, UINT Msg, WPARAM wParam, LPARAM lParam)**
  *function: 
  *parameters: 
    - [i] CSubject* pSubject: 
    - [i] UINT Msg: 
    - [i] WPARAM wParam: 
    - [i] LPARAM lParam: 
  *return value: 

{{anchor:onupdateselecteditems}}
**void OnUpdateSelectedItems(CTargetSet* pTargetSet)**
  *function: 
  *parameters: 
    - [i] CTargetSet* pTargetSet: 
  *return value: 

{{anchor:getselectvbo}}
**CSelectVBO& GetSelectVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getbeamdiagramvbo}}
**CBeamDiagramVBO& GetBeamDiagramVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:glupdatesharedface}}
**void GLUpdateSharedFace()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getsharedfaces}}
**unordered_set<TCursor>& GetSharedFaces ()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:glupdatesharednodevbo}}
**void GLUpdateSharedNodeVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getsharednodevbo}}
**VBO<GLfloat>& GetSharedNodeVBO ()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:glupdatesharedelemvbo}}
**void GLUpdateSharedElemVBO()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:findsharedelemsbysharednode}}
**static void FindSharedElemsBySharedNode(**
  *function: 
  *parameters: 
    - [i] : 
  *return value: 

{{anchor:getsharednodeelems}}
**unordered_set<TCursor>& GetSharedNodeElems ()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getsharedelemfaces}}
**unordered_set<TCursor>& GetSharedElemFaces ()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getsharedelemnodesvbo}}
**VBO<GLfloat>& GetSharedElemNodesVBO ()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:invalidatesharedelem}}
**void InvalidateSharedElem()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:settargetofsharedelem}}
**void SetTargetOfSharedElem(TArray<TCursor>& targets)**
  *function: 
  *parameters: 
    - [i] TArray<TCursor>& targets: 
  *return value: 

{{anchor:setsolidmode}}
**void SetSolidMode(bool val)**
  *function: 
  *parameters: 
    - [i] bool val: 
  *return value: 

{{anchor:buildvboforsolidmode}}
**void BuildVBOforSolidMode(CDBSession* pDBSession, const unordered_set<const DBody*> &Bodies,**
  *function: 
  *parameters: 
    - [i] CDBSession* pDBSession: 
    - [i] const unordered_set<const DBody*> &Bodies: 
    - [i] : 
  *return value: 

{{anchor:getsolidvbomanager}}
**CSolidVBOManager* GetSolidVBOManager()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getsectiondata}}
**CRenderSectionData* GetSectionData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getgroupsectiondata}}
**CGroupRenderSectionData* GetGroupSectionData()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getgrouprenderdata}}
**CGroupVBOManager* GetGroupRenderData()**
  *function: 
  *parameters: NULL
  *return value: