//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   XPlane 类
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   XPlane 类定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "XPlane.h"
#include "XPoint.h"
#include "XPrivateGlobalFunc.h"
#include "XGlobalCurveFunc.h"
#include "XCurveInline.h"

XPlane::XPlane()
	: m_dParaA(0.0), m_dParaB(0.0), m_dParaC(1.0), m_dParaD(0.0) 
{
	
}

XPlane::XPlane(double aa, double bb, double cc, double dd)
	: m_dParaA(aa), m_dParaB(bb), m_dParaC(cc), m_dParaD(dd) 
{ 
	
}

XPlane::XPlane(const XPlane &src)
	: m_dParaA(src.m_dParaA), m_dParaB(src.m_dParaB), 
	  m_dParaC(src.m_dParaC), m_dParaD(src.m_dParaD) 
{
	
}

XPlane::XPlane(const XPoint &ptOrg, const XVector3D &vtNorm)
{
    m_dParaA = vtNorm[0];
    m_dParaB = vtNorm[1];
    m_dParaC = vtNorm[2];
    
	const XVector3D &vt=vtNorm;
    const XPoint &pt=ptOrg;
    
	m_dParaD = 0.0 - (vt[0] * pt[0] + vt[1] * pt[1] + vt[2] * pt[2]);
}


XPlane::~XPlane()
{
	
}

// 3点确定一平面方程
BOOL XPlane::SetFrom3p(const XPoint &pt1, const XPoint &pt2, const XPoint &pt3)
{
    XVector3D vt1 = pt2 - pt1;
    XVector3D vt2 = pt3 - pt1;
    XVector3D vtNorm = vt1 * vt2;
	
    if (vtNorm.Length() < 1.0E-9)
	{
		return FALSE;
	}
	
    vtNorm.Normalize();
    
	m_dParaA = vtNorm[0];
    m_dParaB = vtNorm[1];
    m_dParaC = vtNorm[2];
    
	const XVector3D &vt = vtNorm;
    const XPoint &pt = pt1;
    
	m_dParaD = 0.0 - (vt[0] * pt[0] + vt[1] * pt[1] + vt[2] * pt[2]);
    
	return TRUE;
}

// 平面与线求交，考虑了线是否为无限长
BOOL XPlane::Intersect(const XLine &ln, XPoint &ptInt) const
{
    const XPoint &pt1 = ln.GetStartPoint();
    const XPoint &pt2 = ln.GetEndPoint();
    ads_real l, m, n, t;
    ads_real mid_var1, mid_var2;
	
	l = pt2[0] - pt1[0];
    m = pt2[1] - pt1[1];
    n = pt2[2] - pt1[2];
	
    mid_var1 = l * m_dParaA + m * m_dParaB + n * m_dParaC;
    if (fabs(mid_var1) < 1.0E-9)  
	{
		return FALSE; 
	}
	
    mid_var2 = m_dParaD + pt1[0] * m_dParaA + 
				pt1[1] * m_dParaB + pt1[2] * m_dParaC;
    t = 0.0 - mid_var2 / mid_var1;
	
    ptInt[0] = pt1[0] + l * t;
    ptInt[1] = pt1[1] + m * t;
    ptInt[2] = pt1[2] + n * t;
	
    if (ln.GetLineFlag() != LS_INFINITE) 
	{
        int nPrFlag = ptInt & ln;
        if (nPrFlag == PR_OUTSIDE)
		{
			return FALSE;
		}
    }
	
    return TRUE;
}

// 平面与平面求交，求交线（无限长）
BOOL XPlane::Intersect(const XPlane &plan, XLine &ln) const
{
    AcGePlane plane1(m_dParaA, m_dParaB, 
					 m_dParaC, m_dParaD);
	AcGePlane plan2(plan.GetParaA(), plan.GetParaB(), plan.GetParaC(), plan.GetParaD());
    AcGeLine3d ln3d;
	
	BOOL bRet = plane1.intersectWith(plan2, ln3d);
    if (bRet) 
	{
        AcGeVector3d vt = ln3d.direction();
        
		ln.SetLineFlag(LS_INFINITE);
        ln.SetStartPoint(ln3d.pointOnLine());
        ln.SetEndPoint(ln.GetStartPoint() + vt);
    }
	
    return bRet;
}

XPlane & XPlane::operator = (const XPlane &src) 
{
	m_dParaA = src.GetParaA();
	m_dParaB = src.GetParaB();
	m_dParaC = src.GetParaC();
	m_dParaD = src.GetParaD();
	
	return *this;
}

double XPlane::GetParaA() const
{
	return m_dParaA;
}

void XPlane::SetParaA(const double dVal)
{
	m_dParaA = dVal;
}

double XPlane::GetParaB() const
{
	return m_dParaB;
}

void XPlane::SetParaB(const double dVal)
{
	m_dParaB = dVal;
}

double XPlane::GetParaC() const
{
	return m_dParaC;
}

void XPlane::SetParaC(const double dVal)
{
	m_dParaC = dVal;
}

double XPlane::GetParaD() const
{
	return m_dParaD;
}

void XPlane::SetParaD(const double dVal)
{
	m_dParaD = dVal;
}

BOOL XPlane::IsValid() const 
{
	return (XPoint(m_dParaA, m_dParaB, m_dParaC).Length() > 1.0E-9);
}

BOOL XPlane::operator !() const 
{
	return (!IsValid());
}

XVector3D XPlane::GetNormal() const 
{
	XVector3D vt(m_dParaA, m_dParaB, m_dParaC);
	vt.Normalize();
	return vt;
}

double XPlane::GetAngle(XVector3D vtLight)const
{
	AcGeVector3d vtNormal = GetNormal().AsAcGeVector3d();
	vtLight.Reverse();
	
	AcGeVector3d vt = vtLight.AsAcGeVector3d();
	
	return vt.angleTo(vtNormal);
}

bool XPlane::IsReflect(XVector3D vtLight)const
{
	double dAng = GetAngle(vtLight);
	return dAng < PI / 2 - 1E-4;
}

bool XPlane::Reflect(XVector3D vtLight,XVector3D& vtRes)const
{
	AcGeVector3d vt = vtLight.AsAcGeVector3d();
	vtRes = XVector3D(vt.mirror(GetNormal().AsAcGeVector3d()));
	
	return IsReflect(vtLight);
}

bool XPlane::IsKindOf(XEntity::TEntityId entType) const
{
	switch(entType)
	{
	case XEntity::eEntity:
	case XEntity::ePlane:
		return true;
	}
	return false;
}

XEntity::TEntityId XPlane::Type() const
{
	return XEntity::ePlane;
}

void XPlane::CopyFrom(const XEntity* pImpSrc)
{
	if (this != pImpSrc && pImpSrc->IsKindOf(XEntity::ePlane))
	{
		m_dParaA = ((XPlane*)pImpSrc)->GetParaA();
		m_dParaA = ((XPlane*)pImpSrc)->GetParaB();
		m_dParaA = ((XPlane*)pImpSrc)->GetParaC();
		m_dParaA = ((XPlane*)pImpSrc)->GetParaD();
	}
}

GEOAPI BOOL GetShadowMatrix(const XPlane&plane, const XVector3D &vtLight, AcGeMatrix3d &mShadowMatrix)
{
	double lightPos[4] = {vtLight[0], vtLight[1], vtLight[2], 0.0f};
	double dot = plane.GetParaA() * lightPos[0] 
			   + plane.GetParaB() * lightPos[1] 
			   + plane.GetParaC() * lightPos[2] 
			   + plane.GetParaD() * lightPos[3];
	if (dot>-1.0E-9) 
	{
		return FALSE; //光线平行或同向于平面
	}
	
	mShadowMatrix(0,0) = (1.0 - lightPos[0] * plane.GetParaA() / dot);
	mShadowMatrix(0,1) = (-lightPos[0] * plane.GetParaB() / dot);
	mShadowMatrix(0,2) = (-lightPos[0] * plane.GetParaC() / dot);
	mShadowMatrix(0,3) = (-lightPos[0] * plane.GetParaD() / dot);
	
	mShadowMatrix(1,0) = (-lightPos[1] * plane.GetParaA() / dot);
	mShadowMatrix(1,1) = (1.0 - lightPos[1] * plane.GetParaB() / dot);
	mShadowMatrix(1,2) = (-lightPos[1] * plane.GetParaC() / dot);
	mShadowMatrix(1,3) = (-lightPos[1] * plane.GetParaD() / dot);
	
	mShadowMatrix(2,0) = (-lightPos[2] * plane.GetParaA() / dot);
	mShadowMatrix(2,1) = (-lightPos[2] * plane.GetParaB() / dot);
	mShadowMatrix(2,2) = (1.0 - lightPos[2] * plane.GetParaC() / dot);
	mShadowMatrix(2,3) = (-lightPos[2] * plane.GetParaD() / dot);
	
	mShadowMatrix(3,0) = 0.0;
	mShadowMatrix(3,1) = 0.0;
	mShadowMatrix(3,2) = 0.0;
	mShadowMatrix(3,3) = 1.0;
	return TRUE;
}