sync.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_SYNC_1107121519_HPP
#define OGLPLUS_SYNC_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/basic.hpp>
#include <oglplus/enumerations.hpp>

namespace oglplus {

// NOTE: Xlib.h defines this symbol
// using the preprocessor. To avoid any sort of
// problems here it is necessary to observe correct order
// of header includes or you gotta keep 'em separated
// (in different translation units)
#ifdef Status
#undef Status
#endif


OGLPLUS_ENUM_CLASS_BEGIN(SyncCondition, GLenum)
#include <oglplus/enums/sync_condition.ipp>
OGLPLUS_ENUM_CLASS_END(SyncCondition)

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

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



OGLPLUS_ENUM_CLASS_BEGIN(SyncType, GLenum)
#include <oglplus/enums/sync_type.ipp>
OGLPLUS_ENUM_CLASS_END(SyncType)

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

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



OGLPLUS_ENUM_CLASS_BEGIN(SyncStatus, GLenum)
#include <oglplus/enums/sync_status.ipp>
OGLPLUS_ENUM_CLASS_END(SyncStatus)

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

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


OGLPLUS_ENUM_CLASS_BEGIN(SyncWaitResult, GLenum)
#include <oglplus/enums/sync_wait_result.ipp>
OGLPLUS_ENUM_CLASS_END(SyncWaitResult)

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

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

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_2 || GL_ARB_sync


class Sync
{
private:
    GLsync _sync;
public:
    struct Property
    {
        typedef SyncCondition Condition;

        typedef SyncType Type;

        typedef SyncStatus Status;

        typedef SyncWaitResult WaitResult;
    };


    Sync(SyncCondition condition = SyncCondition::GPUCommandsComplete)
     : _sync(OGLPLUS_GLFUNC(FenceSync)(GLenum(condition), 0))
    {
        OGLPLUS_CHECK_SIMPLE(FenceSync);
    }

#if !OGLPLUS_NO_DELETED_FUNCTIONS
    Sync(const Sync&) = delete;
#else
private:
    Sync(const Sync&);
public:
#endif

    Sync(Sync&& temp)
     : _sync(temp._sync)
    {
        temp._sync = 0;
    }

    ~Sync(void)
    {
        if(_sync != 0) OGLPLUS_GLFUNC(DeleteSync)(_sync);
    }


    bool Signaled(void) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetSynciv)(
            _sync,
            GL_SYNC_STATUS,
            1,
            nullptr,
            &result
        );
        return result == GL_SIGNALED;
    }


    SyncType Type(void) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetSynciv)(
            _sync,
            GL_OBJECT_TYPE,
            1,
            nullptr,
            &result
        );
        return SyncType(result);
    }


    SyncCondition Condition(void) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetSynciv)(
            _sync,
            GL_SYNC_CONDITION,
            1,
            nullptr,
            &result
        );
        return SyncCondition(result);
    }


    SyncStatus Status(void) const
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetSynciv)(
            _sync,
            GL_SYNC_STATUS,
            1,
            nullptr,
            &result
        );
        return SyncStatus(result);
    }


    SyncWaitResult ClientWait(GLuint64 timeout) const
    {
        GLenum result = OGLPLUS_GLFUNC(ClientWaitSync)(
            _sync,
            0,
            timeout
        );
        OGLPLUS_VERIFY_SIMPLE(ClientWaitSync);
        return SyncWaitResult(result);
    }


    void Wait(GLuint64 timeout = GL_TIMEOUT_IGNORED) const
    {
        OGLPLUS_GLFUNC(WaitSync)(_sync, 0, timeout);
        OGLPLUS_VERIFY_SIMPLE(WaitSync);
    }
};

#endif // sync

} // namespace oglplus

#endif // include guard