1252 lines
27 KiB
C++
1252 lines
27 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbLineSegStairDraw.h"
|
|
#include "AecDbLineSegStair.h"
|
|
#include "AecDbEarthWorm.h"
|
|
#include "AcDbX3dSolid.h"
|
|
#include "EarThwormDef.h"
|
|
#include "CoreTools.h"
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
DLLIMPEXP AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
|
|
DLLIMPEXP AcDb3dPolyline* Format3dPolyline(const AcGePoint3dArray& arPts);
|
|
|
|
ACRX_CONS_DEFINE_MEMBERS(AecDbLineSegStairDraw,AecDbXDraw,0);
|
|
|
|
namespace
|
|
{
|
|
AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
|
|
, const AcGeVector3d& vtZ
|
|
, const double& dR)
|
|
{
|
|
AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
|
|
AcDbRegion* pReg = CoreTools::createRegion(pCir);
|
|
DELETE_PTR(pCir);
|
|
return pReg;
|
|
}
|
|
}
|
|
|
|
AecDbLineSegStairDraw::AecDbLineSegStairDraw(void)
|
|
{
|
|
}
|
|
|
|
AecDbLineSegStairDraw::~AecDbLineSegStairDraw(void)
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
const AecDbObjXDataMap* pXDataMap = GetSpecialtyData();
|
|
if (pXDataMap == NULL)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDbEntity* pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
|
|
if (pBaseStair == NULL)
|
|
return Acad::eOk;
|
|
|
|
LineStair data;
|
|
pBaseStair->GetLineStairData(data);
|
|
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
|
|
Adesk::UInt16 nCrBk = 256;
|
|
nCrBk = pEntReal->colorIndex();
|
|
dc.SetLayer(pEntReal->layerId());
|
|
|
|
int nColor = nCrBk;
|
|
if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
else
|
|
dc.SetColor(pEntReal->colorIndex());
|
|
|
|
AcDbCurve* pBaseCurve = pBaseStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)//路径
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
ptSta.z = ptEnd.z = 0.0;
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGeVector3d vtV = ptEnd - ptSta;
|
|
AcGeVector3d vtL = vtV;
|
|
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtV.normalize();
|
|
|
|
vtL.normalize();
|
|
ptEnd = ptSta + vtL * dLx;
|
|
|
|
//左线
|
|
AcGePoint3d ptGe[5];
|
|
ptGe[0] = ptSta;
|
|
ptGe[0] += vtV * 0.5 * data.dW;
|
|
|
|
ptGe[1] = ptEnd;
|
|
ptGe[1] += vtV * 0.5 * data.dW;
|
|
|
|
ptGe[2] = ptGe[1];
|
|
ptGe[2] -= vtV * data.dSidet;
|
|
|
|
ptGe[3] = ptGe[0];
|
|
ptGe[3] -= vtV * data.dSidet;
|
|
|
|
ptGe[4] = ptGe[0];
|
|
|
|
//1.两侧边
|
|
AcDbPolyline* pPl = NULL;
|
|
pPl = FormatPolyline(ptGe,data.bLBeam ? 5 : 2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(pEntReal->colorIndex());
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
|
|
for (int i = 0;i < 5;i++)
|
|
{
|
|
ptGe[i] -= vtV * (data.dW -data.dSidet);
|
|
}
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
pPl = FormatPolyline(ptGe,5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(pEntReal->colorIndex());
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptGe[0] = ptGe[3];
|
|
ptGe[1] = ptGe[2];
|
|
pPl = FormatPolyline(ptGe,2);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(pEntReal->colorIndex());
|
|
dc.DrawEntity(pPl);
|
|
dc.Add2dBuffer(pPl);
|
|
}
|
|
}
|
|
|
|
//2.内部踏板投影
|
|
//垂直高
|
|
double dH = data.dTopEl - data.dBomEl;
|
|
|
|
//踏步数
|
|
int nCount = data.nSteepS;
|
|
|
|
ptGe[0] = ptSta;
|
|
ptGe[0] += vtV * 0.5 * data.dW;
|
|
if (data.bLBeam)
|
|
ptGe[0] -= vtV * data.dSidet;
|
|
|
|
ptGe[1] = ptSta;
|
|
ptGe[1] -= vtV * 0.5 * data.dW;
|
|
if (data.bRBeam)
|
|
ptGe[1] += vtV * data.dSidet;
|
|
|
|
AcDbLine* pLn = NULL;
|
|
vtL.normalize();
|
|
for (int i = 0;i < nCount;i++)
|
|
{
|
|
ptGe[0] += vtL * data.dSteepW;
|
|
ptGe[1] += vtL * data.dSteepW;
|
|
|
|
pLn = new AcDbLine;
|
|
pLn->setStartPoint(ptGe[0]);
|
|
pLn->setEndPoint(ptGe[1]);
|
|
|
|
dc.DrawEntity(pLn);
|
|
dc.Add2dBuffer(pLn);
|
|
}
|
|
|
|
//绘制增高方向线 ----->
|
|
pLn = new AcDbLine;
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
pLn->setColorIndex(kRed);
|
|
dc.DrawEntity(pLn);
|
|
dc.Add2dBuffer(pLn);
|
|
|
|
ptSta = ptEnd;
|
|
vtL.normalize();
|
|
ptSta -= vtL * 0.25 * data.dSteepW;
|
|
ptSta += vtV * 0.25 * data.dSteepW;
|
|
pLn = new AcDbLine;
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
pLn->setColorIndex(kRed);
|
|
dc.DrawEntity(pLn);
|
|
dc.Add2dBuffer(pLn);
|
|
|
|
ptSta = ptEnd;
|
|
vtV.normalize();
|
|
ptSta -= vtL * 0.25 * data.dSteepW;
|
|
ptSta -= vtV * 0.25 * data.dSteepW;
|
|
pLn = new AcDbLine;
|
|
pLn->setStartPoint(ptSta);
|
|
pLn->setEndPoint(ptEnd);
|
|
pLn->setColorIndex(kRed);
|
|
dc.DrawEntity(pLn);
|
|
dc.Add2dBuffer(pLn);
|
|
}
|
|
|
|
dc.SetColor(nCrBk);
|
|
dc.SetLayer(idCurLay);
|
|
dc.SetLineType(idCurLty);
|
|
|
|
delete pBaseCurve;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
del3DCache<AecDbLineSegStair>();
|
|
const AecDbObjXDataMap* pXDataMap = GetSpecialtyData();
|
|
if (pXDataMap == NULL)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDbEntity* pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
|
|
if (pBaseStair == NULL)
|
|
return Acad::eOk;
|
|
|
|
AcDbObjectId idCurLay = dc.GetLayerId();
|
|
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
|
|
|
Adesk::UInt16 nCrBk = 256;
|
|
nCrBk = pEntReal->colorIndex();
|
|
dc.SetLayer(pEntReal->layerId());
|
|
|
|
int nColor = nCrBk;
|
|
if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
else
|
|
dc.SetColor(pEntReal->colorIndex());
|
|
|
|
LineStair data;
|
|
pBaseStair->GetLineStairData(data);
|
|
|
|
AcDbCurve* pBaseCurve = pBaseStair->GetBaseCurve();
|
|
if (pBaseCurve != NULL)//路径
|
|
{
|
|
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptEnd;
|
|
ptSta = pLn->startPoint();
|
|
ptEnd = pLn->endPoint();
|
|
|
|
ptSta.z = data.dBomEl;
|
|
ptEnd.z = data.dTopEl;
|
|
|
|
DrawSide3d(dc,ptSta,ptEnd,data);
|
|
|
|
if (data.bSlope)//坡道
|
|
{
|
|
DrawSlope3d(dc,ptSta,ptEnd,data);
|
|
}
|
|
else
|
|
{
|
|
DrawSteep3d(dc,ptSta,ptEnd,data);
|
|
}
|
|
|
|
//DrawGuardBar3d(dc,ptSta,ptEnd,data);
|
|
|
|
DrawSlopeBase(dc,ptSta,ptEnd,data);
|
|
|
|
DrawHandRail(dc, ptSta, ptEnd, data);
|
|
}
|
|
}
|
|
|
|
dc.SetColor(nCrBk);
|
|
dc.SetLayer(idCurLay);
|
|
dc.SetLineType(idCurLty);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawSide3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
|
|
{
|
|
if (data.bLBeam || data.bRBeam)
|
|
{
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总长
|
|
double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁
|
|
|
|
AcGePoint3d ptV,ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
for(int i = 0;i < nCount-1;i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
//arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
if (i == (nCount - 2))//只需最后踏步上位点
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0,vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln3d.intersectWith(lnEnd,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
//闭合
|
|
arSecPts.append(arSecPts.first());
|
|
|
|
AcGePoint3d ptGe[5];
|
|
ptGe[0] = arSecPts.at(0);
|
|
ptGe[1] = arSecPts.at(1);
|
|
|
|
vtUp = ptGe[1] - ptGe[0];
|
|
ptGe[2] = ptInt + vtUp;
|
|
ptGe[3] = ptInt;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptGe[1]);
|
|
ln.setEndPoint(ptGe[1] + vtW * data.dSidet);
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,5);
|
|
if (pReg != NULL)
|
|
{
|
|
//TEST
|
|
//AcDbEntity* pRegCln = (AcDbEntity*)pReg->clone();
|
|
//pRegCln->setColorIndex(4);
|
|
//CoreTools::CloneAndAddToModelSpace(pRegCln);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if ( xSolid.CreateExtrude(pReg,ln) )
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
if (data.bLBeam)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
}
|
|
|
|
AcGeMatrix3d xform;
|
|
vtW *= (data.dW - data.dSidet);
|
|
xform.setTranslation(vtW);
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
|
|
if (pOtherSide != NULL)
|
|
{
|
|
pOtherSide->transformBy(xform);
|
|
dc.DrawEntity(pOtherSide);
|
|
dc.Add3dBuffer(pOtherSide);
|
|
xSolid.TransformBy(xform);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
if (!data.bLBeam && pSolid != NULL)
|
|
delete pSolid;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawSteep3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
|
|
{
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总宽
|
|
double dSteepL = data.dW;
|
|
|
|
AcGePoint3d ptV,ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
if (data.bLBeam)
|
|
ptV += vtW * 120.0;//变量宽,国家标准120
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
for(int i = 0;i < nCount-1;i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0,vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
int nLast = arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln3d.intersectWith(lnEnd,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
AcGePoint3d& ptT = arSecPts.first();
|
|
//<--[AAA]
|
|
if (!data.bShowInSlab3d)
|
|
{
|
|
ptT.z = ptSta.z;
|
|
AcGeLine3d lnBxy;
|
|
lnBxy.set(ptT,vtLXY);
|
|
|
|
if ( lnBxy.intersectWith(ln3d,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
}
|
|
//闭合
|
|
arSecPts.append(ptT);
|
|
|
|
//测试
|
|
//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
|
|
//pPl->setColorIndex(3);
|
|
//CoreTools::AddToModelSpace(pPl);
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts.asArrayPtr(),arSecPts.length());
|
|
if (pReg != NULL)
|
|
{
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptV0);
|
|
|
|
if (data.bLBeam)
|
|
ptV = ptV0 + vtW * (dSteepL - 120.0);
|
|
else
|
|
ptV = ptV0 + vtW * dSteepL;
|
|
|
|
if (data.bRBeam)
|
|
ptV -= vtW * 120.0;//变梁宽,国标120
|
|
|
|
lnPath.setEndPoint(ptV);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if ( xSolid.CreateExtrude(pReg,lnPath) )
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawSlope3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
|
|
{
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总宽
|
|
double dSteepL = data.dW;
|
|
|
|
AcGePoint3d ptV,ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
AcGePoint3dArray arSecPts2;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
if (data.bLBeam)
|
|
ptV += vtW * 120.0;//变量宽,国家标准120
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
arSecPts2.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
AcGePoint3d ptv2 = ptV;
|
|
ptv2.z -= (data.dSteepW - data.dSteepH);
|
|
arSecPts2.append(ptv2);
|
|
|
|
for(int i = 0;i < nCount-1;i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV);
|
|
arSecPts2.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0,vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
int nLast = arSecPts2.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln3d.intersectWith(lnEnd,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
arSecPts2.append(ptInt);
|
|
|
|
//闭合
|
|
arSecPts.append(arSecPts.first());
|
|
arSecPts2.append(arSecPts2.first());
|
|
|
|
if (data.bNonslip)
|
|
{
|
|
AcGePoint3dArray arSectPts3;
|
|
arSectPts3.append(arSecPts2.first());
|
|
|
|
AcGePoint3d ptBk;
|
|
for(int i = 1;i < nLast;i++)
|
|
{
|
|
if ( (i % 2) == 0)
|
|
{
|
|
AcGePoint3d& pTmp = arSecPts2.at(i);
|
|
ptBk = pTmp;
|
|
pTmp.z += 10;
|
|
arSectPts3.append(pTmp);
|
|
arSectPts3.append(ptBk);
|
|
}
|
|
else
|
|
{
|
|
arSectPts3.append(arSecPts2.at(i));
|
|
}
|
|
}
|
|
|
|
for(int i = nLast;i< arSecPts2.length();i++)
|
|
{
|
|
arSectPts3.append(arSecPts2.at(i));
|
|
}
|
|
arSecPts2.removeAll();
|
|
arSecPts2.append(arSectPts3);
|
|
}
|
|
|
|
//测试
|
|
//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
|
|
//pPl->setColorIndex(3);
|
|
//CoreTools::AddToModelSpace(pPl);
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts2.asArrayPtr(),arSecPts2.length());
|
|
if (pReg != NULL)
|
|
{
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptV0);
|
|
|
|
if (data.bLBeam)
|
|
ptV = ptV0 + vtW * (dSteepL - 120.0);
|
|
else
|
|
ptV = ptV0 + vtW * dSteepL;
|
|
|
|
if (data.bRBeam)
|
|
ptV -= vtW * 120.0;//变梁宽,国标120
|
|
|
|
lnPath.setEndPoint(ptV);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if ( xSolid.CreateExtrude(pReg,lnPath) )
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawGuardBar3d(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
|
|
{
|
|
AcDbEntity* pEntReal = GetAttach();
|
|
if (pEntReal == NULL)
|
|
return Acad::eOk;
|
|
|
|
AecDbBaseStair* pBaseStair = AecDbBaseStair::cast(pEntReal);
|
|
if (pBaseStair == NULL)
|
|
return Acad::eOk;
|
|
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总长
|
|
double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁
|
|
|
|
AcGePoint3d ptV,ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
//插入楼板的点 [AAA]
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
for(int i = 0;i < nCount-1;i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
//arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
if (i == (nCount - 2))//只需最后踏步上位点
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
vtL = vtUp;
|
|
vtL.normalize();
|
|
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0,vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln3d.intersectWith(lnEnd,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
//闭合
|
|
arSecPts.append(arSecPts.first());
|
|
|
|
dL = ptInt.distanceTo(arSecPts.last());
|
|
|
|
ptEnd = arSecPts.at(2);
|
|
vtL = vtUp;
|
|
vtL.normalize();
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
double dH = data.bar.dH;
|
|
double dH1 = data.bar.dH1;
|
|
int nCols = (int)( dL / data.bar.dP + 0.5);
|
|
|
|
AcGePoint3d ptGe[3];
|
|
ptGe[0] = ptSta;
|
|
ptGe[0] -= vtW * 0.5 * (data.dW - data.dSidet);
|
|
ptGe[1] = ptGe[0] + AcGeVector3d::kZAxis * dH1;
|
|
ptGe[2] = ptGe[0] + AcGeVector3d::kZAxis * dH;
|
|
|
|
//上升2个直径
|
|
ptGe[0] += vtL * 2.0 * data.bar.dD;
|
|
ptGe[1] += vtL * 2.0 * data.bar.dD;
|
|
ptGe[2] += vtL * 2.0 * data.bar.dD;
|
|
|
|
AcGePoint3d ptGeFrL[3],ptGeFrR[3],ptGeR[3];
|
|
memcpy(ptGeFrL,ptGe,sizeof(AcGePoint3d) * 3);
|
|
|
|
memcpy(ptGeFrR,ptGe,sizeof(AcGePoint3d) * 3);
|
|
for (int k = 0;k < 3;k++)
|
|
{
|
|
ptGeFrR[k] += vtW * (data.dW - data.dSidet);
|
|
}
|
|
|
|
AcDbLine ln;
|
|
AcDbEntity* pEnt3d = NULL;
|
|
AcDbRegion* pRegCln = NULL;
|
|
|
|
AcGePoint3d ptGe0T;
|
|
AcDbX3dSolid xSolid;
|
|
//左边
|
|
for(int i = 0;i <= nCols;i++)
|
|
{
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGe[0]);
|
|
ln.setEndPoint(ptGe[2]);
|
|
|
|
if (data.bLBeam)
|
|
{
|
|
AcGeMatrix3d mat;
|
|
AcGeVector3d vtSE = (AcGePoint3d::kOrigin - ptGe[0]).normalize();
|
|
mat.setTranslation(vtSE);
|
|
pRegCln->transformBy(mat);
|
|
|
|
AcDbRegion* pRegLeft = (AcDbRegion*)pRegCln->clone();
|
|
pRegLeft->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pRegLeft);
|
|
AcDbLine* pLnLeft = (AcDbLine*)(&ln)->clone();
|
|
pLnLeft->setColorIndex(6);
|
|
CoreTools::AddToModelSpace(pLnLeft);
|
|
|
|
if (xSolid.CreateExtrude(pRegCln, ln))
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (!pSolid)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
pSolid->transformBy(mat);
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
}
|
|
|
|
/*pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}*/
|
|
}
|
|
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
|
|
//右边
|
|
memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
|
|
for (int k = 0;k < 3;k++)
|
|
{
|
|
ptGeR[k] += vtW * (data.dW - data.dSidet);
|
|
}
|
|
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGeR[0]);
|
|
ln.setEndPoint(ptGeR[2]);
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}
|
|
}
|
|
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
|
|
ptGe[0] += vtL * data.bar.dP;
|
|
ptGe[1] += vtL * data.bar.dP;
|
|
ptGe[2] += vtL * data.bar.dP;
|
|
}
|
|
|
|
//倒退一列
|
|
ptGe[0] -= vtL * data.bar.dP;
|
|
ptGe[1] -= vtL * data.bar.dP;
|
|
ptGe[2] -= vtL * data.bar.dP;
|
|
|
|
//斜边 左侧
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGeFrL[1]);
|
|
ln.setEndPoint(ptGe[1]);
|
|
|
|
if (data.bLBeam)
|
|
{
|
|
pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}
|
|
}
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGeFrL[2]);
|
|
ln.setEndPoint(ptGe[2]);
|
|
|
|
if (data.bLBeam)
|
|
{
|
|
pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}
|
|
}
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
|
|
//斜边右侧
|
|
memcpy(ptGeR,ptGe,sizeof(AcGePoint3d) * 3);
|
|
for (int k = 0;k < 3;k++)
|
|
{
|
|
ptGeR[k] += vtW * (data.dW - data.dSidet);
|
|
}
|
|
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGeFrR[1]);
|
|
ln.setEndPoint(ptGeR[1]);
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}
|
|
}
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
|
|
pRegCln = pBaseStair->GetSection();
|
|
if (pRegCln != NULL)
|
|
{
|
|
ln.setStartPoint(ptGeFrR[2]);
|
|
ln.setEndPoint(ptGeR[2]);
|
|
|
|
if (data.bRBeam)
|
|
{
|
|
pEnt3d = dc.DrawPipe(&ln,pRegCln,AcGePoint3d::kOrigin);
|
|
if (pEnt3d != NULL)
|
|
{
|
|
pEnt3d->setColorIndex(3);
|
|
dc.Add3dBuffer(pEnt3d);
|
|
}
|
|
}
|
|
delete pRegCln;
|
|
pRegCln = NULL;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawSlopeBase(AcGiDraw &dc,const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const LineStair& data) const
|
|
{
|
|
if (!data.bSlopeBase)
|
|
return Acad::eOk;
|
|
|
|
AcGePoint3d ptSta = ptFr;
|
|
AcGeVector3d vtL = ptTo - ptFr;
|
|
vtL.normalize();
|
|
|
|
double dLx = data.nSteepS * data.dSteepW;
|
|
double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
|
|
double dL = sqrt(dLx * dLx + dLh * dLh);
|
|
|
|
AcGePoint3d ptEnd = ptSta + vtL * dL;
|
|
|
|
AcGeVector3d vtLXY = vtL;
|
|
vtLXY.z = 0.0;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
|
|
vtL.normalize();
|
|
vtLXY.normalize();
|
|
|
|
AcGeVector3d vtW = vtLXY;
|
|
vtW.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtW.normalize();
|
|
|
|
//踏步左右总宽
|
|
double dSteepL = data.dW;
|
|
|
|
AcGePoint3d ptV,ptV0;
|
|
AcGePoint3dArray arSecPts;
|
|
|
|
ptV = ptSta;
|
|
ptV -= vtW * 0.5 * dSteepL;
|
|
|
|
//if (data.bLBeam)
|
|
//ptV += vtW * 120.0;//变量宽,国家标准120
|
|
|
|
//插入楼板的点 [AAA]
|
|
//if (data.bShowInSlab3d)
|
|
ptV.z -= (data.dSteepW - data.dSteepH);
|
|
|
|
ptV0 = ptV;
|
|
arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepW;//第一层等边直角
|
|
arSecPts.append(ptV);
|
|
|
|
for(int i = 0;i < nCount-1;i++)
|
|
{
|
|
ptV += vtLXY * data.dSteepW;
|
|
//arSecPts.append(ptV);
|
|
|
|
ptV.z += data.dSteepH;
|
|
arSecPts.append(ptV);
|
|
}
|
|
|
|
AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
|
|
AcGeLine3d ln3d;
|
|
ln3d.set(ptV0,vtUp);
|
|
|
|
AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
|
|
arSecPts.append(ptV1);
|
|
|
|
AcGeLine3d lnEnd;
|
|
lnEnd.set(ptV1,AcGeVector3d::kZAxis);
|
|
|
|
AcGePoint3d ptInt;
|
|
if ( ln3d.intersectWith(lnEnd,ptInt) )
|
|
{
|
|
arSecPts.append(ptInt);
|
|
|
|
//闭合
|
|
arSecPts.append(arSecPts.first());
|
|
|
|
AcGePoint3d ptGe[4];
|
|
ptGe[0] = arSecPts.first();
|
|
ptGe[1] = ptInt;
|
|
ptGe[2] = ptGe[0] + vtLXY * data.nSteepS * data.dSteepW;
|
|
ptGe[3] = ptGe[0];
|
|
|
|
AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe,4);
|
|
if (pReg != NULL)
|
|
{
|
|
AcDbLine lnPath;
|
|
lnPath.setStartPoint(ptV0);
|
|
ptV = ptV0 + vtW * dSteepL;
|
|
lnPath.setEndPoint(ptV);
|
|
|
|
AcDbX3dSolid xSolid;
|
|
if ( xSolid.CreateExtrude(pReg,lnPath) )
|
|
{
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
return Acad::eOk;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbLineSegStairDraw::DrawHandRail(AcGiDraw& dc, const AcGePoint3d& ptFr, const AcGePoint3d& ptTo, const LineStair& data) const
|
|
{
|
|
if (!data.bGuardBar)
|
|
return Acad::eOk;
|
|
|
|
//一共多少步
|
|
int nCount = data.nSteepS;
|
|
//踏步左右总长
|
|
double dSteepL = (data.dW/* - 2.0 * data.dSidet*/);//无论左右有无梁
|
|
|
|
AcGePoint3d ptGe[10];
|
|
ptGe[0] = ptFr;
|
|
ptGe[1] = ptTo;
|
|
///ptGe[0].z = 0;
|
|
///ptGe[1].z = 0;
|
|
AcGeVector3d vt = (ptGe[0] - ptGe[1]).normalize();
|
|
vt.z = 0;
|
|
vt.normalize();
|
|
|
|
AcGeVector3d vtDir(vt), Z(AcGeVector3d::kZAxis);
|
|
vtDir.rotateBy(-PI / 2.0, Z);
|
|
vtDir.normalize();
|
|
|
|
ptGe[2] = ptGe[0] + Z * data.dSteepH;
|
|
ptGe[3] = ptGe[2] - vt * data.dSteepW;
|
|
ptGe[3] += Z * data.dSteepH;
|
|
AcGeVector3d vtHand = (ptGe[2] - ptGe[3]).normalize();
|
|
|
|
ptGe[4] = ptGe[2] - vt * data.dSteepW * .5;
|
|
ptGe[5] = ptGe[4] - vt * data.dSteepW * (nCount - 1);
|
|
ptGe[5] += Z * data.dSteepH * (nCount - 1);
|
|
double dLen = ptGe[4].distanceTo(ptGe[5]);
|
|
int nStairsNum = (int)(dLen / data.bar.dP + 0.5);
|
|
|
|
AcGePoint3dArray arPtsHandRail, arPtsRail;
|
|
arPtsHandRail.removeAll();
|
|
arPtsRail.removeAll();
|
|
|
|
arPtsRail.append(ptGe[4]);
|
|
|
|
AcGePoint3d ptRail;
|
|
ptRail = ptGe[0] - vt * data.dSteepW * .5;
|
|
ptRail += Z * data.dSteepH;
|
|
for (int i = 0; i < nStairsNum-1; i++)//nStairsNum-1最后短节去掉
|
|
{
|
|
ptRail -= vtHand * data.bar.dP;
|
|
arPtsRail.append(ptRail);
|
|
}
|
|
arPtsRail.append(ptGe[5]);
|
|
|
|
AcGeMatrix3d mat;
|
|
AcDbX3dSolid xSolid;
|
|
// 栏杆
|
|
for (int i(0); i < arPtsRail.length(); ++i)
|
|
{
|
|
ptRail = arPtsRail.at(i);
|
|
AcDbLine* pLn = new AcDbLine(ptRail, ptRail + Z * data.bar.dH);
|
|
AcDbRegion* pReg = makeCircleRegion(ptRail, Z, data.bar.dD * .5);
|
|
if (xSolid.CreateExtrude(pReg, *pLn))
|
|
{
|
|
DELETE_PTR(pReg);
|
|
DELETE_PTR(pLn);
|
|
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (!pSolid)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
mat.setToIdentity();
|
|
mat.setToTranslation(vtDir * (dSteepL - data.dSidet) * .5);
|
|
pSolid->transformBy(mat);
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
|
|
AcDb3dSolid* pSolidNew = (AcDb3dSolid*)pSolid->clone();
|
|
mat.setToIdentity();
|
|
mat.setToTranslation(vtDir * -(dSteepL - data.dSidet));
|
|
pSolidNew->transformBy(mat);
|
|
if (!pSolidNew)
|
|
{
|
|
DELETE_PTR(pSolid);
|
|
return Acad::eOk;
|
|
}
|
|
dc.DrawEntity(pSolidNew);
|
|
dc.Add3dBuffer(pSolidNew);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
}
|
|
}
|
|
|
|
// 扶手
|
|
ptGe[6] = ptGe[4] + Z * data.bar.dH;
|
|
ptGe[6] += vtDir * (dSteepL - data.dSidet) * .5;
|
|
ptGe[7] = ptGe[5] + Z * data.bar.dH;
|
|
ptGe[7] += vtDir * (dSteepL - data.dSidet) * .5;
|
|
AcDbLine* pLn = new AcDbLine(ptGe[6], ptGe[7]);
|
|
AcGeVector3d vtHandRail = (ptGe[6] - ptGe[7]).normalize();
|
|
AcDbRegion* pReg = makeCircleRegion(ptGe[6], vtHandRail, data.bar.dD * .5);
|
|
if (xSolid.CreateExtrude(pReg, *pLn))
|
|
{
|
|
DELETE_PTR(pReg);
|
|
DELETE_PTR(pLn);
|
|
|
|
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
|
if (!pSolid)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
dc.DrawEntity(pSolid);
|
|
dc.Add3dBuffer(pSolid);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
|
|
AcDb3dSolid* pSolidNew = (AcDb3dSolid*)pSolid->clone();
|
|
if (!pSolidNew)
|
|
{
|
|
DELETE_PTR(pSolid);
|
|
return Acad::eOk;
|
|
}
|
|
mat.setToIdentity();
|
|
mat.setToTranslation(vtDir * -(dSteepL - data.dSidet));
|
|
pSolidNew->transformBy(mat);
|
|
dc.DrawEntity(pSolidNew);
|
|
dc.Add3dBuffer(pSolidNew);
|
|
add3DCache<AecDbLineSegStair>(&xSolid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|