template <typename T>
class CMatrix4
{
public:
    CMatrix4 ()
    {
        _BuildMatrix ();
        _FlushMatrix ();

        m_Data [0][0] = T (1);
        m_Data [1][1] = T (1);
        m_Data [2][2] = T (1);
        m_Data [3][3] = T (1);
    }

    CMatrix4 (
        T m11, T m12, T m13, T m14,
        T m21, T m22, T m23, T m24,
        T m31, T m32, T m33, T m34,
        T m41, T m42, T m43, T m44)
    {
        _BuildMatrix ();

        m_Data [0][0] = m11; m_Data [0][1] = m12; m_Data [0][2] = m13; m_Data [0][3] = m14;
        m_Data [1][0] = m21; m_Data [1][1] = m22; m_Data [1][2] = m23; m_Data [1][3] = m24;
        m_Data [2][0] = m31; m_Data [2][1] = m32; m_Data [2][2] = m33; m_Data [2][3] = m34;
        m_Data [3][0] = m41; m_Data [3][1] = m42; m_Data [3][2] = m43; m_Data [3][3] = m44;
    }

    CMatrix4 (const CMatrix4 & m)
    {
        _BuildMatrix ();

        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                m_Data [i][ii] = m [i][ii];
            }
        }
    }

    ~CMatrix4 ()
    {
        _FreeMatrix ();
    }

    CMatrix4 operator* (const CMatrix4 & o)
    {
        CMatrix4 result;

        //  Loop through the result indices
        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                //  Then we get to the math of it
                result [i][ii] = 0;
                for (int a = 0; a < 4; a++)
                {
                    result [i][ii] += m_Data [i][a] * o [a][ii];
                }
            }
        }

        return result;
    }

    CMatrix4 operator* (const T& s) const
    {
        CMatrix4 result (*this);

        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                result [i][ii] *= s;
            }
        }

        return result;
    }

    CMatrix4 & operator *= (const T& s)
    {
        //  TODO: FASTER
        (*this) = (*this) * s;
        return *this;
    }

    CMatrix4 operator- ()
    {
        CMatrix4 result (*this);
        result *= T (-1);
        return result;
    }

    CMatrix4 & operator= (const CMatrix4 & o)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                m_Data [i][ii] = o [i][ii];
            }
        }

        return *this;
    }

    T * operator[] (ore::t_UInteger i)
    {
        return m_Data [i];
    }

    const T * operator[] (ore::t_UInteger i) const
    {
        return m_Data [i];
    }

    void Transpose ()
    {
        CMatrix4 original (*this);

        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                m_Data [i][ii] = original [ii][i];
            }
        }
    }

    void Translate (const T& x, const T& y, const T& z)
    {
        T w = T (1);

        //  Components of the transformed vector
        T vec1, vec2, vec3;

        //  Transform the translation vector
        vec1 = x*m_Data[0][0] + y*m_Data[1][0] + z*m_Data[2][0] + w*m_Data[3][0];
        vec2 = x*m_Data[0][1] + y*m_Data[1][1] + z*m_Data[2][1] + w*m_Data[3][1];
        vec3 = x*m_Data[0][2] + y*m_Data[1][2] + z*m_Data[2][2] + w*m_Data[3][2];

        m_Data [3][0] += vec1;
        m_Data [3][1] += vec2;
        m_Data [3][2] += vec3;
    }

    void RotateX (float radians)
    {
        (*this) = (*this) * CMatrix4 (
            1,  0,              0,              0,
            0,  cos (radians),  sin (radians),  0,
            0, -sin (radians),  cos (radians),  0,
            0,  0,              0,              1
            );
    }

    void RotateY (float radians)
    {
        (*this) = (*this) * CMatrix4 (
            cos (radians),  0,  -sin (radians), 0,
            0,      1,  0,      0,
            sin (radians),  0,  cos (radians),  0,
            0,      0,  0,      1
            );
    }

    void RotateZ (float radians)
    {
        (*this) = (*this) * CMatrix4 (
            cos (radians),  sin (radians),  0,  0,
            -sin (radians), cos (radians),  0,  0,
            0,      0,      1,  0,
            0,      0,      0,  1
            );
    }

    void Rotate (float x, float y, float z)
    {
        RotateX (x);
        RotateY (y);
        RotateZ (z);
    }

    void Scale (float x, float y, float z)
    {
        (*this) = (*this) * CMatrix4 (
            x,  0,  0,  0,
            0,  y,  0,  0,
            0,  0,  z,  0,
            0,  0,  0,  1
            );
    }

    void PrintContents ()
    {
        ore::Diagnostics::Message (true)
            .Append ("4x4 Matrix Contents:\n")
            .Append ("{ ").Append (m_Data[0][0]).Append (", ").Append (m_Data [0][1]).Append (", ").Append (m_Data [0][2]).Append (", ").Append (m_Data [0][3]).Append ("}\n")
            .Append ("{ ").Append (m_Data[1][0]).Append (", ").Append (m_Data [1][1]).Append (", ").Append (m_Data [1][2]).Append (", ").Append (m_Data [1][3]).Append ("}\n")
            .Append ("{ ").Append (m_Data[2][0]).Append (", ").Append (m_Data [2][1]).Append (", ").Append (m_Data [2][2]).Append (", ").Append (m_Data [2][3]).Append ("}\n")
            .Append ("{ ").Append (m_Data[3][0]).Append (", ").Append (m_Data [3][1]).Append (", ").Append (m_Data [3][2]).Append (", ").Append (m_Data [3][3]).Append ("}\n")
            .Display ();
    }



private:
    T ** m_Data;

    void _BuildMatrix ()
    {
        m_Data = new T* [4];
        for (int i = 0; i < 4; i++)
        {
            m_Data [i] = new T [4];
        }
    }

    void _FreeMatrix ()
    {
        for (int i = 0; i < 4; i++)
        {
            delete [] m_Data [i];
        }

        delete [] m_Data;
    }

    //  NULLs the matrix
    void _FlushMatrix ()
    {
        for (int i = 0; i < 4; i++)
        {
            for (int ii = 0; ii < 4; ii++)
            {
                m_Data [i][ii] = NULL;
            }
        }
    }
};