matrix.hpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MATRIX_HPP
#define MATRIX_HPP

#include "renderstack/rs.h"
#include "renderstack/vec3.hpp"
#include "renderstack/vec4.hpp"
#include <exception>

namespace renderstack {

class matrix_not_invertible_exception : public std::exception
{
};

class quaternion;

class matrix
{
public:
    matrix(){}
    matrix(matrix const &other)
    {
        m[0][0] = other.m[0][0]; m[1][0] = other.m[1][0]; m[2][0] = other.m[2][0]; m[3][0] = other.m[3][0];
        m[0][1] = other.m[0][1]; m[1][1] = other.m[1][1]; m[2][1] = other.m[2][1]; m[3][1] = other.m[3][1];
        m[0][2] = other.m[0][2]; m[1][2] = other.m[1][2]; m[2][2] = other.m[2][2]; m[3][2] = other.m[3][2];
        m[0][3] = other.m[0][3]; m[1][3] = other.m[1][3]; m[2][3] = other.m[2][3]; m[3][3] = other.m[3][3];
    }
    explicit matrix(quaternion const &q);

    matrix &operator=(matrix const &other)
    {
        m[0][0] = other.m[0][0]; m[1][0] = other.m[1][0]; m[2][0] = other.m[2][0]; m[3][0] = other.m[3][0];
        m[0][1] = other.m[0][1]; m[1][1] = other.m[1][1]; m[2][1] = other.m[2][1]; m[3][1] = other.m[3][1];
        m[0][2] = other.m[0][2]; m[1][2] = other.m[1][2]; m[2][2] = other.m[2][2]; m[3][2] = other.m[3][2];
        m[0][3] = other.m[0][3]; m[1][3] = other.m[1][3]; m[2][3] = other.m[2][3]; m[3][3] = other.m[3][3];

        return *this;
    }

    matrix(
        float m00, float m10, float m20, float m30,
        float m01, float m11, float m21, float m31,
        float m02, float m12, float m22, float m32,
        float m03, float m13, float m23, float m33
    )
    {
        m[0][0] = m00; m[1][0] = m10; m[2][0] = m20; m[3][0] = m30;
        m[0][1] = m01; m[1][1] = m11; m[2][1] = m21; m[3][1] = m31;
        m[0][2] = m02; m[1][2] = m12; m[2][2] = m22; m[3][2] = m32;
        m[0][3] = m03; m[1][3] = m13; m[2][3] = m23; m[3][3] = m33;
    }
    matrix(
        vec4 const &row0,
        vec4 const &row1,
        vec4 const &row2,
        vec4 const &row3
    )
    {
        m[0][0] = row0.x; m[1][0] = row0.y; m[2][0] = row0.z; m[3][0] = row0.w;
        m[0][1] = row1.x; m[1][1] = row1.y; m[2][1] = row1.z; m[3][1] = row1.w;
        m[0][2] = row2.x; m[1][2] = row2.y; m[2][2] = row2.z; m[3][2] = row2.w;
        m[0][3] = row3.x; m[1][3] = row3.y; m[2][3] = row3.z; m[3][3] = row3.w;
    }

    vec3    transform_vector            (vec3 const &v) const;
    vec4    transform_vector            (vec4 const &v) const;
    vec3    uniform_transform_direction (vec3 const &v) const;

    matrix  operator*                   (matrix const &other) const;
    matrix  &operator*=                 (matrix const &other) { return *this = *this * other; }

    vec3    column3                     (int column) const;

    vec4    column                      (int column) const;
    vec4    row                         (int row) const;

    void    set_row                     (int row, vec4 const &v);
    void    set_column                  (int col, vec4 const &v);

public:
    float m[4][4];

public:
    static matrix identity()
    {
        return matrix(
            1.0f, 0.0f, 0.0f, 0.0f,
            0.0f, 1.0f, 0.0f, 0.0f,
            0.0f, 0.0f, 1.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 1.0f
        );
    };
};

void    make_matrix_quaternion_xyz           (matrix &m, matrix &mi, quaternion const &q, vec3 const &xyz);
void    make_matrix_quaternion_xyz_scale     (matrix &m, matrix &mi, quaternion const &q, vec3 const &xyz, vec3 const &scaling);

matrix  transpose                            (matrix const &m);
matrix  inverse                              (matrix const &m);

matrix  make_matrix_frustum_centered         (float width, float height, float nearv, float farv);
matrix  make_matrix_frustum                  (float left, float right, float bottom, float top, float nearv, float farv);
matrix  make_matrix_perspective_vertical     (float fovy, float aspect, float near_val, float far_val);
matrix  make_matrix_perspective_horizontal   (float fovx, float aspect, float near_val, float far_val);
matrix  make_matrix_orthogonal_centered      (float width, float height, float near_val, float far_val);
matrix  make_matrix_orthogonal               (float left, float right, float bottom, float top, float near_val, float far_val);

matrix  make_matrix_translate                (vec3 const &translation);
matrix  make_matrix_scale                    (vec3 const &scaling);
matrix  make_matrix_translate_scale          (vec3 const &translation, vec3 const &scaling);

void    make_matrix_hpb_xyz                  (matrix &m, matrix &mi, vec3 const &hpb, vec3 const &translation);
void    make_matrix_hpb_xyz_scale            (matrix &m, matrix &mi, vec3 const &hpb, vec3 const &translation, vec3 const &scaling);

}

#endif