math.beta/include/math/Vector3.h

/*  __      __   ___     _____    ____
 *  \ \    / /  / _ \   |  __ \  |    |
 *   \ \/\/ /  / / \ \  | | / /  |  __|
 *    \_/\_/  /_/   \_\ |_| \_\  |_|
 *      Take it to the next Level
 *
 *	2009 Brian Ernst.
 *	See ReadMe.md for more license info.
 */
#ifndef __VECTOR3_H__
#define __VECTOR3_H__

# include "Debug.h"

# include "math/MathDefs.h"

	template< typename BaseType >
	class TVector3
	{
	public:

		BaseType x, y, z;

					TVector3( void );
					TVector3( BaseType X, BaseType Y, BaseType Z );

		// compare Len, which isn't added yet
		//bool		operator<( const TVector3& ) const;
		bool		operator==( const TVector3& ) const;
		bool		operator!=( const TVector3& ) const;

		TVector3	operator-( void ) const;
		TVector3	operator*( BaseType ) const;
		TVector3	operator/( BaseType ) const;
		TVector3	operator*( const TVector3& ) const;
		TVector3	operator/( const TVector3& ) const;
		TVector3	operator+( const TVector3& ) const;
		TVector3	operator-( const TVector3& ) const;

		TVector3&	operator*=( BaseType );
		TVector3&	operator/=( BaseType );
		TVector3&	operator*=( const TVector3& );
		TVector3&	operator/=( const TVector3& );
		TVector3&	operator+=( const TVector3& );
		TVector3&	operator-=( const TVector3& );

		// TODO: Add other helper functions

		// Can only be used on non-zero vectors. Returns *this so you can chain method calls.
		TVector3&	Normalize( void );
		TVector3&	Clamp( BaseType maxLength );
		TVector3&	Clamp( BaseType minLength, BaseType maxLength );
		TVector3&	SetLen( BaseType length );

		BaseType	Len( void );
		BaseType	LenSqr( void );

		BaseType	Dist( void );
		BaseType	DistSqr( void );

		BaseType	Dot( const TVector3& v );

		BaseType	Angle( const TVector3& v );
		BaseType	AngleNorm( const TVector3& v );

		TVector3	Cross( const TVector3& v );
		TVector3	Perpendicular( void );
		TVector3	Project( const TVector3& v );
		TVector3	Reflect( const TVector3& v );
		TVector3	Rotate( BaseType angle, const TVector3& axis );

		TVector3	Lerp( const TVector3& v, BaseType n );
		TVector3	Slerp( const TVector3& v, BaseType n );
		TVector3	Nlerp( const TVector3& v, BaseType n );

		// might be confusing as method? At least with function you have parameters to
		// tell user what the vector representatio is.
		TVector3	ToPolar( void );
		TVector3	ToCartesian( void );
		TVector3	ToEuler( BaseType angle );

		bool		IsZero( void ) const;


		// Predefined helper vectors
		static TVector3 	Zero;
		static BaseType		Epsilon;
	};

	typedef TVector3< Scalar > Vec3f;


	template< typename BaseType >
 	inline TVector3< BaseType >::TVector3( void )
 	{
 	}

	template< typename BaseType >
	inline TVector3< BaseType >::TVector3( BaseType X, BaseType Y, BaseType Z )
		: x( X )
		, y( Y )
		, z( Z )
	{
	}

	template< typename BaseType >
	inline bool TVector3< BaseType >::operator==( const TVector3& vect ) const
	{
		return cmpf( x, vect.x ) == 0 && cmpf( y, vect.y ) == 0 && cmpf( z, vect.z ) == 0;
	}

	template< typename BaseType >
	inline bool TVector3< BaseType >::operator!=( const TVector3& vect ) const
	{
		return cmpf( x, vect.x ) != 0 && cmpf( y, vect.y ) != 0 && cmpf( z, vect.z ) != 0;
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator-( void ) const
	{
		return TVector3< BaseType >( -x, -y, -z );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator*( BaseType val ) const
	{
		return TVector3< BaseType >( x * val, y * val, z * val );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator/( BaseType val ) const
	{
		return TVector3< BaseType >( x / val, y / val, z / val );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator*( const TVector3& vect ) const
	{
		return TVector3< BaseType >( x * vect.x, y * vect.y, z * vect.z );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator/( const TVector3& vect ) const
	{
		return TVector3< BaseType >( x / vect.x, y / vect.y, z / vect.z );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator+( const TVector3& vect ) const
	{
		return TVector3< BaseType >( x + vect.x, y + vect.y, z + vect.z );
	}

	template< typename BaseType >
	inline TVector3< BaseType >	TVector3< BaseType >::operator-( const TVector3& vect ) const
	{
		return TVector3< BaseType >( x - vect.x, y - vect.y, z - vect.z );
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator*=( BaseType val )
	{
		x *= val;
		y *= val;
		z *= val;
		return *this;
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator/=( BaseType val )
	{
		x /= val;
		y /= val;
		z /= val;
		return *this;
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator*=( const TVector3& vect )
	{
		x *= vect.x;
		y *= vect.y;
		z *= vect.z;
		return *this;
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator/=( const TVector3& vect )
	{
		x /= vect.x;
		y /= vect.y;
		z /= vect.z;
		return *this;
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator+=( const TVector3& vect )
	{
		x += vect.x;
		y += vect.y;
		z += vect.z;
		return *this;
	}

	template< typename BaseType >
	inline TVector3< BaseType >&	TVector3< BaseType >::operator-=( const TVector3& vect )
	{
		x -= vect.x;
		y -= vect.y;
		z -= vect.z;
		return *this;
	}

	template< typename BaseType >
	inline bool					TVector3< BaseType >::IsZero( void ) const
	{
		return cmpf(x, 0) == 0 && cmpf(y, 0) == 0 && cmpf(z, 0) == 0;
	}

	template< typename BaseType >
	TVector3< BaseType > 	TVector3< BaseType >::Zero = TVector3< BaseType >( 0, 0, 0 );

	template< typename BaseType >
	BaseType TVector3< BaseType >::Epsilon = std::numeric_limits< BaseType >::epsilon( );

#endif