GLContext.cpp

#include "GLContext.h"
 
#include "GLFuncPointers.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/DebugUtils.h"
 
 
namespace {
#ifndef __EMSCRIPTEN__
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GLContext");
#endif
 
#if 0
  oid CALLBACK DebugCallback(GLenum        source,
                             GLenum        type,
                             GLuint        id,
                             GLenum        /*severity*/,
                             GLsizei       /*length*/,
                             const GLchar* message,
                             const void*   /*userParam*/) {
    switch (type) {
    case GL_DEBUG_TYPE_OTHER:
      if ((source != GL_DEBUG_SOURCE_APPLICATION) || (id != 1)) {
        break;
      }
    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: // Yes, we know.
    case GL_DEBUG_TYPE_MARKER:
    case GL_DEBUG_TYPE_PUSH_GROUP:
    case GL_DEBUG_TYPE_POP_GROUP:
      return;
    default:
      break;
    }
 
    // Suppress some useless warnings
    switch (id) {
    case 131154: // NVIDIA: "Pixel-path performance warning: Pixel transfer is synchronized with 3D rendering."
    case 131218: // NVIDIA: "Shader will be recompiled due to GL state mismatches"
    case 131184: // NVIDIA: "Buffer detailed info"
    case 131185: // NVIDIA: "Buffer detailed info: Buffer object 1 (bound to GL_ARRAY_BUFFER_ARB, usage hint is GL_STATIC_DRAW) will use VIDEO memory as the source for buffer object operations."
      return;
    case 131204: // NVIDIA: Texture state usage warning: Texture 0 is base level inconsistent. Check texture size.
      //NOTE: This message shows up for unknown reasons regarding texture 0, which is the default texture id.
      if (std::strstr(message, "Texture 0") || std::strstr(message, "texture object (0)")) {
        return;
      }
    default:
      break;
    }
 
    LOG_DEBUG(logger, "%d %d(%d) %s", source, type, id, message);
  }
#endif
 
#ifndef __EMSCRIPTEN__
 
// Handle missing WIN32 define on non-WIN32
#ifndef CALLBACK
#define CALLBACK
#endif
 
  // Compatible with glDebugMessageCallback and glDebugMessageCallbackKHR
  void CALLBACK debugCallback(GLenum source,
                              GLenum type,
                              GLuint id,
                              GLenum severity,
                              GLsizei /*length*/,
                              const char* message,
                              const void* userParam)
  {
    const char* contextName = static_cast<const char*>(userParam);
 
    Cogs::Logging::Category category = Cogs::Logging::Category::Debug;
    switch (severity) {
    case GL_DEBUG_SEVERITY_HIGH:
      category = Cogs::Logging::Category::Error;
      break;
    case GL_DEBUG_SEVERITY_MEDIUM:
      category = Cogs::Logging::Category::Warning;
      break;
    case GL_DEBUG_SEVERITY_LOW:
      category = Cogs::Logging::Category::Debug;
      break;
    case GL_DEBUG_SEVERITY_NOTIFICATION:
      category = Cogs::Logging::Category::Trace;
      break;
    default:
      break;
    }
 
    switch (type)
    {
    case GL_DEBUG_TYPE_ERROR:               [[fallthrough]];
    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: [[fallthrough]];
    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:  [[fallthrough]];
    case GL_DEBUG_TYPE_PORTABILITY:         [[fallthrough]];
    case GL_DEBUG_TYPE_PERFORMANCE:
      break;
    case GL_DEBUG_TYPE_MARKER:              [[fallthrough]];
    case GL_DEBUG_TYPE_PUSH_GROUP:          [[fallthrough]];
    case GL_DEBUG_TYPE_POP_GROUP:
      return;
    case GL_DEBUG_TYPE_OTHER:
      if (strstr(message, "object (0)")) {
        return;
      }
      switch (id) {
      case 0x00020071: //Buffer detailed info : Buffer object 1 (boun...
        return;
      case 0x00020043: //Rasterization quality warning: A non-fullscreen clear caused a fallback from CSAA to MSAA.
        return;
      case 0x00020044: // Rasterization usage warning: Dithering is enabled, but is not supported for integer framebuffers.
        return;
      case 0x00020070: //Buffer info: Total VBO memory usage in the system...
        return;
      default:
        break;
      }
      break;
    default:
      break;
    }
 
    if (contextName) {
      logger.logFileLine(__FILE__, __LINE__, category, Cogs::Logging::ErrorGroup::Unspecified, "%s: %d %d(%d) %s", contextName, source, type, id, message);
    }
    else {
      logger.logFileLine(__FILE__, __LINE__, category, Cogs::Logging::ErrorGroup::Unspecified, "%d %d(%d) %s", source, type, id, message);
    }
 
//#ifdef COGSRENDERING_GFX_BREAK
//    if (Cogs::isBeingDebugged()) {
//      static bool always = false;
//      char c = '\0';
//      while (c != 'y' && !always) {
//        printf("Continue y/n/a: ");
//        c = getc(stdin);
//        if (c == 'n') abort();
//        if (c == 'a') always = true;
//      }
//    }
//#endif
 
  }
 
#endif
 
}
 
 
bool Cogs::setUpGLDebugging(const char* contextName, GLContextBase::Platform platform)
{
#ifdef __EMSCRIPTEN__
  (void)contextName;
  (void)platform;
  return false;
#else
 
  int major = 0;
  int minor = 0;
  glGetIntegerv(GL_MAJOR_VERSION, &major);
  glGetIntegerv(GL_MINOR_VERSION, &minor);
  if (4 < major || (major == 4 && 3 <= minor)) {
#ifndef __APPLE__
    glDebugMessageCallback(debugCallback, contextName);
    glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, true);
    glEnable(GL_DEBUG_OUTPUT);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
    glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION,
                         GL_DEBUG_TYPE_OTHER,
                         0,
                         GL_DEBUG_SEVERITY_LOW, -1, "Initialized OpenGL debug output.");
    goto success;
#endif
  }
  else if(3 <= major) {
    int numExtensions = 0;
    glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
    for (int i = 0; i < numExtensions; i++) {
 
      switch (Cogs::hash(Cogs::StringView((const char*)glGetStringi(GL_EXTENSIONS, i)))) {
 
      case Cogs::hash("GL_KHR_debug"):
        // According to GL_KHR_debug extension specification, in an ES context, the extension API funcs have KHR suffices, but not in a GL context
        switch (platform) {
 
#ifdef COGS_OPENGL20
        case GLContextBase::Platform::GL:
          glDebugMessageCallback(debugCallback, contextName);
          glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, true);
          glEnable(GL_DEBUG_OUTPUT);
          glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
          glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION,
                               GL_DEBUG_TYPE_OTHER,
                               0,
                               GL_DEBUG_SEVERITY_LOW, -1, "Initialized OpenGL debug output.");
          break;
#endif
 
#if defined(COGS_OPENGLES30)
        case GLContextBase::Platform::ES3:
          glDebugMessageCallbackKHR(debugCallback, contextName);
          glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, true);
          glEnable(GL_DEBUG_OUTPUT_KHR);
          glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR);
          glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION_KHR,
                                  GL_DEBUG_TYPE_OTHER_KHR,
                                  0,
                                  GL_DEBUG_SEVERITY_LOW_KHR, -1, "Initialized OpenGL debug output.");
          break;
#endif
        default:
          break;
        }
        goto success;
 
      default:
        break;
      }
    }
  }
 
  LOG_INFO(logger, "No supported debug extension available");
  return false;
 
success:
 
#if 0
#ifdef __linux__
#include "Foundation/Platform/X11Module.h"
#endif
 
#if defined(__linux__)
  // Sync to ensure any errors generated are processed.
  X11Module::instance().XSync(settings.windowData->display, false);
#endif
#endif
 
  return true;
#endif
}