/*************************************************************************/
/*	File : VxPlane.h													 */
/*	Author :  Aymeric Bard												 */	
/*																		 */	
/*	Virtools SDK 															 */	 
/*	Copyright (c) Virtools 2000, All Rights Reserved.						 */	
/*************************************************************************/

#ifndef VXPLANE_H

#define VXPLANE_H

/**********************************************************
{filename:VxPlane}
Name: VxPlane

Summary: Class representation of an infinite plane.

Remarks:
	A VxPlane is defined by a normal VxVector and and is used to represents
	a infinite plane in space (usefull for intersection purposes.)
	It can be created with a point in space and normal,an equation or with 3 points.

A VxPlane is defined as:

			class VxPlane 
			{
				public:
					VxVector	m_Normal;	// The normal to the plane
					float		m_D;		// The D component of Ax + By + Cz + D = 0 equation	
			};




See Also : VxVector,VxRay,Intersections,VxIntersect
*********************************************************/
class VxPlane
{
public:
	
	/************************************************
	Summary: Constructors.

	Input Arguments: 
		a,b,c,d: Equation of the plane.
		n: A VxVector representing the normal of the plane.
		p: A point in space lying on the plane 

	Remarks:
		A VxPlane can be created from its equation, a normal and a point lying on the plane
		or three points belonging to the plane (which must not be aligned).
	************************************************/
	VxPlane() : m_Normal(0,0,0), m_D(0) {}
	VxPlane(const VxVector& n,float d) : m_Normal(n), m_D(d) {}
	VxPlane(float a,float b,float c,float d) : m_Normal(a,b,c), m_D(d) {}
	VxPlane(const VxVector& n,const VxVector& p)  { Create(n,p); }
	VxPlane(const VxVector& a,const VxVector& b,const VxVector& c) { Create(a,b,c); }

	friend const VxPlane operator - (const VxPlane& p);

	const VxVector& GetNormal() const {return m_Normal;}

	/************************************************
	Summary: Returns on which side a point is regarding to a plane..

	Input Arguments: 
		p: A point in space. 

	Remarks:
		Classify the point with regards of the plane : a positive value means the point is front of the plane.

	See Also:Distance
	************************************************/
	float Classify(const VxVector& p) const {return DotProduct(m_Normal,p) + m_D;}

	/************************************************
	Summary: Returns on which side a box is regarding to a plane..

	Input Arguments: 
		box: A box in the plane referential. 

	Remarks:
		Classify the box with regards of the plane : a positive value means the box is front of the plane.
		0 means the box intersects the plane. 

	See Also:Distance
	************************************************/
	float Classify(const VxBbox& box) const {
		VxVector vmin = box.Min;
		VxVector vmax = box.Max;
		for (int axis=0; axis<3; ++axis) {
			if (m_Normal[axis] < 0) {
				vmin[axis] = box.Max[axis];
				vmax[axis] = box.Min[axis];
			}
		}
		float f = Classify(vmin);
		if (f > 0.0f) return f;
		f = Classify(vmax);
		if (f >= 0.0f) return 0.0f;
		return f;
	}

	/************************************************
	Summary: Returns on which side an oriented box is regarding to a plane..

	Input Arguments: 
		box: A box in the referential of the given matrix. 
		max: matrix of the referntial of the box.

	Remarks:
		Classify the box with regards of the plane : a positive value means the box is front of the plane.
		0 means the box intersects the plane. 

	See Also:Distance
	************************************************/
	float Classify(const VxBbox& box, const VxMatrix& mat) const {
		VxVector hsize		= box.GetHalfSize();
		
		float r =	XAbs(DotProduct(m_Normal,mat[0]*hsize[0])) + 
					XAbs(DotProduct(m_Normal,mat[1]*hsize[1])) + 
					XAbs(DotProduct(m_Normal,mat[2]*hsize[2]));

		// hsize is now used as position
		VxVector v = box.GetCenter();
		Vx3DMultiplyMatrixVector(&hsize,mat,&v);
		
		float d =	DotProduct(hsize,m_Normal) + m_D;
		if	(d > r)	return (d-r);
		else if (-d > r) return -(-d - r);
		else return 0.0f;
	}

	/************************************************
	Summary: Returns on which side a face is regarding to a plane..

	Input Arguments: 
		pt0: the first index of the face. 
		pt1: the second index of the face. 
		pt2: the third index of the face. 

	Retun Value: The minimum distance of the face to the plane.

	Remarks:
		Classify the face with regards of the plane : a positive value means the point is front of the plane, a
		negative value that the face is behind the plane.. 0 means that the face is crossing.

	See Also:Distance
	************************************************/
	// Intersection Box - Plane
	float
	ClassifyFace(const VxVector& pt0,const VxVector& pt1,const VxVector& pt2) const
	{
		float d = Classify(pt0);
		float min = d;
		
		d = Classify(pt1);
		if (min > 0.0f) {
			if (d < 0.0f) return 0.0f;
			if (d < min) min = d;
		} else {
			if (d > 0.0f) return 0.0f;
			if (d > min) min = d;
		}
		
		d = Classify(pt2);	
		if (min > 0.0f) {
			if (d < 0.0f) return 0.0f;
			if (d < min) min = d;
		} else {
			if (d > 0.0f) return 0.0f;
			if (d > min) min = d;
		}
		
		return min;
	}

	/************************************************
	Summary: Return the distance of a point to the plane

	Input Arguments: 
		p: A point in space. 

	Return Value : Distance from the point to the plane.
	Remarks:

	See also: Classify
	************************************************/
	float Distance(const VxVector& p) const {return XAbs(Classify(p));}

	/************************************************
	Summary: Return the nearest point from a point on the plane

	Input Arguments: 
		p: A point in space. 

	Return Value : A point on the plane.
	Remarks:

	See also: Classify
	************************************************/
	const VxVector NearestPoint(const VxVector& p) const {return p+m_Normal*-Classify(p);}

	
VX_EXPORT void Create(const VxVector& n,const VxVector& p);
	
VX_EXPORT void Create(const VxVector& a,const VxVector& b,const VxVector& c);
	
	bool operator == (const VxPlane& iPlane) const {
		return (m_Normal == iPlane.m_Normal) && (m_D == iPlane.m_D);
	}


	float XClassify(const VxVector boxaxis[4]) const {
		float r =	XAbs(DotProduct(m_Normal,boxaxis[0])) + 
					XAbs(DotProduct(m_Normal,boxaxis[1])) + 
					XAbs(DotProduct(m_Normal,boxaxis[2]));
		
		float d =	DotProduct(m_Normal,boxaxis[3]) + m_D;
		if	(d > r)	return d;
		else if (d < -r) return d;
		else return 0.0f;
	}

	// The normal to the plane
	VxVector	m_Normal;
	// The D component of Ax + By + Cz + D = 0 equation
	float		m_D;

};

inline const VxPlane operator - (const VxPlane& p)
{
   return VxPlane(-p.m_Normal,-p.m_D);
}

#endif