program_pipeline.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_PROGRAM_PIPELINE_1107121519_HPP
#define OGLPLUS_PROGRAM_PIPELINE_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/shader_type.hpp>
#include <oglplus/program_pipeline_stage.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/error/program.hpp>
#include <oglplus/detail/prog_pl_stages.hpp>

#include <cassert>

namespace oglplus {

// if program-pipeline is available
#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_1 || GL_ARB_separate_shader_objects


template <>
class ObjGenDelOps<tag::ProgramPipeline>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenProgramPipelines)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenProgramPipelines);
    }

#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(tag::Create, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(CreateProgramPipelines)(count, names);
        OGLPLUS_CHECK_SIMPLE(CreateProgramPipelines);
    }
#endif

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(DeleteProgramPipelines)(count, names);
        OGLPLUS_VERIFY_SIMPLE(DeleteProgramPipelines);
    }

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

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

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


    static void Bind(ProgramPipelineName pipeline)
    {
        OGLPLUS_GLFUNC(BindProgramPipeline)(GetGLName(pipeline));
        OGLPLUS_VERIFY(
            BindProgramPipeline,
            ObjectError,
            Object(pipeline)
        );
    }
};


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


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


template <>
class ObjectOps<tag::DirectState, tag::ProgramPipeline>
 : public ObjZeroOps<tag::DirectState, tag::ProgramPipeline>
{
protected:
    ObjectOps(void){ }
public:
    struct Properties
    {
        typedef ProgramPipelineStage Stage;
    };

    GLint GetIntParam(GLenum query) const
    {
        GLint result;
        OGLPLUS_GLFUNC(GetProgramPipelineiv)(_name, query, &result);
        OGLPLUS_VERIFY(
            GetProgramPipelineiv,
            ObjectError,
            Object(*this).
            EnumParam(query)
        );
        return result;
    }


    ProgPLUseStages UseStages(ProgramName program) const
    {
        assert(_name != 0);
        return ProgPLUseStages(
            _name,
            GetGLName(program),
            0
        );
    }


    void UseStages(
        Bitfield<ProgramPipelineStage> stages,
        ProgramName program
    ) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(UseProgramStages)(
            _name,
            GLbitfield(stages),
            GetGLName(program)
        );
        OGLPLUS_CHECK(
            UseProgramStages,
            ObjectError,
            Object(*this)
        );
    }

#if defined GL_ALL_SHADER_BITS

    void UseAllStages(ProgramName program) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(UseProgramStages)(
            _name,
            GL_ALL_SHADER_BITS,
            GetGLName(program)
        );
        OGLPLUS_VERIFY(
            UseProgramStages,
            ObjectError,
            Object(*this)
        );
    }
#endif


    String GetInfoLog(void) const;


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


    void Validate(void) const;


    void ActiveShaderProgram(ProgramName program) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(ActiveShaderProgram)(
            _name,
            GetGLName(program)
        );
        OGLPLUS_CHECK(
            ActiveShaderProgram,
            ObjectError,
            Object(*this)
        );
    }


    ProgramName ActiveShaderProgram(void) const
    {
        return ProgramName(GetIntParam(GL_ACTIVE_PROGRAM));
    }


    bool HasShader(ShaderType shader_type) const
    {
        return GetIntParam(GLenum(shader_type)) != 0;
    }


    ProgramName ShaderProgram(ShaderType shader_type) const
    {
        return ProgramName(GetIntParam(GLenum(shader_type)));
    }
};

typedef ObjectOps<tag::DirectState, tag::ProgramPipeline>
    ProgramPipelineOps;


typedef ObjectZero<ObjZeroOps<tag::DirectState, tag::ProgramPipeline>>
    NoProgramPipeline;


typedef Object<ProgramPipelineOps> ProgramPipeline;

#endif // program pipeline

} // namespace oglplus

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

#endif // include guard