query.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_QUERY_1107121519_HPP
#define OGLPLUS_QUERY_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/object/reference.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/enumerations.hpp>
#include <cassert>

namespace oglplus {


OGLPLUS_ENUM_CLASS_BEGIN(QueryTarget, GLenum)
#include <oglplus/enums/query_target.ipp>
OGLPLUS_ENUM_CLASS_END(QueryTarget)

#if !OGLPLUS_NO_ENUM_VALUE_NAMES
#include <oglplus/enums/query_target_names.ipp>
#endif

#if !OGLPLUS_ENUM_VALUE_RANGES
#include <oglplus/enums/query_target_range.ipp>
#endif


OGLPLUS_ENUM_CLASS_BEGIN(ConditionalRenderMode, GLenum)
#include <oglplus/enums/conditional_render_mode.ipp>
OGLPLUS_ENUM_CLASS_END(ConditionalRenderMode)

#if !OGLPLUS_NO_ENUM_VALUE_NAMES
#include <oglplus/enums/conditional_render_mode_names.ipp>
#endif

#if !OGLPLUS_ENUM_VALUE_RANGES
#include <oglplus/enums/conditional_render_mode_range.ipp>
#endif


template <>
class ObjGenDelOps<tag::Query>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenQueries)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenQueries);
    }
#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(
        tag::Create,
        GLenum target,
        GLsizei count,
        GLuint* names
    )
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(CreateQueries)(target, count, names);
        OGLPLUS_CHECK_SIMPLE(CreateQueries);
    }

    GLenum _type;

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

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

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

template <>
struct ObjectSubtype<tag::Query>
{
    typedef QueryTarget Type;
};

class QueryActivator;

template <typename ResultType>
class QueryExecution;


template <>
class ObjectOps<tag::DirectState, tag::Query>
 : public ObjZeroOps<tag::DirectState, tag::Query>
{
protected:
    ObjectOps(void){ }
public:
    typedef QueryTarget Target;


    void Begin(Target target)
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(BeginQuery)(GLenum(target), _name);
        OGLPLUS_VERIFY(
            BeginQuery,
            ObjectError,
            Object(*this).
            EnumParam(target)
        );
    }


    void End(Target target)
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(EndQuery)(GLenum(target));
        OGLPLUS_VERIFY(
            EndQuery,
            ObjectError,
            Object(*this).
            EnumParam(target)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    void BeginConditionalRender(ConditionalRenderMode mode)
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(BeginConditionalRender)(_name, GLenum(mode));
        OGLPLUS_VERIFY(
            BeginConditionalRender,
            ObjectError,
            Object(*this).
            EnumParam(mode)
        );
    }


    static void EndConditionalRender(void)
    {
        OGLPLUS_GLFUNC(EndConditionalRender)();
        OGLPLUS_VERIFY_SIMPLE(EndConditionalRender);
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_timer_query

    void Counter(Target target)
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(QueryCounter)(_name, GLenum(target));
        OGLPLUS_VERIFY(
            QueryCounter,
            ObjectError,
            Object(*this).
            EnumParam(target)
        );
    }


    void Timestamp(void)
    {
        Counter(Target::Timestamp);
    }
#endif


    bool ResultAvailable(void) const
    {
        assert(_name != 0);
        GLuint result = GL_FALSE;
        OGLPLUS_GLFUNC(GetQueryObjectuiv)(
            _name,
            GL_QUERY_RESULT_AVAILABLE,
            &result
        );
        OGLPLUS_VERIFY(
            GetQueryObjectuiv,
            ObjectError,
            Object(*this)
        );
        return result == GL_TRUE;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    void Result(GLint& result) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(GetQueryObjectiv)(
            _name,
            GL_QUERY_RESULT,
            &result
        );
        OGLPLUS_VERIFY(
            GetQueryObjectiv,
            ObjectError,
            Object(*this)
        );
    }
#endif // GL_VERSION_3_0


    void Result(GLuint& result) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(GetQueryObjectuiv)(
            _name,
            GL_QUERY_RESULT,
            &result
        );
        OGLPLUS_VERIFY(
            GetQueryObjectuiv,
            ObjectError,
            Object(*this)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_3 || GL_ARB_timer_query

    void Result(GLint64& result) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(GetQueryObjecti64v)(
            _name,
            GL_QUERY_RESULT,
            &result
        );
        OGLPLUS_VERIFY(
            GetQueryObjecti64v,
            ObjectError,
            Object(*this)
        );
    }


    void Result(GLuint64& result) const
    {
        assert(_name != 0);
        OGLPLUS_GLFUNC(GetQueryObjectui64v)(
            _name,
            GL_QUERY_RESULT,
            &result
        );
        OGLPLUS_VERIFY(
            GetQueryObjectui64v,
            ObjectError,
            Object(*this)
        );
    }
#endif // timer query

    template <typename ResultType>
    void WaitForResult(ResultType& result) const
    {
        while(!ResultAvailable())
            OGLPLUS_GLFUNC(Finish)();
        Result(result);
    }

    typedef QueryActivator Activator;

    Activator Activate(Target target);


    template <typename ResultType>
    QueryExecution<ResultType>
    Execute(Target target, ResultType& result);
};

typedef ObjectOps<tag::DirectState, tag::Query>
    QueryOps;


class QueryActivator
{
protected:
    QueryName _query;
    QueryTarget _target;
private:
    bool _alive;
    QueryActivator(const QueryActivator&);
public:
    QueryActivator(
        QueryName query,
        QueryTarget target
    ): _query(query)
     , _target(target)
     , _alive(false)
    {
        Reference<QueryOps>(_query).Begin(_target);
        _alive = true;
    }

    QueryActivator(QueryActivator&& temp)
     : _query(std::move(temp._query))
     , _target(temp._target)
     , _alive(temp._alive)
    {
        temp._alive = false;
    }

    ~QueryActivator(void)
    {
        try { Finish(); }
        catch(...) { }
    }

    bool Finish(void)
    {
        if(_alive)
        {
            Reference<QueryOps>(_query).End(_target);
            _alive = false;
            return true;
        }
        else return false;
    }
};

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

class ConditionalRender
{
private:
    bool _alive;
    ConditionalRender(const ConditionalRender&);
public:
    ConditionalRender(
        QueryName query,
        ConditionalRenderMode mode
    ): _alive(false)
    {
        Reference<QueryOps>(query).BeginConditionalRender(mode);
        _alive = true;
    }

    ConditionalRender(ConditionalRender&& temp)
     : _alive(temp._alive)
    {
        temp._alive = false;
    }

    ~ConditionalRender(void)
    {
        try { Finish(); }
        catch(...) { }
    }

    bool Finish(void)
    {
        if(_alive)
        {
            QueryOps::EndConditionalRender();
            _alive = false;
            return true;
        }
        else return false;
    }
};
#endif


template <typename ResultType>
class QueryExecution : public QueryActivator
{
private:
    ResultType& _result;
public:
    QueryExecution(
        QueryName query,
        QueryTarget target,
        ResultType& result
    ): QueryActivator(query, target)
     , _result(result)
    { }

    QueryExecution(QueryExecution&& temp)
     : QueryActivator(static_cast<QueryActivator&&>(temp))
     , _result(temp._result)
    { }

    ~QueryExecution(void)
    {
        try { WaitForResult(); }
        catch(...) { }
    }

    void WaitForResult(void)
    {
        if(this->Finish())
        {
            Reference<QueryOps>(this->_query).WaitForResult(_result);
        }
    }
};

inline
QueryActivator
ObjectOps<tag::DirectState, tag::Query>::
Activate(Target target)
{
    return QueryActivator(*this, target);
}

template <typename ResultType>
inline
QueryExecution<ResultType>
ObjectOps<tag::DirectState, tag::Query>::
Execute(QueryTarget target, ResultType& result)
{
    return QueryExecution<ResultType>(*this, target, result);
}


typedef Object<QueryOps> Query;

} // namespace oglplus

#endif // include guard