Matrix.h

Go to the documentation of this file.

#ifndef _MATRIX_H_
#define _MATRIX_H_

#include "Math.h"
#include "Vector.h"
#include <string.h>

class Mat4 {
        public:
                Mat4();
                Mat4(float val);
                Mat4(float mat[]);

                void loadIdentity();

                // -- used with MilkShape --
                inline void set(const float *matrix);
                void postMultiply(const Mat4 &mat);
                void setTranslation(const float *translation);
                void setInverseTranslation(const float *translation);
                void setRotationRadians(const float *angles);
                inline void translateVect(float *pVect) const;
                inline void rotateVect(float *pVect) const;
                inline void inverseTranslateVect(float *pVect) const;
                inline void inverseRotateVect(float *pVect) const;
                const float *getMatrix() const { return m; }
                // -------------------------

                void loadRotateX(const float angle);
                void loadRotateY(const float angle);
                void loadRotateZ(const float angle);
                void loadRotateXY(const float angleX, const float angleY);
                void loadRotateZXY(const float angleX, const float angleY, const float angleZ);
                void loadRotate(const Vec3 &v, const float angle);

                void loadProjectionMatrix(float fov, float aspect, float zNear, float zFar);

                void translate(const Vec3 &v);
                void setTranslate(const Vec3 &v);
                Vec3 translateVec(const Vec3 &v);
                void scale(const float sx, const float sy, const float sz);

                void rotateX(const float angle);
                void rotateY(const float angle);
                void rotateZ(const float angle);
                void rotateXY(const float angleX, const float angleY);
                void rotateZXY(const float angleX, const float angleY, const float angleZ);
                void rotate(const Vec3 &v, const float angle);
                Vec3 rotateVec(const Vec3 &v);

                void transpose();

                operator float *() { return m; }
                const float &operator () (const int row, const int column) const { return m[row+(column<<2)]; }
                const float &operator [] (const int index) const { return m[index]; }

                void operator += (const Mat4 &v);
                void operator -= (const Mat4 &v);
                void operator *= (const Mat4 &v);

                void operator += (const float s);
                void operator -= (const float s);
                void operator *= (const float s);
                void operator /= (const float s);

                Mat4 operator + (const Mat4 &v);
                Mat4 operator + (const float s);
                Mat4 operator - ();
                Mat4 operator - (const Mat4 &v);
                Mat4 operator - (const float s);
                Mat4 operator * (const Mat4 &v);
                Vec3 operator * (const Vec3 &v);
                Vec4 operator * (const Vec4 &v);
                Mat4 operator * (const float s);
                Mat4 operator / (const float s);
                Mat4 operator ! ();

        protected:
                float m[16];
};


void Mat4::set(const float *matrix) {
        memcpy(m, matrix, sizeof(float)*16);
}

void Mat4::rotateVect(float *pVect) const {
        float vec[3];

        vec[0] = pVect[0]*m[0]+pVect[1]*m[4]+pVect[2]*m[8];
        vec[1] = pVect[0]*m[1]+pVect[1]*m[5]+pVect[2]*m[9];
        vec[2] = pVect[0]*m[2]+pVect[1]*m[6]+pVect[2]*m[10];

        memcpy( pVect, vec, sizeof( float )*3 );
}

void Mat4::inverseRotateVect(float *pVect) const {
        float vec[3];

        vec[0] = pVect[0]*m[0]+pVect[1]*m[1]+pVect[2]*m[2];
        vec[1] = pVect[0]*m[4]+pVect[1]*m[5]+pVect[2]*m[6];
        vec[2] = pVect[0]*m[8]+pVect[1]*m[9]+pVect[2]*m[10];

        memcpy( pVect, vec, sizeof( float )*3 );
}

void Mat4::translateVect(float *pVect) const {
        pVect[0] = pVect[0]+m[12];
        pVect[1] = pVect[1]+m[13];
        pVect[2] = pVect[2]+m[14];
}

void Mat4::inverseTranslateVect(float *pVect) const {
        pVect[0] = pVect[0]-m[12];
        pVect[1] = pVect[1]-m[13];
        pVect[2] = pVect[2]-m[14];
}

#endif

---