vector.h

environment_mapped_bump_mapping using opengl

#ifndef _VECTOR_H
#define _VECTOR_H
#include <math.h>

#ifndef PI180
#define PI180	0.0174532925199432957692369076848861f	// pi / 180
#endif

class CVector  
{
public:
	union
	{
		struct
		{
			float x, y, z;
		};
		float v[3];
	};

	CVector(){}
	inline CVector( const CVector &a);
	inline CVector( const float a, const float b, const float c);
	inline void set( const float a, const float b, const float c);
	inline void clear();

	inline CVector operator+() const;
	inline CVector operator-() const;		// negative

	inline void operator+= ( const CVector &a);
	inline void operator-= ( const CVector &a);
	inline void operator*= ( const CVector &a);
	inline void operator/= ( const CVector &a);

	inline void operator+= ( const float f);
	inline void operator-= ( const float f);
	inline void operator*= ( const float f);
	inline void operator/= ( const float f);
	
	inline CVector CROSS( const CVector &a) const;
	inline float DOT3( const CVector &a) const;
	inline float Length() const;

	inline void RotX( const float angle);
	inline void RotY( const float angle);
	inline void RotZ( const float angle);
	
	inline void Normalise();
	inline void ArbitraryRotate(float theta, CVector r);

	inline friend CVector operator+ ( const CVector &a, const CVector &b );
	inline friend CVector operator- ( const CVector &a, const CVector &b );
	inline friend CVector operator* ( const CVector &a, const CVector &b );
	inline friend CVector operator/ ( const CVector &a, const CVector &b );

	inline friend CVector operator+ ( const float f, const CVector &a );
	inline friend CVector operator- ( const float f, const CVector &a );
	inline friend CVector operator* ( const float f, const CVector &a );
//	inline friend CVector operator/ ( const float f, const CVector &a );
	
	inline friend CVector operator+ ( const CVector &a, const float f );
	inline friend CVector operator- ( const CVector &a, const float f );
	inline friend CVector operator* ( const CVector &a, const float f );
	inline friend CVector operator/ ( const CVector &a, const float f );

	inline friend CVector CROSS ( const CVector &a, const CVector &b );
	inline friend float DOT3  ( const CVector &a, const CVector &b );
	inline friend float Distance ( const CVector &a, const CVector &b);
};

inline CVector::CVector( const CVector &a)
{	x = a.x; y = a.y; z = a.z;}

inline CVector::CVector( const float a, const float b, const float c )
{	x = a; y = b; z = c;}

inline void CVector::set( const float a, const float b, const float c)
{	x = a; y = b; z = c;}

inline void CVector::clear()
{	x = 0.f; y = 0.f; z = 0.f;}

inline CVector CVector::operator+() const	{	return *this;}
inline CVector CVector::operator-() const	{	return CVector( -x, -y, -z);}

inline void CVector::operator+= ( const CVector &a){	x += a.x; y += a.y; z += a.z;}
inline void CVector::operator-= ( const CVector &a){	x -= a.x; y -= a.y; z -= a.z;}
inline void CVector::operator*= ( const CVector &a){	x *= a.x; y *= a.y; z *= a.z;}
inline void CVector::operator/= ( const CVector &a){	x /= a.x; y /= a.y; z /= a.z;}
inline void CVector::operator+= ( const float f){	x += f; y += f; z += f; }
inline void CVector::operator-= ( const float f){	x -= f; y -= f; z -= f; }
inline void CVector::operator*= ( const float f){	x *= f; y *= f; z *= f; }
inline void CVector::operator/= ( const float f){	x /= f; y /= f; z /= f; }

inline CVector operator+ ( const CVector &a, const CVector &b ){return CVector( a.x+b.x, a.y+b.y, a.z+b.z );}
inline CVector operator- ( const CVector &a, const CVector &b ){return CVector( a.x-b.x, a.y-b.y, a.z-b.z );}
inline CVector operator* ( const CVector &a, const CVector &b ){return CVector( a.x*b.x, a.y*b.y, a.z*b.z );}
inline CVector operator/ ( const CVector &a, const CVector &b ){return CVector( a.x/b.x, a.y/b.y, a.z/b.z );}

inline CVector operator+ ( const float f, const CVector &a ){return CVector( f+a.x, f+a.y, f+a.z );}
inline CVector operator- ( const float f, const CVector &a ){return CVector( f-a.x, f-a.y, f-a.z );}
inline CVector operator* ( const float f, const CVector &a ){return CVector( f*a.x, f*a.y, f*a.z );}
inline CVector operator+ ( const CVector &a, const float f ){return CVector( a.x+f, a.y+f, a.z+f );}
inline CVector operator- ( const CVector &a, const float f ){return CVector( a.x-f, a.y-f, a.z-f );}
inline CVector operator* ( const CVector &a, const float f ){return CVector( a.x*f, a.y*f, a.z*f );}
inline CVector operator/ ( const CVector &a, const float f ){float f_ = 1.0f/f;return CVector( a.x*f_, a.y*f_, a.z*f_ );}

inline CVector CROSS ( const CVector &a, const CVector &b )
{
	return CVector( a.y*b.z - a.z*b.y,			//  i   j   k
					a.z*b.x - a.x*b.z,			// a.x a.y a.z
					a.x*b.y - a.y*b.x );		// b.x b.y b.z
}
inline CVector CVector::CROSS( const CVector &a) const
{
	return CVector( y*a.z - z*a.y,
					z*a.x - x*a.z,
					x*a.y - y*a.x );
}

inline float DOT3( const CVector &a, const CVector &b )
{
	return( a.x*b.x + a.y*b.y + a.z*b.z );
}
inline float CVector::DOT3( const CVector &a) const
{
	return (x*a.x + y*a.y +z*a.z);
}

inline float CVector::Length() const
{	
	return (float) sqrt(x*x + y*y + z*z);
}

inline void CVector::RotX( const float angle)
{
	float s = (float) sin( PI180*angle );
	float c = (float) cos( PI180*angle );
	float Y=y;
	y =  y*c - z*s;
	z =  Y*s + z*c;
}
inline void CVector::RotY( const float angle)
{
	float s = (float) sin( PI180*angle );
	float c = (float) cos( PI180*angle );
	float X=x;
	x =  x*c + z*s;
	z = -X*s + z*c;
}
inline void CVector::RotZ( const float angle)
{
	float s = (float) sin( PI180*angle );
	float c = (float) cos( PI180*angle );
	float X=x;
	x =  x*c - y*s;
	y =  X*s + y*c;
}
inline void CVector::Normalise()
{
	float length;

	length = (float) sqrt(x*x + y*y + z*z);
	if (length != 0) {
		x /= length;
		y /= length;
		z /= length;
	} else {
		x = 0;
		y = 0;
		z = 0;
	}
}

//	Rotate a vector by angle theta around an arbitrary axis r
//	Positive angles are anticlockwise looking down the axis  towards the origin.
inline void CVector::ArbitraryRotate(float theta, CVector r)	// Rotate a vector by angle theta around an arbitrary axis r
{
	CVector p(x,y,z);
	float costheta,sintheta;

	theta*=PI180;
	r.Normalise();
	costheta = (float)cos(theta);
	sintheta = (float)sin(theta);

	x  = (costheta + (1 - costheta) * r.x * r.x) * p.x;
	x += ((1 - costheta) * r.x * r.y - r.z * sintheta) * p.y;
	x += ((1 - costheta) * r.x * r.z + r.y * sintheta) * p.z;

	y  = ((1 - costheta) * r.x * r.y + r.z * sintheta) * p.x;
	y += (costheta + (1 - costheta) * r.y * r.y) * p.y;
	y += ((1 - costheta) * r.y * r.z - r.x * sintheta) * p.z;

	z  = ((1 - costheta) * r.x * r.z - r.y * sintheta) * p.x;
	z += ((1 - costheta) * r.y * r.z + r.x * sintheta) * p.y;
	z += (costheta + (1 - costheta) * r.z * r.z) * p.z;
}

inline float Distance ( const CVector &a, const CVector &b)
{
	CVector r = a-b;
	return r.Length();
}

inline CVector ReflectedRay( const CVector &in, const CVector &n)
{
	return (in - 2.f*n*DOT3( in, n));
}

inline char isInfPlus( const float &x)
{
	float a;
	*(unsigned int*)&a = (unsigned int)0x7f800000;
	return ( x==a);
//	return (*(unsigned int*) &x==0x7f800000);
}

inline char isInfMinus( const float &x)
{
	float a;
	*(unsigned int*)&a = (unsigned int)0xff800000;
	return ( x==a);
//	return (*(unsigned int*) &x==0xff800000);
}

#endif