diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp
index 43d1c95..11d9272 100644
--- a/libs/hwui/Android.bp
+++ b/libs/hwui/Android.bp
@@ -92,28 +92,6 @@
     ],
 }
 
-cc_defaults {
-    name: "hwui_debug",
-    cflags: ["-include debug/wrap_gles.h"],
-    srcs: [
-        "debug/wrap_gles.cpp",
-        "debug/DefaultGlesDriver.cpp",
-        "debug/GlesErrorCheckWrapper.cpp",
-        "debug/GlesDriver.cpp",
-        "debug/FatalBaseDriver.cpp",
-        "debug/NullGlesDriver.cpp",
-        "debug/NullSkiaInterface.cpp",
-    ],
-    include_dirs: ["frameworks/native/opengl/libs/GLES2"],
-}
-
-cc_defaults {
-    name: "hwui_enable_opengl_validation",
-    defaults: ["hwui_debug"],
-    cflags: ["-DDEBUG_OPENGL=3"],
-    include_dirs: ["frameworks/native/opengl/libs/GLES2"],
-}
-
 // Build libhwui with PGO by default.
 // Location of PGO profile data is defined in build/soong/cc/pgo.go
 // and is separate from hwui.
@@ -248,27 +226,13 @@
     name: "libhwui",
     defaults: [
         "libhwui_defaults",
-
-        // Enables fine-grained GLES error checking
-        // If enabled, every GLES call is wrapped & error checked
-        // Has moderate overhead
-        //"hwui_enable_opengl_validation",
     ],
 }
 
-// ------------------------
-// static library null gpu
-// ------------------------
-
 cc_library_static {
-    name: "libhwui_static_debug",
+    name: "libhwui_static",
     defaults: [
         "libhwui_defaults",
-        "hwui_debug",
-    ],
-    cflags: ["-DHWUI_NULL_GPU"],
-    srcs: [
-        "debug/nullegl.cpp",
     ],
 }
 
@@ -296,15 +260,11 @@
 
     static_libs: [
         "libgmock",
-        "libhwui_static_debug",
+        "libhwui_static",
     ],
     shared_libs: [
         "libmemunreachable",
     ],
-    cflags: [
-        "-include debug/wrap_gles.h",
-        "-DHWUI_NULL_GPU",
-    ],
 
     srcs: [
         "tests/unit/main.cpp",
@@ -348,8 +308,7 @@
     name: "hwuimacro",
     defaults: ["hwui_test_defaults"],
 
-    // set to libhwui_static_debug to skip actual GL commands
-    whole_static_libs: ["libhwui"],
+    static_libs: ["libhwui"],
     shared_libs: [
         "libmemunreachable",
     ],
@@ -368,12 +327,7 @@
     name: "hwuimicro",
     defaults: ["hwui_test_defaults"],
 
-    cflags: [
-        "-include debug/wrap_gles.h",
-        "-DHWUI_NULL_GPU",
-    ],
-
-    whole_static_libs: ["libhwui_static_debug"],
+    static_libs: ["libhwui_static"],
     shared_libs: [
         "libmemunreachable",
     ],
diff --git a/libs/hwui/Properties.cpp b/libs/hwui/Properties.cpp
index 2196b0f..7c2132d 100644
--- a/libs/hwui/Properties.cpp
+++ b/libs/hwui/Properties.cpp
@@ -178,14 +178,14 @@
 }
 
 void Properties::overrideRenderPipelineType(RenderPipelineType type) {
-#if !defined(HWUI_GLES_WRAP_ENABLED)
     // If we're doing actual rendering then we can't change the renderer after it's been set.
     // Unit tests can freely change this as often as it wants, though, as there's no actual
     // GL rendering happening
     if (sRenderPipelineType != RenderPipelineType::NotInitialized) {
+        LOG_ALWAYS_FATAL_IF(sRenderPipelineType != type,
+                "Trying to change pipeline but it's already set");
         return;
     }
-#endif
     sRenderPipelineType = type;
 }
 
diff --git a/libs/hwui/debug/DefaultGlesDriver.cpp b/libs/hwui/debug/DefaultGlesDriver.cpp
deleted file mode 100644
index 46ab200..0000000
--- a/libs/hwui/debug/DefaultGlesDriver.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "DefaultGlesDriver.h"
-
-#include "gles_undefine.h"
-
-#include <EGL/egl.h>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-// Generate the proxy
-#define API_ENTRY(x) DefaultGlesDriver::x##_
-#define CALL_GL_API(x, ...) x(__VA_ARGS__);
-#define CALL_GL_API_RETURN(x, ...) return x(__VA_ARGS__);
-
-#include "gles_stubs.in"
-
-#undef API_ENTRY
-#undef CALL_GL_API
-#undef CALL_GL_API_RETURN
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/DefaultGlesDriver.h b/libs/hwui/debug/DefaultGlesDriver.h
deleted file mode 100644
index 8027ea2..0000000
--- a/libs/hwui/debug/DefaultGlesDriver.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "GlesDriver.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-class DefaultGlesDriver : public GlesDriver {
-public:
-#define GL_ENTRY(ret, api, ...) virtual ret api##_(__VA_ARGS__) override;
-#include "gles_decls.in"
-#undef GL_ENTRY
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/FatalBaseDriver.cpp b/libs/hwui/debug/FatalBaseDriver.cpp
deleted file mode 100644
index ed0f831..0000000
--- a/libs/hwui/debug/FatalBaseDriver.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "FatalBaseDriver.h"
-
-#include <log/log.h>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-// Generate the proxy
-#define API_ENTRY(x) FatalBaseDriver::x##_
-#define CALL_GL_API(x, ...) LOG_ALWAYS_FATAL("Not Implemented");
-#define CALL_GL_API_RETURN(x, ...)       \
-    LOG_ALWAYS_FATAL("Not Implemented"); \
-    return static_cast<decltype(x(__VA_ARGS__))>(0);
-
-#include "gles_stubs.in"
-
-#undef API_ENTRY
-#undef CALL_GL_API
-#undef CALL_GL_API_RETURN
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/FatalBaseDriver.h b/libs/hwui/debug/FatalBaseDriver.h
deleted file mode 100644
index 45353d0..0000000
--- a/libs/hwui/debug/FatalBaseDriver.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "GlesDriver.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-// A base driver that implements all the pure virtuals in the form of
-// LOG_ALWAYS_FATALS. Suitable for selective-override implementations
-// where only a known subset of methods need to be overridden
-class FatalBaseDriver : public GlesDriver {
-public:
-#define GL_ENTRY(ret, api, ...) virtual ret api##_(__VA_ARGS__) override;
-#include "gles_decls.in"
-#undef GL_ENTRY
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/GlesDriver.cpp b/libs/hwui/debug/GlesDriver.cpp
deleted file mode 100644
index 98f06b0..0000000
--- a/libs/hwui/debug/GlesDriver.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "GlesDriver.h"
-#include "DefaultGlesDriver.h"
-#include "GlesErrorCheckWrapper.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-static DefaultGlesDriver sDefaultDriver;
-
-static std::unique_ptr<GlesDriver> sGlesDriver(new GlesErrorCheckWrapper(sDefaultDriver));
-
-GlesDriver* GlesDriver::get() {
-    return sGlesDriver.get();
-}
-
-std::unique_ptr<GlesDriver> GlesDriver::replace(std::unique_ptr<GlesDriver>&& driver) {
-    std::unique_ptr<GlesDriver> ret = std::move(sGlesDriver);
-    sGlesDriver = std::move(driver);
-    return ret;
-}
-
-sk_sp<const GrGLInterface> GlesDriver::getSkiaInterface() {
-    sk_sp<const GrGLInterface> skiaInterface(GrGLCreateNativeInterface());
-    return skiaInterface;
-}
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/GlesDriver.h b/libs/hwui/debug/GlesDriver.h
deleted file mode 100644
index 1c77c1a..0000000
--- a/libs/hwui/debug/GlesDriver.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#ifndef HWUI_GLES_WRAP_ENABLED
-#error Wrapping wasn't enabled, can't use this!
-#endif
-
-#include <GLES/gl.h>
-#include <GLES/glext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <GLES3/gl3.h>
-#include <GLES3/gl31.h>
-#include <GLES3/gl32.h>
-
-#include <gl/GrGLInterface.h>
-#include <memory>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-// All the gl methods on GlesDriver have a trailing underscore
-// This is to avoid collision with gles_redefine/gles_undefine
-class GlesDriver {
-public:
-    virtual ~GlesDriver() {}
-    virtual sk_sp<const GrGLInterface> getSkiaInterface();
-
-#define GL_ENTRY(ret, api, ...) virtual ret api##_(__VA_ARGS__) = 0;
-#include "gles_decls.in"
-#undef GL_ENTRY
-
-    static GlesDriver* get();
-    static std::unique_ptr<GlesDriver> replace(std::unique_ptr<GlesDriver>&& driver);
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/GlesErrorCheckWrapper.cpp b/libs/hwui/debug/GlesErrorCheckWrapper.cpp
deleted file mode 100644
index 8d11c19..0000000
--- a/libs/hwui/debug/GlesErrorCheckWrapper.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "GlesErrorCheckWrapper.h"
-
-#include <log/log.h>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-void GlesErrorCheckWrapper::assertNoErrors(const char* apicall) {
-    GLenum status = GL_NO_ERROR;
-    GLenum lastError = GL_NO_ERROR;
-    const char* lastErrorName = nullptr;
-    while ((status = mBase.glGetError_()) != GL_NO_ERROR) {
-        lastError = status;
-        switch (status) {
-            case GL_INVALID_ENUM:
-                ALOGE("GL error:  GL_INVALID_ENUM");
-                lastErrorName = "GL_INVALID_ENUM";
-                break;
-            case GL_INVALID_VALUE:
-                ALOGE("GL error:  GL_INVALID_VALUE");
-                lastErrorName = "GL_INVALID_VALUE";
-                break;
-            case GL_INVALID_OPERATION:
-                ALOGE("GL error:  GL_INVALID_OPERATION");
-                lastErrorName = "GL_INVALID_OPERATION";
-                break;
-            case GL_OUT_OF_MEMORY:
-                ALOGE("GL error:  Out of memory!");
-                lastErrorName = "GL_OUT_OF_MEMORY";
-                break;
-            default:
-                ALOGE("GL error: 0x%x", status);
-                lastErrorName = "UNKNOWN";
-        }
-    }
-    LOG_ALWAYS_FATAL_IF(lastError != GL_NO_ERROR, "%s error! %s (0x%x)", apicall, lastErrorName,
-                        lastError);
-}
-
-#define API_ENTRY(x) GlesErrorCheckWrapper::x##_
-#define CALL_GL_API(x, ...)  \
-    mBase.x##_(__VA_ARGS__); \
-    assertNoErrors(#x)
-
-#define CALL_GL_API_RETURN(x, ...)      \
-    auto ret = mBase.x##_(__VA_ARGS__); \
-    assertNoErrors(#x);                 \
-    return ret
-
-#include "gles_stubs.in"
-
-#undef API_ENTRY
-#undef CALL_GL_API
-#undef CALL_GL_API_RETURN
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/GlesErrorCheckWrapper.h b/libs/hwui/debug/GlesErrorCheckWrapper.h
deleted file mode 100644
index 791400b..0000000
--- a/libs/hwui/debug/GlesErrorCheckWrapper.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "GlesDriver.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-class GlesErrorCheckWrapper : public GlesDriver {
-public:
-    explicit GlesErrorCheckWrapper(GlesDriver& base) : mBase(base) {}
-
-#define GL_ENTRY(ret, api, ...) virtual ret api##_(__VA_ARGS__) override;
-#include "gles_decls.in"
-#undef GL_ENTRY
-
-private:
-    void assertNoErrors(const char* apicall);
-
-    GlesDriver& mBase;
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/MockGlesDriver.h b/libs/hwui/debug/MockGlesDriver.h
deleted file mode 100644
index e48ca19..0000000
--- a/libs/hwui/debug/MockGlesDriver.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "FatalBaseDriver.h"
-
-#include <gmock/gmock.h>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-class MockGlesDriver : public FatalBaseDriver {
-public:
-    MOCK_METHOD2(glBindBuffer_, void(GLenum target, GLuint buffer));
-    MOCK_METHOD4(glBufferData_,
-                 void(GLenum target, GLsizeiptr size, const void* data, GLenum usage));
-    MOCK_METHOD2(glGenBuffers_, void(GLsizei n, GLuint* buffers));
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/NullGlesDriver.cpp b/libs/hwui/debug/NullGlesDriver.cpp
deleted file mode 100644
index f27adf0..0000000
--- a/libs/hwui/debug/NullGlesDriver.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <debug/NullGlesDriver.h>
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-extern const GrGLInterface* CreateNullSkiaInterface();
-
-sk_sp<const GrGLInterface> NullGlesDriver::getSkiaInterface() {
-    sk_sp<const GrGLInterface> skiaInterface(CreateNullSkiaInterface());
-    return skiaInterface;
-}
-
-struct {
-    GLboolean scissorEnabled;
-} gState;
-
-static void nullglGenCommon(GLsizei n, GLuint* buffers) {
-    static GLuint nextId = 0;
-    int i;
-    for (i = 0; i < n; i++) {
-        buffers[i] = ++nextId;
-    }
-}
-
-void NullGlesDriver::glGenBuffers_(GLsizei n, GLuint* buffers) {
-    nullglGenCommon(n, buffers);
-}
-
-void NullGlesDriver::glGenFramebuffers_(GLsizei n, GLuint* framebuffers) {
-    nullglGenCommon(n, framebuffers);
-}
-
-void NullGlesDriver::glGenRenderbuffers_(GLsizei n, GLuint* renderbuffers) {
-    nullglGenCommon(n, renderbuffers);
-}
-
-void NullGlesDriver::glGenTextures_(GLsizei n, GLuint* textures) {
-    nullglGenCommon(n, textures);
-}
-
-GLuint NullGlesDriver::glCreateProgram_(void) {
-    static GLuint nextProgram = 0;
-    return ++nextProgram;
-}
-
-GLuint NullGlesDriver::glCreateShader_(GLenum type) {
-    static GLuint nextShader = 0;
-    return ++nextShader;
-}
-
-void NullGlesDriver::glGetProgramiv_(GLuint program, GLenum pname, GLint* params) {
-    switch (pname) {
-        case GL_DELETE_STATUS:
-        case GL_LINK_STATUS:
-        case GL_VALIDATE_STATUS:
-            *params = GL_TRUE;
-            break;
-        case GL_INFO_LOG_LENGTH:
-            *params = 16;
-            break;
-    }
-}
-
-void NullGlesDriver::glGetProgramInfoLog_(GLuint program, GLsizei bufSize, GLsizei* length,
-                                          GLchar* infoLog) {
-    *length = snprintf(infoLog, bufSize, "success");
-    if (*length >= bufSize) {
-        *length = bufSize - 1;
-    }
-}
-
-void NullGlesDriver::glGetShaderiv_(GLuint shader, GLenum pname, GLint* params) {
-    switch (pname) {
-        case GL_COMPILE_STATUS:
-        case GL_DELETE_STATUS:
-            *params = GL_TRUE;
-    }
-}
-
-void NullGlesDriver::glGetShaderInfoLog_(GLuint shader, GLsizei bufSize, GLsizei* length,
-                                         GLchar* infoLog) {
-    *length = snprintf(infoLog, bufSize, "success");
-    if (*length >= bufSize) {
-        *length = bufSize - 1;
-    }
-}
-
-void setBooleanState(GLenum cap, GLboolean value) {
-    switch (cap) {
-        case GL_SCISSOR_TEST:
-            gState.scissorEnabled = value;
-            break;
-    }
-}
-
-void NullGlesDriver::glEnable_(GLenum cap) {
-    setBooleanState(cap, GL_TRUE);
-}
-
-void NullGlesDriver::glDisable_(GLenum cap) {
-    setBooleanState(cap, GL_FALSE);
-}
-
-GLboolean NullGlesDriver::glIsEnabled_(GLenum cap) {
-    switch (cap) {
-        case GL_SCISSOR_TEST:
-            return gState.scissorEnabled;
-        default:
-            return GL_FALSE;
-    }
-}
-
-void NullGlesDriver::glGetIntegerv_(GLenum pname, GLint* data) {
-    switch (pname) {
-        case GL_MAX_TEXTURE_SIZE:
-            *data = 2048;
-            break;
-        case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
-            *data = 4;
-            break;
-        default:
-            *data = 0;
-    }
-}
-
-GLenum NullGlesDriver::glCheckFramebufferStatus_(GLenum target) {
-    switch (target) {
-        case GL_FRAMEBUFFER:
-            return GL_FRAMEBUFFER_COMPLETE;
-        default:
-            return 0;  // error case
-    }
-}
-
-static const char* getString(GLenum name) {
-    switch (name) {
-        case GL_VENDOR:
-            return "android";
-        case GL_RENDERER:
-            return "null";
-        case GL_VERSION:
-            return "OpenGL ES 2.0 rev1";
-        case GL_SHADING_LANGUAGE_VERSION:
-            return "OpenGL ES GLSL ES 2.0 rev1";
-        case GL_EXTENSIONS:
-        default:
-            return "";
-    }
-}
-
-const GLubyte* NullGlesDriver::glGetString_(GLenum name) {
-    return (GLubyte*)getString(name);
-}
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/NullGlesDriver.h b/libs/hwui/debug/NullGlesDriver.h
deleted file mode 100644
index 1a27dbc..0000000
--- a/libs/hwui/debug/NullGlesDriver.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "FatalBaseDriver.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-class NullGlesDriver : public FatalBaseDriver {
-public:
-    virtual sk_sp<const GrGLInterface> getSkiaInterface() override;
-
-    virtual void glGenBuffers_(GLsizei n, GLuint* buffers) override;
-    virtual void glGenFramebuffers_(GLsizei n, GLuint* framebuffers) override;
-    virtual void glGenRenderbuffers_(GLsizei n, GLuint* renderbuffers) override;
-    virtual void glGenTextures_(GLsizei n, GLuint* textures) override;
-    virtual GLuint glCreateProgram_(void) override;
-    virtual GLuint glCreateShader_(GLenum type) override;
-    virtual void glGetProgramiv_(GLuint program, GLenum pname, GLint* params) override;
-    virtual void glGetProgramInfoLog_(GLuint program, GLsizei bufSize, GLsizei* length,
-                                      GLchar* infoLog) override;
-    virtual void glGetShaderiv_(GLuint shader, GLenum pname, GLint* params) override;
-    virtual void glGetShaderInfoLog_(GLuint shader, GLsizei bufSize, GLsizei* length,
-                                     GLchar* infoLog) override;
-    virtual void glEnable_(GLenum cap) override;
-    virtual void glDisable_(GLenum cap) override;
-    virtual GLboolean glIsEnabled_(GLenum cap) override;
-    virtual void glGetIntegerv_(GLenum pname, GLint* data) override;
-    virtual const GLubyte* glGetString_(GLenum name) override;
-    virtual GLenum glCheckFramebufferStatus_(GLenum target) override;
-
-    virtual void glActiveTexture_(GLenum texture) override {}
-    virtual void glAttachShader_(GLuint program, GLuint shader) override {}
-    virtual void glBindAttribLocation_(GLuint program, GLuint index, const GLchar* name) override {}
-    virtual void glBindBuffer_(GLenum target, GLuint buffer) override {}
-    virtual void glBindFramebuffer_(GLenum target, GLuint framebuffer) override {}
-    virtual void glBindRenderbuffer_(GLenum target, GLuint renderbuffer) override {}
-    virtual void glBindTexture_(GLenum target, GLuint texture) override {}
-    virtual void glBlendColor_(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) override {}
-    virtual void glBlendEquation_(GLenum mode) override {}
-    virtual void glBlendEquationSeparate_(GLenum modeRGB, GLenum modeAlpha) override {}
-    virtual void glBlendFunc_(GLenum sfactor, GLenum dfactor) override {}
-    virtual void glBlendFuncSeparate_(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha,
-                                      GLenum dfactorAlpha) override {}
-    virtual void glBufferData_(GLenum target, GLsizeiptr size, const void* data,
-                               GLenum usage) override {}
-    virtual void glBufferSubData_(GLenum target, GLintptr offset, GLsizeiptr size,
-                                  const void* data) override {}
-    virtual void glClear_(GLbitfield mask) override {}
-    virtual void glClearColor_(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) override {}
-    virtual void glClearDepthf_(GLfloat d) override {}
-    virtual void glClearStencil_(GLint s) override {}
-    virtual void glColorMask_(GLboolean red, GLboolean green, GLboolean blue,
-                              GLboolean alpha) override {}
-    virtual void glCompileShader_(GLuint shader) override {}
-    virtual void glCompressedTexImage2D_(GLenum target, GLint level, GLenum internalformat,
-                                         GLsizei width, GLsizei height, GLint border,
-                                         GLsizei imageSize, const void* data) override {}
-    virtual void glCompressedTexSubImage2D_(GLenum target, GLint level, GLint xoffset,
-                                            GLint yoffset, GLsizei width, GLsizei height,
-                                            GLenum format, GLsizei imageSize,
-                                            const void* data) override {}
-    virtual void glCopyTexImage2D_(GLenum target, GLint level, GLenum internalformat, GLint x,
-                                   GLint y, GLsizei width, GLsizei height, GLint border) override {}
-    virtual void glCopyTexSubImage2D_(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-                                      GLint x, GLint y, GLsizei width, GLsizei height) override {}
-    virtual void glCullFace_(GLenum mode) override {}
-    virtual void glDeleteBuffers_(GLsizei n, const GLuint* buffers) override {}
-    virtual void glDeleteFramebuffers_(GLsizei n, const GLuint* framebuffers) override {}
-    virtual void glDeleteProgram_(GLuint program) override {}
-    virtual void glDeleteRenderbuffers_(GLsizei n, const GLuint* renderbuffers) override {}
-    virtual void glDeleteShader_(GLuint shader) override {}
-    virtual void glDeleteTextures_(GLsizei n, const GLuint* textures) override {}
-    virtual void glDepthFunc_(GLenum func) override {}
-    virtual void glDepthMask_(GLboolean flag) override {}
-    virtual void glDepthRangef_(GLfloat n, GLfloat f) override {}
-    virtual void glDetachShader_(GLuint program, GLuint shader) override {}
-    virtual void glDisableVertexAttribArray_(GLuint index) override {}
-    virtual void glDrawArrays_(GLenum mode, GLint first, GLsizei count) override {}
-    virtual void glDrawElements_(GLenum mode, GLsizei count, GLenum type,
-                                 const void* indices) override {}
-    virtual void glEnableVertexAttribArray_(GLuint index) override {}
-    virtual void glFinish_(void) override {}
-    virtual void glFlush_(void) override {}
-    virtual void glFramebufferRenderbuffer_(GLenum target, GLenum attachment,
-                                            GLenum renderbuffertarget,
-                                            GLuint renderbuffer) override {}
-    virtual void glFramebufferTexture2D_(GLenum target, GLenum attachment, GLenum textarget,
-                                         GLuint texture, GLint level) override {}
-    virtual void glFrontFace_(GLenum mode) override {}
-    virtual void glGenerateMipmap_(GLenum target) override {}
-    virtual GLint glGetAttribLocation_(GLuint program, const GLchar* name) override { return 1; }
-    virtual GLenum glGetError_(void) override { return GL_NO_ERROR; }
-    virtual GLint glGetUniformLocation_(GLuint program, const GLchar* name) override { return 2; }
-    virtual void glHint_(GLenum target, GLenum mode) override {}
-    virtual void glLineWidth_(GLfloat width) override {}
-    virtual void glLinkProgram_(GLuint program) override {}
-    virtual void glPixelStorei_(GLenum pname, GLint param) override {}
-    virtual void glPolygonOffset_(GLfloat factor, GLfloat units) override {}
-    virtual void glReadPixels_(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
-                               GLenum type, void* pixels) override {}
-    virtual void glReleaseShaderCompiler_(void) override {}
-    virtual void glRenderbufferStorage_(GLenum target, GLenum internalformat, GLsizei width,
-                                        GLsizei height) override {}
-    virtual void glSampleCoverage_(GLfloat value, GLboolean invert) override {}
-    virtual void glScissor_(GLint x, GLint y, GLsizei width, GLsizei height) override {}
-    virtual void glShaderBinary_(GLsizei count, const GLuint* shaders, GLenum binaryformat,
-                                 const void* binary, GLsizei length) override {}
-    virtual void glShaderSource_(GLuint shader, GLsizei count, const GLchar* const* string,
-                                 const GLint* length) override {}
-    virtual void glStencilFunc_(GLenum func, GLint ref, GLuint mask) override {}
-    virtual void glStencilFuncSeparate_(GLenum face, GLenum func, GLint ref, GLuint mask) override {
-    }
-    virtual void glStencilMask_(GLuint mask) override {}
-    virtual void glStencilMaskSeparate_(GLenum face, GLuint mask) override {}
-    virtual void glStencilOp_(GLenum fail, GLenum zfail, GLenum zpass) override {}
-    virtual void glStencilOpSeparate_(GLenum face, GLenum sfail, GLenum dpfail,
-                                      GLenum dppass) override {}
-    virtual void glTexImage2D_(GLenum target, GLint level, GLint internalformat, GLsizei width,
-                               GLsizei height, GLint border, GLenum format, GLenum type,
-                               const void* pixels) override {}
-    virtual void glTexParameterf_(GLenum target, GLenum pname, GLfloat param) override {}
-    virtual void glTexParameterfv_(GLenum target, GLenum pname, const GLfloat* params) override {}
-    virtual void glTexParameteri_(GLenum target, GLenum pname, GLint param) override {}
-    virtual void glTexParameteriv_(GLenum target, GLenum pname, const GLint* params) override {}
-    virtual void glTexSubImage2D_(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-                                  GLsizei width, GLsizei height, GLenum format, GLenum type,
-                                  const void* pixels) override {}
-    virtual void glUniform1f_(GLint location, GLfloat v0) override {}
-    virtual void glUniform1fv_(GLint location, GLsizei count, const GLfloat* value) override {}
-    virtual void glUniform1i_(GLint location, GLint v0) override {}
-    virtual void glUniform1iv_(GLint location, GLsizei count, const GLint* value) override {}
-    virtual void glUniform2f_(GLint location, GLfloat v0, GLfloat v1) override {}
-    virtual void glUniform2fv_(GLint location, GLsizei count, const GLfloat* value) override {}
-    virtual void glUniform2i_(GLint location, GLint v0, GLint v1) override {}
-    virtual void glUniform2iv_(GLint location, GLsizei count, const GLint* value) override {}
-    virtual void glUniform3f_(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) override {}
-    virtual void glUniform3fv_(GLint location, GLsizei count, const GLfloat* value) override {}
-    virtual void glUniform3i_(GLint location, GLint v0, GLint v1, GLint v2) override {}
-    virtual void glUniform3iv_(GLint location, GLsizei count, const GLint* value) override {}
-    virtual void glUniform4f_(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
-                              GLfloat v3) override {}
-    virtual void glUniform4fv_(GLint location, GLsizei count, const GLfloat* value) override {}
-    virtual void glUniform4i_(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) override {}
-    virtual void glUniform4iv_(GLint location, GLsizei count, const GLint* value) override {}
-    virtual void glUniformMatrix2fv_(GLint location, GLsizei count, GLboolean transpose,
-                                     const GLfloat* value) override {}
-    virtual void glUniformMatrix3fv_(GLint location, GLsizei count, GLboolean transpose,
-                                     const GLfloat* value) override {}
-    virtual void glUniformMatrix4fv_(GLint location, GLsizei count, GLboolean transpose,
-                                     const GLfloat* value) override {}
-    virtual void glUseProgram_(GLuint program) override {}
-    virtual void glValidateProgram_(GLuint program) override {}
-    virtual void glVertexAttrib1f_(GLuint index, GLfloat x) override {}
-    virtual void glVertexAttrib1fv_(GLuint index, const GLfloat* v) override {}
-    virtual void glVertexAttrib2f_(GLuint index, GLfloat x, GLfloat y) override {}
-    virtual void glVertexAttrib2fv_(GLuint index, const GLfloat* v) override {}
-    virtual void glVertexAttrib3f_(GLuint index, GLfloat x, GLfloat y, GLfloat z) override {}
-    virtual void glVertexAttrib3fv_(GLuint index, const GLfloat* v) override {}
-    virtual void glVertexAttrib4f_(GLuint index, GLfloat x, GLfloat y, GLfloat z,
-                                   GLfloat w) override {}
-    virtual void glVertexAttrib4fv_(GLuint index, const GLfloat* v) override {}
-    virtual void glVertexAttribPointer_(GLuint index, GLint size, GLenum type, GLboolean normalized,
-                                        GLsizei stride, const void* pointer) override {}
-    virtual void glViewport_(GLint x, GLint y, GLsizei width, GLsizei height) override {}
-
-    // gles2 ext
-    virtual void glInsertEventMarkerEXT_(GLsizei length, const GLchar* marker) override {}
-    virtual void glPushGroupMarkerEXT_(GLsizei length, const GLchar* marker) override {}
-    virtual void glPopGroupMarkerEXT_(void) override {}
-    virtual void glDiscardFramebufferEXT_(GLenum target, GLsizei numAttachments,
-                                          const GLenum* attachments) override {}
-    virtual void glEGLImageTargetTexture2DOES_(GLenum target, GLeglImageOES image) override {}
-
-    // GLES3
-    virtual void* glMapBufferRange_(GLenum target, GLintptr offset, GLsizeiptr length,
-                                    GLbitfield access) override {
-        return 0;
-    }
-
-    virtual GLboolean glUnmapBuffer_(GLenum target) override { return GL_FALSE; }
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/NullSkiaInterface.cpp b/libs/hwui/debug/NullSkiaInterface.cpp
deleted file mode 100644
index d141b9c..0000000
--- a/libs/hwui/debug/NullSkiaInterface.cpp
+++ /dev/null
@@ -1,1402 +0,0 @@
-/*
- * Copyright (C) 2019 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// TODO: Remove this file. This has been temporarily copied from Skia (where this class is
-// deprecated). The NullGlesDriver should be constructing a GrGLInterface that calls *its*
-// GL functions!
-
-#include "GrNonAtomicRef.h"
-#include "SkMutex.h"
-#include "SkTDArray.h"
-#include "SkTo.h"
-#include "gl/GrGLDefines.h"
-#include "gl/GrGLInterface.h"
-
-#include <type_traits>
-
-// added to suppress 'no previous prototype' warning and because this code is duplicated in
-// SkNullGLContext.cpp
-namespace {
-
-class GLObject : public GrNonAtomicRef<GLObject> {
-public:
-    GLObject(GrGLuint id) : fID(id) {}
-    virtual ~GLObject() {}
-
-    GrGLuint id() const { return fID; }
-
-private:
-    GrGLuint fID;
-};
-
-// This class maintains a sparsely populated array of object pointers.
-template<typename T> class TGLObjectManager {
-   static_assert(std::is_convertible<T*, GLObject*>::value, "T must be a subclass of GLObject");
-
-public:
-    TGLObjectManager() : fFreeListHead(kFreeListEnd) {
-        *fGLObjects.append() = nullptr; // 0 is not a valid GL object id.
-    }
-
-    ~TGLObjectManager() {
-        // nullptr out the entries that are really free list links rather than ptrs before deleting.
-        intptr_t curr = fFreeListHead;
-        while (kFreeListEnd != curr) {
-            intptr_t next = reinterpret_cast<intptr_t>(fGLObjects[SkToS32(curr)]);
-            fGLObjects[SkToS32(curr)] = nullptr;
-            curr = next;
-        }
-
-        fGLObjects.safeUnrefAll();
-    }
-
-    T* lookUp(GrGLuint id) {
-        T* object = fGLObjects[id];
-        SkASSERT(object && object->id() == id);
-        return object;
-    }
-
-    T* create() {
-        GrGLuint id;
-        T* object;
-
-        if (kFreeListEnd == fFreeListHead) {
-            // no free slots - create a new one
-            id = fGLObjects.count();
-            object = new T(id);
-            *fGLObjects.append() = object;
-        } else {
-            // grab the head of the free list and advance the head to the next free slot.
-            id = static_cast<GrGLuint>(fFreeListHead);
-            fFreeListHead = reinterpret_cast<intptr_t>(fGLObjects[id]);
-
-            object = new T(id);
-            fGLObjects[id] = object;
-        }
-
-        return object;
-    }
-
-    void free(T* object) {
-        SkASSERT(object);
-        SkASSERT(fGLObjects.count() > 0);
-
-        GrGLuint id = object->id();
-        object->unref();
-
-        fGLObjects[id] = reinterpret_cast<T*>(fFreeListHead);
-        fFreeListHead = id;
-    }
-
-private:
-    static const intptr_t kFreeListEnd = -1;
-    // Index of the first entry of fGLObjects in the free list. Free slots in fGLObjects are indices
-    // to the next free slot. The last free slot has a value of kFreeListEnd.
-    intptr_t        fFreeListHead;
-    SkTDArray<T*>   fGLObjects;
-};
-
-class Buffer : public GLObject {
-public:
-    Buffer(GrGLuint id) : INHERITED(id), fDataPtr(nullptr), fSize(0), fMapped(false) {}
-    ~Buffer() { delete[] fDataPtr; }
-
-    void allocate(GrGLsizeiptr size, const GrGLchar* dataPtr) {
-        if (fDataPtr) {
-            SkASSERT(0 != fSize);
-            delete[] fDataPtr;
-        }
-
-        fSize = size;
-        fDataPtr = new char[size];
-    }
-
-    GrGLchar* dataPtr()          { return fDataPtr; }
-    GrGLsizeiptr size() const    { return fSize; }
-
-    void setMapped(bool mapped)  { fMapped = mapped; }
-    bool mapped() const          { return fMapped; }
-
-private:
-    GrGLchar*    fDataPtr;
-    GrGLsizeiptr fSize;         // size in bytes
-    bool         fMapped;
-
-    typedef GLObject INHERITED;
-};
-
-class FramebufferAttachment : public GLObject {
-public:
-    int numSamples() const { return fNumSamples; }
-
-protected:
-    FramebufferAttachment(int id) : INHERITED(id), fNumSamples(1) {}
-
-    int fNumSamples;
-
-    typedef GLObject INHERITED;
-};
-
-class Renderbuffer : public FramebufferAttachment {
-public:
-    Renderbuffer(int id) : INHERITED(id) {}
-    void setNumSamples(int numSamples) { fNumSamples = numSamples; }
-
-private:
-    typedef FramebufferAttachment INHERITED;
-};
-
-class Texture : public FramebufferAttachment {
-public:
-    Texture() : INHERITED(1) {}
-
-private:
-    typedef FramebufferAttachment INHERITED;
-};
-
-class Framebuffer : public GLObject {
-public:
-    Framebuffer(int id) : INHERITED(id) {}
-
-    void setAttachment(GrGLenum attachmentPoint, const FramebufferAttachment* attachment) {
-        switch (attachmentPoint) {
-            default:
-                SK_ABORT("Invalid framebuffer attachment.");
-                break;
-            case GR_GL_STENCIL_ATTACHMENT:
-                fAttachments[(int)AttachmentPoint::kStencil].reset(SkRef(attachment));
-                break;
-            case GR_GL_DEPTH_ATTACHMENT:
-                fAttachments[(int)AttachmentPoint::kDepth].reset(SkRef(attachment));
-                break;
-            case GR_GL_COLOR_ATTACHMENT0:
-                fAttachments[(int)AttachmentPoint::kColor].reset(SkRef(attachment));
-                break;
-        }
-    }
-
-    void notifyAttachmentDeleteWhileBound(const FramebufferAttachment* deleted) {
-        for (auto& attachment : fAttachments) {
-            if (attachment.get() == deleted) {
-                attachment.reset(nullptr);
-            }
-        }
-    }
-
-    int numSamples() const {
-        int numSamples = 0;
-        for (auto& attachment : fAttachments) {
-            if (!attachment) {
-                continue;
-            }
-            if (numSamples) {
-                GrAlwaysAssert(attachment->numSamples() == numSamples);
-                continue;
-            }
-            numSamples = attachment->numSamples();
-        }
-        GrAlwaysAssert(numSamples);
-        return numSamples;
-    }
-
-private:
-    enum AttachmentPoint {
-        kStencil,
-        kDepth,
-        kColor
-    };
-    constexpr int static kNumAttachmentPoints = 1 + (int)AttachmentPoint::kColor;
-
-    sk_sp<const FramebufferAttachment> fAttachments[kNumAttachmentPoints];
-
-    typedef GLObject INHERITED;
-};
-
-class TestInterface : public GrGLInterface {
-public:
-    virtual GrGLvoid activeTexture(GrGLenum texture) {}
-    virtual GrGLvoid attachShader(GrGLuint program, GrGLuint shader) {}
-    virtual GrGLvoid beginQuery(GrGLenum target, GrGLuint id) {}
-    virtual GrGLvoid bindAttribLocation(GrGLuint program, GrGLuint index, const char* name) {}
-    virtual GrGLvoid bindBuffer(GrGLenum target, GrGLuint buffer) {}
-    virtual GrGLvoid bindFramebuffer(GrGLenum target, GrGLuint framebuffer) {}
-    virtual GrGLvoid bindRenderbuffer(GrGLenum target, GrGLuint renderbuffer) {}
-    virtual GrGLvoid bindSampler(GrGLuint unit, GrGLuint sampler) {}
-    virtual GrGLvoid bindTexture(GrGLenum target, GrGLuint texture) {}
-    virtual GrGLvoid bindFragDataLocation(GrGLuint program, GrGLuint colorNumber, const GrGLchar* name) {}
-    virtual GrGLvoid bindFragDataLocationIndexed(GrGLuint program, GrGLuint colorNumber, GrGLuint index, const GrGLchar * name) {}
-    virtual GrGLvoid bindVertexArray(GrGLuint array) {}
-    virtual GrGLvoid blendBarrier() {}
-    virtual GrGLvoid blendColor(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha) {}
-    virtual GrGLvoid blendEquation(GrGLenum mode) {}
-    virtual GrGLvoid blendFunc(GrGLenum sfactor, GrGLenum dfactor) {}
-    virtual GrGLvoid blitFramebuffer(GrGLint srcX0, GrGLint srcY0, GrGLint srcX1, GrGLint srcY1, GrGLint dstX0, GrGLint dstY0, GrGLint dstX1, GrGLint dstY1, GrGLbitfield mask, GrGLenum filter) {}
-    virtual GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data, GrGLenum usage) {}
-    virtual GrGLvoid bufferSubData(GrGLenum target, GrGLintptr offset, GrGLsizeiptr size, const GrGLvoid* data) {}
-    virtual GrGLenum checkFramebufferStatus(GrGLenum target) { return GR_GL_FRAMEBUFFER_COMPLETE; }
-    virtual GrGLvoid clear(GrGLbitfield mask) {}
-    virtual GrGLvoid clearColor(GrGLclampf red, GrGLclampf green, GrGLclampf blue, GrGLclampf alpha) {}
-    virtual GrGLvoid clearStencil(GrGLint s) {}
-    virtual GrGLvoid colorMask(GrGLboolean red, GrGLboolean green, GrGLboolean blue, GrGLboolean alpha) {}
-    virtual GrGLvoid compileShader(GrGLuint shader) {}
-    virtual GrGLvoid compressedTexImage2D(GrGLenum target, GrGLint level, GrGLenum internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLsizei imageSize, const GrGLvoid* data) {}
-    virtual GrGLvoid compressedTexSubImage2D(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLsizei imageSize, const GrGLvoid* data) {}
-    virtual GrGLvoid copyTexSubImage2D(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLuint createProgram() { return 0; }
-    virtual GrGLuint createShader(GrGLenum type) { return 0; }
-    virtual GrGLvoid cullFace(GrGLenum mode) {}
-    virtual GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* buffers) {}
-    virtual GrGLvoid deleteFramebuffers(GrGLsizei n, const GrGLuint *framebuffers) {}
-    virtual GrGLvoid deleteProgram(GrGLuint program) {}
-    virtual GrGLvoid deleteQueries(GrGLsizei n, const GrGLuint *ids) {}
-    virtual GrGLvoid deleteRenderbuffers(GrGLsizei n, const GrGLuint *renderbuffers) {}
-    virtual GrGLvoid deleteSamplers(GrGLsizei n, const GrGLuint* samplers) {}
-    virtual GrGLvoid deleteShader(GrGLuint shader) {}
-    virtual GrGLvoid deleteTextures(GrGLsizei n, const GrGLuint* textures) {}
-    virtual GrGLvoid deleteVertexArrays(GrGLsizei n, const GrGLuint *arrays) {}
-    virtual GrGLvoid depthMask(GrGLboolean flag) {}
-    virtual GrGLvoid disable(GrGLenum cap) {}
-    virtual GrGLvoid disableVertexAttribArray(GrGLuint index) {}
-    virtual GrGLvoid drawArrays(GrGLenum mode, GrGLint first, GrGLsizei count) {}
-    virtual GrGLvoid drawArraysInstanced(GrGLenum mode, GrGLint first, GrGLsizei count, GrGLsizei primcount) {}
-    virtual GrGLvoid drawArraysIndirect(GrGLenum mode, const GrGLvoid* indirect) {}
-    virtual GrGLvoid drawBuffer(GrGLenum mode) {}
-    virtual GrGLvoid drawBuffers(GrGLsizei n, const GrGLenum* bufs) {}
-    virtual GrGLvoid drawElements(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid* indices) {}
-    virtual GrGLvoid drawElementsInstanced(GrGLenum mode, GrGLsizei count, GrGLenum type, const GrGLvoid *indices, GrGLsizei primcount) {}
-    virtual GrGLvoid drawElementsIndirect(GrGLenum mode, GrGLenum type, const GrGLvoid* indirect) {}
-    virtual GrGLvoid drawRangeElements(GrGLenum mode, GrGLuint start, GrGLuint end, GrGLsizei count, GrGLenum type, const GrGLvoid* indices) {}
-    virtual GrGLvoid enable(GrGLenum cap) {}
-    virtual GrGLvoid enableVertexAttribArray(GrGLuint index) {}
-    virtual GrGLvoid endQuery(GrGLenum target) {}
-    virtual GrGLvoid finish() {}
-    virtual GrGLvoid flush() {}
-    virtual GrGLvoid flushMappedBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length) {}
-    virtual GrGLvoid framebufferRenderbuffer(GrGLenum target, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer) {}
-    virtual GrGLvoid framebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level) {}
-    virtual GrGLvoid framebufferTexture2DMultisample(GrGLenum target, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level, GrGLsizei samples) {}
-    virtual GrGLvoid frontFace(GrGLenum mode) {}
-    virtual GrGLvoid genBuffers(GrGLsizei n, GrGLuint* buffers) {}
-    virtual GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint *framebuffers) {}
-    virtual GrGLvoid generateMipmap(GrGLenum target) {}
-    virtual GrGLvoid genQueries(GrGLsizei n, GrGLuint *ids) {}
-    virtual GrGLvoid genRenderbuffers(GrGLsizei n, GrGLuint *renderbuffers) {}
-    virtual GrGLvoid genSamplers(GrGLsizei n, GrGLuint *samplers) {}
-    virtual GrGLvoid genTextures(GrGLsizei n, GrGLuint* textures) {}
-    virtual GrGLvoid genVertexArrays(GrGLsizei n, GrGLuint *arrays) {}
-    virtual GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLenum getError() { return GR_GL_NO_ERROR; }
-    virtual GrGLvoid getFramebufferAttachmentParameteriv(GrGLenum target, GrGLenum attachment, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLvoid getIntegerv(GrGLenum pname, GrGLint* params) {}
-    virtual GrGLvoid getMultisamplefv(GrGLenum pname, GrGLuint index, GrGLfloat* val) {}
-    virtual GrGLvoid getProgramInfoLog(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, char* infolog) {}
-    virtual GrGLvoid getProgramiv(GrGLuint program, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLvoid getQueryiv(GrGLenum GLtarget, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid getQueryObjecti64v(GrGLuint id, GrGLenum pname, GrGLint64 *params) {}
-    virtual GrGLvoid getQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid getQueryObjectui64v(GrGLuint id, GrGLenum pname, GrGLuint64 *params) {}
-    virtual GrGLvoid getQueryObjectuiv(GrGLuint id, GrGLenum pname, GrGLuint *params) {}
-    virtual GrGLvoid getRenderbufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLvoid getShaderInfoLog(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length, char* infolog) {}
-    virtual GrGLvoid getShaderiv(GrGLuint shader, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLvoid getShaderPrecisionFormat(GrGLenum shadertype, GrGLenum precisiontype, GrGLint *range, GrGLint *precision) {}
-    virtual const GrGLubyte*  getString(GrGLenum name) { return nullptr; }
-    virtual const GrGLubyte* getStringi(GrGLenum name, GrGLuint index) { return nullptr; }
-    virtual GrGLvoid getTexLevelParameteriv(GrGLenum target, GrGLint level, GrGLenum pname, GrGLint* params) {}
-    virtual GrGLint getUniformLocation(GrGLuint program, const char* name) { return 0; }
-    virtual GrGLvoid insertEventMarker(GrGLsizei length, const char* marker) {}
-    virtual GrGLvoid invalidateBufferData(GrGLuint buffer) {}
-    virtual GrGLvoid invalidateBufferSubData(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length) {}
-    virtual GrGLvoid invalidateFramebuffer(GrGLenum target, GrGLsizei numAttachments,  const GrGLenum *attachments) {}
-    virtual GrGLvoid invalidateSubFramebuffer(GrGLenum target, GrGLsizei numAttachments, const GrGLenum *attachments, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid invalidateTexImage(GrGLuint texture, GrGLint level) {}
-    virtual GrGLvoid invalidateTexSubImage(GrGLuint texture, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLsizei width, GrGLsizei height, GrGLsizei depth) {}
-    virtual GrGLboolean isTexture(GrGLuint texture) { return GR_GL_FALSE; }
-    virtual GrGLvoid lineWidth(GrGLfloat width) {}
-    virtual GrGLvoid linkProgram(GrGLuint program) {}
-    virtual GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) { return nullptr; }
-    virtual GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length, GrGLbitfield access) { return nullptr; }
-    virtual GrGLvoid* mapBufferSubData(GrGLuint target, GrGLintptr offset, GrGLsizeiptr size, GrGLenum access) { return nullptr; }
-    virtual GrGLvoid* mapTexSubImage2D(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, GrGLenum access) { return nullptr; }
-    virtual GrGLvoid pixelStorei(GrGLenum pname, GrGLint param) {}
-    virtual GrGLvoid polygonMode(GrGLenum face, GrGLenum mode) {}
-    virtual GrGLvoid popGroupMarker() {}
-    virtual GrGLvoid pushGroupMarker(GrGLsizei length, const char* marker) {}
-    virtual GrGLvoid queryCounter(GrGLuint id, GrGLenum target) {}
-    virtual GrGLvoid rasterSamples(GrGLuint samples, GrGLboolean fixedsamplelocations) {}
-    virtual GrGLvoid readBuffer(GrGLenum src) {}
-    virtual GrGLvoid readPixels(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, GrGLvoid* pixels) {}
-    virtual GrGLvoid renderbufferStorage(GrGLenum target, GrGLenum internalformat, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid renderbufferStorageMultisample(GrGLenum target, GrGLsizei samples, GrGLenum internalformat, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid resolveMultisampleFramebuffer() {}
-    virtual GrGLvoid samplerParameteri(GrGLuint sampler, GrGLenum pname, GrGLint param) {}
-    virtual GrGLvoid samplerParameteriv(GrGLuint sampler, GrGLenum pname, const GrGLint* param) {}
-    virtual GrGLvoid scissor(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid bindUniformLocation(GrGLuint program, GrGLint location, const char* name) {}
-    virtual GrGLvoid shaderSource(GrGLuint shader, GrGLsizei count, const char* const * str, const GrGLint* length) {}
-    virtual GrGLvoid stencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {}
-    virtual GrGLvoid stencilFuncSeparate(GrGLenum face, GrGLenum func, GrGLint ref, GrGLuint mask) {}
-    virtual GrGLvoid stencilMask(GrGLuint mask) {}
-    virtual GrGLvoid stencilMaskSeparate(GrGLenum face, GrGLuint mask) {}
-    virtual GrGLvoid stencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {}
-    virtual GrGLvoid stencilOpSeparate(GrGLenum face, GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {}
-    virtual GrGLvoid texBuffer(GrGLenum target, GrGLenum internalformat, GrGLuint buffer) {}
-    virtual GrGLvoid texImage2D(GrGLenum target, GrGLint level, GrGLint internalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid* pixels) {}
-    virtual GrGLvoid texParameterf(GrGLenum target, GrGLenum pname, GrGLfloat param) {}
-    virtual GrGLvoid texParameterfv(GrGLenum target, GrGLenum pname, const GrGLfloat* params) {}
-    virtual GrGLvoid texParameteri(GrGLenum target, GrGLenum pname, GrGLint param) {}
-    virtual GrGLvoid texParameteriv(GrGLenum target, GrGLenum pname, const GrGLint* params) {}
-    virtual GrGLvoid texStorage2D(GrGLenum target, GrGLsizei levels, GrGLenum internalformat, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid discardFramebuffer(GrGLenum target, GrGLsizei numAttachments, const GrGLenum* attachments) {}
-    virtual GrGLvoid texSubImage2D(GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, const GrGLvoid* pixels) {}
-    virtual GrGLvoid textureBarrier() {}
-    virtual GrGLvoid uniform1f(GrGLint location, GrGLfloat v0) {}
-    virtual GrGLvoid uniform1i(GrGLint location, GrGLint v0) {}
-    virtual GrGLvoid uniform1fv(GrGLint location, GrGLsizei count, const GrGLfloat* v) {}
-    virtual GrGLvoid uniform1iv(GrGLint location, GrGLsizei count, const GrGLint* v) {}
-    virtual GrGLvoid uniform2f(GrGLint location, GrGLfloat v0, GrGLfloat v1) {}
-    virtual GrGLvoid uniform2i(GrGLint location, GrGLint v0, GrGLint v1) {}
-    virtual GrGLvoid uniform2fv(GrGLint location, GrGLsizei count, const GrGLfloat* v) {}
-    virtual GrGLvoid uniform2iv(GrGLint location, GrGLsizei count, const GrGLint* v) {}
-    virtual GrGLvoid uniform3f(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2) {}
-    virtual GrGLvoid uniform3i(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2) {}
-    virtual GrGLvoid uniform3fv(GrGLint location, GrGLsizei count, const GrGLfloat* v) {}
-    virtual GrGLvoid uniform3iv(GrGLint location, GrGLsizei count, const GrGLint* v) {}
-    virtual GrGLvoid uniform4f(GrGLint location, GrGLfloat v0, GrGLfloat v1, GrGLfloat v2, GrGLfloat v3) {}
-    virtual GrGLvoid uniform4i(GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3) {}
-    virtual GrGLvoid uniform4fv(GrGLint location, GrGLsizei count, const GrGLfloat* v) {}
-    virtual GrGLvoid uniform4iv(GrGLint location, GrGLsizei count, const GrGLint* v) {}
-    virtual GrGLvoid uniformMatrix2fv(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value) {}
-    virtual GrGLvoid uniformMatrix3fv(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value) {}
-    virtual GrGLvoid uniformMatrix4fv(GrGLint location, GrGLsizei count, GrGLboolean transpose, const GrGLfloat* value) {}
-    virtual GrGLboolean unmapBuffer(GrGLenum target) { return GR_GL_TRUE; }
-    virtual GrGLvoid unmapBufferSubData(const GrGLvoid* mem) {}
-    virtual GrGLvoid unmapTexSubImage2D(const GrGLvoid* mem) {}
-    virtual GrGLvoid useProgram(GrGLuint program) {}
-    virtual GrGLvoid vertexAttrib1f(GrGLuint indx, const GrGLfloat value) {}
-    virtual GrGLvoid vertexAttrib2fv(GrGLuint indx, const GrGLfloat* values) {}
-    virtual GrGLvoid vertexAttrib3fv(GrGLuint indx, const GrGLfloat* values) {}
-    virtual GrGLvoid vertexAttrib4fv(GrGLuint indx, const GrGLfloat* values) {}
-    virtual GrGLvoid vertexAttribDivisor(GrGLuint index, GrGLuint divisor) {}
-    virtual GrGLvoid vertexAttribIPointer(GrGLuint indx, GrGLint size, GrGLenum type, GrGLsizei stride, const GrGLvoid* ptr) {}
-    virtual GrGLvoid vertexAttribPointer(GrGLuint indx, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, const GrGLvoid* ptr) {}
-    virtual GrGLvoid viewport(GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid matrixLoadf(GrGLenum matrixMode, const GrGLfloat* m) {}
-    virtual GrGLvoid matrixLoadIdentity(GrGLenum) {}
-    virtual GrGLvoid pathCommands(GrGLuint path, GrGLsizei numCommands, const GrGLubyte *commands, GrGLsizei numCoords, GrGLenum coordType, const GrGLvoid *coords) {}
-    virtual GrGLvoid pathParameteri(GrGLuint path, GrGLenum pname, GrGLint value) {}
-    virtual GrGLvoid pathParameterf(GrGLuint path, GrGLenum pname, GrGLfloat value) {}
-    virtual GrGLuint genPaths(GrGLsizei range) { return 0; }
-    virtual GrGLvoid deletePaths(GrGLuint path, GrGLsizei range) {}
-    virtual GrGLboolean isPath(GrGLuint path) { return true; }
-    virtual GrGLvoid pathStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {}
-    virtual GrGLvoid stencilFillPath(GrGLuint path, GrGLenum fillMode, GrGLuint mask) {}
-    virtual GrGLvoid stencilStrokePath(GrGLuint path, GrGLint reference, GrGLuint mask) {}
-    virtual GrGLvoid stencilFillPathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum transformType, const GrGLfloat *transformValues) {}
-    virtual GrGLvoid stencilStrokePathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum transformType, const GrGLfloat *transformValues) {}
-    virtual GrGLvoid coverFillPath(GrGLuint path, GrGLenum coverMode) {}
-    virtual GrGLvoid coverStrokePath(GrGLuint name, GrGLenum coverMode) {}
-    virtual GrGLvoid coverFillPathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues) {}
-    virtual GrGLvoid coverStrokePathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat* transformValues) {}
-    virtual GrGLvoid stencilThenCoverFillPath(GrGLuint path, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode) {}
-    virtual GrGLvoid stencilThenCoverStrokePath(GrGLuint path, GrGLint reference, GrGLuint mask, GrGLenum coverMode) {}
-    virtual GrGLvoid stencilThenCoverFillPathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLenum fillMode, GrGLuint mask, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues) {}
-    virtual GrGLvoid stencilThenCoverStrokePathInstanced(GrGLsizei numPaths, GrGLenum pathNameType, const GrGLvoid *paths, GrGLuint pathBase, GrGLint reference, GrGLuint mask, GrGLenum coverMode, GrGLenum transformType, const GrGLfloat *transformValues) {}
-    virtual GrGLvoid programPathFragmentInputGen(GrGLuint program, GrGLint location, GrGLenum genMode, GrGLint components,const GrGLfloat *coeffs) {}
-    virtual GrGLvoid bindFragmentInputLocation(GrGLuint program, GrGLint location, const GrGLchar* name) {}
-    virtual GrGLint getProgramResourceLocation(GrGLuint program, GrGLenum programInterface, const GrGLchar *name) { return 0; }
-    virtual GrGLvoid coverageModulation(GrGLenum components) {}
-    virtual GrGLvoid multiDrawArraysIndirect(GrGLenum mode, const GrGLvoid *indirect, GrGLsizei drawcount, GrGLsizei stride) {}
-    virtual GrGLvoid multiDrawElementsIndirect(GrGLenum mode, GrGLenum type, const GrGLvoid *indirect, GrGLsizei drawcount, GrGLsizei stride) {}
-    virtual GrGLuint64 getTextureHandle(GrGLuint texture) { return 0; }
-    virtual GrGLuint64 getTextureSamplerHandle(GrGLuint texture, GrGLuint sampler) { return 0; }
-    virtual GrGLvoid makeTextureHandleResident(GrGLuint64 handle) {}
-    virtual GrGLvoid makeTextureHandleNonResident(GrGLuint64 handle) {}
-    virtual GrGLuint64 getImageHandle(GrGLuint texture, GrGLint level, GrGLboolean layered, GrGLint layer, GrGLint format) { return 0; }
-    virtual GrGLvoid makeImageHandleResident(GrGLuint64 handle, GrGLenum access) {}
-    virtual GrGLvoid makeImageHandleNonResident(GrGLuint64 handle) {}
-    virtual GrGLboolean isTextureHandleResident(GrGLuint64 handle) { return GR_GL_FALSE; }
-    virtual GrGLboolean isImageHandleResident(GrGLuint64 handle) { return GR_GL_FALSE; }
-    virtual GrGLvoid uniformHandleui64(GrGLint location, GrGLuint64 v0) {}
-    virtual GrGLvoid uniformHandleui64v(GrGLint location, GrGLsizei count, const GrGLuint64 *value) {}
-    virtual GrGLvoid programUniformHandleui64(GrGLuint program, GrGLint location, GrGLuint64 v0) {}
-    virtual GrGLvoid programUniformHandleui64v(GrGLuint program, GrGLint location, GrGLsizei count, const GrGLuint64 *value) {}
-    virtual GrGLvoid textureParameteri(GrGLuint texture, GrGLenum target, GrGLenum pname, GrGLint param) {}
-    virtual GrGLvoid textureParameteriv(GrGLuint texture, GrGLenum target, GrGLenum pname, const GrGLint *param) {}
-    virtual GrGLvoid textureParameterf(GrGLuint texture, GrGLenum target, GrGLenum pname, float param) {}
-    virtual GrGLvoid textureParameterfv(GrGLuint texture, GrGLenum target, GrGLenum pname, const float *param) {}
-    virtual GrGLvoid textureImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint GrGLinternalformat, GrGLsizei width, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid textureImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint GrGLinternalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid textureSubImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLsizei width, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid textureSubImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid copyTextureImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum GrGLinternalformat, GrGLint x, GrGLint y, GrGLsizei width, GrGLint border) {}
-    virtual GrGLvoid copyTextureImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum GrGLinternalformat, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height, GrGLint border) {}
-    virtual GrGLvoid copyTextureSubImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint x, GrGLint y, GrGLsizei width) {}
-    virtual GrGLvoid copyTextureSubImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid getTextureImage(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum format, GrGLenum type, GrGLvoid *pixels) {}
-    virtual GrGLvoid getTextureParameterfv(GrGLuint texture, GrGLenum target, GrGLenum pname, float *params) {}
-    virtual GrGLvoid getTextureParameteriv(GrGLuint texture, GrGLenum target, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid getTextureLevelParameterfv(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum pname, float *params) {}
-    virtual GrGLvoid getTextureLevelParameteriv(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid textureImage3D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint GrGLinternalformat, GrGLsizei width, GrGLsizei height, GrGLsizei depth, GrGLint border, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid textureSubImage3D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLsizei width, GrGLsizei height, GrGLsizei depth, GrGLenum format, GrGLenum type, const GrGLvoid *pixels) {}
-    virtual GrGLvoid copyTextureSubImage3D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLint x, GrGLint y, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid compressedTextureImage3D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum GrGLinternalformat, GrGLsizei width, GrGLsizei height, GrGLsizei depth, GrGLint border, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid compressedTextureImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum GrGLinternalformat, GrGLsizei width, GrGLsizei height, GrGLint border, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid compressedTextureImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLenum GrGLinternalformat, GrGLsizei width, GrGLint border, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid compressedTextureSubImage3D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLint zoffset, GrGLsizei width, GrGLsizei height, GrGLsizei depth, GrGLenum format, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid compressedTextureSubImage2D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLint yoffset, GrGLsizei width, GrGLsizei height, GrGLenum format, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid compressedTextureSubImage1D(GrGLuint texture, GrGLenum target, GrGLint level, GrGLint xoffset, GrGLsizei width, GrGLenum format, GrGLsizei imageSize, const GrGLvoid *data) {}
-    virtual GrGLvoid getCompressedTextureImage(GrGLuint texture, GrGLenum target, GrGLint level, GrGLvoid *img) {}
-    virtual GrGLvoid namedBufferData(GrGLuint buffer, GrGLsizeiptr size, const GrGLvoid *data, GrGLenum usage) {}
-    virtual GrGLvoid namedBufferSubData(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr size, const GrGLvoid *data) {}
-    virtual GrGLvoid* mapNamedBuffer(GrGLuint buffer, GrGLenum access) { return nullptr; }
-    virtual GrGLboolean unmapNamedBuffer(GrGLuint buffer) { return GR_GL_FALSE; }
-    virtual GrGLvoid getNamedBufferParameteriv(GrGLuint buffer, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid getNamedBufferPointerv(GrGLuint buffer, GrGLenum pname, GrGLvoid* *params) {}
-    virtual GrGLvoid getNamedBufferSubData(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr size, GrGLvoid *data) {}
-    virtual GrGLvoid programUniform1f(GrGLuint program, GrGLint location, float v0) {}
-    virtual GrGLvoid programUniform2f(GrGLuint program, GrGLint location, float v0, float v1) {}
-    virtual GrGLvoid programUniform3f(GrGLuint program, GrGLint location, float v0, float v1, float v2) {}
-    virtual GrGLvoid programUniform4f(GrGLuint program, GrGLint location, float v0, float v1, float v2, float v3) {}
-    virtual GrGLvoid programUniform1i(GrGLuint program, GrGLint location, GrGLint v0) {}
-    virtual GrGLvoid programUniform2i(GrGLuint program, GrGLint location, GrGLint v0, GrGLint v1) {}
-    virtual GrGLvoid programUniform3i(GrGLuint program, GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2) {}
-    virtual GrGLvoid programUniform4i(GrGLuint program, GrGLint location, GrGLint v0, GrGLint v1, GrGLint v2, GrGLint v3) {}
-    virtual GrGLvoid programUniform1fv(GrGLuint program, GrGLint location, GrGLsizei count, const float *value) {}
-    virtual GrGLvoid programUniform2fv(GrGLuint program, GrGLint location, GrGLsizei count, const float *value) {}
-    virtual GrGLvoid programUniform3fv(GrGLuint program, GrGLint location, GrGLsizei count, const float *value) {}
-    virtual GrGLvoid programUniform4fv(GrGLuint program, GrGLint location, GrGLsizei count, const float *value) {}
-    virtual GrGLvoid programUniform1iv(GrGLuint program, GrGLint location, GrGLsizei count, const GrGLint *value) {}
-    virtual GrGLvoid programUniform2iv(GrGLuint program, GrGLint location, GrGLsizei count, const GrGLint *value) {}
-    virtual GrGLvoid programUniform3iv(GrGLuint program, GrGLint location, GrGLsizei count, const GrGLint *value) {}
-    virtual GrGLvoid programUniform4iv(GrGLuint program, GrGLint location, GrGLsizei count, const GrGLint *value) {}
-    virtual GrGLvoid programUniformMatrix2fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix3fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix4fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix2x3fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix3x2fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix2x4fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix4x2fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix3x4fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid programUniformMatrix4x3fv(GrGLuint program, GrGLint location, GrGLsizei count, GrGLboolean transpose, const float *value) {}
-    virtual GrGLvoid namedRenderbufferStorage(GrGLuint renderbuffer, GrGLenum GrGLinternalformat, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLvoid getNamedRenderbufferParameteriv(GrGLuint renderbuffer, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid namedRenderbufferStorageMultisample(GrGLuint renderbuffer, GrGLsizei samples, GrGLenum GrGLinternalformat, GrGLsizei width, GrGLsizei height) {}
-    virtual GrGLenum checkNamedFramebufferStatus(GrGLuint framebuffer, GrGLenum target) { return GR_GL_FRAMEBUFFER_COMPLETE; }
-    virtual GrGLvoid namedFramebufferTexture1D(GrGLuint framebuffer, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level) {}
-    virtual GrGLvoid namedFramebufferTexture2D(GrGLuint framebuffer, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level) {}
-    virtual GrGLvoid namedFramebufferTexture3D(GrGLuint framebuffer, GrGLenum attachment, GrGLenum textarget, GrGLuint texture, GrGLint level, GrGLint zoffset) {}
-    virtual GrGLvoid namedFramebufferRenderbuffer(GrGLuint framebuffer, GrGLenum attachment, GrGLenum renderbuffertarget, GrGLuint renderbuffer) {}
-    virtual GrGLvoid getNamedFramebufferAttachmentParameteriv(GrGLuint framebuffer, GrGLenum attachment, GrGLenum pname, GrGLint *params) {}
-    virtual GrGLvoid generateTextureMipmap(GrGLuint texture, GrGLenum target) {}
-    virtual GrGLvoid framebufferDrawBuffer(GrGLuint framebuffer, GrGLenum mode) {}
-    virtual GrGLvoid framebufferDrawBuffers(GrGLuint framebuffer, GrGLsizei n, const GrGLenum *bufs) {}
-    virtual GrGLvoid framebufferReadBuffer(GrGLuint framebuffer, GrGLenum mode) {}
-    virtual GrGLvoid getFramebufferParameteriv(GrGLuint framebuffer, GrGLenum pname, GrGLint *param) {}
-    virtual GrGLvoid namedCopyBufferSubData(GrGLuint readBuffer, GrGLuint writeBuffer, GrGLintptr readOffset, GrGLintptr writeOffset, GrGLsizeiptr size) {}
-    virtual GrGLvoid vertexArrayVertexOffset(GrGLuint vaobj, GrGLuint buffer, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayColorOffset(GrGLuint vaobj, GrGLuint buffer, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayEdgeFlagOffset(GrGLuint vaobj, GrGLuint buffer, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayIndexOffset(GrGLuint vaobj, GrGLuint buffer, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayNormalOffset(GrGLuint vaobj, GrGLuint buffer, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayTexCoordOffset(GrGLuint vaobj, GrGLuint buffer, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayMultiTexCoordOffset(GrGLuint vaobj, GrGLuint buffer, GrGLenum texunit, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayFogCoordOffset(GrGLuint vaobj, GrGLuint buffer, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArraySecondaryColorOffset(GrGLuint vaobj, GrGLuint buffer, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayVertexAttribOffset(GrGLuint vaobj, GrGLuint buffer, GrGLuint index, GrGLint size, GrGLenum type, GrGLboolean normalized, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid vertexArrayVertexAttribIOffset(GrGLuint vaobj, GrGLuint buffer, GrGLuint index, GrGLint size, GrGLenum type, GrGLsizei stride, GrGLintptr offset) {}
-    virtual GrGLvoid enableVertexArray(GrGLuint vaobj, GrGLenum array) {}
-    virtual GrGLvoid disableVertexArray(GrGLuint vaobj, GrGLenum array) {}
-    virtual GrGLvoid enableVertexArrayAttrib(GrGLuint vaobj, GrGLuint index) {}
-    virtual GrGLvoid disableVertexArrayAttrib(GrGLuint vaobj, GrGLuint index) {}
-    virtual GrGLvoid getVertexArrayIntegerv(GrGLuint vaobj, GrGLenum pname, GrGLint *param) {}
-    virtual GrGLvoid getVertexArrayPointerv(GrGLuint vaobj, GrGLenum pname, GrGLvoid **param) {}
-    virtual GrGLvoid getVertexArrayIntegeri_v(GrGLuint vaobj, GrGLuint index, GrGLenum pname, GrGLint *param) {}
-    virtual GrGLvoid getVertexArrayPointeri_v(GrGLuint vaobj, GrGLuint index, GrGLenum pname, GrGLvoid **param) {}
-    virtual GrGLvoid* mapNamedBufferRange(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length, GrGLbitfield access) { return nullptr; }
-    virtual GrGLvoid flushMappedNamedBufferRange(GrGLuint buffer, GrGLintptr offset, GrGLsizeiptr length) {}
-    virtual GrGLvoid textureBuffer(GrGLuint texture, GrGLenum target, GrGLenum internalformat, GrGLuint buffer) {}
-    virtual GrGLsync fenceSync(GrGLenum condition, GrGLbitfield flags) { return nullptr;  }
-    virtual GrGLboolean isSync(GrGLsync) { return false;  }
-    virtual GrGLenum clientWaitSync(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout) { return GR_GL_WAIT_FAILED;  }
-    virtual GrGLvoid waitSync(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout) {}
-    virtual GrGLvoid deleteSync(GrGLsync sync) {}
-    virtual GrGLvoid debugMessageControl(GrGLenum source, GrGLenum type, GrGLenum severity, GrGLsizei count, const GrGLuint* ids, GrGLboolean enabled) {}
-    virtual GrGLvoid debugMessageInsert(GrGLenum source, GrGLenum type, GrGLuint id, GrGLenum severity, GrGLsizei length,  const GrGLchar* buf) {}
-    virtual GrGLvoid debugMessageCallback(GRGLDEBUGPROC callback, const GrGLvoid* userParam) {}
-    virtual GrGLuint getDebugMessageLog(GrGLuint count, GrGLsizei bufSize, GrGLenum* sources, GrGLenum* types, GrGLuint* ids, GrGLenum* severities, GrGLsizei* lengths,  GrGLchar* messageLog) { return 0; }
-    virtual GrGLvoid pushDebugGroup(GrGLenum source, GrGLuint id, GrGLsizei length,  const GrGLchar * message) {}
-    virtual GrGLvoid popDebugGroup() {}
-    virtual GrGLvoid objectLabel(GrGLenum identifier, GrGLuint name, GrGLsizei length, const GrGLchar *label) {}
-    virtual GrGLvoid getInternalformativ(GrGLenum target, GrGLenum internalformat, GrGLenum pname, GrGLsizei bufSize, GrGLint *params) {}
-    virtual GrGLvoid programBinary(GrGLuint program, GrGLenum binaryFormat, void *binary, GrGLsizei length) {}
-    virtual GrGLvoid getProgramBinary(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length, GrGLenum *binaryFormat, void *binary) {}
-    virtual GrGLvoid programParameteri(GrGLuint program, GrGLenum pname, GrGLint value) {}
-
-protected:
-    // This must be called by leaf class
-    void init(GrGLStandard standard) {
-        fStandard = standard;
-        fExtensions.init(standard, fFunctions.fGetString, fFunctions.fGetStringi,
-                         fFunctions.fGetIntegerv, nullptr, GR_EGL_NO_DISPLAY);
-    }
-    TestInterface();
-};
-
-template <typename R, typename... A>
-GrGLFunction<R GR_GL_FUNCTION_TYPE(A...)> bind_to_member(TestInterface* interface,
-                                                         R (TestInterface::*member)(A...)) {
-    return [interface, member](A... a) -> R { return (interface->*member)(a...); };
-}
-
-TestInterface::TestInterface() {
-    fFunctions.fActiveTexture = bind_to_member(this, &TestInterface::activeTexture);
-    fFunctions.fAttachShader = bind_to_member(this, &TestInterface::attachShader);
-    fFunctions.fBeginQuery = bind_to_member(this, &TestInterface::beginQuery);
-    fFunctions.fBindAttribLocation = bind_to_member(this, &TestInterface::bindAttribLocation);
-    fFunctions.fBindBuffer = bind_to_member(this, &TestInterface::bindBuffer);
-    fFunctions.fBindFramebuffer = bind_to_member(this, &TestInterface::bindFramebuffer);
-    fFunctions.fBindRenderbuffer = bind_to_member(this, &TestInterface::bindRenderbuffer);
-    fFunctions.fBindSampler = bind_to_member(this, &TestInterface::bindSampler);
-    fFunctions.fBindTexture = bind_to_member(this, &TestInterface::bindTexture);
-    fFunctions.fBindFragDataLocation = bind_to_member(this, &TestInterface::bindFragDataLocation);
-    fFunctions.fBindFragDataLocationIndexed = bind_to_member(this, &TestInterface::bindFragDataLocationIndexed);
-    fFunctions.fBindVertexArray = bind_to_member(this, &TestInterface::bindVertexArray);
-    fFunctions.fBlendBarrier = bind_to_member(this, &TestInterface::blendBarrier);
-    fFunctions.fBlendColor = bind_to_member(this, &TestInterface::blendColor);
-    fFunctions.fBlendEquation = bind_to_member(this, &TestInterface::blendEquation);
-    fFunctions.fBlendFunc = bind_to_member(this, &TestInterface::blendFunc);
-    fFunctions.fBlitFramebuffer = bind_to_member(this, &TestInterface::blitFramebuffer);
-    fFunctions.fBufferData = bind_to_member(this, &TestInterface::bufferData);
-    fFunctions.fBufferSubData = bind_to_member(this, &TestInterface::bufferSubData);
-    fFunctions.fCheckFramebufferStatus = bind_to_member(this, &TestInterface::checkFramebufferStatus);
-    fFunctions.fClear = bind_to_member(this, &TestInterface::clear);
-    fFunctions.fClearColor = bind_to_member(this, &TestInterface::clearColor);
-    fFunctions.fClearStencil = bind_to_member(this, &TestInterface::clearStencil);
-    fFunctions.fColorMask = bind_to_member(this, &TestInterface::colorMask);
-    fFunctions.fCompileShader = bind_to_member(this, &TestInterface::compileShader);
-    fFunctions.fCompressedTexImage2D = bind_to_member(this, &TestInterface::compressedTexImage2D);
-    fFunctions.fCompressedTexSubImage2D = bind_to_member(this, &TestInterface::compressedTexSubImage2D);
-    fFunctions.fCopyTexSubImage2D = bind_to_member(this, &TestInterface::copyTexSubImage2D);
-    fFunctions.fCreateProgram = bind_to_member(this, &TestInterface::createProgram);
-    fFunctions.fCreateShader = bind_to_member(this, &TestInterface::createShader);
-    fFunctions.fCullFace = bind_to_member(this, &TestInterface::cullFace);
-    fFunctions.fDeleteBuffers = bind_to_member(this, &TestInterface::deleteBuffers);
-    fFunctions.fDeleteFramebuffers = bind_to_member(this, &TestInterface::deleteFramebuffers);
-    fFunctions.fDeleteProgram = bind_to_member(this, &TestInterface::deleteProgram);
-    fFunctions.fDeleteQueries = bind_to_member(this, &TestInterface::deleteQueries);
-    fFunctions.fDeleteRenderbuffers = bind_to_member(this, &TestInterface::deleteRenderbuffers);
-    fFunctions.fDeleteSamplers = bind_to_member(this, &TestInterface::deleteSamplers);
-    fFunctions.fDeleteShader = bind_to_member(this, &TestInterface::deleteShader);
-    fFunctions.fDeleteTextures = bind_to_member(this, &TestInterface::deleteTextures);
-    fFunctions.fDeleteVertexArrays = bind_to_member(this, &TestInterface::deleteVertexArrays);
-    fFunctions.fDepthMask = bind_to_member(this, &TestInterface::depthMask);
-    fFunctions.fDisable = bind_to_member(this, &TestInterface::disable);
-    fFunctions.fDisableVertexAttribArray = bind_to_member(this, &TestInterface::disableVertexAttribArray);
-    fFunctions.fDrawArrays = bind_to_member(this, &TestInterface::drawArrays);
-    fFunctions.fDrawArraysInstanced = bind_to_member(this, &TestInterface::drawArraysInstanced);
-    fFunctions.fDrawArraysIndirect = bind_to_member(this, &TestInterface::drawArraysIndirect);
-    fFunctions.fDrawBuffer = bind_to_member(this, &TestInterface::drawBuffer);
-    fFunctions.fDrawBuffers = bind_to_member(this, &TestInterface::drawBuffers);
-    fFunctions.fDrawElements = bind_to_member(this, &TestInterface::drawElements);
-    fFunctions.fDrawElementsInstanced = bind_to_member(this, &TestInterface::drawElementsInstanced);
-    fFunctions.fDrawElementsIndirect = bind_to_member(this, &TestInterface::drawElementsIndirect);
-    fFunctions.fDrawRangeElements = bind_to_member(this, &TestInterface::drawRangeElements);
-    fFunctions.fEnable = bind_to_member(this, &TestInterface::enable);
-    fFunctions.fEnableVertexAttribArray = bind_to_member(this, &TestInterface::enableVertexAttribArray);
-    fFunctions.fEndQuery = bind_to_member(this, &TestInterface::endQuery);
-    fFunctions.fFinish = bind_to_member(this, &TestInterface::finish);
-    fFunctions.fFlush = bind_to_member(this, &TestInterface::flush);
-    fFunctions.fFlushMappedBufferRange = bind_to_member(this, &TestInterface::flushMappedBufferRange);
-    fFunctions.fFramebufferRenderbuffer = bind_to_member(this, &TestInterface::framebufferRenderbuffer);
-    fFunctions.fFramebufferTexture2D = bind_to_member(this, &TestInterface::framebufferTexture2D);
-    fFunctions.fFramebufferTexture2DMultisample = bind_to_member(this, &TestInterface::framebufferTexture2DMultisample);
-    fFunctions.fFrontFace = bind_to_member(this, &TestInterface::frontFace);
-    fFunctions.fGenBuffers = bind_to_member(this, &TestInterface::genBuffers);
-    fFunctions.fGenFramebuffers = bind_to_member(this, &TestInterface::genFramebuffers);
-    fFunctions.fGenerateMipmap = bind_to_member(this, &TestInterface::generateMipmap);
-    fFunctions.fGenQueries = bind_to_member(this, &TestInterface::genQueries);
-    fFunctions.fGenRenderbuffers = bind_to_member(this, &TestInterface::genRenderbuffers);
-    fFunctions.fGenSamplers = bind_to_member(this, &TestInterface::genSamplers);
-    fFunctions.fGenTextures = bind_to_member(this, &TestInterface::genTextures);
-    fFunctions.fGenVertexArrays = bind_to_member(this, &TestInterface::genVertexArrays);
-    fFunctions.fGetBufferParameteriv = bind_to_member(this, &TestInterface::getBufferParameteriv);
-    fFunctions.fGetError = bind_to_member(this, &TestInterface::getError);
-    fFunctions.fGetFramebufferAttachmentParameteriv = bind_to_member(this, &TestInterface::getFramebufferAttachmentParameteriv);
-    fFunctions.fGetIntegerv = bind_to_member(this, &TestInterface::getIntegerv);
-    fFunctions.fGetMultisamplefv = bind_to_member(this, &TestInterface::getMultisamplefv);
-    fFunctions.fGetProgramInfoLog = bind_to_member(this, &TestInterface::getProgramInfoLog);
-    fFunctions.fGetProgramiv = bind_to_member(this, &TestInterface::getProgramiv);
-    fFunctions.fGetQueryiv = bind_to_member(this, &TestInterface::getQueryiv);
-    fFunctions.fGetQueryObjecti64v = bind_to_member(this, &TestInterface::getQueryObjecti64v);
-    fFunctions.fGetQueryObjectiv = bind_to_member(this, &TestInterface::getQueryObjectiv);
-    fFunctions.fGetQueryObjectui64v = bind_to_member(this, &TestInterface::getQueryObjectui64v);
-    fFunctions.fGetQueryObjectuiv = bind_to_member(this, &TestInterface::getQueryObjectuiv);
-    fFunctions.fGetRenderbufferParameteriv = bind_to_member(this, &TestInterface::getRenderbufferParameteriv);
-    fFunctions.fGetShaderInfoLog = bind_to_member(this, &TestInterface::getShaderInfoLog);
-    fFunctions.fGetShaderiv = bind_to_member(this, &TestInterface::getShaderiv);
-    fFunctions.fGetShaderPrecisionFormat = bind_to_member(this, &TestInterface::getShaderPrecisionFormat);
-    fFunctions.fGetString = bind_to_member(this, &TestInterface::getString);
-    fFunctions.fGetStringi = bind_to_member(this, &TestInterface::getStringi);
-    fFunctions.fGetTexLevelParameteriv = bind_to_member(this, &TestInterface::getTexLevelParameteriv);
-    fFunctions.fGetUniformLocation = bind_to_member(this, &TestInterface::getUniformLocation);
-    fFunctions.fInsertEventMarker = bind_to_member(this, &TestInterface::insertEventMarker);
-    fFunctions.fInvalidateBufferData = bind_to_member(this, &TestInterface::invalidateBufferData);
-    fFunctions.fInvalidateBufferSubData = bind_to_member(this, &TestInterface::invalidateBufferSubData);
-    fFunctions.fInvalidateFramebuffer = bind_to_member(this, &TestInterface::invalidateFramebuffer);
-    fFunctions.fInvalidateSubFramebuffer = bind_to_member(this, &TestInterface::invalidateSubFramebuffer);
-    fFunctions.fInvalidateTexImage = bind_to_member(this, &TestInterface::invalidateTexImage);
-    fFunctions.fInvalidateTexSubImage = bind_to_member(this, &TestInterface::invalidateTexSubImage);
-    fFunctions.fIsTexture = bind_to_member(this, &TestInterface::isTexture);
-    fFunctions.fLineWidth = bind_to_member(this, &TestInterface::lineWidth);
-    fFunctions.fLinkProgram = bind_to_member(this, &TestInterface::linkProgram);
-    fFunctions.fMapBuffer = bind_to_member(this, &TestInterface::mapBuffer);
-    fFunctions.fMapBufferRange = bind_to_member(this, &TestInterface::mapBufferRange);
-    fFunctions.fMapBufferSubData = bind_to_member(this, &TestInterface::mapBufferSubData);
-    fFunctions.fMapTexSubImage2D = bind_to_member(this, &TestInterface::mapTexSubImage2D);
-    fFunctions.fPixelStorei = bind_to_member(this, &TestInterface::pixelStorei);
-    fFunctions.fPolygonMode = bind_to_member(this, &TestInterface::polygonMode);
-    fFunctions.fPopGroupMarker = bind_to_member(this, &TestInterface::popGroupMarker);
-    fFunctions.fPushGroupMarker = bind_to_member(this, &TestInterface::pushGroupMarker);
-    fFunctions.fQueryCounter = bind_to_member(this, &TestInterface::queryCounter);
-    fFunctions.fReadBuffer = bind_to_member(this, &TestInterface::readBuffer);
-    fFunctions.fReadPixels = bind_to_member(this, &TestInterface::readPixels);
-    fFunctions.fRenderbufferStorage = bind_to_member(this, &TestInterface::renderbufferStorage);
-    fFunctions.fRenderbufferStorageMultisample = bind_to_member(this, &TestInterface::renderbufferStorageMultisample);
-    fFunctions.fResolveMultisampleFramebuffer = bind_to_member(this, &TestInterface::resolveMultisampleFramebuffer);
-    fFunctions.fScissor = bind_to_member(this, &TestInterface::scissor);
-    fFunctions.fBindUniformLocation = bind_to_member(this, &TestInterface::bindUniformLocation);
-    fFunctions.fSamplerParameteri = bind_to_member(this, &TestInterface::samplerParameteri);
-    fFunctions.fSamplerParameteriv = bind_to_member(this, &TestInterface::samplerParameteriv);
-    fFunctions.fShaderSource = bind_to_member(this, &TestInterface::shaderSource);
-    fFunctions.fStencilFunc = bind_to_member(this, &TestInterface::stencilFunc);
-    fFunctions.fStencilFuncSeparate = bind_to_member(this, &TestInterface::stencilFuncSeparate);
-    fFunctions.fStencilMask = bind_to_member(this, &TestInterface::stencilMask);
-    fFunctions.fStencilMaskSeparate = bind_to_member(this, &TestInterface::stencilMaskSeparate);
-    fFunctions.fStencilOp = bind_to_member(this, &TestInterface::stencilOp);
-    fFunctions.fStencilOpSeparate = bind_to_member(this, &TestInterface::stencilOpSeparate);
-    fFunctions.fTexBuffer = bind_to_member(this, &TestInterface::texBuffer);
-    fFunctions.fTexImage2D = bind_to_member(this, &TestInterface::texImage2D);
-    fFunctions.fTexParameterf = bind_to_member(this, &TestInterface::texParameterf);
-    fFunctions.fTexParameterfv = bind_to_member(this, &TestInterface::texParameterfv);
-    fFunctions.fTexParameteri = bind_to_member(this, &TestInterface::texParameteri);
-    fFunctions.fTexParameteriv = bind_to_member(this, &TestInterface::texParameteriv);
-    fFunctions.fTexStorage2D = bind_to_member(this, &TestInterface::texStorage2D);
-    fFunctions.fDiscardFramebuffer = bind_to_member(this, &TestInterface::discardFramebuffer);
-    fFunctions.fTexSubImage2D = bind_to_member(this, &TestInterface::texSubImage2D);
-    fFunctions.fTextureBarrier = bind_to_member(this, &TestInterface::textureBarrier);
-    fFunctions.fUniform1f = bind_to_member(this, &TestInterface::uniform1f);
-    fFunctions.fUniform1i = bind_to_member(this, &TestInterface::uniform1i);
-    fFunctions.fUniform1fv = bind_to_member(this, &TestInterface::uniform1fv);
-    fFunctions.fUniform1iv = bind_to_member(this, &TestInterface::uniform1iv);
-    fFunctions.fUniform2f = bind_to_member(this, &TestInterface::uniform2f);
-    fFunctions.fUniform2i = bind_to_member(this, &TestInterface::uniform2i);
-    fFunctions.fUniform2fv = bind_to_member(this, &TestInterface::uniform2fv);
-    fFunctions.fUniform2iv = bind_to_member(this, &TestInterface::uniform2iv);
-    fFunctions.fUniform3f = bind_to_member(this, &TestInterface::uniform3f);
-    fFunctions.fUniform3i = bind_to_member(this, &TestInterface::uniform3i);
-    fFunctions.fUniform3fv = bind_to_member(this, &TestInterface::uniform3fv);
-    fFunctions.fUniform3iv = bind_to_member(this, &TestInterface::uniform3iv);
-    fFunctions.fUniform4f = bind_to_member(this, &TestInterface::uniform4f);
-    fFunctions.fUniform4i = bind_to_member(this, &TestInterface::uniform4i);
-    fFunctions.fUniform4fv = bind_to_member(this, &TestInterface::uniform4fv);
-    fFunctions.fUniform4iv = bind_to_member(this, &TestInterface::uniform4iv);
-    fFunctions.fUniformMatrix2fv = bind_to_member(this, &TestInterface::uniformMatrix2fv);
-    fFunctions.fUniformMatrix3fv = bind_to_member(this, &TestInterface::uniformMatrix3fv);
-    fFunctions.fUniformMatrix4fv = bind_to_member(this, &TestInterface::uniformMatrix4fv);
-    fFunctions.fUnmapBuffer = bind_to_member(this, &TestInterface::unmapBuffer);
-    fFunctions.fUnmapBufferSubData = bind_to_member(this, &TestInterface::unmapBufferSubData);
-    fFunctions.fUnmapTexSubImage2D = bind_to_member(this, &TestInterface::unmapTexSubImage2D);
-    fFunctions.fUseProgram = bind_to_member(this, &TestInterface::useProgram);
-    fFunctions.fVertexAttrib1f = bind_to_member(this, &TestInterface::vertexAttrib1f);
-    fFunctions.fVertexAttrib2fv = bind_to_member(this, &TestInterface::vertexAttrib2fv);
-    fFunctions.fVertexAttrib3fv = bind_to_member(this, &TestInterface::vertexAttrib3fv);
-    fFunctions.fVertexAttrib4fv = bind_to_member(this, &TestInterface::vertexAttrib4fv);
-    fFunctions.fVertexAttribDivisor = bind_to_member(this, &TestInterface::vertexAttribDivisor);
-    fFunctions.fVertexAttribIPointer = bind_to_member(this, &TestInterface::vertexAttribIPointer);
-    fFunctions.fVertexAttribPointer = bind_to_member(this, &TestInterface::vertexAttribPointer);
-    fFunctions.fViewport = bind_to_member(this, &TestInterface::viewport);
-    fFunctions.fMatrixLoadf = bind_to_member(this, &TestInterface::matrixLoadf);
-    fFunctions.fMatrixLoadIdentity = bind_to_member(this, &TestInterface::matrixLoadIdentity);
-    fFunctions.fPathCommands = bind_to_member(this, &TestInterface::pathCommands);
-    fFunctions.fPathParameteri = bind_to_member(this, &TestInterface::pathParameteri);
-    fFunctions.fPathParameterf = bind_to_member(this, &TestInterface::pathParameterf);
-    fFunctions.fGenPaths = bind_to_member(this, &TestInterface::genPaths);
-    fFunctions.fDeletePaths = bind_to_member(this, &TestInterface::deletePaths);
-    fFunctions.fIsPath = bind_to_member(this, &TestInterface::isPath);
-    fFunctions.fPathStencilFunc = bind_to_member(this, &TestInterface::pathStencilFunc);
-    fFunctions.fStencilFillPath = bind_to_member(this, &TestInterface::stencilFillPath);
-    fFunctions.fStencilStrokePath = bind_to_member(this, &TestInterface::stencilStrokePath);
-    fFunctions.fStencilFillPathInstanced = bind_to_member(this, &TestInterface::stencilFillPathInstanced);
-    fFunctions.fStencilStrokePathInstanced = bind_to_member(this, &TestInterface::stencilStrokePathInstanced);
-    fFunctions.fCoverFillPath = bind_to_member(this, &TestInterface::coverFillPath);
-    fFunctions.fCoverStrokePath = bind_to_member(this, &TestInterface::coverStrokePath);
-    fFunctions.fCoverFillPathInstanced = bind_to_member(this, &TestInterface::coverFillPathInstanced);
-    fFunctions.fCoverStrokePathInstanced = bind_to_member(this, &TestInterface::coverStrokePathInstanced);
-    fFunctions.fStencilThenCoverFillPath = bind_to_member(this, &TestInterface::stencilThenCoverFillPath);
-    fFunctions.fStencilThenCoverStrokePath = bind_to_member(this, &TestInterface::stencilThenCoverStrokePath);
-    fFunctions.fStencilThenCoverFillPathInstanced = bind_to_member(this, &TestInterface::stencilThenCoverFillPathInstanced);
-    fFunctions.fStencilThenCoverStrokePathInstanced = bind_to_member(this, &TestInterface::stencilThenCoverStrokePathInstanced);
-    fFunctions.fProgramPathFragmentInputGen = bind_to_member(this, &TestInterface::programPathFragmentInputGen);
-    fFunctions.fBindFragmentInputLocation = bind_to_member(this, &TestInterface::bindFragmentInputLocation);
-    fFunctions.fGetProgramResourceLocation = bind_to_member(this, &TestInterface::getProgramResourceLocation);
-    fFunctions.fCoverageModulation = bind_to_member(this, &TestInterface::coverageModulation);
-    fFunctions.fMultiDrawArraysIndirect = bind_to_member(this, &TestInterface::multiDrawArraysIndirect);
-    fFunctions.fMultiDrawElementsIndirect = bind_to_member(this, &TestInterface::multiDrawElementsIndirect);
-    fFunctions.fFenceSync = bind_to_member(this, &TestInterface::fenceSync);
-    fFunctions.fIsSync = bind_to_member(this, &TestInterface::isSync);
-    fFunctions.fClientWaitSync = bind_to_member(this, &TestInterface::clientWaitSync);
-    fFunctions.fWaitSync = bind_to_member(this, &TestInterface::waitSync);
-    fFunctions.fDeleteSync = bind_to_member(this, &TestInterface::deleteSync);
-    fFunctions.fDebugMessageControl = bind_to_member(this, &TestInterface::debugMessageControl);
-    fFunctions.fDebugMessageInsert = bind_to_member(this, &TestInterface::debugMessageInsert);
-    fFunctions.fDebugMessageCallback = bind_to_member(this, &TestInterface::debugMessageCallback);
-    fFunctions.fGetDebugMessageLog = bind_to_member(this, &TestInterface::getDebugMessageLog);
-    fFunctions.fPushDebugGroup = bind_to_member(this, &TestInterface::pushDebugGroup);
-    fFunctions.fPopDebugGroup = bind_to_member(this, &TestInterface::popDebugGroup);
-    fFunctions.fObjectLabel = bind_to_member(this, &TestInterface::objectLabel);
-    fFunctions.fGetInternalformativ = bind_to_member(this, &TestInterface::getInternalformativ);
-    fFunctions.fProgramBinary = bind_to_member(this, &TestInterface::programBinary);
-    fFunctions.fGetProgramBinary = bind_to_member(this, &TestInterface::getProgramBinary);
-    fFunctions.fProgramParameteri = bind_to_member(this, &TestInterface::programParameteri);
-}
-
-/** Null interface implementation */
-class NullInterface : public TestInterface {
-public:
-    NullInterface(bool enableNVPR)
-        : fCurrDrawFramebuffer(0)
-        , fCurrReadFramebuffer(0)
-        , fCurrRenderbuffer(0)
-        , fCurrProgramID(0)
-        , fCurrShaderID(0)
-        , fCurrGenericID(0)
-        , fCurrUniformLocation(0)
-        , fCurrPathID(0) {
-        memset(fBoundBuffers, 0, sizeof(fBoundBuffers));
-        fAdvertisedExtensions.push_back("GL_ARB_framebuffer_object");
-        fAdvertisedExtensions.push_back("GL_ARB_blend_func_extended");
-        fAdvertisedExtensions.push_back("GL_ARB_timer_query");
-        fAdvertisedExtensions.push_back("GL_ARB_draw_buffers");
-        fAdvertisedExtensions.push_back("GL_ARB_occlusion_query");
-        fAdvertisedExtensions.push_back("GL_EXT_stencil_wrap");
-        if (enableNVPR) {
-            fAdvertisedExtensions.push_back("GL_NV_path_rendering");
-            fAdvertisedExtensions.push_back("GL_ARB_program_interface_query");
-        }
-        fAdvertisedExtensions.push_back(nullptr);
-
-        this->init(kGL_GrGLStandard);
-    }
-
-    GrGLenum checkFramebufferStatus(GrGLenum target) override {
-        return GR_GL_FRAMEBUFFER_COMPLETE;
-    }
-
-    GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override {
-        for (int i = 0; i < n; ++i) {
-            Buffer* buffer = fBufferManager.create();
-            ids[i] = buffer->id();
-        }
-    }
-
-    GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data,
-                        GrGLenum usage) override {
-        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
-        if (id > 0) {
-            Buffer* buffer = fBufferManager.lookUp(id);
-            buffer->allocate(size, (const GrGLchar*) data);
-        }
-    }
-
-    GrGLuint createProgram() override {
-        return ++fCurrProgramID;
-    }
-
-    GrGLuint createShader(GrGLenum type) override {
-        return ++fCurrShaderID;
-    }
-
-    GrGLvoid bindBuffer(GrGLenum target, GrGLuint buffer) override {
-        fBoundBuffers[GetBufferIndex(target)] = buffer;
-    }
-
-   // deleting a bound buffer has the side effect of binding 0
-   GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* ids) override {
-        // First potentially unbind the buffers.
-        for (int buffIdx = 0; buffIdx < kNumBufferTargets; ++buffIdx) {
-            if (!fBoundBuffers[buffIdx]) {
-                continue;
-            }
-            for (int i = 0; i < n; ++i) {
-                if (ids[i] == fBoundBuffers[buffIdx]) {
-                    fBoundBuffers[buffIdx] = 0;
-                    break;
-                }
-            }
-        }
-
-        // Then actually "delete" the buffers.
-        for (int i = 0; i < n; ++i) {
-            if (ids[i] > 0) {
-                Buffer* buffer = fBufferManager.lookUp(ids[i]);
-                fBufferManager.free(buffer);
-            }
-        }
-    }
-
-    GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint *framebuffers) override {
-        for (int i = 0; i < n; ++i) {
-            Framebuffer* framebuffer = fFramebufferManager.create();
-            framebuffers[i] = framebuffer->id();
-        }
-    }
-
-    GrGLvoid bindFramebuffer(GrGLenum target, GrGLuint framebuffer) override {
-        SkASSERT(GR_GL_FRAMEBUFFER == target || GR_GL_DRAW_FRAMEBUFFER == target ||
-                 GR_GL_READ_FRAMEBUFFER == target);
-        if (GR_GL_READ_FRAMEBUFFER != target) {
-            fCurrDrawFramebuffer = framebuffer;
-        }
-        if (GR_GL_DRAW_FRAMEBUFFER != target) {
-            fCurrReadFramebuffer = framebuffer;
-        }
-    }
-
-    GrGLvoid deleteFramebuffers(GrGLsizei n, const GrGLuint* ids) override {
-        for (int i = 0; i < n; ++i) {
-            if (ids[i] == fCurrDrawFramebuffer) {
-                fCurrDrawFramebuffer = 0;
-            }
-            if (ids[i] == fCurrReadFramebuffer) {
-                fCurrReadFramebuffer = 0;
-            }
-
-            if (ids[i] > 0) {
-                Framebuffer* framebuffer = fFramebufferManager.lookUp(ids[i]);
-                fFramebufferManager.free(framebuffer);
-            }
-        }
-    }
-
-    GrGLvoid genQueries(GrGLsizei n, GrGLuint *ids) override { this->genGenericIds(n, ids); }
-
-    GrGLvoid genRenderbuffers(GrGLsizei n, GrGLuint *renderbuffers) override {
-        for (int i = 0; i < n; ++i) {
-            Renderbuffer* renderbuffer = fRenderbufferManager.create();
-            renderbuffers[i] = renderbuffer->id();
-        }
-    }
-
-    GrGLvoid bindRenderbuffer(GrGLenum target, GrGLuint renderbuffer) override {
-        SkASSERT(GR_GL_RENDERBUFFER == target);
-        fCurrRenderbuffer = renderbuffer;
-    }
-
-    GrGLvoid deleteRenderbuffers(GrGLsizei n, const GrGLuint* ids) override {
-        for (int i = 0; i < n; ++i) {
-            if (ids[i] <= 0) {
-                continue;
-            }
-            if (ids[i] == fCurrRenderbuffer) {
-                fCurrRenderbuffer = 0;
-            }
-            Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(ids[i]);
-
-            if (fCurrDrawFramebuffer) {
-                Framebuffer* drawFramebuffer = fFramebufferManager.lookUp(fCurrDrawFramebuffer);
-                drawFramebuffer->notifyAttachmentDeleteWhileBound(renderbuffer);
-            }
-            if (fCurrReadFramebuffer) {
-                Framebuffer* readFramebuffer = fFramebufferManager.lookUp(fCurrReadFramebuffer);
-                readFramebuffer->notifyAttachmentDeleteWhileBound(renderbuffer);
-            }
-
-            fRenderbufferManager.free(renderbuffer);
-        }
-    }
-
-    GrGLvoid renderbufferStorage(GrGLenum target, GrGLenum internalformat, GrGLsizei width,
-                                 GrGLsizei height) override {
-        GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
-        GrAlwaysAssert(fCurrRenderbuffer);
-        Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuffer);
-        renderbuffer->setNumSamples(1);
-    }
-
-    GrGLvoid renderbufferStorageMultisample(GrGLenum target, GrGLsizei samples,
-                                            GrGLenum internalformat, GrGLsizei width,
-                                            GrGLsizei height) override {
-        GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
-        GrAlwaysAssert(samples > 0);
-        GrAlwaysAssert(fCurrRenderbuffer);
-        Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuffer);
-        renderbuffer->setNumSamples(samples);
-    }
-
-    GrGLvoid namedRenderbufferStorage(GrGLuint renderbuffer, GrGLenum GrGLinternalformat,
-                                      GrGLsizei width, GrGLsizei height) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid namedRenderbufferStorageMultisample(GrGLuint renderbuffer, GrGLsizei samples,
-                                                 GrGLenum GrGLinternalformat, GrGLsizei width,
-                                                 GrGLsizei height) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid framebufferRenderbuffer(GrGLenum target, GrGLenum attachment,
-                                     GrGLenum renderbuffertarget,
-                                     GrGLuint renderBufferID) override {
-        GrGLuint id = this->getBoundFramebufferID(target);
-        GrAlwaysAssert(id);
-        Framebuffer* framebuffer = fFramebufferManager.lookUp(id);
-
-        GrAlwaysAssert(GR_GL_RENDERBUFFER == renderbuffertarget);
-        if (!renderBufferID && !fCurrRenderbuffer) {
-           return;
-        }
-        GrAlwaysAssert(fCurrRenderbuffer);
-        Renderbuffer* renderbuffer = fRenderbufferManager.lookUp(fCurrRenderbuffer);
-
-        framebuffer->setAttachment(attachment, renderbuffer);
-    }
-
-    GrGLvoid namedFramebufferRenderbuffer(GrGLuint framebuffer, GrGLenum attachment,
-                                          GrGLenum renderbuffertarget,
-                                          GrGLuint renderbuffer) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid genSamplers(GrGLsizei n, GrGLuint* samplers) override {
-        this->genGenericIds(n, samplers);
-    }
-
-    GrGLvoid genTextures(GrGLsizei n, GrGLuint *textures) override {
-        this->genGenericIds(n, textures);
-    }
-
-    GrGLvoid framebufferTexture2D(GrGLenum target, GrGLenum attachment, GrGLenum textarget,
-                                  GrGLuint textureID, GrGLint level) override {
-        GrGLuint id = this->getBoundFramebufferID(target);
-        GrAlwaysAssert(id);
-        Framebuffer* framebuffer = fFramebufferManager.lookUp(id);
-        framebuffer->setAttachment(attachment, this->getSingleTextureObject());
-    }
-
-    GrGLvoid framebufferTexture2DMultisample(GrGLenum target, GrGLenum attachment,
-                                             GrGLenum textarget, GrGLuint texture, GrGLint level,
-                                             GrGLsizei samples) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid namedFramebufferTexture1D(GrGLuint framebuffer, GrGLenum attachment,
-                                       GrGLenum textarget, GrGLuint texture,
-                                       GrGLint level) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid namedFramebufferTexture2D(GrGLuint framebuffer, GrGLenum attachment,
-                                       GrGLenum textarget, GrGLuint texture,
-                                       GrGLint level) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid namedFramebufferTexture3D(GrGLuint framebuffer, GrGLenum attachment,
-                                       GrGLenum textarget, GrGLuint texture, GrGLint level,
-                                       GrGLint zoffset) override {
-        SK_ABORT("Not implemented");
-    }
-
-    GrGLvoid genVertexArrays(GrGLsizei n, GrGLuint *arrays) override {
-        this->genGenericIds(n, arrays);
-    }
-
-    GrGLenum getError() override { return GR_GL_NO_ERROR; }
-
-    GrGLvoid getIntegerv(GrGLenum pname, GrGLint* params) override {
-        // TODO: remove from Ganesh the #defines for gets we don't use.
-        // We would like to minimize gets overall due to performance issues
-        switch (pname) {
-            case GR_GL_CONTEXT_PROFILE_MASK:
-                *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
-                break;
-            case GR_GL_STENCIL_BITS:
-                *params = 8;
-                break;
-            case GR_GL_SAMPLES: {
-                GrAlwaysAssert(fCurrDrawFramebuffer);
-                Framebuffer* framebuffer = fFramebufferManager.lookUp(fCurrDrawFramebuffer);
-                *params = framebuffer->numSamples();
-                break;
-            }
-            case GR_GL_FRAMEBUFFER_BINDING:
-                *params = 0;
-                break;
-            case GR_GL_VIEWPORT:
-                params[0] = 0;
-                params[1] = 0;
-                params[2] = 800;
-                params[3] = 600;
-                break;
-            case GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
-            case GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
-            case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
-            case GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
-                *params = 8;
-                break;
-            case GR_GL_MAX_TEXTURE_COORDS:
-                *params = 8;
-                break;
-            case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
-                *params = kDefaultMaxVertexUniformVectors;
-                break;
-            case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-                *params = kDefaultMaxFragmentUniformVectors;
-                break;
-            case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
-                *params = 16 * 4;
-                break;
-            case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
-                *params = 0;
-                break;
-            case GR_GL_COMPRESSED_TEXTURE_FORMATS:
-                break;
-            case GR_GL_MAX_TEXTURE_SIZE:
-                *params = 8192;
-                break;
-            case GR_GL_MAX_RENDERBUFFER_SIZE:
-                *params = 8192;
-                break;
-            case GR_GL_MAX_SAMPLES:
-                *params = 32;
-                break;
-            case GR_GL_MAX_VERTEX_ATTRIBS:
-                *params = kDefaultMaxVertexAttribs;
-                break;
-            case GR_GL_MAX_VARYING_VECTORS:
-                *params = kDefaultMaxVaryingVectors;
-                break;
-            case GR_GL_NUM_EXTENSIONS: {
-                GrGLint i = 0;
-                while (fAdvertisedExtensions[i++]);
-                *params = i;
-                break;
-            }
-            default:
-                SK_ABORT("Unexpected pname to GetIntegerv");
-        }
-    }
-
-    GrGLvoid getProgramiv(GrGLuint program, GrGLenum pname, GrGLint* params) override {
-        this->getShaderOrProgramiv(program, pname, params);
-    }
-
-    GrGLvoid getProgramInfoLog(GrGLuint program, GrGLsizei bufsize, GrGLsizei* length,
-                               char* infolog) override {
-        this->getInfoLog(program, bufsize, length, infolog);
-    }
-
-    GrGLvoid getMultisamplefv(GrGLenum pname, GrGLuint index, GrGLfloat* val) override {
-        val[0] = val[1] = 0.5f;
-    }
-
-    GrGLvoid getQueryiv(GrGLenum GLtarget, GrGLenum pname, GrGLint *params) override {
-        switch (pname) {
-            case GR_GL_CURRENT_QUERY:
-                *params = 0;
-                break;
-            case GR_GL_QUERY_COUNTER_BITS:
-                *params = 32;
-                break;
-            default:
-                SK_ABORT("Unexpected pname passed GetQueryiv.");
-        }
-    }
-
-    GrGLvoid getQueryObjecti64v(GrGLuint id, GrGLenum pname, GrGLint64 *params) override {
-        this->queryResult(id, pname, params);
-    }
-
-    GrGLvoid getQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params) override {
-        this->queryResult(id, pname, params);
-    }
-
-    GrGLvoid getQueryObjectui64v(GrGLuint id, GrGLenum pname, GrGLuint64 *params) override {
-        this->queryResult(id, pname, params);
-    }
-
-    GrGLvoid getQueryObjectuiv(GrGLuint id, GrGLenum pname, GrGLuint *params) override {
-        this->queryResult(id, pname, params);
-    }
-
-    GrGLvoid getShaderiv(GrGLuint shader, GrGLenum pname, GrGLint* params) override {
-        this->getShaderOrProgramiv(shader, pname, params);
-    }
-
-    GrGLvoid getShaderInfoLog(GrGLuint shader, GrGLsizei bufsize, GrGLsizei* length,
-                              char* infolog) override {
-        this->getInfoLog(shader, bufsize, length, infolog);
-    }
-
-    const GrGLubyte* getString(GrGLenum name) override {
-        switch (name) {
-            case GR_GL_EXTENSIONS:
-                return CombinedExtensionString();
-            case GR_GL_VERSION:
-                return (const GrGLubyte*)"4.0 Null GL";
-            case GR_GL_SHADING_LANGUAGE_VERSION:
-                return (const GrGLubyte*)"4.20.8 Null GLSL";
-            case GR_GL_VENDOR:
-                return (const GrGLubyte*)"Null Vendor";
-            case GR_GL_RENDERER:
-                return (const GrGLubyte*)"The Null (Non-)Renderer";
-            default:
-                SK_ABORT("Unexpected name passed to GetString");
-                return nullptr;
-        }
-    }
-
-    const GrGLubyte* getStringi(GrGLenum name, GrGLuint i) override {
-        switch (name) {
-            case GR_GL_EXTENSIONS: {
-                GrGLint count;
-                this->getIntegerv(GR_GL_NUM_EXTENSIONS, &count);
-                if ((GrGLint)i <= count) {
-                    return (const GrGLubyte*) fAdvertisedExtensions[i];
-                } else {
-                    return nullptr;
-                }
-            }
-            default:
-                SK_ABORT("Unexpected name passed to GetStringi");
-                return nullptr;
-        }
-    }
-
-    GrGLint getUniformLocation(GrGLuint program, const char* name) override {
-        return ++fCurrUniformLocation;
-    }
-
-    GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length,
-                             GrGLbitfield access) override {
-        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
-        if (id > 0) {
-            // We just ignore the offset and length here.
-            Buffer* buffer = fBufferManager.lookUp(id);
-            SkASSERT(!buffer->mapped());
-            buffer->setMapped(true);
-            return buffer->dataPtr();
-        }
-        return nullptr;
-    }
-
-    GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override {
-        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
-        if (id > 0) {
-            Buffer* buffer = fBufferManager.lookUp(id);
-            SkASSERT(!buffer->mapped());
-            buffer->setMapped(true);
-            return buffer->dataPtr();
-        }
-
-        SkASSERT(false);
-        return nullptr;            // no buffer bound to target
-    }
-
-    GrGLboolean unmapBuffer(GrGLenum target) override {
-        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
-        if (id > 0) {
-            Buffer* buffer = fBufferManager.lookUp(id);
-            SkASSERT(buffer->mapped());
-            buffer->setMapped(false);
-            return GR_GL_TRUE;
-        }
-
-        GrAlwaysAssert(false);
-        return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
-    }
-
-    GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) override {
-        switch (pname) {
-            case GR_GL_BUFFER_MAPPED: {
-                *params = GR_GL_FALSE;
-                GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
-                if (id > 0) {
-                    Buffer* buffer = fBufferManager.lookUp(id);
-                    if (buffer->mapped()) {
-                        *params = GR_GL_TRUE;
-                    }
-                }
-                break; }
-            default:
-                SK_ABORT("Unexpected pname to GetBufferParamateriv");
-                break;
-        }
-    }
-
-    // NV_path_rendering
-    GrGLuint genPaths(GrGLsizei range) override {
-        return ++fCurrPathID;
-    }
-
-
-private:
-    inline int static GetBufferIndex(GrGLenum glTarget) {
-        switch (glTarget) {
-            default:                           SK_ABORT("Unexpected GL target to GetBufferIndex");
-            case GR_GL_ARRAY_BUFFER:           return 0;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:   return 1;
-            case GR_GL_TEXTURE_BUFFER:         return 2;
-            case GR_GL_DRAW_INDIRECT_BUFFER:   return 3;
-            case GR_GL_PIXEL_PACK_BUFFER:      return 4;
-            case GR_GL_PIXEL_UNPACK_BUFFER:    return 5;
-        }
-    }
-    constexpr int static kNumBufferTargets = 6;
-
-    TGLObjectManager<Buffer>         fBufferManager;
-    GrGLuint                         fBoundBuffers[kNumBufferTargets];
-    TGLObjectManager<Framebuffer>    fFramebufferManager;
-    GrGLuint                         fCurrDrawFramebuffer;
-    GrGLuint                         fCurrReadFramebuffer;
-    TGLObjectManager<Renderbuffer>   fRenderbufferManager;
-    GrGLuint                         fCurrRenderbuffer;
-    GrGLuint                         fCurrProgramID;
-    GrGLuint                         fCurrShaderID;
-    GrGLuint                         fCurrGenericID;
-    GrGLuint                         fCurrUniformLocation;
-    GrGLuint                         fCurrPathID;
-    sk_sp<const Texture>             fSingleTextureObject;
-    SkTArray<const char*>            fAdvertisedExtensions;
-
-    // the OpenGLES 2.0 spec says this must be >= 128
-    static const GrGLint kDefaultMaxVertexUniformVectors = 128;
-
-    // the OpenGLES 2.0 spec says this must be >=16
-    static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
-
-    // the OpenGLES 2.0 spec says this must be >= 8
-    static const GrGLint kDefaultMaxVertexAttribs = 8;
-
-    // the OpenGLES 2.0 spec says this must be >= 8
-    static const GrGLint kDefaultMaxVaryingVectors = 8;
-
-    GrGLuint getBoundFramebufferID(GrGLenum target) {
-        switch (target) {
-            case GR_GL_FRAMEBUFFER:
-            case GR_GL_DRAW_FRAMEBUFFER:
-                return fCurrDrawFramebuffer;
-            case GR_GL_READ_FRAMEBUFFER:
-                return fCurrReadFramebuffer;
-            default:
-                SK_ABORT("Invalid framebuffer target.");
-                return 0;
-        }
-    }
-
-    const Texture* getSingleTextureObject() {
-        // We currently only use FramebufferAttachment objects for a sample count, and all textures
-        // in Skia have one sample, so there is no need as of yet to track individual textures. This
-        // also works around a bug in chromium's cc_unittests where they send us texture IDs that
-        // were generated by cc::TestGLES2Interface.
-        if (!fSingleTextureObject) {
-            fSingleTextureObject.reset(new Texture);
-        }
-        return fSingleTextureObject.get();
-    }
-
-    const GrGLubyte* CombinedExtensionString() {
-        static SkString gExtString;
-        static SkMutex gMutex;
-        gMutex.acquire();
-        if (0 == gExtString.size()) {
-            int i = 0;
-            while (fAdvertisedExtensions[i]) {
-                if (i > 0) {
-                    gExtString.append(" ");
-                }
-                gExtString.append(fAdvertisedExtensions[i]);
-                ++i;
-            }
-        }
-        gMutex.release();
-        return (const GrGLubyte*) gExtString.c_str();
-    }
-
-    GrGLvoid genGenericIds(GrGLsizei n, GrGLuint* ids) {
-        for (int i = 0; i < n; ++i) {
-            ids[i] = ++fCurrGenericID;
-        }
-    }
-
-    GrGLvoid getInfoLog(GrGLuint object, GrGLsizei bufsize, GrGLsizei* length,
-                        char* infolog) {
-        if (length) {
-            *length = 0;
-        }
-        if (bufsize > 0) {
-            *infolog = 0;
-        }
-    }
-
-    GrGLvoid getShaderOrProgramiv(GrGLuint object,  GrGLenum pname, GrGLint* params) {
-        switch (pname) {
-            case GR_GL_LINK_STATUS:  // fallthru
-            case GR_GL_COMPILE_STATUS:
-                *params = GR_GL_TRUE;
-                break;
-            case GR_GL_INFO_LOG_LENGTH: // fallthru
-            case GL_PROGRAM_BINARY_LENGTH:
-                *params = 0;
-                break;
-                // we don't expect any other pnames
-            default:
-                SK_ABORT("Unexpected pname to GetProgramiv");
-                break;
-        }
-    }
-
-    template <typename T>
-    void queryResult(GrGLenum GLtarget, GrGLenum pname, T *params) {
-        switch (pname) {
-            case GR_GL_QUERY_RESULT_AVAILABLE:
-                *params = GR_GL_TRUE;
-                break;
-            case GR_GL_QUERY_RESULT:
-                *params = 0;
-                break;
-            default:
-                SK_ABORT("Unexpected pname passed to GetQueryObject.");
-                break;
-        }
-    }
-
-    typedef TestInterface INHERITED;
-};
-
-}  // anonymous namespace
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-const GrGLInterface* CreateNullSkiaInterface() { return new NullInterface(false); }
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/ScopedReplaceDriver.h b/libs/hwui/debug/ScopedReplaceDriver.h
deleted file mode 100644
index 110196f..0000000
--- a/libs/hwui/debug/ScopedReplaceDriver.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "GlesDriver.h"
-
-namespace android {
-namespace uirenderer {
-namespace debug {
-
-template <typename Driver>
-class ScopedReplaceDriver {
-public:
-    ScopedReplaceDriver() {
-        std::unique_ptr<Driver> glDriver = std::make_unique<Driver>();
-        mCurrentDriver = glDriver.get();
-        mOldDriver = GlesDriver::replace(std::move(glDriver));
-    }
-
-    Driver& get() { return *mCurrentDriver; }
-
-    ~ScopedReplaceDriver() { GlesDriver::replace(std::move(mOldDriver)); }
-
-private:
-    std::unique_ptr<GlesDriver> mOldDriver;
-    Driver* mCurrentDriver;
-};
-
-}  // namespace debug
-}  // namespace uirenderer
-}  // namespace android
diff --git a/libs/hwui/debug/gles_decls.in b/libs/hwui/debug/gles_decls.in
deleted file mode 100644
index 3900959..0000000
--- a/libs/hwui/debug/gles_decls.in
+++ /dev/null
@@ -1,543 +0,0 @@
-GL_ENTRY(void, glActiveTexture, GLenum texture)
-GL_ENTRY(void, glAttachShader, GLuint program, GLuint shader)
-GL_ENTRY(void, glBindAttribLocation, GLuint program, GLuint index, const GLchar *name)
-GL_ENTRY(void, glBindBuffer, GLenum target, GLuint buffer)
-GL_ENTRY(void, glBindFramebuffer, GLenum target, GLuint framebuffer)
-GL_ENTRY(void, glBindRenderbuffer, GLenum target, GLuint renderbuffer)
-GL_ENTRY(void, glBindTexture, GLenum target, GLuint texture)
-GL_ENTRY(void, glBlendColor, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-GL_ENTRY(void, glBlendEquation, GLenum mode)
-GL_ENTRY(void, glBlendEquationSeparate, GLenum modeRGB, GLenum modeAlpha)
-GL_ENTRY(void, glBlendFunc, GLenum sfactor, GLenum dfactor)
-GL_ENTRY(void, glBlendFuncSeparate, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-GL_ENTRY(void, glBufferData, GLenum target, GLsizeiptr size, const void *data, GLenum usage)
-GL_ENTRY(void, glBufferSubData, GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
-GL_ENTRY(GLenum, glCheckFramebufferStatus, GLenum target)
-GL_ENTRY(void, glClear, GLbitfield mask)
-GL_ENTRY(void, glClearColor, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-GL_ENTRY(void, glClearDepthf, GLfloat d)
-GL_ENTRY(void, glClearStencil, GLint s)
-GL_ENTRY(void, glColorMask, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-GL_ENTRY(void, glCompileShader, GLuint shader)
-GL_ENTRY(void, glCompressedTexImage2D, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glCompressedTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glCopyTexImage2D, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-GL_ENTRY(void, glCopyTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(GLuint, glCreateProgram, void)
-GL_ENTRY(GLuint, glCreateShader, GLenum type)
-GL_ENTRY(void, glCullFace, GLenum mode)
-GL_ENTRY(void, glDeleteBuffers, GLsizei n, const GLuint *buffers)
-GL_ENTRY(void, glDeleteFramebuffers, GLsizei n, const GLuint *framebuffers)
-GL_ENTRY(void, glDeleteProgram, GLuint program)
-GL_ENTRY(void, glDeleteRenderbuffers, GLsizei n, const GLuint *renderbuffers)
-GL_ENTRY(void, glDeleteShader, GLuint shader)
-GL_ENTRY(void, glDeleteTextures, GLsizei n, const GLuint *textures)
-GL_ENTRY(void, glDepthFunc, GLenum func)
-GL_ENTRY(void, glDepthMask, GLboolean flag)
-GL_ENTRY(void, glDepthRangef, GLfloat n, GLfloat f)
-GL_ENTRY(void, glDetachShader, GLuint program, GLuint shader)
-GL_ENTRY(void, glDisable, GLenum cap)
-GL_ENTRY(void, glDisableVertexAttribArray, GLuint index)
-GL_ENTRY(void, glDrawArrays, GLenum mode, GLint first, GLsizei count)
-GL_ENTRY(void, glDrawElements, GLenum mode, GLsizei count, GLenum type, const void *indices)
-GL_ENTRY(void, glEnable, GLenum cap)
-GL_ENTRY(void, glEnableVertexAttribArray, GLuint index)
-GL_ENTRY(void, glFinish, void)
-GL_ENTRY(void, glFlush, void)
-GL_ENTRY(void, glFramebufferRenderbuffer, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-GL_ENTRY(void, glFramebufferTexture2D, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-GL_ENTRY(void, glFrontFace, GLenum mode)
-GL_ENTRY(void, glGenBuffers, GLsizei n, GLuint *buffers)
-GL_ENTRY(void, glGenerateMipmap, GLenum target)
-GL_ENTRY(void, glGenFramebuffers, GLsizei n, GLuint *framebuffers)
-GL_ENTRY(void, glGenRenderbuffers, GLsizei n, GLuint *renderbuffers)
-GL_ENTRY(void, glGenTextures, GLsizei n, GLuint *textures)
-GL_ENTRY(void, glGetActiveAttrib, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-GL_ENTRY(void, glGetActiveUniform, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-GL_ENTRY(void, glGetAttachedShaders, GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
-GL_ENTRY(GLint, glGetAttribLocation, GLuint program, const GLchar *name)
-GL_ENTRY(void, glGetBooleanv, GLenum pname, GLboolean *data)
-GL_ENTRY(void, glGetBufferParameteriv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(GLenum, glGetError, void)
-GL_ENTRY(void, glGetFloatv, GLenum pname, GLfloat *data)
-GL_ENTRY(void, glGetFramebufferAttachmentParameteriv, GLenum target, GLenum attachment, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetIntegerv, GLenum pname, GLint *data)
-GL_ENTRY(void, glGetProgramiv, GLuint program, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetProgramInfoLog, GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-GL_ENTRY(void, glGetRenderbufferParameteriv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetShaderiv, GLuint shader, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetShaderInfoLog, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-GL_ENTRY(void, glGetShaderPrecisionFormat, GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
-GL_ENTRY(void, glGetShaderSource, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-GL_ENTRY(const GLubyte *, glGetString, GLenum name)
-GL_ENTRY(void, glGetTexParameterfv, GLenum target, GLenum pname, GLfloat *params)
-GL_ENTRY(void, glGetTexParameteriv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetUniformfv, GLuint program, GLint location, GLfloat *params)
-GL_ENTRY(void, glGetUniformiv, GLuint program, GLint location, GLint *params)
-GL_ENTRY(GLint, glGetUniformLocation, GLuint program, const GLchar *name)
-GL_ENTRY(void, glGetVertexAttribfv, GLuint index, GLenum pname, GLfloat *params)
-GL_ENTRY(void, glGetVertexAttribiv, GLuint index, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetVertexAttribPointerv, GLuint index, GLenum pname, void **pointer)
-GL_ENTRY(void, glHint, GLenum target, GLenum mode)
-GL_ENTRY(GLboolean, glIsBuffer, GLuint buffer)
-GL_ENTRY(GLboolean, glIsEnabled, GLenum cap)
-GL_ENTRY(GLboolean, glIsFramebuffer, GLuint framebuffer)
-GL_ENTRY(GLboolean, glIsProgram, GLuint program)
-GL_ENTRY(GLboolean, glIsRenderbuffer, GLuint renderbuffer)
-GL_ENTRY(GLboolean, glIsShader, GLuint shader)
-GL_ENTRY(GLboolean, glIsTexture, GLuint texture)
-GL_ENTRY(void, glLineWidth, GLfloat width)
-GL_ENTRY(void, glLinkProgram, GLuint program)
-GL_ENTRY(void, glPixelStorei, GLenum pname, GLint param)
-GL_ENTRY(void, glPolygonOffset, GLfloat factor, GLfloat units)
-GL_ENTRY(void, glReadPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
-GL_ENTRY(void, glReleaseShaderCompiler, void)
-GL_ENTRY(void, glRenderbufferStorage, GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glSampleCoverage, GLfloat value, GLboolean invert)
-GL_ENTRY(void, glScissor, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(void, glShaderBinary, GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
-GL_ENTRY(void, glShaderSource, GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length)
-GL_ENTRY(void, glStencilFunc, GLenum func, GLint ref, GLuint mask)
-GL_ENTRY(void, glStencilFuncSeparate, GLenum face, GLenum func, GLint ref, GLuint mask)
-GL_ENTRY(void, glStencilMask, GLuint mask)
-GL_ENTRY(void, glStencilMaskSeparate, GLenum face, GLuint mask)
-GL_ENTRY(void, glStencilOp, GLenum fail, GLenum zfail, GLenum zpass)
-GL_ENTRY(void, glStencilOpSeparate, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-GL_ENTRY(void, glTexImage2D, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glTexParameterf, GLenum target, GLenum pname, GLfloat param)
-GL_ENTRY(void, glTexParameterfv, GLenum target, GLenum pname, const GLfloat *params)
-GL_ENTRY(void, glTexParameteri, GLenum target, GLenum pname, GLint param)
-GL_ENTRY(void, glTexParameteriv, GLenum target, GLenum pname, const GLint *params)
-GL_ENTRY(void, glTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glUniform1f, GLint location, GLfloat v0)
-GL_ENTRY(void, glUniform1fv, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glUniform1i, GLint location, GLint v0)
-GL_ENTRY(void, glUniform1iv, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glUniform2f, GLint location, GLfloat v0, GLfloat v1)
-GL_ENTRY(void, glUniform2fv, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glUniform2i, GLint location, GLint v0, GLint v1)
-GL_ENTRY(void, glUniform2iv, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glUniform3f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-GL_ENTRY(void, glUniform3fv, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glUniform3i, GLint location, GLint v0, GLint v1, GLint v2)
-GL_ENTRY(void, glUniform3iv, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glUniform4f, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-GL_ENTRY(void, glUniform4fv, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glUniform4i, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-GL_ENTRY(void, glUniform4iv, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glUniformMatrix2fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix3fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix4fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUseProgram, GLuint program)
-GL_ENTRY(void, glValidateProgram, GLuint program)
-GL_ENTRY(void, glVertexAttrib1f, GLuint index, GLfloat x)
-GL_ENTRY(void, glVertexAttrib1fv, GLuint index, const GLfloat *v)
-GL_ENTRY(void, glVertexAttrib2f, GLuint index, GLfloat x, GLfloat y)
-GL_ENTRY(void, glVertexAttrib2fv, GLuint index, const GLfloat *v)
-GL_ENTRY(void, glVertexAttrib3f, GLuint index, GLfloat x, GLfloat y, GLfloat z)
-GL_ENTRY(void, glVertexAttrib3fv, GLuint index, const GLfloat *v)
-GL_ENTRY(void, glVertexAttrib4f, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-GL_ENTRY(void, glVertexAttrib4fv, GLuint index, const GLfloat *v)
-GL_ENTRY(void, glVertexAttribPointer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
-GL_ENTRY(void, glViewport, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(void, glReadBuffer, GLenum src)
-GL_ENTRY(void, glDrawRangeElements, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
-GL_ENTRY(void, glTexImage3D, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glTexSubImage3D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glCopyTexSubImage3D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(void, glCompressedTexImage3D, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glCompressedTexSubImage3D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glGenQueries, GLsizei n, GLuint *ids)
-GL_ENTRY(void, glDeleteQueries, GLsizei n, const GLuint *ids)
-GL_ENTRY(GLboolean, glIsQuery, GLuint id)
-GL_ENTRY(void, glBeginQuery, GLenum target, GLuint id)
-GL_ENTRY(void, glEndQuery, GLenum target)
-GL_ENTRY(void, glGetQueryiv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetQueryObjectuiv, GLuint id, GLenum pname, GLuint *params)
-GL_ENTRY(GLboolean, glUnmapBuffer, GLenum target)
-GL_ENTRY(void, glGetBufferPointerv, GLenum target, GLenum pname, void **params)
-GL_ENTRY(void, glDrawBuffers, GLsizei n, const GLenum *bufs)
-GL_ENTRY(void, glUniformMatrix2x3fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix3x2fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix2x4fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix4x2fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix3x4fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUniformMatrix4x3fv, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glBlitFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-GL_ENTRY(void, glRenderbufferStorageMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glFramebufferTextureLayer, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-GL_ENTRY(void *, glMapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-GL_ENTRY(void, glFlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length)
-GL_ENTRY(void, glBindVertexArray, GLuint array)
-GL_ENTRY(void, glDeleteVertexArrays, GLsizei n, const GLuint *arrays)
-GL_ENTRY(void, glGenVertexArrays, GLsizei n, GLuint *arrays)
-GL_ENTRY(GLboolean, glIsVertexArray, GLuint array)
-GL_ENTRY(void, glGetIntegeri_v, GLenum target, GLuint index, GLint *data)
-GL_ENTRY(void, glBeginTransformFeedback, GLenum primitiveMode)
-GL_ENTRY(void, glEndTransformFeedback, void)
-GL_ENTRY(void, glBindBufferRange, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-GL_ENTRY(void, glBindBufferBase, GLenum target, GLuint index, GLuint buffer)
-GL_ENTRY(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
-GL_ENTRY(void, glGetTransformFeedbackVarying, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-GL_ENTRY(void, glVertexAttribIPointer, GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
-GL_ENTRY(void, glGetVertexAttribIiv, GLuint index, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetVertexAttribIuiv, GLuint index, GLenum pname, GLuint *params)
-GL_ENTRY(void, glVertexAttribI4i, GLuint index, GLint x, GLint y, GLint z, GLint w)
-GL_ENTRY(void, glVertexAttribI4ui, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-GL_ENTRY(void, glVertexAttribI4iv, GLuint index, const GLint *v)
-GL_ENTRY(void, glVertexAttribI4uiv, GLuint index, const GLuint *v)
-GL_ENTRY(void, glGetUniformuiv, GLuint program, GLint location, GLuint *params)
-GL_ENTRY(GLint, glGetFragDataLocation, GLuint program, const GLchar *name)
-GL_ENTRY(void, glUniform1ui, GLint location, GLuint v0)
-GL_ENTRY(void, glUniform2ui, GLint location, GLuint v0, GLuint v1)
-GL_ENTRY(void, glUniform3ui, GLint location, GLuint v0, GLuint v1, GLuint v2)
-GL_ENTRY(void, glUniform4ui, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-GL_ENTRY(void, glUniform1uiv, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glUniform2uiv, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glUniform3uiv, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glUniform4uiv, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glClearBufferiv, GLenum buffer, GLint drawbuffer, const GLint *value)
-GL_ENTRY(void, glClearBufferuiv, GLenum buffer, GLint drawbuffer, const GLuint *value)
-GL_ENTRY(void, glClearBufferfv, GLenum buffer, GLint drawbuffer, const GLfloat *value)
-GL_ENTRY(void, glClearBufferfi, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-GL_ENTRY(const GLubyte *, glGetStringi, GLenum name, GLuint index)
-GL_ENTRY(void, glCopyBufferSubData, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-GL_ENTRY(void, glGetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)
-GL_ENTRY(void, glGetActiveUniformsiv, GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-GL_ENTRY(GLuint, glGetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName)
-GL_ENTRY(void, glGetActiveUniformBlockiv, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetActiveUniformBlockName, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-GL_ENTRY(void, glUniformBlockBinding, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-GL_ENTRY(void, glDrawArraysInstanced, GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-GL_ENTRY(void, glDrawElementsInstanced, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
-GL_ENTRY(GLsync, glFenceSync, GLenum condition, GLbitfield flags)
-GL_ENTRY(GLboolean, glIsSync, GLsync sync)
-GL_ENTRY(void, glDeleteSync, GLsync sync)
-GL_ENTRY(GLenum, glClientWaitSync, GLsync sync, GLbitfield flags, GLuint64 timeout)
-GL_ENTRY(void, glWaitSync, GLsync sync, GLbitfield flags, GLuint64 timeout)
-GL_ENTRY(void, glGetInteger64v, GLenum pname, GLint64 *data)
-GL_ENTRY(void, glGetSynciv, GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
-GL_ENTRY(void, glGetInteger64i_v, GLenum target, GLuint index, GLint64 *data)
-GL_ENTRY(void, glGetBufferParameteri64v, GLenum target, GLenum pname, GLint64 *params)
-GL_ENTRY(void, glGenSamplers, GLsizei count, GLuint *samplers)
-GL_ENTRY(void, glDeleteSamplers, GLsizei count, const GLuint *samplers)
-GL_ENTRY(GLboolean, glIsSampler, GLuint sampler)
-GL_ENTRY(void, glBindSampler, GLuint unit, GLuint sampler)
-GL_ENTRY(void, glSamplerParameteri, GLuint sampler, GLenum pname, GLint param)
-GL_ENTRY(void, glSamplerParameteriv, GLuint sampler, GLenum pname, const GLint *param)
-GL_ENTRY(void, glSamplerParameterf, GLuint sampler, GLenum pname, GLfloat param)
-GL_ENTRY(void, glSamplerParameterfv, GLuint sampler, GLenum pname, const GLfloat *param)
-GL_ENTRY(void, glGetSamplerParameteriv, GLuint sampler, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetSamplerParameterfv, GLuint sampler, GLenum pname, GLfloat *params)
-GL_ENTRY(void, glVertexAttribDivisor, GLuint index, GLuint divisor)
-GL_ENTRY(void, glBindTransformFeedback, GLenum target, GLuint id)
-GL_ENTRY(void, glDeleteTransformFeedbacks, GLsizei n, const GLuint *ids)
-GL_ENTRY(void, glGenTransformFeedbacks, GLsizei n, GLuint *ids)
-GL_ENTRY(GLboolean, glIsTransformFeedback, GLuint id)
-GL_ENTRY(void, glPauseTransformFeedback, void)
-GL_ENTRY(void, glResumeTransformFeedback, void)
-GL_ENTRY(void, glGetProgramBinary, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-GL_ENTRY(void, glProgramBinary, GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
-GL_ENTRY(void, glProgramParameteri, GLuint program, GLenum pname, GLint value)
-GL_ENTRY(void, glInvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum *attachments)
-GL_ENTRY(void, glInvalidateSubFramebuffer, GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(void, glTexStorage2D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glTexStorage3D, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-GL_ENTRY(void, glGetInternalformativ, GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
-GL_ENTRY(void, glDispatchCompute, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-GL_ENTRY(void, glDispatchComputeIndirect, GLintptr indirect)
-GL_ENTRY(void, glDrawArraysIndirect, GLenum mode, const void *indirect)
-GL_ENTRY(void, glDrawElementsIndirect, GLenum mode, GLenum type, const void *indirect)
-GL_ENTRY(void, glFramebufferParameteri, GLenum target, GLenum pname, GLint param)
-GL_ENTRY(void, glGetFramebufferParameteriv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetProgramInterfaceiv, GLuint program, GLenum programInterface, GLenum pname, GLint *params)
-GL_ENTRY(GLuint, glGetProgramResourceIndex, GLuint program, GLenum programInterface, const GLchar *name)
-GL_ENTRY(void, glGetProgramResourceName, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
-GL_ENTRY(void, glGetProgramResourceiv, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
-GL_ENTRY(GLint, glGetProgramResourceLocation, GLuint program, GLenum programInterface, const GLchar *name)
-GL_ENTRY(void, glUseProgramStages, GLuint pipeline, GLbitfield stages, GLuint program)
-GL_ENTRY(void, glActiveShaderProgram, GLuint pipeline, GLuint program)
-GL_ENTRY(GLuint, glCreateShaderProgramv, GLenum type, GLsizei count, const GLchar *const*strings)
-GL_ENTRY(void, glBindProgramPipeline, GLuint pipeline)
-GL_ENTRY(void, glDeleteProgramPipelines, GLsizei n, const GLuint *pipelines)
-GL_ENTRY(void, glGenProgramPipelines, GLsizei n, GLuint *pipelines)
-GL_ENTRY(GLboolean, glIsProgramPipeline, GLuint pipeline)
-GL_ENTRY(void, glGetProgramPipelineiv, GLuint pipeline, GLenum pname, GLint *params)
-GL_ENTRY(void, glProgramUniform1i, GLuint program, GLint location, GLint v0)
-GL_ENTRY(void, glProgramUniform2i, GLuint program, GLint location, GLint v0, GLint v1)
-GL_ENTRY(void, glProgramUniform3i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-GL_ENTRY(void, glProgramUniform4i, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-GL_ENTRY(void, glProgramUniform1ui, GLuint program, GLint location, GLuint v0)
-GL_ENTRY(void, glProgramUniform2ui, GLuint program, GLint location, GLuint v0, GLuint v1)
-GL_ENTRY(void, glProgramUniform3ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-GL_ENTRY(void, glProgramUniform4ui, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-GL_ENTRY(void, glProgramUniform1f, GLuint program, GLint location, GLfloat v0)
-GL_ENTRY(void, glProgramUniform2f, GLuint program, GLint location, GLfloat v0, GLfloat v1)
-GL_ENTRY(void, glProgramUniform3f, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-GL_ENTRY(void, glProgramUniform4f, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-GL_ENTRY(void, glProgramUniform1iv, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform2iv, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform3iv, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform4iv, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform1uiv, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform2uiv, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform3uiv, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform4uiv, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform1fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform2fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform3fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform4fv, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix2fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix2x3fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3x2fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix2x4fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4x2fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3x4fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4x3fv, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glValidateProgramPipeline, GLuint pipeline)
-GL_ENTRY(void, glGetProgramPipelineInfoLog, GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-GL_ENTRY(void, glBindImageTexture, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-GL_ENTRY(void, glGetBooleani_v, GLenum target, GLuint index, GLboolean *data)
-GL_ENTRY(void, glMemoryBarrier, GLbitfield barriers)
-GL_ENTRY(void, glMemoryBarrierByRegion, GLbitfield barriers)
-GL_ENTRY(void, glTexStorage2DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-GL_ENTRY(void, glGetMultisamplefv, GLenum pname, GLuint index, GLfloat *val)
-GL_ENTRY(void, glSampleMaski, GLuint maskNumber, GLbitfield mask)
-GL_ENTRY(void, glGetTexLevelParameteriv, GLenum target, GLint level, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetTexLevelParameterfv, GLenum target, GLint level, GLenum pname, GLfloat *params)
-GL_ENTRY(void, glBindVertexBuffer, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-GL_ENTRY(void, glVertexAttribFormat, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-GL_ENTRY(void, glVertexAttribIFormat, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-GL_ENTRY(void, glVertexAttribBinding, GLuint attribindex, GLuint bindingindex)
-GL_ENTRY(void, glVertexBindingDivisor, GLuint bindingindex, GLuint divisor)
-GL_ENTRY(void, glBlendBarrier, void)
-GL_ENTRY(void, glCopyImageSubData, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-GL_ENTRY(void, glDebugMessageControl, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-GL_ENTRY(void, glDebugMessageInsert, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-GL_ENTRY(void, glDebugMessageCallback, GLDEBUGPROC callback, const void *userParam)
-GL_ENTRY(GLuint, glGetDebugMessageLog, GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-GL_ENTRY(void, glPushDebugGroup, GLenum source, GLuint id, GLsizei length, const GLchar *message)
-GL_ENTRY(void, glPopDebugGroup, void)
-GL_ENTRY(void, glObjectLabel, GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-GL_ENTRY(void, glGetObjectLabel, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-GL_ENTRY(void, glObjectPtrLabel, const void *ptr, GLsizei length, const GLchar *label)
-GL_ENTRY(void, glGetObjectPtrLabel, const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-GL_ENTRY(void, glGetPointerv, GLenum pname, void **params)
-GL_ENTRY(void, glEnablei, GLenum target, GLuint index)
-GL_ENTRY(void, glDisablei, GLenum target, GLuint index)
-GL_ENTRY(void, glBlendEquationi, GLuint buf, GLenum mode)
-GL_ENTRY(void, glBlendEquationSeparatei, GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-GL_ENTRY(void, glBlendFunci, GLuint buf, GLenum src, GLenum dst)
-GL_ENTRY(void, glBlendFuncSeparatei, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-GL_ENTRY(void, glColorMaski, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-GL_ENTRY(GLboolean, glIsEnabledi, GLenum target, GLuint index)
-GL_ENTRY(void, glDrawElementsBaseVertex, GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawRangeElementsBaseVertex, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawElementsInstancedBaseVertex, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-GL_ENTRY(void, glFramebufferTexture, GLenum target, GLenum attachment, GLuint texture, GLint level)
-GL_ENTRY(void, glPrimitiveBoundingBox, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
-GL_ENTRY(GLenum, glGetGraphicsResetStatus, void)
-GL_ENTRY(void, glReadnPixels, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
-GL_ENTRY(void, glGetnUniformfv, GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
-GL_ENTRY(void, glGetnUniformiv, GLuint program, GLint location, GLsizei bufSize, GLint *params)
-GL_ENTRY(void, glGetnUniformuiv, GLuint program, GLint location, GLsizei bufSize, GLuint *params)
-GL_ENTRY(void, glMinSampleShading, GLfloat value)
-GL_ENTRY(void, glPatchParameteri, GLenum pname, GLint value)
-GL_ENTRY(void, glTexParameterIiv, GLenum target, GLenum pname, const GLint *params)
-GL_ENTRY(void, glTexParameterIuiv, GLenum target, GLenum pname, const GLuint *params)
-GL_ENTRY(void, glGetTexParameterIiv, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetTexParameterIuiv, GLenum target, GLenum pname, GLuint *params)
-GL_ENTRY(void, glSamplerParameterIiv, GLuint sampler, GLenum pname, const GLint *param)
-GL_ENTRY(void, glSamplerParameterIuiv, GLuint sampler, GLenum pname, const GLuint *param)
-GL_ENTRY(void, glGetSamplerParameterIiv, GLuint sampler, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetSamplerParameterIuiv, GLuint sampler, GLenum pname, GLuint *params)
-GL_ENTRY(void, glTexBuffer, GLenum target, GLenum internalformat, GLuint buffer)
-GL_ENTRY(void, glTexBufferRange, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-GL_ENTRY(void, glTexStorage3DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-GL_ENTRY(void, glBlendBarrierKHR, void)
-GL_ENTRY(void, glDebugMessageControlKHR, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
-GL_ENTRY(void, glDebugMessageInsertKHR, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
-GL_ENTRY(void, glDebugMessageCallbackKHR, GLDEBUGPROCKHR callback, const void *userParam)
-GL_ENTRY(GLuint, glGetDebugMessageLogKHR, GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
-GL_ENTRY(void, glPushDebugGroupKHR, GLenum source, GLuint id, GLsizei length, const GLchar *message)
-GL_ENTRY(void, glPopDebugGroupKHR, void)
-GL_ENTRY(void, glObjectLabelKHR, GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
-GL_ENTRY(void, glGetObjectLabelKHR, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
-GL_ENTRY(void, glObjectPtrLabelKHR, const void *ptr, GLsizei length, const GLchar *label)
-GL_ENTRY(void, glGetObjectPtrLabelKHR, const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
-GL_ENTRY(void, glGetPointervKHR, GLenum pname, void **params)
-GL_ENTRY(GLenum, glGetGraphicsResetStatusKHR, void)
-GL_ENTRY(void, glReadnPixelsKHR, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
-GL_ENTRY(void, glGetnUniformfvKHR, GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
-GL_ENTRY(void, glGetnUniformivKHR, GLuint program, GLint location, GLsizei bufSize, GLint *params)
-GL_ENTRY(void, glGetnUniformuivKHR, GLuint program, GLint location, GLsizei bufSize, GLuint *params)
-GL_ENTRY(void, glEGLImageTargetTexture2DOES, GLenum target, GLeglImageOES image)
-GL_ENTRY(void, glEGLImageTargetRenderbufferStorageOES, GLenum target, GLeglImageOES image)
-GL_ENTRY(void, glCopyImageSubDataOES, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-GL_ENTRY(void, glEnableiOES, GLenum target, GLuint index)
-GL_ENTRY(void, glDisableiOES, GLenum target, GLuint index)
-GL_ENTRY(void, glBlendEquationiOES, GLuint buf, GLenum mode)
-GL_ENTRY(void, glBlendEquationSeparateiOES, GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-GL_ENTRY(void, glBlendFunciOES, GLuint buf, GLenum src, GLenum dst)
-GL_ENTRY(void, glBlendFuncSeparateiOES, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-GL_ENTRY(void, glColorMaskiOES, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-GL_ENTRY(GLboolean, glIsEnablediOES, GLenum target, GLuint index)
-GL_ENTRY(void, glDrawElementsBaseVertexOES, GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawRangeElementsBaseVertexOES, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawElementsInstancedBaseVertexOES, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-GL_ENTRY(void, glFramebufferTextureOES, GLenum target, GLenum attachment, GLuint texture, GLint level)
-GL_ENTRY(void, glGetProgramBinaryOES, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
-GL_ENTRY(void, glProgramBinaryOES, GLuint program, GLenum binaryFormat, const void *binary, GLint length)
-GL_ENTRY(void *, glMapBufferOES, GLenum target, GLenum access)
-GL_ENTRY(GLboolean, glUnmapBufferOES, GLenum target)
-GL_ENTRY(void, glGetBufferPointervOES, GLenum target, GLenum pname, void **params)
-GL_ENTRY(void, glPrimitiveBoundingBoxOES, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
-GL_ENTRY(void, glMinSampleShadingOES, GLfloat value)
-GL_ENTRY(void, glPatchParameteriOES, GLenum pname, GLint value)
-GL_ENTRY(void, glTexImage3DOES, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
-GL_ENTRY(void, glCopyTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-GL_ENTRY(void, glCompressedTexImage3DOES, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glCompressedTexSubImage3DOES, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
-GL_ENTRY(void, glFramebufferTexture3DOES, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-GL_ENTRY(void, glTexParameterIivOES, GLenum target, GLenum pname, const GLint *params)
-GL_ENTRY(void, glTexParameterIuivOES, GLenum target, GLenum pname, const GLuint *params)
-GL_ENTRY(void, glGetTexParameterIivOES, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetTexParameterIuivOES, GLenum target, GLenum pname, GLuint *params)
-GL_ENTRY(void, glSamplerParameterIivOES, GLuint sampler, GLenum pname, const GLint *param)
-GL_ENTRY(void, glSamplerParameterIuivOES, GLuint sampler, GLenum pname, const GLuint *param)
-GL_ENTRY(void, glGetSamplerParameterIivOES, GLuint sampler, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetSamplerParameterIuivOES, GLuint sampler, GLenum pname, GLuint *params)
-GL_ENTRY(void, glTexBufferOES, GLenum target, GLenum internalformat, GLuint buffer)
-GL_ENTRY(void, glTexBufferRangeOES, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-GL_ENTRY(void, glTexStorage3DMultisampleOES, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
-GL_ENTRY(void, glTextureViewOES, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
-GL_ENTRY(void, glBindVertexArrayOES, GLuint array)
-GL_ENTRY(void, glDeleteVertexArraysOES, GLsizei n, const GLuint *arrays)
-GL_ENTRY(void, glGenVertexArraysOES, GLsizei n, GLuint *arrays)
-GL_ENTRY(GLboolean, glIsVertexArrayOES, GLuint array)
-GL_ENTRY(void, glDrawArraysInstancedBaseInstanceEXT, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
-GL_ENTRY(void, glDrawElementsInstancedBaseInstanceEXT, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
-GL_ENTRY(void, glDrawElementsInstancedBaseVertexBaseInstanceEXT, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
-GL_ENTRY(void, glBindFragDataLocationIndexedEXT, GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
-GL_ENTRY(void, glBindFragDataLocationEXT, GLuint program, GLuint color, const GLchar *name)
-GL_ENTRY(GLint, glGetProgramResourceLocationIndexEXT, GLuint program, GLenum programInterface, const GLchar *name)
-GL_ENTRY(GLint, glGetFragDataIndexEXT, GLuint program, const GLchar *name)
-GL_ENTRY(void, glBufferStorageEXT, GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
-GL_ENTRY(void, glCopyImageSubDataEXT, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
-GL_ENTRY(void, glLabelObjectEXT, GLenum type, GLuint object, GLsizei length, const GLchar *label)
-GL_ENTRY(void, glGetObjectLabelEXT, GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
-GL_ENTRY(void, glInsertEventMarkerEXT, GLsizei length, const GLchar *marker)
-GL_ENTRY(void, glPushGroupMarkerEXT, GLsizei length, const GLchar *marker)
-GL_ENTRY(void, glPopGroupMarkerEXT, void)
-GL_ENTRY(void, glDiscardFramebufferEXT, GLenum target, GLsizei numAttachments, const GLenum *attachments)
-GL_ENTRY(void, glGenQueriesEXT, GLsizei n, GLuint *ids)
-GL_ENTRY(void, glDeleteQueriesEXT, GLsizei n, const GLuint *ids)
-GL_ENTRY(GLboolean, glIsQueryEXT, GLuint id)
-GL_ENTRY(void, glBeginQueryEXT, GLenum target, GLuint id)
-GL_ENTRY(void, glEndQueryEXT, GLenum target)
-GL_ENTRY(void, glQueryCounterEXT, GLuint id, GLenum target)
-GL_ENTRY(void, glGetQueryivEXT, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetQueryObjectivEXT, GLuint id, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetQueryObjectuivEXT, GLuint id, GLenum pname, GLuint *params)
-GL_ENTRY(void, glGetQueryObjecti64vEXT, GLuint id, GLenum pname, GLint64 *params)
-GL_ENTRY(void, glGetQueryObjectui64vEXT, GLuint id, GLenum pname, GLuint64 *params)
-GL_ENTRY(void, glDrawBuffersEXT, GLsizei n, const GLenum *bufs)
-GL_ENTRY(void, glEnableiEXT, GLenum target, GLuint index)
-GL_ENTRY(void, glDisableiEXT, GLenum target, GLuint index)
-GL_ENTRY(void, glBlendEquationiEXT, GLuint buf, GLenum mode)
-GL_ENTRY(void, glBlendEquationSeparateiEXT, GLuint buf, GLenum modeRGB, GLenum modeAlpha)
-GL_ENTRY(void, glBlendFunciEXT, GLuint buf, GLenum src, GLenum dst)
-GL_ENTRY(void, glBlendFuncSeparateiEXT, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-GL_ENTRY(void, glColorMaskiEXT, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-GL_ENTRY(GLboolean, glIsEnablediEXT, GLenum target, GLuint index)
-GL_ENTRY(void, glDrawElementsBaseVertexEXT, GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawRangeElementsBaseVertexEXT, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
-GL_ENTRY(void, glDrawElementsInstancedBaseVertexEXT, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
-GL_ENTRY(void, glMultiDrawElementsBaseVertexEXT, GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, const GLint *basevertex)
-GL_ENTRY(void, glDrawArraysInstancedEXT, GLenum mode, GLint start, GLsizei count, GLsizei primcount)
-GL_ENTRY(void, glDrawElementsInstancedEXT, GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount)
-GL_ENTRY(void, glFramebufferTextureEXT, GLenum target, GLenum attachment, GLuint texture, GLint level)
-GL_ENTRY(void, glVertexAttribDivisorEXT, GLuint index, GLuint divisor)
-GL_ENTRY(void *, glMapBufferRangeEXT, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-GL_ENTRY(void, glFlushMappedBufferRangeEXT, GLenum target, GLintptr offset, GLsizeiptr length)
-GL_ENTRY(void, glMultiDrawArraysEXT, GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
-GL_ENTRY(void, glMultiDrawElementsEXT, GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount)
-GL_ENTRY(void, glMultiDrawArraysIndirectEXT, GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
-GL_ENTRY(void, glMultiDrawElementsIndirectEXT, GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
-GL_ENTRY(void, glRenderbufferStorageMultisampleEXT, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glFramebufferTexture2DMultisampleEXT, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
-GL_ENTRY(void, glReadBufferIndexedEXT, GLenum src, GLint index)
-GL_ENTRY(void, glDrawBuffersIndexedEXT, GLint n, const GLenum *location, const GLint *indices)
-GL_ENTRY(void, glGetIntegeri_vEXT, GLenum target, GLuint index, GLint *data)
-GL_ENTRY(void, glPrimitiveBoundingBoxEXT, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
-GL_ENTRY(void, glRasterSamplesEXT, GLuint samples, GLboolean fixedsamplelocations)
-GL_ENTRY(GLenum, glGetGraphicsResetStatusEXT, void)
-GL_ENTRY(void, glReadnPixelsEXT, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
-GL_ENTRY(void, glGetnUniformfvEXT, GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
-GL_ENTRY(void, glGetnUniformivEXT, GLuint program, GLint location, GLsizei bufSize, GLint *params)
-GL_ENTRY(void, glActiveShaderProgramEXT, GLuint pipeline, GLuint program)
-GL_ENTRY(void, glBindProgramPipelineEXT, GLuint pipeline)
-GL_ENTRY(GLuint, glCreateShaderProgramvEXT, GLenum type, GLsizei count, const GLchar **strings)
-GL_ENTRY(void, glDeleteProgramPipelinesEXT, GLsizei n, const GLuint *pipelines)
-GL_ENTRY(void, glGenProgramPipelinesEXT, GLsizei n, GLuint *pipelines)
-GL_ENTRY(void, glGetProgramPipelineInfoLogEXT, GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-GL_ENTRY(void, glGetProgramPipelineivEXT, GLuint pipeline, GLenum pname, GLint *params)
-GL_ENTRY(GLboolean, glIsProgramPipelineEXT, GLuint pipeline)
-GL_ENTRY(void, glProgramParameteriEXT, GLuint program, GLenum pname, GLint value)
-GL_ENTRY(void, glProgramUniform1fEXT, GLuint program, GLint location, GLfloat v0)
-GL_ENTRY(void, glProgramUniform1fvEXT, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform1iEXT, GLuint program, GLint location, GLint v0)
-GL_ENTRY(void, glProgramUniform1ivEXT, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform2fEXT, GLuint program, GLint location, GLfloat v0, GLfloat v1)
-GL_ENTRY(void, glProgramUniform2fvEXT, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform2iEXT, GLuint program, GLint location, GLint v0, GLint v1)
-GL_ENTRY(void, glProgramUniform2ivEXT, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform3fEXT, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-GL_ENTRY(void, glProgramUniform3fvEXT, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform3iEXT, GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-GL_ENTRY(void, glProgramUniform3ivEXT, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniform4fEXT, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-GL_ENTRY(void, glProgramUniform4fvEXT, GLuint program, GLint location, GLsizei count, const GLfloat *value)
-GL_ENTRY(void, glProgramUniform4iEXT, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-GL_ENTRY(void, glProgramUniform4ivEXT, GLuint program, GLint location, GLsizei count, const GLint *value)
-GL_ENTRY(void, glProgramUniformMatrix2fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glUseProgramStagesEXT, GLuint pipeline, GLbitfield stages, GLuint program)
-GL_ENTRY(void, glValidateProgramPipelineEXT, GLuint pipeline)
-GL_ENTRY(void, glProgramUniform1uiEXT, GLuint program, GLint location, GLuint v0)
-GL_ENTRY(void, glProgramUniform2uiEXT, GLuint program, GLint location, GLuint v0, GLuint v1)
-GL_ENTRY(void, glProgramUniform3uiEXT, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-GL_ENTRY(void, glProgramUniform4uiEXT, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-GL_ENTRY(void, glProgramUniform1uivEXT, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform2uivEXT, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform3uivEXT, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniform4uivEXT, GLuint program, GLint location, GLsizei count, const GLuint *value)
-GL_ENTRY(void, glProgramUniformMatrix2x3fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3x2fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix2x4fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4x2fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix3x4fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glProgramUniformMatrix4x3fvEXT, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-GL_ENTRY(void, glTexPageCommitmentEXT, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit)
-GL_ENTRY(void, glPatchParameteriEXT, GLenum pname, GLint value)
-GL_ENTRY(void, glTexParameterIivEXT, GLenum target, GLenum pname, const GLint *params)
-GL_ENTRY(void, glTexParameterIuivEXT, GLenum target, GLenum pname, const GLuint *params)
-GL_ENTRY(void, glGetTexParameterIivEXT, GLenum target, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetTexParameterIuivEXT, GLenum target, GLenum pname, GLuint *params)
-GL_ENTRY(void, glSamplerParameterIivEXT, GLuint sampler, GLenum pname, const GLint *param)
-GL_ENTRY(void, glSamplerParameterIuivEXT, GLuint sampler, GLenum pname, const GLuint *param)
-GL_ENTRY(void, glGetSamplerParameterIivEXT, GLuint sampler, GLenum pname, GLint *params)
-GL_ENTRY(void, glGetSamplerParameterIuivEXT, GLuint sampler, GLenum pname, GLuint *params)
-GL_ENTRY(void, glTexBufferEXT, GLenum target, GLenum internalformat, GLuint buffer)
-GL_ENTRY(void, glTexBufferRangeEXT, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
-GL_ENTRY(void, glTexStorage1DEXT, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-GL_ENTRY(void, glTexStorage2DEXT, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glTexStorage3DEXT, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-GL_ENTRY(void, glTextureStorage1DEXT, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
-GL_ENTRY(void, glTextureStorage2DEXT, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-GL_ENTRY(void, glTextureStorage3DEXT, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-GL_ENTRY(void, glTextureViewEXT, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
diff --git a/libs/hwui/debug/gles_redefine.h b/libs/hwui/debug/gles_redefine.h
deleted file mode 100644
index 49b5069..0000000
--- a/libs/hwui/debug/gles_redefine.h
+++ /dev/null
@@ -1,914 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define glActiveShaderProgram wrap_glActiveShaderProgram
-#define glActiveShaderProgramEXT wrap_glActiveShaderProgramEXT
-#define glActiveTexture wrap_glActiveTexture
-#define glAlphaFunc wrap_glAlphaFunc
-#define glAlphaFuncQCOM wrap_glAlphaFuncQCOM
-#define glAlphaFuncx wrap_glAlphaFuncx
-#define glAlphaFuncxOES wrap_glAlphaFuncxOES
-#define glApplyFramebufferAttachmentCMAAINTEL wrap_glApplyFramebufferAttachmentCMAAINTEL
-#define glAttachShader wrap_glAttachShader
-#define glBeginConditionalRenderNV wrap_glBeginConditionalRenderNV
-#define glBeginPerfMonitorAMD wrap_glBeginPerfMonitorAMD
-#define glBeginPerfQueryINTEL wrap_glBeginPerfQueryINTEL
-#define glBeginQuery wrap_glBeginQuery
-#define glBeginQueryEXT wrap_glBeginQueryEXT
-#define glBeginTransformFeedback wrap_glBeginTransformFeedback
-#define glBindAttribLocation wrap_glBindAttribLocation
-#define glBindBuffer wrap_glBindBuffer
-#define glBindBufferBase wrap_glBindBufferBase
-#define glBindBufferRange wrap_glBindBufferRange
-#define glBindFragDataLocationEXT wrap_glBindFragDataLocationEXT
-#define glBindFragDataLocationIndexedEXT wrap_glBindFragDataLocationIndexedEXT
-#define glBindFramebuffer wrap_glBindFramebuffer
-#define glBindFramebufferOES wrap_glBindFramebufferOES
-#define glBindImageTexture wrap_glBindImageTexture
-#define glBindProgramPipeline wrap_glBindProgramPipeline
-#define glBindProgramPipelineEXT wrap_glBindProgramPipelineEXT
-#define glBindRenderbuffer wrap_glBindRenderbuffer
-#define glBindRenderbufferOES wrap_glBindRenderbufferOES
-#define glBindSampler wrap_glBindSampler
-#define glBindTexture wrap_glBindTexture
-#define glBindTransformFeedback wrap_glBindTransformFeedback
-#define glBindVertexArray wrap_glBindVertexArray
-#define glBindVertexArrayOES wrap_glBindVertexArrayOES
-#define glBindVertexBuffer wrap_glBindVertexBuffer
-#define glBlendBarrier wrap_glBlendBarrier
-#define glBlendBarrierKHR wrap_glBlendBarrierKHR
-#define glBlendBarrierNV wrap_glBlendBarrierNV
-#define glBlendColor wrap_glBlendColor
-#define glBlendEquation wrap_glBlendEquation
-#define glBlendEquationOES wrap_glBlendEquationOES
-#define glBlendEquationSeparate wrap_glBlendEquationSeparate
-#define glBlendEquationSeparateOES wrap_glBlendEquationSeparateOES
-#define glBlendEquationSeparatei wrap_glBlendEquationSeparatei
-#define glBlendEquationSeparateiEXT wrap_glBlendEquationSeparateiEXT
-#define glBlendEquationSeparateiOES wrap_glBlendEquationSeparateiOES
-#define glBlendEquationi wrap_glBlendEquationi
-#define glBlendEquationiEXT wrap_glBlendEquationiEXT
-#define glBlendEquationiOES wrap_glBlendEquationiOES
-#define glBlendFunc wrap_glBlendFunc
-#define glBlendFuncSeparate wrap_glBlendFuncSeparate
-#define glBlendFuncSeparateOES wrap_glBlendFuncSeparateOES
-#define glBlendFuncSeparatei wrap_glBlendFuncSeparatei
-#define glBlendFuncSeparateiEXT wrap_glBlendFuncSeparateiEXT
-#define glBlendFuncSeparateiOES wrap_glBlendFuncSeparateiOES
-#define glBlendFunci wrap_glBlendFunci
-#define glBlendFunciEXT wrap_glBlendFunciEXT
-#define glBlendFunciOES wrap_glBlendFunciOES
-#define glBlendParameteriNV wrap_glBlendParameteriNV
-#define glBlitFramebuffer wrap_glBlitFramebuffer
-#define glBlitFramebufferANGLE wrap_glBlitFramebufferANGLE
-#define glBlitFramebufferNV wrap_glBlitFramebufferNV
-#define glBufferData wrap_glBufferData
-#define glBufferStorageEXT wrap_glBufferStorageEXT
-#define glBufferSubData wrap_glBufferSubData
-#define glCheckFramebufferStatus wrap_glCheckFramebufferStatus
-#define glCheckFramebufferStatusOES wrap_glCheckFramebufferStatusOES
-#define glClear wrap_glClear
-#define glClearBufferfi wrap_glClearBufferfi
-#define glClearBufferfv wrap_glClearBufferfv
-#define glClearBufferiv wrap_glClearBufferiv
-#define glClearBufferuiv wrap_glClearBufferuiv
-#define glClearColor wrap_glClearColor
-#define glClearColorx wrap_glClearColorx
-#define glClearColorxOES wrap_glClearColorxOES
-#define glClearDepthf wrap_glClearDepthf
-#define glClearDepthfOES wrap_glClearDepthfOES
-#define glClearDepthx wrap_glClearDepthx
-#define glClearDepthxOES wrap_glClearDepthxOES
-#define glClearStencil wrap_glClearStencil
-#define glClientActiveTexture wrap_glClientActiveTexture
-#define glClientWaitSync wrap_glClientWaitSync
-#define glClientWaitSyncAPPLE wrap_glClientWaitSyncAPPLE
-#define glClipPlanef wrap_glClipPlanef
-#define glClipPlanefIMG wrap_glClipPlanefIMG
-#define glClipPlanefOES wrap_glClipPlanefOES
-#define glClipPlanex wrap_glClipPlanex
-#define glClipPlanexIMG wrap_glClipPlanexIMG
-#define glClipPlanexOES wrap_glClipPlanexOES
-#define glColor4f wrap_glColor4f
-#define glColor4ub wrap_glColor4ub
-#define glColor4x wrap_glColor4x
-#define glColor4xOES wrap_glColor4xOES
-#define glColorMask wrap_glColorMask
-#define glColorMaski wrap_glColorMaski
-#define glColorMaskiEXT wrap_glColorMaskiEXT
-#define glColorMaskiOES wrap_glColorMaskiOES
-#define glColorPointer wrap_glColorPointer
-#define glCompileShader wrap_glCompileShader
-#define glCompressedTexImage2D wrap_glCompressedTexImage2D
-#define glCompressedTexImage3D wrap_glCompressedTexImage3D
-#define glCompressedTexImage3DOES wrap_glCompressedTexImage3DOES
-#define glCompressedTexSubImage2D wrap_glCompressedTexSubImage2D
-#define glCompressedTexSubImage3D wrap_glCompressedTexSubImage3D
-#define glCompressedTexSubImage3DOES wrap_glCompressedTexSubImage3DOES
-#define glCopyBufferSubData wrap_glCopyBufferSubData
-#define glCopyBufferSubDataNV wrap_glCopyBufferSubDataNV
-#define glCopyImageSubData wrap_glCopyImageSubData
-#define glCopyImageSubDataEXT wrap_glCopyImageSubDataEXT
-#define glCopyImageSubDataOES wrap_glCopyImageSubDataOES
-#define glCopyPathNV wrap_glCopyPathNV
-#define glCopyTexImage2D wrap_glCopyTexImage2D
-#define glCopyTexSubImage2D wrap_glCopyTexSubImage2D
-#define glCopyTexSubImage3D wrap_glCopyTexSubImage3D
-#define glCopyTexSubImage3DOES wrap_glCopyTexSubImage3DOES
-#define glCopyTextureLevelsAPPLE wrap_glCopyTextureLevelsAPPLE
-#define glCoverFillPathInstancedNV wrap_glCoverFillPathInstancedNV
-#define glCoverFillPathNV wrap_glCoverFillPathNV
-#define glCoverStrokePathInstancedNV wrap_glCoverStrokePathInstancedNV
-#define glCoverStrokePathNV wrap_glCoverStrokePathNV
-#define glCoverageMaskNV wrap_glCoverageMaskNV
-#define glCoverageModulationNV wrap_glCoverageModulationNV
-#define glCoverageModulationTableNV wrap_glCoverageModulationTableNV
-#define glCoverageOperationNV wrap_glCoverageOperationNV
-#define glCreatePerfQueryINTEL wrap_glCreatePerfQueryINTEL
-#define glCreateProgram wrap_glCreateProgram
-#define glCreateShader wrap_glCreateShader
-#define glCreateShaderProgramv wrap_glCreateShaderProgramv
-#define glCreateShaderProgramvEXT wrap_glCreateShaderProgramvEXT
-#define glCullFace wrap_glCullFace
-#define glCurrentPaletteMatrixOES wrap_glCurrentPaletteMatrixOES
-#define glDebugMessageCallback wrap_glDebugMessageCallback
-#define glDebugMessageCallbackKHR wrap_glDebugMessageCallbackKHR
-#define glDebugMessageControl wrap_glDebugMessageControl
-#define glDebugMessageControlKHR wrap_glDebugMessageControlKHR
-#define glDebugMessageInsert wrap_glDebugMessageInsert
-#define glDebugMessageInsertKHR wrap_glDebugMessageInsertKHR
-#define glDeleteBuffers wrap_glDeleteBuffers
-#define glDeleteFencesNV wrap_glDeleteFencesNV
-#define glDeleteFramebuffers wrap_glDeleteFramebuffers
-#define glDeleteFramebuffersOES wrap_glDeleteFramebuffersOES
-#define glDeletePathsNV wrap_glDeletePathsNV
-#define glDeletePerfMonitorsAMD wrap_glDeletePerfMonitorsAMD
-#define glDeletePerfQueryINTEL wrap_glDeletePerfQueryINTEL
-#define glDeleteProgram wrap_glDeleteProgram
-#define glDeleteProgramPipelines wrap_glDeleteProgramPipelines
-#define glDeleteProgramPipelinesEXT wrap_glDeleteProgramPipelinesEXT
-#define glDeleteQueries wrap_glDeleteQueries
-#define glDeleteQueriesEXT wrap_glDeleteQueriesEXT
-#define glDeleteRenderbuffers wrap_glDeleteRenderbuffers
-#define glDeleteRenderbuffersOES wrap_glDeleteRenderbuffersOES
-#define glDeleteSamplers wrap_glDeleteSamplers
-#define glDeleteShader wrap_glDeleteShader
-#define glDeleteSync wrap_glDeleteSync
-#define glDeleteSyncAPPLE wrap_glDeleteSyncAPPLE
-#define glDeleteTextures wrap_glDeleteTextures
-#define glDeleteTransformFeedbacks wrap_glDeleteTransformFeedbacks
-#define glDeleteVertexArrays wrap_glDeleteVertexArrays
-#define glDeleteVertexArraysOES wrap_glDeleteVertexArraysOES
-#define glDepthFunc wrap_glDepthFunc
-#define glDepthMask wrap_glDepthMask
-#define glDepthRangeArrayfvNV wrap_glDepthRangeArrayfvNV
-#define glDepthRangeIndexedfNV wrap_glDepthRangeIndexedfNV
-#define glDepthRangef wrap_glDepthRangef
-#define glDepthRangefOES wrap_glDepthRangefOES
-#define glDepthRangex wrap_glDepthRangex
-#define glDepthRangexOES wrap_glDepthRangexOES
-#define glDetachShader wrap_glDetachShader
-#define glDisable wrap_glDisable
-#define glDisableClientState wrap_glDisableClientState
-#define glDisableDriverControlQCOM wrap_glDisableDriverControlQCOM
-#define glDisableVertexAttribArray wrap_glDisableVertexAttribArray
-#define glDisablei wrap_glDisablei
-#define glDisableiEXT wrap_glDisableiEXT
-#define glDisableiNV wrap_glDisableiNV
-#define glDisableiOES wrap_glDisableiOES
-#define glDiscardFramebufferEXT wrap_glDiscardFramebufferEXT
-#define glDispatchCompute wrap_glDispatchCompute
-#define glDispatchComputeIndirect wrap_glDispatchComputeIndirect
-#define glDrawArrays wrap_glDrawArrays
-#define glDrawArraysIndirect wrap_glDrawArraysIndirect
-#define glDrawArraysInstanced wrap_glDrawArraysInstanced
-#define glDrawArraysInstancedANGLE wrap_glDrawArraysInstancedANGLE
-#define glDrawArraysInstancedBaseInstanceEXT wrap_glDrawArraysInstancedBaseInstanceEXT
-#define glDrawArraysInstancedEXT wrap_glDrawArraysInstancedEXT
-#define glDrawArraysInstancedNV wrap_glDrawArraysInstancedNV
-#define glDrawBuffers wrap_glDrawBuffers
-#define glDrawBuffersEXT wrap_glDrawBuffersEXT
-#define glDrawBuffersIndexedEXT wrap_glDrawBuffersIndexedEXT
-#define glDrawBuffersNV wrap_glDrawBuffersNV
-#define glDrawElements wrap_glDrawElements
-#define glDrawElementsBaseVertex wrap_glDrawElementsBaseVertex
-#define glDrawElementsBaseVertexEXT wrap_glDrawElementsBaseVertexEXT
-#define glDrawElementsBaseVertexOES wrap_glDrawElementsBaseVertexOES
-#define glDrawElementsIndirect wrap_glDrawElementsIndirect
-#define glDrawElementsInstanced wrap_glDrawElementsInstanced
-#define glDrawElementsInstancedANGLE wrap_glDrawElementsInstancedANGLE
-#define glDrawElementsInstancedBaseInstanceEXT wrap_glDrawElementsInstancedBaseInstanceEXT
-#define glDrawElementsInstancedBaseVertex wrap_glDrawElementsInstancedBaseVertex
-#define glDrawElementsInstancedBaseVertexBaseInstanceEXT \
-    wrap_glDrawElementsInstancedBaseVertexBaseInstanceEXT
-#define glDrawElementsInstancedBaseVertexEXT wrap_glDrawElementsInstancedBaseVertexEXT
-#define glDrawElementsInstancedBaseVertexOES wrap_glDrawElementsInstancedBaseVertexOES
-#define glDrawElementsInstancedEXT wrap_glDrawElementsInstancedEXT
-#define glDrawElementsInstancedNV wrap_glDrawElementsInstancedNV
-#define glDrawRangeElements wrap_glDrawRangeElements
-#define glDrawRangeElementsBaseVertex wrap_glDrawRangeElementsBaseVertex
-#define glDrawRangeElementsBaseVertexEXT wrap_glDrawRangeElementsBaseVertexEXT
-#define glDrawRangeElementsBaseVertexOES wrap_glDrawRangeElementsBaseVertexOES
-#define glDrawTexfOES wrap_glDrawTexfOES
-#define glDrawTexfvOES wrap_glDrawTexfvOES
-#define glDrawTexiOES wrap_glDrawTexiOES
-#define glDrawTexivOES wrap_glDrawTexivOES
-#define glDrawTexsOES wrap_glDrawTexsOES
-#define glDrawTexsvOES wrap_glDrawTexsvOES
-#define glDrawTexxOES wrap_glDrawTexxOES
-#define glDrawTexxvOES wrap_glDrawTexxvOES
-#define glEGLImageTargetRenderbufferStorageOES wrap_glEGLImageTargetRenderbufferStorageOES
-#define glEGLImageTargetTexture2DOES wrap_glEGLImageTargetTexture2DOES
-#define glEnable wrap_glEnable
-#define glEnableClientState wrap_glEnableClientState
-#define glEnableDriverControlQCOM wrap_glEnableDriverControlQCOM
-#define glEnableVertexAttribArray wrap_glEnableVertexAttribArray
-#define glEnablei wrap_glEnablei
-#define glEnableiEXT wrap_glEnableiEXT
-#define glEnableiNV wrap_glEnableiNV
-#define glEnableiOES wrap_glEnableiOES
-#define glEndConditionalRenderNV wrap_glEndConditionalRenderNV
-#define glEndPerfMonitorAMD wrap_glEndPerfMonitorAMD
-#define glEndPerfQueryINTEL wrap_glEndPerfQueryINTEL
-#define glEndQuery wrap_glEndQuery
-#define glEndQueryEXT wrap_glEndQueryEXT
-#define glEndTilingQCOM wrap_glEndTilingQCOM
-#define glEndTransformFeedback wrap_glEndTransformFeedback
-#define glExtGetBufferPointervQCOM wrap_glExtGetBufferPointervQCOM
-#define glExtGetBuffersQCOM wrap_glExtGetBuffersQCOM
-#define glExtGetFramebuffersQCOM wrap_glExtGetFramebuffersQCOM
-#define glExtGetProgramBinarySourceQCOM wrap_glExtGetProgramBinarySourceQCOM
-#define glExtGetProgramsQCOM wrap_glExtGetProgramsQCOM
-#define glExtGetRenderbuffersQCOM wrap_glExtGetRenderbuffersQCOM
-#define glExtGetShadersQCOM wrap_glExtGetShadersQCOM
-#define glExtGetTexLevelParameterivQCOM wrap_glExtGetTexLevelParameterivQCOM
-#define glExtGetTexSubImageQCOM wrap_glExtGetTexSubImageQCOM
-#define glExtGetTexturesQCOM wrap_glExtGetTexturesQCOM
-#define glExtIsProgramBinaryQCOM wrap_glExtIsProgramBinaryQCOM
-#define glExtTexObjectStateOverrideiQCOM wrap_glExtTexObjectStateOverrideiQCOM
-#define glFenceSync wrap_glFenceSync
-#define glFenceSyncAPPLE wrap_glFenceSyncAPPLE
-#define glFinish wrap_glFinish
-#define glFinishFenceNV wrap_glFinishFenceNV
-#define glFlush wrap_glFlush
-#define glFlushMappedBufferRange wrap_glFlushMappedBufferRange
-#define glFlushMappedBufferRangeEXT wrap_glFlushMappedBufferRangeEXT
-#define glFogf wrap_glFogf
-#define glFogfv wrap_glFogfv
-#define glFogx wrap_glFogx
-#define glFogxOES wrap_glFogxOES
-#define glFogxv wrap_glFogxv
-#define glFogxvOES wrap_glFogxvOES
-#define glFragmentCoverageColorNV wrap_glFragmentCoverageColorNV
-#define glFramebufferParameteri wrap_glFramebufferParameteri
-#define glFramebufferRenderbuffer wrap_glFramebufferRenderbuffer
-#define glFramebufferRenderbufferOES wrap_glFramebufferRenderbufferOES
-#define glFramebufferSampleLocationsfvNV wrap_glFramebufferSampleLocationsfvNV
-#define glFramebufferTexture wrap_glFramebufferTexture
-#define glFramebufferTexture2D wrap_glFramebufferTexture2D
-#define glFramebufferTexture2DMultisampleEXT wrap_glFramebufferTexture2DMultisampleEXT
-#define glFramebufferTexture2DMultisampleIMG wrap_glFramebufferTexture2DMultisampleIMG
-#define glFramebufferTexture2DOES wrap_glFramebufferTexture2DOES
-#define glFramebufferTexture3DOES wrap_glFramebufferTexture3DOES
-#define glFramebufferTextureEXT wrap_glFramebufferTextureEXT
-#define glFramebufferTextureLayer wrap_glFramebufferTextureLayer
-#define glFramebufferTextureMultisampleMultiviewOVR wrap_glFramebufferTextureMultisampleMultiviewOVR
-#define glFramebufferTextureMultiviewOVR wrap_glFramebufferTextureMultiviewOVR
-#define glFramebufferTextureOES wrap_glFramebufferTextureOES
-#define glFrontFace wrap_glFrontFace
-#define glFrustumf wrap_glFrustumf
-#define glFrustumfOES wrap_glFrustumfOES
-#define glFrustumx wrap_glFrustumx
-#define glFrustumxOES wrap_glFrustumxOES
-#define glGenBuffers wrap_glGenBuffers
-#define glGenFencesNV wrap_glGenFencesNV
-#define glGenFramebuffers wrap_glGenFramebuffers
-#define glGenFramebuffersOES wrap_glGenFramebuffersOES
-#define glGenPathsNV wrap_glGenPathsNV
-#define glGenPerfMonitorsAMD wrap_glGenPerfMonitorsAMD
-#define glGenProgramPipelines wrap_glGenProgramPipelines
-#define glGenProgramPipelinesEXT wrap_glGenProgramPipelinesEXT
-#define glGenQueries wrap_glGenQueries
-#define glGenQueriesEXT wrap_glGenQueriesEXT
-#define glGenRenderbuffers wrap_glGenRenderbuffers
-#define glGenRenderbuffersOES wrap_glGenRenderbuffersOES
-#define glGenSamplers wrap_glGenSamplers
-#define glGenTextures wrap_glGenTextures
-#define glGenTransformFeedbacks wrap_glGenTransformFeedbacks
-#define glGenVertexArrays wrap_glGenVertexArrays
-#define glGenVertexArraysOES wrap_glGenVertexArraysOES
-#define glGenerateMipmap wrap_glGenerateMipmap
-#define glGenerateMipmapOES wrap_glGenerateMipmapOES
-#define glGetActiveAttrib wrap_glGetActiveAttrib
-#define glGetActiveUniform wrap_glGetActiveUniform
-#define glGetActiveUniformBlockName wrap_glGetActiveUniformBlockName
-#define glGetActiveUniformBlockiv wrap_glGetActiveUniformBlockiv
-#define glGetActiveUniformsiv wrap_glGetActiveUniformsiv
-#define glGetAttachedShaders wrap_glGetAttachedShaders
-#define glGetAttribLocation wrap_glGetAttribLocation
-#define glGetBooleani_v wrap_glGetBooleani_v
-#define glGetBooleanv wrap_glGetBooleanv
-#define glGetBufferParameteri64v wrap_glGetBufferParameteri64v
-#define glGetBufferParameteriv wrap_glGetBufferParameteriv
-#define glGetBufferPointerv wrap_glGetBufferPointerv
-#define glGetBufferPointervOES wrap_glGetBufferPointervOES
-#define glGetClipPlanef wrap_glGetClipPlanef
-#define glGetClipPlanefOES wrap_glGetClipPlanefOES
-#define glGetClipPlanex wrap_glGetClipPlanex
-#define glGetClipPlanexOES wrap_glGetClipPlanexOES
-#define glGetCoverageModulationTableNV wrap_glGetCoverageModulationTableNV
-#define glGetDebugMessageLog wrap_glGetDebugMessageLog
-#define glGetDebugMessageLogKHR wrap_glGetDebugMessageLogKHR
-#define glGetDriverControlStringQCOM wrap_glGetDriverControlStringQCOM
-#define glGetDriverControlsQCOM wrap_glGetDriverControlsQCOM
-#define glGetError wrap_glGetError
-#define glGetFenceivNV wrap_glGetFenceivNV
-#define glGetFirstPerfQueryIdINTEL wrap_glGetFirstPerfQueryIdINTEL
-#define glGetFixedv wrap_glGetFixedv
-#define glGetFixedvOES wrap_glGetFixedvOES
-#define glGetFloati_vNV wrap_glGetFloati_vNV
-#define glGetFloatv wrap_glGetFloatv
-#define glGetFragDataIndexEXT wrap_glGetFragDataIndexEXT
-#define glGetFragDataLocation wrap_glGetFragDataLocation
-#define glGetFramebufferAttachmentParameteriv wrap_glGetFramebufferAttachmentParameteriv
-#define glGetFramebufferAttachmentParameterivOES wrap_glGetFramebufferAttachmentParameterivOES
-#define glGetFramebufferParameteriv wrap_glGetFramebufferParameteriv
-#define glGetGraphicsResetStatus wrap_glGetGraphicsResetStatus
-#define glGetGraphicsResetStatusEXT wrap_glGetGraphicsResetStatusEXT
-#define glGetGraphicsResetStatusKHR wrap_glGetGraphicsResetStatusKHR
-#define glGetImageHandleNV wrap_glGetImageHandleNV
-#define glGetInteger64i_v wrap_glGetInteger64i_v
-#define glGetInteger64v wrap_glGetInteger64v
-#define glGetInteger64vAPPLE wrap_glGetInteger64vAPPLE
-#define glGetIntegeri_v wrap_glGetIntegeri_v
-#define glGetIntegeri_vEXT wrap_glGetIntegeri_vEXT
-#define glGetIntegerv wrap_glGetIntegerv
-#define glGetInternalformatSampleivNV wrap_glGetInternalformatSampleivNV
-#define glGetInternalformativ wrap_glGetInternalformativ
-#define glGetLightfv wrap_glGetLightfv
-#define glGetLightxv wrap_glGetLightxv
-#define glGetLightxvOES wrap_glGetLightxvOES
-#define glGetMaterialfv wrap_glGetMaterialfv
-#define glGetMaterialxv wrap_glGetMaterialxv
-#define glGetMaterialxvOES wrap_glGetMaterialxvOES
-#define glGetMultisamplefv wrap_glGetMultisamplefv
-#define glGetNextPerfQueryIdINTEL wrap_glGetNextPerfQueryIdINTEL
-#define glGetObjectLabel wrap_glGetObjectLabel
-#define glGetObjectLabelEXT wrap_glGetObjectLabelEXT
-#define glGetObjectLabelKHR wrap_glGetObjectLabelKHR
-#define glGetObjectPtrLabel wrap_glGetObjectPtrLabel
-#define glGetObjectPtrLabelKHR wrap_glGetObjectPtrLabelKHR
-#define glGetPathCommandsNV wrap_glGetPathCommandsNV
-#define glGetPathCoordsNV wrap_glGetPathCoordsNV
-#define glGetPathDashArrayNV wrap_glGetPathDashArrayNV
-#define glGetPathLengthNV wrap_glGetPathLengthNV
-#define glGetPathMetricRangeNV wrap_glGetPathMetricRangeNV
-#define glGetPathMetricsNV wrap_glGetPathMetricsNV
-#define glGetPathParameterfvNV wrap_glGetPathParameterfvNV
-#define glGetPathParameterivNV wrap_glGetPathParameterivNV
-#define glGetPathSpacingNV wrap_glGetPathSpacingNV
-#define glGetPerfCounterInfoINTEL wrap_glGetPerfCounterInfoINTEL
-#define glGetPerfMonitorCounterDataAMD wrap_glGetPerfMonitorCounterDataAMD
-#define glGetPerfMonitorCounterInfoAMD wrap_glGetPerfMonitorCounterInfoAMD
-#define glGetPerfMonitorCounterStringAMD wrap_glGetPerfMonitorCounterStringAMD
-#define glGetPerfMonitorCountersAMD wrap_glGetPerfMonitorCountersAMD
-#define glGetPerfMonitorGroupStringAMD wrap_glGetPerfMonitorGroupStringAMD
-#define glGetPerfMonitorGroupsAMD wrap_glGetPerfMonitorGroupsAMD
-#define glGetPerfQueryDataINTEL wrap_glGetPerfQueryDataINTEL
-#define glGetPerfQueryIdByNameINTEL wrap_glGetPerfQueryIdByNameINTEL
-#define glGetPerfQueryInfoINTEL wrap_glGetPerfQueryInfoINTEL
-#define glGetPointerv wrap_glGetPointerv
-#define glGetPointervKHR wrap_glGetPointervKHR
-#define glGetProgramBinary wrap_glGetProgramBinary
-#define glGetProgramBinaryOES wrap_glGetProgramBinaryOES
-#define glGetProgramInfoLog wrap_glGetProgramInfoLog
-#define glGetProgramInterfaceiv wrap_glGetProgramInterfaceiv
-#define glGetProgramPipelineInfoLog wrap_glGetProgramPipelineInfoLog
-#define glGetProgramPipelineInfoLogEXT wrap_glGetProgramPipelineInfoLogEXT
-#define glGetProgramPipelineiv wrap_glGetProgramPipelineiv
-#define glGetProgramPipelineivEXT wrap_glGetProgramPipelineivEXT
-#define glGetProgramResourceIndex wrap_glGetProgramResourceIndex
-#define glGetProgramResourceLocation wrap_glGetProgramResourceLocation
-#define glGetProgramResourceLocationIndexEXT wrap_glGetProgramResourceLocationIndexEXT
-#define glGetProgramResourceName wrap_glGetProgramResourceName
-#define glGetProgramResourcefvNV wrap_glGetProgramResourcefvNV
-#define glGetProgramResourceiv wrap_glGetProgramResourceiv
-#define glGetProgramiv wrap_glGetProgramiv
-#define glGetQueryObjecti64vEXT wrap_glGetQueryObjecti64vEXT
-#define glGetQueryObjectivEXT wrap_glGetQueryObjectivEXT
-#define glGetQueryObjectui64vEXT wrap_glGetQueryObjectui64vEXT
-#define glGetQueryObjectuiv wrap_glGetQueryObjectuiv
-#define glGetQueryObjectuivEXT wrap_glGetQueryObjectuivEXT
-#define glGetQueryiv wrap_glGetQueryiv
-#define glGetQueryivEXT wrap_glGetQueryivEXT
-#define glGetRenderbufferParameteriv wrap_glGetRenderbufferParameteriv
-#define glGetRenderbufferParameterivOES wrap_glGetRenderbufferParameterivOES
-#define glGetSamplerParameterIiv wrap_glGetSamplerParameterIiv
-#define glGetSamplerParameterIivEXT wrap_glGetSamplerParameterIivEXT
-#define glGetSamplerParameterIivOES wrap_glGetSamplerParameterIivOES
-#define glGetSamplerParameterIuiv wrap_glGetSamplerParameterIuiv
-#define glGetSamplerParameterIuivEXT wrap_glGetSamplerParameterIuivEXT
-#define glGetSamplerParameterIuivOES wrap_glGetSamplerParameterIuivOES
-#define glGetSamplerParameterfv wrap_glGetSamplerParameterfv
-#define glGetSamplerParameteriv wrap_glGetSamplerParameteriv
-#define glGetShaderInfoLog wrap_glGetShaderInfoLog
-#define glGetShaderPrecisionFormat wrap_glGetShaderPrecisionFormat
-#define glGetShaderSource wrap_glGetShaderSource
-#define glGetShaderiv wrap_glGetShaderiv
-#define glGetString wrap_glGetString
-#define glGetStringi wrap_glGetStringi
-#define glGetSynciv wrap_glGetSynciv
-#define glGetSyncivAPPLE wrap_glGetSyncivAPPLE
-#define glGetTexEnvfv wrap_glGetTexEnvfv
-#define glGetTexEnviv wrap_glGetTexEnviv
-#define glGetTexEnvxv wrap_glGetTexEnvxv
-#define glGetTexEnvxvOES wrap_glGetTexEnvxvOES
-#define glGetTexGenfvOES wrap_glGetTexGenfvOES
-#define glGetTexGenivOES wrap_glGetTexGenivOES
-#define glGetTexGenxvOES wrap_glGetTexGenxvOES
-#define glGetTexLevelParameterfv wrap_glGetTexLevelParameterfv
-#define glGetTexLevelParameteriv wrap_glGetTexLevelParameteriv
-#define glGetTexParameterIiv wrap_glGetTexParameterIiv
-#define glGetTexParameterIivEXT wrap_glGetTexParameterIivEXT
-#define glGetTexParameterIivOES wrap_glGetTexParameterIivOES
-#define glGetTexParameterIuiv wrap_glGetTexParameterIuiv
-#define glGetTexParameterIuivEXT wrap_glGetTexParameterIuivEXT
-#define glGetTexParameterIuivOES wrap_glGetTexParameterIuivOES
-#define glGetTexParameterfv wrap_glGetTexParameterfv
-#define glGetTexParameteriv wrap_glGetTexParameteriv
-#define glGetTexParameterxv wrap_glGetTexParameterxv
-#define glGetTexParameterxvOES wrap_glGetTexParameterxvOES
-#define glGetTextureHandleNV wrap_glGetTextureHandleNV
-#define glGetTextureSamplerHandleNV wrap_glGetTextureSamplerHandleNV
-#define glGetTransformFeedbackVarying wrap_glGetTransformFeedbackVarying
-#define glGetTranslatedShaderSourceANGLE wrap_glGetTranslatedShaderSourceANGLE
-#define glGetUniformBlockIndex wrap_glGetUniformBlockIndex
-#define glGetUniformIndices wrap_glGetUniformIndices
-#define glGetUniformLocation wrap_glGetUniformLocation
-#define glGetUniformfv wrap_glGetUniformfv
-#define glGetUniformiv wrap_glGetUniformiv
-#define glGetUniformuiv wrap_glGetUniformuiv
-#define glGetVertexAttribIiv wrap_glGetVertexAttribIiv
-#define glGetVertexAttribIuiv wrap_glGetVertexAttribIuiv
-#define glGetVertexAttribPointerv wrap_glGetVertexAttribPointerv
-#define glGetVertexAttribfv wrap_glGetVertexAttribfv
-#define glGetVertexAttribiv wrap_glGetVertexAttribiv
-#define glGetnUniformfv wrap_glGetnUniformfv
-#define glGetnUniformfvEXT wrap_glGetnUniformfvEXT
-#define glGetnUniformfvKHR wrap_glGetnUniformfvKHR
-#define glGetnUniformiv wrap_glGetnUniformiv
-#define glGetnUniformivEXT wrap_glGetnUniformivEXT
-#define glGetnUniformivKHR wrap_glGetnUniformivKHR
-#define glGetnUniformuiv wrap_glGetnUniformuiv
-#define glGetnUniformuivKHR wrap_glGetnUniformuivKHR
-#define glHint wrap_glHint
-#define glInsertEventMarkerEXT wrap_glInsertEventMarkerEXT
-#define glInterpolatePathsNV wrap_glInterpolatePathsNV
-#define glInvalidateFramebuffer wrap_glInvalidateFramebuffer
-#define glInvalidateSubFramebuffer wrap_glInvalidateSubFramebuffer
-#define glIsBuffer wrap_glIsBuffer
-#define glIsEnabled wrap_glIsEnabled
-#define glIsEnabledi wrap_glIsEnabledi
-#define glIsEnablediEXT wrap_glIsEnablediEXT
-#define glIsEnablediNV wrap_glIsEnablediNV
-#define glIsEnablediOES wrap_glIsEnablediOES
-#define glIsFenceNV wrap_glIsFenceNV
-#define glIsFramebuffer wrap_glIsFramebuffer
-#define glIsFramebufferOES wrap_glIsFramebufferOES
-#define glIsImageHandleResidentNV wrap_glIsImageHandleResidentNV
-#define glIsPathNV wrap_glIsPathNV
-#define glIsPointInFillPathNV wrap_glIsPointInFillPathNV
-#define glIsPointInStrokePathNV wrap_glIsPointInStrokePathNV
-#define glIsProgram wrap_glIsProgram
-#define glIsProgramPipeline wrap_glIsProgramPipeline
-#define glIsProgramPipelineEXT wrap_glIsProgramPipelineEXT
-#define glIsQuery wrap_glIsQuery
-#define glIsQueryEXT wrap_glIsQueryEXT
-#define glIsRenderbuffer wrap_glIsRenderbuffer
-#define glIsRenderbufferOES wrap_glIsRenderbufferOES
-#define glIsSampler wrap_glIsSampler
-#define glIsShader wrap_glIsShader
-#define glIsSync wrap_glIsSync
-#define glIsSyncAPPLE wrap_glIsSyncAPPLE
-#define glIsTexture wrap_glIsTexture
-#define glIsTextureHandleResidentNV wrap_glIsTextureHandleResidentNV
-#define glIsTransformFeedback wrap_glIsTransformFeedback
-#define glIsVertexArray wrap_glIsVertexArray
-#define glIsVertexArrayOES wrap_glIsVertexArrayOES
-#define glLabelObjectEXT wrap_glLabelObjectEXT
-#define glLightModelf wrap_glLightModelf
-#define glLightModelfv wrap_glLightModelfv
-#define glLightModelx wrap_glLightModelx
-#define glLightModelxOES wrap_glLightModelxOES
-#define glLightModelxv wrap_glLightModelxv
-#define glLightModelxvOES wrap_glLightModelxvOES
-#define glLightf wrap_glLightf
-#define glLightfv wrap_glLightfv
-#define glLightx wrap_glLightx
-#define glLightxOES wrap_glLightxOES
-#define glLightxv wrap_glLightxv
-#define glLightxvOES wrap_glLightxvOES
-#define glLineWidth wrap_glLineWidth
-#define glLineWidthx wrap_glLineWidthx
-#define glLineWidthxOES wrap_glLineWidthxOES
-#define glLinkProgram wrap_glLinkProgram
-#define glLoadIdentity wrap_glLoadIdentity
-#define glLoadMatrixf wrap_glLoadMatrixf
-#define glLoadMatrixx wrap_glLoadMatrixx
-#define glLoadMatrixxOES wrap_glLoadMatrixxOES
-#define glLoadPaletteFromModelViewMatrixOES wrap_glLoadPaletteFromModelViewMatrixOES
-#define glLogicOp wrap_glLogicOp
-#define glMakeImageHandleNonResidentNV wrap_glMakeImageHandleNonResidentNV
-#define glMakeImageHandleResidentNV wrap_glMakeImageHandleResidentNV
-#define glMakeTextureHandleNonResidentNV wrap_glMakeTextureHandleNonResidentNV
-#define glMakeTextureHandleResidentNV wrap_glMakeTextureHandleResidentNV
-#define glMapBufferOES wrap_glMapBufferOES
-#define glMapBufferRange wrap_glMapBufferRange
-#define glMapBufferRangeEXT wrap_glMapBufferRangeEXT
-#define glMaterialf wrap_glMaterialf
-#define glMaterialfv wrap_glMaterialfv
-#define glMaterialx wrap_glMaterialx
-#define glMaterialxOES wrap_glMaterialxOES
-#define glMaterialxv wrap_glMaterialxv
-#define glMaterialxvOES wrap_glMaterialxvOES
-#define glMatrixIndexPointerOES wrap_glMatrixIndexPointerOES
-#define glMatrixLoad3x2fNV wrap_glMatrixLoad3x2fNV
-#define glMatrixLoad3x3fNV wrap_glMatrixLoad3x3fNV
-#define glMatrixLoadTranspose3x3fNV wrap_glMatrixLoadTranspose3x3fNV
-#define glMatrixMode wrap_glMatrixMode
-#define glMatrixMult3x2fNV wrap_glMatrixMult3x2fNV
-#define glMatrixMult3x3fNV wrap_glMatrixMult3x3fNV
-#define glMatrixMultTranspose3x3fNV wrap_glMatrixMultTranspose3x3fNV
-#define glMemoryBarrier wrap_glMemoryBarrier
-#define glMemoryBarrierByRegion wrap_glMemoryBarrierByRegion
-#define glMinSampleShading wrap_glMinSampleShading
-#define glMinSampleShadingOES wrap_glMinSampleShadingOES
-#define glMultMatrixf wrap_glMultMatrixf
-#define glMultMatrixx wrap_glMultMatrixx
-#define glMultMatrixxOES wrap_glMultMatrixxOES
-#define glMultiDrawArraysEXT wrap_glMultiDrawArraysEXT
-#define glMultiDrawArraysIndirectEXT wrap_glMultiDrawArraysIndirectEXT
-#define glMultiDrawElementsBaseVertexEXT wrap_glMultiDrawElementsBaseVertexEXT
-#define glMultiDrawElementsBaseVertexOES wrap_glMultiDrawElementsBaseVertexOES
-#define glMultiDrawElementsEXT wrap_glMultiDrawElementsEXT
-#define glMultiDrawElementsIndirectEXT wrap_glMultiDrawElementsIndirectEXT
-#define glMultiTexCoord4f wrap_glMultiTexCoord4f
-#define glMultiTexCoord4x wrap_glMultiTexCoord4x
-#define glMultiTexCoord4xOES wrap_glMultiTexCoord4xOES
-#define glNamedFramebufferSampleLocationsfvNV wrap_glNamedFramebufferSampleLocationsfvNV
-#define glNormal3f wrap_glNormal3f
-#define glNormal3x wrap_glNormal3x
-#define glNormal3xOES wrap_glNormal3xOES
-#define glNormalPointer wrap_glNormalPointer
-#define glObjectLabel wrap_glObjectLabel
-#define glObjectLabelKHR wrap_glObjectLabelKHR
-#define glObjectPtrLabel wrap_glObjectPtrLabel
-#define glObjectPtrLabelKHR wrap_glObjectPtrLabelKHR
-#define glOrthof wrap_glOrthof
-#define glOrthofOES wrap_glOrthofOES
-#define glOrthox wrap_glOrthox
-#define glOrthoxOES wrap_glOrthoxOES
-#define glPatchParameteri wrap_glPatchParameteri
-#define glPatchParameteriEXT wrap_glPatchParameteriEXT
-#define glPatchParameteriOES wrap_glPatchParameteriOES
-#define glPathCommandsNV wrap_glPathCommandsNV
-#define glPathCoordsNV wrap_glPathCoordsNV
-#define glPathCoverDepthFuncNV wrap_glPathCoverDepthFuncNV
-#define glPathDashArrayNV wrap_glPathDashArrayNV
-#define glPathGlyphIndexArrayNV wrap_glPathGlyphIndexArrayNV
-#define glPathGlyphIndexRangeNV wrap_glPathGlyphIndexRangeNV
-#define glPathGlyphRangeNV wrap_glPathGlyphRangeNV
-#define glPathGlyphsNV wrap_glPathGlyphsNV
-#define glPathMemoryGlyphIndexArrayNV wrap_glPathMemoryGlyphIndexArrayNV
-#define glPathParameterfNV wrap_glPathParameterfNV
-#define glPathParameterfvNV wrap_glPathParameterfvNV
-#define glPathParameteriNV wrap_glPathParameteriNV
-#define glPathParameterivNV wrap_glPathParameterivNV
-#define glPathStencilDepthOffsetNV wrap_glPathStencilDepthOffsetNV
-#define glPathStencilFuncNV wrap_glPathStencilFuncNV
-#define glPathStringNV wrap_glPathStringNV
-#define glPathSubCommandsNV wrap_glPathSubCommandsNV
-#define glPathSubCoordsNV wrap_glPathSubCoordsNV
-#define glPauseTransformFeedback wrap_glPauseTransformFeedback
-#define glPixelStorei wrap_glPixelStorei
-#define glPointAlongPathNV wrap_glPointAlongPathNV
-#define glPointParameterf wrap_glPointParameterf
-#define glPointParameterfv wrap_glPointParameterfv
-#define glPointParameterx wrap_glPointParameterx
-#define glPointParameterxOES wrap_glPointParameterxOES
-#define glPointParameterxv wrap_glPointParameterxv
-#define glPointParameterxvOES wrap_glPointParameterxvOES
-#define glPointSize wrap_glPointSize
-#define glPointSizePointerOES wrap_glPointSizePointerOES
-#define glPointSizex wrap_glPointSizex
-#define glPointSizexOES wrap_glPointSizexOES
-#define glPolygonModeNV wrap_glPolygonModeNV
-#define glPolygonOffset wrap_glPolygonOffset
-#define glPolygonOffsetx wrap_glPolygonOffsetx
-#define glPolygonOffsetxOES wrap_glPolygonOffsetxOES
-#define glPopDebugGroup wrap_glPopDebugGroup
-#define glPopDebugGroupKHR wrap_glPopDebugGroupKHR
-#define glPopGroupMarkerEXT wrap_glPopGroupMarkerEXT
-#define glPopMatrix wrap_glPopMatrix
-#define glPrimitiveBoundingBox wrap_glPrimitiveBoundingBox
-#define glPrimitiveBoundingBoxEXT wrap_glPrimitiveBoundingBoxEXT
-#define glPrimitiveBoundingBoxOES wrap_glPrimitiveBoundingBoxOES
-#define glProgramBinary wrap_glProgramBinary
-#define glProgramBinaryOES wrap_glProgramBinaryOES
-#define glProgramParameteri wrap_glProgramParameteri
-#define glProgramParameteriEXT wrap_glProgramParameteriEXT
-#define glProgramPathFragmentInputGenNV wrap_glProgramPathFragmentInputGenNV
-#define glProgramUniform1f wrap_glProgramUniform1f
-#define glProgramUniform1fEXT wrap_glProgramUniform1fEXT
-#define glProgramUniform1fv wrap_glProgramUniform1fv
-#define glProgramUniform1fvEXT wrap_glProgramUniform1fvEXT
-#define glProgramUniform1i wrap_glProgramUniform1i
-#define glProgramUniform1iEXT wrap_glProgramUniform1iEXT
-#define glProgramUniform1iv wrap_glProgramUniform1iv
-#define glProgramUniform1ivEXT wrap_glProgramUniform1ivEXT
-#define glProgramUniform1ui wrap_glProgramUniform1ui
-#define glProgramUniform1uiEXT wrap_glProgramUniform1uiEXT
-#define glProgramUniform1uiv wrap_glProgramUniform1uiv
-#define glProgramUniform1uivEXT wrap_glProgramUniform1uivEXT
-#define glProgramUniform2f wrap_glProgramUniform2f
-#define glProgramUniform2fEXT wrap_glProgramUniform2fEXT
-#define glProgramUniform2fv wrap_glProgramUniform2fv
-#define glProgramUniform2fvEXT wrap_glProgramUniform2fvEXT
-#define glProgramUniform2i wrap_glProgramUniform2i
-#define glProgramUniform2iEXT wrap_glProgramUniform2iEXT
-#define glProgramUniform2iv wrap_glProgramUniform2iv
-#define glProgramUniform2ivEXT wrap_glProgramUniform2ivEXT
-#define glProgramUniform2ui wrap_glProgramUniform2ui
-#define glProgramUniform2uiEXT wrap_glProgramUniform2uiEXT
-#define glProgramUniform2uiv wrap_glProgramUniform2uiv
-#define glProgramUniform2uivEXT wrap_glProgramUniform2uivEXT
-#define glProgramUniform3f wrap_glProgramUniform3f
-#define glProgramUniform3fEXT wrap_glProgramUniform3fEXT
-#define glProgramUniform3fv wrap_glProgramUniform3fv
-#define glProgramUniform3fvEXT wrap_glProgramUniform3fvEXT
-#define glProgramUniform3i wrap_glProgramUniform3i
-#define glProgramUniform3iEXT wrap_glProgramUniform3iEXT
-#define glProgramUniform3iv wrap_glProgramUniform3iv
-#define glProgramUniform3ivEXT wrap_glProgramUniform3ivEXT
-#define glProgramUniform3ui wrap_glProgramUniform3ui
-#define glProgramUniform3uiEXT wrap_glProgramUniform3uiEXT
-#define glProgramUniform3uiv wrap_glProgramUniform3uiv
-#define glProgramUniform3uivEXT wrap_glProgramUniform3uivEXT
-#define glProgramUniform4f wrap_glProgramUniform4f
-#define glProgramUniform4fEXT wrap_glProgramUniform4fEXT
-#define glProgramUniform4fv wrap_glProgramUniform4fv
-#define glProgramUniform4fvEXT wrap_glProgramUniform4fvEXT
-#define glProgramUniform4i wrap_glProgramUniform4i
-#define glProgramUniform4iEXT wrap_glProgramUniform4iEXT
-#define glProgramUniform4iv wrap_glProgramUniform4iv
-#define glProgramUniform4ivEXT wrap_glProgramUniform4ivEXT
-#define glProgramUniform4ui wrap_glProgramUniform4ui
-#define glProgramUniform4uiEXT wrap_glProgramUniform4uiEXT
-#define glProgramUniform4uiv wrap_glProgramUniform4uiv
-#define glProgramUniform4uivEXT wrap_glProgramUniform4uivEXT
-#define glProgramUniformHandleui64NV wrap_glProgramUniformHandleui64NV
-#define glProgramUniformHandleui64vNV wrap_glProgramUniformHandleui64vNV
-#define glProgramUniformMatrix2fv wrap_glProgramUniformMatrix2fv
-#define glProgramUniformMatrix2fvEXT wrap_glProgramUniformMatrix2fvEXT
-#define glProgramUniformMatrix2x3fv wrap_glProgramUniformMatrix2x3fv
-#define glProgramUniformMatrix2x3fvEXT wrap_glProgramUniformMatrix2x3fvEXT
-#define glProgramUniformMatrix2x4fv wrap_glProgramUniformMatrix2x4fv
-#define glProgramUniformMatrix2x4fvEXT wrap_glProgramUniformMatrix2x4fvEXT
-#define glProgramUniformMatrix3fv wrap_glProgramUniformMatrix3fv
-#define glProgramUniformMatrix3fvEXT wrap_glProgramUniformMatrix3fvEXT
-#define glProgramUniformMatrix3x2fv wrap_glProgramUniformMatrix3x2fv
-#define glProgramUniformMatrix3x2fvEXT wrap_glProgramUniformMatrix3x2fvEXT
-#define glProgramUniformMatrix3x4fv wrap_glProgramUniformMatrix3x4fv
-#define glProgramUniformMatrix3x4fvEXT wrap_glProgramUniformMatrix3x4fvEXT
-#define glProgramUniformMatrix4fv wrap_glProgramUniformMatrix4fv
-#define glProgramUniformMatrix4fvEXT wrap_glProgramUniformMatrix4fvEXT
-#define glProgramUniformMatrix4x2fv wrap_glProgramUniformMatrix4x2fv
-#define glProgramUniformMatrix4x2fvEXT wrap_glProgramUniformMatrix4x2fvEXT
-#define glProgramUniformMatrix4x3fv wrap_glProgramUniformMatrix4x3fv
-#define glProgramUniformMatrix4x3fvEXT wrap_glProgramUniformMatrix4x3fvEXT
-#define glPushDebugGroup wrap_glPushDebugGroup
-#define glPushDebugGroupKHR wrap_glPushDebugGroupKHR
-#define glPushGroupMarkerEXT wrap_glPushGroupMarkerEXT
-#define glPushMatrix wrap_glPushMatrix
-#define glQueryCounterEXT wrap_glQueryCounterEXT
-#define glQueryMatrixxOES wrap_glQueryMatrixxOES
-#define glRasterSamplesEXT wrap_glRasterSamplesEXT
-#define glReadBuffer wrap_glReadBuffer
-#define glReadBufferIndexedEXT wrap_glReadBufferIndexedEXT
-#define glReadBufferNV wrap_glReadBufferNV
-#define glReadPixels wrap_glReadPixels
-#define glReadnPixels wrap_glReadnPixels
-#define glReadnPixelsEXT wrap_glReadnPixelsEXT
-#define glReadnPixelsKHR wrap_glReadnPixelsKHR
-#define glReleaseShaderCompiler wrap_glReleaseShaderCompiler
-#define glRenderbufferStorage wrap_glRenderbufferStorage
-#define glRenderbufferStorageMultisample wrap_glRenderbufferStorageMultisample
-#define glRenderbufferStorageMultisampleANGLE wrap_glRenderbufferStorageMultisampleANGLE
-#define glRenderbufferStorageMultisampleAPPLE wrap_glRenderbufferStorageMultisampleAPPLE
-#define glRenderbufferStorageMultisampleEXT wrap_glRenderbufferStorageMultisampleEXT
-#define glRenderbufferStorageMultisampleIMG wrap_glRenderbufferStorageMultisampleIMG
-#define glRenderbufferStorageMultisampleNV wrap_glRenderbufferStorageMultisampleNV
-#define glRenderbufferStorageOES wrap_glRenderbufferStorageOES
-#define glResolveDepthValuesNV wrap_glResolveDepthValuesNV
-#define glResolveMultisampleFramebufferAPPLE wrap_glResolveMultisampleFramebufferAPPLE
-#define glResumeTransformFeedback wrap_glResumeTransformFeedback
-#define glRotatef wrap_glRotatef
-#define glRotatex wrap_glRotatex
-#define glRotatexOES wrap_glRotatexOES
-#define glSampleCoverage wrap_glSampleCoverage
-#define glSampleCoveragex wrap_glSampleCoveragex
-#define glSampleCoveragexOES wrap_glSampleCoveragexOES
-#define glSampleMaski wrap_glSampleMaski
-#define glSamplerParameterIiv wrap_glSamplerParameterIiv
-#define glSamplerParameterIivEXT wrap_glSamplerParameterIivEXT
-#define glSamplerParameterIivOES wrap_glSamplerParameterIivOES
-#define glSamplerParameterIuiv wrap_glSamplerParameterIuiv
-#define glSamplerParameterIuivEXT wrap_glSamplerParameterIuivEXT
-#define glSamplerParameterIuivOES wrap_glSamplerParameterIuivOES
-#define glSamplerParameterf wrap_glSamplerParameterf
-#define glSamplerParameterfv wrap_glSamplerParameterfv
-#define glSamplerParameteri wrap_glSamplerParameteri
-#define glSamplerParameteriv wrap_glSamplerParameteriv
-#define glScalef wrap_glScalef
-#define glScalex wrap_glScalex
-#define glScalexOES wrap_glScalexOES
-#define glScissor wrap_glScissor
-#define glScissorArrayvNV wrap_glScissorArrayvNV
-#define glScissorIndexedNV wrap_glScissorIndexedNV
-#define glScissorIndexedvNV wrap_glScissorIndexedvNV
-#define glSelectPerfMonitorCountersAMD wrap_glSelectPerfMonitorCountersAMD
-#define glSetFenceNV wrap_glSetFenceNV
-#define glShadeModel wrap_glShadeModel
-#define glShaderBinary wrap_glShaderBinary
-#define glShaderSource wrap_glShaderSource
-#define glStartTilingQCOM wrap_glStartTilingQCOM
-#define glStencilFillPathInstancedNV wrap_glStencilFillPathInstancedNV
-#define glStencilFillPathNV wrap_glStencilFillPathNV
-#define glStencilFunc wrap_glStencilFunc
-#define glStencilFuncSeparate wrap_glStencilFuncSeparate
-#define glStencilMask wrap_glStencilMask
-#define glStencilMaskSeparate wrap_glStencilMaskSeparate
-#define glStencilOp wrap_glStencilOp
-#define glStencilOpSeparate wrap_glStencilOpSeparate
-#define glStencilStrokePathInstancedNV wrap_glStencilStrokePathInstancedNV
-#define glStencilStrokePathNV wrap_glStencilStrokePathNV
-#define glStencilThenCoverFillPathInstancedNV wrap_glStencilThenCoverFillPathInstancedNV
-#define glStencilThenCoverFillPathNV wrap_glStencilThenCoverFillPathNV
-#define glStencilThenCoverStrokePathInstancedNV wrap_glStencilThenCoverStrokePathInstancedNV
-#define glStencilThenCoverStrokePathNV wrap_glStencilThenCoverStrokePathNV
-#define glSubpixelPrecisionBiasNV wrap_glSubpixelPrecisionBiasNV
-#define glTestFenceNV wrap_glTestFenceNV
-#define glTexBuffer wrap_glTexBuffer
-#define glTexBufferEXT wrap_glTexBufferEXT
-#define glTexBufferOES wrap_glTexBufferOES
-#define glTexBufferRange wrap_glTexBufferRange
-#define glTexBufferRangeEXT wrap_glTexBufferRangeEXT
-#define glTexBufferRangeOES wrap_glTexBufferRangeOES
-#define glTexCoordPointer wrap_glTexCoordPointer
-#define glTexEnvf wrap_glTexEnvf
-#define glTexEnvfv wrap_glTexEnvfv
-#define glTexEnvi wrap_glTexEnvi
-#define glTexEnviv wrap_glTexEnviv
-#define glTexEnvx wrap_glTexEnvx
-#define glTexEnvxOES wrap_glTexEnvxOES
-#define glTexEnvxv wrap_glTexEnvxv
-#define glTexEnvxvOES wrap_glTexEnvxvOES
-#define glTexGenfOES wrap_glTexGenfOES
-#define glTexGenfvOES wrap_glTexGenfvOES
-#define glTexGeniOES wrap_glTexGeniOES
-#define glTexGenivOES wrap_glTexGenivOES
-#define glTexGenxOES wrap_glTexGenxOES
-#define glTexGenxvOES wrap_glTexGenxvOES
-#define glTexImage2D wrap_glTexImage2D
-#define glTexImage3D wrap_glTexImage3D
-#define glTexImage3DOES wrap_glTexImage3DOES
-#define glTexPageCommitmentEXT wrap_glTexPageCommitmentEXT
-#define glTexParameterIiv wrap_glTexParameterIiv
-#define glTexParameterIivEXT wrap_glTexParameterIivEXT
-#define glTexParameterIivOES wrap_glTexParameterIivOES
-#define glTexParameterIuiv wrap_glTexParameterIuiv
-#define glTexParameterIuivEXT wrap_glTexParameterIuivEXT
-#define glTexParameterIuivOES wrap_glTexParameterIuivOES
-#define glTexParameterf wrap_glTexParameterf
-#define glTexParameterfv wrap_glTexParameterfv
-#define glTexParameteri wrap_glTexParameteri
-#define glTexParameteriv wrap_glTexParameteriv
-#define glTexParameterx wrap_glTexParameterx
-#define glTexParameterxOES wrap_glTexParameterxOES
-#define glTexParameterxv wrap_glTexParameterxv
-#define glTexParameterxvOES wrap_glTexParameterxvOES
-#define glTexStorage1DEXT wrap_glTexStorage1DEXT
-#define glTexStorage2D wrap_glTexStorage2D
-#define glTexStorage2DEXT wrap_glTexStorage2DEXT
-#define glTexStorage2DMultisample wrap_glTexStorage2DMultisample
-#define glTexStorage3D wrap_glTexStorage3D
-#define glTexStorage3DEXT wrap_glTexStorage3DEXT
-#define glTexStorage3DMultisample wrap_glTexStorage3DMultisample
-#define glTexStorage3DMultisampleOES wrap_glTexStorage3DMultisampleOES
-#define glTexSubImage2D wrap_glTexSubImage2D
-#define glTexSubImage3D wrap_glTexSubImage3D
-#define glTexSubImage3DOES wrap_glTexSubImage3DOES
-#define glTextureStorage1DEXT wrap_glTextureStorage1DEXT
-#define glTextureStorage2DEXT wrap_glTextureStorage2DEXT
-#define glTextureStorage3DEXT wrap_glTextureStorage3DEXT
-#define glTextureViewEXT wrap_glTextureViewEXT
-#define glTextureViewOES wrap_glTextureViewOES
-#define glTransformFeedbackVaryings wrap_glTransformFeedbackVaryings
-#define glTransformPathNV wrap_glTransformPathNV
-#define glTranslatef wrap_glTranslatef
-#define glTranslatex wrap_glTranslatex
-#define glTranslatexOES wrap_glTranslatexOES
-#define glUniform1f wrap_glUniform1f
-#define glUniform1fv wrap_glUniform1fv
-#define glUniform1i wrap_glUniform1i
-#define glUniform1iv wrap_glUniform1iv
-#define glUniform1ui wrap_glUniform1ui
-#define glUniform1uiv wrap_glUniform1uiv
-#define glUniform2f wrap_glUniform2f
-#define glUniform2fv wrap_glUniform2fv
-#define glUniform2i wrap_glUniform2i
-#define glUniform2iv wrap_glUniform2iv
-#define glUniform2ui wrap_glUniform2ui
-#define glUniform2uiv wrap_glUniform2uiv
-#define glUniform3f wrap_glUniform3f
-#define glUniform3fv wrap_glUniform3fv
-#define glUniform3i wrap_glUniform3i
-#define glUniform3iv wrap_glUniform3iv
-#define glUniform3ui wrap_glUniform3ui
-#define glUniform3uiv wrap_glUniform3uiv
-#define glUniform4f wrap_glUniform4f
-#define glUniform4fv wrap_glUniform4fv
-#define glUniform4i wrap_glUniform4i
-#define glUniform4iv wrap_glUniform4iv
-#define glUniform4ui wrap_glUniform4ui
-#define glUniform4uiv wrap_glUniform4uiv
-#define glUniformBlockBinding wrap_glUniformBlockBinding
-#define glUniformHandleui64NV wrap_glUniformHandleui64NV
-#define glUniformHandleui64vNV wrap_glUniformHandleui64vNV
-#define glUniformMatrix2fv wrap_glUniformMatrix2fv
-#define glUniformMatrix2x3fv wrap_glUniformMatrix2x3fv
-#define glUniformMatrix2x3fvNV wrap_glUniformMatrix2x3fvNV
-#define glUniformMatrix2x4fv wrap_glUniformMatrix2x4fv
-#define glUniformMatrix2x4fvNV wrap_glUniformMatrix2x4fvNV
-#define glUniformMatrix3fv wrap_glUniformMatrix3fv
-#define glUniformMatrix3x2fv wrap_glUniformMatrix3x2fv
-#define glUniformMatrix3x2fvNV wrap_glUniformMatrix3x2fvNV
-#define glUniformMatrix3x4fv wrap_glUniformMatrix3x4fv
-#define glUniformMatrix3x4fvNV wrap_glUniformMatrix3x4fvNV
-#define glUniformMatrix4fv wrap_glUniformMatrix4fv
-#define glUniformMatrix4x2fv wrap_glUniformMatrix4x2fv
-#define glUniformMatrix4x2fvNV wrap_glUniformMatrix4x2fvNV
-#define glUniformMatrix4x3fv wrap_glUniformMatrix4x3fv
-#define glUniformMatrix4x3fvNV wrap_glUniformMatrix4x3fvNV
-#define glUnmapBuffer wrap_glUnmapBuffer
-#define glUnmapBufferOES wrap_glUnmapBufferOES
-#define glUseProgram wrap_glUseProgram
-#define glUseProgramStages wrap_glUseProgramStages
-#define glUseProgramStagesEXT wrap_glUseProgramStagesEXT
-#define glValidateProgram wrap_glValidateProgram
-#define glValidateProgramPipeline wrap_glValidateProgramPipeline
-#define glValidateProgramPipelineEXT wrap_glValidateProgramPipelineEXT
-#define glVertexAttrib1f wrap_glVertexAttrib1f
-#define glVertexAttrib1fv wrap_glVertexAttrib1fv
-#define glVertexAttrib2f wrap_glVertexAttrib2f
-#define glVertexAttrib2fv wrap_glVertexAttrib2fv
-#define glVertexAttrib3f wrap_glVertexAttrib3f
-#define glVertexAttrib3fv wrap_glVertexAttrib3fv
-#define glVertexAttrib4f wrap_glVertexAttrib4f
-#define glVertexAttrib4fv wrap_glVertexAttrib4fv
-#define glVertexAttribBinding wrap_glVertexAttribBinding
-#define glVertexAttribDivisor wrap_glVertexAttribDivisor
-#define glVertexAttribDivisorANGLE wrap_glVertexAttribDivisorANGLE
-#define glVertexAttribDivisorEXT wrap_glVertexAttribDivisorEXT
-#define glVertexAttribDivisorNV wrap_glVertexAttribDivisorNV
-#define glVertexAttribFormat wrap_glVertexAttribFormat
-#define glVertexAttribI4i wrap_glVertexAttribI4i
-#define glVertexAttribI4iv wrap_glVertexAttribI4iv
-#define glVertexAttribI4ui wrap_glVertexAttribI4ui
-#define glVertexAttribI4uiv wrap_glVertexAttribI4uiv
-#define glVertexAttribIFormat wrap_glVertexAttribIFormat
-#define glVertexAttribIPointer wrap_glVertexAttribIPointer
-#define glVertexAttribPointer wrap_glVertexAttribPointer
-#define glVertexBindingDivisor wrap_glVertexBindingDivisor
-#define glVertexPointer wrap_glVertexPointer
-#define glViewport wrap_glViewport
-#define glViewportArrayvNV wrap_glViewportArrayvNV
-#define glViewportIndexedfNV wrap_glViewportIndexedfNV
-#define glViewportIndexedfvNV wrap_glViewportIndexedfvNV
-#define glWaitSync wrap_glWaitSync
-#define glWaitSyncAPPLE wrap_glWaitSyncAPPLE
-#define glWeightPathsNV wrap_glWeightPathsNV
-#define glWeightPointerOES wrap_glWeightPointerOES
\ No newline at end of file
diff --git a/libs/hwui/debug/gles_stubs.in b/libs/hwui/debug/gles_stubs.in
deleted file mode 100644
index 7cba0c1..0000000
--- a/libs/hwui/debug/gles_stubs.in
+++ /dev/null
@@ -1,1629 +0,0 @@
-void API_ENTRY(glActiveTexture)(GLenum texture) {
-    CALL_GL_API(glActiveTexture, texture);
-}
-void API_ENTRY(glAttachShader)(GLuint program, GLuint shader) {
-    CALL_GL_API(glAttachShader, program, shader);
-}
-void API_ENTRY(glBindAttribLocation)(GLuint program, GLuint index, const GLchar *name) {
-    CALL_GL_API(glBindAttribLocation, program, index, name);
-}
-void API_ENTRY(glBindBuffer)(GLenum target, GLuint buffer) {
-    CALL_GL_API(glBindBuffer, target, buffer);
-}
-void API_ENTRY(glBindFramebuffer)(GLenum target, GLuint framebuffer) {
-    CALL_GL_API(glBindFramebuffer, target, framebuffer);
-}
-void API_ENTRY(glBindRenderbuffer)(GLenum target, GLuint renderbuffer) {
-    CALL_GL_API(glBindRenderbuffer, target, renderbuffer);
-}
-void API_ENTRY(glBindTexture)(GLenum target, GLuint texture) {
-    CALL_GL_API(glBindTexture, target, texture);
-}
-void API_ENTRY(glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-    CALL_GL_API(glBlendColor, red, green, blue, alpha);
-}
-void API_ENTRY(glBlendEquation)(GLenum mode) {
-    CALL_GL_API(glBlendEquation, mode);
-}
-void API_ENTRY(glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha) {
-    CALL_GL_API(glBlendEquationSeparate, modeRGB, modeAlpha);
-}
-void API_ENTRY(glBlendFunc)(GLenum sfactor, GLenum dfactor) {
-    CALL_GL_API(glBlendFunc, sfactor, dfactor);
-}
-void API_ENTRY(glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
-    CALL_GL_API(glBlendFuncSeparate, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-}
-void API_ENTRY(glBufferData)(GLenum target, GLsizeiptr size, const void *data, GLenum usage) {
-    CALL_GL_API(glBufferData, target, size, data, usage);
-}
-void API_ENTRY(glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) {
-    CALL_GL_API(glBufferSubData, target, offset, size, data);
-}
-GLenum API_ENTRY(glCheckFramebufferStatus)(GLenum target) {
-    CALL_GL_API_RETURN(glCheckFramebufferStatus, target);
-}
-void API_ENTRY(glClear)(GLbitfield mask) {
-    CALL_GL_API(glClear, mask);
-}
-void API_ENTRY(glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-    CALL_GL_API(glClearColor, red, green, blue, alpha);
-}
-void API_ENTRY(glClearDepthf)(GLfloat d) {
-    CALL_GL_API(glClearDepthf, d);
-}
-void API_ENTRY(glClearStencil)(GLint s) {
-    CALL_GL_API(glClearStencil, s);
-}
-void API_ENTRY(glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-    CALL_GL_API(glColorMask, red, green, blue, alpha);
-}
-void API_ENTRY(glCompileShader)(GLuint shader) {
-    CALL_GL_API(glCompileShader, shader);
-}
-void API_ENTRY(glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexImage2D, target, level, internalformat, width, height, border, imageSize, data);
-}
-void API_ENTRY(glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexSubImage2D, target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-void API_ENTRY(glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
-    CALL_GL_API(glCopyTexImage2D, target, level, internalformat, x, y, width, height, border);
-}
-void API_ENTRY(glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glCopyTexSubImage2D, target, level, xoffset, yoffset, x, y, width, height);
-}
-GLuint API_ENTRY(glCreateProgram)(void) {
-    CALL_GL_API_RETURN(glCreateProgram);
-}
-GLuint API_ENTRY(glCreateShader)(GLenum type) {
-    CALL_GL_API_RETURN(glCreateShader, type);
-}
-void API_ENTRY(glCullFace)(GLenum mode) {
-    CALL_GL_API(glCullFace, mode);
-}
-void API_ENTRY(glDeleteBuffers)(GLsizei n, const GLuint *buffers) {
-    CALL_GL_API(glDeleteBuffers, n, buffers);
-}
-void API_ENTRY(glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers) {
-    CALL_GL_API(glDeleteFramebuffers, n, framebuffers);
-}
-void API_ENTRY(glDeleteProgram)(GLuint program) {
-    CALL_GL_API(glDeleteProgram, program);
-}
-void API_ENTRY(glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers) {
-    CALL_GL_API(glDeleteRenderbuffers, n, renderbuffers);
-}
-void API_ENTRY(glDeleteShader)(GLuint shader) {
-    CALL_GL_API(glDeleteShader, shader);
-}
-void API_ENTRY(glDeleteTextures)(GLsizei n, const GLuint *textures) {
-    CALL_GL_API(glDeleteTextures, n, textures);
-}
-void API_ENTRY(glDepthFunc)(GLenum func) {
-    CALL_GL_API(glDepthFunc, func);
-}
-void API_ENTRY(glDepthMask)(GLboolean flag) {
-    CALL_GL_API(glDepthMask, flag);
-}
-void API_ENTRY(glDepthRangef)(GLfloat n, GLfloat f) {
-    CALL_GL_API(glDepthRangef, n, f);
-}
-void API_ENTRY(glDetachShader)(GLuint program, GLuint shader) {
-    CALL_GL_API(glDetachShader, program, shader);
-}
-void API_ENTRY(glDisable)(GLenum cap) {
-    CALL_GL_API(glDisable, cap);
-}
-void API_ENTRY(glDisableVertexAttribArray)(GLuint index) {
-    CALL_GL_API(glDisableVertexAttribArray, index);
-}
-void API_ENTRY(glDrawArrays)(GLenum mode, GLint first, GLsizei count) {
-    CALL_GL_API(glDrawArrays, mode, first, count);
-}
-void API_ENTRY(glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices) {
-    CALL_GL_API(glDrawElements, mode, count, type, indices);
-}
-void API_ENTRY(glEnable)(GLenum cap) {
-    CALL_GL_API(glEnable, cap);
-}
-void API_ENTRY(glEnableVertexAttribArray)(GLuint index) {
-    CALL_GL_API(glEnableVertexAttribArray, index);
-}
-void API_ENTRY(glFinish)(void) {
-    CALL_GL_API(glFinish);
-}
-void API_ENTRY(glFlush)(void) {
-    CALL_GL_API(glFlush);
-}
-void API_ENTRY(glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
-    CALL_GL_API(glFramebufferRenderbuffer, target, attachment, renderbuffertarget, renderbuffer);
-}
-void API_ENTRY(glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
-    CALL_GL_API(glFramebufferTexture2D, target, attachment, textarget, texture, level);
-}
-void API_ENTRY(glFrontFace)(GLenum mode) {
-    CALL_GL_API(glFrontFace, mode);
-}
-void API_ENTRY(glGenBuffers)(GLsizei n, GLuint *buffers) {
-    CALL_GL_API(glGenBuffers, n, buffers);
-}
-void API_ENTRY(glGenerateMipmap)(GLenum target) {
-    CALL_GL_API(glGenerateMipmap, target);
-}
-void API_ENTRY(glGenFramebuffers)(GLsizei n, GLuint *framebuffers) {
-    CALL_GL_API(glGenFramebuffers, n, framebuffers);
-}
-void API_ENTRY(glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers) {
-    CALL_GL_API(glGenRenderbuffers, n, renderbuffers);
-}
-void API_ENTRY(glGenTextures)(GLsizei n, GLuint *textures) {
-    CALL_GL_API(glGenTextures, n, textures);
-}
-void API_ENTRY(glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {
-    CALL_GL_API(glGetActiveAttrib, program, index, bufSize, length, size, type, name);
-}
-void API_ENTRY(glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {
-    CALL_GL_API(glGetActiveUniform, program, index, bufSize, length, size, type, name);
-}
-void API_ENTRY(glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) {
-    CALL_GL_API(glGetAttachedShaders, program, maxCount, count, shaders);
-}
-GLint API_ENTRY(glGetAttribLocation)(GLuint program, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetAttribLocation, program, name);
-}
-void API_ENTRY(glGetBooleanv)(GLenum pname, GLboolean *data) {
-    CALL_GL_API(glGetBooleanv, pname, data);
-}
-void API_ENTRY(glGetBufferParameteriv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetBufferParameteriv, target, pname, params);
-}
-GLenum API_ENTRY(glGetError)(void) {
-    CALL_GL_API_RETURN(glGetError);
-}
-void API_ENTRY(glGetFloatv)(GLenum pname, GLfloat *data) {
-    CALL_GL_API(glGetFloatv, pname, data);
-}
-void API_ENTRY(glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetFramebufferAttachmentParameteriv, target, attachment, pname, params);
-}
-void API_ENTRY(glGetIntegerv)(GLenum pname, GLint *data) {
-    CALL_GL_API(glGetIntegerv, pname, data);
-}
-void API_ENTRY(glGetProgramiv)(GLuint program, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetProgramiv, program, pname, params);
-}
-void API_ENTRY(glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
-    CALL_GL_API(glGetProgramInfoLog, program, bufSize, length, infoLog);
-}
-void API_ENTRY(glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetRenderbufferParameteriv, target, pname, params);
-}
-void API_ENTRY(glGetShaderiv)(GLuint shader, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetShaderiv, shader, pname, params);
-}
-void API_ENTRY(glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
-    CALL_GL_API(glGetShaderInfoLog, shader, bufSize, length, infoLog);
-}
-void API_ENTRY(glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) {
-    CALL_GL_API(glGetShaderPrecisionFormat, shadertype, precisiontype, range, precision);
-}
-void API_ENTRY(glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) {
-    CALL_GL_API(glGetShaderSource, shader, bufSize, length, source);
-}
-const GLubyte * API_ENTRY(glGetString)(GLenum name) {
-    CALL_GL_API_RETURN(glGetString, name);
-}
-void API_ENTRY(glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params) {
-    CALL_GL_API(glGetTexParameterfv, target, pname, params);
-}
-void API_ENTRY(glGetTexParameteriv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetTexParameteriv, target, pname, params);
-}
-void API_ENTRY(glGetUniformfv)(GLuint program, GLint location, GLfloat *params) {
-    CALL_GL_API(glGetUniformfv, program, location, params);
-}
-void API_ENTRY(glGetUniformiv)(GLuint program, GLint location, GLint *params) {
-    CALL_GL_API(glGetUniformiv, program, location, params);
-}
-GLint API_ENTRY(glGetUniformLocation)(GLuint program, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetUniformLocation, program, name);
-}
-void API_ENTRY(glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params) {
-    CALL_GL_API(glGetVertexAttribfv, index, pname, params);
-}
-void API_ENTRY(glGetVertexAttribiv)(GLuint index, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetVertexAttribiv, index, pname, params);
-}
-void API_ENTRY(glGetVertexAttribPointerv)(GLuint index, GLenum pname, void **pointer) {
-    CALL_GL_API(glGetVertexAttribPointerv, index, pname, pointer);
-}
-void API_ENTRY(glHint)(GLenum target, GLenum mode) {
-    CALL_GL_API(glHint, target, mode);
-}
-GLboolean API_ENTRY(glIsBuffer)(GLuint buffer) {
-    CALL_GL_API_RETURN(glIsBuffer, buffer);
-}
-GLboolean API_ENTRY(glIsEnabled)(GLenum cap) {
-    CALL_GL_API_RETURN(glIsEnabled, cap);
-}
-GLboolean API_ENTRY(glIsFramebuffer)(GLuint framebuffer) {
-    CALL_GL_API_RETURN(glIsFramebuffer, framebuffer);
-}
-GLboolean API_ENTRY(glIsProgram)(GLuint program) {
-    CALL_GL_API_RETURN(glIsProgram, program);
-}
-GLboolean API_ENTRY(glIsRenderbuffer)(GLuint renderbuffer) {
-    CALL_GL_API_RETURN(glIsRenderbuffer, renderbuffer);
-}
-GLboolean API_ENTRY(glIsShader)(GLuint shader) {
-    CALL_GL_API_RETURN(glIsShader, shader);
-}
-GLboolean API_ENTRY(glIsTexture)(GLuint texture) {
-    CALL_GL_API_RETURN(glIsTexture, texture);
-}
-void API_ENTRY(glLineWidth)(GLfloat width) {
-    CALL_GL_API(glLineWidth, width);
-}
-void API_ENTRY(glLinkProgram)(GLuint program) {
-    CALL_GL_API(glLinkProgram, program);
-}
-void API_ENTRY(glPixelStorei)(GLenum pname, GLint param) {
-    CALL_GL_API(glPixelStorei, pname, param);
-}
-void API_ENTRY(glPolygonOffset)(GLfloat factor, GLfloat units) {
-    CALL_GL_API(glPolygonOffset, factor, units);
-}
-void API_ENTRY(glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) {
-    CALL_GL_API(glReadPixels, x, y, width, height, format, type, pixels);
-}
-void API_ENTRY(glReleaseShaderCompiler)(void) {
-    CALL_GL_API(glReleaseShaderCompiler);
-}
-void API_ENTRY(glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glRenderbufferStorage, target, internalformat, width, height);
-}
-void API_ENTRY(glSampleCoverage)(GLfloat value, GLboolean invert) {
-    CALL_GL_API(glSampleCoverage, value, invert);
-}
-void API_ENTRY(glScissor)(GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glScissor, x, y, width, height);
-}
-void API_ENTRY(glShaderBinary)(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length) {
-    CALL_GL_API(glShaderBinary, count, shaders, binaryformat, binary, length);
-}
-void API_ENTRY(glShaderSource)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) {
-    CALL_GL_API(glShaderSource, shader, count, string, length);
-}
-void API_ENTRY(glStencilFunc)(GLenum func, GLint ref, GLuint mask) {
-    CALL_GL_API(glStencilFunc, func, ref, mask);
-}
-void API_ENTRY(glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) {
-    CALL_GL_API(glStencilFuncSeparate, face, func, ref, mask);
-}
-void API_ENTRY(glStencilMask)(GLuint mask) {
-    CALL_GL_API(glStencilMask, mask);
-}
-void API_ENTRY(glStencilMaskSeparate)(GLenum face, GLuint mask) {
-    CALL_GL_API(glStencilMaskSeparate, face, mask);
-}
-void API_ENTRY(glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) {
-    CALL_GL_API(glStencilOp, fail, zfail, zpass);
-}
-void API_ENTRY(glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
-    CALL_GL_API(glStencilOpSeparate, face, sfail, dpfail, dppass);
-}
-void API_ENTRY(glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexImage2D, target, level, internalformat, width, height, border, format, type, pixels);
-}
-void API_ENTRY(glTexParameterf)(GLenum target, GLenum pname, GLfloat param) {
-    CALL_GL_API(glTexParameterf, target, pname, param);
-}
-void API_ENTRY(glTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params) {
-    CALL_GL_API(glTexParameterfv, target, pname, params);
-}
-void API_ENTRY(glTexParameteri)(GLenum target, GLenum pname, GLint param) {
-    CALL_GL_API(glTexParameteri, target, pname, param);
-}
-void API_ENTRY(glTexParameteriv)(GLenum target, GLenum pname, const GLint *params) {
-    CALL_GL_API(glTexParameteriv, target, pname, params);
-}
-void API_ENTRY(glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexSubImage2D, target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-void API_ENTRY(glUniform1f)(GLint location, GLfloat v0) {
-    CALL_GL_API(glUniform1f, location, v0);
-}
-void API_ENTRY(glUniform1fv)(GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glUniform1fv, location, count, value);
-}
-void API_ENTRY(glUniform1i)(GLint location, GLint v0) {
-    CALL_GL_API(glUniform1i, location, v0);
-}
-void API_ENTRY(glUniform1iv)(GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glUniform1iv, location, count, value);
-}
-void API_ENTRY(glUniform2f)(GLint location, GLfloat v0, GLfloat v1) {
-    CALL_GL_API(glUniform2f, location, v0, v1);
-}
-void API_ENTRY(glUniform2fv)(GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glUniform2fv, location, count, value);
-}
-void API_ENTRY(glUniform2i)(GLint location, GLint v0, GLint v1) {
-    CALL_GL_API(glUniform2i, location, v0, v1);
-}
-void API_ENTRY(glUniform2iv)(GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glUniform2iv, location, count, value);
-}
-void API_ENTRY(glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
-    CALL_GL_API(glUniform3f, location, v0, v1, v2);
-}
-void API_ENTRY(glUniform3fv)(GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glUniform3fv, location, count, value);
-}
-void API_ENTRY(glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2) {
-    CALL_GL_API(glUniform3i, location, v0, v1, v2);
-}
-void API_ENTRY(glUniform3iv)(GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glUniform3iv, location, count, value);
-}
-void API_ENTRY(glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
-    CALL_GL_API(glUniform4f, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glUniform4fv)(GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glUniform4fv, location, count, value);
-}
-void API_ENTRY(glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
-    CALL_GL_API(glUniform4i, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glUniform4iv)(GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glUniform4iv, location, count, value);
-}
-void API_ENTRY(glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix2fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix3fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix4fv, location, count, transpose, value);
-}
-void API_ENTRY(glUseProgram)(GLuint program) {
-    CALL_GL_API(glUseProgram, program);
-}
-void API_ENTRY(glValidateProgram)(GLuint program) {
-    CALL_GL_API(glValidateProgram, program);
-}
-void API_ENTRY(glVertexAttrib1f)(GLuint index, GLfloat x) {
-    CALL_GL_API(glVertexAttrib1f, index, x);
-}
-void API_ENTRY(glVertexAttrib1fv)(GLuint index, const GLfloat *v) {
-    CALL_GL_API(glVertexAttrib1fv, index, v);
-}
-void API_ENTRY(glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y) {
-    CALL_GL_API(glVertexAttrib2f, index, x, y);
-}
-void API_ENTRY(glVertexAttrib2fv)(GLuint index, const GLfloat *v) {
-    CALL_GL_API(glVertexAttrib2fv, index, v);
-}
-void API_ENTRY(glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
-    CALL_GL_API(glVertexAttrib3f, index, x, y, z);
-}
-void API_ENTRY(glVertexAttrib3fv)(GLuint index, const GLfloat *v) {
-    CALL_GL_API(glVertexAttrib3fv, index, v);
-}
-void API_ENTRY(glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
-    CALL_GL_API(glVertexAttrib4f, index, x, y, z, w);
-}
-void API_ENTRY(glVertexAttrib4fv)(GLuint index, const GLfloat *v) {
-    CALL_GL_API(glVertexAttrib4fv, index, v);
-}
-void API_ENTRY(glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
-    CALL_GL_API(glVertexAttribPointer, index, size, type, normalized, stride, pointer);
-}
-void API_ENTRY(glViewport)(GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glViewport, x, y, width, height);
-}
-void API_ENTRY(glReadBuffer)(GLenum src) {
-    CALL_GL_API(glReadBuffer, src);
-}
-void API_ENTRY(glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {
-    CALL_GL_API(glDrawRangeElements, mode, start, end, count, type, indices);
-}
-void API_ENTRY(glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexImage3D, target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-void API_ENTRY(glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexSubImage3D, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-void API_ENTRY(glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glCopyTexSubImage3D, target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-void API_ENTRY(glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexImage3D, target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-void API_ENTRY(glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexSubImage3D, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-void API_ENTRY(glGenQueries)(GLsizei n, GLuint *ids) {
-    CALL_GL_API(glGenQueries, n, ids);
-}
-void API_ENTRY(glDeleteQueries)(GLsizei n, const GLuint *ids) {
-    CALL_GL_API(glDeleteQueries, n, ids);
-}
-GLboolean API_ENTRY(glIsQuery)(GLuint id) {
-    CALL_GL_API_RETURN(glIsQuery, id);
-}
-void API_ENTRY(glBeginQuery)(GLenum target, GLuint id) {
-    CALL_GL_API(glBeginQuery, target, id);
-}
-void API_ENTRY(glEndQuery)(GLenum target) {
-    CALL_GL_API(glEndQuery, target);
-}
-void API_ENTRY(glGetQueryiv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetQueryiv, target, pname, params);
-}
-void API_ENTRY(glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetQueryObjectuiv, id, pname, params);
-}
-GLboolean API_ENTRY(glUnmapBuffer)(GLenum target) {
-    CALL_GL_API_RETURN(glUnmapBuffer, target);
-}
-void API_ENTRY(glGetBufferPointerv)(GLenum target, GLenum pname, void **params) {
-    CALL_GL_API(glGetBufferPointerv, target, pname, params);
-}
-void API_ENTRY(glDrawBuffers)(GLsizei n, const GLenum *bufs) {
-    CALL_GL_API(glDrawBuffers, n, bufs);
-}
-void API_ENTRY(glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix2x3fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix3x2fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix2x4fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix4x2fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix3x4fv, location, count, transpose, value);
-}
-void API_ENTRY(glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glUniformMatrix4x3fv, location, count, transpose, value);
-}
-void API_ENTRY(glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
-    CALL_GL_API(glBlitFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-void API_ENTRY(glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glRenderbufferStorageMultisample, target, samples, internalformat, width, height);
-}
-void API_ENTRY(glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
-    CALL_GL_API(glFramebufferTextureLayer, target, attachment, texture, level, layer);
-}
-void * API_ENTRY(glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
-    CALL_GL_API_RETURN(glMapBufferRange, target, offset, length, access);
-}
-void API_ENTRY(glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length) {
-    CALL_GL_API(glFlushMappedBufferRange, target, offset, length);
-}
-void API_ENTRY(glBindVertexArray)(GLuint array) {
-    CALL_GL_API(glBindVertexArray, array);
-}
-void API_ENTRY(glDeleteVertexArrays)(GLsizei n, const GLuint *arrays) {
-    CALL_GL_API(glDeleteVertexArrays, n, arrays);
-}
-void API_ENTRY(glGenVertexArrays)(GLsizei n, GLuint *arrays) {
-    CALL_GL_API(glGenVertexArrays, n, arrays);
-}
-GLboolean API_ENTRY(glIsVertexArray)(GLuint array) {
-    CALL_GL_API_RETURN(glIsVertexArray, array);
-}
-void API_ENTRY(glGetIntegeri_v)(GLenum target, GLuint index, GLint *data) {
-    CALL_GL_API(glGetIntegeri_v, target, index, data);
-}
-void API_ENTRY(glBeginTransformFeedback)(GLenum primitiveMode) {
-    CALL_GL_API(glBeginTransformFeedback, primitiveMode);
-}
-void API_ENTRY(glEndTransformFeedback)(void) {
-    CALL_GL_API(glEndTransformFeedback);
-}
-void API_ENTRY(glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
-    CALL_GL_API(glBindBufferRange, target, index, buffer, offset, size);
-}
-void API_ENTRY(glBindBufferBase)(GLenum target, GLuint index, GLuint buffer) {
-    CALL_GL_API(glBindBufferBase, target, index, buffer);
-}
-void API_ENTRY(glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) {
-    CALL_GL_API(glTransformFeedbackVaryings, program, count, varyings, bufferMode);
-}
-void API_ENTRY(glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) {
-    CALL_GL_API(glGetTransformFeedbackVarying, program, index, bufSize, length, size, type, name);
-}
-void API_ENTRY(glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) {
-    CALL_GL_API(glVertexAttribIPointer, index, size, type, stride, pointer);
-}
-void API_ENTRY(glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetVertexAttribIiv, index, pname, params);
-}
-void API_ENTRY(glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetVertexAttribIuiv, index, pname, params);
-}
-void API_ENTRY(glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w) {
-    CALL_GL_API(glVertexAttribI4i, index, x, y, z, w);
-}
-void API_ENTRY(glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {
-    CALL_GL_API(glVertexAttribI4ui, index, x, y, z, w);
-}
-void API_ENTRY(glVertexAttribI4iv)(GLuint index, const GLint *v) {
-    CALL_GL_API(glVertexAttribI4iv, index, v);
-}
-void API_ENTRY(glVertexAttribI4uiv)(GLuint index, const GLuint *v) {
-    CALL_GL_API(glVertexAttribI4uiv, index, v);
-}
-void API_ENTRY(glGetUniformuiv)(GLuint program, GLint location, GLuint *params) {
-    CALL_GL_API(glGetUniformuiv, program, location, params);
-}
-GLint API_ENTRY(glGetFragDataLocation)(GLuint program, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetFragDataLocation, program, name);
-}
-void API_ENTRY(glUniform1ui)(GLint location, GLuint v0) {
-    CALL_GL_API(glUniform1ui, location, v0);
-}
-void API_ENTRY(glUniform2ui)(GLint location, GLuint v0, GLuint v1) {
-    CALL_GL_API(glUniform2ui, location, v0, v1);
-}
-void API_ENTRY(glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2) {
-    CALL_GL_API(glUniform3ui, location, v0, v1, v2);
-}
-void API_ENTRY(glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
-    CALL_GL_API(glUniform4ui, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glUniform1uiv)(GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glUniform1uiv, location, count, value);
-}
-void API_ENTRY(glUniform2uiv)(GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glUniform2uiv, location, count, value);
-}
-void API_ENTRY(glUniform3uiv)(GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glUniform3uiv, location, count, value);
-}
-void API_ENTRY(glUniform4uiv)(GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glUniform4uiv, location, count, value);
-}
-void API_ENTRY(glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value) {
-    CALL_GL_API(glClearBufferiv, buffer, drawbuffer, value);
-}
-void API_ENTRY(glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value) {
-    CALL_GL_API(glClearBufferuiv, buffer, drawbuffer, value);
-}
-void API_ENTRY(glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value) {
-    CALL_GL_API(glClearBufferfv, buffer, drawbuffer, value);
-}
-void API_ENTRY(glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
-    CALL_GL_API(glClearBufferfi, buffer, drawbuffer, depth, stencil);
-}
-const GLubyte * API_ENTRY(glGetStringi)(GLenum name, GLuint index) {
-    CALL_GL_API_RETURN(glGetStringi, name, index);
-}
-void API_ENTRY(glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
-    CALL_GL_API(glCopyBufferSubData, readTarget, writeTarget, readOffset, writeOffset, size);
-}
-void API_ENTRY(glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) {
-    CALL_GL_API(glGetUniformIndices, program, uniformCount, uniformNames, uniformIndices);
-}
-void API_ENTRY(glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetActiveUniformsiv, program, uniformCount, uniformIndices, pname, params);
-}
-GLuint API_ENTRY(glGetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName) {
-    CALL_GL_API_RETURN(glGetUniformBlockIndex, program, uniformBlockName);
-}
-void API_ENTRY(glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetActiveUniformBlockiv, program, uniformBlockIndex, pname, params);
-}
-void API_ENTRY(glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) {
-    CALL_GL_API(glGetActiveUniformBlockName, program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-void API_ENTRY(glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
-    CALL_GL_API(glUniformBlockBinding, program, uniformBlockIndex, uniformBlockBinding);
-}
-void API_ENTRY(glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
-    CALL_GL_API(glDrawArraysInstanced, mode, first, count, instancecount);
-}
-void API_ENTRY(glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) {
-    CALL_GL_API(glDrawElementsInstanced, mode, count, type, indices, instancecount);
-}
-GLsync API_ENTRY(glFenceSync)(GLenum condition, GLbitfield flags) {
-    CALL_GL_API_RETURN(glFenceSync, condition, flags);
-}
-GLboolean API_ENTRY(glIsSync)(GLsync sync) {
-    CALL_GL_API_RETURN(glIsSync, sync);
-}
-void API_ENTRY(glDeleteSync)(GLsync sync) {
-    CALL_GL_API(glDeleteSync, sync);
-}
-GLenum API_ENTRY(glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-    CALL_GL_API_RETURN(glClientWaitSync, sync, flags, timeout);
-}
-void API_ENTRY(glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout) {
-    CALL_GL_API(glWaitSync, sync, flags, timeout);
-}
-void API_ENTRY(glGetInteger64v)(GLenum pname, GLint64 *data) {
-    CALL_GL_API(glGetInteger64v, pname, data);
-}
-void API_ENTRY(glGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) {
-    CALL_GL_API(glGetSynciv, sync, pname, bufSize, length, values);
-}
-void API_ENTRY(glGetInteger64i_v)(GLenum target, GLuint index, GLint64 *data) {
-    CALL_GL_API(glGetInteger64i_v, target, index, data);
-}
-void API_ENTRY(glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params) {
-    CALL_GL_API(glGetBufferParameteri64v, target, pname, params);
-}
-void API_ENTRY(glGenSamplers)(GLsizei count, GLuint *samplers) {
-    CALL_GL_API(glGenSamplers, count, samplers);
-}
-void API_ENTRY(glDeleteSamplers)(GLsizei count, const GLuint *samplers) {
-    CALL_GL_API(glDeleteSamplers, count, samplers);
-}
-GLboolean API_ENTRY(glIsSampler)(GLuint sampler) {
-    CALL_GL_API_RETURN(glIsSampler, sampler);
-}
-void API_ENTRY(glBindSampler)(GLuint unit, GLuint sampler) {
-    CALL_GL_API(glBindSampler, unit, sampler);
-}
-void API_ENTRY(glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param) {
-    CALL_GL_API(glSamplerParameteri, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param) {
-    CALL_GL_API(glSamplerParameteriv, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param) {
-    CALL_GL_API(glSamplerParameterf, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param) {
-    CALL_GL_API(glSamplerParameterfv, sampler, pname, param);
-}
-void API_ENTRY(glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetSamplerParameteriv, sampler, pname, params);
-}
-void API_ENTRY(glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params) {
-    CALL_GL_API(glGetSamplerParameterfv, sampler, pname, params);
-}
-void API_ENTRY(glVertexAttribDivisor)(GLuint index, GLuint divisor) {
-    CALL_GL_API(glVertexAttribDivisor, index, divisor);
-}
-void API_ENTRY(glBindTransformFeedback)(GLenum target, GLuint id) {
-    CALL_GL_API(glBindTransformFeedback, target, id);
-}
-void API_ENTRY(glDeleteTransformFeedbacks)(GLsizei n, const GLuint *ids) {
-    CALL_GL_API(glDeleteTransformFeedbacks, n, ids);
-}
-void API_ENTRY(glGenTransformFeedbacks)(GLsizei n, GLuint *ids) {
-    CALL_GL_API(glGenTransformFeedbacks, n, ids);
-}
-GLboolean API_ENTRY(glIsTransformFeedback)(GLuint id) {
-    CALL_GL_API_RETURN(glIsTransformFeedback, id);
-}
-void API_ENTRY(glPauseTransformFeedback)(void) {
-    CALL_GL_API(glPauseTransformFeedback);
-}
-void API_ENTRY(glResumeTransformFeedback)(void) {
-    CALL_GL_API(glResumeTransformFeedback);
-}
-void API_ENTRY(glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary) {
-    CALL_GL_API(glGetProgramBinary, program, bufSize, length, binaryFormat, binary);
-}
-void API_ENTRY(glProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length) {
-    CALL_GL_API(glProgramBinary, program, binaryFormat, binary, length);
-}
-void API_ENTRY(glProgramParameteri)(GLuint program, GLenum pname, GLint value) {
-    CALL_GL_API(glProgramParameteri, program, pname, value);
-}
-void API_ENTRY(glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments) {
-    CALL_GL_API(glInvalidateFramebuffer, target, numAttachments, attachments);
-}
-void API_ENTRY(glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glInvalidateSubFramebuffer, target, numAttachments, attachments, x, y, width, height);
-}
-void API_ENTRY(glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glTexStorage2D, target, levels, internalformat, width, height);
-}
-void API_ENTRY(glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
-    CALL_GL_API(glTexStorage3D, target, levels, internalformat, width, height, depth);
-}
-void API_ENTRY(glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params) {
-    CALL_GL_API(glGetInternalformativ, target, internalformat, pname, bufSize, params);
-}
-void API_ENTRY(glDispatchCompute)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
-    CALL_GL_API(glDispatchCompute, num_groups_x, num_groups_y, num_groups_z);
-}
-void API_ENTRY(glDispatchComputeIndirect)(GLintptr indirect) {
-    CALL_GL_API(glDispatchComputeIndirect, indirect);
-}
-void API_ENTRY(glDrawArraysIndirect)(GLenum mode, const void *indirect) {
-    CALL_GL_API(glDrawArraysIndirect, mode, indirect);
-}
-void API_ENTRY(glDrawElementsIndirect)(GLenum mode, GLenum type, const void *indirect) {
-    CALL_GL_API(glDrawElementsIndirect, mode, type, indirect);
-}
-void API_ENTRY(glFramebufferParameteri)(GLenum target, GLenum pname, GLint param) {
-    CALL_GL_API(glFramebufferParameteri, target, pname, param);
-}
-void API_ENTRY(glGetFramebufferParameteriv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetFramebufferParameteriv, target, pname, params);
-}
-void API_ENTRY(glGetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetProgramInterfaceiv, program, programInterface, pname, params);
-}
-GLuint API_ENTRY(glGetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetProgramResourceIndex, program, programInterface, name);
-}
-void API_ENTRY(glGetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name) {
-    CALL_GL_API(glGetProgramResourceName, program, programInterface, index, bufSize, length, name);
-}
-void API_ENTRY(glGetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params) {
-    CALL_GL_API(glGetProgramResourceiv, program, programInterface, index, propCount, props, bufSize, length, params);
-}
-GLint API_ENTRY(glGetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetProgramResourceLocation, program, programInterface, name);
-}
-void API_ENTRY(glUseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program) {
-    CALL_GL_API(glUseProgramStages, pipeline, stages, program);
-}
-void API_ENTRY(glActiveShaderProgram)(GLuint pipeline, GLuint program) {
-    CALL_GL_API(glActiveShaderProgram, pipeline, program);
-}
-GLuint API_ENTRY(glCreateShaderProgramv)(GLenum type, GLsizei count, const GLchar *const*strings) {
-    CALL_GL_API_RETURN(glCreateShaderProgramv, type, count, strings);
-}
-void API_ENTRY(glBindProgramPipeline)(GLuint pipeline) {
-    CALL_GL_API(glBindProgramPipeline, pipeline);
-}
-void API_ENTRY(glDeleteProgramPipelines)(GLsizei n, const GLuint *pipelines) {
-    CALL_GL_API(glDeleteProgramPipelines, n, pipelines);
-}
-void API_ENTRY(glGenProgramPipelines)(GLsizei n, GLuint *pipelines) {
-    CALL_GL_API(glGenProgramPipelines, n, pipelines);
-}
-GLboolean API_ENTRY(glIsProgramPipeline)(GLuint pipeline) {
-    CALL_GL_API_RETURN(glIsProgramPipeline, pipeline);
-}
-void API_ENTRY(glGetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetProgramPipelineiv, pipeline, pname, params);
-}
-void API_ENTRY(glProgramUniform1i)(GLuint program, GLint location, GLint v0) {
-    CALL_GL_API(glProgramUniform1i, program, location, v0);
-}
-void API_ENTRY(glProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1) {
-    CALL_GL_API(glProgramUniform2i, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {
-    CALL_GL_API(glProgramUniform3i, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
-    CALL_GL_API(glProgramUniform4i, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform1ui)(GLuint program, GLint location, GLuint v0) {
-    CALL_GL_API(glProgramUniform1ui, program, location, v0);
-}
-void API_ENTRY(glProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1) {
-    CALL_GL_API(glProgramUniform2ui, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) {
-    CALL_GL_API(glProgramUniform3ui, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
-    CALL_GL_API(glProgramUniform4ui, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform1f)(GLuint program, GLint location, GLfloat v0) {
-    CALL_GL_API(glProgramUniform1f, program, location, v0);
-}
-void API_ENTRY(glProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1) {
-    CALL_GL_API(glProgramUniform2f, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
-    CALL_GL_API(glProgramUniform3f, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
-    CALL_GL_API(glProgramUniform4f, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform1iv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform2iv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform3iv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform4iv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform1uiv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform2uiv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform3uiv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform4uiv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform1fv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform2fv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform3fv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform4fv, program, location, count, value);
-}
-void API_ENTRY(glProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2x3fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3x2fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2x4fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4x2fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3x4fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4x3fv, program, location, count, transpose, value);
-}
-void API_ENTRY(glValidateProgramPipeline)(GLuint pipeline) {
-    CALL_GL_API(glValidateProgramPipeline, pipeline);
-}
-void API_ENTRY(glGetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
-    CALL_GL_API(glGetProgramPipelineInfoLog, pipeline, bufSize, length, infoLog);
-}
-void API_ENTRY(glBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
-    CALL_GL_API(glBindImageTexture, unit, texture, level, layered, layer, access, format);
-}
-void API_ENTRY(glGetBooleani_v)(GLenum target, GLuint index, GLboolean *data) {
-    CALL_GL_API(glGetBooleani_v, target, index, data);
-}
-void API_ENTRY(glMemoryBarrier)(GLbitfield barriers) {
-    CALL_GL_API(glMemoryBarrier, barriers);
-}
-void API_ENTRY(glMemoryBarrierByRegion)(GLbitfield barriers) {
-    CALL_GL_API(glMemoryBarrierByRegion, barriers);
-}
-void API_ENTRY(glTexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
-    CALL_GL_API(glTexStorage2DMultisample, target, samples, internalformat, width, height, fixedsamplelocations);
-}
-void API_ENTRY(glGetMultisamplefv)(GLenum pname, GLuint index, GLfloat *val) {
-    CALL_GL_API(glGetMultisamplefv, pname, index, val);
-}
-void API_ENTRY(glSampleMaski)(GLuint maskNumber, GLbitfield mask) {
-    CALL_GL_API(glSampleMaski, maskNumber, mask);
-}
-void API_ENTRY(glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetTexLevelParameteriv, target, level, pname, params);
-}
-void API_ENTRY(glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params) {
-    CALL_GL_API(glGetTexLevelParameterfv, target, level, pname, params);
-}
-void API_ENTRY(glBindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
-    CALL_GL_API(glBindVertexBuffer, bindingindex, buffer, offset, stride);
-}
-void API_ENTRY(glVertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) {
-    CALL_GL_API(glVertexAttribFormat, attribindex, size, type, normalized, relativeoffset);
-}
-void API_ENTRY(glVertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
-    CALL_GL_API(glVertexAttribIFormat, attribindex, size, type, relativeoffset);
-}
-void API_ENTRY(glVertexAttribBinding)(GLuint attribindex, GLuint bindingindex) {
-    CALL_GL_API(glVertexAttribBinding, attribindex, bindingindex);
-}
-void API_ENTRY(glVertexBindingDivisor)(GLuint bindingindex, GLuint divisor) {
-    CALL_GL_API(glVertexBindingDivisor, bindingindex, divisor);
-}
-void API_ENTRY(glBlendBarrier)(void) {
-    CALL_GL_API(glBlendBarrier);
-}
-void API_ENTRY(glCopyImageSubData)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
-    CALL_GL_API(glCopyImageSubData, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-void API_ENTRY(glDebugMessageControl)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) {
-    CALL_GL_API(glDebugMessageControl, source, type, severity, count, ids, enabled);
-}
-void API_ENTRY(glDebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) {
-    CALL_GL_API(glDebugMessageInsert, source, type, id, severity, length, buf);
-}
-void API_ENTRY(glDebugMessageCallback)(GLDEBUGPROC callback, const void *userParam) {
-    CALL_GL_API(glDebugMessageCallback, callback, userParam);
-}
-GLuint API_ENTRY(glGetDebugMessageLog)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog) {
-    CALL_GL_API_RETURN(glGetDebugMessageLog, count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-void API_ENTRY(glPushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar *message) {
-    CALL_GL_API(glPushDebugGroup, source, id, length, message);
-}
-void API_ENTRY(glPopDebugGroup)(void) {
-    CALL_GL_API(glPopDebugGroup);
-}
-void API_ENTRY(glObjectLabel)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) {
-    CALL_GL_API(glObjectLabel, identifier, name, length, label);
-}
-void API_ENTRY(glGetObjectLabel)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) {
-    CALL_GL_API(glGetObjectLabel, identifier, name, bufSize, length, label);
-}
-void API_ENTRY(glObjectPtrLabel)(const void *ptr, GLsizei length, const GLchar *label) {
-    CALL_GL_API(glObjectPtrLabel, ptr, length, label);
-}
-void API_ENTRY(glGetObjectPtrLabel)(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) {
-    CALL_GL_API(glGetObjectPtrLabel, ptr, bufSize, length, label);
-}
-void API_ENTRY(glGetPointerv)(GLenum pname, void **params) {
-    CALL_GL_API(glGetPointerv, pname, params);
-}
-void API_ENTRY(glEnablei)(GLenum target, GLuint index) {
-    CALL_GL_API(glEnablei, target, index);
-}
-void API_ENTRY(glDisablei)(GLenum target, GLuint index) {
-    CALL_GL_API(glDisablei, target, index);
-}
-void API_ENTRY(glBlendEquationi)(GLuint buf, GLenum mode) {
-    CALL_GL_API(glBlendEquationi, buf, mode);
-}
-void API_ENTRY(glBlendEquationSeparatei)(GLuint buf, GLenum modeRGB, GLenum modeAlpha) {
-    CALL_GL_API(glBlendEquationSeparatei, buf, modeRGB, modeAlpha);
-}
-void API_ENTRY(glBlendFunci)(GLuint buf, GLenum src, GLenum dst) {
-    CALL_GL_API(glBlendFunci, buf, src, dst);
-}
-void API_ENTRY(glBlendFuncSeparatei)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-    CALL_GL_API(glBlendFuncSeparatei, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-void API_ENTRY(glColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
-    CALL_GL_API(glColorMaski, index, r, g, b, a);
-}
-GLboolean API_ENTRY(glIsEnabledi)(GLenum target, GLuint index) {
-    CALL_GL_API_RETURN(glIsEnabledi, target, index);
-}
-void API_ENTRY(glDrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawElementsBaseVertex, mode, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawRangeElementsBaseVertex, mode, start, end, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) {
-    CALL_GL_API(glDrawElementsInstancedBaseVertex, mode, count, type, indices, instancecount, basevertex);
-}
-void API_ENTRY(glFramebufferTexture)(GLenum target, GLenum attachment, GLuint texture, GLint level) {
-    CALL_GL_API(glFramebufferTexture, target, attachment, texture, level);
-}
-void API_ENTRY(glPrimitiveBoundingBox)(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
-    CALL_GL_API(glPrimitiveBoundingBox, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
-}
-GLenum API_ENTRY(glGetGraphicsResetStatus)(void) {
-    CALL_GL_API_RETURN(glGetGraphicsResetStatus);
-}
-void API_ENTRY(glReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data) {
-    CALL_GL_API(glReadnPixels, x, y, width, height, format, type, bufSize, data);
-}
-void API_ENTRY(glGetnUniformfv)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params) {
-    CALL_GL_API(glGetnUniformfv, program, location, bufSize, params);
-}
-void API_ENTRY(glGetnUniformiv)(GLuint program, GLint location, GLsizei bufSize, GLint *params) {
-    CALL_GL_API(glGetnUniformiv, program, location, bufSize, params);
-}
-void API_ENTRY(glGetnUniformuiv)(GLuint program, GLint location, GLsizei bufSize, GLuint *params) {
-    CALL_GL_API(glGetnUniformuiv, program, location, bufSize, params);
-}
-void API_ENTRY(glMinSampleShading)(GLfloat value) {
-    CALL_GL_API(glMinSampleShading, value);
-}
-void API_ENTRY(glPatchParameteri)(GLenum pname, GLint value) {
-    CALL_GL_API(glPatchParameteri, pname, value);
-}
-void API_ENTRY(glTexParameterIiv)(GLenum target, GLenum pname, const GLint *params) {
-    CALL_GL_API(glTexParameterIiv, target, pname, params);
-}
-void API_ENTRY(glTexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params) {
-    CALL_GL_API(glTexParameterIuiv, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIiv)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetTexParameterIiv, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetTexParameterIuiv, target, pname, params);
-}
-void API_ENTRY(glSamplerParameterIiv)(GLuint sampler, GLenum pname, const GLint *param) {
-    CALL_GL_API(glSamplerParameterIiv, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameterIuiv)(GLuint sampler, GLenum pname, const GLuint *param) {
-    CALL_GL_API(glSamplerParameterIuiv, sampler, pname, param);
-}
-void API_ENTRY(glGetSamplerParameterIiv)(GLuint sampler, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetSamplerParameterIiv, sampler, pname, params);
-}
-void API_ENTRY(glGetSamplerParameterIuiv)(GLuint sampler, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetSamplerParameterIuiv, sampler, pname, params);
-}
-void API_ENTRY(glTexBuffer)(GLenum target, GLenum internalformat, GLuint buffer) {
-    CALL_GL_API(glTexBuffer, target, internalformat, buffer);
-}
-void API_ENTRY(glTexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
-    CALL_GL_API(glTexBufferRange, target, internalformat, buffer, offset, size);
-}
-void API_ENTRY(glTexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
-    CALL_GL_API(glTexStorage3DMultisample, target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-void API_ENTRY(glBlendBarrierKHR)(void) {
-    CALL_GL_API(glBlendBarrierKHR);
-}
-void API_ENTRY(glDebugMessageControlKHR)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) {
-    CALL_GL_API(glDebugMessageControlKHR, source, type, severity, count, ids, enabled);
-}
-void API_ENTRY(glDebugMessageInsertKHR)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) {
-    CALL_GL_API(glDebugMessageInsertKHR, source, type, id, severity, length, buf);
-}
-void API_ENTRY(glDebugMessageCallbackKHR)(GLDEBUGPROCKHR callback, const void *userParam) {
-    CALL_GL_API(glDebugMessageCallbackKHR, callback, userParam);
-}
-GLuint API_ENTRY(glGetDebugMessageLogKHR)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog) {
-    CALL_GL_API_RETURN(glGetDebugMessageLogKHR, count, bufSize, sources, types, ids, severities, lengths, messageLog);
-}
-void API_ENTRY(glPushDebugGroupKHR)(GLenum source, GLuint id, GLsizei length, const GLchar *message) {
-    CALL_GL_API(glPushDebugGroupKHR, source, id, length, message);
-}
-void API_ENTRY(glPopDebugGroupKHR)(void) {
-    CALL_GL_API(glPopDebugGroupKHR);
-}
-void API_ENTRY(glObjectLabelKHR)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) {
-    CALL_GL_API(glObjectLabelKHR, identifier, name, length, label);
-}
-void API_ENTRY(glGetObjectLabelKHR)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) {
-    CALL_GL_API(glGetObjectLabelKHR, identifier, name, bufSize, length, label);
-}
-void API_ENTRY(glObjectPtrLabelKHR)(const void *ptr, GLsizei length, const GLchar *label) {
-    CALL_GL_API(glObjectPtrLabelKHR, ptr, length, label);
-}
-void API_ENTRY(glGetObjectPtrLabelKHR)(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) {
-    CALL_GL_API(glGetObjectPtrLabelKHR, ptr, bufSize, length, label);
-}
-void API_ENTRY(glGetPointervKHR)(GLenum pname, void **params) {
-    CALL_GL_API(glGetPointervKHR, pname, params);
-}
-GLenum API_ENTRY(glGetGraphicsResetStatusKHR)(void) {
-    CALL_GL_API_RETURN(glGetGraphicsResetStatusKHR);
-}
-void API_ENTRY(glReadnPixelsKHR)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data) {
-    CALL_GL_API(glReadnPixelsKHR, x, y, width, height, format, type, bufSize, data);
-}
-void API_ENTRY(glGetnUniformfvKHR)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params) {
-    CALL_GL_API(glGetnUniformfvKHR, program, location, bufSize, params);
-}
-void API_ENTRY(glGetnUniformivKHR)(GLuint program, GLint location, GLsizei bufSize, GLint *params) {
-    CALL_GL_API(glGetnUniformivKHR, program, location, bufSize, params);
-}
-void API_ENTRY(glGetnUniformuivKHR)(GLuint program, GLint location, GLsizei bufSize, GLuint *params) {
-    CALL_GL_API(glGetnUniformuivKHR, program, location, bufSize, params);
-}
-void API_ENTRY(glEGLImageTargetTexture2DOES)(GLenum target, GLeglImageOES image) {
-    CALL_GL_API(glEGLImageTargetTexture2DOES, target, image);
-}
-void API_ENTRY(glEGLImageTargetRenderbufferStorageOES)(GLenum target, GLeglImageOES image) {
-    CALL_GL_API(glEGLImageTargetRenderbufferStorageOES, target, image);
-}
-void API_ENTRY(glCopyImageSubDataOES)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
-    CALL_GL_API(glCopyImageSubDataOES, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-void API_ENTRY(glEnableiOES)(GLenum target, GLuint index) {
-    CALL_GL_API(glEnableiOES, target, index);
-}
-void API_ENTRY(glDisableiOES)(GLenum target, GLuint index) {
-    CALL_GL_API(glDisableiOES, target, index);
-}
-void API_ENTRY(glBlendEquationiOES)(GLuint buf, GLenum mode) {
-    CALL_GL_API(glBlendEquationiOES, buf, mode);
-}
-void API_ENTRY(glBlendEquationSeparateiOES)(GLuint buf, GLenum modeRGB, GLenum modeAlpha) {
-    CALL_GL_API(glBlendEquationSeparateiOES, buf, modeRGB, modeAlpha);
-}
-void API_ENTRY(glBlendFunciOES)(GLuint buf, GLenum src, GLenum dst) {
-    CALL_GL_API(glBlendFunciOES, buf, src, dst);
-}
-void API_ENTRY(glBlendFuncSeparateiOES)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-    CALL_GL_API(glBlendFuncSeparateiOES, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-void API_ENTRY(glColorMaskiOES)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
-    CALL_GL_API(glColorMaskiOES, index, r, g, b, a);
-}
-GLboolean API_ENTRY(glIsEnablediOES)(GLenum target, GLuint index) {
-    CALL_GL_API_RETURN(glIsEnablediOES, target, index);
-}
-void API_ENTRY(glDrawElementsBaseVertexOES)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawElementsBaseVertexOES, mode, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawRangeElementsBaseVertexOES)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawRangeElementsBaseVertexOES, mode, start, end, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawElementsInstancedBaseVertexOES)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) {
-    CALL_GL_API(glDrawElementsInstancedBaseVertexOES, mode, count, type, indices, instancecount, basevertex);
-}
-void API_ENTRY(glFramebufferTextureOES)(GLenum target, GLenum attachment, GLuint texture, GLint level) {
-    CALL_GL_API(glFramebufferTextureOES, target, attachment, texture, level);
-}
-void API_ENTRY(glGetProgramBinaryOES)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary) {
-    CALL_GL_API(glGetProgramBinaryOES, program, bufSize, length, binaryFormat, binary);
-}
-void API_ENTRY(glProgramBinaryOES)(GLuint program, GLenum binaryFormat, const void *binary, GLint length) {
-    CALL_GL_API(glProgramBinaryOES, program, binaryFormat, binary, length);
-}
-void * API_ENTRY(glMapBufferOES)(GLenum target, GLenum access) {
-    CALL_GL_API_RETURN(glMapBufferOES, target, access);
-}
-GLboolean API_ENTRY(glUnmapBufferOES)(GLenum target) {
-    CALL_GL_API_RETURN(glUnmapBufferOES, target);
-}
-void API_ENTRY(glGetBufferPointervOES)(GLenum target, GLenum pname, void **params) {
-    CALL_GL_API(glGetBufferPointervOES, target, pname, params);
-}
-void API_ENTRY(glPrimitiveBoundingBoxOES)(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
-    CALL_GL_API(glPrimitiveBoundingBoxOES, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
-}
-void API_ENTRY(glMinSampleShadingOES)(GLfloat value) {
-    CALL_GL_API(glMinSampleShadingOES, value);
-}
-void API_ENTRY(glPatchParameteriOES)(GLenum pname, GLint value) {
-    CALL_GL_API(glPatchParameteriOES, pname, value);
-}
-void API_ENTRY(glTexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexImage3DOES, target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-void API_ENTRY(glTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) {
-    CALL_GL_API(glTexSubImage3DOES, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-void API_ENTRY(glCopyTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
-    CALL_GL_API(glCopyTexSubImage3DOES, target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-void API_ENTRY(glCompressedTexImage3DOES)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexImage3DOES, target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-void API_ENTRY(glCompressedTexSubImage3DOES)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) {
-    CALL_GL_API(glCompressedTexSubImage3DOES, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-void API_ENTRY(glFramebufferTexture3DOES)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
-    CALL_GL_API(glFramebufferTexture3DOES, target, attachment, textarget, texture, level, zoffset);
-}
-void API_ENTRY(glTexParameterIivOES)(GLenum target, GLenum pname, const GLint *params) {
-    CALL_GL_API(glTexParameterIivOES, target, pname, params);
-}
-void API_ENTRY(glTexParameterIuivOES)(GLenum target, GLenum pname, const GLuint *params) {
-    CALL_GL_API(glTexParameterIuivOES, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIivOES)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetTexParameterIivOES, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIuivOES)(GLenum target, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetTexParameterIuivOES, target, pname, params);
-}
-void API_ENTRY(glSamplerParameterIivOES)(GLuint sampler, GLenum pname, const GLint *param) {
-    CALL_GL_API(glSamplerParameterIivOES, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameterIuivOES)(GLuint sampler, GLenum pname, const GLuint *param) {
-    CALL_GL_API(glSamplerParameterIuivOES, sampler, pname, param);
-}
-void API_ENTRY(glGetSamplerParameterIivOES)(GLuint sampler, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetSamplerParameterIivOES, sampler, pname, params);
-}
-void API_ENTRY(glGetSamplerParameterIuivOES)(GLuint sampler, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetSamplerParameterIuivOES, sampler, pname, params);
-}
-void API_ENTRY(glTexBufferOES)(GLenum target, GLenum internalformat, GLuint buffer) {
-    CALL_GL_API(glTexBufferOES, target, internalformat, buffer);
-}
-void API_ENTRY(glTexBufferRangeOES)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
-    CALL_GL_API(glTexBufferRangeOES, target, internalformat, buffer, offset, size);
-}
-void API_ENTRY(glTexStorage3DMultisampleOES)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
-    CALL_GL_API(glTexStorage3DMultisampleOES, target, samples, internalformat, width, height, depth, fixedsamplelocations);
-}
-void API_ENTRY(glTextureViewOES)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
-    CALL_GL_API(glTextureViewOES, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
-void API_ENTRY(glBindVertexArrayOES)(GLuint array) {
-    CALL_GL_API(glBindVertexArrayOES, array);
-}
-void API_ENTRY(glDeleteVertexArraysOES)(GLsizei n, const GLuint *arrays) {
-    CALL_GL_API(glDeleteVertexArraysOES, n, arrays);
-}
-void API_ENTRY(glGenVertexArraysOES)(GLsizei n, GLuint *arrays) {
-    CALL_GL_API(glGenVertexArraysOES, n, arrays);
-}
-GLboolean API_ENTRY(glIsVertexArrayOES)(GLuint array) {
-    CALL_GL_API_RETURN(glIsVertexArrayOES, array);
-}
-void API_ENTRY(glDrawArraysInstancedBaseInstanceEXT)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) {
-    CALL_GL_API(glDrawArraysInstancedBaseInstanceEXT, mode, first, count, instancecount, baseinstance);
-}
-void API_ENTRY(glDrawElementsInstancedBaseInstanceEXT)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) {
-    CALL_GL_API(glDrawElementsInstancedBaseInstanceEXT, mode, count, type, indices, instancecount, baseinstance);
-}
-void API_ENTRY(glDrawElementsInstancedBaseVertexBaseInstanceEXT)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
-    CALL_GL_API(glDrawElementsInstancedBaseVertexBaseInstanceEXT, mode, count, type, indices, instancecount, basevertex, baseinstance);
-}
-void API_ENTRY(glBindFragDataLocationIndexedEXT)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name) {
-    CALL_GL_API(glBindFragDataLocationIndexedEXT, program, colorNumber, index, name);
-}
-void API_ENTRY(glBindFragDataLocationEXT)(GLuint program, GLuint color, const GLchar *name) {
-    CALL_GL_API(glBindFragDataLocationEXT, program, color, name);
-}
-GLint API_ENTRY(glGetProgramResourceLocationIndexEXT)(GLuint program, GLenum programInterface, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetProgramResourceLocationIndexEXT, program, programInterface, name);
-}
-GLint API_ENTRY(glGetFragDataIndexEXT)(GLuint program, const GLchar *name) {
-    CALL_GL_API_RETURN(glGetFragDataIndexEXT, program, name);
-}
-void API_ENTRY(glBufferStorageEXT)(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags) {
-    CALL_GL_API(glBufferStorageEXT, target, size, data, flags);
-}
-void API_ENTRY(glCopyImageSubDataEXT)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
-    CALL_GL_API(glCopyImageSubDataEXT, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
-}
-void API_ENTRY(glLabelObjectEXT)(GLenum type, GLuint object, GLsizei length, const GLchar *label) {
-    CALL_GL_API(glLabelObjectEXT, type, object, length, label);
-}
-void API_ENTRY(glGetObjectLabelEXT)(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label) {
-    CALL_GL_API(glGetObjectLabelEXT, type, object, bufSize, length, label);
-}
-void API_ENTRY(glInsertEventMarkerEXT)(GLsizei length, const GLchar *marker) {
-    CALL_GL_API(glInsertEventMarkerEXT, length, marker);
-}
-void API_ENTRY(glPushGroupMarkerEXT)(GLsizei length, const GLchar *marker) {
-    CALL_GL_API(glPushGroupMarkerEXT, length, marker);
-}
-void API_ENTRY(glPopGroupMarkerEXT)(void) {
-    CALL_GL_API(glPopGroupMarkerEXT);
-}
-void API_ENTRY(glDiscardFramebufferEXT)(GLenum target, GLsizei numAttachments, const GLenum *attachments) {
-    CALL_GL_API(glDiscardFramebufferEXT, target, numAttachments, attachments);
-}
-void API_ENTRY(glGenQueriesEXT)(GLsizei n, GLuint *ids) {
-    CALL_GL_API(glGenQueriesEXT, n, ids);
-}
-void API_ENTRY(glDeleteQueriesEXT)(GLsizei n, const GLuint *ids) {
-    CALL_GL_API(glDeleteQueriesEXT, n, ids);
-}
-GLboolean API_ENTRY(glIsQueryEXT)(GLuint id) {
-    CALL_GL_API_RETURN(glIsQueryEXT, id);
-}
-void API_ENTRY(glBeginQueryEXT)(GLenum target, GLuint id) {
-    CALL_GL_API(glBeginQueryEXT, target, id);
-}
-void API_ENTRY(glEndQueryEXT)(GLenum target) {
-    CALL_GL_API(glEndQueryEXT, target);
-}
-void API_ENTRY(glQueryCounterEXT)(GLuint id, GLenum target) {
-    CALL_GL_API(glQueryCounterEXT, id, target);
-}
-void API_ENTRY(glGetQueryivEXT)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetQueryivEXT, target, pname, params);
-}
-void API_ENTRY(glGetQueryObjectivEXT)(GLuint id, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetQueryObjectivEXT, id, pname, params);
-}
-void API_ENTRY(glGetQueryObjectuivEXT)(GLuint id, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetQueryObjectuivEXT, id, pname, params);
-}
-void API_ENTRY(glGetQueryObjecti64vEXT)(GLuint id, GLenum pname, GLint64 *params) {
-    CALL_GL_API(glGetQueryObjecti64vEXT, id, pname, params);
-}
-void API_ENTRY(glGetQueryObjectui64vEXT)(GLuint id, GLenum pname, GLuint64 *params) {
-    CALL_GL_API(glGetQueryObjectui64vEXT, id, pname, params);
-}
-void API_ENTRY(glDrawBuffersEXT)(GLsizei n, const GLenum *bufs) {
-    CALL_GL_API(glDrawBuffersEXT, n, bufs);
-}
-void API_ENTRY(glEnableiEXT)(GLenum target, GLuint index) {
-    CALL_GL_API(glEnableiEXT, target, index);
-}
-void API_ENTRY(glDisableiEXT)(GLenum target, GLuint index) {
-    CALL_GL_API(glDisableiEXT, target, index);
-}
-void API_ENTRY(glBlendEquationiEXT)(GLuint buf, GLenum mode) {
-    CALL_GL_API(glBlendEquationiEXT, buf, mode);
-}
-void API_ENTRY(glBlendEquationSeparateiEXT)(GLuint buf, GLenum modeRGB, GLenum modeAlpha) {
-    CALL_GL_API(glBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha);
-}
-void API_ENTRY(glBlendFunciEXT)(GLuint buf, GLenum src, GLenum dst) {
-    CALL_GL_API(glBlendFunciEXT, buf, src, dst);
-}
-void API_ENTRY(glBlendFuncSeparateiEXT)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-    CALL_GL_API(glBlendFuncSeparateiEXT, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-void API_ENTRY(glColorMaskiEXT)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
-    CALL_GL_API(glColorMaskiEXT, index, r, g, b, a);
-}
-GLboolean API_ENTRY(glIsEnablediEXT)(GLenum target, GLuint index) {
-    CALL_GL_API_RETURN(glIsEnablediEXT, target, index);
-}
-void API_ENTRY(glDrawElementsBaseVertexEXT)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawElementsBaseVertexEXT, mode, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawRangeElementsBaseVertexEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) {
-    CALL_GL_API(glDrawRangeElementsBaseVertexEXT, mode, start, end, count, type, indices, basevertex);
-}
-void API_ENTRY(glDrawElementsInstancedBaseVertexEXT)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) {
-    CALL_GL_API(glDrawElementsInstancedBaseVertexEXT, mode, count, type, indices, instancecount, basevertex);
-}
-void API_ENTRY(glMultiDrawElementsBaseVertexEXT)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, const GLint *basevertex) {
-    CALL_GL_API(glMultiDrawElementsBaseVertexEXT, mode, count, type, indices, primcount, basevertex);
-}
-void API_ENTRY(glDrawArraysInstancedEXT)(GLenum mode, GLint start, GLsizei count, GLsizei primcount) {
-    CALL_GL_API(glDrawArraysInstancedEXT, mode, start, count, primcount);
-}
-void API_ENTRY(glDrawElementsInstancedEXT)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount) {
-    CALL_GL_API(glDrawElementsInstancedEXT, mode, count, type, indices, primcount);
-}
-void API_ENTRY(glFramebufferTextureEXT)(GLenum target, GLenum attachment, GLuint texture, GLint level) {
-    CALL_GL_API(glFramebufferTextureEXT, target, attachment, texture, level);
-}
-void API_ENTRY(glVertexAttribDivisorEXT)(GLuint index, GLuint divisor) {
-    CALL_GL_API(glVertexAttribDivisorEXT, index, divisor);
-}
-void * API_ENTRY(glMapBufferRangeEXT)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
-    CALL_GL_API_RETURN(glMapBufferRangeEXT, target, offset, length, access);
-}
-void API_ENTRY(glFlushMappedBufferRangeEXT)(GLenum target, GLintptr offset, GLsizeiptr length) {
-    CALL_GL_API(glFlushMappedBufferRangeEXT, target, offset, length);
-}
-void API_ENTRY(glMultiDrawArraysEXT)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {
-    CALL_GL_API(glMultiDrawArraysEXT, mode, first, count, primcount);
-}
-void API_ENTRY(glMultiDrawElementsEXT)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount) {
-    CALL_GL_API(glMultiDrawElementsEXT, mode, count, type, indices, primcount);
-}
-void API_ENTRY(glMultiDrawArraysIndirectEXT)(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride) {
-    CALL_GL_API(glMultiDrawArraysIndirectEXT, mode, indirect, drawcount, stride);
-}
-void API_ENTRY(glMultiDrawElementsIndirectEXT)(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride) {
-    CALL_GL_API(glMultiDrawElementsIndirectEXT, mode, type, indirect, drawcount, stride);
-}
-void API_ENTRY(glRenderbufferStorageMultisampleEXT)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glRenderbufferStorageMultisampleEXT, target, samples, internalformat, width, height);
-}
-void API_ENTRY(glFramebufferTexture2DMultisampleEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) {
-    CALL_GL_API(glFramebufferTexture2DMultisampleEXT, target, attachment, textarget, texture, level, samples);
-}
-void API_ENTRY(glReadBufferIndexedEXT)(GLenum src, GLint index) {
-    CALL_GL_API(glReadBufferIndexedEXT, src, index);
-}
-void API_ENTRY(glDrawBuffersIndexedEXT)(GLint n, const GLenum *location, const GLint *indices) {
-    CALL_GL_API(glDrawBuffersIndexedEXT, n, location, indices);
-}
-void API_ENTRY(glGetIntegeri_vEXT)(GLenum target, GLuint index, GLint *data) {
-    CALL_GL_API(glGetIntegeri_vEXT, target, index, data);
-}
-void API_ENTRY(glPrimitiveBoundingBoxEXT)(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
-    CALL_GL_API(glPrimitiveBoundingBoxEXT, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
-}
-void API_ENTRY(glRasterSamplesEXT)(GLuint samples, GLboolean fixedsamplelocations) {
-    CALL_GL_API(glRasterSamplesEXT, samples, fixedsamplelocations);
-}
-GLenum API_ENTRY(glGetGraphicsResetStatusEXT)(void) {
-    CALL_GL_API_RETURN(glGetGraphicsResetStatusEXT);
-}
-void API_ENTRY(glReadnPixelsEXT)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data) {
-    CALL_GL_API(glReadnPixelsEXT, x, y, width, height, format, type, bufSize, data);
-}
-void API_ENTRY(glGetnUniformfvEXT)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params) {
-    CALL_GL_API(glGetnUniformfvEXT, program, location, bufSize, params);
-}
-void API_ENTRY(glGetnUniformivEXT)(GLuint program, GLint location, GLsizei bufSize, GLint *params) {
-    CALL_GL_API(glGetnUniformivEXT, program, location, bufSize, params);
-}
-void API_ENTRY(glActiveShaderProgramEXT)(GLuint pipeline, GLuint program) {
-    CALL_GL_API(glActiveShaderProgramEXT, pipeline, program);
-}
-void API_ENTRY(glBindProgramPipelineEXT)(GLuint pipeline) {
-    CALL_GL_API(glBindProgramPipelineEXT, pipeline);
-}
-GLuint API_ENTRY(glCreateShaderProgramvEXT)(GLenum type, GLsizei count, const GLchar **strings) {
-    CALL_GL_API_RETURN(glCreateShaderProgramvEXT, type, count, strings);
-}
-void API_ENTRY(glDeleteProgramPipelinesEXT)(GLsizei n, const GLuint *pipelines) {
-    CALL_GL_API(glDeleteProgramPipelinesEXT, n, pipelines);
-}
-void API_ENTRY(glGenProgramPipelinesEXT)(GLsizei n, GLuint *pipelines) {
-    CALL_GL_API(glGenProgramPipelinesEXT, n, pipelines);
-}
-void API_ENTRY(glGetProgramPipelineInfoLogEXT)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
-    CALL_GL_API(glGetProgramPipelineInfoLogEXT, pipeline, bufSize, length, infoLog);
-}
-void API_ENTRY(glGetProgramPipelineivEXT)(GLuint pipeline, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetProgramPipelineivEXT, pipeline, pname, params);
-}
-GLboolean API_ENTRY(glIsProgramPipelineEXT)(GLuint pipeline) {
-    CALL_GL_API_RETURN(glIsProgramPipelineEXT, pipeline);
-}
-void API_ENTRY(glProgramParameteriEXT)(GLuint program, GLenum pname, GLint value) {
-    CALL_GL_API(glProgramParameteriEXT, program, pname, value);
-}
-void API_ENTRY(glProgramUniform1fEXT)(GLuint program, GLint location, GLfloat v0) {
-    CALL_GL_API(glProgramUniform1fEXT, program, location, v0);
-}
-void API_ENTRY(glProgramUniform1fvEXT)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform1fvEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform1iEXT)(GLuint program, GLint location, GLint v0) {
-    CALL_GL_API(glProgramUniform1iEXT, program, location, v0);
-}
-void API_ENTRY(glProgramUniform1ivEXT)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform1ivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2fEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1) {
-    CALL_GL_API(glProgramUniform2fEXT, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform2fvEXT)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform2fvEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2iEXT)(GLuint program, GLint location, GLint v0, GLint v1) {
-    CALL_GL_API(glProgramUniform2iEXT, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform2ivEXT)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform2ivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3fEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
-    CALL_GL_API(glProgramUniform3fEXT, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform3fvEXT)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform3fvEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3iEXT)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {
-    CALL_GL_API(glProgramUniform3iEXT, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform3ivEXT)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform3ivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4fEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
-    CALL_GL_API(glProgramUniform4fEXT, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform4fvEXT)(GLuint program, GLint location, GLsizei count, const GLfloat *value) {
-    CALL_GL_API(glProgramUniform4fvEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4iEXT)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
-    CALL_GL_API(glProgramUniform4iEXT, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform4ivEXT)(GLuint program, GLint location, GLsizei count, const GLint *value) {
-    CALL_GL_API(glProgramUniform4ivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniformMatrix2fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glUseProgramStagesEXT)(GLuint pipeline, GLbitfield stages, GLuint program) {
-    CALL_GL_API(glUseProgramStagesEXT, pipeline, stages, program);
-}
-void API_ENTRY(glValidateProgramPipelineEXT)(GLuint pipeline) {
-    CALL_GL_API(glValidateProgramPipelineEXT, pipeline);
-}
-void API_ENTRY(glProgramUniform1uiEXT)(GLuint program, GLint location, GLuint v0) {
-    CALL_GL_API(glProgramUniform1uiEXT, program, location, v0);
-}
-void API_ENTRY(glProgramUniform2uiEXT)(GLuint program, GLint location, GLuint v0, GLuint v1) {
-    CALL_GL_API(glProgramUniform2uiEXT, program, location, v0, v1);
-}
-void API_ENTRY(glProgramUniform3uiEXT)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) {
-    CALL_GL_API(glProgramUniform3uiEXT, program, location, v0, v1, v2);
-}
-void API_ENTRY(glProgramUniform4uiEXT)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
-    CALL_GL_API(glProgramUniform4uiEXT, program, location, v0, v1, v2, v3);
-}
-void API_ENTRY(glProgramUniform1uivEXT)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform1uivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform2uivEXT)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform2uivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform3uivEXT)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform3uivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniform4uivEXT)(GLuint program, GLint location, GLsizei count, const GLuint *value) {
-    CALL_GL_API(glProgramUniform4uivEXT, program, location, count, value);
-}
-void API_ENTRY(glProgramUniformMatrix2x3fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2x3fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3x2fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3x2fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix2x4fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix2x4fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4x2fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4x2fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix3x4fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix3x4fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glProgramUniformMatrix4x3fvEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
-    CALL_GL_API(glProgramUniformMatrix4x3fvEXT, program, location, count, transpose, value);
-}
-void API_ENTRY(glTexPageCommitmentEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) {
-    CALL_GL_API(glTexPageCommitmentEXT, target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
-}
-void API_ENTRY(glPatchParameteriEXT)(GLenum pname, GLint value) {
-    CALL_GL_API(glPatchParameteriEXT, pname, value);
-}
-void API_ENTRY(glTexParameterIivEXT)(GLenum target, GLenum pname, const GLint *params) {
-    CALL_GL_API(glTexParameterIivEXT, target, pname, params);
-}
-void API_ENTRY(glTexParameterIuivEXT)(GLenum target, GLenum pname, const GLuint *params) {
-    CALL_GL_API(glTexParameterIuivEXT, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIivEXT)(GLenum target, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetTexParameterIivEXT, target, pname, params);
-}
-void API_ENTRY(glGetTexParameterIuivEXT)(GLenum target, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetTexParameterIuivEXT, target, pname, params);
-}
-void API_ENTRY(glSamplerParameterIivEXT)(GLuint sampler, GLenum pname, const GLint *param) {
-    CALL_GL_API(glSamplerParameterIivEXT, sampler, pname, param);
-}
-void API_ENTRY(glSamplerParameterIuivEXT)(GLuint sampler, GLenum pname, const GLuint *param) {
-    CALL_GL_API(glSamplerParameterIuivEXT, sampler, pname, param);
-}
-void API_ENTRY(glGetSamplerParameterIivEXT)(GLuint sampler, GLenum pname, GLint *params) {
-    CALL_GL_API(glGetSamplerParameterIivEXT, sampler, pname, params);
-}
-void API_ENTRY(glGetSamplerParameterIuivEXT)(GLuint sampler, GLenum pname, GLuint *params) {
-    CALL_GL_API(glGetSamplerParameterIuivEXT, sampler, pname, params);
-}
-void API_ENTRY(glTexBufferEXT)(GLenum target, GLenum internalformat, GLuint buffer) {
-    CALL_GL_API(glTexBufferEXT, target, internalformat, buffer);
-}
-void API_ENTRY(glTexBufferRangeEXT)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
-    CALL_GL_API(glTexBufferRangeEXT, target, internalformat, buffer, offset, size);
-}
-void API_ENTRY(glTexStorage1DEXT)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) {
-    CALL_GL_API(glTexStorage1DEXT, target, levels, internalformat, width);
-}
-void API_ENTRY(glTexStorage2DEXT)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glTexStorage2DEXT, target, levels, internalformat, width, height);
-}
-void API_ENTRY(glTexStorage3DEXT)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
-    CALL_GL_API(glTexStorage3DEXT, target, levels, internalformat, width, height, depth);
-}
-void API_ENTRY(glTextureStorage1DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) {
-    CALL_GL_API(glTextureStorage1DEXT, texture, target, levels, internalformat, width);
-}
-void API_ENTRY(glTextureStorage2DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
-    CALL_GL_API(glTextureStorage2DEXT, texture, target, levels, internalformat, width, height);
-}
-void API_ENTRY(glTextureStorage3DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
-    CALL_GL_API(glTextureStorage3DEXT, texture, target, levels, internalformat, width, height, depth);
-}
-void API_ENTRY(glTextureViewEXT)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
-    CALL_GL_API(glTextureViewEXT, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
-}
diff --git a/libs/hwui/debug/gles_undefine.h b/libs/hwui/debug/gles_undefine.h
deleted file mode 100644
index e43829d..0000000
--- a/libs/hwui/debug/gles_undefine.h
+++ /dev/null
@@ -1,913 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#undef glActiveShaderProgram
-#undef glActiveShaderProgramEXT
-#undef glActiveTexture
-#undef glAlphaFunc
-#undef glAlphaFuncQCOM
-#undef glAlphaFuncx
-#undef glAlphaFuncxOES
-#undef glApplyFramebufferAttachmentCMAAINTEL
-#undef glAttachShader
-#undef glBeginConditionalRenderNV
-#undef glBeginPerfMonitorAMD
-#undef glBeginPerfQueryINTEL
-#undef glBeginQuery
-#undef glBeginQueryEXT
-#undef glBeginTransformFeedback
-#undef glBindAttribLocation
-#undef glBindBuffer
-#undef glBindBufferBase
-#undef glBindBufferRange
-#undef glBindFragDataLocationEXT
-#undef glBindFragDataLocationIndexedEXT
-#undef glBindFramebuffer
-#undef glBindFramebufferOES
-#undef glBindImageTexture
-#undef glBindProgramPipeline
-#undef glBindProgramPipelineEXT
-#undef glBindRenderbuffer
-#undef glBindRenderbufferOES
-#undef glBindSampler
-#undef glBindTexture
-#undef glBindTransformFeedback
-#undef glBindVertexArray
-#undef glBindVertexArrayOES
-#undef glBindVertexBuffer
-#undef glBlendBarrier
-#undef glBlendBarrierKHR
-#undef glBlendBarrierNV
-#undef glBlendColor
-#undef glBlendEquation
-#undef glBlendEquationOES
-#undef glBlendEquationSeparate
-#undef glBlendEquationSeparateOES
-#undef glBlendEquationSeparatei
-#undef glBlendEquationSeparateiEXT
-#undef glBlendEquationSeparateiOES
-#undef glBlendEquationi
-#undef glBlendEquationiEXT
-#undef glBlendEquationiOES
-#undef glBlendFunc
-#undef glBlendFuncSeparate
-#undef glBlendFuncSeparateOES
-#undef glBlendFuncSeparatei
-#undef glBlendFuncSeparateiEXT
-#undef glBlendFuncSeparateiOES
-#undef glBlendFunci
-#undef glBlendFunciEXT
-#undef glBlendFunciOES
-#undef glBlendParameteriNV
-#undef glBlitFramebuffer
-#undef glBlitFramebufferANGLE
-#undef glBlitFramebufferNV
-#undef glBufferData
-#undef glBufferStorageEXT
-#undef glBufferSubData
-#undef glCheckFramebufferStatus
-#undef glCheckFramebufferStatusOES
-#undef glClear
-#undef glClearBufferfi
-#undef glClearBufferfv
-#undef glClearBufferiv
-#undef glClearBufferuiv
-#undef glClearColor
-#undef glClearColorx
-#undef glClearColorxOES
-#undef glClearDepthf
-#undef glClearDepthfOES
-#undef glClearDepthx
-#undef glClearDepthxOES
-#undef glClearStencil
-#undef glClientActiveTexture
-#undef glClientWaitSync
-#undef glClientWaitSyncAPPLE
-#undef glClipPlanef
-#undef glClipPlanefIMG
-#undef glClipPlanefOES
-#undef glClipPlanex
-#undef glClipPlanexIMG
-#undef glClipPlanexOES
-#undef glColor4f
-#undef glColor4ub
-#undef glColor4x
-#undef glColor4xOES
-#undef glColorMask
-#undef glColorMaski
-#undef glColorMaskiEXT
-#undef glColorMaskiOES
-#undef glColorPointer
-#undef glCompileShader
-#undef glCompressedTexImage2D
-#undef glCompressedTexImage3D
-#undef glCompressedTexImage3DOES
-#undef glCompressedTexSubImage2D
-#undef glCompressedTexSubImage3D
-#undef glCompressedTexSubImage3DOES
-#undef glCopyBufferSubData
-#undef glCopyBufferSubDataNV
-#undef glCopyImageSubData
-#undef glCopyImageSubDataEXT
-#undef glCopyImageSubDataOES
-#undef glCopyPathNV
-#undef glCopyTexImage2D
-#undef glCopyTexSubImage2D
-#undef glCopyTexSubImage3D
-#undef glCopyTexSubImage3DOES
-#undef glCopyTextureLevelsAPPLE
-#undef glCoverFillPathInstancedNV
-#undef glCoverFillPathNV
-#undef glCoverStrokePathInstancedNV
-#undef glCoverStrokePathNV
-#undef glCoverageMaskNV
-#undef glCoverageModulationNV
-#undef glCoverageModulationTableNV
-#undef glCoverageOperationNV
-#undef glCreatePerfQueryINTEL
-#undef glCreateProgram
-#undef glCreateShader
-#undef glCreateShaderProgramv
-#undef glCreateShaderProgramvEXT
-#undef glCullFace
-#undef glCurrentPaletteMatrixOES
-#undef glDebugMessageCallback
-#undef glDebugMessageCallbackKHR
-#undef glDebugMessageControl
-#undef glDebugMessageControlKHR
-#undef glDebugMessageInsert
-#undef glDebugMessageInsertKHR
-#undef glDeleteBuffers
-#undef glDeleteFencesNV
-#undef glDeleteFramebuffers
-#undef glDeleteFramebuffersOES
-#undef glDeletePathsNV
-#undef glDeletePerfMonitorsAMD
-#undef glDeletePerfQueryINTEL
-#undef glDeleteProgram
-#undef glDeleteProgramPipelines
-#undef glDeleteProgramPipelinesEXT
-#undef glDeleteQueries
-#undef glDeleteQueriesEXT
-#undef glDeleteRenderbuffers
-#undef glDeleteRenderbuffersOES
-#undef glDeleteSamplers
-#undef glDeleteShader
-#undef glDeleteSync
-#undef glDeleteSyncAPPLE
-#undef glDeleteTextures
-#undef glDeleteTransformFeedbacks
-#undef glDeleteVertexArrays
-#undef glDeleteVertexArraysOES
-#undef glDepthFunc
-#undef glDepthMask
-#undef glDepthRangeArrayfvNV
-#undef glDepthRangeIndexedfNV
-#undef glDepthRangef
-#undef glDepthRangefOES
-#undef glDepthRangex
-#undef glDepthRangexOES
-#undef glDetachShader
-#undef glDisable
-#undef glDisableClientState
-#undef glDisableDriverControlQCOM
-#undef glDisableVertexAttribArray
-#undef glDisablei
-#undef glDisableiEXT
-#undef glDisableiNV
-#undef glDisableiOES
-#undef glDiscardFramebufferEXT
-#undef glDispatchCompute
-#undef glDispatchComputeIndirect
-#undef glDrawArrays
-#undef glDrawArraysIndirect
-#undef glDrawArraysInstanced
-#undef glDrawArraysInstancedANGLE
-#undef glDrawArraysInstancedBaseInstanceEXT
-#undef glDrawArraysInstancedEXT
-#undef glDrawArraysInstancedNV
-#undef glDrawBuffers
-#undef glDrawBuffersEXT
-#undef glDrawBuffersIndexedEXT
-#undef glDrawBuffersNV
-#undef glDrawElements
-#undef glDrawElementsBaseVertex
-#undef glDrawElementsBaseVertexEXT
-#undef glDrawElementsBaseVertexOES
-#undef glDrawElementsIndirect
-#undef glDrawElementsInstanced
-#undef glDrawElementsInstancedANGLE
-#undef glDrawElementsInstancedBaseInstanceEXT
-#undef glDrawElementsInstancedBaseVertex
-#undef glDrawElementsInstancedBaseVertexBaseInstanceEXT
-#undef glDrawElementsInstancedBaseVertexEXT
-#undef glDrawElementsInstancedBaseVertexOES
-#undef glDrawElementsInstancedEXT
-#undef glDrawElementsInstancedNV
-#undef glDrawRangeElements
-#undef glDrawRangeElementsBaseVertex
-#undef glDrawRangeElementsBaseVertexEXT
-#undef glDrawRangeElementsBaseVertexOES
-#undef glDrawTexfOES
-#undef glDrawTexfvOES
-#undef glDrawTexiOES
-#undef glDrawTexivOES
-#undef glDrawTexsOES
-#undef glDrawTexsvOES
-#undef glDrawTexxOES
-#undef glDrawTexxvOES
-#undef glEGLImageTargetRenderbufferStorageOES
-#undef glEGLImageTargetTexture2DOES
-#undef glEnable
-#undef glEnableClientState
-#undef glEnableDriverControlQCOM
-#undef glEnableVertexAttribArray
-#undef glEnablei
-#undef glEnableiEXT
-#undef glEnableiNV
-#undef glEnableiOES
-#undef glEndConditionalRenderNV
-#undef glEndPerfMonitorAMD
-#undef glEndPerfQueryINTEL
-#undef glEndQuery
-#undef glEndQueryEXT
-#undef glEndTilingQCOM
-#undef glEndTransformFeedback
-#undef glExtGetBufferPointervQCOM
-#undef glExtGetBuffersQCOM
-#undef glExtGetFramebuffersQCOM
-#undef glExtGetProgramBinarySourceQCOM
-#undef glExtGetProgramsQCOM
-#undef glExtGetRenderbuffersQCOM
-#undef glExtGetShadersQCOM
-#undef glExtGetTexLevelParameterivQCOM
-#undef glExtGetTexSubImageQCOM
-#undef glExtGetTexturesQCOM
-#undef glExtIsProgramBinaryQCOM
-#undef glExtTexObjectStateOverrideiQCOM
-#undef glFenceSync
-#undef glFenceSyncAPPLE
-#undef glFinish
-#undef glFinishFenceNV
-#undef glFlush
-#undef glFlushMappedBufferRange
-#undef glFlushMappedBufferRangeEXT
-#undef glFogf
-#undef glFogfv
-#undef glFogx
-#undef glFogxOES
-#undef glFogxv
-#undef glFogxvOES
-#undef glFragmentCoverageColorNV
-#undef glFramebufferParameteri
-#undef glFramebufferRenderbuffer
-#undef glFramebufferRenderbufferOES
-#undef glFramebufferSampleLocationsfvNV
-#undef glFramebufferTexture
-#undef glFramebufferTexture2D
-#undef glFramebufferTexture2DMultisampleEXT
-#undef glFramebufferTexture2DMultisampleIMG
-#undef glFramebufferTexture2DOES
-#undef glFramebufferTexture3DOES
-#undef glFramebufferTextureEXT
-#undef glFramebufferTextureLayer
-#undef glFramebufferTextureMultisampleMultiviewOVR
-#undef glFramebufferTextureMultiviewOVR
-#undef glFramebufferTextureOES
-#undef glFrontFace
-#undef glFrustumf
-#undef glFrustumfOES
-#undef glFrustumx
-#undef glFrustumxOES
-#undef glGenBuffers
-#undef glGenFencesNV
-#undef glGenFramebuffers
-#undef glGenFramebuffersOES
-#undef glGenPathsNV
-#undef glGenPerfMonitorsAMD
-#undef glGenProgramPipelines
-#undef glGenProgramPipelinesEXT
-#undef glGenQueries
-#undef glGenQueriesEXT
-#undef glGenRenderbuffers
-#undef glGenRenderbuffersOES
-#undef glGenSamplers
-#undef glGenTextures
-#undef glGenTransformFeedbacks
-#undef glGenVertexArrays
-#undef glGenVertexArraysOES
-#undef glGenerateMipmap
-#undef glGenerateMipmapOES
-#undef glGetActiveAttrib
-#undef glGetActiveUniform
-#undef glGetActiveUniformBlockName
-#undef glGetActiveUniformBlockiv
-#undef glGetActiveUniformsiv
-#undef glGetAttachedShaders
-#undef glGetAttribLocation
-#undef glGetBooleani_v
-#undef glGetBooleanv
-#undef glGetBufferParameteri64v
-#undef glGetBufferParameteriv
-#undef glGetBufferPointerv
-#undef glGetBufferPointervOES
-#undef glGetClipPlanef
-#undef glGetClipPlanefOES
-#undef glGetClipPlanex
-#undef glGetClipPlanexOES
-#undef glGetCoverageModulationTableNV
-#undef glGetDebugMessageLog
-#undef glGetDebugMessageLogKHR
-#undef glGetDriverControlStringQCOM
-#undef glGetDriverControlsQCOM
-#undef glGetError
-#undef glGetFenceivNV
-#undef glGetFirstPerfQueryIdINTEL
-#undef glGetFixedv
-#undef glGetFixedvOES
-#undef glGetFloati_vNV
-#undef glGetFloatv
-#undef glGetFragDataIndexEXT
-#undef glGetFragDataLocation
-#undef glGetFramebufferAttachmentParameteriv
-#undef glGetFramebufferAttachmentParameterivOES
-#undef glGetFramebufferParameteriv
-#undef glGetGraphicsResetStatus
-#undef glGetGraphicsResetStatusEXT
-#undef glGetGraphicsResetStatusKHR
-#undef glGetImageHandleNV
-#undef glGetInteger64i_v
-#undef glGetInteger64v
-#undef glGetInteger64vAPPLE
-#undef glGetIntegeri_v
-#undef glGetIntegeri_vEXT
-#undef glGetIntegerv
-#undef glGetInternalformatSampleivNV
-#undef glGetInternalformativ
-#undef glGetLightfv
-#undef glGetLightxv
-#undef glGetLightxvOES
-#undef glGetMaterialfv
-#undef glGetMaterialxv
-#undef glGetMaterialxvOES
-#undef glGetMultisamplefv
-#undef glGetNextPerfQueryIdINTEL
-#undef glGetObjectLabel
-#undef glGetObjectLabelEXT
-#undef glGetObjectLabelKHR
-#undef glGetObjectPtrLabel
-#undef glGetObjectPtrLabelKHR
-#undef glGetPathCommandsNV
-#undef glGetPathCoordsNV
-#undef glGetPathDashArrayNV
-#undef glGetPathLengthNV
-#undef glGetPathMetricRangeNV
-#undef glGetPathMetricsNV
-#undef glGetPathParameterfvNV
-#undef glGetPathParameterivNV
-#undef glGetPathSpacingNV
-#undef glGetPerfCounterInfoINTEL
-#undef glGetPerfMonitorCounterDataAMD
-#undef glGetPerfMonitorCounterInfoAMD
-#undef glGetPerfMonitorCounterStringAMD
-#undef glGetPerfMonitorCountersAMD
-#undef glGetPerfMonitorGroupStringAMD
-#undef glGetPerfMonitorGroupsAMD
-#undef glGetPerfQueryDataINTEL
-#undef glGetPerfQueryIdByNameINTEL
-#undef glGetPerfQueryInfoINTEL
-#undef glGetPointerv
-#undef glGetPointervKHR
-#undef glGetProgramBinary
-#undef glGetProgramBinaryOES
-#undef glGetProgramInfoLog
-#undef glGetProgramInterfaceiv
-#undef glGetProgramPipelineInfoLog
-#undef glGetProgramPipelineInfoLogEXT
-#undef glGetProgramPipelineiv
-#undef glGetProgramPipelineivEXT
-#undef glGetProgramResourceIndex
-#undef glGetProgramResourceLocation
-#undef glGetProgramResourceLocationIndexEXT
-#undef glGetProgramResourceName
-#undef glGetProgramResourcefvNV
-#undef glGetProgramResourceiv
-#undef glGetProgramiv
-#undef glGetQueryObjecti64vEXT
-#undef glGetQueryObjectivEXT
-#undef glGetQueryObjectui64vEXT
-#undef glGetQueryObjectuiv
-#undef glGetQueryObjectuivEXT
-#undef glGetQueryiv
-#undef glGetQueryivEXT
-#undef glGetRenderbufferParameteriv
-#undef glGetRenderbufferParameterivOES
-#undef glGetSamplerParameterIiv
-#undef glGetSamplerParameterIivEXT
-#undef glGetSamplerParameterIivOES
-#undef glGetSamplerParameterIuiv
-#undef glGetSamplerParameterIuivEXT
-#undef glGetSamplerParameterIuivOES
-#undef glGetSamplerParameterfv
-#undef glGetSamplerParameteriv
-#undef glGetShaderInfoLog
-#undef glGetShaderPrecisionFormat
-#undef glGetShaderSource
-#undef glGetShaderiv
-#undef glGetString
-#undef glGetStringi
-#undef glGetSynciv
-#undef glGetSyncivAPPLE
-#undef glGetTexEnvfv
-#undef glGetTexEnviv
-#undef glGetTexEnvxv
-#undef glGetTexEnvxvOES
-#undef glGetTexGenfvOES
-#undef glGetTexGenivOES
-#undef glGetTexGenxvOES
-#undef glGetTexLevelParameterfv
-#undef glGetTexLevelParameteriv
-#undef glGetTexParameterIiv
-#undef glGetTexParameterIivEXT
-#undef glGetTexParameterIivOES
-#undef glGetTexParameterIuiv
-#undef glGetTexParameterIuivEXT
-#undef glGetTexParameterIuivOES
-#undef glGetTexParameterfv
-#undef glGetTexParameteriv
-#undef glGetTexParameterxv
-#undef glGetTexParameterxvOES
-#undef glGetTextureHandleNV
-#undef glGetTextureSamplerHandleNV
-#undef glGetTransformFeedbackVarying
-#undef glGetTranslatedShaderSourceANGLE
-#undef glGetUniformBlockIndex
-#undef glGetUniformIndices
-#undef glGetUniformLocation
-#undef glGetUniformfv
-#undef glGetUniformiv
-#undef glGetUniformuiv
-#undef glGetVertexAttribIiv
-#undef glGetVertexAttribIuiv
-#undef glGetVertexAttribPointerv
-#undef glGetVertexAttribfv
-#undef glGetVertexAttribiv
-#undef glGetnUniformfv
-#undef glGetnUniformfvEXT
-#undef glGetnUniformfvKHR
-#undef glGetnUniformiv
-#undef glGetnUniformivEXT
-#undef glGetnUniformivKHR
-#undef glGetnUniformuiv
-#undef glGetnUniformuivKHR
-#undef glHint
-#undef glInsertEventMarkerEXT
-#undef glInterpolatePathsNV
-#undef glInvalidateFramebuffer
-#undef glInvalidateSubFramebuffer
-#undef glIsBuffer
-#undef glIsEnabled
-#undef glIsEnabledi
-#undef glIsEnablediEXT
-#undef glIsEnablediNV
-#undef glIsEnablediOES
-#undef glIsFenceNV
-#undef glIsFramebuffer
-#undef glIsFramebufferOES
-#undef glIsImageHandleResidentNV
-#undef glIsPathNV
-#undef glIsPointInFillPathNV
-#undef glIsPointInStrokePathNV
-#undef glIsProgram
-#undef glIsProgramPipeline
-#undef glIsProgramPipelineEXT
-#undef glIsQuery
-#undef glIsQueryEXT
-#undef glIsRenderbuffer
-#undef glIsRenderbufferOES
-#undef glIsSampler
-#undef glIsShader
-#undef glIsSync
-#undef glIsSyncAPPLE
-#undef glIsTexture
-#undef glIsTextureHandleResidentNV
-#undef glIsTransformFeedback
-#undef glIsVertexArray
-#undef glIsVertexArrayOES
-#undef glLabelObjectEXT
-#undef glLightModelf
-#undef glLightModelfv
-#undef glLightModelx
-#undef glLightModelxOES
-#undef glLightModelxv
-#undef glLightModelxvOES
-#undef glLightf
-#undef glLightfv
-#undef glLightx
-#undef glLightxOES
-#undef glLightxv
-#undef glLightxvOES
-#undef glLineWidth
-#undef glLineWidthx
-#undef glLineWidthxOES
-#undef glLinkProgram
-#undef glLoadIdentity
-#undef glLoadMatrixf
-#undef glLoadMatrixx
-#undef glLoadMatrixxOES
-#undef glLoadPaletteFromModelViewMatrixOES
-#undef glLogicOp
-#undef glMakeImageHandleNonResidentNV
-#undef glMakeImageHandleResidentNV
-#undef glMakeTextureHandleNonResidentNV
-#undef glMakeTextureHandleResidentNV
-#undef glMapBufferOES
-#undef glMapBufferRange
-#undef glMapBufferRangeEXT
-#undef glMaterialf
-#undef glMaterialfv
-#undef glMaterialx
-#undef glMaterialxOES
-#undef glMaterialxv
-#undef glMaterialxvOES
-#undef glMatrixIndexPointerOES
-#undef glMatrixLoad3x2fNV
-#undef glMatrixLoad3x3fNV
-#undef glMatrixLoadTranspose3x3fNV
-#undef glMatrixMode
-#undef glMatrixMult3x2fNV
-#undef glMatrixMult3x3fNV
-#undef glMatrixMultTranspose3x3fNV
-#undef glMemoryBarrier
-#undef glMemoryBarrierByRegion
-#undef glMinSampleShading
-#undef glMinSampleShadingOES
-#undef glMultMatrixf
-#undef glMultMatrixx
-#undef glMultMatrixxOES
-#undef glMultiDrawArraysEXT
-#undef glMultiDrawArraysIndirectEXT
-#undef glMultiDrawElementsBaseVertexEXT
-#undef glMultiDrawElementsBaseVertexOES
-#undef glMultiDrawElementsEXT
-#undef glMultiDrawElementsIndirectEXT
-#undef glMultiTexCoord4f
-#undef glMultiTexCoord4x
-#undef glMultiTexCoord4xOES
-#undef glNamedFramebufferSampleLocationsfvNV
-#undef glNormal3f
-#undef glNormal3x
-#undef glNormal3xOES
-#undef glNormalPointer
-#undef glObjectLabel
-#undef glObjectLabelKHR
-#undef glObjectPtrLabel
-#undef glObjectPtrLabelKHR
-#undef glOrthof
-#undef glOrthofOES
-#undef glOrthox
-#undef glOrthoxOES
-#undef glPatchParameteri
-#undef glPatchParameteriEXT
-#undef glPatchParameteriOES
-#undef glPathCommandsNV
-#undef glPathCoordsNV
-#undef glPathCoverDepthFuncNV
-#undef glPathDashArrayNV
-#undef glPathGlyphIndexArrayNV
-#undef glPathGlyphIndexRangeNV
-#undef glPathGlyphRangeNV
-#undef glPathGlyphsNV
-#undef glPathMemoryGlyphIndexArrayNV
-#undef glPathParameterfNV
-#undef glPathParameterfvNV
-#undef glPathParameteriNV
-#undef glPathParameterivNV
-#undef glPathStencilDepthOffsetNV
-#undef glPathStencilFuncNV
-#undef glPathStringNV
-#undef glPathSubCommandsNV
-#undef glPathSubCoordsNV
-#undef glPauseTransformFeedback
-#undef glPixelStorei
-#undef glPointAlongPathNV
-#undef glPointParameterf
-#undef glPointParameterfv
-#undef glPointParameterx
-#undef glPointParameterxOES
-#undef glPointParameterxv
-#undef glPointParameterxvOES
-#undef glPointSize
-#undef glPointSizePointerOES
-#undef glPointSizex
-#undef glPointSizexOES
-#undef glPolygonModeNV
-#undef glPolygonOffset
-#undef glPolygonOffsetx
-#undef glPolygonOffsetxOES
-#undef glPopDebugGroup
-#undef glPopDebugGroupKHR
-#undef glPopGroupMarkerEXT
-#undef glPopMatrix
-#undef glPrimitiveBoundingBox
-#undef glPrimitiveBoundingBoxEXT
-#undef glPrimitiveBoundingBoxOES
-#undef glProgramBinary
-#undef glProgramBinaryOES
-#undef glProgramParameteri
-#undef glProgramParameteriEXT
-#undef glProgramPathFragmentInputGenNV
-#undef glProgramUniform1f
-#undef glProgramUniform1fEXT
-#undef glProgramUniform1fv
-#undef glProgramUniform1fvEXT
-#undef glProgramUniform1i
-#undef glProgramUniform1iEXT
-#undef glProgramUniform1iv
-#undef glProgramUniform1ivEXT
-#undef glProgramUniform1ui
-#undef glProgramUniform1uiEXT
-#undef glProgramUniform1uiv
-#undef glProgramUniform1uivEXT
-#undef glProgramUniform2f
-#undef glProgramUniform2fEXT
-#undef glProgramUniform2fv
-#undef glProgramUniform2fvEXT
-#undef glProgramUniform2i
-#undef glProgramUniform2iEXT
-#undef glProgramUniform2iv
-#undef glProgramUniform2ivEXT
-#undef glProgramUniform2ui
-#undef glProgramUniform2uiEXT
-#undef glProgramUniform2uiv
-#undef glProgramUniform2uivEXT
-#undef glProgramUniform3f
-#undef glProgramUniform3fEXT
-#undef glProgramUniform3fv
-#undef glProgramUniform3fvEXT
-#undef glProgramUniform3i
-#undef glProgramUniform3iEXT
-#undef glProgramUniform3iv
-#undef glProgramUniform3ivEXT
-#undef glProgramUniform3ui
-#undef glProgramUniform3uiEXT
-#undef glProgramUniform3uiv
-#undef glProgramUniform3uivEXT
-#undef glProgramUniform4f
-#undef glProgramUniform4fEXT
-#undef glProgramUniform4fv
-#undef glProgramUniform4fvEXT
-#undef glProgramUniform4i
-#undef glProgramUniform4iEXT
-#undef glProgramUniform4iv
-#undef glProgramUniform4ivEXT
-#undef glProgramUniform4ui
-#undef glProgramUniform4uiEXT
-#undef glProgramUniform4uiv
-#undef glProgramUniform4uivEXT
-#undef glProgramUniformHandleui64NV
-#undef glProgramUniformHandleui64vNV
-#undef glProgramUniformMatrix2fv
-#undef glProgramUniformMatrix2fvEXT
-#undef glProgramUniformMatrix2x3fv
-#undef glProgramUniformMatrix2x3fvEXT
-#undef glProgramUniformMatrix2x4fv
-#undef glProgramUniformMatrix2x4fvEXT
-#undef glProgramUniformMatrix3fv
-#undef glProgramUniformMatrix3fvEXT
-#undef glProgramUniformMatrix3x2fv
-#undef glProgramUniformMatrix3x2fvEXT
-#undef glProgramUniformMatrix3x4fv
-#undef glProgramUniformMatrix3x4fvEXT
-#undef glProgramUniformMatrix4fv
-#undef glProgramUniformMatrix4fvEXT
-#undef glProgramUniformMatrix4x2fv
-#undef glProgramUniformMatrix4x2fvEXT
-#undef glProgramUniformMatrix4x3fv
-#undef glProgramUniformMatrix4x3fvEXT
-#undef glPushDebugGroup
-#undef glPushDebugGroupKHR
-#undef glPushGroupMarkerEXT
-#undef glPushMatrix
-#undef glQueryCounterEXT
-#undef glQueryMatrixxOES
-#undef glRasterSamplesEXT
-#undef glReadBuffer
-#undef glReadBufferIndexedEXT
-#undef glReadBufferNV
-#undef glReadPixels
-#undef glReadnPixels
-#undef glReadnPixelsEXT
-#undef glReadnPixelsKHR
-#undef glReleaseShaderCompiler
-#undef glRenderbufferStorage
-#undef glRenderbufferStorageMultisample
-#undef glRenderbufferStorageMultisampleANGLE
-#undef glRenderbufferStorageMultisampleAPPLE
-#undef glRenderbufferStorageMultisampleEXT
-#undef glRenderbufferStorageMultisampleIMG
-#undef glRenderbufferStorageMultisampleNV
-#undef glRenderbufferStorageOES
-#undef glResolveDepthValuesNV
-#undef glResolveMultisampleFramebufferAPPLE
-#undef glResumeTransformFeedback
-#undef glRotatef
-#undef glRotatex
-#undef glRotatexOES
-#undef glSampleCoverage
-#undef glSampleCoveragex
-#undef glSampleCoveragexOES
-#undef glSampleMaski
-#undef glSamplerParameterIiv
-#undef glSamplerParameterIivEXT
-#undef glSamplerParameterIivOES
-#undef glSamplerParameterIuiv
-#undef glSamplerParameterIuivEXT
-#undef glSamplerParameterIuivOES
-#undef glSamplerParameterf
-#undef glSamplerParameterfv
-#undef glSamplerParameteri
-#undef glSamplerParameteriv
-#undef glScalef
-#undef glScalex
-#undef glScalexOES
-#undef glScissor
-#undef glScissorArrayvNV
-#undef glScissorIndexedNV
-#undef glScissorIndexedvNV
-#undef glSelectPerfMonitorCountersAMD
-#undef glSetFenceNV
-#undef glShadeModel
-#undef glShaderBinary
-#undef glShaderSource
-#undef glStartTilingQCOM
-#undef glStencilFillPathInstancedNV
-#undef glStencilFillPathNV
-#undef glStencilFunc
-#undef glStencilFuncSeparate
-#undef glStencilMask
-#undef glStencilMaskSeparate
-#undef glStencilOp
-#undef glStencilOpSeparate
-#undef glStencilStrokePathInstancedNV
-#undef glStencilStrokePathNV
-#undef glStencilThenCoverFillPathInstancedNV
-#undef glStencilThenCoverFillPathNV
-#undef glStencilThenCoverStrokePathInstancedNV
-#undef glStencilThenCoverStrokePathNV
-#undef glSubpixelPrecisionBiasNV
-#undef glTestFenceNV
-#undef glTexBuffer
-#undef glTexBufferEXT
-#undef glTexBufferOES
-#undef glTexBufferRange
-#undef glTexBufferRangeEXT
-#undef glTexBufferRangeOES
-#undef glTexCoordPointer
-#undef glTexEnvf
-#undef glTexEnvfv
-#undef glTexEnvi
-#undef glTexEnviv
-#undef glTexEnvx
-#undef glTexEnvxOES
-#undef glTexEnvxv
-#undef glTexEnvxvOES
-#undef glTexGenfOES
-#undef glTexGenfvOES
-#undef glTexGeniOES
-#undef glTexGenivOES
-#undef glTexGenxOES
-#undef glTexGenxvOES
-#undef glTexImage2D
-#undef glTexImage3D
-#undef glTexImage3DOES
-#undef glTexPageCommitmentEXT
-#undef glTexParameterIiv
-#undef glTexParameterIivEXT
-#undef glTexParameterIivOES
-#undef glTexParameterIuiv
-#undef glTexParameterIuivEXT
-#undef glTexParameterIuivOES
-#undef glTexParameterf
-#undef glTexParameterfv
-#undef glTexParameteri
-#undef glTexParameteriv
-#undef glTexParameterx
-#undef glTexParameterxOES
-#undef glTexParameterxv
-#undef glTexParameterxvOES
-#undef glTexStorage1DEXT
-#undef glTexStorage2D
-#undef glTexStorage2DEXT
-#undef glTexStorage2DMultisample
-#undef glTexStorage3D
-#undef glTexStorage3DEXT
-#undef glTexStorage3DMultisample
-#undef glTexStorage3DMultisampleOES
-#undef glTexSubImage2D
-#undef glTexSubImage3D
-#undef glTexSubImage3DOES
-#undef glTextureStorage1DEXT
-#undef glTextureStorage2DEXT
-#undef glTextureStorage3DEXT
-#undef glTextureViewEXT
-#undef glTextureViewOES
-#undef glTransformFeedbackVaryings
-#undef glTransformPathNV
-#undef glTranslatef
-#undef glTranslatex
-#undef glTranslatexOES
-#undef glUniform1f
-#undef glUniform1fv
-#undef glUniform1i
-#undef glUniform1iv
-#undef glUniform1ui
-#undef glUniform1uiv
-#undef glUniform2f
-#undef glUniform2fv
-#undef glUniform2i
-#undef glUniform2iv
-#undef glUniform2ui
-#undef glUniform2uiv
-#undef glUniform3f
-#undef glUniform3fv
-#undef glUniform3i
-#undef glUniform3iv
-#undef glUniform3ui
-#undef glUniform3uiv
-#undef glUniform4f
-#undef glUniform4fv
-#undef glUniform4i
-#undef glUniform4iv
-#undef glUniform4ui
-#undef glUniform4uiv
-#undef glUniformBlockBinding
-#undef glUniformHandleui64NV
-#undef glUniformHandleui64vNV
-#undef glUniformMatrix2fv
-#undef glUniformMatrix2x3fv
-#undef glUniformMatrix2x3fvNV
-#undef glUniformMatrix2x4fv
-#undef glUniformMatrix2x4fvNV
-#undef glUniformMatrix3fv
-#undef glUniformMatrix3x2fv
-#undef glUniformMatrix3x2fvNV
-#undef glUniformMatrix3x4fv
-#undef glUniformMatrix3x4fvNV
-#undef glUniformMatrix4fv
-#undef glUniformMatrix4x2fv
-#undef glUniformMatrix4x2fvNV
-#undef glUniformMatrix4x3fv
-#undef glUniformMatrix4x3fvNV
-#undef glUnmapBuffer
-#undef glUnmapBufferOES
-#undef glUseProgram
-#undef glUseProgramStages
-#undef glUseProgramStagesEXT
-#undef glValidateProgram
-#undef glValidateProgramPipeline
-#undef glValidateProgramPipelineEXT
-#undef glVertexAttrib1f
-#undef glVertexAttrib1fv
-#undef glVertexAttrib2f
-#undef glVertexAttrib2fv
-#undef glVertexAttrib3f
-#undef glVertexAttrib3fv
-#undef glVertexAttrib4f
-#undef glVertexAttrib4fv
-#undef glVertexAttribBinding
-#undef glVertexAttribDivisor
-#undef glVertexAttribDivisorANGLE
-#undef glVertexAttribDivisorEXT
-#undef glVertexAttribDivisorNV
-#undef glVertexAttribFormat
-#undef glVertexAttribI4i
-#undef glVertexAttribI4iv
-#undef glVertexAttribI4ui
-#undef glVertexAttribI4uiv
-#undef glVertexAttribIFormat
-#undef glVertexAttribIPointer
-#undef glVertexAttribPointer
-#undef glVertexBindingDivisor
-#undef glVertexPointer
-#undef glViewport
-#undef glViewportArrayvNV
-#undef glViewportIndexedfNV
-#undef glViewportIndexedfvNV
-#undef glWaitSync
-#undef glWaitSyncAPPLE
-#undef glWeightPathsNV
-#undef glWeightPointerOES
diff --git a/libs/hwui/debug/nullegl.cpp b/libs/hwui/debug/nullegl.cpp
deleted file mode 100644
index ca47f8f..0000000
--- a/libs/hwui/debug/nullegl.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include <pthread.h>
-#include <stdlib.h>
-#include <string.h>
-
-static EGLDisplay gDisplay = (EGLDisplay)1;
-static EGLSyncKHR gFence = (EGLSyncKHR)1;
-
-typedef struct {
-    EGLSurface surface;
-    EGLContext context;
-} ThreadState;
-
-static pthread_key_t ThreadStateKey;
-static pthread_once_t ThreadStateSetupOnce = PTHREAD_ONCE_INIT;
-
-static void destroyThreadState(void* state) {
-    free(state);
-}
-
-static void makeThreadState() {
-    pthread_key_create(&ThreadStateKey, destroyThreadState);
-}
-
-ThreadState* getThreadState() {
-    ThreadState* ptr;
-    pthread_once(&ThreadStateSetupOnce, makeThreadState);
-    if ((ptr = (ThreadState*)pthread_getspecific(ThreadStateKey)) == NULL) {
-        ptr = (ThreadState*)calloc(1, sizeof(ThreadState));
-        ptr->context = EGL_NO_CONTEXT;
-        ptr->surface = EGL_NO_SURFACE;
-        pthread_setspecific(ThreadStateKey, ptr);
-    }
-    return ptr;
-}
-
-EGLint eglGetError(void) {
-    return EGL_SUCCESS;
-}
-
-EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) {
-    return gDisplay;
-}
-
-EGLBoolean eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
-    return EGL_TRUE;
-}
-
-EGLBoolean eglTerminate(EGLDisplay dpy) {
-    return EGL_TRUE;
-}
-
-const char* eglQueryString(EGLDisplay dpy, EGLint name) {
-    if (name == EGL_EXTENSIONS) {
-        return "EGL_KHR_swap_buffers_with_damage";
-    }
-    return "";
-}
-
-EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs,
-                           EGLint config_size, EGLint* num_config) {
-    memset(configs, 9, sizeof(EGLConfig) * config_size);
-    *num_config = config_size;
-    return EGL_TRUE;
-}
-
-EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win,
-                                  const EGLint* attrib_list) {
-    return (EGLSurface)malloc(sizeof(void*));
-}
-
-EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list) {
-    return (EGLSurface)malloc(sizeof(void*));
-}
-
-EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) {
-    free(surface);
-    return EGL_TRUE;
-}
-
-EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value) {
-    *value = 1000;
-    return EGL_TRUE;
-}
-
-EGLBoolean eglReleaseThread(void) {
-    return EGL_TRUE;
-}
-
-EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) {
-    return EGL_TRUE;
-}
-
-EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) {
-    return EGL_TRUE;
-}
-
-EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context,
-                            const EGLint* attrib_list) {
-    return (EGLContext)malloc(sizeof(void*));
-}
-EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) {
-    free(ctx);
-    return EGL_TRUE;
-}
-
-EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) {
-    ThreadState* state = getThreadState();
-    state->surface = draw;
-    state->context = ctx;
-    return EGL_TRUE;
-}
-
-EGLContext eglGetCurrentContext(void) {
-    return getThreadState()->context;
-}
-
-EGLSurface eglGetCurrentSurface(EGLint readdraw) {
-    return getThreadState()->surface;
-}
-
-EGLDisplay eglGetCurrentDisplay(void) {
-    return gDisplay;
-}
-
-EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) {
-    return EGL_TRUE;
-}
-
-EGLBoolean eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects,
-                                       EGLint rectCount) {
-    return EGL_TRUE;
-}
-
-EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
-                              EGLClientBuffer buffer, const EGLint* attrib_list) {
-    return (EGLImageKHR)malloc(sizeof(EGLImageKHR));
-}
-
-EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list) {
-    return gFence;
-}
-
-EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
-    return EGL_TRUE;
-}
-
-EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) {
-    return EGL_CONDITION_SATISFIED_KHR;
-}
-
-EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) {
-    free(image);
-    return EGL_TRUE;
-}
-
-void eglBeginFrame(EGLDisplay dpy, EGLSurface surface) {}
diff --git a/libs/hwui/debug/wrap_gles.cpp b/libs/hwui/debug/wrap_gles.cpp
deleted file mode 100644
index 8dc946e..0000000
--- a/libs/hwui/debug/wrap_gles.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "GlesDriver.h"
-
-using namespace android::uirenderer::debug;
-
-#undef API_ENTRY
-#undef CALL_GL_API
-#undef CALL_GL_API_RETURN
-
-#define API_ENTRY(x) x
-#define CALL_GL_API(api, ...) GlesDriver::get()->api##_(__VA_ARGS__)
-#define CALL_GL_API_RETURN(api, ...) return GlesDriver::get()->api##_(__VA_ARGS__)
-
-#include "gles_stubs.in"
-
-#undef API_ENTRY
-#undef CALL_GL_API
-#undef CALL_GL_API_RETURN
diff --git a/libs/hwui/debug/wrap_gles.h b/libs/hwui/debug/wrap_gles.h
deleted file mode 100644
index 3da6e80..0000000
--- a/libs/hwui/debug/wrap_gles.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// #include'ing this file is bad, bad things should be compile errors
-#ifdef HWUI_GLES_WRAP_ENABLED
-#error wrap_gles.h should only be used as an auto-included header, don't directly #include it
-#endif
-#define HWUI_GLES_WRAP_ENABLED
-
-#include <GLES/gl.h>
-#include <GLES/glext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <GLES3/gl3.h>
-#include <GLES3/gl31.h>
-#include <GLES3/gl32.h>
-
-// constant used by the NULL GPU implementation as well as HWUI's unit tests
-constexpr int NULL_GPU_MAX_TEXTURE_SIZE = 2048;
-
-// Generate stubs that route all the calls to our function table
-#include "gles_redefine.h"
-
-#define GL_ENTRY(ret, api, ...) ret api(__VA_ARGS__);
-
-#include "gles_decls.in"
-#undef GL_ENTRY
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index 41cb8fd..0c5599e 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -31,10 +31,6 @@
 #include "utils/TimeUtils.h"
 #include "utils/TraceUtils.h"
 
-#ifdef HWUI_GLES_WRAP_ENABLED
-#include "debug/GlesDriver.h"
-#endif
-
 #include <GrContextOptions.h>
 #include <gl/GrGLInterface.h>
 
@@ -197,12 +193,7 @@
     }
     mEglManager->initialize();
 
-#ifdef HWUI_GLES_WRAP_ENABLED
-    debug::GlesDriver* driver = debug::GlesDriver::get();
-    sk_sp<const GrGLInterface> glInterface(driver->getSkiaInterface());
-#else
     sk_sp<const GrGLInterface> glInterface(GrGLCreateNativeInterface());
-#endif
     LOG_ALWAYS_FATAL_IF(!glInterface.get());
 
     GrContextOptions options;
diff --git a/libs/hwui/tests/microbench/main.cpp b/libs/hwui/tests/microbench/main.cpp
index b5abf5b..9c4d2596 100644
--- a/libs/hwui/tests/microbench/main.cpp
+++ b/libs/hwui/tests/microbench/main.cpp
@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-#include "debug/GlesDriver.h"
-#include "debug/NullGlesDriver.h"
-
 #include "hwui/Typeface.h"
 
 #include <benchmark/benchmark.h>
@@ -24,10 +21,8 @@
 #include <memory>
 
 using namespace android;
-using namespace android::uirenderer;
 
 int main(int argc, char** argv) {
-    debug::GlesDriver::replace(std::make_unique<debug::NullGlesDriver>());
     benchmark::Initialize(&argc, argv);
     Typeface::setRobotoTypefaceForTest();
     benchmark::RunSpecifiedBenchmarks();
diff --git a/libs/hwui/tests/unit/SkiaPipelineTests.cpp b/libs/hwui/tests/unit/SkiaPipelineTests.cpp
index a671bda..7b76bd8 100644
--- a/libs/hwui/tests/unit/SkiaPipelineTests.cpp
+++ b/libs/hwui/tests/unit/SkiaPipelineTests.cpp
@@ -29,6 +29,7 @@
 #include "pipeline/skia/SkiaRecordingCanvas.h"
 #include "pipeline/skia/SkiaUtils.h"
 #include "renderthread/CanvasContext.h"
+#include "tests/common/TestContext.h"
 #include "tests/common/TestUtils.h"
 
 #include <gui/BufferItemConsumer.h>
@@ -424,17 +425,9 @@
     EXPECT_EQ(1, surface->canvas()->mDrawCounter);
 }
 
-static sp<Surface> createDummySurface() {
-    sp<IGraphicBufferProducer> producer;
-    sp<IGraphicBufferConsumer> consumer;
-    BufferQueue::createBufferQueue(&producer, &consumer);
-    producer->setMaxDequeuedBufferCount(1);
-    producer->setAsyncMode(true);
-    return new Surface(producer);
-}
-
 RENDERTHREAD_SKIA_PIPELINE_TEST(SkiaPipeline, context_lost) {
-    auto surface = createDummySurface();
+    test::TestContext context;
+    auto surface = context.surface();
     auto pipeline = std::make_unique<SkiaOpenGLPipeline>(renderThread);
     EXPECT_FALSE(pipeline->isSurfaceReady());
     EXPECT_TRUE(pipeline->setSurface(surface.get(), SwapBehavior::kSwap_default, ColorMode::SRGB, 0));
diff --git a/libs/hwui/tests/unit/main.cpp b/libs/hwui/tests/unit/main.cpp
index 83d888c..402cb58 100644
--- a/libs/hwui/tests/unit/main.cpp
+++ b/libs/hwui/tests/unit/main.cpp
@@ -18,8 +18,6 @@
 #include "gtest/gtest.h"
 
 #include "Properties.h"
-#include "debug/GlesDriver.h"
-#include "debug/NullGlesDriver.h"
 #include "hwui/Typeface.h"
 #include "tests/common/LeakChecker.h"
 
@@ -65,7 +63,6 @@
     }
 
     // Replace the default GLES driver
-    debug::GlesDriver::replace(std::make_unique<debug::NullGlesDriver>());
     Properties::isolatedProcess = true;
 
     // Run the tests
diff --git a/libs/hwui/utils/GLUtils.cpp b/libs/hwui/utils/GLUtils.cpp
index c694e93..6189762 100644
--- a/libs/hwui/utils/GLUtils.cpp
+++ b/libs/hwui/utils/GLUtils.cpp
@@ -21,19 +21,10 @@
 
 #include "GLUtils.h"
 
-#if DEBUG_OPENGL >= DEBUG_LEVEL_HIGH && !defined(HWUI_GLES_WRAP_ENABLED)
-#error Setting DEBUG_OPENGL to HIGH requires setting HWUI_ENABLE_OPENGL_VALIDATION to true in the Android.mk!
-#endif
-
 namespace android {
 namespace uirenderer {
 
 bool GLUtils::dumpGLErrors() {
-#if DEBUG_OPENGL >= DEBUG_LEVEL_HIGH
-    // If DEBUG_LEVEL_HIGH is set then every GLES call is already wrapped
-    // and asserts that there was no error. So this can just return success.
-    return false;
-#else
     bool errorObserved = false;
     GLenum status = GL_NO_ERROR;
     while ((status = glGetError()) != GL_NO_ERROR) {
@@ -56,7 +47,6 @@
         }
     }
     return errorObserved;
-#endif
 }
 
 const char* GLUtils::getGLFramebufferError() {