/*************************************************************************/
/*	File : VxVector.h													 */
/*	Author :  Romain SIDIDRIS											 */	
/*																		 */	
/*	Virtools SDK 															 */	 
/*	Copyright (c) Virtools 2000, All Rights Reserved.						 */	
/*************************************************************************/
#ifndef VXVECTOR_H

#define VXVECTOR_H

#ifdef macintosh
	#include "VxMacHeader.h"
#endif

VX_EXPORT int	  radToAngle(float val);
VX_EXPORT float   Tsin(int angle);
VX_EXPORT float   Tcos(int angle);

//______________________
// some global variables

/*******************************************************
{filename:VxVector}
Name: VxVector

Summary: Class representation of a Vector in 3 dimensions

Remarks:
A VxVector is defined as:

		typedef struct VxVector {
			union {
					struct {
						float x,y,z;
					};
					float v[3];
			};
		}

Elements can be accessed with x,y,z value or through the array v. 


***********************************************************/
struct VxVector
{
#if defined(_LINUX)
  float x,y,z;
#else
	union
	{
		struct
		{
			float x,y,z;
		};
		float v[3];
	};
#endif

public:
	// =====================================
	// Constructors
	// =====================================
	VxVector();
	VX_EXPORT explicit VxVector(const VxCompressedVector& v);
	VxVector(float f);
	VxVector(float _x, float _y, float _z);
	VxVector(const float f[3]);

	void			Absolute();
/*************************************************
Summary: Returns the square magnitude(length) of a vector.

Return Value:
	Square magnitude of the vector

Remarks:
	This method returns the square magnitude (length*length) of the vector v.


See also: Magnitude
*************************************************/
	float	SquareMagnitude () const {return x*x + y*y + z*z;}

/*************************************************
Summary: Returns the magnitude(length) of a vector.

Return Value:
	Magnitude of the vector

Remarks:
	This method returns the length of the vector v.
	WARNING: Calling this function with a null vector (0,0,0) will
	return an indefinite value (constant NaN - not a number)


See also: SquareMagnitude
*************************************************/
	float	Magnitude () const {return XSqrt(SquareMagnitude());}
	
	// =====================================
	// Access grants
	// =====================================
	const float&	operator[](int i) const;
	float&			operator[](int i);
	void			Set(float X,float Y,float Z);

	VxVector& operator += (const VxVector& v);
	VxVector& operator -= (const VxVector& v);
	VxVector& operator *= (const VxVector& v);
	VxVector& operator /= (const VxVector& v);
	VxVector& operator *= (float s);
	VxVector& operator /= (float s);
VX_EXPORT VxVector& operator = (const VxCompressedVector& v);

	float Dot(const VxVector& iV) const {return x*iV.x + y * iV.y + z * iV.z;}
	VxVector operator + (float s) const {return VxVector(x+s,y+s,z+s);}
	VxVector operator - (float s) const {return VxVector(x-s,y-s,z-s);}

	
	// =====================================
	// Unary operators
	// =====================================
	
	friend const VxVector operator + (const VxVector& v);
	friend const VxVector operator - (const VxVector& v);
	
	// =====================================
	// Binary operators
	// =====================================
	
	// Addition and subtraction
	friend const VxVector operator + (const VxVector& v1, const VxVector& v2);
	friend const VxVector operator - (const VxVector& v1, const VxVector& v2);
	// Scalar multiplication and division
	friend const VxVector operator * (const VxVector& v, float s);
	friend const VxVector operator * (float s, const VxVector& v);
	friend const VxVector operator / (const VxVector& v, float s);
	// Memberwise multiplication and division
	friend const VxVector operator * (const VxVector& v1, const VxVector& v2);
	friend const VxVector operator / (const VxVector& v1, const VxVector& v2);
	
	// Vector dominance
	friend int operator < (const VxVector& v1, const VxVector& v2);
	friend int operator <= (const VxVector& v1, const VxVector& v2);
	
	// Bitwise equality
	friend int operator == (const VxVector& v1, const VxVector& v2);
	friend int operator != (const VxVector& v1, const VxVector& v2);
	
	// Return min/max component of the input vector
	friend float	Min (const VxVector& v);
	friend float	Max (const VxVector& v);
	
		  // Return memberwise min/max of input vectors
	friend const VxVector	Minimize (const VxVector& v1, const VxVector& v2);
	friend const VxVector	Maximize (const VxVector& v1, const VxVector& v2);
	
	// Interpolate two vectors
	friend const VxVector Interpolate (float step, const VxVector& v1, const VxVector& v2);

	// In-place interpolate
	void Interpolate(float amount, const VxVector& target);
	
VX_EXPORT 	void			Normalize();
VX_EXPORT 	void			Rotate(const VxMatrix& M);

VX_EXPORT	const static VxVector& axisX();
VX_EXPORT	const static VxVector& axisY();
VX_EXPORT	const static VxVector& axisZ();
VX_EXPORT	const static VxVector& axis0();
VX_EXPORT	const static VxVector& axis1();
			const static VxVector m_AxisX;	
			const static VxVector m_AxisY;	
			const static VxVector m_AxisZ;	
			const static VxVector m_Axis0;	
			const static VxVector m_Axis1;	
};

/*************************************************
Name: Interpolate

Summary: Constructs a vector representing the interpolation of two vectors.

Arguments:
amount : The interpolation factor.
target: The vector toward which this vector is interpolated

Return value: None.



See also: VxVector
*************************************************/
inline void	VxVector::Interpolate(float amount, const VxVector& target)
{
	x += amount * (target.x - x);
	y += amount * (target.y - y);
	z += amount * (target.z - z);
}

/*************************************************
Name: SquareMagnitude

Summary: Returns the square magnitude(length) of a vector.

Input Arguments:
	v: a pointer to a VxVector which magnitude should be returned

Return Value:
	Square magnitude of v

Remarks:
	This method returns the square magnitude (length*length) of the vector v.



See also: Magnitude
*************************************************/
inline float	SquareMagnitude (const VxVector& v) {return v.x*v.x + v.y*v.y + v.z*v.z;}

/*************************************************
Name: Magnitude

Summary: Returns the magnitude(length) of a vector.

Input Arguments:
	v: a pointer to a VxVector which magnitude should be returned

Return Value:
	Magnitude of v

Remarks:
	This method returns the length of the vector v.
	WARNING: Calling this function with a null vector (0,0,0) will
	return an indefinite value (constant NaN - not a number)



See also: SquareMagnitude
*************************************************/
inline float	Magnitude (const VxVector& v) {return XSqrt(SquareMagnitude(v));}

/*************************************************
Name: InvSquareMagnitude

Summary: Returns the inverse square magnitude(length) of a vector.

Input Arguments:
	v: a pointer to a VxVector which inverse magnitude should be returned

Return Value:
	Inverse Square magnitude of v

Remarks:
	This method returns the inverse square magnitude (1/(length*length)) of the vector v.



See also: SquareMagnitude
*************************************************/
inline float	InvSquareMagnitude (const VxVector& v) {return 1.0f/SquareMagnitude(v);}

/*************************************************
Name: InvMagnitude

Summary: Returns the inverse magnitude(length) of a vector.

Input Arguments:
	v: a pointer to a VxVector which inverse magnitude should be returned

Remarks:
	This method returns the inverse magnitude (1/length) of the vector v.
	WARNING: Calling this function with a null vector (0,0,0) will
	return an indefinite value (constant NaN - not a number)

Return Value:
	Inverse magnitude of v



See also: Magnitude
*************************************************/
inline float	InvMagnitude (const VxVector& v) {return 1.0f/Magnitude(v);}

/*************************************************
Name: Normalize

Summary: Returns a normalized vector (length=1).

Input Arguments:
	Vect: a pointer to a VxVector
	v: Vector to normalize.

Return Value:
	A Vector equal to Vect Normalized.

Remarks:
	This method returns a vector equal to Vect normalized to length 1.0.
	WARNING: Calling this function with a null vector (0,0,0) will
	return an indefinite vector (constant NaN - not a number).
	This function is more precise than VxVector::Normalize.



See also: Magnitude,VxVector,Vx2DVector
*************************************************/
inline const VxVector Normalize (const VxVector& v) {return v*InvMagnitude(v);}

// Necessary for binding in VSL
#if defined(macintosh) || defined(PSX2) || defined(PSP)
	
	const VxVector NormalizeVectorNotInlined(const VxVector& v);
#endif

inline const VxVector Normalize (const VxVector *vect) {return Normalize(*vect);}

/*************************************************
Name: DotProduct

Summary: Calculates the dot product of two vectors.

Input Arguments:
	Vect1:  First source Vector.
	Vect2:  Second source Vector.

Return Value:
	A float result of the dot product of Vect1.Vect2.

Remarks:


See also: VxVector,Vx2DVector
*************************************************/
inline float DotProduct (const VxVector& v1, const VxVector& v2)
{
   return v1.x*v2.x + v1.y * v2.y + v1.z * v2.z;
}

/*************************************************
Name: CrossProduct

Summary: Calculates the cross product of two vectors.

Input Arguments:
	Vect1:  First source Vector.
	Vect2:  Second source Vector.

Return Value:
	A VxVector result of the cross product of Vect1^Vect2.



See also: VxVector
*************************************************/
inline const VxVector CrossProduct (const VxVector& Vect1, const VxVector& Vect2)
{
	return 
	VxVector(Vect1.y * Vect2.z - Vect1.z * Vect2.y,
		Vect1.z * Vect2.x - Vect1.x * Vect2.z
		,Vect1.x * Vect2.y - Vect1.y * Vect2.x);
}

/*************************************************
Summary: Returns the reflection of vector against a plane.

Input Arguments:
	v1: A pointer to a VxVector giving the incident vector (pointing away from the plane)
	Norm: A VxVector giving the normal point away from the plane of reflection.
Return Value:
	A Vector equal to the reflection of v1.

Remarks:
	This method calculates the vector reflection of v1 against the plane described by normal Norm.
using the following equation : 
	R = 2*(V dot N)*N - V

It is expected that the incident vector v1 is pointing away from the plane.
The resultant vector R will also be pointing away from the plane.


See also: DotProduct
*************************************************/
inline const VxVector Reflect(const VxVector& v1,const VxVector& Norm)
{
	float dp2 = 2.0f*(DotProduct(v1,Norm));
	return VxVector(dp2*Norm.x-v1.x,dp2*Norm.y-v1.y,dp2*Norm.z-v1.z);
}

VX_EXPORT 	const VxVector Rotate(const VxMatrix& mat,const VxVector& pt);
VX_EXPORT 	const VxVector Rotate(const VxVector& v1, const VxVector& v2,float angle);
VX_EXPORT 	const VxVector Rotate(const VxVector* v1, const VxVector* v2,float angle);

// For VSL Binding
#if defined(macintosh) || defined(PSX2) || defined(PSP)
	
	VX_EXPORT const VxVector RotateMV(const VxMatrix& mat,const VxVector& pt);
	
	VX_EXPORT const VxVector RotateVVF(const VxVector& v1, const VxVector& v2,float angle);
#endif

/*******************************************************
Name: VxCompressedVector

Summary: Class representation of a unit vector in 3 dimensions

Remarks:  
A VxCompressedVector is defined as:

			typedef struct VxCompressedVector 
			{
				short int xa,ya
			}

The xa and ya members are polar angles 

This representation can be used to store normals or unit vectors using less memory than a conventionnal vector.


***********************************************************/
typedef struct VxCompressedVector
{
public:
			short int xa,ya;	// Polar Angles

			VxCompressedVector() { xa=ya=0; }
			VxCompressedVector(float _x, float _y, float _z) { Set(_x,_y,_z); }

			// Set from a normalized vector
			VX_EXPORT void	Set(float X,float Y,float Z);
			// Spherical linear interpolation
			void	Slerp(float step,VxCompressedVector &v1,VxCompressedVector &v2);
			// Linear interpolation. The vector is kept normalized
			void	Lerp(float step,VxCompressedVector &v1,VxCompressedVector &v2);

			// =====================================
			// Unary operators
			// =====================================

			VxCompressedVector& operator = (const VxVector& v);
			VxCompressedVector& operator = (const VxCompressedVectorOld& v);
} VxCompressedVector;

/*************************************************
Summary: Spherical linear interpolation of a compressed vector by the given amount. 
Contrary to Lerp, Angle variation is linear.

Input Arguments:
step: Interpolation amount
vx1: Vector we are interpolating from
vx2: Vector we are interpolating to
*************************************************/
inline void VxCompressedVector::Slerp(float step,VxCompressedVector &v1,VxCompressedVector &v2)
{	
	VxVector cv1;
	cv1 = v1;
	VxVector cv2;
	cv2 = v2;
	// compute angle between the 2 vectors
	float dot = cv1.Dot(cv2);
	const float dotThreshold = 0.995f;
	if (dot > dotThreshold)
	{
		// The 2 vectors are very close, computing an orthonormal basis
		// may not be precise enough (sinus of the angle is close to 0, as the orthogonal component of v1 is -> normalization will be imprecise)
		// -> just interpolate linearly and renormalize
		// Linear interpolation is ok in this case because angle is ~ to sin(angle) for small angles
		cv1 = step * cv2 + (1.f - step) * cv1;
		cv1.Normalize();
	}
	else
	{
		// Slerp implies linearly interpolating the angle (linear interpolation of 2 unit vector doesn't lead
		// to a linear interpolation of their angle)
		// compute the desired angle
		XThreshold(dot, -1.f, 1.f); // stay in admissible values for acos
		float targetAngle = step * acosf(dot);
		// Now, construct an orthonormal basis
		cv2 = cv2 - dot * cv1; // only kept orthogonal part of v2 relative to v1
		cv2.Normalize(); // (v1, v2) is now orthogonal
		// in the orthonormal basis, just build target vector from desired angle
		cv1 = cosf(targetAngle) * cv1 + sinf(targetAngle) * cv2;
	}

	// back to polar coordinates
	Set(cv1.x, cv1.y, cv1.z);	
}

/*************************************************
Summary: Linear interpolation of a compressed vector by the given amount. 
Because the vector is stored in polar coordinate, it will remains unit sized after the
interpolation.

Input Arguments:
step: Interpolation amount
vx1: Vector we are interpolating from
vx2: Vector we are interpolating to
*************************************************/
inline void VxCompressedVector::Lerp(float step,VxCompressedVector &v1,VxCompressedVector &v2)
{							
	VxVector cv1(v1);	
	VxVector cv2(v2);
	cv1.Interpolate(step, cv2);		
	cv1.Normalize();	
	// back to polar coordinates
	Set(cv1.x, cv1.y, cv1.z);	
}


typedef struct VxCompressedVectorOld
{
public:
			int xa,ya;	// Polar Angles

			VxCompressedVectorOld() { xa=ya=0; }
			VxCompressedVectorOld(float _x, float _y, float _z) { Set(_x,_y,_z); }

			void	Set(float X,float Y,float Z);
			void	Slerp(float step,VxCompressedVectorOld &v1,VxCompressedVectorOld &v2);

			// =====================================
			// Unary operators
			// =====================================

			VxCompressedVectorOld& operator = (const VxVector& v);
			VxCompressedVectorOld& operator = (const VxCompressedVector& v);
} VxCompressedVectorOld;


/*******************************************************
{filename:VxVector4}
Name: VxVector4

Summary: Class representation of a Vector of 4 elements (x,y,z,w)

Remarks:
VxVector4 is used for 3D Transformation when the w component
is used for perspective information.
Most of the methods available for a VxVector are also implemented
for the VxVector4

A VxVector4 is defined as:

			typedef struct VxVector4 {
				union {
						struct {
							float x,y,z,w;
						};
						float v[4];
				};
			}



***********************************************************/
class VxVector4 : public VxVector
{
public:
	float w;

	VxVector4() { x=y=z=w=0.0f; }
	VxVector4(float f) { x=y=z=w=f; }
	VxVector4(float _x, float _y, float _z,float _w) { x=_x; y=_y; z=_z; w=_w; }
	VxVector4(const float f[4]){ x=f[0]; y=f[1]; z=f[2]; w=f[3]; }
	VxVector4& operator = (const VxVector& v) {x=v.x;y=v.y;z=v.z;return *this;}
	
	// =====================================
	// Access grants
	// =====================================
	const float&operator[](int i) const;
	float&operator[](int i);
	
#if defined(_LINUX)
	operator float*() const {return (float*)&x;}
#else
	operator float*() const {return (float*)&v[0];}
#endif
	
	// Initialization
	void			Set(float X,float Y,float Z,float W);
	void			Set(float X,float Y,float Z);
	float Dot(const VxVector4& iV) const {return x*iV.x + y * iV.y + z * iV.z;}
	
	VxVector4& operator += (const VxVector4& v);
	VxVector4& operator -= (const VxVector4& v);
	VxVector4& operator *= (const VxVector4& v);
	VxVector4& operator /= (const VxVector4& v);
	
	VxVector4& operator += (const VxVector& v);
	VxVector4& operator -= (const VxVector& v);
	VxVector4& operator *= (const VxVector& v);
	VxVector4& operator /= (const VxVector& v);

	VxVector4& operator *= (float s);
	VxVector4& operator /= (float s);
	VxVector4 operator + (float s) const {return VxVector4(x+s,y+s,z+s,w+s);}
	VxVector4 operator - (float s) const {return VxVector4(x-s,y-s,z-s,w-s);}

	
	// =====================================
	// Unary operators
	// =====================================
	
	friend const VxVector4 operator + (const VxVector4& v);
	friend const VxVector4 operator - (const VxVector4& v);
	
	// =====================================
	// Binary operators
	// =====================================
	
	// Addition and subtraction
	friend const VxVector4 operator + (const VxVector4& v1, const VxVector4& v2);
	friend const VxVector4 operator - (const VxVector4& v1, const VxVector4& v2);
	// Scalar multiplication and division
	friend const VxVector4 operator * (const VxVector4& v, float s);
	friend const VxVector4 operator * (float s, const VxVector4& v);
	friend const VxVector4 operator / (const VxVector4& v, float s);
	// Memberwise multiplication and division
	friend const VxVector4 operator * (const VxVector4& v1, const VxVector4& v2);
	friend const VxVector4 operator / (const VxVector4& v1, const VxVector4& v2);

	// Bitwise equality
	friend int operator == (const VxVector4& v1, const VxVector4& v2);
	friend int operator != (const VxVector4& v1, const VxVector4& v2);
	
};
 

/*******************************************************
{filename:VxBbox}
Summary: Class representation of a Bounding Box
Remarks:
The VxBbox structure contains two VxVector Min and Max to represents
the Minimum and Maximum coordinates of the corners of a box.

A VxBbox is defined as:

			typedef struct VxBbox {
				union {
					struct {
							VxVector Max;
							VxVector Min;
							}
					};
					float v[6];
				};
			}



***********************************************************/
typedef struct VxBbox
{
#if defined(_LINUX) || defined(PSX2) || defined(PSP) || defined (__GNUC__)
  VxVector Max;	// Maximum corner of the box
  VxVector Min;	// Minimum corner of the box
#else
	union
	{
		struct
		{
			VxVector Max;	// Maximum corner of the box
			VxVector Min;	// Minimum corner of the box
		};
		float v[6];
	};
#endif

	public:


	VxBbox():Max(-1e6f,-1e6f,-1e6f),Min(1e6f,1e6f,1e6f) {}
	VxBbox(VxVector iMin, VxVector iMax):Max(iMax),Min(iMin) {}
	VxBbox( float value ) {
		Max.x=value; Max.y=value; Max.z=value;
		Min.x=-value; Min.y=-value; Min.z=-value;
	}
	BOOL	IsValid() const
	{
		if (Min.x > Max.x) return FALSE;
		if (Min.y > Max.y) return FALSE;
		if (Min.z > Max.z) return FALSE;

		return TRUE;
	}
	VxVector GetSize() const {return Max - Min;}
	VxVector GetHalfSize() const {return (Max-Min)*0.5f;}
	VxVector GetCenter() const {return (Max+Min)*0.5f;}
	void SetCorners(const VxVector& min,const VxVector& max){Min = min;Max = max;}
	void SetDimension(const VxVector& position,const VxVector& size){Min = position;Max = position+size;}
	void SetCenter(const VxVector& center,const VxVector& halfsize)
	{
		Min = center-halfsize;
		Max = center+halfsize;
	}

//-------------------------------------------------------
// Name: Outline
// Summary: Outline bbox extent by the given radius
//-------------------------------------------------------
	void Outline(float radius)
	{
		Min.x -= radius;
		Min.y -= radius;
		Min.z -= radius;
		Max.x += radius;
		Max.y += radius;
		Max.z += radius;
	}


//-------------------------------------------------------
// Name: Reset
// Summary: Resets the minimum and maximum values of the box
// Remarks:
// The Reset method sets the Minimum Value to (1E6,1E6,1E6)
// and maximum value to (-1E6,-1E6,-1E6)
//-------------------------------------------------------
	void Reset()
	{
		Max.x=-1e6f; Max.y=-1e6f; Max.z=-1e6f;
		Min.x=1e6f; Min.y=1e6f; Min.z=1e6f;
	}


//-------------------------------------------------------
// Name: Merge
// Summary: Merges two boxes
// Arguments:
//		v : A VxBbox to merge to this box
// Remarks:
// The Merge method calculates the new extents of this box
// so it contains the v Box 
//-------------------------------------------------------
	void Merge (const VxBbox& v)
	{
		Max.x = XMax(v.Max.x,Max.x);
		Max.y = XMax(v.Max.y,Max.y);
		Max.z = XMax(v.Max.z,Max.z);

		Min.x = XMin(v.Min.x,Min.x);
		Min.y = XMin(v.Min.y,Min.y);
		Min.z = XMin(v.Min.z,Min.z);
	}

//-------------------------------------------------------
// Name: Merge
// Summary: Merges a vector with a box
// Arguments:
//		v : A vector to merge to this box
// Remarks:
// The Merge method calculates the new extents of this box
// so it contains the v point
//-------------------------------------------------------
	void Merge (const VxVector& v)
	{
		if (v.x > Max.x) Max.x = v.x;
		if (v.x < Min.x) Min.x = v.x;
		if (v.y > Max.y) Max.y = v.y;
		if (v.y < Min.y) Min.y = v.y;
		if (v.z > Max.z) Max.z = v.z;
		if (v.z < Min.z) Min.z = v.z;
	}

//-------------------------------------------------------
// Name: Classify
// Summary: Returns on which side a point is
// Remarks:
//  
// Return Value: 
//		A combination of the culling flags
// 
//-------------------------------------------------------
	DWORD Classify(const VxVector& iPoint) const
	{
		DWORD flag = 0;
		if (iPoint.x < Min.x)		flag |= VXCLIP_LEFT;
		else if (iPoint.x > Max.x)	flag |= VXCLIP_RIGHT;
		if (iPoint.y < Min.y)		flag |= VXCLIP_BOTTOM;
		else if (iPoint.y > Max.y)	flag |= VXCLIP_TOP;
		if (iPoint.z < Min.z)		flag |= VXCLIP_BACK;
		else if (iPoint.z > Max.z)	flag |= VXCLIP_FRONT;
		return flag;
	}

//-------------------------------------------------------
// Name: Classify
// Summary: Returns on which side a box is
// Remarks:
//  
// Return Value: 
//		A combination of the culling flags
// 
//-------------------------------------------------------
	DWORD Classify(const VxBbox& iBox) const
	{
		DWORD flag = 0;
		if (iBox.Max.z<Min.z)		flag |= VXCLIP_BACK; 
		else if (iBox.Min.z>Max.z)	flag |= VXCLIP_FRONT; 
		if (iBox.Max.x<Min.x)		flag |= VXCLIP_LEFT; 
		else if (iBox.Min.x>Max.x)	flag |= VXCLIP_RIGHT; 
		if (iBox.Max.y<Min.y)		flag |= VXCLIP_BOTTOM; 
		else if (iBox.Min.y>Max.y)	flag |= VXCLIP_TOP; 
		return flag;
	}

//-------------------------------------------------------
// Name: Classify
// Summary: Returns on which side a box is compared to point
// Remarks:
//  
// Return Value: 
//	 2 : If viewed from point pt the box box2 is on the opposite side of this box		
//	 1 : box2 is inside this box
//   0 : No idea where the box is 
// 
//-------------------------------------------------------
VX_EXPORT int Classify(const VxBbox& box2,const VxVector& pt) const;
	
//-------------------------------------------------------
// Summary: classify an array of vertices against
// the box. An array of dword is filled with
// flags from the enum VXCLIP_BOXFLAGS
// Remarks:
//  
//-------------------------------------------------------
VX_EXPORT void ClassifyVertices(const int iVcount, BYTE* iVertices, DWORD iStride, DWORD* oFlags) const;
//-------------------------------------------------------
// Summary: classify an array of vertices against
// one axis of the box. An array of dword is filled with
// flags 0x01 if < min, 0x10 if > max
// Remarks:
//  
//-------------------------------------------------------
VX_EXPORT void ClassifyVerticesOneAxis(const int iVcount, BYTE* iVertices, DWORD iStride, const int iAxis,DWORD* oFlags) const;

//-------------------------------------------------------
// Name: Intersect
// Summary: Intersects two boxes
// Arguments:
//		v : A VxBbox to intersect with this box
// Remarks:
// The Intersect method calculates the new extents of this box
// so it only contains the intersection with the v Box 
//-------------------------------------------------------
	void Intersect(const VxBbox& v)
	{
		Max.x = XMin(v.Max.x,Max.x);
		Max.y = XMin(v.Max.y,Max.y);
		Max.z = XMin(v.Max.z,Max.z);

		Min.x = XMax(v.Min.x,Min.x);
		Min.y = XMax(v.Min.y,Min.y);
		Min.z = XMax(v.Min.z,Min.z);
	}

//-------------------------------------------------------
// Name: VectorIn
// Summary: Tests if a point is inside the box.
// Arguments:
//		v : A VxVector to test if it is inside the box.
//
// Return Value: TRUE if v is inside this box, FALSE otherwise
//-------------------------------------------------------
	BOOL VectorIn(const VxVector& v) const
	{
		if (v.x<Min.x) return FALSE; 
		if (v.x>Max.x) return FALSE;
		if (v.y<Min.y) return FALSE; 
		if (v.y>Max.y) return FALSE;
		if (v.z<Min.z) return FALSE; 
		if (v.z>Max.z) return FALSE;
		return TRUE;
	}


//-------------------------------------------------------
// Name: IsBoxInside
// Summary: Tests if a box is totally inside this box.
// Arguments:
//		b : A VxBbox to test if it is inside the box.
//
// Return Value: TRUE if b is inside this box, FALSE otherwise
//-------------------------------------------------------
	BOOL IsBoxInside(const VxBbox& b) const
	{
		if (b.Min.x<Min.x) return 0; 
		if (b.Min.y<Min.y) return 0; 
		if (b.Min.z<Min.z) return 0; 

		if (b.Max.x>Max.x) return 0; 
		if (b.Max.y>Max.y) return 0; 
		if (b.Max.z>Max.z) return 0; 
		
		return 1;
	}
	
	bool operator == (const VxBbox& iBox) const {
		return (Max == iBox.Max) && (Min == iBox.Min);
	}

// Transform this box to eight points according to matrix mat
VX_EXPORT void TransformTo(VxVector *pts,const VxMatrix& Mat) const;
// Creates this box from sbox acording to matrix mat
VX_EXPORT void TransformFrom(const VxBbox& sbox,const VxMatrix& Mat);
// Get this bbox corners
inline void GetCorners(VxVector corners[8]) const;
} VxBbox;

inline VxVector::VxVector():x(0),y(0),z(0)
{
}

inline VxVector::VxVector(float f):x(f),y(f),z(f)
{
}

inline VxVector::VxVector(float _x, float _y, float _z):x(_x),y(_y),z(_z)
{
}

inline VxVector::VxVector(const float f[3]):x(f[0]),y(f[1]),z(f[2])
{
}

inline void	VxBbox::GetCorners(VxVector corners[8]) const
{
	corners[0].Set(Min.x, Min.y, Min.z);
	corners[1].Set(Max.x, Min.y, Min.z);
	corners[2].Set(Min.x, Max.y, Min.z);
	corners[3].Set(Max.x, Max.y, Min.z);
	//
	corners[4].Set(Min.x, Min.y, Max.z);
	corners[5].Set(Max.x, Min.y, Max.z);
	corners[6].Set(Min.x, Max.y, Max.z);
	corners[7].Set(Max.x, Max.y, Max.z);
}

// Initialization 
inline void VxVector::Set(float _x, float _y, float _z)
{
    x = _x; y = _y; z = _z;
}

inline const float& VxVector::operator[](int i) const
{
  return *((&x)+i);
}

inline float& VxVector::operator[](int i)
{
  return *((&x)+i);
}

inline VxVector& VxVector::operator += (const VxVector& v)
{
   x += v.x;   y += v.y;   z += v.z;
   return *this;
}

inline VxVector& VxVector::operator -= (const VxVector& v)
{
   x -= v.x;   y -= v.y;   z -= v.z;
   return *this;
}

inline VxVector& VxVector::operator *= (const VxVector& v)
{
   x *= v.x;   y *= v.y;   z *= v.z;
   return *this;
}

inline VxVector& VxVector::operator /= (const VxVector& v)
{
   x /= v.x;   y /= v.y;   z /= v.z;
   return *this;
}

inline VxVector& VxVector::operator *= (float s)
{
   x *= s;   y *= s;   z *= s;
   return *this;
}

inline VxVector& VxVector::operator /= (float s)
{
   float temp=1.0f/s;
   x *= temp;   y *= temp;   z *= temp;
   return *this;
}


// 
inline const VxVector operator + (const VxVector& v)
{
   return v;
}

// 
inline const VxVector operator - (const VxVector& v)
{
   return VxVector(-v.x, -v.y, -v.z);
}

inline const VxVector operator + (const VxVector& v1, const VxVector& v2)
{
   return VxVector(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z);
}

inline const VxVector operator - (const VxVector& v1, const VxVector& v2)
{
   return VxVector(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z);
}

// 
inline const VxVector operator * (const VxVector& v1, const VxVector& v2)
{
   return VxVector(v1.x*v2.x, v1.y*v2.y, v1.z*v2.z);
}
// 
inline const VxVector operator / (const VxVector& v1, const VxVector& v2)
{
   return VxVector(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z);
}

// 
inline int operator < (const VxVector& v1, const VxVector& v2)
{
   return v1[0] < v2[0] && v1[1] < v2[1] && v1[2] < v2[2];
}

// 
inline int operator <= (const VxVector& v1, const VxVector& v2)
{
   return v1[0] <= v2[0] && v1[1] <= v2[1] && v1[2] <= v2[2];
}


inline const VxVector operator * (const VxVector& v, float s)
{
   return VxVector(s*v.x, s*v.y, s*v.z);
}

inline const VxVector operator * (float s, const VxVector& v)
{
   return VxVector(s*v.x, s*v.y, s*v.z);
}

inline const VxVector operator / (const VxVector& v, float s)
{
   float temp=1.0f/s;
   return VxVector(v.x*temp, v.y*temp, v.z*temp);
}

// 
inline int operator == (const VxVector& v1, const VxVector& v2)
{
   return ( (v1.x==v2.x) && (v1.y==v2.y) && (v1.z==v2.z) );
}

// 
inline int operator != (const VxVector& v1, const VxVector& v2)
{
   return !(v1==v2);
}


/*************************************************
Name: Absolute

Summary: Calculates absolute value of a vector.

	- v: A reference to a VxVector.

Return value:
	 A VxVector with each element set to the absolute value of the corresponding element in v.



See also: VxVector,
*************************************************/
inline const VxVector Absolute (const VxVector& v)
{
   return VxVector(XAbs(v.x),XAbs(v.y),XAbs(v.z));
}

/*************************************************
Name: Absolute

Summary: Calculates absolute value of a vector.

Each element is set to its absolute value.

See also: VxVector
*************************************************/
void inline VxVector::Absolute ()
{
	x = XAbs(x);
	y = XAbs(y);
	z = XAbs(z);
}

/*************************************************
Name: MultiplyAdd

Summary: 'dest' is set to 'factor' * 'arg0' + 'arg1'

Arguments:
'dest': The target vector


*************************************************/
inline const void MultiplyAdd(VxVector& dest, float factor, const VxVector& arg0, const VxVector& arg1)
{
	dest.Set(factor * arg0.x + arg1.x, factor * arg0.y + arg1.y, factor * arg0.z + arg1.z);
}

/*************************************************
Name: Min

Summary: Calculates the minimum value among the elements of a vector.

Arguments:
	v: A Vector.

Return value: A float value containing the minimum of the elements of v.



See also: VxVector,Vx2DVector
*************************************************/
inline float Min (const VxVector& v)
{
   return XMin(v.x,v.y,v.z);
}

/*************************************************
Name: Max

Summary: Calculates the maximum value among the elements of a vector.

Arguments:
	v: A Vector.

Return value: A float value containing the maximum of the elements of v.



See also: VxVector,Vx2DVector
************************************************/
inline float Max (const VxVector& v)
{
   float ret = v.x;
   if (ret < v.y) ret = v.y;
   if (ret < v.z) ret = v.z;
   return ret;
}

/*************************************************
Name: Minimize

Summary: Constructs a vector containing minimum values of two vectors.

Arguments:
	v1: A Vector.
	v2: A Vector.

Return value: A VxVector containing with each element equal to the smallest element of v1 or v2.



See also: VxVector
*************************************************/
inline const VxVector Minimize (const VxVector& v1, const VxVector& v2)
{
   return VxVector(XMin(v1[0],v2[0]),XMin(v1[1],v2[1]),XMin(v1[2],v2[2]));
}

/*************************************************
Name: Maximize

Summary: Constructs a vector containing maximum values of two vectors.

Arguments:
	v1: A reference to a VxVector.
	v2: A reference to a VxVector.

Return value: A VxVector containing with each element equal to the greatest element of v1 or v2.



See also: VxVector
*************************************************/
inline const VxVector Maximize (const VxVector& v1, const VxVector& v2)
{
   return VxVector(XMax(v1[0],v2[0]),XMax(v1[1],v2[1]),XMax(v1[2],v2[2]));
}

/*************************************************
Name: Interpolate

Summary: Constructs a vector representing the interpolation of two vectors.

Arguments:
	step : The interpolation factor.
	v1: A reference to a VxVector.
	v2: A reference to a VxVector.

Return value: A VxVector .



See also: VxVector
*************************************************/
inline const VxVector Interpolate (float step, const VxVector& v1, const VxVector& v2)
{
   return VxVector( v1.x + (v2.x-v1.x) * step,
                    v1.y + (v2.y-v1.y) * step,
                    v1.z + (v2.z-v1.z) * step);
}

//------------------------------------------------------------------------------------------------------
// VxVector4 
//-------------------------------------------------------------------------------------------------------

inline VxVector4& VxVector4::operator += (const VxVector4& v)
{
   x += v.x;   y += v.y;   z += v.z;  w += v.w;
   return *this;
}

inline VxVector4& VxVector4::operator -= (const VxVector4& v)
{
   x -= v.x;   y -= v.y;   z -= v.z; w -= v.w;
   return *this;
}

inline VxVector4& VxVector4::operator *= (const VxVector4& v)
{
   x *= v.x;   y *= v.y;   z *= v.z; w *= v.w;
   return *this;
}

inline VxVector4& VxVector4::operator /= (const VxVector4& v)
{
   x /= v.x;   y /= v.y;   z /= v.z; w /= v.w;
   return *this;
}

inline VxVector4& VxVector4::operator += (const VxVector& v)
{
   x += v.x;   y += v.y;   z += v.z;
   return *this;
}

inline VxVector4& VxVector4::operator -= (const VxVector& v)
{
   x -= v.x;   y -= v.y;   z -= v.z; 
   return *this;
}

inline VxVector4& VxVector4::operator *= (const VxVector& v)
{
   x *= v.x;   y *= v.y;   z *= v.z; 
   return *this;
}

inline VxVector4& VxVector4::operator /= (const VxVector& v)
{
   x /= v.x;   y /= v.y;   z /= v.z; 
   return *this;
}

inline VxVector4& VxVector4::operator *= (float s)
{
   x *= s;   y *= s;   z *= s; w *= s;
   return *this;
}

inline VxVector4& VxVector4::operator /= (float s)
{
   float temp=1.0f/s;
   x *= temp;   y *= temp;   z *= temp; w *= temp;
   return *this;
}


// 
inline const VxVector4 operator + (const VxVector4& v)
{
   return v;
}

// 
inline const VxVector4 operator - (const VxVector4& v)
{
   return VxVector4(-v.x, -v.y, -v.z,-v.w);
}

inline const VxVector4 operator + (const VxVector4& v1, const VxVector4& v2)
{
   return VxVector4(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z,v1.w+v2.w);
}

inline const VxVector4 operator - (const VxVector4& v1, const VxVector4& v2)
{
   return VxVector4(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z,v1.w - v2.w);
}

// 
inline const VxVector4 operator * (const VxVector4& v1, const VxVector4& v2)
{
   return VxVector4(v1.x*v2.x, v1.y*v2.y, v1.z*v2.z,v1.w * v2.w);
}
// 
inline const VxVector4 operator / (const VxVector4& v1, const VxVector4& v2)
{
   return VxVector4(v1.x/v2.x, v1.y/v2.y, v1.z/v2.z,v1.w/v2.w);
}

inline const VxVector4 operator * (const VxVector4& v, float s)
{
   return VxVector4(s*v.x, s*v.y, s*v.z,s*v.w);
}

inline const VxVector4 operator * (float s, const VxVector4& v)
{
   return VxVector4(s*v.x, s*v.y, s*v.z,s*v.w);
}

inline const VxVector4 operator / (const VxVector4& v, float s)
{
   float invs = 1.0f / s;
   return VxVector4(invs*v.x, invs*v.y, invs*v.z,invs*v.w);
}

// 
inline int operator == (const VxVector4& v1, const VxVector4& v2)
{
   return ((v1.x==v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w));
}

// 
inline int operator != (const VxVector4& v1, const VxVector4& v2)
{
   return !(v1==v2);
}

// Initialization
inline void VxVector4::Set(float _x, float _y, float _z,float _w)
{
    x = _x; y = _y; z = _z; w=_w;
}

// Initialization
inline void VxVector4::Set(float _x, float _y, float _z)
{
    x = _x; y = _y; z = _z;
}


inline const float& VxVector4::operator[](int i) const
{
#if defined(_LINUX)
  return *((&x)+i);
#else
    return v[i];
#endif
}

inline float& VxVector4::operator[](int i)
{
#if defined(_LINUX)
  return *((&x)+i);
#else
    return v[i];
#endif
}

//------------------------------------------------------------------------------------------------------
// VxCompressed Vector 
//-------------------------------------------------------------------------------------------------------


/*************************************************
Name: Slerp

Summary: Performs a linear interpolation between two vectors.

Arguments:
	v1: A reference to a VxCompressedVectorOld.
	v2: A reference to a VxCompressedVectorOld.
	step: The interpolation factor, 0 means v1 and 1 means v2.

Remarks:
	


See also: VxVector
*************************************************/
inline void VxCompressedVectorOld::Slerp(float step,VxCompressedVectorOld &v1,VxCompressedVectorOld &v2)
{
	int v1y=((int)v1.ya+16384) & 16383;
	int v2y=((int)v2.ya+16384) & 16383;
	v2y=(v2y-v1y);
	if (v2y>8192) v2y=16384-v2y;
	else if (v2y<-8192) v2y=16384+v2y;
	xa=(int)((float)v1.xa+(float)(v2.xa-v1.xa)*step);
	ya=(int)((float)v1y+(float)v2y*step);
}

// 
inline VxCompressedVectorOld& VxCompressedVectorOld::operator = (const VxVector& v)
{
   Set(v.x,v.y,v.z);
   return *this;	
}


/*************************************************
Name: Set

Summary: Creates a VxCompressedVectorOld from 3 components.

Arguments:
	X,Y,Z: float components.

Remarks:
	


See also: VxVector
*************************************************/
inline void VxCompressedVectorOld::Set(float X,float Y,float Z)
{
// calcul de l'angle x
	xa = -radToAngle((float)asin(Y));
// calcul de l'angle y
	ya = radToAngle((float)atan2(X,Z));
}


// 
inline VxCompressedVector& VxCompressedVector::operator = (const VxVector& v)
{
   Set(v.x,v.y,v.z);
   return *this;	
}
/*
inline void VxCompressedVector::Set(float X,float Y,float Z)
{
// calcul de l'angle x
	xa = (short int)-radToAngle((float)asin(Y));
// calcul de l'angle y
	ya = (short int)radToAngle((float)atan2(X,Z));
}
*/

// 
inline VxCompressedVectorOld& VxCompressedVectorOld::operator = (const VxCompressedVector& v)
{
	xa=(int)v.xa;
	ya=(int)v.ya;
	return *this;
}

// 
inline VxCompressedVector& VxCompressedVector::operator = (const VxCompressedVectorOld& v)
{
	xa=(short int)v.xa;
	ya=(short int)v.ya;
	return *this;
}

#endif