program.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_PROGRAM_1107121519_HPP
#define OGLPLUS_PROGRAM_1107121519_HPP

#include <oglplus/config/compiler.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/object/sequence.hpp>
#include <oglplus/error/program.hpp>
#include <oglplus/error/prog_var.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/transform_feedback_mode.hpp>
#include <oglplus/program_resource.hpp>
#include <oglplus/primitive_type.hpp>
#include <oglplus/face_mode.hpp>
#include <oglplus/glsl_source.hpp>
#include <oglplus/vertex_attrib_slot.hpp>
#include <oglplus/detail/base_range.hpp>

#include <vector>
#include <cassert>
#include <tuple>

namespace oglplus {

class VertexAttribOps;


template <>
class ObjGenDelOps<tag::Program>
{
protected:
    static void Gen(tag::Create, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        for(GLsizei i=0; i<count; ++i)
        {
            names[i] = OGLPLUS_GLFUNC(CreateProgram)();
            OGLPLUS_CHECK_SIMPLE(CreateProgram);
        }
    }

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        for(GLsizei i=0; i<count; ++i)
        {
            OGLPLUS_GLFUNC(DeleteProgram)(names[i]);
            OGLPLUS_VERIFY_SIMPLE(DeleteProgram);
        }
    }

    static GLboolean IsA(GLuint name)
    {
        assert(name != 0);
        GLboolean result = OGLPLUS_GLFUNC(IsProgram)(name);
        OGLPLUS_VERIFY_SIMPLE(IsProgram);
        return result;
    }
};

template <>
struct ObjGenTag<tag::DirectState, tag::Program>
{
    typedef tag::Create Type;
};

template <>
class ObjBindingOps<tag::Program>
{
protected:
    static GLuint _binding(void)
    {
        GLint name = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_CURRENT_PROGRAM, &name);
        OGLPLUS_VERIFY(
            GetIntegerv,
            Error,
            EnumParam(GLenum(GL_CURRENT_PROGRAM))
        );
        return name;
    }
public:

    static ProgramName Binding(void)
    {
        return ProgramName(_binding());
    }


    static void Bind(ProgramName program)
    {
        OGLPLUS_GLFUNC(UseProgram)(GetGLName(program));
        OGLPLUS_VERIFY(
            UseProgram,
            ObjectError,
            Object(program)
        );
    }
};


template <>
class ObjCommonOps<tag::Program>
 : public ProgramName
 , public ObjBindingOps<tag::Program>
{
protected:
    ObjCommonOps(void){ }
public:
    using ObjBindingOps<tag::Program>::Bind;


    void Bind(void) const
    {
        Bind(*this);
    }


    void Use(void) const
    {
        Bind(*this);
    }
};



template <>
class ObjectOps<tag::DirectState, tag::Program>
 : public ObjZeroOps<tag::DirectState, tag::Program>
{
protected:
    ObjectOps(void){ }
public:
    GLint GetIntParam(GLenum query) const
    {
        GLint result;
        OGLPLUS_GLFUNC(GetProgramiv)(_name, query, &result);
        OGLPLUS_VERIFY(
            GetProgramiv,
            ObjectError,
            Object(*this).
            EnumParam(query)
        );
        return result;
    }

#if GL_VERSION_4_0 || GL_ARB_shader_subroutine
    GLint GetStageIntParam(GLenum stage, GLenum query) const
    {
        GLint result;
        OGLPLUS_GLFUNC(GetProgramStageiv)(_name, stage, query, &result);
        OGLPLUS_VERIFY(
            GetProgramStageiv,
            ObjectError,
            Object(*this).
            EnumParam(query)
        );
        return result;
    }
#endif


    ObjectOps& AttachShader(ShaderName shader);

    ObjectOps& AttachShaders(const Sequence<ShaderName>& shaders);


    ObjectOps& DetachShader(ShaderName shader);


    bool IsLinked(void) const
    {
        return GetIntParam(GL_LINK_STATUS) == GL_TRUE;
    }


    String GetInfoLog(void) const;


    ObjectOps& Link(void);


    ObjectOps& Build(void);

#if OGLPLUS_DOCUMENTATION_ONLY ||\
    GL_ARB_shading_language_include


    ObjectOps& BuildInclude(
        GLsizei count,
        const GLchar* const* paths,
        const GLint* lengths
    );

    ObjectOps& BuildInclude(GLSLString&& incl)
    {
        return BuildInclude(
            incl.Count(),
            incl.Parts(),
            incl.Lengths()
        );
    }

    ObjectOps& BuildInclude(GLSLStrings&& incl)
    {
        return BuildInclude(
            incl.Count(),
            incl.Parts(),
            incl.Lengths()
        );
    }

    ObjectOps& BuildInclude(const GLSLSource&& incl)
    {
        return BuildInclude(
            incl.Count(),
            incl.Parts(),
            incl.Lengths()
        );
    }
#endif


    bool IsValid(void) const
    {
        return GetIntParam(GL_VALIDATE_STATUS) == GL_TRUE;
    }


    ObjectOps& Validate(void);


    void TransformFeedbackVaryings(
        GLsizei count,
        const GLchar** varyings,
        TransformFeedbackMode mode
    );


    void TransformFeedbackVarying(const GLchar* varying)
    {
        TransformFeedbackVaryings(
            1, &varying,
            TransformFeedbackMode::SeparateAttribs
        );
    }

    template <typename std::size_t N>
    void TransformFeedbackVaryings(
        const GLchar* (&varyings)[N],
        TransformFeedbackMode mode
    )
    {
        TransformFeedbackVaryings(N, varyings, mode);
    }


    void TransformFeedbackVaryings(
        const std::vector<String>& varyings,
        TransformFeedbackMode mode
    ) const;

#if OGLPLUS_DOCUMENTATION_ONLY

    class ActiveVariableInfo
    {
    public:
        GLuint Index(void) const;

        const String& Name(void) const;

        const GLint Size(void) const;

        const SLDataType Type(void) const;
    };


    typedef Unspecified InterfaceContext;

    typedef Range<ProgramResource> ActiveResourceRange;

    typedef Range<ActiveVariableInfo> ActiveAttribRange;
    typedef Range<ActiveVariableInfo> ActiveUniformRange;
    typedef Range<ActiveVariableInfo> ActiveSubroutineUniformRange;
    typedef Range<ActiveVariableInfo> TransformFeedbackVaryingRange;
    typedef Range<Managed<Shader> > ShaderRange;
#else
    typedef aux::ActiveVariableInfo ActiveVariableInfo;
    typedef aux::ProgramInterfaceContext InterfaceContext;

#if GL_VERSION_4_3
    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        ProgramResource
    > ActiveResourceRange;
#endif

    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::ActiveAttribInfo
    > ActiveAttribRange;

    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::ActiveUniformInfo
    > ActiveUniformRange;

#if GL_VERSION_4_0 || GL_ARB_shader_subroutine
    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::ActiveSubroutineInfo
    > ActiveSubroutineRange;

    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::ActiveSubroutineUniformInfo
    > ActiveSubroutineUniformRange;
#endif
    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::TransformFeedbackVaryingInfo
    > TransformFeedbackVaryingRange;

    struct ShaderIterationContext
    {
        std::vector<GLuint> _shader_names;

        ShaderIterationContext(GLuint name, GLuint count);

        ShaderIterationContext(ShaderIterationContext&& temp)
         : _shader_names(std::move(temp._shader_names))
        { }
    };

    struct IteratedShaderName
     : ShaderName
    {
        IteratedShaderName(
            const ShaderIterationContext& context,
            unsigned index
        ): ShaderName(context._shader_names.at(index))
        { }
    };

    typedef aux::ContextElementRange<
            ShaderIterationContext,
            IteratedShaderName
    > ShaderRange;
#endif // !OGLPLUS_DOCUMENTATION_ONLY

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    InterfaceContext ActiveResourceContext(ProgramInterface intf) const;


    ActiveResourceRange ActiveResources(ProgramInterface intf) const;
#endif


    InterfaceContext ActiveAttribContext(void) const;


    ActiveAttribRange ActiveAttribs(void) const;


    InterfaceContext ActiveUniformContext(void) const;


    ActiveUniformRange ActiveUniforms(void) const;

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_shader_subroutine


    InterfaceContext ActiveSubroutineContext(ShaderType stage) const;


    ActiveSubroutineRange ActiveSubroutines(ShaderType stage) const;


    InterfaceContext ActiveSubroutineUniformContext(ShaderType stage) const;


    ActiveSubroutineUniformRange ActiveSubroutineUniforms(ShaderType stage) const;
#endif


    InterfaceContext TransformFeedbackVaryingContext(void) const;


    TransformFeedbackVaryingRange TransformFeedbackVaryings(void) const;

    ShaderRange AttachedShaders(void) const;

#if OGLPLUS_DOCUMENTATION_ONLY

    class ActiveUniformBlockInfo
    {
        GLuint Index(void) const;

        const String& Name(void) const;

        // TODO: active uniform indices, etc.
    };

    typedef Range<ActiveUniformBlockInfo> ActiveUniformRange;
#else
    typedef aux::ContextElementRange<
        aux::ProgramInterfaceContext,
        aux::ActiveUniformBlockInfo
    > ActiveUniformBlockRange;
#endif


    ActiveUniformBlockRange ActiveUniformBlocks(void) const;

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_separate_shader_objects

    ObjectOps& MakeSeparable(bool para = true);
#endif // separate shader objects

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_get_program_binary

    ObjectOps& MakeRetrievable(bool para = true);


    void GetBinary(std::vector<GLubyte>& binary, GLenum& format) const;


    void Binary(const std::vector<GLubyte>& binary, GLenum format);
#endif // get program binary


    TransformFeedbackMode TransformFeedbackBufferMode(void) const
    {
        return TransformFeedbackMode(
            GetIntParam(GL_TRANSFORM_FEEDBACK_BUFFER_MODE)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2

    GLint GeometryVerticesOut(void) const
    {
        return GetIntParam(GL_GEOMETRY_VERTICES_OUT);
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_gpu_shader5


    GLint GeometryShaderInvocations(void) const
    {
        return GetIntParam(GL_GEOMETRY_SHADER_INVOCATIONS);
    }
#endif // gpu shader 5

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2


    PrimitiveType GeometryInputType(void) const
    {
        return PrimitiveType(GetIntParam(GL_GEOMETRY_INPUT_TYPE));
    }


    PrimitiveType GeometryOutputType(void) const
    {
        return PrimitiveType(GetIntParam(GL_GEOMETRY_OUTPUT_TYPE));
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_tessellation_shader


    FaceOrientation TessGenVertexOrder(void) const
    {
        return FaceOrientation(GetIntParam(GL_TESS_GEN_VERTEX_ORDER));
    }


    TessGenPrimitiveType TessGenMode(void) const
    {
        return TessGenPrimitiveType(GetIntParam(GL_TESS_GEN_MODE));
    }


    TessGenPrimitiveSpacing TessGenSpacing(void) const
    {
        return TessGenPrimitiveSpacing(GetIntParam(GL_TESS_GEN_SPACING));
    }


    bool TessGenPointMode(void) const
    {
        return GetIntParam(GL_TESS_GEN_POINT_MODE) == GL_TRUE;
    }
#endif // tessellation shader


    void BindLocation(
        VertexAttribSlot vertex_attrib_slot,
        StrCRef identifier
    )
    {
        OGLPLUS_GLFUNC(BindAttribLocation)(
            _name,
            GLuint(vertex_attrib_slot),
            identifier.c_str()
        );
        OGLPLUS_CHECK(
            BindAttribLocation,
            ProgVarError,
            Program(*this).
            Identifier(identifier).
            Index(GLuint(vertex_attrib_slot))
        );
    }
};

typedef ObjectOps<tag::DirectState, tag::Program>
    ProgramOps;


typedef ObjectZero<ObjZeroOps<tag::DirectState, tag::Program>>
    NoProgram;


typedef Object<ProgramOps> Program;

// syntax-sugar operators

inline ProgramOps& operator << (
    ProgramOps& program,
    ShaderName shader
)
{
    program.AttachShader(shader);
    return program;
}

struct ProgAndXFBMode
{
    ProgramOps& prog;
    TransformFeedbackMode mode;

    ProgAndXFBMode(ProgramOps& p, TransformFeedbackMode m)
     : prog(p)
     , mode(m)
    { }
};

inline ProgAndXFBMode operator << (
    ProgramOps& prog,
    TransformFeedbackMode mode
)
{
    return ProgAndXFBMode(prog, mode);
}

template <std::size_t N>
inline ProgramOps& operator << (
    ProgAndXFBMode pam,
    const GLchar* (&varyings)[N]
)
{
    pam.prog.TransformFeedbackVaryings(varyings, pam.mode);
    return pam.prog;
}

struct ProgXFBModeAndNames
{
    ProgramOps& prog;
    TransformFeedbackMode mode;
    std::vector<const GLchar*> names;

    ProgXFBModeAndNames(ProgAndXFBMode pam, const GLchar* name)
     : prog(pam.prog)
     , mode(pam.mode)
    {
        names.reserve(8);
        names.push_back(name);
    }

    ProgXFBModeAndNames(ProgXFBModeAndNames&& pman, const GLchar* name)
     : prog(pman.prog)
     , mode(pman.mode)
     , names(std::move(pman.names))
    {
        names.push_back(name);
    }

    ProgXFBModeAndNames(ProgXFBModeAndNames&& tmp)
     : prog(tmp.prog)
     , mode(tmp.mode)
     , names(std::move(tmp.names))
    { }


#if !OGLPLUS_NO_DELETED_FUNCTIONS
    ProgXFBModeAndNames(const ProgXFBModeAndNames&) = delete;
#else
private:
    ProgXFBModeAndNames(const ProgXFBModeAndNames&);
public:
#endif

    ~ProgXFBModeAndNames(void)
    {
        if(!names.empty())
        {
            prog.TransformFeedbackVaryings(
                names.size(),
                names.data(),
                mode
            );
        }
    }
};

inline ProgXFBModeAndNames operator << (
    ProgAndXFBMode pam,
    const GLchar* name
)
{
    return ProgXFBModeAndNames(pam, name);
}

inline ProgXFBModeAndNames operator << (
    ProgXFBModeAndNames&& pman,
    const GLchar* name
)
{
    return ProgXFBModeAndNames(std::move(pman), name);
}


#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_separate_shader_objects

class ShaderProgram
 : public Program
{
private:
    static ProgramName _make(
        ShaderType shader_type,
        GLsizei count,
        const GLchar* const* strings
    );

    template <typename Src>
    static ProgramName _make(ShaderType shader_type, const Src& source)
    {
        return _make(shader_type, source.Count(), source.Parts());
    }

    void _check(void);
public:

    ShaderProgram(
        ShaderType shader_type,
        GLSLString&& source
    ): Program(_make(shader_type, source))
    { _check(); }


    ShaderProgram(
        ShaderType shader_type,
        GLSLString&& source,
        ObjectDesc&& object_desc
    ): Program(_make(shader_type, source), std::move(object_desc))
    { _check(); }


    ShaderProgram(
        ShaderType shader_type,
        GLSLStrings&& source
    ): Program(_make(shader_type, source))
    { _check(); }


    ShaderProgram(
        ShaderType shader_type,
        GLSLStrings&& source,
        ObjectDesc&& object_desc
    ): Program(_make(shader_type, source), std::move(object_desc))
    { _check(); }


    ShaderProgram(
        ShaderType shader_type,
        const GLSLSource& glsl_source
    ): Program(_make(shader_type, glsl_source.Count(), glsl_source.Parts()))
    { _check(); }


    ShaderProgram(
        ShaderType shader_type,
        const GLSLSource& glsl_source,
        ObjectDesc&& object_desc
    ): Program(
        _make(shader_type, glsl_source.Count(), glsl_source.Parts()),
        std::move(object_desc)
    )
    { _check(); }
};
#endif


class QuickProgram
 : public Program
{
public:
    QuickProgram(const Sequence<ShaderName>& shaders)
    {
        AttachShaders(shaders);
        Link();
        Use();
    }

    QuickProgram(
        ObjectDesc&& object_desc,
        const Sequence<ShaderName>& shaders
    ): Program(std::move(object_desc))
    {
        AttachShaders(shaders);
        Link();
        Use();
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_separate_shader_objects

    QuickProgram(bool separable, const Sequence<ShaderName>& shaders)
    {
        AttachShaders(shaders);
        if(separable) MakeSeparable();
        Link();
        Use();
    }


    QuickProgram(
        ObjectDesc&& object_desc,
        bool separable,
        const Sequence<ShaderName>& shaders
    ): Program(std::move(object_desc))
    {
        AttachShaders(shaders);
        if(separable) MakeSeparable();
        Link();
        Use();
    }
#endif
};

} // namespace oglplus

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

#endif // include guard