DebugFunctions.cpp

Go to the documentation of this file.

#include <Windows.h> //wglGetProcAddress
#include "DebugFunctions.h"

void APIENTRY DebugFunctions::DebugCallback(GLenum source,
                                            GLenum type,
                                            GLuint id,
                                            GLenum severity,
                                            GLsizei length,
                                            const GLchar* message,
                                            GLvoid* userParam)
{
    // Messages to ignore, as they appear to be a NVIDIA driver peculiarity ->
    // FBO bound textures have to have nearest neighbor filtering and the texture border definition explicity set
    if (id == 131218)
    {
        // Source: OpenGL
        // Msg.Type: Performance
        // Msg. ID: 131218
        // Severity: Medium
        // Message: Program/shader state performance warning:
        // Fragment Shader is going to be recompiled because the shader key based on GL state mismatches.
        //
        // "NVIDIA like to optimise their shaders to run as fast as possible with the current OpenGL state
        // (eg. eliminating code because a uniform is set to 0 or 1).
        // Therefore it has to be recompiled if the state changes in a way that will cause the optimised shader to give incorrect results."
        return;
    }
    std::string error = FormatDebugOutput(source, type, id, severity, message);
    std::cout << error << std::endl;
}

std::string DebugFunctions::FormatDebugOutput(  GLenum source,
                                                GLenum type,
                                                GLuint id,
                                                GLenum severity,
                                                const char* msg)
{
    std::stringstream stringStream;
    std::string sourceString;
    std::string typeString;
    std::string severityString;

    switch (source) {
        case GL_DEBUG_SOURCE_API: {
            sourceString = "API";
            break;
        }
        case GL_DEBUG_SOURCE_APPLICATION: {
            sourceString = "Application";
            break;
        }
        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: {
            sourceString = "Window System";
            break;
        }
        case GL_DEBUG_SOURCE_SHADER_COMPILER: {
            sourceString = "Shader Compiler";
            break;
        }
        case GL_DEBUG_SOURCE_THIRD_PARTY: {
            sourceString = "Third Party";
            break;
        }
        case GL_DEBUG_SOURCE_OTHER: {
            sourceString = "Other";
            break;
        }
        default: {
            sourceString = "Unknown";
            break;
        }
    }

    switch (type) {
        case GL_DEBUG_TYPE_ERROR: {
            typeString = "Error";
            break;
        }
        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: {
            typeString = "Deprecated Behavior";
            break;
        }
        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: {
            typeString = "Undefined Behavior";
            break;
        }
        case GL_DEBUG_TYPE_PORTABILITY_ARB: {
            typeString = "Portability";
            break;
        }
        case GL_DEBUG_TYPE_PERFORMANCE: {
            typeString = "Performance";
            break;
        }
        case GL_DEBUG_TYPE_OTHER: {
            typeString = "Other";
            break;
        }
        default: {
            typeString = "Unknown";
            break;
        }
    }

    switch (severity) {
        case GL_DEBUG_SEVERITY_HIGH: {
            severityString = "High";
            break;
        }
        case GL_DEBUG_SEVERITY_MEDIUM: {
            severityString = "Medium";
            break;
        }
        case GL_DEBUG_SEVERITY_LOW: {
            severityString = "Low";
            break;
        }
        default: {
            severityString = "Unknown";
            break;
        }
    }

    stringStream << "OpenGL Error: " << msg;
    stringStream << " [Source = " << sourceString;
    stringStream << ", Type = " << typeString;
    stringStream << ", Severity = " << severityString;
    stringStream << ", ID = " << id << "]";
 
    return stringStream.str();
}


void DebugFunctions::registerCallBackFunction()
{
    // Query the OpenGL function to register your callback function.
    PFNGLDEBUGMESSAGECALLBACKPROC _glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) wglGetProcAddress("glDebugMessageCallback");
    PFNGLDEBUGMESSAGECALLBACKARBPROC _glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC) wglGetProcAddress("glDebugMessageCallbackARB");
 
    // Register your callback function.
    if (_glDebugMessageCallback != NULL) {
        _glDebugMessageCallback(DebugCallback, NULL);
    }
    else if (_glDebugMessageCallbackARB != NULL) {
        _glDebugMessageCallbackARB(DebugCallback, NULL);
    }
 
    // Enable synchronous callback. This ensures that your callback function is called
    // right after an error has occurred. This capability is not defined in the AMD
    // version.
    if ((_glDebugMessageCallback != NULL) || (_glDebugMessageCallbackARB != NULL)) {
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
    }
}