C:/Users/Marc/Desktop/Phystank/trunk/src/util/Matrix.h

//This file is part of PhysTank.
//
//PhysTank is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//PhysTank is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with PhysTank.  If not, see <http://www.gnu.org/licenses/>.
//
// © Marc Johnson, 2009

#ifndef _MATRIX_
#define _MATRIX_

#include "util/Vector2.h"

class Matrix
{
public:
        float _00, _10, _20;
        float _01, _11, _21;
        float _02, _12, _22;

        Matrix()
        :_00(1.0f), _10(0.0f), _20(0.0f), _01(0.0f), _11(1.0f), _21(0.0f),
        _02(0.0f), _12(0.0f), _22(1.0f)
        {
        }

        Matrix(const float m00, const float m10, const float m20,
                   const float m01, const float m11, const float m21,
                   const float m02, const float m12, const float m22)
    :_00(m00), _10(m10), _20(m20), _01(m01), _11(m11), _21(m21), _02(m02), _12(m12), _22(m22)
        {
        }

        Matrix(const Matrix & other)
        :_00(other._00), _10(other._10), _20(other._20), _01(other._01), _11(other._11), _21(other._21),
        _02(other._02), _12(other._12), _22(other._22)
        {
        }

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

        Matrix GetInverse() const;
        Matrix & Inverse();
        Matrix & Identity();

        Matrix & Rotation(const float fRotation);
        Matrix & Translation(const float fTranslationX, const float fTranslationY);
        Matrix & Scaling(const float fScaleX, const float fScaleY);

        float GetDeterminant() const;
};

inline Matrix Matrix::operator * (const Matrix& other) const
{
        Matrix result;

        result._00 = _00 * other._00 + _10 * other._01 + _20 * other._02;
        result._10 = _00 * other._10 + _10 * other._11 + _20 * other._12;
        result._20 = _00 * other._20 + _10 * other._21 + _20 * other._22;

        result._01 = _01 * other._00 + _11 * other._01 + _21 * other._02;
        result._11 = _01 * other._10 + _11 * other._11 + _21 * other._12;
        result._21 = _01 * other._20 + _11 * other._21 + _21 * other._22;

        result._02 = _02 * other._00 + _12 * other._01 + _22 * other._02;
        result._12 = _02 * other._10 + _12 * other._11 + _22 * other._12;
        result._22 = _02 * other._20 + _12 * other._21 + _22 * other._22;

        return result;
}

inline Matrix & Matrix::operator *= (const Matrix& other)
{
        *this = *this * other;

        return *this;
}

inline Matrix Matrix::GetInverse() const
{
        float fDeterminant = GetDeterminant();

        if(fDeterminant != 0)
        {
                float fInvDeterminant = 1 / fDeterminant;
                Matrix temp;

                temp._00 = ((_11 * _22) - (_21 * _12)) * fInvDeterminant;
                temp._10 = ((_20 * _12) - (_10 * _22)) * fInvDeterminant;
                temp._20 = ((_20 * _21) - (_20 * _11)) * fInvDeterminant;

                temp._01 = ((_21 * _02) - (_01 * _22)) * fInvDeterminant;
                temp._11 = ((_00 * _22) - (_20 * _02)) * fInvDeterminant;
                temp._21 = ((_20 * _01) - (_00 * _21)) * fInvDeterminant;

                temp._02 = ((_01 * _12) - (_11 * _02)) * fInvDeterminant;
                temp._12 = ((_10 * _02) - (_00 * _12)) * fInvDeterminant;
                temp._22 = ((_00 * _11) - (_10 * _01)) * fInvDeterminant;

                return temp;
        }

        return Matrix();
}

inline Matrix & Matrix::Inverse()
{
        *this = GetInverse();

        return *this;
}

inline Matrix & Matrix::Identity()
{
        memset(this, 0, sizeof(float) * 9);

        _00 = _11 = _22 = 1.0f;

        return *this;
}

inline Matrix & Matrix::Rotation(const float fRotation)
{
        float fCos = cosf(fRotation);
        float fSin = sinf(fRotation);

        _00 = fCos;
        _10 = -fSin;
        _01 = fSin;
        _11 = fCos;

        return *this;
}

inline Matrix & Matrix::Translation(const float fTranslationX, const float fTranslationY)
{
        _02 = fTranslationX;
        _12 = fTranslationY;

        return *this;
}

inline Matrix & Matrix::Scaling(const float fScaleX, const float fScaleY)
{
        _00 = fScaleX;
        _11 = fScaleY;

        return *this;
}

inline float Matrix::GetDeterminant() const
{
        float det1 = 0;
        float det2 = 0;
        float det3 = 0;
        float det4 = 0;
        float det5 = 0;
        float det6 = 0;

        det1 = _00 * _11 * _22;
        det2 = _00 * _12 * _02;
        det3 = _10 * _21 * _02;
        det4 = _10 * _01 * _22;
        det5 = _20 * _11 * _02;
        det6 = _20 * _01 * _12;

        return det1 - det2 + det3 - det4 + det5 - det6;
}

inline Vector2 operator * (const Vector2 & v, const Matrix & m)
{
        Vector2 temp;

        temp._x = v._x * m._00 + v._y * m._01 + m._02;
        temp._y = v._x * m._10 + v._y * m._11 + m._12;
        float z = v._x * m._20 + v._y * m._21 + m._22;

        if(z != 0)
        {
                temp._x /= z;
                temp._y /= z;
        }

        return temp;
}

inline Vector2 & operator *= (Vector2 & v, const Matrix & m)
{
        Vector2 temp = v * m;

        v = temp;

        return v;
}


#endif

---