envi-code/SourceCode/Code2026/CoreLibrary/AecDbParamEquipment.cpp

#include "stdafx.h"
#include "encryption.h"
#include "mfcdbdwgfiler.h"
#include "AecDbParamEquipment.h"
#include "paramequimpl.h"
#include "AcGiViewDraw.h"
#include "AecDbXDrawPointer.h"

#ifndef BIM_REC_LEN
#define BIM_REC_LEN			_T("_`!@#$^&*BIM_REC_LEN*&^$#@!`_")
#endif

extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
extern void DLLIMPEXP OrthoProjected3DSubMesh(AcDbSubDMesh* pSubMesh,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt,AcDbDatabase* pDb = NULL,bool bClose = true);
extern void ProjectToPlane(AcDbVoidPtrArray& arEntPtrs,const AcGePlane& plan,AcDbVoidPtrArray& arNewPtrs);

namespace
{
	void setType(AecDbObjXDataMap *pXData, int nType)
	{
		if (pXData)
			pXData->SetAt(KEY_TYPE, nType);
	}
}


ACRX_DXF_DEFINE_MEMBERS (AecDbParamEquipment, AecDbEntityBase,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						 AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning, 
						 AEC_DBPARAEQUI,
						 "AecDbParamEquipment"
						 "|Product Desc:     shanghua earthworm app obj"
						 "|Company:          shanghua inc"
						 "|WEB Address:      www.shanghuasoft.com")


						 Adesk::UInt32 AecDbParamEquipment::kCurrentVersionNumber = 1;


AecDbParamEquipment::AecDbParamEquipment(const int &type): m_pImpl(NULL)
{
	m_pImpl = AecDbParamEquipment::createParamEquImpl(type, &m_XDataMap);
}

AecDbParamEquipment::~AecDbParamEquipment(void)
{
	DELETE_PTR(m_pImpl);
}

void AecDbParamEquipment::SetType(int nType)
{
	assertWriteEnabled();
	setType(&m_XDataMap, nType);
}

int AecDbParamEquipment::GetType() const
{
	assertReadEnabled();
	int nType = 0;
	m_XDataMap.GetAt(KEY_TYPE, nType);
	return nType;
}

Acad::ErrorStatus AecDbParamEquipment::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	//----- Read parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgInFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be read first
	Adesk::UInt32 version =0 ;
	if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
		return (es) ;

	if ( version > AecDbParamEquipment::kCurrentVersionNumber )
		return (Acad::eMakeMeProxy);

	m_XDataMap.dwgInFields(pFiler);

	DELETE_PTR(m_pImpl);

	int type = GetType();
	m_pImpl = AecDbParamEquipment::createParamEquImpl(type, &m_XDataMap);

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbParamEquipment::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();

	//----- Save parent class information first.
	Acad::ErrorStatus es = Acad::eOk;
	if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
	{
		es = AecDbEntityBase::dwgOutFields (pFiler) ;
		if ( es != Acad::eOk )
			return (es) ;
	}

	//----- Object version number needs to be saved first
	if ( (es =pFiler->writeUInt32 (AecDbParamEquipment::kCurrentVersionNumber)) != Acad::eOk )
		return (es) ;

	m_XDataMap.dwgOutFields(pFiler);

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbParamEquipment::dxfInFields(AcDbDxfFiler* pFiler)
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subExplode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

void AecDbParamEquipment::subList() const
{
	assertReadEnabled();
	AecDbEntityBase::subList();
	m_XDataMap.List();
}

bool AecDbParamEquipment::GetBimInfoTip(CString& sInfoTip) const
{
	assertReadEnabled();

	CString sField,sFmt,sVal,sKey;

	GetSpecialtyData()->GetAt(KEY_NAME, sVal);
	MAKEFIELD(_T("名称"),_T("%s"),sVal,sInfoTip);

	int nCount = 0;
	GetSpecialtyData()->GetAt(BIM_REC_LEN, nCount);
	for (int i = 0;i < nCount;i++)
	{
		sKey.Format(_T("user%d"), i);
		if ( !GetSpecialtyData()->GetAt(sKey,sVal))
			break;

		MAKEFIELDUSER(_T(""),_T("%s"),sVal,sInfoTip);
	}
	return true;
}

Acad::ErrorStatus AecDbParamEquipment::copyFrom(const AcRxObject* pSrc)
{
	AssertWriteEnabled();
	AecDbParamEquipment *pSrcEqu = AecDbParamEquipment::cast(pSrc);
	if (!pSrcEqu) return Acad::eInvalidInput;
	m_XDataMap.CopyFrom(pSrcEqu->GetSpecialtyData());
	//发送提资需要相同的ID
	extern CString IDCreate();
	Adesk::Int16 nVal = acdbCurDwg()->useri4();
	if (nVal != KEY_NOPROTECT)
	{
		int nVt = 0;
		CString sID = IDCreate();
		if (m_XDataMap.HasKey(KEY_NO, nVt))
			m_XDataMap.SetAt(KEY_NO, sID);
	}
	m_pImpl = pSrcEqu->cloneImpl(&m_XDataMap);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;
	AcGePoint3d pt;
	m_pImpl->transformBy(xform);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subGetGripPoints(AcDbGripDataPtrArray & grips
	, const double curViewUnitSize
	, const int gripSize
	, const AcGeVector3d & curViewDir
	, const int bitflags) const
{
	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus AecDbParamEquipment::subGetGripPoints(AcGePoint3dArray &gripPoints, AcDbIntArray &osnapModes, AcDbIntArray &geomIds) const
{
	assertReadEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;
	gripPoints.append(m_pImpl->getPos());
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subMoveGripPointsAt(const AcDbIntArray & indices, const AcGeVector3d & offset)
{
	AssertWriteEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;
	AcGeMatrix3d mat;
	mat.setToTranslation(offset);

	return subTransformBy(mat);
}

Acad::ErrorStatus AecDbParamEquipment::subMoveGripPointsAt(const AcDbVoidPtrArray &appData, const AcGeVector3d &offset, const int bitflags)
{
	return Acad::eInetNotImplemented;
}

Acad::ErrorStatus AecDbParamEquipment::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const 
{
	assertReadEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;
	stretchPoints.append(m_pImpl->getPos());
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
	AssertWriteEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;
	AcGeMatrix3d mat;
	mat.setToTranslation(offset);

	return subTransformBy(mat);
}

Acad::ErrorStatus AecDbParamEquipment::subGetOsnapPoints(AcDb::OsnapMode     osnapMode,
									  INT_PTR             gsSelectionMark,
									  const AcGePoint3d&  pickPoint,
									  const AcGePoint3d&  lastPoint,
									  const AcGeMatrix3d& viewXform,
									  AcGePoint3dArray&   snapPoints,
									  AcDbIntArray&       geomIds) const
{
	assertReadEnabled();
	if (!m_pImpl) return Acad::eInvalidInput;

	AcGePoint3d pt(m_pImpl->getPos());
	AcDbPoint pos(pt);
	return pos.getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
}

Acad::ErrorStatus AecDbParamEquipment::subGetGeomExtents(AcDbExtents& extents) const
{
	assertReadEnabled();

	if (!Has3DBuffer())
	{
		AcGiViewDraw dc;
		Draw3d(dc);
	}

	AcDbExtents ext;
	const AcDbVoidPtrArray &ar = Get3DBuffer();
	for (int i = 0; i < ar.length(); ++i)
	{
		AcDbEntity *pEnt = (AcDbEntity*)ar[i];
		pEnt->getGeomExtents(ext);
		extents.addExt(ext);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subIntersectWith(	const AcDbEntity*	pEnt, 
									 AcDb::Intersect		intType, 
									 AcGePoint3dArray&	points, 
									 INT_PTR				thisGsMarker, 
									 INT_PTR				otherGsMarker) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::subIntersectWith(	const AcDbEntity*	pEnt,
									 AcDb::Intersect		intType,
									 const AcGePlane&	projPlane,
									 AcGePoint3dArray&	points,
									 INT_PTR				thisGsMarker,
									 INT_PTR				otherGsMarker) const
{
	
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();
	if (g_BALock::instance().Draw() != BIT_SUCCESS)
		return Acad::eOk;

	int clr(256);
	m_XDataMap.GetAt(_T("COLOR"), clr);
	int oldClr = dc.GetColor();
	dc.SetColor(clr);

	if (Has2DBuffer())
	{
		Draw2DBuffers(dc);
		dc.SetColor(oldClr);
		return Acad::eOk;
	}

	CString sRxDraw;
	if ( m_XDataMap.GetAt(KEY_DRAW2D,sRxDraw) )
	{
		AecDbXDrawPointer aecDbXDraw(this,sRxDraw);
		aecDbXDraw.Draw2d(dc);

		AcDbVoidPtrArray arEntPtrs;
		dc.Get2dBuffer(arEntPtrs);
		Add2DBuffer(arEntPtrs);
		dc.SetColor(oldClr);
		return Acad::eOk;
	}

	if (m_pImpl)
	{
		AcDbVoidPtrArray ar2d;
		m_pImpl->draw2d(ar2d);
		for (int i = 0; i < ar2d.length(); ++i)
		{
			AcDbEntity *p((AcDbEntity*)ar2d[i]);
			if (p)
			{
				dc.DrawEntity(*p);
				Add2DBuffer(p);
			}
		}
		dc.SetColor(oldClr);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParamEquipment::Draw3d(AcGiDraw &dc) const
{
	assertReadEnabled();
	if (g_BALock::instance().Draw() != BIT_SUCCESS)
		return Acad::eOk;

	int clr(256);
	m_XDataMap.GetAt(_T("COLOR"), clr);
	int oldClr = dc.GetColor();
	dc.SetColor(clr);

	if (Has3DBuffer())
	{
		Draw3DBuffers(dc);
		dc.SetColor(oldClr);
		return Acad::eOk;
	}

	if (m_pImpl)
	{ 

		AcDbVoidPtrArray ar3d;
		m_pImpl->draw3d(ar3d);
		for (int i = 0; i < ar3d.length(); ++i)
		{
			AcDbEntity *p((AcDbEntity*)ar3d[i]);
			if (p)
			{
				p->setTransparency(transparency());
				dc.DrawEntity(*p);
				Add3DBuffer(p);
			}
		}
		dc.SetColor(oldClr);
	}
	return Acad::eOk;
}

//获取三维显示图形
int AecDbParamEquipment::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo/* = false*/) const
{
	assertReadEnabled();

	AcDbEntity* pEnt = NULL,*pEntClone = NULL;
	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);
		pEntClone = (AcDbEntity*)pEnt->clone();

		if (bWriteBimInfo)
		{
			m_XDataMap.Write(pEntClone,_T("BIMDATA"));
		}
		pEntClone->setLayer(layerId());
		arEntPtrs.append(pEntClone);
	}

	//扩展数据
	AcDbPoint* pPt = new AcDbPoint;
	AcGePoint3d ptIns;
	AcGeVector3d vtDir;
	GetInsert(ptIns,vtDir);

	pPt->setPosition(ptIns);
	pPt->setLayer(layerId());
	pPt->setNormal(AcGeVector3d::kZAxis);
	m_XDataMap.Write(pPt,BIMDATA_APP);
	arEntPtrs.append(pPt);

	return arEntPtrs.length();
}

int AecDbParamEquipment::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();

	AcDbObjectId id = objectId();

	AcDbEntity* pEnt = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	if (ar2D.isEmpty())
	{
		AcGePlane plan = AcGePlane::kXYPlane;
		AcGeMatrix3d xform;
		xform.setToPlaneToWorld(plan);
		xform.invert();

		AcDbVoidPtrArray arSubEntPtrs;
		AcDb3dSolid* pSolid = NULL;
		AcDbSubDMesh* pSubMesh = NULL;

		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);

			pSolid = AcDb3dSolid::cast(pEnt);
			if (pSolid != NULL)
			{
				//投影法
				OrthoProjected3DSolid(pSolid,plan,xform,arSubEntPtrs);
			}

			pSubMesh = AcDbSubDMesh::cast(pEnt);
			if (pSubMesh != NULL)
			{
				OrthoProjected3DSubMesh(pSubMesh,plan,xform,arSubEntPtrs);
			}
		}

		AcDbObjectId idLayer = layerId();
		for (int i = 0;i < arSubEntPtrs.length();i++)
		{
			pEnt = (AcDbEntity*)arSubEntPtrs.at(i);
			pEnt->setLayer(idLayer);
			if (GetSpecialtyData() != NULL)
			{
				GetSpecialtyData()->Write(pEnt,BIMDATA_APP);
			}
			arEntPtrs.append(pEnt);
		}

		//扩展数据
		AcDbPoint* pPt = new AcDbPoint;
		AcGePoint3d ptIns,ptIns2;
		AcGeVector3d vtDir;
		GetInsert(ptIns,vtDir);

		ptIns2 = ptIns.orthoProject(AcGePlane::kXYPlane);
		pPt->setPosition(ptIns2);
		pPt->setLayer(layerId());
		pPt->setNormal(plan.normal());
		pPt->transformBy(xform);
		m_XDataMap.Write(pPt,BIMDATA_APP);
		arEntPtrs.append(pPt);
	}
	else
	{
		AcGePlane plan = AcGePlane::kXYPlane;
		AcGeMatrix3d xform;
		xform.setToPlaneToWorld(plan);
		xform.invert();

		AcDbVoidPtrArray arSubEntPtrs;
		AcDb3dSolid* pSolid = NULL;
		AcDbSubDMesh* pSubMesh = NULL;

		AcDbEntity* pClnEnt = NULL;
		AcDbObjectId idLayer = layerId();
		for (int i = 0;i < ar2D.length();i++)
		{
			pEnt = (AcDbEntity*)ar2D.at(i);
			pClnEnt = (AcDbEntity*)pEnt->clone();
			pClnEnt->setLayer(idLayer);

			pSolid = AcDb3dSolid::cast(pClnEnt);
			if (pSolid != NULL)
			{
				//投影法
				OrthoProjected3DSolid(pSolid,plan,xform,arSubEntPtrs);
				continue;
			}

			pSubMesh = AcDbSubDMesh::cast(pClnEnt);
			if (pSubMesh != NULL)
			{
				OrthoProjected3DSubMesh(pSubMesh,plan,xform,arSubEntPtrs);
				continue;
			}

			arSubEntPtrs.append(pClnEnt);
		}

		for (int i = 0;i < arSubEntPtrs.length();i++)
		{
			pEnt = (AcDbEntity*)arSubEntPtrs.at(i);
			pEnt->setLayer(idLayer);

			if (GetSpecialtyData() != NULL)
			{
				GetSpecialtyData()->Write(pEnt,BIMDATA_APP);
			}
			arEntPtrs.append(pEnt);
		}

		//扩展数据
		AcDbPoint* pPt = new AcDbPoint;
		AcGePoint3d ptIns,ptIns2;
		AcGeVector3d vtDir;
		GetInsert(ptIns,vtDir);

		ptIns2 = ptIns.orthoProject(AcGePlane::kXYPlane);
		pPt->setPosition(ptIns2);
		pPt->setLayer(layerId());
		pPt->setNormal(AcGeVector3d::kZAxis);
		m_XDataMap.Write(pPt,BIMDATA_APP);
		arEntPtrs.append(pPt);
	}

	return arEntPtrs.length();
}

const AecDbObjXDataMap* AecDbParamEquipment::GetSpecialtyData() const
{
	return &m_XDataMap;
}

AecDbObjXDataMap* AecDbParamEquipment::GetSpecialtyData(AcDb::OpenMode bMode)
{
	if (bMode == AcDb::kForRead)
		assertReadEnabled();
	else if (bMode == AcDb::kForWrite)
	{
		if (!isWriteEnabled())
		{
			upgradeOpen();
		}
		AssertWriteEnabled();
	}
	else
		return NULL;
	return &m_XDataMap;
}

bool AecDbParamEquipment::GetInterface(AcArray<AecInterface>& arInfs) const
{
	return false;
}

bool AecDbParamEquipment::GetInterface(int nIndex,AecInterface& inf) const
{
	return false;
}

int AecDbParamEquipment::GetInterfaceCount() const
{
	return 0;
}

int AecDbParamEquipment::GetActiveInf() const
{
	return 0;
}

void AecDbParamEquipment::SetActiveInf(int nIndex)
{
}

void AecDbParamEquipment::LockInf(int nInf)
{
	
}

bool AecDbParamEquipment::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
{
	return false;
}

void AecDbParamEquipment::SetPosAndDir(const AcGePoint3d & pt, const AcGeVector3d & dir)
{
	AssertWriteEnabled();
	m_XDataMap.SetAt(_T("Pos"), pt);
	m_XDataMap.SetAt(_T("Dir"), dir);
}

void AecDbParamEquipment::GetInsert(AcGePoint3d& ptIns,AcGeVector3d& vtDir) const
{
	assertReadEnabled();
	m_XDataMap.GetAt(_T("Pos"), ptIns);
	m_XDataMap.GetAt(_T("Dir"), vtDir);
}

void AecDbParamEquipment::SetElev(const double & dElev)
{
	AssertWriteEnabled();
	if (m_pImpl)
		m_pImpl->setElev(dElev);
}

CParamEquImplBase* AecDbParamEquipment::cloneImpl(AecDbObjXDataMap *pXData)
{
	if (m_pImpl)
		return m_pImpl->makeSelf(pXData);
	return NULL;
}

double AecDbParamEquipment::GetElev()
{
	if (m_pImpl)
		return m_pImpl->getPos().z;
	return 0.0;
}

#define _CREATE_(region,type1,func)\
case region::type1:\
	setType(pXData, type);\
	pImp = new ::region::func(pXData);\
	break

CParamEquImplBase* AecDbParamEquipment::createParamEquImpl(const int & type, AecDbObjXDataMap *pXData)
{
	CParamEquImplBase *pImp(NULL);
	switch (type)
	{
		_CREATE_(GESHAN,XHG_I,XHG);
		_CREATE_(GESHAN,XHG_II,XHG);
		_CREATE_(GESHAN,SG,SG);
		_CREATE_(GESHAN,BLQ,SG);
		_CREATE_(GESHAN,ZG_I,ZG);
		_CREATE_(GESHAN,ZG_II,ZG);
		_CREATE_(BAOQIQI,PAN_SI,BaoQiQi);
		_CREATE_(BAOQIQI,GUAN_SI,BaoQiQi);
		_CREATE_(SHASHUIFENLI,XCS,XCS);
		_CREATE_(SHASHUIFENLI,HXS,HXS);
		_CREATE_(SHASHUIFENLI,LCS,LCS);
		_CREATE_(LUOXUANBENG,LXB,LXB);
		_CREATE_(QIBIJI,QS_I_P,QS_I_P);
		_CREATE_(QIBIJI,QS_I_Y,QS_I_Y);
		_CREATE_(QIBIJI,QS_I_L,QS_I_L);
		_CREATE_(QIBIJI,QS_II_Y,QS_II_Y);
		_CREATE_(QIBIJI,QS_II_L,QS_II_L);
		_CREATE_(ZHAMEN,RECT_ZHAMEN,RectZhaMen);
		_CREATE_(ZHAMEN,CIRCLE_ZHAMEN,CircleZhaMen);
		_CREATE_(ZHAMEN,SHENG_NI_FA,ShengNiFa);
		_CREATE_(GUANIJI,XZG,XZG);
		_CREATE_(GUANIJI,CZG,CZG);
		_CREATE_(GUANIJI,ZG,ZG);
		_CREATE_(GUANIJI,QG,QG);
		_CREATE_(GUANIJI,PJ,PJ);
		_CREATE_(GUANIJI,SX,SX);
		_CREATE_(GUANIJI,SB,SB);
		_CREATE_(GUANIJI,LIANTIAO,LIANTIAO);
		_CREATE_(NONGSUOJI,NC,NC);
		_CREATE_(NONGSUOJI,NB,NB);
		_CREATE_(BAOQIJI,YHG,YHG);
		_CREATE_(BAOQIJI,AD,AD);
		_CREATE_(JIAYAOHUNHE,GJ,GJ);
		_CREATE_(JIAYAOHUNHE,PJ,PJ);
		_CREATE_(JIAYAOHUNHE,TJ,TJ);
		_CREATE_(JIAYAOHUNHE,LJF,LJF);
		_CREATE_(LVBUJI,ZHUANPAN,ZHUANPAN);
	default:
		return NULL;
	}
	return pImp;
}

bool AecDbParamEquipment::GetSrcString(CString &src)
{
	assertReadEnabled();
	return m_XDataMap.GetAt(_T("_SRC_STRING_"), src) == 0 ? false : true;
}

void AecDbParamEquipment::SetSrcString(LPCTSTR src)
{
	assertWriteEnabled();
	if (src && !CString(src).IsEmpty())
		m_XDataMap.SetAt(_T("_SRC_STRING_"), src);
}

int AecDbParamEquipment::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegPtrs) const
{
	AcGeVector3d vtLn = ptTo - ptFr;
	AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);

	AcGePlane plan;
	plan.set(ptFr,vtNorm);

	AcGeMatrix3d xform;
	xform.setToPlaneToWorld(plan);
	xform.invert();

	if (Get3DBuffer().length() == 0)
	{
		AcGiViewDraw dc(NULL,NULL);
		Draw3d(dc);
	}

	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;
	AcDbSubDMesh* pSubMesh = NULL;
	AcDbVoidPtrArray arRegPtrsT;
	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);

		pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			//投影法
			OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrsT);
		}

		pSubMesh = AcDbSubDMesh::cast(pEnt);
		if (pSubMesh != NULL)
		{
			OrthoProjected3DSubMesh(pSubMesh,plan,xform,arRegPtrsT);
		}
	}

	//扩展数据
	AcDbPoint* pPt = new AcDbPoint;
	AcGePoint3d ptIns,ptIns2;
	AcGeVector3d vtDir;
	GetInsert(ptIns,vtDir);

	pPt->setPosition(ptIns);
	pPt->setLayer(layerId());
	pPt->setNormal(plan.normal());
	pPt->transformBy(xform);
	m_XDataMap.Write(pPt,BIMDATA_APP);
	arRegPtrsT.append(pPt);

	for (int i = 0;i < arRegPtrsT.length();i++)
	{
		pEnt = (AcDbEntity*)arRegPtrsT.at(i);
		pEnt->setLayer(layerId());
		arRegPtrs.append(pEnt);
	}

	return arRegPtrs.length();
}

SHJson::WValue& AecDbParamEquipment::ToJson(bool bExprotGeo) const
{
	using namespace SHJson;
	return AecDbEntityBase::ToJson(bExprotGeo);
}

bool AecDbParamEquipment::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEntityBase::ByJson(v);
}