debug_output.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_OPT_DEBUG_OUTPUT_1209031534_HPP
#define OGLPLUS_OPT_DEBUG_OUTPUT_1209031534_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/enumerations.hpp>

#include <cassert>
#include <stack>
#include <functional>
#include <memory>

namespace oglplus {


OGLPLUS_ENUM_CLASS_BEGIN(DebugOutputSeverity, GLenum)
#include <oglplus/enums/debug_output_severity.ipp>
OGLPLUS_ENUM_CLASS_END(DebugOutputSeverity)

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

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



OGLPLUS_ENUM_CLASS_BEGIN(DebugOutputSource, GLenum)
#include <oglplus/enums/debug_output_source.ipp>
OGLPLUS_ENUM_CLASS_END(DebugOutputSource)

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

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


OGLPLUS_ENUM_CLASS_BEGIN(DebugOutputType, GLenum)
#include <oglplus/enums/debug_output_type.ipp>
OGLPLUS_ENUM_CLASS_END(DebugOutputType)

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

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


#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3


class Debug
{
public:
    typedef DebugOutputSeverity Severity;

    typedef DebugOutputSource Source;

    typedef DebugOutputType Type;



    static void MessageControl(
        DebugOutputSource source,
        DebugOutputType type,
        DebugOutputSeverity severity,
        bool enable
    )
    {
        OGLPLUS_GLFUNC(DebugMessageControl)(
            GLenum(source),
            GLenum(type),
            GLenum(severity),
            0, nullptr,
            enable ? GL_TRUE : GL_FALSE
        );
        OGLPLUS_VERIFY_SIMPLE(DebugMessageControl);
    }

    struct CallbackData
    {
        DebugOutputSource source;
        DebugOutputType type;
        GLuint id;
        DebugOutputSeverity severity;
        GLsizei length;
        const GLchar* message;
    };

    typedef std::function<void (const CallbackData&)> Callback;


    class LogSink
    {
    private:
        static void GLAPIENTRY _gl_debug_proc(
            GLenum source,
            GLenum type,
            GLuint id,
            GLenum severity,
            GLsizei length,
            const GLchar* message,
            const GLvoid* user_param
        )
        {
            LogSink* self = (LogSink*)(user_param);
            assert(self);
            if(self->_callback)
            {
                CallbackData data;
                data.source = DebugOutputSource(source);
                data.type = DebugOutputType(type);
                data.id = id;
                data.severity = DebugOutputSeverity(severity);
                data.length = length;
                data.message = message;
                self->_callback(data);
            }
        }

        Callback _callback;
        GLDEBUGPROC _prev_callback;
        void* _prev_context;
    public:

        LogSink(Callback callback)
         : _callback(callback)
         , _prev_callback(nullptr)
         , _prev_context(nullptr)
        {
            // get the previous callback
            GLDEBUGPROC _tmp_callback = nullptr;
            void** _tmp_ptr =
                reinterpret_cast<void**>(&_tmp_callback);
            OGLPLUS_GLFUNC(GetPointerv)(
                GL_DEBUG_CALLBACK_FUNCTION,
                _tmp_ptr
            );
            OGLPLUS_VERIFY_SIMPLE(GetPointerv);
            _prev_callback = _tmp_callback;

            //get the previous context
            OGLPLUS_GLFUNC(GetPointerv)(
                GL_DEBUG_CALLBACK_USER_PARAM,
                &_prev_context
            );
            OGLPLUS_VERIFY_SIMPLE(GetPointerv);

            OGLPLUS_GLFUNC(DebugMessageCallback)(
                &LogSink::_gl_debug_proc,
                static_cast<void*>(this)
            );
            OGLPLUS_VERIFY_SIMPLE(DebugMessageCallback);
        }

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


        ~LogSink(void)
        {
            OGLPLUS_GLFUNC(DebugMessageCallback)(
                _prev_callback,
                _prev_context
            );
            OGLPLUS_VERIFY_SIMPLE(DebugMessageCallback);
        }
    };

    class Group
    {
    public:

        Group(
            DebugOutputSource source,
            GLuint id,
            const GLchar* message,
            GLint length = -1
        )
        {
            OGLPLUS_GLFUNC(PushDebugGroup)(
                GLenum(source),
                id,
                length,
                message
            );
            OGLPLUS_VERIFY_SIMPLE(PushDebugGroup);
        }


        Group(
            DebugOutputSource source,
            GLuint id,
            StrCRef message
        )
        {
            OGLPLUS_GLFUNC(PushDebugGroup)(
                GLenum(source),
                id,
                message.size(),
                message.begin()
            );
            OGLPLUS_VERIFY_SIMPLE(PushDebugGroup);
        }


        Group(
            DebugOutputSource source,
            GLuint id,
            const String& message
        )
        {
            OGLPLUS_GLFUNC(PushDebugGroup)(
                GLenum(source),
                id,
                message.size(),
                message.c_str()
            );
            OGLPLUS_VERIFY_SIMPLE(PushDebugGroup);
        }

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

        ~Group(void)
        {
            OGLPLUS_GLFUNC(PopDebugGroup)();
            OGLPLUS_VERIFY_SIMPLE(PopDebugGroup);
        }
    };


    template <typename ObjTag>
    static void ObjectLabel(
        const ObjectName<ObjTag>& object,
        StrCRef label
    )
    {
        OGLPLUS_GLFUNC(ObjectLabel)(
            GetGLName(object),
            ObjTypeOps<ObjTag>::ObjectType(),
            label.size(),
            label.c_str()
        );
        OGLPLUS_VERIFY_SIMPLE(ObjectLabel);
    }


    static void Synchronous(bool enable)
    {
        if(enable)
        {
            OGLPLUS_GLFUNC(Enable)(
                GL_DEBUG_OUTPUT_SYNCHRONOUS
            );
            OGLPLUS_VERIFY_SIMPLE(Enable);
        }
        else
        {
            OGLPLUS_GLFUNC(Disable)(
                GL_DEBUG_OUTPUT_SYNCHRONOUS
            );
            OGLPLUS_VERIFY_SIMPLE(Disable);
        }
    }


    static void InsertMessage(
        DebugOutputSource source,
        DebugOutputType type,
        GLuint id,
        DebugOutputSeverity severity,
        const GLchar* buffer,
        GLint length = -1
    )
    {
        OGLPLUS_GLFUNC(DebugMessageInsert)(
            GLenum(source),
            GLenum(type),
            id,
            GLenum(severity),
            length,
            buffer
        );
        OGLPLUS_VERIFY_SIMPLE(DebugMessageInsert);
    }


    static void InsertMessage(
        DebugOutputSource source,
        DebugOutputType type,
        GLuint id,
        DebugOutputSeverity severity,
        StrCRef message
    )
    {
        OGLPLUS_GLFUNC(DebugMessageInsert)(
            GLenum(source),
            GLenum(type),
            id,
            GLenum(severity),
            message.size(),
            message.c_str()
        );
        OGLPLUS_VERIFY_SIMPLE(DebugMessageInsert);
    }


    static void InsertMessage(
        DebugOutputSource source,
        DebugOutputType type,
        GLuint id,
        DebugOutputSeverity severity,
        const String& message
    )
    {
        OGLPLUS_GLFUNC(DebugMessageInsert)(
            GLenum(source),
            GLenum(type),
            id,
            GLenum(severity),
            message.size(),
            message.c_str()
        );
        OGLPLUS_VERIFY_SIMPLE(DebugMessageInsert);
    }
};
#endif

} // namespace oglplus

#endif // include guard