#ifndef _VecMath_h
#define _VecMath_h

// File:	VecMath.h
//
//	Classes to support 2D and 3D linear vector space and their duals
//	D. P. Mitchell  95/06/02.
//
// History:
// -@- 07/06/95 (mikemarr) - added Print and Read functions
// -@- 08/01/95 (mikemarr) - added fuzzy compare for floats
// -@- 04/15/96 (mikemarr) - changed stdio stuff to don's stream stuff
// -@- 04/18/96 (mikemarr) - added vector.inl to this file
// -@- 06/21/96 (mikemarr) - added +=, etc. operators
// -@- 06/21/96 (mikemarr) - added Rotate
// -@- 10/29/97 (mikemarr) - removed I/O
//                         - changed +=,-=,*=,/= operators to return reference
//                         - added operator const float *
//                         - added Unitize, Perp, NormSquared, SetNorm, Negate
//                         - comments/cleanup
//                         - changed fuzzy equal to be IsEqual, operator == to be exact
//                         - bug fix on Transpose
//                         - changed multiple divides to be 1 divide + multiplies
//                         - assert on divide by zero
// -@- 11/04/97 (mikemarr) - added intialization with SIZE

// Function: FloatEquals
//    Peform a "fuzzy" compare of two floating point numbers.  This relies
//  on the IEEE bit representation of floating point numbers.
int	FloatEquals(float x1, float x2);

class CoVector2;
class CoVector3;
class Vector3;

// Class:		Vector2
// Hungarian:	v
// Description:
//    This class represents a floating point 2D column vector useful for computational
//  geometry calculations.
class  Vector2 {
public:
						Vector2()					{}
						Vector2(float a, float b)	: x(a), y(b) {}
						Vector2(const SIZE &siz)	: x(float(siz.cx)), y(float(siz.cy)) {}

	friend Vector2		operator +(const Vector2 &u, const Vector2 &v);
	friend Vector2		operator -(const Vector2 &u, const Vector2 &v);
	friend Vector2		operator -(const Vector2 &u);
	friend Vector2		operator *(const Vector2 &u, float a);
	friend Vector2		operator *(float a, const Vector2 &u);
	friend Vector2		operator /(const Vector2 &u, float a);
	friend int			operator ==(const Vector2 &u, const Vector2 &v);
	friend int			operator !=(const Vector2 &u, const Vector2 &v);

	friend Vector2 &	operator +=(Vector2 &u, const Vector2 &v);
	friend Vector2 &	operator -=(Vector2 &u, const Vector2 &v);
	friend Vector2 &	operator *=(Vector2 &u, float a);
	friend Vector2 &	operator /=(Vector2 &u, float a);

#ifndef DISABLE_CROSSDOT
	friend float 		Cross(const Vector2 &u, const Vector2 &v);
	friend float 		Dot(const Vector2 &u, const Vector2 &v);
#endif
	friend int			IsEqual(const Vector2 &u, const Vector2 &v);

						operator const float *() const { return &x; }

	CoVector2 			Transpose() const;
	float 				Norm() const;
	float 				NormSquared() const;
	void				SetNorm(float a);
	Vector2  			Unit() const;
	void				Unitize();
	Vector2				Perp() const;	// points to left
	void				Negate();

public:
	float				x, y;
};


// Class:		CoVector2
// Hungarian:	cv
// Description:
//    This class represents a floating point 2D row vector useful for computational
//  geometry calculations.
class  CoVector2 {
public:
						CoVector2()						{}
						CoVector2(float a, float b)		: x(a), y(b) {}
						CoVector2(const SIZE &siz)		: x(float(siz.cx)), y(float(siz.cy)) {}

	friend CoVector2	operator +(const CoVector2 &u, const CoVector2 &v);
	friend CoVector2	operator -(const CoVector2 &u, const CoVector2 &v);
	friend CoVector2	operator -(const CoVector2 &u);
	friend CoVector2	operator *(const CoVector2 &u, float a);
	friend CoVector2	operator *(float a, const CoVector2 &u);
	friend CoVector2	operator /(const CoVector2 &u, float a);
	friend int			operator ==(const CoVector2 &u, const CoVector2 &v);
	friend int			operator !=(const CoVector2 &u, const CoVector2 &v);

	friend CoVector2 &	operator +=(CoVector2 &u, const CoVector2 &v);
	friend CoVector2 &	operator -=(CoVector2 &u, const CoVector2 &v);
	friend CoVector2 &	operator *=(CoVector2 &u, float a);
	friend CoVector2 &	operator /=(CoVector2 &u, float a);

#ifndef DISABLE_CROSSDOT
	friend float		Cross(const CoVector2 &u, const CoVector2 &v);
	friend float		Dot(const CoVector2 &u, const CoVector2 &v);
#endif
	friend int			IsEqual(const CoVector2 &u, const CoVector2 &v);

						operator const float *() const { return &x; }

	Vector2				Transpose() const;
	float				Norm() const;
	float 				NormSquared() const;
	void				SetNorm(float a);
	CoVector2 			Unit() const;
	void		 		Unitize();
	friend float		operator *(const CoVector2 &c, const Vector2 &v);
	CoVector2			Perp() const; 	// points to left
	void				Negate();

public:
	float				x, y;
};


// Class:		Vector3
// Hungarian:	v
// Description:
//    This class represents a floating point 3D column vector useful for computational
//  geometry calculations.
class  Vector3 {
public:
						Vector3()							{}
						Vector3(float a, float b, float c)	: x(a), y(b), z(c) {}

	friend Vector3		operator +(const Vector3 &u, const Vector3 &v);
	friend Vector3		operator -(const Vector3 &u, const Vector3 &v);
	friend Vector3		operator -(const Vector3 &u);
	friend Vector3		operator *(const Vector3 &u, float a);
	friend Vector3		operator *(float a, const Vector3 &u);
	friend Vector3		operator /(const Vector3 &u, float a);
	friend int			operator ==(const Vector3 &u, const Vector3 &v);
	friend int			operator !=(const Vector3 &u, const Vector3 &v);

	friend Vector3 &	operator +=(Vector3 &u, const Vector3 &v);
	friend Vector3 &	operator -=(Vector3 &u, const Vector3 &v);
	friend Vector3 &	operator *=(Vector3 &u, float a);
	friend Vector3 &	operator /=(Vector3 &u, float a);

#ifndef DISABLE_CROSSDOT
	friend Vector3		Cross(const Vector3 &u, const Vector3 &v);
	friend float		Dot(const Vector3 &u, const Vector3 &v);
#endif
	friend int			IsEqual(const Vector3 &u, const Vector3 &v);

						operator const float *() const { return &x; }

	CoVector3			Transpose() const;
	float				Norm() const;
	float 				NormSquared() const;
	void				SetNorm(float a);
	Vector3				Unit() const;
	void		 		Unitize();
	Vector2				Project(DWORD iAxis) const;
	void				Rotate(const Vector3 &vAxis, float fTheta);
	void				Negate();

public:
	float				x, y, z;
};


// Class:		CoVector3
// Hungarian:	cv
// Description:
//    This class represents a floating point 3D row vector useful for computational
//  geometry calculations.
class  CoVector3 {
public:
						CoVector3()								{}
						CoVector3(float a, float b, float c)	: x(a), y(b), z(c) {}

	friend CoVector3	operator +(const CoVector3 &u, const CoVector3 &v);
	friend CoVector3	operator -(const CoVector3 &u, const CoVector3 &v);
	friend CoVector3	operator -(const CoVector3 &u);
	friend CoVector3	operator *(const CoVector3 &u, float a);
	friend CoVector3	operator *(float, const CoVector3 &u);
	friend CoVector3	operator /(const CoVector3 &u, float a);
	friend int			operator ==(const CoVector3 &u, const CoVector3 &v);
	friend int			operator !=(const CoVector3 &u, const CoVector3 &v);

	friend CoVector3 &	operator +=(CoVector3 &u, const CoVector3 &v);
	friend CoVector3 &	operator -=(CoVector3 &u, const CoVector3 &v);
	friend CoVector3 &	operator *=(CoVector3 &u, float a);
	friend CoVector3 &	operator /=(CoVector3 &u, float a);

#ifndef DISABLE_CROSSDOT
	friend CoVector3	Cross(const CoVector3 &u, const CoVector3 &v);
	friend float		Dot(const CoVector3 &u, const CoVector3 &v);
#endif
	friend int			IsEqual(const CoVector3 &u, const CoVector3 &v);

						operator const float *() const { return &x; }

	Vector3				Transpose() const;
	float				Norm() const;
	float 				NormSquared() const;
	void				SetNorm(float a);
	CoVector3			Unit() const;
	void				Unitize();
	friend float		operator *(const CoVector3 &c, const Vector3 &u);	// linear form
	void				Negate();

public:
	float				x, y, z;
};


////////////
// Vector2
////////////

inline Vector2
operator +(const Vector2 &u, const Vector2 &v)
{
	return Vector2(u.x+v.x, u.y+v.y);
}

inline Vector2
operator -(const Vector2 &u, const Vector2 &v)
{
	return Vector2(u.x-v.x, u.y-v.y);
}

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

inline Vector2
operator *(float a, const Vector2 &v)
{
	return Vector2(a*v.x, a*v.y);
}

inline Vector2
operator *(const Vector2 &v, float a)
{
	return Vector2(a*v.x, a*v.y);
}

inline Vector2
operator /(const Vector2 &v, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	return Vector2(v.x * fTmp, v.y * fTmp);
}

inline int
operator ==(const Vector2 &u, const Vector2 &v)
{
	return ((u.x == v.x) && (u.y == v.y));
}

inline int
IsEqual(const Vector2 &u, const Vector2 &v)
{
	return (FloatEquals(u.x, v.x) && FloatEquals(u.y, v.y));
}

inline int
operator !=(const Vector2 &u, const Vector2 &v)
{
	return !(u == v);
}

inline Vector2 &
operator +=(Vector2 &u, const Vector2 &v)
{
	u.x += v.x; 
	u.y += v.y;
	return u;
}

inline Vector2 &
operator -=(Vector2 &u, const Vector2 &v)
{
	u.x -= v.x; 
	u.y -= v.y;
	return u;
}

inline Vector2 &
operator *=(Vector2 &u, float a)
{
	u.x *= a;
	u.y *= a;
	return u;
}

inline Vector2 &
operator /=(Vector2 &u, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	u.x *= fTmp;
	u.y *= fTmp;
	return u;
}

#ifndef DISABLE_CROSSDOT
inline float
Cross(const Vector2 &u, const Vector2 &v)
{
	return u.x*v.y - u.y*v.x;
}

inline float
Dot(const Vector2 &u, const Vector2 &v)
{
	return u.x*v.x + u.y*v.y;
}
#endif

inline CoVector2
Vector2::Transpose() const
{
	return CoVector2(x, y);
}

inline Vector2
Vector2::Unit() const
{
	return *this/this->Norm();
}

inline void
Vector2::Unitize()
{
	*this /= this->Norm();
}

inline Vector2
Vector2::Perp() const
{
	return Vector2(-y, x);
}

inline float
Vector2::NormSquared() const
{
	return x*x + y*y;
}

inline void
Vector2::SetNorm(float a)
{
	*this *= (a / Norm());
}

inline void
Vector2::Negate()
{
	x = -x; y = -y;
}



//////////////
// CoVector2
//////////////

inline CoVector2
operator +(const CoVector2 &u, const CoVector2 &v)
{
	return CoVector2(u.x+v.x, u.y+v.y);
}

inline CoVector2
operator -(const CoVector2 &u, const CoVector2 &v)
{
	return CoVector2(u.x-v.x, u.y-v.y);
}

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

inline CoVector2
operator *(float a, const CoVector2 &v)
{
	return CoVector2(a*v.x, a*v.y);
}

inline CoVector2
operator *(const CoVector2 &v, float a)
{
	return CoVector2(a*v.x, a*v.y);
}

inline CoVector2
operator /(const CoVector2 &v, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	return CoVector2(v.x * fTmp, v.y * fTmp);
}

inline int
operator ==(const CoVector2 &u, const CoVector2 &v)
{
	return ((u.x == v.x) && (u.y == v.y));
}

inline int
IsEqual(const CoVector2 &u, const CoVector2 &v)
{
	return (FloatEquals(u.x, v.x) && FloatEquals(u.y, v.y));
}

inline int
operator !=(const CoVector2 &u, const CoVector2 &v)
{
	return !(u == v);
}

inline CoVector2 &
operator +=(CoVector2 &u, const CoVector2 &v)
{
	u.x += v.x; 
	u.y += v.y;
	return u;
}

inline CoVector2 &
operator -=(CoVector2 &u, const CoVector2 &v)
{
	u.x -= v.x; 
	u.y -= v.y;
	return u;
}

inline CoVector2 &
operator *=(CoVector2 &u, float a)
{
	u.x *= a;
	u.y *= a;
	return u;
}

inline CoVector2 &
operator /=(CoVector2 &u, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	u.x *= fTmp;
	u.y *= fTmp;
	return u;
}

#ifndef DISABLE_CROSSDOT
inline float
Cross(const CoVector2 &u, const CoVector2 &v)
{
	return u.x*v.y - u.y*v.x;
}

inline float
Dot(const CoVector2 &u, const CoVector2 &v)
{
	return u.x*v.x + u.y*v.y;
}
#endif

inline Vector2
CoVector2::Transpose() const
{
	return Vector2(x, y);
}

inline CoVector2
CoVector2::Unit() const
{
	return *this/this->Norm();
}

inline void
CoVector2::Unitize()
{
	*this /= this->Norm();
}

inline float
operator *(const CoVector2 &c, const Vector2 &v)
{
	return c.x*v.x + c.y*v.y;
}

inline CoVector2
CoVector2::Perp() const
{
	return CoVector2(-y, x);
}

inline float
CoVector2::NormSquared() const
{
	return x*x + y*y;
}

inline void
CoVector2::SetNorm(float a)
{
	*this *= (a / Norm());
}

inline void
CoVector2::Negate()
{
	x = -x; y = -y;
}

////////////
// Vector3
////////////

inline Vector3
operator +(const Vector3 &u, const Vector3 &v)
{
	return Vector3(u.x+v.x, u.y+v.y, u.z+v.z);
}

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

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

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

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

inline Vector3
operator /(const Vector3 &v, float a)
{
	float fTmp = 1.f / a;
	return Vector3(v.x * fTmp, v.y * fTmp, v.z * fTmp);
}

inline int
operator ==(const Vector3 &u, const Vector3 &v)
{
	return ((u.x == v.x) && (u.y == v.y) && (u.z == v.z));
}

inline int
IsEqual(const Vector3 &u, const Vector3 &v)
{
	return (FloatEquals(u.x, v.x) && FloatEquals(u.y, v.y) && FloatEquals(u.z, v.z));
}

inline int
operator !=(const Vector3 &u, const Vector3 &v)
{
	return !(u == v);
}

inline Vector3 &
operator +=(Vector3 &u, const Vector3 &v)
{
	u.x += v.x; 
	u.y += v.y;
	u.z += v.z;
	return u;
}

inline Vector3 &
operator -=(Vector3 &u, const Vector3 &v)
{
	u.x -= v.x; 
	u.y -= v.y;
	u.z -= v.z;
	return u;
}

inline Vector3 &
operator *=(Vector3 &u, float a)
{
	u.x *= a;
	u.y *= a;
	u.z *= a;
	return u;
}

inline Vector3 &
operator /=(Vector3 &u, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	u.x *= fTmp;
	u.y *= fTmp;
	u.z *= fTmp;
	return u;
}

#ifndef DISABLE_CROSSDOT
inline Vector3
Cross(const Vector3 &u, const Vector3 &v)
{
	return Vector3(u.y*v.z-u.z*v.y, u.z*v.x-u.x*v.z, u.x*v.y-u.y*v.x);
}

inline float
Dot(const Vector3 &u, const Vector3 &v)
{
	return u.x*v.x + u.y*v.y + u.z*v.z;
}
#endif

inline float
operator *(const CoVector3 &c, const Vector3 &v)
{
	return c.x*v.x + c.y*v.y + c.z*v.z;
}

inline CoVector3
Vector3::Transpose() const
{
	return CoVector3(x, y, z);
}

inline Vector3
Vector3::Unit() const
{
	return *this/this->Norm();
}

inline void
Vector3::Unitize()
{
	*this /= this->Norm();
}

inline float
Vector3::NormSquared() const
{
	return x*x + y*y + z*z;
}

inline void
Vector3::SetNorm(float a)
{
	*this *= (a / Norm());
}

inline void
Vector3::Negate()
{
	x = -x; y = -y; z = -z;
}

inline Vector2
Vector3::Project(DWORD iAxis) const
{
	switch (iAxis) {
	case 0: return Vector2(y, z);
	case 1: return Vector2(x, z);
	case 2: return Vector2(x, y);
	}
	return Vector2(0.f, 0.f);
}

//////////////
// CoVector3
//////////////

inline CoVector3
operator +(const CoVector3 &u, const CoVector3 &v)
{
	return CoVector3(u.x+v.x, u.y+v.y, u.z+v.z);
}

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

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

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

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

inline CoVector3
operator /(const CoVector3 &v, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	return CoVector3(v.x * fTmp, v.y * fTmp, v.z * fTmp);
}

inline int
operator ==(const CoVector3 &u, const CoVector3 &v)
{
	return ((u.x == v.x) && (u.y == v.y) && (u.z == v.z));
}

inline int
IsEqual(const CoVector3 &u, const CoVector3 &v)
{
	return (FloatEquals(u.x, v.x) && FloatEquals(u.y, v.y) && FloatEquals(u.z, v.z));
}

inline int
operator !=(const CoVector3 &u, const CoVector3 &v)
{
	return !(u == v);
}

inline CoVector3 &
operator +=(CoVector3 &u, const CoVector3 &v)
{
	u.x += v.x; 
	u.y += v.y;
	u.z += v.z;
	return u;
}

inline CoVector3 &
operator -=(CoVector3 &u, const CoVector3 &v)
{
	u.x -= v.x; 
	u.y -= v.y;
	u.z -= v.z;
	return u;
}

inline CoVector3 &
operator *=(CoVector3 &u, float a)
{
	u.x *= a;
	u.y *= a;
	u.z *= a;
	return u;
}

inline CoVector3 &
operator /=(CoVector3 &u, float a)
{
	MMASSERT(a != 0.f);
	float fTmp = 1.f/a;
	u.x *= fTmp;
	u.y *= fTmp;
	u.z *= fTmp;
	return u;
}

#ifndef DISABLE_CROSSDOT
inline CoVector3
Cross(const CoVector3 &u, const CoVector3 &v)
{
	return CoVector3(u.y*v.z-u.z*v.y, u.z*v.x-u.x*v.z, u.x*v.y-u.y*v.x);
}

inline float
Dot(const CoVector3 &u, const CoVector3 &v)
{
	return u.x*v.x + u.y*v.y + u.z*v.z;
}
#endif

inline Vector3
CoVector3::Transpose() const
{
	return Vector3(x, y, z);
}

inline CoVector3
CoVector3::Unit() const
{
	return *this/this->Norm();
}

inline void
CoVector3::Unitize()
{
	*this /= this->Norm();
}

inline float
CoVector3::NormSquared() const
{
	return x*x + y*y + z*z;
}

inline void
CoVector3::SetNorm(float a)
{
	*this *= (a / Norm());
}

inline void
CoVector3::Negate()
{
	x = -x; y = -y; z = -z;
}

#endif