Matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H_
#define MATRIX_H_

#include <assert.h>
#define _USE_MATH_DEFINES
#include <math.h>

#include "Vector.h"

template<class Type = float, int size = 4>
class Matrix {
        public:
                Matrix();

                // default copy ctor, assignment op and dtor are ok

                Matrix& operator +=(const Matrix& m);
                Matrix operator +(const Matrix& m) const;

                Type* operator [](int col) {
                        assert(col < size);
                        return mMatrix[col];
                }

                const Type* operator [](int col) const {
                        assert(col < size);
                        return mMatrix[col];
                }

                Matrix& operator *=(const Matrix& other);
                Matrix operator *(const Matrix& other) const;

                void loadIdentity();
                
                Type* matrix() { return &mMatrix[0][0]; }


        private:
                Type mMatrix[size][size];
};

template<class Type, int size>
Matrix<Type, size>::Matrix() {
        loadIdentity();
}

template<class Type, int size>
void Matrix<Type, size>::loadIdentity(){
        for (int x = 0; x < size; ++x) {
                for (int y = 0; y < size; ++y) {
                        if (x == y)
                                mMatrix[x][y] = 1;
                        else
                                mMatrix[x][y] = 0;
                }
        }
}

template<class Type, int size>
Matrix<Type, size> Matrix<Type, size>::operator+(const Matrix& m) const {
        Matrix ret(*this);
        return ret += m;
}

template<class Type, int size>
Matrix<Type, size>& Matrix<Type, size>::operator+=(const Matrix& m) {
        for (int x = 0; x < size; ++x) {
                for (int y = 0; y < size; ++y) {
                                mMatrix[x][y] += m[x][y];
                }
        }
        return *this;
}

template<class Type, int size>
Matrix<Type, size> Matrix<Type, size>::operator*(const Matrix& m) const {
        Matrix ret(*this);
        return ret *= m;
}

template<class Type, int size>          //written by biesi
Matrix<Type, size>& Matrix<Type, size>::operator*=(const Matrix& m) {
        Matrix<> rv(*this);
        for(int rowL = 0; rowL < size; ++rowL) {
                for(int columnR = 0; columnR < size; ++columnR) {
                        Type val = 0;
                        for (int el = 0; el < size; ++el) {
                                val += mMatrix[rowL][el] * m[el][columnR];
                        }
                        rv[rowL][columnR] = val;
                }
        }
        *this = rv;
        return *this;
}

template<class Type>
Vector<> operator*(Matrix<Type, 4>& m, const Vector<>& v) {
        Type vals[4];
        for(int rowL = 0; rowL < 3; ++rowL) {
                vals[rowL] = 0;
                for (int el = 0; el < 3; ++el) {
                        vals[rowL] += m[rowL][el] * v.vector()[el];
                }
        }
        return Vector<>(vals[0], vals[1], vals[2]);
}

enum Axis {
        AXIS_X,
        AXIS_Y,
        AXIS_Z
};

template<class Type>
Matrix<Type, 4> makeRotationMatrix(Type angle, Axis axis) {
        Type cosa = cos(angle), sina = sin(angle);
        Matrix<Type, 4> m;
        switch (axis) {
                case AXIS_X:
                        m[1][1] =  cosa;
                        m[1][2] =  -sina;
                        m[2][1] =  sina;
                        m[2][2] =  cosa;
                        break;
                case AXIS_Y:
                        m[0][0] =  cosa;
                        m[0][2] =  sina;
                        m[2][0] =  -sina;
                        m[2][2] =  cosa;
                        break;
                case AXIS_Z:
                        m[0][0] =  cosa;
                        m[0][1] =  -sina;
                        m[1][0] =  sina;
                        m[1][1] =  cosa;
                        break;
        }
        return m;
}

template<class Type>
void rotate(Matrix<Type, 4>& m, Type angle, Axis axis) {
        Matrix<Type> rotMatrix = makeRotationMatrix(angle, axis);
        m *= rotMatrix;
}

template<class Type>
void translate(Matrix<Type, 4>&m, const Vector<Type>& aTranslateBy) {
        Matrix<Type> translateMatrix;
        translateMatrix[3][0] = aTranslateBy.x();
        translateMatrix[3][1] = aTranslateBy.y();
        translateMatrix[3][2] = aTranslateBy.z();
        m *= translateMatrix;
}



#endif

---