matrix.hpp

#pragma once
#ifndef OGLPLUS_EXT_DSA_MATRIX_1107121519_HPP
#define OGLPLUS_EXT_DSA_MATRIX_1107121519_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/ext/ARB_compatibility/matrix_mode.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_EXT_direct_state_access


class DSAMatrixEXT
{
private:
    CompatibilityMatrixMode _mode;
public:
    typedef CompatibilityMatrixMode Mode;

    DSAMatrixEXT(Mode mode)
     : _mode(mode)
    { }


    DSAMatrixEXT& Push(void)
    {
        OGLPLUS_GLFUNC(MatrixPushEXT)(GLenum(_mode));
        OGLPLUS_VERIFY_SIMPLE(MatrixPushEXT);
        return *this;
    }


    DSAMatrixEXT& Pop(void)
    {
        OGLPLUS_GLFUNC(MatrixPopEXT)(GLenum(_mode));
        OGLPLUS_VERIFY_SIMPLE(MatrixPopEXT);
        return *this;
    }


    DSAMatrixEXT& LoadIdentity(void)
    {
        OGLPLUS_GLFUNC(MatrixLoadIdentityEXT)(GLenum(_mode));
        OGLPLUS_VERIFY_SIMPLE(MatrixLoadIdentityEXT);
        return *this;
    }


    DSAMatrixEXT& Load(const Matrix<GLfloat, 4, 4>& matrix)
    {
        OGLPLUS_GLFUNC(MatrixLoadTransposefEXT)(
            GLenum(_mode),
            Data(matrix)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixLoadTransposefEXT);
        return *this;
    }


    DSAMatrixEXT& Load(const Matrix<GLdouble, 4, 4>& matrix)
    {
        OGLPLUS_GLFUNC(MatrixLoadTransposedEXT)(
            GLenum(_mode),
            Data(matrix)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixLoadTransposedEXT);
        return *this;
    }


    DSAMatrixEXT& Mult(const Matrix<GLfloat, 4, 4>& matrix)
    {
        OGLPLUS_GLFUNC(MatrixMultTransposefEXT)(
            GLenum(_mode),
            Data(matrix)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixMultTransposefEXT);
        return *this;
    }


    DSAMatrixEXT& Mult(const Matrix<GLdouble, 4, 4>& matrix)
    {
        OGLPLUS_GLFUNC(MatrixMultTransposedEXT)(
            GLenum(_mode),
            Data(matrix)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixMultTransposedEXT);
        return *this;
    }


    DSAMatrixEXT& Rotate(
        Angle<GLfloat> angle,
        const GLfloat x,
        const GLfloat y,
        const GLfloat z
    )
    {
        OGLPLUS_GLFUNC(MatrixRotatefEXT)(
            GLenum(_mode),
            Degrees(angle),
            x, y, z
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixRotatefEXT);
        return *this;
    }


    DSAMatrixEXT& Rotate(
        Angle<GLfloat> angle,
        const Vector<GLfloat, 3>& axis
    )
    {
        OGLPLUS_GLFUNC(MatrixRotatefEXT)(
            GLenum(_mode),
            Degrees(angle),
            At(axis, 0),
            At(axis, 1),
            At(axis, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixRotatefEXT);
        return *this;
    }


    DSAMatrixEXT& Rotate(
        Angle<GLdouble> angle,
        const Vector<GLdouble, 3>& axis
    )
    {
        OGLPLUS_GLFUNC(MatrixRotatedEXT)(
            GLenum(_mode),
            Degrees(angle),
            At(axis, 0),
            At(axis, 1),
            At(axis, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixRotatedEXT);
        return *this;
    }


    DSAMatrixEXT& Scale(const GLfloat x, const GLfloat y, const GLfloat z)
    {
        OGLPLUS_GLFUNC(MatrixScalefEXT)(GLenum(_mode), x, y, z);
        OGLPLUS_VERIFY_SIMPLE(MatrixScalefEXT);
        return *this;
    }


    DSAMatrixEXT& Scale(const Vector<GLfloat, 3>& amount)
    {
        OGLPLUS_GLFUNC(MatrixScalefEXT)(
            GLenum(_mode),
            At(amount, 0),
            At(amount, 1),
            At(amount, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixScalefEXT);
        return *this;
    }


    DSAMatrixEXT& Scale(const Vector<GLdouble, 3>& amount)
    {
        OGLPLUS_GLFUNC(MatrixScalefEXT)(
            GLenum(_mode),
            At(amount, 0),
            At(amount, 1),
            At(amount, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixScaledEXT);
        return *this;
    }


    DSAMatrixEXT& Translate(
        const GLfloat x,
        const GLfloat y,
        const GLfloat z
    )
    {
        OGLPLUS_GLFUNC(MatrixTranslatefEXT)(GLenum(_mode), x, y, z);
        OGLPLUS_VERIFY_SIMPLE(MatrixTranslatefEXT);
        return *this;
    }


    DSAMatrixEXT& Translate(const Vector<GLfloat, 3>& amount)
    {
        OGLPLUS_GLFUNC(MatrixTranslatefEXT)(
            GLenum(_mode),
            At(amount, 0),
            At(amount, 1),
            At(amount, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixTranslatefEXT);
        return *this;
    }


    DSAMatrixEXT& Translate(const Vector<GLdouble, 3>& amount)
    {
        OGLPLUS_GLFUNC(MatrixTranslatefEXT)(
            GLenum(_mode),
            At(amount, 0),
            At(amount, 1),
            At(amount, 2)
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixTranslatedEXT);
        return *this;
    }


    DSAMatrixEXT& Ortho(
        GLdouble left,
        GLdouble right,
        GLdouble bottom,
        GLdouble top,
        GLdouble near_depth,
        GLdouble far_depth
    )
    {
        OGLPLUS_GLFUNC(MatrixOrthoEXT)(
            GLenum(_mode),
            left,
            right,
            bottom,
            top,
            near_depth,
            far_depth
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixOrthoEXT);
        return *this;
    }


    DSAMatrixEXT& Frustum(
        GLdouble left,
        GLdouble right,
        GLdouble bottom,
        GLdouble top,
        GLdouble near_depth,
        GLdouble far_depth
    )
    {
        OGLPLUS_GLFUNC(MatrixFrustumEXT)(
            GLenum(_mode),
            left,
            right,
            bottom,
            top,
            near_depth,
            far_depth
        );
        OGLPLUS_VERIFY_SIMPLE(MatrixFrustumEXT);
        return *this;
    }
};

class DSAModelviewMatrixEXT
 : public DSAMatrixEXT
{
public:
    DSAModelviewMatrixEXT(void)
     : DSAMatrixEXT(CompatibilityMatrixMode::Modelview)
    { }
};

class DSAProjectionMatrixEXT
 : public DSAMatrixEXT
{
public:
    DSAProjectionMatrixEXT(void)
     : DSAMatrixEXT(CompatibilityMatrixMode::Projection)
    { }
};

#endif // GL_EXT_direct_state_access

} // namespace oglplus

#endif // include guard