shader.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SHADER_1107121519_HPP
#define OGLPLUS_SHADER_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/object/array.hpp>
#include <oglplus/error/program.hpp>
#include <oglplus/precision_type.hpp>
#include <oglplus/shader_type.hpp>
#include <oglplus/glsl_source.hpp>

#include <array>
#include <vector>
#include <cassert>

namespace oglplus {


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

    GLenum _type;

    void Gen(tag::Create create, GLsizei count, GLuint* names) const
    {
        Gen(create, count, names, _type);
    }

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

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

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


template <>
class ObjCommonOps<tag::Shader>
 : public ShaderName
{
protected:
    ObjCommonOps(void) { }

#if OGLPLUS_DOCUMENTATION_ONLY || \
    GL_ES_VERSION_3_0 || \
    GL_VERSION_4_1 || \
    GL_ARB_ES2_compatibility

    static void PrecisionFormat(
        ShaderType shader_type,
        PrecisionType precision_type,
        GLint* range_log_2,
        GLint* precision_log_2
    )
    {
        OGLPLUS_GLFUNC(GetShaderPrecisionFormat)(
            GLenum(shader_type),
            GLenum(precision_type),
            range_log_2,
            precision_log_2
        );
        OGLPLUS_VERIFY_SIMPLE(GetShaderPrecisionFormat);
    }
#endif
};


template <>
class ObjectOps<tag::DirectState, tag::Shader>
 : public ObjCommonOps<tag::Shader>
{
protected:
    ObjectOps(void){ }
public:
    struct Property
    {
        typedef ShaderType Type;
    };


    ShaderType Type(void) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetShaderiv)(
            _name,
            GL_SHADER_TYPE,
            &result
        );
        OGLPLUS_VERIFY(
            GetShaderiv,
            ObjectError,
            Object(*this)
        );
        return ShaderType(result);
    }


    ObjectOps& Source(
        const GLsizei count,
        const GLchar* const * srcs,
        const GLint* lens
    )
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(ShaderSource)(
            _name,
            count,
            const_cast<const GLchar**>(srcs),
            lens
        );
        OGLPLUS_VERIFY(
            ShaderSource,
            ObjectError,
            Object(*this)
        );
        return *this;
    }

    template <typename Src>
    ObjectOps& SourceTpl(const Src& src)
    {
        return Source(src.Count(), src.Parts(), src.Lengths());
    }


    ObjectOps& Source(GLSLString&& source)
    {
        return SourceTpl(source);
    }


    ObjectOps& Source(GLSLStrings&& source)
    {
        return SourceTpl(source);
    }


    ObjectOps& Source(const GLSLSource& glsl_source)
    {
        return SourceTpl(glsl_source);
    }


    bool IsCompiled(void) const
    {
        assert(_name != 0);
        int status;
        OGLPLUS_GLFUNC(GetShaderiv)(_name, GL_COMPILE_STATUS, &status);
        OGLPLUS_VERIFY(
            GetShaderiv,
            ObjectError,
            Object(*this).
            EnumParam(Type())
        );
        return status == GL_TRUE;
    }


    String GetInfoLog(void) const;


    ObjectOps& Compile(void);


#if OGLPLUS_DOCUMENTATION_ONLY || \
    GL_ARB_shading_language_include


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


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

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

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

#if OGLPLUS_DOCUMENTATION_ONLY || \
    GL_ES_VERSION_3_0 || \
    GL_VERSION_4_1 || \
    GL_ARB_ES2_compatibility

    static void ReleaseCompiler(void)
    {
        OGLPLUS_GLFUNC(ReleaseShaderCompiler)();
        OGLPLUS_VERIFY_SIMPLE(ReleaseShaderCompiler);
    }
#endif
};

typedef ObjectOps<tag::DirectState, tag::Shader>
    ShaderOps;

template <>
struct ObjectSubtype<tag::Shader>
{
    typedef ShaderType Type;
};


class Shader
 : public Object<ShaderOps>
{
private:
    Shader(const Shader&); // = delete;
protected:
    using Object<ShaderOps>::Uninitialized_;

    Shader(Uninitialized_ u)
     : Object<ShaderOps>(u)
    { }
public:
    Shader(ShaderType type)
     : Object<ShaderOps>(type)
    { }

    Shader(ShaderType type, ObjectDesc&& description)
     : Object<ShaderOps>(type, std::move(description))
    { }

    Shader(
        ShaderType type,
        GLSLString&& glsl_source
    ): Object<ShaderOps>(type)
    {
        this->Source(std::move(glsl_source));
        this->Compile();
    }

    Shader(
        ShaderType type,
        ObjectDesc&& description,
        GLSLString&& glsl_source
    ): Object<ShaderOps>(type, std::move(description))
    {
        this->Source(std::move(glsl_source));
        this->Compile();
    }

    Shader(
        ShaderType type,
        GLSLStrings&& glsl_source
    ): Object<ShaderOps>(type)
    {
        this->Source(std::move(glsl_source));
        this->Compile();
    }

    Shader(
        ShaderType type,
        ObjectDesc&& description,
        GLSLStrings&& glsl_source
    ): Object<ShaderOps>(type, std::move(description))
    {
        this->Source(std::move(glsl_source));
        this->Compile();
    }

    Shader(
        ShaderType type,
        const GLSLSource& glsl_source
    ): Object<ShaderOps>(type)
    {
        this->Source(glsl_source);
        this->Compile();
    }

    Shader(
        ShaderType type,
        ObjectDesc&& description,
        const GLSLSource& glsl_source
    ): Object<ShaderOps>(type, std::move(description))
    {
        this->Source(glsl_source);
        this->Compile();
    }

    Shader(Shader&& temp)
     : Object<ShaderOps>(static_cast<Object<ShaderOps>&&>(temp))
    { }

    Shader& operator = (Shader&& temp)
    {
        Object<ShaderOps>::operator = (std::move(temp));
        return *this;
    }
};

template <>
struct Classify<Shader>
 : Classify<Object<ShaderOps>>
{ };

template <>
class Array<Shader>
 : public Array<ObjectOps<tag::DirectState, tag::Shader>>
{
public:
    Array(GLsizei n, ShaderType type)
     : Array<ObjectOps<tag::DirectState, tag::Shader>>(n, type)
    { }
};

template <ShaderType ShType>
class SpecShader
 : public Shader
{
private:
    SpecShader(const SpecShader&); // = delete;
public:
    SpecShader(void)
     : Shader(ShType)
    { }

    SpecShader(ObjectDesc&& description)
     : Shader(ShType, std::move(description))
    { }

    SpecShader(GLSLString&& glsl_source)
     : Shader(ShType, std::move(glsl_source))
    { }

    SpecShader(
        ObjectDesc&& description,
        GLSLString&& glsl_source
    ): Shader(ShType, std::move(description), std::move(glsl_source))
    { }

    SpecShader(GLSLStrings&& glsl_source)
     : Shader(ShType, std::move(glsl_source))
    { }

    SpecShader(
        ObjectDesc&& description,
        GLSLStrings&& glsl_source
    ): Shader(ShType, std::move(description), std::move(glsl_source))
    { }

    SpecShader(const GLSLSource& glsl_source)
     : Shader(ShType, glsl_source)
    { }

    SpecShader(
        ObjectDesc&& description,
        const GLSLSource& glsl_source
    ): Shader(ShType, std::move(description), glsl_source)
    { }

    SpecShader(SpecShader&& temp)
     : Shader(static_cast<Shader&&>(temp))
    { }
};


typedef SpecShader<ShaderType::Vertex> VertexShader;

#if OGLPLUS_DOCUMENTATION_ONLY || GL_GEOMETRY_SHADER

typedef SpecShader<ShaderType::Geometry> GeometryShader;
#endif


typedef SpecShader<ShaderType::Fragment> FragmentShader;

#if OGLPLUS_DOCUMENTATION_ONLY || GL_TESS_CONTROL_SHADER

typedef SpecShader<ShaderType::TessControl> TessControlShader;
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_TESS_EVALUATION_SHADER

typedef SpecShader<ShaderType::TessEvaluation> TessEvaluationShader;
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_COMPUTE_SHADER

typedef SpecShader<ShaderType::Compute> ComputeShader;
#endif

} // namespace oglplus

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

#endif // include guard