MicroStation has many types of elements that we can divide into graphical and non-graphical elements. This chapter will discuss how to create graphical elements in MDL programs. Since the CE SDK encapsulates the original C functions, it provides a new set of methods for creating elements. The following table lists most of the graphic elements supported in MicroStation. It also lists the old and new methods of creating elements.

In the CE SDK, most of the old C functions are still retained, but their function prototypes have changed. The main reason is that the CE version completely uses Unicode character encoding. This chapter will only introduce the new C ++ programming method. 

One of the most important classes in CE SDK is ElementHandle, whose object represents an element in memory. MDL defines multiple variants for the same class, the purpose of which is to simplify the writing of C ++ itself. As shown in the following table: 

Class Name	Actual definition
ElementHandleP	ElementHandle *
ElementHandleCP	ElementHandle const *
ElementHandleR	ElementHandle &
ElementHandleCR	ElementHandle const &

After understanding some of the basics above, we started to write code to generate elements.

1. Edit the HelloWorld.cpp file. The final result is as follows:

/*-------------------------------------------------------------+ 

|   HelloWorld.cpp                                                | 

+-------------------------------------------------------------*/ 

#include <Mstn\MdlApi\MdlApi.h> 

#include <DgnPlatform\DgnPlatformApi.h> 

 

USING_NAMESPACE_BENTLEY_DGNPLATFORM 

USING_NAMESPACE_BENTLEY_MSTNPLATFORM 

USING_NAMESPACE_BENTLEY_MSTNPLATFORM_ELEMENT 

 

double g_1mu; 

 

void createALine(DPoint3dCR basePt) 

{ 

EditElementHandle eeh; 

DSegment3d seg; 

seg.Init(basePt, DPoint3d::From(basePt.x + g_1mu * 2, basePt.y + g_1mu)); 

ICurvePrimitivePtr pCurve = ICurvePrimitive::CreateLine(seg); 

DraftingElementSchema::ToElement(eeh, *pCurve, nullptr, ACTIVEMODEL->Is3d(), *ACTIVEMODEL); 

eeh.AddToModel(); 

} 

 

void createAComplexShape(DPoint3dCR basePt) 

{ 

EditElementHandle eeh; 

DPoint3d         pts[3]; 

 

pts[0] = pts[1] = pts[2] = basePt; 

pts[1].x += g_1mu*0.3;    pts[1].y += g_1mu*0.7; 

pts[0].x += g_1mu;        pts[0].y += g_1mu; 

DEllipse3d arcPts = DEllipse3d::FromPointsOnArc(pts[2], pts[1], pts[0]); 

CurveVectorPtr pCurveVec = CurveVector::Create(CurveVector::BOUNDARY_TYPE_Outer); 

pCurveVec->Add(ICurvePrimitive::CreateArc(arcPts)); 

 

pts[1].x = pts[0].x;    pts[1].y = pts[2].y; 

pCurveVec->Add(ICurvePrimitive::CreateLineString(pts, 3)); 

DraftingElementSchema::ToElement(eeh, *pCurveVec, nullptr, ACTIVEMODEL->Is3d(), *ACTIVEMODEL); 

eeh.AddToModel(); 

} 

 

void createAProjectedSolid(DPoint3dCR basePt) 

{ 

DPoint3d  pts[6]; 

pts[0] = basePt; 

pts[1].x = pts[0].x;               pts[1].y = pts[0].y - g_1mu / 2;   pts[1].z = pts[0].z; 

pts[2].x = pts[1].x + g_1mu / 2;   pts[2].y = pts[1].y;               pts[2].z = pts[0].z; 

pts[3].x = pts[2].x;               pts[3].y = pts[2].y - g_1mu / 2;   pts[3].z = pts[0].z; 

pts[4].x = pts[3].x + g_1mu / 2;   pts[4].y = pts[3].y;               pts[4].z = pts[0].z; 

pts[5].x = pts[4].x;               pts[5].y = pts[0].y;               pts[5].z = pts[0].z; 

 

CurveVectorPtr pCurveVec = CurveVector::CreateLinear(pts, 6, CurveVector::BOUNDARY_TYPE_Outer); 

DVec3d extrusionVec = DVec3d::From(0, 0, g_1mu); 

DgnExtrusionDetail  data(pCurveVec, extrusionVec, true); 

ISolidPrimitivePtr pSolid = ISolidPrimitive::CreateDgnExtrusion(data); 

EditElementHandle eeh; 

DraftingElementSchema::ToElement(eeh, *pSolid, nullptr, *ACTIVEMODEL); 

eeh.AddToModel(); 

} 

 

void createABsplineSurface(DPoint3dCR basePt) 

{ 

MSBsplineSurface bsSurface; 

MSBsplineCurve   bsCurves[4]; 

DPoint3d         center[4]; 

RotMatrix        rMatrix[4]; 

double           radius = g_1mu / 2; 

 

center[0] = center[1] = center[2] = center[3] = basePt; 

center[0].x += radius; 

center[1].x += g_1mu;     center[1].y += radius; 

center[2].x += radius;    center[2].y += g_1mu; 

center[3].y += radius; 

 

DVec3d xVec = DVec3d::From(1, 0, 0), negativeXVec = DVec3d::From(-1, 0, 0); 

DVec3d yVec = DVec3d::From(0, 1, 0), negativeYVec = DVec3d::From(0, -1, 0); 

DVec3d zVec = DVec3d::From(0, 0, 1); 

rMatrix[0].InitFrom2Vectors(xVec, zVec);  //Front View 

rMatrix[1].InitFrom2Vectors(yVec, zVec);  //Right View 

rMatrix[2].InitFrom2Vectors(negativeXVec, zVec);  //Back View 

rMatrix[3].InitFrom2Vectors(negativeYVec, zVec);  //Left View 

 

EditElementHandle eeh; 

for (int i = 0; i<4; i++) 

{ 

bsCurves[i].InitEllipticArc(center[i], radius, radius, 0, PI, &rMatrix[i]); 

} 

if (SUCCESS == mdlBspline_coonsPatch(&bsSurface, bsCurves)) 

{ 

DraftingElementSchema::ToElement(eeh, bsSurface, nullptr, *ACTIVEMODEL); 

eeh.AddToModel(); 

mdlBspline_freeSurface(&bsSurface); 

} 

for (int i = 0; i<4; i++) 

mdlBspline_freeCurve(&bsCurves[i]); 

} 

 

extern "C" DLLEXPORT void MdlMain(int argc, WCharCP argv[]) 

{ 

ModelInfoCP pInfo = ACTIVEMODEL->GetModelInfoCP(); 

g_1mu = pInfo->GetUorPerStorage(); 

 

DPoint3d basePt = DPoint3d::FromZero(); 

createALine(basePt); 

basePt.x += g_1mu*1.7;     basePt.y -= g_1mu*0.3;    basePt.z -= g_1mu*0.6; 

createAComplexShape(basePt); 

basePt.x += g_1mu*1.5;     basePt.y -= g_1mu*0.3;    basePt.z -= g_1mu*0.6; 

createAProjectedSolid(basePt); 

basePt.x += g_1mu*2.2;     basePt.y -= g_1mu*1.7;    basePt.z -= g_1mu*0.6; 

createABsplineSurface(basePt); 

} 

Explanation:

• This code consists of four functions that demonstrate how to create a line, a complex shape, a solid, and a B-spline surface.
• There are two header files MdlApi.h and DgnPlatformApi.h, which contain most of the class definitions and function prototypes that we can use.
• Three namespaces Bentley::DgnPlatform, Bentley::MstnPlatform, and Bentley::MstnPlatform::Element were introduced. Instead of using the C++ standard using namespace syntax, the three predefined macros in MDL are used directly. Note that these three lines do not need to end with a semicolon, because the macro definition already contains a semicolon.
• Since the default unit in MDL is UOR (Unit of Resolution) instead of the main unit in MicroStation, we define a global variable g_1mu to represent a main unit. In the MdlMain function, assign it to UorPerStorage under ModelInfo. For the relationship between the main unit, sub unit and resolution unit, please refer to the following figure (select the menu File> Settings> File> Design File Settings to open this dialog box):

• The createALine function creates a line. First construct the DSegment3d object seg, which represents the two endpoints of a single line segment, then call CreateLine under the ICurvePrimitive interface to create the geometry of the line segment, and then call the ToElement function under DraftingElementSchema to convert the geometry into an EditElementHandle object eeh, and finally call the AddToModel function to eeh Added to the model. This kind of thinking is a big change of MicroStation CE SDK. Geometry can be understood as a universal geometric expression that has nothing to do with MicroStation. Only after being converted to EditElementHandle, it becomes an element in MicroStation.
• The createAComplexShape function creates a complex shape consisting of arcs and line strings. First create a CurveVector of type BOUNDARY_TYPE_Outer. CurveVector is a dynamic array (Vector in STL) composed of ICurvePrimitive, which can be used to express complex elements such as Complex Chain or Complex Shape. Then call ICurvePrimitive::CreateArc and ICurvePrimitive::CreateLineString respectively to create an arc and a line string to add to the CurveVector, and finally call DraftingElementSchema::ToElement like createALine to generate an EditElementHandle and add it to the model.
• The createAProjectedSolid function generates an extruded volume based on a section. First create a CurveVector that expresses the section, then create a DgnExtrusionDetail geometric data based on this section and the extrusion vector, and then call ISolidPrimitive::CreateDgnExtrusion to create an extruded volume. ISolidPrimitive is used to represent the basic geometric entities defined by Bentley, while ISolidKernelEntity is used to represent any complex entity expressed using the ParaSolid kernel.
• The createABsplineSurface function generates a Kongs surface from four arcs. Since no suitable member function was found in the MSBsplineSurface class, we continue to call the MDL C function mdlBspline_coonsPatch. Because neither MSBsplineSurface nor MSBsplineCurve uses smart pointers (the ones that end in Ptr are all smart pointers defined in MDL), you need to explicitly call mdlBspline_freeSurface and mdlBspline_freeCurve to release memory, otherwise memory leaks will occur.

2. Type bmake -a in the MicroStation Developer Shell to generate the final HelloWorld.ma and HelloWorld.dll.

3. Start MicroStation, open or create a new 3D model, type MDL LOAD HelloWorld in the input command field and press Enter to generate the figure shown below. This graphic is the effect seen in the ISO view.

Prev:[[Detailed explanation of mke file]]

Next:[[Adding commands to MDL applications]]