Extensible GL extension support

10 files changed, 299 insertions, 96 deletions

diff --git a/src/mbgl/geometry/vao.cpp b/src/mbgl/geometry/vao.cpp
index fef74396a9..4f6e89332f 100644
--- a/src/mbgl/geometry/vao.cpp
+++ b/src/mbgl/geometry/vao.cpp
@@ -5,11 +5,45 @@
 
 namespace mbgl {
 
+static gl::ExtensionFunction<
+    void (GLuint array)>
+    BindVertexArray({
+        {"GL_ARB_vertex_array_object", "glBindVertexArray"},
+        {"GL_OES_vertex_array_object", "glBindVertexArrayOES"},
+        {"GL_APPLE_vertex_array_object", "glBindVertexArrayAPPLE"}
+    });
+
+static gl::ExtensionFunction<
+    void (GLsizei n,
+          const GLuint* arrays)>
+    DeleteVertexArrays({
+        {"GL_ARB_vertex_array_object", "glDeleteVertexArrays"},
+        {"GL_OES_vertex_array_object", "glDeleteVertexArraysOES"},
+        {"GL_APPLE_vertex_array_object", "glDeleteVertexArraysAPPLE"}
+    });
+
+static gl::ExtensionFunction<
+    void (GLsizei n,
+          GLuint* arrays)>
+    GenVertexArrays({
+        {"GL_ARB_vertex_array_object", "glGenVertexArrays"},
+        {"GL_OES_vertex_array_object", "glGenVertexArraysOES"},
+        {"GL_APPLE_vertex_array_object", "glGenVertexArraysAPPLE"}
+    });
+
+void VertexArrayObject::Bind(GLuint array) {
+    MBGL_CHECK_ERROR(BindVertexArray(array));
+}
+
+void VertexArrayObject::Delete(GLsizei n, const GLuint* arrays) {
+    MBGL_CHECK_ERROR(DeleteVertexArrays(n, arrays));
+}
+
 VertexArrayObject::VertexArrayObject() {
 }
 
 VertexArrayObject::~VertexArrayObject() {
-    if (!gl::DeleteVertexArrays) return;
+    if (!DeleteVertexArrays) return;
 
     if (vao) {
         Environment::Get().abandonVAO(vao);
@@ -17,7 +51,7 @@ VertexArrayObject::~VertexArrayObject() {
 }
 
 void VertexArrayObject::bindVertexArrayObject() {
-    if (!gl::GenVertexArrays || !gl::BindVertexArray) {
+    if (!GenVertexArrays || !BindVertexArray) {
         static bool reported = false;
         if (!reported) {
             Log::Warning(Event::OpenGL, "Not using Vertex Array Objects");
@@ -27,9 +61,9 @@ void VertexArrayObject::bindVertexArrayObject() {
     }
 
     if (!vao) {
-        MBGL_CHECK_ERROR(gl::GenVertexArrays(1, &vao));
+        MBGL_CHECK_ERROR(GenVertexArrays(1, &vao));
     }
-    MBGL_CHECK_ERROR(gl::BindVertexArray(vao));
+    MBGL_CHECK_ERROR(BindVertexArray(vao));
 }
 
 void VertexArrayObject::verifyBinding(Shader &shader, GLuint vertexBuffer, GLuint elementsBuffer,
diff --git a/src/mbgl/geometry/vao.hpp b/src/mbgl/geometry/vao.hpp
index 72bacfd793..e35fcc9bf8 100644
--- a/src/mbgl/geometry/vao.hpp
+++ b/src/mbgl/geometry/vao.hpp
@@ -11,6 +11,9 @@ namespace mbgl {
 
 class VertexArrayObject : public util::noncopyable {
 public:
+    static void Bind(GLuint array);
+    static void Delete(GLsizei n, const GLuint* arrays);
+
     VertexArrayObject();
     ~VertexArrayObject();
 
diff --git a/src/mbgl/gl/debugging.cpp b/src/mbgl/gl/debugging.cpp
new file mode 100644
index 0000000000..5fc90e8274
--- /dev/null
+++ b/src/mbgl/gl/debugging.cpp
@@ -0,0 +1,195 @@
+#include <mbgl/gl/debugging.hpp>
+#include <mbgl/platform/gl.hpp>
+#include <mbgl/platform/event.hpp>
+#include <mbgl/platform/log.hpp>
+
+#define GL_DEBUG_OUTPUT_SYNCHRONOUS       0x8242
+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
+#define GL_DEBUG_CALLBACK_FUNCTION        0x8244
+#define GL_DEBUG_CALLBACK_USER_PARAM      0x8245
+#define GL_DEBUG_SOURCE_API               0x8246
+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM     0x8247
+#define GL_DEBUG_SOURCE_SHADER_COMPILER   0x8248
+#define GL_DEBUG_SOURCE_THIRD_PARTY       0x8249
+#define GL_DEBUG_SOURCE_APPLICATION       0x824A
+#define GL_DEBUG_SOURCE_OTHER             0x824B
+#define GL_DEBUG_TYPE_ERROR               0x824C
+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D
+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR  0x824E
+#define GL_DEBUG_TYPE_PORTABILITY         0x824F
+#define GL_DEBUG_TYPE_PERFORMANCE         0x8250
+#define GL_DEBUG_TYPE_OTHER               0x8251
+#define GL_MAX_DEBUG_MESSAGE_LENGTH       0x9143
+#define GL_MAX_DEBUG_LOGGED_MESSAGES      0x9144
+#define GL_DEBUG_LOGGED_MESSAGES          0x9145
+#define GL_DEBUG_SEVERITY_HIGH            0x9146
+#define GL_DEBUG_SEVERITY_MEDIUM          0x9147
+#define GL_DEBUG_SEVERITY_LOW             0x9148
+#define GL_DEBUG_TYPE_MARKER              0x8268
+#define GL_DEBUG_TYPE_PUSH_GROUP          0x8269
+#define GL_DEBUG_TYPE_POP_GROUP           0x826A
+#define GL_DEBUG_SEVERITY_NOTIFICATION    0x826B
+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH    0x826C
+#define GL_DEBUG_GROUP_STACK_DEPTH        0x826D
+#define GL_BUFFER                         0x82E0
+#define GL_SHADER                         0x82E1
+#define GL_PROGRAM                        0x82E2
+#define GL_QUERY                          0x82E3
+#define GL_PROGRAM_PIPELINE               0x82E4
+#define GL_SAMPLER                        0x82E6
+#define GL_MAX_LABEL_LENGTH               0x82E8
+#define GL_DEBUG_OUTPUT                   0x92E0
+#define GL_CONTEXT_FLAG_DEBUG_BIT         0x00000002
+#define GL_DISPLAY_LIST                   0x82E7
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_TRANSFORM_FEEDBACK             0x8E22
+#define GL_TEXTURE                        0x1702
+#define GL_RENDERBUFFER                   0x8D41
+#define GL_FRAMEBUFFER                    0x8D40
+
+namespace mbgl {
+namespace gl {
+namespace debugging {
+
+typedef void (*GLDEBUGPROC)(GLenum source,
+                            GLenum type,
+                            GLuint id,
+                            GLenum severity,
+                            GLsizei length,
+                            const GLchar *message,
+                            const void *userParam);
+
+static ExtensionFunction<
+    void (GLenum source,
+          GLenum type,
+          GLenum severity,
+          GLsizei count,
+          const GLuint *ids,
+          GLboolean enabled)>
+    DebugMessageControl({
+        {"GL_KHR_debug",        "glDebugMessageControl"},
+        {"GL_ARB_debug_output", "glDebugMessageControlARB"}
+    });
+
+static ExtensionFunction<
+    void (GLDEBUGPROC callback,
+          const void *userParam)>
+    DebugMessageCallback({
+        {"GL_KHR_debug",        "glDebugMessageCallback"},
+        {"GL_ARB_debug_output", "glDebugMessageCallbackARB"}
+    });
+
+static ExtensionFunction<
+    void (GLenum source,
+          GLuint id,
+          GLsizei length,
+          const GLchar *message)>
+    PushDebugGroup({
+        {"GL_KHR_debug", "glPushDebugGroup"}
+    });
+
+static ExtensionFunction<
+    void ()>
+    PopDebugGroup({
+        {"GL_KHR_debug", "glPopDebugGroup"}
+    });
+
+static ExtensionFunction<
+    void (GLsizei length,
+          const GLchar *marker)>
+    PushGroupMarkerEXT({
+      {"GL_EXT_debug_marker", "glPushGroupMarkerEXT"}
+    });
+
+static ExtensionFunction<
+    void ()>
+    PopGroupMarkerEXT({
+      {"GL_EXT_debug_marker", "glPopGroupMarkerEXT"}
+    });
+
+void debugCallback(GLenum source,
+                   GLenum type,
+                   GLuint id,
+                   GLenum severity,
+                   GLsizei /*length*/,
+                   const GLchar* message,
+                   const void* /*userParam*/)
+{
+    std::string strSource;
+    switch (source) {
+        case GL_DEBUG_SOURCE_API: strSource = "DEBUG_SOURCE_API"; break;
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: strSource = "DEBUG_SOURCE_WINDOW_SYSTEM"; break;
+        case GL_DEBUG_SOURCE_SHADER_COMPILER: strSource = "DEBUG_SOURCE_SHADER_COMPILER"; break;
+        case GL_DEBUG_SOURCE_THIRD_PARTY: strSource = "DEBUG_SOURCE_THIRD_PARTY"; break;
+        case GL_DEBUG_SOURCE_APPLICATION: strSource = "DEBUG_SOURCE_APPLICATION"; break;
+        case GL_DEBUG_SOURCE_OTHER: strSource = "DEBUG_SOURCE_OTHER"; break;
+        default: strSource = "(unknown)"; break;
+    }
+
+    std::string strType;
+    switch (type) {
+        case GL_DEBUG_TYPE_ERROR: strType = "DEBUG_TYPE_ERROR"; break;
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: strType = "DEBUG_TYPE_DEPRECATED_BEHAVIOR"; break;
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: strType = "DEBUG_TYPE_UNDEFINED_BEHAVIOR"; break;
+        case GL_DEBUG_TYPE_PERFORMANCE: strType = "DEBUG_TYPE_PERFORMANCE"; break;
+        case GL_DEBUG_TYPE_PORTABILITY: strType = "DEBUG_TYPE_PORTABILITY"; break;
+        case GL_DEBUG_TYPE_OTHER: strType = "DEBUG_TYPE_OTHER"; break;
+        case GL_DEBUG_TYPE_MARKER: strType = "DEBUG_TYPE_MARKER"; break;
+        case GL_DEBUG_TYPE_PUSH_GROUP: strType = "DEBUG_TYPE_OTHER"; break;
+        case GL_DEBUG_TYPE_POP_GROUP: strType = "DEBUG_TYPE_POP_GROUP"; break;
+        default: strSource = "(unknown)"; break;
+    }
+
+    std::string strSeverity;
+    mbgl::EventSeverity evtSeverity;
+    switch (severity) {
+        case GL_DEBUG_SEVERITY_HIGH: strSeverity = "DEBUG_SEVERITY_HIGH"; evtSeverity = mbgl::EventSeverity::Error; break;
+        case GL_DEBUG_SEVERITY_MEDIUM: strSeverity = "DEBUG_SEVERITY_MEDIUM"; evtSeverity = mbgl::EventSeverity::Warning; break;
+        case GL_DEBUG_SEVERITY_LOW: strSeverity = "DEBUG_SEVERITY_LOW"; evtSeverity = mbgl::EventSeverity::Info; break;
+        case GL_DEBUG_SEVERITY_NOTIFICATION: strSeverity = "DEBUG_SEVERITY_NOTIFICATION"; evtSeverity = mbgl::EventSeverity::Debug; break;
+        default: strSource = "(unknown)"; evtSeverity = mbgl::EventSeverity::Debug; break;
+    }
+
+    mbgl::Log::Record(evtSeverity, mbgl::Event::OpenGL, "GL_%s GL_%s %u GL_%s - %s", strSource.c_str(), strType.c_str(), id, strSeverity.c_str(), message);
+}
+
+void enable() {
+    if (!DebugMessageControl || !DebugMessageCallback) {
+        return;
+    }
+
+    // This will enable all messages including performance hints
+    //MBGL_CHECK_ERROR(DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE));
+
+    // This will only enable high and medium severity messages
+    MBGL_CHECK_ERROR(DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE));
+    MBGL_CHECK_ERROR(DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE));
+    MBGL_CHECK_ERROR(DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, nullptr, GL_FALSE));
+
+    MBGL_CHECK_ERROR(DebugMessageCallback(debugCallback, nullptr));
+}
+
+#if defined(DEBUG)
+group::group(const std::string& str) {
+    if (PushDebugGroup) {
+        PushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, GLsizei(str.size()), str.c_str());
+    } else if (PushGroupMarkerEXT) {
+        PushGroupMarkerEXT(GLsizei(str.size()), str.c_str());
+    }
+}
+
+group::~group() {
+    if (PopDebugGroup) {
+        PopDebugGroup();
+    } else if (PopGroupMarkerEXT) {
+        PopGroupMarkerEXT();
+    }
+}
+#else
+group::group(const std::string&) {}
+group::~group() = default;
+#endif
+
+}
+}
+}
diff --git a/src/mbgl/gl/debugging.hpp b/src/mbgl/gl/debugging.hpp
new file mode 100644
index 0000000000..82d08a53fb
--- /dev/null
+++ b/src/mbgl/gl/debugging.hpp
@@ -0,0 +1,21 @@
+#ifndef MBGL_GL_DEBUG_MESSAGES
+#define MBGL_GL_DEBUG_MESSAGES
+
+#include <string>
+
+namespace mbgl {
+namespace gl {
+namespace debugging {
+
+void enable();
+
+struct group {
+    group(const std::string&);
+    ~group();
+};
+
+}
+}
+}
+
+#endif
diff --git a/src/mbgl/map/environment.cpp b/src/mbgl/map/environment.cpp
index 327efeecff..d121f96555 100644
--- a/src/mbgl/map/environment.cpp
+++ b/src/mbgl/map/environment.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/platform/gl.hpp>
 #include <mbgl/util/run_loop.hpp>
+#include <mbgl/geometry/vao.hpp>
 
 #include <uv.h>
 
@@ -155,8 +156,8 @@ void Environment::performCleanup() {
     assert(currentlyOn(ThreadType::Map));
 
     if (!abandonedVAOs.empty()) {
-        MBGL_CHECK_ERROR(gl::DeleteVertexArrays(static_cast<GLsizei>(abandonedVAOs.size()),
-                                                abandonedVAOs.data()));
+        MBGL_CHECK_ERROR(VertexArrayObject::Delete(static_cast<GLsizei>(abandonedVAOs.size()),
+                                                   abandonedVAOs.data()));
         abandonedVAOs.clear();
     }
 
diff --git a/src/mbgl/map/source.cpp b/src/mbgl/map/source.cpp
index afe775be30..686b15c24e 100644
--- a/src/mbgl/map/source.cpp
+++ b/src/mbgl/map/source.cpp
@@ -21,6 +21,7 @@
 #include <mbgl/map/raster_tile_data.hpp>
 #include <mbgl/map/live_tile_data.hpp>
 #include <mbgl/style/style.hpp>
+#include <mbgl/gl/debugging.hpp>
 
 #include <algorithm>
 
@@ -179,7 +180,7 @@ void Source::updateMatrices(const mat4 &projMatrix, const TransformState &transf
 void Source::drawClippingMasks(Painter &painter) {
     for (const auto& pair : tiles) {
         Tile &tile = *pair.second;
-        gl::group group(std::string { "mask: " } + std::string(tile.id));
+        gl::debugging::group group(std::string { "mask: " } + std::string(tile.id));
         painter.drawClippingMask(tile.matrix, tile.clip);
     }
 }
diff --git a/src/mbgl/platform/gl.cpp b/src/mbgl/platform/gl.cpp
index 096ec8393f..3d8a237c70 100644
--- a/src/mbgl/platform/gl.cpp
+++ b/src/mbgl/platform/gl.cpp
@@ -1,75 +1,31 @@
 #include <mbgl/platform/gl.hpp>
-#include <mbgl/platform/log.hpp>
-
-#include <iostream>
-
 
 namespace mbgl {
 namespace gl {
 
-PFNGLDEBUGMESSAGECONTROLPROC DebugMessageControl = nullptr;
-PFNGLDEBUGMESSAGEINSERTPROC DebugMessageInsert = nullptr;
-PFNGLDEBUGMESSAGECALLBACKPROC DebugMessageCallback = nullptr;
-PFNGLGETDEBUGMESSAGELOGPROC GetDebugMessageLog = nullptr;
-PFNGLGETPOINTERVPROC GetPointerv = nullptr;
-PFNGLPUSHDEBUGGROUPPROC PushDebugGroup = nullptr;
-PFNGLPOPDEBUGGROUPPROC PopDebugGroup = nullptr;
-PFNGLOBJECTLABELPROC ObjectLabel = nullptr;
-PFNGLGETOBJECTLABELPROC GetObjectLabel = nullptr;
-PFNGLOBJECTPTRLABELPROC ObjectPtrLabel = nullptr;
-PFNGLGETOBJECTPTRLABELPROC GetObjectPtrLabel = nullptr;
+std::vector<ExtensionFunctionBase*>& ExtensionFunctionBase::functions() {
+    static std::vector<ExtensionFunctionBase*> functions;
+    return functions;
+}
 
-void debug_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei, const GLchar *message, const void *) {
-    std::string strSource;
-    switch (source) {
-        case GL_DEBUG_SOURCE_API: strSource = "DEBUG_SOURCE_API"; break;
-        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: strSource = "DEBUG_SOURCE_WINDOW_SYSTEM"; break;
-        case GL_DEBUG_SOURCE_SHADER_COMPILER: strSource = "DEBUG_SOURCE_SHADER_COMPILER"; break;
-        case GL_DEBUG_SOURCE_THIRD_PARTY: strSource = "DEBUG_SOURCE_THIRD_PARTY"; break;
-        case GL_DEBUG_SOURCE_APPLICATION: strSource = "DEBUG_SOURCE_APPLICATION"; break;
-        case GL_DEBUG_SOURCE_OTHER: strSource = "DEBUG_SOURCE_OTHER"; break;
-        default: strSource = "(unknown)"; break;
-    }
+void InitializeExtensions(glProc (*getProcAddress)(const char *)) {
+    const char * extensionsPtr = reinterpret_cast<const char *>(
+        MBGL_CHECK_ERROR(glGetString(GL_EXTENSIONS)));
 
-    std::string strType;
-    switch (type) {
-        case GL_DEBUG_TYPE_ERROR: strType = "DEBUG_TYPE_ERROR"; break;
-        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: strType = "DEBUG_TYPE_DEPRECATED_BEHAVIOR"; break;
-        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: strType = "DEBUG_TYPE_UNDEFINED_BEHAVIOR"; break;
-        case GL_DEBUG_TYPE_PERFORMANCE: strType = "DEBUG_TYPE_PERFORMANCE"; break;
-        case GL_DEBUG_TYPE_PORTABILITY: strType = "DEBUG_TYPE_PORTABILITY"; break;
-        case GL_DEBUG_TYPE_OTHER: strType = "DEBUG_TYPE_OTHER"; break;
-        case GL_DEBUG_TYPE_MARKER: strType = "DEBUG_TYPE_MARKER"; break;
-        case GL_DEBUG_TYPE_PUSH_GROUP: strType = "DEBUG_TYPE_OTHER"; break;
-        case GL_DEBUG_TYPE_POP_GROUP: strType = "DEBUG_TYPE_POP_GROUP"; break;
-        default: strSource = "(unknown)"; break;
-    }
+    if (!extensionsPtr)
+        return;
 
-    std::string strSeverity;
-    mbgl::EventSeverity evtSeverity;
-    switch (severity) {
-        case GL_DEBUG_SEVERITY_HIGH: strSeverity = "DEBUG_SEVERITY_HIGH"; evtSeverity = mbgl::EventSeverity::Error; break;
-        case GL_DEBUG_SEVERITY_MEDIUM: strSeverity = "DEBUG_SEVERITY_MEDIUM"; evtSeverity = mbgl::EventSeverity::Warning; break;
-        case GL_DEBUG_SEVERITY_LOW: strSeverity = "DEBUG_SEVERITY_LOW"; evtSeverity = mbgl::EventSeverity::Info; break;
-        case GL_DEBUG_SEVERITY_NOTIFICATION: strSeverity = "DEBUG_SEVERITY_NOTIFICATION"; evtSeverity = mbgl::EventSeverity::Debug; break;
-        default: strSource = "(unknown)"; evtSeverity = mbgl::EventSeverity::Debug; break;
+    const std::string extensions = extensionsPtr;
+    for (auto fn : ExtensionFunctionBase::functions()) {
+        for (auto probe : fn->probes) {
+            if (extensions.find(probe.first) != std::string::npos) {
+                fn->ptr = getProcAddress(probe.second);
+                break;
+            }
+        }
     }
-
-    mbgl::Log::Record(evtSeverity, mbgl::Event::OpenGL, "GL_%s GL_%s %u GL_%s - %s", strSource.c_str(), strType.c_str(), id, strSeverity.c_str(), message);
 }
 
-PFNGLINSERTEVENTMARKEREXTPROC InsertEventMarkerEXT = nullptr;
-PFNGLPUSHGROUPMARKEREXTPROC PushGroupMarkerEXT = nullptr;
-PFNGLPOPGROUPMARKEREXTPROC PopGroupMarkerEXT = nullptr;
-
-PFNGLLABELOBJECTEXTPROC LabelObjectEXT = nullptr;
-PFNGLGETOBJECTLABELEXTPROC GetObjectLabelEXT = nullptr;
-
-PFNGLBINDVERTEXARRAYPROC BindVertexArray = nullptr;
-PFNGLDELETEVERTEXARRAYSPROC DeleteVertexArrays = nullptr;
-PFNGLGENVERTEXARRAYSPROC GenVertexArrays = nullptr;
-PFNGLISVERTEXARRAYPROC IsVertexArray = nullptr;
-
 void checkError(const char *cmd, const char *file, int line) {
     const GLenum err = glGetError();
     if (err != GL_NO_ERROR) {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 56d814c03a..f306dec2d3 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/map/tile.hpp>
 
 #include <mbgl/platform/log.hpp>
+#include <mbgl/gl/debugging.hpp>
 
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/style_layer.hpp>
@@ -56,18 +57,7 @@ bool Painter::needsAnimation() const {
 }
 
 void Painter::setup() {
-    // Enable GL debugging
-    if ((gl::DebugMessageControl != nullptr) && (gl::DebugMessageCallback != nullptr)) {
-        // This will enable all messages including performance hints
-        //MBGL_CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE));
-
-        // This will only enable high and medium severity messages
-        MBGL_CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, GL_TRUE));
-        MBGL_CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, GL_TRUE));
-        MBGL_CHECK_ERROR(gl::DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, nullptr, GL_FALSE));
-
-        MBGL_CHECK_ERROR(gl::DebugMessageCallback(gl::debug_callback, nullptr));
-    }
+    gl::debugging::enable();
 
     setupShaders();
 
@@ -160,7 +150,7 @@ void Painter::changeMatrix() {
 }
 
 void Painter::clear() {
-    gl::group group("clear");
+    gl::debugging::group group("clear");
     config.stencilTest = true;
     config.stencilMask = 0xFF;
     config.depthTest = false;
@@ -212,7 +202,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // - UPLOAD PASS -------------------------------------------------------------------------------
     // Uploads all required buffers and images before we do any actual rendering.
     {
-        const gl::group upload("upload");
+        const gl::debugging::group upload("upload");
 
         tileStencilBuffer.upload();
         tileBorderBuffer.upload();
@@ -231,7 +221,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // - CLIPPING MASKS ----------------------------------------------------------------------------
     // Draws the clipping masks to the stencil buffer.
     {
-        const gl::group clip("clip");
+        const gl::debugging::group clip("clip");
 
         // Update all clipping IDs.
         ClipIDGenerator generator;
@@ -259,7 +249,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // - OPAQUE PASS -------------------------------------------------------------------------------
     // Render everything top-to-bottom by using reverse iterators. Render opaque objects first.
     {
-        const gl::group _("opaque");
+        const gl::debugging::group _("opaque");
 
         if (debug::renderTree) {
             Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "OPAQUE {");
@@ -270,13 +260,13 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
             const auto& item = *it;
             if (item.bucket && item.tile) {
                 if (item.hasRenderPass(RenderPass::Opaque)) {
-                    const gl::group group(item.layer.id + " - " + std::string(item.tile->id));
+                    const gl::debugging::group group(item.layer.id + " - " + std::string(item.tile->id));
                     setStrata(i * strata_thickness);
                     prepareTile(*item.tile);
                     item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix);
                 }
             } else {
-                const gl::group group("background");
+                const gl::debugging::group group("background");
                 setStrata(i * strata_thickness);
                 renderBackground(item.layer);
             }
@@ -289,7 +279,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // - TRANSLUCENT PASS --------------------------------------------------------------------------
     // Make a second pass, rendering translucent objects. This time, we render bottom-to-top.
     {
-        const gl::group _("translucent");
+        const gl::debugging::group _("translucent");
 
         if (debug::renderTree) {
             Log::Info(Event::Render, "%*s%s", indent++ * 4, "", "TRANSLUCENT {");
@@ -300,7 +290,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
             const auto& item = *it;
             if (item.bucket && item.tile) {
                 if (item.hasRenderPass(RenderPass::Translucent)) {
-                    const gl::group group(item.layer.id + " - " + std::string(item.tile->id));
+                    const gl::debugging::group group(item.layer.id + " - " + std::string(item.tile->id));
                     setStrata(i * strata_thickness);
                     prepareTile(*item.tile);
                     item.bucket->render(*this, item.layer, item.tile->id, item.tile->matrix);
@@ -317,7 +307,7 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // - DEBUG PASS --------------------------------------------------------------------------------
     // Renders debug overlays.
     {
-        const gl::group _("debug");
+        const gl::debugging::group _("debug");
 
         // Finalize the rendering, e.g. by calling debug render calls per tile.
         // This guarantees that we have at least one function per tile called.
@@ -331,10 +321,10 @@ void Painter::render(const Style& style, TransformState state_, TimePoint time)
     // TODO: Find a better way to unbind VAOs after we're done with them without introducing
     // unnecessary bind(0)/bind(N) sequences.
     {
-        const gl::group _("cleanup");
+        const gl::debugging::group _("cleanup");
 
         MBGL_CHECK_ERROR(glBindTexture(GL_TEXTURE_2D, 0));
-        MBGL_CHECK_ERROR(gl::BindVertexArray(0));
+        MBGL_CHECK_ERROR(VertexArrayObject::Bind(0));
     }
 }
 
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index c495359282..c2a8e6f500 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/map/source.hpp>
 #include <mbgl/shader/plain_shader.hpp>
 #include <mbgl/util/clip_id.hpp>
+#include <mbgl/gl/debugging.hpp>
 
 #ifndef BUFFER_OFFSET
 #define BUFFER_OFFSET(i) ((char *)nullptr + (i))
@@ -10,7 +11,7 @@
 using namespace mbgl;
 
 void Painter::drawClippingMasks(const std::set<Source*>& sources) {
-    gl::group group("clipping masks");
+    gl::debugging::group group("clipping masks");
 
     useProgram(plainShader->program);
     config.stencilTest = true;
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index b252e2e835..d4306d3e1a 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/shader/plain_shader.hpp>
 #include <mbgl/util/string.hpp>
+#include <mbgl/gl/debugging.hpp>
 
 #ifndef BUFFER_OFFSET
 #define BUFFER_OFFSET(i) ((char *)nullptr + (i))
@@ -12,7 +13,7 @@
 using namespace mbgl;
 
 void Painter::renderTileDebug(const Tile& tile) {
-    gl::group group(std::string { "debug " } + std::string(tile.id));
+    gl::debugging::group group(std::string { "debug " } + std::string(tile.id));
     assert(tile.data);
     if (debug) {
         prepareTile(tile);
@@ -22,7 +23,7 @@ void Painter::renderTileDebug(const Tile& tile) {
 }
 
 void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
-    gl::group group("debug text");
+    gl::debugging::group group("debug text");
 
     config.depthTest = false;
 
@@ -49,7 +50,7 @@ void Painter::renderDebugText(DebugBucket& bucket, const mat4 &matrix) {
 }
 
 void Painter::renderDebugFrame(const mat4 &matrix) {
-    gl::group group("debug frame");
+    gl::debugging::group group("debug frame");
 
     // Disable depth test and don't count this towards the depth buffer,
     // but *don't* disable stencil test, as we want to clip the red tile border
@@ -72,7 +73,7 @@ void Painter::renderDebugText(const std::vector<std::string> &strings) {
         return;
     }
 
-    gl::group group("debug text");
+    gl::debugging::group group("debug text");
 
     config.depthTest = false;
     config.stencilTest = true;