string_queries.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_CONTEXT_STRING_QUERIES_1202210920_HPP
#define OGLPLUS_CONTEXT_STRING_QUERIES_1202210920_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/string_query.hpp>

#include <cassert>

namespace oglplus {
namespace aux {

class StrQueryRange
{
private:
    GLuint _index, _count;
    GLenum _param;
public:
    typedef String ValueType;

    StrQueryRange(GLuint n, GLenum p)
     : _index(0)
     , _count(n)
     , _param(p)
    { }

    bool Empty(void) const
    {
        assert(_index <= _count);
        return _index == _count;
    }

    std::size_t Size(void) const
    {
        return _count;
    }

    StrCRef Front(void) const
    {
        assert(!Empty());
        const GLubyte* result = OGLPLUS_GLFUNC(GetStringi)(
            _param,
            _index
        );
        OGLPLUS_VERIFY_SIMPLE(GetStringi);
        return StrCRef((const GLchar*)result);
    }

    void Next(void)
    {
        assert(!Empty());
        ++_index;
    }
};

} // namespace aux

namespace context {


class StringQueries
{
public:

    static const GLubyte* GetString(StringQuery query)
    {
        const GLubyte* result = OGLPLUS_GLFUNC(GetString)(GLenum(query));
        OGLPLUS_VERIFY_SIMPLE(GetString);
        return result;
    }


    static const char* Vendor(void)
    {
        return (const char*)GetString(StringQuery::Vendor);
    }


    static const char* Version(void)
    {
        return (const char*)GetString(StringQuery::Version);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    static GLuint NumShadingLanguageVersions(void)
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(
            GL_NUM_SHADING_LANGUAGE_VERSIONS,
            &result
        );
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return GLuint(result);
    }


    static const GLubyte* ShadingLanguageVersion(GLuint index)
    {
        const GLubyte* result = OGLPLUS_GLFUNC(GetStringi)(
            GL_SHADING_LANGUAGE_VERSION,
            index
        );
        OGLPLUS_VERIFY_SIMPLE(GetStringi);
        return result;
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY

    static Range<String> ShadingLanguageVersions(void);
#elif GL_VERSION_4_3
    static aux::StrQueryRange ShadingLanguageVersions(void)
    {
        return aux::StrQueryRange(
            NumShadingLanguageVersions(),
            GL_SHADING_LANGUAGE_VERSION
        );
    }
#endif


    static const char* ShadingLanguageVersion(void)
    {
        return (const char*)GetString(StringQuery::ShadingLanguageVersion);
    }


    static const char* Renderer(void)
    {
        return (const char*)GetString(StringQuery::Renderer);
    }


    static GLuint NumExtensions(void)
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(GL_NUM_EXTENSIONS, &result);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return GLuint(result);
    }



    static const GLubyte* Extensions(GLuint index)
    {
        const GLubyte* result = OGLPLUS_GLFUNC(GetStringi)(
            GL_EXTENSIONS,
            index
        );
        OGLPLUS_VERIFY_SIMPLE(GetStringi);
        return result;
    }

#if OGLPLUS_DOCUMENTATION_ONLY

    static Range<StrCRef> Extensions(void);
#else
    static aux::StrQueryRange Extensions(void)
    {
        return aux::StrQueryRange(
            NumExtensions(),
            GL_EXTENSIONS
        );
    }
#endif
};

} // namespace context
} // namespace oglplus

#endif // include guard