polyadvent

A game engine from scratch in C
git clone git://jb55.com/polyadvent
Log | Files | Refs | README
commit 69e6213e73924e4061b72cf343572a082dd7588a
parent 6291496d8715522922309ca13746ff212a4452c3
Author: William Casarin <jb55@jb55.com>
Date:   Fri,  6 Aug 2021 12:51:55 -0700

dlopen gl metaloader

Signed-off-by: William Casarin <jb55@jb55.com>

Diffstat:

Msrc/geometry.c | 11-----------


Asrc/gl.c | 2129+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


Msrc/gl.h | 2413+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----


3 files changed, 4432 insertions(+), 121 deletions(-)

diff --git a/src/geometry.c b/src/geometry.c
@@ -41,22 +41,11 @@ void bind_geometry(struct geometry *geom, gpu_addr *vertex_attrs) {
     }
 }
 
-static void check_for_patches(struct gpu_program *program, int *type) {
-    int has_tess_shader =
-        get_program_shader(program, GL_TESS_EVALUATION_SHADER) != NULL;
-
-    if (has_tess_shader) {
-        glPatchParameteri(GL_PATCH_VERTICES, 3);
-        *type = GL_PATCHES;
-    }
-}
-
 
 void render_geometry(struct geometry *geom, gpu_addr *vertex_attrs,
                      struct gpu_program *program)
 {
     int type = GL_TRIANGLES;
-    //check_for_patches(program, &type);
     bind_geometry(geom, vertex_attrs);
     if (geom->num_indices) {
         glDrawElements(type,
diff --git a/src/gl.c b/src/gl.c
@@ -0,0 +1,2129 @@
+#include "gl.h"
+/* This file was auto-generated by Galogen */
+#include <assert.h>
+#if defined(_WIN32)
+void* GalogenGetProcAddress(const char *name) {
+  static HMODULE opengl32module = NULL;
+  static PROC(WINAPI *wgl_get_proc_address)(LPCSTR name) = NULL;
+  if (!wgl_get_proc_address) {
+    if (!opengl32module) {
+      opengl32module = LoadLibraryA("opengl32.dll");
+    }
+    wgl_get_proc_address = (PROC(WINAPI*)(LPCSTR))GetProcAddress(opengl32module, "wglGetProcAddress");
+    assert(wgl_get_proc_address);
+  }
+  void *ptr = (void *)wgl_get_proc_address(name);
+  if(ptr == 0 || (ptr == (void*)1) || (ptr == (void*)2) || (ptr == (void*)3) ||
+     (ptr == (void*)-1) ) {
+    if (opengl32module == NULL) {
+      opengl32module = LoadLibraryA("opengl32.dll");
+      assert(opengl32module);
+    }
+    ptr = (void *)GetProcAddress(opengl32module, name);
+  }
+  return ptr;
+}
+
+#elif defined(__APPLE__)
+#include <dlfcn.h>
+
+static void* GalogenGetProcAddress (const char *name)
+{
+  static void* lib = NULL;
+  if (NULL == lib)
+    lib = dlopen(
+      "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL",
+      RTLD_LAZY);
+  return lib ? dlsym(lib, name) : NULL;
+}
+#elif defined(__ANDROID__)
+#include <dlfcn.h>
+#if GALOGEN_API_VER_MAJ == 3
+#define GALOGEN_GLES_LIB "libGLESv3.so"
+#elif GALOGEN_API_VER_MAJ == 2
+#define GALOGEN_GLES_LIB "libGLESv2.so"
+#else
+#define GALOGEN_GLES_LIB "libGLESv1_CM.so"
+#endif
+static void* GalogenGetProcAddress(const char *name)
+{
+  static void* lib = NULL;
+  if (NULL == lib) {
+    lib = dlopen(GALOGEN_GLES_LIB, RTLD_LAZY);
+    assert(lib);
+  }
+  return lib ? dlsym(lib, name) : NULL;
+}
+
+#else
+
+#include <GL/glx.h>
+#define GalogenGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
+
+#endif
+
+
+static void  GL_APIENTRY _impl_glVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
+  _glptr_glVertexAttribP4uiv = (PFN_glVertexAttribP4uiv)GalogenGetProcAddress("glVertexAttribP4uiv");
+   _glptr_glVertexAttribP4uiv(index, type, normalized, value);
+}
+PFN_glVertexAttribP4uiv _glptr_glVertexAttribP4uiv = _impl_glVertexAttribP4uiv;
+
+static void  GL_APIENTRY _impl_glVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
+  _glptr_glVertexAttribP3uiv = (PFN_glVertexAttribP3uiv)GalogenGetProcAddress("glVertexAttribP3uiv");
+   _glptr_glVertexAttribP3uiv(index, type, normalized, value);
+}
+PFN_glVertexAttribP3uiv _glptr_glVertexAttribP3uiv = _impl_glVertexAttribP3uiv;
+
+static void  GL_APIENTRY _impl_glVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
+  _glptr_glVertexAttribP2uiv = (PFN_glVertexAttribP2uiv)GalogenGetProcAddress("glVertexAttribP2uiv");
+   _glptr_glVertexAttribP2uiv(index, type, normalized, value);
+}
+PFN_glVertexAttribP2uiv _glptr_glVertexAttribP2uiv = _impl_glVertexAttribP2uiv;
+
+static void  GL_APIENTRY _impl_glVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
+  _glptr_glVertexAttribP2ui = (PFN_glVertexAttribP2ui)GalogenGetProcAddress("glVertexAttribP2ui");
+   _glptr_glVertexAttribP2ui(index, type, normalized, value);
+}
+PFN_glVertexAttribP2ui _glptr_glVertexAttribP2ui = _impl_glVertexAttribP2ui;
+
+static void  GL_APIENTRY _impl_glVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
+  _glptr_glVertexAttribP1uiv = (PFN_glVertexAttribP1uiv)GalogenGetProcAddress("glVertexAttribP1uiv");
+   _glptr_glVertexAttribP1uiv(index, type, normalized, value);
+}
+PFN_glVertexAttribP1uiv _glptr_glVertexAttribP1uiv = _impl_glVertexAttribP1uiv;
+
+static void  GL_APIENTRY _impl_glGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 * params) {
+  _glptr_glGetQueryObjectui64v = (PFN_glGetQueryObjectui64v)GalogenGetProcAddress("glGetQueryObjectui64v");
+   _glptr_glGetQueryObjectui64v(id, pname, params);
+}
+PFN_glGetQueryObjectui64v _glptr_glGetQueryObjectui64v = _impl_glGetQueryObjectui64v;
+
+static void  GL_APIENTRY _impl_glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat * params) {
+  _glptr_glGetSamplerParameterfv = (PFN_glGetSamplerParameterfv)GalogenGetProcAddress("glGetSamplerParameterfv");
+   _glptr_glGetSamplerParameterfv(sampler, pname, params);
+}
+PFN_glGetSamplerParameterfv _glptr_glGetSamplerParameterfv = _impl_glGetSamplerParameterfv;
+
+static void  GL_APIENTRY _impl_glSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint * param) {
+  _glptr_glSamplerParameterIuiv = (PFN_glSamplerParameterIuiv)GalogenGetProcAddress("glSamplerParameterIuiv");
+   _glptr_glSamplerParameterIuiv(sampler, pname, param);
+}
+PFN_glSamplerParameterIuiv _glptr_glSamplerParameterIuiv = _impl_glSamplerParameterIuiv;
+
+static void  GL_APIENTRY _impl_glSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat * param) {
+  _glptr_glSamplerParameterfv = (PFN_glSamplerParameterfv)GalogenGetProcAddress("glSamplerParameterfv");
+   _glptr_glSamplerParameterfv(sampler, pname, param);
+}
+PFN_glSamplerParameterfv _glptr_glSamplerParameterfv = _impl_glSamplerParameterfv;
+
+static void  GL_APIENTRY _impl_glSamplerParameteriv (GLuint sampler, GLenum pname, const GLint * param) {
+  _glptr_glSamplerParameteriv = (PFN_glSamplerParameteriv)GalogenGetProcAddress("glSamplerParameteriv");
+   _glptr_glSamplerParameteriv(sampler, pname, param);
+}
+PFN_glSamplerParameteriv _glptr_glSamplerParameteriv = _impl_glSamplerParameteriv;
+
+static void  GL_APIENTRY _impl_glSamplerParameteri (GLuint sampler, GLenum pname, GLint param) {
+  _glptr_glSamplerParameteri = (PFN_glSamplerParameteri)GalogenGetProcAddress("glSamplerParameteri");
+   _glptr_glSamplerParameteri(sampler, pname, param);
+}
+PFN_glSamplerParameteri _glptr_glSamplerParameteri = _impl_glSamplerParameteri;
+
+static void  GL_APIENTRY _impl_glBindSampler (GLuint unit, GLuint sampler) {
+  _glptr_glBindSampler = (PFN_glBindSampler)GalogenGetProcAddress("glBindSampler");
+   _glptr_glBindSampler(unit, sampler);
+}
+PFN_glBindSampler _glptr_glBindSampler = _impl_glBindSampler;
+
+static void  GL_APIENTRY _impl_glSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param) {
+  _glptr_glSamplerParameterf = (PFN_glSamplerParameterf)GalogenGetProcAddress("glSamplerParameterf");
+   _glptr_glSamplerParameterf(sampler, pname, param);
+}
+PFN_glSamplerParameterf _glptr_glSamplerParameterf = _impl_glSamplerParameterf;
+
+static GLboolean GL_APIENTRY _impl_glIsSampler (GLuint sampler) {
+  _glptr_glIsSampler = (PFN_glIsSampler)GalogenGetProcAddress("glIsSampler");
+  return _glptr_glIsSampler(sampler);
+}
+PFN_glIsSampler _glptr_glIsSampler = _impl_glIsSampler;
+
+static void  GL_APIENTRY _impl_glGenSamplers (GLsizei count, GLuint * samplers) {
+  _glptr_glGenSamplers = (PFN_glGenSamplers)GalogenGetProcAddress("glGenSamplers");
+   _glptr_glGenSamplers(count, samplers);
+}
+PFN_glGenSamplers _glptr_glGenSamplers = _impl_glGenSamplers;
+
+static void  GL_APIENTRY _impl_glBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name) {
+  _glptr_glBindFragDataLocationIndexed = (PFN_glBindFragDataLocationIndexed)GalogenGetProcAddress("glBindFragDataLocationIndexed");
+   _glptr_glBindFragDataLocationIndexed(program, colorNumber, index, name);
+}
+PFN_glBindFragDataLocationIndexed _glptr_glBindFragDataLocationIndexed = _impl_glBindFragDataLocationIndexed;
+
+static void  GL_APIENTRY _impl_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat * val) {
+  _glptr_glGetMultisamplefv = (PFN_glGetMultisamplefv)GalogenGetProcAddress("glGetMultisamplefv");
+   _glptr_glGetMultisamplefv(pname, index, val);
+}
+PFN_glGetMultisamplefv _glptr_glGetMultisamplefv = _impl_glGetMultisamplefv;
+
+static void  GL_APIENTRY _impl_glTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
+  _glptr_glTexImage3DMultisample = (PFN_glTexImage3DMultisample)GalogenGetProcAddress("glTexImage3DMultisample");
+   _glptr_glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+}
+PFN_glTexImage3DMultisample _glptr_glTexImage3DMultisample = _impl_glTexImage3DMultisample;
+
+static void  GL_APIENTRY _impl_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level) {
+  _glptr_glFramebufferTexture = (PFN_glFramebufferTexture)GalogenGetProcAddress("glFramebufferTexture");
+   _glptr_glFramebufferTexture(target, attachment, texture, level);
+}
+PFN_glFramebufferTexture _glptr_glFramebufferTexture = _impl_glFramebufferTexture;
+
+static void  GL_APIENTRY _impl_glGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 * params) {
+  _glptr_glGetBufferParameteri64v = (PFN_glGetBufferParameteri64v)GalogenGetProcAddress("glGetBufferParameteri64v");
+   _glptr_glGetBufferParameteri64v(target, pname, params);
+}
+PFN_glGetBufferParameteri64v _glptr_glGetBufferParameteri64v = _impl_glGetBufferParameteri64v;
+
+static void  GL_APIENTRY _impl_glGetInteger64i_v (GLenum target, GLuint index, GLint64 * data) {
+  _glptr_glGetInteger64i_v = (PFN_glGetInteger64i_v)GalogenGetProcAddress("glGetInteger64i_v");
+   _glptr_glGetInteger64i_v(target, index, data);
+}
+PFN_glGetInteger64i_v _glptr_glGetInteger64i_v = _impl_glGetInteger64i_v;
+
+static void  GL_APIENTRY _impl_glWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
+  _glptr_glWaitSync = (PFN_glWaitSync)GalogenGetProcAddress("glWaitSync");
+   _glptr_glWaitSync(sync, flags, timeout);
+}
+PFN_glWaitSync _glptr_glWaitSync = _impl_glWaitSync;
+
+static GLboolean GL_APIENTRY _impl_glIsSync (GLsync sync) {
+  _glptr_glIsSync = (PFN_glIsSync)GalogenGetProcAddress("glIsSync");
+  return _glptr_glIsSync(sync);
+}
+PFN_glIsSync _glptr_glIsSync = _impl_glIsSync;
+
+static GLsync GL_APIENTRY _impl_glFenceSync (GLenum condition, GLbitfield flags) {
+  _glptr_glFenceSync = (PFN_glFenceSync)GalogenGetProcAddress("glFenceSync");
+  return _glptr_glFenceSync(condition, flags);
+}
+PFN_glFenceSync _glptr_glFenceSync = _impl_glFenceSync;
+
+static void  GL_APIENTRY _impl_glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex) {
+  _glptr_glMultiDrawElementsBaseVertex = (PFN_glMultiDrawElementsBaseVertex)GalogenGetProcAddress("glMultiDrawElementsBaseVertex");
+   _glptr_glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+}
+PFN_glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex = _impl_glMultiDrawElementsBaseVertex;
+
+static void  GL_APIENTRY _impl_glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex) {
+  _glptr_glDrawElementsInstancedBaseVertex = (PFN_glDrawElementsInstancedBaseVertex)GalogenGetProcAddress("glDrawElementsInstancedBaseVertex");
+   _glptr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+}
+PFN_glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex = _impl_glDrawElementsInstancedBaseVertex;
+
+static void  GL_APIENTRY _impl_glGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) {
+  _glptr_glGetActiveUniformBlockName = (PFN_glGetActiveUniformBlockName)GalogenGetProcAddress("glGetActiveUniformBlockName");
+   _glptr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+}
+PFN_glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName = _impl_glGetActiveUniformBlockName;
+
+static GLuint GL_APIENTRY _impl_glGetUniformBlockIndex (GLuint program, const GLchar * uniformBlockName) {
+  _glptr_glGetUniformBlockIndex = (PFN_glGetUniformBlockIndex)GalogenGetProcAddress("glGetUniformBlockIndex");
+  return _glptr_glGetUniformBlockIndex(program, uniformBlockName);
+}
+PFN_glGetUniformBlockIndex _glptr_glGetUniformBlockIndex = _impl_glGetUniformBlockIndex;
+
+static void  GL_APIENTRY _impl_glGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName) {
+  _glptr_glGetActiveUniformName = (PFN_glGetActiveUniformName)GalogenGetProcAddress("glGetActiveUniformName");
+   _glptr_glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+}
+PFN_glGetActiveUniformName _glptr_glGetActiveUniformName = _impl_glGetActiveUniformName;
+
+static void  GL_APIENTRY _impl_glGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices) {
+  _glptr_glGetUniformIndices = (PFN_glGetUniformIndices)GalogenGetProcAddress("glGetUniformIndices");
+   _glptr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+}
+PFN_glGetUniformIndices _glptr_glGetUniformIndices = _impl_glGetUniformIndices;
+
+static void  GL_APIENTRY _impl_glTexBuffer (GLenum target, GLenum internalformat, GLuint buffer) {
+  _glptr_glTexBuffer = (PFN_glTexBuffer)GalogenGetProcAddress("glTexBuffer");
+   _glptr_glTexBuffer(target, internalformat, buffer);
+}
+PFN_glTexBuffer _glptr_glTexBuffer = _impl_glTexBuffer;
+
+static GLboolean GL_APIENTRY _impl_glIsVertexArray (GLuint array) {
+  _glptr_glIsVertexArray = (PFN_glIsVertexArray)GalogenGetProcAddress("glIsVertexArray");
+  return _glptr_glIsVertexArray(array);
+}
+PFN_glIsVertexArray _glptr_glIsVertexArray = _impl_glIsVertexArray;
+
+static void  GL_APIENTRY _impl_glBindVertexArray (GLuint array) {
+  _glptr_glBindVertexArray = (PFN_glBindVertexArray)GalogenGetProcAddress("glBindVertexArray");
+   _glptr_glBindVertexArray(array);
+}
+PFN_glBindVertexArray _glptr_glBindVertexArray = _impl_glBindVertexArray;
+
+static void  GL_APIENTRY _impl_glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length) {
+  _glptr_glFlushMappedBufferRange = (PFN_glFlushMappedBufferRange)GalogenGetProcAddress("glFlushMappedBufferRange");
+   _glptr_glFlushMappedBufferRange(target, offset, length);
+}
+PFN_glFlushMappedBufferRange _glptr_glFlushMappedBufferRange = _impl_glFlushMappedBufferRange;
+
+static void * GL_APIENTRY _impl_glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
+  _glptr_glMapBufferRange = (PFN_glMapBufferRange)GalogenGetProcAddress("glMapBufferRange");
+  return _glptr_glMapBufferRange(target, offset, length, access);
+}
+PFN_glMapBufferRange _glptr_glMapBufferRange = _impl_glMapBufferRange;
+
+static void  GL_APIENTRY _impl_glGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) {
+  _glptr_glGetActiveUniformsiv = (PFN_glGetActiveUniformsiv)GalogenGetProcAddress("glGetActiveUniformsiv");
+   _glptr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+}
+PFN_glGetActiveUniformsiv _glptr_glGetActiveUniformsiv = _impl_glGetActiveUniformsiv;
+
+static void  GL_APIENTRY _impl_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
+  _glptr_glFramebufferTextureLayer = (PFN_glFramebufferTextureLayer)GalogenGetProcAddress("glFramebufferTextureLayer");
+   _glptr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
+}
+PFN_glFramebufferTextureLayer _glptr_glFramebufferTextureLayer = _impl_glFramebufferTextureLayer;
+
+static void  GL_APIENTRY _impl_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint * params) {
+  _glptr_glGetFramebufferAttachmentParameteriv = (PFN_glGetFramebufferAttachmentParameteriv)GalogenGetProcAddress("glGetFramebufferAttachmentParameteriv");
+   _glptr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+}
+PFN_glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv = _impl_glGetFramebufferAttachmentParameteriv;
+
+static void  GL_APIENTRY _impl_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
+  _glptr_glFramebufferTexture3D = (PFN_glFramebufferTexture3D)GalogenGetProcAddress("glFramebufferTexture3D");
+   _glptr_glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+}
+PFN_glFramebufferTexture3D _glptr_glFramebufferTexture3D = _impl_glFramebufferTexture3D;
+
+static void  GL_APIENTRY _impl_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
+  _glptr_glFramebufferTexture1D = (PFN_glFramebufferTexture1D)GalogenGetProcAddress("glFramebufferTexture1D");
+   _glptr_glFramebufferTexture1D(target, attachment, textarget, texture, level);
+}
+PFN_glFramebufferTexture1D _glptr_glFramebufferTexture1D = _impl_glFramebufferTexture1D;
+
+static void  GL_APIENTRY _impl_glGenFramebuffers (GLsizei n, GLuint * framebuffers) {
+  _glptr_glGenFramebuffers = (PFN_glGenFramebuffers)GalogenGetProcAddress("glGenFramebuffers");
+   _glptr_glGenFramebuffers(n, framebuffers);
+}
+PFN_glGenFramebuffers _glptr_glGenFramebuffers = _impl_glGenFramebuffers;
+
+static void  GL_APIENTRY _impl_glBindFramebuffer (GLenum target, GLuint framebuffer) {
+  _glptr_glBindFramebuffer = (PFN_glBindFramebuffer)GalogenGetProcAddress("glBindFramebuffer");
+   _glptr_glBindFramebuffer(target, framebuffer);
+}
+PFN_glBindFramebuffer _glptr_glBindFramebuffer = _impl_glBindFramebuffer;
+
+static void  GL_APIENTRY _impl_glGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 * params) {
+  _glptr_glGetQueryObjecti64v = (PFN_glGetQueryObjecti64v)GalogenGetProcAddress("glGetQueryObjecti64v");
+   _glptr_glGetQueryObjecti64v(id, pname, params);
+}
+PFN_glGetQueryObjecti64v _glptr_glGetQueryObjecti64v = _impl_glGetQueryObjecti64v;
+
+static void  GL_APIENTRY _impl_glGetInteger64v (GLenum pname, GLint64 * data) {
+  _glptr_glGetInteger64v = (PFN_glGetInteger64v)GalogenGetProcAddress("glGetInteger64v");
+   _glptr_glGetInteger64v(pname, data);
+}
+PFN_glGetInteger64v _glptr_glGetInteger64v = _impl_glGetInteger64v;
+
+static GLboolean GL_APIENTRY _impl_glIsFramebuffer (GLuint framebuffer) {
+  _glptr_glIsFramebuffer = (PFN_glIsFramebuffer)GalogenGetProcAddress("glIsFramebuffer");
+  return _glptr_glIsFramebuffer(framebuffer);
+}
+PFN_glIsFramebuffer _glptr_glIsFramebuffer = _impl_glIsFramebuffer;
+
+static void  GL_APIENTRY _impl_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint * params) {
+  _glptr_glGetRenderbufferParameteriv = (PFN_glGetRenderbufferParameteriv)GalogenGetProcAddress("glGetRenderbufferParameteriv");
+   _glptr_glGetRenderbufferParameteriv(target, pname, params);
+}
+PFN_glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv = _impl_glGetRenderbufferParameteriv;
+
+static void  GL_APIENTRY _impl_glBindRenderbuffer (GLenum target, GLuint renderbuffer) {
+  _glptr_glBindRenderbuffer = (PFN_glBindRenderbuffer)GalogenGetProcAddress("glBindRenderbuffer");
+   _glptr_glBindRenderbuffer(target, renderbuffer);
+}
+PFN_glBindRenderbuffer _glptr_glBindRenderbuffer = _impl_glBindRenderbuffer;
+
+static GLboolean GL_APIENTRY _impl_glIsRenderbuffer (GLuint renderbuffer) {
+  _glptr_glIsRenderbuffer = (PFN_glIsRenderbuffer)GalogenGetProcAddress("glIsRenderbuffer");
+  return _glptr_glIsRenderbuffer(renderbuffer);
+}
+PFN_glIsRenderbuffer _glptr_glIsRenderbuffer = _impl_glIsRenderbuffer;
+
+static const GLubyte * GL_APIENTRY _impl_glGetStringi (GLenum name, GLuint index) {
+  _glptr_glGetStringi = (PFN_glGetStringi)GalogenGetProcAddress("glGetStringi");
+  return _glptr_glGetStringi(name, index);
+}
+PFN_glGetStringi _glptr_glGetStringi = _impl_glGetStringi;
+
+static void  GL_APIENTRY _impl_glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
+  _glptr_glClearBufferfi = (PFN_glClearBufferfi)GalogenGetProcAddress("glClearBufferfi");
+   _glptr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
+}
+PFN_glClearBufferfi _glptr_glClearBufferfi = _impl_glClearBufferfi;
+
+static void  GL_APIENTRY _impl_glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat * value) {
+  _glptr_glClearBufferfv = (PFN_glClearBufferfv)GalogenGetProcAddress("glClearBufferfv");
+   _glptr_glClearBufferfv(buffer, drawbuffer, value);
+}
+PFN_glClearBufferfv _glptr_glClearBufferfv = _impl_glClearBufferfv;
+
+static void  GL_APIENTRY _impl_glGetTexParameterIiv (GLenum target, GLenum pname, GLint * params) {
+  _glptr_glGetTexParameterIiv = (PFN_glGetTexParameterIiv)GalogenGetProcAddress("glGetTexParameterIiv");
+   _glptr_glGetTexParameterIiv(target, pname, params);
+}
+PFN_glGetTexParameterIiv _glptr_glGetTexParameterIiv = _impl_glGetTexParameterIiv;
+
+static void  GL_APIENTRY _impl_glGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint * params) {
+  _glptr_glGetSamplerParameterIuiv = (PFN_glGetSamplerParameterIuiv)GalogenGetProcAddress("glGetSamplerParameterIuiv");
+   _glptr_glGetSamplerParameterIuiv(sampler, pname, params);
+}
+PFN_glGetSamplerParameterIuiv _glptr_glGetSamplerParameterIuiv = _impl_glGetSamplerParameterIuiv;
+
+static void  GL_APIENTRY _impl_glTexParameterIiv (GLenum target, GLenum pname, const GLint * params) {
+  _glptr_glTexParameterIiv = (PFN_glTexParameterIiv)GalogenGetProcAddress("glTexParameterIiv");
+   _glptr_glTexParameterIiv(target, pname, params);
+}
+PFN_glTexParameterIiv _glptr_glTexParameterIiv = _impl_glTexParameterIiv;
+
+static void  GL_APIENTRY _impl_glUniform4uiv (GLint location, GLsizei count, const GLuint * value) {
+  _glptr_glUniform4uiv = (PFN_glUniform4uiv)GalogenGetProcAddress("glUniform4uiv");
+   _glptr_glUniform4uiv(location, count, value);
+}
+PFN_glUniform4uiv _glptr_glUniform4uiv = _impl_glUniform4uiv;
+
+static void  GL_APIENTRY _impl_glUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2) {
+  _glptr_glUniform3ui = (PFN_glUniform3ui)GalogenGetProcAddress("glUniform3ui");
+   _glptr_glUniform3ui(location, v0, v1, v2);
+}
+PFN_glUniform3ui _glptr_glUniform3ui = _impl_glUniform3ui;
+
+static void  GL_APIENTRY _impl_glUniform1ui (GLint location, GLuint v0) {
+  _glptr_glUniform1ui = (PFN_glUniform1ui)GalogenGetProcAddress("glUniform1ui");
+   _glptr_glUniform1ui(location, v0);
+}
+PFN_glUniform1ui _glptr_glUniform1ui = _impl_glUniform1ui;
+
+static GLint GL_APIENTRY _impl_glGetFragDataLocation (GLuint program, const GLchar * name) {
+  _glptr_glGetFragDataLocation = (PFN_glGetFragDataLocation)GalogenGetProcAddress("glGetFragDataLocation");
+  return _glptr_glGetFragDataLocation(program, name);
+}
+PFN_glGetFragDataLocation _glptr_glGetFragDataLocation = _impl_glGetFragDataLocation;
+
+static void  GL_APIENTRY _impl_glBindFragDataLocation (GLuint program, GLuint color, const GLchar * name) {
+  _glptr_glBindFragDataLocation = (PFN_glBindFragDataLocation)GalogenGetProcAddress("glBindFragDataLocation");
+   _glptr_glBindFragDataLocation(program, color, name);
+}
+PFN_glBindFragDataLocation _glptr_glBindFragDataLocation = _impl_glBindFragDataLocation;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4iv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttribI4iv = (PFN_glVertexAttribI4iv)GalogenGetProcAddress("glVertexAttribI4iv");
+   _glptr_glVertexAttribI4iv(index, v);
+}
+PFN_glVertexAttribI4iv _glptr_glVertexAttribI4iv = _impl_glVertexAttribI4iv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI2iv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttribI2iv = (PFN_glVertexAttribI2iv)GalogenGetProcAddress("glVertexAttribI2iv");
+   _glptr_glVertexAttribI2iv(index, v);
+}
+PFN_glVertexAttribI2iv _glptr_glVertexAttribI2iv = _impl_glVertexAttribI2iv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI1iv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttribI1iv = (PFN_glVertexAttribI1iv)GalogenGetProcAddress("glVertexAttribI1iv");
+   _glptr_glVertexAttribI1iv(index, v);
+}
+PFN_glVertexAttribI1iv _glptr_glVertexAttribI1iv = _impl_glVertexAttribI1iv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {
+  _glptr_glVertexAttribI4ui = (PFN_glVertexAttribI4ui)GalogenGetProcAddress("glVertexAttribI4ui");
+   _glptr_glVertexAttribI4ui(index, x, y, z, w);
+}
+PFN_glVertexAttribI4ui _glptr_glVertexAttribI4ui = _impl_glVertexAttribI4ui;
+
+static void  GL_APIENTRY _impl_glVertexAttribI2ui (GLuint index, GLuint x, GLuint y) {
+  _glptr_glVertexAttribI2ui = (PFN_glVertexAttribI2ui)GalogenGetProcAddress("glVertexAttribI2ui");
+   _glptr_glVertexAttribI2ui(index, x, y);
+}
+PFN_glVertexAttribI2ui _glptr_glVertexAttribI2ui = _impl_glVertexAttribI2ui;
+
+static void  GL_APIENTRY _impl_glVertexAttribI1ui (GLuint index, GLuint x) {
+  _glptr_glVertexAttribI1ui = (PFN_glVertexAttribI1ui)GalogenGetProcAddress("glVertexAttribI1ui");
+   _glptr_glVertexAttribI1ui(index, x);
+}
+PFN_glVertexAttribI1ui _glptr_glVertexAttribI1ui = _impl_glVertexAttribI1ui;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w) {
+  _glptr_glVertexAttribI4i = (PFN_glVertexAttribI4i)GalogenGetProcAddress("glVertexAttribI4i");
+   _glptr_glVertexAttribI4i(index, x, y, z, w);
+}
+PFN_glVertexAttribI4i _glptr_glVertexAttribI4i = _impl_glVertexAttribI4i;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4bv (GLuint index, const GLbyte * v) {
+  _glptr_glVertexAttribI4bv = (PFN_glVertexAttribI4bv)GalogenGetProcAddress("glVertexAttribI4bv");
+   _glptr_glVertexAttribI4bv(index, v);
+}
+PFN_glVertexAttribI4bv _glptr_glVertexAttribI4bv = _impl_glVertexAttribI4bv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI2i (GLuint index, GLint x, GLint y) {
+  _glptr_glVertexAttribI2i = (PFN_glVertexAttribI2i)GalogenGetProcAddress("glVertexAttribI2i");
+   _glptr_glVertexAttribI2i(index, x, y);
+}
+PFN_glVertexAttribI2i _glptr_glVertexAttribI2i = _impl_glVertexAttribI2i;
+
+static void  GL_APIENTRY _impl_glVertexAttribI1i (GLuint index, GLint x) {
+  _glptr_glVertexAttribI1i = (PFN_glVertexAttribI1i)GalogenGetProcAddress("glVertexAttribI1i");
+   _glptr_glVertexAttribI1i(index, x);
+}
+PFN_glVertexAttribI1i _glptr_glVertexAttribI1i = _impl_glVertexAttribI1i;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribIiv (GLuint index, GLenum pname, GLint * params) {
+  _glptr_glGetVertexAttribIiv = (PFN_glGetVertexAttribIiv)GalogenGetProcAddress("glGetVertexAttribIiv");
+   _glptr_glGetVertexAttribIiv(index, pname, params);
+}
+PFN_glGetVertexAttribIiv _glptr_glGetVertexAttribIiv = _impl_glGetVertexAttribIiv;
+
+static void  GL_APIENTRY _impl_glVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) {
+  _glptr_glVertexAttribIPointer = (PFN_glVertexAttribIPointer)GalogenGetProcAddress("glVertexAttribIPointer");
+   _glptr_glVertexAttribIPointer(index, size, type, stride, pointer);
+}
+PFN_glVertexAttribIPointer _glptr_glVertexAttribIPointer = _impl_glVertexAttribIPointer;
+
+static void  GL_APIENTRY _impl_glBeginConditionalRender (GLuint id, GLenum mode) {
+  _glptr_glBeginConditionalRender = (PFN_glBeginConditionalRender)GalogenGetProcAddress("glBeginConditionalRender");
+   _glptr_glBeginConditionalRender(id, mode);
+}
+PFN_glBeginConditionalRender _glptr_glBeginConditionalRender = _impl_glBeginConditionalRender;
+
+static void  GL_APIENTRY _impl_glClampColor (GLenum target, GLenum clamp) {
+  _glptr_glClampColor = (PFN_glClampColor)GalogenGetProcAddress("glClampColor");
+   _glptr_glClampColor(target, clamp);
+}
+PFN_glClampColor _glptr_glClampColor = _impl_glClampColor;
+
+static void  GL_APIENTRY _impl_glBindBufferBase (GLenum target, GLuint index, GLuint buffer) {
+  _glptr_glBindBufferBase = (PFN_glBindBufferBase)GalogenGetProcAddress("glBindBufferBase");
+   _glptr_glBindBufferBase(target, index, buffer);
+}
+PFN_glBindBufferBase _glptr_glBindBufferBase = _impl_glBindBufferBase;
+
+static void  GL_APIENTRY _impl_glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
+  _glptr_glBindBufferRange = (PFN_glBindBufferRange)GalogenGetProcAddress("glBindBufferRange");
+   _glptr_glBindBufferRange(target, index, buffer, offset, size);
+}
+PFN_glBindBufferRange _glptr_glBindBufferRange = _impl_glBindBufferRange;
+
+static void  GL_APIENTRY _impl_glBeginTransformFeedback (GLenum primitiveMode) {
+  _glptr_glBeginTransformFeedback = (PFN_glBeginTransformFeedback)GalogenGetProcAddress("glBeginTransformFeedback");
+   _glptr_glBeginTransformFeedback(primitiveMode);
+}
+PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback = _impl_glBeginTransformFeedback;
+
+static GLboolean GL_APIENTRY _impl_glIsEnabledi (GLenum target, GLuint index) {
+  _glptr_glIsEnabledi = (PFN_glIsEnabledi)GalogenGetProcAddress("glIsEnabledi");
+  return _glptr_glIsEnabledi(target, index);
+}
+PFN_glIsEnabledi _glptr_glIsEnabledi = _impl_glIsEnabledi;
+
+static void  GL_APIENTRY _impl_glGetIntegeri_v (GLenum target, GLuint index, GLint * data) {
+  _glptr_glGetIntegeri_v = (PFN_glGetIntegeri_v)GalogenGetProcAddress("glGetIntegeri_v");
+   _glptr_glGetIntegeri_v(target, index, data);
+}
+PFN_glGetIntegeri_v _glptr_glGetIntegeri_v = _impl_glGetIntegeri_v;
+
+static void  GL_APIENTRY _impl_glColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
+  _glptr_glColorMaski = (PFN_glColorMaski)GalogenGetProcAddress("glColorMaski");
+   _glptr_glColorMaski(index, r, g, b, a);
+}
+PFN_glColorMaski _glptr_glColorMaski = _impl_glColorMaski;
+
+static void  GL_APIENTRY _impl_glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix4x3fv = (PFN_glUniformMatrix4x3fv)GalogenGetProcAddress("glUniformMatrix4x3fv");
+   _glptr_glUniformMatrix4x3fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv = _impl_glUniformMatrix4x3fv;
+
+static void  GL_APIENTRY _impl_glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix3x4fv = (PFN_glUniformMatrix3x4fv)GalogenGetProcAddress("glUniformMatrix3x4fv");
+   _glptr_glUniformMatrix3x4fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv = _impl_glUniformMatrix3x4fv;
+
+static void  GL_APIENTRY _impl_glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix2x4fv = (PFN_glUniformMatrix2x4fv)GalogenGetProcAddress("glUniformMatrix2x4fv");
+   _glptr_glUniformMatrix2x4fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv = _impl_glUniformMatrix2x4fv;
+
+static void  GL_APIENTRY _impl_glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix3x2fv = (PFN_glUniformMatrix3x2fv)GalogenGetProcAddress("glUniformMatrix3x2fv");
+   _glptr_glUniformMatrix3x2fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv = _impl_glUniformMatrix3x2fv;
+
+static void  GL_APIENTRY _impl_glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix2x3fv = (PFN_glUniformMatrix2x3fv)GalogenGetProcAddress("glUniformMatrix2x3fv");
+   _glptr_glUniformMatrix2x3fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv = _impl_glUniformMatrix2x3fv;
+
+static void  GL_APIENTRY _impl_glVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
+  _glptr_glVertexAttribP4ui = (PFN_glVertexAttribP4ui)GalogenGetProcAddress("glVertexAttribP4ui");
+   _glptr_glVertexAttribP4ui(index, type, normalized, value);
+}
+PFN_glVertexAttribP4ui _glptr_glVertexAttribP4ui = _impl_glVertexAttribP4ui;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4ubv (GLuint index, const GLubyte * v) {
+  _glptr_glVertexAttrib4ubv = (PFN_glVertexAttrib4ubv)GalogenGetProcAddress("glVertexAttrib4ubv");
+   _glptr_glVertexAttrib4ubv(index, v);
+}
+PFN_glVertexAttrib4ubv _glptr_glVertexAttrib4ubv = _impl_glVertexAttrib4ubv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4sv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttrib4sv = (PFN_glVertexAttrib4sv)GalogenGetProcAddress("glVertexAttrib4sv");
+   _glptr_glVertexAttrib4sv(index, v);
+}
+PFN_glVertexAttrib4sv _glptr_glVertexAttrib4sv = _impl_glVertexAttrib4sv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4fv (GLuint index, const GLfloat * v) {
+  _glptr_glVertexAttrib4fv = (PFN_glVertexAttrib4fv)GalogenGetProcAddress("glVertexAttrib4fv");
+   _glptr_glVertexAttrib4fv(index, v);
+}
+PFN_glVertexAttrib4fv _glptr_glVertexAttrib4fv = _impl_glVertexAttrib4fv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nusv (GLuint index, const GLushort * v) {
+  _glptr_glVertexAttrib4Nusv = (PFN_glVertexAttrib4Nusv)GalogenGetProcAddress("glVertexAttrib4Nusv");
+   _glptr_glVertexAttrib4Nusv(index, v);
+}
+PFN_glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv = _impl_glVertexAttrib4Nusv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nuiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttrib4Nuiv = (PFN_glVertexAttrib4Nuiv)GalogenGetProcAddress("glVertexAttrib4Nuiv");
+   _glptr_glVertexAttrib4Nuiv(index, v);
+}
+PFN_glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv = _impl_glVertexAttrib4Nuiv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nubv (GLuint index, const GLubyte * v) {
+  _glptr_glVertexAttrib4Nubv = (PFN_glVertexAttrib4Nubv)GalogenGetProcAddress("glVertexAttrib4Nubv");
+   _glptr_glVertexAttrib4Nubv(index, v);
+}
+PFN_glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv = _impl_glVertexAttrib4Nubv;
+
+static void  GL_APIENTRY _impl_glProvokingVertex (GLenum mode) {
+  _glptr_glProvokingVertex = (PFN_glProvokingVertex)GalogenGetProcAddress("glProvokingVertex");
+   _glptr_glProvokingVertex(mode);
+}
+PFN_glProvokingVertex _glptr_glProvokingVertex = _impl_glProvokingVertex;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nsv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttrib4Nsv = (PFN_glVertexAttrib4Nsv)GalogenGetProcAddress("glVertexAttrib4Nsv");
+   _glptr_glVertexAttrib4Nsv(index, v);
+}
+PFN_glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv = _impl_glVertexAttrib4Nsv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z) {
+  _glptr_glVertexAttrib3f = (PFN_glVertexAttrib3f)GalogenGetProcAddress("glVertexAttrib3f");
+   _glptr_glVertexAttrib3f(index, x, y, z);
+}
+PFN_glVertexAttrib3f _glptr_glVertexAttrib3f = _impl_glVertexAttrib3f;
+
+static void  GL_APIENTRY _impl_glVertexAttribI1uiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttribI1uiv = (PFN_glVertexAttribI1uiv)GalogenGetProcAddress("glVertexAttribI1uiv");
+   _glptr_glVertexAttribI1uiv(index, v);
+}
+PFN_glVertexAttribI1uiv _glptr_glVertexAttribI1uiv = _impl_glVertexAttribI1uiv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3dv (GLuint index, const GLdouble * v) {
+  _glptr_glVertexAttrib3dv = (PFN_glVertexAttrib3dv)GalogenGetProcAddress("glVertexAttrib3dv");
+   _glptr_glVertexAttrib3dv(index, v);
+}
+PFN_glVertexAttrib3dv _glptr_glVertexAttrib3dv = _impl_glVertexAttrib3dv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) {
+  _glptr_glVertexAttrib3d = (PFN_glVertexAttrib3d)GalogenGetProcAddress("glVertexAttrib3d");
+   _glptr_glVertexAttrib3d(index, x, y, z);
+}
+PFN_glVertexAttrib3d _glptr_glVertexAttrib3d = _impl_glVertexAttrib3d;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2sv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttrib2sv = (PFN_glVertexAttrib2sv)GalogenGetProcAddress("glVertexAttrib2sv");
+   _glptr_glVertexAttrib2sv(index, v);
+}
+PFN_glVertexAttrib2sv _glptr_glVertexAttrib2sv = _impl_glVertexAttrib2sv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2fv (GLuint index, const GLfloat * v) {
+  _glptr_glVertexAttrib2fv = (PFN_glVertexAttrib2fv)GalogenGetProcAddress("glVertexAttrib2fv");
+   _glptr_glVertexAttrib2fv(index, v);
+}
+PFN_glVertexAttrib2fv _glptr_glVertexAttrib2fv = _impl_glVertexAttrib2fv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2dv (GLuint index, const GLdouble * v) {
+  _glptr_glVertexAttrib2dv = (PFN_glVertexAttrib2dv)GalogenGetProcAddress("glVertexAttrib2dv");
+   _glptr_glVertexAttrib2dv(index, v);
+}
+PFN_glVertexAttrib2dv _glptr_glVertexAttrib2dv = _impl_glVertexAttrib2dv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y) {
+  _glptr_glVertexAttrib2d = (PFN_glVertexAttrib2d)GalogenGetProcAddress("glVertexAttrib2d");
+   _glptr_glVertexAttrib2d(index, x, y);
+}
+PFN_glVertexAttrib2d _glptr_glVertexAttrib2d = _impl_glVertexAttrib2d;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y) {
+  _glptr_glVertexAttrib2f = (PFN_glVertexAttrib2f)GalogenGetProcAddress("glVertexAttrib2f");
+   _glptr_glVertexAttrib2f(index, x, y);
+}
+PFN_glVertexAttrib2f _glptr_glVertexAttrib2f = _impl_glVertexAttrib2f;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1s (GLuint index, GLshort x) {
+  _glptr_glVertexAttrib1s = (PFN_glVertexAttrib1s)GalogenGetProcAddress("glVertexAttrib1s");
+   _glptr_glVertexAttrib1s(index, x);
+}
+PFN_glVertexAttrib1s _glptr_glVertexAttrib1s = _impl_glVertexAttrib1s;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1fv (GLuint index, const GLfloat * v) {
+  _glptr_glVertexAttrib1fv = (PFN_glVertexAttrib1fv)GalogenGetProcAddress("glVertexAttrib1fv");
+   _glptr_glVertexAttrib1fv(index, v);
+}
+PFN_glVertexAttrib1fv _glptr_glVertexAttrib1fv = _impl_glVertexAttrib1fv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1f (GLuint index, GLfloat x) {
+  _glptr_glVertexAttrib1f = (PFN_glVertexAttrib1f)GalogenGetProcAddress("glVertexAttrib1f");
+   _glptr_glVertexAttrib1f(index, x);
+}
+PFN_glVertexAttrib1f _glptr_glVertexAttrib1f = _impl_glVertexAttrib1f;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1dv (GLuint index, const GLdouble * v) {
+  _glptr_glVertexAttrib1dv = (PFN_glVertexAttrib1dv)GalogenGetProcAddress("glVertexAttrib1dv");
+   _glptr_glVertexAttrib1dv(index, v);
+}
+PFN_glVertexAttrib1dv _glptr_glVertexAttrib1dv = _impl_glVertexAttrib1dv;
+
+static void  GL_APIENTRY _impl_glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint * value) {
+  _glptr_glClearBufferuiv = (PFN_glClearBufferuiv)GalogenGetProcAddress("glClearBufferuiv");
+   _glptr_glClearBufferuiv(buffer, drawbuffer, value);
+}
+PFN_glClearBufferuiv _glptr_glClearBufferuiv = _impl_glClearBufferuiv;
+
+static void  GL_APIENTRY _impl_glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix3fv = (PFN_glUniformMatrix3fv)GalogenGetProcAddress("glUniformMatrix3fv");
+   _glptr_glUniformMatrix3fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix3fv _glptr_glUniformMatrix3fv = _impl_glUniformMatrix3fv;
+
+static void  GL_APIENTRY _impl_glDeleteRenderbuffers (GLsizei n, const GLuint * renderbuffers) {
+  _glptr_glDeleteRenderbuffers = (PFN_glDeleteRenderbuffers)GalogenGetProcAddress("glDeleteRenderbuffers");
+   _glptr_glDeleteRenderbuffers(n, renderbuffers);
+}
+PFN_glDeleteRenderbuffers _glptr_glDeleteRenderbuffers = _impl_glDeleteRenderbuffers;
+
+static void  GL_APIENTRY _impl_glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix2fv = (PFN_glUniformMatrix2fv)GalogenGetProcAddress("glUniformMatrix2fv");
+   _glptr_glUniformMatrix2fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix2fv _glptr_glUniformMatrix2fv = _impl_glUniformMatrix2fv;
+
+static void  GL_APIENTRY _impl_glUniform4iv (GLint location, GLsizei count, const GLint * value) {
+  _glptr_glUniform4iv = (PFN_glUniform4iv)GalogenGetProcAddress("glUniform4iv");
+   _glptr_glUniform4iv(location, count, value);
+}
+PFN_glUniform4iv _glptr_glUniform4iv = _impl_glUniform4iv;
+
+static void  GL_APIENTRY _impl_glUniform1iv (GLint location, GLsizei count, const GLint * value) {
+  _glptr_glUniform1iv = (PFN_glUniform1iv)GalogenGetProcAddress("glUniform1iv");
+   _glptr_glUniform1iv(location, count, value);
+}
+PFN_glUniform1iv _glptr_glUniform1iv = _impl_glUniform1iv;
+
+static void  GL_APIENTRY _impl_glUniform4fv (GLint location, GLsizei count, const GLfloat * value) {
+  _glptr_glUniform4fv = (PFN_glUniform4fv)GalogenGetProcAddress("glUniform4fv");
+   _glptr_glUniform4fv(location, count, value);
+}
+PFN_glUniform4fv _glptr_glUniform4fv = _impl_glUniform4fv;
+
+static void  GL_APIENTRY _impl_glUniform2fv (GLint location, GLsizei count, const GLfloat * value) {
+  _glptr_glUniform2fv = (PFN_glUniform2fv)GalogenGetProcAddress("glUniform2fv");
+   _glptr_glUniform2fv(location, count, value);
+}
+PFN_glUniform2fv _glptr_glUniform2fv = _impl_glUniform2fv;
+
+static void  GL_APIENTRY _impl_glUniform3i (GLint location, GLint v0, GLint v1, GLint v2) {
+  _glptr_glUniform3i = (PFN_glUniform3i)GalogenGetProcAddress("glUniform3i");
+   _glptr_glUniform3i(location, v0, v1, v2);
+}
+PFN_glUniform3i _glptr_glUniform3i = _impl_glUniform3i;
+
+static void  GL_APIENTRY _impl_glUniform2i (GLint location, GLint v0, GLint v1) {
+  _glptr_glUniform2i = (PFN_glUniform2i)GalogenGetProcAddress("glUniform2i");
+   _glptr_glUniform2i(location, v0, v1);
+}
+PFN_glUniform2i _glptr_glUniform2i = _impl_glUniform2i;
+
+static void  GL_APIENTRY _impl_glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
+  _glptr_glUniform4f = (PFN_glUniform4f)GalogenGetProcAddress("glUniform4f");
+   _glptr_glUniform4f(location, v0, v1, v2, v3);
+}
+PFN_glUniform4f _glptr_glUniform4f = _impl_glUniform4f;
+
+static void  GL_APIENTRY _impl_glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
+  _glptr_glUniform3f = (PFN_glUniform3f)GalogenGetProcAddress("glUniform3f");
+   _glptr_glUniform3f(location, v0, v1, v2);
+}
+PFN_glUniform3f _glptr_glUniform3f = _impl_glUniform3f;
+
+static void  GL_APIENTRY _impl_glUniform1f (GLint location, GLfloat v0) {
+  _glptr_glUniform1f = (PFN_glUniform1f)GalogenGetProcAddress("glUniform1f");
+   _glptr_glUniform1f(location, v0);
+}
+PFN_glUniform1f _glptr_glUniform1f = _impl_glUniform1f;
+
+static void  GL_APIENTRY _impl_glUseProgram (GLuint program) {
+  _glptr_glUseProgram = (PFN_glUseProgram)GalogenGetProcAddress("glUseProgram");
+   _glptr_glUseProgram(program);
+}
+PFN_glUseProgram _glptr_glUseProgram = _impl_glUseProgram;
+
+static void  GL_APIENTRY _impl_glShaderSource (GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length) {
+  _glptr_glShaderSource = (PFN_glShaderSource)GalogenGetProcAddress("glShaderSource");
+   _glptr_glShaderSource(shader, count, string, length);
+}
+PFN_glShaderSource _glptr_glShaderSource = _impl_glShaderSource;
+
+static void  GL_APIENTRY _impl_glLinkProgram (GLuint program) {
+  _glptr_glLinkProgram = (PFN_glLinkProgram)GalogenGetProcAddress("glLinkProgram");
+   _glptr_glLinkProgram(program);
+}
+PFN_glLinkProgram _glptr_glLinkProgram = _impl_glLinkProgram;
+
+static GLboolean GL_APIENTRY _impl_glIsShader (GLuint shader) {
+  _glptr_glIsShader = (PFN_glIsShader)GalogenGetProcAddress("glIsShader");
+  return _glptr_glIsShader(shader);
+}
+PFN_glIsShader _glptr_glIsShader = _impl_glIsShader;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribPointerv (GLuint index, GLenum pname, void ** pointer) {
+  _glptr_glGetVertexAttribPointerv = (PFN_glGetVertexAttribPointerv)GalogenGetProcAddress("glGetVertexAttribPointerv");
+   _glptr_glGetVertexAttribPointerv(index, pname, pointer);
+}
+PFN_glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv = _impl_glGetVertexAttribPointerv;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribiv (GLuint index, GLenum pname, GLint * params) {
+  _glptr_glGetVertexAttribiv = (PFN_glGetVertexAttribiv)GalogenGetProcAddress("glGetVertexAttribiv");
+   _glptr_glGetVertexAttribiv(index, pname, params);
+}
+PFN_glGetVertexAttribiv _glptr_glGetVertexAttribiv = _impl_glGetVertexAttribiv;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat * params) {
+  _glptr_glGetVertexAttribfv = (PFN_glGetVertexAttribfv)GalogenGetProcAddress("glGetVertexAttribfv");
+   _glptr_glGetVertexAttribfv(index, pname, params);
+}
+PFN_glGetVertexAttribfv _glptr_glGetVertexAttribfv = _impl_glGetVertexAttribfv;
+
+static void  GL_APIENTRY _impl_glUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
+  _glptr_glUniformBlockBinding = (PFN_glUniformBlockBinding)GalogenGetProcAddress("glUniformBlockBinding");
+   _glptr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+}
+PFN_glUniformBlockBinding _glptr_glUniformBlockBinding = _impl_glUniformBlockBinding;
+
+static GLint GL_APIENTRY _impl_glGetUniformLocation (GLuint program, const GLchar * name) {
+  _glptr_glGetUniformLocation = (PFN_glGetUniformLocation)GalogenGetProcAddress("glGetUniformLocation");
+  return _glptr_glGetUniformLocation(program, name);
+}
+PFN_glGetUniformLocation _glptr_glGetUniformLocation = _impl_glGetUniformLocation;
+
+static void  GL_APIENTRY _impl_glGetShaderiv (GLuint shader, GLenum pname, GLint * params) {
+  _glptr_glGetShaderiv = (PFN_glGetShaderiv)GalogenGetProcAddress("glGetShaderiv");
+   _glptr_glGetShaderiv(shader, pname, params);
+}
+PFN_glGetShaderiv _glptr_glGetShaderiv = _impl_glGetShaderiv;
+
+static void  GL_APIENTRY _impl_glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
+  _glptr_glGetProgramInfoLog = (PFN_glGetProgramInfoLog)GalogenGetProcAddress("glGetProgramInfoLog");
+   _glptr_glGetProgramInfoLog(program, bufSize, length, infoLog);
+}
+PFN_glGetProgramInfoLog _glptr_glGetProgramInfoLog = _impl_glGetProgramInfoLog;
+
+static GLint GL_APIENTRY _impl_glGetAttribLocation (GLuint program, const GLchar * name) {
+  _glptr_glGetAttribLocation = (PFN_glGetAttribLocation)GalogenGetProcAddress("glGetAttribLocation");
+  return _glptr_glGetAttribLocation(program, name);
+}
+PFN_glGetAttribLocation _glptr_glGetAttribLocation = _impl_glGetAttribLocation;
+
+static void  GL_APIENTRY _impl_glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders) {
+  _glptr_glGetAttachedShaders = (PFN_glGetAttachedShaders)GalogenGetProcAddress("glGetAttachedShaders");
+   _glptr_glGetAttachedShaders(program, maxCount, count, shaders);
+}
+PFN_glGetAttachedShaders _glptr_glGetAttachedShaders = _impl_glGetAttachedShaders;
+
+static void  GL_APIENTRY _impl_glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
+  _glptr_glGetActiveUniform = (PFN_glGetActiveUniform)GalogenGetProcAddress("glGetActiveUniform");
+   _glptr_glGetActiveUniform(program, index, bufSize, length, size, type, name);
+}
+PFN_glGetActiveUniform _glptr_glGetActiveUniform = _impl_glGetActiveUniform;
+
+static void  GL_APIENTRY _impl_glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
+  _glptr_glGetActiveAttrib = (PFN_glGetActiveAttrib)GalogenGetProcAddress("glGetActiveAttrib");
+   _glptr_glGetActiveAttrib(program, index, bufSize, length, size, type, name);
+}
+PFN_glGetActiveAttrib _glptr_glGetActiveAttrib = _impl_glGetActiveAttrib;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4iv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttrib4iv = (PFN_glVertexAttrib4iv)GalogenGetProcAddress("glVertexAttrib4iv");
+   _glptr_glVertexAttrib4iv(index, v);
+}
+PFN_glVertexAttrib4iv _glptr_glVertexAttrib4iv = _impl_glVertexAttrib4iv;
+
+static void  GL_APIENTRY _impl_glDisableVertexAttribArray (GLuint index) {
+  _glptr_glDisableVertexAttribArray = (PFN_glDisableVertexAttribArray)GalogenGetProcAddress("glDisableVertexAttribArray");
+   _glptr_glDisableVertexAttribArray(index);
+}
+PFN_glDisableVertexAttribArray _glptr_glDisableVertexAttribArray = _impl_glDisableVertexAttribArray;
+
+static void  GL_APIENTRY _impl_glDeleteShader (GLuint shader) {
+  _glptr_glDeleteShader = (PFN_glDeleteShader)GalogenGetProcAddress("glDeleteShader");
+   _glptr_glDeleteShader(shader);
+}
+PFN_glDeleteShader _glptr_glDeleteShader = _impl_glDeleteShader;
+
+static void  GL_APIENTRY _impl_glDeleteProgram (GLuint program) {
+  _glptr_glDeleteProgram = (PFN_glDeleteProgram)GalogenGetProcAddress("glDeleteProgram");
+   _glptr_glDeleteProgram(program);
+}
+PFN_glDeleteProgram _glptr_glDeleteProgram = _impl_glDeleteProgram;
+
+static void  GL_APIENTRY _impl_glGetBooleani_v (GLenum target, GLuint index, GLboolean * data) {
+  _glptr_glGetBooleani_v = (PFN_glGetBooleani_v)GalogenGetProcAddress("glGetBooleani_v");
+   _glptr_glGetBooleani_v(target, index, data);
+}
+PFN_glGetBooleani_v _glptr_glGetBooleani_v = _impl_glGetBooleani_v;
+
+static void  GL_APIENTRY _impl_glCompileShader (GLuint shader) {
+  _glptr_glCompileShader = (PFN_glCompileShader)GalogenGetProcAddress("glCompileShader");
+   _glptr_glCompileShader(shader);
+}
+PFN_glCompileShader _glptr_glCompileShader = _impl_glCompileShader;
+
+static void  GL_APIENTRY _impl_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask) {
+  _glptr_glStencilFuncSeparate = (PFN_glStencilFuncSeparate)GalogenGetProcAddress("glStencilFuncSeparate");
+   _glptr_glStencilFuncSeparate(face, func, ref, mask);
+}
+PFN_glStencilFuncSeparate _glptr_glStencilFuncSeparate = _impl_glStencilFuncSeparate;
+
+static void  GL_APIENTRY _impl_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
+  _glptr_glStencilOpSeparate = (PFN_glStencilOpSeparate)GalogenGetProcAddress("glStencilOpSeparate");
+   _glptr_glStencilOpSeparate(face, sfail, dpfail, dppass);
+}
+PFN_glStencilOpSeparate _glptr_glStencilOpSeparate = _impl_glStencilOpSeparate;
+
+static void  GL_APIENTRY _impl_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
+  _glptr_glRenderbufferStorageMultisample = (PFN_glRenderbufferStorageMultisample)GalogenGetProcAddress("glRenderbufferStorageMultisample");
+   _glptr_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
+}
+PFN_glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample = _impl_glRenderbufferStorageMultisample;
+
+static void  GL_APIENTRY _impl_glDrawBuffers (GLsizei n, const GLenum * bufs) {
+  _glptr_glDrawBuffers = (PFN_glDrawBuffers)GalogenGetProcAddress("glDrawBuffers");
+   _glptr_glDrawBuffers(n, bufs);
+}
+PFN_glDrawBuffers _glptr_glDrawBuffers = _impl_glDrawBuffers;
+
+static void  GL_APIENTRY _impl_glGetBufferParameteriv (GLenum target, GLenum pname, GLint * params) {
+  _glptr_glGetBufferParameteriv = (PFN_glGetBufferParameteriv)GalogenGetProcAddress("glGetBufferParameteriv");
+   _glptr_glGetBufferParameteriv(target, pname, params);
+}
+PFN_glGetBufferParameteriv _glptr_glGetBufferParameteriv = _impl_glGetBufferParameteriv;
+
+static void  GL_APIENTRY _impl_glVertexAttribDivisor (GLuint index, GLuint divisor) {
+  _glptr_glVertexAttribDivisor = (PFN_glVertexAttribDivisor)GalogenGetProcAddress("glVertexAttribDivisor");
+   _glptr_glVertexAttribDivisor(index, divisor);
+}
+PFN_glVertexAttribDivisor _glptr_glVertexAttribDivisor = _impl_glVertexAttribDivisor;
+
+static GLboolean GL_APIENTRY _impl_glUnmapBuffer (GLenum target) {
+  _glptr_glUnmapBuffer = (PFN_glUnmapBuffer)GalogenGetProcAddress("glUnmapBuffer");
+  return _glptr_glUnmapBuffer(target);
+}
+PFN_glUnmapBuffer _glptr_glUnmapBuffer = _impl_glUnmapBuffer;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4dv (GLuint index, const GLdouble * v) {
+  _glptr_glVertexAttrib4dv = (PFN_glVertexAttrib4dv)GalogenGetProcAddress("glVertexAttrib4dv");
+   _glptr_glVertexAttrib4dv(index, v);
+}
+PFN_glVertexAttrib4dv _glptr_glVertexAttrib4dv = _impl_glVertexAttrib4dv;
+
+static void * GL_APIENTRY _impl_glMapBuffer (GLenum target, GLenum access) {
+  _glptr_glMapBuffer = (PFN_glMapBuffer)GalogenGetProcAddress("glMapBuffer");
+  return _glptr_glMapBuffer(target, access);
+}
+PFN_glMapBuffer _glptr_glMapBuffer = _impl_glMapBuffer;
+
+static void  GL_APIENTRY _impl_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void * data) {
+  _glptr_glBufferSubData = (PFN_glBufferSubData)GalogenGetProcAddress("glBufferSubData");
+   _glptr_glBufferSubData(target, offset, size, data);
+}
+PFN_glBufferSubData _glptr_glBufferSubData = _impl_glBufferSubData;
+
+static void  GL_APIENTRY _impl_glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint * params) {
+  _glptr_glGetQueryObjectuiv = (PFN_glGetQueryObjectuiv)GalogenGetProcAddress("glGetQueryObjectuiv");
+   _glptr_glGetQueryObjectuiv(id, pname, params);
+}
+PFN_glGetQueryObjectuiv _glptr_glGetQueryObjectuiv = _impl_glGetQueryObjectuiv;
+
+static void  GL_APIENTRY _impl_glGetQueryObjectiv (GLuint id, GLenum pname, GLint * params) {
+  _glptr_glGetQueryObjectiv = (PFN_glGetQueryObjectiv)GalogenGetProcAddress("glGetQueryObjectiv");
+   _glptr_glGetQueryObjectiv(id, pname, params);
+}
+PFN_glGetQueryObjectiv _glptr_glGetQueryObjectiv = _impl_glGetQueryObjectiv;
+
+static GLboolean GL_APIENTRY _impl_glIsQuery (GLuint id) {
+  _glptr_glIsQuery = (PFN_glIsQuery)GalogenGetProcAddress("glIsQuery");
+  return _glptr_glIsQuery(id);
+}
+PFN_glIsQuery _glptr_glIsQuery = _impl_glIsQuery;
+
+static void  GL_APIENTRY _impl_glDeleteQueries (GLsizei n, const GLuint * ids) {
+  _glptr_glDeleteQueries = (PFN_glDeleteQueries)GalogenGetProcAddress("glDeleteQueries");
+   _glptr_glDeleteQueries(n, ids);
+}
+PFN_glDeleteQueries _glptr_glDeleteQueries = _impl_glDeleteQueries;
+
+static void  GL_APIENTRY _impl_glGenQueries (GLsizei n, GLuint * ids) {
+  _glptr_glGenQueries = (PFN_glGenQueries)GalogenGetProcAddress("glGenQueries");
+   _glptr_glGenQueries(n, ids);
+}
+PFN_glGenQueries _glptr_glGenQueries = _impl_glGenQueries;
+
+static void  GL_APIENTRY _impl_glBlendEquation (GLenum mode) {
+  _glptr_glBlendEquation = (PFN_glBlendEquation)GalogenGetProcAddress("glBlendEquation");
+   _glptr_glBlendEquation(mode);
+}
+PFN_glBlendEquation _glptr_glBlendEquation = _impl_glBlendEquation;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3sv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttrib3sv = (PFN_glVertexAttrib3sv)GalogenGetProcAddress("glVertexAttrib3sv");
+   _glptr_glVertexAttrib3sv(index, v);
+}
+PFN_glVertexAttrib3sv _glptr_glVertexAttrib3sv = _impl_glVertexAttrib3sv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z) {
+  _glptr_glVertexAttribI3ui = (PFN_glVertexAttribI3ui)GalogenGetProcAddress("glVertexAttribI3ui");
+   _glptr_glVertexAttribI3ui(index, x, y, z);
+}
+PFN_glVertexAttribI3ui _glptr_glVertexAttribI3ui = _impl_glVertexAttribI3ui;
+
+static void  GL_APIENTRY _impl_glGenBuffers (GLsizei n, GLuint * buffers) {
+  _glptr_glGenBuffers = (PFN_glGenBuffers)GalogenGetProcAddress("glGenBuffers");
+   _glptr_glGenBuffers(n, buffers);
+}
+PFN_glGenBuffers _glptr_glGenBuffers = _impl_glGenBuffers;
+
+static GLenum GL_APIENTRY _impl_glCheckFramebufferStatus (GLenum target) {
+  _glptr_glCheckFramebufferStatus = (PFN_glCheckFramebufferStatus)GalogenGetProcAddress("glCheckFramebufferStatus");
+  return _glptr_glCheckFramebufferStatus(target);
+}
+PFN_glCheckFramebufferStatus _glptr_glCheckFramebufferStatus = _impl_glCheckFramebufferStatus;
+
+static void  GL_APIENTRY _impl_glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
+  _glptr_glUniform4i = (PFN_glUniform4i)GalogenGetProcAddress("glUniform4i");
+   _glptr_glUniform4i(location, v0, v1, v2, v3);
+}
+PFN_glUniform4i _glptr_glUniform4i = _impl_glUniform4i;
+
+static void  GL_APIENTRY _impl_glPointParameteriv (GLenum pname, const GLint * params) {
+  _glptr_glPointParameteriv = (PFN_glPointParameteriv)GalogenGetProcAddress("glPointParameteriv");
+   _glptr_glPointParameteriv(pname, params);
+}
+PFN_glPointParameteriv _glptr_glPointParameteriv = _impl_glPointParameteriv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib2s (GLuint index, GLshort x, GLshort y) {
+  _glptr_glVertexAttrib2s = (PFN_glVertexAttrib2s)GalogenGetProcAddress("glVertexAttrib2s");
+   _glptr_glVertexAttrib2s(index, x, y);
+}
+PFN_glVertexAttrib2s _glptr_glVertexAttrib2s = _impl_glVertexAttrib2s;
+
+static void  GL_APIENTRY _impl_glFinish () {
+  _glptr_glFinish = (PFN_glFinish)GalogenGetProcAddress("glFinish");
+   _glptr_glFinish();
+}
+PFN_glFinish _glptr_glFinish = _impl_glFinish;
+
+static void  GL_APIENTRY _impl_glPointParameteri (GLenum pname, GLint param) {
+  _glptr_glPointParameteri = (PFN_glPointParameteri)GalogenGetProcAddress("glPointParameteri");
+   _glptr_glPointParameteri(pname, param);
+}
+PFN_glPointParameteri _glptr_glPointParameteri = _impl_glPointParameteri;
+
+static void  GL_APIENTRY _impl_glMultiDrawArrays (GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount) {
+  _glptr_glMultiDrawArrays = (PFN_glMultiDrawArrays)GalogenGetProcAddress("glMultiDrawArrays");
+   _glptr_glMultiDrawArrays(mode, first, count, drawcount);
+}
+PFN_glMultiDrawArrays _glptr_glMultiDrawArrays = _impl_glMultiDrawArrays;
+
+static void  GL_APIENTRY _impl_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
+  _glptr_glFramebufferRenderbuffer = (PFN_glFramebufferRenderbuffer)GalogenGetProcAddress("glFramebufferRenderbuffer");
+   _glptr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+}
+PFN_glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer = _impl_glFramebufferRenderbuffer;
+
+static GLint GL_APIENTRY _impl_glGetFragDataIndex (GLuint program, const GLchar * name) {
+  _glptr_glGetFragDataIndex = (PFN_glGetFragDataIndex)GalogenGetProcAddress("glGetFragDataIndex");
+  return _glptr_glGetFragDataIndex(program, name);
+}
+PFN_glGetFragDataIndex _glptr_glGetFragDataIndex = _impl_glGetFragDataIndex;
+
+static void  GL_APIENTRY _impl_glGetQueryiv (GLenum target, GLenum pname, GLint * params) {
+  _glptr_glGetQueryiv = (PFN_glGetQueryiv)GalogenGetProcAddress("glGetQueryiv");
+   _glptr_glGetQueryiv(target, pname, params);
+}
+PFN_glGetQueryiv _glptr_glGetQueryiv = _impl_glGetQueryiv;
+
+static void  GL_APIENTRY _impl_glGetUniformfv (GLuint program, GLint location, GLfloat * params) {
+  _glptr_glGetUniformfv = (PFN_glGetUniformfv)GalogenGetProcAddress("glGetUniformfv");
+   _glptr_glGetUniformfv(program, location, params);
+}
+PFN_glGetUniformfv _glptr_glGetUniformfv = _impl_glGetUniformfv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4usv (GLuint index, const GLushort * v) {
+  _glptr_glVertexAttrib4usv = (PFN_glVertexAttrib4usv)GalogenGetProcAddress("glVertexAttrib4usv");
+   _glptr_glVertexAttrib4usv(index, v);
+}
+PFN_glVertexAttrib4usv _glptr_glVertexAttrib4usv = _impl_glVertexAttrib4usv;
+
+static void  GL_APIENTRY _impl_glDeleteSync (GLsync sync) {
+  _glptr_glDeleteSync = (PFN_glDeleteSync)GalogenGetProcAddress("glDeleteSync");
+   _glptr_glDeleteSync(sync);
+}
+PFN_glDeleteSync _glptr_glDeleteSync = _impl_glDeleteSync;
+
+static void  GL_APIENTRY _impl_glGetCompressedTexImage (GLenum target, GLint level, void * img) {
+  _glptr_glGetCompressedTexImage = (PFN_glGetCompressedTexImage)GalogenGetProcAddress("glGetCompressedTexImage");
+   _glptr_glGetCompressedTexImage(target, level, img);
+}
+PFN_glGetCompressedTexImage _glptr_glGetCompressedTexImage = _impl_glGetCompressedTexImage;
+
+static void  GL_APIENTRY _impl_glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexSubImage2D = (PFN_glCompressedTexSubImage2D)GalogenGetProcAddress("glCompressedTexSubImage2D");
+   _glptr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+PFN_glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D = _impl_glCompressedTexSubImage2D;
+
+static void  GL_APIENTRY _impl_glUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
+  _glptr_glUniform4ui = (PFN_glUniform4ui)GalogenGetProcAddress("glUniform4ui");
+   _glptr_glUniform4ui(location, v0, v1, v2, v3);
+}
+PFN_glUniform4ui _glptr_glUniform4ui = _impl_glUniform4ui;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4usv (GLuint index, const GLushort * v) {
+  _glptr_glVertexAttribI4usv = (PFN_glVertexAttribI4usv)GalogenGetProcAddress("glVertexAttribI4usv");
+   _glptr_glVertexAttribI4usv(index, v);
+}
+PFN_glVertexAttribI4usv _glptr_glVertexAttribI4usv = _impl_glVertexAttribI4usv;
+
+static void  GL_APIENTRY _impl_glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexImage2D = (PFN_glCompressedTexImage2D)GalogenGetProcAddress("glCompressedTexImage2D");
+   _glptr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+}
+PFN_glCompressedTexImage2D _glptr_glCompressedTexImage2D = _impl_glCompressedTexImage2D;
+
+static void  GL_APIENTRY _impl_glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexImage3D = (PFN_glCompressedTexImage3D)GalogenGetProcAddress("glCompressedTexImage3D");
+   _glptr_glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+}
+PFN_glCompressedTexImage3D _glptr_glCompressedTexImage3D = _impl_glCompressedTexImage3D;
+
+static void  GL_APIENTRY _impl_glSampleCoverage (GLfloat value, GLboolean invert) {
+  _glptr_glSampleCoverage = (PFN_glSampleCoverage)GalogenGetProcAddress("glSampleCoverage");
+   _glptr_glSampleCoverage(value, invert);
+}
+PFN_glSampleCoverage _glptr_glSampleCoverage = _impl_glSampleCoverage;
+
+static void  GL_APIENTRY _impl_glActiveTexture (GLenum texture) {
+  _glptr_glActiveTexture = (PFN_glActiveTexture)GalogenGetProcAddress("glActiveTexture");
+   _glptr_glActiveTexture(texture);
+}
+PFN_glActiveTexture _glptr_glActiveTexture = _impl_glActiveTexture;
+
+static void  GL_APIENTRY _impl_glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
+  _glptr_glCopyTexSubImage3D = (PFN_glCopyTexSubImage3D)GalogenGetProcAddress("glCopyTexSubImage3D");
+   _glptr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+}
+PFN_glCopyTexSubImage3D _glptr_glCopyTexSubImage3D = _impl_glCopyTexSubImage3D;
+
+static void  GL_APIENTRY _impl_glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexImage1D = (PFN_glCompressedTexImage1D)GalogenGetProcAddress("glCompressedTexImage1D");
+   _glptr_glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+}
+PFN_glCompressedTexImage1D _glptr_glCompressedTexImage1D = _impl_glCompressedTexImage1D;
+
+static void  GL_APIENTRY _impl_glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexSubImage3D = (PFN_glTexSubImage3D)GalogenGetProcAddress("glTexSubImage3D");
+   _glptr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+}
+PFN_glTexSubImage3D _glptr_glTexSubImage3D = _impl_glTexSubImage3D;
+
+static void  GL_APIENTRY _impl_glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix4fv = (PFN_glUniformMatrix4fv)GalogenGetProcAddress("glUniformMatrix4fv");
+   _glptr_glUniformMatrix4fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix4fv _glptr_glUniformMatrix4fv = _impl_glUniformMatrix4fv;
+
+static const GLubyte * GL_APIENTRY _impl_glGetString (GLenum name) {
+  _glptr_glGetString = (PFN_glGetString)GalogenGetProcAddress("glGetString");
+  return _glptr_glGetString(name);
+}
+PFN_glGetString _glptr_glGetString = _impl_glGetString;
+
+static void  GL_APIENTRY _impl_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
+  _glptr_glRenderbufferStorage = (PFN_glRenderbufferStorage)GalogenGetProcAddress("glRenderbufferStorage");
+   _glptr_glRenderbufferStorage(target, internalformat, width, height);
+}
+PFN_glRenderbufferStorage _glptr_glRenderbufferStorage = _impl_glRenderbufferStorage;
+
+static GLboolean GL_APIENTRY _impl_glIsTexture (GLuint texture) {
+  _glptr_glIsTexture = (PFN_glIsTexture)GalogenGetProcAddress("glIsTexture");
+  return _glptr_glIsTexture(texture);
+}
+PFN_glIsTexture _glptr_glIsTexture = _impl_glIsTexture;
+
+static void  GL_APIENTRY _impl_glGenTextures (GLsizei n, GLuint * textures) {
+  _glptr_glGenTextures = (PFN_glGenTextures)GalogenGetProcAddress("glGenTextures");
+   _glptr_glGenTextures(n, textures);
+}
+PFN_glGenTextures _glptr_glGenTextures = _impl_glGenTextures;
+
+static void  GL_APIENTRY _impl_glVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
+  _glptr_glVertexAttribP3ui = (PFN_glVertexAttribP3ui)GalogenGetProcAddress("glVertexAttribP3ui");
+   _glptr_glVertexAttribP3ui(index, type, normalized, value);
+}
+PFN_glVertexAttribP3ui _glptr_glVertexAttribP3ui = _impl_glVertexAttribP3ui;
+
+static void  GL_APIENTRY _impl_glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexSubImage1D = (PFN_glTexSubImage1D)GalogenGetProcAddress("glTexSubImage1D");
+   _glptr_glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
+}
+PFN_glTexSubImage1D _glptr_glTexSubImage1D = _impl_glTexSubImage1D;
+
+static GLenum GL_APIENTRY _impl_glClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
+  _glptr_glClientWaitSync = (PFN_glClientWaitSync)GalogenGetProcAddress("glClientWaitSync");
+  return _glptr_glClientWaitSync(sync, flags, timeout);
+}
+PFN_glClientWaitSync _glptr_glClientWaitSync = _impl_glClientWaitSync;
+
+static void  GL_APIENTRY _impl_glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
+  _glptr_glCopyTexSubImage2D = (PFN_glCopyTexSubImage2D)GalogenGetProcAddress("glCopyTexSubImage2D");
+   _glptr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+}
+PFN_glCopyTexSubImage2D _glptr_glCopyTexSubImage2D = _impl_glCopyTexSubImage2D;
+
+static void  GL_APIENTRY _impl_glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
+  _glptr_glCopyTexSubImage1D = (PFN_glCopyTexSubImage1D)GalogenGetProcAddress("glCopyTexSubImage1D");
+   _glptr_glCopyTexSubImage1D(target, level, xoffset, x, y, width);
+}
+PFN_glCopyTexSubImage1D _glptr_glCopyTexSubImage1D = _impl_glCopyTexSubImage1D;
+
+static void  GL_APIENTRY _impl_glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
+  _glptr_glCopyTexImage1D = (PFN_glCopyTexImage1D)GalogenGetProcAddress("glCopyTexImage1D");
+   _glptr_glCopyTexImage1D(target, level, internalformat, x, y, width, border);
+}
+PFN_glCopyTexImage1D _glptr_glCopyTexImage1D = _impl_glCopyTexImage1D;
+
+static void  GL_APIENTRY _impl_glPolygonOffset (GLfloat factor, GLfloat units) {
+  _glptr_glPolygonOffset = (PFN_glPolygonOffset)GalogenGetProcAddress("glPolygonOffset");
+   _glptr_glPolygonOffset(factor, units);
+}
+PFN_glPolygonOffset _glptr_glPolygonOffset = _impl_glPolygonOffset;
+
+static void  GL_APIENTRY _impl_glTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
+  _glptr_glTexImage2DMultisample = (PFN_glTexImage2DMultisample)GalogenGetProcAddress("glTexImage2DMultisample");
+   _glptr_glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+}
+PFN_glTexImage2DMultisample _glptr_glTexImage2DMultisample = _impl_glTexImage2DMultisample;
+
+static void  GL_APIENTRY _impl_glDrawElements (GLenum mode, GLsizei count, GLenum type, const void * indices) {
+  _glptr_glDrawElements = (PFN_glDrawElements)GalogenGetProcAddress("glDrawElements");
+   _glptr_glDrawElements(mode, count, type, indices);
+}
+PFN_glDrawElements _glptr_glDrawElements = _impl_glDrawElements;
+
+static void  GL_APIENTRY _impl_glEndConditionalRender () {
+  _glptr_glEndConditionalRender = (PFN_glEndConditionalRender)GalogenGetProcAddress("glEndConditionalRender");
+   _glptr_glEndConditionalRender();
+}
+PFN_glEndConditionalRender _glptr_glEndConditionalRender = _impl_glEndConditionalRender;
+
+static void  GL_APIENTRY _impl_glGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) {
+  _glptr_glGetTransformFeedbackVarying = (PFN_glGetTransformFeedbackVarying)GalogenGetProcAddress("glGetTransformFeedbackVarying");
+   _glptr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+}
+PFN_glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying = _impl_glGetTransformFeedbackVarying;
+
+static void  GL_APIENTRY _impl_glTexParameteriv (GLenum target, GLenum pname, const GLint * params) {
+  _glptr_glTexParameteriv = (PFN_glTexParameteriv)GalogenGetProcAddress("glTexParameteriv");
+   _glptr_glTexParameteriv(target, pname, params);
+}
+PFN_glTexParameteriv _glptr_glTexParameteriv = _impl_glTexParameteriv;
+
+static void  GL_APIENTRY _impl_glDeleteFramebuffers (GLsizei n, const GLuint * framebuffers) {
+  _glptr_glDeleteFramebuffers = (PFN_glDeleteFramebuffers)GalogenGetProcAddress("glDeleteFramebuffers");
+   _glptr_glDeleteFramebuffers(n, framebuffers);
+}
+PFN_glDeleteFramebuffers _glptr_glDeleteFramebuffers = _impl_glDeleteFramebuffers;
+
+static void  GL_APIENTRY _impl_glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha) {
+  _glptr_glBlendEquationSeparate = (PFN_glBlendEquationSeparate)GalogenGetProcAddress("glBlendEquationSeparate");
+   _glptr_glBlendEquationSeparate(modeRGB, modeAlpha);
+}
+PFN_glBlendEquationSeparate _glptr_glBlendEquationSeparate = _impl_glBlendEquationSeparate;
+
+static void  GL_APIENTRY _impl_glDeleteTextures (GLsizei n, const GLuint * textures) {
+  _glptr_glDeleteTextures = (PFN_glDeleteTextures)GalogenGetProcAddress("glDeleteTextures");
+   _glptr_glDeleteTextures(n, textures);
+}
+PFN_glDeleteTextures _glptr_glDeleteTextures = _impl_glDeleteTextures;
+
+static void  GL_APIENTRY _impl_glGetProgramiv (GLuint program, GLenum pname, GLint * params) {
+  _glptr_glGetProgramiv = (PFN_glGetProgramiv)GalogenGetProcAddress("glGetProgramiv");
+   _glptr_glGetProgramiv(program, pname, params);
+}
+PFN_glGetProgramiv _glptr_glGetProgramiv = _impl_glGetProgramiv;
+
+static void  GL_APIENTRY _impl_glUniform1uiv (GLint location, GLsizei count, const GLuint * value) {
+  _glptr_glUniform1uiv = (PFN_glUniform1uiv)GalogenGetProcAddress("glUniform1uiv");
+   _glptr_glUniform1uiv(location, count, value);
+}
+PFN_glUniform1uiv _glptr_glUniform1uiv = _impl_glUniform1uiv;
+
+static void  GL_APIENTRY _impl_glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
+  _glptr_glCopyTexImage2D = (PFN_glCopyTexImage2D)GalogenGetProcAddress("glCopyTexImage2D");
+   _glptr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+}
+PFN_glCopyTexImage2D _glptr_glCopyTexImage2D = _impl_glCopyTexImage2D;
+
+static void  GL_APIENTRY _impl_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat * params) {
+  _glptr_glGetTexLevelParameterfv = (PFN_glGetTexLevelParameterfv)GalogenGetProcAddress("glGetTexLevelParameterfv");
+   _glptr_glGetTexLevelParameterfv(target, level, pname, params);
+}
+PFN_glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv = _impl_glGetTexLevelParameterfv;
+
+static void  GL_APIENTRY _impl_glSampleMaski (GLuint maskNumber, GLbitfield mask) {
+  _glptr_glSampleMaski = (PFN_glSampleMaski)GalogenGetProcAddress("glSampleMaski");
+   _glptr_glSampleMaski(maskNumber, mask);
+}
+PFN_glSampleMaski _glptr_glSampleMaski = _impl_glSampleMaski;
+
+static void  GL_APIENTRY _impl_glBindTexture (GLenum target, GLuint texture) {
+  _glptr_glBindTexture = (PFN_glBindTexture)GalogenGetProcAddress("glBindTexture");
+   _glptr_glBindTexture(target, texture);
+}
+PFN_glBindTexture _glptr_glBindTexture = _impl_glBindTexture;
+
+static void  GL_APIENTRY _impl_glGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) {
+  _glptr_glGetActiveUniformBlockiv = (PFN_glGetActiveUniformBlockiv)GalogenGetProcAddress("glGetActiveUniformBlockiv");
+   _glptr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+}
+PFN_glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv = _impl_glGetActiveUniformBlockiv;
+
+static void  GL_APIENTRY _impl_glGetUniformuiv (GLuint program, GLint location, GLuint * params) {
+  _glptr_glGetUniformuiv = (PFN_glGetUniformuiv)GalogenGetProcAddress("glGetUniformuiv");
+   _glptr_glGetUniformuiv(program, location, params);
+}
+PFN_glGetUniformuiv _glptr_glGetUniformuiv = _impl_glGetUniformuiv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nbv (GLuint index, const GLbyte * v) {
+  _glptr_glVertexAttrib4Nbv = (PFN_glVertexAttrib4Nbv)GalogenGetProcAddress("glVertexAttrib4Nbv");
+   _glptr_glVertexAttrib4Nbv(index, v);
+}
+PFN_glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv = _impl_glVertexAttrib4Nbv;
+
+static void  GL_APIENTRY _impl_glTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexImage3D = (PFN_glTexImage3D)GalogenGetProcAddress("glTexImage3D");
+   _glptr_glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+}
+PFN_glTexImage3D _glptr_glTexImage3D = _impl_glTexImage3D;
+
+static void  GL_APIENTRY _impl_glQueryCounter (GLuint id, GLenum target) {
+  _glptr_glQueryCounter = (PFN_glQueryCounter)GalogenGetProcAddress("glQueryCounter");
+   _glptr_glQueryCounter(id, target);
+}
+PFN_glQueryCounter _glptr_glQueryCounter = _impl_glQueryCounter;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
+  _glptr_glVertexAttrib4f = (PFN_glVertexAttrib4f)GalogenGetProcAddress("glVertexAttrib4f");
+   _glptr_glVertexAttrib4f(index, x, y, z, w);
+}
+PFN_glVertexAttrib4f _glptr_glVertexAttrib4f = _impl_glVertexAttrib4f;
+
+static void  GL_APIENTRY _impl_glUniform2ui (GLint location, GLuint v0, GLuint v1) {
+  _glptr_glUniform2ui = (PFN_glUniform2ui)GalogenGetProcAddress("glUniform2ui");
+   _glptr_glUniform2ui(location, v0, v1);
+}
+PFN_glUniform2ui _glptr_glUniform2ui = _impl_glUniform2ui;
+
+static void  GL_APIENTRY _impl_glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void * pixels) {
+  _glptr_glGetTexImage = (PFN_glGetTexImage)GalogenGetProcAddress("glGetTexImage");
+   _glptr_glGetTexImage(target, level, format, type, pixels);
+}
+PFN_glGetTexImage _glptr_glGetTexImage = _impl_glGetTexImage;
+
+static void  GL_APIENTRY _impl_glGetTexParameterIuiv (GLenum target, GLenum pname, GLuint * params) {
+  _glptr_glGetTexParameterIuiv = (PFN_glGetTexParameterIuiv)GalogenGetProcAddress("glGetTexParameterIuiv");
+   _glptr_glGetTexParameterIuiv(target, pname, params);
+}
+PFN_glGetTexParameterIuiv _glptr_glGetTexParameterIuiv = _impl_glGetTexParameterIuiv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4bv (GLuint index, const GLbyte * v) {
+  _glptr_glVertexAttrib4bv = (PFN_glVertexAttrib4bv)GalogenGetProcAddress("glVertexAttrib4bv");
+   _glptr_glVertexAttrib4bv(index, v);
+}
+PFN_glVertexAttrib4bv _glptr_glVertexAttrib4bv = _impl_glVertexAttrib4bv;
+
+static void  GL_APIENTRY _impl_glUniform2uiv (GLint location, GLsizei count, const GLuint * value) {
+  _glptr_glUniform2uiv = (PFN_glUniform2uiv)GalogenGetProcAddress("glUniform2uiv");
+   _glptr_glUniform2uiv(location, count, value);
+}
+PFN_glUniform2uiv _glptr_glUniform2uiv = _impl_glUniform2uiv;
+
+static void  GL_APIENTRY _impl_glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) {
+  _glptr_glGetShaderSource = (PFN_glGetShaderSource)GalogenGetProcAddress("glGetShaderSource");
+   _glptr_glGetShaderSource(shader, bufSize, length, source);
+}
+PFN_glGetShaderSource _glptr_glGetShaderSource = _impl_glGetShaderSource;
+
+static GLboolean GL_APIENTRY _impl_glIsBuffer (GLuint buffer) {
+  _glptr_glIsBuffer = (PFN_glIsBuffer)GalogenGetProcAddress("glIsBuffer");
+  return _glptr_glIsBuffer(buffer);
+}
+PFN_glIsBuffer _glptr_glIsBuffer = _impl_glIsBuffer;
+
+static void  GL_APIENTRY _impl_glGetBufferPointerv (GLenum target, GLenum pname, void ** params) {
+  _glptr_glGetBufferPointerv = (PFN_glGetBufferPointerv)GalogenGetProcAddress("glGetBufferPointerv");
+   _glptr_glGetBufferPointerv(target, pname, params);
+}
+PFN_glGetBufferPointerv _glptr_glGetBufferPointerv = _impl_glGetBufferPointerv;
+
+static void  GL_APIENTRY _impl_glPolygonMode (GLenum face, GLenum mode) {
+  _glptr_glPolygonMode = (PFN_glPolygonMode)GalogenGetProcAddress("glPolygonMode");
+   _glptr_glPolygonMode(face, mode);
+}
+PFN_glPolygonMode _glptr_glPolygonMode = _impl_glPolygonMode;
+
+static void  GL_APIENTRY _impl_glBindAttribLocation (GLuint program, GLuint index, const GLchar * name) {
+  _glptr_glBindAttribLocation = (PFN_glBindAttribLocation)GalogenGetProcAddress("glBindAttribLocation");
+   _glptr_glBindAttribLocation(program, index, name);
+}
+PFN_glBindAttribLocation _glptr_glBindAttribLocation = _impl_glBindAttribLocation;
+
+static void  GL_APIENTRY _impl_glDeleteSamplers (GLsizei count, const GLuint * samplers) {
+  _glptr_glDeleteSamplers = (PFN_glDeleteSamplers)GalogenGetProcAddress("glDeleteSamplers");
+   _glptr_glDeleteSamplers(count, samplers);
+}
+PFN_glDeleteSamplers _glptr_glDeleteSamplers = _impl_glDeleteSamplers;
+
+static void  GL_APIENTRY _impl_glUniform2f (GLint location, GLfloat v0, GLfloat v1) {
+  _glptr_glUniform2f = (PFN_glUniform2f)GalogenGetProcAddress("glUniform2f");
+   _glptr_glUniform2f(location, v0, v1);
+}
+PFN_glUniform2f _glptr_glUniform2f = _impl_glUniform2f;
+
+static void  GL_APIENTRY _impl_glPixelStoref (GLenum pname, GLfloat param) {
+  _glptr_glPixelStoref = (PFN_glPixelStoref)GalogenGetProcAddress("glPixelStoref");
+   _glptr_glPixelStoref(pname, param);
+}
+PFN_glPixelStoref _glptr_glPixelStoref = _impl_glPixelStoref;
+
+static void  GL_APIENTRY _impl_glLogicOp (GLenum opcode) {
+  _glptr_glLogicOp = (PFN_glLogicOp)GalogenGetProcAddress("glLogicOp");
+   _glptr_glLogicOp(opcode);
+}
+PFN_glLogicOp _glptr_glLogicOp = _impl_glLogicOp;
+
+static GLuint GL_APIENTRY _impl_glCreateShader (GLenum type) {
+  _glptr_glCreateShader = (PFN_glCreateShader)GalogenGetProcAddress("glCreateShader");
+  return _glptr_glCreateShader(type);
+}
+PFN_glCreateShader _glptr_glCreateShader = _impl_glCreateShader;
+
+static void  GL_APIENTRY _impl_glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexSubImage2D = (PFN_glTexSubImage2D)GalogenGetProcAddress("glTexSubImage2D");
+   _glptr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+}
+PFN_glTexSubImage2D _glptr_glTexSubImage2D = _impl_glTexSubImage2D;
+
+static void  GL_APIENTRY _impl_glClearDepth (GLdouble depth) {
+  _glptr_glClearDepth = (PFN_glClearDepth)GalogenGetProcAddress("glClearDepth");
+   _glptr_glClearDepth(depth);
+}
+PFN_glClearDepth _glptr_glClearDepth = _impl_glClearDepth;
+
+static void  GL_APIENTRY _impl_glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void * data) {
+  _glptr_glGetBufferSubData = (PFN_glGetBufferSubData)GalogenGetProcAddress("glGetBufferSubData");
+   _glptr_glGetBufferSubData(target, offset, size, data);
+}
+PFN_glGetBufferSubData _glptr_glGetBufferSubData = _impl_glGetBufferSubData;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4uiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttrib4uiv = (PFN_glVertexAttrib4uiv)GalogenGetProcAddress("glVertexAttrib4uiv");
+   _glptr_glVertexAttrib4uiv(index, v);
+}
+PFN_glVertexAttrib4uiv _glptr_glVertexAttrib4uiv = _impl_glVertexAttrib4uiv;
+
+static void  GL_APIENTRY _impl_glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
+  _glptr_glCopyBufferSubData = (PFN_glCopyBufferSubData)GalogenGetProcAddress("glCopyBufferSubData");
+   _glptr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+}
+PFN_glCopyBufferSubData _glptr_glCopyBufferSubData = _impl_glCopyBufferSubData;
+
+static void  GL_APIENTRY _impl_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
+  _glptr_glFramebufferTexture2D = (PFN_glFramebufferTexture2D)GalogenGetProcAddress("glFramebufferTexture2D");
+   _glptr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
+}
+PFN_glFramebufferTexture2D _glptr_glFramebufferTexture2D = _impl_glFramebufferTexture2D;
+
+static void  GL_APIENTRY _impl_glPointParameterf (GLenum pname, GLfloat param) {
+  _glptr_glPointParameterf = (PFN_glPointParameterf)GalogenGetProcAddress("glPointParameterf");
+   _glptr_glPointParameterf(pname, param);
+}
+PFN_glPointParameterf _glptr_glPointParameterf = _impl_glPointParameterf;
+
+static void  GL_APIENTRY _impl_glDisablei (GLenum target, GLuint index) {
+  _glptr_glDisablei = (PFN_glDisablei)GalogenGetProcAddress("glDisablei");
+   _glptr_glDisablei(target, index);
+}
+PFN_glDisablei _glptr_glDisablei = _impl_glDisablei;
+
+static void  GL_APIENTRY _impl_glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
+  _glptr_glUniformMatrix4x2fv = (PFN_glUniformMatrix4x2fv)GalogenGetProcAddress("glUniformMatrix4x2fv");
+   _glptr_glUniformMatrix4x2fv(location, count, transpose, value);
+}
+PFN_glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv = _impl_glUniformMatrix4x2fv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
+  _glptr_glVertexAttrib4d = (PFN_glVertexAttrib4d)GalogenGetProcAddress("glVertexAttrib4d");
+   _glptr_glVertexAttrib4d(index, x, y, z, w);
+}
+PFN_glVertexAttrib4d _glptr_glVertexAttrib4d = _impl_glVertexAttrib4d;
+
+static void  GL_APIENTRY _impl_glTexParameterIuiv (GLenum target, GLenum pname, const GLuint * params) {
+  _glptr_glTexParameterIuiv = (PFN_glTexParameterIuiv)GalogenGetProcAddress("glTexParameterIuiv");
+   _glptr_glTexParameterIuiv(target, pname, params);
+}
+PFN_glTexParameterIuiv _glptr_glTexParameterIuiv = _impl_glTexParameterIuiv;
+
+static void  GL_APIENTRY _impl_glGetFloatv (GLenum pname, GLfloat * data) {
+  _glptr_glGetFloatv = (PFN_glGetFloatv)GalogenGetProcAddress("glGetFloatv");
+   _glptr_glGetFloatv(pname, data);
+}
+PFN_glGetFloatv _glptr_glGetFloatv = _impl_glGetFloatv;
+
+static GLuint GL_APIENTRY _impl_glCreateProgram () {
+  _glptr_glCreateProgram = (PFN_glCreateProgram)GalogenGetProcAddress("glCreateProgram");
+  return _glptr_glCreateProgram();
+}
+PFN_glCreateProgram _glptr_glCreateProgram = _impl_glCreateProgram;
+
+static void  GL_APIENTRY _impl_glTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode) {
+  _glptr_glTransformFeedbackVaryings = (PFN_glTransformFeedbackVaryings)GalogenGetProcAddress("glTransformFeedbackVaryings");
+   _glptr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
+}
+PFN_glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings = _impl_glTransformFeedbackVaryings;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1d (GLuint index, GLdouble x) {
+  _glptr_glVertexAttrib1d = (PFN_glVertexAttrib1d)GalogenGetProcAddress("glVertexAttrib1d");
+   _glptr_glVertexAttrib1d(index, x);
+}
+PFN_glVertexAttrib1d _glptr_glVertexAttrib1d = _impl_glVertexAttrib1d;
+
+static void  GL_APIENTRY _impl_glViewport (GLint x, GLint y, GLsizei width, GLsizei height) {
+  _glptr_glViewport = (PFN_glViewport)GalogenGetProcAddress("glViewport");
+   _glptr_glViewport(x, y, width, height);
+}
+PFN_glViewport _glptr_glViewport = _impl_glViewport;
+
+static void  GL_APIENTRY _impl_glDeleteBuffers (GLsizei n, const GLuint * buffers) {
+  _glptr_glDeleteBuffers = (PFN_glDeleteBuffers)GalogenGetProcAddress("glDeleteBuffers");
+   _glptr_glDeleteBuffers(n, buffers);
+}
+PFN_glDeleteBuffers _glptr_glDeleteBuffers = _impl_glDeleteBuffers;
+
+static void  GL_APIENTRY _impl_glFlush () {
+  _glptr_glFlush = (PFN_glFlush)GalogenGetProcAddress("glFlush");
+   _glptr_glFlush();
+}
+PFN_glFlush _glptr_glFlush = _impl_glFlush;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4sv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttribI4sv = (PFN_glVertexAttribI4sv)GalogenGetProcAddress("glVertexAttribI4sv");
+   _glptr_glVertexAttribI4sv(index, v);
+}
+PFN_glVertexAttribI4sv _glptr_glVertexAttribI4sv = _impl_glVertexAttribI4sv;
+
+static void  GL_APIENTRY _impl_glDrawArrays (GLenum mode, GLint first, GLsizei count) {
+  _glptr_glDrawArrays = (PFN_glDrawArrays)GalogenGetProcAddress("glDrawArrays");
+   _glptr_glDrawArrays(mode, first, count);
+}
+PFN_glDrawArrays _glptr_glDrawArrays = _impl_glDrawArrays;
+
+static void  GL_APIENTRY _impl_glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount) {
+  _glptr_glDrawElementsInstanced = (PFN_glDrawElementsInstanced)GalogenGetProcAddress("glDrawElementsInstanced");
+   _glptr_glDrawElementsInstanced(mode, count, type, indices, instancecount);
+}
+PFN_glDrawElementsInstanced _glptr_glDrawElementsInstanced = _impl_glDrawElementsInstanced;
+
+static void  GL_APIENTRY _impl_glUniform3iv (GLint location, GLsizei count, const GLint * value) {
+  _glptr_glUniform3iv = (PFN_glUniform3iv)GalogenGetProcAddress("glUniform3iv");
+   _glptr_glUniform3iv(location, count, value);
+}
+PFN_glUniform3iv _glptr_glUniform3iv = _impl_glUniform3iv;
+
+static void  GL_APIENTRY _impl_glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer) {
+  _glptr_glVertexAttribPointer = (PFN_glVertexAttribPointer)GalogenGetProcAddress("glVertexAttribPointer");
+   _glptr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
+}
+PFN_glVertexAttribPointer _glptr_glVertexAttribPointer = _impl_glVertexAttribPointer;
+
+static void  GL_APIENTRY _impl_glGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values) {
+  _glptr_glGetSynciv = (PFN_glGetSynciv)GalogenGetProcAddress("glGetSynciv");
+   _glptr_glGetSynciv(sync, pname, bufSize, length, values);
+}
+PFN_glGetSynciv _glptr_glGetSynciv = _impl_glGetSynciv;
+
+static void  GL_APIENTRY _impl_glPrimitiveRestartIndex (GLuint index) {
+  _glptr_glPrimitiveRestartIndex = (PFN_glPrimitiveRestartIndex)GalogenGetProcAddress("glPrimitiveRestartIndex");
+   _glptr_glPrimitiveRestartIndex(index);
+}
+PFN_glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex = _impl_glPrimitiveRestartIndex;
+
+static void  GL_APIENTRY _impl_glUniform1i (GLint location, GLint v0) {
+  _glptr_glUniform1i = (PFN_glUniform1i)GalogenGetProcAddress("glUniform1i");
+   _glptr_glUniform1i(location, v0);
+}
+PFN_glUniform1i _glptr_glUniform1i = _impl_glUniform1i;
+
+static void  GL_APIENTRY _impl_glVertexAttrib1sv (GLuint index, const GLshort * v) {
+  _glptr_glVertexAttrib1sv = (PFN_glVertexAttrib1sv)GalogenGetProcAddress("glVertexAttrib1sv");
+   _glptr_glVertexAttrib1sv(index, v);
+}
+PFN_glVertexAttrib1sv _glptr_glVertexAttrib1sv = _impl_glVertexAttrib1sv;
+
+static void  GL_APIENTRY _impl_glDisable (GLenum cap) {
+  _glptr_glDisable = (PFN_glDisable)GalogenGetProcAddress("glDisable");
+   _glptr_glDisable(cap);
+}
+PFN_glDisable _glptr_glDisable = _impl_glDisable;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4uiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttribI4uiv = (PFN_glVertexAttribI4uiv)GalogenGetProcAddress("glVertexAttribI4uiv");
+   _glptr_glVertexAttribI4uiv(index, v);
+}
+PFN_glVertexAttribI4uiv _glptr_glVertexAttribI4uiv = _impl_glVertexAttribI4uiv;
+
+static void  GL_APIENTRY _impl_glEndQuery (GLenum target) {
+  _glptr_glEndQuery = (PFN_glEndQuery)GalogenGetProcAddress("glEndQuery");
+   _glptr_glEndQuery(target);
+}
+PFN_glEndQuery _glptr_glEndQuery = _impl_glEndQuery;
+
+static void  GL_APIENTRY _impl_glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
+  _glptr_glColorMask = (PFN_glColorMask)GalogenGetProcAddress("glColorMask");
+   _glptr_glColorMask(red, green, blue, alpha);
+}
+PFN_glColorMask _glptr_glColorMask = _impl_glColorMask;
+
+static void  GL_APIENTRY _impl_glEnablei (GLenum target, GLuint index) {
+  _glptr_glEnablei = (PFN_glEnablei)GalogenGetProcAddress("glEnablei");
+   _glptr_glEnablei(target, index);
+}
+PFN_glEnablei _glptr_glEnablei = _impl_glEnablei;
+
+static void  GL_APIENTRY _impl_glBindBuffer (GLenum target, GLuint buffer) {
+  _glptr_glBindBuffer = (PFN_glBindBuffer)GalogenGetProcAddress("glBindBuffer");
+   _glptr_glBindBuffer(target, buffer);
+}
+PFN_glBindBuffer _glptr_glBindBuffer = _impl_glBindBuffer;
+
+static void  GL_APIENTRY _impl_glGetDoublev (GLenum pname, GLdouble * data) {
+  _glptr_glGetDoublev = (PFN_glGetDoublev)GalogenGetProcAddress("glGetDoublev");
+   _glptr_glGetDoublev(pname, data);
+}
+PFN_glGetDoublev _glptr_glGetDoublev = _impl_glGetDoublev;
+
+static void  GL_APIENTRY _impl_glGetTexParameteriv (GLenum target, GLenum pname, GLint * params) {
+  _glptr_glGetTexParameteriv = (PFN_glGetTexParameteriv)GalogenGetProcAddress("glGetTexParameteriv");
+   _glptr_glGetTexParameteriv(target, pname, params);
+}
+PFN_glGetTexParameteriv _glptr_glGetTexParameteriv = _impl_glGetTexParameteriv;
+
+static void  GL_APIENTRY _impl_glDeleteVertexArrays (GLsizei n, const GLuint * arrays) {
+  _glptr_glDeleteVertexArrays = (PFN_glDeleteVertexArrays)GalogenGetProcAddress("glDeleteVertexArrays");
+   _glptr_glDeleteVertexArrays(n, arrays);
+}
+PFN_glDeleteVertexArrays _glptr_glDeleteVertexArrays = _impl_glDeleteVertexArrays;
+
+static void  GL_APIENTRY _impl_glVertexAttribI2uiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttribI2uiv = (PFN_glVertexAttribI2uiv)GalogenGetProcAddress("glVertexAttribI2uiv");
+   _glptr_glVertexAttribI2uiv(index, v);
+}
+PFN_glVertexAttribI2uiv _glptr_glVertexAttribI2uiv = _impl_glVertexAttribI2uiv;
+
+static void  GL_APIENTRY _impl_glDepthMask (GLboolean flag) {
+  _glptr_glDepthMask = (PFN_glDepthMask)GalogenGetProcAddress("glDepthMask");
+   _glptr_glDepthMask(flag);
+}
+PFN_glDepthMask _glptr_glDepthMask = _impl_glDepthMask;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribdv (GLuint index, GLenum pname, GLdouble * params) {
+  _glptr_glGetVertexAttribdv = (PFN_glGetVertexAttribdv)GalogenGetProcAddress("glGetVertexAttribdv");
+   _glptr_glGetVertexAttribdv(index, pname, params);
+}
+PFN_glGetVertexAttribdv _glptr_glGetVertexAttribdv = _impl_glGetVertexAttribdv;
+
+static void  GL_APIENTRY _impl_glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices) {
+  _glptr_glDrawRangeElements = (PFN_glDrawRangeElements)GalogenGetProcAddress("glDrawRangeElements");
+   _glptr_glDrawRangeElements(mode, start, end, count, type, indices);
+}
+PFN_glDrawRangeElements _glptr_glDrawRangeElements = _impl_glDrawRangeElements;
+
+static void  GL_APIENTRY _impl_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
+  _glptr_glDrawArraysInstanced = (PFN_glDrawArraysInstanced)GalogenGetProcAddress("glDrawArraysInstanced");
+   _glptr_glDrawArraysInstanced(mode, first, count, instancecount);
+}
+PFN_glDrawArraysInstanced _glptr_glDrawArraysInstanced = _impl_glDrawArraysInstanced;
+
+static void  GL_APIENTRY _impl_glGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint * params) {
+  _glptr_glGetSamplerParameterIiv = (PFN_glGetSamplerParameterIiv)GalogenGetProcAddress("glGetSamplerParameterIiv");
+   _glptr_glGetSamplerParameterIiv(sampler, pname, params);
+}
+PFN_glGetSamplerParameterIiv _glptr_glGetSamplerParameterIiv = _impl_glGetSamplerParameterIiv;
+
+static void  GL_APIENTRY _impl_glClearStencil (GLint s) {
+  _glptr_glClearStencil = (PFN_glClearStencil)GalogenGetProcAddress("glClearStencil");
+   _glptr_glClearStencil(s);
+}
+PFN_glClearStencil _glptr_glClearStencil = _impl_glClearStencil;
+
+static void  GL_APIENTRY _impl_glVertexAttribI3iv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttribI3iv = (PFN_glVertexAttribI3iv)GalogenGetProcAddress("glVertexAttribI3iv");
+   _glptr_glVertexAttribI3iv(index, v);
+}
+PFN_glVertexAttribI3iv _glptr_glVertexAttribI3iv = _impl_glVertexAttribI3iv;
+
+static void  GL_APIENTRY _impl_glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex) {
+  _glptr_glDrawRangeElementsBaseVertex = (PFN_glDrawRangeElementsBaseVertex)GalogenGetProcAddress("glDrawRangeElementsBaseVertex");
+   _glptr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+}
+PFN_glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex = _impl_glDrawRangeElementsBaseVertex;
+
+static void  GL_APIENTRY _impl_glScissor (GLint x, GLint y, GLsizei width, GLsizei height) {
+  _glptr_glScissor = (PFN_glScissor)GalogenGetProcAddress("glScissor");
+   _glptr_glScissor(x, y, width, height);
+}
+PFN_glScissor _glptr_glScissor = _impl_glScissor;
+
+static void  GL_APIENTRY _impl_glGenerateMipmap (GLenum target) {
+  _glptr_glGenerateMipmap = (PFN_glGenerateMipmap)GalogenGetProcAddress("glGenerateMipmap");
+   _glptr_glGenerateMipmap(target);
+}
+PFN_glGenerateMipmap _glptr_glGenerateMipmap = _impl_glGenerateMipmap;
+
+static void  GL_APIENTRY _impl_glUniform3fv (GLint location, GLsizei count, const GLfloat * value) {
+  _glptr_glUniform3fv = (PFN_glUniform3fv)GalogenGetProcAddress("glUniform3fv");
+   _glptr_glUniform3fv(location, count, value);
+}
+PFN_glUniform3fv _glptr_glUniform3fv = _impl_glUniform3fv;
+
+static void  GL_APIENTRY _impl_glUniform3uiv (GLint location, GLsizei count, const GLuint * value) {
+  _glptr_glUniform3uiv = (PFN_glUniform3uiv)GalogenGetProcAddress("glUniform3uiv");
+   _glptr_glUniform3uiv(location, count, value);
+}
+PFN_glUniform3uiv _glptr_glUniform3uiv = _impl_glUniform3uiv;
+
+static void  GL_APIENTRY _impl_glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint * value) {
+  _glptr_glClearBufferiv = (PFN_glClearBufferiv)GalogenGetProcAddress("glClearBufferiv");
+   _glptr_glClearBufferiv(buffer, drawbuffer, value);
+}
+PFN_glClearBufferiv _glptr_glClearBufferiv = _impl_glClearBufferiv;
+
+static void  GL_APIENTRY _impl_glVertexAttribI4ubv (GLuint index, const GLubyte * v) {
+  _glptr_glVertexAttribI4ubv = (PFN_glVertexAttribI4ubv)GalogenGetProcAddress("glVertexAttribI4ubv");
+   _glptr_glVertexAttribI4ubv(index, v);
+}
+PFN_glVertexAttribI4ubv _glptr_glVertexAttribI4ubv = _impl_glVertexAttribI4ubv;
+
+static void  GL_APIENTRY _impl_glGetBooleanv (GLenum pname, GLboolean * data) {
+  _glptr_glGetBooleanv = (PFN_glGetBooleanv)GalogenGetProcAddress("glGetBooleanv");
+   _glptr_glGetBooleanv(pname, data);
+}
+PFN_glGetBooleanv _glptr_glGetBooleanv = _impl_glGetBooleanv;
+
+static void  GL_APIENTRY _impl_glValidateProgram (GLuint program) {
+  _glptr_glValidateProgram = (PFN_glValidateProgram)GalogenGetProcAddress("glValidateProgram");
+   _glptr_glValidateProgram(program);
+}
+PFN_glValidateProgram _glptr_glValidateProgram = _impl_glValidateProgram;
+
+static void  GL_APIENTRY _impl_glGenRenderbuffers (GLsizei n, GLuint * renderbuffers) {
+  _glptr_glGenRenderbuffers = (PFN_glGenRenderbuffers)GalogenGetProcAddress("glGenRenderbuffers");
+   _glptr_glGenRenderbuffers(n, renderbuffers);
+}
+PFN_glGenRenderbuffers _glptr_glGenRenderbuffers = _impl_glGenRenderbuffers;
+
+static void  GL_APIENTRY _impl_glUniform2iv (GLint location, GLsizei count, const GLint * value) {
+  _glptr_glUniform2iv = (PFN_glUniform2iv)GalogenGetProcAddress("glUniform2iv");
+   _glptr_glUniform2iv(location, count, value);
+}
+PFN_glUniform2iv _glptr_glUniform2iv = _impl_glUniform2iv;
+
+static void  GL_APIENTRY _impl_glBufferData (GLenum target, GLsizeiptr size, const void * data, GLenum usage) {
+  _glptr_glBufferData = (PFN_glBufferData)GalogenGetProcAddress("glBufferData");
+   _glptr_glBufferData(target, size, data, usage);
+}
+PFN_glBufferData _glptr_glBufferData = _impl_glBufferData;
+
+static void  GL_APIENTRY _impl_glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
+  _glptr_glBlendFuncSeparate = (PFN_glBlendFuncSeparate)GalogenGetProcAddress("glBlendFuncSeparate");
+   _glptr_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+}
+PFN_glBlendFuncSeparate _glptr_glBlendFuncSeparate = _impl_glBlendFuncSeparate;
+
+static void  GL_APIENTRY _impl_glTexParameteri (GLenum target, GLenum pname, GLint param) {
+  _glptr_glTexParameteri = (PFN_glTexParameteri)GalogenGetProcAddress("glTexParameteri");
+   _glptr_glTexParameteri(target, pname, param);
+}
+PFN_glTexParameteri _glptr_glTexParameteri = _impl_glTexParameteri;
+
+static void  GL_APIENTRY _impl_glHint (GLenum target, GLenum mode) {
+  _glptr_glHint = (PFN_glHint)GalogenGetProcAddress("glHint");
+   _glptr_glHint(target, mode);
+}
+PFN_glHint _glptr_glHint = _impl_glHint;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3fv (GLuint index, const GLfloat * v) {
+  _glptr_glVertexAttrib3fv = (PFN_glVertexAttrib3fv)GalogenGetProcAddress("glVertexAttrib3fv");
+   _glptr_glVertexAttrib3fv(index, v);
+}
+PFN_glVertexAttrib3fv _glptr_glVertexAttrib3fv = _impl_glVertexAttrib3fv;
+
+static void  GL_APIENTRY _impl_glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint * params) {
+  _glptr_glGetSamplerParameteriv = (PFN_glGetSamplerParameteriv)GalogenGetProcAddress("glGetSamplerParameteriv");
+   _glptr_glGetSamplerParameteriv(sampler, pname, params);
+}
+PFN_glGetSamplerParameteriv _glptr_glGetSamplerParameteriv = _impl_glGetSamplerParameteriv;
+
+static void  GL_APIENTRY _impl_glDrawBuffer (GLenum buf) {
+  _glptr_glDrawBuffer = (PFN_glDrawBuffer)GalogenGetProcAddress("glDrawBuffer");
+   _glptr_glDrawBuffer(buf);
+}
+PFN_glDrawBuffer _glptr_glDrawBuffer = _impl_glDrawBuffer;
+
+static GLboolean GL_APIENTRY _impl_glIsProgram (GLuint program) {
+  _glptr_glIsProgram = (PFN_glIsProgram)GalogenGetProcAddress("glIsProgram");
+  return _glptr_glIsProgram(program);
+}
+PFN_glIsProgram _glptr_glIsProgram = _impl_glIsProgram;
+
+static void  GL_APIENTRY _impl_glGetIntegerv (GLenum pname, GLint * data) {
+  _glptr_glGetIntegerv = (PFN_glGetIntegerv)GalogenGetProcAddress("glGetIntegerv");
+   _glptr_glGetIntegerv(pname, data);
+}
+PFN_glGetIntegerv _glptr_glGetIntegerv = _impl_glGetIntegerv;
+
+static void  GL_APIENTRY _impl_glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex) {
+  _glptr_glDrawElementsBaseVertex = (PFN_glDrawElementsBaseVertex)GalogenGetProcAddress("glDrawElementsBaseVertex");
+   _glptr_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
+}
+PFN_glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex = _impl_glDrawElementsBaseVertex;
+
+static void  GL_APIENTRY _impl_glEnable (GLenum cap) {
+  _glptr_glEnable = (PFN_glEnable)GalogenGetProcAddress("glEnable");
+   _glptr_glEnable(cap);
+}
+PFN_glEnable _glptr_glEnable = _impl_glEnable;
+
+static void  GL_APIENTRY _impl_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
+  _glptr_glBlitFramebuffer = (PFN_glBlitFramebuffer)GalogenGetProcAddress("glBlitFramebuffer");
+   _glptr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+}
+PFN_glBlitFramebuffer _glptr_glBlitFramebuffer = _impl_glBlitFramebuffer;
+
+static void  GL_APIENTRY _impl_glBeginQuery (GLenum target, GLuint id) {
+  _glptr_glBeginQuery = (PFN_glBeginQuery)GalogenGetProcAddress("glBeginQuery");
+   _glptr_glBeginQuery(target, id);
+}
+PFN_glBeginQuery _glptr_glBeginQuery = _impl_glBeginQuery;
+
+static void  GL_APIENTRY _impl_glStencilMask (GLuint mask) {
+  _glptr_glStencilMask = (PFN_glStencilMask)GalogenGetProcAddress("glStencilMask");
+   _glptr_glStencilMask(mask);
+}
+PFN_glStencilMask _glptr_glStencilMask = _impl_glStencilMask;
+
+static void  GL_APIENTRY _impl_glAttachShader (GLuint program, GLuint shader) {
+  _glptr_glAttachShader = (PFN_glAttachShader)GalogenGetProcAddress("glAttachShader");
+   _glptr_glAttachShader(program, shader);
+}
+PFN_glAttachShader _glptr_glAttachShader = _impl_glAttachShader;
+
+static void  GL_APIENTRY _impl_glPointSize (GLfloat size) {
+  _glptr_glPointSize = (PFN_glPointSize)GalogenGetProcAddress("glPointSize");
+   _glptr_glPointSize(size);
+}
+PFN_glPointSize _glptr_glPointSize = _impl_glPointSize;
+
+static void  GL_APIENTRY _impl_glMultiDrawElements (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount) {
+  _glptr_glMultiDrawElements = (PFN_glMultiDrawElements)GalogenGetProcAddress("glMultiDrawElements");
+   _glptr_glMultiDrawElements(mode, count, type, indices, drawcount);
+}
+PFN_glMultiDrawElements _glptr_glMultiDrawElements = _impl_glMultiDrawElements;
+
+static void  GL_APIENTRY _impl_glGetTexParameterfv (GLenum target, GLenum pname, GLfloat * params) {
+  _glptr_glGetTexParameterfv = (PFN_glGetTexParameterfv)GalogenGetProcAddress("glGetTexParameterfv");
+   _glptr_glGetTexParameterfv(target, pname, params);
+}
+PFN_glGetTexParameterfv _glptr_glGetTexParameterfv = _impl_glGetTexParameterfv;
+
+static GLboolean GL_APIENTRY _impl_glIsEnabled (GLenum cap) {
+  _glptr_glIsEnabled = (PFN_glIsEnabled)GalogenGetProcAddress("glIsEnabled");
+  return _glptr_glIsEnabled(cap);
+}
+PFN_glIsEnabled _glptr_glIsEnabled = _impl_glIsEnabled;
+
+static void  GL_APIENTRY _impl_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint * params) {
+  _glptr_glGetTexLevelParameteriv = (PFN_glGetTexLevelParameteriv)GalogenGetProcAddress("glGetTexLevelParameteriv");
+   _glptr_glGetTexLevelParameteriv(target, level, pname, params);
+}
+PFN_glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv = _impl_glGetTexLevelParameteriv;
+
+static GLenum GL_APIENTRY _impl_glGetError () {
+  _glptr_glGetError = (PFN_glGetError)GalogenGetProcAddress("glGetError");
+  return _glptr_glGetError();
+}
+PFN_glGetError _glptr_glGetError = _impl_glGetError;
+
+static void  GL_APIENTRY _impl_glEndTransformFeedback () {
+  _glptr_glEndTransformFeedback = (PFN_glEndTransformFeedback)GalogenGetProcAddress("glEndTransformFeedback");
+   _glptr_glEndTransformFeedback();
+}
+PFN_glEndTransformFeedback _glptr_glEndTransformFeedback = _impl_glEndTransformFeedback;
+
+static void  GL_APIENTRY _impl_glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+  _glptr_glClearColor = (PFN_glClearColor)GalogenGetProcAddress("glClearColor");
+   _glptr_glClearColor(red, green, blue, alpha);
+}
+PFN_glClearColor _glptr_glClearColor = _impl_glClearColor;
+
+static void  GL_APIENTRY _impl_glBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
+  _glptr_glBlendColor = (PFN_glBlendColor)GalogenGetProcAddress("glBlendColor");
+   _glptr_glBlendColor(red, green, blue, alpha);
+}
+PFN_glBlendColor _glptr_glBlendColor = _impl_glBlendColor;
+
+static void  GL_APIENTRY _impl_glVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z) {
+  _glptr_glVertexAttribI3i = (PFN_glVertexAttribI3i)GalogenGetProcAddress("glVertexAttribI3i");
+   _glptr_glVertexAttribI3i(index, x, y, z);
+}
+PFN_glVertexAttribI3i _glptr_glVertexAttribI3i = _impl_glVertexAttribI3i;
+
+static void  GL_APIENTRY _impl_glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexSubImage3D = (PFN_glCompressedTexSubImage3D)GalogenGetProcAddress("glCompressedTexSubImage3D");
+   _glptr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+}
+PFN_glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D = _impl_glCompressedTexSubImage3D;
+
+static void  GL_APIENTRY _impl_glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels) {
+  _glptr_glReadPixels = (PFN_glReadPixels)GalogenGetProcAddress("glReadPixels");
+   _glptr_glReadPixels(x, y, width, height, format, type, pixels);
+}
+PFN_glReadPixels _glptr_glReadPixels = _impl_glReadPixels;
+
+static void  GL_APIENTRY _impl_glTexParameterf (GLenum target, GLenum pname, GLfloat param) {
+  _glptr_glTexParameterf = (PFN_glTexParameterf)GalogenGetProcAddress("glTexParameterf");
+   _glptr_glTexParameterf(target, pname, param);
+}
+PFN_glTexParameterf _glptr_glTexParameterf = _impl_glTexParameterf;
+
+static void  GL_APIENTRY _impl_glSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint * param) {
+  _glptr_glSamplerParameterIiv = (PFN_glSamplerParameterIiv)GalogenGetProcAddress("glSamplerParameterIiv");
+   _glptr_glSamplerParameterIiv(sampler, pname, param);
+}
+PFN_glSamplerParameterIiv _glptr_glSamplerParameterIiv = _impl_glSamplerParameterIiv;
+
+static void  GL_APIENTRY _impl_glPointParameterfv (GLenum pname, const GLfloat * params) {
+  _glptr_glPointParameterfv = (PFN_glPointParameterfv)GalogenGetProcAddress("glPointParameterfv");
+   _glptr_glPointParameterfv(pname, params);
+}
+PFN_glPointParameterfv _glptr_glPointParameterfv = _impl_glPointParameterfv;
+
+static void  GL_APIENTRY _impl_glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
+  _glptr_glGetShaderInfoLog = (PFN_glGetShaderInfoLog)GalogenGetProcAddress("glGetShaderInfoLog");
+   _glptr_glGetShaderInfoLog(shader, bufSize, length, infoLog);
+}
+PFN_glGetShaderInfoLog _glptr_glGetShaderInfoLog = _impl_glGetShaderInfoLog;
+
+static void  GL_APIENTRY _impl_glDepthFunc (GLenum func) {
+  _glptr_glDepthFunc = (PFN_glDepthFunc)GalogenGetProcAddress("glDepthFunc");
+   _glptr_glDepthFunc(func);
+}
+PFN_glDepthFunc _glptr_glDepthFunc = _impl_glDepthFunc;
+
+static void  GL_APIENTRY _impl_glVertexAttribI3uiv (GLuint index, const GLuint * v) {
+  _glptr_glVertexAttribI3uiv = (PFN_glVertexAttribI3uiv)GalogenGetProcAddress("glVertexAttribI3uiv");
+   _glptr_glVertexAttribI3uiv(index, v);
+}
+PFN_glVertexAttribI3uiv _glptr_glVertexAttribI3uiv = _impl_glVertexAttribI3uiv;
+
+static void  GL_APIENTRY _impl_glStencilOp (GLenum fail, GLenum zfail, GLenum zpass) {
+  _glptr_glStencilOp = (PFN_glStencilOp)GalogenGetProcAddress("glStencilOp");
+   _glptr_glStencilOp(fail, zfail, zpass);
+}
+PFN_glStencilOp _glptr_glStencilOp = _impl_glStencilOp;
+
+static void  GL_APIENTRY _impl_glStencilFunc (GLenum func, GLint ref, GLuint mask) {
+  _glptr_glStencilFunc = (PFN_glStencilFunc)GalogenGetProcAddress("glStencilFunc");
+   _glptr_glStencilFunc(func, ref, mask);
+}
+PFN_glStencilFunc _glptr_glStencilFunc = _impl_glStencilFunc;
+
+static void  GL_APIENTRY _impl_glEnableVertexAttribArray (GLuint index) {
+  _glptr_glEnableVertexAttribArray = (PFN_glEnableVertexAttribArray)GalogenGetProcAddress("glEnableVertexAttribArray");
+   _glptr_glEnableVertexAttribArray(index);
+}
+PFN_glEnableVertexAttribArray _glptr_glEnableVertexAttribArray = _impl_glEnableVertexAttribArray;
+
+static void  GL_APIENTRY _impl_glBlendFunc (GLenum sfactor, GLenum dfactor) {
+  _glptr_glBlendFunc = (PFN_glBlendFunc)GalogenGetProcAddress("glBlendFunc");
+   _glptr_glBlendFunc(sfactor, dfactor);
+}
+PFN_glBlendFunc _glptr_glBlendFunc = _impl_glBlendFunc;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
+  _glptr_glVertexAttrib4Nub = (PFN_glVertexAttrib4Nub)GalogenGetProcAddress("glVertexAttrib4Nub");
+   _glptr_glVertexAttrib4Nub(index, x, y, z, w);
+}
+PFN_glVertexAttrib4Nub _glptr_glVertexAttrib4Nub = _impl_glVertexAttrib4Nub;
+
+static void  GL_APIENTRY _impl_glUniform1fv (GLint location, GLsizei count, const GLfloat * value) {
+  _glptr_glUniform1fv = (PFN_glUniform1fv)GalogenGetProcAddress("glUniform1fv");
+   _glptr_glUniform1fv(location, count, value);
+}
+PFN_glUniform1fv _glptr_glUniform1fv = _impl_glUniform1fv;
+
+static void  GL_APIENTRY _impl_glPixelStorei (GLenum pname, GLint param) {
+  _glptr_glPixelStorei = (PFN_glPixelStorei)GalogenGetProcAddress("glPixelStorei");
+   _glptr_glPixelStorei(pname, param);
+}
+PFN_glPixelStorei _glptr_glPixelStorei = _impl_glPixelStorei;
+
+static void  GL_APIENTRY _impl_glLineWidth (GLfloat width) {
+  _glptr_glLineWidth = (PFN_glLineWidth)GalogenGetProcAddress("glLineWidth");
+   _glptr_glLineWidth(width);
+}
+PFN_glLineWidth _glptr_glLineWidth = _impl_glLineWidth;
+
+static void  GL_APIENTRY _impl_glVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
+  _glptr_glVertexAttribP1ui = (PFN_glVertexAttribP1ui)GalogenGetProcAddress("glVertexAttribP1ui");
+   _glptr_glVertexAttribP1ui(index, type, normalized, value);
+}
+PFN_glVertexAttribP1ui _glptr_glVertexAttribP1ui = _impl_glVertexAttribP1ui;
+
+static void  GL_APIENTRY _impl_glGetUniformiv (GLuint program, GLint location, GLint * params) {
+  _glptr_glGetUniformiv = (PFN_glGetUniformiv)GalogenGetProcAddress("glGetUniformiv");
+   _glptr_glGetUniformiv(program, location, params);
+}
+PFN_glGetUniformiv _glptr_glGetUniformiv = _impl_glGetUniformiv;
+
+static void  GL_APIENTRY _impl_glReadBuffer (GLenum src) {
+  _glptr_glReadBuffer = (PFN_glReadBuffer)GalogenGetProcAddress("glReadBuffer");
+   _glptr_glReadBuffer(src);
+}
+PFN_glReadBuffer _glptr_glReadBuffer = _impl_glReadBuffer;
+
+static void  GL_APIENTRY _impl_glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexImage1D = (PFN_glTexImage1D)GalogenGetProcAddress("glTexImage1D");
+   _glptr_glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
+}
+PFN_glTexImage1D _glptr_glTexImage1D = _impl_glTexImage1D;
+
+static void  GL_APIENTRY _impl_glTexParameterfv (GLenum target, GLenum pname, const GLfloat * params) {
+  _glptr_glTexParameterfv = (PFN_glTexParameterfv)GalogenGetProcAddress("glTexParameterfv");
+   _glptr_glTexParameterfv(target, pname, params);
+}
+PFN_glTexParameterfv _glptr_glTexParameterfv = _impl_glTexParameterfv;
+
+static void  GL_APIENTRY _impl_glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z) {
+  _glptr_glVertexAttrib3s = (PFN_glVertexAttrib3s)GalogenGetProcAddress("glVertexAttrib3s");
+   _glptr_glVertexAttrib3s(index, x, y, z);
+}
+PFN_glVertexAttrib3s _glptr_glVertexAttrib3s = _impl_glVertexAttrib3s;
+
+static void  GL_APIENTRY _impl_glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) {
+  _glptr_glCompressedTexSubImage1D = (PFN_glCompressedTexSubImage1D)GalogenGetProcAddress("glCompressedTexSubImage1D");
+   _glptr_glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+}
+PFN_glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D = _impl_glCompressedTexSubImage1D;
+
+static void  GL_APIENTRY _impl_glClear (GLbitfield mask) {
+  _glptr_glClear = (PFN_glClear)GalogenGetProcAddress("glClear");
+   _glptr_glClear(mask);
+}
+PFN_glClear _glptr_glClear = _impl_glClear;
+
+static void  GL_APIENTRY _impl_glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) {
+  _glptr_glTexImage2D = (PFN_glTexImage2D)GalogenGetProcAddress("glTexImage2D");
+   _glptr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+}
+PFN_glTexImage2D _glptr_glTexImage2D = _impl_glTexImage2D;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4Niv (GLuint index, const GLint * v) {
+  _glptr_glVertexAttrib4Niv = (PFN_glVertexAttrib4Niv)GalogenGetProcAddress("glVertexAttrib4Niv");
+   _glptr_glVertexAttrib4Niv(index, v);
+}
+PFN_glVertexAttrib4Niv _glptr_glVertexAttrib4Niv = _impl_glVertexAttrib4Niv;
+
+static void  GL_APIENTRY _impl_glGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint * params) {
+  _glptr_glGetVertexAttribIuiv = (PFN_glGetVertexAttribIuiv)GalogenGetProcAddress("glGetVertexAttribIuiv");
+   _glptr_glGetVertexAttribIuiv(index, pname, params);
+}
+PFN_glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv = _impl_glGetVertexAttribIuiv;
+
+static void  GL_APIENTRY _impl_glStencilMaskSeparate (GLenum face, GLuint mask) {
+  _glptr_glStencilMaskSeparate = (PFN_glStencilMaskSeparate)GalogenGetProcAddress("glStencilMaskSeparate");
+   _glptr_glStencilMaskSeparate(face, mask);
+}
+PFN_glStencilMaskSeparate _glptr_glStencilMaskSeparate = _impl_glStencilMaskSeparate;
+
+static void  GL_APIENTRY _impl_glGenVertexArrays (GLsizei n, GLuint * arrays) {
+  _glptr_glGenVertexArrays = (PFN_glGenVertexArrays)GalogenGetProcAddress("glGenVertexArrays");
+   _glptr_glGenVertexArrays(n, arrays);
+}
+PFN_glGenVertexArrays _glptr_glGenVertexArrays = _impl_glGenVertexArrays;
+
+static void  GL_APIENTRY _impl_glFrontFace (GLenum mode) {
+  _glptr_glFrontFace = (PFN_glFrontFace)GalogenGetProcAddress("glFrontFace");
+   _glptr_glFrontFace(mode);
+}
+PFN_glFrontFace _glptr_glFrontFace = _impl_glFrontFace;
+
+static void  GL_APIENTRY _impl_glDepthRange (GLdouble n, GLdouble f) {
+  _glptr_glDepthRange = (PFN_glDepthRange)GalogenGetProcAddress("glDepthRange");
+   _glptr_glDepthRange(n, f);
+}
+PFN_glDepthRange _glptr_glDepthRange = _impl_glDepthRange;
+
+static void  GL_APIENTRY _impl_glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
+  _glptr_glVertexAttrib4s = (PFN_glVertexAttrib4s)GalogenGetProcAddress("glVertexAttrib4s");
+   _glptr_glVertexAttrib4s(index, x, y, z, w);
+}
+PFN_glVertexAttrib4s _glptr_glVertexAttrib4s = _impl_glVertexAttrib4s;
+
+static void  GL_APIENTRY _impl_glDetachShader (GLuint program, GLuint shader) {
+  _glptr_glDetachShader = (PFN_glDetachShader)GalogenGetProcAddress("glDetachShader");
+   _glptr_glDetachShader(program, shader);
+}
+PFN_glDetachShader _glptr_glDetachShader = _impl_glDetachShader;
+
+static void  GL_APIENTRY _impl_glCullFace (GLenum mode) {
+  _glptr_glCullFace = (PFN_glCullFace)GalogenGetProcAddress("glCullFace");
+   _glptr_glCullFace(mode);
+}
+PFN_glCullFace _glptr_glCullFace = _impl_glCullFace;
+
diff --git a/src/gl.h b/src/gl.h
@@ -1,113 +1,2306 @@
-#ifndef POLYADVENT_GL_H
-#define POLYADVENT_GL_H
-
-/* #include <epoxy/gl.h> */
-#include <SDL.h>
-#include <GL/gl.h>
-/*
-#include <GL/glx.h>
-#include <GL/glext.h>
-*/
-
-void glGenBuffers(GLsizei n, GLuint * buffers);
-void glGetShaderiv(GLuint shader, GLenum pname, GLint *params);
-void glGetShaderInfoLog(GLuint shader, GLsizei maxLength, GLsizei *length, GLchar *infoLog);
-void glBindBuffer(GLenum target, GLuint buffer);
-GLuint glCreateShader(GLenum shaderType);
-void glCompileShader(GLuint shader);
-
-void glShaderSource(GLuint shader, GLsizei count, const GLchar **string,
-                    const GLint *length);
-
-void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
-GLint glGetUniformLocation(GLuint program, const GLchar *name);
-GLint glGetAttribLocation(GLuint program, const GLchar *name);
-void glEnableVertexAttribArray(GLuint index);
-void glDeleteShader(GLuint shader);
-
-void glDeleteBuffers(GLsizei n, const GLuint * buffers);
-
-void glVertexAttribPointer(GLuint index, GLint size, GLenum type,
-                           GLboolean normalized, GLsizei stride,
-                           const GLvoid * pointer);
-
-void glVertexAttribIPointer(GLuint index,
-                            GLint size,
-                            GLenum type,
-                            GLsizei stride,
-                            const GLvoid * pointer);
-
-void glUniform1i(GLint location, GLint i);
-void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-GLuint glCreateProgram(void);
-void glAttachShader(GLuint program, GLuint shader);
-void glLinkProgram(GLuint program);
-
-void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
-                        const GLfloat *value);
-
-void glUseProgram(GLuint program);
-void glUniform1f(GLint location, GLfloat v0);
-void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
-void glGetProgramiv(GLuint program, GLenum pname, GLint *params);
-void glDeleteProgram(	GLuint program);
-
-void glGenFramebuffers(GLsizei handle, GLuint *ids);
-void glBindFramebuffer(	GLenum target, GLuint framebuffer);
-GLenum glCheckFramebufferStatus(GLenum target);
-void glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers);
-
-void glDisableVertexAttribArray(GLuint index);
-void glDeleteVertexArrays(GLsizei n, const GLuint *arrays);
-
-GLboolean glIsBuffer(	GLuint buffer);
-
-
-void glTexImage2D(	GLenum target,
-                    GLint level,
-                    GLint internalformat,
-                    GLsizei width,
-                    GLsizei height,
-                    GLint border,
-                    GLenum format,
-                    GLenum type,
-                    const GLvoid * data);
-
-void glFramebufferTexture2D(	GLenum target,
-                                GLenum attachment,
-                                GLenum textarget,
-                                GLuint texture,
-                                GLint level);
-
-void glGenRenderbuffers(	GLsizei n,
-                            GLuint * renderbuffers);
-
-void glBindRenderbuffer(	GLenum target,
-                            GLuint renderbuffer);
-
-void glRenderbufferStorage(	GLenum target,
-                            GLenum internalformat,
-                            GLsizei width,
-                            GLsizei height);
-
-void glFramebufferRenderbuffer(	GLenum target,
-                                GLenum attachment,
-                                GLenum renderbuffertarget,
-                                GLuint renderbuffer);
-
-
-void glDeleteRenderbuffers(	GLsizei n,
-                            GLuint *renderbuffers);
-
-
-void glFramebufferTexture(	GLenum target,
-                            GLenum attachment,
-                            GLuint texture,
-                            GLint level);
+/* This file was auto-generated by Galogen */
+#ifndef _GALOGEN_HEADER_
+#define _GALOGEN_HEADER_
+#if defined(__gl_h_) || defined(__GL_H__) || defined(__glext_h_) || defined(__GLEXT_H_) || defined(__gltypes_h_) || defined(__glcorearb_h_) || defined(__gl_glcorearb_h)
+#error Galogen-generated header included after a GL header.
+#endif
 
-void glPatchParameteri(	GLenum pname,
-                        GLint value);
+#define __gl_h_ 1
+#define __gl32_h_ 1
+#define __gl31_h_ 1
+#define __GL_H__ 1
+#define __glext_h_ 1
+#define __GLEXT_H_ 1
+#define __gltypes_h_ 1
+#define __glcorearb_h_ 1
+#define __gl_glcorearb_h_ 1
 
-void glBindVertexArray(	GLuint array);
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#define GL_APIENTRY APIENTRY
+#else
+#define GL_APIENTRY
+#endif
 
-#endif /* POLYADVENT_GL_H */
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define GALOGEN_API_NAME "gl"
+#define GALOGEN_API_PROFILE "core"
+#define GALOGEN_API_VER_MAJ 3
+#define GALOGEN_API_VER_MIN 3
+typedef unsigned int  GLenum;
+typedef unsigned int  GLuint;
+typedef int  GLsizei;
+typedef char  GLchar;
+#include <stddef.h>
+typedef ptrdiff_t  GLintptr;
+typedef ptrdiff_t  GLsizeiptr;
+typedef double  GLclampd;
+typedef unsigned short  GLushort;
+typedef unsigned char  GLubyte;
+typedef unsigned char  GLboolean;
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glxext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GL_EXT_timer_query extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+typedef uint64_t  GLuint64;
+typedef double  GLdouble;
+typedef unsigned short  GLhalf;
+typedef float  GLclampf;
+typedef unsigned int  GLbitfield;
+typedef signed char  GLbyte;
+typedef short  GLshort;
+typedef void  GLvoid;
+typedef int64_t  GLint64;
+typedef float  GLfloat;
+typedef struct __GLsync * GLsync;
+typedef int  GLint;
+#define GL_INT_2_10_10_10_REV 0x8D9F
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_RGB10_A2UI 0x906F
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
+#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
+#define GL_SRC1_COLOR 0x88F9
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
+#define GL_WAIT_FAILED 0x911D
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_CONDITION 0x9113
+#define GL_OBJECT_TYPE 0x9112
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+#define GL_PROVOKING_VERTEX 0x8E4F
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_RG16_SNORM 0x8F99
+#define GL_R16_SNORM 0x8F98
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+#define GL_RG16I 0x8239
+#define GL_RG8UI 0x8238
+#define GL_R32UI 0x8236
+#define GL_R32I 0x8235
+#define GL_R16I 0x8233
+#define GL_R8I 0x8231
+#define GL_RG32F 0x8230
+#define GL_RG16F 0x822F
+#define GL_R32F 0x822E
+#define GL_RG16 0x822C
+#define GL_R16 0x822A
+#define GL_RG_INTEGER 0x8228
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_PROGRAM_POINT_SIZE 0x8642
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_MAP_READ_BIT 0x0001
+#define GL_FRAMEBUFFER_SRGB 0x8DB9
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_STENCIL_INDEX16 0x8D49
+#define GL_STENCIL_INDEX4 0x8D47
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_DEPTH_ATTACHMENT 0x8D00
+#define GL_COLOR_ATTACHMENT31 0x8CFF
+#define GL_COLOR_ATTACHMENT29 0x8CFD
+#define GL_COLOR_ATTACHMENT27 0x8CFB
+#define GL_COLOR_ATTACHMENT26 0x8CFA
+#define GL_COLOR_ATTACHMENT23 0x8CF7
+#define GL_COLOR_ATTACHMENT19 0x8CF3
+#define GL_COLOR_ATTACHMENT18 0x8CF2
+#define GL_COLOR_ATTACHMENT17 0x8CF1
+#define GL_COLOR_ATTACHMENT15 0x8CEF
+#define GL_COLOR_ATTACHMENT14 0x8CEE
+#define GL_COLOR_ATTACHMENT12 0x8CEC
+#define GL_COLOR_ATTACHMENT11 0x8CEB
+#define GL_COLOR_ATTACHMENT10 0x8CEA
+#define GL_COLOR_ATTACHMENT9 0x8CE9
+#define GL_COLOR_ATTACHMENT8 0x8CE8
+#define GL_COLOR_ATTACHMENT7 0x8CE7
+#define GL_COLOR_ATTACHMENT6 0x8CE6
+#define GL_COLOR_ATTACHMENT4 0x8CE4
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_R16F 0x822D
+#define GL_COLOR_ATTACHMENT30 0x8CFE
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_COLOR_ATTACHMENT22 0x8CF6
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_TEXTURE_ALPHA_TYPE 0x8C13
+#define GL_RG8I 0x8237
+#define GL_TEXTURE_BLUE_TYPE 0x8C12
+#define GL_COLOR_ATTACHMENT16 0x8CF0
+#define GL_TEXTURE_GREEN_TYPE 0x8C11
+#define GL_TEXTURE_STENCIL_SIZE 0x88F1
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
+#define GL_QUERY_NO_WAIT 0x8E14
+#define GL_QUERY_WAIT 0x8E13
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_BGR_INTEGER 0x8D9A
+#define GL_BLUE_INTEGER 0x8D96
+#define GL_GREEN_INTEGER 0x8D95
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_RED_INTEGER 0x8D94
+#define GL_RGBA8I 0x8D8E
+#define GL_RGBA16I 0x8D88
+#define GL_RGB32I 0x8D83
+#define GL_RGBA32I 0x8D82
+#define GL_RGB16UI 0x8D77
+#define GL_RGBA16UI 0x8D76
+#define GL_RGB32UI 0x8D71
+#define GL_RGBA32UI 0x8D70
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_PRIMITIVES_GENERATED 0x8C87
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_RGB9_E5 0x8C3D
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
+#define GL_TEXTURE_1D_ARRAY 0x8C18
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define MAX_VARYING_FLOATS 0x8B4B
+#define GL_CLAMP_READ_COLOR 0x891C
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_CONTEXT_FLAGS 0x821E
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_CLIP_DISTANCE6 0x3006
+#define GL_CLIP_DISTANCE4 0x3004
+#define GL_CLIP_PLANE4 0x3004
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_INT_SAMPLER_1D 0x8DC9
+#define GL_SRGB8 0x8C41
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#define GL_COMPARE_R_TO_TEXTURE 0x884E
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_UPPER_LEFT 0x8CA2
+#define GL_COMPRESSED_SRGB 0x8C48
+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_COLOR_ATTACHMENT20 0x8CF4
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_DELETE_STATUS 0x8B80
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_BOOL_VEC3 0x8B58
+#define GL_BOOL 0x8B56
+#define GL_INT_VEC4 0x8B55
+#define GL_INT_VEC2 0x8B53
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_VARYING_FLOATS 0x8B4B
+#define GL_TEXTURE_SHARED_SIZE 0x8C3F
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_BLEND_EQUATION_ALPHA 0x883D
+#define GL_DRAW_BUFFER15 0x8834
+#define GL_DRAW_BUFFER12 0x8831
+#define GL_DRAW_BUFFER10 0x882F
+#define GL_DRAW_BUFFER8 0x882D
+#define GL_DRAW_BUFFER7 0x882C
+#define GL_DRAW_BUFFER5 0x882A
+#define GL_DRAW_BUFFER2 0x8827
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_DRAW_BUFFER9 0x882E
+#define GL_SRC1_ALPHA 0x8589
+#define GL_SOURCE1_ALPHA 0x8589
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+#define GL_INCR 0x1E02
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_DRAW 0x88E4
+#define GL_UNPACK_LSB_FIRST 0x0CF1
+#define GL_STREAM_READ 0x88E1
+#define GL_READ_WRITE 0x88BA
+#define GL_WRITE_ONLY 0x88B9
+#define GL_SAMPLER_1D_SHADOW 0x8B61
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_READ_ONLY 0x88B8
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_QUERY_RESULT 0x8866
+#define GL_CURRENT_QUERY 0x8865
+#define GL_MAX 0x8008
+#define GL_MIN 0x8007
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_BLEND_COLOR 0x8005
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_TEXTURE3 0x84C3
+#define GL_TEXTURE_RED_TYPE 0x8C10
+#define GL_DRAW_BUFFER13 0x8832
+#define GL_DRAW_BUFFER1 0x8826
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_COLOR_ATTACHMENT21 0x8CF5
+#define GL_TEXTURE_DEPTH_SIZE 0x884A
+#define GL_RGBA2 0x8055
+#define GL_DECR_WRAP 0x8508
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_R8 0x8229
+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_TEXTURE_LOD_BIAS 0x8501
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_BUFFER_ACCESS 0x88BB
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_FIXED_ONLY 0x891D
+#define GL_SHORT 0x1402
+#define GL_DEPTH_TEST 0x0B71
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_R8UI 0x8232
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_CLAMP_TO_BORDER 0x812D
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_LINK_STATUS 0x8B82
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
+#define GL_COMPRESSED_RGBA 0x84EE
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_COMPRESSED_RGB 0x84ED
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_RGBA16F 0x881A
+#define GL_TEXTURE28 0x84DC
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_TEXTURE26 0x84DA
+#define GL_TEXTURE25 0x84D9
+#define GL_TEXTURE24 0x84D8
+#define GL_TEXTURE22 0x84D6
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_TEXTURE18 0x84D2
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_TEXTURE17 0x84D1
+#define GL_TEXTURE16 0x84D0
+#define GL_TEXTURE13 0x84CD
+#define GL_TEXTURE11 0x84CB
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_TEXTURE10 0x84CA
+#define GL_TEXTURE8 0x84C8
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_TEXTURE7 0x84C7
+#define GL_MAJOR_VERSION 0x821B
+#define GL_TEXTURE6 0x84C6
+#define GL_TEXTURE2 0x84C2
+#define GL_TEXTURE0 0x84C0
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_TEXTURE19 0x84D3
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_RGB8_SNORM 0x8F96
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_DRAW_BUFFER4 0x8829
+#define GL_BGR 0x80E0
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_RGB16I 0x8D89
+#define GL_TEXTURE15 0x84CF
+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_INT_VEC3 0x8B54
+#define GL_DRAW_BUFFER11 0x8830
+#define GL_TEXTURE_DEPTH 0x8071
+#define GL_PACK_SKIP_IMAGES 0x806B
+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_POINT 0x1B00
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_R8_SNORM 0x8F94
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_TEXTURE31 0x84DF
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_R16UI 0x8234
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_STREAM_DRAW 0x88E0
+#define GL_VIEWPORT 0x0BA2
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_FRONT_FACE 0x0B46
+#define GL_ONE 1
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_RG8 0x822B
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_BGRA_INTEGER 0x8D9B
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNSIGNALED 0x9118
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_POLYGON_OFFSET_POINT 0x2A01
+#define GL_OR 0x1507
+#define GL_BUFFER_USAGE 0x8765
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_RGBA16 0x805B
+#define GL_RGBA12 0x805A
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_RGB10_A2 0x8059
+#define GL_RGBA8 0x8058
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_RGBA4 0x8056
+#define GL_RGB8 0x8051
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_QUERY_BY_REGION_WAIT 0x8E15
+#define GL_PROXY_TEXTURE_1D 0x8063
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_TEXTURE_BLUE_SIZE 0x805E
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_DOUBLE 0x140A
+#define GL_TEXTURE_ALPHA_SIZE 0x805F
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_TEXTURE_GREEN_SIZE 0x805D
+#define GL_SIGNALED 0x9119
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_COLOR_ATTACHMENT13 0x8CED
+#define GL_RGB32F 0x8815
+#define GL_CLEAR 0x1500
+#define GL_SAMPLES_PASSED 0x8914
+#define GL_INVALID_OPERATION 0x0502
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TEXTURE_BINDING_1D 0x8068
+#define GL_POLYGON_OFFSET_LINE 0x2A02
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_LOWER_LEFT 0x8CA1
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_STENCIL 0x1802
+#define GL_COLOR_LOGIC_OP 0x0BF2
+#define GL_RGB16F 0x881B
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_BGRA 0x80E1
+#define GL_CLIP_DISTANCE7 0x3007
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_SRGB 0x8C40
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_RGB12 0x8053
+#define GL_RG16UI 0x823A
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_LINE_SMOOTH_HINT 0x0C52
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_MINOR_VERSION 0x821C
+#define GL_DEPTH 0x1801
+#define GL_FRONT_RIGHT 0x0401
+#define GL_RGB4 0x804F
+#define GL_FRONT 0x0404
+#define GL_BOOL_VEC2 0x8B57
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define GL_LINE_SMOOTH 0x0B20
+#define GL_TEXTURE29 0x84DD
+#define GL_TEXTURE27 0x84DB
+#define GL_COMPRESSED_RG 0x8226
+#define GL_DONT_CARE 0x1100
+#define GL_DEPTH_CLAMP 0x864F
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_NOR 0x1508
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_POLYGON_SMOOTH 0x0B41
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_PACK_LSB_FIRST 0x0D01
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#define GL_RGB16 0x8054
+#define GL_REPEAT 0x2901
+#define GL_LINE_WIDTH 0x0B21
+#define GL_RGB8I 0x8D8F
+#define GL_RGBA 0x1908
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+#define GL_TEXTURE_RED_SIZE 0x805C
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_DECR 0x1E03
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_DEPTH_COMPONENT32 0x81A7
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_DRAW_BUFFER 0x0C01
+#define GL_R3_G3_B2 0x2A10
+#define GL_INT 0x1404
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_FLOAT 0x1406
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_STENCIL_INDEX1 0x8D46
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_TEXTURE1 0x84C1
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COLOR_ATTACHMENT5 0x8CE5
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_TIMESTAMP 0x8E28
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_RG8_SNORM 0x8F95
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_COLOR 0x1800
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_TRIANGLES 0x0004
+#define GL_DOUBLEBUFFER 0x0C32
+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
+#define GL_LINE 0x1B01
+#define GL_BLEND_EQUATION 0x8009
+#define GL_NAND 0x150E
+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
+#define GL_COLOR_ATTACHMENT24 0x8CF8
+#define GL_AND 0x1501
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
+#define GL_CLIP_DISTANCE5 0x3005
+#define GL_CLIP_PLANE5 0x3005
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_PACK_IMAGE_HEIGHT 0x806C
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
+#define GL_NONE 0
+#define GL_CLIP_DISTANCE1 0x3001
+#define GL_CLIP_PLANE1 0x3001
+#define GL_BACK_LEFT 0x0402
+#define GL_XOR 0x1506
+#define GL_SRC_COLOR 0x0300
+#define GL_SAMPLER_1D_ARRAY 0x8DC0
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_BUFFER_SIZE 0x8764
+#define GL_STREAM_COPY 0x88E2
+#define GL_BYTE 0x1400
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_LINE_STRIP 0x0003
+#define GL_TEXTURE_3D 0x806F
+#define GL_LOGIC_OP_MODE 0x0BF0
+#define GL_CW 0x0900
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_LINEAR 0x2601
+#define GL_RENDERBUFFER 0x8D41
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_BACK_RIGHT 0x0403
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_TEXTURE30 0x84DE
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_AND_REVERSE 0x1502
+#define GL_QUERY_COUNTER_BITS 0x8864
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#define GL_GEQUAL 0x0206
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_INVALID_ENUM 0x0500
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_RGBA32F 0x8814
+#define GL_SAMPLER_1D 0x8B5D
+#define GL_BOOL_VEC4 0x8B59
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_CLIP_DISTANCE0 0x3000
+#define GL_CLIP_PLANE0 0x3000
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_SAMPLES 0x80A9
+#define GL_COLOR_ATTACHMENT25 0x8CF9
+#define GL_TEXTURE9 0x84C9
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_TEXTURE 0x1702
+#define GL_AND_INVERTED 0x1504
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_BLEND 0x0BE2
+#define GL_SRGB_ALPHA 0x8C42
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAX_CLIP_DISTANCES 0x0D32
+#define GL_MAX_CLIP_PLANES 0x0D32
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_INVALID_VALUE 0x0501
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_DRAW_BUFFER3 0x8828
+#define GL_EXTENSIONS 0x1F03
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_RENDERER 0x1F01
+#define GL_NO_ERROR 0
+#define GL_REPLACE 0x1E01
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_KEEP 0x1E00
+#define GL_FILL 0x1B02
+#define GL_CCW 0x0901
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_TEXTURE14 0x84CE
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_TEXTURE_WIDTH 0x1000
+#define GL_NOOP 0x1505
+#define GL_RGB 0x1907
+#define GL_ALPHA 0x1906
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_BLUE 0x1905
+#define GL_GREEN 0x1904
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_STENCIL_INDEX 0x1901
+#define GL_SET 0x150F
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_FALSE 0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_COPY_INVERTED 0x150C
+#define GL_ZERO 0
+#define GL_CULL_FACE 0x0B44
+#define GL_OR_REVERSE 0x150B
+#define GL_INVERT 0x150A
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_EQUIV 0x1509
+#define GL_POINT_SIZE 0x0B11
+#define GL_TEXTURE20 0x84D4
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_COPY 0x1503
+#define GL_TEXTURE_COMPRESSED 0x86A1
+#define GL_UNSIGNED_INT 0x1405
+#define GL_TEXTURE4 0x84C4
+#define GL_TIME_ELAPSED 0x88BF
+#define GL_HALF_FLOAT 0x140B
+#define GL_STATIC_COPY 0x88E6
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_TEXTURE_1D 0x0DE0
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_NEAREST 0x2600
+#define GL_BLEND_SRC 0x0BE1
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_RG32I 0x823B
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_TEXTURE12 0x84CC
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_COMPRESSED_RED 0x8225
+#define GL_LEQUAL 0x0203
+#define GL_POLYGON_MODE 0x0B40
+#define GL_BLEND_DST 0x0BE0
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_OR_INVERTED 0x150D
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_READ_BUFFER 0x0C02
+#define GL_NICEST 0x1102
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_STENCIL_TEST 0x0B90
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_DITHER 0x0BD0
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_PACK_SWAP_BYTES 0x0D00
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#define GL_STENCIL_REF 0x0B97
+#define GL_PROXY_TEXTURE_3D 0x8070
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_RG32UI 0x823C
+#define GL_EQUAL 0x0202
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_UNPACK_SWAP_BYTES 0x0CF0
+#define GL_POLYGON_SMOOTH_HINT 0x0C53
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_RGB5 0x8050
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_TEXTURE21 0x84D5
+#define GL_LINES 0x0001
+#define GL_TEXTURE_DEPTH_TYPE 0x8C16
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_RIGHT 0x0407
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_SRC_ALPHA 0x0302
+#define GL_INCR_WRAP 0x8507
+#define GL_LESS 0x0201
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MULTISAMPLE 0x809D
+#define GL_DRAW_BUFFER6 0x882B
+#define GL_SYNC_FLAGS 0x9115
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_LEFT 0x0406
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_RGB8UI 0x8D7D
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_BACK 0x0405
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_RGB10 0x8052
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_CLIP_DISTANCE3 0x3003
+#define GL_CLIP_PLANE3 0x3003
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_RG 0x8227
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_ALWAYS 0x0207
+#define GL_COLOR_ATTACHMENT28 0x8CFC
+#define GL_FUNC_ADD 0x8006
+#define GL_CLIP_DISTANCE2 0x3002
+#define GL_CLIP_PLANE2 0x3002
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_FRONT_LEFT 0x0400
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_DRAW_BUFFER14 0x8833
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_LINE_LOOP 0x0002
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_NOTEQUAL 0x0205
+#define GL_TEXTURE5 0x84C5
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_DST_COLOR 0x0306
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_RED 0x1903
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_RGB_INTEGER 0x8D98
+#define GL_FASTEST 0x1101
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#define GL_DST_ALPHA 0x0304
+#define GL_STEREO 0x0C33
+#define GL_RGB5_A1 0x8057
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_GREATER 0x0204
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_TRUE 1
+#define GL_NEVER 0x0200
+#define GL_VENDOR 0x1F00
+#define GL_POINTS 0x0000
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_RGBA8UI 0x8D7C
+#define GL_VERSION 0x1F02
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_TEXTURE23 0x84D7
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
+extern PFN_glVertexAttribP4uiv _glptr_glVertexAttribP4uiv;
+#define glVertexAttribP4uiv _glptr_glVertexAttribP4uiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
+extern PFN_glVertexAttribP3uiv _glptr_glVertexAttribP3uiv;
+#define glVertexAttribP3uiv _glptr_glVertexAttribP3uiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
+extern PFN_glVertexAttribP2uiv _glptr_glVertexAttribP2uiv;
+#define glVertexAttribP2uiv _glptr_glVertexAttribP2uiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+extern PFN_glVertexAttribP2ui _glptr_glVertexAttribP2ui;
+#define glVertexAttribP2ui _glptr_glVertexAttribP2ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
+extern PFN_glVertexAttribP1uiv _glptr_glVertexAttribP1uiv;
+#define glVertexAttribP1uiv _glptr_glVertexAttribP1uiv
+
+typedef void  (GL_APIENTRY *PFN_glGetQueryObjectui64v)(GLuint id, GLenum pname, GLuint64 * params);
+extern PFN_glGetQueryObjectui64v _glptr_glGetQueryObjectui64v;
+#define glGetQueryObjectui64v _glptr_glGetQueryObjectui64v
+
+typedef void  (GL_APIENTRY *PFN_glGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat * params);
+extern PFN_glGetSamplerParameterfv _glptr_glGetSamplerParameterfv;
+#define glGetSamplerParameterfv _glptr_glGetSamplerParameterfv
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameterIuiv)(GLuint sampler, GLenum pname, const GLuint * param);
+extern PFN_glSamplerParameterIuiv _glptr_glSamplerParameterIuiv;
+#define glSamplerParameterIuiv _glptr_glSamplerParameterIuiv
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat * param);
+extern PFN_glSamplerParameterfv _glptr_glSamplerParameterfv;
+#define glSamplerParameterfv _glptr_glSamplerParameterfv
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameteriv)(GLuint sampler, GLenum pname, const GLint * param);
+extern PFN_glSamplerParameteriv _glptr_glSamplerParameteriv;
+#define glSamplerParameteriv _glptr_glSamplerParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
+extern PFN_glSamplerParameteri _glptr_glSamplerParameteri;
+#define glSamplerParameteri _glptr_glSamplerParameteri
+
+typedef void  (GL_APIENTRY *PFN_glBindSampler)(GLuint unit, GLuint sampler);
+extern PFN_glBindSampler _glptr_glBindSampler;
+#define glBindSampler _glptr_glBindSampler
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
+extern PFN_glSamplerParameterf _glptr_glSamplerParameterf;
+#define glSamplerParameterf _glptr_glSamplerParameterf
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsSampler)(GLuint sampler);
+extern PFN_glIsSampler _glptr_glIsSampler;
+#define glIsSampler _glptr_glIsSampler
+
+typedef void  (GL_APIENTRY *PFN_glGenSamplers)(GLsizei count, GLuint * samplers);
+extern PFN_glGenSamplers _glptr_glGenSamplers;
+#define glGenSamplers _glptr_glGenSamplers
+
+typedef void  (GL_APIENTRY *PFN_glBindFragDataLocationIndexed)(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name);
+extern PFN_glBindFragDataLocationIndexed _glptr_glBindFragDataLocationIndexed;
+#define glBindFragDataLocationIndexed _glptr_glBindFragDataLocationIndexed
+
+typedef void  (GL_APIENTRY *PFN_glGetMultisamplefv)(GLenum pname, GLuint index, GLfloat * val);
+extern PFN_glGetMultisamplefv _glptr_glGetMultisamplefv;
+#define glGetMultisamplefv _glptr_glGetMultisamplefv
+
+typedef void  (GL_APIENTRY *PFN_glTexImage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
+extern PFN_glTexImage3DMultisample _glptr_glTexImage3DMultisample;
+#define glTexImage3DMultisample _glptr_glTexImage3DMultisample
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferTexture)(GLenum target, GLenum attachment, GLuint texture, GLint level);
+extern PFN_glFramebufferTexture _glptr_glFramebufferTexture;
+#define glFramebufferTexture _glptr_glFramebufferTexture
+
+typedef void  (GL_APIENTRY *PFN_glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 * params);
+extern PFN_glGetBufferParameteri64v _glptr_glGetBufferParameteri64v;
+#define glGetBufferParameteri64v _glptr_glGetBufferParameteri64v
+
+typedef void  (GL_APIENTRY *PFN_glGetInteger64i_v)(GLenum target, GLuint index, GLint64 * data);
+extern PFN_glGetInteger64i_v _glptr_glGetInteger64i_v;
+#define glGetInteger64i_v _glptr_glGetInteger64i_v
+
+typedef void  (GL_APIENTRY *PFN_glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+extern PFN_glWaitSync _glptr_glWaitSync;
+#define glWaitSync _glptr_glWaitSync
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsSync)(GLsync sync);
+extern PFN_glIsSync _glptr_glIsSync;
+#define glIsSync _glptr_glIsSync
+
+typedef GLsync (GL_APIENTRY *PFN_glFenceSync)(GLenum condition, GLbitfield flags);
+extern PFN_glFenceSync _glptr_glFenceSync;
+#define glFenceSync _glptr_glFenceSync
+
+typedef void  (GL_APIENTRY *PFN_glMultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex);
+extern PFN_glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex;
+#define glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex
+
+typedef void  (GL_APIENTRY *PFN_glDrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex);
+extern PFN_glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex;
+#define glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName);
+extern PFN_glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName;
+#define glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName
+
+typedef GLuint (GL_APIENTRY *PFN_glGetUniformBlockIndex)(GLuint program, const GLchar * uniformBlockName);
+extern PFN_glGetUniformBlockIndex _glptr_glGetUniformBlockIndex;
+#define glGetUniformBlockIndex _glptr_glGetUniformBlockIndex
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName);
+extern PFN_glGetActiveUniformName _glptr_glGetActiveUniformName;
+#define glGetActiveUniformName _glptr_glGetActiveUniformName
+
+typedef void  (GL_APIENTRY *PFN_glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices);
+extern PFN_glGetUniformIndices _glptr_glGetUniformIndices;
+#define glGetUniformIndices _glptr_glGetUniformIndices
+
+typedef void  (GL_APIENTRY *PFN_glTexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);
+extern PFN_glTexBuffer _glptr_glTexBuffer;
+#define glTexBuffer _glptr_glTexBuffer
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsVertexArray)(GLuint array);
+extern PFN_glIsVertexArray _glptr_glIsVertexArray;
+#define glIsVertexArray _glptr_glIsVertexArray
+
+typedef void  (GL_APIENTRY *PFN_glBindVertexArray)(GLuint array);
+extern PFN_glBindVertexArray _glptr_glBindVertexArray;
+#define glBindVertexArray _glptr_glBindVertexArray
+
+typedef void  (GL_APIENTRY *PFN_glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
+extern PFN_glFlushMappedBufferRange _glptr_glFlushMappedBufferRange;
+#define glFlushMappedBufferRange _glptr_glFlushMappedBufferRange
+
+typedef void * (GL_APIENTRY *PFN_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+extern PFN_glMapBufferRange _glptr_glMapBufferRange;
+#define glMapBufferRange _glptr_glMapBufferRange
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params);
+extern PFN_glGetActiveUniformsiv _glptr_glGetActiveUniformsiv;
+#define glGetActiveUniformsiv _glptr_glGetActiveUniformsiv
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+extern PFN_glFramebufferTextureLayer _glptr_glFramebufferTextureLayer;
+#define glFramebufferTextureLayer _glptr_glFramebufferTextureLayer
+
+typedef void  (GL_APIENTRY *PFN_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params);
+extern PFN_glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv;
+#define glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+extern PFN_glFramebufferTexture3D _glptr_glFramebufferTexture3D;
+#define glFramebufferTexture3D _glptr_glFramebufferTexture3D
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+extern PFN_glFramebufferTexture1D _glptr_glFramebufferTexture1D;
+#define glFramebufferTexture1D _glptr_glFramebufferTexture1D
+
+typedef void  (GL_APIENTRY *PFN_glGenFramebuffers)(GLsizei n, GLuint * framebuffers);
+extern PFN_glGenFramebuffers _glptr_glGenFramebuffers;
+#define glGenFramebuffers _glptr_glGenFramebuffers
+
+typedef void  (GL_APIENTRY *PFN_glBindFramebuffer)(GLenum target, GLuint framebuffer);
+extern PFN_glBindFramebuffer _glptr_glBindFramebuffer;
+#define glBindFramebuffer _glptr_glBindFramebuffer
+
+typedef void  (GL_APIENTRY *PFN_glGetQueryObjecti64v)(GLuint id, GLenum pname, GLint64 * params);
+extern PFN_glGetQueryObjecti64v _glptr_glGetQueryObjecti64v;
+#define glGetQueryObjecti64v _glptr_glGetQueryObjecti64v
+
+typedef void  (GL_APIENTRY *PFN_glGetInteger64v)(GLenum pname, GLint64 * data);
+extern PFN_glGetInteger64v _glptr_glGetInteger64v;
+#define glGetInteger64v _glptr_glGetInteger64v
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsFramebuffer)(GLuint framebuffer);
+extern PFN_glIsFramebuffer _glptr_glIsFramebuffer;
+#define glIsFramebuffer _glptr_glIsFramebuffer
+
+typedef void  (GL_APIENTRY *PFN_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params);
+extern PFN_glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv;
+#define glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
+extern PFN_glBindRenderbuffer _glptr_glBindRenderbuffer;
+#define glBindRenderbuffer _glptr_glBindRenderbuffer
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsRenderbuffer)(GLuint renderbuffer);
+extern PFN_glIsRenderbuffer _glptr_glIsRenderbuffer;
+#define glIsRenderbuffer _glptr_glIsRenderbuffer
+
+typedef const GLubyte * (GL_APIENTRY *PFN_glGetStringi)(GLenum name, GLuint index);
+extern PFN_glGetStringi _glptr_glGetStringi;
+#define glGetStringi _glptr_glGetStringi
+
+typedef void  (GL_APIENTRY *PFN_glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+extern PFN_glClearBufferfi _glptr_glClearBufferfi;
+#define glClearBufferfi _glptr_glClearBufferfi
+
+typedef void  (GL_APIENTRY *PFN_glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat * value);
+extern PFN_glClearBufferfv _glptr_glClearBufferfv;
+#define glClearBufferfv _glptr_glClearBufferfv
+
+typedef void  (GL_APIENTRY *PFN_glGetTexParameterIiv)(GLenum target, GLenum pname, GLint * params);
+extern PFN_glGetTexParameterIiv _glptr_glGetTexParameterIiv;
+#define glGetTexParameterIiv _glptr_glGetTexParameterIiv
+
+typedef void  (GL_APIENTRY *PFN_glGetSamplerParameterIuiv)(GLuint sampler, GLenum pname, GLuint * params);
+extern PFN_glGetSamplerParameterIuiv _glptr_glGetSamplerParameterIuiv;
+#define glGetSamplerParameterIuiv _glptr_glGetSamplerParameterIuiv
+
+typedef void  (GL_APIENTRY *PFN_glTexParameterIiv)(GLenum target, GLenum pname, const GLint * params);
+extern PFN_glTexParameterIiv _glptr_glTexParameterIiv;
+#define glTexParameterIiv _glptr_glTexParameterIiv
+
+typedef void  (GL_APIENTRY *PFN_glUniform4uiv)(GLint location, GLsizei count, const GLuint * value);
+extern PFN_glUniform4uiv _glptr_glUniform4uiv;
+#define glUniform4uiv _glptr_glUniform4uiv
+
+typedef void  (GL_APIENTRY *PFN_glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+extern PFN_glUniform3ui _glptr_glUniform3ui;
+#define glUniform3ui _glptr_glUniform3ui
+
+typedef void  (GL_APIENTRY *PFN_glUniform1ui)(GLint location, GLuint v0);
+extern PFN_glUniform1ui _glptr_glUniform1ui;
+#define glUniform1ui _glptr_glUniform1ui
+
+typedef GLint (GL_APIENTRY *PFN_glGetFragDataLocation)(GLuint program, const GLchar * name);
+extern PFN_glGetFragDataLocation _glptr_glGetFragDataLocation;
+#define glGetFragDataLocation _glptr_glGetFragDataLocation
+
+typedef void  (GL_APIENTRY *PFN_glBindFragDataLocation)(GLuint program, GLuint color, const GLchar * name);
+extern PFN_glBindFragDataLocation _glptr_glBindFragDataLocation;
+#define glBindFragDataLocation _glptr_glBindFragDataLocation
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4iv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttribI4iv _glptr_glVertexAttribI4iv;
+#define glVertexAttribI4iv _glptr_glVertexAttribI4iv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI2iv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttribI2iv _glptr_glVertexAttribI2iv;
+#define glVertexAttribI2iv _glptr_glVertexAttribI2iv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI1iv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttribI1iv _glptr_glVertexAttribI1iv;
+#define glVertexAttribI1iv _glptr_glVertexAttribI1iv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+extern PFN_glVertexAttribI4ui _glptr_glVertexAttribI4ui;
+#define glVertexAttribI4ui _glptr_glVertexAttribI4ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
+extern PFN_glVertexAttribI2ui _glptr_glVertexAttribI2ui;
+#define glVertexAttribI2ui _glptr_glVertexAttribI2ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI1ui)(GLuint index, GLuint x);
+extern PFN_glVertexAttribI1ui _glptr_glVertexAttribI1ui;
+#define glVertexAttribI1ui _glptr_glVertexAttribI1ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+extern PFN_glVertexAttribI4i _glptr_glVertexAttribI4i;
+#define glVertexAttribI4i _glptr_glVertexAttribI4i
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4bv)(GLuint index, const GLbyte * v);
+extern PFN_glVertexAttribI4bv _glptr_glVertexAttribI4bv;
+#define glVertexAttribI4bv _glptr_glVertexAttribI4bv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI2i)(GLuint index, GLint x, GLint y);
+extern PFN_glVertexAttribI2i _glptr_glVertexAttribI2i;
+#define glVertexAttribI2i _glptr_glVertexAttribI2i
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI1i)(GLuint index, GLint x);
+extern PFN_glVertexAttribI1i _glptr_glVertexAttribI1i;
+#define glVertexAttribI1i _glptr_glVertexAttribI1i
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint * params);
+extern PFN_glGetVertexAttribIiv _glptr_glGetVertexAttribIiv;
+#define glGetVertexAttribIiv _glptr_glGetVertexAttribIiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);
+extern PFN_glVertexAttribIPointer _glptr_glVertexAttribIPointer;
+#define glVertexAttribIPointer _glptr_glVertexAttribIPointer
+
+typedef void  (GL_APIENTRY *PFN_glBeginConditionalRender)(GLuint id, GLenum mode);
+extern PFN_glBeginConditionalRender _glptr_glBeginConditionalRender;
+#define glBeginConditionalRender _glptr_glBeginConditionalRender
+
+typedef void  (GL_APIENTRY *PFN_glClampColor)(GLenum target, GLenum clamp);
+extern PFN_glClampColor _glptr_glClampColor;
+#define glClampColor _glptr_glClampColor
+
+typedef void  (GL_APIENTRY *PFN_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer);
+extern PFN_glBindBufferBase _glptr_glBindBufferBase;
+#define glBindBufferBase _glptr_glBindBufferBase
+
+typedef void  (GL_APIENTRY *PFN_glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+extern PFN_glBindBufferRange _glptr_glBindBufferRange;
+#define glBindBufferRange _glptr_glBindBufferRange
+
+typedef void  (GL_APIENTRY *PFN_glBeginTransformFeedback)(GLenum primitiveMode);
+extern PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback;
+#define glBeginTransformFeedback _glptr_glBeginTransformFeedback
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsEnabledi)(GLenum target, GLuint index);
+extern PFN_glIsEnabledi _glptr_glIsEnabledi;
+#define glIsEnabledi _glptr_glIsEnabledi
+
+typedef void  (GL_APIENTRY *PFN_glGetIntegeri_v)(GLenum target, GLuint index, GLint * data);
+extern PFN_glGetIntegeri_v _glptr_glGetIntegeri_v;
+#define glGetIntegeri_v _glptr_glGetIntegeri_v
+
+typedef void  (GL_APIENTRY *PFN_glColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+extern PFN_glColorMaski _glptr_glColorMaski;
+#define glColorMaski _glptr_glColorMaski
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv;
+#define glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv;
+#define glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv;
+#define glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv;
+#define glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv;
+#define glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+extern PFN_glVertexAttribP4ui _glptr_glVertexAttribP4ui;
+#define glVertexAttribP4ui _glptr_glVertexAttribP4ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4ubv)(GLuint index, const GLubyte * v);
+extern PFN_glVertexAttrib4ubv _glptr_glVertexAttrib4ubv;
+#define glVertexAttrib4ubv _glptr_glVertexAttrib4ubv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4sv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttrib4sv _glptr_glVertexAttrib4sv;
+#define glVertexAttrib4sv _glptr_glVertexAttrib4sv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4fv)(GLuint index, const GLfloat * v);
+extern PFN_glVertexAttrib4fv _glptr_glVertexAttrib4fv;
+#define glVertexAttrib4fv _glptr_glVertexAttrib4fv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nusv)(GLuint index, const GLushort * v);
+extern PFN_glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv;
+#define glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nuiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv;
+#define glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nubv)(GLuint index, const GLubyte * v);
+extern PFN_glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv;
+#define glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv
+
+typedef void  (GL_APIENTRY *PFN_glProvokingVertex)(GLenum mode);
+extern PFN_glProvokingVertex _glptr_glProvokingVertex;
+#define glProvokingVertex _glptr_glProvokingVertex
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nsv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv;
+#define glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern PFN_glVertexAttrib3f _glptr_glVertexAttrib3f;
+#define glVertexAttrib3f _glptr_glVertexAttrib3f
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI1uiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttribI1uiv _glptr_glVertexAttribI1uiv;
+#define glVertexAttribI1uiv _glptr_glVertexAttribI1uiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3dv)(GLuint index, const GLdouble * v);
+extern PFN_glVertexAttrib3dv _glptr_glVertexAttrib3dv;
+#define glVertexAttrib3dv _glptr_glVertexAttrib3dv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern PFN_glVertexAttrib3d _glptr_glVertexAttrib3d;
+#define glVertexAttrib3d _glptr_glVertexAttrib3d
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2sv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttrib2sv _glptr_glVertexAttrib2sv;
+#define glVertexAttrib2sv _glptr_glVertexAttrib2sv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2fv)(GLuint index, const GLfloat * v);
+extern PFN_glVertexAttrib2fv _glptr_glVertexAttrib2fv;
+#define glVertexAttrib2fv _glptr_glVertexAttrib2fv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2dv)(GLuint index, const GLdouble * v);
+extern PFN_glVertexAttrib2dv _glptr_glVertexAttrib2dv;
+#define glVertexAttrib2dv _glptr_glVertexAttrib2dv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);
+extern PFN_glVertexAttrib2d _glptr_glVertexAttrib2d;
+#define glVertexAttrib2d _glptr_glVertexAttrib2d
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);
+extern PFN_glVertexAttrib2f _glptr_glVertexAttrib2f;
+#define glVertexAttrib2f _glptr_glVertexAttrib2f
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1s)(GLuint index, GLshort x);
+extern PFN_glVertexAttrib1s _glptr_glVertexAttrib1s;
+#define glVertexAttrib1s _glptr_glVertexAttrib1s
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1fv)(GLuint index, const GLfloat * v);
+extern PFN_glVertexAttrib1fv _glptr_glVertexAttrib1fv;
+#define glVertexAttrib1fv _glptr_glVertexAttrib1fv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1f)(GLuint index, GLfloat x);
+extern PFN_glVertexAttrib1f _glptr_glVertexAttrib1f;
+#define glVertexAttrib1f _glptr_glVertexAttrib1f
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1dv)(GLuint index, const GLdouble * v);
+extern PFN_glVertexAttrib1dv _glptr_glVertexAttrib1dv;
+#define glVertexAttrib1dv _glptr_glVertexAttrib1dv
+
+typedef void  (GL_APIENTRY *PFN_glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint * value);
+extern PFN_glClearBufferuiv _glptr_glClearBufferuiv;
+#define glClearBufferuiv _glptr_glClearBufferuiv
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix3fv _glptr_glUniformMatrix3fv;
+#define glUniformMatrix3fv _glptr_glUniformMatrix3fv
+
+typedef void  (GL_APIENTRY *PFN_glDeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers);
+extern PFN_glDeleteRenderbuffers _glptr_glDeleteRenderbuffers;
+#define glDeleteRenderbuffers _glptr_glDeleteRenderbuffers
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix2fv _glptr_glUniformMatrix2fv;
+#define glUniformMatrix2fv _glptr_glUniformMatrix2fv
+
+typedef void  (GL_APIENTRY *PFN_glUniform4iv)(GLint location, GLsizei count, const GLint * value);
+extern PFN_glUniform4iv _glptr_glUniform4iv;
+#define glUniform4iv _glptr_glUniform4iv
+
+typedef void  (GL_APIENTRY *PFN_glUniform1iv)(GLint location, GLsizei count, const GLint * value);
+extern PFN_glUniform1iv _glptr_glUniform1iv;
+#define glUniform1iv _glptr_glUniform1iv
+
+typedef void  (GL_APIENTRY *PFN_glUniform4fv)(GLint location, GLsizei count, const GLfloat * value);
+extern PFN_glUniform4fv _glptr_glUniform4fv;
+#define glUniform4fv _glptr_glUniform4fv
+
+typedef void  (GL_APIENTRY *PFN_glUniform2fv)(GLint location, GLsizei count, const GLfloat * value);
+extern PFN_glUniform2fv _glptr_glUniform2fv;
+#define glUniform2fv _glptr_glUniform2fv
+
+typedef void  (GL_APIENTRY *PFN_glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
+extern PFN_glUniform3i _glptr_glUniform3i;
+#define glUniform3i _glptr_glUniform3i
+
+typedef void  (GL_APIENTRY *PFN_glUniform2i)(GLint location, GLint v0, GLint v1);
+extern PFN_glUniform2i _glptr_glUniform2i;
+#define glUniform2i _glptr_glUniform2i
+
+typedef void  (GL_APIENTRY *PFN_glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+extern PFN_glUniform4f _glptr_glUniform4f;
+#define glUniform4f _glptr_glUniform4f
+
+typedef void  (GL_APIENTRY *PFN_glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+extern PFN_glUniform3f _glptr_glUniform3f;
+#define glUniform3f _glptr_glUniform3f
+
+typedef void  (GL_APIENTRY *PFN_glUniform1f)(GLint location, GLfloat v0);
+extern PFN_glUniform1f _glptr_glUniform1f;
+#define glUniform1f _glptr_glUniform1f
+
+typedef void  (GL_APIENTRY *PFN_glUseProgram)(GLuint program);
+extern PFN_glUseProgram _glptr_glUseProgram;
+#define glUseProgram _glptr_glUseProgram
+
+typedef void  (GL_APIENTRY *PFN_glShaderSource)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length);
+extern PFN_glShaderSource _glptr_glShaderSource;
+#define glShaderSource _glptr_glShaderSource
+
+typedef void  (GL_APIENTRY *PFN_glLinkProgram)(GLuint program);
+extern PFN_glLinkProgram _glptr_glLinkProgram;
+#define glLinkProgram _glptr_glLinkProgram
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsShader)(GLuint shader);
+extern PFN_glIsShader _glptr_glIsShader;
+#define glIsShader _glptr_glIsShader
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void ** pointer);
+extern PFN_glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv;
+#define glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint * params);
+extern PFN_glGetVertexAttribiv _glptr_glGetVertexAttribiv;
+#define glGetVertexAttribiv _glptr_glGetVertexAttribiv
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params);
+extern PFN_glGetVertexAttribfv _glptr_glGetVertexAttribfv;
+#define glGetVertexAttribfv _glptr_glGetVertexAttribfv
+
+typedef void  (GL_APIENTRY *PFN_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+extern PFN_glUniformBlockBinding _glptr_glUniformBlockBinding;
+#define glUniformBlockBinding _glptr_glUniformBlockBinding
+
+typedef GLint (GL_APIENTRY *PFN_glGetUniformLocation)(GLuint program, const GLchar * name);
+extern PFN_glGetUniformLocation _glptr_glGetUniformLocation;
+#define glGetUniformLocation _glptr_glGetUniformLocation
+
+typedef void  (GL_APIENTRY *PFN_glGetShaderiv)(GLuint shader, GLenum pname, GLint * params);
+extern PFN_glGetShaderiv _glptr_glGetShaderiv;
+#define glGetShaderiv _glptr_glGetShaderiv
+
+typedef void  (GL_APIENTRY *PFN_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+extern PFN_glGetProgramInfoLog _glptr_glGetProgramInfoLog;
+#define glGetProgramInfoLog _glptr_glGetProgramInfoLog
+
+typedef GLint (GL_APIENTRY *PFN_glGetAttribLocation)(GLuint program, const GLchar * name);
+extern PFN_glGetAttribLocation _glptr_glGetAttribLocation;
+#define glGetAttribLocation _glptr_glGetAttribLocation
+
+typedef void  (GL_APIENTRY *PFN_glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);
+extern PFN_glGetAttachedShaders _glptr_glGetAttachedShaders;
+#define glGetAttachedShaders _glptr_glGetAttachedShaders
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+extern PFN_glGetActiveUniform _glptr_glGetActiveUniform;
+#define glGetActiveUniform _glptr_glGetActiveUniform
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
+extern PFN_glGetActiveAttrib _glptr_glGetActiveAttrib;
+#define glGetActiveAttrib _glptr_glGetActiveAttrib
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4iv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttrib4iv _glptr_glVertexAttrib4iv;
+#define glVertexAttrib4iv _glptr_glVertexAttrib4iv
+
+typedef void  (GL_APIENTRY *PFN_glDisableVertexAttribArray)(GLuint index);
+extern PFN_glDisableVertexAttribArray _glptr_glDisableVertexAttribArray;
+#define glDisableVertexAttribArray _glptr_glDisableVertexAttribArray
+
+typedef void  (GL_APIENTRY *PFN_glDeleteShader)(GLuint shader);
+extern PFN_glDeleteShader _glptr_glDeleteShader;
+#define glDeleteShader _glptr_glDeleteShader
+
+typedef void  (GL_APIENTRY *PFN_glDeleteProgram)(GLuint program);
+extern PFN_glDeleteProgram _glptr_glDeleteProgram;
+#define glDeleteProgram _glptr_glDeleteProgram
+
+typedef void  (GL_APIENTRY *PFN_glGetBooleani_v)(GLenum target, GLuint index, GLboolean * data);
+extern PFN_glGetBooleani_v _glptr_glGetBooleani_v;
+#define glGetBooleani_v _glptr_glGetBooleani_v
+
+typedef void  (GL_APIENTRY *PFN_glCompileShader)(GLuint shader);
+extern PFN_glCompileShader _glptr_glCompileShader;
+#define glCompileShader _glptr_glCompileShader
+
+typedef void  (GL_APIENTRY *PFN_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
+extern PFN_glStencilFuncSeparate _glptr_glStencilFuncSeparate;
+#define glStencilFuncSeparate _glptr_glStencilFuncSeparate
+
+typedef void  (GL_APIENTRY *PFN_glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+extern PFN_glStencilOpSeparate _glptr_glStencilOpSeparate;
+#define glStencilOpSeparate _glptr_glStencilOpSeparate
+
+typedef void  (GL_APIENTRY *PFN_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+extern PFN_glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample;
+#define glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample
+
+typedef void  (GL_APIENTRY *PFN_glDrawBuffers)(GLsizei n, const GLenum * bufs);
+extern PFN_glDrawBuffers _glptr_glDrawBuffers;
+#define glDrawBuffers _glptr_glDrawBuffers
+
+typedef void  (GL_APIENTRY *PFN_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint * params);
+extern PFN_glGetBufferParameteriv _glptr_glGetBufferParameteriv;
+#define glGetBufferParameteriv _glptr_glGetBufferParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribDivisor)(GLuint index, GLuint divisor);
+extern PFN_glVertexAttribDivisor _glptr_glVertexAttribDivisor;
+#define glVertexAttribDivisor _glptr_glVertexAttribDivisor
+
+typedef GLboolean (GL_APIENTRY *PFN_glUnmapBuffer)(GLenum target);
+extern PFN_glUnmapBuffer _glptr_glUnmapBuffer;
+#define glUnmapBuffer _glptr_glUnmapBuffer
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4dv)(GLuint index, const GLdouble * v);
+extern PFN_glVertexAttrib4dv _glptr_glVertexAttrib4dv;
+#define glVertexAttrib4dv _glptr_glVertexAttrib4dv
+
+typedef void * (GL_APIENTRY *PFN_glMapBuffer)(GLenum target, GLenum access);
+extern PFN_glMapBuffer _glptr_glMapBuffer;
+#define glMapBuffer _glptr_glMapBuffer
+
+typedef void  (GL_APIENTRY *PFN_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data);
+extern PFN_glBufferSubData _glptr_glBufferSubData;
+#define glBufferSubData _glptr_glBufferSubData
+
+typedef void  (GL_APIENTRY *PFN_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params);
+extern PFN_glGetQueryObjectuiv _glptr_glGetQueryObjectuiv;
+#define glGetQueryObjectuiv _glptr_glGetQueryObjectuiv
+
+typedef void  (GL_APIENTRY *PFN_glGetQueryObjectiv)(GLuint id, GLenum pname, GLint * params);
+extern PFN_glGetQueryObjectiv _glptr_glGetQueryObjectiv;
+#define glGetQueryObjectiv _glptr_glGetQueryObjectiv
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsQuery)(GLuint id);
+extern PFN_glIsQuery _glptr_glIsQuery;
+#define glIsQuery _glptr_glIsQuery
+
+typedef void  (GL_APIENTRY *PFN_glDeleteQueries)(GLsizei n, const GLuint * ids);
+extern PFN_glDeleteQueries _glptr_glDeleteQueries;
+#define glDeleteQueries _glptr_glDeleteQueries
+
+typedef void  (GL_APIENTRY *PFN_glGenQueries)(GLsizei n, GLuint * ids);
+extern PFN_glGenQueries _glptr_glGenQueries;
+#define glGenQueries _glptr_glGenQueries
+
+typedef void  (GL_APIENTRY *PFN_glBlendEquation)(GLenum mode);
+extern PFN_glBlendEquation _glptr_glBlendEquation;
+#define glBlendEquation _glptr_glBlendEquation
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3sv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttrib3sv _glptr_glVertexAttrib3sv;
+#define glVertexAttrib3sv _glptr_glVertexAttrib3sv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
+extern PFN_glVertexAttribI3ui _glptr_glVertexAttribI3ui;
+#define glVertexAttribI3ui _glptr_glVertexAttribI3ui
+
+typedef void  (GL_APIENTRY *PFN_glGenBuffers)(GLsizei n, GLuint * buffers);
+extern PFN_glGenBuffers _glptr_glGenBuffers;
+#define glGenBuffers _glptr_glGenBuffers
+
+typedef GLenum (GL_APIENTRY *PFN_glCheckFramebufferStatus)(GLenum target);
+extern PFN_glCheckFramebufferStatus _glptr_glCheckFramebufferStatus;
+#define glCheckFramebufferStatus _glptr_glCheckFramebufferStatus
+
+typedef void  (GL_APIENTRY *PFN_glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+extern PFN_glUniform4i _glptr_glUniform4i;
+#define glUniform4i _glptr_glUniform4i
+
+typedef void  (GL_APIENTRY *PFN_glPointParameteriv)(GLenum pname, const GLint * params);
+extern PFN_glPointParameteriv _glptr_glPointParameteriv;
+#define glPointParameteriv _glptr_glPointParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib2s)(GLuint index, GLshort x, GLshort y);
+extern PFN_glVertexAttrib2s _glptr_glVertexAttrib2s;
+#define glVertexAttrib2s _glptr_glVertexAttrib2s
+
+typedef void  (GL_APIENTRY *PFN_glFinish)();
+extern PFN_glFinish _glptr_glFinish;
+#define glFinish _glptr_glFinish
+
+typedef void  (GL_APIENTRY *PFN_glPointParameteri)(GLenum pname, GLint param);
+extern PFN_glPointParameteri _glptr_glPointParameteri;
+#define glPointParameteri _glptr_glPointParameteri
+
+typedef void  (GL_APIENTRY *PFN_glMultiDrawArrays)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount);
+extern PFN_glMultiDrawArrays _glptr_glMultiDrawArrays;
+#define glMultiDrawArrays _glptr_glMultiDrawArrays
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+extern PFN_glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer;
+#define glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer
+
+typedef GLint (GL_APIENTRY *PFN_glGetFragDataIndex)(GLuint program, const GLchar * name);
+extern PFN_glGetFragDataIndex _glptr_glGetFragDataIndex;
+#define glGetFragDataIndex _glptr_glGetFragDataIndex
+
+typedef void  (GL_APIENTRY *PFN_glGetQueryiv)(GLenum target, GLenum pname, GLint * params);
+extern PFN_glGetQueryiv _glptr_glGetQueryiv;
+#define glGetQueryiv _glptr_glGetQueryiv
+
+typedef void  (GL_APIENTRY *PFN_glGetUniformfv)(GLuint program, GLint location, GLfloat * params);
+extern PFN_glGetUniformfv _glptr_glGetUniformfv;
+#define glGetUniformfv _glptr_glGetUniformfv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4usv)(GLuint index, const GLushort * v);
+extern PFN_glVertexAttrib4usv _glptr_glVertexAttrib4usv;
+#define glVertexAttrib4usv _glptr_glVertexAttrib4usv
+
+typedef void  (GL_APIENTRY *PFN_glDeleteSync)(GLsync sync);
+extern PFN_glDeleteSync _glptr_glDeleteSync;
+#define glDeleteSync _glptr_glDeleteSync
+
+typedef void  (GL_APIENTRY *PFN_glGetCompressedTexImage)(GLenum target, GLint level, void * img);
+extern PFN_glGetCompressedTexImage _glptr_glGetCompressedTexImage;
+#define glGetCompressedTexImage _glptr_glGetCompressedTexImage
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D;
+#define glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D
+
+typedef void  (GL_APIENTRY *PFN_glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+extern PFN_glUniform4ui _glptr_glUniform4ui;
+#define glUniform4ui _glptr_glUniform4ui
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4usv)(GLuint index, const GLushort * v);
+extern PFN_glVertexAttribI4usv _glptr_glVertexAttribI4usv;
+#define glVertexAttribI4usv _glptr_glVertexAttribI4usv
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexImage2D _glptr_glCompressedTexImage2D;
+#define glCompressedTexImage2D _glptr_glCompressedTexImage2D
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexImage3D _glptr_glCompressedTexImage3D;
+#define glCompressedTexImage3D _glptr_glCompressedTexImage3D
+
+typedef void  (GL_APIENTRY *PFN_glSampleCoverage)(GLfloat value, GLboolean invert);
+extern PFN_glSampleCoverage _glptr_glSampleCoverage;
+#define glSampleCoverage _glptr_glSampleCoverage
+
+typedef void  (GL_APIENTRY *PFN_glActiveTexture)(GLenum texture);
+extern PFN_glActiveTexture _glptr_glActiveTexture;
+#define glActiveTexture _glptr_glActiveTexture
+
+typedef void  (GL_APIENTRY *PFN_glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern PFN_glCopyTexSubImage3D _glptr_glCopyTexSubImage3D;
+#define glCopyTexSubImage3D _glptr_glCopyTexSubImage3D
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexImage1D _glptr_glCompressedTexImage1D;
+#define glCompressedTexImage1D _glptr_glCompressedTexImage1D
+
+typedef void  (GL_APIENTRY *PFN_glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexSubImage3D _glptr_glTexSubImage3D;
+#define glTexSubImage3D _glptr_glTexSubImage3D
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix4fv _glptr_glUniformMatrix4fv;
+#define glUniformMatrix4fv _glptr_glUniformMatrix4fv
+
+typedef const GLubyte * (GL_APIENTRY *PFN_glGetString)(GLenum name);
+extern PFN_glGetString _glptr_glGetString;
+#define glGetString _glptr_glGetString
+
+typedef void  (GL_APIENTRY *PFN_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+extern PFN_glRenderbufferStorage _glptr_glRenderbufferStorage;
+#define glRenderbufferStorage _glptr_glRenderbufferStorage
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsTexture)(GLuint texture);
+extern PFN_glIsTexture _glptr_glIsTexture;
+#define glIsTexture _glptr_glIsTexture
+
+typedef void  (GL_APIENTRY *PFN_glGenTextures)(GLsizei n, GLuint * textures);
+extern PFN_glGenTextures _glptr_glGenTextures;
+#define glGenTextures _glptr_glGenTextures
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+extern PFN_glVertexAttribP3ui _glptr_glVertexAttribP3ui;
+#define glVertexAttribP3ui _glptr_glVertexAttribP3ui
+
+typedef void  (GL_APIENTRY *PFN_glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexSubImage1D _glptr_glTexSubImage1D;
+#define glTexSubImage1D _glptr_glTexSubImage1D
+
+typedef GLenum (GL_APIENTRY *PFN_glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
+extern PFN_glClientWaitSync _glptr_glClientWaitSync;
+#define glClientWaitSync _glptr_glClientWaitSync
+
+typedef void  (GL_APIENTRY *PFN_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern PFN_glCopyTexSubImage2D _glptr_glCopyTexSubImage2D;
+#define glCopyTexSubImage2D _glptr_glCopyTexSubImage2D
+
+typedef void  (GL_APIENTRY *PFN_glCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern PFN_glCopyTexSubImage1D _glptr_glCopyTexSubImage1D;
+#define glCopyTexSubImage1D _glptr_glCopyTexSubImage1D
+
+typedef void  (GL_APIENTRY *PFN_glCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+extern PFN_glCopyTexImage1D _glptr_glCopyTexImage1D;
+#define glCopyTexImage1D _glptr_glCopyTexImage1D
+
+typedef void  (GL_APIENTRY *PFN_glPolygonOffset)(GLfloat factor, GLfloat units);
+extern PFN_glPolygonOffset _glptr_glPolygonOffset;
+#define glPolygonOffset _glptr_glPolygonOffset
+
+typedef void  (GL_APIENTRY *PFN_glTexImage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
+extern PFN_glTexImage2DMultisample _glptr_glTexImage2DMultisample;
+#define glTexImage2DMultisample _glptr_glTexImage2DMultisample
+
+typedef void  (GL_APIENTRY *PFN_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void * indices);
+extern PFN_glDrawElements _glptr_glDrawElements;
+#define glDrawElements _glptr_glDrawElements
+
+typedef void  (GL_APIENTRY *PFN_glEndConditionalRender)();
+extern PFN_glEndConditionalRender _glptr_glEndConditionalRender;
+#define glEndConditionalRender _glptr_glEndConditionalRender
+
+typedef void  (GL_APIENTRY *PFN_glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
+extern PFN_glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying;
+#define glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying
+
+typedef void  (GL_APIENTRY *PFN_glTexParameteriv)(GLenum target, GLenum pname, const GLint * params);
+extern PFN_glTexParameteriv _glptr_glTexParameteriv;
+#define glTexParameteriv _glptr_glTexParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glDeleteFramebuffers)(GLsizei n, const GLuint * framebuffers);
+extern PFN_glDeleteFramebuffers _glptr_glDeleteFramebuffers;
+#define glDeleteFramebuffers _glptr_glDeleteFramebuffers
+
+typedef void  (GL_APIENTRY *PFN_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
+extern PFN_glBlendEquationSeparate _glptr_glBlendEquationSeparate;
+#define glBlendEquationSeparate _glptr_glBlendEquationSeparate
+
+typedef void  (GL_APIENTRY *PFN_glDeleteTextures)(GLsizei n, const GLuint * textures);
+extern PFN_glDeleteTextures _glptr_glDeleteTextures;
+#define glDeleteTextures _glptr_glDeleteTextures
+
+typedef void  (GL_APIENTRY *PFN_glGetProgramiv)(GLuint program, GLenum pname, GLint * params);
+extern PFN_glGetProgramiv _glptr_glGetProgramiv;
+#define glGetProgramiv _glptr_glGetProgramiv
+
+typedef void  (GL_APIENTRY *PFN_glUniform1uiv)(GLint location, GLsizei count, const GLuint * value);
+extern PFN_glUniform1uiv _glptr_glUniform1uiv;
+#define glUniform1uiv _glptr_glUniform1uiv
+
+typedef void  (GL_APIENTRY *PFN_glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern PFN_glCopyTexImage2D _glptr_glCopyTexImage2D;
+#define glCopyTexImage2D _glptr_glCopyTexImage2D
+
+typedef void  (GL_APIENTRY *PFN_glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params);
+extern PFN_glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv;
+#define glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv
+
+typedef void  (GL_APIENTRY *PFN_glSampleMaski)(GLuint maskNumber, GLbitfield mask);
+extern PFN_glSampleMaski _glptr_glSampleMaski;
+#define glSampleMaski _glptr_glSampleMaski
+
+typedef void  (GL_APIENTRY *PFN_glBindTexture)(GLenum target, GLuint texture);
+extern PFN_glBindTexture _glptr_glBindTexture;
+#define glBindTexture _glptr_glBindTexture
+
+typedef void  (GL_APIENTRY *PFN_glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params);
+extern PFN_glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv;
+#define glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv
+
+typedef void  (GL_APIENTRY *PFN_glGetUniformuiv)(GLuint program, GLint location, GLuint * params);
+extern PFN_glGetUniformuiv _glptr_glGetUniformuiv;
+#define glGetUniformuiv _glptr_glGetUniformuiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nbv)(GLuint index, const GLbyte * v);
+extern PFN_glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv;
+#define glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv
+
+typedef void  (GL_APIENTRY *PFN_glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexImage3D _glptr_glTexImage3D;
+#define glTexImage3D _glptr_glTexImage3D
+
+typedef void  (GL_APIENTRY *PFN_glQueryCounter)(GLuint id, GLenum target);
+extern PFN_glQueryCounter _glptr_glQueryCounter;
+#define glQueryCounter _glptr_glQueryCounter
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern PFN_glVertexAttrib4f _glptr_glVertexAttrib4f;
+#define glVertexAttrib4f _glptr_glVertexAttrib4f
+
+typedef void  (GL_APIENTRY *PFN_glUniform2ui)(GLint location, GLuint v0, GLuint v1);
+extern PFN_glUniform2ui _glptr_glUniform2ui;
+#define glUniform2ui _glptr_glUniform2ui
+
+typedef void  (GL_APIENTRY *PFN_glGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
+extern PFN_glGetTexImage _glptr_glGetTexImage;
+#define glGetTexImage _glptr_glGetTexImage
+
+typedef void  (GL_APIENTRY *PFN_glGetTexParameterIuiv)(GLenum target, GLenum pname, GLuint * params);
+extern PFN_glGetTexParameterIuiv _glptr_glGetTexParameterIuiv;
+#define glGetTexParameterIuiv _glptr_glGetTexParameterIuiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4bv)(GLuint index, const GLbyte * v);
+extern PFN_glVertexAttrib4bv _glptr_glVertexAttrib4bv;
+#define glVertexAttrib4bv _glptr_glVertexAttrib4bv
+
+typedef void  (GL_APIENTRY *PFN_glUniform2uiv)(GLint location, GLsizei count, const GLuint * value);
+extern PFN_glUniform2uiv _glptr_glUniform2uiv;
+#define glUniform2uiv _glptr_glUniform2uiv
+
+typedef void  (GL_APIENTRY *PFN_glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source);
+extern PFN_glGetShaderSource _glptr_glGetShaderSource;
+#define glGetShaderSource _glptr_glGetShaderSource
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsBuffer)(GLuint buffer);
+extern PFN_glIsBuffer _glptr_glIsBuffer;
+#define glIsBuffer _glptr_glIsBuffer
+
+typedef void  (GL_APIENTRY *PFN_glGetBufferPointerv)(GLenum target, GLenum pname, void ** params);
+extern PFN_glGetBufferPointerv _glptr_glGetBufferPointerv;
+#define glGetBufferPointerv _glptr_glGetBufferPointerv
+
+typedef void  (GL_APIENTRY *PFN_glPolygonMode)(GLenum face, GLenum mode);
+extern PFN_glPolygonMode _glptr_glPolygonMode;
+#define glPolygonMode _glptr_glPolygonMode
+
+typedef void  (GL_APIENTRY *PFN_glBindAttribLocation)(GLuint program, GLuint index, const GLchar * name);
+extern PFN_glBindAttribLocation _glptr_glBindAttribLocation;
+#define glBindAttribLocation _glptr_glBindAttribLocation
+
+typedef void  (GL_APIENTRY *PFN_glDeleteSamplers)(GLsizei count, const GLuint * samplers);
+extern PFN_glDeleteSamplers _glptr_glDeleteSamplers;
+#define glDeleteSamplers _glptr_glDeleteSamplers
+
+typedef void  (GL_APIENTRY *PFN_glUniform2f)(GLint location, GLfloat v0, GLfloat v1);
+extern PFN_glUniform2f _glptr_glUniform2f;
+#define glUniform2f _glptr_glUniform2f
+
+typedef void  (GL_APIENTRY *PFN_glPixelStoref)(GLenum pname, GLfloat param);
+extern PFN_glPixelStoref _glptr_glPixelStoref;
+#define glPixelStoref _glptr_glPixelStoref
+
+typedef void  (GL_APIENTRY *PFN_glLogicOp)(GLenum opcode);
+extern PFN_glLogicOp _glptr_glLogicOp;
+#define glLogicOp _glptr_glLogicOp
+
+typedef GLuint (GL_APIENTRY *PFN_glCreateShader)(GLenum type);
+extern PFN_glCreateShader _glptr_glCreateShader;
+#define glCreateShader _glptr_glCreateShader
+
+typedef void  (GL_APIENTRY *PFN_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexSubImage2D _glptr_glTexSubImage2D;
+#define glTexSubImage2D _glptr_glTexSubImage2D
+
+typedef void  (GL_APIENTRY *PFN_glClearDepth)(GLdouble depth);
+extern PFN_glClearDepth _glptr_glClearDepth;
+#define glClearDepth _glptr_glClearDepth
+
+typedef void  (GL_APIENTRY *PFN_glGetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, void * data);
+extern PFN_glGetBufferSubData _glptr_glGetBufferSubData;
+#define glGetBufferSubData _glptr_glGetBufferSubData
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4uiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttrib4uiv _glptr_glVertexAttrib4uiv;
+#define glVertexAttrib4uiv _glptr_glVertexAttrib4uiv
+
+typedef void  (GL_APIENTRY *PFN_glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+extern PFN_glCopyBufferSubData _glptr_glCopyBufferSubData;
+#define glCopyBufferSubData _glptr_glCopyBufferSubData
+
+typedef void  (GL_APIENTRY *PFN_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+extern PFN_glFramebufferTexture2D _glptr_glFramebufferTexture2D;
+#define glFramebufferTexture2D _glptr_glFramebufferTexture2D
+
+typedef void  (GL_APIENTRY *PFN_glPointParameterf)(GLenum pname, GLfloat param);
+extern PFN_glPointParameterf _glptr_glPointParameterf;
+#define glPointParameterf _glptr_glPointParameterf
+
+typedef void  (GL_APIENTRY *PFN_glDisablei)(GLenum target, GLuint index);
+extern PFN_glDisablei _glptr_glDisablei;
+#define glDisablei _glptr_glDisablei
+
+typedef void  (GL_APIENTRY *PFN_glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
+extern PFN_glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv;
+#define glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern PFN_glVertexAttrib4d _glptr_glVertexAttrib4d;
+#define glVertexAttrib4d _glptr_glVertexAttrib4d
+
+typedef void  (GL_APIENTRY *PFN_glTexParameterIuiv)(GLenum target, GLenum pname, const GLuint * params);
+extern PFN_glTexParameterIuiv _glptr_glTexParameterIuiv;
+#define glTexParameterIuiv _glptr_glTexParameterIuiv
+
+typedef void  (GL_APIENTRY *PFN_glGetFloatv)(GLenum pname, GLfloat * data);
+extern PFN_glGetFloatv _glptr_glGetFloatv;
+#define glGetFloatv _glptr_glGetFloatv
+
+typedef GLuint (GL_APIENTRY *PFN_glCreateProgram)();
+extern PFN_glCreateProgram _glptr_glCreateProgram;
+#define glCreateProgram _glptr_glCreateProgram
+
+typedef void  (GL_APIENTRY *PFN_glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
+extern PFN_glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings;
+#define glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1d)(GLuint index, GLdouble x);
+extern PFN_glVertexAttrib1d _glptr_glVertexAttrib1d;
+#define glVertexAttrib1d _glptr_glVertexAttrib1d
+
+typedef void  (GL_APIENTRY *PFN_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
+extern PFN_glViewport _glptr_glViewport;
+#define glViewport _glptr_glViewport
+
+typedef void  (GL_APIENTRY *PFN_glDeleteBuffers)(GLsizei n, const GLuint * buffers);
+extern PFN_glDeleteBuffers _glptr_glDeleteBuffers;
+#define glDeleteBuffers _glptr_glDeleteBuffers
+
+typedef void  (GL_APIENTRY *PFN_glFlush)();
+extern PFN_glFlush _glptr_glFlush;
+#define glFlush _glptr_glFlush
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4sv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttribI4sv _glptr_glVertexAttribI4sv;
+#define glVertexAttribI4sv _glptr_glVertexAttribI4sv
+
+typedef void  (GL_APIENTRY *PFN_glDrawArrays)(GLenum mode, GLint first, GLsizei count);
+extern PFN_glDrawArrays _glptr_glDrawArrays;
+#define glDrawArrays _glptr_glDrawArrays
+
+typedef void  (GL_APIENTRY *PFN_glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount);
+extern PFN_glDrawElementsInstanced _glptr_glDrawElementsInstanced;
+#define glDrawElementsInstanced _glptr_glDrawElementsInstanced
+
+typedef void  (GL_APIENTRY *PFN_glUniform3iv)(GLint location, GLsizei count, const GLint * value);
+extern PFN_glUniform3iv _glptr_glUniform3iv;
+#define glUniform3iv _glptr_glUniform3iv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);
+extern PFN_glVertexAttribPointer _glptr_glVertexAttribPointer;
+#define glVertexAttribPointer _glptr_glVertexAttribPointer
+
+typedef void  (GL_APIENTRY *PFN_glGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values);
+extern PFN_glGetSynciv _glptr_glGetSynciv;
+#define glGetSynciv _glptr_glGetSynciv
+
+typedef void  (GL_APIENTRY *PFN_glPrimitiveRestartIndex)(GLuint index);
+extern PFN_glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex;
+#define glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex
+
+typedef void  (GL_APIENTRY *PFN_glUniform1i)(GLint location, GLint v0);
+extern PFN_glUniform1i _glptr_glUniform1i;
+#define glUniform1i _glptr_glUniform1i
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib1sv)(GLuint index, const GLshort * v);
+extern PFN_glVertexAttrib1sv _glptr_glVertexAttrib1sv;
+#define glVertexAttrib1sv _glptr_glVertexAttrib1sv
+
+typedef void  (GL_APIENTRY *PFN_glDisable)(GLenum cap);
+extern PFN_glDisable _glptr_glDisable;
+#define glDisable _glptr_glDisable
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4uiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttribI4uiv _glptr_glVertexAttribI4uiv;
+#define glVertexAttribI4uiv _glptr_glVertexAttribI4uiv
+
+typedef void  (GL_APIENTRY *PFN_glEndQuery)(GLenum target);
+extern PFN_glEndQuery _glptr_glEndQuery;
+#define glEndQuery _glptr_glEndQuery
+
+typedef void  (GL_APIENTRY *PFN_glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern PFN_glColorMask _glptr_glColorMask;
+#define glColorMask _glptr_glColorMask
+
+typedef void  (GL_APIENTRY *PFN_glEnablei)(GLenum target, GLuint index);
+extern PFN_glEnablei _glptr_glEnablei;
+#define glEnablei _glptr_glEnablei
+
+typedef void  (GL_APIENTRY *PFN_glBindBuffer)(GLenum target, GLuint buffer);
+extern PFN_glBindBuffer _glptr_glBindBuffer;
+#define glBindBuffer _glptr_glBindBuffer
+
+typedef void  (GL_APIENTRY *PFN_glGetDoublev)(GLenum pname, GLdouble * data);
+extern PFN_glGetDoublev _glptr_glGetDoublev;
+#define glGetDoublev _glptr_glGetDoublev
+
+typedef void  (GL_APIENTRY *PFN_glGetTexParameteriv)(GLenum target, GLenum pname, GLint * params);
+extern PFN_glGetTexParameteriv _glptr_glGetTexParameteriv;
+#define glGetTexParameteriv _glptr_glGetTexParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glDeleteVertexArrays)(GLsizei n, const GLuint * arrays);
+extern PFN_glDeleteVertexArrays _glptr_glDeleteVertexArrays;
+#define glDeleteVertexArrays _glptr_glDeleteVertexArrays
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI2uiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttribI2uiv _glptr_glVertexAttribI2uiv;
+#define glVertexAttribI2uiv _glptr_glVertexAttribI2uiv
+
+typedef void  (GL_APIENTRY *PFN_glDepthMask)(GLboolean flag);
+extern PFN_glDepthMask _glptr_glDepthMask;
+#define glDepthMask _glptr_glDepthMask
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble * params);
+extern PFN_glGetVertexAttribdv _glptr_glGetVertexAttribdv;
+#define glGetVertexAttribdv _glptr_glGetVertexAttribdv
+
+typedef void  (GL_APIENTRY *PFN_glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices);
+extern PFN_glDrawRangeElements _glptr_glDrawRangeElements;
+#define glDrawRangeElements _glptr_glDrawRangeElements
+
+typedef void  (GL_APIENTRY *PFN_glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+extern PFN_glDrawArraysInstanced _glptr_glDrawArraysInstanced;
+#define glDrawArraysInstanced _glptr_glDrawArraysInstanced
+
+typedef void  (GL_APIENTRY *PFN_glGetSamplerParameterIiv)(GLuint sampler, GLenum pname, GLint * params);
+extern PFN_glGetSamplerParameterIiv _glptr_glGetSamplerParameterIiv;
+#define glGetSamplerParameterIiv _glptr_glGetSamplerParameterIiv
+
+typedef void  (GL_APIENTRY *PFN_glClearStencil)(GLint s);
+extern PFN_glClearStencil _glptr_glClearStencil;
+#define glClearStencil _glptr_glClearStencil
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI3iv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttribI3iv _glptr_glVertexAttribI3iv;
+#define glVertexAttribI3iv _glptr_glVertexAttribI3iv
+
+typedef void  (GL_APIENTRY *PFN_glDrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex);
+extern PFN_glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex;
+#define glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex
+
+typedef void  (GL_APIENTRY *PFN_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
+extern PFN_glScissor _glptr_glScissor;
+#define glScissor _glptr_glScissor
+
+typedef void  (GL_APIENTRY *PFN_glGenerateMipmap)(GLenum target);
+extern PFN_glGenerateMipmap _glptr_glGenerateMipmap;
+#define glGenerateMipmap _glptr_glGenerateMipmap
+
+typedef void  (GL_APIENTRY *PFN_glUniform3fv)(GLint location, GLsizei count, const GLfloat * value);
+extern PFN_glUniform3fv _glptr_glUniform3fv;
+#define glUniform3fv _glptr_glUniform3fv
+
+typedef void  (GL_APIENTRY *PFN_glUniform3uiv)(GLint location, GLsizei count, const GLuint * value);
+extern PFN_glUniform3uiv _glptr_glUniform3uiv;
+#define glUniform3uiv _glptr_glUniform3uiv
+
+typedef void  (GL_APIENTRY *PFN_glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint * value);
+extern PFN_glClearBufferiv _glptr_glClearBufferiv;
+#define glClearBufferiv _glptr_glClearBufferiv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI4ubv)(GLuint index, const GLubyte * v);
+extern PFN_glVertexAttribI4ubv _glptr_glVertexAttribI4ubv;
+#define glVertexAttribI4ubv _glptr_glVertexAttribI4ubv
+
+typedef void  (GL_APIENTRY *PFN_glGetBooleanv)(GLenum pname, GLboolean * data);
+extern PFN_glGetBooleanv _glptr_glGetBooleanv;
+#define glGetBooleanv _glptr_glGetBooleanv
+
+typedef void  (GL_APIENTRY *PFN_glValidateProgram)(GLuint program);
+extern PFN_glValidateProgram _glptr_glValidateProgram;
+#define glValidateProgram _glptr_glValidateProgram
+
+typedef void  (GL_APIENTRY *PFN_glGenRenderbuffers)(GLsizei n, GLuint * renderbuffers);
+extern PFN_glGenRenderbuffers _glptr_glGenRenderbuffers;
+#define glGenRenderbuffers _glptr_glGenRenderbuffers
+
+typedef void  (GL_APIENTRY *PFN_glUniform2iv)(GLint location, GLsizei count, const GLint * value);
+extern PFN_glUniform2iv _glptr_glUniform2iv;
+#define glUniform2iv _glptr_glUniform2iv
+
+typedef void  (GL_APIENTRY *PFN_glBufferData)(GLenum target, GLsizeiptr size, const void * data, GLenum usage);
+extern PFN_glBufferData _glptr_glBufferData;
+#define glBufferData _glptr_glBufferData
+
+typedef void  (GL_APIENTRY *PFN_glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+extern PFN_glBlendFuncSeparate _glptr_glBlendFuncSeparate;
+#define glBlendFuncSeparate _glptr_glBlendFuncSeparate
+
+typedef void  (GL_APIENTRY *PFN_glTexParameteri)(GLenum target, GLenum pname, GLint param);
+extern PFN_glTexParameteri _glptr_glTexParameteri;
+#define glTexParameteri _glptr_glTexParameteri
+
+typedef void  (GL_APIENTRY *PFN_glHint)(GLenum target, GLenum mode);
+extern PFN_glHint _glptr_glHint;
+#define glHint _glptr_glHint
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3fv)(GLuint index, const GLfloat * v);
+extern PFN_glVertexAttrib3fv _glptr_glVertexAttrib3fv;
+#define glVertexAttrib3fv _glptr_glVertexAttrib3fv
+
+typedef void  (GL_APIENTRY *PFN_glGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint * params);
+extern PFN_glGetSamplerParameteriv _glptr_glGetSamplerParameteriv;
+#define glGetSamplerParameteriv _glptr_glGetSamplerParameteriv
+
+typedef void  (GL_APIENTRY *PFN_glDrawBuffer)(GLenum buf);
+extern PFN_glDrawBuffer _glptr_glDrawBuffer;
+#define glDrawBuffer _glptr_glDrawBuffer
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsProgram)(GLuint program);
+extern PFN_glIsProgram _glptr_glIsProgram;
+#define glIsProgram _glptr_glIsProgram
+
+typedef void  (GL_APIENTRY *PFN_glGetIntegerv)(GLenum pname, GLint * data);
+extern PFN_glGetIntegerv _glptr_glGetIntegerv;
+#define glGetIntegerv _glptr_glGetIntegerv
+
+typedef void  (GL_APIENTRY *PFN_glDrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex);
+extern PFN_glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex;
+#define glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex
+
+typedef void  (GL_APIENTRY *PFN_glEnable)(GLenum cap);
+extern PFN_glEnable _glptr_glEnable;
+#define glEnable _glptr_glEnable
+
+typedef void  (GL_APIENTRY *PFN_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+extern PFN_glBlitFramebuffer _glptr_glBlitFramebuffer;
+#define glBlitFramebuffer _glptr_glBlitFramebuffer
+
+typedef void  (GL_APIENTRY *PFN_glBeginQuery)(GLenum target, GLuint id);
+extern PFN_glBeginQuery _glptr_glBeginQuery;
+#define glBeginQuery _glptr_glBeginQuery
+
+typedef void  (GL_APIENTRY *PFN_glStencilMask)(GLuint mask);
+extern PFN_glStencilMask _glptr_glStencilMask;
+#define glStencilMask _glptr_glStencilMask
+
+typedef void  (GL_APIENTRY *PFN_glAttachShader)(GLuint program, GLuint shader);
+extern PFN_glAttachShader _glptr_glAttachShader;
+#define glAttachShader _glptr_glAttachShader
+
+typedef void  (GL_APIENTRY *PFN_glPointSize)(GLfloat size);
+extern PFN_glPointSize _glptr_glPointSize;
+#define glPointSize _glptr_glPointSize
+
+typedef void  (GL_APIENTRY *PFN_glMultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount);
+extern PFN_glMultiDrawElements _glptr_glMultiDrawElements;
+#define glMultiDrawElements _glptr_glMultiDrawElements
+
+typedef void  (GL_APIENTRY *PFN_glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params);
+extern PFN_glGetTexParameterfv _glptr_glGetTexParameterfv;
+#define glGetTexParameterfv _glptr_glGetTexParameterfv
+
+typedef GLboolean (GL_APIENTRY *PFN_glIsEnabled)(GLenum cap);
+extern PFN_glIsEnabled _glptr_glIsEnabled;
+#define glIsEnabled _glptr_glIsEnabled
+
+typedef void  (GL_APIENTRY *PFN_glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params);
+extern PFN_glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv;
+#define glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv
+
+typedef GLenum (GL_APIENTRY *PFN_glGetError)();
+extern PFN_glGetError _glptr_glGetError;
+#define glGetError _glptr_glGetError
+
+typedef void  (GL_APIENTRY *PFN_glEndTransformFeedback)();
+extern PFN_glEndTransformFeedback _glptr_glEndTransformFeedback;
+#define glEndTransformFeedback _glptr_glEndTransformFeedback
+
+typedef void  (GL_APIENTRY *PFN_glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern PFN_glClearColor _glptr_glClearColor;
+#define glClearColor _glptr_glClearColor
+
+typedef void  (GL_APIENTRY *PFN_glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern PFN_glBlendColor _glptr_glBlendColor;
+#define glBlendColor _glptr_glBlendColor
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
+extern PFN_glVertexAttribI3i _glptr_glVertexAttribI3i;
+#define glVertexAttribI3i _glptr_glVertexAttribI3i
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D;
+#define glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D
+
+typedef void  (GL_APIENTRY *PFN_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
+extern PFN_glReadPixels _glptr_glReadPixels;
+#define glReadPixels _glptr_glReadPixels
+
+typedef void  (GL_APIENTRY *PFN_glTexParameterf)(GLenum target, GLenum pname, GLfloat param);
+extern PFN_glTexParameterf _glptr_glTexParameterf;
+#define glTexParameterf _glptr_glTexParameterf
+
+typedef void  (GL_APIENTRY *PFN_glSamplerParameterIiv)(GLuint sampler, GLenum pname, const GLint * param);
+extern PFN_glSamplerParameterIiv _glptr_glSamplerParameterIiv;
+#define glSamplerParameterIiv _glptr_glSamplerParameterIiv
+
+typedef void  (GL_APIENTRY *PFN_glPointParameterfv)(GLenum pname, const GLfloat * params);
+extern PFN_glPointParameterfv _glptr_glPointParameterfv;
+#define glPointParameterfv _glptr_glPointParameterfv
+
+typedef void  (GL_APIENTRY *PFN_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
+extern PFN_glGetShaderInfoLog _glptr_glGetShaderInfoLog;
+#define glGetShaderInfoLog _glptr_glGetShaderInfoLog
+
+typedef void  (GL_APIENTRY *PFN_glDepthFunc)(GLenum func);
+extern PFN_glDepthFunc _glptr_glDepthFunc;
+#define glDepthFunc _glptr_glDepthFunc
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribI3uiv)(GLuint index, const GLuint * v);
+extern PFN_glVertexAttribI3uiv _glptr_glVertexAttribI3uiv;
+#define glVertexAttribI3uiv _glptr_glVertexAttribI3uiv
+
+typedef void  (GL_APIENTRY *PFN_glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
+extern PFN_glStencilOp _glptr_glStencilOp;
+#define glStencilOp _glptr_glStencilOp
+
+typedef void  (GL_APIENTRY *PFN_glStencilFunc)(GLenum func, GLint ref, GLuint mask);
+extern PFN_glStencilFunc _glptr_glStencilFunc;
+#define glStencilFunc _glptr_glStencilFunc
+
+typedef void  (GL_APIENTRY *PFN_glEnableVertexAttribArray)(GLuint index);
+extern PFN_glEnableVertexAttribArray _glptr_glEnableVertexAttribArray;
+#define glEnableVertexAttribArray _glptr_glEnableVertexAttribArray
+
+typedef void  (GL_APIENTRY *PFN_glBlendFunc)(GLenum sfactor, GLenum dfactor);
+extern PFN_glBlendFunc _glptr_glBlendFunc;
+#define glBlendFunc _glptr_glBlendFunc
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern PFN_glVertexAttrib4Nub _glptr_glVertexAttrib4Nub;
+#define glVertexAttrib4Nub _glptr_glVertexAttrib4Nub
+
+typedef void  (GL_APIENTRY *PFN_glUniform1fv)(GLint location, GLsizei count, const GLfloat * value);
+extern PFN_glUniform1fv _glptr_glUniform1fv;
+#define glUniform1fv _glptr_glUniform1fv
+
+typedef void  (GL_APIENTRY *PFN_glPixelStorei)(GLenum pname, GLint param);
+extern PFN_glPixelStorei _glptr_glPixelStorei;
+#define glPixelStorei _glptr_glPixelStorei
+
+typedef void  (GL_APIENTRY *PFN_glLineWidth)(GLfloat width);
+extern PFN_glLineWidth _glptr_glLineWidth;
+#define glLineWidth _glptr_glLineWidth
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
+extern PFN_glVertexAttribP1ui _glptr_glVertexAttribP1ui;
+#define glVertexAttribP1ui _glptr_glVertexAttribP1ui
+
+typedef void  (GL_APIENTRY *PFN_glGetUniformiv)(GLuint program, GLint location, GLint * params);
+extern PFN_glGetUniformiv _glptr_glGetUniformiv;
+#define glGetUniformiv _glptr_glGetUniformiv
+
+typedef void  (GL_APIENTRY *PFN_glReadBuffer)(GLenum src);
+extern PFN_glReadBuffer _glptr_glReadBuffer;
+#define glReadBuffer _glptr_glReadBuffer
+
+typedef void  (GL_APIENTRY *PFN_glTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexImage1D _glptr_glTexImage1D;
+#define glTexImage1D _glptr_glTexImage1D
+
+typedef void  (GL_APIENTRY *PFN_glTexParameterfv)(GLenum target, GLenum pname, const GLfloat * params);
+extern PFN_glTexParameterfv _glptr_glTexParameterfv;
+#define glTexParameterfv _glptr_glTexParameterfv
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);
+extern PFN_glVertexAttrib3s _glptr_glVertexAttrib3s;
+#define glVertexAttrib3s _glptr_glVertexAttrib3s
+
+typedef void  (GL_APIENTRY *PFN_glCompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);
+extern PFN_glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D;
+#define glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D
+
+typedef void  (GL_APIENTRY *PFN_glClear)(GLbitfield mask);
+extern PFN_glClear _glptr_glClear;
+#define glClear _glptr_glClear
+
+typedef void  (GL_APIENTRY *PFN_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+extern PFN_glTexImage2D _glptr_glTexImage2D;
+#define glTexImage2D _glptr_glTexImage2D
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4Niv)(GLuint index, const GLint * v);
+extern PFN_glVertexAttrib4Niv _glptr_glVertexAttrib4Niv;
+#define glVertexAttrib4Niv _glptr_glVertexAttrib4Niv
+
+typedef void  (GL_APIENTRY *PFN_glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint * params);
+extern PFN_glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv;
+#define glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv
+
+typedef void  (GL_APIENTRY *PFN_glStencilMaskSeparate)(GLenum face, GLuint mask);
+extern PFN_glStencilMaskSeparate _glptr_glStencilMaskSeparate;
+#define glStencilMaskSeparate _glptr_glStencilMaskSeparate
+
+typedef void  (GL_APIENTRY *PFN_glGenVertexArrays)(GLsizei n, GLuint * arrays);
+extern PFN_glGenVertexArrays _glptr_glGenVertexArrays;
+#define glGenVertexArrays _glptr_glGenVertexArrays
+
+typedef void  (GL_APIENTRY *PFN_glFrontFace)(GLenum mode);
+extern PFN_glFrontFace _glptr_glFrontFace;
+#define glFrontFace _glptr_glFrontFace
+
+typedef void  (GL_APIENTRY *PFN_glDepthRange)(GLdouble n, GLdouble f);
+extern PFN_glDepthRange _glptr_glDepthRange;
+#define glDepthRange _glptr_glDepthRange
+
+typedef void  (GL_APIENTRY *PFN_glVertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern PFN_glVertexAttrib4s _glptr_glVertexAttrib4s;
+#define glVertexAttrib4s _glptr_glVertexAttrib4s
+
+typedef void  (GL_APIENTRY *PFN_glDetachShader)(GLuint program, GLuint shader);
+extern PFN_glDetachShader _glptr_glDetachShader;
+#define glDetachShader _glptr_glDetachShader
+
+typedef void  (GL_APIENTRY *PFN_glCullFace)(GLenum mode);
+extern PFN_glCullFace _glptr_glCullFace;
+#define glCullFace _glptr_glCullFace
+#if defined(__cplusplus)
+}
+#endif
+#endif