matrix.hpp

#pragma once

#include <iostream>

namespace rt{

class vector;

class matrix{
public:
    enum Format{
        RowMajorFormat, 
        ColumnMajorFormat 
    };

    matrix();

    matrix(const matrix &);

    matrix(double *data, Format format = RowMajorFormat);

    matrix(double m11, double m12, double m13, double m14, double m21, double m22, double m23, double m24, double m31, double m32, double m33, double m34, double m41, double m42, double m43, double m44);

    void set(double m11, double m12, double m13, double m14, double m21, double m22, double m23, double m24, double m31, double m32, double m33, double m34, double m41, double m42, double m43, double m44);

    void optimize();

    void setToIdentity();

    bool isIdentity() const;

    double determinant() const;

    void invert(bool *invertible = 0);

    void transpose();

    void translate(const vector &);

    void translate(double x, double y, double z);

    void scale(const vector &);

    void scale(double x, double y, double z);

    void scale(double factor);

    void rotate(double angle, const vector &);

    void rotate(double angle, double x, double y, double z = 0.0f);

    matrix inverted(bool *invertible = 0) const;
    matrix transposed() const;
    matrix translated(const vector &) const;
    matrix translated(double x, double y, double z) const;
    matrix scaled(const vector &) const;
    matrix scaled(double x, double y, double z) const;
    matrix scaled(double factor) const;
    matrix rotated(double angle, const vector &) const;
    matrix rotated(double angle, double x, double y, double z) const;

    void lookAt(const vector & eye, const vector & center, const vector & up);
    vector position() const;
    vector rotation() const;
    vector scale() const; // TODO

    double at(int row, int column) const;
    vector map(const vector &) const;

    const double & operator()(int row, int column) const;
    double & operator()(int row, int column);

    matrix& operator +=(const matrix &);
    matrix& operator -=(const matrix &);
    matrix& operator *=(const matrix &);
    matrix& operator *=(double);
    bool operator ==(const matrix &) const;
    bool operator !=(const matrix &) const;

    friend matrix operator+(const matrix& m1, const matrix& m2);
    friend matrix operator-(const matrix& m1, const matrix& m2);
    friend matrix operator*(const matrix& m1, const matrix& m2);
    friend vector operator*(const matrix& m, const vector& v);
    friend vector operator*(const vector& v, const matrix& m);
    friend matrix operator-(const matrix& m);
    friend matrix operator*(double, const matrix& m);
    friend matrix operator*(const matrix& m, double);

    const double *data() const; // column-major

private:
    enum MatrixFlags{
        Any = 0,
        Identity = 1,
        Translation = 2,
        Rotation = 4,
        Scale = 8,
        Perspective = 16,
        Ortho = 32
    };

    double _data[4][4]; // column-major
    mutable int _flags;
};

rt::matrix operator+(const rt::matrix& m1, const rt::matrix& m2);
rt::matrix operator-(const rt::matrix& m1, const rt::matrix& m2);
rt::matrix operator*(const rt::matrix& m1, const rt::matrix& m2);
rt::vector operator*(const rt::vector& vector, const rt::matrix& matrix);
rt::vector operator*(const rt::matrix& matrix, const rt::vector& vector);
rt::matrix operator-(const rt::matrix& matrix);
rt::matrix operator*(double factor, const rt::matrix& matrix);
rt::matrix operator*(const rt::matrix& matrix, double factor);

}

std::ostream & operator<<(std::ostream &, const rt::matrix & m);
std::ostream & operator<<(std::ostream &, const rt::vector & v);