Wrapping OpenGL calls in error checks

gen_debug_header.py

#!/usr/bin/env python3
# Originally written by Torsten Becker <torsten.becker@gmail.com> in 2011


import re

gl_function = re.compile(r'^extern\s+(.+)\s+(\w+)\s*\((.+)\)\s*;\s*$')
argument    = re.compile(r'(\w+)\s*$')


print("""/* OpenGL Debug Header, automatically generated... */

""")

source = []

# XXX: Replace gl_header.h with your header file name
with open('gl_header.h') as f:
    for line in f:
        match = gl_function.match(line)
        if match:
            return_type = match.group(1)
            function_name = match.group(2)
            args = match.group(3)
            
            if args.strip() == 'void':
                argstring = ''
            
            else:
                aaaa = []
                new_args = []
                for i, a in enumerate(args.split(',')):
                    if len(a.strip().split(' ')) > 1:
                        a_match = argument.search(a)
                        aaaa.append(a_match.group(1))
                        new_args.append(a)
                    else:
                        aaaa.append("_gl_unnamed_arg_%d" % i)
                        new_args.append(a + " _gl_unnamed_arg_%d" % i)
            
                args = ",".join(new_args)
                argstring = ", ".join(aaaa)

            print("""#define %(function_name)s _gl_debug_error_%(function_name)s
%(return_type)s _gl_debug_error_%(function_name)s(%(args)s);
""" % locals())

            if return_type != 'void':
                source.append("""
%(return_type)s _gl_debug_error_%(function_name)s(%(args)s) {
    %(return_type)s var = %(function_name)s(%(argstring)s);
    CHECK_GL_ERROR();
    return var;
}
""" % locals())
            else:
                source.append("""
%(return_type)s _gl_debug_error_%(function_name)s(%(args)s) {
    %(function_name)s(%(argstring)s);
    CHECK_GL_ERROR();
}""" % locals())


print("""/* OpenGL Debug Source, automatically generated... */

#include <OpenGL/gl.h>
#include <stdio.h>
#include <stdarg.h>

#define CHECK_GL_ERROR() \\
    { GLenum __error = glGetError(); \\
      if(__error) \\
          printf("OpenGL error 0x%04X in %s\\n", __error, __FUNCTION__); \\
    }

""")

print("\n".join(source))

gl_debug_overwrites.c

/* OpenGL Debug Source, automatically generated... */

#include <OpenGL/gl.h>
#include <stdio.h>
#include <stdarg.h>

#define CHECK_GL_ERROR() \
    { GLenum __error = glGetError(); \
      if(__error) \
          printf("OpenGL error 0x%04X in %s\n", __error, __FUNCTION__); \
    }



void _gl_debug_error_glAccum(GLenum op, GLfloat value) {
    glAccum(op, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glAlphaFunc(GLenum func, GLclampf ref) {
    glAlphaFunc(func, ref);
    CHECK_GL_ERROR();
}

GLboolean _gl_debug_error_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) {
    GLboolean var = glAreTexturesResident(n, textures, residences);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glArrayElement(GLint i) {
    glArrayElement(i);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBegin(GLenum mode) {
    glBegin(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBindTexture(GLenum target, GLuint texture) {
    glBindTexture(target, texture);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {
    glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
    glBlendColor(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBlendEquation(GLenum mode) {
    glBlendEquation(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
    glBlendEquationSeparate(modeRGB, modeAlpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBlendFunc(GLenum sfactor, GLenum dfactor) {
    glBlendFunc(sfactor, dfactor);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCallList(GLuint list) {
    glCallList(list);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCallLists(GLsizei n, GLenum type, const GLvoid *lists) {
    glCallLists(n, type, lists);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClear(GLbitfield mask) {
    glClear(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    glClearAccum(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
    glClearColor(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClearDepth(GLclampd depth) {
    glClearDepth(depth);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClearIndex(GLfloat c) {
    glClearIndex(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClearStencil(GLint s) {
    glClearStencil(s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClipPlane(GLenum plane, const GLdouble *equation) {
    glClipPlane(plane, equation);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3b(GLbyte red, GLbyte green, GLbyte blue) {
    glColor3b(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3bv(const GLbyte *v) {
    glColor3bv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3d(GLdouble red, GLdouble green, GLdouble blue) {
    glColor3d(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3dv(const GLdouble *v) {
    glColor3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
    glColor3f(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3fv(const GLfloat *v) {
    glColor3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3i(GLint red, GLint green, GLint blue) {
    glColor3i(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3iv(const GLint *v) {
    glColor3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3s(GLshort red, GLshort green, GLshort blue) {
    glColor3s(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3sv(const GLshort *v) {
    glColor3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
    glColor3ub(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3ubv(const GLubyte *v) {
    glColor3ubv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3ui(GLuint red, GLuint green, GLuint blue) {
    glColor3ui(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3uiv(const GLuint *v) {
    glColor3uiv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3us(GLushort red, GLushort green, GLushort blue) {
    glColor3us(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor3usv(const GLushort *v) {
    glColor3usv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
    glColor4b(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4bv(const GLbyte *v) {
    glColor4bv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
    glColor4d(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4dv(const GLdouble *v) {
    glColor4dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    glColor4f(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4fv(const GLfloat *v) {
    glColor4fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
    glColor4i(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4iv(const GLint *v) {
    glColor4iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
    glColor4s(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4sv(const GLshort *v) {
    glColor4sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
    glColor4ub(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4ubv(const GLubyte *v) {
    glColor4ubv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
    glColor4ui(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4uiv(const GLuint *v) {
    glColor4uiv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
    glColor4us(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColor4usv(const GLushort *v) {
    glColor4usv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
    glColorMask(red, green, blue, alpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorMaterial(GLenum face, GLenum mode) {
    glColorMaterial(face, mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
    glColorPointer(size, type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) {
    glColorSubTable(target, start, count, format, type, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) {
    glColorTable(target, internalformat, width, format, type, table);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
    glColorTableParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) {
    glColorTableParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) {
    glConvolutionFilter1D(target, internalformat, width, format, type, image);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) {
    glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) {
    glConvolutionParameterf(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
    glConvolutionParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) {
    glConvolutionParameteri(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params) {
    glConvolutionParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) {
    glCopyColorSubTable(target, start, x, y, width);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
    glCopyColorTable(target, internalformat, x, y, width);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {
    glCopyConvolutionFilter1D(target, internalformat, x, y, width);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {
    glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {
    glCopyPixels(x, y, width, height, type);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
    glCopyTexImage1D(target, level, internalformat, x, y, width, border);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
    glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
    glCopyTexSubImage1D(target, level, xoffset, x, y, width);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCullFace(GLenum mode) {
    glCullFace(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteLists(GLuint list, GLsizei range) {
    glDeleteLists(list, range);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteTextures(GLsizei n, const GLuint *textures) {
    glDeleteTextures(n, textures);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDepthFunc(GLenum func) {
    glDepthFunc(func);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDepthMask(GLboolean flag) {
    glDepthMask(flag);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDepthRange(GLclampd zNear, GLclampd zFar) {
    glDepthRange(zNear, zFar);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDisable(GLenum cap) {
    glDisable(cap);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDisableClientState(GLenum array) {
    glDisableClientState(array);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
    glDrawArrays(mode, first, count);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawBuffer(GLenum mode) {
    glDrawBuffer(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {
    glDrawElements(mode, count, type, indices);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
    glDrawPixels(width, height, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) {
    glDrawRangeElements(mode, start, end, count, type, indices);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEdgeFlag(GLboolean flag) {
    glEdgeFlag(flag);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer) {
    glEdgeFlagPointer(stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEdgeFlagv(const GLboolean *flag) {
    glEdgeFlagv(flag);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEnable(GLenum cap) {
    glEnable(cap);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEnableClientState(GLenum array) {
    glEnableClientState(array);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEnd(void) {
    glEnd();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEndList(void) {
    glEndList();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord1d(GLdouble u) {
    glEvalCoord1d(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord1dv(const GLdouble *u) {
    glEvalCoord1dv(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord1f(GLfloat u) {
    glEvalCoord1f(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord1fv(const GLfloat *u) {
    glEvalCoord1fv(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord2d(GLdouble u, GLdouble v) {
    glEvalCoord2d(u, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord2dv(const GLdouble *u) {
    glEvalCoord2dv(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord2f(GLfloat u, GLfloat v) {
    glEvalCoord2f(u, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalCoord2fv(const GLfloat *u) {
    glEvalCoord2fv(u);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalMesh1(GLenum mode, GLint i1, GLint i2) {
    glEvalMesh1(mode, i1, i2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {
    glEvalMesh2(mode, i1, i2, j1, j2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalPoint1(GLint i) {
    glEvalPoint1(i);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEvalPoint2(GLint i, GLint j) {
    glEvalPoint2(i, j);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {
    glFeedbackBuffer(size, type, buffer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFinish(void) {
    glFinish();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFlush(void) {
    glFlush();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogf(GLenum pname, GLfloat param) {
    glFogf(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogfv(GLenum pname, const GLfloat *params) {
    glFogfv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogi(GLenum pname, GLint param) {
    glFogi(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogiv(GLenum pname, const GLint *params) {
    glFogiv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFrontFace(GLenum mode) {
    glFrontFace(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
    glFrustum(left, right, bottom, top, zNear, zFar);
    CHECK_GL_ERROR();
}

GLuint _gl_debug_error_glGenLists(GLsizei range) {
    GLuint var = glGenLists(range);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGenTextures(GLsizei n, GLuint *textures) {
    glGenTextures(n, textures);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetBooleanv(GLenum pname, GLboolean *params) {
    glGetBooleanv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetClipPlane(GLenum plane, GLdouble *equation) {
    glGetClipPlane(plane, equation);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table) {
    glGetColorTable(target, format, type, table);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetColorTableParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetColorTableParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image) {
    glGetConvolutionFilter(target, format, type, image);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetConvolutionParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetConvolutionParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetDoublev(GLenum pname, GLdouble *params) {
    glGetDoublev(pname, params);
    CHECK_GL_ERROR();
}

GLenum _gl_debug_error_glGetError(void) {
    GLenum var = glGetError();
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGetFloatv(GLenum pname, GLfloat *params) {
    glGetFloatv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
    glGetHistogram(target, reset, format, type, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetHistogramParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetHistogramParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetIntegerv(GLenum pname, GLint *params) {
    glGetIntegerv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
    glGetLightfv(light, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetLightiv(GLenum light, GLenum pname, GLint *params) {
    glGetLightiv(light, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMapdv(GLenum target, GLenum query, GLdouble *v) {
    glGetMapdv(target, query, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMapfv(GLenum target, GLenum query, GLfloat *v) {
    glGetMapfv(target, query, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMapiv(GLenum target, GLenum query, GLint *v) {
    glGetMapiv(target, query, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
    glGetMaterialfv(face, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
    glGetMaterialiv(face, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) {
    glGetMinmax(target, reset, format, type, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetMinmaxParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetMinmaxParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetPixelMapfv(GLenum map, GLfloat *values) {
    glGetPixelMapfv(map, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetPixelMapuiv(GLenum map, GLuint *values) {
    glGetPixelMapuiv(map, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetPixelMapusv(GLenum map, GLushort *values) {
    glGetPixelMapusv(map, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetPointerv(GLenum pname, GLvoid* *params) {
    glGetPointerv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetPolygonStipple(GLubyte *mask) {
    glGetPolygonStipple(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) {
    glGetSeparableFilter(target, format, type, row, column, span);
    CHECK_GL_ERROR();
}

const GLubyte * _gl_debug_error_glGetString(GLenum name) {
    const GLubyte * var = glGetString(name);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetTexEnvfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
    glGetTexEnviv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
    glGetTexGendv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
    glGetTexGenfv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
    glGetTexGeniv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {
    glGetTexImage(target, level, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
    glGetTexLevelParameterfv(target, level, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
    glGetTexLevelParameteriv(target, level, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
    glGetTexParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetTexParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glHint(GLenum target, GLenum mode) {
    glHint(target, mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) {
    glHistogram(target, width, internalformat, sink);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexMask(GLuint mask) {
    glIndexMask(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
    glIndexPointer(type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexd(GLdouble c) {
    glIndexd(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexdv(const GLdouble *c) {
    glIndexdv(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexf(GLfloat c) {
    glIndexf(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexfv(const GLfloat *c) {
    glIndexfv(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexi(GLint c) {
    glIndexi(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexiv(const GLint *c) {
    glIndexiv(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexs(GLshort c) {
    glIndexs(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexsv(const GLshort *c) {
    glIndexsv(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexub(GLubyte c) {
    glIndexub(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glIndexubv(const GLubyte *c) {
    glIndexubv(c);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glInitNames(void) {
    glInitNames();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) {
    glInterleavedArrays(format, stride, pointer);
    CHECK_GL_ERROR();
}

GLboolean _gl_debug_error_glIsEnabled(GLenum cap) {
    GLboolean var = glIsEnabled(cap);
    CHECK_GL_ERROR();
    return var;
}


GLboolean _gl_debug_error_glIsList(GLuint list) {
    GLboolean var = glIsList(list);
    CHECK_GL_ERROR();
    return var;
}


GLboolean _gl_debug_error_glIsTexture(GLuint texture) {
    GLboolean var = glIsTexture(texture);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glLightModelf(GLenum pname, GLfloat param) {
    glLightModelf(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightModelfv(GLenum pname, const GLfloat *params) {
    glLightModelfv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightModeli(GLenum pname, GLint param) {
    glLightModeli(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightModeliv(GLenum pname, const GLint *params) {
    glLightModeliv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightf(GLenum light, GLenum pname, GLfloat param) {
    glLightf(light, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightfv(GLenum light, GLenum pname, const GLfloat *params) {
    glLightfv(light, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLighti(GLenum light, GLenum pname, GLint param) {
    glLighti(light, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLightiv(GLenum light, GLenum pname, const GLint *params) {
    glLightiv(light, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLineStipple(GLint factor, GLushort pattern) {
    glLineStipple(factor, pattern);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLineWidth(GLfloat width) {
    glLineWidth(width);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glListBase(GLuint base) {
    glListBase(base);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadIdentity(void) {
    glLoadIdentity();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadMatrixd(const GLdouble *m) {
    glLoadMatrixd(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadMatrixf(const GLfloat *m) {
    glLoadMatrixf(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadName(GLuint name) {
    glLoadName(name);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLogicOp(GLenum opcode) {
    glLogicOp(opcode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) {
    glMap1d(target, u1, u2, stride, order, points);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {
    glMap1f(target, u1, u2, stride, order, points);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {
    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {
    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
    glMapGrid1d(un, u1, u2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {
    glMapGrid1f(un, u1, u2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {
    glMapGrid2d(un, u1, u2, vn, v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {
    glMapGrid2f(un, u1, u2, vn, v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
    glMaterialf(face, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
    glMaterialfv(face, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMateriali(GLenum face, GLenum pname, GLint param) {
    glMateriali(face, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMaterialiv(GLenum face, GLenum pname, const GLint *params) {
    glMaterialiv(face, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMatrixMode(GLenum mode) {
    glMatrixMode(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) {
    glMinmax(target, internalformat, sink);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultMatrixd(const GLdouble *m) {
    glMultMatrixd(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultMatrixf(const GLfloat *m) {
    glMultMatrixf(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNewList(GLuint list, GLenum mode) {
    glNewList(list, mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
    glNormal3b(nx, ny, nz);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3bv(const GLbyte *v) {
    glNormal3bv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
    glNormal3d(nx, ny, nz);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3dv(const GLdouble *v) {
    glNormal3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
    glNormal3f(nx, ny, nz);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3fv(const GLfloat *v) {
    glNormal3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3i(GLint nx, GLint ny, GLint nz) {
    glNormal3i(nx, ny, nz);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3iv(const GLint *v) {
    glNormal3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3s(GLshort nx, GLshort ny, GLshort nz) {
    glNormal3s(nx, ny, nz);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormal3sv(const GLshort *v) {
    glNormal3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
    glNormalPointer(type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
    glOrtho(left, right, bottom, top, zNear, zFar);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPassThrough(GLfloat token) {
    glPassThrough(token);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values) {
    glPixelMapfv(map, mapsize, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values) {
    glPixelMapuiv(map, mapsize, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values) {
    glPixelMapusv(map, mapsize, values);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelStoref(GLenum pname, GLfloat param) {
    glPixelStoref(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelStorei(GLenum pname, GLint param) {
    glPixelStorei(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelTransferf(GLenum pname, GLfloat param) {
    glPixelTransferf(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelTransferi(GLenum pname, GLint param) {
    glPixelTransferi(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPixelZoom(GLfloat xfactor, GLfloat yfactor) {
    glPixelZoom(xfactor, yfactor);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPointSize(GLfloat size) {
    glPointSize(size);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPolygonMode(GLenum face, GLenum mode) {
    glPolygonMode(face, mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPolygonOffset(GLfloat factor, GLfloat units) {
    glPolygonOffset(factor, units);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPolygonStipple(const GLubyte *mask) {
    glPolygonStipple(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPopAttrib(void) {
    glPopAttrib();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPopClientAttrib(void) {
    glPopClientAttrib();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPopMatrix(void) {
    glPopMatrix();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPopName(void) {
    glPopName();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
    glPrioritizeTextures(n, textures, priorities);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPushAttrib(GLbitfield mask) {
    glPushAttrib(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPushClientAttrib(GLbitfield mask) {
    glPushClientAttrib(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPushMatrix(void) {
    glPushMatrix();
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPushName(GLuint name) {
    glPushName(name);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2d(GLdouble x, GLdouble y) {
    glRasterPos2d(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2dv(const GLdouble *v) {
    glRasterPos2dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2f(GLfloat x, GLfloat y) {
    glRasterPos2f(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2fv(const GLfloat *v) {
    glRasterPos2fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2i(GLint x, GLint y) {
    glRasterPos2i(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2iv(const GLint *v) {
    glRasterPos2iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2s(GLshort x, GLshort y) {
    glRasterPos2s(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos2sv(const GLshort *v) {
    glRasterPos2sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {
    glRasterPos3d(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3dv(const GLdouble *v) {
    glRasterPos3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {
    glRasterPos3f(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3fv(const GLfloat *v) {
    glRasterPos3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3i(GLint x, GLint y, GLint z) {
    glRasterPos3i(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3iv(const GLint *v) {
    glRasterPos3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3s(GLshort x, GLshort y, GLshort z) {
    glRasterPos3s(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos3sv(const GLshort *v) {
    glRasterPos3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
    glRasterPos4d(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4dv(const GLdouble *v) {
    glRasterPos4dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    glRasterPos4f(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4fv(const GLfloat *v) {
    glRasterPos4fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) {
    glRasterPos4i(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4iv(const GLint *v) {
    glRasterPos4iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {
    glRasterPos4s(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRasterPos4sv(const GLshort *v) {
    glRasterPos4sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glReadBuffer(GLenum mode) {
    glReadBuffer(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {
    glReadPixels(x, y, width, height, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
    glRectd(x1, y1, x2, y2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectdv(const GLdouble *v1, const GLdouble *v2) {
    glRectdv(v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
    glRectf(x1, y1, x2, y2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectfv(const GLfloat *v1, const GLfloat *v2) {
    glRectfv(v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
    glRecti(x1, y1, x2, y2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectiv(const GLint *v1, const GLint *v2) {
    glRectiv(v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
    glRects(x1, y1, x2, y2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRectsv(const GLshort *v1, const GLshort *v2) {
    glRectsv(v1, v2);
    CHECK_GL_ERROR();
}

GLint _gl_debug_error_glRenderMode(GLenum mode) {
    GLint var = glRenderMode(mode);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glResetHistogram(GLenum target) {
    glResetHistogram(target);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glResetMinmax(GLenum target) {
    glResetMinmax(target);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
    glRotated(angle, x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
    glRotatef(angle, x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glScaled(GLdouble x, GLdouble y, GLdouble z) {
    glScaled(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glScalef(GLfloat x, GLfloat y, GLfloat z) {
    glScalef(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
    glScissor(x, y, width, height);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSelectBuffer(GLsizei size, GLuint *buffer) {
    glSelectBuffer(size, buffer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) {
    glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glShadeModel(GLenum mode) {
    glShadeModel(mode);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
    glStencilFunc(func, ref, mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glStencilMask(GLuint mask) {
    glStencilMask(mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
    glStencilOp(fail, zfail, zpass);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1d(GLdouble s) {
    glTexCoord1d(s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1dv(const GLdouble *v) {
    glTexCoord1dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1f(GLfloat s) {
    glTexCoord1f(s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1fv(const GLfloat *v) {
    glTexCoord1fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1i(GLint s) {
    glTexCoord1i(s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1iv(const GLint *v) {
    glTexCoord1iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1s(GLshort s) {
    glTexCoord1s(s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord1sv(const GLshort *v) {
    glTexCoord1sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2d(GLdouble s, GLdouble t) {
    glTexCoord2d(s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2dv(const GLdouble *v) {
    glTexCoord2dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2f(GLfloat s, GLfloat t) {
    glTexCoord2f(s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2fv(const GLfloat *v) {
    glTexCoord2fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2i(GLint s, GLint t) {
    glTexCoord2i(s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2iv(const GLint *v) {
    glTexCoord2iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2s(GLshort s, GLshort t) {
    glTexCoord2s(s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord2sv(const GLshort *v) {
    glTexCoord2sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
    glTexCoord3d(s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3dv(const GLdouble *v) {
    glTexCoord3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
    glTexCoord3f(s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3fv(const GLfloat *v) {
    glTexCoord3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3i(GLint s, GLint t, GLint r) {
    glTexCoord3i(s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3iv(const GLint *v) {
    glTexCoord3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3s(GLshort s, GLshort t, GLshort r) {
    glTexCoord3s(s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord3sv(const GLshort *v) {
    glTexCoord3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
    glTexCoord4d(s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4dv(const GLdouble *v) {
    glTexCoord4dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
    glTexCoord4f(s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4fv(const GLfloat *v) {
    glTexCoord4fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
    glTexCoord4i(s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4iv(const GLint *v) {
    glTexCoord4iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
    glTexCoord4s(s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoord4sv(const GLshort *v) {
    glTexCoord4sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
    glTexCoordPointer(size, type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
    glTexEnvf(target, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
    glTexEnvfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexEnvi(GLenum target, GLenum pname, GLint param) {
    glTexEnvi(target, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexEnviv(GLenum target, GLenum pname, const GLint *params) {
    glTexEnviv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGend(GLenum coord, GLenum pname, GLdouble param) {
    glTexGend(coord, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
    glTexGendv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGenf(GLenum coord, GLenum pname, GLfloat param) {
    glTexGenf(coord, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
    glTexGenfv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGeni(GLenum coord, GLenum pname, GLint param) {
    glTexGeni(coord, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
    glTexGeniv(coord, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
    glTexParameterf(target, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
    glTexParameterfv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexParameteri(GLenum target, GLenum pname, GLint param) {
    glTexParameteri(target, pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
    glTexParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) {
    glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTranslated(GLdouble x, GLdouble y, GLdouble z) {
    glTranslated(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
    glTranslatef(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2d(GLdouble x, GLdouble y) {
    glVertex2d(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2dv(const GLdouble *v) {
    glVertex2dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2f(GLfloat x, GLfloat y) {
    glVertex2f(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2fv(const GLfloat *v) {
    glVertex2fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2i(GLint x, GLint y) {
    glVertex2i(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2iv(const GLint *v) {
    glVertex2iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2s(GLshort x, GLshort y) {
    glVertex2s(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex2sv(const GLshort *v) {
    glVertex2sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3d(GLdouble x, GLdouble y, GLdouble z) {
    glVertex3d(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3dv(const GLdouble *v) {
    glVertex3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
    glVertex3f(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3fv(const GLfloat *v) {
    glVertex3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3i(GLint x, GLint y, GLint z) {
    glVertex3i(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3iv(const GLint *v) {
    glVertex3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3s(GLshort x, GLshort y, GLshort z) {
    glVertex3s(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex3sv(const GLshort *v) {
    glVertex3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
    glVertex4d(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4dv(const GLdouble *v) {
    glVertex4dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    glVertex4f(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4fv(const GLfloat *v) {
    glVertex4fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4i(GLint x, GLint y, GLint z, GLint w) {
    glVertex4i(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4iv(const GLint *v) {
    glVertex4iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
    glVertex4s(x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertex4sv(const GLshort *v) {
    glVertex4sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
    glVertexPointer(size, type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
    glViewport(x, y, width, height);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSampleCoverage(GLclampf value, GLboolean invert) {
    glSampleCoverage(value, invert);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSamplePass(GLenum pass) {
    glSamplePass(pass);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadTransposeMatrixf(const GLfloat *m) {
    glLoadTransposeMatrixf(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLoadTransposeMatrixd(const GLdouble *m) {
    glLoadTransposeMatrixd(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultTransposeMatrixf(const GLfloat *m) {
    glMultTransposeMatrixf(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultTransposeMatrixd(const GLdouble *m) {
    glMultTransposeMatrixd(m);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) {
    glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img) {
    glGetCompressedTexImage(target, lod, img);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glActiveTexture(GLenum texture) {
    glActiveTexture(texture);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glClientActiveTexture(GLenum texture) {
    glClientActiveTexture(texture);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1d(GLenum target, GLdouble s) {
    glMultiTexCoord1d(target, s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1dv(GLenum target, const GLdouble *v) {
    glMultiTexCoord1dv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1f(GLenum target, GLfloat s) {
    glMultiTexCoord1f(target, s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1fv(GLenum target, const GLfloat *v) {
    glMultiTexCoord1fv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1i(GLenum target, GLint s) {
    glMultiTexCoord1i(target, s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1iv(GLenum target, const GLint *v) {
    glMultiTexCoord1iv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1s(GLenum target, GLshort s) {
    glMultiTexCoord1s(target, s);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord1sv(GLenum target, const GLshort *v) {
    glMultiTexCoord1sv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) {
    glMultiTexCoord2d(target, s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2dv(GLenum target, const GLdouble *v) {
    glMultiTexCoord2dv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {
    glMultiTexCoord2f(target, s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2fv(GLenum target, const GLfloat *v) {
    glMultiTexCoord2fv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2i(GLenum target, GLint s, GLint t) {
    glMultiTexCoord2i(target, s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2iv(GLenum target, const GLint *v) {
    glMultiTexCoord2iv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) {
    glMultiTexCoord2s(target, s, t);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord2sv(GLenum target, const GLshort *v) {
    glMultiTexCoord2sv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) {
    glMultiTexCoord3d(target, s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3dv(GLenum target, const GLdouble *v) {
    glMultiTexCoord3dv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {
    glMultiTexCoord3f(target, s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3fv(GLenum target, const GLfloat *v) {
    glMultiTexCoord3fv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) {
    glMultiTexCoord3i(target, s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3iv(GLenum target, const GLint *v) {
    glMultiTexCoord3iv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) {
    glMultiTexCoord3s(target, s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord3sv(GLenum target, const GLshort *v) {
    glMultiTexCoord3sv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
    glMultiTexCoord4d(target, s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4dv(GLenum target, const GLdouble *v) {
    glMultiTexCoord4dv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
    glMultiTexCoord4f(target, s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4fv(GLenum target, const GLfloat *v) {
    glMultiTexCoord4fv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4i(GLenum target, GLint _gl_unnamed_arg_1, GLint s, GLint t, GLint r) {
    glMultiTexCoord4i(target, _gl_unnamed_arg_1, s, t, r);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4iv(GLenum target, const GLint *v) {
    glMultiTexCoord4iv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {
    glMultiTexCoord4s(target, s, t, r, q);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiTexCoord4sv(GLenum target, const GLshort *v) {
    glMultiTexCoord4sv(target, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogCoordf(GLfloat coord) {
    glFogCoordf(coord);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogCoordfv(const GLfloat *coord) {
    glFogCoordfv(coord);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogCoordd(GLdouble coord) {
    glFogCoordd(coord);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogCoorddv(const GLdouble * coord) {
    glFogCoorddv(coord);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
    glFogCoordPointer(type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) {
    glSecondaryColor3b(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3bv(const GLbyte *v) {
    glSecondaryColor3bv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) {
    glSecondaryColor3d(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3dv(const GLdouble *v) {
    glSecondaryColor3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) {
    glSecondaryColor3f(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3fv(const GLfloat *v) {
    glSecondaryColor3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3i(GLint red, GLint green, GLint blue) {
    glSecondaryColor3i(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3iv(const GLint *v) {
    glSecondaryColor3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) {
    glSecondaryColor3s(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3sv(const GLshort *v) {
    glSecondaryColor3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
    glSecondaryColor3ub(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3ubv(const GLubyte *v) {
    glSecondaryColor3ubv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) {
    glSecondaryColor3ui(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3uiv(const GLuint *v) {
    glSecondaryColor3uiv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) {
    glSecondaryColor3us(red, green, blue);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColor3usv(const GLushort *v) {
    glSecondaryColor3usv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
    glSecondaryColorPointer(size, type, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPointParameterf(GLenum pname, GLfloat param) {
    glPointParameterf(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPointParameterfv(GLenum pname, const GLfloat *params) {
    glPointParameterfv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPointParameteri(GLenum pname, GLint param) {
    glPointParameteri(pname, param);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glPointParameteriv(GLenum pname, const GLint *params) {
    glPointParameteriv(pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
    glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {
    glMultiDrawArrays(mode, first, count, primcount);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
    glMultiDrawElements(mode, count, type, indices, primcount);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2d(GLdouble x, GLdouble y) {
    glWindowPos2d(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2dv(const GLdouble *v) {
    glWindowPos2dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2f(GLfloat x, GLfloat y) {
    glWindowPos2f(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2fv(const GLfloat *v) {
    glWindowPos2fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2i(GLint x, GLint y) {
    glWindowPos2i(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2iv(const GLint *v) {
    glWindowPos2iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2s(GLshort x, GLshort y) {
    glWindowPos2s(x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos2sv(const GLshort *v) {
    glWindowPos2sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) {
    glWindowPos3d(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3dv(const GLdouble *v) {
    glWindowPos3dv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) {
    glWindowPos3f(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3fv(const GLfloat *v) {
    glWindowPos3fv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3i(GLint x, GLint y, GLint z) {
    glWindowPos3i(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3iv(const GLint *v) {
    glWindowPos3iv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3s(GLshort x, GLshort y, GLshort z) {
    glWindowPos3s(x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glWindowPos3sv(const GLshort *v) {
    glWindowPos3sv(v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGenQueries(GLsizei n, GLuint *ids) {
    glGenQueries(n, ids);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteQueries(GLsizei n, const GLuint *ids) {
    glDeleteQueries(n, ids);
    CHECK_GL_ERROR();
}

GLboolean _gl_debug_error_glIsQuery(GLuint id) {
    GLboolean var = glIsQuery(id);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glBeginQuery(GLenum target, GLuint id) {
    glBeginQuery(target, id);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEndQuery(GLenum target) {
    glEndQuery(target);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetQueryiv(GLenum target, GLenum pname, GLint *params) {
    glGetQueryiv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) {
    glGetQueryObjectiv(id, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) {
    glGetQueryObjectuiv(id, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBindBuffer(GLenum target, GLuint buffer) {
    glBindBuffer(target, buffer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteBuffers(GLsizei n, const GLuint *buffers) {
    glDeleteBuffers(n, buffers);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGenBuffers(GLsizei n, GLuint *buffers) {
    glGenBuffers(n, buffers);
    CHECK_GL_ERROR();
}

GLboolean _gl_debug_error_glIsBuffer(GLuint buffer) {
    GLboolean var = glIsBuffer(buffer);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) {
    glBufferData(target, size, data, usage);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) {
    glBufferSubData(target, offset, size, data);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) {
    glGetBufferSubData(target, offset, size, data);
    CHECK_GL_ERROR();
}

GLvoid * _gl_debug_error_glMapBuffer(GLenum target, GLenum access) {
    GLvoid * var = glMapBuffer(target, access);
    CHECK_GL_ERROR();
    return var;
}


GLboolean _gl_debug_error_glUnmapBuffer(GLenum target) {
    GLboolean var = glUnmapBuffer(target);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) {
    glGetBufferParameteriv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params) {
    glGetBufferPointerv(target, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDrawBuffers(GLsizei n, const GLenum *bufs) {
    glDrawBuffers(n, bufs);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1d(GLuint index, GLdouble x) {
    glVertexAttrib1d(index, x);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1dv(GLuint index, const GLdouble *v) {
    glVertexAttrib1dv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1f(GLuint index, GLfloat x) {
    glVertexAttrib1f(index, x);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1fv(GLuint index, const GLfloat *v) {
    glVertexAttrib1fv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1s(GLuint index, GLshort x) {
    glVertexAttrib1s(index, x);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib1sv(GLuint index, const GLshort *v) {
    glVertexAttrib1sv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) {
    glVertexAttrib2d(index, x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2dv(GLuint index, const GLdouble *v) {
    glVertexAttrib2dv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {
    glVertexAttrib2f(index, x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2fv(GLuint index, const GLfloat *v) {
    glVertexAttrib2fv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) {
    glVertexAttrib2s(index, x, y);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib2sv(GLuint index, const GLshort *v) {
    glVertexAttrib2sv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) {
    glVertexAttrib3d(index, x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3dv(GLuint index, const GLdouble *v) {
    glVertexAttrib3dv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
    glVertexAttrib3f(index, x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3fv(GLuint index, const GLfloat *v) {
    glVertexAttrib3fv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) {
    glVertexAttrib3s(index, x, y, z);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib3sv(GLuint index, const GLshort *v) {
    glVertexAttrib3sv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nbv(GLuint index, const GLbyte *v) {
    glVertexAttrib4Nbv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Niv(GLuint index, const GLint *v) {
    glVertexAttrib4Niv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nsv(GLuint index, const GLshort *v) {
    glVertexAttrib4Nsv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
    glVertexAttrib4Nub(index, x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nubv(GLuint index, const GLubyte *v) {
    glVertexAttrib4Nubv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nuiv(GLuint index, const GLuint *v) {
    glVertexAttrib4Nuiv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4Nusv(GLuint index, const GLushort *v) {
    glVertexAttrib4Nusv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4bv(GLuint index, const GLbyte *v) {
    glVertexAttrib4bv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
    glVertexAttrib4d(index, x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4dv(GLuint index, const GLdouble *v) {
    glVertexAttrib4dv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
    glVertexAttrib4f(index, x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4fv(GLuint index, const GLfloat *v) {
    glVertexAttrib4fv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4iv(GLuint index, const GLint *v) {
    glVertexAttrib4iv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
    glVertexAttrib4s(index, x, y, z, w);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4sv(GLuint index, const GLshort *v) {
    glVertexAttrib4sv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4ubv(GLuint index, const GLubyte *v) {
    glVertexAttrib4ubv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4uiv(GLuint index, const GLuint *v) {
    glVertexAttrib4uiv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttrib4usv(GLuint index, const GLushort *v) {
    glVertexAttrib4usv(index, v);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {
    glVertexAttribPointer(index, size, type, normalized, stride, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glEnableVertexAttribArray(GLuint index) {
    glEnableVertexAttribArray(index);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDisableVertexAttribArray(GLuint index) {
    glDisableVertexAttribArray(index);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) {
    glGetVertexAttribdv(index, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) {
    glGetVertexAttribfv(index, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) {
    glGetVertexAttribiv(index, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer) {
    glGetVertexAttribPointerv(index, pname, pointer);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteShader(GLuint shader) {
    glDeleteShader(shader);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDetachShader(GLuint program, GLuint shader) {
    glDetachShader(program, shader);
    CHECK_GL_ERROR();
}

GLuint _gl_debug_error_glCreateShader(GLenum type) {
    GLuint var = glCreateShader(type);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glShaderSource(GLuint shader, GLsizei count, const GLchar* *string, const GLint *length) {
    glShaderSource(shader, count, string, length);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glCompileShader(GLuint shader) {
    glCompileShader(shader);
    CHECK_GL_ERROR();
}

GLuint _gl_debug_error_glCreateProgram(void) {
    GLuint var = glCreateProgram();
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glAttachShader(GLuint program, GLuint shader) {
    glAttachShader(program, shader);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glLinkProgram(GLuint program) {
    glLinkProgram(program);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUseProgram(GLuint program) {
    glUseProgram(program);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glDeleteProgram(GLuint program) {
    glDeleteProgram(program);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glValidateProgram(GLuint program) {
    glValidateProgram(program);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform1f(GLint location, GLfloat v0) {
    glUniform1f(location, v0);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform2f(GLint location, GLfloat v0, GLfloat v1) {
    glUniform2f(location, v0, v1);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
    glUniform3f(location, v0, v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
    glUniform4f(location, v0, v1, v2, v3);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform1i(GLint location, GLint v0) {
    glUniform1i(location, v0);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform2i(GLint location, GLint v0, GLint v1) {
    glUniform2i(location, v0, v1);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
    glUniform3i(location, v0, v1, v2);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
    glUniform4i(location, v0, v1, v2, v3);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform1fv(GLint location, GLsizei count, const GLfloat *value) {
    glUniform1fv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {
    glUniform2fv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {
    glUniform3fv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {
    glUniform4fv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform1iv(GLint location, GLsizei count, const GLint *value) {
    glUniform1iv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform2iv(GLint location, GLsizei count, const GLint *value) {
    glUniform2iv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform3iv(GLint location, GLsizei count, const GLint *value) {
    glUniform3iv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniform4iv(GLint location, GLsizei count, const GLint *value) {
    glUniform4iv(location, count, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix2fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix3fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix4fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

GLboolean _gl_debug_error_glIsShader(GLuint shader) {
    GLboolean var = glIsShader(shader);
    CHECK_GL_ERROR();
    return var;
}


GLboolean _gl_debug_error_glIsProgram(GLuint program) {
    GLboolean var = glIsProgram(program);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
    glGetShaderiv(shader, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
    glGetProgramiv(program, pname, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) {
    glGetAttachedShaders(program, maxCount, count, shaders);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
    glGetShaderInfoLog(shader, bufSize, length, infoLog);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
    glGetProgramInfoLog(program, bufSize, length, infoLog);
    CHECK_GL_ERROR();
}

GLint _gl_debug_error_glGetUniformLocation(GLuint program, const GLchar *name) {
    GLint var = glGetUniformLocation(program, name);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {
    glGetActiveUniform(program, index, bufSize, length, size, type, name);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetUniformfv(GLuint program, GLint location, GLfloat *params) {
    glGetUniformfv(program, location, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetUniformiv(GLuint program, GLint location, GLint *params) {
    glGetUniformiv(program, location, params);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) {
    glGetShaderSource(shader, bufSize, length, source);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) {
    glBindAttribLocation(program, index, name);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) {
    glGetActiveAttrib(program, index, bufSize, length, size, type, name);
    CHECK_GL_ERROR();
}

GLint _gl_debug_error_glGetAttribLocation(GLuint program, const GLchar *name) {
    GLint var = glGetAttribLocation(program, name);
    CHECK_GL_ERROR();
    return var;
}


void _gl_debug_error_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
    glStencilFuncSeparate(face, func, ref, mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
    glStencilOpSeparate(face, fail, zfail, zpass);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glStencilMaskSeparate(GLenum face, GLuint mask) {
    glStencilMaskSeparate(face, mask);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix2x3fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix3x2fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix2x4fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix4x2fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix3x4fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

void _gl_debug_error_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {
    glUniformMatrix4x3fv(location, count, transpose, value);
    CHECK_GL_ERROR();
}

gl_debug_overwrites.h

/* OpenGL Debug Header, automatically generated... */


#define glAccum _gl_debug_error_glAccum
void _gl_debug_error_glAccum(GLenum op, GLfloat value);

#define glAlphaFunc _gl_debug_error_glAlphaFunc
void _gl_debug_error_glAlphaFunc(GLenum func, GLclampf ref);

#define glAreTexturesResident _gl_debug_error_glAreTexturesResident
GLboolean _gl_debug_error_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);

#define glArrayElement _gl_debug_error_glArrayElement
void _gl_debug_error_glArrayElement(GLint i);

#define glBegin _gl_debug_error_glBegin
void _gl_debug_error_glBegin(GLenum mode);

#define glBindTexture _gl_debug_error_glBindTexture
void _gl_debug_error_glBindTexture(GLenum target, GLuint texture);

#define glBitmap _gl_debug_error_glBitmap
void _gl_debug_error_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);

#define glBlendColor _gl_debug_error_glBlendColor
void _gl_debug_error_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

#define glBlendEquation _gl_debug_error_glBlendEquation
void _gl_debug_error_glBlendEquation(GLenum mode);

#define glBlendEquationSeparate _gl_debug_error_glBlendEquationSeparate
void _gl_debug_error_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

#define glBlendFunc _gl_debug_error_glBlendFunc
void _gl_debug_error_glBlendFunc(GLenum sfactor, GLenum dfactor);

#define glCallList _gl_debug_error_glCallList
void _gl_debug_error_glCallList(GLuint list);

#define glCallLists _gl_debug_error_glCallLists
void _gl_debug_error_glCallLists(GLsizei n, GLenum type, const GLvoid *lists);

#define glClear _gl_debug_error_glClear
void _gl_debug_error_glClear(GLbitfield mask);

#define glClearAccum _gl_debug_error_glClearAccum
void _gl_debug_error_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

#define glClearColor _gl_debug_error_glClearColor
void _gl_debug_error_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

#define glClearDepth _gl_debug_error_glClearDepth
void _gl_debug_error_glClearDepth(GLclampd depth);

#define glClearIndex _gl_debug_error_glClearIndex
void _gl_debug_error_glClearIndex(GLfloat c);

#define glClearStencil _gl_debug_error_glClearStencil
void _gl_debug_error_glClearStencil(GLint s);

#define glClipPlane _gl_debug_error_glClipPlane
void _gl_debug_error_glClipPlane(GLenum plane, const GLdouble *equation);

#define glColor3b _gl_debug_error_glColor3b
void _gl_debug_error_glColor3b(GLbyte red, GLbyte green, GLbyte blue);

#define glColor3bv _gl_debug_error_glColor3bv
void _gl_debug_error_glColor3bv(const GLbyte *v);

#define glColor3d _gl_debug_error_glColor3d
void _gl_debug_error_glColor3d(GLdouble red, GLdouble green, GLdouble blue);

#define glColor3dv _gl_debug_error_glColor3dv
void _gl_debug_error_glColor3dv(const GLdouble *v);

#define glColor3f _gl_debug_error_glColor3f
void _gl_debug_error_glColor3f(GLfloat red, GLfloat green, GLfloat blue);

#define glColor3fv _gl_debug_error_glColor3fv
void _gl_debug_error_glColor3fv(const GLfloat *v);

#define glColor3i _gl_debug_error_glColor3i
void _gl_debug_error_glColor3i(GLint red, GLint green, GLint blue);

#define glColor3iv _gl_debug_error_glColor3iv
void _gl_debug_error_glColor3iv(const GLint *v);

#define glColor3s _gl_debug_error_glColor3s
void _gl_debug_error_glColor3s(GLshort red, GLshort green, GLshort blue);

#define glColor3sv _gl_debug_error_glColor3sv
void _gl_debug_error_glColor3sv(const GLshort *v);

#define glColor3ub _gl_debug_error_glColor3ub
void _gl_debug_error_glColor3ub(GLubyte red, GLubyte green, GLubyte blue);

#define glColor3ubv _gl_debug_error_glColor3ubv
void _gl_debug_error_glColor3ubv(const GLubyte *v);

#define glColor3ui _gl_debug_error_glColor3ui
void _gl_debug_error_glColor3ui(GLuint red, GLuint green, GLuint blue);

#define glColor3uiv _gl_debug_error_glColor3uiv
void _gl_debug_error_glColor3uiv(const GLuint *v);

#define glColor3us _gl_debug_error_glColor3us
void _gl_debug_error_glColor3us(GLushort red, GLushort green, GLushort blue);

#define glColor3usv _gl_debug_error_glColor3usv
void _gl_debug_error_glColor3usv(const GLushort *v);

#define glColor4b _gl_debug_error_glColor4b
void _gl_debug_error_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);

#define glColor4bv _gl_debug_error_glColor4bv
void _gl_debug_error_glColor4bv(const GLbyte *v);

#define glColor4d _gl_debug_error_glColor4d
void _gl_debug_error_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);

#define glColor4dv _gl_debug_error_glColor4dv
void _gl_debug_error_glColor4dv(const GLdouble *v);

#define glColor4f _gl_debug_error_glColor4f
void _gl_debug_error_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

#define glColor4fv _gl_debug_error_glColor4fv
void _gl_debug_error_glColor4fv(const GLfloat *v);

#define glColor4i _gl_debug_error_glColor4i
void _gl_debug_error_glColor4i(GLint red, GLint green, GLint blue, GLint alpha);

#define glColor4iv _gl_debug_error_glColor4iv
void _gl_debug_error_glColor4iv(const GLint *v);

#define glColor4s _gl_debug_error_glColor4s
void _gl_debug_error_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);

#define glColor4sv _gl_debug_error_glColor4sv
void _gl_debug_error_glColor4sv(const GLshort *v);

#define glColor4ub _gl_debug_error_glColor4ub
void _gl_debug_error_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);

#define glColor4ubv _gl_debug_error_glColor4ubv
void _gl_debug_error_glColor4ubv(const GLubyte *v);

#define glColor4ui _gl_debug_error_glColor4ui
void _gl_debug_error_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);

#define glColor4uiv _gl_debug_error_glColor4uiv
void _gl_debug_error_glColor4uiv(const GLuint *v);

#define glColor4us _gl_debug_error_glColor4us
void _gl_debug_error_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);

#define glColor4usv _gl_debug_error_glColor4usv
void _gl_debug_error_glColor4usv(const GLushort *v);

#define glColorMask _gl_debug_error_glColorMask
void _gl_debug_error_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

#define glColorMaterial _gl_debug_error_glColorMaterial
void _gl_debug_error_glColorMaterial(GLenum face, GLenum mode);

#define glColorPointer _gl_debug_error_glColorPointer
void _gl_debug_error_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

#define glColorSubTable _gl_debug_error_glColorSubTable
void _gl_debug_error_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);

#define glColorTable _gl_debug_error_glColorTable
void _gl_debug_error_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);

#define glColorTableParameterfv _gl_debug_error_glColorTableParameterfv
void _gl_debug_error_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);

#define glColorTableParameteriv _gl_debug_error_glColorTableParameteriv
void _gl_debug_error_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);

#define glConvolutionFilter1D _gl_debug_error_glConvolutionFilter1D
void _gl_debug_error_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);

#define glConvolutionFilter2D _gl_debug_error_glConvolutionFilter2D
void _gl_debug_error_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);

#define glConvolutionParameterf _gl_debug_error_glConvolutionParameterf
void _gl_debug_error_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);

#define glConvolutionParameterfv _gl_debug_error_glConvolutionParameterfv
void _gl_debug_error_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params);

#define glConvolutionParameteri _gl_debug_error_glConvolutionParameteri
void _gl_debug_error_glConvolutionParameteri(GLenum target, GLenum pname, GLint params);

#define glConvolutionParameteriv _gl_debug_error_glConvolutionParameteriv
void _gl_debug_error_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params);

#define glCopyColorSubTable _gl_debug_error_glCopyColorSubTable
void _gl_debug_error_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);

#define glCopyColorTable _gl_debug_error_glCopyColorTable
void _gl_debug_error_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);

#define glCopyConvolutionFilter1D _gl_debug_error_glCopyConvolutionFilter1D
void _gl_debug_error_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);

#define glCopyConvolutionFilter2D _gl_debug_error_glCopyConvolutionFilter2D
void _gl_debug_error_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);

#define glCopyPixels _gl_debug_error_glCopyPixels
void _gl_debug_error_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);

#define glCopyTexImage1D _gl_debug_error_glCopyTexImage1D
void _gl_debug_error_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);

#define glCopyTexImage2D _gl_debug_error_glCopyTexImage2D
void _gl_debug_error_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

#define glCopyTexSubImage1D _gl_debug_error_glCopyTexSubImage1D
void _gl_debug_error_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

#define glCopyTexSubImage2D _gl_debug_error_glCopyTexSubImage2D
void _gl_debug_error_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

#define glCopyTexSubImage3D _gl_debug_error_glCopyTexSubImage3D
void _gl_debug_error_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

#define glCullFace _gl_debug_error_glCullFace
void _gl_debug_error_glCullFace(GLenum mode);

#define glDeleteLists _gl_debug_error_glDeleteLists
void _gl_debug_error_glDeleteLists(GLuint list, GLsizei range);

#define glDeleteTextures _gl_debug_error_glDeleteTextures
void _gl_debug_error_glDeleteTextures(GLsizei n, const GLuint *textures);

#define glDepthFunc _gl_debug_error_glDepthFunc
void _gl_debug_error_glDepthFunc(GLenum func);

#define glDepthMask _gl_debug_error_glDepthMask
void _gl_debug_error_glDepthMask(GLboolean flag);

#define glDepthRange _gl_debug_error_glDepthRange
void _gl_debug_error_glDepthRange(GLclampd zNear, GLclampd zFar);

#define glDisable _gl_debug_error_glDisable
void _gl_debug_error_glDisable(GLenum cap);

#define glDisableClientState _gl_debug_error_glDisableClientState
void _gl_debug_error_glDisableClientState(GLenum array);

#define glDrawArrays _gl_debug_error_glDrawArrays
void _gl_debug_error_glDrawArrays(GLenum mode, GLint first, GLsizei count);

#define glDrawBuffer _gl_debug_error_glDrawBuffer
void _gl_debug_error_glDrawBuffer(GLenum mode);

#define glDrawElements _gl_debug_error_glDrawElements
void _gl_debug_error_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);

#define glDrawPixels _gl_debug_error_glDrawPixels
void _gl_debug_error_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

#define glDrawRangeElements _gl_debug_error_glDrawRangeElements
void _gl_debug_error_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);

#define glEdgeFlag _gl_debug_error_glEdgeFlag
void _gl_debug_error_glEdgeFlag(GLboolean flag);

#define glEdgeFlagPointer _gl_debug_error_glEdgeFlagPointer
void _gl_debug_error_glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer);

#define glEdgeFlagv _gl_debug_error_glEdgeFlagv
void _gl_debug_error_glEdgeFlagv(const GLboolean *flag);

#define glEnable _gl_debug_error_glEnable
void _gl_debug_error_glEnable(GLenum cap);

#define glEnableClientState _gl_debug_error_glEnableClientState
void _gl_debug_error_glEnableClientState(GLenum array);

#define glEnd _gl_debug_error_glEnd
void _gl_debug_error_glEnd(void);

#define glEndList _gl_debug_error_glEndList
void _gl_debug_error_glEndList(void);

#define glEvalCoord1d _gl_debug_error_glEvalCoord1d
void _gl_debug_error_glEvalCoord1d(GLdouble u);

#define glEvalCoord1dv _gl_debug_error_glEvalCoord1dv
void _gl_debug_error_glEvalCoord1dv(const GLdouble *u);

#define glEvalCoord1f _gl_debug_error_glEvalCoord1f
void _gl_debug_error_glEvalCoord1f(GLfloat u);

#define glEvalCoord1fv _gl_debug_error_glEvalCoord1fv
void _gl_debug_error_glEvalCoord1fv(const GLfloat *u);

#define glEvalCoord2d _gl_debug_error_glEvalCoord2d
void _gl_debug_error_glEvalCoord2d(GLdouble u, GLdouble v);

#define glEvalCoord2dv _gl_debug_error_glEvalCoord2dv
void _gl_debug_error_glEvalCoord2dv(const GLdouble *u);

#define glEvalCoord2f _gl_debug_error_glEvalCoord2f
void _gl_debug_error_glEvalCoord2f(GLfloat u, GLfloat v);

#define glEvalCoord2fv _gl_debug_error_glEvalCoord2fv
void _gl_debug_error_glEvalCoord2fv(const GLfloat *u);

#define glEvalMesh1 _gl_debug_error_glEvalMesh1
void _gl_debug_error_glEvalMesh1(GLenum mode, GLint i1, GLint i2);

#define glEvalMesh2 _gl_debug_error_glEvalMesh2
void _gl_debug_error_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);

#define glEvalPoint1 _gl_debug_error_glEvalPoint1
void _gl_debug_error_glEvalPoint1(GLint i);

#define glEvalPoint2 _gl_debug_error_glEvalPoint2
void _gl_debug_error_glEvalPoint2(GLint i, GLint j);

#define glFeedbackBuffer _gl_debug_error_glFeedbackBuffer
void _gl_debug_error_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);

#define glFinish _gl_debug_error_glFinish
void _gl_debug_error_glFinish(void);

#define glFlush _gl_debug_error_glFlush
void _gl_debug_error_glFlush(void);

#define glFogf _gl_debug_error_glFogf
void _gl_debug_error_glFogf(GLenum pname, GLfloat param);

#define glFogfv _gl_debug_error_glFogfv
void _gl_debug_error_glFogfv(GLenum pname, const GLfloat *params);

#define glFogi _gl_debug_error_glFogi
void _gl_debug_error_glFogi(GLenum pname, GLint param);

#define glFogiv _gl_debug_error_glFogiv
void _gl_debug_error_glFogiv(GLenum pname, const GLint *params);

#define glFrontFace _gl_debug_error_glFrontFace
void _gl_debug_error_glFrontFace(GLenum mode);

#define glFrustum _gl_debug_error_glFrustum
void _gl_debug_error_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

#define glGenLists _gl_debug_error_glGenLists
GLuint _gl_debug_error_glGenLists(GLsizei range);

#define glGenTextures _gl_debug_error_glGenTextures
void _gl_debug_error_glGenTextures(GLsizei n, GLuint *textures);

#define glGetBooleanv _gl_debug_error_glGetBooleanv
void _gl_debug_error_glGetBooleanv(GLenum pname, GLboolean *params);

#define glGetClipPlane _gl_debug_error_glGetClipPlane
void _gl_debug_error_glGetClipPlane(GLenum plane, GLdouble *equation);

#define glGetColorTable _gl_debug_error_glGetColorTable
void _gl_debug_error_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);

#define glGetColorTableParameterfv _gl_debug_error_glGetColorTableParameterfv
void _gl_debug_error_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetColorTableParameteriv _gl_debug_error_glGetColorTableParameteriv
void _gl_debug_error_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params);

#define glGetConvolutionFilter _gl_debug_error_glGetConvolutionFilter
void _gl_debug_error_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image);

#define glGetConvolutionParameterfv _gl_debug_error_glGetConvolutionParameterfv
void _gl_debug_error_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetConvolutionParameteriv _gl_debug_error_glGetConvolutionParameteriv
void _gl_debug_error_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params);

#define glGetDoublev _gl_debug_error_glGetDoublev
void _gl_debug_error_glGetDoublev(GLenum pname, GLdouble *params);

#define glGetError _gl_debug_error_glGetError
GLenum _gl_debug_error_glGetError(void);

#define glGetFloatv _gl_debug_error_glGetFloatv
void _gl_debug_error_glGetFloatv(GLenum pname, GLfloat *params);

#define glGetHistogram _gl_debug_error_glGetHistogram
void _gl_debug_error_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);

#define glGetHistogramParameterfv _gl_debug_error_glGetHistogramParameterfv
void _gl_debug_error_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetHistogramParameteriv _gl_debug_error_glGetHistogramParameteriv
void _gl_debug_error_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params);

#define glGetIntegerv _gl_debug_error_glGetIntegerv
void _gl_debug_error_glGetIntegerv(GLenum pname, GLint *params);

#define glGetLightfv _gl_debug_error_glGetLightfv
void _gl_debug_error_glGetLightfv(GLenum light, GLenum pname, GLfloat *params);

#define glGetLightiv _gl_debug_error_glGetLightiv
void _gl_debug_error_glGetLightiv(GLenum light, GLenum pname, GLint *params);

#define glGetMapdv _gl_debug_error_glGetMapdv
void _gl_debug_error_glGetMapdv(GLenum target, GLenum query, GLdouble *v);

#define glGetMapfv _gl_debug_error_glGetMapfv
void _gl_debug_error_glGetMapfv(GLenum target, GLenum query, GLfloat *v);

#define glGetMapiv _gl_debug_error_glGetMapiv
void _gl_debug_error_glGetMapiv(GLenum target, GLenum query, GLint *v);

#define glGetMaterialfv _gl_debug_error_glGetMaterialfv
void _gl_debug_error_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);

#define glGetMaterialiv _gl_debug_error_glGetMaterialiv
void _gl_debug_error_glGetMaterialiv(GLenum face, GLenum pname, GLint *params);

#define glGetMinmax _gl_debug_error_glGetMinmax
void _gl_debug_error_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);

#define glGetMinmaxParameterfv _gl_debug_error_glGetMinmaxParameterfv
void _gl_debug_error_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetMinmaxParameteriv _gl_debug_error_glGetMinmaxParameteriv
void _gl_debug_error_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params);

#define glGetPixelMapfv _gl_debug_error_glGetPixelMapfv
void _gl_debug_error_glGetPixelMapfv(GLenum map, GLfloat *values);

#define glGetPixelMapuiv _gl_debug_error_glGetPixelMapuiv
void _gl_debug_error_glGetPixelMapuiv(GLenum map, GLuint *values);

#define glGetPixelMapusv _gl_debug_error_glGetPixelMapusv
void _gl_debug_error_glGetPixelMapusv(GLenum map, GLushort *values);

#define glGetPointerv _gl_debug_error_glGetPointerv
void _gl_debug_error_glGetPointerv(GLenum pname, GLvoid* *params);

#define glGetPolygonStipple _gl_debug_error_glGetPolygonStipple
void _gl_debug_error_glGetPolygonStipple(GLubyte *mask);

#define glGetSeparableFilter _gl_debug_error_glGetSeparableFilter
void _gl_debug_error_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);

#define glGetString _gl_debug_error_glGetString
const GLubyte * _gl_debug_error_glGetString(GLenum name);

#define glGetTexEnvfv _gl_debug_error_glGetTexEnvfv
void _gl_debug_error_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetTexEnviv _gl_debug_error_glGetTexEnviv
void _gl_debug_error_glGetTexEnviv(GLenum target, GLenum pname, GLint *params);

#define glGetTexGendv _gl_debug_error_glGetTexGendv
void _gl_debug_error_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);

#define glGetTexGenfv _gl_debug_error_glGetTexGenfv
void _gl_debug_error_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);

#define glGetTexGeniv _gl_debug_error_glGetTexGeniv
void _gl_debug_error_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);

#define glGetTexImage _gl_debug_error_glGetTexImage
void _gl_debug_error_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);

#define glGetTexLevelParameterfv _gl_debug_error_glGetTexLevelParameterfv
void _gl_debug_error_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);

#define glGetTexLevelParameteriv _gl_debug_error_glGetTexLevelParameteriv
void _gl_debug_error_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);

#define glGetTexParameterfv _gl_debug_error_glGetTexParameterfv
void _gl_debug_error_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);

#define glGetTexParameteriv _gl_debug_error_glGetTexParameteriv
void _gl_debug_error_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);

#define glHint _gl_debug_error_glHint
void _gl_debug_error_glHint(GLenum target, GLenum mode);

#define glHistogram _gl_debug_error_glHistogram
void _gl_debug_error_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);

#define glIndexMask _gl_debug_error_glIndexMask
void _gl_debug_error_glIndexMask(GLuint mask);

#define glIndexPointer _gl_debug_error_glIndexPointer
void _gl_debug_error_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);

#define glIndexd _gl_debug_error_glIndexd
void _gl_debug_error_glIndexd(GLdouble c);

#define glIndexdv _gl_debug_error_glIndexdv
void _gl_debug_error_glIndexdv(const GLdouble *c);

#define glIndexf _gl_debug_error_glIndexf
void _gl_debug_error_glIndexf(GLfloat c);

#define glIndexfv _gl_debug_error_glIndexfv
void _gl_debug_error_glIndexfv(const GLfloat *c);

#define glIndexi _gl_debug_error_glIndexi
void _gl_debug_error_glIndexi(GLint c);

#define glIndexiv _gl_debug_error_glIndexiv
void _gl_debug_error_glIndexiv(const GLint *c);

#define glIndexs _gl_debug_error_glIndexs
void _gl_debug_error_glIndexs(GLshort c);

#define glIndexsv _gl_debug_error_glIndexsv
void _gl_debug_error_glIndexsv(const GLshort *c);

#define glIndexub _gl_debug_error_glIndexub
void _gl_debug_error_glIndexub(GLubyte c);

#define glIndexubv _gl_debug_error_glIndexubv
void _gl_debug_error_glIndexubv(const GLubyte *c);

#define glInitNames _gl_debug_error_glInitNames
void _gl_debug_error_glInitNames(void);

#define glInterleavedArrays _gl_debug_error_glInterleavedArrays
void _gl_debug_error_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);

#define glIsEnabled _gl_debug_error_glIsEnabled
GLboolean _gl_debug_error_glIsEnabled(GLenum cap);

#define glIsList _gl_debug_error_glIsList
GLboolean _gl_debug_error_glIsList(GLuint list);

#define glIsTexture _gl_debug_error_glIsTexture
GLboolean _gl_debug_error_glIsTexture(GLuint texture);

#define glLightModelf _gl_debug_error_glLightModelf
void _gl_debug_error_glLightModelf(GLenum pname, GLfloat param);

#define glLightModelfv _gl_debug_error_glLightModelfv
void _gl_debug_error_glLightModelfv(GLenum pname, const GLfloat *params);

#define glLightModeli _gl_debug_error_glLightModeli
void _gl_debug_error_glLightModeli(GLenum pname, GLint param);

#define glLightModeliv _gl_debug_error_glLightModeliv
void _gl_debug_error_glLightModeliv(GLenum pname, const GLint *params);

#define glLightf _gl_debug_error_glLightf
void _gl_debug_error_glLightf(GLenum light, GLenum pname, GLfloat param);

#define glLightfv _gl_debug_error_glLightfv
void _gl_debug_error_glLightfv(GLenum light, GLenum pname, const GLfloat *params);

#define glLighti _gl_debug_error_glLighti
void _gl_debug_error_glLighti(GLenum light, GLenum pname, GLint param);

#define glLightiv _gl_debug_error_glLightiv
void _gl_debug_error_glLightiv(GLenum light, GLenum pname, const GLint *params);

#define glLineStipple _gl_debug_error_glLineStipple
void _gl_debug_error_glLineStipple(GLint factor, GLushort pattern);

#define glLineWidth _gl_debug_error_glLineWidth
void _gl_debug_error_glLineWidth(GLfloat width);

#define glListBase _gl_debug_error_glListBase
void _gl_debug_error_glListBase(GLuint base);

#define glLoadIdentity _gl_debug_error_glLoadIdentity
void _gl_debug_error_glLoadIdentity(void);

#define glLoadMatrixd _gl_debug_error_glLoadMatrixd
void _gl_debug_error_glLoadMatrixd(const GLdouble *m);

#define glLoadMatrixf _gl_debug_error_glLoadMatrixf
void _gl_debug_error_glLoadMatrixf(const GLfloat *m);

#define glLoadName _gl_debug_error_glLoadName
void _gl_debug_error_glLoadName(GLuint name);

#define glLogicOp _gl_debug_error_glLogicOp
void _gl_debug_error_glLogicOp(GLenum opcode);

#define glMap1d _gl_debug_error_glMap1d
void _gl_debug_error_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);

#define glMap1f _gl_debug_error_glMap1f
void _gl_debug_error_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);

#define glMap2d _gl_debug_error_glMap2d
void _gl_debug_error_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);

#define glMap2f _gl_debug_error_glMap2f
void _gl_debug_error_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);

#define glMapGrid1d _gl_debug_error_glMapGrid1d
void _gl_debug_error_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);

#define glMapGrid1f _gl_debug_error_glMapGrid1f
void _gl_debug_error_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);

#define glMapGrid2d _gl_debug_error_glMapGrid2d
void _gl_debug_error_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);

#define glMapGrid2f _gl_debug_error_glMapGrid2f
void _gl_debug_error_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);

#define glMaterialf _gl_debug_error_glMaterialf
void _gl_debug_error_glMaterialf(GLenum face, GLenum pname, GLfloat param);

#define glMaterialfv _gl_debug_error_glMaterialfv
void _gl_debug_error_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);

#define glMateriali _gl_debug_error_glMateriali
void _gl_debug_error_glMateriali(GLenum face, GLenum pname, GLint param);

#define glMaterialiv _gl_debug_error_glMaterialiv
void _gl_debug_error_glMaterialiv(GLenum face, GLenum pname, const GLint *params);

#define glMatrixMode _gl_debug_error_glMatrixMode
void _gl_debug_error_glMatrixMode(GLenum mode);

#define glMinmax _gl_debug_error_glMinmax
void _gl_debug_error_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);

#define glMultMatrixd _gl_debug_error_glMultMatrixd
void _gl_debug_error_glMultMatrixd(const GLdouble *m);

#define glMultMatrixf _gl_debug_error_glMultMatrixf
void _gl_debug_error_glMultMatrixf(const GLfloat *m);

#define glNewList _gl_debug_error_glNewList
void _gl_debug_error_glNewList(GLuint list, GLenum mode);

#define glNormal3b _gl_debug_error_glNormal3b
void _gl_debug_error_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);

#define glNormal3bv _gl_debug_error_glNormal3bv
void _gl_debug_error_glNormal3bv(const GLbyte *v);

#define glNormal3d _gl_debug_error_glNormal3d
void _gl_debug_error_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);

#define glNormal3dv _gl_debug_error_glNormal3dv
void _gl_debug_error_glNormal3dv(const GLdouble *v);

#define glNormal3f _gl_debug_error_glNormal3f
void _gl_debug_error_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);

#define glNormal3fv _gl_debug_error_glNormal3fv
void _gl_debug_error_glNormal3fv(const GLfloat *v);

#define glNormal3i _gl_debug_error_glNormal3i
void _gl_debug_error_glNormal3i(GLint nx, GLint ny, GLint nz);

#define glNormal3iv _gl_debug_error_glNormal3iv
void _gl_debug_error_glNormal3iv(const GLint *v);

#define glNormal3s _gl_debug_error_glNormal3s
void _gl_debug_error_glNormal3s(GLshort nx, GLshort ny, GLshort nz);

#define glNormal3sv _gl_debug_error_glNormal3sv
void _gl_debug_error_glNormal3sv(const GLshort *v);

#define glNormalPointer _gl_debug_error_glNormalPointer
void _gl_debug_error_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);

#define glOrtho _gl_debug_error_glOrtho
void _gl_debug_error_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

#define glPassThrough _gl_debug_error_glPassThrough
void _gl_debug_error_glPassThrough(GLfloat token);

#define glPixelMapfv _gl_debug_error_glPixelMapfv
void _gl_debug_error_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);

#define glPixelMapuiv _gl_debug_error_glPixelMapuiv
void _gl_debug_error_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);

#define glPixelMapusv _gl_debug_error_glPixelMapusv
void _gl_debug_error_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);

#define glPixelStoref _gl_debug_error_glPixelStoref
void _gl_debug_error_glPixelStoref(GLenum pname, GLfloat param);

#define glPixelStorei _gl_debug_error_glPixelStorei
void _gl_debug_error_glPixelStorei(GLenum pname, GLint param);

#define glPixelTransferf _gl_debug_error_glPixelTransferf
void _gl_debug_error_glPixelTransferf(GLenum pname, GLfloat param);

#define glPixelTransferi _gl_debug_error_glPixelTransferi
void _gl_debug_error_glPixelTransferi(GLenum pname, GLint param);

#define glPixelZoom _gl_debug_error_glPixelZoom
void _gl_debug_error_glPixelZoom(GLfloat xfactor, GLfloat yfactor);

#define glPointSize _gl_debug_error_glPointSize
void _gl_debug_error_glPointSize(GLfloat size);

#define glPolygonMode _gl_debug_error_glPolygonMode
void _gl_debug_error_glPolygonMode(GLenum face, GLenum mode);

#define glPolygonOffset _gl_debug_error_glPolygonOffset
void _gl_debug_error_glPolygonOffset(GLfloat factor, GLfloat units);

#define glPolygonStipple _gl_debug_error_glPolygonStipple
void _gl_debug_error_glPolygonStipple(const GLubyte *mask);

#define glPopAttrib _gl_debug_error_glPopAttrib
void _gl_debug_error_glPopAttrib(void);

#define glPopClientAttrib _gl_debug_error_glPopClientAttrib
void _gl_debug_error_glPopClientAttrib(void);

#define glPopMatrix _gl_debug_error_glPopMatrix
void _gl_debug_error_glPopMatrix(void);

#define glPopName _gl_debug_error_glPopName
void _gl_debug_error_glPopName(void);

#define glPrioritizeTextures _gl_debug_error_glPrioritizeTextures
void _gl_debug_error_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities);

#define glPushAttrib _gl_debug_error_glPushAttrib
void _gl_debug_error_glPushAttrib(GLbitfield mask);

#define glPushClientAttrib _gl_debug_error_glPushClientAttrib
void _gl_debug_error_glPushClientAttrib(GLbitfield mask);

#define glPushMatrix _gl_debug_error_glPushMatrix
void _gl_debug_error_glPushMatrix(void);

#define glPushName _gl_debug_error_glPushName
void _gl_debug_error_glPushName(GLuint name);

#define glRasterPos2d _gl_debug_error_glRasterPos2d
void _gl_debug_error_glRasterPos2d(GLdouble x, GLdouble y);

#define glRasterPos2dv _gl_debug_error_glRasterPos2dv
void _gl_debug_error_glRasterPos2dv(const GLdouble *v);

#define glRasterPos2f _gl_debug_error_glRasterPos2f
void _gl_debug_error_glRasterPos2f(GLfloat x, GLfloat y);

#define glRasterPos2fv _gl_debug_error_glRasterPos2fv
void _gl_debug_error_glRasterPos2fv(const GLfloat *v);

#define glRasterPos2i _gl_debug_error_glRasterPos2i
void _gl_debug_error_glRasterPos2i(GLint x, GLint y);

#define glRasterPos2iv _gl_debug_error_glRasterPos2iv
void _gl_debug_error_glRasterPos2iv(const GLint *v);

#define glRasterPos2s _gl_debug_error_glRasterPos2s
void _gl_debug_error_glRasterPos2s(GLshort x, GLshort y);

#define glRasterPos2sv _gl_debug_error_glRasterPos2sv
void _gl_debug_error_glRasterPos2sv(const GLshort *v);

#define glRasterPos3d _gl_debug_error_glRasterPos3d
void _gl_debug_error_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);

#define glRasterPos3dv _gl_debug_error_glRasterPos3dv
void _gl_debug_error_glRasterPos3dv(const GLdouble *v);

#define glRasterPos3f _gl_debug_error_glRasterPos3f
void _gl_debug_error_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);

#define glRasterPos3fv _gl_debug_error_glRasterPos3fv
void _gl_debug_error_glRasterPos3fv(const GLfloat *v);

#define glRasterPos3i _gl_debug_error_glRasterPos3i
void _gl_debug_error_glRasterPos3i(GLint x, GLint y, GLint z);

#define glRasterPos3iv _gl_debug_error_glRasterPos3iv
void _gl_debug_error_glRasterPos3iv(const GLint *v);

#define glRasterPos3s _gl_debug_error_glRasterPos3s
void _gl_debug_error_glRasterPos3s(GLshort x, GLshort y, GLshort z);

#define glRasterPos3sv _gl_debug_error_glRasterPos3sv
void _gl_debug_error_glRasterPos3sv(const GLshort *v);

#define glRasterPos4d _gl_debug_error_glRasterPos4d
void _gl_debug_error_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

#define glRasterPos4dv _gl_debug_error_glRasterPos4dv
void _gl_debug_error_glRasterPos4dv(const GLdouble *v);

#define glRasterPos4f _gl_debug_error_glRasterPos4f
void _gl_debug_error_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

#define glRasterPos4fv _gl_debug_error_glRasterPos4fv
void _gl_debug_error_glRasterPos4fv(const GLfloat *v);

#define glRasterPos4i _gl_debug_error_glRasterPos4i
void _gl_debug_error_glRasterPos4i(GLint x, GLint y, GLint z, GLint w);

#define glRasterPos4iv _gl_debug_error_glRasterPos4iv
void _gl_debug_error_glRasterPos4iv(const GLint *v);

#define glRasterPos4s _gl_debug_error_glRasterPos4s
void _gl_debug_error_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);

#define glRasterPos4sv _gl_debug_error_glRasterPos4sv
void _gl_debug_error_glRasterPos4sv(const GLshort *v);

#define glReadBuffer _gl_debug_error_glReadBuffer
void _gl_debug_error_glReadBuffer(GLenum mode);

#define glReadPixels _gl_debug_error_glReadPixels
void _gl_debug_error_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);

#define glRectd _gl_debug_error_glRectd
void _gl_debug_error_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);

#define glRectdv _gl_debug_error_glRectdv
void _gl_debug_error_glRectdv(const GLdouble *v1, const GLdouble *v2);

#define glRectf _gl_debug_error_glRectf
void _gl_debug_error_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);

#define glRectfv _gl_debug_error_glRectfv
void _gl_debug_error_glRectfv(const GLfloat *v1, const GLfloat *v2);

#define glRecti _gl_debug_error_glRecti
void _gl_debug_error_glRecti(GLint x1, GLint y1, GLint x2, GLint y2);

#define glRectiv _gl_debug_error_glRectiv
void _gl_debug_error_glRectiv(const GLint *v1, const GLint *v2);

#define glRects _gl_debug_error_glRects
void _gl_debug_error_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);

#define glRectsv _gl_debug_error_glRectsv
void _gl_debug_error_glRectsv(const GLshort *v1, const GLshort *v2);

#define glRenderMode _gl_debug_error_glRenderMode
GLint _gl_debug_error_glRenderMode(GLenum mode);

#define glResetHistogram _gl_debug_error_glResetHistogram
void _gl_debug_error_glResetHistogram(GLenum target);

#define glResetMinmax _gl_debug_error_glResetMinmax
void _gl_debug_error_glResetMinmax(GLenum target);

#define glRotated _gl_debug_error_glRotated
void _gl_debug_error_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);

#define glRotatef _gl_debug_error_glRotatef
void _gl_debug_error_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

#define glScaled _gl_debug_error_glScaled
void _gl_debug_error_glScaled(GLdouble x, GLdouble y, GLdouble z);

#define glScalef _gl_debug_error_glScalef
void _gl_debug_error_glScalef(GLfloat x, GLfloat y, GLfloat z);

#define glScissor _gl_debug_error_glScissor
void _gl_debug_error_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);

#define glSelectBuffer _gl_debug_error_glSelectBuffer
void _gl_debug_error_glSelectBuffer(GLsizei size, GLuint *buffer);

#define glSeparableFilter2D _gl_debug_error_glSeparableFilter2D
void _gl_debug_error_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);

#define glShadeModel _gl_debug_error_glShadeModel
void _gl_debug_error_glShadeModel(GLenum mode);

#define glStencilFunc _gl_debug_error_glStencilFunc
void _gl_debug_error_glStencilFunc(GLenum func, GLint ref, GLuint mask);

#define glStencilMask _gl_debug_error_glStencilMask
void _gl_debug_error_glStencilMask(GLuint mask);

#define glStencilOp _gl_debug_error_glStencilOp
void _gl_debug_error_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);

#define glTexCoord1d _gl_debug_error_glTexCoord1d
void _gl_debug_error_glTexCoord1d(GLdouble s);

#define glTexCoord1dv _gl_debug_error_glTexCoord1dv
void _gl_debug_error_glTexCoord1dv(const GLdouble *v);

#define glTexCoord1f _gl_debug_error_glTexCoord1f
void _gl_debug_error_glTexCoord1f(GLfloat s);

#define glTexCoord1fv _gl_debug_error_glTexCoord1fv
void _gl_debug_error_glTexCoord1fv(const GLfloat *v);

#define glTexCoord1i _gl_debug_error_glTexCoord1i
void _gl_debug_error_glTexCoord1i(GLint s);

#define glTexCoord1iv _gl_debug_error_glTexCoord1iv
void _gl_debug_error_glTexCoord1iv(const GLint *v);

#define glTexCoord1s _gl_debug_error_glTexCoord1s
void _gl_debug_error_glTexCoord1s(GLshort s);

#define glTexCoord1sv _gl_debug_error_glTexCoord1sv
void _gl_debug_error_glTexCoord1sv(const GLshort *v);

#define glTexCoord2d _gl_debug_error_glTexCoord2d
void _gl_debug_error_glTexCoord2d(GLdouble s, GLdouble t);

#define glTexCoord2dv _gl_debug_error_glTexCoord2dv
void _gl_debug_error_glTexCoord2dv(const GLdouble *v);

#define glTexCoord2f _gl_debug_error_glTexCoord2f
void _gl_debug_error_glTexCoord2f(GLfloat s, GLfloat t);

#define glTexCoord2fv _gl_debug_error_glTexCoord2fv
void _gl_debug_error_glTexCoord2fv(const GLfloat *v);

#define glTexCoord2i _gl_debug_error_glTexCoord2i
void _gl_debug_error_glTexCoord2i(GLint s, GLint t);

#define glTexCoord2iv _gl_debug_error_glTexCoord2iv
void _gl_debug_error_glTexCoord2iv(const GLint *v);

#define glTexCoord2s _gl_debug_error_glTexCoord2s
void _gl_debug_error_glTexCoord2s(GLshort s, GLshort t);

#define glTexCoord2sv _gl_debug_error_glTexCoord2sv
void _gl_debug_error_glTexCoord2sv(const GLshort *v);

#define glTexCoord3d _gl_debug_error_glTexCoord3d
void _gl_debug_error_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);

#define glTexCoord3dv _gl_debug_error_glTexCoord3dv
void _gl_debug_error_glTexCoord3dv(const GLdouble *v);

#define glTexCoord3f _gl_debug_error_glTexCoord3f
void _gl_debug_error_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);

#define glTexCoord3fv _gl_debug_error_glTexCoord3fv
void _gl_debug_error_glTexCoord3fv(const GLfloat *v);

#define glTexCoord3i _gl_debug_error_glTexCoord3i
void _gl_debug_error_glTexCoord3i(GLint s, GLint t, GLint r);

#define glTexCoord3iv _gl_debug_error_glTexCoord3iv
void _gl_debug_error_glTexCoord3iv(const GLint *v);

#define glTexCoord3s _gl_debug_error_glTexCoord3s
void _gl_debug_error_glTexCoord3s(GLshort s, GLshort t, GLshort r);

#define glTexCoord3sv _gl_debug_error_glTexCoord3sv
void _gl_debug_error_glTexCoord3sv(const GLshort *v);

#define glTexCoord4d _gl_debug_error_glTexCoord4d
void _gl_debug_error_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);

#define glTexCoord4dv _gl_debug_error_glTexCoord4dv
void _gl_debug_error_glTexCoord4dv(const GLdouble *v);

#define glTexCoord4f _gl_debug_error_glTexCoord4f
void _gl_debug_error_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);

#define glTexCoord4fv _gl_debug_error_glTexCoord4fv
void _gl_debug_error_glTexCoord4fv(const GLfloat *v);

#define glTexCoord4i _gl_debug_error_glTexCoord4i
void _gl_debug_error_glTexCoord4i(GLint s, GLint t, GLint r, GLint q);

#define glTexCoord4iv _gl_debug_error_glTexCoord4iv
void _gl_debug_error_glTexCoord4iv(const GLint *v);

#define glTexCoord4s _gl_debug_error_glTexCoord4s
void _gl_debug_error_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);

#define glTexCoord4sv _gl_debug_error_glTexCoord4sv
void _gl_debug_error_glTexCoord4sv(const GLshort *v);

#define glTexCoordPointer _gl_debug_error_glTexCoordPointer
void _gl_debug_error_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

#define glTexEnvf _gl_debug_error_glTexEnvf
void _gl_debug_error_glTexEnvf(GLenum target, GLenum pname, GLfloat param);

#define glTexEnvfv _gl_debug_error_glTexEnvfv
void _gl_debug_error_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);

#define glTexEnvi _gl_debug_error_glTexEnvi
void _gl_debug_error_glTexEnvi(GLenum target, GLenum pname, GLint param);

#define glTexEnviv _gl_debug_error_glTexEnviv
void _gl_debug_error_glTexEnviv(GLenum target, GLenum pname, const GLint *params);

#define glTexGend _gl_debug_error_glTexGend
void _gl_debug_error_glTexGend(GLenum coord, GLenum pname, GLdouble param);

#define glTexGendv _gl_debug_error_glTexGendv
void _gl_debug_error_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);

#define glTexGenf _gl_debug_error_glTexGenf
void _gl_debug_error_glTexGenf(GLenum coord, GLenum pname, GLfloat param);

#define glTexGenfv _gl_debug_error_glTexGenfv
void _gl_debug_error_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);

#define glTexGeni _gl_debug_error_glTexGeni
void _gl_debug_error_glTexGeni(GLenum coord, GLenum pname, GLint param);

#define glTexGeniv _gl_debug_error_glTexGeniv
void _gl_debug_error_glTexGeniv(GLenum coord, GLenum pname, const GLint *params);

#define glTexImage1D _gl_debug_error_glTexImage1D
void _gl_debug_error_glTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

#define glTexImage2D _gl_debug_error_glTexImage2D
void _gl_debug_error_glTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

#define glTexImage3D _gl_debug_error_glTexImage3D
void _gl_debug_error_glTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

#define glTexParameterf _gl_debug_error_glTexParameterf
void _gl_debug_error_glTexParameterf(GLenum target, GLenum pname, GLfloat param);

#define glTexParameterfv _gl_debug_error_glTexParameterfv
void _gl_debug_error_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);

#define glTexParameteri _gl_debug_error_glTexParameteri
void _gl_debug_error_glTexParameteri(GLenum target, GLenum pname, GLint param);

#define glTexParameteriv _gl_debug_error_glTexParameteriv
void _gl_debug_error_glTexParameteriv(GLenum target, GLenum pname, const GLint *params);

#define glTexSubImage1D _gl_debug_error_glTexSubImage1D
void _gl_debug_error_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);

#define glTexSubImage2D _gl_debug_error_glTexSubImage2D
void _gl_debug_error_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

#define glTexSubImage3D _gl_debug_error_glTexSubImage3D
void _gl_debug_error_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);

#define glTranslated _gl_debug_error_glTranslated
void _gl_debug_error_glTranslated(GLdouble x, GLdouble y, GLdouble z);

#define glTranslatef _gl_debug_error_glTranslatef
void _gl_debug_error_glTranslatef(GLfloat x, GLfloat y, GLfloat z);

#define glVertex2d _gl_debug_error_glVertex2d
void _gl_debug_error_glVertex2d(GLdouble x, GLdouble y);

#define glVertex2dv _gl_debug_error_glVertex2dv
void _gl_debug_error_glVertex2dv(const GLdouble *v);

#define glVertex2f _gl_debug_error_glVertex2f
void _gl_debug_error_glVertex2f(GLfloat x, GLfloat y);

#define glVertex2fv _gl_debug_error_glVertex2fv
void _gl_debug_error_glVertex2fv(const GLfloat *v);

#define glVertex2i _gl_debug_error_glVertex2i
void _gl_debug_error_glVertex2i(GLint x, GLint y);

#define glVertex2iv _gl_debug_error_glVertex2iv
void _gl_debug_error_glVertex2iv(const GLint *v);

#define glVertex2s _gl_debug_error_glVertex2s
void _gl_debug_error_glVertex2s(GLshort x, GLshort y);

#define glVertex2sv _gl_debug_error_glVertex2sv
void _gl_debug_error_glVertex2sv(const GLshort *v);

#define glVertex3d _gl_debug_error_glVertex3d
void _gl_debug_error_glVertex3d(GLdouble x, GLdouble y, GLdouble z);

#define glVertex3dv _gl_debug_error_glVertex3dv
void _gl_debug_error_glVertex3dv(const GLdouble *v);

#define glVertex3f _gl_debug_error_glVertex3f
void _gl_debug_error_glVertex3f(GLfloat x, GLfloat y, GLfloat z);

#define glVertex3fv _gl_debug_error_glVertex3fv
void _gl_debug_error_glVertex3fv(const GLfloat *v);

#define glVertex3i _gl_debug_error_glVertex3i
void _gl_debug_error_glVertex3i(GLint x, GLint y, GLint z);

#define glVertex3iv _gl_debug_error_glVertex3iv
void _gl_debug_error_glVertex3iv(const GLint *v);

#define glVertex3s _gl_debug_error_glVertex3s
void _gl_debug_error_glVertex3s(GLshort x, GLshort y, GLshort z);

#define glVertex3sv _gl_debug_error_glVertex3sv
void _gl_debug_error_glVertex3sv(const GLshort *v);

#define glVertex4d _gl_debug_error_glVertex4d
void _gl_debug_error_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

#define glVertex4dv _gl_debug_error_glVertex4dv
void _gl_debug_error_glVertex4dv(const GLdouble *v);

#define glVertex4f _gl_debug_error_glVertex4f
void _gl_debug_error_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

#define glVertex4fv _gl_debug_error_glVertex4fv
void _gl_debug_error_glVertex4fv(const GLfloat *v);

#define glVertex4i _gl_debug_error_glVertex4i
void _gl_debug_error_glVertex4i(GLint x, GLint y, GLint z, GLint w);

#define glVertex4iv _gl_debug_error_glVertex4iv
void _gl_debug_error_glVertex4iv(const GLint *v);

#define glVertex4s _gl_debug_error_glVertex4s
void _gl_debug_error_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);

#define glVertex4sv _gl_debug_error_glVertex4sv
void _gl_debug_error_glVertex4sv(const GLshort *v);

#define glVertexPointer _gl_debug_error_glVertexPointer
void _gl_debug_error_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

#define glViewport _gl_debug_error_glViewport
void _gl_debug_error_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);

#define glSampleCoverage _gl_debug_error_glSampleCoverage
void _gl_debug_error_glSampleCoverage(GLclampf value, GLboolean invert);

#define glSamplePass _gl_debug_error_glSamplePass
void _gl_debug_error_glSamplePass(GLenum pass);

#define glLoadTransposeMatrixf _gl_debug_error_glLoadTransposeMatrixf
void _gl_debug_error_glLoadTransposeMatrixf(const GLfloat *m);

#define glLoadTransposeMatrixd _gl_debug_error_glLoadTransposeMatrixd
void _gl_debug_error_glLoadTransposeMatrixd(const GLdouble *m);

#define glMultTransposeMatrixf _gl_debug_error_glMultTransposeMatrixf
void _gl_debug_error_glMultTransposeMatrixf(const GLfloat *m);

#define glMultTransposeMatrixd _gl_debug_error_glMultTransposeMatrixd
void _gl_debug_error_glMultTransposeMatrixd(const GLdouble *m);

#define glCompressedTexImage3D _gl_debug_error_glCompressedTexImage3D
void _gl_debug_error_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);

#define glCompressedTexImage2D _gl_debug_error_glCompressedTexImage2D
void _gl_debug_error_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);

#define glCompressedTexImage1D _gl_debug_error_glCompressedTexImage1D
void _gl_debug_error_glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);

#define glCompressedTexSubImage3D _gl_debug_error_glCompressedTexSubImage3D
void _gl_debug_error_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);

#define glCompressedTexSubImage2D _gl_debug_error_glCompressedTexSubImage2D
void _gl_debug_error_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);

#define glCompressedTexSubImage1D _gl_debug_error_glCompressedTexSubImage1D
void _gl_debug_error_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);

#define glGetCompressedTexImage _gl_debug_error_glGetCompressedTexImage
void _gl_debug_error_glGetCompressedTexImage(GLenum target, GLint lod, GLvoid *img);

#define glActiveTexture _gl_debug_error_glActiveTexture
void _gl_debug_error_glActiveTexture(GLenum texture);

#define glClientActiveTexture _gl_debug_error_glClientActiveTexture
void _gl_debug_error_glClientActiveTexture(GLenum texture);

#define glMultiTexCoord1d _gl_debug_error_glMultiTexCoord1d
void _gl_debug_error_glMultiTexCoord1d(GLenum target, GLdouble s);

#define glMultiTexCoord1dv _gl_debug_error_glMultiTexCoord1dv
void _gl_debug_error_glMultiTexCoord1dv(GLenum target, const GLdouble *v);

#define glMultiTexCoord1f _gl_debug_error_glMultiTexCoord1f
void _gl_debug_error_glMultiTexCoord1f(GLenum target, GLfloat s);

#define glMultiTexCoord1fv _gl_debug_error_glMultiTexCoord1fv
void _gl_debug_error_glMultiTexCoord1fv(GLenum target, const GLfloat *v);

#define glMultiTexCoord1i _gl_debug_error_glMultiTexCoord1i
void _gl_debug_error_glMultiTexCoord1i(GLenum target, GLint s);

#define glMultiTexCoord1iv _gl_debug_error_glMultiTexCoord1iv
void _gl_debug_error_glMultiTexCoord1iv(GLenum target, const GLint *v);

#define glMultiTexCoord1s _gl_debug_error_glMultiTexCoord1s
void _gl_debug_error_glMultiTexCoord1s(GLenum target, GLshort s);

#define glMultiTexCoord1sv _gl_debug_error_glMultiTexCoord1sv
void _gl_debug_error_glMultiTexCoord1sv(GLenum target, const GLshort *v);

#define glMultiTexCoord2d _gl_debug_error_glMultiTexCoord2d
void _gl_debug_error_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t);

#define glMultiTexCoord2dv _gl_debug_error_glMultiTexCoord2dv
void _gl_debug_error_glMultiTexCoord2dv(GLenum target, const GLdouble *v);

#define glMultiTexCoord2f _gl_debug_error_glMultiTexCoord2f
void _gl_debug_error_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t);

#define glMultiTexCoord2fv _gl_debug_error_glMultiTexCoord2fv
void _gl_debug_error_glMultiTexCoord2fv(GLenum target, const GLfloat *v);

#define glMultiTexCoord2i _gl_debug_error_glMultiTexCoord2i
void _gl_debug_error_glMultiTexCoord2i(GLenum target, GLint s, GLint t);

#define glMultiTexCoord2iv _gl_debug_error_glMultiTexCoord2iv
void _gl_debug_error_glMultiTexCoord2iv(GLenum target, const GLint *v);

#define glMultiTexCoord2s _gl_debug_error_glMultiTexCoord2s
void _gl_debug_error_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t);

#define glMultiTexCoord2sv _gl_debug_error_glMultiTexCoord2sv
void _gl_debug_error_glMultiTexCoord2sv(GLenum target, const GLshort *v);

#define glMultiTexCoord3d _gl_debug_error_glMultiTexCoord3d
void _gl_debug_error_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r);

#define glMultiTexCoord3dv _gl_debug_error_glMultiTexCoord3dv
void _gl_debug_error_glMultiTexCoord3dv(GLenum target, const GLdouble *v);

#define glMultiTexCoord3f _gl_debug_error_glMultiTexCoord3f
void _gl_debug_error_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r);

#define glMultiTexCoord3fv _gl_debug_error_glMultiTexCoord3fv
void _gl_debug_error_glMultiTexCoord3fv(GLenum target, const GLfloat *v);

#define glMultiTexCoord3i _gl_debug_error_glMultiTexCoord3i
void _gl_debug_error_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r);

#define glMultiTexCoord3iv _gl_debug_error_glMultiTexCoord3iv
void _gl_debug_error_glMultiTexCoord3iv(GLenum target, const GLint *v);

#define glMultiTexCoord3s _gl_debug_error_glMultiTexCoord3s
void _gl_debug_error_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r);

#define glMultiTexCoord3sv _gl_debug_error_glMultiTexCoord3sv
void _gl_debug_error_glMultiTexCoord3sv(GLenum target, const GLshort *v);

#define glMultiTexCoord4d _gl_debug_error_glMultiTexCoord4d
void _gl_debug_error_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);

#define glMultiTexCoord4dv _gl_debug_error_glMultiTexCoord4dv
void _gl_debug_error_glMultiTexCoord4dv(GLenum target, const GLdouble *v);

#define glMultiTexCoord4f _gl_debug_error_glMultiTexCoord4f
void _gl_debug_error_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);

#define glMultiTexCoord4fv _gl_debug_error_glMultiTexCoord4fv
void _gl_debug_error_glMultiTexCoord4fv(GLenum target, const GLfloat *v);

#define glMultiTexCoord4i _gl_debug_error_glMultiTexCoord4i
void _gl_debug_error_glMultiTexCoord4i(GLenum target, GLint _gl_unnamed_arg_1, GLint s, GLint t, GLint r);

#define glMultiTexCoord4iv _gl_debug_error_glMultiTexCoord4iv
void _gl_debug_error_glMultiTexCoord4iv(GLenum target, const GLint *v);

#define glMultiTexCoord4s _gl_debug_error_glMultiTexCoord4s
void _gl_debug_error_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);

#define glMultiTexCoord4sv _gl_debug_error_glMultiTexCoord4sv
void _gl_debug_error_glMultiTexCoord4sv(GLenum target, const GLshort *v);

#define glFogCoordf _gl_debug_error_glFogCoordf
void _gl_debug_error_glFogCoordf(GLfloat coord);

#define glFogCoordfv _gl_debug_error_glFogCoordfv
void _gl_debug_error_glFogCoordfv(const GLfloat *coord);

#define glFogCoordd _gl_debug_error_glFogCoordd
void _gl_debug_error_glFogCoordd(GLdouble coord);

#define glFogCoorddv _gl_debug_error_glFogCoorddv
void _gl_debug_error_glFogCoorddv(const GLdouble * coord);

#define glFogCoordPointer _gl_debug_error_glFogCoordPointer
void _gl_debug_error_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);

#define glSecondaryColor3b _gl_debug_error_glSecondaryColor3b
void _gl_debug_error_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);

#define glSecondaryColor3bv _gl_debug_error_glSecondaryColor3bv
void _gl_debug_error_glSecondaryColor3bv(const GLbyte *v);

#define glSecondaryColor3d _gl_debug_error_glSecondaryColor3d
void _gl_debug_error_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);

#define glSecondaryColor3dv _gl_debug_error_glSecondaryColor3dv
void _gl_debug_error_glSecondaryColor3dv(const GLdouble *v);

#define glSecondaryColor3f _gl_debug_error_glSecondaryColor3f
void _gl_debug_error_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);

#define glSecondaryColor3fv _gl_debug_error_glSecondaryColor3fv
void _gl_debug_error_glSecondaryColor3fv(const GLfloat *v);

#define glSecondaryColor3i _gl_debug_error_glSecondaryColor3i
void _gl_debug_error_glSecondaryColor3i(GLint red, GLint green, GLint blue);

#define glSecondaryColor3iv _gl_debug_error_glSecondaryColor3iv
void _gl_debug_error_glSecondaryColor3iv(const GLint *v);

#define glSecondaryColor3s _gl_debug_error_glSecondaryColor3s
void _gl_debug_error_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);

#define glSecondaryColor3sv _gl_debug_error_glSecondaryColor3sv
void _gl_debug_error_glSecondaryColor3sv(const GLshort *v);

#define glSecondaryColor3ub _gl_debug_error_glSecondaryColor3ub
void _gl_debug_error_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);

#define glSecondaryColor3ubv _gl_debug_error_glSecondaryColor3ubv
void _gl_debug_error_glSecondaryColor3ubv(const GLubyte *v);

#define glSecondaryColor3ui _gl_debug_error_glSecondaryColor3ui
void _gl_debug_error_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);

#define glSecondaryColor3uiv _gl_debug_error_glSecondaryColor3uiv
void _gl_debug_error_glSecondaryColor3uiv(const GLuint *v);

#define glSecondaryColor3us _gl_debug_error_glSecondaryColor3us
void _gl_debug_error_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);

#define glSecondaryColor3usv _gl_debug_error_glSecondaryColor3usv
void _gl_debug_error_glSecondaryColor3usv(const GLushort *v);

#define glSecondaryColorPointer _gl_debug_error_glSecondaryColorPointer
void _gl_debug_error_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

#define glPointParameterf _gl_debug_error_glPointParameterf
void _gl_debug_error_glPointParameterf(GLenum pname, GLfloat param);

#define glPointParameterfv _gl_debug_error_glPointParameterfv
void _gl_debug_error_glPointParameterfv(GLenum pname, const GLfloat *params);

#define glPointParameteri _gl_debug_error_glPointParameteri
void _gl_debug_error_glPointParameteri(GLenum pname, GLint param);

#define glPointParameteriv _gl_debug_error_glPointParameteriv
void _gl_debug_error_glPointParameteriv(GLenum pname, const GLint *params);

#define glBlendFuncSeparate _gl_debug_error_glBlendFuncSeparate
void _gl_debug_error_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

#define glMultiDrawArrays _gl_debug_error_glMultiDrawArrays
void _gl_debug_error_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);

#define glMultiDrawElements _gl_debug_error_glMultiDrawElements
void _gl_debug_error_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);

#define glWindowPos2d _gl_debug_error_glWindowPos2d
void _gl_debug_error_glWindowPos2d(GLdouble x, GLdouble y);

#define glWindowPos2dv _gl_debug_error_glWindowPos2dv
void _gl_debug_error_glWindowPos2dv(const GLdouble *v);

#define glWindowPos2f _gl_debug_error_glWindowPos2f
void _gl_debug_error_glWindowPos2f(GLfloat x, GLfloat y);

#define glWindowPos2fv _gl_debug_error_glWindowPos2fv
void _gl_debug_error_glWindowPos2fv(const GLfloat *v);

#define glWindowPos2i _gl_debug_error_glWindowPos2i
void _gl_debug_error_glWindowPos2i(GLint x, GLint y);

#define glWindowPos2iv _gl_debug_error_glWindowPos2iv
void _gl_debug_error_glWindowPos2iv(const GLint *v);

#define glWindowPos2s _gl_debug_error_glWindowPos2s
void _gl_debug_error_glWindowPos2s(GLshort x, GLshort y);

#define glWindowPos2sv _gl_debug_error_glWindowPos2sv
void _gl_debug_error_glWindowPos2sv(const GLshort *v);

#define glWindowPos3d _gl_debug_error_glWindowPos3d
void _gl_debug_error_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z);

#define glWindowPos3dv _gl_debug_error_glWindowPos3dv
void _gl_debug_error_glWindowPos3dv(const GLdouble *v);

#define glWindowPos3f _gl_debug_error_glWindowPos3f
void _gl_debug_error_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z);

#define glWindowPos3fv _gl_debug_error_glWindowPos3fv
void _gl_debug_error_glWindowPos3fv(const GLfloat *v);

#define glWindowPos3i _gl_debug_error_glWindowPos3i
void _gl_debug_error_glWindowPos3i(GLint x, GLint y, GLint z);

#define glWindowPos3iv _gl_debug_error_glWindowPos3iv
void _gl_debug_error_glWindowPos3iv(const GLint *v);

#define glWindowPos3s _gl_debug_error_glWindowPos3s
void _gl_debug_error_glWindowPos3s(GLshort x, GLshort y, GLshort z);

#define glWindowPos3sv _gl_debug_error_glWindowPos3sv
void _gl_debug_error_glWindowPos3sv(const GLshort *v);

#define glGenQueries _gl_debug_error_glGenQueries
void _gl_debug_error_glGenQueries(GLsizei n, GLuint *ids);

#define glDeleteQueries _gl_debug_error_glDeleteQueries
void _gl_debug_error_glDeleteQueries(GLsizei n, const GLuint *ids);

#define glIsQuery _gl_debug_error_glIsQuery
GLboolean _gl_debug_error_glIsQuery(GLuint id);

#define glBeginQuery _gl_debug_error_glBeginQuery
void _gl_debug_error_glBeginQuery(GLenum target, GLuint id);

#define glEndQuery _gl_debug_error_glEndQuery
void _gl_debug_error_glEndQuery(GLenum target);

#define glGetQueryiv _gl_debug_error_glGetQueryiv
void _gl_debug_error_glGetQueryiv(GLenum target, GLenum pname, GLint *params);

#define glGetQueryObjectiv _gl_debug_error_glGetQueryObjectiv
void _gl_debug_error_glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params);

#define glGetQueryObjectuiv _gl_debug_error_glGetQueryObjectuiv
void _gl_debug_error_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);

#define glBindBuffer _gl_debug_error_glBindBuffer
void _gl_debug_error_glBindBuffer(GLenum target, GLuint buffer);

#define glDeleteBuffers _gl_debug_error_glDeleteBuffers
void _gl_debug_error_glDeleteBuffers(GLsizei n, const GLuint *buffers);

#define glGenBuffers _gl_debug_error_glGenBuffers
void _gl_debug_error_glGenBuffers(GLsizei n, GLuint *buffers);

#define glIsBuffer _gl_debug_error_glIsBuffer
GLboolean _gl_debug_error_glIsBuffer(GLuint buffer);

#define glBufferData _gl_debug_error_glBufferData
void _gl_debug_error_glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);

#define glBufferSubData _gl_debug_error_glBufferSubData
void _gl_debug_error_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);

#define glGetBufferSubData _gl_debug_error_glGetBufferSubData
void _gl_debug_error_glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);

#define glMapBuffer _gl_debug_error_glMapBuffer
GLvoid * _gl_debug_error_glMapBuffer(GLenum target, GLenum access);

#define glUnmapBuffer _gl_debug_error_glUnmapBuffer
GLboolean _gl_debug_error_glUnmapBuffer(GLenum target);

#define glGetBufferParameteriv _gl_debug_error_glGetBufferParameteriv
void _gl_debug_error_glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params);

#define glGetBufferPointerv _gl_debug_error_glGetBufferPointerv
void _gl_debug_error_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params);

#define glDrawBuffers _gl_debug_error_glDrawBuffers
void _gl_debug_error_glDrawBuffers(GLsizei n, const GLenum *bufs);

#define glVertexAttrib1d _gl_debug_error_glVertexAttrib1d
void _gl_debug_error_glVertexAttrib1d(GLuint index, GLdouble x);

#define glVertexAttrib1dv _gl_debug_error_glVertexAttrib1dv
void _gl_debug_error_glVertexAttrib1dv(GLuint index, const GLdouble *v);

#define glVertexAttrib1f _gl_debug_error_glVertexAttrib1f
void _gl_debug_error_glVertexAttrib1f(GLuint index, GLfloat x);

#define glVertexAttrib1fv _gl_debug_error_glVertexAttrib1fv
void _gl_debug_error_glVertexAttrib1fv(GLuint index, const GLfloat *v);

#define glVertexAttrib1s _gl_debug_error_glVertexAttrib1s
void _gl_debug_error_glVertexAttrib1s(GLuint index, GLshort x);

#define glVertexAttrib1sv _gl_debug_error_glVertexAttrib1sv
void _gl_debug_error_glVertexAttrib1sv(GLuint index, const GLshort *v);

#define glVertexAttrib2d _gl_debug_error_glVertexAttrib2d
void _gl_debug_error_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y);

#define glVertexAttrib2dv _gl_debug_error_glVertexAttrib2dv
void _gl_debug_error_glVertexAttrib2dv(GLuint index, const GLdouble *v);

#define glVertexAttrib2f _gl_debug_error_glVertexAttrib2f
void _gl_debug_error_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y);

#define glVertexAttrib2fv _gl_debug_error_glVertexAttrib2fv
void _gl_debug_error_glVertexAttrib2fv(GLuint index, const GLfloat *v);

#define glVertexAttrib2s _gl_debug_error_glVertexAttrib2s
void _gl_debug_error_glVertexAttrib2s(GLuint index, GLshort x, GLshort y);

#define glVertexAttrib2sv _gl_debug_error_glVertexAttrib2sv
void _gl_debug_error_glVertexAttrib2sv(GLuint index, const GLshort *v);

#define glVertexAttrib3d _gl_debug_error_glVertexAttrib3d
void _gl_debug_error_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);

#define glVertexAttrib3dv _gl_debug_error_glVertexAttrib3dv
void _gl_debug_error_glVertexAttrib3dv(GLuint index, const GLdouble *v);

#define glVertexAttrib3f _gl_debug_error_glVertexAttrib3f
void _gl_debug_error_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);

#define glVertexAttrib3fv _gl_debug_error_glVertexAttrib3fv
void _gl_debug_error_glVertexAttrib3fv(GLuint index, const GLfloat *v);

#define glVertexAttrib3s _gl_debug_error_glVertexAttrib3s
void _gl_debug_error_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);

#define glVertexAttrib3sv _gl_debug_error_glVertexAttrib3sv
void _gl_debug_error_glVertexAttrib3sv(GLuint index, const GLshort *v);

#define glVertexAttrib4Nbv _gl_debug_error_glVertexAttrib4Nbv
void _gl_debug_error_glVertexAttrib4Nbv(GLuint index, const GLbyte *v);

#define glVertexAttrib4Niv _gl_debug_error_glVertexAttrib4Niv
void _gl_debug_error_glVertexAttrib4Niv(GLuint index, const GLint *v);

#define glVertexAttrib4Nsv _gl_debug_error_glVertexAttrib4Nsv
void _gl_debug_error_glVertexAttrib4Nsv(GLuint index, const GLshort *v);

#define glVertexAttrib4Nub _gl_debug_error_glVertexAttrib4Nub
void _gl_debug_error_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);

#define glVertexAttrib4Nubv _gl_debug_error_glVertexAttrib4Nubv
void _gl_debug_error_glVertexAttrib4Nubv(GLuint index, const GLubyte *v);

#define glVertexAttrib4Nuiv _gl_debug_error_glVertexAttrib4Nuiv
void _gl_debug_error_glVertexAttrib4Nuiv(GLuint index, const GLuint *v);

#define glVertexAttrib4Nusv _gl_debug_error_glVertexAttrib4Nusv
void _gl_debug_error_glVertexAttrib4Nusv(GLuint index, const GLushort *v);

#define glVertexAttrib4bv _gl_debug_error_glVertexAttrib4bv
void _gl_debug_error_glVertexAttrib4bv(GLuint index, const GLbyte *v);

#define glVertexAttrib4d _gl_debug_error_glVertexAttrib4d
void _gl_debug_error_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);

#define glVertexAttrib4dv _gl_debug_error_glVertexAttrib4dv
void _gl_debug_error_glVertexAttrib4dv(GLuint index, const GLdouble *v);

#define glVertexAttrib4f _gl_debug_error_glVertexAttrib4f
void _gl_debug_error_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

#define glVertexAttrib4fv _gl_debug_error_glVertexAttrib4fv
void _gl_debug_error_glVertexAttrib4fv(GLuint index, const GLfloat *v);

#define glVertexAttrib4iv _gl_debug_error_glVertexAttrib4iv
void _gl_debug_error_glVertexAttrib4iv(GLuint index, const GLint *v);

#define glVertexAttrib4s _gl_debug_error_glVertexAttrib4s
void _gl_debug_error_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);

#define glVertexAttrib4sv _gl_debug_error_glVertexAttrib4sv
void _gl_debug_error_glVertexAttrib4sv(GLuint index, const GLshort *v);

#define glVertexAttrib4ubv _gl_debug_error_glVertexAttrib4ubv
void _gl_debug_error_glVertexAttrib4ubv(GLuint index, const GLubyte *v);

#define glVertexAttrib4uiv _gl_debug_error_glVertexAttrib4uiv
void _gl_debug_error_glVertexAttrib4uiv(GLuint index, const GLuint *v);

#define glVertexAttrib4usv _gl_debug_error_glVertexAttrib4usv
void _gl_debug_error_glVertexAttrib4usv(GLuint index, const GLushort *v);

#define glVertexAttribPointer _gl_debug_error_glVertexAttribPointer
void _gl_debug_error_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);

#define glEnableVertexAttribArray _gl_debug_error_glEnableVertexAttribArray
void _gl_debug_error_glEnableVertexAttribArray(GLuint index);

#define glDisableVertexAttribArray _gl_debug_error_glDisableVertexAttribArray
void _gl_debug_error_glDisableVertexAttribArray(GLuint index);

#define glGetVertexAttribdv _gl_debug_error_glGetVertexAttribdv
void _gl_debug_error_glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params);

#define glGetVertexAttribfv _gl_debug_error_glGetVertexAttribfv
void _gl_debug_error_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);

#define glGetVertexAttribiv _gl_debug_error_glGetVertexAttribiv
void _gl_debug_error_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params);

#define glGetVertexAttribPointerv _gl_debug_error_glGetVertexAttribPointerv
void _gl_debug_error_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer);

#define glDeleteShader _gl_debug_error_glDeleteShader
void _gl_debug_error_glDeleteShader(GLuint shader);

#define glDetachShader _gl_debug_error_glDetachShader
void _gl_debug_error_glDetachShader(GLuint program, GLuint shader);

#define glCreateShader _gl_debug_error_glCreateShader
GLuint _gl_debug_error_glCreateShader(GLenum type);

#define glShaderSource _gl_debug_error_glShaderSource
void _gl_debug_error_glShaderSource(GLuint shader, GLsizei count, const GLchar* *string, const GLint *length);

#define glCompileShader _gl_debug_error_glCompileShader
void _gl_debug_error_glCompileShader(GLuint shader);

#define glCreateProgram _gl_debug_error_glCreateProgram
GLuint _gl_debug_error_glCreateProgram(void);

#define glAttachShader _gl_debug_error_glAttachShader
void _gl_debug_error_glAttachShader(GLuint program, GLuint shader);

#define glLinkProgram _gl_debug_error_glLinkProgram
void _gl_debug_error_glLinkProgram(GLuint program);

#define glUseProgram _gl_debug_error_glUseProgram
void _gl_debug_error_glUseProgram(GLuint program);

#define glDeleteProgram _gl_debug_error_glDeleteProgram
void _gl_debug_error_glDeleteProgram(GLuint program);

#define glValidateProgram _gl_debug_error_glValidateProgram
void _gl_debug_error_glValidateProgram(GLuint program);

#define glUniform1f _gl_debug_error_glUniform1f
void _gl_debug_error_glUniform1f(GLint location, GLfloat v0);

#define glUniform2f _gl_debug_error_glUniform2f
void _gl_debug_error_glUniform2f(GLint location, GLfloat v0, GLfloat v1);

#define glUniform3f _gl_debug_error_glUniform3f
void _gl_debug_error_glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

#define glUniform4f _gl_debug_error_glUniform4f
void _gl_debug_error_glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

#define glUniform1i _gl_debug_error_glUniform1i
void _gl_debug_error_glUniform1i(GLint location, GLint v0);

#define glUniform2i _gl_debug_error_glUniform2i
void _gl_debug_error_glUniform2i(GLint location, GLint v0, GLint v1);

#define glUniform3i _gl_debug_error_glUniform3i
void _gl_debug_error_glUniform3i(GLint location, GLint v0, GLint v1, GLint v2);

#define glUniform4i _gl_debug_error_glUniform4i
void _gl_debug_error_glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

#define glUniform1fv _gl_debug_error_glUniform1fv
void _gl_debug_error_glUniform1fv(GLint location, GLsizei count, const GLfloat *value);

#define glUniform2fv _gl_debug_error_glUniform2fv
void _gl_debug_error_glUniform2fv(GLint location, GLsizei count, const GLfloat *value);

#define glUniform3fv _gl_debug_error_glUniform3fv
void _gl_debug_error_glUniform3fv(GLint location, GLsizei count, const GLfloat *value);

#define glUniform4fv _gl_debug_error_glUniform4fv
void _gl_debug_error_glUniform4fv(GLint location, GLsizei count, const GLfloat *value);

#define glUniform1iv _gl_debug_error_glUniform1iv
void _gl_debug_error_glUniform1iv(GLint location, GLsizei count, const GLint *value);

#define glUniform2iv _gl_debug_error_glUniform2iv
void _gl_debug_error_glUniform2iv(GLint location, GLsizei count, const GLint *value);

#define glUniform3iv _gl_debug_error_glUniform3iv
void _gl_debug_error_glUniform3iv(GLint location, GLsizei count, const GLint *value);

#define glUniform4iv _gl_debug_error_glUniform4iv
void _gl_debug_error_glUniform4iv(GLint location, GLsizei count, const GLint *value);

#define glUniformMatrix2fv _gl_debug_error_glUniformMatrix2fv
void _gl_debug_error_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix3fv _gl_debug_error_glUniformMatrix3fv
void _gl_debug_error_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix4fv _gl_debug_error_glUniformMatrix4fv
void _gl_debug_error_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glIsShader _gl_debug_error_glIsShader
GLboolean _gl_debug_error_glIsShader(GLuint shader);

#define glIsProgram _gl_debug_error_glIsProgram
GLboolean _gl_debug_error_glIsProgram(GLuint program);

#define glGetShaderiv _gl_debug_error_glGetShaderiv
void _gl_debug_error_glGetShaderiv(GLuint shader, GLenum pname, GLint *params);

#define glGetProgramiv _gl_debug_error_glGetProgramiv
void _gl_debug_error_glGetProgramiv(GLuint program, GLenum pname, GLint *params);

#define glGetAttachedShaders _gl_debug_error_glGetAttachedShaders
void _gl_debug_error_glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);

#define glGetShaderInfoLog _gl_debug_error_glGetShaderInfoLog
void _gl_debug_error_glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

#define glGetProgramInfoLog _gl_debug_error_glGetProgramInfoLog
void _gl_debug_error_glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

#define glGetUniformLocation _gl_debug_error_glGetUniformLocation
GLint _gl_debug_error_glGetUniformLocation(GLuint program, const GLchar *name);

#define glGetActiveUniform _gl_debug_error_glGetActiveUniform
void _gl_debug_error_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

#define glGetUniformfv _gl_debug_error_glGetUniformfv
void _gl_debug_error_glGetUniformfv(GLuint program, GLint location, GLfloat *params);

#define glGetUniformiv _gl_debug_error_glGetUniformiv
void _gl_debug_error_glGetUniformiv(GLuint program, GLint location, GLint *params);

#define glGetShaderSource _gl_debug_error_glGetShaderSource
void _gl_debug_error_glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);

#define glBindAttribLocation _gl_debug_error_glBindAttribLocation
void _gl_debug_error_glBindAttribLocation(GLuint program, GLuint index, const GLchar *name);

#define glGetActiveAttrib _gl_debug_error_glGetActiveAttrib
void _gl_debug_error_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

#define glGetAttribLocation _gl_debug_error_glGetAttribLocation
GLint _gl_debug_error_glGetAttribLocation(GLuint program, const GLchar *name);

#define glStencilFuncSeparate _gl_debug_error_glStencilFuncSeparate
void _gl_debug_error_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

#define glStencilOpSeparate _gl_debug_error_glStencilOpSeparate
void _gl_debug_error_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

#define glStencilMaskSeparate _gl_debug_error_glStencilMaskSeparate
void _gl_debug_error_glStencilMaskSeparate(GLenum face, GLuint mask);

#define glUniformMatrix2x3fv _gl_debug_error_glUniformMatrix2x3fv
void _gl_debug_error_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix3x2fv _gl_debug_error_glUniformMatrix3x2fv
void _gl_debug_error_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix2x4fv _gl_debug_error_glUniformMatrix2x4fv
void _gl_debug_error_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix4x2fv _gl_debug_error_glUniformMatrix4x2fv
void _gl_debug_error_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix3x4fv _gl_debug_error_glUniformMatrix3x4fv
void _gl_debug_error_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

#define glUniformMatrix4x3fv _gl_debug_error_glUniformMatrix4x3fv
void _gl_debug_error_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);