uniform_block.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_UNIFORM_BLOCK_1107121519_HPP
#define OGLPLUS_UNIFORM_BLOCK_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/error/prog_var.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 <oglplus/shader_type.hpp>
#include <oglplus/buffer_binding.hpp>

#include <cassert>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_1 || GL_ARB_uniform_buffer_object

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

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

template <>
class ProgVarCommonOps<tag::UniformBlock>
 : public ProgVarLoc<tag::UniformBlock>
{
private:
    static GLenum _translate_ref(ShaderType shader_type);
    static GLenum _translate_max(ShaderType shader_type);
protected:
    ProgVarCommonOps(UniformBlockLoc ubloc)
     : ProgVarLoc<tag::UniformBlock>(ubloc)
    { }
public:
    static GLuint MaxIn(ShaderType shader_type)
    {
        GLint result;
        OGLPLUS_GLFUNC(GetIntegerv)(
            _translate_max(shader_type),
            &result
        );
        OGLPLUS_VERIFY(
            GetIntegerv,
            Error,
            EnumParam(_translate_max(shader_type))
        );
        assert(result >= 0);
        return GLuint(result);
    }


    bool ReferencedBy(ShaderType shader_type) const
    {
        GLint result;
        OGLPLUS_GLFUNC(GetActiveUniformBlockiv)(
            this->_program,
            this->_location,
            _translate_ref(shader_type),
            &result
        );
        OGLPLUS_VERIFY(
            GetActiveUniformBlockiv,
            Error,
            EnumParam(_translate_ref(shader_type))
        );
        return result == GL_TRUE;
    }


    GLuint DataSize(void) const
    {
        GLint result;
        OGLPLUS_GLFUNC(GetActiveUniformBlockiv)(
            this->_program,
            this->_location,
            GL_UNIFORM_BLOCK_DATA_SIZE,
            &result
        );
        OGLPLUS_VERIFY(
            GetActiveUniformBlockiv,
            Error,
            EnumParam(GLenum(GL_UNIFORM_BLOCK_DATA_SIZE))
        );
        assert(result >= 0);
        return GLuint(result);
    }


    void Binding(UniformBufferBindingPoint binding)
    {
        OGLPLUS_GLFUNC(UniformBlockBinding)(
            this->_program,
            this->_location,
            GLuint(binding)
        );
        OGLPLUS_VERIFY(
            UniformBlockBinding,
            ProgVarError,
            Program(ProgramName(this->_program)).
            Index(GLuint(binding))
        );
    }
};


typedef ProgVar<
    tag::ImplicitSel,
    tag::UniformBlock,
    tag::NoTypecheck,
    void
> UniformBlock;

#endif // uniform buffer object

} // namespace oglplus

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

#endif // include guard