1593 lines
40 KiB
C++
1593 lines
40 KiB
C++
#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;
|
|
} |