_Matrix4.h

Go to the documentation of this file.

#ifndef __VECMATH_MATRIX4_HPP
#define __VECMATH_MATRIX4_HPP

#ifndef __LANG_MATH_HPP
#include <vecmath/Math.h>
#endif

template <class Type> class VECMATH_EXPORT _Matrix4;

#ifndef __VECMATH_MATRIX3_HPP
#include <vecmath/_Matrix3.h>
#endif

//template <class Type> ostream& operator <<(ostream& os, const _Matrix4<Type>& m);
//template <class Type> ostream& operator <<(ostream& os, const _Matrix4<Type>* m);

//#define DEBUGMATRIX4(d) d
#define DEBUGMATRIX4(d)

template <class Type> class VECMATH_EXPORT _Matrix4 {
public:
    // order is important! - used for casting
//      Type    m00, m01, m02, m03,
//          m10, m11, m12, m13,
//          m20, m21, m22, m23,
//          m30, m31, m32, m33;

    // order is important! - stored as OpenGL transponed matrix
    Type m00, m10, m20, m30,
        m01, m11, m21, m31,
        m02, m12, m22, m32,
        m03, m13, m23, m33;

    _Matrix4<Type>() {}

    _Matrix4<Type>(Type s) {
        setScaleTranslate(s);
        DEBUGMATRIX4(cout << "_Matrix4 constructor scale " << endl << *this << endl);
    }

    explicit _Matrix4<Type>(Type m00      , Type m01      , Type m02 = 0.0, Type m03 = 0.0,
                            Type m10 = 0.0, Type m11 = 0.0, Type m12 = 0.0, Type m13 = 0.0,
                            Type m20 = 0.0, Type m21 = 0.0, Type m22 = 0.0, Type m23 = 0.0,
                            Type m30 = 0.0, Type m31 = 0.0, Type m32 = 0.0, Type m33 = 0.0) {
        set(m00, m01, m02, m03,
            m10, m11, m12, m13,
            m20, m21, m22, m23,
            m30, m31, m32, m33);
        DEBUGMATRIX4(cout << "_Matrix4 constructor R16 " << endl << *this << endl);
    }

    _Matrix4<Type>(const _Matrix4<double>& m) {
        set(m);
        DEBUGMATRIX4(cout << "_Matrix4 constructor double& " << endl << *this << endl);
    }

    _Matrix4<Type>(const _Matrix4<float>& m) {
        set(m);
        DEBUGMATRIX4(cout << "_Matrix4 constructor float& " << endl << *this << endl);
    }

    _Matrix4<Type>(const Type v[16]) {
        set(v);
        DEBUGMATRIX4(cout << "_Matrix4 constructor v[16] " << endl << *this << endl);
    }


    void add(Type d) {
        add(d, *this);
    }

    void add(Type d, const _Matrix4<Type>& m);

    void add(const _Matrix4<Type>& m) {
        add(*this, m);
    }

    void add(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);

    void adjoint() {
        adjoint(*this);
    }

    void adjoint(const _Matrix4<Type>& m);

    // do it more effiently
    // usualy
    Type determinant() const {
        return m00 * _Matrix3<Type>::determinant3x3(m11, m12, m13,
                                                    m21, m22, m23,
                                                    m31, m32, m33) -
            m01 * _Matrix3<Type>::determinant3x3(m10, m12, m13,
                                                 m20, m22, m23,
                                                 m30, m32, m33) +
            m02 * _Matrix3<Type>::determinant3x3(m10, m11, m13,
                                                 m20, m21, m23,
                                                 m30, m31, m33) -
            m03 * _Matrix3<Type>::determinant3x3(m10, m11, m12,
                                                 m20, m21, m22,
                                                 m30, m31, m32);
//  
//          ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32)
//           - m13 * m22 * m31 - m11 * m23 * m32 - m12 * m21 * m33)
//          - m01 * ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32)
//                   - m13 * m22 * m30 - m10 * m23 * m32 - m12 * m20 * m33)
//          + m02 * ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31)
//                   - m13 * m21 * m30 - m10 * m23 * m31 - m11 * m20 * m33)
//          - m03 * ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31)
//                   - m12 * m21 * m30 - m10 * m22 * m31 - m11 * m20 * m32);
    }

    Type determinant3x3() const {
        return _Matrix3<Type>::determinant3x3(m00, m01, m02,
                                              m10, m11, m12,
                                              m20, m21, m22);
    }

    bool epsilonEquals(const _Matrix4<Type>& m, Type epsilon) const;

    bool equals(const _Matrix4<Type>& m) const {
        DEBUGMATRIX4(cout << "_Matrix4 equals " << endl << *this << " == " << endl << m << endl);
        return (m00 == m.m00 && m01 == m.m01 && m02 == m.m02 && m03 == m.m03 &&
                m10 == m.m10 && m11 == m.m11 && m12 == m.m12 && m13 == m.m13 &&
                m20 == m.m20 && m21 == m.m21 && m22 == m.m22 && m23 == m.m23 &&
                m30 == m.m30 && m31 == m.m31 && m32 == m.m32 && m33 == m.m33);
    }

    void get(double m[16]) const {
        m[0]  = m00,  m[1] = m01,  m[2] = m02,  m[3] = m03;
        m[4]  = m10,  m[5] = m11,  m[6] = m12,  m[7] = m13;
        m[8]  = m20,  m[9] = m21, m[10] = m22, m[11] = m23;
        m[12] = m30, m[13] = m31, m[14] = m32, m[15] = m33;
    }

    void get(float m[16]) const {
        m[0]  = m00,  m[1] = m01,  m[2] = m02,  m[3] = m03;
        m[4]  = m10,  m[5] = m11,  m[6] = m12,  m[7] = m13;
        m[8]  = m20,  m[9] = m21, m[10] = m22, m[11] = m23;
        m[12] = m30, m[13] = m31, m[14] = m32, m[15] = m33;
    }

    void get(_Matrix3<double>& m) const;
    Type get(_Matrix3<double>& m, _Vector3<double>& v) const;
    void get(_Matrix3<double>& m, _Vector3<double>& v, _Vector3<double>& s) const;
    void get(_Matrix3<float>& m) const;
    Type get(_Matrix3<float>& m, _Vector3<float>& v) const;
    void get(_Matrix3<float>& m, _Vector3<float>& v, _Vector3<float>& s) const;
    void get(_Quat4<double>& q) const;
    void get(_Quat4<float>& q) const;

    void get(_Vector3<double>& v) const {
        v.set(m03, m13, m23);
    }

    void get(_Vector3<float>& v) const {
        v.set(m03, m13, m23);
    }

    void get3x3(double m[9]) const {
        m[0] = m00, m[1] = m01, m[2] = m02;
        m[3] = m10, m[4] = m11, m[5] = m12;
        m[6] = m20, m[7] = m21, m[8] = m22;
    }

    void getColumn(int column, _Vector4<Type>& v) const;
    void getColumn(int column, Type c[]) const;
    Type getElement(int row, int column) const;

    void getEuler(_Vector3<Type>) const;

    void getRotationScale(_Matrix3<double>& m3d) const;
    void getRotationScale(_Matrix3<float>& m3f) const;
    void getRow(int row, _Vector4<Type>& v) const;
    void getRow(int row, Type r[]) const;

    double getScale() const;
    // making it public (private in J3D)
    void getScaleRotate(double scale[3], double rot[9]) const;

    void invert() {
        invert(*this);
    }

    void invert(const _Matrix4<Type>& m);

    void mul(Type d) {
        mul(d, *this);
    }

    void mul(Type d, const _Matrix4<Type>& m);
    void mul(const _Matrix4<Type>& m);
    void mul(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);
    void mulTransposeBoth(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);
    void mulTransposeLeft(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);
    void mulTransposeRight(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);

    void negate() {
        negate(*this);
    }

    void negate(const _Matrix4<Type>& m) {
        set(-m.m00, -m.m01, -m.m02, -m.m03,
            -m.m10, -m.m11, -m.m12, -m.m13,
            -m.m20, -m.m21, -m.m22, -m.m23,
            -m.m30, -m.m31, -m.m32, -m.m33);
    }

    void scale(Type s) {
        m00 *= s, m01 *= s, m02 *= s, m03 *= s;
        m10 *= s, m11 *= s, m12 *= s, m13 *= s;
        m20 *= s, m21 *= s, m22 *= s, m23 *= s;
        m30 *= s, m31 *= s, m32 *= s, m33 *= s;
    }

    void scaleAdd(Type s, const _Matrix4<Type>& m) {
        scaleAdd(s, m, *this);
    }

    void scaleAdd(Type s, const _Matrix4<Type>& m, const _Matrix4& m1) {
        set(m.m00 * s + m1.m00, m.m01 * s + m1.m01, m.m02 * s + m1.m02, m.m03 * s + m1.m03,
            m.m10 * s + m1.m10, m.m11 * s + m1.m11, m.m12 * s + m1.m12, m.m13 * s + m1.m13,
            m.m20 * s + m1.m20, m.m21 * s + m1.m21, m.m22 * s + m1.m22, m.m23 * s + m1.m23,
            m.m30 * s + m1.m30, m.m31 * s + m1.m31, m.m32 * s + m1.m32, m.m33 * s + m1.m33);
    }

    void set3x3(Type mm00 = 0, Type mm01 = 0, Type mm02 = 0,
                Type mm10 = 0, Type mm11 = 0, Type mm12 = 0,
                Type mm20 = 0, Type mm21 = 0, Type mm22 = 0) {
        m00 = mm00, m01 = mm01, m02 = mm02,
        m10 = mm10, m11 = mm11, m12 = mm12,
        m20 = mm20, m21 = mm21, m22 = mm22;
    }

    void set(Type mm00      , Type mm01      , Type mm02 = 0.0, Type mm03 = 0.0,
             Type mm10 = 0.0, Type mm11 = 0.0, Type mm12 = 0.0, Type mm13 = 0.0,
             Type mm20 = 0.0, Type mm21 = 0.0, Type mm22 = 0.0, Type mm23 = 0.0,
             Type mm30 = 0.0, Type mm31 = 0.0, Type mm32 = 0.0, Type mm33 = 0.0) {
        m00 = mm00, m01 = mm01, m02 = mm02, m03 = mm03;
        m10 = mm10, m11 = mm11, m12 = mm12, m13 = mm13;
        m20 = mm20, m21 = mm21, m22 = mm22, m23 = mm23;
        m30 = mm30, m31 = mm31, m32 = mm32, m33 = mm33;
    }

    void set(const _Matrix4<double>& m) {
        set(m.m00, m.m01, m.m02, m.m03,
            m.m10, m.m11, m.m12, m.m13,
            m.m20, m.m21, m.m22, m.m23,
            m.m30, m.m31, m.m32, m.m33);
    }

    void set(const _Matrix4<float>& m) {
        set(m.m00, m.m01, m.m02, m.m03,
            m.m10, m.m11, m.m12, m.m13,
            m.m20, m.m21, m.m22, m.m23,
            m.m30, m.m31, m.m32, m.m33);
    }

    void set(const _Matrix3<double>& m) {
        set(m.m00, m.m01, m.m02, 0.0,
            m.m10, m.m11, m.m12, 0.0,
            m.m20, m.m21, m.m22, 0.0,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Matrix3<float>& m) {
        set(m.m00, m.m01, m.m02, 0.0,
            m.m10, m.m11, m.m12, 0.0,
            m.m20, m.m21, m.m22, 0.0,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Matrix3<double>& m, const _Vector3<double>& v, double s) {
        set(m.m00 * s, m.m01 * s, m.m02 * s, v.x,
            m.m10 * s, m.m11 * s, m.m12 * s, v.y,
            m.m20 * s, m.m21 * s, m.m22 * s, v.z,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Matrix3<float>& m, const _Vector3<double>& v, double s) {
        set(m.m00 * s, m.m01 * s, m.m02 * s, v.x,
            m.m10 * s, m.m11 * s, m.m12 * s, v.y,
            m.m20 * s, m.m21 * s, m.m22 * s, v.z,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Matrix3<double>& m, const _Vector3<double>& v, const _Vector3<double>& s) {
        set(m.m00 * s.x, m.m01 * s.y, m.m02 * s.z, v.x,
            m.m10 * s.x, m.m11 * s.y, m.m12 * s.z, v.y,
            m.m20 * s.x, m.m21 * s.y, m.m22 * s.z, v.z,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Matrix3<float>& m, const _Vector3<float>& v, const _Vector3<float>& s) {
        set(m.m00 * s.x, m.m01 * s.y, m.m02 * s.z, v.x,
            m.m10 * s.x, m.m11 * s.y, m.m12 * s.z, v.y,
            m.m20 * s.x, m.m21 * s.y, m.m22 * s.z, v.z,
            0.0, 0.0, 0.0, 1.0);
    }

    void set(const _Vector3<double>& v) {
        setIdentity();
        setTranslation(v);
    }

    void set(const _Vector3<float>& v) {
        setIdentity();
        setTranslation(v);
    }

    void set(const _Vector3<double>& v, double s) {
        setScaleTranslate(s, v.x, v.y, v.z);
        setTranslation(v);
    }

    void set(const _Vector3<float>& v, double s) {
        setScaleTranslate(s, v.x, v.y, v.z);
        setTranslation(v);
    }

    void set(const double at[16]) {
        set(at[0],   at[1],  at[2],  at[3],
            at[4],   at[5],  at[6],  at[7],
            at[8],   at[9], at[10], at[11],
            at[12], at[13], at[14], at[15]);
    }

    void set(const float at[16]) {
        set(at[0],   at[1],  at[2],  at[3],
            at[4],   at[5],  at[6],  at[7],
            at[8],   at[9], at[10], at[11],
            at[12], at[13], at[14], at[15]);
    }

    void setTranspose(const Type at[16]) {
        set(at[0], at[4],  at[8], at[12],
            at[1], at[5],  at[9], at[13],
            at[2], at[6], at[10], at[14],
            at[3], at[7], at[11], at[15]);
    }

    void setColumn(int column, Type x, Type y, Type z, Type w);
    void setElement(int row, int column, Type value);

    void setIdentity() {
        setScaleTranslate(1.0);
    }

    void setIdentity3x3() {
        set3x3(1.0, 0.0, 0.0,
               0.0, 1.0, 0.0,
               0.0, 0.0, 1.0);
    }

//    void setRotation(const _AxisAngle4<double>& a);
//    void setRotation(const _AxisAngle4<float>& a);
    void setRotation(const _Matrix3<double>& m);
    void setRotation(const _Matrix3<float>& m);
    void setRotation(const _Quat4<double>& q);
    void setRotation(const _Quat4<float>& q);

    void setRotationScale(const _Matrix3<double>& m) {
        set3x3(m.m00, m.m01, m.m02,
               m.m10, m.m11, m.m12,
               m.m20, m.m21, m.m22);
    }

    void setRotationScale(const _Matrix3<float>& m) {
        set3x3(m.m00, m.m01, m.m02,
               m.m10, m.m11, m.m12,
               m.m20, m.m21, m.m22);
    }


    void setRow(int row, Type x, Type y, Type z, Type w);

    //extension
    void setScaleTranslate(Type scale, Type x = 0.0, Type y = 0.0, Type z = 0.0) {
        set(scale, 0.0, 0.0, x,
            0.0, scale, 0.0, y,
            0.0, 0.0, scale, z,
            0.0, 0.0, 0.0,   1.0);
    }

    void setTranslation(const _Vector3<Type>& trans) {
        m03 = trans.x;
        m13 = trans.y;
        m23 = trans.z;
    }

    void setZero() {
        setScaleTranslate(0.0);
        m33 = 0.0;
    }

    void sub(const _Matrix4<Type>& m) {
        sub(*this, m);
    }

    void sub(const _Matrix4<Type>& m1, const _Matrix4<Type>& m2);
    void rotX(double angle);
    void rotY(double angle);
    void rotZ(double angle);
    void rotationGL(double angle, const _Vector3<Type>& axis);
    //void toString();

    void transform(_Tuple3<double>& t) const {
        transform(t, t);
    }
    void transform(const _Tuple3<double>& t, _Tuple3<double>& t1) const;

    void transform(_Tuple3<float>& t) const {
        transform(t, t);
    }
    void transform(const _Tuple3<float>& t, _Tuple3<float>& t1) const;

    void transform(_Tuple4<double>& t) const {
        transform(t, t);
    }
    void transform(const _Tuple4<double>& t, _Tuple4<double>& t1) const;

    void transform(_Tuple4<float>& t) const {
        transform(t, t);
    }
    void transform(const _Tuple4<float>& t, _Tuple4<float>& t1) const;

    void transpose();
    void transpose(const _Matrix4<Type>& m);

    _Matrix4<Type>& operator +=(const _Matrix4<Type>& t) {
        add(t);
        DEBUGTUPLE3(cout << "_Matrix4 operator+= _Matrix4 " << *this  << endl);
        return *this;
    }

    _Matrix4<Type>& operator -=(const _Matrix4<Type>& t) {
        sub(t);
        DEBUGTUPLE3(cout << "_Matrix4 operator+= _Matrix4 " << *this  << endl);
        return *this;
    }

    // can be used for casting to OpenGL transformation matrix
    operator const Type * () const {
        return &m00;
    }

    // quite hard to tune this part  - now it works
    Type& operator ()(int row, int column) const {
//      cerr  << &m00 << "   -  " << &((&m00)[column * 4 + row]) << "  r:  " << row << "  c: " << column << endl;
//      cerr  << (operator const Type *() + column * 4 + row) << endl;
        return (Type &)(*((operator const Type *()) + column * 4 + row));
    }

//    friend ostream & operator << <>(ostream &, const _Matrix4<Type>& );
//    friend ostream & operator << <>(ostream &, const _Matrix4<Type>* );

private:
    static bool luDecomposition(Type ad[], int ai[]);
    static void luBacksubstitution(Type ad[], int ai[], Type ad1[]);

    void setRotationScale3x3(double mm00, double mm01, double mm02,
                             double mm10, double mm11, double mm12,
                             double mm20, double mm21, double mm22) {
        double tmp_scale[3];
        double tmp_rot[9];
        getScaleRotate(tmp_scale, tmp_rot);
        set3x3(mm00 * tmp_scale[0], mm01 * tmp_scale[1], mm02 * tmp_scale[2],
               mm10 * tmp_scale[0], mm11 * tmp_scale[1], mm12 * tmp_scale[2],
               mm20 * tmp_scale[0], mm21 * tmp_scale[1], mm22 * tmp_scale[2]);
    }
};

#endif

---