acdbequitriangle.cpp

这是树上的代码

// AcDbEquiTriangle.cpp - Impletement file

#include "AcDbEquiTriangle.h"
#include <dbproxy.h>		// for AcDbProxyEntity class
#include <geassign.h>		// for asPnt3d macro
#include <gemat3d.h>		// for AcGeMatrix3d class
#include <acgi.h>			// for AcGiWorldDraw class
#include <dbspline.h>		// for AcDbSpline class

ACRX_DXF_DEFINE_MEMBERS(AcDbEquiTriangle, AcDbEntity,
						AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 
						AcDbProxyEntity::kAllAllowedBits, 
						TRIANGLE, "MyTriangle|Author: Liu Lianghua|E-mail: [e-mail]");

#define SUBCLASSNAME ("MyTriangle")
#define PI 3.14159265

void 
AcDbEquiTriangle::set(const AcGePoint3d& leftPnt, 
					  const AcGePoint3d& rightPnt)
{
	m_leftPoint = leftPnt;	/*正三角形的左下角点*/ 
	m_rightPoint = rightPnt;
}

Acad::ErrorStatus
AcDbEquiTriangle::getVertices3d(AcGePoint3dArray& vertexArray) const
{
	vertexArray.append(m_leftPoint);
	vertexArray.append(m_rightPoint);

	AcGeVector3d vec = m_rightPoint-m_leftPoint;
	vec.rotateBy(PI/3.0, AcGeVector3d(0, 0, 1));
	double sideLen = m_leftPoint.distanceTo(m_rightPoint);
	AcGePoint3d vertex = m_leftPoint + vec.normal()*sideLen;
	vertexArray.append(vertex);
	
	// center point
	AcGePoint3d center;
	center[X] = (m_leftPoint[X]+m_rightPoint[X]+vertex[X])/3.0;
	center[Y] = (m_leftPoint[Y]+m_rightPoint[Y]+vertex[Y])/3.0;
	center[Z] = (m_leftPoint[Z]+m_rightPoint[Z]+vertex[Z])/3.0;
	vertexArray.append(center);

	return Acad::eOk;
}

////////////////////////////////////////////////////////////////////////////
Acad::ErrorStatus 
AcDbEquiTriangle::dwgOutFields(AcDbDwgFiler* filer) const
{
	assertReadEnabled();
	Acad::ErrorStatus es;
	if((es = AcDbEntity::dwgOutFields(filer)) != Acad::eOk)
	{
		return es;
	}

	//private data of custom entity
	filer->writePoint3d(m_leftPoint);
	filer->writePoint3d(m_rightPoint);

	return filer->filerStatus();
}

Acad::ErrorStatus 
AcDbEquiTriangle::dwgInFields(AcDbDwgFiler* filer)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;
	if((es = AcDbEntity::dwgInFields(filer)) != Acad::eOk)
	{
		return es;
	}

	filer->readPoint3d(&m_leftPoint);
	filer->readPoint3d(&m_rightPoint);

	return filer->filerStatus();
}

Acad::ErrorStatus 
AcDbEquiTriangle::dxfOutFields(AcDbDxfFiler* filer) const
{
	assertReadEnabled();
	Acad::ErrorStatus es;
	if((es = AcDbEntity::dxfOutFields(filer)) != Acad::eOk)
	{
		return es;
	}
	filer->writeItem(AcDb::kDxfSubclass, SUBCLASSNAME);	// 注意

	// 派生类的私有数据
	filer->writePoint3d(AcDb::kDxfXCoord, m_leftPoint);
	filer->writePoint3d(AcDb::kDxfXCoord + 1, m_rightPoint);

	return filer->filerStatus();
}

Acad::ErrorStatus 
AcDbEquiTriangle::dxfInFields(AcDbDxfFiler* filer)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;
	if((es = AcDbEntity::dxfInFields(filer)) != Acad::eOk)
	{
		return es;
	}
	if(!filer->atSubclassData(SUBCLASSNAME))
		return filer->filerStatus();

	// private data of custom entity
	struct resbuf rb;
	while(es == Acad::eOk && 
		(es = filer->readResBuf(&rb)) == Acad::eOk)
	{
		switch(rb.restype)
		{
		case AcDb::kDxfXCoord:
			m_leftPoint = asPnt3d(rb.resval.rpoint);
			break;
		case AcDb::kDxfXCoord+1:
			m_rightPoint = asPnt3d(rb.resval.rpoint);
			break;
		default:
			filer->pushBackItem();
			es = Acad::eEndOfFile;
			break;
		}
	}

	if(es != Acad::eEndOfFile)	// 读完数据（es == Acad::eEndOfFile）
		return Acad::eInvalidResBuf;

	return filer->filerStatus();
}


//从AcDbEntity基类派生时必须重载的函数
Adesk::Boolean 
AcDbEquiTriangle::worldDraw(AcGiWorldDraw* worldDraw)
{
    assertReadEnabled();
	if(worldDraw->regenAbort())
		return Adesk::kTrue;
	
	if(!worldDraw)
		return Adesk::kFalse;
    for(int i = 0; i < 3 /*只有三个顶点*/; i++) 
	{	
		worldDraw->subEntityTraits().setSelectionMarker(i + 1);
	}

	AcGePoint3dArray vertexArray;
	getVertices3d(vertexArray);

    AcGePoint3d	ptArray[4];
	ptArray[0] = vertexArray[0];
	ptArray[1] = vertexArray[1];
	ptArray[2] = vertexArray[2];
	ptArray[3] = vertexArray[0];

	worldDraw->geometry().polyline(4, ptArray);
	return Adesk::kTrue;
}

Acad::ErrorStatus 
AcDbEquiTriangle::getGeomExtents(AcDbExtents& extents) const
{
    assertReadEnabled();
	AcGePoint3dArray vertexArray;
	getVertices3d(vertexArray);
	AcGePoint3d minPnt, maxPnt;
	for(int i = 0; i < vertexArray.length(); i++)
	{
		//
		if(i == 0)
		{
			minPnt = vertexArray[i];
			maxPnt = vertexArray[i];
			continue;
		}

		for(int jj = X; jj < Z; jj++) // X, Y, Z
		{
			if(vertexArray[i][jj] < minPnt[jj])
				minPnt[jj] = vertexArray[i][jj];
			else if(vertexArray[i][jj] > maxPnt[jj])
				maxPnt[jj] = vertexArray[i][jj];
		}
	}

	extents.set(minPnt, maxPnt);
	return Acad::eOk;
}

Acad::ErrorStatus 
AcDbEquiTriangle::transformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	m_leftPoint.transformBy(xform);
	m_rightPoint.transformBy(xform);

	return Acad::eOk;
}

Acad::ErrorStatus 
AcDbEquiTriangle::getTransformedCopy(const AcGeMatrix3d& xform,
									 AcDbEntity*& ent) const
{
    assertReadEnabled();
	return AcDbEntity::getTransformedCopy(xform, ent);
}

Acad::ErrorStatus
AcDbEquiTriangle::getGripPoints(AcGePoint3dArray& gripPoints,
								AcDbIntArray& osnapModes,
								AcDbIntArray& geomIds) const
{
    assertReadEnabled();
	return getVertices3d(gripPoints); // 数据中的元素依次是左下角点，右下角点；顶点，中心点
}

Acad::ErrorStatus
AcDbEquiTriangle::moveGripPointsAt(const AcDbIntArray& indices,
								   const AcGeVector3d& offset)
{
    assertWriteEnabled();
	if(indices.length() == 0 || offset.isZeroLength())
		return Acad::eOk;

	if(indices.length() > 1 || indices[0] == 3 /* center point */)
		return	transformBy(AcGeMatrix3d::translation(offset));	 


	AcGePoint3dArray vertexArray;
	getVertices3d(vertexArray);
	AcGeVector3d vec1, vec2;
	vec1 = m_rightPoint - m_leftPoint;
	vec2 = vertexArray[2] - m_leftPoint;
	AcGeVector3d normalVec = vec1.crossProduct(vec2);

	double rotateBy1 = (2*PI/3.0)*(-indices[0]);	//左
	double rotateBy2 = (2*PI/3.0)*(1-indices[0]);	//右

	AcGeVector3d off1(offset), off2(offset);
	off1.rotateBy(rotateBy1, normalVec);
	off2.rotateBy(rotateBy2, normalVec);

	m_leftPoint += off1;
	m_rightPoint += off2;

	return Acad::eOk;
}