math.h

这是VCF框架的代码

/*	Math.h: the vrtoad::Math classes
	Author: Alan Fischer
	Email: siralanf_at_lightningtoads_dot_com
	Date: 9/21/03
	Note: These are untemplated because VC6 fails to optimized templates effectivly.
*/

#ifndef VRTOAD_MATH_H
#define VRTOAD_MATH_H

#if defined(WIN32) && defined(_MSC_VER)
#	define inline __forceinline
#	pragma warning(disable:4244)
#endif

#ifdef __BORLANDC__
#include <cstdlib>
#include <cmath>
using std::srand;
using std::rand;
using std::sqrt;
using std::acos;
using std::asin;
using std::cos;
using std::sin;
using std::atan2;
using std::exp;
using std::log;
using std::fabs;
using std::itoa;
using std::putenv;
using std::ultoa;
using std::swab;
#define _itoa itoa
#define _ultoa ultoa
#define _putenv putenv
#define _swab swab
#else
#include <math.h>
#include <stdlib.h>
#endif
#include <vector>

#ifdef VRTOAD_MATH_DOUBLE
#	define cos cos
#	define sin sin
#	define sqrt sqrt
#	define vrReal double
#else
#ifndef __BORLANDC__
#	define cos cosf
#	define sin sinf
#	if 1
#		define sqrt sqrtf
#	else
#		define sqrt fastsqrt
#	endif
#endif
#	define vrReal float
#endif

namespace vrtoad{

//Constants
const vrReal vrEpsilon=		(vrReal)0.001;
const vrReal vrInfinity=	(vrReal)100000000;
const vrReal vrSqrt2=		(vrReal)1.41421356237309504880168;
const vrReal vrPi=			(vrReal)3.14159265358979323846264;

template<class T> inline T Max(const T &t1,const T &t2){
	return ((t1>t2)?t1:t2);
}

template<class T> inline T Min(const T &t1,const T &t2){
	return ((t1<t2)?t1:t2);
}

template<class T> inline T abs(const T &t1){
	return ((t1>0)?t1:-t1);
}

template<class T> inline T square(const T &t1){
	return t1*t1;
}

template<class T> inline T linearInterpolate(const T &t1,const T &t2,vrReal time){
	return t1*(1-time)+t2*time;
}

template<class T1,class T2,class T3> inline T3 clamp(const T1 low,const T2 high,const T3 value){
        if(value<low)
                return low;
        if(value>high)
                return high;
        return value;
}

template<class T> inline bool finite(const T &t){
	return t==t;
}

//These two methods aren't templated, because otherwise if you call toRad(90), it will treat it as an integer, which is BAD
inline vrReal toRad(vrReal deg){
	return vrReal(deg*(vrReal)(vrPi/180.0));
}

inline vrReal toDeg(vrReal rad){
	return vrReal(rad*(vrReal)(180.0/vrPi));
}

#define setBit(v,b) (v|=b)
#define clearBit(v,b) (v&=~b)
#define isBitSet(v,b) (v&b)

inline void setRandomSeed(unsigned int seed){
	srand(seed);
}

//For some reason it appears that the random number functions sometime return numbers equal to upper
inline float randomFloat(float lower,float upper){
	float r=(float)rand()/(float)RAND_MAX*(upper-lower)+lower;
	if(r>=upper){r=lower;}
	return r;
}

inline int randomInt(int lower,int upper){
	int r=(int)((float)rand()/(float)RAND_MAX*(float)(upper-lower))+lower;
	if(r>=upper){r=lower;}
	return r;
}

float fastsqrt(float n);

//Vector2
class Vector2{
public:
	vrReal x,y;

	inline Vector2():x(0),y(0){}

	inline Vector2(vrReal x1,vrReal y1):x(x1),y(y1){}

	inline vrReal *getData(){return (vrReal*)&x;}
	inline const vrReal *getData() const{return (vrReal*)&x;}

	inline bool operator==(const Vector2 &vec) const{
		return (vec.x==x && vec.y==y);
	}

	inline bool operator!=(const Vector2 &vec) const{
		return (vec.x!=x || vec.y!=y);
	}

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

	inline void operator+=(const Vector2 &vec){
		x+=vec.x;
		y+=vec.y;
	}

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

	inline void operator-=(const Vector2 &vec){
		x-=vec.x;
		y-=vec.y;
	}

	inline Vector2 operator*(vrReal f) const{
		return Vector2(x*f,y*f);
	}

	inline void operator*=(vrReal f){
		x*=f;
		y*=f;
	}

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

	inline void operator*=(const Vector2 &vec){
		x*=vec.x;
		y*=vec.y;
	}

	inline Vector2 operator/(vrReal f) const{
		f=1/f;
		return Vector2(x*f,y*f);
	}

	inline void operator/=(vrReal f){
		f=1/f;
		x*=f;
		y*=f;
	}

	inline Vector2 operator/(const Vector2 &vec) const{
		return Vector2(x/vec.x,y/vec.y);
	}

	inline void operator/=(const Vector2 &vec){
		x/=vec.x;
		y/=vec.y;
	}

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

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

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

	//TODO: Remove these on the vectors.  They're not "well defined" operations
	inline bool operator>(const Vector2 &vec) const{
		return (x>vec.x && y>vec.y);
	}

	inline bool operator<(const Vector2 &vec) const{
		return (x<vec.x && y<vec.y);
	}

	inline bool operator>=(const Vector2 &vec) const{
		return (x>=vec.x && y>=vec.y);
	}

	inline bool operator<=(const Vector2 &vec) const{
		return (x<=vec.x && y<=vec.y);
	}
};

inline Vector2 operator*(vrReal scalar,const Vector2 &vector){
	return Vector2(vector.x*scalar,vector.y*scalar);
}

inline vrReal lengthSquared(const Vector2 &vec){
	return vec.x*vec.x+vec.y*vec.y;
}

inline vrReal length(const Vector2 &vec){
	return (vrReal)sqrt((vrReal)(vec.x*vec.x+vec.y*vec.y));
}

// TODO: return void?
inline Vector2 normalize(Vector2 &vec){
	vrReal l=1/length(vec);
	vec.x*=l;
	vec.y*=l;
	return vec;
}

inline Vector2 normalize(const Vector2 &vec){
	vrReal l=1/length(vec);
	Vector2 vec2;
	vec2.x=vec.x*l;
	vec2.y=vec.y*l;
	return vec2;
}

//Vector3
class Vector3{
public:
	vrReal x,y,z;

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

	inline Vector3(vrReal x1,vrReal y1,vrReal z1):x(x1),y(y1),z(z1){}

	inline Vector3(const Vector2 &vec,vrReal z1){
		x=vec.x;y=vec.y;z=z1;
	}

	inline vrReal *getData(){return (vrReal*)&x;}
	inline const vrReal *getData() const{return (vrReal*)&x;}

	inline bool operator==(const Vector3 &vec) const{
		return (vec.x==x && vec.y==y && vec.z==z);
	}

	inline bool operator!=(const Vector3 &vec) const{
		return (vec.x!=x || vec.y!=y || vec.z!=z);
	}

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

	inline void operator+=(const Vector3 &vec){
		x+=vec.x;
		y+=vec.y;
		z+=vec.z;
	}

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

	inline void operator-=(const Vector3 &vec){
		x-=vec.x;
		y-=vec.y;
		z-=vec.z;
	}

	inline Vector3 operator*(vrReal f) const{
		return Vector3(x*f,y*f,z*f);
	}

	inline void operator*=(vrReal f){
		x*=f;
		y*=f;
		z*=f;
	}

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

	inline void operator*=(const Vector3 &vec){
		x*=vec.x;
		y*=vec.y;
		z*=vec.z;
	}

	inline Vector3 operator/(vrReal f) const{
		f=1/f;
		return Vector3(x*f,y*f,z*f);
	}

	inline void operator/=(vrReal f){
		f=1/f;
		x*=f;
		y*=f;
		z*=f;
	}

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

	inline void operator/=(const Vector3 &vec){
		x/=vec.x;
		y/=vec.y;
		z/=vec.z;
	}

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

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

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

	inline bool operator>(const Vector3 &vec) const{
		return (x>vec.x && y>vec.y && z>vec.z);
	}

	inline bool operator<(const Vector3 &vec) const{
		return (x<vec.x && y<vec.y && z<vec.z);
	}

	inline bool operator>=(const Vector3 &vec) const{
		return (x>=vec.x && y>=vec.y && z>=vec.z);
	}

	inline bool operator<=(const Vector3 &vec) const{
		return (x<=vec.x && y<=vec.y && z<=vec.z);
	}
};

const Vector3 vrRight(1,0,0);
const Vector3 vrForward(0,1,0);
const Vector3 vrUp(0,0,1);

inline vrReal lengthSquared(const Vector3 &vec){
	return vec.x*vec.x+vec.y*vec.y+vec.z*vec.z;
}

inline vrReal length(const Vector3 &vec){
	return (vrReal)sqrt((vrReal)(vec.x*vec.x+vec.y*vec.y+vec.z*vec.z));
}

// TODO: return void?
inline Vector3 normalize(Vector3 &vec){
	vrReal l=1/length(vec);
	vec.x*=l;
	vec.y*=l;
	vec.z*=l;
	return vec;
}

inline Vector3 normalize(const Vector3 &vec){
	vrReal l=1/length(vec);
	Vector3 vec2;
	vec2.x=vec.x*l;
	vec2.y=vec.y*l;
	vec2.z=vec.z*l;
	return vec2;
}

// To keep code clean, use this for an XYZ Euler angle, instead of a Vector
typedef Vector3 EulerAngle;

inline EulerAngle toRad(const EulerAngle &deg){
	return EulerAngle(toRad(deg.x),toRad(deg.y),toRad(deg.z));
}

inline EulerAngle toDeg(const EulerAngle &deg){
	return EulerAngle(toDeg(deg.x),toDeg(deg.y),toDeg(deg.z));
}

inline Vector3 cross(const Vector3 &vec1,const Vector3 &vec2){
	return Vector3(vec1.y*vec2.z-vec1.z*vec2.y,vec1.z*vec2.x-vec1.x*vec2.z,vec1.x*vec2.y-vec1.y*vec2.x);
}

inline Vector3 operator*(vrReal scalar,const Vector3 &vector){
	return Vector3(vector.x*scalar,vector.y*scalar,vector.z*scalar);
}

inline vrReal dot(const Vector3 &vec1,const Vector3 &vec2){
	return vec1.x*vec2.x+vec1.y*vec2.y+vec1.z*vec2.z;
}

inline Vector3 reflectVector(const Vector3 &vec,const Vector3 &norm){
	return norm*(2*dot(vec,norm))-vec;
}

void setVectorsFromEulerAngles(const EulerAngle &angles,Vector3 &forward,Vector3 &up,Vector3 &right);

vrReal getXYAngle(const Vector3 &vec1,const Vector3 &vec2);

inline vrReal angleBetween(const Vector3 &vec1,const Vector3 &vec2){
	return acos(dot(vec1,vec2));
}

//Vector4
class Vector4{
public:
	vrReal x,y,z,w;

	inline Vector4():x(0),y(0),z(0),w(0){}

	inline Vector4(vrReal x1,vrReal y1,vrReal z1,vrReal w1):x(x1),y(y1),z(z1),w(w1){}

	inline Vector4(const Vector3 &vec,vrReal w1){
		x=vec.x;y=vec.y;z=vec.z;w=w1;
	}

	inline vrReal *getData(){return (vrReal*)&x;}
	inline const vrReal *getData() const{return (vrReal*)&x;}

	inline bool operator==(const Vector4 &vec) const{
		return (vec.x==x && vec.y==y && vec.z==z && vec.w==w);
	}

	inline bool operator!=(const Vector4 &vec) const{
		return (vec.x!=x || vec.y!=y || vec.z!=z || vec.w!=w);
	}

	inline Vector4 operator+(const Vector4 &vec) const{
		return Vector4(x+vec.x,y+vec.y,z+vec.z,w+vec.w);
	}

	inline void operator+=(const Vector4 &vec){
		x+=vec.x;
		y+=vec.y;
		z+=vec.z;
		w+=vec.w;
	}

	inline Vector4 operator-(const Vector4 &vec) const{
		return Vector4(x-vec.x,y-vec.y,z-vec.z,w-vec.w);
	}

	inline void operator-=(const Vector4 &vec){
		x-=vec.x;
		y-=vec.y;
		z-=vec.z;
		w-=vec.w;
	}

	inline Vector4 operator*(vrReal f) const{
		return Vector4(x*f,y*f,z*f,w*f);
	}

	inline void operator*=(vrReal f){
		x*=f;
		y*=f;
		z*=f;
		w*=f;
	}

	inline Vector4 operator*(const Vector4 &vec) const{
		return Vector4(x*vec.x,y*vec.y,z*vec.z,w*vec.w);
	}

	inline void operator*=(const Vector4 &vec){
		x*=vec.x;
		y*=vec.y;
		z*=vec.z;
		w*=vec.w;
	}

	inline Vector4 operator/(vrReal f) const{
		f=1/f;
		return Vector4(x*f,y*f,z*f,w*f);
	}

	inline void operator/=(vrReal f){
		f=1/f;
		x*=f;
		y*=f;
		z*=f;
		w*=f;
	}

	inline void operator/=(const Vector4 &vec){
		x/=vec.x;
		y/=vec.y;
		z/=vec.z;
		w/=vec.w;
	}

	inline Vector4 operator-() const{
		return Vector4(-x,-y,-z,-w);
	}

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

	inline vrReal operator[](int i) const{