///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////*****************************************************************************************************//////////////// ///////////////** **/////////////// //////////////** ~ Zoo Engine (Moteur 3D pour SCOL) ~ **////////////// /////////////** ~ version 1.0 ~ **///////////// /////////////** **///////////// //////////////** par Pacôme DANHIEZ **////////////// ///////////////** **/////////////// ////////////////*****************************************************************************************************//////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// /// FICHIER : ZooMatrix.inl /// /// /// /// NATURE : Librairie matricielle en deux versions -> optimisée P3, et 100% C++ - Definition des fonctions INLINE /// /// /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// INLINED FUNCTIONS /// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ZMatrix Class /// /// - Classe des matrices 4x4 /// - Méthodes de calculs classiques /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /// Constructors /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix::ZMatrix( float f11, float f21, float f31, float f41, float f12, float f22, float f32, float f42, float f13, float f23, float f33, float f43, float f14, float f24, float f34, float f44 ) { _14=f14; _13=f13; _12=f12; _11=f11; _24=f24; _23=f23; _22=f22; _21=f21; _34=f34; _33=f33; _32=f32; _31=f31; _44=f44; _43=f43; _42=f42; _41=f41; } /////////////////////////////////////////////////////////////////////////// /// ZeroMatrix /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix ZeroMatrix() { ZMatrix Res; Res._14 = Res._13 = Res._12 = Res._11 = Res._24 = Res._23 = Res._22 = Res._21 = Res._34 = Res._33 = Res._32 = Res._31 = Res._44 = Res._43 = Res._42 = Res._41 = 0.0f; return Res; } inline void ZMatrix::ZeroMatrix() { _14 = _13 = _12 = _11 = _24 = _23 = _22 = _21 = _34 = _33 = _32 = _31 = _44 = _43 = _42 = _41 = 0.0f; } /////////////////////////////////////////////////////////////////////////// /// IdentityMatrix /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix IdentityMatrix() { ZMatrix Res; Res._14 = Res._13 = Res._12 = Res._24 = Res._23 = Res._21 = Res._34 = Res._32 = Res._31 = Res._43 = Res._42 = Res._41 = 0.0f; Res._11 = Res._22 = Res._33 = Res._44 = 1.0f; return Res; } inline void ZMatrix::IdentityMatrix() { _14 = _13 = _12 = _24 = _23 = _21 = _34 = _32 = _31 = _43 = _42 = _41 = 0.0f; _11 = _22 = _33 = _44 = 1.0f; } /////////////////////////////////////////////////////////////////////////// /// MatrixMult (A*B = Res) /// /////////////////////////////////////////////////////////////////////////// inline void MatrixMult(const ZMatrix &A, const ZMatrix &B, ZMatrix &Res) { ZMatrix Result; Result._11 = A._11*B._11 + A._12*B._21 + A._13*B._31 + A._14*B._41; Result._12 = A._11*B._12 + A._12*B._22 + A._13*B._32 + A._14*B._42; Result._13 = A._11*B._13 + A._12*B._23 + A._13*B._33 + A._14*B._43; Result._14 = A._11*B._14 + A._12*B._24 + A._13*B._34 + A._14*B._44; Result._21 = A._21*B._11 + A._22*B._21 + A._23*B._31 + A._24*B._41; Result._22 = A._21*B._12 + A._22*B._22 + A._23*B._32 + A._24*B._42; Result._23 = A._21*B._13 + A._22*B._23 + A._23*B._33 + A._24*B._43; Result._24 = A._21*B._14 + A._22*B._24 + A._23*B._34 + A._24*B._44; Result._31 = A._31*B._11 + A._32*B._21 + A._33*B._31 + A._34*B._41; Result._32 = A._31*B._12 + A._32*B._22 + A._33*B._32 + A._34*B._42; Result._33 = A._31*B._13 + A._32*B._23 + A._33*B._33 + A._34*B._43; Result._34 = A._31*B._14 + A._32*B._24 + A._33*B._34 + A._34*B._44; Result._41 = A._41*B._11 + A._42*B._21 + A._43*B._31 + A._44*B._41; Result._42 = A._41*B._12 + A._42*B._22 + A._43*B._32 + A._44*B._42; Result._43 = A._41*B._13 + A._42*B._23 + A._43*B._33 + A._44*B._43; Result._44 = A._41*B._14 + A._42*B._24 + A._43*B._34 + A._44*B._44; Res = Result; } /////////////////////////////////////////////////////////////////////////// /// MatrixMult (A*B = Res) /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix MatrixMult(const ZMatrix &A, const ZMatrix &B) { ZMatrix Res; Res._11 = A._11*B._11 + A._12*B._21 + A._13*B._31 + A._14*B._41; Res._12 = A._11*B._12 + A._12*B._22 + A._13*B._32 + A._14*B._42; Res._13 = A._11*B._13 + A._12*B._23 + A._13*B._33 + A._14*B._43; Res._14 = A._11*B._14 + A._12*B._24 + A._13*B._34 + A._14*B._44; Res._21 = A._21*B._11 + A._22*B._21 + A._23*B._31 + A._24*B._41; Res._22 = A._21*B._12 + A._22*B._22 + A._23*B._32 + A._24*B._42; Res._23 = A._21*B._13 + A._22*B._23 + A._23*B._33 + A._24*B._43; Res._24 = A._21*B._14 + A._22*B._24 + A._23*B._34 + A._24*B._44; Res._31 = A._31*B._11 + A._32*B._21 + A._33*B._31 + A._34*B._41; Res._32 = A._31*B._12 + A._32*B._22 + A._33*B._32 + A._34*B._42; Res._33 = A._31*B._13 + A._32*B._23 + A._33*B._33 + A._34*B._43; Res._34 = A._31*B._14 + A._32*B._24 + A._33*B._34 + A._34*B._44; Res._41 = A._41*B._11 + A._42*B._21 + A._43*B._31 + A._44*B._41; Res._42 = A._41*B._12 + A._42*B._22 + A._43*B._32 + A._44*B._42; Res._43 = A._41*B._13 + A._42*B._23 + A._43*B._33 + A._44*B._43; Res._44 = A._41*B._14 + A._42*B._24 + A._43*B._34 + A._44*B._44; return Res; } /////////////////////////////////////////////////////////////////////////// /// Matrix multiplication operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator * (const ZMatrix &A, const ZMatrix &B) { return MatrixMult(A, B); } /////////////////////////////////////////////////////////////////////////// /// Multiplication & affectation operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix & ZMatrix::operator *= (const ZMatrix &B) { MatrixMult(*this, B, *this); return *this; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator * (const ZMatrix &A, const float s) { ZMatrix Res; for (int i=0; i<16; i++) *(((float*)&Res._11)+i) = *(((float*)&A._11)+i) * s; return Res; } inline ZMatrix operator * (const float s, const ZMatrix &A) { ZMatrix Res; for (int i=0; i<16; i++) *(((float*)&Res._11)+i) = *(((float*)&A._11)+i) * s; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication & affectation operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix & ZMatrix::operator *= (const float s) { for (int i=0; i<16; i++) *(((float*)&_11)+i) = *(((float*)&_11)+i) * s; return *this; } /////////////////////////////////////////////////////////////////////////// /// Matrix addition operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator + (const ZMatrix &A, const ZMatrix &B) { ZMatrix Res; for (int i=0; i<16; i++) *(((float*)&Res._11)+i) = *(((float*)&A._11)+i) + *(((float*)&B._11)+i); return Res; } /////////////////////////////////////////////////////////////////////////// /// Matrix addition & affectation operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix & ZMatrix::operator += (const ZMatrix &B) { for (int i=0; i<16; i++) *(((float*)&_11)+i) = *(((float*)&_11)+i) + *(((float*)&B._11)+i); return *this; } /////////////////////////////////////////////////////////////////////////// /// Matrix substraction operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator - (const ZMatrix &A, const ZMatrix &B) { ZMatrix Res; for (int i=0; i<16; i++) *(((float*)&Res._11)+i) = *(((float*)&A._11)+i) - *(((float*)&B._11)+i); return Res; } /////////////////////////////////////////////////////////////////////////// /// Matrix substraction & affectation operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix & ZMatrix::operator -= (const ZMatrix &B) { for (int i=0; i<16; i++) *(((float*)&_11)+i) = *(((float*)&_11)+i) - *(((float*)&B._11)+i); return *this; } /////////////////////////////////////////////////////////////////////////// /// Negative operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator - (const ZMatrix &A) { ZMatrix Res; for (int i=0; i<16; i++) *(((float*)&Res._11)+i) = - *(((float*)&A._11)+i); return Res; } /////////////////////////////////////////////////////////////////////////// /// Positive operator /// /////////////////////////////////////////////////////////////////////////// inline ZMatrix operator + (const ZMatrix &A) { return A; } /////////////////////////////////////////////////////////////////////////// /// Transpose computing /// /////////////////////////////////////////////////////////////////////////// inline void ZMatrix::Transpose() { float tmp; tmp = _12; _12 = _21; _21 = tmp; tmp = _13; _13 = _31; _31 = tmp; tmp = _14; _14 = _41; _41 = tmp; tmp = _23; _23 = _32; _32 = tmp; tmp = _24; _24 = _42; _42 = tmp; tmp = _34; _34 = _43; _43 = tmp; } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ZVector4 Class /// /// - Classe des vecteurs de dim 4 /// - Méthodes de calculs classiques sur les vecteurs /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /// Vector multiplication with a matrix /// /////////////////////////////////////////////////////////////////////////// inline void VectorMult(const ZMatrix &Mat, const ZVector4 &Vec, ZVector4 &Res) { ZVector4 Result; Result.x = Mat._11 * Vec.x + Mat._12 * Vec.y + Mat._13 * Vec.z + Mat._14 * Vec.w; Result.y = Mat._21 * Vec.x + Mat._22 * Vec.y + Mat._23 * Vec.z + Mat._24 * Vec.w; Result.z = Mat._31 * Vec.x + Mat._32 * Vec.y + Mat._33 * Vec.z + Mat._34 * Vec.w; Result.w = Mat._41 * Vec.x + Mat._42 * Vec.y + Mat._43 * Vec.z + Mat._44 * Vec.w; Res.x = Result.x; Res.y = Result.y; Res.z = Result.z; Res.w = Result.w; } inline ZVector4 VectorMult(const ZMatrix &Mat, const ZVector4 &Vec) { ZVector4 Res; Res.x = Mat._11 * Vec.x + Mat._12 * Vec.y + Mat._13 * Vec.z + Mat._14 * Vec.w; Res.y = Mat._21 * Vec.x + Mat._22 * Vec.y + Mat._23 * Vec.z + Mat._24 * Vec.w; Res.z = Mat._31 * Vec.x + Mat._32 * Vec.y + Mat._33 * Vec.z + Mat._34 * Vec.w; Res.w = Mat._41 * Vec.x + Mat._42 * Vec.y + Mat._43 * Vec.z + Mat._44 * Vec.w; return Res; } inline ZVector4 operator * (const ZMatrix& Mat, const ZVector4& Vec) { return VectorMult(Mat, Vec); } /////////////////////////////////////////////////////////////////////////// /// Vector multiplication with a matrix & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector4& ZVector4::operator *= (const ZMatrix& Mat) { VectorMult(Mat, *this, *this); return *this; } /////////////////////////////////////////////////////////////////////////// /// Dot product /// /////////////////////////////////////////////////////////////////////////// inline float operator * (const ZVector4& A, const ZVector4& B) { return (A.x*B.x + A.y*B.y + A.z*B.z + A.w*B.w); } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator * (const ZVector4 &V, const float s) { ZVector4 Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; Res.w = V.w * s; return Res; } inline ZVector4 operator * (const float s, const ZVector4 &V) { ZVector4 Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; Res.w = V.w * s; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector4& ZVector4::operator *= (const float s) { x *= s; y *= s; z *= s; w *= s; return *this; } /////////////////////////////////////////////////////////////////////////// /// Addition operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator + (const ZVector4& A, const ZVector4& B) { ZVector4 Res; Res.x = A.x + B.x; Res.y = A.y + B.y; Res.z = A.z + B.z; Res.w = A.w + B.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Substraction operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator - (const ZVector4& A, const ZVector4& B) { ZVector4 Res; Res.x = A.x - B.x; Res.y = A.y - B.y; Res.z = A.z - B.z; Res.w = A.w - B.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Addition & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 & ZVector4::operator += (const ZVector4 &B) { x += B.x; y += B.y; z += B.z; w += B.w; return *this; } /////////////////////////////////////////////////////////////////////////// /// Substraction & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 & ZVector4::operator -= (const ZVector4 &B) { x -= B.x; y -= B.y; z -= B.z; w -= B.w; return *this; } /////////////////////////////////////////////////////////////////////////// /// Negative operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator - (const ZVector4 &A) { ZVector4 Res; Res.x = -A.x; Res.y = -A.y; Res.z = -A.z; Res.w = -A.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Positive operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator + (const ZVector4 &A) { return A; } /////////////////////////////////////////////////////////////////////////// /// Lenght of the vector /// /////////////////////////////////////////////////////////////////////////// inline float ZVector4::Length() { return ((float)sqrt(x*x + y*y + z*z + w*w)); } /////////////////////////////////////////////////////////////////////////// /// Lenght of the vector /// /////////////////////////////////////////////////////////////////////////// inline float ZVector4::SqLength() { return ((float)(x*x + y*y + z*z + w*w)); } /////////////////////////////////////////////////////////////////////////// /// Normalization of the vector /// /////////////////////////////////////////////////////////////////////////// inline ZVector4& ZVector4::Normalize() { float t = ((float)sqrt(x*x + y*y + z*z + w*w)); if((t<0.000001)&&(t>-0.000001)) t=1; x /= t; y /= t; z /= t; w /= t; return *this; } /////////////////////////////////////////////////////////////////////////// /// Normalization operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator ~ (const ZVector4 &V) { float t = ((float)sqrt(V.x*V.x + V.y*V.y + V.z*V.z + V.w*V.w)); ZVector4 Res; Res.x = V.x/t; Res.y = V.y/t; Res.z = V.z/t; Res.w = V.w/t; return Res; } /////////////////////////////////////////////////////////////////////////// /// Conversion (dim 3 -> dim 4) /// /////////////////////////////////////////////////////////////////////////// inline ZVector4& ZVector4::operator = (const ZVector3 &a) { x = a.x; y = a.y; z = a.z; w = 0.0f; return *this; } /////////////////////////////////////////////////////////////////////////// /// Setting des 4 coords du vecteur /// /////////////////////////////////////////////////////////////////////////// inline void ZVector4::SetCoord(float nx, float ny, float nz, float nw) { x = nx; y = ny; z = nz; w = nw; } /////////////////////////////////////////////////////////////////////////// /// Setting des 4 coords à zéro /// /////////////////////////////////////////////////////////////////////////// inline void ZVector4::SetNull() { x = y = z = w = 0.0f; } /////////////////////////////////////////////////////////////////////////// /// Cross product /// /////////////////////////////////////////////////////////////////////////// inline ZVector4 operator ^ (const ZVector4& A, const ZVector4& B) { ZVector4 Res; Res.x = A.y*B.z - A.z*B.y; Res.y = A.z*B.x - A.x*B.z; Res.z = A.x*B.y - A.y*B.x; Res.w = 0.0f; return Res; } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ZVector3 Class /// /// - Classe des vecteurs de dim 3 /// - Méthodes de calculs classiques sur les vecteurs /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /// Vector multiplication with a matrix (x y z 1) /// /////////////////////////////////////////////////////////////////////////// inline void VectorMult(const ZMatrix &Mat, const ZVector3 &Vec, ZVector3 &Res) { ZVector3 Result; Result.x = Mat._11 * Vec.x + Mat._12 * Vec.y + Mat._13 * Vec.z + Mat._14; Result.y = Mat._21 * Vec.x + Mat._22 * Vec.y + Mat._23 * Vec.z + Mat._24; Result.z = Mat._31 * Vec.x + Mat._32 * Vec.y + Mat._33 * Vec.z + Mat._34; Res.x = Result.x; Res.y = Result.y; Res.z = Result.z; } inline ZVector3 VectorMult(const ZMatrix &Mat, const ZVector3 &Vec) { ZVector3 Res; Res.x = Mat._11 * Vec.x + Mat._12 * Vec.y + Mat._13 * Vec.z + Mat._14; Res.y = Mat._21 * Vec.x + Mat._22 * Vec.y + Mat._23 * Vec.z + Mat._24; Res.z = Mat._31 * Vec.x + Mat._32 * Vec.y + Mat._33 * Vec.z + Mat._34; return Res; } inline ZVector3 operator * (const ZMatrix& Mat, const ZVector3& Vec) { return VectorMult(Mat, Vec); } /////////////////////////////////////////////////////////////////////////// /// Vector multiplication with a matrix & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector3& ZVector3::operator *= (const ZMatrix& Mat) { VectorMult(Mat, *this, *this); return *this; } /////////////////////////////////////////////////////////////////////////// /// Dot product /// /////////////////////////////////////////////////////////////////////////// inline float operator * (const ZVector3& A, const ZVector3& B) { return (A.x*B.x + A.y*B.y + A.z*B.z); } /////////////////////////////////////////////////////////////////////////// /// Cross product /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator ^ (const ZVector3& A, const ZVector3& B) { ZVector3 Res; Res.x = A.y*B.z - A.z*B.y; Res.y = A.z*B.x - A.x*B.z; Res.z = A.x*B.y - A.y*B.x; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator * (const ZVector3 &V, const float s) { ZVector3 Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; return Res; } inline ZVector3 operator * (const float s, const ZVector3 &V) { ZVector3 Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector3& ZVector3::operator *= (const float s) { x *= s; y *= s; z *= s; return *this; } /////////////////////////////////////////////////////////////////////////// /// Addition operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator + (const ZVector3& A, const ZVector3& B) { ZVector3 Res; Res.x = A.x + B.x; Res.y = A.y + B.y; Res.z = A.z + B.z; return Res; } /////////////////////////////////////////////////////////////////////////// /// Substraction operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator - (const ZVector3& A, const ZVector3& B) { ZVector3 Res; Res.x = A.x - B.x; Res.y = A.y - B.y; Res.z = A.z - B.z; return Res; } /////////////////////////////////////////////////////////////////////////// /// Addition & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 & ZVector3::operator += (const ZVector3 &B) { x += B.x; y += B.y; z += B.z; return *this; } /////////////////////////////////////////////////////////////////////////// /// Substraction & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 & ZVector3::operator -= (const ZVector3 &B) { x -= B.x; y -= B.y; z -= B.z; return *this; } /////////////////////////////////////////////////////////////////////////// /// Negative operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator - (const ZVector3 &A) { ZVector3 Res; Res.x = -A.x; Res.y = -A.y; Res.z = -A.z; return Res; } /////////////////////////////////////////////////////////////////////////// /// Positive operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator + (const ZVector3 &A) { return A; } /////////////////////////////////////////////////////////////////////////// /// Lenght of the vector /// /////////////////////////////////////////////////////////////////////////// inline float ZVector3::Length() { return ((float)sqrt(x*x + y*y + z*z)); } /////////////////////////////////////////////////////////////////////////// /// Lenght of the vector /// /////////////////////////////////////////////////////////////////////////// inline float ZVector3::SqLength() { return ((float)(x*x + y*y + z*z)); } /////////////////////////////////////////////////////////////////////////// /// Normalization of the vector /// /////////////////////////////////////////////////////////////////////////// inline ZVector3& ZVector3::Normalize() { float t = ((float)sqrt(x*x + y*y + z*z)); if((t<0.000001)&&(t>-0.000001)) t=1; x /= t; y /= t; z /= t; return *this; } /////////////////////////////////////////////////////////////////////////// /// Normalization operator /// /////////////////////////////////////////////////////////////////////////// inline ZVector3 operator ~ (const ZVector3 &V) { float t = ((float)sqrt(V.x*V.x + V.y*V.y + V.z*V.z)); ZVector3 Res; Res.x = V.x/t; Res.y = V.y/t; Res.z = V.z/t; return Res; } /////////////////////////////////////////////////////////////////////////// /// Setting des 3 coords du vecteur /// /////////////////////////////////////////////////////////////////////////// inline void ZVector3::SetCoord(float nx, float ny, float nz) { x = nx; y = ny; z = nz; } /////////////////////////////////////////////////////////////////////////// /// Setting des 3 coords à zéro /// /////////////////////////////////////////////////////////////////////////// inline void ZVector3::SetNull() { x = y = z = 0.0f; } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ZUV Class /// /// - Classe des vecteurs de dim 3 /// - Méthodes de calculs classiques sur les vecteurs /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication /// /////////////////////////////////////////////////////////////////////////// inline ZUV operator * (const ZUV &V, const float s) { ZUV Res; Res.u = V.u * s; Res.v = V.v * s; return Res; } inline ZUV operator * (const float s, const ZUV &V) { ZUV Res; Res.u = V.u * s; Res.v = V.v * s; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZUV& ZUV::operator *= (const float s) { u *= s; v *= s; return *this; } /////////////////////////////////////////////////////////////////////////// /// Addition operator /// /////////////////////////////////////////////////////////////////////////// inline ZUV operator + (const ZUV& A, const ZUV& B) { ZUV Res; Res.u = A.u + B.u; Res.v = A.v + B.v; return Res; } /////////////////////////////////////////////////////////////////////////// /// Substraction operator /// /////////////////////////////////////////////////////////////////////////// inline ZUV operator - (const ZUV& A, const ZUV& B) { ZUV Res; Res.u = A.u - B.u; Res.v = A.v - B.v; return Res; } /////////////////////////////////////////////////////////////////////////// /// Addition & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZUV & ZUV::operator += (const ZUV &B) { u += B.u; v += B.v; return *this; } /////////////////////////////////////////////////////////////////////////// /// Substraction & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZUV & ZUV::operator -= (const ZUV &B) { u -= B.u; v -= B.v; return *this; } /////////////////////////////////////////////////////////////////////////// /// Negative operator /// /////////////////////////////////////////////////////////////////////////// inline ZUV operator - (const ZUV &A) { ZUV Res; Res.u = -A.u; Res.v = -A.v; return Res; } /////////////////////////////////////////////////////////////////////////// /// Positive operator /// /////////////////////////////////////////////////////////////////////////// inline ZUV operator + (const ZUV &A) { return A; } /////////////////////////////////////////////////////////////////////////// /// Setting des 3 coords du vecteur /// /////////////////////////////////////////////////////////////////////////// inline void ZUV::SetCoord(float nu, float nv) { u = nu; v = nv; } /////////////////////////////////////////////////////////////////////////// /// Setting des 3 coords à zéro /// /////////////////////////////////////////////////////////////////////////// inline void ZUV::SetNull() { u = v = 0.0f; } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ZQuat Class /// /// - Classe des quaternions /// - Méthodes de passage de quaternion a matrice, et vice-versa /// - Interpolation circulaire de quaternions /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /// Setting des 4 coords du vecteur /// /////////////////////////////////////////////////////////////////////////// inline void ZQuat::SetCoord(float nx, float ny, float nz, float nw) { x = nx; y = ny; z = nz; w = nw; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication /// /////////////////////////////////////////////////////////////////////////// inline ZQuat operator * (const ZQuat &V, const float s) { ZQuat Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; Res.w = V.w * s; return Res; } inline ZQuat operator * (const float s, const ZQuat &V) { ZQuat Res; Res.x = V.x * s; Res.y = V.y * s; Res.z = V.z * s; Res.w = V.w * s; return Res; } /////////////////////////////////////////////////////////////////////////// /// Scalar multiplication & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZQuat& ZQuat::operator *= (const float s) { x *= s; y *= s; z *= s; w *= s; return *this; } /////////////////////////////////////////////////////////////////////////// /// Addition operator /// /////////////////////////////////////////////////////////////////////////// inline ZQuat operator + (const ZQuat& A, const ZQuat& B) { ZQuat Res; Res.x = A.x + B.x; Res.y = A.y + B.y; Res.z = A.z + B.z; Res.w = A.w + B.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Substraction operator /// /////////////////////////////////////////////////////////////////////////// inline ZQuat operator - (const ZQuat& A, const ZQuat& B) { ZQuat Res; Res.x = A.x - B.x; Res.y = A.y - B.y; Res.z = A.z - B.z; Res.w = A.w - B.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Addition & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZQuat & ZQuat::operator += (const ZQuat &B) { x += B.x; y += B.y; z += B.z; w += B.w; return *this; } /////////////////////////////////////////////////////////////////////////// /// Substraction & affectation /// /////////////////////////////////////////////////////////////////////////// inline ZQuat & ZQuat::operator -= (const ZQuat &B) { x -= B.x; y -= B.y; z -= B.z; w -= B.w; return *this; } /////////////////////////////////////////////////////////////////////////// /// Negative operator /// /////////////////////////////////////////////////////////////////////////// inline ZQuat operator - (const ZQuat &A) { ZQuat Res; Res.x = -A.x; Res.y = -A.y; Res.z = -A.z; Res.w = -A.w; return Res; } /////////////////////////////////////////////////////////////////////////// /// Positive operator /// /////////////////////////////////////////////////////////////////////////// inline ZQuat operator + (const ZQuat &A) { return A; }