Matrix4.h

Go to the documentation of this file.

 
#pragma once
 
 
 
#define _USE_MATH_DEFINES  // Enable non-standard math defines (MSVC)
#include <math.h>
 
 
 
 
 
template <typename T>
// tolua_begin
class Matrix4
{
 
    TOLUA_TEMPLATE_BIND((T, float, double))
 
    // tolua_end
 
public:
 
    T cell[16];
 
    // tolua_begin
 
    inline Matrix4(void)
    {
        Identity();
    }
 
    inline Matrix4(const Matrix4 & a_Rhs)
    {
        *this = a_Rhs;
    }
 
    // tolua_end
 
    inline Matrix4 & operator = (const Matrix4 & a_Rhs)
    {
        for (unsigned int i = 0; i < 16; ++i)
        {
            cell[i] = a_Rhs.cell[i];
        }
        return *this;
    }
 
    // tolua_begin
 
    inline T & operator [] (int a_N)
    {
        ASSERT(a_N < 16);
        return cell[a_N];
    }
 
    inline void Identity()
    {
        cell[1]  = cell[2]  = cell[3]  = cell[4]  = 0;
        cell[6]  = cell[7]  = cell[8]  = cell[9]  = 0;
        cell[11] = cell[12] = cell[13] = cell[14] = 0;
 
        cell[0] = cell[5] = cell[10] = cell[15] = 1;
    }
 
    inline void Init(const Vector3<T> & a_Pos, T a_RX, T a_RY, T a_RZ)
    {
        Matrix4<T> t;
        t.RotateX(a_RZ);
        RotateY(a_RY);
        Concatenate(t);
        t.RotateZ(a_RX);
        Concatenate(t);
        Translate(a_Pos);
    }
 
    inline void RotateX(T a_RX)
    {
        T sx = static_cast<T>(sin(a_RX * M_PI / 180));
        T cx = static_cast<T>(cos(a_RX * M_PI / 180));
 
        Identity();
 
        cell[5] = cx;  cell[6]  = sx;
        cell[9] = -sx; cell[10] = cx;
    }
 
    inline void RotateY(T a_RY)
    {
        T sy = static_cast<T>(sin(a_RY * M_PI / 180));
        T cy = static_cast<T>(cos(a_RY * M_PI / 180));
 
        Identity();
 
        cell[0] = cy; cell[2] = -sy;
        cell[8] = sy; cell[10] = cy;
    }
 
    inline void RotateZ(T a_RZ)
    {
        T sz = static_cast<T>(sin(a_RZ * M_PI / 180));
        T cz = static_cast<T>(cos(a_RZ * M_PI / 180));
 
        Identity();
 
        cell[0] = cz;  cell[1] = sz;
        cell[4] = -sz; cell[5] = cz;
    }
 
    inline void Translate(const Vector3<T> & a_Pos)
    {
        cell[3]  += a_Pos.x;
        cell[7]  += a_Pos.y;
        cell[11] += a_Pos.z;
    }
 
    inline void SetTranslation(const Vector3<T> & a_Pos)
    {
        cell[3]  = a_Pos.x;
        cell[7]  = a_Pos.y;
        cell[11] = a_Pos.z;
    }
 
    inline void Concatenate(const Matrix4 & m2)
    {
        Matrix4 res;
 
        for (unsigned int c = 0; c < 4; ++c)
        {
            for (unsigned int r = 0; r < 4; ++r)
            {
                res.cell[r * 4 + c] = (
                    cell[r * 4 + 0] * m2.cell[c + 0] +
                    cell[r * 4 + 1] * m2.cell[c + 4] +
                    cell[r * 4 + 2] * m2.cell[c + 8] +
                    cell[r * 4 + 3] * m2.cell[c + 12]
                );
            }
        }
 
        *this = res;
    }
 
    inline Vector3<T> Transform(const Vector3<T> & v) const
    {
        T x  = cell[0] * v.x + cell[1] * v.y + cell[2]  * v.z + cell[3];
        T y  = cell[4] * v.x + cell[5] * v.y + cell[6]  * v.z + cell[7];
        T z  = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
 
        return Vector3<T>(x, y, z);
    }
 
    inline void Invert(void)
    {
        Matrix4 t;
 
        T tx = -cell[3];
        T ty = -cell[7];
        T tz = -cell[11];
 
        for (unsigned int h = 0; h < 3; ++h)
        {
            for (unsigned int v = 0; v < 3; ++v)
            {
                t.cell[h + v * 4] = cell[v + h * 4];
            }
        }
 
        for (unsigned int i = 0; i < 11; ++i)
        {
            cell[i] = t.cell[i];
        }
 
        cell[3]  = tx * cell[0] + ty * cell[1] + tz * cell[2];
        cell[7]  = tx * cell[4] + ty * cell[5] + tz * cell[6];
        cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
    }
 
    inline Vector3<T> GetXColumn(void) const
    {
        return Vector3<T>(cell[0], cell[1], cell[2]);
    }
 
    inline Vector3<T> GetYColumn(void) const
    {
        return Vector3<T>(cell[4], cell[5], cell[6]);
    }
 
    inline Vector3<T> GetZColumn(void) const
    {
        return Vector3<T>(cell[8], cell[9], cell[10]);
    }
 
    inline void SetXColumn(const Vector3<T> & a_X)
    {
        cell[0] = a_X.x;
        cell[1] = a_X.y;
        cell[2] = a_X.z;
    }
 
    inline void SetYColumn(const Vector3<T> & a_Y)
    {
        cell[4] = a_Y.x;
        cell[5] = a_Y.y;
        cell[6] = a_Y.z;
    }
 
    inline void SetZColumn(const Vector3<T> & a_Z)
    {
        cell[8]  = a_Z.x;
        cell[9]  = a_Z.y;
        cell[10] = a_Z.z;
    }
};
// tolua_end
 
 
 
 
// tolua_begin
typedef Matrix4<double> Matrix4d;
typedef Matrix4<float>  Matrix4f;
// tolua_end