program_resource.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_PROGRAM_RESOURCE_1208301144_HPP
#define OGLPLUS_PROGRAM_RESOURCE_1208301144_HPP

#include <oglplus/error/object.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/shader_type.hpp>
#include <oglplus/program_interface.hpp>
#include <oglplus/detail/program.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

class ProgramResource
{
private:
    GLint _program;
    GLenum _interface;
    GLuint _index;
    String _name;

    void QueryParams(
        GLenum property,
        GLsizei bufsize,
        GLsizei* written,
        GLint* params
    ) const
    {
        OGLPLUS_GLFUNC(GetProgramResourceiv)(
            _program,
            _interface,
            _index,
            1, &property,
            bufsize,
            written,
            params
        );
    }

    GLint GetParam(GLenum property) const
    {
        GLint res;
        QueryParams(property, 1, nullptr, &res);
        OGLPLUS_VERIFY(
            GetProgramResourceiv,
            Error,
            EnumParam(property)
        );
        return res;
    }

    bool HasProp(GLenum property) const
    {
        GLint res;
        QueryParams(GLenum(property), 1, nullptr, &res);
        return OGLPLUS_GLFUNC(GetError)() == GL_NO_ERROR;
    }
public:
    ProgramResource(
        aux::ProgramInterfaceContext& context,
        GLuint index
    );


    GLint GetIntParam(ProgramResourceProperty property) const
    {
        return GetParam(GLenum(property));
    }


    bool GetBoolParam(ProgramResourceProperty property) const
    {
        return GetParam(GLenum(property)) == GL_TRUE;
    }


    bool Has(ProgramResourceProperty property) const
    {
        return HasProp(GLenum(property));
    }

    ProgramInterface Interface(void) const
    {
        return ProgramInterface(_interface);
    }


    const String& Name(void) const
    {
        return _name;
    }

    GLuint Index(void) const
    {
        return _index;
    }

    bool HasType(void) const
    {
        return HasProp(GL_TYPE);
    }


    SLDataType Type(void) const
    {
        return SLDataType(GetParam(GL_TYPE));
    }


    GLint Location(void) const
    {
        return GetParam(GL_LOCATION);
    }


    GLint LocationIndex(void) const
    {
        return GetParam(GL_LOCATION_INDEX);
    }


    GLint ArraySize(void) const
    {
        return GetParam(GL_ARRAY_SIZE);
    }

    GLenum ReferencedByProperty(ShaderType type) const;


    bool ReferencedBy(ShaderType shader_type) const
    {
        return GetParam(ReferencedByProperty(shader_type)) == GL_TRUE;
    }


    bool IsPerPatch(void) const
    {
        return GetParam(GL_IS_PER_PATCH) == GL_TRUE;
    }

    // TODO: finish this
};

#endif // GL_VERSION_4_3

} // namespace oglplus

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

#endif // include guard