envi-code/SourceCode/Code2026/PIDLineCmd/KTCurveCreator.cpp

#include "stdafx.h"
#include "KTCurveCreator.h"
#include "KT3DModel.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

namespace
{
	BOOL GetArcParam(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, double dBulge, const AcGeVector3d& vtNormal,
		AcGePoint3d& ptCenter, double& dRadius, double& dStartAngle, double& dEndAngle)
	{
		ASSERT(!_IsZero_(dBulge));
		ASSERT(ptStart != ptEnd);

		// 调整顺序
		const AcGePoint3d* pt1;
		const AcGePoint3d* pt2;
		if (dBulge < 0.0)
		{
			pt1 = &ptEnd;
			pt2 = &ptStart;
			dBulge = -dBulge;
		}
		else
		{
			pt1 = &ptStart;
			pt2 = &ptEnd;
		}

		// 直角三角形对边与斜边关系R = L/sin(A/2)
		// 代入万能公式 sin(A)=2*tg(A/2)/(1+tg(A/2)*tg(A/2))
		// 得到 R = L*(1+B*B) / (2B)  -->L:(p1->p2)/2  B:bulge
		double dL = pt1->distanceTo(*pt2) / 2.0;
		dRadius = dL * (1 + dBulge * dBulge) / (2.0 * dBulge);

		double dA = PI / 2.0 - atan(dBulge) * 2.0;
		AcGeVector3d vt(*pt2 - *pt1);
		vt.rotateBy(dA, vtNormal);
		vt.normalize();
		ptCenter = *pt1 + vt * dRadius;

		acdbWcs2Ecs(asDblArray(AcGeVector3d::kXAxis), asDblArray(vt), asDblArray(vtNormal), true);
		dStartAngle = vt.angleTo(*pt1 - ptCenter, vtNormal);
		dEndAngle = vt.angleTo(*pt2 - ptCenter, vtNormal);

		return TRUE;
	}
}

namespace KTAcadUtl {

#define BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation)	\
	DWORD dwBit, dwFlag = 0;	\
	do	\
	{	\
		if (RTSTR == pRb->restype)	\
		{	\
			dwBit = 0;	\
			if (FALSE) ;	\
			ON_RESBUF_CHAR_NA(pRb, _T("Layer"), sLayer);	\
			ON_RESBUF_CHAR_NA(pRb, _T("XData"), sXData);	\
			ON_RESBUF_POINT_NA(pRb, _T("Position"), ptPosition);	\
			ON_RESBUF_POINT_NA(pRb, _T("Rotation"), ptRotation)	\

#define ON_RESBUF_BOOL		ON_RESBUF_INT
#define ON_RESBUF_BOOL_NA	ON_RESBUF_INT_NA
#define ON_RESBUF_INT(pRb, pszParam, lValue)	\
			else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTLONG == pRb->restype && (dwFlag |= (1<<dwBit)))	\
				lValue = pRb->resval.rlong	\

#define ON_RESBUF_INT_NA(pRb, pszParam, lValue)	\
			else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTLONG == pRb->restype)	\
				lValue = pRb->resval.rlong	\

#define ON_RESBUF_REAL(pRb, pszParam, dValue)	\
			else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTREAL == pRb->restype && (dwFlag |= (1<<dwBit)))	\
				dValue = pRb->resval.rreal	\

#define ON_RESBUF_REAL_NA(pRb, pszParam, dValue)	\
			else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTREAL == pRb->restype)	\
				dValue = pRb->resval.rreal	\

#define ON_RESBUF_CHAR(pRb, pszParam, sValue)	\
			else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTSTR == pRb->restype && (dwFlag |= (1<<dwBit)))	\
				sValue = pRb->resval.rstring	\

#define ON_RESBUF_CHAR_NA(pRb, pszParam, sValue)	\
			else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RTSTR == pRb->restype)	\
				sValue = pRb->resval.rstring	\

#define ON_RESBUF_POINT(pRb, pszParam, ptValue)	\
			else if ((++dwBit) && _tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RT3DPOINT == pRb->restype && (dwFlag |= (1<<dwBit)))	\
				ptValue = asPnt3d(pRb->resval.rpoint)	\

#define ON_RESBUF_POINT_NA(pRb, pszParam, ptValue)	\
			else if (_tcsicmp(pRb->resval.rstring, pszParam) == 0	\
				&& NULL != (pRb = pRb->rbnext) && RT3DPOINT == pRb->restype)	\
				ptValue = asPnt3d(pRb->resval.rpoint)	\

#define END_RESBUF_VALUE(pRb, nVars)	\
			else	\
			{	\
				pRb = pRb->rbnext;	\
			}	\
		}	\
		pRb = (NULL == pRb ? NULL : pRb->rbnext);	\
	} while	(NULL != pRb);	\
	dwBit = nVars;	\
	for (; dwBit > 0; dwBit--)	\
		if ((dwFlag & (1<<dwBit)) == 0)	\
			return	\

void AttachAttr(AcDbEntity* pEnt, LPCTSTR pszLayer)
{
	if (NULL == pEnt || NULL == pszLayer || _tcslen(pszLayer) <= 0)
		return;

	AcDbObjectId idLayer = KTSetting::InitLayer(pszLayer);
	pEnt->setLayer(idLayer);
}

void AttachXData(AcDbEntity* pEnt, LPCTSTR pszXData)
{
	if (NULL == pEnt || NULL == pszXData || _tcslen(pszXData) <= 0)
		return;

	resbuf rbHead, *pRb;
	pRb = &rbHead;

	int i;
	CString sSub;
	BOOL bStr = FALSE;
	while (_T('\0') != pszXData[0])
	{
		i = _tcsinc(pszXData) - pszXData;
		if (1 == i)
		{
			switch (pszXData[0])
			{
			case _T('\"'):
				if (bStr)
					bStr = FALSE;
				else
					bStr = TRUE;
				break;
			case _T(','):
				if (bStr)
					sSub += _T(',');
				else
				{
					pRb->rbnext = acutNewRb(AcDb::kDxfXdAsciiString);
					if (NULL != pRb->rbnext)
					{
						pRb = pRb->rbnext;
						acutNewString(sSub, pRb->resval.rstring);
					}
					sSub.Empty();
				}
				break;
			case _T('\\'):
				if (_T('\"') == pszXData[1] || _T('\\') == pszXData[1]
					|| _T(',') == pszXData[1] || _T(' ') == pszXData[1])
				{
					sSub += pszXData[1];
					pszXData++;
				}
				else
				{
					sSub += _T('\\');
				}
				break;
			case _T(' '):
				if (bStr || !sSub.IsEmpty())
					sSub += _T(' ');
				break;
			default:
				sSub += pszXData[0];
				break;
			}
			pszXData++;
		}
		else
		{
			for (; i > 0; i--, pszXData++)
				sSub += pszXData[0];
		}
	}

	pRb->rbnext = acutNewRb(AcDb::kDxfXdAsciiString);
	if (NULL != pRb->rbnext)
	{
		pRb = pRb->rbnext;
		acutNewString(sSub, pRb->resval.rstring);
	}

	if (NULL == rbHead.rbnext)
		return;

	rbHead.restype = AcDb::kDxfRegAppName;
	rbHead.resval.rstring = _tcsdup(_T("KTParamPart"));
	acdbRegApp(rbHead.resval.rstring);

	pEnt->setXData(&rbHead);

	acutRelRb(rbHead.rbnext);
}

void CreateLineDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	double dWidth;
	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 3);

	if (_IsZero_(dWidth))
	{
		AcDbLine* pLine = new AcDbLine(ptStart, ptEnd);
		ASSERT(NULL != pLine);

		AttachAttr(pLine, sLayer);
		AttachXData(pLine, sXData);

		pLine->setDatabaseDefaults();
		arpEnts.append(pLine);
	}
	else
	{
		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane));
		pPLine->addVertexAt(1, ptEnd.convert2d(plane));
		pPLine->setConstantWidth(dWidth);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateLinePtAngLen(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dAngle, dLength, dWidth;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
		ON_RESBUF_REAL(pRb, _T("Length"), dLength);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 4);

	AcGeVector3d vtDir(AcGeVector3d::kXAxis);
	vtDir.rotateBy(dAngle, AcGeVector3d::kZAxis);
	ptEnd = ptStart + vtDir * dLength;

	if (_IsZero_(dWidth))
	{
		AcDbLine* pLine = new AcDbLine(ptStart, ptEnd);
		ASSERT(NULL != pLine);

		AttachAttr(pLine, sLayer);
		AttachXData(pLine, sXData);

		pLine->setDatabaseDefaults();
		arpEnts.append(pLine);
	}
	else
	{
		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane));
		pPLine->addVertexAt(1, ptEnd.convert2d(plane));
		pPLine->setConstantWidth(dWidth);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateArcDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptCenter;
	double dRadius, dStartAngle, dEndAngle, dWidth;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
		ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 5);

	if (_IsZero_(dWidth))
	{
		AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
		ASSERT(NULL != pArc);

		AttachAttr(pArc, sLayer);
		AttachXData(pArc, sXData);

		pArc->setDatabaseDefaults();
		arpEnts.append(pArc);
	}
	else
	{
		AcGePoint3d ptStart, ptEnd;
		acutPolar(asDblArray(ptCenter), dStartAngle, dRadius, asDblArray(ptStart));
		acutPolar(asDblArray(ptCenter), dEndAngle, dRadius, asDblArray(ptEnd));
		double dAngle = dEndAngle - dStartAngle;
		if (dAngle < 0.0) dAngle += PI * 2.0;
		double dBulge = tan(dAngle / 4.0);

		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane));
		pPLine->setConstantWidth(dWidth);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateArcPtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	double dWidth;
	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd, ptOn;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
		ON_RESBUF_POINT(pRb, _T("Point"), ptOn);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 4);

	AcGePoint3d ptCenter;
	double dRadius, dStartAngle, dEndAngle, dAngle;
	AcGeCircArc3d geArc(ptStart, ptOn, ptEnd);
	dAngle = AcGeVector3d::kXAxis.angleTo(geArc.refVec(), AcGeVector3d::kZAxis);
	ptCenter = geArc.center();
	dRadius = geArc.radius();
	dStartAngle = fmod(dAngle + geArc.startAng(), PI * 2.0);
	dEndAngle = fmod(dAngle + geArc.endAng(), PI * 2.0);

	if (_IsZero_(dWidth))
	{
		AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
		ASSERT(NULL != pArc);

		AttachAttr(pArc, sLayer);
		AttachXData(pArc, sXData);

		pArc->setDatabaseDefaults();
		arpEnts.append(pArc);
	}
	else
	{
		double dAngle = dEndAngle - dStartAngle;
		if (dAngle < 0.0) dAngle += PI * 2.0;
		double dBulge = tan(dAngle / 4.0);

		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane));
		pPLine->setConstantWidth(dWidth);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateArcPtPtBulge(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	double dBulge, dWidth;
	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
		ON_RESBUF_REAL(pRb, _T("Bulge"), dBulge);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 4);

	if (_IsZero_(dWidth))
	{
		AcGePoint3d ptCenter;
		double dRadius, dStartAngle, dEndAngle;
		if (!GetArcParam(ptStart, ptEnd, dBulge, AcGeVector3d::kZAxis, ptCenter, dRadius, dStartAngle, dEndAngle))
			return;

		AcDbArc* pArc = new AcDbArc(ptCenter, dRadius, dStartAngle, dEndAngle);
		ASSERT(NULL != pArc);

		AttachAttr(pArc, sLayer);
		AttachXData(pArc, sXData);

		pArc->setDatabaseDefaults();
		arpEnts.append(pArc);
	}
	else
	{
		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), dBulge);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane));
		pPLine->setConstantWidth(dWidth);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateCircleDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dWidth;
	AcGePoint3d ptPosition, ptRotation, ptCenter;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 3);

	if (_IsZero_(dWidth))
	{
		AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
		ASSERT(NULL != pCircle);

		AttachAttr(pCircle, sLayer);
		AttachXData(pCircle, sXData);

		pCircle->setDatabaseDefaults();
		arpEnts.append(pCircle);
	}
	else
	{
		AcGePoint3d ptStart(ptCenter + AcGeVector3d::kXAxis * dRadius);
		AcGePoint3d ptEnd(ptCenter - AcGeVector3d::kXAxis * dRadius);

		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
		pPLine->setConstantWidth(dWidth);
		pPLine->setClosed(TRUE);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateCirclePtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	double dWidth;
	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("Point1"), pt1);
		ON_RESBUF_POINT(pRb, _T("Point2"), pt2);
		ON_RESBUF_POINT(pRb, _T("Point3"), pt3);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 4);

	double dRadius;
	AcGePoint3d ptCenter;
	AcGeCircArc3d geArc(pt1, pt2, pt3);
	ptCenter = geArc.center();
	dRadius = geArc.radius();

	if (_IsZero_(dWidth))
	{
		AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
		ASSERT(NULL != pCircle);

		AttachAttr(pCircle, sLayer);
		AttachXData(pCircle, sXData);

		pCircle->setDatabaseDefaults();
		arpEnts.append(pCircle);
	}
	else
	{
		AcGePoint3d ptStart(ptCenter + AcGeVector3d::kXAxis * dRadius);
		AcGePoint3d ptEnd(ptCenter - AcGeVector3d::kXAxis * dRadius);

		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
		pPLine->setConstantWidth(dWidth);
		pPLine->setClosed(TRUE);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateCircleDiameter(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	double dWidth;
	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
	END_RESBUF_VALUE(pRb, 3);

	AcGePoint3d ptCenter((ptStart.x + ptEnd.x) / 2.0, (ptStart.y + ptEnd.y) / 2.0, (ptStart.z + ptEnd.z) / 2.0);
	double dRadius = ptStart.distanceTo(ptCenter);

	if (_IsZero_(dWidth))
	{
		AcDbCircle* pCircle = new AcDbCircle(ptCenter, AcGeVector3d::kZAxis, dRadius);
		ASSERT(NULL != pCircle);

		AttachAttr(pCircle, sLayer);
		AttachXData(pCircle, sXData);

		pCircle->setDatabaseDefaults();
		arpEnts.append(pCircle);
	}
	else
	{
		AcDbPolyline* pPLine = new AcDbPolyline(2);
		ASSERT(NULL != pPLine);
		AcGePlane plane(AcGePoint3d::kOrigin, AcGeVector3d::kZAxis);
		pPLine->setNormal(AcGeVector3d::kZAxis);
		pPLine->addVertexAt(0, ptStart.convert2d(plane), 1);
		pPLine->addVertexAt(1, ptEnd.convert2d(plane), 1);
		pPLine->setConstantWidth(dWidth);
		pPLine->setClosed(TRUE);

		AttachAttr(pPLine, sLayer);
		AttachXData(pPLine, sXData);

		pPLine->setDatabaseDefaults();
		arpEnts.append(pPLine);
	}
}

void CreateEllipseDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, ptCenter;
	double dMajor, dMinor, dDirAngle, dStartAngle, dEndAngle;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("Center"), ptCenter);
		ON_RESBUF_REAL(pRb, _T("MajorAxis"), dMajor);
		ON_RESBUF_REAL(pRb, _T("MinorAxis"), dMinor);
		ON_RESBUF_REAL(pRb, _T("DirectAngle"), dDirAngle);
		ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
		ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
	END_RESBUF_VALUE(pRb, 6);

	if (_IsZero_(dMajor))
		return;

	AcGeVector3d vtMajor(AcGeVector3d::kXAxis);
	vtMajor.rotateBy(dDirAngle, AcGeVector3d::kZAxis);

	AcDbEllipse* pEllipse = new AcDbEllipse(ptCenter, AcGeVector3d::kZAxis, vtMajor * dMajor / 2.0,
											dMinor / dMajor, dStartAngle, dEndAngle);
	ASSERT(NULL != pEllipse);

	AttachAttr(pEllipse, sLayer);
	AttachXData(pEllipse, sXData);

	pEllipse->setDatabaseDefaults();
	arpEnts.append(pEllipse);
}

void CreateEllipsePtPtRatio(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRatio, dStartAngle, dEndAngle;
	AcGePoint3d ptPosition, ptRotation, ptStart, ptEnd;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("StartPoint"), ptStart);
		ON_RESBUF_POINT(pRb, _T("EndPoint"), ptEnd);
		ON_RESBUF_REAL(pRb, _T("Ratio"), dRatio);
		ON_RESBUF_REAL(pRb, _T("StartAngle"), dStartAngle);
		ON_RESBUF_REAL(pRb, _T("EndAngle"), dEndAngle);
	END_RESBUF_VALUE(pRb, 5);

	AcGePoint3d ptCenter((ptStart.x + ptEnd.x) / 2.0, (ptStart.y + ptEnd.y) / 2.0, (ptStart.z + ptEnd.z) / 2.0);
	AcGeVector3d vtMajor(ptStart - ptCenter);

	AcDbEllipse* pEllipse = new AcDbEllipse(ptCenter, AcGeVector3d::kZAxis, vtMajor,
											dRatio, dStartAngle, dEndAngle);
	ASSERT(NULL != pEllipse);

	AttachAttr(pEllipse, sLayer);
	AttachXData(pEllipse, sXData);

	pEllipse->setDatabaseDefaults();
	arpEnts.append(pEllipse);
}

void CreateTextDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sContent;
	double dHeight, dAngle;
	CString sLayer, sXData, sStyle, sAlignment;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_CHAR_NA(pRb, _T("Style"), sStyle);
		ON_RESBUF_CHAR_NA(pRb, _T("Alignment"), sAlignment);
		ON_RESBUF_CHAR(pRb, _T("Content"), sContent);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
		ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
	END_RESBUF_VALUE(pRb, 3);

	AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
	AcDbObjectId idStyle = KTSetting::InitTextStyle(sStyle);
	if (idStyle.isNull()) idStyle = pDb->textstyle();

	AcDbText* pText = new AcDbText(ptPosition, sContent, idStyle, dHeight, dAngle);
	ASSERT(NULL != pText);

	int iLen = sAlignment.GetLength();
	for (int i = 0; i < iLen && !_istdigit(sAlignment[i]); i++) ;
	int iAlign = ((i < iLen && sAlignment[i] <= _T('5')) ? sAlignment[i] - _T('0') : 0);
	pText->setHorizontalMode((AcDb::TextHorzMode)iAlign);
	//
	for (i++; i < iLen && !_istdigit(sAlignment[i]); i++) ;
	iAlign = ((i < iLen && sAlignment[i] <= _T('3')) ? sAlignment[i] - _T('0') : 0);
	pText->setVerticalMode((AcDb::TextVertMode)iAlign);
	//
	pText->setAlignmentPoint(ptPosition);
	pText->adjustAlignment(pDb);

	AttachAttr(pText, sLayer);
	AttachXData(pText, sXData);

	pText->setDatabaseDefaults();
	arpEnts.append(pText);
}

void CreatePointDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
	END_RESBUF_VALUE(pRb, 0);

	AcDbPoint* pPoint = new AcDbPoint(ptPosition);
	ASSERT(NULL != pPoint);

	AttachAttr(pPoint, sLayer);
	AttachXData(pPoint, sXData);

	pPoint->setDatabaseDefaults();
	arpEnts.append(pPoint);
}

void CreateSolidDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3, pt4;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("First"), pt1);
		ON_RESBUF_POINT(pRb, _T("Second"), pt2);
		ON_RESBUF_POINT(pRb, _T("Third"), pt3);
		ON_RESBUF_POINT(pRb, _T("Fourth"), pt4);
	END_RESBUF_VALUE(pRb, 4);

	AcDbSolid* pSolid = new AcDbSolid(pt1, pt2, pt3, pt4);
	ASSERT(NULL != pSolid);

	AttachAttr(pSolid, sLayer);
	AttachXData(pSolid, sXData);

	pSolid->setDatabaseDefaults();
	arpEnts.append(pSolid);
}

void CreateSolidPtPtPt(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation, pt1, pt2, pt3;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_POINT(pRb, _T("First"), pt1);
		ON_RESBUF_POINT(pRb, _T("Second"), pt2);
		ON_RESBUF_POINT(pRb, _T("Third"), pt3);
	END_RESBUF_VALUE(pRb, 3);

	AcDbSolid* pSolid = new AcDbSolid(pt1, pt2, pt3);
	ASSERT(NULL != pSolid);

	AttachAttr(pSolid, sLayer);
	AttachXData(pSolid, sXData);

	pSolid->setDatabaseDefaults();
	arpEnts.append(pSolid);
}

void CreateCubeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dLength, dWidth, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Length"), dLength);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Cube(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth, AcGeVector3d::kZAxis * dHeight, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateCylinderDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 2);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Cylinder(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateConeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 2);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Cone(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateTorusDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dRadius1, dAngle;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
		ON_RESBUF_REAL(pRb, _T("Angle"), dAngle);
	END_RESBUF_VALUE(pRb, 3);

	dAngle = AsRadian(dAngle);

	AcGeVector3d vt(AcGeVector3d::kXAxis * dRadius);
	AcGePoint3d ptCenter(ptPosition - vt);
	vt.rotateBy(dAngle / 2.0, AcGeVector3d::kZAxis);
	AcGePoint3d pt1(ptCenter + vt);
	vt.rotateBy(dAngle / 2.0, AcGeVector3d::kZAxis);
	AcGePoint3d pt2(ptCenter + vt);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Elbow(ptPosition, pt1, pt2, dRadius1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreatePipeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 2);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Pipe(ptPosition, dRadius, AcGeVector3d::kZAxis * dHeight, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateDuctDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dLength, dWidth, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Length"), dLength);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Duct(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth, AcGeVector3d::kZAxis * dHeight, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateEccPipeRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation;
	double dRadius, dRadius1, dHeight, dOffsetX, dOffsetY;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
		ON_RESBUF_REAL(pRb, _T("OffsetX"), dOffsetX);
		ON_RESBUF_REAL(pRb, _T("OffsetY"), dOffsetY);
	END_RESBUF_VALUE(pRb, 5);

	AcGeVector3d vtOffset(dOffsetX, dOffsetY, 0);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::PipeEccRed(ptPosition, dRadius, ptPosition + AcGeVector3d(dOffsetX, dOffsetY, dHeight),
							dRadius1, vtOffset, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreatePipeRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dRadius1, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::PipeRed(ptPosition, dRadius, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateTrConeDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dRadius1, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Radius1"), dRadius1);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::ConeRed(ptPosition, dRadius, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateDuctRedDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	AcGePoint3d ptPosition, ptRotation;
	double dLength, dWidth, dLength1, dWidth1, dHeight;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Length"), dLength);
		ON_RESBUF_REAL(pRb, _T("Width"), dWidth);
		ON_RESBUF_REAL(pRb, _T("Length1"), dLength1);
		ON_RESBUF_REAL(pRb, _T("Width1"), dWidth1);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 5);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::PyRam(ptPosition, AcGeVector3d::kXAxis * dLength, AcGeVector3d::kYAxis * dWidth,
					ptPosition + AcGeVector3d::kZAxis * dHeight, dLength1, dWidth1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateHemiSphDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
	END_RESBUF_VALUE(pRb, 2);

	AcGeVector3d vtNormal(AcGeVector3d::kZAxis);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::HemiSph(ptPosition, dRadius, dHeight, vtNormal, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateCapDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight, dHeight1;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
		ON_RESBUF_REAL(pRb, _T("Height1"), dHeight1);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Cap(ptPosition, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius, dHeight1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

void CreateTankDefault(AcDbVoidPtrArray& arpEnts, const struct resbuf* pRb)
{
	if (NULL == pRb)
		return;

	CString sLayer, sXData;
	double dRadius, dHeight, dHeight1;
	AcGePoint3d ptPosition, ptRotation;
	BEGIN_RESBUF_VALUE(pRb, sLayer, sXData, ptPosition, ptRotation);
		ON_RESBUF_REAL(pRb, _T("Radius"), dRadius);
		ON_RESBUF_REAL(pRb, _T("Height"), dHeight);
		ON_RESBUF_REAL(pRb, _T("Height1"), dHeight1);
	END_RESBUF_VALUE(pRb, 3);

	AcDbVoidPtrArray arpFaces;
	KT3DModel::Container(ptPosition, ptPosition + AcGeVector3d::kZAxis * dHeight, dRadius, dHeight1, arpFaces);

	AcGeMatrix3d mat1, mat2, mat3;
	mat1.setToRotation(AsRadian(ptRotation.x), AcGeVector3d::kZAxis, ptPosition);
	mat2.setToRotation(AsRadian(ptRotation.y), AcGeVector3d::kXAxis, ptPosition);
	mat3.setToRotation(AsRadian(ptRotation.z), AcGeVector3d::kZAxis, ptPosition);
	AcGeMatrix3d mat(mat3 * mat2 * mat1);

	AcDbEntity* pEnt;
	int iPos = arpFaces.length();
	while ((--iPos) >= 0)
	{
		pEnt = (AcDbEntity*)arpFaces[iPos];
		pEnt->transformBy(mat);

		AttachAttr(pEnt, sLayer);
		AttachXData(pEnt, sXData);

		pEnt->setDatabaseDefaults();
		arpEnts.append(pEnt);
	}
}

};