From e81cbbac0b8139945187054430e291ff04f16903 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Tue, 16 May 2017 21:17:16 +0200 Subject: [PATCH] [DEV] plop --- etk/math/Matrix2.cpp | 236 ------------------- etk/math/Matrix2x2.cpp | 236 +++++++++++++++++++ etk/math/{Matrix2.hpp => Matrix2x2.hpp} | 56 ++--- etk/math/Matrix2x3.cpp | 248 ++++++++++++++++++++ etk/math/Matrix2x3.hpp | 211 +++++++++++++++++ etk/math/{Matrix3.cpp => Matrix3x3.cpp} | 116 ++++----- etk/math/{Matrix3.hpp => Matrix3x3.hpp} | 50 ++-- etk/math/{Matrix4.cpp => Matrix4x4.cpp} | 90 +++---- etk/math/{Matrix4.hpp => Matrix4x4.hpp} | 50 ++-- etk/math/Quaternion.cpp | 22 +- etk/math/Quaternion.hpp | 6 +- etk/math/{Transform.cpp => Transform3D.cpp} | 0 etk/math/{Transform.hpp => Transform3D.hpp} | 36 +-- lutin_etk.py | 18 +- test/testMatrix2x2.cpp | 66 +++--- test/testMatrix3x3.cpp | 68 +++--- test/testQuaternion.cpp | 10 +- test/testVector3_f.cpp | 32 +-- 18 files changed, 1006 insertions(+), 545 deletions(-) delete mode 100644 etk/math/Matrix2.cpp create mode 100644 etk/math/Matrix2x2.cpp rename etk/math/{Matrix2.hpp => Matrix2x2.hpp} (82%) create mode 100644 etk/math/Matrix2x3.cpp create mode 100644 etk/math/Matrix2x3.hpp rename etk/math/{Matrix3.cpp => Matrix3x3.cpp} (61%) rename etk/math/{Matrix3.hpp => Matrix3x3.hpp} (83%) rename etk/math/{Matrix4.cpp => Matrix4x4.cpp} (77%) rename etk/math/{Matrix4.hpp => Matrix4x4.hpp} (86%) rename etk/math/{Transform.cpp => Transform3D.cpp} (100%) rename etk/math/{Transform.hpp => Transform3D.hpp} (80%) diff --git a/etk/math/Matrix2.cpp b/etk/math/Matrix2.cpp deleted file mode 100644 index 282cffd..0000000 --- a/etk/math/Matrix2.cpp +++ /dev/null @@ -1,236 +0,0 @@ -/** @file - * @author Edouard DUPIN - * @copyright 2011, Edouard DUPIN, all right reserved - * @license MPL v2.0 (see license file) - */ - -#include - -std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix2& _obj) { - _os << "{"; - _os << _obj.m_mat[0] << ","; - _os << _obj.m_mat[1] << ";"; - _os << _obj.m_mat[2] << ","; - _os << _obj.m_mat[3] << "}"; - return _os; -} - -etk::Matrix2::Matrix2() { - m_mat[0] = 0.0f; - m_mat[1] = 0.0f; - m_mat[2] = 0.0f; - m_mat[3] = 0.0f; -} - -etk::Matrix2::Matrix2(float _value) { - m_mat[0] = _value; - m_mat[1] = _value; - m_mat[2] = _value; - m_mat[3] = _value; -} - -etk::Matrix2::Matrix2(float _a1, float _a2,float _b1, float _b2) { - m_mat[0] = _a1; - m_mat[1] = _a2; - m_mat[2] = _b1; - m_mat[3] = _b2; -} - -etk::Matrix2::Matrix2(const Matrix2& _obj) { - m_mat[0] = _obj.m_mat[0]; - m_mat[1] = _obj.m_mat[1]; - m_mat[2] = _obj.m_mat[2]; - m_mat[3] = _obj.m_mat[3]; -} - -void etk::Matrix2::setValue(float _a1, float _a2,float _b1, float _b2) { - m_mat[0] = _a1; - m_mat[1] = _a2; - m_mat[2] = _b1; - m_mat[3] = _b2; -} - -void etk::Matrix2::setZero() { - m_mat[0] = 0; - m_mat[1] = 0; - m_mat[2] = 0; - m_mat[3] = 0; -} - -vec2 etk::Matrix2::getColumn(uint32_t _iii) const { - if (_iii == 0) { - return vec2(m_mat[0], m_mat[2]); - } - return vec2(m_mat[1], m_mat[3]); -} - -vec2 etk::Matrix2::getRow(uint32_t _iii) const { - if (_iii == 0) { - return vec2(m_mat[0], m_mat[1]); - } - return vec2(m_mat[2], m_mat[3]); -} - -const etk::Matrix2& etk::Matrix2::operator= (const etk::Matrix2& _obj ) { - for(int32_t iii=0; iii<2*2 ; ++iii) { - m_mat[iii] = _obj.m_mat[iii]; - } - return *this; -} - -bool etk::Matrix2::operator== (const etk::Matrix2& _obj) const { - for(int32_t iii=0; iii<2*2 ; ++iii) { - if(m_mat[iii] != _obj.m_mat[iii]) { - return false; - } - } - return true; -} - -bool etk::Matrix2::operator!= (const etk::Matrix2& _obj) const { - for(int32_t iii=0; iii<2*2 ; ++iii) { - if(m_mat[iii] != _obj.m_mat[iii]) { - return true; - } - } - return false; -} - -const etk::Matrix2& etk::Matrix2::operator+= (const etk::Matrix2& _obj) { - for(int32_t iii=0; iii<2*2 ; ++iii) { - m_mat[iii] += _obj.m_mat[iii]; - } - return *this; -} - -etk::Matrix2 etk::Matrix2::operator+ (const etk::Matrix2& _obj) const { - etk::Matrix2 tmpp(*this); - tmpp += _obj; - return tmpp; -} - -const etk::Matrix2& etk::Matrix2::operator-= (const etk::Matrix2& _obj) { - for(int32_t iii=0; iii<2*2 ; ++iii) { - m_mat[iii] -= _obj.m_mat[iii]; - } - return *this; -} - -etk::Matrix2 etk::Matrix2::operator- (const etk::Matrix2& _obj) const { - etk::Matrix2 tmpp(*this); - tmpp -= _obj; - return tmpp; -} - - -const etk::Matrix2& etk::Matrix2::operator *= (const etk::Matrix2& _obj) { - float t0 = m_mat[0] * _obj.m_mat[0] + m_mat[1] * _obj.m_mat[2]; - float t2 = m_mat[2] * _obj.m_mat[0] + m_mat[3] * _obj.m_mat[2]; - m_mat[1] = m_mat[0] * _obj.m_mat[1] + m_mat[1] * _obj.m_mat[3]; - m_mat[3] = m_mat[2] * _obj.m_mat[1] + m_mat[3] * _obj.m_mat[3]; - m_mat[0] = t0; - m_mat[2] = t2; - return *this; -} - -etk::Matrix2 etk::Matrix2::operator * (const etk::Matrix2& _obj) const { - etk::Matrix2 tmp(*this); - tmp *= _obj; - return tmp; -} - -vec2 etk::Matrix2::operator * (const vec2& _point) const { - return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1], - _point.x()*m_mat[2] + _point.y()*m_mat[3]); -} - -const etk::Matrix2& etk::Matrix2::operator *= (float _value) { - m_mat[0] *= _value; - m_mat[1] *= _value; - m_mat[2] *= _value; - m_mat[3] *= _value; - return *this; -} - -etk::Matrix2 etk::Matrix2::operator * (float _value) const { - etk::Matrix2 tmp(*this); - tmp *= _value; - return tmp; -} - -etk::Matrix2 etk::Matrix2::getTranspose() const { - return Matrix2(m_mat[0], m_mat[2], - m_mat[1], m_mat[3]); -} -void etk::Matrix2::transpose() { - float tmp = m_mat[2]; - m_mat[2] = m_mat[1]; - m_mat[1] = tmp; -} - -float etk::Matrix2::determinant() const { - return m_mat[0] * m_mat[3] - m_mat[2] * m_mat[1]; -} - -float etk::Matrix2::getTrace() const { - return m_mat[0] + m_mat[3]; -} - -void etk::Matrix2::setIdentity() { - m_mat[0] = 1.0f; - m_mat[1] = 0.0f; - m_mat[2] = 0.0f; - m_mat[3] = 1.0f; -} - -etk::Matrix2 etk::Matrix2::identity() { - return etk::Matrix2(1.0f, 0.0f, 0.0f, 1.0f); -} - -etk::Matrix2 etk::Matrix2::zero() { - return etk::Matrix2(0.0f, 0.0f, 0.0f, 0.0f); -} - -etk::Matrix2 etk::Matrix2::getAbsolute() const { - return Matrix2(std::abs(m_mat[0]), std::abs(m_mat[1]), - std::abs(m_mat[2]), std::abs(m_mat[3])); -} -void etk::Matrix2::absolute() { - m_mat[0] = std::abs(m_mat[0]); - m_mat[1] = std::abs(m_mat[1]); - m_mat[2] = std::abs(m_mat[2]); - m_mat[3] = std::abs(m_mat[3]); -} - -void etk::Matrix2::inverse() { - *this = getInverse(); -} - -etk::Matrix2 etk::Matrix2::getInverse() const { - float det = determinant(); - //assert(std::abs(det) > MACHINE_EPSILON); - float invDet = 1.0f / det; - return etk::Matrix2(m_mat[3], -m_mat[1], -m_mat[2], m_mat[0]) * invDet; -} - - - -etk::Matrix2 etk::mat2Rotate(float _angleRad) { - return Matrix2(cos(_angleRad), sin(_angleRad), -sin(_angleRad), cos(_angleRad)); -} - -etk::Matrix2 etk::mat2Scale(const vec2& _scale) { - return Matrix2(_scale.x(), 0.0, 0.0, _scale.y()); -} - -etk::Matrix2 etk::mat2Scale(float _scale) { - return Matrix2(_scale, 0.0, 0.0, _scale); -} - -etk::Matrix2 etk::mat2Skew(const vec2& _skew) { - return Matrix2(1.0, tan(_skew.y()), tan(_skew.x()), 1.0); -} - -etk::Matrix2 operator-(const etk::Matrix2& _matrix) { - return etk::Matrix2(-_matrix.m_mat[0], -_matrix.m_mat[1], -_matrix.m_mat[2], -_matrix.m_mat[3]); -} \ No newline at end of file diff --git a/etk/math/Matrix2x2.cpp b/etk/math/Matrix2x2.cpp new file mode 100644 index 0000000..9cf6644 --- /dev/null +++ b/etk/math/Matrix2x2.cpp @@ -0,0 +1,236 @@ +/** @file + * @author Edouard DUPIN + * @copyright 2011, Edouard DUPIN, all right reserved + * @license MPL v2.0 (see license file) + */ + +#include + +std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix2x2& _obj) { + _os << "{"; + _os << _obj.m_mat[0] << ","; + _os << _obj.m_mat[1] << ";"; + _os << _obj.m_mat[2] << ","; + _os << _obj.m_mat[3] << "}"; + return _os; +} + +etk::Matrix2x2::Matrix2x2() { + m_mat[0] = 0.0f; + m_mat[1] = 0.0f; + m_mat[2] = 0.0f; + m_mat[3] = 0.0f; +} + +etk::Matrix2x2::Matrix2x2(float _value) { + m_mat[0] = _value; + m_mat[1] = _value; + m_mat[2] = _value; + m_mat[3] = _value; +} + +etk::Matrix2x2::Matrix2x2(float _a1, float _a2,float _b1, float _b2) { + m_mat[0] = _a1; + m_mat[1] = _a2; + m_mat[2] = _b1; + m_mat[3] = _b2; +} + +etk::Matrix2x2::Matrix2x2(const Matrix2x2& _obj) { + m_mat[0] = _obj.m_mat[0]; + m_mat[1] = _obj.m_mat[1]; + m_mat[2] = _obj.m_mat[2]; + m_mat[3] = _obj.m_mat[3]; +} + +void etk::Matrix2x2::setValue(float _a1, float _a2,float _b1, float _b2) { + m_mat[0] = _a1; + m_mat[1] = _a2; + m_mat[2] = _b1; + m_mat[3] = _b2; +} + +void etk::Matrix2x2::setZero() { + m_mat[0] = 0; + m_mat[1] = 0; + m_mat[2] = 0; + m_mat[3] = 0; +} + +vec2 etk::Matrix2x2::getColumn(uint32_t _iii) const { + if (_iii == 0) { + return vec2(m_mat[0], m_mat[2]); + } + return vec2(m_mat[1], m_mat[3]); +} + +vec2 etk::Matrix2x2::getRow(uint32_t _iii) const { + if (_iii == 0) { + return vec2(m_mat[0], m_mat[1]); + } + return vec2(m_mat[2], m_mat[3]); +} + +const etk::Matrix2x2& etk::Matrix2x2::operator= (const etk::Matrix2x2& _obj ) { + for(int32_t iii=0; iii<2*2 ; ++iii) { + m_mat[iii] = _obj.m_mat[iii]; + } + return *this; +} + +bool etk::Matrix2x2::operator== (const etk::Matrix2x2& _obj) const { + for(int32_t iii=0; iii<2*2 ; ++iii) { + if(m_mat[iii] != _obj.m_mat[iii]) { + return false; + } + } + return true; +} + +bool etk::Matrix2x2::operator!= (const etk::Matrix2x2& _obj) const { + for(int32_t iii=0; iii<2*2 ; ++iii) { + if(m_mat[iii] != _obj.m_mat[iii]) { + return true; + } + } + return false; +} + +const etk::Matrix2x2& etk::Matrix2x2::operator+= (const etk::Matrix2x2& _obj) { + for(int32_t iii=0; iii<2*2 ; ++iii) { + m_mat[iii] += _obj.m_mat[iii]; + } + return *this; +} + +etk::Matrix2x2 etk::Matrix2x2::operator+ (const etk::Matrix2x2& _obj) const { + etk::Matrix2x2 tmpp(*this); + tmpp += _obj; + return tmpp; +} + +const etk::Matrix2x2& etk::Matrix2x2::operator-= (const etk::Matrix2x2& _obj) { + for(int32_t iii=0; iii<2*2 ; ++iii) { + m_mat[iii] -= _obj.m_mat[iii]; + } + return *this; +} + +etk::Matrix2x2 etk::Matrix2x2::operator- (const etk::Matrix2x2& _obj) const { + etk::Matrix2x2 tmpp(*this); + tmpp -= _obj; + return tmpp; +} + + +const etk::Matrix2x2& etk::Matrix2x2::operator *= (const etk::Matrix2x2& _obj) { + float t0 = m_mat[0] * _obj.m_mat[0] + m_mat[1] * _obj.m_mat[2]; + float t2 = m_mat[2] * _obj.m_mat[0] + m_mat[3] * _obj.m_mat[2]; + m_mat[1] = m_mat[0] * _obj.m_mat[1] + m_mat[1] * _obj.m_mat[3]; + m_mat[3] = m_mat[2] * _obj.m_mat[1] + m_mat[3] * _obj.m_mat[3]; + m_mat[0] = t0; + m_mat[2] = t2; + return *this; +} + +etk::Matrix2x2 etk::Matrix2x2::operator * (const etk::Matrix2x2& _obj) const { + etk::Matrix2x2 tmp(*this); + tmp *= _obj; + return tmp; +} + +vec2 etk::Matrix2x2::operator * (const vec2& _point) const { + return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1], + _point.x()*m_mat[2] + _point.y()*m_mat[3]); +} + +const etk::Matrix2x2& etk::Matrix2x2::operator *= (float _value) { + m_mat[0] *= _value; + m_mat[1] *= _value; + m_mat[2] *= _value; + m_mat[3] *= _value; + return *this; +} + +etk::Matrix2x2 etk::Matrix2x2::operator * (float _value) const { + etk::Matrix2x2 tmp(*this); + tmp *= _value; + return tmp; +} + +etk::Matrix2x2 etk::Matrix2x2::getTranspose() const { + return Matrix2x2(m_mat[0], m_mat[2], + m_mat[1], m_mat[3]); +} +void etk::Matrix2x2::transpose() { + float tmp = m_mat[2]; + m_mat[2] = m_mat[1]; + m_mat[1] = tmp; +} + +float etk::Matrix2x2::determinant() const { + return m_mat[0] * m_mat[3] - m_mat[2] * m_mat[1]; +} + +float etk::Matrix2x2::getTrace() const { + return m_mat[0] + m_mat[3]; +} + +void etk::Matrix2x2::setIdentity() { + m_mat[0] = 1.0f; + m_mat[1] = 0.0f; + m_mat[2] = 0.0f; + m_mat[3] = 1.0f; +} + +etk::Matrix2x2 etk::Matrix2x2::identity() { + return etk::Matrix2x2(1.0f, 0.0f, 0.0f, 1.0f); +} + +etk::Matrix2x2 etk::Matrix2x2::zero() { + return etk::Matrix2x2(0.0f, 0.0f, 0.0f, 0.0f); +} + +etk::Matrix2x2 etk::Matrix2x2::getAbsolute() const { + return Matrix2x2(std::abs(m_mat[0]), std::abs(m_mat[1]), + std::abs(m_mat[2]), std::abs(m_mat[3])); +} +void etk::Matrix2x2::absolute() { + m_mat[0] = std::abs(m_mat[0]); + m_mat[1] = std::abs(m_mat[1]); + m_mat[2] = std::abs(m_mat[2]); + m_mat[3] = std::abs(m_mat[3]); +} + +void etk::Matrix2x2::inverse() { + *this = getInverse(); +} + +etk::Matrix2x2 etk::Matrix2x2::getInverse() const { + float det = determinant(); + //assert(std::abs(det) > MACHINE_EPSILON); + float invDet = 1.0f / det; + return etk::Matrix2x2(m_mat[3], -m_mat[1], -m_mat[2], m_mat[0]) * invDet; +} + + + +etk::Matrix2x2 etk::mat2x2Rotate(float _angleRad) { + return Matrix2x2(cos(_angleRad), sin(_angleRad), -sin(_angleRad), cos(_angleRad)); +} + +etk::Matrix2x2 etk::mat2x2Scale(const vec2& _scale) { + return Matrix2x2(_scale.x(), 0.0, 0.0, _scale.y()); +} + +etk::Matrix2x2 etk::mat2x2Scale(float _scale) { + return Matrix2x2(_scale, 0.0, 0.0, _scale); +} + +etk::Matrix2x2 etk::mat2x2Skew(const vec2& _skew) { + return Matrix2x2(1.0, tan(_skew.y()), tan(_skew.x()), 1.0); +} + +etk::Matrix2x2 operator-(const etk::Matrix2x2& _matrix) { + return etk::Matrix2x2(-_matrix.m_mat[0], -_matrix.m_mat[1], -_matrix.m_mat[2], -_matrix.m_mat[3]); +} \ No newline at end of file diff --git a/etk/math/Matrix2.hpp b/etk/math/Matrix2x2.hpp similarity index 82% rename from etk/math/Matrix2.hpp rename to etk/math/Matrix2x2.hpp index 6160a49..254b538 100644 --- a/etk/math/Matrix2.hpp +++ b/etk/math/Matrix2x2.hpp @@ -12,7 +12,7 @@ namespace etk { /** * This class represents a 2x2 matrix. */ - class Matrix2 { + class Matrix2x2 { public: /** * @brief Internal data @@ -24,12 +24,12 @@ namespace etk { /** * @brief Constructor that load zero matrix */ - Matrix2(); + Matrix2x2(); /** * @brief Configuration constructorwith single value. * @param[in] _value single vamue */ - Matrix2(float _value); + Matrix2x2(float _value); /** * @brief Configuration constructor. * @param[in] _a1 element 0x0 @@ -37,12 +37,12 @@ namespace etk { * @param[in] _b1 element 1x0 * @param[in] _b2 element 1x1 */ - Matrix2(float _a1, float _a2, float _b1, float _b2); + Matrix2x2(float _a1, float _a2, float _b1, float _b2); /** * @brief Copy constructor. * @param[in] _obj Matrix object to copy */ - Matrix2(const Matrix2& _matrix); + Matrix2x2(const Matrix2x2& _matrix); /** * @brief Set Value on the matrix * @param[in] _a1 element 0x0 @@ -71,7 +71,7 @@ namespace etk { * @brief get a transpose matrix of this one. * @return the transpose matrix */ - Matrix2 getTranspose() const; + Matrix2x2 getTranspose() const; /** * @brief Transpose the current matrix. */ @@ -91,7 +91,7 @@ namespace etk { * @note The determinant must be != 0, otherwithe the matrix can't be inverted. * @return The inverted matrix. */ - Matrix2 getInverse() const; + Matrix2x2 getInverse() const; /** * @brief Inverts the current matrix. * @note The determinant must be != 0, otherwithe the matrix can't be inverted. @@ -101,7 +101,7 @@ namespace etk { * @brief get the mathix with the absolute value * @return matix in absolute */ - Matrix2 getAbsolute() const; + Matrix2x2 getAbsolute() const; /** * @brief absolutise the matrix */ @@ -114,80 +114,80 @@ namespace etk { * @brief create a Identity matrix * @return created new matrix */ - static etk::Matrix2 identity(); + static etk::Matrix2x2 identity(); /** * @brief create a ZERO matrix * @return created new matrix */ - static Matrix2 zero(); + static Matrix2x2 zero(); /** * @brief Operator= Asign the current object with an other object * @param[in] _obj Reference on the external object * @return Local reference of the vector asigned */ - const Matrix2& operator= (const Matrix2& _obj ); + const Matrix2x2& operator= (const Matrix2x2& _obj ); /** * @brief Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are identical * @return false The Objects are NOT identical */ - bool operator== (const Matrix2& _obj) const; + bool operator== (const Matrix2x2& _obj) const; /** * @brief In-Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are NOT identical * @return false The Objects are identical */ - bool operator!= (const Matrix2& _obj) const; + bool operator!= (const Matrix2x2& _obj) const; /** * @brief Operator+= Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector additionned */ - const Matrix2& operator+= (const Matrix2& _obj); + const Matrix2x2& operator+= (const Matrix2x2& _obj); /** * @brief Operator+ Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix2 operator+ (const Matrix2& _obj) const; + Matrix2x2 operator+ (const Matrix2x2& _obj) const; /** * @brief Operator-= Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector decremented */ - const Matrix2& operator-= (const Matrix2& _obj); + const Matrix2x2& operator-= (const Matrix2x2& _obj); /** * @brief Operator- Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix2 operator- (const Matrix2& _obj) const; + Matrix2x2 operator- (const Matrix2x2& _obj) const; /** * @brief Operator*= Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector multiplicated */ - const Matrix2& operator *= (const Matrix2& _obj); + const Matrix2x2& operator *= (const Matrix2x2& _obj); /** * @brief Operator* Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix2 operator * (const Matrix2& _obj) const; + Matrix2x2 operator * (const Matrix2x2& _obj) const; /** * @brief Operator*= Multiplication a value * @param[in] _value value to multiply all the matrix * @return Local reference of the vector multiplicated */ - const Matrix2& operator *= (float _value); + const Matrix2x2& operator *= (float _value); /** * @brief Operator*= Multiplication a value * @param[in] _value value to multiply all the matrix * @return Local reference of the vector multiplicated */ - Matrix2 operator * (float _value) const; + Matrix2x2 operator * (float _value) const; /** * @brief Operator* apply matrix on a vector * @param[in] _point Point value to apply the matrix @@ -201,32 +201,32 @@ namespace etk { * @param[in] _angleRad Radian angle to set at the matrix * @return New matrix of the transformation requested */ - Matrix2 mat2Rotate(float _angleRad); + Matrix2x2 mat2x2Rotate(float _angleRad); /** * @brief Create a matrix 2D with a simple scale * @param[in] _scale 2 dimention scale * @return New matrix of the transformation requested */ - Matrix2 mat2Scale(const vec2& _scale); + Matrix2x2 mat2x2Scale(const vec2& _scale); /** * @brief Create a matrix 2D with a simple scale * @param[in] _scale same scale in 2 and Y * @return New matrix of the transformation requested */ - Matrix2 mat2Scale(float _scale); + Matrix2x2 mat2x2Scale(float _scale); /** * @brief Create a matrix 2D with a simple skew * @param[in] _skew 2 dimention skew * @return New matrix of the transformation requested */ - Matrix2 mat2Skew(const vec2& _skew); + Matrix2x2 mat2x2Skew(const vec2& _skew); //! @not_in_doc - std::ostream& operator <<(std::ostream& _os, const etk::Matrix2& _obj); + std::ostream& operator <<(std::ostream& _os, const etk::Matrix2x2& _obj); } -etk::Matrix2 operator-(const etk::Matrix2& _matrix); +etk::Matrix2x2 operator-(const etk::Matrix2x2& _matrix); // simplify using of matrix ... -using mat2 = etk::Matrix2; //!< Use simplification in upper application to use matrix like openGL shader +using mat2 = etk::Matrix2x2; //!< Use simplification in upper application to use matrix like openGL shader diff --git a/etk/math/Matrix2x3.cpp b/etk/math/Matrix2x3.cpp new file mode 100644 index 0000000..96791f9 --- /dev/null +++ b/etk/math/Matrix2x3.cpp @@ -0,0 +1,248 @@ +/** @file + * @author Edouard DUPIN + * @copyright 2011, Edouard DUPIN, all right reserved + * @license MPL v2.0 (see license file) + */ + +#include + +std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix2x3& _obj) { + _os << "{"; + _os << _obj.m_mat[0] << ","; + _os << _obj.m_mat[4] << ","; + _os << _obj.m_mat[1] << ","; + _os << _obj.m_mat[3] << ","; + _os << _obj.m_mat[2] << ","; + _os << _obj.m_mat[5] << "}"; + return _os; +} + +void etk::Matrix2x3::identity() { + m_mat[0] = 1.0; + m_mat[1] = 0.0; + m_mat[2] = 0.0; + m_mat[3] = 1.0; + m_mat[4] = 0.0; + m_mat[5] = 0.0; +} + +etk::Matrix2x3::Matrix2x3() { + // TODO: Remove this ... + identity(); +} +etk::Matrix2x3::Matrix2x3(const etk::Matrix2x3& _obj) { + for(int32_t iii=0; iii<2*3 ; iii++) { + m_mat[iii] = _obj.m_mat[iii]; + } +} + +etk::Matrix2x3::Matrix2x3(float _sx, + float _shy, + float _shx, + float _sy, + float _tx, + float _ty) { + m_mat[0] = _sx; + m_mat[4] = _shy; + m_mat[1] = _shx; + m_mat[3] = _sy; + m_mat[2] = _tx; + m_mat[5] = _ty; +} + +etk::Matrix2x3::Matrix2x3(const float* _values) { + if (_values == nullptr) { + identity(); + return; + } + m_mat[0] = _values[0]; + m_mat[4] = _values[1]; + m_mat[1] = _values[2]; + m_mat[3] = _values[3]; + m_mat[2] = _values[4]; + m_mat[5] = _values[5]; +} + +etk::Matrix2x3::Matrix2x3(const double* _values) { + if (_values == nullptr) { + identity(); + return; + } + m_mat[0] = _values[0]; + m_mat[4] = _values[1]; + m_mat[1] = _values[2]; + m_mat[3] = _values[3]; + m_mat[2] = _values[4]; + m_mat[5] = _values[5]; +} + +const etk::Matrix2x3& etk::Matrix2x3::operator= (const etk::Matrix2x3& _obj ) { + for(int32_t iii=0; iii<2*3 ; ++iii) { + m_mat[iii] = _obj.m_mat[iii]; + } + return *this; +} + +bool etk::Matrix2x3::operator== (const etk::Matrix2x3& _obj) const { + for(int32_t iii=0; iii<2*3 ; ++iii) { + if(m_mat[iii] != _obj.m_mat[iii]) { + return false; + } + } + return true; +} + +bool etk::Matrix2x3::operator!= (const etk::Matrix2x3& _obj) const { + for(int32_t iii=0; iii<2*3 ; ++iii) { + if(m_mat[iii] != _obj.m_mat[iii]) { + return true; + } + } + return false; +} + +const etk::Matrix2x3& etk::Matrix2x3::operator+= (const etk::Matrix2x3& _obj) { + for(int32_t iii=0; iii<2*3 ; ++iii) { + m_mat[iii] += _obj.m_mat[iii]; + } + return *this; +} + +etk::Matrix2x3 etk::Matrix2x3::operator+ (const etk::Matrix2x3& _obj) const { + etk::Matrix2x3 tmpp(*this); + tmpp += _obj; + return tmpp; +} + +const etk::Matrix2x3& etk::Matrix2x3::operator-= (const etk::Matrix2x3& _obj) { + for(int32_t iii=0; iii<2*3 ; ++iii) { + m_mat[iii] -= _obj.m_mat[iii]; + } + return *this; +} + +etk::Matrix2x3 etk::Matrix2x3::operator- (const etk::Matrix2x3& _obj) const { + etk::Matrix2x3 tmpp(*this); + tmpp += _obj; + return tmpp; +} + +const etk::Matrix2x3& etk::Matrix2x3::operator *= (const etk::Matrix2x3& _obj) { + float t0 = m_mat[0] * _obj.m_mat[0] + m_mat[4] * _obj.m_mat[1]; + float t2 = m_mat[1] * _obj.m_mat[0] + m_mat[3] * _obj.m_mat[1]; + float t4 = m_mat[2] * _obj.m_mat[0] + m_mat[5] * _obj.m_mat[1] + _obj.m_mat[2]; + m_mat[4] = m_mat[0] * _obj.m_mat[4] + m_mat[4] * _obj.m_mat[3]; + m_mat[3] = m_mat[1] * _obj.m_mat[4] + m_mat[3] * _obj.m_mat[3]; + m_mat[5] = m_mat[2] * _obj.m_mat[4] + m_mat[5] * _obj.m_mat[3] + _obj.m_mat[5]; + m_mat[0] = t0; + m_mat[1] = t2; + m_mat[2] = t4; + return *this; +} + +etk::Matrix2x3 etk::Matrix2x3::operator * (const etk::Matrix2x3& _obj) { + etk::Matrix2x3 tmp(*this); + tmp *= _obj; + return tmp; +} + +vec2 etk::Matrix2x3::operator * (const vec2& _point) const { + return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1] + m_mat[2], + _point.x()*m_mat[4] + _point.y()*m_mat[3] + m_mat[5]); +} + +vec2 etk::Matrix2x3::applyScaleRotation(const vec2& _point) const { + return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1], + _point.x()*m_mat[4] + _point.y()*m_mat[3]); +} + +etk::Matrix2x3 etk::Matrix2x3::operator ~ () const { + etk::Matrix2x3 tmp(*this); + tmp.invert(); + return tmp; +} + +void etk::Matrix2x3::flipX() { + m_mat[0] = -m_mat[0]; + m_mat[4] = -m_mat[4]; + m_mat[2] = -m_mat[2]; +} + +void etk::Matrix2x3::flipY() { + m_mat[1] = -m_mat[1]; + m_mat[3] = -m_mat[3]; + m_mat[5] = -m_mat[5]; +} + +void etk::Matrix2x3::scale(const vec2& _vect) { + m_mat[0] *= _vect.x(); + m_mat[1] *= _vect.x(); + m_mat[2] *= _vect.x(); + m_mat[4] *= _vect.y(); + m_mat[3] *= _vect.y(); + m_mat[5] *= _vect.y(); +} + +void etk::Matrix2x3::scale(float _value) { + m_mat[0] *= _value; + m_mat[1] *= _value; + m_mat[2] *= _value; + m_mat[4] *= _value; + m_mat[3] *= _value; + m_mat[5] *= _value; +} + +void etk::Matrix2x3::rotate(float _angleRad) { + float ca = cos(_angleRad); + float sa = sin(_angleRad); + float t0 = m_mat[0] * ca - m_mat[4] * sa; + float t2 = m_mat[1] * ca - m_mat[3] * sa; + float t4 = m_mat[2] * ca - m_mat[5] * sa; + m_mat[4] = m_mat[0] * sa + m_mat[4] * ca; + m_mat[3] = m_mat[1] * sa + m_mat[3] * ca; + m_mat[5] = m_mat[2] * sa + m_mat[5] * ca; + m_mat[0] = t0; + m_mat[1] = t2; + m_mat[2] = t4; +} + +void etk::Matrix2x3::translate(const vec2& _vect) { + m_mat[2] += _vect.x(); + m_mat[5] += _vect.y(); +} + +float etk::Matrix2x3::determinant() const { + return m_mat[0] * m_mat[3] - m_mat[4] * m_mat[1]; +} + +void etk::Matrix2x3::invert() { + float det = 1.0f / determinant(); + float t0 = m_mat[3] * det; + m_mat[3] = m_mat[0] * det; + m_mat[4] = -m_mat[4] * det; + m_mat[1] = -m_mat[1] * det; + float t4 = -m_mat[2] * t0 - m_mat[5] * m_mat[1]; + m_mat[5] = -m_mat[2] * m_mat[4] - m_mat[5] * m_mat[3]; + m_mat[0] = t0; + m_mat[2] = t4; +} + +etk::Matrix2x3 etk::mat2x3Rotate(float _angleRad) { + return etk::Matrix2x3(cos(_angleRad), sin(_angleRad), -sin(_angleRad), cos(_angleRad), 0.0, 0.0); +}; + +etk::Matrix2x3 etk::mat2x3Scale(const vec2& _scale) { + return etk::Matrix2x3(_scale.x(), 0.0, 0.0, _scale.y(), 0.0, 0.0); +}; + +etk::Matrix2x3 etk::mat2x3Scale(float _scale) { + return etk::Matrix2x3(_scale, 0.0, 0.0, _scale, 0.0, 0.0); +}; + +etk::Matrix2x3 etk::mat2x3Translate(const vec2& _translate) { + return etk::Matrix2x3(1.0, 0.0, 0.0, 1.0, _translate.x(), _translate.y()); +}; + +etk::Matrix2x3 etk::mat2x3Skew(const vec2& _skew) { + return etk::Matrix2x3(1.0, tan(_skew.y()), tan(_skew.x()), 1.0, 0.0, 0.0); +}; diff --git a/etk/math/Matrix2x3.hpp b/etk/math/Matrix2x3.hpp new file mode 100644 index 0000000..b8babba --- /dev/null +++ b/etk/math/Matrix2x3.hpp @@ -0,0 +1,211 @@ +/** @file + * @author Edouard DUPIN + * @copyright 2011, Edouard DUPIN, all right reserved + * @license MPL v2.0 (see license file) + */ + +#pragma once + +#include +#include +namespace etk { + /** + * @brief Transformation matrix for vector 2D. + */ + class Matrix2x3 { + public: + /** + * @brief Internal data + * sx shx tx + * sy shy ty + */ + float m_mat[2*3]; + public: + /** + * @brief Constructor that load identity + */ + Matrix2x3(); + /** + * @brief Copy constructor. + * @param[in] _obj Matrix object to copy + */ + Matrix2x3(const Matrix2x3& _obj); + /** + * @brief Configuration constructor. + * @param[in] _sx Scale threw X axis + * @param[in] _shy Rotate in radian threw Y axis + * @param[in] _shx Rotate in radian threw X axis + * @param[in] _sy Scale threw Y axis + * @param[in] _tx Translate threw X axis + * @param[in] _ty translate threw Y axis + */ + Matrix2x3(float _sx, + float _shy, + float _shx, + float _sy, + float _tx, + float _ty); + /** + * @brief Configuration constructor. + * @param[in] _values vector of values in float + */ + Matrix2x3(const float* _values); + /** + * @brief Configuration constructor. + * @param[in] _values vector of values in double + */ + Matrix2x3(const double* _values); + /** + * @brief Load Identity matrix + */ + void identity(); + /** + * @brief Operator= Asign the current object with an other object + * @param[in] _obj Reference on the external object + * @return Local reference of the vector asigned + */ + const Matrix2x3& operator= (const Matrix2x3& _obj ); + /** + * @brief Equality compare operator with an other object. + * @param[in] _obj Reference on the comparing object + * @return true The Objects are identical + * @return false The Objects are NOT identical + */ + bool operator== (const Matrix2x3& _obj) const; + /** + * @brief In-Equality compare operator with an other object. + * @param[in] _obj Reference on the comparing object + * @return true The Objects are NOT identical + * @return false The Objects are identical + */ + bool operator!= (const Matrix2x3& _obj) const; + /** + * @brief Operator+= Addition an other matrix with this one + * @param[in] _obj Reference on the external object + * @return Local reference of the vector additionned + */ + const Matrix2x3& operator+= (const Matrix2x3& _obj); + /** + * @brief Operator+ Addition an other matrix with this one + * @param[in] _obj Reference on the external object + * @return New vector containing the value + */ + Matrix2x3 operator+ (const Matrix2x3& _obj) const; + /** + * @brief Operator-= Decrement an other matrix with this one + * @param[in] _obj Reference on the external object + * @return Local reference of the vector decremented + */ + const Matrix2x3& operator-= (const Matrix2x3& _obj); + /** + * @brief Operator- Decrement an other matrix with this one + * @param[in] _obj Reference on the external object + * @return New vector containing the value + */ + Matrix2x3 operator- (const Matrix2x3& _obj) const; + /** + * @brief Operator*= Multiplication an other matrix with this one + * @param[in] _obj Reference on the external object + * @return Local reference of the vector multiplicated + */ + const Matrix2x3& operator *= (const Matrix2x3& _obj); + /** + * @brief Operator* Multiplication an other matrix with this one + * @param[in] _obj Reference on the external object + * @return New vector containing the value + */ + Matrix2x3 operator * (const Matrix2x3& _obj); + /** + * @brief Operator* apply matrix on a vector + * @param[in] _point Point value to apply the matrix + * @return New vector containing the value + */ + vec2 operator * (const vec2& _point) const; + /** + * @brief Apply matrix on a vector Scale Rotate, but NOT the translation + * @param[in] _point Point value to apply the matrix + * @return New vector containing the value + */ + vec2 applyScaleRotation(const vec2& _point) const; + /** + * @brief Inverse the current Matrix + * @return New vector containing the value + */ + Matrix2x3 operator ~ () const; + /** + * @brief Flip the mathix threw the X axis + */ + void flipX(); + /** + * @brief Flip the mathix threw the Y axis + */ + void flipY(); + /** + * @brief Scale the current Matrix. + * @param[in] _vect Vector to scale matrix. + */ + void scale(const vec2& _vect); + /** + * @brief Scale the current Matrix. + * @param[in] _value Single value to scale in X andf Y. + */ + void scale(float _value); + /** + * @brief Makes a rotation matrix. + * @param[in] _angleRad angle to apply. + */ + void rotate(float _angleRad); + /** + * @brief Makes a translation of the matrix + * @param[in] _vect Translation to apply. + */ + void translate(const vec2& _vect); + /** + * @brief Computes the determinant of the matrix. + * @return The determinent Value. + */ + float determinant() const; + /** + * @brief Inverts the matrix. + * @note The determinant must be != 0, otherwithe the matrix can't be inverted. + * @return The inverted matrix. + */ + void invert(); + }; + /** + * @brief Create a matrix 2D with a simple rotation + * @param[in] _angleRad Radian angle to set at the matrix + * @return New matrix of the transformation requested + */ + Matrix2x3 mat2x3Rotate(float _angleRad); + /** + * @brief Create a matrix 2D with a simple scale + * @param[in] _scale 2 dimention scale + * @return New matrix of the transformation requested + */ + Matrix2x3 mat2x3Scale(const vec2& _scale); + /** + * @brief Create a matrix 2D with a simple scale + * @param[in] _scale same scale in 2 and Y + * @return New matrix of the transformation requested + */ + Matrix2x3 mat2x3Scale(float _scale); + /** + * @brief Create a matrix 2D with a simple translation + * @param[in] _translate 2 dimention translation + * @return New matrix of the transformation requested + */ + Matrix2x3 mat2x3Translate(const vec2& _translate); + /** + * @brief Create a matrix 2D with a simple skew + * @param[in] _skew 2 dimention skew + * @return New matrix of the transformation requested + */ + Matrix2x3 mat2x3Skew(const vec2& _skew); + //! @not_in_doc + std::ostream& operator <<(std::ostream& _os, const etk::Matrix2x3& _obj); +} +// simplify using of matrix ... +using mat2x3 = etk::Matrix2x3; //!< Use simplification in upper application to use matrix like openGL shader + + diff --git a/etk/math/Matrix3.cpp b/etk/math/Matrix3x3.cpp similarity index 61% rename from etk/math/Matrix3.cpp rename to etk/math/Matrix3x3.cpp index 70e40aa..c795d1b 100644 --- a/etk/math/Matrix3.cpp +++ b/etk/math/Matrix3x3.cpp @@ -4,10 +4,10 @@ * @license MPL v2.0 (see license file) */ -#include +#include -std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix3& _obj) { +std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix3x3& _obj) { _os << "{"; _os << _obj.m_mat[0] << ","; _os << _obj.m_mat[1] << ","; @@ -21,7 +21,7 @@ std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix3& _obj) { return _os; } -etk::Matrix3::Matrix3() { +etk::Matrix3x3::Matrix3x3() { m_mat[0] = 0.0f; m_mat[1] = 0.0f; m_mat[2] = 0.0f; @@ -33,7 +33,7 @@ etk::Matrix3::Matrix3() { m_mat[8] = 0.0f; } -etk::Matrix3::Matrix3(float _value) { +etk::Matrix3x3::Matrix3x3(float _value) { m_mat[0] = _value; m_mat[1] = _value; m_mat[2] = _value; @@ -45,7 +45,7 @@ etk::Matrix3::Matrix3(float _value) { m_mat[8] = _value; } -etk::Matrix3::Matrix3(float _a1, float _a2, float _a3, +etk::Matrix3x3::Matrix3x3(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3) { m_mat[0] = _a1; m_mat[1] = _a2; m_mat[2] = _a3; @@ -53,7 +53,7 @@ etk::Matrix3::Matrix3(float _a1, float _a2, float _a3, m_mat[6] = _c1; m_mat[7] = _c2; m_mat[8] = _c3; } -etk::Matrix3::Matrix3(const etk::Matrix3& _obj) { +etk::Matrix3x3::Matrix3x3(const etk::Matrix3x3& _obj) { m_mat[0] = _obj.m_mat[0]; m_mat[1] = _obj.m_mat[1]; m_mat[2] = _obj.m_mat[2]; @@ -65,7 +65,7 @@ etk::Matrix3::Matrix3(const etk::Matrix3& _obj) { m_mat[8] = _obj.m_mat[8]; } -void etk::Matrix3::setValue(float _a1, float _a2, float _a3, +void etk::Matrix3x3::setValue(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3) { m_mat[0] = _a1; m_mat[1] = _a2; m_mat[2] = _a3; @@ -73,7 +73,7 @@ void etk::Matrix3::setValue(float _a1, float _a2, float _a3, m_mat[6] = _c1; m_mat[7] = _c2; m_mat[8] = _c3; } -void etk::Matrix3::setZero() { +void etk::Matrix3x3::setZero() { m_mat[0] = 0.0f; m_mat[1] = 0.0f; m_mat[2] = 0.0f; @@ -85,7 +85,7 @@ void etk::Matrix3::setZero() { m_mat[8] = 0.0f; } -vec3 etk::Matrix3::getColumn(uint32_t _iii) const { +vec3 etk::Matrix3x3::getColumn(uint32_t _iii) const { if (_iii == 0) { return vec3(m_mat[0], m_mat[3], m_mat[6]); } else if (_iii == 1) { @@ -94,7 +94,7 @@ vec3 etk::Matrix3::getColumn(uint32_t _iii) const { return vec3(m_mat[2], m_mat[5], m_mat[8]); } -vec3 etk::Matrix3::getRow(uint32_t _iii) const { +vec3 etk::Matrix3x3::getRow(uint32_t _iii) const { if (_iii == 0) { return vec3(m_mat[0], m_mat[1], m_mat[2]); } else if (_iii == 1) { @@ -103,13 +103,13 @@ vec3 etk::Matrix3::getRow(uint32_t _iii) const { return vec3(m_mat[6], m_mat[7], m_mat[8]); } -etk::Matrix3 etk::Matrix3::getTranspose() const { - return etk::Matrix3(m_mat[0], m_mat[3], m_mat[6], +etk::Matrix3x3 etk::Matrix3x3::getTranspose() const { + return etk::Matrix3x3(m_mat[0], m_mat[3], m_mat[6], m_mat[1], m_mat[4], m_mat[7], m_mat[2], m_mat[5], m_mat[8]); } -void etk::Matrix3::transpose() { +void etk::Matrix3x3::transpose() { float tmp = m_mat[1]; m_mat[1] = m_mat[3]; m_mat[3] = tmp; @@ -121,31 +121,31 @@ void etk::Matrix3::transpose() { m_mat[7] = tmp; } -float etk::Matrix3::determinant() const { +float etk::Matrix3x3::determinant() const { return m_mat[0]*(m_mat[4]*m_mat[8]-m_mat[7]*m_mat[5]) - m_mat[1]*(m_mat[3]*m_mat[8]-m_mat[6]*m_mat[5]) + m_mat[2]*(m_mat[3]*m_mat[7]-m_mat[6]*m_mat[4]); } -float etk::Matrix3::getTrace() const { +float etk::Matrix3x3::getTrace() const { return (m_mat[0] + m_mat[4] + m_mat[8]); } -void etk::Matrix3::setIdentity() { +void etk::Matrix3x3::setIdentity() { m_mat[0] = 1.0; m_mat[1] = 0.0; m_mat[2] = 0.0; m_mat[3] = 0.0; m_mat[4] = 1.0; m_mat[5] = 0.0; m_mat[6] = 0.0; m_mat[7] = 0.0; m_mat[8] = 1.0; } -etk::Matrix3 etk::Matrix3::identity() { - return etk::Matrix3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0); +etk::Matrix3x3 etk::Matrix3x3::identity() { + return etk::Matrix3x3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0); } -etk::Matrix3 etk::Matrix3::zero() { - return etk::Matrix3(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); +etk::Matrix3x3 etk::Matrix3x3::zero() { + return etk::Matrix3x3(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); } -void etk::Matrix3::absolute() { +void etk::Matrix3x3::absolute() { m_mat[0] = std::abs(m_mat[0]); m_mat[1] = std::abs(m_mat[1]); m_mat[2] = std::abs(m_mat[2]); @@ -157,22 +157,22 @@ void etk::Matrix3::absolute() { m_mat[8] = std::abs(m_mat[8]); } -etk::Matrix3 etk::Matrix3::getAbsolute() const { - return etk::Matrix3(std::abs(m_mat[0]), std::abs(m_mat[1]), std::abs(m_mat[2]), +etk::Matrix3x3 etk::Matrix3x3::getAbsolute() const { + return etk::Matrix3x3(std::abs(m_mat[0]), std::abs(m_mat[1]), std::abs(m_mat[2]), std::abs(m_mat[3]), std::abs(m_mat[4]), std::abs(m_mat[5]), std::abs(m_mat[6]), std::abs(m_mat[7]), std::abs(m_mat[8])); } -const etk::Matrix3& etk::Matrix3::operator= (const etk::Matrix3& _obj ) { +const etk::Matrix3x3& etk::Matrix3x3::operator= (const etk::Matrix3x3& _obj ) { for(int32_t iii=0; iii<3*3 ; ++iii) { m_mat[iii] = _obj.m_mat[iii]; } return *this; } -bool etk::Matrix3::operator== (const etk::Matrix3& _obj) const { +bool etk::Matrix3x3::operator== (const etk::Matrix3x3& _obj) const { for(int32_t iii=0; iii<3*3 ; ++iii) { if(m_mat[iii] != _obj.m_mat[iii]) { return false; @@ -181,7 +181,7 @@ bool etk::Matrix3::operator== (const etk::Matrix3& _obj) const { return true; } -bool etk::Matrix3::operator!= (const etk::Matrix3& _obj) const { +bool etk::Matrix3x3::operator!= (const etk::Matrix3x3& _obj) const { for(int32_t iii=0; iii<3*3 ; ++iii) { if(m_mat[iii] != _obj.m_mat[iii]) { return true; @@ -190,33 +190,33 @@ bool etk::Matrix3::operator!= (const etk::Matrix3& _obj) const { return false; } -const etk::Matrix3& etk::Matrix3::operator+= (const etk::Matrix3& _obj) { +const etk::Matrix3x3& etk::Matrix3x3::operator+= (const etk::Matrix3x3& _obj) { for(int32_t iii=0; iii<3*3 ; ++iii) { m_mat[iii] += _obj.m_mat[iii]; } return *this; } -etk::Matrix3 etk::Matrix3::operator+ (const etk::Matrix3& _obj) const { - etk::Matrix3 tmpp(*this); +etk::Matrix3x3 etk::Matrix3x3::operator+ (const etk::Matrix3x3& _obj) const { + etk::Matrix3x3 tmpp(*this); tmpp += _obj; return tmpp; } -const etk::Matrix3& etk::Matrix3::operator-= (const etk::Matrix3& _obj) { +const etk::Matrix3x3& etk::Matrix3x3::operator-= (const etk::Matrix3x3& _obj) { for(int32_t iii=0; iii<3*3 ; ++iii) { m_mat[iii] -= _obj.m_mat[iii]; } return *this; } -etk::Matrix3 etk::Matrix3::operator- (const etk::Matrix3& _obj) const { - etk::Matrix3 tmpp(*this); +etk::Matrix3x3 etk::Matrix3x3::operator- (const etk::Matrix3x3& _obj) const { + etk::Matrix3x3 tmpp(*this); tmpp -= _obj; return tmpp; } -const etk::Matrix3& etk::Matrix3::operator *= (const etk::Matrix3& _obj) { +const etk::Matrix3x3& etk::Matrix3x3::operator *= (const etk::Matrix3x3& _obj) { float a1 = m_mat[0]*_obj.m_mat[0] + m_mat[1]*_obj.m_mat[3] + m_mat[2]*_obj.m_mat[6]; float b1 = m_mat[3]*_obj.m_mat[0] + m_mat[4]*_obj.m_mat[3] + m_mat[5]*_obj.m_mat[6]; float c1 = m_mat[6]*_obj.m_mat[0] + m_mat[7]*_obj.m_mat[3] + m_mat[8]*_obj.m_mat[6]; @@ -235,19 +235,19 @@ const etk::Matrix3& etk::Matrix3::operator *= (const etk::Matrix3& _obj) { return *this; } -etk::Matrix3 etk::Matrix3::operator * (const etk::Matrix3& _obj) const { - etk::Matrix3 tmp(*this); +etk::Matrix3x3 etk::Matrix3x3::operator * (const etk::Matrix3x3& _obj) const { + etk::Matrix3x3 tmp(*this); tmp *= _obj; return tmp; } -vec3 etk::Matrix3::operator * (const vec3& _point) const { +vec3 etk::Matrix3x3::operator * (const vec3& _point) const { return vec3(_point.x()*m_mat[0] + _point.y()*m_mat[1] + _point.z()*m_mat[2], _point.x()*m_mat[3] + _point.y()*m_mat[4] + _point.z()*m_mat[5], _point.x()*m_mat[6] + _point.y()*m_mat[7] + _point.z()*m_mat[8]); } -const etk::Matrix3& etk::Matrix3::operator *= (float _value) { +const etk::Matrix3x3& etk::Matrix3x3::operator *= (float _value) { m_mat[0] *= _value; m_mat[1] *= _value; m_mat[2] *= _value; @@ -260,39 +260,39 @@ const etk::Matrix3& etk::Matrix3::operator *= (float _value) { return *this; } -etk::Matrix3 etk::Matrix3::operator * (float _value) const { - etk::Matrix3 tmp(*this); +etk::Matrix3x3 etk::Matrix3x3::operator * (float _value) const { + etk::Matrix3x3 tmp(*this); tmp *= _value; return tmp; } -void etk::Matrix3::inverse() { +void etk::Matrix3x3::inverse() { *this = getInverse(); } -etk::Matrix3 etk::Matrix3::getInverse() const { +etk::Matrix3x3 etk::Matrix3x3::getInverse() const { float det = determinant(); //assert(std::abs(det) > MACHINE_EPSILON); float invDet = 1.0f / det; - return etk::Matrix3( (m_mat[4]*m_mat[8]-m_mat[7]*m_mat[5]), - -(m_mat[1]*m_mat[8]-m_mat[7]*m_mat[2]), - (m_mat[1]*m_mat[5]-m_mat[2]*m_mat[4]), - -(m_mat[3]*m_mat[8]-m_mat[6]*m_mat[5]), - (m_mat[0]*m_mat[8]-m_mat[6]*m_mat[2]), - -(m_mat[0]*m_mat[5]-m_mat[3]*m_mat[2]), - (m_mat[3]*m_mat[7]-m_mat[6]*m_mat[4]), - -(m_mat[0]*m_mat[7]-m_mat[6]*m_mat[1]), - (m_mat[0]*m_mat[4]-m_mat[1]*m_mat[3]))* invDet; + return etk::Matrix3x3( (m_mat[4]*m_mat[8]-m_mat[7]*m_mat[5]), + -(m_mat[1]*m_mat[8]-m_mat[7]*m_mat[2]), + (m_mat[1]*m_mat[5]-m_mat[2]*m_mat[4]), + -(m_mat[3]*m_mat[8]-m_mat[6]*m_mat[5]), + (m_mat[0]*m_mat[8]-m_mat[6]*m_mat[2]), + -(m_mat[0]*m_mat[5]-m_mat[3]*m_mat[2]), + (m_mat[3]*m_mat[7]-m_mat[6]*m_mat[4]), + -(m_mat[0]*m_mat[7]-m_mat[6]*m_mat[1]), + (m_mat[0]*m_mat[4]-m_mat[1]*m_mat[3]))* invDet; } -etk::Matrix3 etk::Matrix3::computeSkewSymmetricMatrixForCrossProduct(const vec3& vector) { - return etk::Matrix3( 0.0f , -vector.z(), vector.y(), - vector.z(), 0.0f , -vector.x(), - -vector.y(), vector.x(), 0.0f); +etk::Matrix3x3 etk::Matrix3x3::computeSkewSymmetricMatrixForCrossProduct(const vec3& vector) { + return etk::Matrix3x3( 0.0f , -vector.z(), vector.y(), + vector.z(), 0.0f , -vector.x(), + -vector.y(), vector.x(), 0.0f); } -etk::Matrix3 operator-(const etk::Matrix3& _matrix) { - return etk::Matrix3(-_matrix.m_mat[0], -_matrix.m_mat[1], -_matrix.m_mat[2], - -_matrix.m_mat[3], -_matrix.m_mat[4], -_matrix.m_mat[5], - -_matrix.m_mat[6], -_matrix.m_mat[7], -_matrix.m_mat[8]); +etk::Matrix3x3 operator-(const etk::Matrix3x3& _matrix) { + return etk::Matrix3x3(-_matrix.m_mat[0], -_matrix.m_mat[1], -_matrix.m_mat[2], + -_matrix.m_mat[3], -_matrix.m_mat[4], -_matrix.m_mat[5], + -_matrix.m_mat[6], -_matrix.m_mat[7], -_matrix.m_mat[8]); } diff --git a/etk/math/Matrix3.hpp b/etk/math/Matrix3x3.hpp similarity index 83% rename from etk/math/Matrix3.hpp rename to etk/math/Matrix3x3.hpp index 8592c53..2f537ce 100644 --- a/etk/math/Matrix3.hpp +++ b/etk/math/Matrix3x3.hpp @@ -12,19 +12,19 @@ namespace etk { /** * @brief This class represents a 3x3 matrix. */ - class Matrix3 { + class Matrix3x3 { public: float m_mat[3*3]; //!< matrix data public : /** * @brief Constructor that load zero matrix */ - Matrix3(); + Matrix3x3(); /** * @brief Configuration constructorwith single value. * @param[in] _value single vamue */ - Matrix3(float value); + Matrix3x3(float value); /** * @brief Configuration constructor. * @param[in] _a1 element 0x0 @@ -37,14 +37,14 @@ namespace etk { * @param[in] _c2 element 2x1 * @param[in] _c3 element 2x2 */ - Matrix3(float _a1, float _a2, float _a3, + Matrix3x3(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3); /** * @brief Copy constructor. * @param[in] _obj Matrix object to copy */ - Matrix3(const Matrix3& _obj); + Matrix3x3(const Matrix3x3& _obj); /** * @brief Set Value on the matrix * @param[in] _a1 element 0x0 @@ -80,7 +80,7 @@ namespace etk { * @brief get a transpose matrix of this one. * @return the transpose matrix */ - Matrix3 getTranspose() const; + Matrix3x3 getTranspose() const; /** * @brief Transpose the current matrix. */ @@ -100,7 +100,7 @@ namespace etk { * @note The determinant must be != 0, otherwithe the matrix can't be inverted. * @return The inverted matrix. */ - Matrix3 getInverse() const; + Matrix3x3 getInverse() const; /** * @brief Inverts the current matrix. * @note The determinant must be != 0, otherwithe the matrix can't be inverted. @@ -110,7 +110,7 @@ namespace etk { * @brief get the matrix with the absolute value * @return matix in absolute */ - Matrix3 getAbsolute() const; + Matrix3x3 getAbsolute() const; /** * @brief absolutise the matrix */ @@ -123,86 +123,86 @@ namespace etk { * @brief create a Identity matrix * @return created new matrix */ - static Matrix3 identity(); + static Matrix3x3 identity(); /** * @brief create a ZERO matrix * @return created new matrix */ - static Matrix3 zero(); + static Matrix3x3 zero(); /** * @brief create a skew-symmetric matrix using a given vector that can be used to compute cross product with another vector using matrix multiplication * @param[in] _vector Vector to comute * @return Matrix to compute */ - static Matrix3 computeSkewSymmetricMatrixForCrossProduct(const vec3& _vector); + static Matrix3x3 computeSkewSymmetricMatrixForCrossProduct(const vec3& _vector); /** * @brief Operator= Asign the current object with an other object * @param[in] _obj Reference on the external object * @return Local reference of the vector asigned */ - const Matrix3& operator= (const Matrix3& _obj ); + const Matrix3x3& operator= (const Matrix3x3& _obj ); /** * @brief Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are identical * @return false The Objects are NOT identical */ - bool operator== (const Matrix3& _obj) const; + bool operator== (const Matrix3x3& _obj) const; /** * @brief In-Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are NOT identical * @return false The Objects are identical */ - bool operator!= (const Matrix3& _obj) const; + bool operator!= (const Matrix3x3& _obj) const; /** * @brief Operator+= Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector additionned */ - const Matrix3& operator+= (const Matrix3& _obj); + const Matrix3x3& operator+= (const Matrix3x3& _obj); /** * @brief Operator+ Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix3 operator+ (const Matrix3& _obj) const; + Matrix3x3 operator+ (const Matrix3x3& _obj) const; /** * @brief Operator-= Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector decremented */ - const Matrix3& operator-= (const Matrix3& _obj); + const Matrix3x3& operator-= (const Matrix3x3& _obj); /** * @brief Operator- Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix3 operator- (const Matrix3& _obj) const; + Matrix3x3 operator- (const Matrix3x3& _obj) const; /** * @brief Operator*= Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector multiplicated */ - const Matrix3& operator *= (const Matrix3& _obj); + const Matrix3x3& operator *= (const Matrix3x3& _obj); /** * @brief Operator* Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix3 operator * (const Matrix3& _obj) const; + Matrix3x3 operator * (const Matrix3x3& _obj) const; /** * @brief Operator*= Multiplication a value * @param[in] _value value to multiply all the matrix * @return Local reference of the vector multiplicated */ - const Matrix3& operator *= (float _value); + const Matrix3x3& operator *= (float _value); /** * @brief Operator*= Multiplication a value * @param[in] _value value to multiply all the matrix * @return Local reference of the vector multiplicated */ - Matrix3 operator * (float _value) const; + Matrix3x3 operator * (float _value) const; /** * @brief Operator* apply matrix on a vector * @param[in] _point Point value to apply the matrix @@ -211,12 +211,12 @@ namespace etk { vec3 operator * (const vec3& _point) const; }; //! @not_in_doc - std::ostream& operator <<(std::ostream& _os, const etk::Matrix3& _obj); + std::ostream& operator <<(std::ostream& _os, const etk::Matrix3x3& _obj); } -etk::Matrix3 operator-(const etk::Matrix3& _matrix); +etk::Matrix3x3 operator-(const etk::Matrix3x3& _matrix); // simplify using of matrix ... -using mat3 = etk::Matrix3; //!< Use simplification in upper application to use matrix like openGL shader +using mat3 = etk::Matrix3x3; //!< Use simplification in upper application to use matrix like openGL shader diff --git a/etk/math/Matrix4.cpp b/etk/math/Matrix4x4.cpp similarity index 77% rename from etk/math/Matrix4.cpp rename to etk/math/Matrix4x4.cpp index 95ff32f..087639d 100644 --- a/etk/math/Matrix4.cpp +++ b/etk/math/Matrix4x4.cpp @@ -5,11 +5,11 @@ */ #include -#include +#include #include #include -void etk::Matrix4::identity() { +void etk::Matrix4x4::identity() { for(int32_t iii=0; iii<4*4 ; iii++) { m_mat[iii] = 0; } @@ -19,17 +19,17 @@ void etk::Matrix4::identity() { m_mat[15] = 1.0; } -etk::Matrix4::Matrix4() { +etk::Matrix4x4::Matrix4x4() { identity(); } -etk::Matrix4::Matrix4(const Matrix4& _obj) { +etk::Matrix4x4::Matrix4x4(const Matrix4x4& _obj) { for(int32_t iii=0; iii<4*4 ; iii++) { m_mat[iii] = _obj.m_mat[iii]; } } -etk::Matrix4::Matrix4(float _a1, float _b1, float _c1, float _d1, +etk::Matrix4x4::Matrix4x4(float _a1, float _b1, float _c1, float _d1, float _a2, float _b2, float _c2, float _d2, float _a3, float _b3, float _c3, float _d3, float _a4, float _b4, float _c4, float _d4) { @@ -51,7 +51,7 @@ etk::Matrix4::Matrix4(float _a1, float _b1, float _c1, float _d1, m_mat[15] = _d4; } -etk::Matrix4::Matrix4(float* _obj) { +etk::Matrix4x4::Matrix4x4(float* _obj) { if (_obj == nullptr) { identity(); return; @@ -61,14 +61,14 @@ etk::Matrix4::Matrix4(float* _obj) { } } -const etk::Matrix4& etk::Matrix4::operator= (const etk::Matrix4& _obj ) { +const etk::Matrix4x4& etk::Matrix4x4::operator= (const etk::Matrix4x4& _obj ) { for(int32_t iii=0; iii<4*4 ; ++iii) { m_mat[iii] = _obj.m_mat[iii]; } return *this; } -bool etk::Matrix4::operator== (const etk::Matrix4& _obj) const { +bool etk::Matrix4x4::operator== (const etk::Matrix4x4& _obj) const { for(int32_t iii=0; iii<4*4 ; ++iii) { if(m_mat[iii] != _obj.m_mat[iii]) { return false; @@ -77,7 +77,7 @@ bool etk::Matrix4::operator== (const etk::Matrix4& _obj) const { return true; } -bool etk::Matrix4::operator!= (const etk::Matrix4& _obj) const { +bool etk::Matrix4x4::operator!= (const etk::Matrix4x4& _obj) const { for(int32_t iii=0; iii<4*4 ; ++iii) { if(m_mat[iii] != _obj.m_mat[iii]) { return true; @@ -86,33 +86,33 @@ bool etk::Matrix4::operator!= (const etk::Matrix4& _obj) const { return false; } -const etk::Matrix4& etk::Matrix4::operator+= (const etk::Matrix4& _obj) { +const etk::Matrix4x4& etk::Matrix4x4::operator+= (const etk::Matrix4x4& _obj) { for(int32_t iii=0; iii<4*4 ; ++iii) { m_mat[iii] += _obj.m_mat[iii]; } return *this; } -etk::Matrix4 etk::Matrix4::operator+ (const etk::Matrix4& _obj) const { - etk::Matrix4 tmpp(*this); +etk::Matrix4x4 etk::Matrix4x4::operator+ (const etk::Matrix4x4& _obj) const { + etk::Matrix4x4 tmpp(*this); tmpp += _obj; return tmpp; } -const etk::Matrix4& etk::Matrix4::operator-= (const etk::Matrix4& _obj) { +const etk::Matrix4x4& etk::Matrix4x4::operator-= (const etk::Matrix4x4& _obj) { for(int32_t iii=0; iii<4*4 ; ++iii) { m_mat[iii] -= _obj.m_mat[iii]; } return *this; } -etk::Matrix4 etk::Matrix4::operator- (const etk::Matrix4& _obj) const { - etk::Matrix4 tmpp(*this); +etk::Matrix4x4 etk::Matrix4x4::operator- (const etk::Matrix4x4& _obj) const { + etk::Matrix4x4 tmpp(*this); tmpp += _obj; return tmpp; } -const etk::Matrix4& etk::Matrix4::operator*= (const etk::Matrix4& _obj) { +const etk::Matrix4x4& etk::Matrix4x4::operator*= (const etk::Matrix4x4& _obj) { // output Matrix float matrixOut[4*4]; for(int32_t jjj=0; jjj<4 ; jjj++) { @@ -136,19 +136,19 @@ const etk::Matrix4& etk::Matrix4::operator*= (const etk::Matrix4& _obj) { return *this; } -etk::Matrix4 etk::Matrix4::operator* (const etk::Matrix4& _obj) const { - etk::Matrix4 tmpp(*this); +etk::Matrix4x4 etk::Matrix4x4::operator* (const etk::Matrix4x4& _obj) const { + etk::Matrix4x4 tmpp(*this); tmpp *= _obj; return tmpp; } -vec3 etk::Matrix4::operator*(const vec3& _point) const { +vec3 etk::Matrix4x4::operator*(const vec3& _point) const { return vec3( m_mat[0]*_point.x() + m_mat[1]*_point.y() + m_mat[2]*_point.z() + m_mat[3], m_mat[4]*_point.x() + m_mat[5]*_point.y() + m_mat[6]*_point.z() + m_mat[7], m_mat[8]*_point.x() + m_mat[9]*_point.y() + m_mat[10]*_point.z() + m_mat[11] ); } -void etk::Matrix4::transpose() { +void etk::Matrix4x4::transpose() { float tmpVal = m_mat[1]; m_mat[1] = m_mat[4]; m_mat[4] = tmpVal; @@ -174,29 +174,29 @@ void etk::Matrix4::transpose() { m_mat[14] = tmpVal; } -void etk::Matrix4::scale(const vec3& _vect) { +void etk::Matrix4x4::scale(const vec3& _vect) { scale(_vect.x(), _vect.y(), _vect.z()); } -void etk::Matrix4::scale(float _sx, float _sy, float _sz) { +void etk::Matrix4x4::scale(float _sx, float _sy, float _sz) { m_mat[0] *= _sx; m_mat[1] *= _sy; m_mat[2] *= _sz; m_mat[4] *= _sx; m_mat[5] *= _sy; m_mat[6] *= _sz; m_mat[8] *= _sx; m_mat[9] *= _sy; m_mat[10] *= _sz; } -void etk::Matrix4::rotate(const vec3& _vect, float _angleRad) { - etk::Matrix4 tmpMat = etk::matRotate(_vect, _angleRad); +void etk::Matrix4x4::rotate(const vec3& _vect, float _angleRad) { + etk::Matrix4x4 tmpMat = etk::matRotate(_vect, _angleRad); *this *= tmpMat; } -void etk::Matrix4::translate(const vec3& _vect) { - etk::Matrix4 tmpMat = etk::matTranslate(_vect); +void etk::Matrix4x4::translate(const vec3& _vect) { + etk::Matrix4x4 tmpMat = etk::matTranslate(_vect); *this *= tmpMat; } -etk::Matrix4 etk::matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, float _zNear, float _zFar) { - etk::Matrix4 tmp; +etk::Matrix4x4 etk::matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, float _zNear, float _zFar) { + etk::Matrix4x4 tmp; for(int32_t iii=0; iii<4*4 ; iii++) { tmp.m_mat[iii] = 0; } @@ -214,7 +214,7 @@ etk::Matrix4 etk::matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, return tmp; } -etk::Matrix4 etk::matPerspective(float _fovx, float _aspect, float _zNear, float _zFar) { +etk::Matrix4x4 etk::matPerspective(float _fovx, float _aspect, float _zNear, float _zFar) { //TK_DEBUG("drax perspective: fovx=" << fovx << "->" << aspect << " " << zNear << "->" << zFar); float xmax = _zNear * tanf(_fovx/2.0); float xmin = -xmax; @@ -225,8 +225,8 @@ etk::Matrix4 etk::matPerspective(float _fovx, float _aspect, float _zNear, float return etk::matFrustum(xmin, xmax, ymin, ymax, _zNear, _zFar); } -etk::Matrix4 etk::matOrtho(float _left, float _right, float _bottom, float _top, float _nearVal, float _farVal) { - etk::Matrix4 tmp; +etk::Matrix4x4 etk::matOrtho(float _left, float _right, float _bottom, float _top, float _nearVal, float _farVal) { + etk::Matrix4x4 tmp; for(int32_t iii=0; iii<4*4 ; iii++) { tmp.m_mat[iii] = 0; } @@ -240,8 +240,8 @@ etk::Matrix4 etk::matOrtho(float _left, float _right, float _bottom, float _top, return tmp; } -etk::Matrix4 etk::matTranslate(vec3 _vect) { - etk::Matrix4 tmp; +etk::Matrix4x4 etk::matTranslate(vec3 _vect) { + etk::Matrix4x4 tmp; // set translation : tmp.m_mat[3] = _vect.x(); tmp.m_mat[7] = _vect.y(); @@ -251,8 +251,8 @@ etk::Matrix4 etk::matTranslate(vec3 _vect) { return tmp; } -etk::Matrix4 etk::matScale(vec3 _vect) { - etk::Matrix4 tmp; +etk::Matrix4x4 etk::matScale(vec3 _vect) { + etk::Matrix4x4 tmp; tmp.scale(_vect); /* // set scale : @@ -265,8 +265,8 @@ etk::Matrix4 etk::matScale(vec3 _vect) { return tmp; } -etk::Matrix4 etk::matRotate(vec3 _vect, float _angleRad) { - etk::Matrix4 tmp; +etk::Matrix4x4 etk::matRotate(vec3 _vect, float _angleRad) { + etk::Matrix4x4 tmp; float cosVal = cos(_angleRad); float sinVal = sin(_angleRad); float invVal = 1.0-cosVal; @@ -285,14 +285,14 @@ etk::Matrix4 etk::matRotate(vec3 _vect, float _angleRad) { return tmp; } -etk::Matrix4 etk::matRotate2(vec3 _vect) { +etk::Matrix4x4 etk::matRotate2(vec3 _vect) { return matLookAt(_vect, vec3(0,0,0), vec3(0,1,0)); } -etk::Matrix4 etk::matLookAt(const vec3& _eye, +etk::Matrix4x4 etk::matLookAt(const vec3& _eye, const vec3& _target, const vec3& _up) { - etk::Matrix4 tmp; + etk::Matrix4x4 tmp; vec3 forward = _eye; forward -= _target; @@ -325,7 +325,7 @@ etk::Matrix4 etk::matLookAt(const vec3& _eye, } -float etk::Matrix4::coFactor(int32_t _row, int32_t _col) const { +float etk::Matrix4x4::coFactor(int32_t _row, int32_t _col) const { return ( ( m_mat[((_row+1)&3)*4 + ((_col+1)&3)] * m_mat[((_row+2)&3)*4 + ((_col+2)&3)] * m_mat[((_row+3)&3)*4 + ((_col+3)&3)] + m_mat[((_row+1)&3)*4 + ((_col+2)&3)] * m_mat[((_row+2)&3)*4 + ((_col+3)&3)] * m_mat[((_row+3)&3)*4 + ((_col+1)&3)] + m_mat[((_row+1)&3)*4 + ((_col+3)&3)] * m_mat[((_row+2)&3)*4 + ((_col+1)&3)] * m_mat[((_row+3)&3)*4 + ((_col+2)&3)] ) @@ -336,7 +336,7 @@ float etk::Matrix4::coFactor(int32_t _row, int32_t _col) const { } -float etk::Matrix4::determinant() const { +float etk::Matrix4x4::determinant() const { return m_mat[0] * coFactor(0, 0) + m_mat[1] * coFactor(0, 1) + m_mat[2] * coFactor(0, 2) + @@ -344,13 +344,13 @@ float etk::Matrix4::determinant() const { } -etk::Matrix4 etk::Matrix4::invert() { +etk::Matrix4x4 etk::Matrix4x4::invert() { float det = determinant(); if(std::abs(det) < (1.0e-7f)) { // The matrix is not invertible! Singular case! return *this; } - etk::Matrix4 temp; + etk::Matrix4x4 temp; float iDet = 1.0f / det; temp.m_mat[0] = coFactor(0,0) * iDet; temp.m_mat[1] = coFactor(0,1) * iDet; @@ -372,7 +372,7 @@ etk::Matrix4 etk::Matrix4::invert() { } -std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix4& _obj) { +std::ostream& etk::operator <<(std::ostream& _os, const etk::Matrix4x4& _obj) { _os << "matrix4 : ("; for (int32_t iii=0; iii<16; iii++) { _os << _obj.m_mat[iii]; diff --git a/etk/math/Matrix4.hpp b/etk/math/Matrix4x4.hpp similarity index 86% rename from etk/math/Matrix4.hpp rename to etk/math/Matrix4x4.hpp index 1974871..e03f60d 100644 --- a/etk/math/Matrix4.hpp +++ b/etk/math/Matrix4x4.hpp @@ -34,7 +34,7 @@ namespace etk { /** * @brief This class represents a 4x4 matrix. */ - class Matrix4 { + class Matrix4x4 { public: float m_mat[4*4]; //!< matrix data public: @@ -45,12 +45,12 @@ namespace etk { /** * @brief Constructor that load identity */ - Matrix4(); + Matrix4x4(); /** * @brief Copy constructor. * @param[in] _obj Matrix object to copy */ - Matrix4(const Matrix4& _obj); + Matrix4x4(const Matrix4x4& _obj); /** * @brief Configuration constructor. * @param[in] _a1 1st colomn, 1 line value @@ -70,7 +70,7 @@ namespace etk { * @param[in] _c4 3rd colomn, 4 line value * @param[in] _d4 4th colomn, 4 line value */ - Matrix4(float _a1, float _b1, float _c1, float _d1, + Matrix4x4(float _a1, float _b1, float _c1, float _d1, float _a2, float _b2, float _c2, float _d2, float _a3, float _b3, float _c3, float _d3, float _a4, float _b4, float _c4, float _d4); @@ -78,63 +78,63 @@ namespace etk { * @brief Configuration constructor. * @param[in] _values vector of values */ - Matrix4(float* _values); + Matrix4x4(float* _values); /** * @brief Operator= Asign the current object with an other object * @param[in] _obj Reference on the external object * @return Local reference of the vector asigned */ - const Matrix4& operator= (const Matrix4& _obj); + const Matrix4x4& operator= (const Matrix4x4& _obj); /** * @brief Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are identical * @return false The Objects are NOT identical */ - bool operator== (const Matrix4& _obj) const; + bool operator== (const Matrix4x4& _obj) const; /** * @brief In-Equality compare operator with an other object. * @param[in] _obj Reference on the comparing object * @return true The Objects are NOT identical * @return false The Objects are identical */ - bool operator!= (const Matrix4& _obj) const; + bool operator!= (const Matrix4x4& _obj) const; /** * @brief Operator+= Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector additionned */ - const Matrix4& operator+= (const Matrix4& _obj); + const Matrix4x4& operator+= (const Matrix4x4& _obj); /** * @brief Operator+ Addition an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix4 operator+ (const Matrix4& _obj) const; + Matrix4x4 operator+ (const Matrix4x4& _obj) const; /** * @brief Operator-= Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector decremented */ - const Matrix4& operator-= (const Matrix4& _obj); + const Matrix4x4& operator-= (const Matrix4x4& _obj); /** * @brief Operator- Decrement an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix4 operator- (const Matrix4& _obj) const; + Matrix4x4 operator- (const Matrix4x4& _obj) const; /** * @brief Operator*= Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return Local reference of the vector multiplicated */ - const Matrix4& operator*= (const Matrix4& _obj); + const Matrix4x4& operator*= (const Matrix4x4& _obj); /** * @brief Operator* Multiplication an other matrix with this one * @param[in] _obj Reference on the external object * @return New vector containing the value */ - Matrix4 operator* (const Matrix4& _obj) const; + Matrix4x4 operator* (const Matrix4x4& _obj) const; /** * @brief Operator* apply matrix on a vector * @param[in] _point Point value to apply the matrix @@ -185,7 +185,7 @@ namespace etk { * @note The determinant must be != 0, otherwithe the matrix can't be inverted. * @return The inverted matrix. */ - Matrix4 invert(); + Matrix4x4 invert(); }; /** * @brief Create projection matrix with the box parameter (camera view in -z axis) @@ -197,7 +197,7 @@ namespace etk { * @param[in] _zFar Z maximum size of the frustum * @return New matrix of the transformation requested */ - Matrix4 matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, float _zNear, float _zFar); + Matrix4x4 matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, float _zNear, float _zFar); /** * @brief Create projection matrix with human repensentation view (camera view in -z axis) * @param[in] _foxy Focal in radian of the camera @@ -206,7 +206,7 @@ namespace etk { * @param[in] _zFar Z far size of the camera * @return New matrix of the transformation requested */ - Matrix4 matPerspective(float _foxy, float _aspect, float _zNear, float _zFar); + Matrix4x4 matPerspective(float _foxy, float _aspect, float _zNear, float _zFar); /** * @brief Create orthogonal projection matrix with the box parameter (camera view in -z axis) * @param[in] _left left size of the camera @@ -217,28 +217,28 @@ namespace etk { * @param[in] _farVal Z far size of the camera * @return New matrix of the transformation requested */ - Matrix4 matOrtho(float _left, float _right, float _bottom, float _top, float _nearVal, float _farVal); + Matrix4x4 matOrtho(float _left, float _right, float _bottom, float _top, float _nearVal, float _farVal); /** * @brief Create a matrix 3D with a simple translation * @param[in] _translate 3 dimention translation * @return New matrix of the transformation requested */ - Matrix4 matTranslate(vec3 _translate); + Matrix4x4 matTranslate(vec3 _translate); /** * @brief Create a matrix 3D with a simple scale * @param[in] _scale 3 dimention scale * @return New matrix of the transformation requested */ - Matrix4 matScale(vec3 _scale); + Matrix4x4 matScale(vec3 _scale); /** * @brief Create a matrix 3D with a simple rotation * @param[in] _normal vector aroud witch apply the rotation * @param[in] _angleRad Radian angle to set at the matrix * @return New matrix of the transformation requested */ - Matrix4 matRotate(vec3 _normal, float _angleRad=0.0); + Matrix4x4 matRotate(vec3 _normal, float _angleRad=0.0); //! @not_in_doc - Matrix4 matRotate2(vec3 _vect); + Matrix4x4 matRotate2(vec3 _vect); /** * @brief Create projection matrix with camera property (camera view in -z axis) * @param[in] _eye Optical center of the camera @@ -246,14 +246,14 @@ namespace etk { * @param[in] _up Up vector of the camera * @return New matrix of the transformation requested */ - Matrix4 matLookAt(const vec3& _eye, + Matrix4x4 matLookAt(const vec3& _eye, const vec3& _target, const vec3& _up); //! @not_in_doc - std::ostream& operator <<(std::ostream& _os, const etk::Matrix4& _obj); + std::ostream& operator <<(std::ostream& _os, const etk::Matrix4x4& _obj); }; // To siplify the writing of the code ==> this permit to have the same name with the glsl language... -using mat4 = etk::Matrix4; //!< Matrix naming like openGl shader +using mat4 = etk::Matrix4x4; //!< Matrix naming like openGl shader diff --git a/etk/math/Quaternion.cpp b/etk/math/Quaternion.cpp index 4f0638e..0f37fc2 100644 --- a/etk/math/Quaternion.cpp +++ b/etk/math/Quaternion.cpp @@ -19,7 +19,7 @@ std::ostream& etk::operator <<(std::ostream &_os, const etk::Quaternion& _obj) { return _os; } -etk::Quaternion::Quaternion(const etk::Matrix3& _matrix) { +etk::Quaternion::Quaternion(const etk::Matrix3x3& _matrix) { float trace = _matrix.getTrace(); if (trace < 0.0f) { if (_matrix.m_mat[4] > _matrix.m_mat[0]) { @@ -71,7 +71,7 @@ void etk::Quaternion::getAngleAxis(float& _angle, vec3& _axis) const { _axis.setValue(rotationAxis.x(), rotationAxis.y(), rotationAxis.z()); } -etk::Matrix3 etk::Quaternion::getMatrix() const { +etk::Matrix3x3 etk::Quaternion::getMatrix() const { float nQ = m_floats[0]*m_floats[0] + m_floats[1]*m_floats[1] + m_floats[2]*m_floats[2] @@ -92,15 +92,15 @@ etk::Matrix3 etk::Quaternion::getMatrix() const { float yys = m_floats[1]*ys; float yzs = m_floats[1]*zs; float zzs = m_floats[2]*zs; - return etk::Matrix3(1.0f - yys - zzs, - xys - wzs, - xzs + wys, - xys + wzs, - 1.0f - xxs - zzs, - yzs - wxs, - xzs - wys, - yzs + wxs, - 1.0f - xxs - yys); + return etk::Matrix3x3(1.0f - yys - zzs, + xys - wzs, + xzs + wys, + xys + wzs, + 1.0f - xxs - zzs, + yzs - wxs, + xzs - wys, + yzs + wxs, + 1.0f - xxs - yys); } etk::Quaternion etk::Quaternion::slerp(const Quaternion& _obj1, diff --git a/etk/math/Quaternion.hpp b/etk/math/Quaternion.hpp index e7f11ec..3c3c6db 100644 --- a/etk/math/Quaternion.hpp +++ b/etk/math/Quaternion.hpp @@ -8,7 +8,7 @@ #include #include -#include +#include #include namespace etk { @@ -63,7 +63,7 @@ namespace etk { * @brief Create a unit quaternion from a rotation matrix * @param _matrix generic matrix */ - Quaternion(const etk::Matrix3& _matrix); + Quaternion(const etk::Matrix3x3& _matrix); /** * @brief Add a vector to this one. * @param[in] _obj The vector to add to this one @@ -527,7 +527,7 @@ namespace etk { * @brief Get the orientation matrix corresponding to this quaternion * @return the 3x3 transformation matrix */ - etk::Matrix3 getMatrix() const; + etk::Matrix3x3 getMatrix() const; /** * @brief Compute the spherical linear interpolation between two quaternions. * @param[in] _obj1 First quaternion diff --git a/etk/math/Transform.cpp b/etk/math/Transform3D.cpp similarity index 100% rename from etk/math/Transform.cpp rename to etk/math/Transform3D.cpp diff --git a/etk/math/Transform.hpp b/etk/math/Transform3D.hpp similarity index 80% rename from etk/math/Transform.hpp rename to etk/math/Transform3D.hpp index 73d7b26..20bc88a 100644 --- a/etk/math/Transform.hpp +++ b/etk/math/Transform3D.hpp @@ -15,24 +15,24 @@ namespace etk { /** * @brief This class represents a position and an orientation in 3D. It can also be seen as representing a translation and a rotation. */ - class Transform { + class Transform3D { public: - Transform(): + Transform3D(): m_position(vec3(0.0, 0.0, 0.0)), m_orientation(Quaternion::identity()) { } - Transform(const vec3& _position, const Matrix3x3& _orientation): + Transform3D(const vec3& _position, const Matrix3x3& _orientation): m_position(_position), m_orientation(Quaternion(_orientation)) { } - Transform(const vec3& _position, const Quaternion& _orientation): + Transform3D(const vec3& _position, const Quaternion& _orientation): m_position(_position), m_orientation(_orientation) { } - Transform(const Transform& _other): + Transform3D(const Transform3D& _other): m_position(_other.m_position), m_orientation(_other.m_orientation) { @@ -60,7 +60,7 @@ namespace etk { m_orientation = _orientation; } public: - /// Set the transform to the identity transform + /// Set the Transform3D to the identity transform void setToIdentity() { m_position = vec3(0.0, 0.0, 0.0); m_orientation = Quaternion::identity(); @@ -94,45 +94,45 @@ namespace etk { _matrix[15] = 1.0; } /// Return the inverse of the transform - Transform getInverse() const { + Transform3D getInverse() const { const Quaternion& invQuaternion = m_orientation.getInverse(); Matrix3x3 invMatrix = invQuaternion.getMatrix(); - return Transform(invMatrix * (-m_position), invQuaternion); + return Transform3D(invMatrix * (-m_position), invQuaternion); } /// Return an interpolated transform - Transform interpolateTransforms(const Transform& _old, - const Transform& _new, + Transform3D interpolateTransforms(const Transform3D& _old, + const Transform3D& _new, float _interpolationFactor) { vec3 interPosition = _old.m_position * (decimal(1.0) - _interpolationFactor) + _new.m_position * _interpolationFactor; Quaternion interOrientation = Quaternion::slerp(_old.m_orientation, _naw.m_orientation, _interpolationFactor); - return Transform(interPosition, interOrientation); + return Transform3D(interPosition, interOrientation); } /// Return the identity transform - Transform identity() { - return Transform(vec3(0, 0, 0), Quaternion::identity()); + Transform3D identity() { + return Transform3D(vec3(0, 0, 0), Quaternion::identity()); } /// Return the transformed vector vec3 operator*(const vec3& _vector) const { return (m_orientation.getMatrix() * _vector) + m_position; } /// Operator of multiplication of a transform with another one - Transform operator*(const Transform& _transform2) const { - return Transform(m_position + m_orientation.getMatrix() * _transform2.m_position, + Transform3D operator*(const Transform3D& _transform2) const { + return Transform3D(m_position + m_orientation.getMatrix() * _transform2.m_position, m_orientation * _transform2.m_orientation); } /// Return true if the two transforms are equal - bool operator==(const Transform& _transform2) const { + bool operator==(const Transform3D& _transform2) const { return (m_position == _transform2.m_position) && (m_orientation == _transform2.m_orientation); } /// Return true if the two transforms are different - bool operator!=(const Transform& _transform2) const { + bool operator!=(const Transform3D& _transform2) const { return !(*this == _transform2); } /// Assignment operator - Transform& operator=(const Transform& _transform) { + Transform3D& operator=(const Transform3D& _transform) { if (&_transform != this) { m_position = _transform.m_position; m_orientation = _transform.m_orientation; diff --git a/lutin_etk.py b/lutin_etk.py index f9bbc4b..14aafc4 100644 --- a/lutin_etk.py +++ b/lutin_etk.py @@ -35,14 +35,15 @@ def configure(target, my_module): 'etk/Noise.cpp', 'etk/Color.cpp', 'etk/RegExp.cpp', - 'etk/math/Matrix2.cpp', - 'etk/math/Matrix3.cpp', - 'etk/math/Matrix4.cpp', + 'etk/math/Matrix2x2.cpp', + 'etk/math/Matrix2x3.cpp', + 'etk/math/Matrix3x3.cpp', + 'etk/math/Matrix4x4.cpp', 'etk/math/Vector2D.cpp', 'etk/math/Vector3D.cpp', 'etk/math/Vector4D.cpp', 'etk/math/Quaternion.cpp', - 'etk/math/Transform.cpp', + 'etk/math/Transform3D.cpp', 'etk/os/FSNode.cpp', 'etk/os/FSNodeRight.cpp', 'etk/archive/Archive.cpp', @@ -59,14 +60,15 @@ def configure(target, my_module): 'etk/RegExp.hpp', 'etk/Buffer.hpp', 'etk/Hash.hpp', - 'etk/math/Matrix2.hpp', - 'etk/math/Matrix3.hpp', - 'etk/math/Matrix4.hpp', + 'etk/math/Matrix2x2.hpp', + 'etk/math/Matrix2x3.hpp', + 'etk/math/Matrix3x3.hpp', + 'etk/math/Matrix4x4.hpp', 'etk/math/Vector2D.hpp', 'etk/math/Vector3D.hpp', 'etk/math/Vector4D.hpp', 'etk/math/Quaternion.hpp', - 'etk/math/Transform.hpp', + 'etk/math/Transform3D.hpp', 'etk/os/Fifo.hpp', 'etk/os/FSNode.hpp', 'etk/os/FSNodeRight.hpp', diff --git a/test/testMatrix2x2.cpp b/test/testMatrix2x2.cpp index 415b41d..9f4e9eb 100644 --- a/test/testMatrix2x2.cpp +++ b/test/testMatrix2x2.cpp @@ -7,29 +7,29 @@ */ #include -#include +#include #include #define NAME "etk::Matrix2x2" TEST(TestMatrix2x2, constructor) { // Test contructor value - etk::Matrix2 test1(99.0); + etk::Matrix2x2 test1(99.0); EXPECT_FLOAT_EQ(test1.m_mat[0], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[1], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[2], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[3], 99.0); - etk::Matrix2 test2(11,22,33,44); + etk::Matrix2x2 test2(11,22,33,44); EXPECT_FLOAT_EQ(test2.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test2.m_mat[1], 22.0); EXPECT_FLOAT_EQ(test2.m_mat[2], 33.0); EXPECT_FLOAT_EQ(test2.m_mat[3], 44.0); - etk::Matrix2 test3(test2); + etk::Matrix2x2 test3(test2); EXPECT_FLOAT_EQ(test3.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test3.m_mat[1], 22.0); EXPECT_FLOAT_EQ(test3.m_mat[2], 33.0); EXPECT_FLOAT_EQ(test3.m_mat[3], 44.0); - etk::Matrix2 test4 = test1; + etk::Matrix2x2 test4 = test1; EXPECT_FLOAT_EQ(test4.m_mat[0], 99.0); EXPECT_FLOAT_EQ(test4.m_mat[1], 99.0); EXPECT_FLOAT_EQ(test4.m_mat[2], 99.0); @@ -42,9 +42,9 @@ TEST(TestMatrix2x2, constructor) { } TEST(TestMatrix2x2, equity) { - etk::Matrix2 test1(99,32,56,92); - etk::Matrix2 test2(11,22,33,44); - etk::Matrix2 test3(11,22,33,44); + etk::Matrix2x2 test1(99,32,56,92); + etk::Matrix2x2 test2(11,22,33,44); + etk::Matrix2x2 test3(11,22,33,44); EXPECT_EQ(test1 == test2, false); EXPECT_EQ(test1 != test2, true); EXPECT_EQ(test3 == test2, true); @@ -52,7 +52,7 @@ TEST(TestMatrix2x2, equity) { } TEST(TestMatrix2x2, set) { - etk::Matrix2 test; + etk::Matrix2x2 test; test.setValue(22, 54, 45, 985); EXPECT_FLOAT_EQ(test.m_mat[0], 22.0); EXPECT_FLOAT_EQ(test.m_mat[1], 54.0); @@ -68,12 +68,12 @@ TEST(TestMatrix2x2, set) { EXPECT_FLOAT_EQ(test.m_mat[1], 0.0); EXPECT_FLOAT_EQ(test.m_mat[2], 0.0); EXPECT_FLOAT_EQ(test.m_mat[3], 1.0); - test = etk::Matrix2::zero(); + test = etk::Matrix2x2::zero(); EXPECT_FLOAT_EQ(test.m_mat[0], 0.0); EXPECT_FLOAT_EQ(test.m_mat[1], 0.0); EXPECT_FLOAT_EQ(test.m_mat[2], 0.0); EXPECT_FLOAT_EQ(test.m_mat[3], 0.0); - test = etk::Matrix2::identity(); + test = etk::Matrix2x2::identity(); EXPECT_FLOAT_EQ(test.m_mat[0], 1.0); EXPECT_FLOAT_EQ(test.m_mat[1], 0.0); EXPECT_FLOAT_EQ(test.m_mat[2], 0.0); @@ -81,7 +81,7 @@ TEST(TestMatrix2x2, set) { } TEST(TestMatrix2x2, getRowColomn) { - etk::Matrix2 test(11, 22, 33, 44); + etk::Matrix2x2 test(11, 22, 33, 44); EXPECT_FLOAT_EQ(test.getColumn(0).x(), 11.0); EXPECT_FLOAT_EQ(test.getColumn(0).y(), 33.0); EXPECT_FLOAT_EQ(test.getColumn(1).x(), 22.0); @@ -97,8 +97,8 @@ TEST(TestMatrix2x2, getRowColomn) { } TEST(TestMatrix2x2, transpose) { - etk::Matrix2 test(11, 22, 33, 44); - etk::Matrix2 test2 = test.getTranspose(); + etk::Matrix2x2 test(11, 22, 33, 44); + etk::Matrix2x2 test2 = test.getTranspose(); EXPECT_FLOAT_EQ(test2.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test2.m_mat[1], 33.0); EXPECT_FLOAT_EQ(test2.m_mat[2], 22.0); @@ -116,19 +116,19 @@ TEST(TestMatrix2x2, transpose) { } TEST(TestMatrix2x2, determinant) { - etk::Matrix2 test(11, 22, 33, 44); + etk::Matrix2x2 test(11, 22, 33, 44); EXPECT_FLOAT_EQ(test.determinant(), -242.0); - EXPECT_FLOAT_EQ(etk::Matrix2::identity().determinant(), 1.0); + EXPECT_FLOAT_EQ(etk::Matrix2x2::identity().determinant(), 1.0); } TEST(TestMatrix2x2, trace) { - etk::Matrix2 test(11, 22, 33, 44); + etk::Matrix2x2 test(11, 22, 33, 44); EXPECT_FLOAT_EQ(test.getTrace(), 55.0); } TEST(TestMatrix2x2, inverse) { - etk::Matrix2 test(1, 2, 3, 4); - etk::Matrix2 test2 = test.getInverse(); + etk::Matrix2x2 test(1, 2, 3, 4); + etk::Matrix2x2 test2 = test.getInverse(); // check if original matrix is not inversed EXPECT_FLOAT_EQ(test.m_mat[0], 1.0); EXPECT_FLOAT_EQ(test.m_mat[1], 2.0); @@ -146,8 +146,8 @@ TEST(TestMatrix2x2, inverse) { } TEST(TestMatrix2x2, absolute) { - etk::Matrix2 test(-1, -2, -3, -4); - etk::Matrix2 test2 = test.getAbsolute(); + etk::Matrix2x2 test(-1, -2, -3, -4); + etk::Matrix2x2 test2 = test.getAbsolute(); // check if original matrix is not inversed EXPECT_FLOAT_EQ(test.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test.m_mat[1], -2.0); @@ -165,9 +165,9 @@ TEST(TestMatrix2x2, absolute) { } TEST(TestMatrix2x2, operatorAddition) { - etk::Matrix2 test1(-1, -2, -3, -4); - etk::Matrix2 test2(1, 2, 3, 4); - etk::Matrix2 test3 = test1 + test2; + etk::Matrix2x2 test1(-1, -2, -3, -4); + etk::Matrix2x2 test2(1, 2, 3, 4); + etk::Matrix2x2 test3 = test1 + test2; // check no change EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); @@ -190,9 +190,9 @@ TEST(TestMatrix2x2, operatorAddition) { } TEST(TestMatrix2x2, operatorSubstraction) { - etk::Matrix2 test1(-1, -2, -3, -4); - etk::Matrix2 test2(1, 2, 3, 4); - etk::Matrix2 test3 = test1 - test2; + etk::Matrix2x2 test1(-1, -2, -3, -4); + etk::Matrix2x2 test2(1, 2, 3, 4); + etk::Matrix2x2 test3 = test1 - test2; // check no change EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); @@ -214,8 +214,8 @@ TEST(TestMatrix2x2, operatorSubstraction) { } TEST(TestMatrix2x2, operatorNegation) { - etk::Matrix2 test1(-1, -2, -3, -4); - etk::Matrix2 test2 = -test1; + etk::Matrix2x2 test1(-1, -2, -3, -4); + etk::Matrix2x2 test2 = -test1; EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); EXPECT_FLOAT_EQ(test1.m_mat[2], -3.0); @@ -227,9 +227,9 @@ TEST(TestMatrix2x2, operatorNegation) { } TEST(TestMatrix2x2, operatorMultiplicationMatrix) { - etk::Matrix2 test1(1, 2, 3, 4); - etk::Matrix2 test2(5, 6, 7, 10); - etk::Matrix2 test3 = test1 * test2; + etk::Matrix2x2 test1(1, 2, 3, 4); + etk::Matrix2x2 test2(5, 6, 7, 10); + etk::Matrix2x2 test3 = test1 * test2; EXPECT_FLOAT_EQ(test1.m_mat[0], 1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], 2.0); EXPECT_FLOAT_EQ(test1.m_mat[2], 3.0); @@ -250,7 +250,7 @@ TEST(TestMatrix2x2, operatorMultiplicationMatrix) { } TEST(TestMatrix2x2, operatorMultiplicationVector) { - etk::Matrix2 test1(1, 2, 3, 4); + etk::Matrix2x2 test1(1, 2, 3, 4); vec2 result = test1 * vec2(1,2); EXPECT_FLOAT_EQ(result.x(), 5.0); EXPECT_FLOAT_EQ(result.y(), 11.0); diff --git a/test/testMatrix3x3.cpp b/test/testMatrix3x3.cpp index 0259c0c..c7e2741 100644 --- a/test/testMatrix3x3.cpp +++ b/test/testMatrix3x3.cpp @@ -8,14 +8,14 @@ #include #include -#include +#include #include -#define NAME "etk::Matrix3" +#define NAME "etk::Matrix3x3" TEST(TestMatrix3x3, constructor) { // Test contructor value - etk::Matrix3 test1(99.0); + etk::Matrix3x3 test1(99.0); EXPECT_FLOAT_EQ(test1.m_mat[0], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[1], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[2], 99.0); @@ -25,7 +25,7 @@ TEST(TestMatrix3x3, constructor) { EXPECT_FLOAT_EQ(test1.m_mat[6], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[7], 99.0); EXPECT_FLOAT_EQ(test1.m_mat[8], 99.0); - etk::Matrix3 test2(11,22,33,44,55,66,77,88,99); + etk::Matrix3x3 test2(11,22,33,44,55,66,77,88,99); EXPECT_FLOAT_EQ(test2.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test2.m_mat[1], 22.0); EXPECT_FLOAT_EQ(test2.m_mat[2], 33.0); @@ -35,7 +35,7 @@ TEST(TestMatrix3x3, constructor) { EXPECT_FLOAT_EQ(test2.m_mat[6], 77.0); EXPECT_FLOAT_EQ(test2.m_mat[7], 88.0); EXPECT_FLOAT_EQ(test2.m_mat[8], 99.0); - etk::Matrix3 test3(test2); + etk::Matrix3x3 test3(test2); EXPECT_FLOAT_EQ(test3.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test3.m_mat[1], 22.0); EXPECT_FLOAT_EQ(test3.m_mat[2], 33.0); @@ -45,7 +45,7 @@ TEST(TestMatrix3x3, constructor) { EXPECT_FLOAT_EQ(test3.m_mat[6], 77.0); EXPECT_FLOAT_EQ(test3.m_mat[7], 88.0); EXPECT_FLOAT_EQ(test3.m_mat[8], 99.0); - etk::Matrix3 test4 = test1; + etk::Matrix3x3 test4 = test1; EXPECT_FLOAT_EQ(test4.m_mat[0], 99.0); EXPECT_FLOAT_EQ(test4.m_mat[1], 99.0); EXPECT_FLOAT_EQ(test4.m_mat[2], 99.0); @@ -68,9 +68,9 @@ TEST(TestMatrix3x3, constructor) { } TEST(TestMatrix3x3, equity) { - etk::Matrix3 test1(99,32,56,92,56,32,45,12,54); - etk::Matrix3 test2(11,22,33,44,55,66,77,88,99); - etk::Matrix3 test3(11,22,33,44,55,66,77,88,99); + etk::Matrix3x3 test1(99,32,56,92,56,32,45,12,54); + etk::Matrix3x3 test2(11,22,33,44,55,66,77,88,99); + etk::Matrix3x3 test3(11,22,33,44,55,66,77,88,99); EXPECT_EQ(test1 == test2, false); EXPECT_EQ(test1 != test2, true); EXPECT_EQ(test3 == test2, true); @@ -78,7 +78,7 @@ TEST(TestMatrix3x3, equity) { } TEST(TestMatrix3x3, set) { - etk::Matrix3 test; + etk::Matrix3x3 test; test.setValue(22, 54, 45, 985, 54, 87, 98, 6532, -8652); EXPECT_FLOAT_EQ(test.m_mat[0], 22.0); EXPECT_FLOAT_EQ(test.m_mat[1], 54.0); @@ -109,7 +109,7 @@ TEST(TestMatrix3x3, set) { EXPECT_FLOAT_EQ(test.m_mat[6], 0.0); EXPECT_FLOAT_EQ(test.m_mat[7], 0.0); EXPECT_FLOAT_EQ(test.m_mat[8], 1.0); - test = etk::Matrix3::zero(); + test = etk::Matrix3x3::zero(); EXPECT_FLOAT_EQ(test.m_mat[0], 0.0); EXPECT_FLOAT_EQ(test.m_mat[1], 0.0); EXPECT_FLOAT_EQ(test.m_mat[2], 0.0); @@ -119,7 +119,7 @@ TEST(TestMatrix3x3, set) { EXPECT_FLOAT_EQ(test.m_mat[6], 0.0); EXPECT_FLOAT_EQ(test.m_mat[7], 0.0); EXPECT_FLOAT_EQ(test.m_mat[8], 0.0); - test = etk::Matrix3::identity(); + test = etk::Matrix3x3::identity(); EXPECT_FLOAT_EQ(test.m_mat[0], 1.0); EXPECT_FLOAT_EQ(test.m_mat[1], 0.0); EXPECT_FLOAT_EQ(test.m_mat[2], 0.0); @@ -132,7 +132,7 @@ TEST(TestMatrix3x3, set) { } TEST(TestMatrix3x3, getRowColomn) { - etk::Matrix3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); + etk::Matrix3x3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); EXPECT_FLOAT_EQ(test.getColumn(0).x(), 11.0); EXPECT_FLOAT_EQ(test.getColumn(0).y(), 44.0); EXPECT_FLOAT_EQ(test.getColumn(0).z(), 77.0); @@ -160,8 +160,8 @@ TEST(TestMatrix3x3, getRowColomn) { } TEST(TestMatrix3x3, transpose) { - etk::Matrix3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); - etk::Matrix3 test2 = test.getTranspose(); + etk::Matrix3x3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); + etk::Matrix3x3 test2 = test.getTranspose(); EXPECT_FLOAT_EQ(test2.m_mat[0], 11.0); EXPECT_FLOAT_EQ(test2.m_mat[1], 44.0); EXPECT_FLOAT_EQ(test2.m_mat[2], 77.0); @@ -194,19 +194,19 @@ TEST(TestMatrix3x3, transpose) { } TEST(TestMatrix3x3, determinant) { - etk::Matrix3 test(11, -6, 6, 4, -5, 1, 8, -9, -6); + etk::Matrix3x3 test(11, -6, 6, 4, -5, 1, 8, -9, -6); EXPECT_FLOAT_EQ(test.determinant(), 261.0); - EXPECT_FLOAT_EQ(etk::Matrix3::identity().determinant(), 1.0); + EXPECT_FLOAT_EQ(etk::Matrix3x3::identity().determinant(), 1.0); } TEST(TestMatrix3x3, trace) { - etk::Matrix3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); + etk::Matrix3x3 test(11, 22, 33, 44, 55, 66, 77, 88, 99); EXPECT_FLOAT_EQ(test.getTrace(), 165.0); } TEST(TestMatrix3x3, inverse) { - etk::Matrix3 test(1, -4, 3, -6, 5, 6, 7, 8, 9); - etk::Matrix3 test2 = test.getInverse(); + etk::Matrix3x3 test(1, -4, 3, -6, 5, 6, 7, 8, 9); + etk::Matrix3x3 test2 = test.getInverse(); // check if original matrix is not inversed EXPECT_FLOAT_EQ(test.m_mat[0], 1.0); EXPECT_FLOAT_EQ(test.m_mat[1], -4.0); @@ -239,8 +239,8 @@ TEST(TestMatrix3x3, inverse) { } TEST(TestMatrix3x3, absolute) { - etk::Matrix3 test(-1, -2, -3, -4, -5, -6, -7, -8, -9); - etk::Matrix3 test2 = test.getAbsolute(); + etk::Matrix3x3 test(-1, -2, -3, -4, -5, -6, -7, -8, -9); + etk::Matrix3x3 test2 = test.getAbsolute(); // check if original matrix is not inversed EXPECT_FLOAT_EQ(test.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test.m_mat[1], -2.0); @@ -273,9 +273,9 @@ TEST(TestMatrix3x3, absolute) { } TEST(TestMatrix3x3, operatorAddition) { - etk::Matrix3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); - etk::Matrix3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); - etk::Matrix3 test3 = test1 + test2; + etk::Matrix3x3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); + etk::Matrix3x3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); + etk::Matrix3x3 test3 = test1 + test2; // check no change EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); @@ -317,9 +317,9 @@ TEST(TestMatrix3x3, operatorAddition) { } TEST(TestMatrix3x3, operatorSubstraction) { - etk::Matrix3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); - etk::Matrix3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); - etk::Matrix3 test3 = test1 - test2; + etk::Matrix3x3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); + etk::Matrix3x3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); + etk::Matrix3x3 test3 = test1 - test2; // check no change EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); @@ -361,8 +361,8 @@ TEST(TestMatrix3x3, operatorSubstraction) { } TEST(TestMatrix3x3, operatorNegation) { - etk::Matrix3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); - etk::Matrix3 test2 = -test1; + etk::Matrix3x3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); + etk::Matrix3x3 test2 = -test1; // check no change EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); @@ -385,9 +385,9 @@ TEST(TestMatrix3x3, operatorNegation) { } TEST(TestMatrix3x3, operatorMultiplicationMatrix) { - etk::Matrix3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); - etk::Matrix3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); - etk::Matrix3 test3 = test1 * test2; + etk::Matrix3x3 test1(-1, -2, -3, -4, -5, -6, -7, -8, -9); + etk::Matrix3x3 test2(1, 2, 3, 4, 5, 6, 7, 8, 9); + etk::Matrix3x3 test3 = test1 * test2; EXPECT_FLOAT_EQ(test1.m_mat[0], -1.0); EXPECT_FLOAT_EQ(test1.m_mat[1], -2.0); EXPECT_FLOAT_EQ(test1.m_mat[2], -3.0); @@ -428,7 +428,7 @@ TEST(TestMatrix3x3, operatorMultiplicationMatrix) { } TEST(TestMatrix3x3, operatorMultiplicationVector) { - etk::Matrix3 test1(1, 2, 3, 4, 5, 6, 7, 8, 9); + etk::Matrix3x3 test1(1, 2, 3, 4, 5, 6, 7, 8, 9); vec3 result = test1 * vec3(1,2,3); EXPECT_FLOAT_EQ(result.x(), 14.0); EXPECT_FLOAT_EQ(result.y(), 32.0); diff --git a/test/testQuaternion.cpp b/test/testQuaternion.cpp index 5b156cd..25a935e 100644 --- a/test/testQuaternion.cpp +++ b/test/testQuaternion.cpp @@ -16,7 +16,7 @@ TEST(TestQuaternion, constructor) { EXPECT_FLOAT_EQ(test0.y(), 2.0); EXPECT_FLOAT_EQ(test0.z(), 3.0); EXPECT_FLOAT_EQ(test0.w(), 4.0); - etk::Quaternion test1(4, etk::Vector3D(1,2,3)); + etk::Quaternion test1(4, vec3(1,2,3)); EXPECT_FLOAT_EQ(test1.x(), 1.0); EXPECT_FLOAT_EQ(test1.y(), 2.0); EXPECT_FLOAT_EQ(test1.z(), 3.0); @@ -53,7 +53,7 @@ TEST(TestQuaternion, constructorMatrix) { } TEST(TestQuaternion, constructorEuler) { - etk::Quaternion test0(etk::Vector3D(M_PI*0.5f, 0, 0)); + etk::Quaternion test0(vec3(M_PI*0.5f, 0, 0)); etk::Quaternion test01(std::sin(M_PI*0.25f), 0, 0, std::cos(M_PI*0.25f)); test01.normalize(); EXPECT_FLOAT_EQ(test0.x(), test01.x()); @@ -61,7 +61,7 @@ TEST(TestQuaternion, constructorEuler) { EXPECT_FLOAT_EQ(test0.z(), test01.z()); EXPECT_FLOAT_EQ(test0.w(), test01.w()); - etk::Quaternion test1(etk::Vector3D(0, M_PI*0.5f, 0)); + etk::Quaternion test1(vec3(0, M_PI*0.5f, 0)); etk::Quaternion test11(0, std::sin(M_PI*0.25f), 0, std::cos(M_PI*0.25f)); test11.normalize(); EXPECT_FLOAT_EQ(test1.x(), test11.x()); @@ -69,7 +69,7 @@ TEST(TestQuaternion, constructorEuler) { EXPECT_FLOAT_EQ(test1.z(), test11.z()); EXPECT_FLOAT_EQ(test1.w(), test11.w()); - etk::Quaternion test2(etk::Vector3D(0, 0, M_PI*0.5f)); + etk::Quaternion test2(vec3(0, 0, M_PI*0.5f)); etk::Quaternion test21(0, 0, std::sin(M_PI*0.25f), std::cos(M_PI*0.25f)); test21.normalize(); EXPECT_FLOAT_EQ(test2.x(), test21.x()); @@ -135,7 +135,7 @@ TEST(TestQuaternion, set) { TEST(TestQuaternion, getVector) { etk::Quaternion test1(5, 3, 8, 2); - etk::Vector3D test2 = test1.getVectorV(); + vec3 test2 = test1.getVectorV(); EXPECT_FLOAT_EQ(test2.x(), 5.0); EXPECT_FLOAT_EQ(test2.y(), 3.0); EXPECT_FLOAT_EQ(test2.z(), 8.0); diff --git a/test/testVector3_f.cpp b/test/testVector3_f.cpp index d0c928b..9ebbc0e 100644 --- a/test/testVector3_f.cpp +++ b/test/testVector3_f.cpp @@ -12,19 +12,19 @@ TEST(TestVector3D_f, constructor) { // Test contructor value - etk::Vector3D test0(0,0,0); + vec3 test0(0,0,0); EXPECT_FLOAT_EQ(test0.x(), 0.0); EXPECT_FLOAT_EQ(test0.y(), 0.0); EXPECT_FLOAT_EQ(test0.z(), 0.0); - etk::Vector3D vect1(4,5,8); + vec3 vect1(4,5,8); EXPECT_FLOAT_EQ(vect1.x(), 4.0); EXPECT_FLOAT_EQ(vect1.y(), 5.0); EXPECT_FLOAT_EQ(vect1.z(), 8.0); - etk::Vector3D vect2(vect1); + vec3 vect2(vect1); EXPECT_FLOAT_EQ(vect2.x(), 4.0); EXPECT_FLOAT_EQ(vect2.y(), 5.0); EXPECT_FLOAT_EQ(vect2.z(), 8.0); - etk::Vector3D vect3 = vect1; + vec3 vect3 = vect1; EXPECT_FLOAT_EQ(vect3.x(), 4.0); EXPECT_FLOAT_EQ(vect3.y(), 5.0); EXPECT_FLOAT_EQ(vect3.z(), 8.0); @@ -35,9 +35,9 @@ TEST(TestVector3D_f, constructor) { } TEST(TestVector3D_f, equity) { - etk::Vector3D test1(99,32,56); - etk::Vector3D test2(11,22,33); - etk::Vector3D test3(11,22,33); + vec3 test1(99,32,56); + vec3 test2(11,22,33); + vec3 test3(11,22,33); EXPECT_EQ(test1 == test2, false); EXPECT_EQ(test1 != test2, true); EXPECT_EQ(test3 == test2, true); @@ -46,7 +46,7 @@ TEST(TestVector3D_f, equity) { TEST(TestVector3D_f, set) { // Test contructor value - etk::Vector3D test1(0,0,0); + vec3 test1(0,0,0); EXPECT_FLOAT_EQ(test1.x(), 0.0); EXPECT_FLOAT_EQ(test1.y(), 0.0); EXPECT_FLOAT_EQ(test1.z(), 0.0); @@ -58,7 +58,7 @@ TEST(TestVector3D_f, set) { TEST(TestVector3D_f, setSetZero) { // Test contructor value - etk::Vector3D test1(4,5,6); + vec3 test1(4,5,6); EXPECT_FLOAT_EQ(test1.x(), 4.0); EXPECT_FLOAT_EQ(test1.y(), 5.0); EXPECT_FLOAT_EQ(test1.z(), 6.0); @@ -71,7 +71,7 @@ TEST(TestVector3D_f, setSetZero) { TEST(TestVector3D_f, length) { // Test contructor value - etk::Vector3D test1(0,0,0); + vec3 test1(0,0,0); EXPECT_FLOAT_EQ(test1.length(), 0.0); EXPECT_FLOAT_EQ(test1.length2(), 0.0); test1.setValue(2,0,0); @@ -85,8 +85,8 @@ TEST(TestVector3D_f, length) { } TEST(TestVector3D_f, normalize) { - etk::Vector3D test1(11,22,33); - etk::Vector3D test2 = test1.normalized(); + vec3 test1(11,22,33); + vec3 test2 = test1.normalized(); EXPECT_FLOAT_EQ(test1.x(), 11.0); EXPECT_FLOAT_EQ(test1.y(), 22.0); EXPECT_FLOAT_EQ(test1.z(), 33.0); @@ -100,8 +100,8 @@ TEST(TestVector3D_f, normalize) { } TEST(TestVector3D_f, dot) { - etk::Vector3D test1(11,0,0); - etk::Vector3D test2(0,88,66); + vec3 test1(11,0,0); + vec3 test2(0,88,66); EXPECT_FLOAT_EQ(test1.dot(test1), 121.0); EXPECT_FLOAT_EQ(test1.dot(test2), 0.0); test1.setValue(2,3,5); @@ -110,8 +110,8 @@ TEST(TestVector3D_f, dot) { } TEST(TestVector3D_f, cross) { - etk::Vector3D test1(0,0,0); - etk::Vector3D test2(-55,88,66); + vec3 test1(0,0,0); + vec3 test2(-55,88,66); EXPECT_EQ(test1.cross(test1), vec3(0,0,0)); EXPECT_EQ(test2.cross(test2), vec3(0,0,0)); test1.setValue(1,0,0);