# HG changeset patch # User Eris Caffee # Date 1367820372 18000 # Node ID 1d2b25d4517f41471458a2c4e449d851ddd13b29 # Parent 398894c52b697ee927fe6be88f33f4b5150da1e4 Lot's of updates, some quite old since I guess I forgot to commit a while back. But I just added rotation matrix related things. diff -r 398894c52b69 -r 1d2b25d4517f include/Math.h --- a/include/Math.h Fri Oct 07 13:33:48 2011 -0500 +++ b/include/Math.h Mon May 06 01:06:12 2013 -0500 @@ -4,29 +4,30 @@ #include "Vector.h" #include "Matrix.h" +/////////////////////////////////////////////////////////////////////////////////// +// Notes for improvement +// +// The angle related constants (PI, 2PI, etc) and functions (deg_to_rad, rad_to_deg) +// could be made faster by using #define's. In fact, this would turn them into +// compile time operations. But it would also put them, effectively, in the +// global namespace. Do I want that? For now I'm leaving things as const +// variables and inline functions. I can profile things later to see if changes +// are really needed. + namespace arda { //////////////////////////////////////////////////////////////////////////////// - // General notes: - // - // As much as possible is defined inline for performance. - // Using typedef'ed arrays for vectors and matrices necessitates a lot of - // redundant function names: scale2, scale3, scale4, for example. - // This is, however, perfectly in line with the implementation of OpenGL and - // allows the library to maintain optimal memory usage and performance. (I hope!) - // In any event, I think I could do far worse than to emulate the OpenGL - // working group - a group of people who have studied this for years and are - // experts in the field. - - //////////////////////////////////////////////////////////////////////////////// // Angles namespace Math { // This many decimals is enough to cover even IEEE quad precision (128 bit) // reals. Run on PA-RISC lately? :) - const double PI = 3.14159265358979323846264338327950288; + long double const PI = 3.14159265358979323846264338327950288; + long double const TWO_PI = 6.28318530717958647692528676655900577; + long double const PI_DIV_180 = 0.01745329251994329576923690768488613; + long double const INV_PI_DIV_180 = 57.29577951308232087679815481410517033; ////////////////////////////////////////////////////////////////////////// // Mixed Vector / Matrix operations. @@ -35,8 +36,10 @@ // operators are not part of the class. They are defined independently. // - // Vector * Matrix - template inline Vector2& operator*=(Vector2& v, const Matrix22& m) + // Vector2 * Matrix22 + template + inline Vector2& operator*=(Vector2 & v, + Matrix22 const & m) { Vector2 vres(0); vres[0] = v[0]*m[0] + v[1]*m[1]; @@ -44,12 +47,16 @@ v = vres; return v; } - template inline Vector2 operator*(const Vector2& v, const Matrix22& m) + + template + inline Vector2 operator*(Vector2 const & v, + Matrix22 const & m) { return Vector2(v) *= m; } - // Matrix * Vector // Note: can't define Matrix *= Vector since the result is a Vector. - template inline Vector2 operator*(const Matrix22& m, const Vector2& v) + template + inline Vector2 operator*(Matrix22 const & m, + Vector2 const & v) { Vector2 vres(0); vres[0] = m[0]*v[0] + m[2]*v[1]; @@ -57,8 +64,110 @@ return vres; } + //////////////////////////////////////// + // Vector3 * Matrix33 + template + inline Vector3& operator*=(Vector3 & v, + Matrix33 const & m) + { + Vector3 vres(0); + vres[0] = v[0]*m[0] + v[1]*m[1] + v[2]*m[2]; + vres[1] = v[0]*m[3] + v[1]*m[4] + v[2]*m[5]; + vres[2] = v[0]*m[6] + v[1]*m[7] + v[2]*m[8]; + v = vres; + return v; + } + + template + inline Vector3 operator*(Vector3 const & v, + Matrix33 const & m) + { return Vector3(v) *= m; } + + // Matrix * Vector + // Note: can't define Matrix *= Vector since the result is a Vector. + template + inline Vector3 operator*(Matrix33 const & m, + Vector3 const & v) + { + Vector3 vres(0); + vres[0] = m[0]*v[0] + m[3]*v[1] + m[6]*v[2]; + vres[1] = m[1]*v[0] + m[4]*v[1] + m[7]*v[2]; + vres[2] = m[2]*v[0] + m[5]*v[1] + m[8]*v[2]; + return vres; + } + + //////////////////////////////////////// + // Vector4 * Matrix44 + template + inline Vector4& operator*=(Vector4 & v, + Matrix44 const & m) + { + Vector4 vres(0); + vres[0] = v[0]*m[0] + v[1]*m[1] + v[2]*m[2] + v[3]*m[3]; + vres[1] = v[0]*m[4] + v[1]*m[5] + v[2]*m[6] + v[3]*m[7]; + vres[8] = v[0]*m[8] + v[1]*m[9] + v[2]*m[10] + v[3]*m[11]; + vres[3] = v[0]*m[12] + v[1]*m[13] + v[2]*m[14] + v[3]*m[15]; + v = vres; + return v; + } + + template + inline Vector4 operator*(Vector4 const & v, + Matrix44 const & m) + { return Vector4(v) *= m; } + + // Matrix * Vector + // Note: can't define Matrix *= Vector since the result is a Vector. + template + inline Vector4 operator*(Matrix44 const & m, + Vector4 const & v) + { + Vector4 vres(0); + vres[0] = m[0]*v[0] + m[4]*v[1] + m[8]*v[2] + m[12]*v[3]; + vres[1] = m[1]*v[0] + m[5]*v[1] + m[9]*v[2] + m[13]*v[3]; + vres[2] = m[2]*v[0] + m[6]*v[1] + m[10]*v[2] + m[14]*v[3]; + vres[3] = m[3]*v[0] + m[7]*v[1] + m[11]*v[2] + m[15]*v[3]; + return vres; + } + + ////////////////////////////////////////////////////////////////////////// + + template + void get_rot_mat33(Matrix33 & m, float rot, Vector3 v); + + + ////////////////////////////////////////////////////////////////////////// + + inline double deg_to_rad(double deg) { return deg * PI_DIV_180; }; + inline double rad_to_deg(double rad) { return rad * INV_PI_DIV_180; }; + } // namespace Math } // namespace arda +//////////////////////////////////////////////////////////////////////////////// +template +void arda::Math::get_rot_mat33(arda::Math::Matrix33 & m, float theta, arda::Math::Vector3 v) + { + m.setidentity(); + if (0.0 == v.length()) + return; + + // TODO: I should also immediately return identity if theta is a multiple of 2*PI but I'm not + // yet sure how I should I check for that (taking into account floating point imprecision). + + + v.normalize(); + + float c = cos(theta); + float s = sin(theta); + float one_minus_c = 1.0f - c; + + m.assign( + c + one_minus_c * v.x * v.x , one_minus_c * v.x * v.y + s * v.z , one_minus_c * v.x * v.z - s * v.y , + one_minus_c * v.x * v.y - s * v.z , c + one_minus_c * v.y * v.y , one_minus_c * v.y * v.z + s * v.x , + one_minus_c * v.x * v.z + s * v.y , one_minus_c * v.y * v.z - s * v.x , c + one_minus_c * v.z * v.z + ); + } + #endif diff -r 398894c52b69 -r 1d2b25d4517f include/Matrix.h --- a/include/Matrix.h Fri Oct 07 13:33:48 2011 -0500 +++ b/include/Matrix.h Mon May 06 01:06:12 2013 -0500 @@ -33,7 +33,7 @@ // // assign() Assign the value of one matrix to another. // getcol() Returns the vector that is column n of the matrix. - // getstring() Returns a printable string representation of the matrix. + // to_string() Returns a printable string representation of the matrix. // setcol() Set the vector that is column n of the matrix. // Overloaded so that you can set from a vector or from // specific values. @@ -50,7 +50,8 @@ // transpose() Returns the transpose of a matrix. ////////////////////////////////////////////////////////////////////////// - template class Matrix22 + template + class Matrix22 { public: T m[4]; @@ -66,19 +67,20 @@ // Array indexing // Remember: column major order is used. - inline T& operator[](unsigned int i) + inline T& operator[](unsigned int const i) { assert (i<4); return m[i]; } - inline T operator[](unsigned int i) const + inline T operator[](unsigned int const i) const { assert (i<4); return m[i]; } // Assignment - inline Matrix22& operator=(const Matrix22& m2) + inline Matrix22& operator=(Matrix22 const & m2) { m[0] = m2[0]; m[2] = m2[2]; m[1] = m2[1]; m[3] = m2[3]; return *this; } - inline Matrix22& assign(T a0, T a1, T a2, T a3) + inline Matrix22& assign(T const a0, T const a1, + T const a2, T const a3) { m[0] = a0; m[2] = a2; m[1] = a1; m[3] = a3; @@ -86,49 +88,49 @@ } // Comparison - inline bool operator==(Matrix22& m2) const + inline bool operator==(Matrix22 const & m2) const { return m[0] == m2[0] && m[2] == m2[2] && m[1] == m2[1] && m[3] == m2[3]; } - inline bool operator!=(Matrix22& m2) const + inline bool operator!=(Matrix22 const & m2) const { return ! (*this == m2); } // Matrix addition - inline Matrix22& operator+=(const Matrix22& m2) + inline Matrix22& operator+=(Matrix22 const & m2) { m[0] += m2[0]; m[2] += m2[2]; m[1] += m2[1]; m[3] += m2[3]; return *this; } - inline Matrix22 operator+(const Matrix22& m2) const + inline Matrix22 operator+(Matrix22 const & m2) const { return Matrix22(*this) += m2; } // Matrix subtraction - inline Matrix22& operator-=(const Matrix22& m2) + inline Matrix22& operator-=(Matrix22 const & m2) { m[0] -= m2[0]; m[2] -= m2[2]; m[1] -= m2[1]; m[3] -= m2[3]; return *this; } - inline Matrix22 operator-(const Matrix22& m2) const + inline Matrix22 operator-(Matrix22 const & m2) const { return Matrix22(*this) -= m2; } // Scalar multiplication - inline Matrix22& operator*=(const int a) + inline Matrix22& operator*=(int const a) { m[0] *= a; m[2] *= a; m[1] *= a; m[3] *= a; return *this; } - inline Matrix22& operator*=(const float a) + inline Matrix22& operator*=(float const a) { m[0] *= a; m[2] *= a; m[1] *= a; m[3] *= a; return *this; } - inline Matrix22& operator*=(const double a) + inline Matrix22& operator*=(double const a) { m[0] *= a; m[2] *= a; m[1] *= a; m[3] *= a; @@ -136,39 +138,39 @@ } // Scalar division - inline Matrix22& operator/=(const int a) + inline Matrix22& operator/=(int const a) { assert(a!=0); m[0] /= a; m[2] /= a; m[1] /= a; m[3] /= a; return *this; } - inline Matrix22& operator/=(const float a) + inline Matrix22& operator/=(float const a) { assert(a!=0); m[0] /= a; m[2] /= a; m[1] /= a; m[3] /= a; return *this; } - inline Matrix22& operator/=(const double a) + inline Matrix22& operator/=(double const a) { assert(a!=0); m[0] /= a; m[2] /= a; m[1] /= a; m[3] /= a; return *this; } - inline Matrix22 operator/(const int a) + inline Matrix22 operator/(int const a) { return Matrix22(*this) /= a; } - inline Matrix22 operator/(const float a) + inline Matrix22 operator/(float const a) { return Matrix22(*this) /= a; } - inline Matrix22 operator/(const double a) + inline Matrix22 operator/(double const a) { return Matrix22(*this) /= a; } // Matrix multiplication // Not sure if this should be inlined at all. Sure the compiler will // probably ignore the inline request here, but maybe it won't and maybe // that would be bad. Needs real testing. - inline Matrix22& operator*=(Matrix22 m2) + inline Matrix22& operator*=(Matrix22 const & m2) { const int size=2; Matrix22 mres(0); @@ -180,34 +182,34 @@ *this = mres; return *this; } - inline Matrix22 operator*(Matrix22 m2) const + inline Matrix22 operator*(Matrix22 const & m2) const { return Matrix22(*this) *= m2; } - inline Vector2 getcol(const unsigned int i) const + inline Vector2 getcol(unsigned int const i) const { assert(i<2); - const int size=2; + int const size=2; return Vector2(m[i*size], m[i*size+1]); } - inline Vector2 getrow(const unsigned int i) const + inline Vector2 getrow(unsigned int const i) const { assert(i<2); - const int size=2; + int const size=2; return Vector2(m[i], m[i+size]); } - inline Matrix22& setcol(const unsigned int i, const Vector2& v) + inline Matrix22& setcol(unsigned int const i, Vector2 const & v) { assert(i<2); - const int size=2; + int const size=2; m[i*size] = v[0]; m[i*size+1] = v[1]; return *this; } - inline Matrix22& setcol(const unsigned int i, const T a, const T b) + inline Matrix22& setcol(unsigned int const i, T const a, T const b) { assert(i<2); const int size=2; @@ -216,25 +218,25 @@ return *this; } - inline Matrix22& setrow(const unsigned int i, const Vector2& v) + inline Matrix22& setrow(unsigned int const i, Vector2 const & v) { assert(i<2); - const int size=2; + int const size=2; m[i] = v[0]; m[i+size] = v[1]; return *this; } - inline Matrix22& setrow(const unsigned int i, const T a, const T b) + inline Matrix22& setrow(unsigned int const i, T const a, T const b) { assert(i<2); - const int size=2; + int const size=2; m[i] = a; m[i+size] = b; return *this; } - std::string & getstring(std::string & s) const; + std::string & to_string(std::string & s) const; inline Matrix22& setidentity() { @@ -246,28 +248,560 @@ }; // Scalar multiplication continued - template inline Matrix22 operator*(const Matrix22& m, const int a) + template + inline Matrix22 operator*(Matrix22 const & m, int const a) { return Matrix22(m) *= a; } - template inline Matrix22 operator*(const int a, const Matrix22& m) + + template + inline Matrix22 operator*(int const a, Matrix22 const & m) { return Matrix22(m) *= a; } - template inline Matrix22 operator*(const Matrix22& m, const float a) + + template + inline Matrix22 operator*(Matrix22 const & m, float const a) { return Matrix22(m) *= a; } - template inline Matrix22 operator*(const float a, const Matrix22& m) + + template + inline Matrix22 operator*(float const a, Matrix22 const & m) { return Matrix22(m) *= a; } - template inline Matrix22 operator*(const Matrix22& m, const double a) + + template + inline Matrix22 operator*(Matrix22 const & m, double const a) { return Matrix22(m) *= a; } - template inline Matrix22 operator*(const double a, const Matrix22& m) + + template + inline Matrix22 operator*(double const a, Matrix22 const & m) { return Matrix22(m) *= a; } ////////////////////////////////////////////////////////////////////////// + template + class Matrix33 + { + public: + T m[9]; + + // Constructors + Matrix33() {} + explicit Matrix33(T a) + { + // TODO: Is this really more efficient than memset? + m[0] = m[1] = m[2] = m[3] = m[4] = m[5] = m[6] = m[7] = m[8] = a; + } + Matrix33(T a0, T a1, T a2, + T a3, T a4, T a5, + T a6, T a7, T a8) + { + m[0] = a0; m[3] = a3; m[6] = a6; + m[1] = a1; m[4] = a4; m[7] = a7; + m[2] = a2; m[5] = a5; m[8] = a8; + } + + // Array indexing + // Remember: column major order is used. + inline T& operator[](unsigned int const i) + { assert (i<9); return m[i]; } + inline T operator[](unsigned int const i) const + { assert (i<9); return m[i]; } + + // Assignment + inline Matrix33& operator=(Matrix33 const & m2) + { + m[0] = m2[0]; m[3] = m2[3]; m[6] = m2[6]; + m[1] = m2[1]; m[4] = m2[4]; m[7] = m2[7]; + m[2] = m2[2]; m[5] = m2[5]; m[8] = m2[8]; + return *this; + } + inline Matrix33& assign(T const a0, T const a1, T const a2, + T const a3, T const a4, T const a5, + T const a6, T const a7, T const a8) + { + m[0] = a0; m[3] = a3; m[6] = a6; + m[1] = a1; m[4] = a4; m[7] = a7; + m[2] = a2; m[5] = a5; m[8] = a8; + return *this; + } + + // Comparison + inline bool operator==(Matrix33 const & m2) const + { + return + m[0] == m2[0] && m[3] == m2[3] && m[6] == m2[6] && + m[1] == m2[1] && m[4] == m2[4] && m[7] == m2[7] && + m[2] == m2[2] && m[5] == m2[5] && m[8] == m2[8]; + } + inline bool operator!=(Matrix33 const & m2) const + { return ! (*this == m2); } + + // Matrix addition + inline Matrix33& operator+=(Matrix33 const & m2) + { + m[0] += m2[0]; m[3] += m2[3]; m[6] += m2[6]; + m[1] += m2[1]; m[4] += m2[4]; m[7] += m2[7]; + m[2] += m2[2]; m[5] += m2[5]; m[8] += m2[8]; + return *this; + } + inline Matrix33 operator+(Matrix33 const & m2) const + { return Matrix33(*this) += m2; } + + // Matrix subtraction + inline Matrix33& operator-=(Matrix33 const & m2) + { + m[0] -= m2[0]; m[3] -= m2[3]; m[6] -= m2[6]; + m[1] -= m2[1]; m[4] -= m2[4]; m[7] -= m2[7]; + m[2] -= m2[2]; m[5] -= m2[5]; m[8] -= m2[8]; + return *this; + } + inline Matrix33 operator-(Matrix33 const & m2) const + { return Matrix33(*this) -= m2; } + + // Scalar multiplication + inline Matrix33& operator*=(int const a) + { + m[0] *= a; m[3] *= a; m[6] *= a; + m[1] *= a; m[4] *= a; m[7] *= a; + m[2] *= a; m[5] *= a; m[8] *= a; + return *this; + } + inline Matrix33& operator*=(float const a) + { + m[0] *= a; m[3] *= a; m[6] *= a; + m[1] *= a; m[4] *= a; m[7] *= a; + m[2] *= a; m[5] *= a; m[8] *= a; + return *this; + } + inline Matrix33& operator*=(double const a) + { + m[0] *= a; m[3] *= a; m[6] *= a; + m[1] *= a; m[4] *= a; m[7] *= a; + m[2] *= a; m[5] *= a; m[8] *= a; + return *this; + } + + // Scalar division + inline Matrix33& operator/=(int const a) + { + assert(a!=0); + m[0] /= a; m[3] /= a; m[6] /= a; + m[1] /= a; m[4] /= a; m[7] /= a; + m[2] /= a; m[5] /= a; m[8] /= a; + return *this; + } + inline Matrix33& operator/=(float const a) + { + assert(a!=0); + m[0] /= a; m[3] /= a; m[6] /= a; + m[1] /= a; m[4] /= a; m[7] /= a; + m[2] /= a; m[5] /= a; m[8] /= a; + return *this; + } + inline Matrix33& operator/=(double const a) + { + assert(a!=0); + m[0] /= a; m[3] /= a; m[6] /= a; + m[1] /= a; m[4] /= a; m[7] /= a; + m[2] /= a; m[5] /= a; m[8] /= a; + return *this; + } + inline Matrix33 operator/(int const a) + { return Matrix33(*this) /= a; } + inline Matrix33 operator/(float const a) + { return Matrix33(*this) /= a; } + inline Matrix33 operator/(double const a) + { return Matrix33(*this) /= a; } + + // Matrix multiplication + // Not sure if this should be inlined at all. Sure the compiler will + // probably ignore the inline request here, but maybe it won't and maybe + // that would be bad. Needs real testing. + inline Matrix33& operator*=(Matrix33 const & m2) + { + const int size=3; + Matrix33 mres(0); + int i, j, k; + for (i=0; i operator*(Matrix33 const & m2) const + { return Matrix33(*this) *= m2; } + + + inline Vector3 getcol(unsigned int const i) const + { + assert(i<3); + const int size=3; + return Vector3(m[i*size], m[i*size+1], m[i*size+2]); + } + + inline Vector3 getrow(unsigned int const i) const + { + assert(i<3); + const int size=3; + return Vector3(m[i], m[i+size], m[i+2*size]); + } + + inline Matrix33& setcol(unsigned int const i, Vector3 const & v) + { + assert(i<3); + const int size=3; + m[i*size] = v[0]; + m[i*size+1] = v[1]; + m[i*size+2] = v[2]; + return *this; + } + + inline Matrix33& setcol(unsigned int const i, + T const a0, T const a1, T const a2) + { + assert(i<3); + const int size=3; + m[i*size] = a0; + m[i*size+1] = a1; + m[i*size+2] = a2; + return *this; + } + + inline Matrix33& setrow(unsigned int const i, Vector3 const & v) + { + assert(i<3); + const int size=3; + m[i] = v[0]; + m[i+size] = v[1]; + m[i+2*size] = v[2]; + return *this; + } + + inline Matrix33& setrow(unsigned int const i, + T const a0, T const a1, T const a2) + { + assert(i<3); + const int size=3; + m[i] = a0; + m[i+size] = a1; + m[i+2*size] = a2; + return *this; + } + + std::string & to_string(std::string & s) const; + + inline Matrix33& setidentity() + { + memset(m, 0, sizeof(m)); + m[0] = m[4] = m[8] = 1; + return *this; + } + + }; + + // Scalar multiplication continued + template + inline Matrix33 operator*(Matrix33 const & m, int const a) + { return Matrix33(m) *= a; } + + template + inline Matrix33 operator*(int const a, Matrix33 const & m) + { return Matrix33(m) *= a; } + + template + inline Matrix33 operator*(Matrix33 const & m, float const a) + { return Matrix33(m) *= a; } + + template + inline Matrix33 operator*(float const a, Matrix33 const & m) + { return Matrix33(m) *= a; } + + template + inline Matrix33 operator*(Matrix33 const & m, double const a) + { return Matrix33(m) *= a; } + + template + inline Matrix33 operator*(double const a, Matrix33 const & m) + { return Matrix33(m) *= a; } + + + + + ////////////////////////////////////////////////////////////////////////// + template + class Matrix44 + { + public: + T m[16]; + + // Constructors + Matrix44() {} + explicit Matrix44(T a) + { + // TODO: Is this really more efficient than memset? + m[0] = m[1] = m[2] = m[3] = m[4] = m[5] = m[6] = m[7] = m[8] = + m[9] = m[10] = m[11] = m[12] = m[13] = m[14] = m[15] = a; + } + Matrix44(T a0, T a1, T a2, T a3, + T a4, T a5, T a6, T a7, + T a8, T a9, T a10, T a11, + T a12, T a13, T a14, T a15) + { + m[0] = a0; m[4] = a4; m[8] = a8; m[12] = a12; + m[1] = a1; m[5] = a5; m[9] = a9; m[13] = a13; + m[2] = a2; m[6] = a6; m[10] = a10; m[14] = a14; + m[3] = a3; m[7] = a7; m[11] = a11; m[15] = a15; + } + + // Array indexing + // Remember: column major order is used. + inline T& operator[](unsigned int const i) + { assert (i<16); return m[i]; } + inline T operator[](unsigned int const i) const + { assert (i<16); return m[i]; } + + // Assignment + inline Matrix44& operator=(Matrix44 const & m2) + { + m[0] = m2[0]; m[4] = m2[4]; m[8] = m2[8]; m[12] = m2[12]; + m[1] = m2[1]; m[5] = m2[5]; m[9] = m2[9]; m[13] = m2[13]; + m[2] = m2[2]; m[6] = m2[6]; m[10] = m2[10]; m[14] = m2[14]; + m[3] = m2[3]; m[7] = m2[7]; m[11] = m2[11]; m[15] = m2[15]; + return *this; + } + inline Matrix44& assign(T const a0, T const a1, T const a2, T const a3, + T const a4, T const a5, T const a6, T const a7, + T const a8, T const a9, T const a10, T const a11, + T const a12, T const a13, T const a14, T const a15) + { + m[0] = a0; m[4] = a4; m[8] = a8; m[12] = a12; + m[1] = a1; m[5] = a5; m[9] = a9; m[13] = a13; + m[2] = a2; m[6] = a6; m[10] = a10; m[14] = a14; + m[3] = a3; m[7] = a7; m[11] = a11; m[15] = a15; + return *this; + } + + // Comparison + inline bool operator==(Matrix44 const & m2) const + { + // TODO: Should this use memcmp? + return + m[0] == m2[0] && m[4] == m2[4] && m[8] == m2[8] && m[12] == m2[12] && + m[1] == m2[1] && m[5] == m2[5] && m[9] == m2[9] && m[13] == m2[13] && + m[2] == m2[2] && m[6] == m2[6] && m[10] == m2[10] && m[14] == m2[14] && + m[3] == m2[3] && m[7] == m2[7] && m[11] == m2[11] && m[15] == m2[15]; + } + inline bool operator!=(Matrix44 const & m2) const + { return ! (*this == m2); } + + // Matrix addition + inline Matrix44& operator+=(Matrix44 const & m2) + { + m[0] += m2[0]; m[4] += m2[4]; m[8] += m2[8]; m[12] += m2[12]; + m[1] += m2[1]; m[5] += m2[5]; m[9] += m2[9]; m[13] += m2[13]; + m[2] += m2[2]; m[6] += m2[6]; m[10] += m2[10]; m[14] += m2[14]; + m[3] += m2[3]; m[7] += m2[7]; m[11] += m2[11]; m[15] += m2[15]; + return *this; + } + inline Matrix44 operator+(Matrix44 const & m2) const + { return Matrix44(*this) += m2; } + + // Matrix subtraction + inline Matrix44& operator-=(Matrix44 const & m2) + { + m[0] -= m2[0]; m[4] -= m2[4]; m[8] -= m2[8]; m[12] -= m2[12]; + m[1] -= m2[1]; m[5] -= m2[5]; m[9] -= m2[9]; m[13] -= m2[13]; + m[2] -= m2[2]; m[6] -= m2[6]; m[10] -= m2[10]; m[14] -= m2[14]; + m[3] -= m2[3]; m[7] -= m2[7]; m[11] -= m2[11]; m[15] -= m2[15]; + return *this; + } + inline Matrix44 operator-(Matrix44 const & m2) const + { return Matrix44(*this) -= m2; } + + // Scalar multiplication + inline Matrix44& operator*=(int const a) + { + m[0] *= a; m[4] *= a; m[8] *= a; m[12] *= a; + m[1] *= a; m[5] *= a; m[9] *= a; m[13] *= a; + m[2] *= a; m[6] *= a; m[10] *= a; m[14] *= a; + m[3] *= a; m[7] *= a; m[11] *= a; m[15] *= a; + return *this; + } + inline Matrix44& operator*=(float const a) + { + m[0] *= a; m[4] *= a; m[8] *= a; m[12] *= a; + m[1] *= a; m[5] *= a; m[9] *= a; m[13] *= a; + m[2] *= a; m[6] *= a; m[10] *= a; m[14] *= a; + m[3] *= a; m[7] *= a; m[11] *= a; m[15] *= a; + return *this; + } + inline Matrix44& operator*=(double const a) + { + m[0] *= a; m[4] *= a; m[8] *= a; m[12] *= a; + m[1] *= a; m[5] *= a; m[9] *= a; m[13] *= a; + m[2] *= a; m[6] *= a; m[10] *= a; m[14] *= a; + m[3] *= a; m[7] *= a; m[11] *= a; m[15] *= a; + return *this; + } + + // Scalar division + inline Matrix44& operator/=(int const a) + { + assert(a!=0); + m[0] /= a; m[4] /= a; m[8] /= a; m[12] /= a; + m[1] /= a; m[5] /= a; m[9] /= a; m[13] /= a; + m[2] /= a; m[6] /= a; m[10] /= a; m[14] /= a; + m[3] /= a; m[7] /= a; m[11] /= a; m[15] /= a; + return *this; + } + inline Matrix44& operator/=(float const a) + { + assert(a!=0); + m[0] /= a; m[4] /= a; m[8] /= a; m[12] /= a; + m[1] /= a; m[5] /= a; m[9] /= a; m[13] /= a; + m[2] /= a; m[6] /= a; m[10] /= a; m[14] /= a; + m[3] /= a; m[7] /= a; m[11] /= a; m[15] /= a; + return *this; + } + inline Matrix44& operator/=(double const a) + { + assert(a!=0); + m[0] /= a; m[4] /= a; m[8] /= a; m[12] /= a; + m[1] /= a; m[5] /= a; m[9] /= a; m[13] /= a; + m[2] /= a; m[6] /= a; m[10] /= a; m[14] /= a; + m[3] /= a; m[7] /= a; m[11] /= a; m[15] /= a; + return *this; + } + inline Matrix44 operator/(int const a) + { return Matrix44(*this) /= a; } + inline Matrix44 operator/(float const a) + { return Matrix44(*this) /= a; } + inline Matrix44 operator/(double const a) + { return Matrix44(*this) /= a; } + + // Matrix multiplication + // Not sure if this should be inlined at all. Sure the compiler will + // probably ignore the inline request here, but maybe it won't and maybe + // that would be bad. Needs real testing. + inline Matrix44& operator*=(Matrix44 const & m2) + { + const int size=4; + Matrix44 mres(0); + int i, j, k; + for (i=0; i operator*(Matrix44 const & m2) const + { return Matrix44(*this) *= m2; } + + + inline Vector4 getcol(unsigned int const i) const + { + assert(i<4); + const int size=4; + return Vector4(m[i*size], m[i*size+1], m[i*size+2], m[i*size+3]); + } + + inline Vector4 getrow(unsigned int const i) const + { + assert(i<4); + const int size=4; + return Vector4(m[i], m[i+size], m[i+2*size], m[i+3*size]); + } + + inline Matrix44& setcol(unsigned int const i, Vector4 const & v) + { + assert(i<4); + const int size=4; + m[i*size] = v[0]; + m[i*size+1] = v[1]; + m[i*size+2] = v[2]; + m[i*size+3] = v[3]; + return *this; + } + + inline Matrix44& setcol(unsigned int const i, + T const a0, T const a1, T const a2, T const a3) + { + assert(i<4); + const int size=4; + m[i*size] = a0; + m[i*size+1] = a1; + m[i*size+2] = a2; + m[i*size+3] = a3; + return *this; + } + + inline Matrix44& setrow(unsigned int const i, Vector4 const & v) + { + assert(i<4); + const int size=4; + m[i] = v[0]; + m[i+size] = v[1]; + m[i+2*size] = v[2]; + m[i+3*size] = v[3]; + return *this; + } + + inline Matrix44& setrow(unsigned int const i, + T const a0, T const a1, T const a2, T const a3) + { + assert(i<4); + const int size=4; + m[i] = a0; + m[i+size] = a1; + m[i+2*size] = a2; + m[i+3*size] = a3; + return *this; + } + + std::string & to_string(std::string & s) const; + + inline Matrix44& setidentity() + { + memset(m, 0, sizeof(m)); + m[0] = m[5] = m[10] = m[15] = 1; + return *this; + } + + }; + + // Scalar multiplication continued + template + inline Matrix44 operator*(Matrix44 const & m, int const a) + { return Matrix44(m) *= a; } + + template + inline Matrix44 operator*(int const a, Matrix44 const & m) + { return Matrix44(m) *= a; } + + template + inline Matrix44 operator*(Matrix44 const & m, float const a) + { return Matrix44(m) *= a; } + + template + inline Matrix44 operator*(float const a, Matrix44 const & m) + { return Matrix44(m) *= a; } + + template + inline Matrix44 operator*(Matrix44 const & m, double const a) + { return Matrix44(m) *= a; } + + template + inline Matrix44 operator*(double const a, Matrix44 const & m) + { return Matrix44(m) *= a; } + + + + + ////////////////////////////////////////////////////////////////////////// typedef Matrix22 Matrix22i; typedef Matrix22 Matrix22f; typedef Matrix22 Matrix22d; -#ifdef NOTHING typedef Matrix33 Matrix33i; typedef Matrix33 Matrix33f; typedef Matrix33 Matrix33d; @@ -275,18 +809,23 @@ typedef Matrix44 Matrix44i; typedef Matrix44 Matrix44f; typedef Matrix44 Matrix44d; - -#endif - ////////////////////////////////////////////////////////////////////////// // Matrix functions + // TODO: The determinant functions suffer from some bad round off error. + // If it significant? I don't know. None of the other game engines + // I've checked bother to do anything to calculate det more accurately. + // So maybe it just doesn't matter enough for game purposes. - template inline double det(const Matrix22 m) - { return (double) (m[0] * m[3]) - (double) (m[1] * m[2]); } + template + inline double det(Matrix22 const & m) + { + return (double) (m[0] * m[3]) - (double) (m[1] * m[2]); + } - template inline Matrix22 transpose(const Matrix22& m) + template + inline Matrix22 transpose(Matrix22 const & m) { const int size=2; Matrix22 mres(0); @@ -297,6 +836,53 @@ return mres; } + template + inline double det(Matrix33 const & m) + { + return m[0] * ( (double) m[4] * m[8] - (double) m[5] * m[7]) + - m[3] * ( (double) m[1] * m[8] - (double) m[2] * m[7]) + + m[6] * ( (double) m[1] * m[5] - (double) m[2] * m[4]); + } + template + inline Matrix33 transpose(Matrix33 const & m) + { + const int size=3; + Matrix33 mres(0); + int i, j; + for (i=0; i + inline double det(Matrix44 const & m) + { + return m[0] * ( m[5] * (m[10] * m[15] - m[11] * m[14]) + - m[9] * (m[6] * m[15] - m[7] * m[14]) + + m[13] * (m[6] * m[11] - m[7] * m[10])) + - m[4] * ( m[1] * (m[10] * m[15] - m[11] * m[14]) + - m[9] * (m[2] * m[15] - m[3] * m[14]) + + m[13] * (m[2] * m[11] - m[3] * m[10])) + + m[8] * ( m[1] * (m[6] * m[15] - m[7] * m[14]) + - m[5] * (m[2] * m[15] - m[3] * m[14]) + + m[13] * (m[2] * m[7] - m[3] * m[6])) + + m[12] * ( m[1] * (m[6] * m[11] - m[7] * m[10]) + - m[5] * (m[2] * m[11] - m[3] * m[10]) + + m[9] * (m[2] * m[7] - m[3] * m[6])); + } + template + inline Matrix44 transpose(Matrix44 const & m) + { + const int size=4; + Matrix44 mres(0); + int i, j; + for (i=0; i std::string & arda::Math::Matrix22::getstring(std::string & s) const +template +std::string & arda::Math::Matrix22::to_string(std::string & s) const { s.clear(); std::stringstream ss; @@ -315,98 +902,32 @@ return s; } - - - - - - - - - - - -#ifdef NOTHING - ////////////////////////////////////////////////////////////////////////// - // det*(Matrix m) - // Computer the determinant of a matrix. - // Returns the determinant. - - inline double det3(Matrix3i m) - { return m[0] * ( m[4] * m[8] - - m[5] * m[7]) - - m[3] * ( m[1] * m[8] - - m[2] * m[7]) - + m[6] * ( m[1] * m[5] - - m[2] * m[4]); } - - inline double det4(Matrix4i m) - { return m[0] * (m[5] * (m[10] * m[15] - - m[11] * m[14]) - - m[9] * (m[6] * m[15] - - m[7] * m[14]) + - m[13] * (m[6] * m[11] - - m[7] * m[10])) - - m[4] * (m[1] * (m[10] * m[15] - - m[11] * m[14]) - - m[9] * (m[2] * m[15] - - m[3] * m[14]) + - m[13] * (m[2] * m[11] - - m[3] * m[10])) + - m[8] * (m[1] * (m[6] * m[15] - - m[7] * m[14]) - - m[5] * (m[2] * m[15] - - m[3] * m[14]) + - m[13] * (m[2] * m[7] - - m[3] * m[6])) + - m[12] * (m[1] * (m[6] * m[11] - - m[7] * m[10]) - - m[5] * (m[2] * m[11] - - m[3] * m[10]) + - m[9] * (m[2] * m[7] - - m[3] * m[6])); } - -//////////////////////////////////////////////////////////////////////////////// -int * arda::Matrix::multvec3mv(Matrix3i m, Vector3i v, Vector3i vres) +template +std::string & arda::Math::Matrix33::to_string(std::string & s) const { - vres[0] = m[0]*v[0] + m[3]*v[1] + m[6]*v[2]; - vres[1] = m[1]*v[0] + m[4]*v[1] + m[7]*v[2]; - vres[2] = m[2]*v[0] + m[5]*v[1] + m[8]*v[2]; - return vres; + s.clear(); + std::stringstream ss; + ss << "[ " + "[ " << m[0] << ", " << m[1] << ", " << m[2] << " ], " + "[ " << m[3] << ", " << m[4] << ", " << m[5] << " ], " + "[ " << m[6] << ", " << m[7] << ", " << m[8] << " ], ""]"; + s = ss.str(); + return s; } -//////////////////////////////////////////////////////////////////////////////// -int * arda::Matrix::multvec4mv(Matrix4i m, Vector4i v, Vector4i vres) +template +std::string & arda::Math::Matrix44::to_string(std::string & s) const { - vres[0] = m[0]*v[0] + m[4]*v[1] + m[8] *v[2] + m[12]*v[3]; - vres[1] = m[1]*v[0] + m[5]*v[1] + m[9]*v[2] + m[13]*v[3]; - vres[2] = m[2]*v[0] + m[6]*v[1] + m[10]*v[2] + m[14]*v[3]; - vres[3] = m[3]*v[0] + m[7]*v[1] + m[11]*v[2] + m[15]*v[3]; - return vres; + s.clear(); + std::stringstream ss; + ss << "[ " + "[ " << m[0] << ", " << m[1] << ", " << m[2] << ", " << m[3] << " ], " + "[ " << m[4] << ", " << m[5] << ", " << m[6] << ", " << m[7] << " ], " + "[ " << m[8] << ", " << m[9] << ", " << m[10] << ", " << m[11] << " ], " + "[ " << m[12] << ", " << m[13] << ", " << m[14] << ", " << m[15] << " ], ""]"; + s = ss.str(); + return s; } -//////////////////////////////////////////////////////////////////////////////// -int * arda::Matrix::multvec3vm(Vector3i v, Matrix3i m, Vector3i vres) - { - vres[0] = v[0]*m[0] + v[1]*m[1] + v[2]*m[2]; - vres[1] = v[0]*m[3] + v[1]*m[4] + v[2]*m[5]; - vres[2] = v[0]*m[6] + v[1]*m[7] + v[2]*m[8]; - return vres; - } - -//////////////////////////////////////////////////////////////////////////////// -float * arda::Matrix::multvec4vm(Vector4f v, Matrix4f m, Vector4f vres) - { - vres[0] = v[0]*m[0] + v[1]*m[1] + v[2]*m[2] + v[3]*m[3]; - vres[1] = v[0]*m[4] + v[1]*m[5] + v[2]*m[6] + v[3]*m[7]; - vres[2] = v[0]*m[8] + v[1]*m[9] + v[2]*m[10] + v[3]*m[11]; - vres[3] = v[0]*m[12] + v[1]*m[13] + v[2]*m[14] + v[3]*m[15]; - return vres; - } -#endif - - - - #endif // MATRIX_H_ diff -r 398894c52b69 -r 1d2b25d4517f include/Vector.h --- a/include/Vector.h Fri Oct 07 13:33:48 2011 -0500 +++ b/include/Vector.h Mon May 06 01:06:12 2013 -0500 @@ -51,14 +51,14 @@ // get_anglen(Vector& v2) // Like get_angle(), but the vectors must already be normalized. // Not meaningful for int vectors. - // getstring(std::string & s) + // to_string(std::string & s) // Returns a C string representation of the vector. // This is one of the few non-inline Vector functions. // length() // Get the length of a vector. // Returns a double for all vector types. // normalize() - // Normalizes the vecor. + // Normalizes the vector. // Not meaningful for int vectors. // proj(Vector& v2, Vector& vres) // Calculates the projection of the vector onto v2 and returns the result @@ -103,192 +103,207 @@ ///////////////////////////////////////////////////////////////////////////// - template class Vector2 + template + class Vector2 { public: T x, y; // Constructors Vector2() {} - explicit Vector2(const T a) : x (a), y(a) {} - Vector2(const T a, const T b) : x (a), y(b) {} + explicit Vector2(T a) : x (a), y(a) {} + Vector2(T a, T b) : x (a), y(b) {} // Array indexing - inline T& operator[](unsigned int i) + inline T& operator[](unsigned int const i) { assert (i<2); if (i==0) return x; return y; } - inline T operator[](unsigned int i) const + inline T operator[](unsigned int const i) const { assert (i<2); if (i==0) return x; return y; } // Assignment - inline Vector2& operator=(const Vector2& v2) + inline Vector2& operator=(Vector2 const & v2) { x = v2.x; y = v2.y; return *this; } - inline Vector2& assign(const T a, const T b) + inline Vector2& assign(T const a, T const b) { x = a; y = b; return *this; } // Comparison - inline bool operator==(Vector2& v2) const + inline bool operator==(Vector2 const & v2) const { return ((x == v2.x) && (y == v2.y)); } - inline bool operator!=(Vector2& v2) const + inline bool operator!=(Vector2 const & v2) const { return ! (*this == v2); } // Vector addition - inline Vector2& operator+=(const Vector2& v2) + inline Vector2& operator+=(Vector2 const & v2) { x += v2.x; y += v2.y; return *this; } - inline Vector2 operator+(const Vector2& v2) const + inline Vector2 operator+(Vector2 const & v2) const { return Vector2(*this) += v2; } // Vector subtraction - inline Vector2& operator-=(const Vector2& v2) + inline Vector2& operator-=(Vector2 const & v2) { x -= v2.x; y -= v2.y; return *this; } - inline Vector2 operator-(const Vector2& v2) const + inline Vector2 operator-(Vector2 const & v2) const { return Vector2(*this) -= v2; } // Scalar multiplication - inline Vector2& operator*=(const int a) + inline Vector2& operator*=(int const a) { x *= a; y *= a; return *this; } - inline Vector2& operator*=(const float a) + inline Vector2& operator*=(float const a) { x *= a; y *= a; return *this; } - inline Vector2& operator*=(const double a) + inline Vector2& operator*=(double const a) { x *= a; y *= a; return *this; } - inline Vector2