3D游戏中的数学方法（C++实现）1

从今天开始开始3D游戏中的相关的数学实现：

先从基本必须的3D向量类实现开始：

vector3d.h:

#include<cmath>
#include<cassert>


namespace OG3D
{
class CVector3D
{
public:
float x,y,z;


public:
CVector3D(float const& _x=0.0f,float const& _y=0.0f,float const& _z=0.0f):
x(_x),y(_y),z(_z) { }
CVector3D(CVector3D const& av): x(av.x),y(av.y),z(av.z) { }
~CVector3D() { }


CVector3D& operator=(CVector3D const& vec)
{
x=vec.x;
y=vec.y;
z=vec.z;
return *this;
}


float& operator[](size_t i)
{
i%=3;
if(i==0) return x;
if(i==1) return y;
return z;
}
float const& operator[](size_t i) const
{
i%=3;
if(i==0) return x;
if(i==1) return y;
return z;
}


bool valid() const
{
return x==0.0f && y==0.0f && z==0.0f;
}


float length_square() const
{
return x*x+y*y+z*z;
}
float length() const
{
return sqrtf(length_square());
}


void normalize()
{
float _t(length());
assert(_t!=0.0f);
_t=1.0f/_t;


x*=_t;
y*=_t;
z*=_t;
}


CVector3D& operator*=(float const& c)
{
x*=c;
y*=c;
z*=c;
return *this;
}
CVector3D& operator/=(float const& c)
{
assert(c!=0.0f);


float const _tc(1.0f/c);
x*=_tc;
y*=_tc;
z*=_tc;
return *this;
}


CVector3D& operator+=(CVector3D const& rv)
{
x+=rv.x;
y+=rv.y;
z+=rv.z;
return *this;
}
CVector3D& operator-=(CVector3D const& rv)
{
x-=rv.x;
y-=rv.y;
z-=rv.z;
return *this;
}


float operator%=(CVector3D const& rv) const
{
return dot(rv);
}


CVector3D& operator*=(CVector3D const& rv)
{
return product(rv);
}


private:
float dot(CVector3D const& vec) const
{
return x*vec.x+y*vec.y+z*vec.z;
}


CVector3D& product(CVector3D const& vec)
{
float _tx(0.0f),_ty(0.0f),_tz(0.0f);
_tx=y*vec.z-z*vec.y;
_ty=z*vec.x-x*vec.z;
_tz=x*vec.y-y*vec.x;
return *this;
}
};


inline CVector3D operator*(CVector3D const& lhs,float const& rhs)
{
CVector3D _res(lhs);
_res*=rhs;
return _res;
}


inline CVector3D operator*(float const& lhs,CVector3D const& rhs)
{
CVector3D _res(rhs);
_res*=lhs;
return _res;
}


inline CVector3D operator/(CVector3D const& lhs,float const& rhs)
{
CVector3D _res(lhs);
_res/=rhs;
return _res;
}


inline float operator%(CVector3D const& lhs,CVector3D const& rhs)
{
return lhs%=rhs;
}


inline CVector3D operator*(CVector3D const& lhs,CVector3D const& rhs)
{
CVector3D _res(lhs);
_res*=rhs;
return _res;
}


inline bool operator==(CVector3D const& lhs,CVector3D const& rhs)
{
return lhs[0]==rhs[0] && lhs[1]==rhs[1] && lhs[2]==rhs[2];
}


inline bool operator!=(CVector3D const& lhs,CVector3D const& rhs)
{
return lhs[0]!=rhs[0] || lhs[1]!=rhs[1] || lhs[2]!=rhs[2];
}

}

这个只是初始版，之后还有矩阵类的相关变换，包括平移和旋转，相关实现在矩阵类