matrix4.hpp

Go to the documentation of this file.

/*
**    TP CPE Lyon
**    Copyright (C) 2013 Damien Rohmer
**
**    This program 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.
**
**   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/


#ifndef MATRIX4_HPP
#define MATRIX4_HPP

#include <iostream>
#include <vector>

#include <exception_cpe.hpp>

namespace cpe
{
class vec3;
class vec4;
class matrix3;

class matrix4
{


public:

    // ********************************************* //
    // ********************************************* //
    //  CONSTRUCTORS
    // ********************************************* //
    // ********************************************* //

    matrix4();
    matrix4(float x00,float x01,float x02,float x03,
            float x10,float x11,float x12,float x13,
            float x20,float x21,float x22,float x23,
            float x30,float x31,float x32,float x33);
    matrix4(const matrix3& m);

    // ********************************************* //
    // ********************************************* //
    //  Special initialization
    // ********************************************* //
    // ********************************************* //

    static matrix4 identity();
    static matrix4 zeros();
    static matrix4 rotation(const vec3& axis,float angle);
    static matrix4 scale(float s);
    static matrix4 scale(float s_x,float s_y,float s_z,float s_w);
    static matrix4 translation(const vec3& translation);
    static matrix4 transformation(const matrix3& m3,const vec3& translation);

    // ********************************************* //
    // ********************************************* //
    //  Projection matrix (emulate glu(t) functions)
    // ********************************************* //
    // ********************************************* //

    static matrix4 projection_perspective(float fovy,float aspect,float z_near,float z_far);
    static matrix4 projection_frustum(float left,float right,float bottom,float top,float near,float far);
    static matrix4 projection_orthographic(float left,float right,float bottom,float top,float near,float far);
    static matrix4 projection_look_at(const matrix4& current_matrix,const vec3& eye,const vec3& center,const vec3& up);


    // ********************************************* //
    // ********************************************* //
    //  Element access
    // ********************************************* //
    // ********************************************* //

    float operator()(const size_t& k1,const size_t& k2) const;
    float& operator()(const size_t& k1,const size_t& k2);

    const float* pointer() const;
    float* pointer_unprotected();



    // ********************************************* //
    // ********************************************* //
    //  Math operator
    // ********************************************* //
    // ********************************************* //

    matrix4 operator+(const matrix4& m2) const;
    matrix4 operator+(float s) const;

    matrix4 operator-(const matrix4& m2) const;
    matrix4 operator-(float s) const;


    matrix4 operator*(float s) const;
    vec4 operator*(const vec4& v) const;
    vec3 operator*(const vec3& v) const;
    matrix4 operator*(const matrix4& m2) const;
    matrix4 operator/(float s) const;


    matrix4& operator+=(const matrix4& m);
    matrix4& operator+=(float s);
    matrix4& operator-=(const matrix4& m);
    matrix4& operator-=(float s);
    matrix4& operator*=(float s);
    matrix4& operator/=(float s);

    matrix4 operator-() const;

    matrix4 product_compontentwise(const matrix4& m) const;
    matrix4& product_compontentwise_internal(const matrix4& m);

    matrix4 transposed() const;

    // ********************************************* //
    // ********************************************* //
    //  Deformation
    // ********************************************* //
    // ********************************************* //

    matrix4 translated(const vec3& translation) const;
    void translate_internal(const vec3& translation);






    // ********************************************* //
    // ********************************************* //
    //  Projection matrix
    // ********************************************* //
    // ********************************************* //

    std::vector<float> to_vector() const;

private:

    // ********************************************* //
    // ********************************************* //
    //  Internal parameters
    // ********************************************* //
    // ********************************************* //

    float m[16];


    // ********************************************* //
    // ********************************************* //
    //  Helper
    // ********************************************* //
    // ********************************************* //

    void assert_size(const size_t& k1,const size_t& k2) const;

};

// ********************************************* //
// ********************************************* //
//  Output
// ********************************************* //
// ********************************************* //

std::ostream& operator<<(std::ostream& stream,const matrix4& m);


class exception_matrix4 : public exception_cpe
{
public:

    exception_matrix4():exception_cpe(){}
    exception_matrix4(const std::string& msg_param,const std::string& file_param,const std::string& caller_param,const int& line_param):exception_cpe(msg_param,file_param,caller_param,line_param){}
};

matrix4 operator+(float s,const matrix4& m);
matrix4 operator-(float s,const matrix4& m);
matrix4 operator*(float s,const matrix4& m);

}

#endif