envi-code/SourceCode/Code2026/ArchCmd/AecDbAscentDraw.cpp

#include "stdafx.h"
#include "AecDbAscent.h"
#include "AecDbAscentDraw.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"

#ifndef AS_INT
#define AS_INT(f) (f < 0.0 ? int((f) - 0.5) : int((f) + 0.5))
#endif

DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);

ACRX_CONS_DEFINE_MEMBERS(AecDbAscentDraw,AecDbXDraw,0);

AecDbAscentDraw::AecDbAscentDraw(void)
{
}

AecDbAscentDraw::~AecDbAscentDraw(void)
{
}

static void TrimLine(AcDbLine* pLnUp,AcDbLine* pLnL,int nSorE)
{
	AcGePoint3dArray pts;
	pLnUp->intersectWith(pLnL,AcDb::kOnBothOperands,pts);

	if (pts.length() == 1)
	{
		if (nSorE == 0)
			pLnUp->setStartPoint(pts.first());
		else
			pLnUp->setEndPoint(pts.first());
	}
}

Acad::ErrorStatus AecDbAscentDraw::Draw2d(AcGiDraw &dc) const
{
	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbAscent* pAscent = AecDbAscent::cast(pEntReal);
	if (pAscent == NULL)
		return Acad::eOk;

	AscentData data;
	pAscent->GetAscentData(data);

	AcDbCurve* pBaseCrv = pAscent->GetBaseCurve();
	if (pBaseCrv != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCrv);
		if (pLn != NULL)
		{
			AcGePoint3d ptE = pLn->startPoint();
			AcGePoint3d ptS = pLn->endPoint();
			ptS.z = ptE.z = 0.0;
			AcGeVector3d vtDir = ptE - ptS;
			AcGeVector3d vtW = vtDir;
			vtW.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

			vtW.normalize();
			vtDir.normalize();

			AcGePoint3d ptGe[6],ptT;
			ptGe[0] = ptS;
			ptGe[0] -= vtW * 0.5 * data.dW;
			ptGe[1] = ptGe[0] + vtW * data.dW;

			ptGe[2] = ptGe[1] + vtDir * data.dLx;
			ptGe[3] = ptGe[0] + vtDir * data.dLx;

			ptGe[4] = ptGe[0];

			AcDbPolyline* pPl = FormatPolyline(ptGe,5);
			if (pPl != NULL)
			{
				dc.DrawPolyline(*pPl);
				dc.Add2dBuffer(pPl);
			}

			AcDbLine* pLnL = NULL;
			AcDbLine* pLnR = NULL;
			if (!data.bAlignL)
			{
				ptGe[3] += vtW * data.dSideW;
				pLnL = new AcDbLine(ptGe[0],ptGe[3]);
				dc.DrawEntity(pLnL);
				dc.Add2dBuffer(pLnL);
			}
			else
			{
				pLnL = new AcDbLine(ptGe[0],ptGe[3]);
			}

			if (!data.bAlignR)
			{
				ptGe[2] -= vtW * data.dSideW;
				pLnR = new AcDbLine(ptGe[1],ptGe[2]);
				dc.DrawEntity(pLnR);
				dc.Add2dBuffer(pLnR);
			}
			else
			{
				pLnR = new AcDbLine(ptGe[1],ptGe[2]);
			}

			if (data.bNonslip)
			{
				int nRow = AS_INT(data.dLx / 100.0);
				double dSp = data.dLx / nRow;
				AcDbLine* pLnUp = NULL;

				vtDir.normalize();
				vtDir *= dSp;

				for(int i=1; i < nRow; i++)
				{
					ptGe[0] += vtDir;
					ptGe[1] += vtDir;

					pLnUp = new AcDbLine;
					pLnUp->setStartPoint(ptGe[0]);
					pLnUp->setEndPoint(ptGe[1]);

					TrimLine(pLnUp,pLnL,0);
					TrimLine(pLnUp,pLnR,1);

					dc.DrawEntity(pLnUp);
					dc.Add2dBuffer(pLnUp);
				}
			}
			if (data.bAlignL)
				delete pLnL;
			if (data.bAlignR)
				delete pLnR;
		}
		delete pBaseCrv;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbAscentDraw::Draw3d(AcGiDraw &dc) const
{
	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbAscent* pAscent = AecDbAscent::cast(pEntReal);
	if (pAscent == NULL)
		return Acad::eOk;

	AscentData data;
	pAscent->GetAscentData(data);

	AcDbCurve* pBaseCrv = pAscent->GetBaseCurve();
	if (pBaseCrv != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCrv);
		if (pLn != NULL)
		{
			AcGePoint3d ptE = pLn->startPoint();
			AcGePoint3d ptS = pLn->endPoint();

			ptS.z = ptE.z = 0.0;
			AcGeVector3d vtDir = ptE - ptS;
			AcGeVector3d vtW = vtDir;
			vtW.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

			vtW.normalize();
			vtDir.normalize();

			AcGePoint3d ptGe[6],ptT;
			ptGe[0] = ptS;
			ptGe[0] -= vtW * 0.5 * data.dW;
			ptGe[1] = ptGe[0] + vtW * data.dW;

			ptGe[2] = ptGe[1] + vtDir * data.dLx;
			ptGe[3] = ptGe[0] + vtDir * data.dLx;
			ptGe[4] = ptGe[0];

			AcGePoint3d ptGe22 = ptGe[2];
			AcGePoint3d ptGe33 = ptGe[3];

			ptGe[2].z = data.dTopEl;
			ptGe[3].z = data.dTopEl;

			AcGePoint3d ptGe00 = ptGe[0];
			AcGePoint3d ptGe11 = ptGe[1];

			ptGe[0].z = data.dTopEl - data.dLy;
			ptGe[1].z = ptGe[0].z;

			ptGe00.z = ptGe[0].z;
			ptGe11.z = ptGe[1].z;
			ptGe22.z = ptGe[1].z;
			ptGe33.z = ptGe[0].z;

			vtDir = ptGe[3] - ptGe[0];
			vtDir.normalize();

			AcDbLine lnEx;
			lnEx.setStartPoint(ptGe[2]);
			lnEx.setEndPoint(ptGe[3]);

			AcGePoint3dArray arPts;
			arPts.append(ptGe[0]);
			if (data.bNonslip)
			{
				double dL = sqrt(data.dLx*data.dLx+data.dLy*data.dLy);
				int nRow = AS_INT(data.dLx / 100.0);
				double dSp = dL / nRow;
				vtDir *= dSp;

				for(int i=1; i < nRow; i++)
				{
					ptGe[0] += vtDir;
					ptGe[1] = ptGe[0];
					ptGe[1].z += 10;//防滑尺寸
					arPts.append(ptGe[1]);
					arPts.append(ptGe[0]);
				}
			}
			arPts.append(ptGe[3]);
			arPts.append(ptGe33);
			arPts.append(ptGe00);

			//测试
			//AcDbPolyline* pPl = FormatPolyline(arPts.asArrayPtr(),arPts.length());
			//pPl->setColorIndex(3);
			//CoreTools::AddToModelSpace(pPl);

			AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arPts.asArrayPtr(),arPts.length());
			if (pReg != NULL)
			{
				AcDbX3dSolid xSolid;
				if ( xSolid.CreateExtrude(pReg, lnEx))
				{
					AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
					if (pSolid != NULL)
					{
						AcDb3dSolid* pNegSolid = NULL;
						if (!data.bAlignL)
						{
							ptGe[3] += vtW * data.dSideW;

							AcGePlane plan1;
							plan1.set(ptGe00,ptGe33,ptGe[3]);
							pSolid->getSlice(plan1,false,pNegSolid);
						}

						if (!data.bAlignR)
						{
							ptGe[2] -= vtW * data.dSideW;

							AcGePlane plan2;
							plan2.set(ptGe11,ptGe[2],ptGe22);
							pSolid->getSlice(plan2,false,pNegSolid);
						}

						dc.DrawEntity(pSolid);
						dc.Add3dBuffer(pSolid);
						delete pBaseCrv;
						return Acad::eOk;
					}
				}
			}
		}
		delete pBaseCrv;
	}
	return Acad::eOk;
}