uniform_subroutines.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_UNIFORM_SUBROUTINE_1107121519_HPP
#define OGLPLUS_UNIFORM_SUBROUTINE_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/error/prog_var.hpp>
#include <oglplus/prog_var/location.hpp>
#include <oglplus/prog_var/set_ops.hpp>
#include <oglplus/prog_var/wrapper.hpp>
#include <oglplus/shader_type.hpp>

#include <cassert>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_shader_subroutine

template <>
class ProgVarLocOps<tag::Subroutine>
{
private:
    ShaderType _stage;
    static const char* MsgGettingInactive(void);
protected:
    static const char* MsgUsingInactive(void);
    ProgVarLocOps(ShaderType stage)
     : _stage(stage)
    { }
public:

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


    GLint GetLocation(
        ProgramName program,
        StrCRef identifier,
        bool active_only
    )
    {
        return GetLocation(
            program,
            this->_stage,
            identifier,
            active_only
        );
    }

    ShaderType Stage(void) const
    {
        return _stage;
    }
};

template <>
class ProgVar<tag::ImplicitSel, tag::Subroutine, tag::NoTypecheck, void>
 : public ProgVarLoc<tag::Subroutine>
{
public:
    ProgVar(SubroutineLoc pvloc)
     : ProgVarLoc<tag::Subroutine>(pvloc)
    { }

    ProgVar(ProgramName program, ShaderType stage, StrCRef identifier)
     : ProgVarLoc<tag::Subroutine>(stage, program, identifier)
    { }

    ProgVar(
        ProgramName program,
        ShaderType stage,
        StrCRef identifier,
        bool active_only
    ): ProgVarLoc<tag::Subroutine>(stage, program, identifier, active_only)
    { }
};

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

template <>
class ProgVarLocOps<tag::SubroutineUniform>
{
private:
    ShaderType _stage;
    static const char* MsgGettingInactive(void);
protected:
    static const char* MsgUsingInactive(void);
    ProgVarLocOps(ShaderType stage)
     : _stage(stage)
    { }
public:

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


    GLint GetLocation(
        ProgramName program,
        StrCRef identifier,
        bool active_only
    )
    {
        return GetLocation(
            program,
            this->_stage,
            identifier,
            active_only
        );
    }

    ShaderType Stage(void) const
    {
        return _stage;
    }
};

template <>
class ProgVar<tag::ImplicitSel, tag::SubroutineUniform, tag::NoTypecheck, void>
 : public ProgVarLoc<tag::SubroutineUniform>
{
public:
    ProgVar(SubroutineUniformLoc pvloc)
     : ProgVarLoc<tag::SubroutineUniform>(pvloc)
    { }

    ProgVar(ProgramName program, ShaderType stage, StrCRef identifier)
     : ProgVarLoc<tag::SubroutineUniform>(stage, program, identifier)
    { }

    ProgVar(
        ProgramName program,
        ShaderType stage,
        StrCRef identifier,
        bool active_only
    ): ProgVarLoc<tag::SubroutineUniform>(
        stage,
        program,
        identifier,
        active_only
    ){ }
};

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


class UniformSubroutines
{
private:
    ProgramName _program;
    ShaderType _stage;
    std::vector<GLuint> _indices;

    static GLsizei _get_location_count(
        ProgramName program,
        ShaderType stage
    )
    {
        GLint result;
        OGLPLUS_GLFUNC(GetProgramStageiv)(
            GetGLName(program),
            GLenum(stage),
            GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS,
            &result
        );
        OGLPLUS_VERIFY(
            GetProgramStageiv,
            ObjectError,
            Object(program).
            EnumParam(stage)
        );
        return result;
    }

    std::vector<GLuint>& _get_indices(void)
    {
        if(_indices.empty())
        {
            _indices.resize(
                _get_location_count(
                    _program,
                    _stage
                ), 0
            );
        }
        return _indices;
    }
public:
    UniformSubroutines(
        ProgramName program,
        ShaderType stage
    ): _program(program)
     , _stage(stage)
    { }


    UniformSubroutines& Assign(
        const SubroutineUniform& uniform,
        const Subroutine& subroutine
    )
    {
        assert(uniform.Program() == _program);
        assert(subroutine.Program() == _program);
        assert(uniform.Stage() == ShaderType(_stage));
        assert(subroutine.Stage() == ShaderType(_stage));
        assert(uniform.IsActive());
        assert(uniform.Location() <= GLint(_get_indices().size()));

        _get_indices()[uniform.Location()] = subroutine.Location();
        return *this;
    }


    class Preset
    {
    private:
        friend class UniformSubroutines;

        const std::vector<GLuint> _indices;
#ifndef NDEBUG
        ProgramName _program;
        ShaderType _stage;
#endif

        Preset(
#ifndef NDEBUG
            ProgramName program,
            ShaderType stage,
#endif
            const std::vector<GLuint>& indices
        ): _indices(indices)
#ifndef NDEBUG
         , _program(program)
         , _stage(stage)
#endif
        { }
    public:
        Preset(Preset&& tmp)
         : _indices(std::move(tmp._indices))
#ifndef NDEBUG
         , _program(tmp._program)
         , _stage(tmp._stage)
#endif
        { }
    };


    Preset Save(void)
    {
        return Preset(
#ifndef NDEBUG
            _program,
            _stage,
#endif
            _get_indices()
        );
    }


    void Load(const Preset& preset)
    {
        assert(_program == preset._program);
        assert(_stage == preset._stage);
        assert(_get_indices().size() == preset._indices.size());
        _get_indices() = preset._indices;
    }


    void Apply(const Preset& preset)
    {
        assert(_program == preset._program);
        assert(_stage == preset._stage);
        assert(_get_indices().size() == preset._indices.size());

        OGLPLUS_GLFUNC(UniformSubroutinesuiv)(
            GLenum(_stage),
            GLsizei(preset._indices.size()),
            preset._indices.data()
        );
        OGLPLUS_CHECK(
            UniformSubroutinesuiv,
            Error,
            EnumParam(_stage)
        );
    }


    void Apply(void)
    {
        OGLPLUS_GLFUNC(UniformSubroutinesuiv)(
            GLenum(_stage),
            GLsizei(_get_indices().size()),
            _get_indices().data()
        );
        OGLPLUS_CHECK(
            UniformSubroutinesuiv,
            Error,
            EnumParam(_stage)
        );
    }
};

#endif // GL_ARB_shader_subroutine

} // namespace oglplus

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

#endif // include guard