====== CRndModel ======

**//Inherited from//**  [[class::crndbase|CRndBase]],

**//Inherited by//**  NULL

**//Friend class//**  NULL

**//Description//**

**//Members//**
  * unique_ptr<Shader> [[crndmodel#m_psdnode|m_pSDNode]]
  * unique_ptr<Shader> [[crndmodel#m_psdcolorcode|m_pSDColorCode]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontour|m_pSDContour]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontourbothside|m_pSDContourBothSide]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontouralpha|m_pSDContourAlpha]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontour1d|m_pSDContour1D]]
  * unique_ptr<Shader> [[crndmodel#m_psdedge|m_pSDEdge]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontouredge|m_pSDContourEdge]]
  * unique_ptr<Shader> [[crndmodel#m_psdmodel|m_pSDModel]]
  * unique_ptr<Shader> [[crndmodel#m_psdmodelalpha|m_pSDModelAlpha]]
  * unique_ptr<Shader> [[crndmodel#m_psdnolighting|m_pSDNoLighting]]
  * unique_ptr<Shader> [[crndmodel#m_psdoriginalline|m_pSDOriginalLine]]
  * unique_ptr<Shader> [[crndmodel#m_psdoriginalshade|m_pSDOriginalShade]]
  * unique_ptr<Shader> [[crndmodel#m_psdhighlight|m_pSDHighlight]]
  * unique_ptr<Shader> [[crndmodel#m_ppointspritehighlight|m_pPointSpriteHighlight]]
  * unique_ptr<Shader> [[crndmodel#m_psdoit|m_pSDOIT]]
  * unique_ptr<Shader> [[crndmodel#m_psdoitdeform|m_pSDOITDeform]]
  * unique_ptr<Shader> [[crndmodel#m_psdoitcontour|m_pSDOITContour]]
  * unique_ptr<Shader> [[crndmodel#m_psdoitcontourdeform|m_pSDOITContourDeform]]
  * unique_ptr<Shader> [[crndmodel#m_psdcontourtransnmri|m_pSDContourTransNMRI]]
  * unique_ptr<Shader> [[crndmodel#m_psdhgacontourmapping|m_pSDHGAContourMapping]]
  * CFrameRenderBuffer* [[crndmodel#m_prendertexture|m_pRenderTexture]]
  * int [[crndmodel#m_itexwidth|m_iTexWidth]]
  * int [[crndmodel#m_itexheight|m_iTexHeight]]
  * unique_ptr<Shader> [[crndmodel#m_psdadvcremoveelem|m_pSDAdvcRemoveElem]]
  * unique_ptr<Shader> [[crndmodel#m_psdadvcremoveelemmesh|m_pSDAdvcRemoveElemMesh]]
  * unique_ptr<Shader> [[crndmodel#m_psdgururitranparent|m_pSDGururiTranparent]]
  * unique_ptr<Shader> [[crndmodel#m_psdgururitranparentcontour|m_pSDGururiTranparentContour]]
  * unique_ptr<CFrameTranparencyBuffer> [[crndmodel#m_poittranparencybuffer|m_pOITTranparencyBuffer]]
  * GLUquadricObj* [[crndmodel#m_glquadricobj|m_glQuadricObj]]
  * CRndIsoSurf* [[crndmodel#m_prndisosurf|m_pRndIsoSurf]]
**//Public interface//**
  * [[crndmodel#crndmodel1|CRndModel]](CRndHelper* pHelper)
  * [[crndmodel#~crndmodel|~CRndModel]]()
  * void [[crndmodel#initialize|Initialize]]()
  * void [[crndmodel#loadshaders|LoadShaders]]()
  * void [[crndmodel#initializevbos|InitializeVBOs]]()
  * void [[crndmodel#uninitialized|Uninitialized]]()
  * void [[crndmodel#gldrawshade|GLDrawShade]](const TRenderOption& opt)
  * void [[crndmodel#gldrawshadesurfacedistance|GLDrawShadeSurfaceDistance]](const TRenderOption& opt)
  * void [[crndmodel#gldrawpostoriginal|GLDrawPostOriginal]]()
  * void [[crndmodel#gldrawgururitransparent|GLDrawGururiTransparent]](const TRenderOption& opt)
  * void [[crndmodel#gldrawbarpart|GLDrawBarPart]](const TRenderOption& opt, bool bDepthCode = false)
  * void [[crndmodel#gldrawbarpart|GLDrawBarPart]](const DBody* pBody, unsigned char color[4])
  * void [[crndmodel#gldrawbarpart|GLDrawBarPart]](const DBody* pBody)
  * void [[crndmodel#gldrawcontourmappinghga|GLDrawContourMappingHGA]](const TRenderOption& opt)
  * void [[crndmodel#gldrawcompairshade|GLDrawCompairShade]](Shader* pShader)
  * void [[crndmodel#gldrawpreviewcompairshade|GLDrawPreviewCompairShade]](Shader* pShader)
  * void [[crndmodel#gldrawadvctransparency|GLDrawADVCTransparency]](const TRenderOption& opt)
  * void [[crndmodel#gldrawadvcmeshline|GLDrawADVCMeshLine]]()
  * void [[crndmodel#gldrawonlyadvcmeshline|GLDrawOnlyADVCMeshLine]]()
  * void [[crndmodel#gldrawonlyadvctransparency|GLDrawOnlyADVCTransparency]](const TRenderOption& opt)
  * void [[crndmodel#gldrawmeshline|GLDrawMeshLine]]()
  * void [[crndmodel#gldrawmeshline|GLDrawMeshLine]](const DBody* pBody)
  * void [[crndmodel#gldrawmeshlineshape|GLDrawMeshLineShape]](const DBody * pBody)
  * void [[crndmodel#gldrawmeshline|GLDrawMeshLine]](const DFace* pFace)
  * void [[crndmodel#gldrawmeshlinewithcolor|GLDrawMeshLineWithColor]](const DFace* pFace, COLORREF col)
  * void [[crndmodel#gldrawmeshlinewithcolor|GLDrawMeshLineWithColor]](const DBody* pBody, COLORREF col)
  * void [[crndmodel#gldrawnode|GLDrawNode]](const TRenderOption& opt)
  * void [[crndmodel#gldrawcornernode|GLDrawCornerNode]](Shader* pShader, const TRenderOption& opt)
  * void [[crndmodel#gldrawmidnode|GLDrawMidNode]](Shader* pShader, const TRenderOption& opt)
  * void [[crndmodel#gldrawedgeline|GLDrawEdgeLine]](bool bIgnoreDrawBarBody = false)
  * void [[crndmodel#gldrawedgeline|GLDrawEdgeLine]](const DEdge* pEdge)
  * void [[crndmodel#gldrawedgeline|GLDrawEdgeLine]](const DBody* pBody)
  * void [[crndmodel#gldrawedgelineshape|GLDrawEdgeLineShape]](const DBody* pBody)
  * void [[crndmodel#gldrawedgelineshape|GLDrawEdgeLineShape]](const DBody* pBody, unsigned char color[4])
  * void [[crndmodel#gldrawedgelinesurfacedistance|GLDrawEdgeLineSurfaceDistance]]()
  * void [[crndmodel#gldrawedgenode|GLDrawEdgeNode]]()
  * void [[crndmodel#gldrawedgecornernode|GLDrawEdgeCornerNode]](Shader* pShader, const TRenderOption& opt, bool bDrawBarOnly = false)
  * void [[crndmodel#gldrawedgemidnode|GLDrawEdgeMidNode]](Shader* pShader, const TRenderOption& opt, bool bDrawBarOnly = false)
  * void [[crndmodel#gldrawvertices|GLDrawVertices]](const DBody* pBody)
  * void [[crndmodel#gldrawvertices|GLDrawVertices]]()
  * void [[crndmodel#gldrawfloatingnodes|GLDrawFloatingNodes]](bool drawForColorCode)
  * void [[crndmodel#gldrawfloatingedgenodes|GLDrawFloatingEdgeNodes]](bool drawForColorCode)
  * void [[crndmodel#gldrawnodes|GLDrawNodes]](bool drawForColorCode, vector<TCursor> const &vecNodeCR, COLORREF col = RGB(0, 255, 0))
  * void [[crndmodel#gldrawcolorcode|GLDrawColorCode]](COLOR_CODE_TYPE colorCodeType)
  * void [[crndmodel#gldrawdepthcode|GLDrawDepthCode]]()
  * void [[crndmodel#gldrawhighlight|GLDrawHighlight]]()
  * void [[crndmodel#gldrawhighlight|GLDrawHighlight]](TCursor cursor)
  * void [[crndmodel#gldrawselected|GLDrawSelected]](CSelectBuffer* pSelBuf)
  * void [[crndmodel#gldrawhighlightbuffer|GLDrawHighlightBuffer]](CSelectBuffer* pHighlightBuffer)
  * void [[crndmodel#gldrawselecteditem|GLDrawSelectedItem]](const TTargetItem &targetItem, bool bHighlight, bool bDrawElemNode = true)
  * void [[crndmodel#gldrawidforselected|GLDrawIDForSelected]](CSelectBuffer* pSelBuf)
  * void [[crndmodel#gldrawidforselecteditem|GLDrawIDForSelectedItem]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#gldrawnameforselected|GLDrawNameForSelected]](CSelectBuffer* pSelBuf)
  * void [[crndmodel#gldrawnameforselecteditem|GLDrawNameForSelectedItem]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#gldrawstringonentity|GLDrawStringOnEntity]](TCursor cr, COLORREF col, const CString& str)
  * void [[crndmodel#gldrawface|GLDrawFace]](const DFace* pFace)
  * void [[crndmodel#gldrawlocalsetting|GLDrawLocalSetting]]()
  * void [[crndmodel#gldrawshadefaceshape|GLDrawShadeFaceShape]](const DFace* pFace)
  * void [[crndmodel#gldrawshadefaceshape|GLDrawShadeFaceShape]](const DFace* pFace, unsigned char color[4])
  * void [[crndmodel#gldrawshadefaceshapeforcolorcode|GLDrawShadeFaceShapeForColorCode]](const DFace* pFace)
  * void [[crndmodel#gldrawshadefaceshapelocalsetting|GLDrawShadeFaceShapeLocalSetting]](const vector<CModelVBORange>&localsettingfaceVBOIdx)
  * void [[crndmodel#gldrawedgeshape|GLDrawEdgeShape]](const DEdge* pEdge)
  * void [[crndmodel#gldrawedgeshape|GLDrawEdgeShape]](const DEdge* pEdge, unsigned char color[4])
  * void [[crndmodel#gldrawshadeedgeshapelocalsetting|GLDrawShadeEdgeShapeLocalSetting]](const vector<CModelVBORange>&localsettingedgeVBOIdx)
  * void [[crndmodel#gldrawfacenormals|GLDrawFaceNormals]]()
  * void [[crndmodel#gldrawfacenormalsforface|GLDrawFaceNormalsForFace]](const DFace* pFace)
  * void [[crndmodel#gldrawfacenormalsforfaceavr|GLDrawFaceNormalsForFaceAvr]](const DFace* pFace)
  * void [[crndmodel#gldrawfacenormalsforelem|GLDrawFaceNormalsForElem]](const DElem* pElem)
  * void [[crndmodel#gldrawfacenormals|GLDrawFaceNormals]](CSelectBuffer* pSelBuf)
  * void [[crndmodel#gldrawshadeexcludeselected|GLDrawShadeExcludeSelected]](CSelectBuffer* pSelBuf, const TRenderOption& opt)
  * void [[crndmodel#gldrawsharedelem|GLDrawSharedElem]](const TRenderOption& opt)
  * void [[crndmodel#gldrawsharedfacenode|GLDrawSharedFaceNode]](const TRenderOption& opt)
  * bool [[crndmodel#isshowshape|IsShowShape]](const DShape* pShape)
  * void [[crndmodel#gldrawrefbodies|GLDrawRefBodies]](DRAW_COLOR_TYPE drawColorType, COLOR_CODE_TYPE colorCodeType)
  * void [[crndmodel#gldrawtransparentbodies|GLDrawTransparentBodies]](const TRenderOption& opt)
  * void [[crndmodel#gldrawtransparentrefbodies|GLDrawTransparentRefBodies]](const TRenderOption& opt)
  * void [[crndmodel#gldrawtransparentbodiesex|GLDrawTransparentBodiesEx]](const TRenderOption& opt)
  * void [[crndmodel#filledgetoavoidpickingbackfacingface|FillEdgeToAvoidPickingBackFacingFace]]()
  * void [[crndmodel#drawelementbytriangles|DrawElementByTriangles]](const DElem* pElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbytriangles|DrawElementByTriangles]](const DROElem * pRoElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementby3nodes|DrawElementBy3Nodes]](TCursor crNode0, TCursor crNode1, TCursor crNode2, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbytrianglesforselection|DrawElementByTrianglesForSelection]](const DElem* pElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbytrianglesforselection|DrawElementByTrianglesForSelection]](const DROElem * pRoElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbytrianglesforselection|DrawElementByTrianglesForSelection]](const DRefElem * pElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbylines2|DrawElementByLines2]](const DElem* pElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbylines2|DrawElementByLines2]](const DROElem* pRoElem, BOOL bPreview = FALSE)
  * void [[crndmodel#drawelementbylines2|DrawElementByLines2]](const DRefElem * pElem, BOOL bPreview = FALSE)
  * static void [[crndmodel#drawelementshapebytriangles|DrawElementShapeByTriangles]](const DElem* pElem)
  * static void [[crndmodel#setcolorofelement|SetColorOfElement]](const DElem* pElem)
  * static void [[crndmodel#drawelementbylines|DrawElementByLines]](const DElem* pElem)
  * void [[crndmodel#drawelementedge|DrawElementEdge]](TElemEdge elemEdge)
  * void [[crndmodel#drawedge|DrawEdge]](const DEdge* pEdge, bool showAlways = true)
  * void [[crndmodel#drawedgepreview|DrawEdgePreview]](const DEdge* pEdge, bool showAlways = true)
  * void [[crndmodel#drawnode|DrawNode]](const DNode* pNode)
  * void [[crndmodel#drawnodepreview|DrawNodePreview]](const DNode* pNode, bool showAlways = true)
  * void [[crndmodel#drawronode|DrawRONode]](const DRONode* pNode)
  * void [[crndmodel#gldrawshadebodyshape|GLDrawShadeBodyShape]](const DBody* pBody)
  * void [[crndmodel#gldrawshadebody|GLDrawShadeBody]](const DBody* pBody)
  * void [[crndmodel#gldrawshadeface|GLDrawShadeFace]](const DFace* pFace)
  * void [[crndmodel#gldrawshadebodyshape|GLDrawShadeBodyShape]](const DBody* pBody, unsigned char color[4])
  * void [[crndmodel#gldrawsolidfordepthcode|GLDrawSolidForDepthCode]]()
  * void [[crndmodel#gldrawsolid|GLDrawSolid]](DRAW_COLOR_TYPE drawColorType, COLOR_CODE_TYPE colorCodeType)
  * void [[crndmodel#gldrawsolidforcolorcode|GLDrawSolidForColorCode]](COLOR_CODE_TYPE colorCodeType)
  * void [[crndmodel#gldrawshadesolidelem|GLDrawShadeSolidELem]](const TRenderOption& opt)
  * void [[crndmodel#gldrawsolidelemforcolorcode|GLDrawSolidElemForColorCode]]()
  * void [[crndmodel#gldrawsolidelemmeshline|GLDrawSolidElemMeshLine]]()
  * void [[crndmodel#gldrawbeamdiagram|GLDrawBeamDiagram]]()
  * void [[crndmodel#gldrawshowadjacentfacepreview|GLDrawShowAdjacentFacePreview]]()
  * void [[crndmodel#gldrawshowadjacentelementpreview|GLDrawShowAdjacentElementPreview]]()
  * void [[crndmodel#gldrawselectvbo|GLDrawSelectVBO]](CSelectVBO& selectVBO)
  * CRndIsoSurf* [[crndmodel#getrndisosurf|GetRndIsoSurf]]()
  * Shader* [[crndmodel#getactiveshader|GetActiveShader]](const TRenderOption& opt)
  * Shader* [[crndmodel#getactiveedgeshader|GetActiveEdgeShader]](const TRenderOption& opt)
  * Shader* [[crndmodel#getactivemeshlineshader|GetActiveMeshLineShader]](const TRenderOption& opt)
  * Shader* [[crndmodel#getactivehighlightshader|GetActiveHighlightShader]](const TRenderOption& opt)
  * Shader* [[crndmodel#getactivepointspritehighlightshader|GetActivePointSpriteHighlightShader]](const TRenderOption& opt)
  * void [[crndmodel#gldrawcolorcodebody|GLDrawColorCodeBody]]()
  * void [[crndmodel#gldrawcolorcodebarbody|GLDrawColorCodeBarBody]]()
  * void [[crndmodel#gldrawcolorcodeedgeline|GLDrawColorCodeEdgeLine]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodeface|GLDrawColorCodeFace]]()
  * void [[crndmodel#gldrawcolorcodeedge|GLDrawColorCodeEdge]]()
  * void [[crndmodel#gldrawcolorcodevertex|GLDrawColorCodeVertex]]()
  * void [[crndmodel#gldrawcolorcodevertex|GLDrawColorCodeVertex]](const DVertex* pVertex)
  * void [[crndmodel#gldrawcolorcodevertex|GLDrawColorCodeVertex]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodeelement|GLDrawColorCodeElement]](bool isFillEdge = true)
  * void [[crndmodel#gldrawcolorcodeelement|GLDrawColorCodeElement]](const DFace* pFace)
  * void [[crndmodel#gldrawcolorcodeelement|GLDrawColorCodeElement]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodeelement1d|GLDrawColorCodeElement1D]]()
  * void [[crndmodel#gldrawcolorcodeelement1d|GLDrawColorCodeElement1D]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodeelement1d|GLDrawColorCodeElement1D]](const DEdge* pEdge)
  * void [[crndmodel#gldrawcolorcodeelementedge|GLDrawColorCodeElementEdge]]()
  * void [[crndmodel#gldrawcolorcodeelementedge|GLDrawColorCodeElementEdge]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodemidnode|GLDrawColorCodeMidNode]]()
  * void [[crndmodel#gldrawcolorcodemidnode|GLDrawColorCodeMidNode]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodemidnode|GLDrawColorCodeMidNode]](const DFace* pFace)
  * void [[crndmodel#gldrawcolorcodemidnode|GLDrawColorCodeMidNode]](const DEdge* pEdge)
  * void [[crndmodel#gldrawcolorcodenode|GLDrawColorCodeNode]]()
  * void [[crndmodel#gldrawcolorcodenode|GLDrawColorCodeNode]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodenode|GLDrawColorCodeNode]](const DFace* pFace)
  * void [[crndmodel#gldrawcolorcodenode|GLDrawColorCodeNode]](const DEdge* pEdge)
  * void [[crndmodel#setshaderuniform|SetShaderUniform]](Shader* pShader, const TRenderOption& opt, BOOL bRenderMesh = FALSE)
  * void [[crndmodel#setshadercompareuniform|SetShaderCompareUniform]](Shader* pShader, const TRenderOption& opt)
  * void [[crndmodel#setshaderuniformrefdoc|SetShaderUniformRefDoc]](Shader* pShader)
  * void [[crndmodel#setdeformuniform|SetDeformUniform]](Shader* pShader)
  * void [[crndmodel#setcontouruniform|SetContourUniform]](Shader* pShader, BOOL bRenderMesh = FALSE)
  * void [[crndmodel#setlightinguniform|SetLightingUniform]](Shader* pShader)
  * bool [[crndmodel#issurfacedistance|IsSurfaceDistance]]()
  * bool [[crndmodel#hasdata|HasData]](set<TKey> setKeys)
**//Protected interface//**
  * void [[crndmodel#gldrawshadeclipmode|GLDrawShadeClipMode]](const TRenderOption& opt)
  * void [[crndmodel#gldrawedgelineclipmode|GLDrawEdgeLineClipMode]](const TRenderOption& opt, bool bIgnoreBarBody = false)
  * void [[crndmodel#gldrawmeshlineclippingmode|GLDrawMeshLineClippingMode]]()
  * void [[crndmodel#gldrawmeshlineisovolume|GLDrawMeshLineIsoVolume]]()
  * void [[crndmodel#gldrawcolorcodeelementclippingmode|GLDrawColorCodeElementClippingMode]]()
  * void [[crndmodel#gldrawcolorcodeelement1dclippingmode|GLDrawColorCodeElement1DClippingMode]]()
  * void [[crndmodel#gldrawshadenomalmode|GLDrawShadeNomalMode]](const TRenderOption& opt)
  * void [[crndmodel#gldrawedgelinenomalmode|GLDrawEdgeLineNomalMode]](const TRenderOption& opt, bool bIgnoreBarBody = false)
  * void [[crndmodel#gldrawmeshlinenormalmode|GLDrawMeshLineNormalMode]]()
  * void [[crndmodel#gldrawcolorcodeelementnomalmode|GLDrawColorCodeElementNomalMode]]()
  * void [[crndmodel#gldrawcolorcodeelement1dnomalmode|GLDrawColorCodeElement1DNomalMode]]()
  * void [[crndmodel#gldrawtransparentbodyshape|GLDrawTransparentBodyShape]](const DBody* pBody)
  * void [[crndmodel#gldrawcolorcodenodeset|GLDrawColorCodeNodeSet]]()
  * void [[crndmodel#gldrawcolorcodenodesetforsolidelem|GLDrawColorCodeNodeSetForSolidElem]]()
  * void [[crndmodel#drawselectednode|DrawSelectedNode]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedelement|DrawSelectedElement]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedelementedge|DrawSelectedElementEdge]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedvertex|DrawSelectedVertex]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedvertex|DrawSelectedVertex]](TCursor crVertex)
  * void [[crndmodel#drawselectededge|DrawSelectedEdge]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedface|DrawSelectedFace]](const DFace* pFace, bool bHighlight)
  * void [[crndmodel#drawselectedface|DrawSelectedFace]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedbody|DrawSelectedBody]](const TTargetItem &targetItem, bool bHighlight)
  * void [[crndmodel#drawselectedpoint|DrawSelectedPoint]](const TTargetItem & targetItem, bool bHighlight = false)
  * void [[crndmodel#drawface|DrawFace]](const DFace* pFace)
  * void [[crndmodel#drawfaceline|DrawFaceLine]](const DFace* pFace)
  * void [[crndmodel#gldrawshadebodybygltriangles|GLDrawShadeBodyByGLTriangles]](const DBody* pBody)
  * void [[crndmodel#gldrawmeshlinesbygllines|GLDrawMeshLinesByGLLines]](const DBody* pBody)
  * void [[crndmodel#gldrawfacelinesbygllines|GLDrawFaceLinesByGLLines]](const DFace* pFace)
  * void [[crndmodel#gldrawbarbodysection|GLDrawBarBodySection]](const DBody* pBody, bool isColorCode)
  * void [[crndmodel#gldrawrefbody|GLDrawRefBody]](const DRefBody* pBody)
  * void [[crndmodel#drawrefface|DrawRefFace]](const DRefFace* pFace)
  * void [[crndmodel#drawrefelementbytriangles|DrawRefElementByTriangles]](const DRefElem* pElem)
  * void [[crndmodel#gldrawmeshlinesofrefbody|GLDrawMeshLinesOfRefBody]](const DRefBody* pBody)
  * void [[crndmodel#drawmeshlinesofrefface|DrawMeshLinesOfRefFace]](const DRefFace* pFace)
  * void [[crndmodel#gldrawedgesofrefbody|GLDrawEdgesOfRefBody]](const DRefBody* pBody)
  * void [[crndmodel#drawrefedge|DrawRefEdge]](const DRefEdge* pEdge)
  * void [[crndmodel#gldrawpostoriginalmeshline|GLDrawPostOriginalMeshLine]](PostDataVizOptDeform& optDeform)
  * void [[crndmodel#gldrawpostoriginaledgeline|GLDrawPostOriginalEdgeLine]](PostDataVizOptDeform& optDeform)
  * void [[crndmodel#gldrawpostoriginalshade|GLDrawPostOriginalShade]](PostDataVizOptDeform& optDeform)
  * void [[crndmodel#gldrawpartstencil|GLDrawPartstencil]](CClipPlane* pClipPlane, Shader *pShader, const TRenderOption& opt, int iSection = 0)
  * void [[crndmodel#gldrawpartstenciloriginal|GLDrawPartstencilOriginal]](CClipPlane* pClipPlane, Shader *pShader, PostDataVizOptDeform& optDeform, int iSection = 0)
  * void [[crndmodel#gldrawfaceofrefbody|GLDrawFaceOfRefBody]]()
  * void [[crndmodel#gldrawcolorcodefaceofrefbody|GLDrawColorCodeFaceOfRefBody]]()
  * void [[crndmodel#gldrawcolorcodeedgeofrefbody|GLDrawColorCodeEdgeOfRefBody]]()
  * void [[crndmodel#gldrawcolorcodenodeofrefbody|GLDrawColorCodeNodeOfRefBody]]()
  * void [[crndmodel#gldrawmeshlinesofrefbody|GLDrawMeshLinesOfRefBody]]()
  * void [[crndmodel#gldrawedgesofrefbody|GLDrawEdgesOfRefBody]]()
  * BOOL [[crndmodel#createrendertexture|CreateRenderTexture]](int nWidth, int nHeight)
  * BOOL [[crndmodel#isbodyclip|IsBodyClip]](TCursor cr)
  * void [[crndmodel#begincapping|BeginCapping]](CClipPlane* pClipPlane, int iSection = 0)
  * void [[crndmodel#endcapping|EndCapping]](CClipPlane* pClipPlane, COLORREF partColor, int iSection = 0, int transperency = 255)
  * bool [[crndmodel#isshowdeform|isShowDeform]]()
  * bool [[crndmodel#isshowcontour|isShowContour]]()

----

{{anchor:m_psdnode}}
**unique_ptr<Shader> m_pSDNode**

{{anchor:m_psdcolorcode}}
**unique_ptr<Shader> m_pSDColorCode**

{{anchor:m_psdcontour}}
**unique_ptr<Shader> m_pSDContour**

{{anchor:m_psdcontourbothside}}
**unique_ptr<Shader> m_pSDContourBothSide**

{{anchor:m_psdcontouralpha}}
**unique_ptr<Shader> m_pSDContourAlpha**

{{anchor:m_psdcontour1d}}
**unique_ptr<Shader> m_pSDContour1D**

{{anchor:m_psdedge}}
**unique_ptr<Shader> m_pSDEdge**

{{anchor:m_psdcontouredge}}
**unique_ptr<Shader> m_pSDContourEdge**

{{anchor:m_psdmodel}}
**unique_ptr<Shader> m_pSDModel**

{{anchor:m_psdmodelalpha}}
**unique_ptr<Shader> m_pSDModelAlpha**

{{anchor:m_psdnolighting}}
**unique_ptr<Shader> m_pSDNoLighting**

{{anchor:m_psdoriginalline}}
**unique_ptr<Shader> m_pSDOriginalLine**

{{anchor:m_psdoriginalshade}}
**unique_ptr<Shader> m_pSDOriginalShade**

{{anchor:m_psdhighlight}}
**unique_ptr<Shader> m_pSDHighlight**

{{anchor:m_ppointspritehighlight}}
**unique_ptr<Shader> m_pPointSpriteHighlight**

{{anchor:m_psdoit}}
**unique_ptr<Shader> m_pSDOIT**

{{anchor:m_psdoitdeform}}
**unique_ptr<Shader> m_pSDOITDeform**

{{anchor:m_psdoitcontour}}
**unique_ptr<Shader> m_pSDOITContour**

{{anchor:m_psdoitcontourdeform}}
**unique_ptr<Shader> m_pSDOITContourDeform**

{{anchor:m_psdcontourtransnmri}}
**unique_ptr<Shader> m_pSDContourTransNMRI**

{{anchor:m_psdhgacontourmapping}}
**unique_ptr<Shader> m_pSDHGAContourMapping**

{{anchor:m_prendertexture}}
**CFrameRenderBuffer* m_pRenderTexture**

{{anchor:m_itexwidth}}
**int m_iTexWidth**

{{anchor:m_itexheight}}
**int m_iTexHeight**

{{anchor:m_psdadvcremoveelem}}
**unique_ptr<Shader> m_pSDAdvcRemoveElem**

{{anchor:m_psdadvcremoveelemmesh}}
**unique_ptr<Shader> m_pSDAdvcRemoveElemMesh**

{{anchor:m_psdgururitranparent}}
**unique_ptr<Shader> m_pSDGururiTranparent**

{{anchor:m_psdgururitranparentcontour}}
**unique_ptr<Shader> m_pSDGururiTranparentContour**

{{anchor:m_poittranparencybuffer}}
**unique_ptr<CFrameTranparencyBuffer> m_pOITTranparencyBuffer**

{{anchor:m_glquadricobj}}
**GLUquadricObj* m_glQuadricObj**

{{anchor:m_prndisosurf}}
**CRndIsoSurf* m_pRndIsoSurf**

----

{{anchor:crndmodel1}}
**CRndModel(CRndHelper* pHelper)**
  *function: 
  *parameters: 
    - [i] CRndHelper* pHelper: 
  *return value: 

{{anchor:~crndmodel}}
**~CRndModel()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:initialize}}
**void Initialize()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:loadshaders}}
**void LoadShaders()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:initializevbos}}
**void InitializeVBOs()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:uninitialized}}
**void Uninitialized()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawshade}}
**void GLDrawShade(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawshadesurfacedistance}}
**void GLDrawShadeSurfaceDistance(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawpostoriginal}}
**void GLDrawPostOriginal()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawgururitransparent}}
**void GLDrawGururiTransparent(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawbarpart}}
**void GLDrawBarPart(const TRenderOption& opt, bool bDepthCode = false)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
    - [i] bool bDepthCode = false: 
  *return value: 

{{anchor:gldrawbarpart}}
**void GLDrawBarPart(const DBody* pBody, unsigned char color[4])**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] unsigned char color[4]: 
  *return value: 

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

{{anchor:gldrawcontourmappinghga}}
**void GLDrawContourMappingHGA(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawcompairshade}}
**void GLDrawCompairShade(Shader* pShader)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
  *return value: 

{{anchor:gldrawpreviewcompairshade}}
**void GLDrawPreviewCompairShade(Shader* pShader)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
  *return value: 

{{anchor:gldrawadvctransparency}}
**void GLDrawADVCTransparency(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawadvcmeshline}}
**void GLDrawADVCMeshLine()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawonlyadvcmeshline}}
**void GLDrawOnlyADVCMeshLine()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawonlyadvctransparency}}
**void GLDrawOnlyADVCTransparency(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawmeshline}}
**void GLDrawMeshLine()**
  *function: 
  *parameters: NULL
  *return value: 

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

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

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

{{anchor:gldrawmeshlinewithcolor}}
**void GLDrawMeshLineWithColor(const DFace* pFace, COLORREF col)**
  *function: 
  *parameters: 
    - [i] const DFace* pFace: 
    - [i] COLORREF col: 
  *return value: 

{{anchor:gldrawmeshlinewithcolor}}
**void GLDrawMeshLineWithColor(const DBody* pBody, COLORREF col)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] COLORREF col: 
  *return value: 

{{anchor:gldrawnode}}
**void GLDrawNode(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawcornernode}}
**void GLDrawCornerNode(Shader* pShader, const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawmidnode}}
**void GLDrawMidNode(Shader* pShader, const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawedgeline}}
**void GLDrawEdgeLine(bool bIgnoreDrawBarBody = false)**
  *function: 
  *parameters: 
    - [i] bool bIgnoreDrawBarBody = false: 
  *return value: 

{{anchor:gldrawedgeline}}
**void GLDrawEdgeLine(const DEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
  *return value: 

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

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

{{anchor:gldrawedgelineshape}}
**void GLDrawEdgeLineShape(const DBody* pBody, unsigned char color[4])**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] unsigned char color[4]: 
  *return value: 

{{anchor:gldrawedgelinesurfacedistance}}
**void GLDrawEdgeLineSurfaceDistance()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawedgenode}}
**void GLDrawEdgeNode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawedgecornernode}}
**void GLDrawEdgeCornerNode(Shader* pShader, const TRenderOption& opt, bool bDrawBarOnly = false)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
    - [i] bool bDrawBarOnly = false: 
  *return value: 

{{anchor:gldrawedgemidnode}}
**void GLDrawEdgeMidNode(Shader* pShader, const TRenderOption& opt, bool bDrawBarOnly = false)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
    - [i] bool bDrawBarOnly = false: 
  *return value: 

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

{{anchor:gldrawvertices}}
**void GLDrawVertices()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawfloatingnodes}}
**void GLDrawFloatingNodes(bool drawForColorCode)**
  *function: 
  *parameters: 
    - [i] bool drawForColorCode: 
  *return value: 

{{anchor:gldrawfloatingedgenodes}}
**void GLDrawFloatingEdgeNodes(bool drawForColorCode)**
  *function: 
  *parameters: 
    - [i] bool drawForColorCode: 
  *return value: 

{{anchor:gldrawnodes}}
**void GLDrawNodes(bool drawForColorCode, vector<TCursor> const &vecNodeCR, COLORREF col = RGB(0, 255, 0))**
  *function: 
  *parameters: 
    - [i] bool drawForColorCode: 
    - [i] vector<TCursor> const &vecNodeCR: 
    - [i] COLORREF col = RGB(0: 
    - [i] 255: 
    - [i] 0: 
  *return value: 

{{anchor:gldrawcolorcode}}
**void GLDrawColorCode(COLOR_CODE_TYPE colorCodeType)**
  *function: 
  *parameters: 
    - [i] COLOR_CODE_TYPE colorCodeType: 
  *return value: 

{{anchor:gldrawdepthcode}}
**void GLDrawDepthCode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawhighlight}}
**void GLDrawHighlight()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawhighlight}}
**void GLDrawHighlight(TCursor cursor)**
  *function: 
  *parameters: 
    - [i] TCursor cursor: 
  *return value: 

{{anchor:gldrawselected}}
**void GLDrawSelected(CSelectBuffer* pSelBuf)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pSelBuf: 
  *return value: 

{{anchor:gldrawhighlightbuffer}}
**void GLDrawHighlightBuffer(CSelectBuffer* pHighlightBuffer)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pHighlightBuffer: 
  *return value: 

{{anchor:gldrawselecteditem}}
**void GLDrawSelectedItem(const TTargetItem &targetItem, bool bHighlight, bool bDrawElemNode = true)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
    - [i] bool bDrawElemNode = true: 
  *return value: 

{{anchor:gldrawidforselected}}
**void GLDrawIDForSelected(CSelectBuffer* pSelBuf)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pSelBuf: 
  *return value: 

{{anchor:gldrawidforselecteditem}}
**void GLDrawIDForSelectedItem(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:gldrawnameforselected}}
**void GLDrawNameForSelected(CSelectBuffer* pSelBuf)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pSelBuf: 
  *return value: 

{{anchor:gldrawnameforselecteditem}}
**void GLDrawNameForSelectedItem(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:gldrawstringonentity}}
**void GLDrawStringOnEntity(TCursor cr, COLORREF col, const CString& str)**
  *function: 
  *parameters: 
    - [i] TCursor cr: 
    - [i] COLORREF col: 
    - [i] const CString& str: 
  *return value: 

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

{{anchor:gldrawlocalsetting}}
**void GLDrawLocalSetting()**
  *function: 
  *parameters: NULL
  *return value: 

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

{{anchor:gldrawshadefaceshape}}
**void GLDrawShadeFaceShape(const DFace* pFace, unsigned char color[4])**
  *function: 
  *parameters: 
    - [i] const DFace* pFace: 
    - [i] unsigned char color[4]: 
  *return value: 

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

{{anchor:gldrawshadefaceshapelocalsetting}}
**void GLDrawShadeFaceShapeLocalSetting(const vector<CModelVBORange>&localsettingfaceVBOIdx)**
  *function: 
  *parameters: 
    - [i] const vector<CModelVBORange>&localsettingfaceVBOIdx: 
  *return value: 

{{anchor:gldrawedgeshape}}
**void GLDrawEdgeShape(const DEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
  *return value: 

{{anchor:gldrawedgeshape}}
**void GLDrawEdgeShape(const DEdge* pEdge, unsigned char color[4])**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
    - [i] unsigned char color[4]: 
  *return value: 

{{anchor:gldrawshadeedgeshapelocalsetting}}
**void GLDrawShadeEdgeShapeLocalSetting(const vector<CModelVBORange>&localsettingedgeVBOIdx)**
  *function: 
  *parameters: 
    - [i] const vector<CModelVBORange>&localsettingedgeVBOIdx: 
  *return value: 

{{anchor:gldrawfacenormals}}
**void GLDrawFaceNormals()**
  *function: 
  *parameters: NULL
  *return value: 

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

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

{{anchor:gldrawfacenormalsforelem}}
**void GLDrawFaceNormalsForElem(const DElem* pElem)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
  *return value: 

{{anchor:gldrawfacenormals}}
**void GLDrawFaceNormals(CSelectBuffer* pSelBuf)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pSelBuf: 
  *return value: 

{{anchor:gldrawshadeexcludeselected}}
**void GLDrawShadeExcludeSelected(CSelectBuffer* pSelBuf, const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] CSelectBuffer* pSelBuf: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawsharedelem}}
**void GLDrawSharedElem(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawsharedfacenode}}
**void GLDrawSharedFaceNode(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:isshowshape}}
**bool IsShowShape(const DShape* pShape)**
  *function: 
  *parameters: 
    - [i] const DShape* pShape: 
  *return value: 

{{anchor:gldrawrefbodies}}
**void GLDrawRefBodies(DRAW_COLOR_TYPE drawColorType, COLOR_CODE_TYPE colorCodeType)**
  *function: 
  *parameters: 
    - [i] DRAW_COLOR_TYPE drawColorType: 
    - [i] COLOR_CODE_TYPE colorCodeType: 
  *return value: 

{{anchor:gldrawtransparentbodies}}
**void GLDrawTransparentBodies(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawtransparentrefbodies}}
**void GLDrawTransparentRefBodies(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawtransparentbodiesex}}
**void GLDrawTransparentBodiesEx(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:filledgetoavoidpickingbackfacingface}}
**void FillEdgeToAvoidPickingBackFacingFace()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:drawelementbytriangles}}
**void DrawElementByTriangles(const DElem* pElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbytriangles}}
**void DrawElementByTriangles(const DROElem * pRoElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DROElem * pRoElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementby3nodes}}
**void DrawElementBy3Nodes(TCursor crNode0, TCursor crNode1, TCursor crNode2, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] TCursor crNode0: 
    - [i] TCursor crNode1: 
    - [i] TCursor crNode2: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbytrianglesforselection}}
**void DrawElementByTrianglesForSelection(const DElem* pElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbytrianglesforselection}}
**void DrawElementByTrianglesForSelection(const DROElem * pRoElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DROElem * pRoElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbytrianglesforselection}}
**void DrawElementByTrianglesForSelection(const DRefElem * pElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DRefElem * pElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbylines2}}
**void DrawElementByLines2(const DElem* pElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbylines2}}
**void DrawElementByLines2(const DROElem* pRoElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DROElem* pRoElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementbylines2}}
**void DrawElementByLines2(const DRefElem * pElem, BOOL bPreview = FALSE)**
  *function: 
  *parameters: 
    - [i] const DRefElem * pElem: 
    - [i] BOOL bPreview = FALSE: 
  *return value: 

{{anchor:drawelementshapebytriangles}}
**static void DrawElementShapeByTriangles(const DElem* pElem)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
  *return value: 

{{anchor:setcolorofelement}}
**static void SetColorOfElement(const DElem* pElem)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
  *return value: 

{{anchor:drawelementbylines}}
**static void DrawElementByLines(const DElem* pElem)**
  *function: 
  *parameters: 
    - [i] const DElem* pElem: 
  *return value: 

{{anchor:drawelementedge}}
**void DrawElementEdge(TElemEdge elemEdge)**
  *function: 
  *parameters: 
    - [i] TElemEdge elemEdge: 
  *return value: 

{{anchor:drawedge}}
**void DrawEdge(const DEdge* pEdge, bool showAlways = true)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
    - [i] bool showAlways = true: 
  *return value: 

{{anchor:drawedgepreview}}
**void DrawEdgePreview(const DEdge* pEdge, bool showAlways = true)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
    - [i] bool showAlways = true: 
  *return value: 

{{anchor:drawnode}}
**void DrawNode(const DNode* pNode)**
  *function: 
  *parameters: 
    - [i] const DNode* pNode: 
  *return value: 

{{anchor:drawnodepreview}}
**void DrawNodePreview(const DNode* pNode, bool showAlways = true)**
  *function: 
  *parameters: 
    - [i] const DNode* pNode: 
    - [i] bool showAlways = true: 
  *return value: 

{{anchor:drawronode}}
**void DrawRONode(const DRONode* pNode)**
  *function: 
  *parameters: 
    - [i] const DRONode* pNode: 
  *return value: 

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

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

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

{{anchor:gldrawshadebodyshape}}
**void GLDrawShadeBodyShape(const DBody* pBody, unsigned char color[4])**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] unsigned char color[4]: 
  *return value: 

{{anchor:gldrawsolidfordepthcode}}
**void GLDrawSolidForDepthCode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawsolid}}
**void GLDrawSolid(DRAW_COLOR_TYPE drawColorType, COLOR_CODE_TYPE colorCodeType)**
  *function: 
  *parameters: 
    - [i] DRAW_COLOR_TYPE drawColorType: 
    - [i] COLOR_CODE_TYPE colorCodeType: 
  *return value: 

{{anchor:gldrawsolidforcolorcode}}
**void GLDrawSolidForColorCode(COLOR_CODE_TYPE colorCodeType)**
  *function: 
  *parameters: 
    - [i] COLOR_CODE_TYPE colorCodeType: 
  *return value: 

{{anchor:gldrawshadesolidelem}}
**void GLDrawShadeSolidELem(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawsolidelemforcolorcode}}
**void GLDrawSolidElemForColorCode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawsolidelemmeshline}}
**void GLDrawSolidElemMeshLine()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawbeamdiagram}}
**void GLDrawBeamDiagram()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawshowadjacentfacepreview}}
**void GLDrawShowAdjacentFacePreview()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawshowadjacentelementpreview}}
**void GLDrawShowAdjacentElementPreview()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawselectvbo}}
**void GLDrawSelectVBO(CSelectVBO& selectVBO)**
  *function: 
  *parameters: 
    - [i] CSelectVBO& selectVBO: 
  *return value: 

{{anchor:getrndisosurf}}
**CRndIsoSurf* GetRndIsoSurf()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:getactiveshader}}
**Shader* GetActiveShader(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:getactiveedgeshader}}
**Shader* GetActiveEdgeShader(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:getactivemeshlineshader}}
**Shader* GetActiveMeshLineShader(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:getactivehighlightshader}}
**Shader* GetActiveHighlightShader(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:getactivepointspritehighlightshader}}
**Shader* GetActivePointSpriteHighlightShader(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawcolorcodebody}}
**void GLDrawColorCodeBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodebarbody}}
**void GLDrawColorCodeBarBody()**
  *function: 
  *parameters: NULL
  *return value: 

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

{{anchor:gldrawcolorcodeface}}
**void GLDrawColorCodeFace()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeedge}}
**void GLDrawColorCodeEdge()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodevertex}}
**void GLDrawColorCodeVertex()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodevertex}}
**void GLDrawColorCodeVertex(const DVertex* pVertex)**
  *function: 
  *parameters: 
    - [i] const DVertex* pVertex: 
  *return value: 

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

{{anchor:gldrawcolorcodeelement}}
**void GLDrawColorCodeElement(bool isFillEdge = true)**
  *function: 
  *parameters: 
    - [i] bool isFillEdge = true: 
  *return value: 

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

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

{{anchor:gldrawcolorcodeelement1d}}
**void GLDrawColorCodeElement1D()**
  *function: 
  *parameters: NULL
  *return value: 

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

{{anchor:gldrawcolorcodeelement1d}}
**void GLDrawColorCodeElement1D(const DEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
  *return value: 

{{anchor:gldrawcolorcodeelementedge}}
**void GLDrawColorCodeElementEdge()**
  *function: 
  *parameters: NULL
  *return value: 

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

{{anchor:gldrawcolorcodemidnode}}
**void GLDrawColorCodeMidNode()**
  *function: 
  *parameters: NULL
  *return value: 

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

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

{{anchor:gldrawcolorcodemidnode}}
**void GLDrawColorCodeMidNode(const DEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
  *return value: 

{{anchor:gldrawcolorcodenode}}
**void GLDrawColorCodeNode()**
  *function: 
  *parameters: NULL
  *return value: 

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

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

{{anchor:gldrawcolorcodenode}}
**void GLDrawColorCodeNode(const DEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DEdge* pEdge: 
  *return value: 

{{anchor:setshaderuniform}}
**void SetShaderUniform(Shader* pShader, const TRenderOption& opt, BOOL bRenderMesh = FALSE)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
    - [i] BOOL bRenderMesh = FALSE: 
  *return value: 

{{anchor:setshadercompareuniform}}
**void SetShaderCompareUniform(Shader* pShader, const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:setshaderuniformrefdoc}}
**void SetShaderUniformRefDoc(Shader* pShader)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
  *return value: 

{{anchor:setdeformuniform}}
**void SetDeformUniform(Shader* pShader)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
  *return value: 

{{anchor:setcontouruniform}}
**void SetContourUniform(Shader* pShader, BOOL bRenderMesh = FALSE)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
    - [i] BOOL bRenderMesh = FALSE: 
  *return value: 

{{anchor:setlightinguniform}}
**void SetLightingUniform(Shader* pShader)**
  *function: 
  *parameters: 
    - [i] Shader* pShader: 
  *return value: 

{{anchor:issurfacedistance}}
**bool IsSurfaceDistance()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:hasdata}}
**bool HasData(set<TKey> setKeys)**
  *function: 
  *parameters: 
    - [i] set<TKey> setKeys: 
  *return value: 

----

{{anchor:gldrawshadeclipmode}}
**void GLDrawShadeClipMode(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawedgelineclipmode}}
**void GLDrawEdgeLineClipMode(const TRenderOption& opt, bool bIgnoreBarBody = false)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
    - [i] bool bIgnoreBarBody = false: 
  *return value: 

{{anchor:gldrawmeshlineclippingmode}}
**void GLDrawMeshLineClippingMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawmeshlineisovolume}}
**void GLDrawMeshLineIsoVolume()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeelementclippingmode}}
**void GLDrawColorCodeElementClippingMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeelement1dclippingmode}}
**void GLDrawColorCodeElement1DClippingMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawshadenomalmode}}
**void GLDrawShadeNomalMode(const TRenderOption& opt)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
  *return value: 

{{anchor:gldrawedgelinenomalmode}}
**void GLDrawEdgeLineNomalMode(const TRenderOption& opt, bool bIgnoreBarBody = false)**
  *function: 
  *parameters: 
    - [i] const TRenderOption& opt: 
    - [i] bool bIgnoreBarBody = false: 
  *return value: 

{{anchor:gldrawmeshlinenormalmode}}
**void GLDrawMeshLineNormalMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeelementnomalmode}}
**void GLDrawColorCodeElementNomalMode()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeelement1dnomalmode}}
**void GLDrawColorCodeElement1DNomalMode()**
  *function: 
  *parameters: NULL
  *return value: 

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

{{anchor:gldrawcolorcodenodeset}}
**void GLDrawColorCodeNodeSet()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodenodesetforsolidelem}}
**void GLDrawColorCodeNodeSetForSolidElem()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:drawselectednode}}
**void DrawSelectedNode(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedelement}}
**void DrawSelectedElement(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedelementedge}}
**void DrawSelectedElementEdge(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedvertex}}
**void DrawSelectedVertex(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedvertex}}
**void DrawSelectedVertex(TCursor crVertex)**
  *function: 
  *parameters: 
    - [i] TCursor crVertex: 
  *return value: 

{{anchor:drawselectededge}}
**void DrawSelectedEdge(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedface}}
**void DrawSelectedFace(const DFace* pFace, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const DFace* pFace: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedface}}
**void DrawSelectedFace(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedbody}}
**void DrawSelectedBody(const TTargetItem &targetItem, bool bHighlight)**
  *function: 
  *parameters: 
    - [i] const TTargetItem &targetItem: 
    - [i] bool bHighlight: 
  *return value: 

{{anchor:drawselectedpoint}}
**void DrawSelectedPoint(const TTargetItem & targetItem, bool bHighlight = false)**
  *function: 
  *parameters: 
    - [i] const TTargetItem & targetItem: 
    - [i] bool bHighlight = false: 
  *return value: 

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

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

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

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

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

{{anchor:gldrawbarbodysection}}
**void GLDrawBarBodySection(const DBody* pBody, bool isColorCode)**
  *function: 
  *parameters: 
    - [i] const DBody* pBody: 
    - [i] bool isColorCode: 
  *return value: 

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

{{anchor:drawrefface}}
**void DrawRefFace(const DRefFace* pFace)**
  *function: 
  *parameters: 
    - [i] const DRefFace* pFace: 
  *return value: 

{{anchor:drawrefelementbytriangles}}
**void DrawRefElementByTriangles(const DRefElem* pElem)**
  *function: 
  *parameters: 
    - [i] const DRefElem* pElem: 
  *return value: 

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

{{anchor:drawmeshlinesofrefface}}
**void DrawMeshLinesOfRefFace(const DRefFace* pFace)**
  *function: 
  *parameters: 
    - [i] const DRefFace* pFace: 
  *return value: 

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

{{anchor:drawrefedge}}
**void DrawRefEdge(const DRefEdge* pEdge)**
  *function: 
  *parameters: 
    - [i] const DRefEdge* pEdge: 
  *return value: 

{{anchor:gldrawpostoriginalmeshline}}
**void GLDrawPostOriginalMeshLine(PostDataVizOptDeform& optDeform)**
  *function: 
  *parameters: 
    - [i] PostDataVizOptDeform& optDeform: 
  *return value: 

{{anchor:gldrawpostoriginaledgeline}}
**void GLDrawPostOriginalEdgeLine(PostDataVizOptDeform& optDeform)**
  *function: 
  *parameters: 
    - [i] PostDataVizOptDeform& optDeform: 
  *return value: 

{{anchor:gldrawpostoriginalshade}}
**void GLDrawPostOriginalShade(PostDataVizOptDeform& optDeform)**
  *function: 
  *parameters: 
    - [i] PostDataVizOptDeform& optDeform: 
  *return value: 

{{anchor:gldrawpartstencil}}
**void GLDrawPartstencil(CClipPlane* pClipPlane, Shader *pShader, const TRenderOption& opt, int iSection = 0)**
  *function: 
  *parameters: 
    - [i] CClipPlane* pClipPlane: 
    - [i] Shader *pShader: 
    - [i] const TRenderOption& opt: 
    - [i] int iSection = 0: 
  *return value: 

{{anchor:gldrawpartstenciloriginal}}
**void GLDrawPartstencilOriginal(CClipPlane* pClipPlane, Shader *pShader, PostDataVizOptDeform& optDeform, int iSection = 0)**
  *function: 
  *parameters: 
    - [i] CClipPlane* pClipPlane: 
    - [i] Shader *pShader: 
    - [i] PostDataVizOptDeform& optDeform: 
    - [i] int iSection = 0: 
  *return value: 

{{anchor:gldrawfaceofrefbody}}
**void GLDrawFaceOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodefaceofrefbody}}
**void GLDrawColorCodeFaceOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodeedgeofrefbody}}
**void GLDrawColorCodeEdgeOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawcolorcodenodeofrefbody}}
**void GLDrawColorCodeNodeOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawmeshlinesofrefbody}}
**void GLDrawMeshLinesOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:gldrawedgesofrefbody}}
**void GLDrawEdgesOfRefBody()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:createrendertexture}}
**BOOL CreateRenderTexture(int nWidth, int nHeight)**
  *function: 
  *parameters: 
    - [i] int nWidth: 
    - [i] int nHeight: 
  *return value: 

{{anchor:isbodyclip}}
**BOOL IsBodyClip(TCursor cr)**
  *function: 
  *parameters: 
    - [i] TCursor cr: 
  *return value: 

{{anchor:begincapping}}
**void BeginCapping(CClipPlane* pClipPlane, int iSection = 0)**
  *function: 
  *parameters: 
    - [i] CClipPlane* pClipPlane: 
    - [i] int iSection = 0: 
  *return value: 

{{anchor:endcapping}}
**void EndCapping(CClipPlane* pClipPlane, COLORREF partColor, int iSection = 0, int transperency = 255)**
  *function: 
  *parameters: 
    - [i] CClipPlane* pClipPlane: 
    - [i] COLORREF partColor: 
    - [i] int iSection = 0: 
    - [i] int transperency = 255: 
  *return value: 

{{anchor:isshowdeform}}
**bool isShowDeform()**
  *function: 
  *parameters: NULL
  *return value: 

{{anchor:isshowcontour}}
**bool isShowContour()**
  *function: 
  *parameters: NULL
  *return value: