vertex_attrib.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_VERTEX_ATTRIB_1107121519_HPP
#define OGLPLUS_VERTEX_ATTRIB_1107121519_HPP

#include <oglplus/fwd.hpp>
#include <oglplus/glfunc.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/vertex_attrib_slot.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/error/prog_var.hpp>
#include <oglplus/object/name.hpp>
#include <oglplus/object/sequence.hpp>
#include <oglplus/prog_var/location.hpp>
#include <oglplus/prog_var/varpara_fns.hpp>
#include <oglplus/prog_var/set_ops.hpp>
#include <oglplus/prog_var/wrapper.hpp>

#include <type_traits>

namespace oglplus {

template <>
class ProgVarLocOps<tag::VertexAttrib>
{
private:
    static const char* MsgGettingInactive(void);
protected:
    static const char* MsgUsingInactive(void);
public:

    static void BindLocation(
        ProgramName program,
        VertexAttribSlot location,
        StrCRef identifier
    )
    {
        OGLPLUS_GLFUNC(BindAttribLocation)(
            GetGLName(program),
            GLuint(location),
            identifier.c_str()
        );
        OGLPLUS_CHECK(
            BindAttribLocation,
            ProgVarError,
            Program(program).
            Identifier(identifier).
            Index(GLuint(location))
        );
    }


    static GLint GetLocation(
        ProgramName program,
        StrCRef identifier,
        bool active_only
    )
    {
        GLint result = OGLPLUS_GLFUNC(GetAttribLocation)(
            GetGLName(program),
            identifier.c_str()
        );
        OGLPLUS_CHECK(
            GetAttribLocation,
            ProgVarError,
            Program(program).
            Identifier(identifier)
        );
        OGLPLUS_HANDLE_ERROR_IF(
            active_only && (result < 0),
            GL_INVALID_OPERATION,
            MsgGettingInactive(),
            ProgVarError,
            Program(program).
            Identifier(identifier)
        );
        return result;
    }

    static VertexAttribSlot GetLocation(
        ProgramName program,
        StrCRef identifier
    )
    {
        return VertexAttribSlot(GetLocation(program, identifier, true));
    }


    static bool QueryActiveLocation(
        ProgramName program,
        StrCRef identifier,
        VertexAttribSlot& location
    )
    {
        GLint result = GetLocation(program, identifier, false);
        if(result < 0) return false;
        location = VertexAttribSlot(result);
        return true;
    }


    static bool QueryCommonLocation(
        const Sequence<ProgramName>& programs,
        StrCRef identifier,
        VertexAttribSlot& location
    );


    static VertexAttribSlot GetCommonLocation(
        const Sequence<ProgramName>& programs,
        StrCRef identifier
    );
};

template <>
class ProgVarSetters<tag::ImplicitSel, tag::VertexAttrib, tag::NativeTypes>
{
protected:
    OGLPLUS_ERROR_CONTEXT(VertexAttrib, VertexAttrib)

    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, f, t, GLfloat)
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, d, t, GLdouble)
    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, s, t, GLshort)

    OGLPLUS_AUX_VARPARA_FNS(VertexAttribI, i, t, GLint)
    OGLPLUS_AUX_VARPARA_FNS(VertexAttribI, ui, t, GLuint)
#endif

    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, fv, v, GLfloat)
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, dv, v, GLdouble)
    OGLPLUS_AUX_VARPARA_FNS(VertexAttrib, sv, v, GLshort)

    OGLPLUS_AUX_VARPARA_FNS(VertexAttribI, i, v, GLint)
    OGLPLUS_AUX_VARPARA_FNS(VertexAttribI, ui, v, GLuint)
#endif
};

template <>
class ProgVarCommonOps<tag::VertexAttrib>
 : public ProgVarLoc<tag::VertexAttrib>
{
protected:
    ProgVarCommonOps(VertexAttribLoc valoc)
     : ProgVarLoc<tag::VertexAttrib>(valoc)
    { }

    // Functions for autodetection of values-per-vertex
    template <typename T>
    static GLint _get_vpv(T*) { return 1; }

    template <typename T, std::size_t N>
    static GLint _get_vpv(Vector<T, N>*) { return N; }

    template <typename T, std::size_t Rows, std::size_t Cols>
    static GLint _get_vpv(Matrix<T, Rows, Cols>*) { return Rows*Cols; }

    // Functions for autodetection of element type
    template <typename T>
    static T _get_et(T* p);

    template <typename T, std::size_t N>
    static T _get_et(Vector<T, N>*);

    template <typename T, std::size_t Rows, std::size_t Cols>
    static T _get_et(Matrix<T, Rows, Cols>*);
public:
    void Bind(StrCRef identifier)
    {
        BindLocation(
            this->Program(),
            this->_location,
            identifier
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3

    void Divisor(GLuint divisor) const
    {
        OGLPLUS_GLFUNC(VertexAttribDivisor)(
            _location,
            divisor
        );
        OGLPLUS_CHECK_SIMPLE(VertexAttribDivisor);
    }
#endif
};


template <typename OpsTag, typename T>
class ProgVarGetSetOps<OpsTag, tag::VertexAttrib, T>
 : public ProgVarCommonOps<tag::VertexAttrib>
 , public ProgVarBaseSetOps<OpsTag, tag::VertexAttrib, tag::NativeTypes, T, 16>
{
protected:
    ProgVarGetSetOps(VertexAttribLoc valoc)
     : ProgVarCommonOps<tag::VertexAttrib>(valoc)
    { }
public:

    void SetValue(T value)
    {
        this->_do_set(_program, _location, value);
    }
};

template <typename OpsTag, typename T, std::size_t N>
class ProgVarGetSetOps<OpsTag, tag::VertexAttrib, Vector<T, N>>
 : public ProgVarCommonOps<tag::VertexAttrib>
 , public ProgVarBaseSetOps<OpsTag, tag::VertexAttrib, tag::NativeTypes, T, 4>
{
protected:
    ProgVarGetSetOps(VertexAttribLoc valoc)
     : ProgVarCommonOps<tag::VertexAttrib>(valoc)
    { }
public:
    void SetValue(const Vector<T, N>& value)
    {
        this->template _do_set<N>(_program, _location, Data(value));
    }
};

template <typename OpsTag, typename T, std::size_t R, std::size_t C>
class ProgVarGetSetOps<OpsTag, tag::VertexAttrib, Matrix<T, R, C>>
 : public ProgVarCommonOps<tag::VertexAttrib>
 , public ProgVarBaseSetOps<OpsTag, tag::VertexAttrib, tag::NativeTypes, T, 16>
{
protected:
    ProgVarGetSetOps(VertexAttribLoc valoc)
     : ProgVarCommonOps<tag::VertexAttrib>(valoc)
    { }
public:
    void SetValue(const Matrix<T, R, C>& value)
    {
        this->template _do_set<R*C>(_program, _location, Data(value));
    }
};

OGLPLUS_DECLARE_PROG_VAR(
    VertexAttrib,
    tag::ImplicitSel,
    tag::VertexAttrib,
    tag::NoTypecheck
)


class VertexArrayAttrib
 : public ProgVarCommonOps<tag::VertexAttrib>
{
public:

    VertexArrayAttrib(VertexAttribSlot location)
     : ProgVarCommonOps<tag::VertexAttrib>(VertexAttribLoc(GLint(location)))
    { }


    VertexArrayAttrib(ProgramName program, VertexAttribSlot location)
     : ProgVarCommonOps<tag::VertexAttrib>(
        VertexAttribLoc(program, GLint(location))
    ){ }


    VertexArrayAttrib(ProgramName program, StrCRef identifier)
     : ProgVarCommonOps<tag::VertexAttrib>(
        VertexAttribLoc(program, identifier)
    ){ }


    const VertexArrayAttrib& Setup(
        GLint values_per_vertex,
        DataType data_type
    ) const
    {
        if(data_type == DataType::Float)
        {
            Pointer(
                values_per_vertex,
                data_type,
                false,
                0,
                nullptr
            );
        }
#ifdef GL_DOUBLE
        else if(data_type == DataType::Double)
        {
            LPointer(
                values_per_vertex,
                data_type,
                0,
                nullptr
            );
        }
#endif
        else
        {
            IPointer(
                values_per_vertex,
                data_type,
                0,
                nullptr
            );
        }
        return *this;
    }

    const VertexArrayAttrib& Setup(
        GLint values_per_vertex,
        std::integral_constant<DataType, DataType::Float>
    ) const
    {
        return Pointer(
            values_per_vertex,
            DataType::Float,
            false,
            0,
            nullptr
        );
    }

#ifdef GL_DOUBLE
    const VertexArrayAttrib& Setup(
        GLint values_per_vertex,
        std::integral_constant<DataType, DataType::Double>
    ) const
    {
        return LPointer(
            values_per_vertex,
            DataType::Double,
            0,
            nullptr
        );
    }
#endif

    template <DataType DataTypeValue>
    const VertexArrayAttrib& Setup(
        GLint values_per_vertex,
        std::integral_constant<DataType, DataTypeValue>
    ) const
    {
        return IPointer(
            values_per_vertex,
            DataTypeValue,
            0,
            nullptr
        );
    }


    template <typename T>
    const VertexArrayAttrib& Setup(GLuint n = 1) const
    {
        typedef decltype(_get_et((T*)nullptr)) elem_type;

        return Setup(
            _get_vpv((T*)nullptr)*n,
            typename DataTypeCT<elem_type>::type()
        );
    }


    const VertexArrayAttrib& Pointer(
        GLint values_per_vertex,
        DataType data_type,
        bool normalized,
        GLsizei stride,
        const void* pointer
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribPointer)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            normalized ? GL_TRUE : GL_FALSE,
            stride,
            pointer
        );
        OGLPLUS_CHECK(
            VertexAttribPointer,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }


    const VertexArrayAttrib& IPointer(
        GLuint values_per_vertex,
        DataType data_type,
        GLsizei stride,
        const void* pointer
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribIPointer)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            stride,
            pointer
        );
        OGLPLUS_CHECK(
            VertexAttribIPointer,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }


#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_vertex_attrib_64bit

    const VertexArrayAttrib& LPointer(
        GLuint values_per_vertex,
        DataType data_type,
        GLsizei stride,
        const void* pointer
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribLPointer)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            stride,
            pointer
        );
        OGLPLUS_CHECK(VertexAttribLPointer,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }
#else
    const VertexArrayAttrib& LPointer(
        GLuint,
        DataType,
        GLsizei,
        const void*
    ) const
    {
        assert(!
        "The glVertexAttribLPointer function is "
        "required but not available! Double-precision "
        "vertex attribute values are not supported."
        );
        return *this;
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3 || GL_ARB_vertex_attrib_binding

    const VertexArrayAttrib& Format(
        GLint values_per_vertex,
        DataType data_type,
        bool normalized,
        GLuint relative_offset
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribFormat)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            normalized ? GL_TRUE : GL_FALSE,
            relative_offset
        );
        OGLPLUS_CHECK(
            VertexAttribFormat,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }


    const VertexArrayAttrib& IFormat(
        GLint values_per_vertex,
        DataType data_type,
        GLuint relative_offset
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribIFormat)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            relative_offset
        );
        OGLPLUS_CHECK(
            VertexAttribIFormat,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }


    const VertexArrayAttrib& LFormat(
        GLint values_per_vertex,
        DataType data_type,
        GLuint relative_offset
    ) const
    {
        OGLPLUS_GLFUNC(VertexAttribLFormat)(
            _location,
            values_per_vertex,
            GLenum(data_type),
            relative_offset
        );
        OGLPLUS_CHECK(
            VertexAttribLFormat,
            Error,
            EnumParam(data_type).
            Index(_location)
        );
        return *this;
    }
#endif


    const VertexArrayAttrib& Enable(void) const
    {
        OGLPLUS_GLFUNC(EnableVertexAttribArray)(_location);
        OGLPLUS_VERIFY(
            EnableVertexArrayAttrib,
            Error,
            Index(_location)
        );
        return *this;
    }


    const VertexArrayAttrib& Disable(void) const
    {
        OGLPLUS_GLFUNC(DisableVertexAttribArray)(_location);
        OGLPLUS_VERIFY(
            DisableVertexArrayAttrib,
            Error,
            Index(_location)
        );
        return *this;
    }
};


template <std::size_t N>
inline VertexArrayAttrib operator | (
    ProgramName program,
    const GLchar (&identifier)[N]
)
{
    return VertexArrayAttrib(program, identifier);
}


inline VertexArrayAttrib operator | (
    ProgramName program,
    GLuint location
)
{
    return VertexArrayAttrib(program, VertexAttribSlot(location));
}

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/vertex_attrib.ipp>
#endif

#endif // include guard