#include "stdafx.h"
#include "AecDbCornerStair.h"
#include "AecDbCornerStairDraw.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.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(AecDbCornerStairDraw, AecDbXDraw, 0);

namespace
{
	AcDbRegion* makeRegion(const AcGePoint3dArray& arPts)
	{
		AcDbVoidPtrArray ar;
		ar.removeAll();
		for (int i = 0; i < arPts.length() - 1; ++i)
			ar.append(new AcDbLine(arPts[i], arPts[i + 1]));

		AcDbRegion* pReg = CoreTools::createRegion(ar);
		deleteArrayVoidPtrs<AcDbEntity>(ar);
		return pReg;
	}

	AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
		, const double& dL
		, const double& dW
		, const AcGeVector3d& vecL
		, const AcGeVector3d& vecW)
	{
		AcGePoint3d ptGe[5];
		AcGePoint3d pt1(ptOrg), pt2, pt3, pt4;

		pt1 += vecW * dW * .5;
		pt1 += vecL * dL * .5;
		pt2 = pt1 - vecW * dW;
		pt3 = pt2 - vecL * dL;
		pt4 = pt3 + vecW * dW;

		ptGe[0] = pt1;
		ptGe[1] = pt2;
		ptGe[2] = pt3;
		ptGe[3] = pt4;
		ptGe[4] = ptGe[0];
		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
		if (!pReg) return NULL;
		return pReg;
	}

	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;
	}

	void drawText(AcGiDraw& dc
		, const ACHAR* text
		, const double& dTextH
		, const AcGePoint3d& ptAlign
		, const double& dAngle
		, const AcGeVector3d& vtTrans
		, AcDb::TextHorzMode nHorMode
		, AcDb::TextVertMode nVerMode
		, AcGiDraw::TextAlignment nAlign)
	{
		/*int nOldClr = dc.GetColor();
		dc.SetColor(1);*/

		AcDbText* pText = new AcDbText();
		if (pText == NULL) return;

		pText->setTextString(text);
		pText->setHeight(dTextH);

		AcDbExtents ext;
		pText->getGeomExtents(ext);
		pText->setHorizontalMode(nHorMode);
		pText->setVerticalMode(nVerMode);
		pText->setAlignmentPoint(ptAlign);
		AcGeMatrix3d mat;
		mat.setToRotation(dAngle, vtTrans, ptAlign);
		pText->setPosition(dc.Align2Base(nAlign, ptAlign, ext.maxPoint()));
		pText->transformBy(mat);
		pText->setColorIndex(1);

		dc.DrawEntity(pText);
		dc.Add2dBuffer(pText);

		//dc.SetColor(nOldClr);
	}
}

AecDbCornerStairDraw::AecDbCornerStairDraw(void)
{
}

AecDbCornerStairDraw::~AecDbCornerStairDraw(void)
{
}

Acad::ErrorStatus AecDbCornerStairDraw::Draw2d(AcGiDraw &dc) const
{
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbCornerStair *pCorStair = AecDbCornerStair::cast(pEntReal);
	if (pCorStair == NULL)
		return Acad::eOk;

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

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

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pCorStair->GetSFPXStair(data);

	AcDbVoidPtrArray arEntPtrs;

	AcDbCurve* pBaseCurve = pCorStair->GetBaseCurve();
	if (pBaseCurve != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta, ptEnd, ptPathSta, ptPathEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();

			AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
			vtSEDir = (ptSta - ptEnd).normalize();
			vtSE = vtSEDir;
			vtSE.rotateBy(PI / 2.0, Z);
			vtSE.normalize();
			double dSidet = 120;

			DrawStair2d(dc, ptSta, ptEnd, vtSEDir, vtSE, data.dStairSW, data.nSteepsS, data);
			ptSta -= vtSE * ((data.nSteepsS - 1) * data.dSteepW + (data.dRestPtL - data.dStairMW) * .5);
			ptSta -= vtSEDir * data.dRestPtW;
			DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
			ptSta -= vtSE * (data.dStairMW + (data.dRestPtL - data.dStairMW) * .5);
			ptSta += vtSEDir * data.dRestPtW;
			DrawStair2d(dc, ptSta, ptEnd, vtSEDir, vtSE, data.dStairSW, data.nSteepsS, data);

			ptSta += vtSE * (data.dRestPtL + data.nSteepsS * data.dSteepW);
			DrawRestPlatform2d(dc, ptSta, vtSE, vtSEDir, data);

			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			ptSta -= vtSEDir * (data.dStairSW - data.dGarSize[0]);
			DrawHandRailIn2d(dc, ptSta, vtSE, vtSEDir, data);

			ptSta -= vtSE * (data.dRestPtL + (data.nSteepsS - 1) * data.dSteepW * 2);
			DrawHandRailIn2d(dc, ptSta, -vtSE, vtSEDir, data);

			if (data.bOutSideHRail)
			{
				ptSta -= vtSE * data.nSteepsS * data.dSteepW;
				DrawHandRailOut2d(dc, ptSta, -vtSE, vtSEDir, data);
			}

			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

			DrawWithin(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
		}
	}

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

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::Draw3d(AcGiDraw &dc) const
{
	del3DCache<AecDbCornerStair>();
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbCornerStair *pCorStair = AecDbCornerStair::cast(pEntReal);
	if (pCorStair == NULL)
		return Acad::eOk;

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

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

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pCorStair->GetSFPXStair(data);

	AcDbCurve* pBaseCurve = pCorStair->GetBaseCurve();
	if (pBaseCurve != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta, ptEnd, ptPathSta, ptPathEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();

			AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);

			ptSta += Z * data.dBomEl;
			ptEnd += Z * data.dBomEl;

			vtSEDir = (ptSta - ptEnd).normalize();
			vtSE = vtSEDir;
			vtSE.rotateBy(PI / 2.0, Z);
			vtSE.normalize();

			DrawRestPlatform3d(dc, ptSta, vtSE, vtSEDir, data);
			if (data.nUpSide == 0)
			{
				DrawStairMid3d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
			}
			else
			{
				DrawStairSide3d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
			}
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawStair2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const double& dist
	, const int& num
	, const SFPXStair& data) const 
{
	AcGePoint3d ptS(ptSta), ptE;
	AcDbPolyline* pPoly(NULL);
	AcGePoint3d ptGe[5];

	ptGe[0] = ptS;
	ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
	ptGe[2] = ptGe[1] - vt * dist;
	ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
	ptGe[4] = ptGe[0];

	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 5);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	for (int i(0); i < num; ++i)
	{
		ptGe[0] = ptS - vtDir * data.dSteepW * i;
		ptGe[1] = ptGe[0] - vt * dist;
		pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
		if (!pPoly) return Acad::eOk;
		pPoly->setColorIndex(2);
		dc.DrawEntity(pPoly);
		dc.Add2dBuffer(pPoly);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawRestPlatform2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGePoint3d ptOrg(ptSta);
	SFSPStair data1(data);
	AcGePoint3d ptGe[9];

	ptOrg -= vt * data1.nSteepsS * data1.dSteepW;
	ptGe[0] = ptOrg;
	ptGe[1] = ptGe[0] - vtDir * data1.dStairSW;
	ptGe[2] = ptGe[1] - vt * ((data1.dRestPtL - data1.dStairMW) * .5);
	ptGe[3] = ptGe[2] - vtDir * (data1.dRestPtW - data1.dStairSW);
	ptGe[4] = ptGe[3] - vt * data1.dStairMW;
	ptGe[5] = ptGe[4] + vtDir * (data1.dRestPtW - data1.dStairSW);
	ptGe[6] = ptGe[5] - vt * ((data1.dRestPtL - data1.dStairMW) * .5);
	ptGe[7] = ptGe[6] + vtDir * data1.dStairSW;
	ptGe[8] = ptGe[0];
	
	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 9);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawHandRailIn2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGePoint3d ptOrg(ptSta);
	SFSPStair data1(data);
	AcGePoint3d ptGe[7];

	ptGe[0] = ptOrg + vt * data1.dZGarExt;
	ptGe[0] += vtDir * data1.dBarSide;
	ptGe[1] = ptGe[0] - vtDir * data1.dGarSize[0];
	ptGe[2] = ptGe[1] - vt * (data1.dZGarExt + (data1.nSteepsS - 1) * data1.dSteepW + (data1.dRestPtL - data1.dStairMW) * .5 + data1.dBarSide);
	ptGe[3] = ptGe[2] - vtDir * (data1.dRestPtW - data1.dStairSW + (data1.nSteepMs - 1) * data1.dSteepW + data1.dGarExt + data1.dBarSide);
	ptGe[4] = ptGe[3] - vt * data1.dGarSize[0];
	ptGe[5] = ptGe[4] + vtDir * (data1.dRestPtW - data1.dStairSW + (data1.nSteepMs - 1) * data1.dSteepW + data1.dGarExt + data1.dGarSize[0] + data1.dBarSide);
	ptGe[6] = ptGe[5] + vt * (data1.dGarSize[0] + data1.dZGarExt + (data1.nSteepsS - 1) * data1.dSteepW + (data1.dRestPtL - data1.dStairMW) * .5 + data1.dBarSide);

	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 7);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawHandRailOut2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGePoint3d ptOrg(ptSta);
	SFSPStair data1(data);
	AcGePoint3d ptGe[5];

	ptOrg -= vt * data1.nSteepsS * data1.dSteepW;
	ptOrg += vtDir * (data1.dStairSW - data.dGarSize[0]);
	ptOrg -= vtDir * data1.dBarSide;
	ptGe[0] = ptOrg + vt * data1.dZGarExt;
	ptGe[1] = ptGe[0] - vtDir * data1.dGarSize[0];
	ptGe[2] = ptGe[1] - vt * (data1.dZGarExt * 2 + (data1.nSteepsS - 1) * data1.dSteepW * 2 + data1.dRestPtL);
	ptGe[3] = ptGe[2] + vtDir * data1.dGarSize[0];
	ptGe[4] = ptGe[0] ;

	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 5);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawBeam2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptS(ptSta), ptE;
	AcGePoint3d ptGe[5];
	double dSidet = 120;

	if (data.bRBeam)
	{
		ptGe[0] = ptS;
		ptGe[1] = ptGe[0] - vtDir * dSidet;
		ptGe[2] = ptGe[1] - vt * (data.nSteepsS - 1) * data.dSteepW;
		ptGe[3] = ptGe[2] + vtDir * dSidet;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl = NULL;
		pPl = FormatPolyline(ptGe, 5);
		if (pPl == NULL) return Acad::eOk;
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);

		ptS -= vt * ((data.nSteepsS - 1) * data.dSteepW + data.dRestPtL);
		ptGe[0] = ptS;
		ptGe[1] = ptGe[0] - vtDir * dSidet;
		ptGe[2] = ptGe[1] - vt * (data.nSteepsS - 1) * data.dSteepW;
		ptGe[3] = ptGe[2] + vtDir * dSidet;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl1 = NULL;
		pPl1 = FormatPolyline(ptGe, 5);
		if (pPl1 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl1);
		dc.Add2dBuffer(pPl1);
	}
	if (data.bLBeam)
	{
		ptS -= vtDir * (data.dStairSW - dSidet);
		ptGe[0] = ptS;
		ptGe[1] = ptGe[0] - vtDir * dSidet;
		ptGe[2] = ptGe[1] - vt * (data.nSteepsS - 1) * data.dSteepW;
		ptGe[3] = ptGe[2] + vtDir * dSidet;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl2 = NULL;
		pPl2 = FormatPolyline(ptGe, 5);
		if (pPl2 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl2);
		dc.Add2dBuffer(pPl2);

		if(data.bRBeam)
		{
			ptS += vt * ((data.nSteepsS - 1) * data.dSteepW + data.dRestPtL);
		}
		else
		{
			ptS -= vt * ((data.nSteepsS - 1) * data.dSteepW + data.dRestPtL);
		}
		ptGe[0] = ptS;
		ptGe[1] = ptGe[0] - vtDir * dSidet;
		ptGe[2] = ptGe[1] - vt * (data.nSteepsS - 1) * data.dSteepW;
		ptGe[3] = ptGe[2] + vtDir * dSidet;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl3 = NULL;
		pPl3 = FormatPolyline(ptGe, 5);
		if (pPl3 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl3);
		dc.Add2dBuffer(pPl3);

		if (data.bRBeam)
		{
			ptS -= vt * ((data.nSteepsS - 1) * data.dSteepW + (data.dRestPtL - data.dStairMW) * .5);
			ptS -= vtDir * (data.dRestPtW - data.dStairSW + dSidet);

			ptGe[0] = ptS;
			ptGe[1] = ptGe[0] - vt * dSidet;
			ptGe[2] = ptGe[1] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
			ptGe[3] = ptGe[2] + vt * dSidet;
			ptGe[4] = ptGe[0];

			AcDbPolyline* pPl4 = NULL;
			pPl4 = FormatPolyline(ptGe, 5);
			if (pPl4 == NULL) return Acad::eOk;
			dc.DrawEntity(pPl4);
			dc.Add2dBuffer(pPl4);

			ptS -= vt * (data.dStairMW - dSidet);
			ptGe[0] = ptS;
			ptGe[1] = ptGe[0] - vt * dSidet;
			ptGe[2] = ptGe[1] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
			ptGe[3] = ptGe[2] + vt * dSidet;
			ptGe[4] = ptGe[0];

			AcDbPolyline* pPl5 = NULL;
			pPl5 = FormatPolyline(ptGe, 5);
			if (pPl5 == NULL) return Acad::eOk;
			dc.DrawEntity(pPl5);
			dc.Add2dBuffer(pPl5);

		}
		else
		{
			ptS += vt * data.dStairMW;
			ptS -= vtDir * dSidet;
			ptGe[0] = ptS;
			ptGe[1] = ptGe[0] - vt * dSidet;
			ptGe[2] = ptGe[1] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
			ptGe[3] = ptGe[2] + vt * dSidet;
			ptGe[4] = ptGe[0];

			AcDbPolyline* pPl4 = NULL;
			pPl4 = FormatPolyline(ptGe, 5);
			if (pPl4 == NULL) return Acad::eOk;
			dc.DrawEntity(pPl4);
			dc.Add2dBuffer(pPl4);

			ptS -= vt * (data.dStairMW - dSidet);
			ptGe[0] = ptS;
			ptGe[1] = ptGe[0] - vt * dSidet;
			ptGe[2] = ptGe[1] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
			ptGe[3] = ptGe[2] + vt * dSidet;
			ptGe[4] = ptGe[0];

			AcDbPolyline* pPl5 = NULL;
			pPl5 = FormatPolyline(ptGe, 5);
			if (pPl5 == NULL) return Acad::eOk;
			dc.DrawEntity(pPl5);
			dc.Add2dBuffer(pPl5);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawWithin(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d pt1(ptSta), pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, pt10, pt11, pt12, pt13;
	AcGePoint3d ptGe[3];
	double dScale = CoreTools::getPScaleForSymb();
	double dW(dScale * .8);
	double dH(dScale * 3);
	double dTextH(dScale * 3.5);
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;

	if (data.nUpSide == 0)
	{
		pt1 -= vtDir * data.dStairSW * .5;
		pt1 -= vt * ((data.nSteepsS - 1) * data.dSteepW + data.dRestPtL * .5);
 		pt2 = pt1 - vtDir * (data.dRestPtW - data.dStairSW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW);
 		pt3 = pt2 + vtDir * dH;

		ptGe[0] = pt1;
		ptGe[1] = pt2;
		ptGe[2] = pt3;

		AcDbPolyline* pPl = FormatPolyline(ptGe, 3);
		if (pPl == NULL) return Acad::eOk;
		pPl->setWidthsAt(1, 0, dW);
		pPl->setColorIndex(3);
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);

		pt4 = pt1 - vtDir * (data.dRestPtW - data.dStairSW * .5 + (data.nSteepMs - .5) * data.dSteepW);
		pt5 = pt4 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
		pt6 = pt5 - vtDir * dH;
		
		ptGe[0] = pt4;
		ptGe[1] = pt5;
		ptGe[2] = pt6;

		AcDbPolyline* pPl1 = FormatPolyline(ptGe, 3);
		if (pPl1 == NULL) return Acad::eOk;
		pPl1->setWidthsAt(1, 0, dW);
		pPl1->setColorIndex(3);
		dc.DrawEntity(pPl1);
		dc.Add2dBuffer(pPl1);

		drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		
		pt7 = pt1 + vt * ((data.nSteepsS - .5) * data.dSteepW + data.dRestPtL * .5);
		pt8 = pt7 - vt * (data.dRestPtL + (data.nSteepsS - 1) * data.dSteepW * 2 + data.dSteepW);
	
		ptGe[0] = pt7;
		ptGe[1] = pt8;

		AcDbPolyline* pPl2 = FormatPolyline(ptGe, 2);
		if (pPl2 == NULL) return Acad::eOk;
		pPl2->setColorIndex(3);
		dc.DrawEntity(pPl2);
		dc.Add2dBuffer(pPl2);

		drawText(dc, _T("下"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
		drawText(dc, _T("下"), dTextH, ptGe[1], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

	}
	else
	{
		pt1 -= vtDir * data.dStairSW * .5;
		pt1 += vt * data.dSteepW * .5;
		pt2 =pt1 - vt * ((data.nSSteeps - .5) * data.dSteepW);
		pt3 = pt2 + vt * dH;

		ptGe[0] = pt1;
		ptGe[1] = pt2;
		ptGe[2] = pt3;

		AcDbPolyline* pPl = FormatPolyline(ptGe, 3);
		if (pPl == NULL) return Acad::eOk;
		pPl->setWidthsAt(1, 0, dW);
		pPl->setColorIndex(3);
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);

		drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

		pt4 = pt1 - vt * ((data.nSteepsS - .5) * data.dSteepW + data.dRestPtL * .5);
		pt5 = pt1 - vt * (data.nSSteeps + .5) * data.dSteepW;
		pt6 = pt5 - vt * dH;

		ptGe[0] = pt4;
		ptGe[1] = pt5;
		ptGe[2] = pt6;
		
		AcDbPolyline* pPl1 = FormatPolyline(ptGe, 3);
		if (pPl1 == NULL) return Acad::eOk;
		pPl1->setWidthsAt(1, 0, dW);
		pPl1->setColorIndex(3);
		dc.DrawEntity(pPl1);
		dc.Add2dBuffer(pPl1);

		pt7 = pt4;
		pt8 = pt7 - vt * ((data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + data.dRestPtL * .5);
		pt9 = pt8 + vt * dH;
		
		ptGe[0] = pt7;
		ptGe[1] = pt8;
		ptGe[2] = pt9;

		AcDbPolyline* pPl2 = FormatPolyline(ptGe, 3);
		if (pPl2 == NULL) return Acad::eOk;
		pPl2->setWidthsAt(1, 0, dW);
		pPl2->setColorIndex(3);
		dc.DrawEntity(pPl2);
		dc.Add2dBuffer(pPl2);

		pt10 = pt7 - vt * (data.dRestPtL * .5 + (data.nSteepsS - .5) * data.dSteepW);
		pt11 = pt10 + vt * (data.nSSteeps - 1 + .5) * data.dSteepW;
		pt12 = pt11 - vt * dH;

		ptGe[0] = pt10;
		ptGe[1] = pt11;
		ptGe[2] = pt12;

		AcDbPolyline* pPl3 = FormatPolyline(ptGe, 3);
		if (pPl3 == NULL) return Acad::eOk;
		pPl3->setWidthsAt(1, 0, dW);
		pPl3->setColorIndex(3);
		dc.DrawEntity(pPl3);
		dc.Add2dBuffer(pPl3);

		drawText(dc, _T("上"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

		pt13 = pt7 - vtDir * (data.dRestPtW - data.dStairSW * .5 + (data.nSteepMs - .5) * data.dSteepW);
		
		ptGe[0] = pt7;
		ptGe[1] = pt13;

		AcDbPolyline* pPl4 = FormatPolyline(ptGe, 2);
		if (pPl4 == NULL) return Acad::eOk;
		pPl4->setWidthsAt(1, 0, dW);
		pPl4->setColorIndex(3);
		dc.DrawEntity(pPl4);
		dc.Add2dBuffer(pPl4);

		drawText(dc, _T("下"), dTextH, ptGe[1], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);

	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawSteep3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const SFPXStair& data
	, const double& dW) 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 = 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();

		//闭合
		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<AecDbCornerStair>(&xSolid);
					return Acad::eOk;
				}
			}
		}
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawRestPlatform3d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGePoint3d ptOrg(ptSta);
	SFSPStair data1(data);
	AcGePoint3dArray ar;
	AcDbLine ln;
	AcGePoint3d ptGe[9];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nUpSide == 0)
	{
		ptOrg += Z * (data1.nSteepMs * data1.dSteepH);
		ptOrg -= vt * data1.nSteepsS * data1.dSteepW;
		ptGe[0] = ptOrg;
		ptGe[1] = ptGe[0] - vtDir * data1.dStairSW;
		ptGe[2] = ptGe[1] - vt * (data1.dRestPtL - data1.dStairMW) * .5;
		ptGe[3] = ptGe[2] - vtDir * (data1.dRestPtW - data1.dStairSW);
		ptGe[4] = ptGe[3] - vt * data1.dStairMW;
		ptGe[5] = ptGe[4] + vtDir * (data1.dRestPtW - data1.dStairSW);
		ptGe[6] = ptGe[5] - vt * (data1.dRestPtL - data1.dStairMW) * .5;
		ptGe[7] = ptGe[6] + vtDir * data1.dStairSW;
		ptGe[8] = ptGe[0];
	}
	else
	{
		ptOrg +=Z * (data1.nSteepsS * data1.dSteepH);
		ptOrg -= vt * data1.nSteepsS * data1.dSteepW;

		ptGe[0] = ptOrg;
		ptGe[1] = ptGe[0] - vtDir * (data1.dStairSW - data1.dGarSize[0]);
		ptGe[2] = ptGe[1] - vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] - data1.dSteepW);
		ptGe[3] = ptGe[2] - vtDir * (data1.dRestPtW - data1.dStairSW + data1.dGarSize[0]);
		ptGe[4] = ptGe[3] - vt * (data1.dStairMW - data1.dGarSize[0] * 2);
		ptGe[5] = ptGe[4] + vtDir * (data1.dRestPtW - data1.dStairSW + data1.dGarSize[0]);
		ptGe[6] = ptGe[5] - vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] - data1.dSteepW);
		ptGe[7] = ptGe[6] + vtDir * (data1.dStairSW - data1.dGarSize[0]);
		ptGe[8] = ptGe[0];
	}
	
	ar.append(ptGe[0]);
	ar.append(ptGe[1]);
	ar.append(ptGe[2]);
	ar.append(ptGe[3]);
	ar.append(ptGe[4]);
	ar.append(ptGe[5]);
	ar.append(ptGe[6]);
	ar.append(ptGe[7]);
	ar.append(ptGe[8]);

	pReg = makeRegion(ar);

	ln.setStartPoint(ptOrg);
	ln.setEndPoint(ptOrg - AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));

	AcDbX3dSolid xSolid;
	AcGeMatrix3d mat;
	double dH(.0);
	if (xSolid.CreateExtrude(pReg, ln))
	{
		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (pSolid != NULL)
		{
			mat.setTranslation(AcGeVector3d::kZAxis * dH);
			pSolid->transformBy(mat);
			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			add3DCache<AecDbCornerStair>(&xSolid);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawStairMid3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptS(ptFr), ptE(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	ptS += Z * data1.nSteepMs * data1.dSteepH;
	ptE = ptS - vt * data1.nSteepsS * data1.dSteepW;
	ptS -= vtDir * data1.dStairSW * .5;
	ptE -= vtDir * data1.dStairSW * .5;
	data1.nSteepS = data1.nSteepsS;
	DrawSteep3d(dc, ptE, ptS, data1, data1.dStairSW);
	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptE, ptS, 0, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard3d(dc, ptE, ptS, 1, data.dStairSW, data1);
	}

	ptGeL[0] = ptE;
	ptGeL[1] = ptS;

	ptS = ptE - vt * data1.dRestPtL;
	ptE = ptS - vt * data1.nSteepsS * data1.dSteepW;
	data1.nSteepS = data1.nSteepsS;
	DrawSteep3d(dc, ptS, ptE, data1, data1.dStairSW);
	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 1, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 0, data.dStairSW, data1);
	}

	ptGeR[0] = ptS;
	ptGeR[1] = ptE;

	ptS -= Z * data1.nSteepMs * data1.dSteepH;
	ptS += vt * data1.dRestPtL * .5;
	ptS -= vtDir * (data1.dRestPtW - data1.dStairSW);
	ptS -= vtDir * data1.dStairSW * .5;
	ptE = ptS - vtDir * data1.nSteepMs * data1.dSteepW;
	ptS += vtDir * data.dSteepW;
	ptE += vtDir * data.dSteepW;

	data1.nSteepS = data1.nSteepMs;
	DrawSteep3d(dc, ptE, ptS, data1, data1.dStairMW);

	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptE, ptS, 0, data.dStairMW, data1);
		DrawGuard3d(dc, ptE, ptS, 1, data.dStairMW, data1);
	}

	ptGeL[2] = ptE;
	ptGeL[3] = ptS;

	ptGeR[2] = ptE;
	ptGeR[3] = ptS;

	DrawHandRail3dL(dc, ptGeL, 0, vt, vtDir, 0, data1);
	DrawHandRail3dR(dc, ptGeR, 0, vt, vtDir, 1, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawStairSide3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptS(ptFr), ptE(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	ptS -= vtDir * data1.dStairSW * .5;
	ptE = ptS - vt * data1.nSteepsS * data1.dSteepW;
	data1.nSteepS = data1.nSteepsS;
	DrawSteep3d(dc, ptS, ptE, data1, data1.dStairSW);

	data1.nSteepS = data1.nSteepsS;
	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 0, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 1, data.dStairSW, data1);
	}

	ptGeL[0] = ptS;
	ptGeL[1] = ptE;

	ptS -= vt * ((data1.nSteepsS - 1) * data1.dSteepW * 2 + data1.dRestPtL);
	DrawSteep3d(dc, ptS, ptE, data1, data1.dStairSW);
	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 1, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 0, data.dStairSW, data1);
	}

	ptGeR[0] = ptS;
	ptGeR[1] = ptE;

	ptS += Z * data1.nSteepsS * data1.dSteepH;
	ptS += vt * ((data1.nSteepsS - 1) * data1.dSteepW + data1.dRestPtL * .5);
	ptS -= vtDir * (data1.dRestPtW - data1.dStairSW);
	ptS -= vtDir * data1.dStairSW * .5;
	ptE = ptS - vtDir * data1.nSteepMs * data1.dSteepW;

	data1.nSteepS = data1.nSteepMs;
	DrawSteep3d(dc, ptS, ptE, data1, data1.dStairMW);
	if (data.bInsideRail)
	{
		DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data1);
		DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data1);
	}

	ptGeL[2] = ptS;
	ptGeL[3] = ptE;

	ptGeR[2] = ptS;
	ptGeR[3] = ptE;

	DrawHandRail3dL(dc, ptGeL, 0, vt, vtDir, 0, data1);
	DrawHandRail3dR(dc, ptGeR, 0, vt, vtDir, 1, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawGuard3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& num
	, const double& dW
	, const SFSPStair& 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), ptEnd(ptTo);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL);
	vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtLDir.normalize();

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

	AcGePoint3dArray arSecPts;

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}

	//插入楼板的点 [AAA]
	ptSta.z -= (data.dSteepW - data.dSteepH);
	ptSta.z += data.dSteepW;//第一层等边直角

	arSecPts.removeAll();
	for (int i = 0; i < nCount - 1; i++)
	{
		ptSta -= vtL * data.dSteepW * .5;
		arSecPts.append(ptSta);

		ptSta -= vtL * data.dSteepW * .5;
		ptSta.z += data.dSteepH;
	}

	AcDbX3dSolid xSolid;
	AcDbRegion* pReg(NULL);

	for (int i = 0; i < arSecPts.length(); i++)
	{
		if (!data.nBShape)
		{
			pReg = makeRectRegion(arSecPts.at(i), data.dBarSize[0], data.dBarSize[1], vtL, vtLDir);
		}
		else
		{
 			pReg = makeCircleRegion(arSecPts.at(i), AcGeVector3d::kZAxis, data.dBarSize[0] * .5);
		}
		if (pReg == NULL) return Acad::eOk;
		AcDbLine line(arSecPts.at(i), arSecPts.at(i) + AcGeVector3d::kZAxis * data.dBarH);
		if (xSolid.CreateExtrude(pReg, line))
		{
			AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
			if (pSolid == NULL) return Acad::eOk;
			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			add3DCache<AecDbCornerStair>(&xSolid);
		}
	}

	return Acad::eOk;
}

AcDbLine* AecDbCornerStairDraw::DrawHandRail(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& num
	, const double& dW
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL);
	vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtLDir.normalize();

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

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

	AcGePoint3d ptV, ptV0;
	AcGePoint3dArray arSecPts;

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}

	ptSta.z += (data.dBarH - data.dSteepH * .5);

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

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

	for (int i = 0; i < nCount - 1; i++)
	{
		ptSta -= vtL * data.dSteepW;
		ptSta.z += data.dSteepH;

		if (i == (nCount - 2))//只需最后踏步上位点
		arSecPts.append(ptSta);
	}

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

	AcGePoint3d ptV1 = ptSta - vtL * data.dSteepW;
	arSecPts.append(ptV1);

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

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

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

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

		AcDbLine* pLine = new AcDbLine(ptGe[1], ptGe[2]);
		return pLine;
	}

	return NULL;
}

AcDbLine* AecDbCornerStairDraw::DrawHandRailSide(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& num
	, const double& dW
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL);
	vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtLDir.normalize();

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

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

	AcGePoint3d ptV, ptV0;
	AcGePoint3dArray arSecPts;
	double dSidet(120);

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dW - dSidet) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dW - dSidet) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dW - dSidet) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dW - dSidet) * .5 - data.dBarSide) * 2 * num;
	}

	ptSta.z += (data.dBarH - data.dSteepH * .5);

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

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

	for (int i = 0; i < nCount - 1; i++)
	{
		ptSta -= vtL * data.dSteepW;
		ptSta.z += data.dSteepH;

		if (i == (nCount - 2))//只需最后踏步上位点
			arSecPts.append(ptSta);
	}

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

	AcGePoint3d ptV1 = ptSta - vtL * data.dSteepW;
	arSecPts.append(ptV1);

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

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

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

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

		AcDbLine* pLine = new AcDbLine(ptGe[1], ptGe[2]);
		/*pLine->setColorIndex(3);
		CoreTools::AddToModelSpace(pLine);*/
		return pLine;
	}

	return NULL;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawHandRailPath3d(AcGiDraw& dc
	, const AcGePoint3dArray& arPts
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGeVector3d vec = (arPts.at(0) - arPts.at(1)).normalize();

	if (!data.nBShape)
	{
		vec.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
		vec.normalize();
		pReg = makeRectRegion(arPts.at(0), data.dGarSize[0], data.dGarSize[1], vec, AcGeVector3d::kZAxis);
	}
	else
	{
		pReg = makeCircleRegion(arPts.at(0), vec, data.dGarSize[0] * .5);
	}

	if (pReg == NULL) return Acad::eOk;
	AcDbPolyline* pPoly = (AcDbPolyline*)Format3dPolyline(arPts);
	AcDbX3dSolid xSolid;
	if (xSolid.CreateSweep(pReg, pPoly))
	{
		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (pSolid == NULL) return Acad::eOk;
		dc.DrawEntity(pSolid);
		dc.Add3dBuffer(pSolid);
		add3DCache<AecDbCornerStair>(&xSolid);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawHandRail3dL(AcGiDraw& dc
	, const AcGePoint3d* ptAr
	, const double& dRestL
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const int& num
	, const SFSPStair& data) const
{
	AcGePoint3d ptS, ptE, pt;
	SFSPStair data1(data);
	AcDbLine *pLine1(NULL), *pLine2(NULL);
	AcGePoint3dArray ptGeIn, ptGeOut;
	
	if (data.nUpSide == 0)
	{
		data1.nSteepS = data1.nSteepsS;
		pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairSW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.removeAll();
		ptGeIn.append(ptE);
		ptGeIn.append(ptS);

		ptS = ptGeIn.at(1) - vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] + data1.dBarSide);
		ptGeIn.append(ptS);

		ptS -= vtDir * (data1.dRestPtW - data1.dStairSW + data1.dBarSide);
		ptGeIn.append(ptS);

		//边梯扶手伸出
		if (UP_ZERO(data1.dZGarExt))
		{
			ptS = ptGeIn.at(0);
			ptGeIn.insertAt(0, ptS);
			ptS += vt * data1.dZGarExt;
			ptGeIn.insertAt(0, ptS);
		}

		data1.nSteepS = data1.nSteepMs - 1;
		pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairMW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.append(ptE);
		ptGeIn.append(ptS);

		//中梯扶手伸出
		if (UP_ZERO(data1.dGarExt))
		{
			ptS -= vtDir * data1.dGarExt;
			ptGeIn.append(ptS);
		}

		DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

		if (data1.bOutSideHRail)
		{
			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			ptS = ptGeIn.at(1) - vt * data1.dRestPtL;
			ptGeIn.append(ptS);

			//边梯扶手伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0);
				ptGeIn.insertAt(0, ptS);
				ptS += vt * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
		}
	}
	else
	{
		data1.nSteepS = data1.nSteepsS - 1;
		pLine1 = DrawHandRailSide(dc, ptAr[0], ptAr[1], num, data1.dStairSW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.removeAll();
		ptGeIn.append(ptS);
		ptGeIn.append(ptE);
		
		
		ptS = ptGeIn.at(1) - vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] + data1.dBarSide);
		ptGeIn.append(ptS);

		ptS -= vtDir * (data1.dRestPtW - data1.dStairSW + data1.dBarSide);
		ptGeIn.append(ptS);

		//边梯扶手伸出
		if (UP_ZERO(data1.dZGarExt))
		{
			ptS = ptGeIn.at(0);
			ptGeIn.insertAt(0, ptS);
			ptS += vt * data1.dZGarExt;
			ptGeIn.insertAt(0, ptS);
		}

		data1.nSteepS = data1.nSteepMs;
		pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairMW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.append(ptS);
		ptGeIn.append(ptE);

		//中梯扶手伸出
		if (UP_ZERO(data1.dGarExt))
		{
			ptE -= vtDir * data1.dGarExt;
			ptGeIn.append(ptE);
		}

		DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

		if (data1.bOutSideHRail)
		{
			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			ptS = ptGeIn.at(1) - vt * (data1.dRestPtL - data.dSteepW * 2);
			ptGeIn.append(ptS);

			//边梯扶手伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0);
				ptGeIn.insertAt(0, ptS);
				ptS += vt * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbCornerStairDraw::DrawHandRail3dR(AcGiDraw& dc
	, const AcGePoint3d* ptAr
	, const double& dRestL
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const int& num
	, const SFSPStair& data) const
{
	AcGePoint3d ptS, ptE;
	SFSPStair data1(data);
	AcDbLine* pLine1(NULL), * pLine2(NULL);
	AcGePoint3dArray ptGeIn, ptGeOut;

	if (data.nUpSide == 0)
	{
		data1.nSteepS = data1.nSteepsS;
		pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairSW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.removeAll();
		ptGeIn.append(ptE);
		ptGeIn.append(ptS);

		ptS = ptGeIn.at(1) + vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] + data1.dBarSide);
		ptGeIn.append(ptS);

		ptS -= vtDir * (data1.dRestPtW - data1.dStairSW + data1.dBarSide);
		ptGeIn.append(ptS);

		//边梯扶手伸出
		if (UP_ZERO(data1.dZGarExt))
		{
			ptS = ptGeIn.at(0);
			ptGeIn.insertAt(0, ptS);
			ptS -= vt * data1.dZGarExt;
			ptGeIn.insertAt(0, ptS);
		}

		data1.nSteepS = data1.nSteepMs - 1;
		pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairMW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.append(ptE);
		ptGeIn.append(ptS);

		//中梯扶手伸出
		if (UP_ZERO(data1.dGarExt))
		{
			ptS -= vtDir * data1.dGarExt;
			ptGeIn.append(ptS);
		}

		DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

		if (data1.bOutSideHRail)
		{
			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			////边梯扶手伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0);
				ptGeIn.insertAt(0, ptS);
				ptS -= vt * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
		}
	}
	else
	{
		data1.nSteepS = data1.nSteepsS - 1;
		pLine1 = DrawHandRailSide(dc, ptAr[0], ptAr[1], num, data1.dStairSW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.removeAll();
		ptGeIn.append(ptS);
		ptGeIn.append(ptE);

		ptS = ptGeIn.at(1) + vt * ((data1.dRestPtL - data1.dStairMW) * .5 + data1.dGarSize[0] + data1.dBarSide);
		ptGeIn.append(ptS);

		ptS -= vtDir * (data1.dRestPtW - data1.dStairSW + data1.dBarSide);
		ptGeIn.append(ptS);

		//边梯扶手伸出
		if (UP_ZERO(data1.dZGarExt))
		{
			ptS = ptGeIn.at(0);
			ptGeIn.insertAt(0, ptS);
			ptS -= vt * data1.dZGarExt;
			ptGeIn.insertAt(0, ptS);
		}

		data1.nSteepS = data1.nSteepMs;
		pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairMW, data1);
		pLine1->getStartPoint(ptS);
		pLine1->getEndPoint(ptE);
		ptGeIn.append(ptS);
		ptGeIn.append(ptE);

		//中梯扶手伸出
		if (UP_ZERO(data1.dGarExt))
		{
			ptE -= vtDir * data1.dGarExt;
			ptGeIn.append(ptE);
		}

		DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

		if (data1.bOutSideHRail)
		{
			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			//边梯扶手伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptE = ptGeIn.at(1) - vt * data1.dZGarExt;
				ptGeIn.append(ptE);
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
		}
	}

	return Acad::eOk;
}