/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEK_Math__
#define __GEK_Math__
/*! 
	\author MoJo
    \file GEKXMath.h
    \brief GEKvX Math Main Header
*/

/*! 
	\mainpage GEKvX Math Library
	\section disclamer Disclamer
		Game Excelleration Kit vX

		<center><img src="..\..\hourglass.jpg" alt="HourGlass SoftWare"></center>
		Copyright (C) 2001 by HourGlass Software NonInc

		This program is free software; you can redistribute it and/or modify
		it under the terms of the GNU General Public License as published by
		the Free Software Foundation; either version 2 of the License, or
		(at your option) any later version.

		This program is distributed in the hope that it will be useful,
		but WITHOUT ANY WARRANTY; without even the implied warranty of
		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
		GNU General Public License for more details.

		You should have received a copy of the GNU General Public License
		along with this program; if not, write to the Free Software
		Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

		Please read the file LICENSE.TXT for additional details.

		<a href="http://www.doxygen.org>Doxygen</a> was used for all documentation.
*/

#define _PI							3.14159265358979323846f		//!< Extended floating point definition of PI
#define _2_PI						6.28318530717958623200f		//!< Extended floating point definition of (PI * 2)
#define _PI_2						1.57079632679489661923f		//!< Extended floating point definition of (PI / 2)
#define _INV_PI						0.31830988618379069122f		//!< Extended floating point definition of Inverse PI
#define _DEGTORAD(x)				(x * (_PI / 180.0f))		//!< Macro to convert degrees to radians
#define _RADTODEG(x)				(x * (180.0f / _PI))		//!< Macro to convert radians to degrees
#define _EPSILON					1.0e-5f						//!< Small offset to account for floating point error

int __fastcall F2ID(float fValue);		//!< Rounds a value down and returns the integer
int __fastcall F2IU(float fValue);		//!< Rounds a value up and returns the integer
float __fastcall ABS(float fValue);		//!< Returns the absolute value of a value
float __fastcall SIN(float fValue);		//!< Returns the sin of a value
float __fastcall COS(float fValue);		//!< Returns the cos of a value
float TAN(float fValue);				//!< Returns the tangent of a value
float SQRT(float fValue);				//!< Returns the square root of a value
float __fastcall ISQRT(float fValue);	//!< Returns the inverse square root of a value
int NextSquare(int iValue);				//!< Returns the next possible squared value

template <typename CLASS>
inline void SWAP(CLASS &kValueA, CLASS &kValueB)
{
	CLASS kTemp = kValueA;
	kValueA = kValueB;
	kValueB = kTemp;
}

struct GEKVECTOR2;				//!< 2D Vector Class
struct GEKVECTOR3;				//!< 3D Vector Class
struct GEKVECTOR4;				//!< 4D Vector Class
struct GEKQUATERNION;			//!< 4D Quaternion Class
struct GEKMATRIX;				//!< 4x4 Matrix Class
struct GEKPLANE;				//!< Standard Plane Equation
typedef GEKVECTOR4 GEKCOLOR;	//!< RGBA Color Class
struct GEKSPHERE;				//!< Basic Bounding Sphere
struct GEKAABB;					//!< Basic Axis Aligned Bounding Box
struct GEKRAY;					//!< Basic Ray class

#include ".\Include\GEKRect.h"
#include ".\Include\GEKVector2.h"
#include ".\Include\GEKVector3.h"
#include ".\Include\GEKVector4.h"
#include ".\Include\GEKQuaternion.h"
#include ".\Include\GEKMatrix.h"
#include ".\Include\GEKPlane.h"

#include ".\Include\GEKCurve.h"
#include ".\Include\GEKContain.h"
#include ".\Include\GEKFrustum.h"

#include ".\Inline\GEKRect.inl"
#include ".\Inline\GEKVector2.inl"
#include ".\Inline\GEKVector3.inl"
#include ".\Inline\GEKVector4.inl"
#include ".\Inline\GEKQuaternion.inl"
#include ".\Inline\GEKMatrix.inl"
#include ".\Inline\GEKPlane.inl"

#endif
 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKContain__
#define __GEKContain__
/*! 
	\author MoJo
    \file GEKContain.h
    \brief Basic Containment
*/

struct GEKRAY
{
public:
	GEKVECTOR3 m_kOrigin;
	GEKVECTOR3 m_kVector;

public:
	GEKRAY(void);
	GEKRAY(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kVector);

	inline float GetLength(void) { return m_kVector.GetLength(); };
	inline GEKVECTOR3 GetEnd(void) { return (m_kOrigin + m_kVector); };
};

struct GEKAABB
{
public:
	GEKVECTOR3 m_kMin;
	GEKVECTOR3 m_kMax;

public:
	bool Collision(const GEKAABB &kAABB) const;
	bool Collision(const GEKSPHERE &kSphere) const;

	void Extend(const GEKVECTOR3 &kPoint);
	inline GEKVECTOR3 GetSize(void) { return (m_kMax - m_kMin); };
	inline GEKVECTOR3 GetCenter(void) { return ((m_kMax + m_kMin) / 2.0f); };
};

struct GEKSPHERE
{
public:
	GEKVECTOR3 m_kOrigin;
	float m_fRadius;

public:
	GEKSPHERE(void);
	GEKSPHERE(const GEKVECTOR3 &kOrigin, float fRadius);

	bool Collision(const GEKAABB &kAABB) const;
	bool Collision(const GEKSPHERE &kSphere) const;
};

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKCurve__
#define __GEKCurve__
/*! 
	\author MoJo
    \file GEKCurve.h
    \brief Curve Calculation
*/

#include <math.h>

template <class CLASS>
CLASS GEKXBernstein(float fFactor, CLASS *pkBase)
{
	CLASS kA(pkBase[0] * powf(fFactor, 3.0f));
	CLASS kB(pkBase[1] * (3.0f * powf(fFactor, 2.0f) * (1.0f - fFactor)));
	CLASS kC(pkBase[2] * (3.0f * fFactor * powf((1.0f - fFactor), 2.0f)));
	CLASS kD(pkBase[3] * powf((1.0f - fFactor), 3.0f));
	return ((kA + kB) + (kC + kD));
}

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKFrustum__
#define __GEKFrustum__
/*! 
	\author MoJo
    \file GEKCollide.h
    \brief Basic View Frustum
*/

struct GEKFRUSTUM
{
public:
	GEKPLANE m_akFrustum[6];

public:
	void Generate(const GEKMATRIX &kMatrix);

	bool Visible(const GEKVECTOR3 &kPoint) const;
	bool Visible(const GEKSPHERE &kSphere) const;
	bool Visible(const GEKAABB &kAABB) const;
};

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKMatrix__
#define __GEKMatrix__
/*! 
	\author MoJo
    \file GEKMatrix.h
    \brief 4x4 Matrix Class
*/

//! 4x4 Matrix Class
struct GEKMATRIX
{
public:
	union
	{
		float d[16];
		float m[4][4];

		struct
		{
			float _11, _12, _13, _14;	
			float _21, _22, _23, _24;
			float _31, _32, _33, _34;
			float _41, _42, _43, _44;
		};

		struct
		{
			GEKVECTOR4 rx;
			GEKVECTOR4 ry;
			GEKVECTOR4 rz;

			union
			{
				struct
				{
					GEKVECTOR3 t;
					float w;
				};

				struct
				{
					float x, y, z, w;
				};
			};
		};
	};

public:
	inline GEKMATRIX(void);
	inline GEKMATRIX(float *pfData);
	inline GEKMATRIX(float _11, float _12, float _13, float _14,
					 float _21, float _22, float _23, float _24,
					 float _31, float _32, float _33, float _34,
					 float _41, float _42, float _43, float _44);
	inline GEKMATRIX(const GEKMATRIX &kMatrix);
	inline GEKMATRIX(const GEKVECTOR3 &kAxis, float fAngle);
	inline GEKMATRIX(const GEKVECTOR3 &kEuler);

	//@{ 
	//! Assignment Operators
	inline GEKMATRIX operator = (const GEKMATRIX &kMatrix);
	void operator *= (const GEKMATRIX &kMatrix);
	//@}

	//@{ 
	//! Casting Operators
	inline float operator () (int iRow, int iCol) const;
	inline float operator () (int iRow, int iCol);
	inline operator const float * (void) const;
	inline operator float * (void);
	//@}

	//! Binary Operator
	GEKMATRIX operator * (const GEKMATRIX &kMatrix);

	inline void SetIdentity(void);								//!< Sets a matrix to identity
	void SetEuler(const GEKVECTOR3 &kEuler);					//!< Sets the XYZ euler angles of a rotation matrix
	void SetRotation(const GEKVECTOR3 &kAxis, float fAngle);	//!< Sets the axial angle of a rotation matrix
	void SetQuaternion(const GEKQUATERNION &kQuat);				//!< Converts a quaternion to a rotation matrix

	inline void SetScaling(const GEKVECTOR3 &kScale);			//!< Sets the scaling factor of a matrix
	inline GEKVECTOR3 GetScaling(void);							//!< Gets the scaling factor of a matrix

	void Transpose(void);										//!< Transposes a matrix
	inline float Determinant(void);								//!< Calculates the determinant of a matrix
	GEKMATRIX Inverse(void);									//!< Calculates the inverse of a matrix
	void Invert(void);											//!< Inverts a matrix

	//! Rotates a matrix preserving translations
	void Rotate(const GEKMATRIX &kMatrix);

	//@{
	//! Rotates a point by a rotation matrix
	GEKVECTOR3 Rotate(const GEKVECTOR2 &kVector);
	GEKVECTOR3 Rotate(const GEKVECTOR3 &kVector);
	GEKVECTOR3 Rotate(const GEKVECTOR4 &kVector);
	GEKVECTOR3 Rotate(const GEKVECTOR2 &kVector) const;
	GEKVECTOR3 Rotate(const GEKVECTOR3 &kVector) const;
	GEKVECTOR3 Rotate(const GEKVECTOR4 &kVector) const;
	//@}

	//@{
	//! Transforms a point by a matrix
	GEKVECTOR4 Transform(const GEKVECTOR2 &kVector);
	GEKVECTOR4 Transform(const GEKVECTOR3 &kVector);
	GEKVECTOR4 Transform(const GEKVECTOR4 &kVector);
	GEKVECTOR4 Transform(const GEKVECTOR2 &kVector) const;
	GEKVECTOR4 Transform(const GEKVECTOR3 &kVector) const;
	GEKVECTOR4 Transform(const GEKVECTOR4 &kVector) const;
	//@}
};

/*!
	\brief Creates an orthographic projection matrix
	\param fXMin [in] the minimum X value of the view volume
	\param fYMin [in] the minimum Y value of the view volume
	\param fXMax [in] the maximum X value of the view volume
	\param fYMax [in] the maximum Y value of the view volume
	\param fNear [in] the distance from the viewer to the near clipping plane
	\param fFar [in] the distance from the viewer to the far clipping plane

	The orthographic matrix is defined as follows:
<pre>
	fX		 0		  0		 fTX
	 0		fY		  0		 fTY
	 0		 0		-fZ		-fTZ
	 0		 0		  0		   1

	fX = (2.0f / (fXMax - fXMin))
	fY = (2.0f / (fYMax - fYMin))
	fZ = (-2.0f / (fFar - fNear))
	fTX = -((fXMax + fXMin) / (fXMax - fXMin))
	fTY = -((fYMax + fYMin) / (fYMax - fYMin))
	fTZ = -((fFar + fNear) / (fFar - fNear))
</pre>
*/
GEKMATRIX GEKMatrixOrtho(float fXMin, float fYMin, float fXMax, float fYMax, float fNear, float fFar);

/*!
	\brief Creates a perspective projection matrix
	\param fFOV [in] the field of view angle of the view volume
	\param fAspect [in] the width to height aspect ratio of the view volume
	\param fNear [in] the distance from the viewer to the near clipping plane
	\param fFar [in] the distance from the viewer to the far clipping plane
	
	The perspective matrix is defined as follows:
<pre>
	fX		 0		fA		 0
	 0		fY		fB		 0
	 0		 0		fC		fD
	 0		 0		-1		 0

	fX = ((2.0f * fNear) / (fXMax - fXMin))
	fY = ((2.0f * fNear) / (fYMax - fYMin))
	fA = ((fXMax + fXMin) / (fXMax - fXMin))
	fB = ((fYMax + fYMin) / (fYMax - fYMin))
	fC = -((fFar + fNear) / (fFar - fNear))
	fD = -((2.0f * fFar * fNear) / (fFar - fNear))
</pre>
*/
GEKMATRIX GEKMatrixPerspective(float fFOV, float fAspect, float fNear, float fFar);

/*!
	\brief Creates a matrix to mirror coordinates around a plane
	\param kPlane [in] the plane to mirror coordinates by
*/
GEKMATRIX GEKMatrixMirror(const GEKPLANE &kPlane);

/*!
	\brief Creates a view matrix based upon a direction
	\param kOrigin [in] the origin of the view matrix
	\param kTarget [in] the target of the view matrix
*/
GEKMATRIX GEKMatrixTarget(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kTarget);

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKPlane__
#define __GEKPlane__
/*! 
	\author MoJo
    \file GEKPlane.h
    \brief Plane Class
*/

//! Generates a normal from 3 planar points
GEKVECTOR3 GEKNormalize(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3);

//! Plane Class
struct GEKPLANE
{
public:
	GEKVECTOR3 n;
	float d;

public:
	inline GEKPLANE(void);
	inline GEKPLANE(const GEKPLANE &kPlane);
	inline GEKPLANE(float fA, float fB, float fC, float fD);
	inline GEKPLANE(const GEKVECTOR3 &kNormal, float fDistance);
	GEKPLANE(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3);

	//! Assignment Operator
	inline GEKPLANE operator = (const GEKPLANE &kPlane);

	//! Returns the distance from a plane to a point
	float Distance(const GEKVECTOR3 &kPoint) const;

	/*!
		\brief Returns the if a ray and a plane intersect
		\param kRay [in] the ray to check against
	*/
	bool Intersect(const GEKRAY &kRay) const;

	/*!
		\brief Returns the point of intersection of a ray to a plane
		\param kRay [in] the ray to check against
	*/
	GEKVECTOR3 Intersection(const GEKRAY &kRay) const;
};

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKQuaternion__
#define __GEKQuaternion__
/*! 
    \author MoJo
    \file GEKQuaternion.h
    \brief 4D Quaternion Class
*/

//! 4D Quaternion Class
struct GEKQUATERNION
{
public:
	float x;
	float y;
	float z;
	float w;

public:
	inline GEKQUATERNION(void);
	inline GEKQUATERNION(const GEKMATRIX &kMatrix);
	inline GEKQUATERNION(const GEKQUATERNION &kQuat);
	inline GEKQUATERNION(float fX, float fY, float fZ, float fW);
	inline GEKQUATERNION(const GEKVECTOR3 &kAxis, float fAngle);
	inline GEKQUATERNION(const GEKVECTOR3 &kEuler);

	//! Casting Operator
	inline operator float * (void);

	//@{
	//! Assignment Operators
	void operator *= (const GEKQUATERNION &kQuat);
	inline GEKQUATERNION operator = (const GEKQUATERNION &kQuat);
	inline operator -= (const GEKQUATERNION &kQuat);
	inline operator += (const GEKQUATERNION &kQuat);
	inline operator /= (float fScalar);
	inline operator *= (float fScalar);
	//@}

	//@{
	//! Binary Operators
	GEKQUATERNION operator * (const GEKQUATERNION &kQuat);
	inline GEKQUATERNION operator - (const GEKQUATERNION &kQuat);
	inline GEKQUATERNION operator + (const GEKQUATERNION &kQuat);
	inline GEKQUATERNION operator / (float fScalar);
	inline GEKQUATERNION operator * (float fScalar);
	//@}

	inline void SetIdentity(void);								//!< Sets a quaternion to identity
	void SetEuler(const GEKVECTOR3 &kEuler);					//!< Sets the XYZ euler angles of a quaternion
	void SetRotation(const GEKVECTOR3 &kAxis, float fAngle);	//!< Sets the axial angle of a quaternion
	void SetMatrix(const GEKMATRIX &kMatrix);					//!< Converts a rotation matrix to a quaternion
	
	inline float Dot(const GEKQUATERNION &kQuat);				//!< Calculates the dot product of two quaternions
	inline float LengthSqr(void);								//!< Calculates the square length of a quaternion
	inline float Length(void);									//!< Calculates the length of a quaternion

	GEKQUATERNION Normal(void);									//!< Calculates the normal of a quaternion
	void Normalize(void);										//!< Normalizes a quaternion

	GEKQUATERNION Slerp(const GEKQUATERNION &kQuat, float fFactor);	//!< Calculates the spherical interpolation of two quaternions
	GEKQUATERNION Lerp(const GEKQUATERNION &kQuat, float fFactor);	//!< Calculates the linear interpolation of two quaternions
};

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKRect__
#define __GEKRect__
/*! 
    \author MoJo
    \file GEKRect.h
    \brief Basic Rectangle Class
*/

//! Basic Rectangle Class
struct GEKRECT
{
public:
	
	float m_fXPos;
	float m_fYPos;
	float m_fXSize;
	float m_fYSize;

public:
	inline GEKRECT(void);
	inline GEKRECT(int iXPos, int iYPos, int iXSize, int iYSize);
	inline GEKRECT(float fXPos, float fYPos, float fXSize, float fYSize);
};

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKVECTOR2__
#define __GEKVECTOR2__
/*! 
    \author MoJo
    \file GEKVector2.h
    \brief 2D Vector Class
*/

//! 2D Vector Class
struct GEKVECTOR2
{
public:
	union
	{
		float xy[2];
		float uv[2];
		struct { float x, y; };
		struct { float u, v; };
	};

public:
	inline GEKVECTOR2(void);
	inline GEKVECTOR2(const GEKVECTOR2 &kVector);
	inline GEKVECTOR2(const GEKVECTOR3 &kVector);
	inline GEKVECTOR2(const GEKVECTOR4 &kVector);
	inline GEKVECTOR2(float fX, float fY);

	inline float &operator [] (int iAxis);
	inline bool operator < (const GEKVECTOR2 &kVector) const;
	inline bool operator > (const GEKVECTOR2 &kVector) const;

	//@{
	//! Casting operator
	inline operator float * (void);
	inline operator const float * (void) const;
	//@}

	//@{
	//! Assignment operators
	inline GEKVECTOR2 operator = (const GEKVECTOR2 &kVector);
	inline GEKVECTOR2 operator = (const GEKVECTOR3 &kVector);
	inline GEKVECTOR2 operator = (const GEKVECTOR4 &kVector);
	inline operator -= (const GEKVECTOR2 &kVector);
	inline operator += (const GEKVECTOR2 &kVector);
	inline operator /= (float fScalar);
	inline operator *= (float fScalar);
	//@}

	//@{
	//! Binary Operators
	inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector) const;
	inline GEKVECTOR2 operator + (const GEKVECTOR2 &kVector) const;
	inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector);
	inline GEKVECTOR2 operator + (const GEKVECTOR2 &kVector);
	inline GEKVECTOR2 operator / (float fScalar) const;
	inline GEKVECTOR2 operator * (float fScalar) const;
	inline GEKVECTOR2 operator / (float fScalar);
	inline GEKVECTOR2 operator * (float fScalar);
	//@}

	inline void SetLength(float fLength);					//!< Sets the length of a vector
	inline float GetLengthSqr(void) const;					//!< Calculates the square length of a vector
	inline float GetLengthSqr(void);						//!< Calculates the square length of a vector
	inline float GetLength(void) const;						//!< Calculates the length of a vector
	inline float GetLength(void);							//!< Calculates the length of a vector

	inline float GetAngle(const GEKVECTOR2 &kVector);		//!< Calculates the angle between two vectors
	inline float Distance(const GEKVECTOR2 &kVector) const;	//!< Calculates the distance to a vector
	inline float Distance(const GEKVECTOR2 &kVector);		//!< Calculates the distance to a vector
	inline float Dot(const GEKVECTOR2 &kVector) const;		//!< Calculates the dot product of two vectors
	inline float Dot(const GEKVECTOR2 &kVector);			//!< Calculates the dot product of two vectors

	inline GEKVECTOR2 Lerp(const GEKVECTOR2 &kVector, float fFactor) const;	//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR2 Lerp(const GEKVECTOR2 &kVector, float fFactor);		//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR2 Normal(void) const;									//!< Calculates the normal of a vector
	inline GEKVECTOR2 Normal(void);											//!< Calculates the normal of a vector
	inline void Normalize(void);											//!< Normalizes a vector
};

inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector);	//!< Negative Operator
inline GEKVECTOR2 operator - (GEKVECTOR2 &kVector);			//!< Negative Operator

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKVECTOR3__
#define __GEKVECTOR3__
/*! 
    \author MoJo
    \file GEKVector3.h
    \brief 3D Vector Class
*/

//! 3D Vector Class
struct GEKVECTOR3
{
public:
	union
	{
		float xyz[3];
		struct { float x, y, z; };
	};

public:
	inline GEKVECTOR3(void);
	inline GEKVECTOR3(const GEKVECTOR2 &kVector);
	inline GEKVECTOR3(const GEKVECTOR3 &kVector);
	inline GEKVECTOR3(const GEKVECTOR4 &kVector);
	inline GEKVECTOR3(float fX, float fY, float fZ);

	inline float &operator [] (int iAxis);
	inline bool operator < (const GEKVECTOR3 &kVector) const;
	inline bool operator > (const GEKVECTOR3 &kVector) const;

	//@{
	//! Casting operator
	inline operator float * (void);
	inline operator const float * (void) const;
	//@}

	//@{
	//! Assignment operators
	inline GEKVECTOR3 operator = (const GEKVECTOR2 &kVector);
	inline GEKVECTOR3 operator = (const GEKVECTOR3 &kVector);
	inline GEKVECTOR3 operator = (const GEKVECTOR4 &kVector);
	inline operator -= (const GEKVECTOR3 &kVector);
	inline operator += (const GEKVECTOR3 &kVector);
	inline operator /= (float fScalar);
	inline operator *= (float fScalar);
	//@}

	//@{
	//! Binary Operators
	inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector) const;
	inline GEKVECTOR3 operator + (const GEKVECTOR3 &kVector) const;
	inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector);
	inline GEKVECTOR3 operator + (const GEKVECTOR3 &kVector);
	inline GEKVECTOR3 operator / (float fScalar) const;
	inline GEKVECTOR3 operator * (float fScalar) const;
	inline GEKVECTOR3 operator / (float fScalar);
	inline GEKVECTOR3 operator * (float fScalar);
	//@}

	inline void SetLength(float fLength);						//!< Sets the length of a vector
	inline float GetLengthSqr(void) const;						//!< Calculates the square length of a vector
	inline float GetLengthSqr(void);							//!< Calculates the square length of a vector
	inline float GetLength(void) const;							//!< Calculates the length of a vector
	inline float GetLength(void);								//!< Calculates the length of a vector

	inline float GetAngle(const GEKVECTOR3 &kVector);		//!< Calculates the angle between two vectors
	inline GEKVECTOR3 Cross(const GEKVECTOR3 &kVector) const;	//!< Calculates the cross product of two vectors
	inline GEKVECTOR3 Cross(const GEKVECTOR3 &kVector);			//!< Calculates the cross product of two vectors
	inline float Distance(const GEKVECTOR3 &kVector) const;		//!< Calculates the distance to a vector
	inline float Distance(const GEKVECTOR3 &kVector);			//!< Calculates the distance to a vector
	inline float Dot(const GEKVECTOR3 &kVector) const;			//!< Calculates the dot product of two vectors
	inline float Dot(const GEKVECTOR3 &kVector);				//!< Calculates the dot product of two vectors

	inline GEKVECTOR3 Lerp(const GEKVECTOR3 &kVector, float fFactor) const;		//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR3 Lerp(const GEKVECTOR3 &kVector, float fFactor);			//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR3 Normal(void) const;										//!< Calculates the normal of a vector
	inline GEKVECTOR3 Normal(void);												//!< Calculates the normal of a vector
	inline void Normalize(void);												//!< Normalizes a vector
};

inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector);	//!< Negative Operator
inline GEKVECTOR3 operator - (GEKVECTOR3 &kVector);			//!< Negative Operator

#endif 

/***************************************************/
/* Game Excelleration Kit vX                       */
/* Copyright (C) 2001 by HourGlass Software NonInc */
/***************************************************/
#ifndef __GEKVECTOR4__
#define __GEKVECTOR4__
/*! 
    \author MoJo
    \file GEKVector4.h
    \brief 4D Vector Class
*/

//! 4D Vector Class
struct GEKVECTOR4
{
public:
	union
	{
		float xyzw[4];
		float rgba[4];
		struct { float x, y, z, w; };
		struct { float r, g, b, a; };
	};

public:
	inline GEKVECTOR4(void);
	inline GEKVECTOR4(const GEKVECTOR2 &kVector);
	inline GEKVECTOR4(const GEKVECTOR3 &kVector);
	inline GEKVECTOR4(const GEKVECTOR4 &kVector);
	inline GEKVECTOR4(float fX, float fY, float fZ, float fW);

	inline float &operator [] (int iAxis);
	inline bool operator < (const GEKVECTOR4 &kVector) const;
	inline bool operator > (const GEKVECTOR4 &kVector) const;

	//@{
	//! Casting operator
	inline operator float * (void);
	inline operator const float * (void) const;
	//@}

	//@{
	//! Assignment operators
	inline GEKVECTOR4 operator = (const GEKVECTOR2 &kVector);
	inline GEKVECTOR4 operator = (const GEKVECTOR3 &kVector);
	inline GEKVECTOR4 operator = (const GEKVECTOR4 &kVector);
	inline operator -= (const GEKVECTOR4 &kVector);
	inline operator += (const GEKVECTOR4 &kVector);
	inline operator /= (float fScalar);
	inline operator *= (float fScalar);
	//@}

	//@{
	//! Binary Operators
	inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector) const;
	inline GEKVECTOR4 operator + (const GEKVECTOR4 &kVector) const;
	inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector);
	inline GEKVECTOR4 operator + (const GEKVECTOR4 &kVector);
	inline GEKVECTOR4 operator / (float fScalar) const;
	inline GEKVECTOR4 operator * (float fScalar) const;
	inline GEKVECTOR4 operator / (float fScalar);
	inline GEKVECTOR4 operator * (float fScalar);
	//@}

	inline void SetLength(float fLength);						//!< Sets the length of a vector
	inline float GetLengthSqr(void) const;						//!< Calculates the square length of a vector
	inline float GetLengthSqr(void);							//!< Calculates the square length of a vector
	inline float GetLength(void) const;							//!< Calculates the length of a vector
	inline float GetLength(void);								//!< Calculates the length of a vector

	inline float GetAngle(const GEKVECTOR4 &kVector);		//!< Calculates the angle between two vectors
	inline GEKVECTOR4 Cross(const GEKVECTOR4 &kVector) const;	//!< Calculates the cross product of two vectors
	inline GEKVECTOR4 Cross(const GEKVECTOR4 &kVector);			//!< Calculates the cross product of two vectors
	inline float Distance(const GEKVECTOR4 &kVector) const;		//!< Calculates the distance to a vector
	inline float Distance(const GEKVECTOR4 &kVector);			//!< Calculates the distance to a vector
	inline float Dot(const GEKVECTOR4 &kVector) const;			//!< Calculates the dot product of two vectors
	inline float Dot(const GEKVECTOR4 &kVector);				//!< Calculates the dot product of two vectors

	inline GEKVECTOR4 Lerp(const GEKVECTOR4 &kVector, float fFactor) const;	//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR4 Lerp(const GEKVECTOR4 &kVector, float fFactor);		//!< Calculates the linear interpolation of two vectors
	inline GEKVECTOR4 Normal(void) const;									//!< Calculates the normal of a vector
	inline GEKVECTOR4 Normal(void);											//!< Calculates the normal of a vector
	void Normalize(void);													//!< Normalizes a vector
};

inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector);	//!< Negative Operator
inline GEKVECTOR4 operator - (GEKVECTOR4 &kVector);			//!< Negative Operator

#endif 

#include "..\GEKXMath.h"

GEKRAY::GEKRAY(void)
{
}

GEKRAY::GEKRAY(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kVector)
{
	m_kOrigin = kOrigin;
	m_kVector = kVector;
}

bool GEKAABB::Collision(const GEKAABB &kAABB) const
{
	if(m_kMin > kAABB.m_kMax) return false;
	if(m_kMax < kAABB.m_kMin) return false;
	return true;
}

inline bool GEK_AABB_Sphere_Collision(const GEKSPHERE &kSphere, const GEKAABB &kAABB)
{
	float fDistance = 0.0f;
	for(int iAxis = 0; iAxis < 3; iAxis++)
	{
		if(kSphere.m_kOrigin[iAxis] < kAABB.m_kMin[iAxis])
		{
			float fValue = (kSphere.m_kOrigin[iAxis] - kAABB.m_kMin[iAxis]);
			fDistance += (fValue * fValue);
		}
		else if(kSphere.m_kOrigin[iAxis] > kAABB.m_kMax[iAxis])
		{
			float fValue = (kSphere.m_kOrigin[iAxis] - kAABB.m_kMax[iAxis]);
			fDistance += (fValue * fValue);
		}
	}

	if(fDistance <= (kSphere.m_fRadius * kSphere.m_fRadius)) return true;
	return false;
}

bool GEKAABB::Collision(const GEKSPHERE &kSphere) const
{
	return GEK_AABB_Sphere_Collision(kSphere, *this);
}

void GEKAABB::Extend(const GEKVECTOR3 &kPoint)
{
	if(kPoint.x < m_kMin.x) m_kMin.x = kPoint.x;
	if(kPoint.y < m_kMin.y) m_kMin.y = kPoint.y;
	if(kPoint.z < m_kMin.z) m_kMin.z = kPoint.z;
	if(kPoint.x > m_kMax.x) m_kMax.x = kPoint.x;
	if(kPoint.y > m_kMax.y) m_kMax.y = kPoint.y;
	if(kPoint.z > m_kMax.z) m_kMax.z = kPoint.z;
}

GEKSPHERE::GEKSPHERE(void)
{
	m_fRadius = 0.0f;
}

GEKSPHERE::GEKSPHERE(const GEKVECTOR3 &kOrigin, float fRadius)
{
	m_kOrigin = kOrigin;
	m_fRadius = fRadius;
}

bool GEKSPHERE::Collision(const GEKAABB &kAABB) const
{
	return GEK_AABB_Sphere_Collision(*this, kAABB);
}

bool GEKSPHERE::Collision(const GEKSPHERE &kSphere) const
{
	GEKVECTOR3 kDistance(m_kOrigin - kSphere.m_kOrigin);
	float fDistance = kDistance.GetLengthSqr();

	float fRadius = (m_fRadius + kSphere.m_fRadius);
	if(fDistance <= (fRadius * fRadius)) return true;
	return false;
} 

#include "..\GEKXMath.h"
 

#include "..\GEKXMath.h"

void GEKFRUSTUM::Generate(const GEKMATRIX &kMatrix)
{
// Extract the near plane
	m_akFrustum[0].n.x = (kMatrix[ 3] + kMatrix[ 2]);
	m_akFrustum[0].n.y = (kMatrix[ 7] + kMatrix[ 6]);
	m_akFrustum[0].n.z = (kMatrix[11] + kMatrix[10]);
	m_akFrustum[0].d =   (kMatrix[15] + kMatrix[14]);
	
// Extract the far plane
	m_akFrustum[1].n.x = (kMatrix[ 3] - kMatrix[ 2]);
	m_akFrustum[1].n.y = (kMatrix[ 7] - kMatrix[ 6]);
	m_akFrustum[1].n.z = (kMatrix[11] - kMatrix[10]);
	m_akFrustum[1].d =   (kMatrix[15] - kMatrix[14]);

// Extract the left plane
	m_akFrustum[2].n.x = (kMatrix[ 3] + kMatrix[ 0]);
	m_akFrustum[2].n.y = (kMatrix[ 7] + kMatrix[ 4]);
	m_akFrustum[2].n.z = (kMatrix[11] + kMatrix[ 8]);
	m_akFrustum[2].d =   (kMatrix[15] + kMatrix[12]);

// Extract the right plane
	m_akFrustum[3].n.x = (kMatrix[ 3] - kMatrix[ 0]);
	m_akFrustum[3].n.y = (kMatrix[ 7] - kMatrix[ 4]);
	m_akFrustum[3].n.z = (kMatrix[11] - kMatrix[ 8]);
	m_akFrustum[3].d =   (kMatrix[15] - kMatrix[12]);

// Extract the bottom plane
	m_akFrustum[4].n.x = (kMatrix[ 3] + kMatrix[ 1]);
	m_akFrustum[4].n.y = (kMatrix[ 7] + kMatrix[ 5]);
	m_akFrustum[4].n.z = (kMatrix[11] + kMatrix[ 9]);
	m_akFrustum[4].d =   (kMatrix[15] + kMatrix[13]);

// Extract the top plane
	m_akFrustum[5].n.x = (kMatrix[ 3] - kMatrix[ 1]);
	m_akFrustum[5].n.y = (kMatrix[ 7] - kMatrix[ 5]);
	m_akFrustum[5].n.z = (kMatrix[11] - kMatrix[ 9]);
	m_akFrustum[5].d =   (kMatrix[15] - kMatrix[13]);
}

bool GEKFRUSTUM::Visible(const GEKVECTOR3 &kPoint) const
{
	for(int iIndex = 0; iIndex < 6; iIndex++)
	{
		if(m_akFrustum[iIndex].Distance(kPoint) <= 0.0f) return false;
	}

	return true;
}

bool GEKFRUSTUM::Visible(const GEKSPHERE &kSphere) const
{
	for(int iIndex = 0; iIndex < 6; iIndex++)
	{
		float fDistance = m_akFrustum[iIndex].Distance(kSphere.m_kOrigin);
		if(fDistance <= -kSphere.m_fRadius) return false;
	}

	return true;
}

bool GEKFRUSTUM::Visible(const GEKAABB &kAABB) const
{
	GEKVECTOR3 kPoint;
	for(int iIndex = 0; iIndex < 6; iIndex++)
	{
		kPoint.x = ((m_akFrustum[iIndex].n.x < 0.0f) ? kAABB.m_kMin.x : kAABB.m_kMax.x);
		kPoint.y = ((m_akFrustum[iIndex].n.y < 0.0f) ? kAABB.m_kMin.y : kAABB.m_kMax.y);
		kPoint.z = ((m_akFrustum[iIndex].n.z < 0.0f) ? kAABB.m_kMin.z : kAABB.m_kMax.z);
		if(m_akFrustum[iIndex].Distance(kPoint) <= 0.0f) return false;
	}

	return true;
} 

#include "..\GEKXMath.h"

GEKMATRIX GEKMATRIX::operator * (const GEKMATRIX &kMatrix)
{
	return GEKMATRIX(((_11 * kMatrix._11) + (_12 * kMatrix._21) + (_13 * kMatrix._31) + (_14 * kMatrix._41)),
					 ((_11 * kMatrix._12) + (_12 * kMatrix._22) + (_13 * kMatrix._32) + (_14 * kMatrix._42)),
					 ((_11 * kMatrix._13) + (_12 * kMatrix._23) + (_13 * kMatrix._33) + (_14 * kMatrix._43)),
					 ((_11 * kMatrix._14) + (_12 * kMatrix._24) + (_13 * kMatrix._34) + (_14 * kMatrix._44)),

					 ((_21 * kMatrix._11) + (_22 * kMatrix._21) + (_23 * kMatrix._31) + (_24 * kMatrix._41)),
					 ((_21 * kMatrix._12) + (_22 * kMatrix._22) + (_23 * kMatrix._32) + (_24 * kMatrix._42)),
					 ((_21 * kMatrix._13) + (_22 * kMatrix._23) + (_23 * kMatrix._33) + (_24 * kMatrix._43)),
					 ((_21 * kMatrix._14) + (_22 * kMatrix._24) + (_23 * kMatrix._34) + (_24 * kMatrix._44)),

					 ((_31 * kMatrix._11) + (_32 * kMatrix._21) + (_33 * kMatrix._31) + (_34 * kMatrix._41)),
					 ((_31 * kMatrix._12) + (_32 * kMatrix._22) + (_33 * kMatrix._32) + (_34 * kMatrix._42)),
					 ((_31 * kMatrix._13) + (_32 * kMatrix._23) + (_33 * kMatrix._33) + (_34 * kMatrix._43)),
					 ((_31 * kMatrix._14) + (_32 * kMatrix._24) + (_33 * kMatrix._34) + (_34 * kMatrix._44)),

					 ((_41 * kMatrix._11) + (_42 * kMatrix._21) + (_43 * kMatrix._31) + (_44 * kMatrix._41)),
					 ((_41 * kMatrix._12) + (_42 * kMatrix._22) + (_43 * kMatrix._32) + (_44 * kMatrix._42)),
					 ((_41 * kMatrix._13) + (_42 * kMatrix._23) + (_43 * kMatrix._33) + (_44 * kMatrix._43)),
					 ((_41 * kMatrix._14) + (_42 * kMatrix._24) + (_43 * kMatrix._34) + (_44 * kMatrix._44)));
}

void GEKMATRIX::operator *= (const GEKMATRIX &kMatrix)
{
	*this =  GEKMATRIX(((_11 * kMatrix._11) + (_12 * kMatrix._21) + (_13 * kMatrix._31) + (_14 * kMatrix._41)),
					   ((_11 * kMatrix._12) + (_12 * kMatrix._22) + (_13 * kMatrix._32) + (_14 * kMatrix._42)),
					   ((_11 * kMatrix._13) + (_12 * kMatrix._23) + (_13 * kMatrix._33) + (_14 * kMatrix._43)),
					   ((_11 * kMatrix._14) + (_12 * kMatrix._24) + (_13 * kMatrix._34) + (_14 * kMatrix._44)),

					   ((_21 * kMatrix._11) + (_22 * kMatrix._21) + (_23 * kMatrix._31) + (_24 * kMatrix._41)),
					   ((_21 * kMatrix._12) + (_22 * kMatrix._22) + (_23 * kMatrix._32) + (_24 * kMatrix._42)),
					   ((_21 * kMatrix._13) + (_22 * kMatrix._23) + (_23 * kMatrix._33) + (_24 * kMatrix._43)),
					   ((_21 * kMatrix._14) + (_22 * kMatrix._24) + (_23 * kMatrix._34) + (_24 * kMatrix._44)),

					   ((_31 * kMatrix._11) + (_32 * kMatrix._21) + (_33 * kMatrix._31) + (_34 * kMatrix._41)),
					   ((_31 * kMatrix._12) + (_32 * kMatrix._22) + (_33 * kMatrix._32) + (_34 * kMatrix._42)),
					   ((_31 * kMatrix._13) + (_32 * kMatrix._23) + (_33 * kMatrix._33) + (_34 * kMatrix._43)),
					   ((_31 * kMatrix._14) + (_32 * kMatrix._24) + (_33 * kMatrix._34) + (_34 * kMatrix._44)),

					   ((_41 * kMatrix._11) + (_42 * kMatrix._21) + (_43 * kMatrix._31) + (_44 * kMatrix._41)),
					   ((_41 * kMatrix._12) + (_42 * kMatrix._22) + (_43 * kMatrix._32) + (_44 * kMatrix._42)),
					   ((_41 * kMatrix._13) + (_42 * kMatrix._23) + (_43 * kMatrix._33) + (_44 * kMatrix._43)),
					   ((_41 * kMatrix._14) + (_42 * kMatrix._24) + (_43 * kMatrix._34) + (_44 * kMatrix._44)));
}

void GEKMATRIX::Rotate(const GEKMATRIX &kMatrix)
{
	GEKMATRIX kBase(*this);
	_11 = ((kBase._11 * kMatrix._11) + (kBase._12 * kMatrix._21) + (kBase._13 * kMatrix._31));
	_12 = ((kBase._11 * kMatrix._12) + (kBase._12 * kMatrix._22) + (kBase._13 * kMatrix._32));
	_13 = ((kBase._11 * kMatrix._13) + (kBase._12 * kMatrix._23) + (kBase._13 * kMatrix._33));

	_21 = ((kBase._21 * kMatrix._11) + (kBase._22 * kMatrix._21) + (kBase._23 * kMatrix._31));
	_22 = ((kBase._21 * kMatrix._12) + (kBase._22 * kMatrix._22) + (kBase._23 * kMatrix._32));
	_23 = ((kBase._21 * kMatrix._13) + (kBase._22 * kMatrix._23) + (kBase._23 * kMatrix._33));

	_31 = ((kBase._31 * kMatrix._11) + (kBase._32 * kMatrix._21) + (kBase._33 * kMatrix._31));
	_32 = ((kBase._31 * kMatrix._12) + (kBase._32 * kMatrix._22) + (kBase._33 * kMatrix._32));
	_33 = ((kBase._31 * kMatrix._13) + (kBase._32 * kMatrix._23) + (kBase._33 * kMatrix._33));
}

void GEKMATRIX::SetEuler(const GEKVECTOR3 &kEuler)
{
	SetIdentity();
	float fCOSx = COS(kEuler.x);
	float fSINx = SIN(kEuler.x);
	float fCOSy = COS(kEuler.y);
	float fSINy = SIN(kEuler.y);
	float fCOSz = COS(kEuler.z);
	float fSINz = SIN(kEuler.z);

	_11 = (fCOSy * fCOSz);
	_12 = (fCOSy * fSINz);
	_13 = (-fSINy);

	float fSINxSINy = (fSINx * fSINy);
	float fCOSxSINy = (fCOSx * fSINy);

	_21 = ((fSINxSINy * fCOSz) - (fCOSx * fSINz));
	_22 = ((fSINxSINy * fSINz) + (fCOSx * fCOSz));
	_23 = (fSINx * fCOSy);

	_31 = ((fCOSxSINy * fCOSz) + (fSINx * fSINz));
	_32 = ((fCOSxSINy * fSINz) - (fSINx * fCOSz));
	_33 = (fCOSx * fCOSy);
}

void GEKMATRIX::SetRotation(const GEKVECTOR3 &kAxis, float fAngle)
{
    float fCOS = COS(fAngle);
    float fSIN = SIN(fAngle);
	GEKVECTOR3 kNormal(((GEKVECTOR3 &)kAxis).Normal());

    _11 = ((kNormal.x * kNormal.x) * (1.0f - fCOS) + fCOS);
    _12 = ((kNormal.x * kNormal.y) * (1.0f - fCOS) - (kNormal.z * fSIN));
    _13 = ((kNormal.x * kNormal.z) * (1.0f - fCOS) + (kNormal.y * fSIN));

    _21 = ((kNormal.y * kNormal.x) * (1.0f - fCOS) + (kNormal.z * fSIN));
    _22 = ((kNormal.y * kNormal.y) * (1.0f - fCOS) + fCOS);
    _23 = ((kNormal.y * kNormal.z) * (1.0f - fCOS) - (kNormal.x * fSIN));

    _31 = ((kNormal.z * kNormal.x) * (1.0f - fCOS) - (kNormal.y * fSIN));
    _32 = ((kNormal.z * kNormal.y) * (1.0f - fCOS) + (kNormal.x * fSIN));
    _33 = ((kNormal.z * kNormal.z) * (1.0f - fCOS) + fCOS);
}

void GEKMATRIX::SetQuaternion(const GEKQUATERNION &kQuat)
{
	float f2X = (kQuat.x * 2.0f);
	float f2Y = (kQuat.y * 2.0f);
	float f2Z = (kQuat.z * 2.0f);
	float fWX = (kQuat.w * f2X);
	float fWY = (kQuat.w * f2Y);
	float fWZ = (kQuat.w * f2Z);
	float fXX = (kQuat.x * f2X);
	float fXY = (kQuat.x * f2Y);
	float fXZ = (kQuat.x * f2Z);
	float fYY = (kQuat.y * f2Y);
	float fYZ = (kQuat.y * f2Z);
	float fZZ = (kQuat.z * f2Z);
	
	_11 = (1.0f - fYY - fZZ);
	_12 = (fXY + fWZ);
	_13 = (fXZ - fWY);

	_21 = (fXY - fWZ);
	_22 = (1.0f - fXX - fZZ);
	_23 = (fYZ + fWX);

	_31 = (fXZ + fWY);
	_32 = (fYZ - fWX);
	_33 = (1.0f - fXX - fYY);
}

void GEKMATRIX::Transpose(void)
{
	GEKMATRIX kMatrix(*this);
    _11 = kMatrix._11;    _12 = kMatrix._21;    _13 = kMatrix._31;    _14 = kMatrix._41;
    _21 = kMatrix._12;    _22 = kMatrix._22;    _23 = kMatrix._32;    _24 = kMatrix._42;
    _31 = kMatrix._13;    _32 = kMatrix._23;    _33 = kMatrix._33;    _34 = kMatrix._43;
    _41 = kMatrix._14;    _42 = kMatrix._24;    _43 = kMatrix._34;    _44 = kMatrix._44;
}

GEKMATRIX GEKMATRIX::Inverse(void)
{
/*	if((ABS(_44 - 1.0f) > 0.001f)||
	   (ABS(_14) > 0.001f)||
	   (ABS(_24) > 0.001f)||
	   (ABS(_34) > 0.001f)) return *this;*/

	GEKMATRIX kResult;
	float fDetInverse = (1.0f / Determinant());
    kResult._11 = ( fDetInverse * ((_22 * _33) - (_23 * _32)));
    kResult._12 = (-fDetInverse * ((_12 * _33) - (_13 * _32)));
    kResult._13 = ( fDetInverse * ((_12 * _23) - (_13 * _22)));
    kResult._14 = 0.0f;

    kResult._21 = (-fDetInverse * ((_21 * _33) - (_23 * _31)));
    kResult._22 = ( fDetInverse * ((_11 * _33) - (_13 * _31)));
    kResult._23 = (-fDetInverse * ((_11 * _23) - (_13 * _21)));
    kResult._24 = 0.0f;

    kResult._31 = ( fDetInverse * ((_21 * _32) - (_22 * _31)));
    kResult._32 = (-fDetInverse * ((_11 * _32) - (_12 * _31)));
    kResult._33 = ( fDetInverse * ((_11 * _22) - (_12 * _21)));
    kResult._34 = 0.0f;

    kResult._41 = -((_41 * kResult._11) + (_42 * kResult._21) + (_43 * kResult._31));
    kResult._42 = -((_41 * kResult._12) + (_42 * kResult._22) + (_43 * kResult._32));
    kResult._43 = -((_41 * kResult._13) + (_42 * kResult._23) + (_43 * kResult._33));
    kResult._44 = 1.0f;
	return kResult;
}

void GEKMATRIX::Invert(void)
{
	*this = Inverse();
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR2 &kVector)
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21)),
					  ((kVector.x * _12) + (kVector.y * _22)),
					  ((kVector.x * _13) + (kVector.y * _23)));
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR3 &kVector)
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33)));
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR4 &kVector)
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33)));
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR2 &kVector) const
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21)),
					  ((kVector.x * _12) + (kVector.y * _22)),
					  ((kVector.x * _13) + (kVector.y * _23)));
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR3 &kVector) const
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33)));
}

GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR4 &kVector) const
{
	return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33)));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR2 &kVector)
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + _41),
					  ((kVector.x * _12) + (kVector.y * _22) + _42),
					  ((kVector.x * _13) + (kVector.y * _23) + _43),
					  ((kVector.x * _14) + (kVector.y * _24) + _44));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR3 &kVector)
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + _41),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + _42),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + _43),
					  ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + _44));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR4 &kVector)
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + (kVector.w * _41)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + (kVector.w * _42)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + (kVector.w * _43)),
					  ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + (kVector.w * _44)));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR2 &kVector) const
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + _41),
					  ((kVector.x * _12) + (kVector.y * _22) + _42),
					  ((kVector.x * _13) + (kVector.y * _23) + _43),
					  ((kVector.x * _14) + (kVector.y * _24) + _44));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR3 &kVector) const
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + _41),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + _42),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + _43),
					  ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + _44));
}

GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR4 &kVector) const
{
	return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + (kVector.w * _41)),
					  ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + (kVector.w * _42)),
					  ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + (kVector.w * _43)),
					  ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + (kVector.w * _44)));
}

GEKMATRIX GEKMatrixOrtho(float fXMin, float fYMin, float fXMax, float fYMax, float fNear, float fFar)
{
	float fX = (2.0f / (fXMax - fXMin));
	float fY = (2.0f / (fYMax - fYMin));
	float fZ = (-2.0f / (fFar - fNear));
	float fTX = -((fXMax + fXMin) / (fXMax - fXMin));
	float fTY = -((fYMax + fYMin) / (fYMax - fYMin));
	float fTZ = -((fFar + fNear) / (fFar - fNear));

	return GEKMATRIX(  fX, 0.0f, 0.0f, 0.0f,
					 0.0f,  -fY, 0.0f, 0.0f,
					 0.0f, 0.0f,  -fZ, 0.0f,
					  fTX, -fTY, -fTZ, 1.0f);
}

GEKMATRIX GEKMatrixPerspective(float fFOV, float fAspect, float fNear, float fFar)
{
	float fYMax = (fNear * (SIN(fFOV / 2.0f) / COS(fFOV / 2.0f)));
	float fXMax = (fYMax * fAspect);
	float fYMin = -fYMax;
	float fXMin = -fXMax;

	float fX = ((2.0f * fNear) / (fXMax - fXMin));
	float fY = ((2.0f * fNear) / (fYMax - fYMin));
	float fA = ((fXMax + fXMin) / (fXMax - fXMin));
	float fB = ((fYMax + fYMin) / (fYMax - fYMin));
	float fC = -((fFar + fNear) / (fFar - fNear));
	float fD = -((2.0f * fFar * fNear) / (fFar - fNear));

	return GEKMATRIX(  fX, 0.0f,   fA, 0.0f,
					 0.0f,   fY,   fB, 0.0f,
					 0.0f, 0.0f,  -fC,  -fD,
					 0.0f, 0.0f,-1.0f, 0.0f);
}

GEKMATRIX GEKMatrixMirror(const GEKPLANE &kPlane)
{
	float fX = kPlane.n.x;
	float fY = kPlane.n.y;
	float fZ = kPlane.n.z;
	float fD = kPlane.d;

	return GEKMATRIX((0.0f - (2.0f * fX * fX)), (0.0f - (2.0f * fX * fY)), (0.0f - (2.0f * fX * fZ)), 0.0f,
					 (0.0f - (2.0f * fY * fX)), (0.0f - (2.0f * fY * fY)), (0.0f - (2.0f * fY * fZ)), 0.0f,
					 (0.0f - (2.0f * fZ * fX)), (0.0f - (2.0f * fZ * fY)), (0.0f - (2.0f * fZ * fZ)), 0.0f,
					 (0.0f - (2.0f * fD * fX)), (0.0f - (2.0f * fD * fY)), (0.0f - (2.0f * fD * fZ)), 1.0f);
}

GEKMATRIX GEKMatrixTarget(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kTarget)
{
	GEKVECTOR3 kZAxis(kTarget - kOrigin);
	kZAxis.Normalize();

	GEKVECTOR3 m_kYAxis(0.0f, 1.0f, 0.0f);
	GEKVECTOR3 kXAxis(m_kYAxis.Cross(kZAxis));
	kXAxis.Normalize();

	GEKVECTOR3 kYAxis(kZAxis.Cross(kXAxis));

	return GEKMATRIX(kXAxis.x, kXAxis.y, kXAxis.z, -kXAxis.Dot(kOrigin),
					 kYAxis.x, kYAxis.y, kYAxis.z, -kYAxis.Dot(kOrigin),
					 kZAxis.x, kZAxis.y, kZAxis.z, -kZAxis.Dot(kOrigin),
					 0.0f, 0.0f, 0.0f, 1.0f);
} 

#include "..\GEKXMath.h"

GEKVECTOR3 GEKNormalize(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3)
{
	GEKVECTOR3 kVectorA(kVector2 - kVector1);
	GEKVECTOR3 kVectorB(kVector3 - kVector1);
	GEKVECTOR3 kCross(kVectorA.Cross(kVectorB));
	return kCross.Normal();
}

GEKPLANE::GEKPLANE(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3)
{
	n = GEKNormalize(kVector1, kVector2, kVector3);
	d = -n.Dot(kVector1);
}

float GEKPLANE::Distance(const GEKVECTOR3 &kPoint) const
{
	return (n.Dot(kPoint) + d);
}

bool GEKPLANE::Intersect(const GEKRAY &kRay) const
{
	float fDistanceA = Distance(kRay.m_kOrigin);
	float fDistanceB = Distance(kRay.m_kOrigin + kRay.m_kVector);
	if((fDistanceA > 0.0f)&&(fDistanceB < 0.0f)) return true;
	if((fDistanceA < 0.0f)&&(fDistanceB > 0.0f)) return true;
	return false;
}

GEKVECTOR3 GEKPLANE::Intersection(const GEKRAY &kRay) const
{
	float fNumer = n.Dot(kRay.m_kOrigin);
	float fDenom = n.Dot(kRay.m_kVector);
	float fInter = (d - (fNumer / fDenom));
	return (kRay.m_kOrigin + (kRay.m_kVector * fInter));
} 

#include "..\GEKXMath.h"

GEKQUATERNION GEKQUATERNION::operator * (const GEKQUATERNION &kQuat)
{
	GEKQUATERNION kResult;
	kResult.x = ((w * kQuat.x) + (x * kQuat.w) + (y * kQuat.z) - (z * kQuat.y));
	kResult.y = ((w * kQuat.y) - (x * kQuat.z) + (y * kQuat.w) + (z * kQuat.x));
	kResult.z = ((w * kQuat.z) + (x * kQuat.y) - (y * kQuat.x) + (z * kQuat.w));
	kResult.w = ((w * kQuat.w) - (x * kQuat.x) - (y * kQuat.y) - (z * kQuat.z));
	return kResult;
}

void GEKQUATERNION::operator *= (const GEKQUATERNION &kQuat)
{
	GEKQUATERNION kResult;
	kResult.x = ((w * kQuat.x) + (x * kQuat.w) + (y * kQuat.z) - (z * kQuat.y));
	kResult.y = ((w * kQuat.y) - (x * kQuat.z) + (y * kQuat.w) + (z * kQuat.x));
	kResult.z = ((w * kQuat.z) + (x * kQuat.y) - (y * kQuat.x) + (z * kQuat.w));
	kResult.w = ((w * kQuat.w) - (x * kQuat.x) - (y * kQuat.y) - (z * kQuat.z));
	*this = kResult;
}

void GEKQUATERNION::SetEuler(const GEKVECTOR3 &kEuler)
{
    float fSINx = SIN(kEuler.x * 0.5f);
    float fSINy = SIN(kEuler.y * 0.5f);
    float fSINz = SIN(kEuler.z * 0.5f);
    float fCOSx = COS(kEuler.x * 0.5f);
    float fCOSy = COS(kEuler.y * 0.5f);
    float fCOSz = COS(kEuler.z * 0.5f);
	float fSINyCOSz = (fSINy * fCOSz);
	float fSINySINz = (fSINy * fSINz);
	float fCOSyCOSz = (fCOSy * fCOSz);
	float fCOSySINz = (fCOSy * fSINz);

	x = ((fSINx * fCOSyCOSz) - (fCOSx * fSINySINz));
	y = ((fSINx * fCOSySINz) + (fCOSx * fSINyCOSz));
	z = ((fCOSx * fCOSySINz) - (fSINx * fSINyCOSz));
	w = ((fCOSx * fCOSyCOSz) + (fSINx * fSINySINz));
}

void GEKQUATERNION::SetRotation(const GEKVECTOR3 &kAxis, float fAngle)
{
	GEKVECTOR3 kNormal(((GEKVECTOR3 &)kAxis).Normal());
	float fSinA = SIN(fAngle * 0.5f);

	x = (kNormal.x * fSinA);
	y = (kNormal.y * fSinA);
	z = (kNormal.z * fSinA);
	w = COS(fAngle * 0.5f);
}

void GEKQUATERNION::SetMatrix(const GEKMATRIX &kMatrix)
{
static int aiNext[3] = {1, 2, 0};
	float fDiagonal = (kMatrix._11 + kMatrix._22 + kMatrix._33);
	if(fDiagonal > 0.0f)
	{
		float fSQRT = SQRT(fDiagonal + 1.0f);
		w = (fSQRT / 2.0f);

		fSQRT = (0.5f / fSQRT);
		x = ((kMatrix._23 - kMatrix._32) * fSQRT);
		y = ((kMatrix._31 - kMatrix._13) * fSQRT);
		z = ((kMatrix._12 - kMatrix._21) * fSQRT);
	}
	else
	{
		int iCount = 0; 
		if(kMatrix._22 > kMatrix._11) iCount = 1;
		if(kMatrix._33 > kMatrix.m[iCount][iCount]) iCount = 2;

		float afTemp[4];
		int iTemp1 = aiNext[iCount];
		int iTemp2 = aiNext[iTemp1];

		float fSQRT = SQRT((kMatrix.m[iCount][iCount] - 
						   (kMatrix.m[iTemp1][iTemp1] + 
						    kMatrix.m[iTemp2][iTemp2])) + 1.0f);
		afTemp[iCount] = (fSQRT * 0.5f);

		if(fSQRT != 0.0) fSQRT = (0.5f / fSQRT);
		afTemp[3] =      ((kMatrix.m[iTemp1][iTemp2] - kMatrix.m[iTemp2][iTemp1]) * fSQRT);
		afTemp[iTemp1] = ((kMatrix.m[iCount][iTemp1] + kMatrix.m[iTemp1][iCount]) * fSQRT);
		afTemp[iTemp2] = ((kMatrix.m[iCount][iTemp2] + kMatrix.m[iTemp2][iCount]) * fSQRT);
		x = afTemp[0];
		y = afTemp[1];
		z = afTemp[2];
		w = afTemp[3];
	}
}

GEKQUATERNION GEKQUATERNION::Normal(void)
{
	float fLength = Length();
	return GEKQUATERNION((x / fLength),
						 (y / fLength),
						 (z / fLength),
						 (w / fLength));
}

void GEKQUATERNION::Normalize(void)
{
	*this = Normal();
}

#include <math.h>
GEKQUATERNION GEKQUATERNION::Slerp(const GEKQUATERNION &kQuat, float fFactor)
{
	float fDot = Dot(kQuat);
	float fSqrt = SQRT(ABS(1.0f - fDot * fDot));
	if(ABS(fSqrt) < (_EPSILON * 100.0f)) return *this;
	if(fDot < 0.0f) fDot = -fDot;

	float fAngle = 0.0f;
	if(fDot != 0.0f) fAngle = (float)atanf(fSqrt / fDot);
	fSqrt = 1 / fSqrt;
	
	GEKQUATERNION kResult;
	kResult.x = ((x * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.x * fSqrt * SIN(fAngle * fFactor)));
	kResult.y = ((y * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.y * fSqrt * SIN(fAngle * fFactor)));
	kResult.z = ((z * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.z * fSqrt * SIN(fAngle * fFactor)));
	kResult.w = ((w * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.w * fSqrt * SIN(fAngle * fFactor)));
	return kResult;
}

GEKQUATERNION GEKQUATERNION::Lerp(const GEKQUATERNION &kQuat, float fFactor)
{
	GEKQUATERNION kResult;
	kResult.x = (x + ((kQuat.x - x) * fFactor));
	kResult.y = (y + ((kQuat.y - y) * fFactor));
	kResult.z = (z + ((kQuat.z - z) * fFactor));
	kResult.w = (w + ((kQuat.w - w) * fFactor));
	return kResult;
} 

#include "..\GEKXMath.h" 

#include "..\GEKXMath.h" 

#include "..\GEKXMath.h" 

#include "..\GEKXMath.h"

int NextSquare(int iValue)
{
	long Squared = 1;
	while(Squared < iValue) Squared <<= 1;
	if(Squared == iValue) return Squared;
	else return (Squared >> 1);
}

__declspec(naked) int __fastcall F2ID(float fValue)
{ 
	__asm
	{
		push      ebp
		mov       ebp,esp
		push      ecx
		push      ebx
		push      esi
		mov       eax,dword ptr [ebp+8]
		mov       ebx,eax
		sar       ebx,31
		mov       edx,eax
		and       edx,2147483647
		sar       edx,23
		add       edx,-127
		mov       ecx,edx
		sar       ecx,31
		not       ecx
		mov       dword ptr [ebp-4],ecx
		mov       ecx,dword ptr [ebp-4]
		and       ecx,edx
		push      ecx
		mov       ecx,31
		pop       esi
		sub       ecx,esi
		mov       esi,1
		shl       esi,cl
		dec       esi
		and       eax,8388607
		mov       ecx,31
		sub       ecx,edx
		mov       edx,eax
		or        edx,8388608
		shl       edx,8
		shr       edx,cl
		and       edx,dword ptr [ebp-4]
		xor       edx,ebx
		shl       eax,8
		test      eax,esi
		sete      al
		and       eax,1
		and       ebx,eax
		add       edx,ebx
		mov       eax,edx
		pop       esi
		pop       ebx
		pop       ecx
		pop       ebp
		ret       4
	};
}

__declspec(naked) int __fastcall F2IU(float fValue)
{ 
	__asm
	{
		push      ebp
		mov       ebp,esp
		push      ecx
		push      ebx
		push      esi
		mov       eax,dword ptr [ebp+8]
		xor       eax,-2147483648
		mov       edx,eax
		sar       edx,31
		mov       dword ptr [ebp-4],edx
		mov       edx,eax
		and       edx,2147483647
		sar       edx,23
		add       edx,-127
		mov       ebx,edx
		sar       ebx,31
		not       ebx
		mov       ecx,ebx
		and       ecx,edx
		push      ecx
		mov       ecx,31
		pop       esi
		sub       ecx,esi
		mov       esi,1
		shl       esi,cl
		dec       esi
		and       eax,8388607
		mov       ecx,31
		sub       ecx,edx
		mov       edx,eax
		or        edx,8388608
		shl       edx,8
		shr       edx,cl
		and       edx,ebx
		xor       edx,dword ptr [ebp-4]
		shl       eax,8
		test      eax,esi
		sete      al
		and       eax,1
		and       eax,dword ptr [ebp-4]
		and       ebx,eax
		add       edx,ebx
		neg       edx
		mov       eax,edx
		pop       esi
		pop       ebx
		pop       ecx
		pop       ebp
		ret       4
	};
}

__declspec(naked) float __fastcall ABS(float fValue)
{
	__asm 
	{
		fld		dword ptr[esp + 4] 
		fabs
		ret 4
	};
}

__declspec(naked) float __fastcall SIN(float fValue)
{
	__asm 
	{
		fld		dword ptr[esp + 4] 
		fsin
		ret 4
	};
}

__declspec(naked) float __fastcall COS(float fValue)
{
	__asm 
	{
		fld		dword ptr[esp + 4] 
		fcos
		ret 4
	};
}

float TAN(float fValue)
{
	return (SIN(fValue) / COS(fValue));
}

float SQRT(float fValue)
{
	return (fValue ? (fValue * ISQRT(fValue)) : 0.0f);
}

__declspec(naked) float __fastcall ISQRT(float fValue)
{
	__asm 
	{
		mov		eax, 0be6eb508h
		mov		dword ptr[esp-12],03fc00000h
		sub		eax, dword ptr[esp + 4]
		sub		dword ptr[esp+4], 800000h
		shr		eax, 1
		mov		dword ptr[esp -  8], eax

		fld		dword ptr[esp -  8]
		fmul	st, st
		fld		dword ptr[esp -  8]
		fxch	st(1)
		fmul	dword ptr[esp +  4]
		fld		dword ptr[esp - 12]
		fld		st(0)
		fsub	st,st(2)

		fld		st(1)
		fxch	st(1)
		fmul	st(3),st
		fmul	st(3),st
		fmulp	st(4),st
		fsub	st,st(2)

		fmul	st(2),st
		fmul	st(3),st
		fmulp	st(2),st
		fxch	st(1)
		fsubp	st(1),st

		fmulp	st(1), st
		ret 4
	}
}