#include "stdafx.h"
#include "AecDbLineSegStairDraw.h"
#include "AecDbLineSegStair.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"
#include "EarThwormDef.h"
#include "CoreTools.h"

static const Adesk::UInt16 kColorByBlock = 0;
static const Adesk::UInt16 kRed = 1;
static const Adesk::UInt16 kYellow = 2;
static const Adesk::UInt16 kGreen = 3;
static const Adesk::UInt16 kCyan = 4;
static const Adesk::UInt16 kBlue = 5;
static const Adesk::UInt16 kMagenta = 6;
static const Adesk::UInt16 kWhite = 7;
static const Adesk::UInt16 kColorByLayer = 256;

DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
DLLIMPEXP AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);

ACRX_CONS_DEFINE_MEMBERS(AecDbLineSegStairDraw,AecDbXDraw,0);

namespace 
{
	AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
		, const AcGeVector3d& vtZ
		, const double& dR)
	{
		AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
		AcDbRegion* pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);
		return pReg;
	}
}

AecDbLineSegStairDraw::AecDbLineSegStairDraw(void)
{
}

AecDbLineSegStairDraw::~AecDbLineSegStairDraw(void)
{
}

Acad::ErrorStatus AecDbLineSegStairDraw::Draw2d(AcGiDraw &dc) const
{
	const AecDbObjXDataMap* pXDataMap = GetSpecialtyData();
	if (pXDataMap == NULL)
	{
		return Acad::eOk;
	}

	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
	if (pBaseStair == NULL)
		return Acad::eOk;

	LineStair data;
	pBaseStair->GetLineStairData(data);

	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();

	Adesk::UInt16 nCrBk = 256;
	nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}
	else
		dc.SetColor(pEntReal->colorIndex());

	AcDbCurve* pBaseCurve = pBaseStair->GetBaseCurve();
	if (pBaseCurve != NULL)//路径
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			ptSta.z = ptEnd.z = 0.0;

			double dLx = data.nSteepS * data.dSteepW;
			double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
			double dL = sqrt(dLx * dLx + dLh * dLh);

			AcGeVector3d vtV = ptEnd - ptSta;
			AcGeVector3d vtL = vtV;

			vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
			vtV.normalize();

			vtL.normalize();
			ptEnd = ptSta + vtL * dLx;

			//左线
			AcGePoint3d ptGe[5];
			ptGe[0] = ptSta;
			ptGe[0] += vtV * 0.5 * data.dW;

			ptGe[1] = ptEnd;
			ptGe[1] += vtV * 0.5 * data.dW;

			ptGe[2] = ptGe[1];
			ptGe[2] -= vtV * data.dSidet;

			ptGe[3] = ptGe[0];
			ptGe[3] -= vtV * data.dSidet;

			ptGe[4] = ptGe[0];

			//1.两侧边
			AcDbPolyline* pPl = NULL;
			pPl = FormatPolyline(ptGe,data.bLBeam ? 5 : 2);
			if (pPl != NULL)
			{
				pPl->setColorIndex(pEntReal->colorIndex());
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);
			}
			
			for (int i = 0;i < 5;i++)
			{
				ptGe[i] -= vtV * (data.dW -data.dSidet);
			}

			if (data.bRBeam)
			{
				pPl = FormatPolyline(ptGe,5);
				if (pPl != NULL)
				{
					pPl->setColorIndex(pEntReal->colorIndex());
					dc.DrawEntity(pPl);
					dc.Add2dBuffer(pPl);
				}
			}
            else
			{
				ptGe[0] = ptGe[3];
				ptGe[1] = ptGe[2];
				pPl = FormatPolyline(ptGe,2);
				if (pPl != NULL)
				{
					pPl->setColorIndex(pEntReal->colorIndex());
					dc.DrawEntity(pPl);
					dc.Add2dBuffer(pPl);
				}
			}

			//2.内部踏板投影
			//垂直高
			double dH = data.dTopEl - data.dBomEl;

			//踏步数
			int nCount = data.nSteepS;

			ptGe[0] = ptSta;
			ptGe[0] += vtV * 0.5 * data.dW;
			if (data.bLBeam)
				ptGe[0] -= vtV * data.dSidet;

			ptGe[1] = ptSta;
			ptGe[1] -= vtV * 0.5 * data.dW;
			if (data.bRBeam)
				ptGe[1] += vtV * data.dSidet;

			AcDbLine* pLn = NULL;
			vtL.normalize();
			for (int i = 0;i < nCount;i++)
			{
				ptGe[0] += vtL * data.dSteepW;
				ptGe[1] += vtL * data.dSteepW;

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

				dc.DrawEntity(pLn);
				dc.Add2dBuffer(pLn);
			}

			//绘制增高方向线 ----->
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			dc.Add2dBuffer(pLn);

			ptSta = ptEnd;
			vtL.normalize();
			ptSta -= vtL * 0.25 * data.dSteepW;
			ptSta += vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			dc.Add2dBuffer(pLn);

			ptSta = ptEnd;
			vtV.normalize();
			ptSta -= vtL * 0.25 * data.dSteepW;
			ptSta -= vtV * 0.25 * data.dSteepW;
			pLn = new AcDbLine;
			pLn->setStartPoint(ptSta);
			pLn->setEndPoint(ptEnd);
			pLn->setColorIndex(kRed);
			dc.DrawEntity(pLn);
			dc.Add2dBuffer(pLn);
		}

		dc.SetColor(nCrBk);
		dc.SetLayer(idCurLay);
		dc.SetLineType(idCurLty);

		delete pBaseCurve;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineSegStairDraw::Draw3d(AcGiDraw &dc) const
{
	del3DCache<AecDbLineSegStair>();
	const AecDbObjXDataMap* pXDataMap = GetSpecialtyData();
	if (pXDataMap == NULL)
	{
		return Acad::eOk;
	}

	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
	if (pBaseStair == NULL)
		return Acad::eOk;

	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();

	Adesk::UInt16 nCrBk = 256;
	nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}
	else
		dc.SetColor(pEntReal->colorIndex());

	LineStair data;
	pBaseStair->GetLineStairData(data);

	AcDbCurve* pBaseCurve = pBaseStair->GetBaseCurve();
	if (pBaseCurve != NULL)//路径
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta,ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();

			ptSta.z = data.dBomEl;
			ptEnd.z = data.dTopEl;

			DrawSide3d(dc,ptSta,ptEnd,data);

			if (data.bSlope)//坡道
			{
				DrawSlope3d(dc,ptSta,ptEnd,data);
			}
			else
			{
				DrawSteep3d(dc,ptSta,ptEnd,data);
			}

			//DrawGuardBar3d(dc,ptSta,ptEnd,data);

			DrawSlopeBase(dc,ptSta,ptEnd,data);

			DrawHandRail(dc, ptSta, ptEnd, data);
		}
	}

	dc.SetColor(nCrBk);
	dc.SetLayer(idCurLay);
	dc.SetLineType(idCurLty);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawSide3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
{
	if (data.bLBeam || data.bRBeam)
	{
		AcGePoint3d ptSta = ptFr;
		AcGeVector3d vtL = ptTo - ptFr;
		vtL.normalize();

		double dLx = data.nSteepS * data.dSteepW;
		double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
		double dL = sqrt(dLx * dLx + dLh * dLh);

		AcGePoint3d ptEnd = ptSta + vtL * dL;

		AcGeVector3d vtLXY = vtL;
		vtLXY.z = 0.0;

		//一共多少步
		int nCount = data.nSteepS;

		vtL.normalize();
		vtLXY.normalize();

		AcGeVector3d vtW = vtLXY;
		vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
		vtW.normalize();

		//踏步左右总长
		double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁

		AcGePoint3d ptV,ptV0;
		AcGePoint3dArray arSecPts;

		ptV = ptSta;
		ptV -= vtW * 0.5 * dSteepL;

		//插入楼板的点 [AAA]
		ptV.z -= (data.dSteepW - data.dSteepH);
		ptV0 = ptV;
		arSecPts.append(ptV);

		ptV.z += data.dSteepW;//第一层等边直角
		arSecPts.append(ptV);

		for(int i = 0;i < nCount-1;i++)
		{
			ptV += vtLXY * data.dSteepW;
			//arSecPts.append(ptV);

			ptV.z += data.dSteepH;
			if (i == (nCount - 2))//只需最后踏步上位点
				arSecPts.append(ptV);
		}

		AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
		AcGeLine3d ln3d;
		ln3d.set(ptV0,vtUp);

		AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
		arSecPts.append(ptV1);

		AcGeLine3d lnEnd;
		lnEnd.set(ptV1,AcGeVector3d::kZAxis);

		AcGePoint3d ptInt;
		if ( ln3d.intersectWith(lnEnd,ptInt) )
		{
			arSecPts.append(ptInt);			

			//闭合
			arSecPts.append(arSecPts.first());

			AcGePoint3d ptGe[5];
			ptGe[0] = arSecPts.at(0);
			ptGe[1] = arSecPts.at(1);

			vtUp = ptGe[1] - ptGe[0];
			ptGe[2] = ptInt + vtUp;
			ptGe[3] = ptInt;
			ptGe[4] = ptGe[0];

			AcDbLine ln;
			ln.setStartPoint(ptGe[1]);
			ln.setEndPoint(ptGe[1] + vtW * data.dSidet);

			AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,5);
			if (pReg != NULL)
			{
				//TEST
				//AcDbEntity* pRegCln = (AcDbEntity*)pReg->clone();
				//pRegCln->setColorIndex(4);
				//CoreTools::CloneAndAddToModelSpace(pRegCln);

				AcDbX3dSolid xSolid;
				if ( xSolid.CreateExtrude(pReg,ln) )
				{
					AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
					if (pSolid != NULL)
					{
						if (data.bLBeam)
						{
							dc.DrawEntity(pSolid);
							dc.Add3dBuffer(pSolid);
							add3DCache<AecDbLineSegStair>(&xSolid);
						}

						AcGeMatrix3d xform;
						vtW *= (data.dW - data.dSidet);
						xform.setTranslation(vtW);

						if (data.bRBeam)
						{
							AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
							if (pOtherSide != NULL)
							{
								pOtherSide->transformBy(xform);
								dc.DrawEntity(pOtherSide);
								dc.Add3dBuffer(pOtherSide);
								xSolid.TransformBy(xform);
								add3DCache<AecDbLineSegStair>(&xSolid);
							}
						}
						
						if (!data.bLBeam && pSolid != NULL)
							delete pSolid;
					}
				}
			}
		}
	}
	else
	{
		return Acad::eOk;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawSteep3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
{
	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = data.nSteepS * data.dSteepW;
	double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
	double dL = sqrt(dLx * dLx + dLh * dLh);

	AcGePoint3d ptEnd = ptSta + vtL * dL;

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = data.nSteepS;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总宽
	double dSteepL = data.dW;

	AcGePoint3d ptV,ptV0;
	AcGePoint3dArray arSecPts;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	if (data.bLBeam)
		ptV += vtW * 120.0;//变量宽,国家标准120

	//插入楼板的点 [AAA]
	ptV.z -= (data.dSteepW - data.dSteepH);

	ptV0 = ptV;
	arSecPts.append(ptV);

	ptV.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptV);

	for(int i = 0;i < nCount-1;i++)
	{
		ptV += vtLXY * data.dSteepW;
		arSecPts.append(ptV);

		ptV.z += data.dSteepH;
		arSecPts.append(ptV);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	AcGeLine3d ln3d;
	ln3d.set(ptV0,vtUp);

	AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
	int nLast = arSecPts.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1,AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if ( ln3d.intersectWith(lnEnd,ptInt) )
	{
		arSecPts.append(ptInt);
		
		AcGePoint3d& ptT = arSecPts.first();
		//<--[AAA]
		if (!data.bShowInSlab3d)
		{
			ptT.z = ptSta.z;
			AcGeLine3d lnBxy;
			lnBxy.set(ptT,vtLXY);

			if ( lnBxy.intersectWith(ln3d,ptInt) )
			{
				arSecPts.append(ptInt);
			}
			else
			{
				return Acad::eInvalidInput;
			}
		}
		//闭合
		arSecPts.append(ptT);

		//测试
		//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
		//pPl->setColorIndex(3);
		//CoreTools::AddToModelSpace(pPl);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts.asArrayPtr(),arSecPts.length());
		if (pReg != NULL)
		{
			AcDbLine lnPath;
			lnPath.setStartPoint(ptV0);

			if (data.bLBeam)
				ptV = ptV0 + vtW * (dSteepL - 120.0);
			else
				ptV = ptV0 + vtW * dSteepL;

			if (data.bRBeam)
				ptV -= vtW * 120.0;//变梁宽,国标120

			lnPath.setEndPoint(ptV);

			AcDbX3dSolid xSolid;
			if ( xSolid.CreateExtrude(pReg,lnPath) )
			{
				AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
				if (pSolid != NULL)
				{
					dc.DrawEntity(pSolid);
					dc.Add3dBuffer(pSolid);
					add3DCache<AecDbLineSegStair>(&xSolid);
					return Acad::eOk;
				}
			}
		}
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawSlope3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
{
	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = data.nSteepS * data.dSteepW;
	double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
	double dL = sqrt(dLx * dLx + dLh * dLh);

	AcGePoint3d ptEnd = ptSta + vtL * dL;

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = data.nSteepS;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总宽
	double dSteepL = data.dW;

	AcGePoint3d ptV,ptV0;
	AcGePoint3dArray arSecPts;
	AcGePoint3dArray arSecPts2;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	if (data.bLBeam)
		ptV += vtW * 120.0;//变量宽,国家标准120

	//插入楼板的点 [AAA]
	ptV.z -= (data.dSteepW - data.dSteepH);

	ptV0 = ptV;
	arSecPts.append(ptV);
	arSecPts2.append(ptV);

	ptV.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptV);

	AcGePoint3d ptv2 = ptV;
	ptv2.z -= (data.dSteepW - data.dSteepH);
	arSecPts2.append(ptv2);

	for(int i = 0;i < nCount-1;i++)
	{
		ptV += vtLXY * data.dSteepW;
		arSecPts.append(ptV);
		arSecPts2.append(ptV);

		ptV.z += data.dSteepH;
		arSecPts.append(ptV);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	AcGeLine3d ln3d;
	ln3d.set(ptV0,vtUp);

	AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
	arSecPts.append(ptV1);
	int nLast = arSecPts2.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1,AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if ( ln3d.intersectWith(lnEnd,ptInt) )
	{
		arSecPts.append(ptInt);
		arSecPts2.append(ptInt);

		//闭合
		arSecPts.append(arSecPts.first());
		arSecPts2.append(arSecPts2.first());

		if (data.bNonslip)
		{
			AcGePoint3dArray arSectPts3;
			arSectPts3.append(arSecPts2.first());

			AcGePoint3d ptBk;
			for(int i = 1;i < nLast;i++)
			{
				if ( (i % 2) == 0)
				{
					AcGePoint3d& pTmp = arSecPts2.at(i);
					ptBk = pTmp;
					pTmp.z += 10;
					arSectPts3.append(pTmp);
					arSectPts3.append(ptBk);
				}
				else
				{
					arSectPts3.append(arSecPts2.at(i));
				}
			}

			for(int i = nLast;i< arSecPts2.length();i++)
			{
				arSectPts3.append(arSecPts2.at(i));
			}
			arSecPts2.removeAll();
			arSecPts2.append(arSectPts3);
		}

		//测试
		//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
		//pPl->setColorIndex(3);
		//CoreTools::AddToModelSpace(pPl);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts2.asArrayPtr(),arSecPts2.length());
		if (pReg != NULL)
		{
			AcDbLine lnPath;
			lnPath.setStartPoint(ptV0);

			if (data.bLBeam)
				ptV = ptV0 + vtW * (dSteepL - 120.0);
			else
				ptV = ptV0 + vtW * dSteepL;

			if (data.bRBeam)
				ptV -= vtW * 120.0;//变梁宽,国标120

			lnPath.setEndPoint(ptV);

			AcDbX3dSolid xSolid;
			if ( xSolid.CreateExtrude(pReg,lnPath) )
			{
				AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
				if (pSolid != NULL)
				{
					dc.DrawEntity(pSolid);
					dc.Add3dBuffer(pSolid);
					add3DCache<AecDbLineSegStair>(&xSolid);
					return Acad::eOk;
				}
			}
		}
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawGuardBar3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
{
	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
	if (pBaseStair == NULL)
		return Acad::eOk;

	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = data.nSteepS * data.dSteepW;
	double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
	double dL = sqrt(dLx * dLx + dLh * dLh);

	AcGePoint3d ptEnd = ptSta + vtL * dL;

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = data.nSteepS;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总长
	double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁

	AcGePoint3d ptV,ptV0;
	AcGePoint3dArray arSecPts;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	//插入楼板的点 [AAA]
	ptV.z -= (data.dSteepW - data.dSteepH);
	ptV0 = ptV;
	arSecPts.append(ptV);

	ptV.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptV);

	for(int i = 0;i < nCount-1;i++)
	{
		ptV += vtLXY * data.dSteepW;
		//arSecPts.append(ptV);

		ptV.z += data.dSteepH;
		if (i == (nCount - 2))//只需最后踏步上位点
			arSecPts.append(ptV);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	vtL = vtUp;
	vtL.normalize();

	AcGeLine3d ln3d;
	ln3d.set(ptV0,vtUp);

	AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
	arSecPts.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1,AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if ( ln3d.intersectWith(lnEnd,ptInt) )
	{
		arSecPts.append(ptInt);			

		//闭合
		arSecPts.append(arSecPts.first());

		dL =  ptInt.distanceTo(arSecPts.last());

		ptEnd = arSecPts.at(2);
		vtL = vtUp;
		vtL.normalize();

		AcGeVector3d vtLXY = vtL;
		vtLXY.z = 0.0;
		vtLXY.normalize();

		AcGeVector3d vtW = vtLXY;
		vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
		vtW.normalize();

		double dH = data.bar.dH;
		double dH1 = data.bar.dH1;
		int nCols = (int)( dL / data.bar.dP + 0.5);

		AcGePoint3d ptGe[3];
		ptGe[0] = ptSta;
		ptGe[0] -= vtW * 0.5 * (data.dW - data.dSidet);
		ptGe[1] = ptGe[0] + AcGeVector3d::kZAxis * dH1;
		ptGe[2] = ptGe[0] + AcGeVector3d::kZAxis * dH;

		//上升2个直径
		ptGe[0] += vtL * 2.0 * data.bar.dD;
		ptGe[1] += vtL * 2.0 * data.bar.dD;
		ptGe[2] += vtL * 2.0 * data.bar.dD;

		AcGePoint3d ptGeFrL[3],ptGeFrR[3],ptGeR[3];
		memcpy(ptGeFrL,ptGe,sizeof(AcGePoint3d) * 3);

		memcpy(ptGeFrR,ptGe,sizeof(AcGePoint3d) * 3);
		for (int k = 0;k < 3;k++)
		{
			ptGeFrR[k] += vtW * (data.dW - data.dSidet);
		}

		AcDbLine ln;
		AcDbEntity* pEnt3d = NULL;
		AcDbRegion* pRegCln = NULL;

		AcGePoint3d ptGe0T;
		AcDbX3dSolid xSolid;
		//左边
		for(int i = 0;i <= nCols;i++)
		{
			pRegCln = pBaseStair->GetSection();
			if (pRegCln != NULL)
			{
				ln.setStartPoint(ptGe[0]);
				ln.setEndPoint(ptGe[2]);

				if (data.bLBeam)
				{	
					AcGeMatrix3d mat;
					AcGeVector3d vtSE = (AcGePoint3d::kOrigin - ptGe[0]).normalize();
					mat.setTranslation(vtSE);
					pRegCln->transformBy(mat);

					AcDbRegion* pRegLeft = (AcDbRegion*)pRegCln->clone();
					pRegLeft->setColorIndex(6);
					CoreTools::AddToModelSpace(pRegLeft);
					AcDbLine* pLnLeft = (AcDbLine*)(&ln)->clone();
					pLnLeft->setColorIndex(6);
					CoreTools::AddToModelSpace(pLnLeft);

					if (xSolid.CreateExtrude(pRegCln, ln))
					{
						AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
						if (!pSolid)
						{
							return Acad::eOk;
						}
						pSolid->transformBy(mat);
						dc.DrawEntity(pSolid);
						dc.Add3dBuffer(pSolid);
						add3DCache<AecDbLineSegStair>(&xSolid);
					}

					/*pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
					if (pEnt3d != NULL)
					{
						pEnt3d->setColorIndex(3);
						dc.Add3dBuffer(pEnt3d);
					}*/
				}

				delete pRegCln;
				pRegCln = NULL;
			}

			//右边
			memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
			for (int k = 0;k < 3;k++)
			{
				ptGeR[k] += vtW * (data.dW - data.dSidet);
			}

			pRegCln = pBaseStair->GetSection();
			if (pRegCln != NULL)
			{
				ln.setStartPoint(ptGeR[0]);
				ln.setEndPoint(ptGeR[2]);

				if (data.bRBeam)
				{
					pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
					if (pEnt3d != NULL)
					{
						pEnt3d->setColorIndex(3);
						dc.Add3dBuffer(pEnt3d);
					}
				}

				delete pRegCln;
				pRegCln = NULL;
			}

			ptGe[0] += vtL * data.bar.dP;
			ptGe[1] += vtL * data.bar.dP;
			ptGe[2] += vtL * data.bar.dP;
		}

		//倒退一列
		ptGe[0] -= vtL * data.bar.dP;
		ptGe[1] -= vtL * data.bar.dP;
		ptGe[2] -= vtL * data.bar.dP;

		//斜边 左侧
		pRegCln = pBaseStair->GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGeFrL[1]);
			ln.setEndPoint(ptGe[1]);

			if (data.bLBeam)
			{
				pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(3);
					dc.Add3dBuffer(pEnt3d);
				}
			}
			delete pRegCln;
			pRegCln = NULL;
		}

		pRegCln = pBaseStair->GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGeFrL[2]);
			ln.setEndPoint(ptGe[2]);

			if (data.bLBeam)
			{
				pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(3);
					dc.Add3dBuffer(pEnt3d);
				}
			}
			delete pRegCln;
			pRegCln = NULL;
		}

		//斜边右侧
		memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
		for (int k = 0;k < 3;k++)
		{
			ptGeR[k] += vtW * (data.dW - data.dSidet);
		}

		pRegCln = pBaseStair->GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGeFrR[1]);
			ln.setEndPoint(ptGeR[1]);

			if (data.bRBeam)
			{
				pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(3);
					dc.Add3dBuffer(pEnt3d);
				}
			}
			delete pRegCln;
			pRegCln = NULL;
		}

		pRegCln = pBaseStair->GetSection();
		if (pRegCln != NULL)
		{
			ln.setStartPoint(ptGeFrR[2]);
			ln.setEndPoint(ptGeR[2]);

			if (data.bRBeam)
			{
				pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
				if (pEnt3d != NULL)
				{
					pEnt3d->setColorIndex(3);
					dc.Add3dBuffer(pEnt3d);
				}
			}
			delete pRegCln;
			pRegCln = NULL;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawSlopeBase(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
{
	if (!data.bSlopeBase)
		return Acad::eOk;

	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = data.nSteepS * data.dSteepW;
	double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
	double dL = sqrt(dLx * dLx + dLh * dLh);

	AcGePoint3d ptEnd = ptSta + vtL * dL;

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = data.nSteepS;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总宽
	double dSteepL = data.dW;

	AcGePoint3d ptV,ptV0;
	AcGePoint3dArray arSecPts;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	//if (data.bLBeam)
	//ptV += vtW * 120.0;//变量宽,国家标准120

	//插入楼板的点 [AAA]
	//if (data.bShowInSlab3d)
	ptV.z -= (data.dSteepW - data.dSteepH);

	ptV0 = ptV;
	arSecPts.append(ptV);

	ptV.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptV);

	for(int i = 0;i < nCount-1;i++)
	{
		ptV += vtLXY * data.dSteepW;
		//arSecPts.append(ptV);

		ptV.z += data.dSteepH;
		arSecPts.append(ptV);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	AcGeLine3d ln3d;
	ln3d.set(ptV0,vtUp);

	AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
	arSecPts.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1,AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if ( ln3d.intersectWith(lnEnd,ptInt) )
	{
		arSecPts.append(ptInt);

		//闭合
		arSecPts.append(arSecPts.first());

		AcGePoint3d ptGe[4];
		ptGe[0] = arSecPts.first();
		ptGe[1] = ptInt;
		ptGe[2] = ptGe[0] + vtLXY * data.nSteepS * data.dSteepW;
		ptGe[3] = ptGe[0];

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,4);
		if (pReg != NULL)
		{
			AcDbLine lnPath;
			lnPath.setStartPoint(ptV0);
			ptV = ptV0 + vtW * dSteepL;
			lnPath.setEndPoint(ptV);

			AcDbX3dSolid xSolid;
			if ( xSolid.CreateExtrude(pReg,lnPath) )
			{
				AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
				if (pSolid != NULL)
				{
					dc.DrawEntity(pSolid);
					dc.Add3dBuffer(pSolid);
					add3DCache<AecDbLineSegStair>(&xSolid);
					return Acad::eOk;
				}
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbLineSegStairDraw::DrawHandRail(AcGiDraw& dc, const AcGePoint3d& ptFr, const AcGePoint3d& ptTo, const LineStair& data) const
{
	if (!data.bGuardBar)
		return Acad::eOk;

	//一共多少步
	int nCount = data.nSteepS;
	//踏步左右总长
	double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁

	AcGePoint3d ptGe[10];
	ptGe[0] = ptFr;
	ptGe[1] = ptTo;
	///ptGe[0].z = 0;
	///ptGe[1].z = 0;
	AcGeVector3d vt = (ptGe[0] - ptGe[1]).normalize();
	vt.z = 0;
	vt.normalize();

	AcGeVector3d vtDir(vt), Z(AcGeVector3d::kZAxis);
	vtDir.rotateBy(-PI / 2.0, Z);
	vtDir.normalize();

	ptGe[2] = ptGe[0] + Z * data.dSteepH;
	ptGe[3] = ptGe[2] - vt * data.dSteepW;
	ptGe[3] += Z * data.dSteepH;
	AcGeVector3d vtHand = (ptGe[2] - ptGe[3]).normalize();

	ptGe[4] = ptGe[2] - vt * data.dSteepW * .5;
	ptGe[5] = ptGe[4] - vt * data.dSteepW * (nCount - 1);
	ptGe[5] += Z * data.dSteepH * (nCount - 1);
	double dLen = ptGe[4].distanceTo(ptGe[5]);
	int nStairsNum = (int)(dLen / data.bar.dP + 0.5);

	AcGePoint3dArray arPtsHandRail, arPtsRail;
	arPtsHandRail.removeAll();
	arPtsRail.removeAll();

	arPtsRail.append(ptGe[4]);

	AcGePoint3d ptRail;
	ptRail = ptGe[0] - vt * data.dSteepW * .5;
	ptRail += Z * data.dSteepH;
	for (int i = 0; i < nStairsNum-1; i++)//nStairsNum-1最后短节去掉
	{
		ptRail -= vtHand * data.bar.dP;
		arPtsRail.append(ptRail);
	}
	arPtsRail.append(ptGe[5]);

	AcGeMatrix3d mat;
	AcDbX3dSolid xSolid;
	// 栏杆
	for (int i(0); i < arPtsRail.length(); ++i)
	{
		ptRail = arPtsRail.at(i);
		AcDbLine* pLn = new AcDbLine(ptRail, ptRail + Z * data.bar.dH);
		AcDbRegion* pReg = makeCircleRegion(ptRail, Z, data.bar.dD * .5);
		if (xSolid.CreateExtrude(pReg, *pLn))
		{
			DELETE_PTR(pReg);
			DELETE_PTR(pLn);

			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (!pSolid)
			{
				return Acad::eOk;
			}
			mat.setToIdentity();
			mat.setToTranslation(vtDir * (dSteepL - data.dSidet) * .5);
			pSolid->transformBy(mat);
			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			add3DCache<AecDbLineSegStair>(&xSolid);

			AcDb3dSolid* pSolidNew = (AcDb3dSolid*)pSolid->clone();
			mat.setToIdentity();
			mat.setToTranslation(vtDir * -(dSteepL - data.dSidet));
			pSolidNew->transformBy(mat);
			if (!pSolidNew)
			{
				DELETE_PTR(pSolid);
				return Acad::eOk;
			}
			dc.DrawEntity(pSolidNew);
			dc.Add3dBuffer(pSolidNew);
			add3DCache<AecDbLineSegStair>(&xSolid);
		}
	}

	// 扶手
	ptGe[6] = ptGe[4] + Z * data.bar.dH;
	ptGe[6] += vtDir * (dSteepL - data.dSidet) * .5;
	ptGe[7] = ptGe[5] + Z * data.bar.dH;
	ptGe[7] += vtDir * (dSteepL - data.dSidet) * .5;
	AcDbLine* pLn = new AcDbLine(ptGe[6], ptGe[7]);
	AcGeVector3d vtHandRail = (ptGe[6] - ptGe[7]).normalize();
	AcDbRegion* pReg = makeCircleRegion(ptGe[6], vtHandRail, data.bar.dD * .5);
	if (xSolid.CreateExtrude(pReg, *pLn))
	{
		DELETE_PTR(pReg);
		DELETE_PTR(pLn);

		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (!pSolid)
		{
			return Acad::eOk;
		}
		dc.DrawEntity(pSolid);
		dc.Add3dBuffer(pSolid);
		add3DCache<AecDbLineSegStair>(&xSolid);

		AcDb3dSolid* pSolidNew = (AcDb3dSolid*)pSolid->clone();
		if (!pSolidNew)
		{
			DELETE_PTR(pSolid);
			return Acad::eOk;
		}
		mat.setToIdentity();
		mat.setToTranslation(vtDir * -(dSteepL - data.dSidet));
		pSolidNew->transformBy(mat);
		dc.DrawEntity(pSolidNew);
		dc.Add3dBuffer(pSolidNew);
		add3DCache<AecDbLineSegStair>(&xSolid);
	}

	return Acad::eOk;
}