2010 lines
39 KiB
C++
2010 lines
39 KiB
C++
#include "stdafx.h"
|
||
#include "AecDbArcSegStairDraw.h"
|
||
#include "AecDbArcSegStair.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(AecDbArcSegStairDraw,AecDbXDraw,0);
|
||
|
||
namespace
|
||
{
|
||
AcDbRegion* makeRectRegion(const AcGePoint3d& ptOrg
|
||
, const bool& bIsCenterPt
|
||
, const double& dL
|
||
, const double& dW
|
||
, const AcGeVector3d& vecL
|
||
, const AcGeVector3d& vecW
|
||
)
|
||
{
|
||
AcGePoint3d ptGe[5];
|
||
|
||
if (bIsCenterPt)
|
||
{
|
||
// ptOrg为矩形的中心点
|
||
ptGe[0] = ptOrg + vecW * dW * .5;
|
||
ptGe[0] += vecL * dL * .5;
|
||
ptGe[1] = ptGe[0] - vecW * dW;
|
||
ptGe[2] = ptGe[1] - vecL * dL;
|
||
ptGe[3] = ptGe[2] + vecW * dW;
|
||
}
|
||
else
|
||
{
|
||
// ptOrg为矩形的顶点
|
||
ptGe[0] = ptOrg - vecL * dL;
|
||
ptGe[1] = ptGe[0] - vecW * dW;
|
||
ptGe[2] = ptGe[1] + vecL * dL;
|
||
ptGe[3] = ptGe[2] + vecW * dW;
|
||
}
|
||
|
||
ptGe[4] = ptGe[0];
|
||
|
||
return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
||
}
|
||
|
||
// 通过两个点获取矩形截面
|
||
AcDbRegion* makeRectRegionByPts(const AcGePoint3d& ptL
|
||
, const AcGePoint3d& ptR
|
||
, const double& dL
|
||
, const double& dW
|
||
, const AcGeVector3d& vecL
|
||
, const AcGeVector3d& vecW
|
||
)
|
||
{
|
||
AcGePoint3d ptGe[5];
|
||
|
||
ptGe[0] = ptL;
|
||
ptGe[1] = ptR;
|
||
ptGe[2] = ptGe[1] - vecW * dW;
|
||
ptGe[3] = ptGe[2] + vecL * dL;
|
||
|
||
ptGe[4] = ptGe[0];
|
||
|
||
return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
||
}
|
||
|
||
AcDbRegion* makeCircleRegion(const AcGePoint3d& ptOrg
|
||
, const AcGeVector3d& vtZ
|
||
, const double& dR)
|
||
{
|
||
AcDbCircle* pCir(new AcDbCircle(ptOrg, vtZ, dR));
|
||
if (!pCir) return NULL;
|
||
|
||
return CoreTools::createRegion(pCir);
|
||
}
|
||
|
||
// 获取圆弧长度
|
||
double getArcLen(const AcDbArc* pArc)
|
||
{
|
||
AcGePoint3d ptE;
|
||
pArc->getEndPoint(ptE);
|
||
|
||
double dLen(.0);
|
||
pArc->getDistAtPoint(ptE, dLen);
|
||
|
||
return dLen;
|
||
}
|
||
|
||
// 2D 获取圆弧凸度
|
||
double getBulge(const AcDbArc* pArc)
|
||
{
|
||
double dStaAngle = pArc->startAngle();
|
||
double dEndAngle = pArc->endAngle();
|
||
double dAngleDiff = dEndAngle - dStaAngle;
|
||
// 终止角度小于起始角度
|
||
if (dAngleDiff < 0.0)
|
||
{
|
||
dAngleDiff = 2 * PI + dAngleDiff;
|
||
}
|
||
|
||
return tan(dAngleDiff / 4);
|
||
}
|
||
|
||
AcGePoint3d getRegCenter(AcDbRegion* pReg)
|
||
{
|
||
AcDbExtents ext;
|
||
pReg->getGeomExtents(ext);
|
||
AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
|
||
return ptCen;
|
||
}
|
||
|
||
// 2D 楼梯 多段线包含圆弧
|
||
AcDbPolyline* makePoly(const AcDbVoidPtrArray& CurveAr
|
||
, const double& dBulge
|
||
, const BOOL& bIsLine)
|
||
{
|
||
if (CurveAr.length() < 1) return NULL;
|
||
|
||
AcGePoint3d ptGe[5];
|
||
|
||
AcDbArc* pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc) return NULL;
|
||
pArc->getStartPoint(ptGe[0]);
|
||
pArc->getEndPoint(ptGe[1]);
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc) return NULL;
|
||
pArc->getEndPoint(ptGe[2]);
|
||
pArc->getStartPoint(ptGe[3]);
|
||
ptGe[4] = ptGe[0];
|
||
|
||
AcDbPolyline* pPoly = FormatPolyline(ptGe, 5);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return NULL;
|
||
}
|
||
|
||
if (!bIsLine) // 多段线包含圆弧
|
||
{
|
||
pPoly->setBulgeAt(0, dBulge);
|
||
pPoly->setBulgeAt(2, -dBulge);
|
||
}
|
||
|
||
return pPoly;
|
||
}
|
||
|
||
// 画楼梯 3D 截面为直线, 不包括圆弧
|
||
AcDbRegion* makeStairsReg(const AcDbVoidPtrArray& CurveAr, const double& dBulge)
|
||
{
|
||
if (CurveAr.length() < 1) return NULL;
|
||
|
||
AcGePoint3d ptGe[5];
|
||
|
||
AcDbArc* pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc) return NULL;
|
||
pArc->getStartPoint(ptGe[0]);
|
||
pArc->getEndPoint(ptGe[1]);
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc) return NULL;
|
||
pArc->getEndPoint(ptGe[2]);
|
||
pArc->getStartPoint(ptGe[3]);
|
||
ptGe[4] = ptGe[0];
|
||
|
||
return AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
||
}
|
||
|
||
AcDbCurve* makeOffsetArcByDir(AcDbCurve* pArc, const double& dOffset)
|
||
{
|
||
if (!pArc) return NULL;
|
||
|
||
AcDbVoidPtrArray ar;
|
||
pArc->getOffsetCurves(dOffset, ar);
|
||
if (ar.isEmpty()) return NULL;
|
||
|
||
AcDbCurve* pArcOff = (AcDbCurve*)(((AcDbEntity*)ar.first())->clone());
|
||
deleteArrayVoidPtrs<AcDbEntity>(ar);
|
||
|
||
return pArcOff;
|
||
}
|
||
|
||
// 通过截面获取拉伸体
|
||
void drawSolid(AcGiDraw& dc
|
||
, const AcDbRegion* pReg
|
||
, const double& dThick
|
||
, const double& dH
|
||
, const AcGeVector3d& vtThick
|
||
, const AcGeVector3d& vtH)
|
||
{
|
||
if (!pReg) return;
|
||
|
||
AcDbExtents ext;
|
||
pReg->getGeomExtents(ext);
|
||
AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
|
||
AcDbLine ln(ptCen, ptCen + vtThick * -dThick);
|
||
|
||
AcDbX3dSolid xSolid;
|
||
AcGeMatrix3d mat;
|
||
if (xSolid.CreateExtrude(pReg, ln) == FALSE) return;
|
||
AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
|
||
if (!pSolid) return;
|
||
mat.setTranslation(vtH * dH);
|
||
pSolid->transformBy(mat);
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
}
|
||
|
||
// 获取直线的中间点
|
||
AcGePoint3d getLineMidPt(AcDbLine* pLine)
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
pLine->getStartPoint(ptS);
|
||
pLine->getEndPoint(ptE);
|
||
double len = ptS.distanceTo(ptE);
|
||
AcGeVector3d vec = (ptS - ptE).normalize();
|
||
AcGePoint3d pt = ptS - vec * len / 2;
|
||
return pt;
|
||
}
|
||
|
||
// 获取直线的垂直向量
|
||
AcGeVector3d getLineVerVec(AcDbLine* pLine, const AcGeVector3d& vecNormal)
|
||
{
|
||
AcGePoint3d ptS, ptE;
|
||
pLine->getStartPoint(ptS);
|
||
pLine->getEndPoint(ptE);
|
||
AcGeVector3d vec = (ptS - ptE).normalize();
|
||
vec.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
||
vec.normalize();
|
||
return vec;
|
||
}
|
||
|
||
void getAveCurves(const AcDbArc* pArc
|
||
, AcDbVoidPtrArray* pArArc
|
||
, const SFPXStair& data)
|
||
{
|
||
int nCount = data.nSteepS;
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen = dLen / (nCount - 1);
|
||
|
||
AcGePoint3d ptC, pt;
|
||
ptC = pArc->center();
|
||
AcGeVector3d vec;
|
||
|
||
AcGePoint3dArray arPt3d;
|
||
arPt3d.removeAll();
|
||
AcGeVector3dArray acVec3d;
|
||
acVec3d.removeAll();
|
||
|
||
for (int i = 1; i < nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
arPt3d.append(pt);
|
||
vec = (pt - ptC).normalize();
|
||
acVec3d.append(vec);
|
||
}
|
||
|
||
pArc->getSplitCurves(arPt3d, *pArArc);
|
||
}
|
||
}
|
||
|
||
AecDbArcSegStairDraw::AecDbArcSegStairDraw(void)
|
||
{
|
||
}
|
||
|
||
AecDbArcSegStairDraw::~AecDbArcSegStairDraw(void)
|
||
{
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::Draw2d(AcGiDraw &dc) const
|
||
{
|
||
AcDbObjectId idCurLay = dc.GetLayerId();
|
||
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
||
AcDbEntity* pEntReal = GetAttach();
|
||
if (pEntReal == NULL)
|
||
return Acad::eOk;
|
||
|
||
AecDbArcSegStair* pStair = AecDbArcSegStair::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);
|
||
|
||
//.....
|
||
AcDbCurve* pBaseCurve = pStair->GetBaseCurve();//路径
|
||
if (!pBaseCurve) return Acad::eOk;
|
||
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
||
if (!pLn) return Acad::eOk;
|
||
|
||
/*AcDbLine* pLnTest = (AcDbLine*)pLn->clone();
|
||
if (!pLnTest) return Acad::eOk;
|
||
pLnTest->setColorIndex(6);
|
||
CoreTools::AddToModelSpace(pLnTest);
|
||
AcDbCircle* pCir = new AcDbCircle(pLn->startPoint(), AcGeVector3d::kZAxis, 50);
|
||
pCir->setColorIndex(6);
|
||
CoreTools::AddToModelSpace(pCir);*/
|
||
|
||
AcGePoint3d ptC;
|
||
ptC = pLn->startPoint();
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
|
||
ptC += Z * data.dBomEl;
|
||
|
||
AcDbVoidPtrArray CurveAr;
|
||
CurveAr.removeAll();
|
||
|
||
double dStaAngle(.0); // 起始角度
|
||
double dEndAngle(.0); // 终止角度
|
||
|
||
AcDbArc* pArc(NULL);
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
dStaAngle = CoreTools::A2R(data.dRestPtMW);
|
||
dEndAngle = CoreTools::A2R(data.dRestPtMW + data.dRestPtML);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtW, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtL, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
DrawUpStairs2d(dc, CurveAr, data.bLBeam, data.bRBeam, data);
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
dStaAngle = CoreTools::A2R(data.dRestPtMW - data.dRestPtML);
|
||
dEndAngle = CoreTools::A2R(data.dRestPtMW);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtW, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtL, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
DrawUpStairs2d(dc, CurveAr, data.bRBeam, data.bLBeam, data);
|
||
}
|
||
|
||
dc.SetColor(nCrBk);
|
||
dc.SetLayer(idCurLay);
|
||
dc.SetLineType(idCurLty);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::Draw3d(AcGiDraw &dc) const
|
||
{
|
||
AcDbObjectId idCurLay = dc.GetLayerId();
|
||
AcDbObjectId idCurLty = dc.GetLineTypeId();
|
||
AcDbEntity* pEntReal = GetAttach();
|
||
if (pEntReal == NULL)
|
||
return Acad::eOk;
|
||
|
||
AecDbArcSegStair* pStair = AecDbArcSegStair::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) return Acad::eOk;
|
||
AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
|
||
if (!pLn) return Acad::eOk;
|
||
|
||
AcGePoint3d ptC;
|
||
ptC = pLn->startPoint();
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
|
||
ptC += Z * data.dBomEl;
|
||
|
||
AcDbVoidPtrArray CurveAr;
|
||
CurveAr.removeAll();
|
||
|
||
double dStaAngle(.0); // 起始角度
|
||
double dEndAngle(.0); // 终止角度
|
||
|
||
AcDbArc* pArc(NULL);
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
dStaAngle = CoreTools::A2R(data.dRestPtMW);
|
||
dEndAngle = CoreTools::A2R(data.dRestPtMW + data.dRestPtML);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtW, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtL, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
dStaAngle = CoreTools::A2R(data.dRestPtMW - data.dRestPtML);
|
||
dEndAngle = CoreTools::A2R(data.dRestPtMW);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtW, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
|
||
pArc = new AcDbArc(ptC, Z, data.dRestPtL, dStaAngle, dEndAngle);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pBaseCurve);
|
||
return Acad::eOk;
|
||
}
|
||
CurveAr.append(pArc);
|
||
}
|
||
|
||
data.dSteepW = 270;
|
||
|
||
// 坡道用途
|
||
if (data.bOutSideHRail)
|
||
{
|
||
// 三角落地结构
|
||
if (data.nGShape)
|
||
{
|
||
DrawSide3d(dc, CurveAr, 120, 200, 200, data.nSteepS + 1, data);
|
||
}
|
||
else
|
||
{
|
||
DrawSide3d(dc, CurveAr, 120, 270, data.dSteepH, data.nSteepS + 1, data);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
DrawSide3d(dc, CurveAr, 120, 270, data.dSteepH, data.nSteepS, data);
|
||
}
|
||
DrawStairsAndSlope3d(dc, CurveAr, data);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawUpStairs2d(AcGiDraw& dc
|
||
, const AcDbVoidPtrArray& CurveAr
|
||
, const BOOL& bLBeam
|
||
, const BOOL& bRBeam
|
||
, const SFPXStair& data) const
|
||
{
|
||
if(CurveAr.length() < 1) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(6);
|
||
|
||
AcGePoint3d pt, ptC;
|
||
AcGeVector3d vec, Z(AcGeVector3d::kZAxis);
|
||
double dBulge(.0);
|
||
|
||
double dSide = 120;
|
||
|
||
AcDbArc* pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc) return Acad::eOk;
|
||
dBulge = getBulge(pArc);
|
||
AcDbPolyline* pPoly = makePoly(CurveAr, dBulge, FALSE);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
|
||
AcDbVoidPtrArray arArc;
|
||
arArc.removeAll();
|
||
arArc.append(pArc);
|
||
AcDbArc* pArcOff = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
if (!pArcOff)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
arArc.append(pArcOff);
|
||
if (bLBeam)
|
||
{
|
||
pPoly = makePoly(arArc, dBulge, FALSE);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
}
|
||
|
||
arArc.removeAll();
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
arArc.append(pArc);
|
||
pArcOff = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
if (!pArcOff)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
arArc.append(pArcOff);
|
||
if (bRBeam)
|
||
{
|
||
pPoly = makePoly(arArc, dBulge, FALSE);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
}
|
||
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen(.0);
|
||
|
||
int i(0);
|
||
int nCount = data.nSteepS;
|
||
double dSteepL = data.dRestPtL - data.dRestPtW;
|
||
|
||
arArc.removeAll();
|
||
|
||
AcGePoint3dArray arPt3d;
|
||
arPt3d.removeAll();
|
||
AcGeVector3dArray acVec3d;
|
||
acVec3d.removeAll();
|
||
AcDbVoidPtrArray arArcSpilt;
|
||
arArcSpilt.removeAll();
|
||
|
||
if (data.bOutSideHRail)
|
||
{
|
||
if (data.bDimUpstair)
|
||
{
|
||
dAveLen = dLen / nCount;
|
||
for (i = 1; i <= nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
arPt3d.append(pt);
|
||
vec = (pt - ptC).normalize();
|
||
acVec3d.append(vec);
|
||
}
|
||
|
||
pArc->getSplitCurves(arPt3d, arArc);
|
||
for (i = 0; i < arArc.length(); ++i)
|
||
{
|
||
pArc = (AcDbArc*)arArc.at(i);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dBulge = getBulge(pArc);;
|
||
pArcOff = (AcDbArc*)makeOffsetArcByDir(pArc, -dSteepL);
|
||
if (!pArcOff)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
arArcSpilt.removeAll();
|
||
arArcSpilt.append(pArc);
|
||
arArcSpilt.append(pArcOff);
|
||
pPoly = makePoly(arArcSpilt, dBulge, FALSE);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dAveLen = dLen / (nCount - 1);
|
||
for (i = 1; i < nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
arPt3d.append(pt);
|
||
vec = (pt - ptC).normalize();
|
||
acVec3d.append(vec);
|
||
}
|
||
|
||
pArc->getSplitCurves(arPt3d, arArc);
|
||
for (i = 0; i < arArc.length(); ++i)
|
||
{
|
||
pArc = (AcDbArc*)arArc.at(i);
|
||
if (!pArc)
|
||
{
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dBulge = getBulge(pArc);
|
||
pArcOff = (AcDbArc*)makeOffsetArcByDir(pArc, -dSteepL);
|
||
if (!pArcOff)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
arArcSpilt.removeAll();
|
||
arArcSpilt.append(pArc);
|
||
arArcSpilt.append(pArcOff);
|
||
pPoly = makePoly(arArcSpilt, dBulge, FALSE);
|
||
if (!pPoly)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pArcOff);
|
||
return Acad::eOk;
|
||
}
|
||
dc.DrawEntity(pPoly);
|
||
dc.Add2dBuffer(pPoly);
|
||
}
|
||
}
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawUpStairs3d(AcGiDraw& dc
|
||
, const AcDbVoidPtrArray& CurveAr
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (CurveAr.length() < 1) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
int i(0);
|
||
|
||
//一共多少步
|
||
int nCount(data.nSteepS);
|
||
double dSide(120);
|
||
|
||
AcDbVoidPtrArray arArcSpilt;
|
||
arArcSpilt.removeAll();
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
double dBulge(.0), dH(.0);
|
||
AcDbRegion* pReg(NULL);
|
||
AcDbArc* pArc(NULL);
|
||
|
||
AcDbVoidPtrArray arArcL, arArcR;
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
|
||
arArcL.removeAll();
|
||
arArcR.removeAll();
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
getAveCurves(pArc, &arArcL, data);
|
||
if (arArcL.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
getAveCurves(pArc, &arArcR, data);
|
||
if (arArcR.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
for (i = 0; i < arArcL.length(); ++i)
|
||
{
|
||
arArcSpilt.removeAll();
|
||
|
||
arArcSpilt.append(arArcL.at(i));
|
||
arArcSpilt.append(arArcR.at(i));
|
||
|
||
dBulge = getBulge((AcDbArc*)arArcR.at(i));
|
||
|
||
pReg = makeStairsReg(arArcSpilt, dBulge);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
dH = dH + data.dSteepH;
|
||
drawSolid(dc, pReg, data.dSteepH, dH, Z, Z);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
|
||
arArcL.removeAll();
|
||
arArcR.removeAll();
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
getAveCurves(pArc, &arArcL, data);
|
||
if (arArcL.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
getAveCurves(pArc, &arArcR, data);
|
||
if (arArcR.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
for (i = arArcL.length() - 1; i >= 0; --i)
|
||
{
|
||
arArcSpilt.removeAll();
|
||
|
||
arArcSpilt.append(arArcL.at(i));
|
||
arArcSpilt.append(arArcR.at(i));
|
||
|
||
dBulge = getBulge((AcDbArc*)arArcR.at(i));
|
||
|
||
pReg = makeStairsReg(arArcSpilt, dBulge);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
dH = dH + data.dSteepH;
|
||
drawSolid(dc, pReg, data.dSteepH, dH, Z, Z);
|
||
}
|
||
}
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawRail3d(AcGiDraw& dc
|
||
, const AcDbArc* pArc
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (!pArc) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis), vec;
|
||
int i(0);
|
||
|
||
// 一共多少步
|
||
int nCount = data.nSteepS;
|
||
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen = dLen / ((nCount - 1) * 2);
|
||
double dH(.0);
|
||
AcGePoint3d pt, pt1, pt2;
|
||
AcDbRegion* pReg(NULL);
|
||
AcDbLine* pLine;
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
for (i = 1; i < (nCount - 1) * 2; i = i + 2)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
|
||
dH += data.dSteepH;
|
||
pt += Z * dH;
|
||
|
||
pReg = makeCircleRegion(pt, Z, data.dGarSize[0] * .5);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
drawSolid(dc, pReg, -data.dBarH, .0, Z, Z);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
for (i = (nCount - 1) * 2 - 1; i > 0; i = i - 2)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
|
||
dH += data.dSteepH;
|
||
pt += Z * dH;
|
||
|
||
pReg = makeCircleRegion(pt, Z, data.dGarSize[0] * .5);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
drawSolid(dc, pReg, -data.dBarH, .0, Z, Z);
|
||
}
|
||
}
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawHandRail3d(AcGiDraw& dc
|
||
, const AcDbArc* pArc
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (!pArc) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis), vt;
|
||
int i(0);
|
||
|
||
// 一共多少步
|
||
int nCount = data.nSteepS;
|
||
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen = dLen / ((nCount - 1) * 2);
|
||
double dH(.0);
|
||
AcGePoint3d pt, pt1, pt2, ptC;
|
||
AcDbLine* pLine(NULL);
|
||
AcGePoint3dArray arPts;
|
||
arPts.removeAll();
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
for (i = 0; i < ((nCount - 1) * 2); ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
|
||
dH += data.dSteepH * .5;
|
||
pt += Z * dH;
|
||
|
||
arPts.append(pt);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
for (i = ((nCount - 1) * 2); i >= 0; --i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
|
||
dH += data.dSteepH * .5;
|
||
pt += Z * dH;
|
||
//dH += data.dSteepH * .5;
|
||
|
||
arPts.append(pt);
|
||
}
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbSpline* pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbSweepOptions op;
|
||
op.setAlign(AcDbSweepOptions::kNoAlignment);
|
||
op.setMiterOption(AcDbSweepOptions::kDefaultMiter);
|
||
vt = (arPts[1] - arPts[0]).normalize();
|
||
AcDbRegion* pReg = makeCircleRegion(arPts[0], vt, data.dGarSize[0] * .5);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
Acad::ErrorStatus es = pSolid->createSweptSolid(pReg, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pLine);
|
||
DELETE_PTR(pSpline);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcGeMatrix3d mat;
|
||
mat.setTranslation(Z * data.dBarH);
|
||
pSolid->transformBy(mat);
|
||
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawSide3d(AcGiDraw& dc
|
||
, const AcDbVoidPtrArray& CurveAr
|
||
, const double& dRegW
|
||
, const double& dRegH
|
||
, const double& dMoveH
|
||
, const int& nCount
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (CurveAr.length() < 1) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis), vec;
|
||
int i(0);
|
||
|
||
AcGePoint3d pt, ptC;
|
||
AcDbArc* pArc(NULL);
|
||
double dLen(.0), dAveLen(.0), dH(.0);
|
||
|
||
AcGePoint3dArray arPts;
|
||
arPts.removeAll();
|
||
|
||
AcArray<AcDbEntity*> crossSectionCurves, guideCurves;
|
||
crossSectionCurves.removeAll();
|
||
guideCurves.removeAll();
|
||
|
||
Acad::ErrorStatus es;
|
||
AcDbLoftOptions op;
|
||
AcDb3dSolid* pLSolid = new AcDb3dSolid;
|
||
AcDb3dSolid* pRSolid = new AcDb3dSolid;
|
||
|
||
AcDbSpline* pSpline(NULL);
|
||
AcDbRegion* pReg(NULL);
|
||
|
||
AcArray<AcDbRegion*> arRegs;
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
|
||
// Left
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
ptC = pArc->center();
|
||
dLen = getArcLen(pArc);
|
||
dAveLen = dLen / (nCount - 1);
|
||
|
||
for (i; i < nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
vec = (pt - ptC).normalize();
|
||
pt += Z * (dMoveH + data.dSteepH * i);
|
||
|
||
pReg = makeRectRegion(pt, FALSE, dRegW, dRegH, -vec, Z);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
pt = getRegCenter(pReg);
|
||
arPts.append(pt);
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbX3dSolid xsolid;
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*) * crossSectionCurves.length());
|
||
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
es = pLSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
if (data.bLBeam)
|
||
{
|
||
dc.DrawEntity(pLSolid);
|
||
dc.Add3dBuffer(pLSolid);
|
||
}
|
||
|
||
// Right
|
||
arPts.removeAll();
|
||
crossSectionCurves.removeAll();
|
||
guideCurves.removeAll();
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
ptC = pArc->center();
|
||
dLen = getArcLen(pArc);
|
||
dAveLen = dLen / (nCount - 1);
|
||
|
||
for (i = 0; i < nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
vec = (pt - ptC).normalize();
|
||
pt += Z * (dMoveH + data.dSteepH * i);
|
||
|
||
pReg = makeRectRegion(pt, FALSE, dRegW, dRegH, vec, Z);
|
||
if (!pReg)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
pt = getRegCenter(pReg);
|
||
arPts.append(pt);
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*)* crossSectionCurves.length());
|
||
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
es = pRSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
if (data.bRBeam)
|
||
{
|
||
dc.DrawEntity(pRSolid);
|
||
dc.Add3dBuffer(pRSolid);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Right
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
ptC = pArc->center();
|
||
dLen = getArcLen(pArc);
|
||
dAveLen = dLen / (nCount - 1);
|
||
|
||
int j(0);
|
||
|
||
for (i = nCount - 1, j = 0; i >= 0, j < nCount; --i, ++j)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
vec = (pt - ptC).normalize();
|
||
pt += Z * (dMoveH + data.dSteepH * j);
|
||
|
||
pReg = makeRectRegion(pt, FALSE, dRegW, dRegH, -vec, Z);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
pt = getRegCenter(pReg);
|
||
arPts.append(pt);
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbX3dSolid xsolid;
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*) * crossSectionCurves.length());
|
||
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
es = pRSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
if (data.bRBeam)
|
||
{
|
||
dc.DrawEntity(pRSolid);
|
||
dc.Add3dBuffer(pRSolid);
|
||
}
|
||
|
||
// Left
|
||
arPts.removeAll();
|
||
crossSectionCurves.removeAll();
|
||
guideCurves.removeAll();
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
ptC = pArc->center();
|
||
dLen = getArcLen(pArc);
|
||
dAveLen = dLen / (nCount - 1);
|
||
|
||
dH = 0;
|
||
for (i = nCount - 1, j = 0; i >= 0, j < nCount; --i, ++j)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt);
|
||
vec = (pt - ptC).normalize();
|
||
pt += Z * (dMoveH + data.dSteepH * j);
|
||
|
||
pReg = makeRectRegion(pt, FALSE, dRegW, dRegH, vec, Z);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
pt = getRegCenter(pReg);
|
||
arPts.append(pt);
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*)* crossSectionCurves.length());
|
||
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
es = pLSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pReg);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
if (data.bLBeam)
|
||
{
|
||
dc.DrawEntity(pLSolid);
|
||
dc.Add3dBuffer(pLSolid);
|
||
}
|
||
}
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawTriangleLand3d(const AcDbArc* pArc
|
||
, AcArray<AcDbRegion*>& crossSectionCruves
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (!pArc) return Acad::eOk;
|
||
|
||
// 一共多少步
|
||
int nCount = data.nSteepS;
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen = dLen / nCount;
|
||
double dH(.0);
|
||
int i(0);
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d pt1, pt2;
|
||
|
||
AcGePoint3d ptGe[5];
|
||
|
||
AcDbRegion* pReg(NULL);
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
for (i; i < nCount; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt1);
|
||
pArc->getPointAtDist(dAveLen * (i + 1), pt2);
|
||
|
||
ptGe[0] = pt1;
|
||
ptGe[1] = pt2;
|
||
|
||
pt1 += Z * data.dSteepH * i;
|
||
pt2 += Z * data.dSteepH * (i + 1);
|
||
|
||
ptGe[2] = pt2;
|
||
ptGe[3] = pt1;
|
||
|
||
ptGe[4] = ptGe[0];
|
||
|
||
pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
||
if (!pReg) return Acad::eOk;
|
||
crossSectionCruves.append(pReg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
for (i = nCount; i > 0; --i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt1);
|
||
pArc->getPointAtDist(dAveLen * (i - 1), pt2);
|
||
|
||
ptGe[0] = pt1;
|
||
ptGe[1] = pt2;
|
||
|
||
pt1 += Z * dH;
|
||
dH += data.dSteepH;
|
||
pt2 += Z * dH;
|
||
|
||
ptGe[2] = pt2;
|
||
ptGe[3] = pt1;
|
||
|
||
ptGe[4] = ptGe[0];
|
||
|
||
pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
|
||
if (!pReg) return Acad::eOk;
|
||
crossSectionCruves.append(pReg);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawNonSilp3d(const AcDbArc* pArc
|
||
, AcArray<AcDbRegion*>& crossSectionCruves
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (!pArc) return Acad::eOk;
|
||
|
||
// 一共多少步
|
||
int nCount = data.nSteepS;
|
||
double dLen = getArcLen(pArc);
|
||
double dAveLen = dLen / nCount;
|
||
double dH(.0);
|
||
int i(0);
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis);
|
||
AcGePoint3d pt1, pt2;
|
||
|
||
AcGePoint3d ptGe[4];
|
||
|
||
AcDbRegion* pReg(NULL);
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
for (i; i < nCount - 1; ++i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt1);
|
||
pArc->getPointAtDist(dAveLen * (i + 1), pt2);
|
||
|
||
pt1 += Z * data.dSteepH * i;
|
||
pt2 += Z * data.dSteepH * (i + 1);
|
||
|
||
ptGe[0] = pt1;
|
||
ptGe[1] = pt2;
|
||
|
||
ptGe[2] = ptGe[1] + Z * data.dSteepH * .1;
|
||
|
||
ptGe[3] = ptGe[0];
|
||
|
||
pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
|
||
if (!pReg) return Acad::eOk;
|
||
crossSectionCruves.append(pReg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
for (i = nCount; i > 1; --i)
|
||
{
|
||
pArc->getPointAtDist(dAveLen * i, pt1);
|
||
pArc->getPointAtDist(dAveLen * (i - 1), pt2);
|
||
|
||
pt1 += Z * dH;
|
||
dH += data.dSteepH;
|
||
pt2 += Z * dH;
|
||
|
||
ptGe[0] = pt1;
|
||
ptGe[1] = pt2;
|
||
|
||
ptGe[2] = ptGe[1] + Z * data.dSteepH * .1;
|
||
|
||
ptGe[3] = ptGe[0];
|
||
|
||
pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 4);
|
||
if (!pReg) return Acad::eOk;
|
||
crossSectionCruves.append(pReg);
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawSlope3d(AcGiDraw& dc
|
||
, const AcDbVoidPtrArray& CurveAr
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (CurveAr.length() < 1) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
// 一共多少步
|
||
int nCount = data.nSteepS;
|
||
double dLenIn(.0), dAveLenIn(.0), dLenOut(.0), dAveLenOut(.0), dH(.0);
|
||
double dSide = 120;
|
||
double dSteepL = data.dRestPtL - data.dRestPtW;
|
||
|
||
AcGeVector3d Z(AcGeVector3d::kZAxis), vec;
|
||
|
||
AcGePoint3dArray arPts;
|
||
arPts.removeAll();
|
||
|
||
AcDbRegion* pReg(NULL);
|
||
AcArray<AcDbEntity*> crossSectionCurves, guideCurves;
|
||
crossSectionCurves.removeAll();
|
||
guideCurves.removeAll();
|
||
|
||
AcDbArc* pArcIn = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArcIn)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
AcDbArc* pArcOut = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArcOut)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcGePoint3d ptIn, ptOut, ptC;
|
||
ptC = pArcIn->center();
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
|
||
if (data.bLBeam)
|
||
{
|
||
pArcIn = (AcDbArc*)makeOffsetArcByDir(pArcIn, dSide);
|
||
}
|
||
if (!pArcIn)
|
||
{
|
||
DELETE_PTR(pArcOut);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bRBeam)
|
||
{
|
||
pArcOut = (AcDbArc*)makeOffsetArcByDir(pArcOut, -dSide);
|
||
}
|
||
if (!pArcOut)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
dLenIn = getArcLen(pArcIn);
|
||
dAveLenIn = dLenIn / nCount;
|
||
|
||
dLenOut = getArcLen(pArcOut);
|
||
dAveLenOut = dLenOut / nCount;
|
||
|
||
for (int i(0); i <= nCount; ++i)
|
||
{
|
||
pArcIn->getPointAtDist(dAveLenIn * i, ptIn);
|
||
pArcOut->getPointAtDist(dAveLenOut * i, ptOut);
|
||
|
||
ptIn += Z * data.dSteepH * i;
|
||
ptOut += Z * data.dSteepH * i;
|
||
|
||
dSteepL = ptIn.distanceTo(ptOut);
|
||
|
||
vec = (ptIn - ptOut).normalize();
|
||
pReg = makeRectRegionByPts(ptIn, ptOut, dSteepL, dSide, vec, Z);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
DELETE_PTR(pArcOut);
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
ptC = getRegCenter(pReg);
|
||
arPts.append(ptC);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
|
||
if (data.bLBeam)
|
||
{
|
||
pArcOut = (AcDbArc*)makeOffsetArcByDir(pArcOut, -dSide);
|
||
}
|
||
if (!pArcOut)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bRBeam)
|
||
{
|
||
pArcIn = (AcDbArc*)makeOffsetArcByDir(pArcIn, dSide);
|
||
}
|
||
if (!pArcIn)
|
||
{
|
||
DELETE_PTR(pArcOut);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
dLenIn = getArcLen(pArcIn);
|
||
dAveLenIn = dLenIn / nCount;
|
||
|
||
dLenOut = getArcLen(pArcOut);
|
||
dAveLenOut = dLenOut / nCount;
|
||
|
||
for (int i(nCount); i >= 0; --i)
|
||
{
|
||
pArcIn->getPointAtDist(dAveLenIn * i, ptIn);
|
||
pArcOut->getPointAtDist(dAveLenOut * i, ptOut);
|
||
|
||
ptIn += Z * dH;
|
||
ptOut += Z * dH;
|
||
dH += data.dSteepH;
|
||
|
||
dSteepL = ptIn.distanceTo(ptOut);
|
||
|
||
vec = (ptIn - ptOut).normalize();
|
||
pReg = makeRectRegionByPts(ptIn, ptOut, dSteepL, dSide, vec, Z);
|
||
if (!pReg)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
DELETE_PTR(pArcOut);
|
||
return Acad::eOk;
|
||
}
|
||
crossSectionCurves.append(pReg);
|
||
|
||
ptC = getRegCenter(pReg);
|
||
arPts.append(ptC);
|
||
}
|
||
}
|
||
|
||
if (arPts.length() < 1)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
DELETE_PTR(pArcOut);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDbSpline* pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
DELETE_PTR(pArcOut);
|
||
DELETE_PTR(pReg);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
AcDbLoftOptions op;
|
||
|
||
AcArray<AcDbRegion*> arRegs;
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*)* crossSectionCurves.length());
|
||
AcDbX3dSolid xsolid;
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
Acad::ErrorStatus es = pSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArcIn);
|
||
DELETE_PTR(pArcOut);
|
||
DELETE_PTR(pReg);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus AecDbArcSegStairDraw::DrawStairsAndSlope3d(AcGiDraw& dc
|
||
, const AcDbVoidPtrArray& CurveAr
|
||
, const SFPXStair& data) const
|
||
{
|
||
if (CurveAr.length() < 1) return Acad::eOk;
|
||
|
||
int nOldClr = dc.GetColor();
|
||
dc.SetColor(3);
|
||
|
||
int nCount = data.nSteepS;
|
||
double dSide(120);
|
||
double dSteepL = data.dRestPtL - data.dRestPtW;
|
||
|
||
AcDbArc* pArc(NULL);
|
||
AcArray<AcDbRegion*> SectionCruves1;
|
||
AcArray<AcDbRegion*> SectionCruves2;
|
||
|
||
AcGePoint3dArray arPts;
|
||
arPts.removeAll();
|
||
|
||
AcArray<AcDbEntity*> crossSectionCurves, guideCurves;
|
||
crossSectionCurves.removeAll();
|
||
guideCurves.removeAll();
|
||
|
||
AcGePoint3d pt;
|
||
|
||
// 坡道用途
|
||
if (data.bOutSideHRail)
|
||
{
|
||
// 防滑条
|
||
if (data.bDimUpstair)
|
||
{
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
SectionCruves1.removeAll();
|
||
DrawNonSilp3d(pArc, SectionCruves1, data);
|
||
if (SectionCruves1.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
SectionCruves2.removeAll();
|
||
DrawNonSilp3d(pArc, SectionCruves2, data);
|
||
if (SectionCruves2.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
for (int i(0); i < SectionCruves1.length(); ++i)
|
||
{
|
||
crossSectionCurves.removeAll();
|
||
|
||
crossSectionCurves.append(SectionCruves1.at(i));
|
||
pt = getRegCenter(SectionCruves1.at(i));
|
||
arPts.removeAll();
|
||
arPts.append(pt);
|
||
crossSectionCurves.append(SectionCruves2.at(i));
|
||
pt = getRegCenter(SectionCruves2.at(i));
|
||
arPts.append(pt);
|
||
|
||
AcDbSpline* pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
AcDbLoftOptions op;
|
||
|
||
AcArray<AcDbRegion*> arRegs;
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*) * crossSectionCurves.length());
|
||
AcDbX3dSolid xsolid;
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
Acad::ErrorStatus es = pSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
}
|
||
}
|
||
|
||
// 三角落地结构
|
||
if (data.nGShape)
|
||
{
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, dSide);
|
||
}
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
SectionCruves1.removeAll();
|
||
DrawTriangleLand3d(pArc, SectionCruves1, data);
|
||
if (SectionCruves1.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bOutSideRail)
|
||
{
|
||
// 逆时针
|
||
if (data.bRBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 顺时针
|
||
if (data.bLBeam)
|
||
{
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -dSide);
|
||
}
|
||
}
|
||
if (!pArc)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
SectionCruves2.removeAll();
|
||
DrawTriangleLand3d(pArc, SectionCruves2, data);
|
||
if (SectionCruves2.length() < 1)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
for (int i(0); i < SectionCruves1.length(); ++i)
|
||
{
|
||
crossSectionCurves.removeAll();
|
||
|
||
crossSectionCurves.append(SectionCruves1.at(i));
|
||
pt = getRegCenter(SectionCruves1.at(i));
|
||
arPts.removeAll();
|
||
arPts.append(pt);
|
||
crossSectionCurves.append(SectionCruves2.at(i));
|
||
pt = getRegCenter(SectionCruves2.at(i));
|
||
arPts.append(pt);
|
||
|
||
AcDbSpline* pSpline = new AcDbSpline(arPts);
|
||
if (!pSpline)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
||
AcDbLoftOptions op;
|
||
|
||
AcArray<AcDbRegion*> arRegs;
|
||
arRegs.removeAll();
|
||
arRegs.setLogicalLength(crossSectionCurves.length());
|
||
::memcpy(arRegs.asArrayPtr()
|
||
, crossSectionCurves.asArrayPtr()
|
||
, sizeof(AcDbRegion*)* crossSectionCurves.length());
|
||
AcDbX3dSolid xsolid;
|
||
if (xsolid.CreateLoft(arRegs, pSpline))
|
||
{
|
||
add3DCache<AecDbArcSegStair>(&xsolid);
|
||
}
|
||
|
||
Acad::ErrorStatus es = pSolid->createLoftedSolid(crossSectionCurves, guideCurves, pSpline, op);
|
||
if (es != eOk)
|
||
{
|
||
DELETE_PTR(pArc);
|
||
DELETE_PTR(pSpline);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
dc.DrawEntity(pSolid);
|
||
dc.Add3dBuffer(pSolid);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
DrawSlope3d(dc, CurveAr, data);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
DrawUpStairs3d(dc, CurveAr, data);
|
||
|
||
if (DOWN_ZERO(data.dBarSide))
|
||
{
|
||
AfxMessageBox(_T("扶手距边不能小于0！"));
|
||
return Acad::eOk;
|
||
}
|
||
|
||
if (data.bInsideRail)
|
||
{
|
||
pArc = (AcDbArc*)CurveAr.at(0);
|
||
if (!pArc) return Acad::eOk;
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, data.dBarSide + data.dGarSize[0] * .5);
|
||
if (!pArc) return Acad::eOk;
|
||
DrawRail3d(dc, pArc, data);
|
||
DrawHandRail3d(dc, pArc, data);
|
||
|
||
pArc = (AcDbArc*)CurveAr.at(1);
|
||
if (!pArc) return Acad::eOk;
|
||
pArc = (AcDbArc*)makeOffsetArcByDir(pArc, -(data.dBarSide + data.dGarSize[0] * .5));
|
||
if (!pArc) return Acad::eOk;
|
||
DrawRail3d(dc, pArc, data);
|
||
DrawHandRail3d(dc, pArc, data);
|
||
}
|
||
}
|
||
|
||
dc.SetColor(nOldClr);
|
||
|
||
return Acad::eOk;
|
||
} |