Skip to content

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Wrapping OpenGL calls in error checks
#!/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))
/* 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();
}
/* 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);