2115 lines
53 KiB
C++
2115 lines
53 KiB
C++
#include "stdafx.h"
|
||
#include "AecDbTriangleStair.h"
|
||
#include "AecDbTriangleStairDraw.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(AecDbTriangleStairDraw, 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;
|
||
}
|
||
|
||
AcDb3dPolyline* drawRestPoly2d(AcGiDraw& dc
|
||
, AcGePoint3dArray& arPts
|
||
, const AcGeVector3d& vtL
|
||
, const AcGeVector3d& vtR
|
||
, const SFPXStair& data)
|
||
{
|
||
AcGePoint3d ptIntersect;
|
||
AcGePoint3d ptL, ptR;
|
||
AcGeLine3d lnS, lnE;
|
||
lnS.set(arPts.first(), vtL);
|
||
lnE.set(arPts.last(), vtR);
|
||
|
||
AcDb3dPolyline* pPoly(NULL);
|
||
if (lnS.intersectWith(lnE, ptIntersect))
|
||
{
|
||
double dist = arPts[0].distanceTo(ptIntersect);
|
||
|
||
if (data.dRestPtW >= dist)
|
||
{
|
||
arPts.append(ptIntersect);
|
||
arPts.append(arPts[0]);
|
||
//pPoly = Format3dPolyline(arPts);
|
||
//return pPoly;
|
||
}
|
||
else
|
||
{
|
||
ptR = arPts.last() + vtR * data.dRestPtW;
|
||
arPts.append(ptR);
|
||
ptL = arPts.first() + vtL * data.dRestPtW;
|
||
arPts.insertAt(0, ptL);
|
||
arPts.append(arPts[0]);
|
||
//pPoly = Format3dPolyline(arPts);
|
||
//return pPoly;
|
||
}
|
||
|
||
pPoly = Format3dPolyline(arPts);
|
||
return pPoly;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
AcDbPolyline* drawHangRailInPoly2d(AcGiDraw& dc
|
||
, AcGePoint3dArray& arPts
|
||
, const AcGeVector3d& vtL
|
||
, const AcGeVector3d& vtR
|
||
, const SFPXStair& data)
|
||
{
|
||
AcGePoint3d ptIntersect;
|
||
AcGeLine3d lnS, lnE;
|
||
lnS.set(arPts.first(), vtL);
|
||
lnE.set(arPts.last(), vtR);
|
||
|
||
AcDbPolyline* pPoly(NULL);
|
||
if (lnS.intersectWith(lnE, ptIntersect))
|
||
{
|
||
double dist = arPts[0].distanceTo(ptIntersect);
|
||
|
||
if (data.dZGarExt >= dist)
|
||
{
|
||
arPts.insertAt(1,ptIntersect);
|
||
pPoly = FormatPolyline((AcGePoint3d*)arPts.asArrayPtr(), arPts.length());
|
||
}
|
||
else
|
||
{
|
||
pPoly = FormatPolyline((AcGePoint3d*)arPts.asArrayPtr(), arPts.length());
|
||
}
|
||
}
|
||
|
||
return pPoly;
|
||
}
|
||
|
||
AcGePoint3d drawHangRailInPoly3d(AcGiDraw& dc
|
||
, AcGePoint3dArray& arPts
|
||
, const AcGeVector3d& vtL
|
||
, const AcGeVector3d& vtR
|
||
, const SFPXStair& data)
|
||
{
|
||
AcGePoint3d ptIntersect;
|
||
AcGeLine3d lnS, lnE;
|
||
lnS.set(arPts.first(), vtL);
|
||
lnE.set(arPts.last(), vtR);
|
||
|
||
AcDbPolyline* pPoly(NULL);
|
||
if (lnS.intersectWith(lnE, ptIntersect))
|
||
{
|
||
return ptIntersect;
|
||
}
|
||
|
||
}
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
AecDbTriangleStairDraw::AecDbTriangleStairDraw(void)
|
||
{
|
||
}
|
||
|
||
AecDbTriangleStairDraw::~AecDbTriangleStairDraw(void)
|
||
{
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::Draw2d(AcGiDraw &dc) const
|
||
{
|
||
AcDbObjectId idCurLay = dc.GetLayerId();
|
||
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
||
AcDbEntity *pEntReal = GetAttach();
|
||
if (pEntReal == NULL)
|
||
return Acad::eOk;
|
||
|
||
AecDbTriangleStair *pStair = AecDbTriangleStair::cast(pEntReal);
|
||
if (pStair == 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));
|
||
pStair->GetSFPXStair(data);
|
||
|
||
AcDbVoidPtrArray arEntPtrs;
|
||
AcDbCurve* pBaseCurve = pStair->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;
|
||
|
||
/*pLn->setColorIndex(3);
|
||
dc.DrawEntity(pLn);
|
||
dc.Add2dBuffer(pLn);*/
|
||
|
||
AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
|
||
vtSE = (ptSta - ptEnd).normalize();
|
||
vtSEDir = vtSE;
|
||
vtSEDir.rotateBy(-PI / 2.0, Z);
|
||
vtSEDir.normalize();
|
||
|
||
DrawStair2d(dc, ptSta, vtSE, vtSEDir, data);
|
||
DrawHandRailIn2d(dc, ptSta, vtSE, vtSEDir, data);
|
||
DrawRestPlatform2d(dc, ptSta, vtSE, vtSEDir, data);
|
||
DrawWithin2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
||
}
|
||
}
|
||
|
||
|
||
dc.SetColor(nCrBk);
|
||
dc.SetLayer(idCurLay);
|
||
dc.SetLineType(idCurLty);
|
||
dc.Add2dBuffer(arEntPtrs);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::Draw3d(AcGiDraw &dc) const
|
||
{
|
||
del3DCache<AecDbTriangleStair>();
|
||
AcDbObjectId idCurLay = dc.GetLayerId();
|
||
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
||
AcDbEntity *pEntReal = GetAttach();
|
||
if (pEntReal == NULL)
|
||
return Acad::eOk;
|
||
|
||
AecDbTriangleStair *pStair = AecDbTriangleStair::cast(pEntReal);
|
||
if (pStair == 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));
|
||
pStair->GetSFPXStair(data);
|
||
|
||
AcDbCurve* pBaseCurve = pStair->GetBaseCurve();
|
||
if (pBaseCurve != NULL)
|
||
{
|
||
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
||
if (pLn != NULL)
|
||
{
|
||
AcGePoint3d ptSta, ptEnd;
|
||
ptSta = pLn->startPoint();
|
||
ptEnd = pLn->endPoint();
|
||
|
||
AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
|
||
|
||
ptSta += Z * data.dBomEl;
|
||
ptEnd += Z * data.dBomEl;
|
||
|
||
vtSE = (ptSta - ptEnd).normalize();
|
||
vtSEDir = vtSE;
|
||
vtSEDir.rotateBy(-PI / 2.0, Z);
|
||
vtSEDir.normalize();
|
||
if (!data.nUpSide)
|
||
{
|
||
DrawStair3dClock(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
||
DrawRest3dClock(dc, ptSta, vtSE, vtSEDir, data);
|
||
}
|
||
else
|
||
{
|
||
DrawStair3dAntiClock(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
|
||
DrawRest3dAntiClock(dc, ptSta, vtSE, vtSEDir, data);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawStair2d(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFPXStair& data) const
|
||
{
|
||
AcGePoint3d pt, ptS(ptSta);
|
||
AcGePoint3d ptGe[5];
|
||
AcGePoint3d ptGe1[5];
|
||
AcGePoint3d ptGe2[5] ;
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcDbPolyline *pPoly(NULL), *pPoly1(NULL);
|
||
|
||
ptGe[0] = ptS;
|
||
ptGe[1] = ptGe[0] + vtDir * (data.nSteepS - 1) * data.dSteepW;
|
||
ptGe[2] = ptGe[1] - vt * data.dStairMW;
|
||
ptGe[3] = ptGe[2] - vtDir * (data.nSteepS - 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 < data.nSteepS; ++i)
|
||
{
|
||
ptGe[0] = ptS + vtDir * data.dSteepW * i;
|
||
ptGe[1] = ptGe[0] - vt * data.dStairMW;
|
||
pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
||
if (!pPoly) return Acad::eOk;
|
||
pPoly->setColorIndex(2);
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
}
|
||
|
||
if (data.bOutSideHRail)
|
||
{
|
||
DrawHandRailOut2d(dc, ptSta, vt, vtDir, data);
|
||
}
|
||
|
||
ptGe1[0] = ptS + vtDir * (data.nSteepS - 1) * data.dSteepW;
|
||
ptGe1[0] -= vt * data.dStairMW;
|
||
ptGe1[0] -= vt * sin(PI / 3) * data.dWell;
|
||
ptGe1[0] += vtDir * data.dWell * .5;
|
||
ptGe1[1] = ptGe1[0] - vt * data.dStairMW * .5;
|
||
ptGe1[1] += vtDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (ptGe1[1] - ptGe1[0]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, Z);
|
||
vtSDir.normalize();
|
||
|
||
ptGe1[2] = ptGe1[1] + vtSDir * (data.nSteepS - 1) * data.dSteepW;
|
||
ptGe1[3] = ptGe1[2] - vtS * data.dStairMW;
|
||
ptGe1[4] = ptGe1[0];
|
||
|
||
AcDbPolyline* pPl1 = NULL;
|
||
pPl1 = FormatPolyline(ptGe1, 5);
|
||
dc.DrawEntity(pPl1);
|
||
dc.Add2dBuffer(pPl1);
|
||
|
||
for (int i(0); i < data.nSteepS - 1; ++i)
|
||
{
|
||
ptGe[0] = ptGe1[0] + vtSDir * data.dSteepW * i;
|
||
ptGe[1] = ptGe[0] + vtS * data.dStairMW;
|
||
pPoly1 = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
||
if (!pPoly1) return Acad::eOk;
|
||
pPoly1->setColorIndex(2);
|
||
dc.DrawEntity(pPoly1);
|
||
dc.Add2dBuffer(pPoly1);
|
||
}
|
||
|
||
if (data.bOutSideHRail)
|
||
{
|
||
DrawHandRailOut2d(dc, ptGe1[2], vtS, -vtSDir, data);
|
||
}
|
||
|
||
ptGe2[0] = ptGe1[3] - vtS * sin(PI / 3) * data.dWell;
|
||
ptGe2[0] += vtSDir * data.dWell * .5;
|
||
ptGe2[1] = ptGe2[0] -vtS * data.dStairMW * .5;
|
||
ptGe2[1] += vtSDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe2[1] - ptGe2[0]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, Z);
|
||
vtS2Dir.normalize();
|
||
|
||
ptGe2[2] = ptGe2[1] + vtS2Dir * (data.nSteepS - 1) * data.dSteepW;
|
||
ptGe2[3] = ptGe2[2] - vtS2 * data.dStairMW;
|
||
ptGe2[4] = ptGe2[0];
|
||
|
||
AcDbPolyline* pPl2 = NULL;
|
||
pPl2 = FormatPolyline(ptGe2, 5);
|
||
dc.DrawEntity(pPl2);
|
||
dc.Add2dBuffer(pPl2);
|
||
|
||
for (int i(0); i < data.nSteepS - 1; ++i)
|
||
{
|
||
ptGe[0] = ptGe2[0] + vtS2Dir * data.dSteepW * i;
|
||
ptGe[1] = ptGe[0] + vtS2 * data.dStairMW;
|
||
pPoly1 = (AcDbPolyline*)FormatPolyline(ptGe, 2);
|
||
if (!pPoly1) return Acad::eOk;
|
||
pPoly1->setColorIndex(2);
|
||
dc.DrawEntity(pPoly1);
|
||
dc.Add2dBuffer(pPoly1);
|
||
}
|
||
|
||
if (data.bOutSideHRail)
|
||
{
|
||
DrawHandRailOut2d(dc, ptGe2[2], vtS2, -vtS2Dir, data);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawRestPlatform2d(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcDbRegion* pReg(NULL), * pReg1(NULL), * pReg2(NULL);
|
||
AcDbLine ln, ln1, ln2;
|
||
SFSPStair data1(data);
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGe[10];
|
||
AcGePoint3d ptGe1[9];
|
||
AcGePoint3d ptGe2[9];
|
||
|
||
ptGe[0] = ptSta + vtDir * (data1.nSteepS - 1) * data.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * cos(PI / 6) * data1.dWell;
|
||
ptGe[2] += vtDir * sin(PI / 6) * data1.dWell;
|
||
ptGe[3] = ptGe[2] - vt * cos(PI / 3) * data1.dStairMW;
|
||
ptGe[3] += vtDir * sin(PI / 3) * data1.dStairMW;
|
||
|
||
vtS = (ptGe[2] - ptGe[3]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
AcGePoint3dArray ar;
|
||
ar.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar.append(ptGe[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly = drawRestPoly2d(dc, ar, vtDir, vtSDir, data);
|
||
pPoly->setColorIndex(2);
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
|
||
ptGe1[0] = ptGe[3] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[0] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[1] = ptGe[2] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[1] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[2] = ptGe1[1] + vtS * sin(PI / 3) * data1.dWell;
|
||
ptGe1[2] -= vtSDir * data1.dWell * .5;
|
||
ptGe1[3] = ptGe1[2] + vtS * data1.dStairMW * .5;
|
||
ptGe1[3] -= vtSDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe1[2] - ptGe1[3]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
AcGePoint3dArray ar1;
|
||
ar1.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar1.append(ptGe1[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly1 = drawRestPoly2d(dc, ar1, -vtSDir, vtS2Dir, data);
|
||
pPoly1->setColorIndex(2);
|
||
dc.DrawEntity(pPoly1);
|
||
dc.Add2dBuffer(pPoly1);
|
||
|
||
ptGe2[0] = ptGe1[3] - vtS2Dir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[0] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[1] = ptGe1[2] - vtS2Dir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[1] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[2] = ptGe2[1] + vtS2 * sin(PI / 3) * data1.dWell;
|
||
ptGe2[2] -= vtS2Dir * data1.dWell * .5;
|
||
ptGe2[3] = ptGe2[2] + vtS2 * data1.dStairMW * .5;
|
||
ptGe2[3] -= vtS2Dir * data1.dStairMW * sin(PI / 3);
|
||
|
||
AcGePoint3dArray ar2;
|
||
ar2.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar2.append(ptGe2[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly2 = drawRestPoly2d(dc, ar2, -vtS2Dir, -vtDir, data);
|
||
pPoly2->setColorIndex(2);
|
||
dc.DrawEntity(pPoly2);
|
||
dc.Add2dBuffer(pPoly2);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRailIn2d(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS(ptSta), pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7;
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGe[10];
|
||
|
||
pt0 = ptS - vt * (data.dStairMW - data.dGarSize[0] * .5 - data.dBarSide);
|
||
pt0 -= vtDir * data.dZGarExt;
|
||
pt1 = pt0 + vtDir * ((data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2);
|
||
|
||
ptGe[0] = pt0;
|
||
ptGe[1] = pt1;
|
||
|
||
pt1 -= vt * (data.dGarSize[0] * .5 + data.dBarSide);
|
||
pt1 -= vtDir * data.dZGarExt;
|
||
pt2 = pt1 - vt * cos(PI / 6) * data.dWell;
|
||
pt2 += vtDir * sin(PI / 6) * data.dWell;
|
||
pt3 = pt2 - vt * cos(PI / 3) * data.dStairMW;
|
||
pt3 += vtDir * sin(PI / 3) * data.dStairMW;
|
||
|
||
vtS = (pt2 - pt3).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
pt2 -= vtS * (data.dGarSize[0] * .5 + data.dBarSide);
|
||
pt2 += vtSDir * data.dZGarExt;
|
||
pt3 = pt2 - vtSDir * ((data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2);
|
||
|
||
ptGe[3] = pt2;
|
||
ptGe[4] = pt3;
|
||
|
||
AcGePoint3dArray ar;
|
||
ar.removeAll();
|
||
ar.append(ptGe[1]);
|
||
ar.append(ptGe[3]);
|
||
|
||
AcDbPolyline* pPoly = drawHangRailInPoly2d(dc, ar, vtDir, vtSDir, data);
|
||
if (pPoly == NULL) return Acad::eOk;
|
||
|
||
ptGe[2] = ar.at(1);
|
||
|
||
pt3 += vtSDir * data.dZGarExt;
|
||
pt3 += vtS * (data.dGarSize[0] * .5 + data.dBarSide);
|
||
pt3 += vtS * cos(PI / 6) * data.dWell;
|
||
pt3 -= vtSDir * sin(PI / 6) * data.dWell;
|
||
pt4 = pt3 + vtS * cos(PI / 3) * data.dStairMW;
|
||
pt4 -= vtSDir * sin(PI / 3) * data.dStairMW;
|
||
|
||
vtS2 = (pt3 - pt4).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
pt3 -= vtS2 * (data.dGarSize[0] * .5 + data.dBarSide);
|
||
pt3 += vtS2Dir * data.dZGarExt;
|
||
pt4 = pt3 - vtS2Dir * ((data.nSteepS - 1) * data.dSteepW + data.dZGarExt * 2);
|
||
|
||
ptGe[6] = pt3;
|
||
ptGe[7] = pt4;
|
||
|
||
ar.removeAll();
|
||
ar.append(ptGe[4]);
|
||
ar.append(ptGe[6]);
|
||
|
||
AcDbPolyline* pPoly1 = drawHangRailInPoly2d(dc, ar, -vtSDir, vtS2Dir, data);
|
||
ptGe[5] = ar.at(1);
|
||
|
||
ar.removeAll();
|
||
ar.append(ptGe[7]);
|
||
ar.append(ptGe[0]);
|
||
|
||
AcDbPolyline* pPoly2 = drawHangRailInPoly2d(dc, ar, vtS2Dir, -vtDir, data);
|
||
if (pPoly2 == NULL) return Acad::eOk;
|
||
|
||
ptGe[8] = ar.at(1);
|
||
ptGe[9] = ptGe[0];
|
||
|
||
AcDbPolyline* pPl = FormatPolyline(ptGe, 10);
|
||
if (pPl == NULL) return Acad::eOk;
|
||
|
||
AcDbVoidPtrArray arptR;
|
||
pPl->getOffsetCurves(30, arptR);
|
||
if (arptR.isEmpty()) return Acad::eOk;
|
||
|
||
AcDbPolyline* pNewPolyR = (AcDbPolyline*)(((AcDbEntity*)arptR.first())->clone());
|
||
deleteArrayVoidPtrs<AcDbEntity>(arptR);
|
||
if (pNewPolyR == NULL) return Acad::eOk;
|
||
pNewPolyR->setColorIndex(2);
|
||
dc.DrawEntity(pNewPolyR);
|
||
dc.Add2dBuffer(pNewPolyR);
|
||
|
||
AcDbVoidPtrArray arptL;
|
||
pPl->getOffsetCurves(-30, arptL);
|
||
if (arptL.isEmpty()) return Acad::eOk;
|
||
|
||
AcDbPolyline* pNewPolyL = (AcDbPolyline*)(((AcDbEntity*)arptL.first())->clone());
|
||
deleteArrayVoidPtrs<AcDbEntity>(arptL);
|
||
if (pNewPolyL == NULL) return Acad::eOk;
|
||
pNewPolyL->setColorIndex(2);
|
||
dc.DrawEntity(pNewPolyL);
|
||
dc.Add2dBuffer(pNewPolyL);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRailOut2d(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS(ptSta);
|
||
AcGePoint3d ptGe[5];
|
||
|
||
ptS -= vt * data.dBarSide;
|
||
ptGe[0] = ptS - vtDir * data.dZGarExt;
|
||
ptGe[1] = ptGe[0] - vt * data.dBarSize[0];
|
||
ptGe[2] = ptGe[1] + vtDir * (data.dZGarExt * 2 + (data.nSteepS - 1) * data.dSteepW);
|
||
ptGe[3] = ptGe[2] + vt * data.dBarSize[0];
|
||
ptGe[4] = ptGe[0];
|
||
|
||
AcDbPolyline* pPl = NULL;
|
||
pPl = FormatPolyline(ptGe, 5);
|
||
dc.DrawEntity(pPl);
|
||
dc.Add2dBuffer(pPl);
|
||
|
||
return Acad::eOk;
|
||
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawWithin2d(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;
|
||
AcGePoint3d ptGe[4];
|
||
double dScale = CoreTools::getPScaleForSymb();
|
||
double dW(dScale * .8);
|
||
double dH(dScale * 3);
|
||
double dTextH(dScale * 3.5);
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;
|
||
|
||
if (data.nUpSide == 0)
|
||
{
|
||
pt1 -= vt * data.dStairMW * .5;
|
||
pt1 -= vtDir * data.dSteepW * .5;
|
||
pt2 = pt1 + vtDir * ((data.nSSteeps - .5) * 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);
|
||
|
||
drawText(dc, _T("��"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
||
|
||
pt4 = pt2 + vtDir * (data.nSteepS + 1 - data.nSSteeps) * data.dSteepW;
|
||
pt5 = pt4 - vtDir * (data.nSteepS - data.nSSteeps) * 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);
|
||
|
||
pt7 = pt4 - vtDir * data.dSteepW;
|
||
pt7 -= vt * data.dStairMW * .5;
|
||
pt7 -= vt * sin(PI / 3) * data.dWell;
|
||
pt7 += vtDir * data.dWell * .5;
|
||
pt8 = pt7 - vt * data.dStairMW * .5;
|
||
pt8 += vtDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (pt8 - pt7).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, Z);
|
||
vtSDir.normalize();
|
||
|
||
pt7 += vtS * data.dStairMW * .5;
|
||
pt7 -= vtSDir * data.dSteepW;
|
||
pt8 = pt7 + vtSDir * (data.nSteepS + 1) * data.dSteepW;
|
||
|
||
ptGe[0] = pt4;
|
||
ptGe[1] = pt7;
|
||
ptGe[2] = pt8;
|
||
|
||
AcDbPolyline* pPl2 = FormatPolyline(ptGe, 3);
|
||
if (pPl2 == NULL) return Acad::eOk;
|
||
pPl2->setColorIndex(3);
|
||
dc.DrawEntity(pPl2);
|
||
dc.Add2dBuffer(pPl2);
|
||
|
||
pt9 = pt8 - vtSDir * data.dSteepW;
|
||
pt9 -= vtS * data.dStairMW * .5;
|
||
pt9 -= vtS * sin(PI / 3) * data.dWell;
|
||
pt9 += vtSDir * data.dWell * .5;
|
||
pt10 = pt9 - vtS * data.dStairMW * .5;
|
||
pt10 += vtSDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (pt10 - pt9).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, Z);
|
||
vtS2Dir.normalize();
|
||
|
||
pt9 += vtS2 * data.dStairMW * .5;
|
||
pt9 -= vtS2Dir * data.dSteepW;
|
||
pt10 = pt9 + vtS2Dir * (data.nSteepS + 1) * data.dSteepW;
|
||
|
||
ptGe[0] = pt8;
|
||
ptGe[1] = pt9;
|
||
ptGe[2] = pt10;
|
||
|
||
AcDbPolyline* pPl3 = FormatPolyline(ptGe, 3);
|
||
if (pPl3 == NULL) return Acad::eOk;
|
||
pPl3->setColorIndex(3);
|
||
dc.DrawEntity(pPl3);
|
||
dc.Add2dBuffer(pPl3);
|
||
|
||
drawText(dc, _T("��"), dTextH, ptGe[2], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
||
|
||
}
|
||
else
|
||
{
|
||
pt1 -= vt * data.dStairMW * .5;
|
||
pt1 -= vtDir * data.dSteepW * .5;
|
||
pt2 = pt1 + vtDir * ((data.nSteepS + .5) * data.dSteepW);
|
||
|
||
ptGe[0] = pt1;
|
||
ptGe[1] = pt2;
|
||
|
||
AcDbPolyline* pPl = FormatPolyline(ptGe, 2);
|
||
if (pPl == NULL) return Acad::eOk;
|
||
pPl->setColorIndex(3);
|
||
dc.DrawEntity(pPl);
|
||
dc.Add2dBuffer(pPl);
|
||
|
||
drawText(dc, _T("��"), dTextH, ptGe[0], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
||
|
||
pt3 = pt2 - vtDir * data.dSteepW;
|
||
pt3 -= vt * data.dStairMW * .5;
|
||
pt3 -= vt * sin(PI / 3) * data.dWell;
|
||
pt3 += vtDir * data.dWell * .5;
|
||
pt4 = pt3 - vt * data.dStairMW * .5;
|
||
pt4 += vtDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (pt4 - pt3).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, Z);
|
||
vtSDir.normalize();
|
||
|
||
pt3 += vtS * data.dStairMW * .5;
|
||
pt3 -= vtSDir * data.dSteepW;
|
||
pt4 = pt3 + vtSDir * (data.nSteepS + 1) * data.dSteepW;
|
||
|
||
ptGe[0] = pt2;
|
||
ptGe[1] = pt3;
|
||
ptGe[2] = pt4;
|
||
|
||
AcDbPolyline* pPl1 = FormatPolyline(ptGe, 3);
|
||
if (pPl1 == NULL) return Acad::eOk;
|
||
pPl1->setColorIndex(3);
|
||
dc.DrawEntity(pPl1);
|
||
dc.Add2dBuffer(pPl1);
|
||
|
||
pt5 = pt4 - vtSDir * data.dSteepW;
|
||
pt5 -= vtS * data.dStairMW * .5;
|
||
pt5 -= vtS * sin(PI / 3) * data.dWell;
|
||
pt5 += vtSDir * data.dWell * .5;
|
||
pt6 = pt5 - vtS * data.dStairMW * .5;
|
||
pt6 += vtSDir * data.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (pt6 - pt5).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, Z);
|
||
vtS2Dir.normalize();
|
||
|
||
pt5 += vtS2 * data.dStairMW * .5;
|
||
pt5 -= vtS2Dir * data.dSteepW;
|
||
pt6 = pt5 + vtS2Dir * (data.nSteepS - data.nSSteeps) * data.dSteepW;
|
||
pt7 = pt6 - vtS2Dir * dH;
|
||
|
||
ptGe[0] = pt4;
|
||
ptGe[1] = pt5;
|
||
ptGe[2] = pt6;
|
||
ptGe[3] = pt7;
|
||
|
||
AcDbPolyline* pPl2 = FormatPolyline(ptGe, 4);
|
||
if (pPl2 == NULL) return Acad::eOk;
|
||
pPl2->setWidthsAt(2, 0, dW);
|
||
pPl2->setColorIndex(3);
|
||
dc.DrawEntity(pPl2);
|
||
dc.Add2dBuffer(pPl2);
|
||
|
||
pt8 = pt6 + vtS2Dir * (data.nSSteeps + .5) * data.dSteepW;
|
||
pt9 = pt8 - vtS2Dir * (data.nSSteeps - .5) * data.dSteepW;
|
||
pt10 = pt9 + vtS2Dir * dH;
|
||
|
||
ptGe[0] = pt8;
|
||
ptGe[1] = pt9;
|
||
ptGe[2] = pt10;
|
||
|
||
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[2], angle, Z, AcDb::kTextCenter, AcDb::kTextTop, AcGiDraw::kTopCenter);
|
||
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::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<AecDbTriangleStair>(&xSolid);
|
||
return Acad::eOk;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawStair3dClock(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);
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGeL1[4];
|
||
AcGePoint3d ptGeL2[4];
|
||
AcGePoint3d ptGeL3[4];
|
||
AcGePoint3d ptGe[4];
|
||
AcGePoint3d ptGe1[4];
|
||
|
||
ptS -= vt * data1.dStairMW * .5;
|
||
ptE = ptS + vtDir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptS, ptE, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL1[0] = ptS;
|
||
ptGeL1[1] = ptE;
|
||
|
||
ptGe[0] = ptS + vt * data1.dStairMW * .5;
|
||
ptGe[0] += vtDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe[0] += Z * (data1.nSteepS * data1.dSteepH);
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe[2] += vtDir * data1.dWell * .5;
|
||
ptGe[3] = ptGe[2] - vt * data1.dStairMW * .5;
|
||
ptGe[3] += vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (ptGe[3] - ptGe[2]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, Z);
|
||
vtSDir.normalize();
|
||
|
||
ptS = ptGe[2] + vtS * data1.dStairMW * .5;
|
||
ptE = ptS + vtSDir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptS, ptE, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL2[0] = ptS;
|
||
ptGeL2[1] = ptE;
|
||
|
||
ptGe1[0] = ptE + vtS * data1.dStairMW * .5;
|
||
ptGe1[0] -= vtSDir * data.dSteepW;
|
||
ptGe1[0] += Z * (data1.nSteepS * data1.dSteepH);
|
||
ptGe1[1] = ptGe1[0] - vtS * data1.dStairMW;
|
||
ptGe1[2] = ptGe1[1] - vtS * sin(PI / 3) * data1.dWell;
|
||
ptGe1[2] += vtSDir * data1.dWell * .5;
|
||
ptGe1[3] = ptGe1[2] - vtS * data1.dStairMW * .5;
|
||
ptGe1[3] += vtSDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe1[3] - ptGe1[2]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, Z);
|
||
vtS2Dir.normalize();
|
||
|
||
ptS = ptGe1[2] + vtS2 * data1.dStairMW * .5;
|
||
ptE = ptS + vtS2Dir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptS, ptE, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptS, ptE, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL3[0] = ptS;
|
||
ptGeL3[1] = ptE;
|
||
|
||
ptS = ptFr;
|
||
DrawHandRail3d1(dc, ptS, ptGeL1, vt, vtDir, 1, data1);
|
||
DrawHandRail3d2(dc, ptS, ptGeL2, vtS, vtSDir, 1, data1);
|
||
DrawHandRail3d3(dc, ptS, ptGeL3, vtS2, vtS2Dir, 1, data1);
|
||
DrawHandRail3dIn(dc, ptS, ptGeL1, vt, vtDir, 1, data1);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawStair3dAntiClock(AcGiDraw& dc
|
||
, const AcGePoint3d& ptFr
|
||
, const AcGePoint3d& ptTo
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS(ptFr), ptE(ptTo);
|
||
SFSPStair data1(data);
|
||
AcGePoint3dArray ar;
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGe[4];
|
||
AcGePoint3d ptGe1[4];
|
||
AcGePoint3d ptGe2[4];
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir;
|
||
AcGePoint3d ptGeL1[4];
|
||
AcGePoint3d ptGeL2[4];
|
||
AcGePoint3d ptGeL3[4];
|
||
|
||
ptS.z = (data1.nSteepS * 3 - 8) * data1.dSteepH + data1.dSteepW;
|
||
ptS -= vt * data1.dStairMW * .5;
|
||
ptE = ptS + vtDir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptE, ptS, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL1[0] = ptE;
|
||
ptGeL1[1] = ptS;
|
||
|
||
ptGe[0] = ptS + vt * data1.dStairMW * .5;
|
||
ptGe[0] += vtDir * data1.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe[2] -= vtDir * data1.dWell * .5;
|
||
ptGe[3] = ptGe[2] - vt * data1.dStairMW * .5;
|
||
ptGe[3] -= vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
ar.append(ptGe[0]);
|
||
ar.append(ptGe[1]);
|
||
ar.append(ptGe[2]);
|
||
ar.append(ptGe[3]);
|
||
|
||
ptGe1[0] = ptE + vt * data1.dStairMW * .5;
|
||
ptGe1[1] = ptGe1[0] - vt * data1.dStairMW;
|
||
ptGe1[2] = ptGe1[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe1[2] += vtDir * data1.dWell * .5;
|
||
ptGe1[3] = ptGe1[2] - vt * data1.dStairMW * .5;
|
||
ptGe1[3] += vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (ptGe1[3] - ptGe1[2]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, Z);
|
||
vtSDir.normalize();
|
||
|
||
ptS = ptGe1[2] - vtSDir * data1.dSteepW;
|
||
ptS += vtS * data1.dStairMW * .5;
|
||
ptS -= Z * data1.nSteepS * data1.dSteepH;
|
||
ptE = ptS + vtSDir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptE, ptS, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL2[0] = ptE;
|
||
ptGeL2[1] = ptS;
|
||
|
||
ptGe2[0] = ptE + vtS * data1.dStairMW * .5;
|
||
ptGe2[1] = ptGe2[0] - vtS * data1.dStairMW;
|
||
ptGe2[2] = ptGe2[1] - vtS * sin(PI / 3) * data1.dWell;
|
||
ptGe2[2] += vtSDir * data1.dWell * .5;
|
||
ptGe2[3] = ptGe2[2] - vtS * data1.dStairMW * .5;
|
||
ptGe2[3] += vtSDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe2[3] - ptGe2[2]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, Z);
|
||
vtS2Dir.normalize();
|
||
|
||
ptS = ptGe2[2] - vtS2Dir * data1.dSteepW;
|
||
ptS += vtS2 * data1.dStairMW * .5;
|
||
ptS -= Z * (data1.nSteepS - 1) * data1.dSteepH;
|
||
ptE = ptS + vtS2Dir * data1.nSteepS * data1.dSteepW;
|
||
DrawSteep3d(dc, ptE, ptS, data1, data1.dStairMW);
|
||
if (data.bInsideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 1, data.dStairMW, data1);
|
||
}
|
||
if (data.bOutSideRail)
|
||
{
|
||
DrawGuard3d(dc, ptE, ptS, 0, data.dStairMW, data1);
|
||
}
|
||
|
||
ptGeL3[0] = ptE;
|
||
ptGeL3[1] = ptS;
|
||
|
||
ptS = ptFr;
|
||
DrawHandRail3d1(dc, ptS, ptGeL1, vt, vtDir, 1, data1);
|
||
DrawHandRail3d2(dc, ptS, ptGeL2, vtS, vtSDir, 1, data1);
|
||
DrawHandRail3d3(dc, ptS, ptGeL3, vtS2, -vtS2Dir, 1, data1);
|
||
DrawHandRail3dIn(dc, ptS, ptGeL1, vt, vtDir, 1, data1);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawRest3dClock(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcDbRegion *pReg(NULL), *pReg1(NULL), * pReg2(NULL);
|
||
AcDbLine ln, ln1, ln2;
|
||
SFSPStair data1(data);
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGe[10];
|
||
AcGePoint3d ptGe1[9];
|
||
AcGePoint3d ptGe2[9];
|
||
|
||
ptGe[0] = ptSta + vtDir * (data1.nSteepS - 1) * data.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * cos(PI / 6) * data1.dWell;
|
||
ptGe[2] += vtDir * sin(PI / 6) * data1.dWell;
|
||
ptGe[3] = ptGe[2] - vt * cos(PI / 3) * data1.dStairMW;
|
||
ptGe[3] += vtDir * sin(PI / 3) * data1.dStairMW;
|
||
|
||
vtS = (ptGe[2] - ptGe[3]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
AcGePoint3dArray ar;
|
||
ar.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar.append(ptGe[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly = drawRestPoly2d(dc, ar, vtDir, vtSDir, data);
|
||
|
||
pReg = makeRegion(ar);
|
||
ln.setStartPoint(ptSta);
|
||
ln.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid;
|
||
AcGeMatrix3d mat;
|
||
if (xSolid.CreateExtrude(pReg, ln))
|
||
{
|
||
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
||
if (pSolid != NULL)
|
||
{
|
||
mat.setTranslation(Z * (data.nSteepS * data.dSteepH - 120));
|
||
pSolid->transformBy(mat);
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
xSolid.TransformBy(mat);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
ptGe1[0] = ptGe[3] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[0] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[1] = ptGe[2] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[1] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[2] = ptGe1[1] + vtS * sin(PI / 3) * data1.dWell;
|
||
ptGe1[2] -= vtSDir * data1.dWell * .5;
|
||
ptGe1[3] = ptGe1[2] + vtS * data1.dStairMW * .5;
|
||
ptGe1[3] -= vtSDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe1[2] - ptGe1[3]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
AcGePoint3dArray ar1;
|
||
ar1.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar1.append(ptGe1[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly1 = drawRestPoly2d(dc, ar1, -vtSDir, vtS2Dir, data);
|
||
|
||
pReg1 = makeRegion(ar1);
|
||
ln1.setStartPoint(ptSta);
|
||
ln1.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid1;
|
||
AcGeMatrix3d mat1;
|
||
if (xSolid1.CreateExtrude(pReg1, ln1))
|
||
{
|
||
AcDb3dSolid* pSolid1 = xSolid1.GetDraw3dSolid();
|
||
if (pSolid1 != NULL)
|
||
{
|
||
mat1.setTranslation(Z * (data.nSteepS * data.dSteepH));
|
||
pSolid1->transformBy(mat1);
|
||
dc.DrawEntity(pSolid1);
|
||
dc.Add3dBuffer(pSolid1);
|
||
xSolid.TransformBy(mat1);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
ptGe2[0] = ptGe1[3] - vtS2Dir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[0] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[1] = ptGe1[2] - vtS2Dir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[1] += Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[2] = ptGe2[1] + vtS2 * sin(PI / 3) * data1.dWell;
|
||
ptGe2[2] -= vtS2Dir * data1.dWell * .5;
|
||
ptGe2[3] = ptGe2[2] + vtS2 * data1.dStairMW * .5;
|
||
ptGe2[3] -= vtS2Dir * data1.dStairMW * sin(PI / 3);
|
||
|
||
AcGePoint3dArray ar2;
|
||
ar2.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar2.append(ptGe2[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly2 = drawRestPoly2d(dc, ar2, -vtS2Dir, -vtDir, data);
|
||
|
||
pReg2 = makeRegion(ar2);
|
||
ln2.setStartPoint(ptSta);
|
||
ln2.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid2;
|
||
AcGeMatrix3d mat2;
|
||
if (xSolid2.CreateExtrude(pReg2, ln2))
|
||
{
|
||
AcDb3dSolid* pSolid2 = xSolid2.GetDraw3dSolid();
|
||
if (pSolid2 != NULL)
|
||
{
|
||
mat2.setTranslation(Z * (data.nSteepS * data.dSteepH));
|
||
pSolid2->transformBy(mat2);
|
||
dc.DrawEntity(pSolid2);
|
||
dc.Add3dBuffer(pSolid2);
|
||
xSolid.TransformBy(mat2);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawRest3dAntiClock(AcGiDraw& dc
|
||
, const AcGePoint3d& ptSta
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS(ptSta);
|
||
SFSPStair data1(data);
|
||
AcGePoint3d ptGe[4];
|
||
AcGePoint3d ptGe1[4];
|
||
AcGePoint3d ptGe2[4];
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcDbRegion* pReg(NULL), * pReg1(NULL), * pReg2(NULL);
|
||
AcDbLine ln, ln1, ln2;
|
||
|
||
ptS.z = (data1.nSteepS * 3 - 8) * data1.dSteepH + data1.dSteepW;
|
||
ptGe[0] = ptS + vtDir * data1.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe[2] -= vtDir * data1.dWell * .5;
|
||
ptGe[3] = ptGe[2] - vt * data1.dStairMW * .5;
|
||
ptGe[3] -= vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS2 = (ptGe[2] - ptGe[3]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
AcGePoint3dArray ar;
|
||
ar.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar.append(ptGe[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly = drawRestPoly2d(dc, ar, -vtDir, -vtS2Dir, data);
|
||
|
||
pReg = makeRegion(ar);
|
||
ln.setStartPoint(ptSta);
|
||
ln.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid;
|
||
AcGeMatrix3d mat;
|
||
if (xSolid.CreateExtrude(pReg, ln))
|
||
{
|
||
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
||
if (pSolid != NULL)
|
||
{
|
||
mat.setTranslation(Z * (data.nSteepS * data.dSteepH));
|
||
pSolid->transformBy(mat);
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
xSolid.TransformBy(mat);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
ptGe1[0] = ptGe[0] + vtDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[0] -= Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[1] = ptGe[1] + vtDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe1[1] -= Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe1[2] = ptGe1[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe1[2] += vtDir * data1.dWell * .5;
|
||
ptGe1[3] = ptGe1[2] - vt * data1.dStairMW * .5;
|
||
ptGe1[3] += vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (ptGe1[2] - ptGe1[3]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
AcGePoint3dArray ar1;
|
||
ar1.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar1.append(ptGe1[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly1 = drawRestPoly2d(dc, ar1, vtDir, vtSDir, data);
|
||
|
||
pReg1 = makeRegion(ar1);
|
||
ln1.setStartPoint(ptSta);
|
||
ln1.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid1;
|
||
AcGeMatrix3d mat1;
|
||
if (xSolid1.CreateExtrude(pReg1, ln1))
|
||
{
|
||
AcDb3dSolid* pSolid1 = xSolid1.GetDraw3dSolid();
|
||
if (pSolid1 != NULL)
|
||
{
|
||
mat1.setTranslation(Z * (data.nSteepS * data.dSteepH));
|
||
pSolid1->transformBy(mat1);
|
||
dc.DrawEntity(pSolid1);
|
||
dc.Add3dBuffer(pSolid1);
|
||
xSolid.TransformBy(mat1);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
ptGe2[0] = ptGe1[3] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[0] -= Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[1] = ptGe1[2] - vtSDir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptGe2[1] -= Z * data1.nSteepS * data1.dSteepH;
|
||
ptGe2[2] = ptGe2[1] + vtS * sin(PI / 3) * data1.dWell;
|
||
ptGe2[2] -= vtSDir * data1.dWell * .5;
|
||
ptGe2[3] = ptGe2[2] + vtS * data1.dStairMW * .5;
|
||
ptGe2[3] -= vtSDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
AcGePoint3dArray ar2;
|
||
ar2.removeAll();
|
||
|
||
for (int i(0); i < 4; ++i)
|
||
{
|
||
ar2.append(ptGe2[i]);
|
||
}
|
||
|
||
AcDb3dPolyline* pPoly2 = drawRestPoly2d(dc, ar2, -vtSDir, vtS2Dir, data);
|
||
|
||
pReg2 = makeRegion(ar2);
|
||
ln2.setStartPoint(ptSta);
|
||
ln2.setEndPoint(ptSta + AcGeVector3d::kZAxis * (data.dSteepW - data.dSteepH));
|
||
|
||
AcDbX3dSolid xSolid2;
|
||
AcGeMatrix3d mat2;
|
||
if (xSolid2.CreateExtrude(pReg2, ln2))
|
||
{
|
||
AcDb3dSolid* pSolid2 = xSolid2.GetDraw3dSolid();
|
||
if (pSolid2 != NULL)
|
||
{
|
||
mat2.setTranslation(Z * (data.nSteepS * data.dSteepH));
|
||
pSolid2->transformBy(mat2);
|
||
dc.DrawEntity(pSolid2);
|
||
dc.Add3dBuffer(pSolid2);
|
||
xSolid.TransformBy(mat2);
|
||
add3DCache<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::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;
|
||
double dSidet(120);
|
||
|
||
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<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbLine* AecDbTriangleStairDraw::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;
|
||
double dSidet(120);
|
||
|
||
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]);
|
||
/*pLine->setColorIndex(3);
|
||
CoreTools::AddToModelSpace(pLine);*/
|
||
return pLine;
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::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<AecDbTriangleStair>(&xSolid);
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRail3d1(AcGiDraw& dc
|
||
, const AcGePoint3d& ptFr
|
||
, const AcGePoint3d* ptAr
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const int& num
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
SFSPStair data1(data);
|
||
AcDbLine* pLine1(NULL);
|
||
AcGePoint3dArray ptGeIn;
|
||
|
||
if (data.nUpSide == 0)
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptS);
|
||
ptGeIn.append(ptE);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRail3d2(AcGiDraw& dc
|
||
, const AcGePoint3d& ptFr
|
||
, const AcGePoint3d* ptAr
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const int& num
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
SFSPStair data1(data);
|
||
AcDbLine* pLine1(NULL);
|
||
AcGePoint3dArray ptGeIn;
|
||
|
||
if (data.nUpSide == 0)
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS -= vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE += vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRail3d3(AcGiDraw& dc
|
||
, const AcGePoint3d& ptFr
|
||
, const AcGePoint3d* ptAr
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const int& num
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
SFSPStair data1(data);
|
||
AcDbLine* pLine1(NULL);
|
||
AcGePoint3dArray ptGeIn;
|
||
|
||
if (data.nUpSide == 0)
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbTriangleStairDraw::DrawHandRail3dIn(AcGiDraw& dc
|
||
, const AcGePoint3d& ptFr
|
||
, const AcGePoint3d* ptAr
|
||
, const AcGeVector3d& vt
|
||
, const AcGeVector3d& vtDir
|
||
, const int& num
|
||
, const SFSPStair& data) const
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
SFSPStair data1(data);
|
||
AcDbLine* pLine1(NULL);
|
||
AcGePoint3dArray ptGeIn;
|
||
|
||
if (data.nUpSide == 0)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, 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 += vtDir * data.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
AcGePoint3d ptSta(ptFr);
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir, Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d ptGe[10];
|
||
AcGePoint3d ptGe1[9];
|
||
AcGePoint3d ptGe2[9];
|
||
|
||
ptGe[0] = ptSta + vtDir * (data1.nSteepS - 1) * data.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * cos(PI / 6) * data1.dWell;
|
||
ptGe[2] += vtDir * sin(PI / 6) * data1.dWell;
|
||
ptGe[3] = ptGe[2] - vt * cos(PI / 3) * data1.dStairMW;
|
||
ptGe[3] += vtDir * sin(PI / 3) * data1.dStairMW;
|
||
|
||
vtS = (ptGe[2] - ptGe[3]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
ptGe[1] += vt * (data1.dBarSide + data1.dGarSize[0]);
|
||
ptGe[2] -= vtS * (data1.dBarSide + data1.dGarSize[0]);
|
||
ptGe[2] += Z * (data.nSteepS * data1.dSteepH + data1.dBarH + data1.dGarSize[0]);
|
||
|
||
ptS = ptGe[2];
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtSDir * data1.nSteepS * data1.dSteepW;
|
||
ptS.z += data1.nSteepS * data1.dSteepH;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtSDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS += vtSDir * (data1.dZGarExt + data1.dSteepW);
|
||
ptS += vtS * (data1.dBarSide + data1.dGarSize[0]);
|
||
|
||
ptGe[0] = ptS + vtS * cos(PI / 6) * data1.dWell;
|
||
ptGe[0] -= vtSDir * sin(PI / 6) * data1.dWell;
|
||
ptGe[1] = ptGe[0] + vtS * cos(PI / 3) * data1.dStairMW;
|
||
ptGe[1] -= vtSDir * sin(PI / 3) * data1.dStairMW;
|
||
|
||
vtS2 = (ptGe[0] - ptGe[1]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
ptGe[0] -= vtS2 * (data1.dBarSide + data1.dGarSize[0]);
|
||
ptS = ptGe[0];
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtS2Dir * (data1.nSteepS * data1.dSteepW);
|
||
ptS.z += data1.nSteepS * data1.dSteepH;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtS2Dir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
}
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptE);
|
||
ptGeIn.append(ptS);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptS);
|
||
ptGeIn.append(ptE);
|
||
|
||
if (UP_ZERO(data1.dZGarExt))
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptS);
|
||
ptGeIn.append(ptE);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
AcGePoint3d ptS(ptFr);
|
||
AcGePoint3d ptGe[4];
|
||
AcGeVector3d vtS, vtSDir, vtS2, vtS2Dir;
|
||
|
||
ptS.z = data1.nSteepS * 3 * data1.dSteepH + data1.dBarSize[0] * .5;
|
||
ptGe[0] = ptS + vtDir * data1.nSteepS * data1.dSteepW;
|
||
ptGe[1] = ptGe[0] - vt * data1.dStairMW;
|
||
ptGe[2] = ptGe[1] - vt * sin(PI / 3) * data1.dWell;
|
||
ptGe[2] += vtDir * data1.dWell * .5;
|
||
ptGe[3] = ptGe[2] - vt * data1.dStairMW * .5;
|
||
ptGe[3] += vtDir * data1.dStairMW * sin(PI / 3);
|
||
|
||
vtS = (ptGe[2] - ptGe[3]).normalize();
|
||
vtSDir = vtS;
|
||
vtSDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtSDir.normalize();
|
||
|
||
ptGe[1] += vt * (data1.dBarSide + data1.dGarSize[0]);
|
||
ptGe[2] -= vtS * (data1.dBarSide + data1.dGarSize[0]);
|
||
ptGe[2] += vtSDir * data1.dSteepW;
|
||
|
||
ptS = ptGe[2];
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtSDir * (data1.nSteepS * data1.dSteepW);
|
||
ptS.z -= data1.nSteepS * data1.dSteepH;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtSDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS += vtSDir * data1.dZGarExt;
|
||
ptS += vtS * (data1.dBarSide + data1.dGarSize[0]);
|
||
|
||
ptGe[0] = ptS + vtS * cos(PI / 6) * data1.dWell;
|
||
ptGe[0] -= vtSDir * sin(PI / 6) * data1.dWell;
|
||
ptGe[1] = ptGe[0] + vtS * cos(PI / 3) * data1.dStairMW;
|
||
ptGe[1] -= vtSDir * sin(PI / 3) * data1.dStairMW;
|
||
|
||
vtS2 = (ptGe[0] - ptGe[1]).normalize();
|
||
vtS2Dir = vtS2;
|
||
vtS2Dir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vtS2Dir.normalize();
|
||
|
||
ptGe[0] -= vtS2 * (data1.dBarSide + data1.dGarSize[0]);
|
||
|
||
ptS = ptGe[0];
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtS2Dir * (data1.nSteepS - 1) * data1.dSteepW;
|
||
ptS.z -= (data1.nSteepS - 1) * data1.dSteepH;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptS -= vtS2Dir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
}
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
|
||
if (data1.bOutSideHRail)
|
||
{
|
||
pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], !num, data1.dStairMW, data1);
|
||
pLine1->getStartPoint(ptS);
|
||
pLine1->getEndPoint(ptE);
|
||
ptGeIn.removeAll();
|
||
ptGeIn.append(ptS);
|
||
ptGeIn.append(ptE);
|
||
|
||
ptS = ptGeIn.at(0);
|
||
ptGeIn.insertAt(0, ptS);
|
||
ptS += vtDir * data1.dZGarExt;
|
||
ptGeIn.insertAt(0, ptS);
|
||
|
||
ptE = ptGeIn.at(3);
|
||
ptGeIn.insertAt(3, ptE);
|
||
ptE -= vtDir * data1.dZGarExt;
|
||
ptGeIn.append(ptE);
|
||
|
||
DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
} |