ioq3quest/code/macosx/macosx_qgl.h

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
/**** This file is autogenerated.  Run GenerateQGL.pl to update it ****/

#ifdef QGL_LOG_GL_CALLS
extern unsigned int QGLLogGLCalls;
extern FILE *QGLDebugFile(void);
#endif

extern void QGLCheckError(const char *message);
extern unsigned int QGLBeginStarted;

// This has to be done to avoid infinite recursion between our glGetError wrapper and QGLCheckError()
static inline GLenum _glGetError(void) {
    return glGetError();
}

// void glAccum (GLenum op, GLfloat value);
static inline void qglAccum(GLenum op, GLfloat value)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glAccum(op=%lu, value=%f)\n", op, value);
#endif
    glAccum(op, value);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glAccum");
#endif
}

// void glAlphaFunc (GLenum func, GLclampf ref);
static inline void qglAlphaFunc(GLenum func, GLclampf ref)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glAlphaFunc(func=%lu, ref=%f)\n", func, ref);
#endif
    glAlphaFunc(func, ref);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glAlphaFunc");
#endif
}

// GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences);
static inline GLboolean qglAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
{
    GLboolean returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glAreTexturesResident(n=%ld, textures=%p, residences=%p)\n", n, textures, residences);
#endif
    returnValue = glAreTexturesResident(n, textures, residences);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glAreTexturesResident");
#endif
    return returnValue;
}

// void glArrayElement (GLint i);
static inline void qglArrayElement(GLint i)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glArrayElement(i=%ld)\n", i);
#endif
    glArrayElement(i);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glArrayElement");
#endif
}

// void glBegin (GLenum mode);
static inline void qglBegin(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBegin(mode=%lu)\n", mode);
#endif
    glBegin(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    QGLBeginStarted++;
    if (!QGLBeginStarted)
        QGLCheckError("glBegin");
#endif
}

// void glBindTexture (GLenum target, GLuint texture);
static inline void qglBindTexture(GLenum target, GLuint texture)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBindTexture(target=%lu, texture=%lu)\n", target, texture);
#endif
    glBindTexture(target, texture);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBindTexture");
#endif
}

// void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
static inline void qglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBitmap(width=%ld, height=%ld, xorig=%f, yorig=%f, xmove=%f, ymove=%f, bitmap=%p)\n", width, height, xorig, yorig, xmove, ymove, bitmap);
#endif
    glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBitmap");
#endif
}

// void glBlendFunc (GLenum sfactor, GLenum dfactor);
static inline void qglBlendFunc(GLenum sfactor, GLenum dfactor)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBlendFunc(sfactor=%lu, dfactor=%lu)\n", sfactor, dfactor);
#endif
    glBlendFunc(sfactor, dfactor);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBlendFunc");
#endif
}

// void glCallList (GLuint list);
static inline void qglCallList(GLuint list)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCallList(list=%lu)\n", list);
#endif
    glCallList(list);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCallList");
#endif
}

// void glCallLists (GLsizei n, GLenum type, const GLvoid *lists);
static inline void qglCallLists(GLsizei n, GLenum type, const GLvoid *lists)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCallLists(n=%ld, type=%lu, lists=%p)\n", n, type, lists);
#endif
    glCallLists(n, type, lists);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCallLists");
#endif
}

// void glClear (GLbitfield mask);
static inline void qglClear(GLbitfield mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClear(mask=%lu)\n", mask);
#endif
    glClear(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClear");
#endif
}

// void glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static inline void qglClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearAccum(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
#endif
    glClearAccum(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearAccum");
#endif
}

// void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
static inline void qglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearColor(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
#endif
    glClearColor(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearColor");
#endif
}

// void glClearDepth (GLclampd depth);
static inline void qglClearDepth(GLclampd depth)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearDepth(depth=%f)\n", depth);
#endif
    glClearDepth(depth);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearDepth");
#endif
}

// void glClearIndex (GLfloat c);
static inline void qglClearIndex(GLfloat c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearIndex(c=%f)\n", c);
#endif
    glClearIndex(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearIndex");
#endif
}

// void glClearStencil (GLint s);
static inline void qglClearStencil(GLint s)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearStencil(s=%ld)\n", s);
#endif
    glClearStencil(s);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearStencil");
#endif
}

// void glClipPlane (GLenum plane, const GLdouble *equation);
static inline void qglClipPlane(GLenum plane, const GLdouble *equation)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClipPlane(plane=%lu, equation=%p)\n", plane, equation);
#endif
    glClipPlane(plane, equation);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClipPlane");
#endif
}

// void glColor3b (GLbyte red, GLbyte green, GLbyte blue);
static inline void qglColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3b(red=%d, green=%d, blue=%d)\n", red, green, blue);
#endif
    glColor3b(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3b");
#endif
}

// void glColor3bv (const GLbyte *v);
static inline void qglColor3bv(const GLbyte *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3bv(v=%p)\n", v);
#endif
    glColor3bv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3bv");
#endif
}

// void glColor3d (GLdouble red, GLdouble green, GLdouble blue);
static inline void qglColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3d(red=%f, green=%f, blue=%f)\n", red, green, blue);
#endif
    glColor3d(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3d");
#endif
}

// void glColor3dv (const GLdouble *v);
static inline void qglColor3dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3dv(v=%p)\n", v);
#endif
    glColor3dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3dv");
#endif
}

// void glColor3f (GLfloat red, GLfloat green, GLfloat blue);
static inline void qglColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3f(red=%f, green=%f, blue=%f)\n", red, green, blue);
#endif
    glColor3f(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3f");
#endif
}

// void glColor3fv (const GLfloat *v);
static inline void qglColor3fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3fv(v=%p)\n", v);
#endif
    glColor3fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3fv");
#endif
}

// void glColor3i (GLint red, GLint green, GLint blue);
static inline void qglColor3i(GLint red, GLint green, GLint blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3i(red=%ld, green=%ld, blue=%ld)\n", red, green, blue);
#endif
    glColor3i(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3i");
#endif
}

// void glColor3iv (const GLint *v);
static inline void qglColor3iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3iv(v=%p)\n", v);
#endif
    glColor3iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3iv");
#endif
}

// void glColor3s (GLshort red, GLshort green, GLshort blue);
static inline void qglColor3s(GLshort red, GLshort green, GLshort blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3s(red=%d, green=%d, blue=%d)\n", red, green, blue);
#endif
    glColor3s(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3s");
#endif
}

// void glColor3sv (const GLshort *v);
static inline void qglColor3sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3sv(v=%p)\n", v);
#endif
    glColor3sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3sv");
#endif
}

// void glColor3ub (GLubyte red, GLubyte green, GLubyte blue);
static inline void qglColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3ub(red=%u, green=%u, blue=%u)\n", red, green, blue);
#endif
    glColor3ub(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3ub");
#endif
}

// void glColor3ubv (const GLubyte *v);
static inline void qglColor3ubv(const GLubyte *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3ubv(v=%p)\n", v);
#endif
    glColor3ubv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3ubv");
#endif
}

// void glColor3ui (GLuint red, GLuint green, GLuint blue);
static inline void qglColor3ui(GLuint red, GLuint green, GLuint blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3ui(red=%lu, green=%lu, blue=%lu)\n", red, green, blue);
#endif
    glColor3ui(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3ui");
#endif
}

// void glColor3uiv (const GLuint *v);
static inline void qglColor3uiv(const GLuint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3uiv(v=%p)\n", v);
#endif
    glColor3uiv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3uiv");
#endif
}

// void glColor3us (GLushort red, GLushort green, GLushort blue);
static inline void qglColor3us(GLushort red, GLushort green, GLushort blue)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3us(red=%u, green=%u, blue=%u)\n", red, green, blue);
#endif
    glColor3us(red, green, blue);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3us");
#endif
}

// void glColor3usv (const GLushort *v);
static inline void qglColor3usv(const GLushort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor3usv(v=%p)\n", v);
#endif
    glColor3usv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor3usv");
#endif
}

// void glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
static inline void qglColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4b(red=%d, green=%d, blue=%d, alpha=%d)\n", red, green, blue, alpha);
#endif
    glColor4b(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4b");
#endif
}

// void glColor4bv (const GLbyte *v);
static inline void qglColor4bv(const GLbyte *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4bv(v=%p)\n", v);
#endif
    glColor4bv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4bv");
#endif
}

// void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
static inline void qglColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4d(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
#endif
    glColor4d(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4d");
#endif
}

// void glColor4dv (const GLdouble *v);
static inline void qglColor4dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4dv(v=%p)\n", v);
#endif
    glColor4dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4dv");
#endif
}

// void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
static inline void qglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4f(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
#endif
    glColor4f(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4f");
#endif
}

// void glColor4fv (const GLfloat *v);
static inline void qglColor4fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4fv(v=%p)\n", v);
#endif
    glColor4fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4fv");
#endif
}

// void glColor4i (GLint red, GLint green, GLint blue, GLint alpha);
static inline void qglColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4i(red=%ld, green=%ld, blue=%ld, alpha=%ld)\n", red, green, blue, alpha);
#endif
    glColor4i(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4i");
#endif
}

// void glColor4iv (const GLint *v);
static inline void qglColor4iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4iv(v=%p)\n", v);
#endif
    glColor4iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4iv");
#endif
}

// void glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha);
static inline void qglColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4s(red=%d, green=%d, blue=%d, alpha=%d)\n", red, green, blue, alpha);
#endif
    glColor4s(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4s");
#endif
}

// void glColor4sv (const GLshort *v);
static inline void qglColor4sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4sv(v=%p)\n", v);
#endif
    glColor4sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4sv");
#endif
}

// void glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
static inline void qglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4ub(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
#endif
    glColor4ub(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4ub");
#endif
}

// void glColor4ubv (const GLubyte *v);
static inline void qglColor4ubv(const GLubyte *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4ubv(v=%p)\n", v);
#endif
    glColor4ubv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4ubv");
#endif
}

// void glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha);
static inline void qglColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4ui(red=%lu, green=%lu, blue=%lu, alpha=%lu)\n", red, green, blue, alpha);
#endif
    glColor4ui(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4ui");
#endif
}

// void glColor4uiv (const GLuint *v);
static inline void qglColor4uiv(const GLuint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4uiv(v=%p)\n", v);
#endif
    glColor4uiv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4uiv");
#endif
}

// void glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha);
static inline void qglColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4us(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
#endif
    glColor4us(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4us");
#endif
}

// void glColor4usv (const GLushort *v);
static inline void qglColor4usv(const GLushort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4usv(v=%p)\n", v);
#endif
    glColor4usv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4usv");
#endif
}

// void glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
static inline void qglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColorMask(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
#endif
    glColorMask(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColorMask");
#endif
}

// void glColorMaterial (GLenum face, GLenum mode);
static inline void qglColorMaterial(GLenum face, GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColorMaterial(face=%lu, mode=%lu)\n", face, mode);
#endif
    glColorMaterial(face, mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColorMaterial");
#endif
}

// void glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static inline void qglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColorPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
#endif
    glColorPointer(size, type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColorPointer");
#endif
}

// void glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
static inline void qglCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCopyPixels(x=%ld, y=%ld, width=%ld, height=%ld, type=%lu)\n", x, y, width, height, type);
#endif
    glCopyPixels(x, y, width, height, type);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCopyPixels");
#endif
}

// void glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
static inline void qglCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCopyTexImage1D(target=%lu, level=%ld, internalFormat=%lu, x=%ld, y=%ld, width=%ld, border=%ld)\n", target, level, internalFormat, x, y, width, border);
#endif
    glCopyTexImage1D(target, level, internalFormat, x, y, width, border);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCopyTexImage1D");
#endif
}

// void glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
static inline void qglCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCopyTexImage2D(target=%lu, level=%ld, internalFormat=%lu, x=%ld, y=%ld, width=%ld, height=%ld, border=%ld)\n", target, level, internalFormat, x, y, width, height, border);
#endif
    glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCopyTexImage2D");
#endif
}

// void glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
static inline void qglCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCopyTexSubImage1D(target=%lu, level=%ld, xoffset=%ld, x=%ld, y=%ld, width=%ld)\n", target, level, xoffset, x, y, width);
#endif
    glCopyTexSubImage1D(target, level, xoffset, x, y, width);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCopyTexSubImage1D");
#endif
}

// void glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
static inline void qglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCopyTexSubImage2D(target=%lu, level=%ld, xoffset=%ld, yoffset=%ld, x=%ld, y=%ld, width=%ld, height=%ld)\n", target, level, xoffset, yoffset, x, y, width, height);
#endif
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCopyTexSubImage2D");
#endif
}

// void glCullFace (GLenum mode);
static inline void qglCullFace(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCullFace(mode=%lu)\n", mode);
#endif
    glCullFace(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCullFace");
#endif
}

// void glDeleteLists (GLuint list, GLsizei range);
static inline void qglDeleteLists(GLuint list, GLsizei range)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDeleteLists(list=%lu, range=%ld)\n", list, range);
#endif
    glDeleteLists(list, range);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDeleteLists");
#endif
}

// void glDeleteTextures (GLsizei n, const GLuint *textures);
static inline void qglDeleteTextures(GLsizei n, const GLuint *textures)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDeleteTextures(n=%ld, textures=%p)\n", n, textures);
#endif
    glDeleteTextures(n, textures);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDeleteTextures");
#endif
}

// void glDepthFunc (GLenum func);
static inline void qglDepthFunc(GLenum func)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthFunc(func=%lu)\n", func);
#endif
    glDepthFunc(func);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDepthFunc");
#endif
}

// void glDepthMask (GLboolean flag);
static inline void qglDepthMask(GLboolean flag)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthMask(flag=%u)\n", flag);
#endif
    glDepthMask(flag);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDepthMask");
#endif
}

// void glDepthRange (GLclampd zNear, GLclampd zFar);
static inline void qglDepthRange(GLclampd zNear, GLclampd zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthRange(zNear=%f, zFar=%f)\n", zNear, zFar);
#endif
    glDepthRange(zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDepthRange");
#endif
}

// void glDisable (GLenum cap);
static inline void qglDisable(GLenum cap)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDisable(cap=%lu)\n", cap);
#endif
    glDisable(cap);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDisable");
#endif
}

// void glDisableClientState (GLenum array);
static inline void qglDisableClientState(GLenum array)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDisableClientState(array=%lu)\n", array);
#endif
    glDisableClientState(array);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDisableClientState");
#endif
}

// void glDrawArrays (GLenum mode, GLint first, GLsizei count);
static inline void qglDrawArrays(GLenum mode, GLint first, GLsizei count)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDrawArrays(mode=%lu, first=%ld, count=%ld)\n", mode, first, count);
#endif
    glDrawArrays(mode, first, count);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawArrays");
#endif
}

// void glDrawBuffer (GLenum mode);
static inline void qglDrawBuffer(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDrawBuffer(mode=%lu)\n", mode);
#endif
    glDrawBuffer(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawBuffer");
#endif
}

// void glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
static inline void qglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDrawElements(mode=%lu, count=%ld, type=%lu, indices=%p)\n", mode, count, type, indices);
#endif
    glDrawElements(mode, count, type, indices);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawElements");
#endif
}

// void glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static inline void qglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDrawPixels(width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", width, height, format, type, pixels);
#endif
    glDrawPixels(width, height, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawPixels");
#endif
}

// void glEdgeFlag (GLboolean flag);
static inline void qglEdgeFlag(GLboolean flag)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEdgeFlag(flag=%u)\n", flag);
#endif
    glEdgeFlag(flag);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEdgeFlag");
#endif
}

// void glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer);
static inline void qglEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEdgeFlagPointer(stride=%ld, pointer=%p)\n", stride, pointer);
#endif
    glEdgeFlagPointer(stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEdgeFlagPointer");
#endif
}

// void glEdgeFlagv (const GLboolean *flag);
static inline void qglEdgeFlagv(const GLboolean *flag)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEdgeFlagv(flag=%p)\n", flag);
#endif
    glEdgeFlagv(flag);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEdgeFlagv");
#endif
}

// void glEnable (GLenum cap);
static inline void qglEnable(GLenum cap)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEnable(cap=%lu)\n", cap);
#endif
    glEnable(cap);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEnable");
#endif
}

// void glEnableClientState (GLenum array);
static inline void qglEnableClientState(GLenum array)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEnableClientState(array=%lu)\n", array);
#endif
    glEnableClientState(array);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEnableClientState");
#endif
}

// void glEnd (void);
static inline void qglEnd(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEnd(void)\n");
#endif
    glEnd();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    QGLBeginStarted--;
    if (!QGLBeginStarted)
        QGLCheckError("glEnd");
#endif
}

// void glEndList (void);
static inline void qglEndList(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEndList(void)\n");
#endif
    glEndList();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEndList");
#endif
}

// void glEvalCoord1d (GLdouble u);
static inline void qglEvalCoord1d(GLdouble u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord1d(u=%f)\n", u);
#endif
    glEvalCoord1d(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord1d");
#endif
}

// void glEvalCoord1dv (const GLdouble *u);
static inline void qglEvalCoord1dv(const GLdouble *u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord1dv(u=%p)\n", u);
#endif
    glEvalCoord1dv(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord1dv");
#endif
}

// void glEvalCoord1f (GLfloat u);
static inline void qglEvalCoord1f(GLfloat u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord1f(u=%f)\n", u);
#endif
    glEvalCoord1f(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord1f");
#endif
}

// void glEvalCoord1fv (const GLfloat *u);
static inline void qglEvalCoord1fv(const GLfloat *u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord1fv(u=%p)\n", u);
#endif
    glEvalCoord1fv(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord1fv");
#endif
}

// void glEvalCoord2d (GLdouble u, GLdouble v);
static inline void qglEvalCoord2d(GLdouble u, GLdouble v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord2d(u=%f, v=%f)\n", u, v);
#endif
    glEvalCoord2d(u, v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord2d");
#endif
}

// void glEvalCoord2dv (const GLdouble *u);
static inline void qglEvalCoord2dv(const GLdouble *u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord2dv(u=%p)\n", u);
#endif
    glEvalCoord2dv(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord2dv");
#endif
}

// void glEvalCoord2f (GLfloat u, GLfloat v);
static inline void qglEvalCoord2f(GLfloat u, GLfloat v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord2f(u=%f, v=%f)\n", u, v);
#endif
    glEvalCoord2f(u, v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord2f");
#endif
}

// void glEvalCoord2fv (const GLfloat *u);
static inline void qglEvalCoord2fv(const GLfloat *u)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalCoord2fv(u=%p)\n", u);
#endif
    glEvalCoord2fv(u);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalCoord2fv");
#endif
}

// void glEvalMesh1 (GLenum mode, GLint i1, GLint i2);
static inline void qglEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalMesh1(mode=%lu, i1=%ld, i2=%ld)\n", mode, i1, i2);
#endif
    glEvalMesh1(mode, i1, i2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalMesh1");
#endif
}

// void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
static inline void qglEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalMesh2(mode=%lu, i1=%ld, i2=%ld, j1=%ld, j2=%ld)\n", mode, i1, i2, j1, j2);
#endif
    glEvalMesh2(mode, i1, i2, j1, j2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalMesh2");
#endif
}

// void glEvalPoint1 (GLint i);
static inline void qglEvalPoint1(GLint i)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalPoint1(i=%ld)\n", i);
#endif
    glEvalPoint1(i);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalPoint1");
#endif
}

// void glEvalPoint2 (GLint i, GLint j);
static inline void qglEvalPoint2(GLint i, GLint j)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glEvalPoint2(i=%ld, j=%ld)\n", i, j);
#endif
    glEvalPoint2(i, j);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEvalPoint2");
#endif
}

// void glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer);
static inline void qglFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFeedbackBuffer(size=%ld, type=%lu, buffer=%p)\n", size, type, buffer);
#endif
    glFeedbackBuffer(size, type, buffer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFeedbackBuffer");
#endif
}

// void glFinish (void);
static inline void qglFinish(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFinish(void)\n");
#endif
    glFinish();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFinish");
#endif
}

// void glFlush (void);
static inline void qglFlush(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFlush(void)\n");
#endif
    glFlush();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFlush");
#endif
}

// void glFogf (GLenum pname, GLfloat param);
static inline void qglFogf(GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogf(pname=%lu, param=%f)\n", pname, param);
#endif
    glFogf(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogf");
#endif
}

// void glFogfv (GLenum pname, const GLfloat *params);
static inline void qglFogfv(GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogfv(pname=%lu, params=%p)\n", pname, params);
#endif
    glFogfv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogfv");
#endif
}

// void glFogi (GLenum pname, GLint param);
static inline void qglFogi(GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogi(pname=%lu, param=%ld)\n", pname, param);
#endif
    glFogi(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogi");
#endif
}

// void glFogiv (GLenum pname, const GLint *params);
static inline void qglFogiv(GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogiv(pname=%lu, params=%p)\n", pname, params);
#endif
    glFogiv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogiv");
#endif
}

// void glFrontFace (GLenum mode);
static inline void qglFrontFace(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFrontFace(mode=%lu)\n", mode);
#endif
    glFrontFace(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFrontFace");
#endif
}

// void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
static inline void qglFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFrustum(left=%f, right=%f, bottom=%f, top=%f, zNear=%f, zFar=%f)\n", left, right, bottom, top, zNear, zFar);
#endif
    glFrustum(left, right, bottom, top, zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFrustum");
#endif
}

// GLuint glGenLists (GLsizei range);
static inline GLuint qglGenLists(GLsizei range)
{
    GLuint returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGenLists(range=%ld)\n", range);
#endif
    returnValue = glGenLists(range);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGenLists");
#endif
    return returnValue;
}

// void glGenTextures (GLsizei n, GLuint *textures);
static inline void qglGenTextures(GLsizei n, GLuint *textures)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGenTextures(n=%ld, textures=%p)\n", n, textures);
#endif
    glGenTextures(n, textures);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGenTextures");
#endif
}

// void glGetBooleanv (GLenum pname, GLboolean *params);
static inline void qglGetBooleanv(GLenum pname, GLboolean *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetBooleanv(pname=%lu, params=%p)\n", pname, params);
#endif
    glGetBooleanv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetBooleanv");
#endif
}

// void glGetClipPlane (GLenum plane, GLdouble *equation);
static inline void qglGetClipPlane(GLenum plane, GLdouble *equation)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetClipPlane(plane=%lu, equation=%p)\n", plane, equation);
#endif
    glGetClipPlane(plane, equation);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetClipPlane");
#endif
}

// void glGetDoublev (GLenum pname, GLdouble *params);
static inline void qglGetDoublev(GLenum pname, GLdouble *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetDoublev(pname=%lu, params=%p)\n", pname, params);
#endif
    glGetDoublev(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetDoublev");
#endif
}

// GLenum glGetError (void);
static inline GLenum qglGetError(void)
{
    GLenum returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetError(void)\n");
#endif
    returnValue = glGetError();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetError");
#endif
    return returnValue;
}

// void glGetFloatv (GLenum pname, GLfloat *params);
static inline void qglGetFloatv(GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetFloatv(pname=%lu, params=%p)\n", pname, params);
#endif
    glGetFloatv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetFloatv");
#endif
}

// void glGetIntegerv (GLenum pname, GLint *params);
static inline void qglGetIntegerv(GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetIntegerv(pname=%lu, params=%p)\n", pname, params);
#endif
    glGetIntegerv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetIntegerv");
#endif
}

// void glGetLightfv (GLenum light, GLenum pname, GLfloat *params);
static inline void qglGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetLightfv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
#endif
    glGetLightfv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetLightfv");
#endif
}

// void glGetLightiv (GLenum light, GLenum pname, GLint *params);
static inline void qglGetLightiv(GLenum light, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetLightiv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
#endif
    glGetLightiv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetLightiv");
#endif
}

// void glGetMapdv (GLenum target, GLenum query, GLdouble *v);
static inline void qglGetMapdv(GLenum target, GLenum query, GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMapdv(target=%lu, query=%lu, v=%p)\n", target, query, v);
#endif
    glGetMapdv(target, query, v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMapdv");
#endif
}

// void glGetMapfv (GLenum target, GLenum query, GLfloat *v);
static inline void qglGetMapfv(GLenum target, GLenum query, GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMapfv(target=%lu, query=%lu, v=%p)\n", target, query, v);
#endif
    glGetMapfv(target, query, v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMapfv");
#endif
}

// void glGetMapiv (GLenum target, GLenum query, GLint *v);
static inline void qglGetMapiv(GLenum target, GLenum query, GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMapiv(target=%lu, query=%lu, v=%p)\n", target, query, v);
#endif
    glGetMapiv(target, query, v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMapiv");
#endif
}

// void glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params);
static inline void qglGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMaterialfv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
#endif
    glGetMaterialfv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMaterialfv");
#endif
}

// void glGetMaterialiv (GLenum face, GLenum pname, GLint *params);
static inline void qglGetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMaterialiv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
#endif
    glGetMaterialiv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMaterialiv");
#endif
}

// void glGetPixelMapfv (GLenum map, GLfloat *values);
static inline void qglGetPixelMapfv(GLenum map, GLfloat *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPixelMapfv(map=%lu, values=%p)\n", map, values);
#endif
    glGetPixelMapfv(map, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPixelMapfv");
#endif
}

// void glGetPixelMapuiv (GLenum map, GLuint *values);
static inline void qglGetPixelMapuiv(GLenum map, GLuint *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPixelMapuiv(map=%lu, values=%p)\n", map, values);
#endif
    glGetPixelMapuiv(map, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPixelMapuiv");
#endif
}

// void glGetPixelMapusv (GLenum map, GLushort *values);
static inline void qglGetPixelMapusv(GLenum map, GLushort *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPixelMapusv(map=%lu, values=%p)\n", map, values);
#endif
    glGetPixelMapusv(map, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPixelMapusv");
#endif
}

// void glGetPointerv (GLenum pname, GLvoid* *params);
static inline void qglGetPointerv(GLenum pname, GLvoid* *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPointerv(pname=%lu, params=%p)\n", pname, params);
#endif
    glGetPointerv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPointerv");
#endif
}

// void glGetPolygonStipple (GLubyte *mask);
static inline void qglGetPolygonStipple(GLubyte *mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPolygonStipple(mask=%p)\n", mask);
#endif
    glGetPolygonStipple(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPolygonStipple");
#endif
}

// const GLubyte * glGetString (GLenum name);
static inline const GLubyte * qglGetString(GLenum name)
{
    const GLubyte * returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetString(name=%lu)\n", name);
#endif
    returnValue = glGetString(name);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetString");
#endif
    return returnValue;
}

// void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);
static inline void qglGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexEnvfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glGetTexEnvfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexEnvfv");
#endif
}

// void glGetTexEnviv (GLenum target, GLenum pname, GLint *params);
static inline void qglGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexEnviv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glGetTexEnviv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexEnviv");
#endif
}

// void glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);
static inline void qglGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexGendv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glGetTexGendv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexGendv");
#endif
}

// void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);
static inline void qglGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexGenfv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glGetTexGenfv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexGenfv");
#endif
}

// void glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);
static inline void qglGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexGeniv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glGetTexGeniv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexGeniv");
#endif
}

// void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
static inline void qglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexImage(target=%lu, level=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, format, type, pixels);
#endif
    glGetTexImage(target, level, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexImage");
#endif
}

// void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
static inline void qglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexLevelParameterfv(target=%lu, level=%ld, pname=%lu, params=%p)\n", target, level, pname, params);
#endif
    glGetTexLevelParameterfv(target, level, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexLevelParameterfv");
#endif
}

// void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
static inline void qglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexLevelParameteriv(target=%lu, level=%ld, pname=%lu, params=%p)\n", target, level, pname, params);
#endif
    glGetTexLevelParameteriv(target, level, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexLevelParameteriv");
#endif
}

// void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params);
static inline void qglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexParameterfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glGetTexParameterfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexParameterfv");
#endif
}

// void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params);
static inline void qglGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexParameteriv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glGetTexParameteriv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexParameteriv");
#endif
}

// void glHint (GLenum target, GLenum mode);
static inline void qglHint(GLenum target, GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glHint(target=%lu, mode=%lu)\n", target, mode);
#endif
    glHint(target, mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glHint");
#endif
}

// void glIndexMask (GLuint mask);
static inline void qglIndexMask(GLuint mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexMask(mask=%lu)\n", mask);
#endif
    glIndexMask(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexMask");
#endif
}

// void glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
static inline void qglIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexPointer(type=%lu, stride=%ld, pointer=%p)\n", type, stride, pointer);
#endif
    glIndexPointer(type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexPointer");
#endif
}

// void glIndexd (GLdouble c);
static inline void qglIndexd(GLdouble c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexd(c=%f)\n", c);
#endif
    glIndexd(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexd");
#endif
}

// void glIndexdv (const GLdouble *c);
static inline void qglIndexdv(const GLdouble *c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexdv(c=%p)\n", c);
#endif
    glIndexdv(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexdv");
#endif
}

// void glIndexf (GLfloat c);
static inline void qglIndexf(GLfloat c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexf(c=%f)\n", c);
#endif
    glIndexf(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexf");
#endif
}

// void glIndexfv (const GLfloat *c);
static inline void qglIndexfv(const GLfloat *c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexfv(c=%p)\n", c);
#endif
    glIndexfv(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexfv");
#endif
}

// void glIndexi (GLint c);
static inline void qglIndexi(GLint c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexi(c=%ld)\n", c);
#endif
    glIndexi(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexi");
#endif
}

// void glIndexiv (const GLint *c);
static inline void qglIndexiv(const GLint *c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexiv(c=%p)\n", c);
#endif
    glIndexiv(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexiv");
#endif
}

// void glIndexs (GLshort c);
static inline void qglIndexs(GLshort c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexs(c=%d)\n", c);
#endif
    glIndexs(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexs");
#endif
}

// void glIndexsv (const GLshort *c);
static inline void qglIndexsv(const GLshort *c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexsv(c=%p)\n", c);
#endif
    glIndexsv(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexsv");
#endif
}

// void glIndexub (GLubyte c);
static inline void qglIndexub(GLubyte c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexub(c=%u)\n", c);
#endif
    glIndexub(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexub");
#endif
}

// void glIndexubv (const GLubyte *c);
static inline void qglIndexubv(const GLubyte *c)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIndexubv(c=%p)\n", c);
#endif
    glIndexubv(c);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIndexubv");
#endif
}

// void glInitNames (void);
static inline void qglInitNames(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glInitNames(void)\n");
#endif
    glInitNames();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glInitNames");
#endif
}

// void glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer);
static inline void qglInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glInterleavedArrays(format=%lu, stride=%ld, pointer=%p)\n", format, stride, pointer);
#endif
    glInterleavedArrays(format, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glInterleavedArrays");
#endif
}

// GLboolean glIsEnabled (GLenum cap);
static inline GLboolean qglIsEnabled(GLenum cap)
{
    GLboolean returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIsEnabled(cap=%lu)\n", cap);
#endif
    returnValue = glIsEnabled(cap);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIsEnabled");
#endif
    return returnValue;
}

// GLboolean glIsList (GLuint list);
static inline GLboolean qglIsList(GLuint list)
{
    GLboolean returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIsList(list=%lu)\n", list);
#endif
    returnValue = glIsList(list);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIsList");
#endif
    return returnValue;
}

// GLboolean glIsTexture (GLuint texture);
static inline GLboolean qglIsTexture(GLuint texture)
{
    GLboolean returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glIsTexture(texture=%lu)\n", texture);
#endif
    returnValue = glIsTexture(texture);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIsTexture");
#endif
    return returnValue;
}

// void glLightModelf (GLenum pname, GLfloat param);
static inline void qglLightModelf(GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModelf(pname=%lu, param=%f)\n", pname, param);
#endif
    glLightModelf(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModelf");
#endif
}

// void glLightModelfv (GLenum pname, const GLfloat *params);
static inline void qglLightModelfv(GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModelfv(pname=%lu, params=%p)\n", pname, params);
#endif
    glLightModelfv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModelfv");
#endif
}

// void glLightModeli (GLenum pname, GLint param);
static inline void qglLightModeli(GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModeli(pname=%lu, param=%ld)\n", pname, param);
#endif
    glLightModeli(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModeli");
#endif
}

// void glLightModeliv (GLenum pname, const GLint *params);
static inline void qglLightModeliv(GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModeliv(pname=%lu, params=%p)\n", pname, params);
#endif
    glLightModeliv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModeliv");
#endif
}

// void glLightf (GLenum light, GLenum pname, GLfloat param);
static inline void qglLightf(GLenum light, GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightf(light=%lu, pname=%lu, param=%f)\n", light, pname, param);
#endif
    glLightf(light, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightf");
#endif
}

// void glLightfv (GLenum light, GLenum pname, const GLfloat *params);
static inline void qglLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightfv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
#endif
    glLightfv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightfv");
#endif
}

// void glLighti (GLenum light, GLenum pname, GLint param);
static inline void qglLighti(GLenum light, GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLighti(light=%lu, pname=%lu, param=%ld)\n", light, pname, param);
#endif
    glLighti(light, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLighti");
#endif
}

// void glLightiv (GLenum light, GLenum pname, const GLint *params);
static inline void qglLightiv(GLenum light, GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightiv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
#endif
    glLightiv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightiv");
#endif
}

// void glLineStipple (GLint factor, GLushort pattern);
static inline void qglLineStipple(GLint factor, GLushort pattern)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLineStipple(factor=%ld, pattern=%u)\n", factor, pattern);
#endif
    glLineStipple(factor, pattern);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLineStipple");
#endif
}

// void glLineWidth (GLfloat width);
static inline void qglLineWidth(GLfloat width)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLineWidth(width=%f)\n", width);
#endif
    glLineWidth(width);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLineWidth");
#endif
}

// void glListBase (GLuint base);
static inline void qglListBase(GLuint base)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glListBase(base=%lu)\n", base);
#endif
    glListBase(base);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glListBase");
#endif
}

// void glLoadIdentity (void);
static inline void qglLoadIdentity(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLoadIdentity(void)\n");
#endif
    glLoadIdentity();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLoadIdentity");
#endif
}

// void glLoadMatrixd (const GLdouble *m);
static inline void qglLoadMatrixd(const GLdouble *m)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLoadMatrixd(m=%p)\n", m);
#endif
    glLoadMatrixd(m);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLoadMatrixd");
#endif
}

// void glLoadMatrixf (const GLfloat *m);
static inline void qglLoadMatrixf(const GLfloat *m)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLoadMatrixf(m=%p)\n", m);
#endif
    glLoadMatrixf(m);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLoadMatrixf");
#endif
}

// void glLoadName (GLuint name);
static inline void qglLoadName(GLuint name)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLoadName(name=%lu)\n", name);
#endif
    glLoadName(name);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLoadName");
#endif
}

// void glLogicOp (GLenum opcode);
static inline void qglLogicOp(GLenum opcode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLogicOp(opcode=%lu)\n", opcode);
#endif
    glLogicOp(opcode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLogicOp");
#endif
}

// void glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
static inline void qglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMap1d(target=%lu, u1=%f, u2=%f, stride=%ld, order=%ld, points=%p)\n", target, u1, u2, stride, order, points);
#endif
    glMap1d(target, u1, u2, stride, order, points);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMap1d");
#endif
}

// void glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
static inline void qglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMap1f(target=%lu, u1=%f, u2=%f, stride=%ld, order=%ld, points=%p)\n", target, u1, u2, stride, order, points);
#endif
    glMap1f(target, u1, u2, stride, order, points);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMap1f");
#endif
}

// void glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
static inline void qglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMap2d(target=%lu, u1=%f, u2=%f, ustride=%ld, uorder=%ld, v1=%f, v2=%f, vstride=%ld, vorder=%ld, points=%p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
#endif
    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMap2d");
#endif
}

// void glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
static inline void qglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMap2f(target=%lu, u1=%f, u2=%f, ustride=%ld, uorder=%ld, v1=%f, v2=%f, vstride=%ld, vorder=%ld, points=%p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
#endif
    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMap2f");
#endif
}

// void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2);
static inline void qglMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMapGrid1d(un=%ld, u1=%f, u2=%f)\n", un, u1, u2);
#endif
    glMapGrid1d(un, u1, u2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMapGrid1d");
#endif
}

// void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2);
static inline void qglMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMapGrid1f(un=%ld, u1=%f, u2=%f)\n", un, u1, u2);
#endif
    glMapGrid1f(un, u1, u2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMapGrid1f");
#endif
}

// void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
static inline void qglMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMapGrid2d(un=%ld, u1=%f, u2=%f, vn=%ld, v1=%f, v2=%f)\n", un, u1, u2, vn, v1, v2);
#endif
    glMapGrid2d(un, u1, u2, vn, v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMapGrid2d");
#endif
}

// void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
static inline void qglMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMapGrid2f(un=%ld, u1=%f, u2=%f, vn=%ld, v1=%f, v2=%f)\n", un, u1, u2, vn, v1, v2);
#endif
    glMapGrid2f(un, u1, u2, vn, v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMapGrid2f");
#endif
}

// void glMaterialf (GLenum face, GLenum pname, GLfloat param);
static inline void qglMaterialf(GLenum face, GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMaterialf(face=%lu, pname=%lu, param=%f)\n", face, pname, param);
#endif
    glMaterialf(face, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialf");
#endif
}

// void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
static inline void qglMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMaterialfv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
#endif
    glMaterialfv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialfv");
#endif
}

// void glMateriali (GLenum face, GLenum pname, GLint param);
static inline void qglMateriali(GLenum face, GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMateriali(face=%lu, pname=%lu, param=%ld)\n", face, pname, param);
#endif
    glMateriali(face, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMateriali");
#endif
}

// void glMaterialiv (GLenum face, GLenum pname, const GLint *params);
static inline void qglMaterialiv(GLenum face, GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMaterialiv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
#endif
    glMaterialiv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialiv");
#endif
}

// void glMatrixMode (GLenum mode);
static inline void qglMatrixMode(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMatrixMode(mode=%lu)\n", mode);
#endif
    glMatrixMode(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMatrixMode");
#endif
}

// void glMultMatrixd (const GLdouble *m);
static inline void qglMultMatrixd(const GLdouble *m)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMultMatrixd(m=%p)\n", m);
#endif
    glMultMatrixd(m);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMultMatrixd");
#endif
}

// void glMultMatrixf (const GLfloat *m);
static inline void qglMultMatrixf(const GLfloat *m)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMultMatrixf(m=%p)\n", m);
#endif
    glMultMatrixf(m);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMultMatrixf");
#endif
}

// void glNewList (GLuint list, GLenum mode);
static inline void qglNewList(GLuint list, GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNewList(list=%lu, mode=%lu)\n", list, mode);
#endif
    glNewList(list, mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNewList");
#endif
}

// void glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz);
static inline void qglNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3b(nx=%d, ny=%d, nz=%d)\n", nx, ny, nz);
#endif
    glNormal3b(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3b");
#endif
}

// void glNormal3bv (const GLbyte *v);
static inline void qglNormal3bv(const GLbyte *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3bv(v=%p)\n", v);
#endif
    glNormal3bv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3bv");
#endif
}

// void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz);
static inline void qglNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3d(nx=%f, ny=%f, nz=%f)\n", nx, ny, nz);
#endif
    glNormal3d(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3d");
#endif
}

// void glNormal3dv (const GLdouble *v);
static inline void qglNormal3dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3dv(v=%p)\n", v);
#endif
    glNormal3dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3dv");
#endif
}

// void glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz);
static inline void qglNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3f(nx=%f, ny=%f, nz=%f)\n", nx, ny, nz);
#endif
    glNormal3f(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3f");
#endif
}

// void glNormal3fv (const GLfloat *v);
static inline void qglNormal3fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3fv(v=%p)\n", v);
#endif
    glNormal3fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3fv");
#endif
}

// void glNormal3i (GLint nx, GLint ny, GLint nz);
static inline void qglNormal3i(GLint nx, GLint ny, GLint nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3i(nx=%ld, ny=%ld, nz=%ld)\n", nx, ny, nz);
#endif
    glNormal3i(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3i");
#endif
}

// void glNormal3iv (const GLint *v);
static inline void qglNormal3iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3iv(v=%p)\n", v);
#endif
    glNormal3iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3iv");
#endif
}

// void glNormal3s (GLshort nx, GLshort ny, GLshort nz);
static inline void qglNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3s(nx=%d, ny=%d, nz=%d)\n", nx, ny, nz);
#endif
    glNormal3s(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3s");
#endif
}

// void glNormal3sv (const GLshort *v);
static inline void qglNormal3sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3sv(v=%p)\n", v);
#endif
    glNormal3sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3sv");
#endif
}

// void glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
static inline void qglNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormalPointer(type=%lu, stride=%ld, pointer=%p)\n", type, stride, pointer);
#endif
    glNormalPointer(type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormalPointer");
#endif
}

// void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
static inline void qglOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glOrtho(left=%f, right=%f, bottom=%f, top=%f, zNear=%f, zFar=%f)\n", left, right, bottom, top, zNear, zFar);
#endif
    glOrtho(left, right, bottom, top, zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glOrtho");
#endif
}

// void glPassThrough (GLfloat token);
static inline void qglPassThrough(GLfloat token)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPassThrough(token=%f)\n", token);
#endif
    glPassThrough(token);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPassThrough");
#endif
}

// void glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values);
static inline void qglPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelMapfv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
#endif
    glPixelMapfv(map, mapsize, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelMapfv");
#endif
}

// void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values);
static inline void qglPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelMapuiv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
#endif
    glPixelMapuiv(map, mapsize, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelMapuiv");
#endif
}

// void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values);
static inline void qglPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelMapusv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
#endif
    glPixelMapusv(map, mapsize, values);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelMapusv");
#endif
}

// void glPixelStoref (GLenum pname, GLfloat param);
static inline void qglPixelStoref(GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelStoref(pname=%lu, param=%f)\n", pname, param);
#endif
    glPixelStoref(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelStoref");
#endif
}

// void glPixelStorei (GLenum pname, GLint param);
static inline void qglPixelStorei(GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelStorei(pname=%lu, param=%ld)\n", pname, param);
#endif
    glPixelStorei(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelStorei");
#endif
}

// void glPixelTransferf (GLenum pname, GLfloat param);
static inline void qglPixelTransferf(GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelTransferf(pname=%lu, param=%f)\n", pname, param);
#endif
    glPixelTransferf(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelTransferf");
#endif
}

// void glPixelTransferi (GLenum pname, GLint param);
static inline void qglPixelTransferi(GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelTransferi(pname=%lu, param=%ld)\n", pname, param);
#endif
    glPixelTransferi(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelTransferi");
#endif
}

// void glPixelZoom (GLfloat xfactor, GLfloat yfactor);
static inline void qglPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPixelZoom(xfactor=%f, yfactor=%f)\n", xfactor, yfactor);
#endif
    glPixelZoom(xfactor, yfactor);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelZoom");
#endif
}

// void glPointSize (GLfloat size);
static inline void qglPointSize(GLfloat size)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPointSize(size=%f)\n", size);
#endif
    glPointSize(size);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPointSize");
#endif
}

// void glPolygonMode (GLenum face, GLenum mode);
static inline void qglPolygonMode(GLenum face, GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPolygonMode(face=%lu, mode=%lu)\n", face, mode);
#endif
    glPolygonMode(face, mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPolygonMode");
#endif
}

// void glPolygonOffset (GLfloat factor, GLfloat units);
static inline void qglPolygonOffset(GLfloat factor, GLfloat units)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPolygonOffset(factor=%f, units=%f)\n", factor, units);
#endif
    glPolygonOffset(factor, units);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPolygonOffset");
#endif
}

// void glPolygonStipple (const GLubyte *mask);
static inline void qglPolygonStipple(const GLubyte *mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPolygonStipple(mask=%p)\n", mask);
#endif
    glPolygonStipple(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPolygonStipple");
#endif
}

// void glPopAttrib (void);
static inline void qglPopAttrib(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPopAttrib(void)\n");
#endif
    glPopAttrib();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPopAttrib");
#endif
}

// void glPopClientAttrib (void);
static inline void qglPopClientAttrib(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPopClientAttrib(void)\n");
#endif
    glPopClientAttrib();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPopClientAttrib");
#endif
}

// void glPopMatrix (void);
static inline void qglPopMatrix(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPopMatrix(void)\n");
#endif
    glPopMatrix();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPopMatrix");
#endif
}

// void glPopName (void);
static inline void qglPopName(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPopName(void)\n");
#endif
    glPopName();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPopName");
#endif
}

// void glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities);
static inline void qglPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPrioritizeTextures(n=%ld, textures=%p, priorities=%p)\n", n, textures, priorities);
#endif
    glPrioritizeTextures(n, textures, priorities);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPrioritizeTextures");
#endif
}

// void glPushAttrib (GLbitfield mask);
static inline void qglPushAttrib(GLbitfield mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPushAttrib(mask=%lu)\n", mask);
#endif
    glPushAttrib(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPushAttrib");
#endif
}

// void glPushClientAttrib (GLbitfield mask);
static inline void qglPushClientAttrib(GLbitfield mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPushClientAttrib(mask=%lu)\n", mask);
#endif
    glPushClientAttrib(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPushClientAttrib");
#endif
}

// void glPushMatrix (void);
static inline void qglPushMatrix(void)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPushMatrix(void)\n");
#endif
    glPushMatrix();
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPushMatrix");
#endif
}

// void glPushName (GLuint name);
static inline void qglPushName(GLuint name)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPushName(name=%lu)\n", name);
#endif
    glPushName(name);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPushName");
#endif
}

// void glRasterPos2d (GLdouble x, GLdouble y);
static inline void qglRasterPos2d(GLdouble x, GLdouble y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2d(x=%f, y=%f)\n", x, y);
#endif
    glRasterPos2d(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2d");
#endif
}

// void glRasterPos2dv (const GLdouble *v);
static inline void qglRasterPos2dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2dv(v=%p)\n", v);
#endif
    glRasterPos2dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2dv");
#endif
}

// void glRasterPos2f (GLfloat x, GLfloat y);
static inline void qglRasterPos2f(GLfloat x, GLfloat y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2f(x=%f, y=%f)\n", x, y);
#endif
    glRasterPos2f(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2f");
#endif
}

// void glRasterPos2fv (const GLfloat *v);
static inline void qglRasterPos2fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2fv(v=%p)\n", v);
#endif
    glRasterPos2fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2fv");
#endif
}

// void glRasterPos2i (GLint x, GLint y);
static inline void qglRasterPos2i(GLint x, GLint y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2i(x=%ld, y=%ld)\n", x, y);
#endif
    glRasterPos2i(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2i");
#endif
}

// void glRasterPos2iv (const GLint *v);
static inline void qglRasterPos2iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2iv(v=%p)\n", v);
#endif
    glRasterPos2iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2iv");
#endif
}

// void glRasterPos2s (GLshort x, GLshort y);
static inline void qglRasterPos2s(GLshort x, GLshort y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2s(x=%d, y=%d)\n", x, y);
#endif
    glRasterPos2s(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2s");
#endif
}

// void glRasterPos2sv (const GLshort *v);
static inline void qglRasterPos2sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos2sv(v=%p)\n", v);
#endif
    glRasterPos2sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos2sv");
#endif
}

// void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z);
static inline void qglRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3d(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glRasterPos3d(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3d");
#endif
}

// void glRasterPos3dv (const GLdouble *v);
static inline void qglRasterPos3dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3dv(v=%p)\n", v);
#endif
    glRasterPos3dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3dv");
#endif
}

// void glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);
static inline void qglRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3f(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glRasterPos3f(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3f");
#endif
}

// void glRasterPos3fv (const GLfloat *v);
static inline void qglRasterPos3fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3fv(v=%p)\n", v);
#endif
    glRasterPos3fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3fv");
#endif
}

// void glRasterPos3i (GLint x, GLint y, GLint z);
static inline void qglRasterPos3i(GLint x, GLint y, GLint z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3i(x=%ld, y=%ld, z=%ld)\n", x, y, z);
#endif
    glRasterPos3i(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3i");
#endif
}

// void glRasterPos3iv (const GLint *v);
static inline void qglRasterPos3iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3iv(v=%p)\n", v);
#endif
    glRasterPos3iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3iv");
#endif
}

// void glRasterPos3s (GLshort x, GLshort y, GLshort z);
static inline void qglRasterPos3s(GLshort x, GLshort y, GLshort z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3s(x=%d, y=%d, z=%d)\n", x, y, z);
#endif
    glRasterPos3s(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3s");
#endif
}

// void glRasterPos3sv (const GLshort *v);
static inline void qglRasterPos3sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos3sv(v=%p)\n", v);
#endif
    glRasterPos3sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos3sv");
#endif
}

// void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static inline void qglRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4d(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
#endif
    glRasterPos4d(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4d");
#endif
}

// void glRasterPos4dv (const GLdouble *v);
static inline void qglRasterPos4dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4dv(v=%p)\n", v);
#endif
    glRasterPos4dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4dv");
#endif
}

// void glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static inline void qglRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4f(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
#endif
    glRasterPos4f(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4f");
#endif
}

// void glRasterPos4fv (const GLfloat *v);
static inline void qglRasterPos4fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4fv(v=%p)\n", v);
#endif
    glRasterPos4fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4fv");
#endif
}

// void glRasterPos4i (GLint x, GLint y, GLint z, GLint w);
static inline void qglRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4i(x=%ld, y=%ld, z=%ld, w=%ld)\n", x, y, z, w);
#endif
    glRasterPos4i(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4i");
#endif
}

// void glRasterPos4iv (const GLint *v);
static inline void qglRasterPos4iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4iv(v=%p)\n", v);
#endif
    glRasterPos4iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4iv");
#endif
}

// void glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w);
static inline void qglRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4s(x=%d, y=%d, z=%d, w=%d)\n", x, y, z, w);
#endif
    glRasterPos4s(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4s");
#endif
}

// void glRasterPos4sv (const GLshort *v);
static inline void qglRasterPos4sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRasterPos4sv(v=%p)\n", v);
#endif
    glRasterPos4sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRasterPos4sv");
#endif
}

// void glReadBuffer (GLenum mode);
static inline void qglReadBuffer(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glReadBuffer(mode=%lu)\n", mode);
#endif
    glReadBuffer(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glReadBuffer");
#endif
}

// void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
static inline void qglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glReadPixels(x=%ld, y=%ld, width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", x, y, width, height, format, type, pixels);
#endif
    glReadPixels(x, y, width, height, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glReadPixels");
#endif
}

// void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
static inline void qglRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectd(x1=%f, y1=%f, x2=%f, y2=%f)\n", x1, y1, x2, y2);
#endif
    glRectd(x1, y1, x2, y2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectd");
#endif
}

// void glRectdv (const GLdouble *v1, const GLdouble *v2);
static inline void qglRectdv(const GLdouble *v1, const GLdouble *v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectdv(v1=%p, v2=%p)\n", v1, v2);
#endif
    glRectdv(v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectdv");
#endif
}

// void glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
static inline void qglRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectf(x1=%f, y1=%f, x2=%f, y2=%f)\n", x1, y1, x2, y2);
#endif
    glRectf(x1, y1, x2, y2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectf");
#endif
}

// void glRectfv (const GLfloat *v1, const GLfloat *v2);
static inline void qglRectfv(const GLfloat *v1, const GLfloat *v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectfv(v1=%p, v2=%p)\n", v1, v2);
#endif
    glRectfv(v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectfv");
#endif
}

// void glRecti (GLint x1, GLint y1, GLint x2, GLint y2);
static inline void qglRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRecti(x1=%ld, y1=%ld, x2=%ld, y2=%ld)\n", x1, y1, x2, y2);
#endif
    glRecti(x1, y1, x2, y2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRecti");
#endif
}

// void glRectiv (const GLint *v1, const GLint *v2);
static inline void qglRectiv(const GLint *v1, const GLint *v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectiv(v1=%p, v2=%p)\n", v1, v2);
#endif
    glRectiv(v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectiv");
#endif
}

// void glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2);
static inline void qglRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRects(x1=%d, y1=%d, x2=%d, y2=%d)\n", x1, y1, x2, y2);
#endif
    glRects(x1, y1, x2, y2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRects");
#endif
}

// void glRectsv (const GLshort *v1, const GLshort *v2);
static inline void qglRectsv(const GLshort *v1, const GLshort *v2)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRectsv(v1=%p, v2=%p)\n", v1, v2);
#endif
    glRectsv(v1, v2);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRectsv");
#endif
}

// GLint glRenderMode (GLenum mode);
static inline GLint qglRenderMode(GLenum mode)
{
    GLint returnValue;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRenderMode(mode=%lu)\n", mode);
#endif
    returnValue = glRenderMode(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRenderMode");
#endif
    return returnValue;
}

// void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
static inline void qglRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRotated(angle=%f, x=%f, y=%f, z=%f)\n", angle, x, y, z);
#endif
    glRotated(angle, x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRotated");
#endif
}

// void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
static inline void qglRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRotatef(angle=%f, x=%f, y=%f, z=%f)\n", angle, x, y, z);
#endif
    glRotatef(angle, x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRotatef");
#endif
}

// void glScaled (GLdouble x, GLdouble y, GLdouble z);
static inline void qglScaled(GLdouble x, GLdouble y, GLdouble z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glScaled(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glScaled(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glScaled");
#endif
}

// void glScalef (GLfloat x, GLfloat y, GLfloat z);
static inline void qglScalef(GLfloat x, GLfloat y, GLfloat z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glScalef(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glScalef(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glScalef");
#endif
}

// void glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
static inline void qglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glScissor(x=%ld, y=%ld, width=%ld, height=%ld)\n", x, y, width, height);
#endif
    glScissor(x, y, width, height);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glScissor");
#endif
}

// void glSelectBuffer (GLsizei size, GLuint *buffer);
static inline void qglSelectBuffer(GLsizei size, GLuint *buffer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glSelectBuffer(size=%ld, buffer=%p)\n", size, buffer);
#endif
    glSelectBuffer(size, buffer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glSelectBuffer");
#endif
}

// void glShadeModel (GLenum mode);
static inline void qglShadeModel(GLenum mode)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glShadeModel(mode=%lu)\n", mode);
#endif
    glShadeModel(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glShadeModel");
#endif
}

// void glStencilFunc (GLenum func, GLint ref, GLuint mask);
static inline void qglStencilFunc(GLenum func, GLint ref, GLuint mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glStencilFunc(func=%lu, ref=%ld, mask=%lu)\n", func, ref, mask);
#endif
    glStencilFunc(func, ref, mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glStencilFunc");
#endif
}

// void glStencilMask (GLuint mask);
static inline void qglStencilMask(GLuint mask)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glStencilMask(mask=%lu)\n", mask);
#endif
    glStencilMask(mask);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glStencilMask");
#endif
}

// void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
static inline void qglStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glStencilOp(fail=%lu, zfail=%lu, zpass=%lu)\n", fail, zfail, zpass);
#endif
    glStencilOp(fail, zfail, zpass);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glStencilOp");
#endif
}

// void glTexCoord1d (GLdouble s);
static inline void qglTexCoord1d(GLdouble s)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1d(s=%f)\n", s);
#endif
    glTexCoord1d(s);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1d");
#endif
}

// void glTexCoord1dv (const GLdouble *v);
static inline void qglTexCoord1dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1dv(v=%p)\n", v);
#endif
    glTexCoord1dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1dv");
#endif
}

// void glTexCoord1f (GLfloat s);
static inline void qglTexCoord1f(GLfloat s)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1f(s=%f)\n", s);
#endif
    glTexCoord1f(s);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1f");
#endif
}

// void glTexCoord1fv (const GLfloat *v);
static inline void qglTexCoord1fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1fv(v=%p)\n", v);
#endif
    glTexCoord1fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1fv");
#endif
}

// void glTexCoord1i (GLint s);
static inline void qglTexCoord1i(GLint s)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1i(s=%ld)\n", s);
#endif
    glTexCoord1i(s);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1i");
#endif
}

// void glTexCoord1iv (const GLint *v);
static inline void qglTexCoord1iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1iv(v=%p)\n", v);
#endif
    glTexCoord1iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1iv");
#endif
}

// void glTexCoord1s (GLshort s);
static inline void qglTexCoord1s(GLshort s)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1s(s=%d)\n", s);
#endif
    glTexCoord1s(s);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1s");
#endif
}

// void glTexCoord1sv (const GLshort *v);
static inline void qglTexCoord1sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord1sv(v=%p)\n", v);
#endif
    glTexCoord1sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord1sv");
#endif
}

// void glTexCoord2d (GLdouble s, GLdouble t);
static inline void qglTexCoord2d(GLdouble s, GLdouble t)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2d(s=%f, t=%f)\n", s, t);
#endif
    glTexCoord2d(s, t);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2d");
#endif
}

// void glTexCoord2dv (const GLdouble *v);
static inline void qglTexCoord2dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2dv(v=%p)\n", v);
#endif
    glTexCoord2dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2dv");
#endif
}

// void glTexCoord2f (GLfloat s, GLfloat t);
static inline void qglTexCoord2f(GLfloat s, GLfloat t)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2f(s=%f, t=%f)\n", s, t);
#endif
    glTexCoord2f(s, t);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2f");
#endif
}

// void glTexCoord2fv (const GLfloat *v);
static inline void qglTexCoord2fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2fv(v=%p)\n", v);
#endif
    glTexCoord2fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2fv");
#endif
}

// void glTexCoord2i (GLint s, GLint t);
static inline void qglTexCoord2i(GLint s, GLint t)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2i(s=%ld, t=%ld)\n", s, t);
#endif
    glTexCoord2i(s, t);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2i");
#endif
}

// void glTexCoord2iv (const GLint *v);
static inline void qglTexCoord2iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2iv(v=%p)\n", v);
#endif
    glTexCoord2iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2iv");
#endif
}

// void glTexCoord2s (GLshort s, GLshort t);
static inline void qglTexCoord2s(GLshort s, GLshort t)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2s(s=%d, t=%d)\n", s, t);
#endif
    glTexCoord2s(s, t);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2s");
#endif
}

// void glTexCoord2sv (const GLshort *v);
static inline void qglTexCoord2sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord2sv(v=%p)\n", v);
#endif
    glTexCoord2sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord2sv");
#endif
}

// void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r);
static inline void qglTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3d(s=%f, t=%f, r=%f)\n", s, t, r);
#endif
    glTexCoord3d(s, t, r);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3d");
#endif
}

// void glTexCoord3dv (const GLdouble *v);
static inline void qglTexCoord3dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3dv(v=%p)\n", v);
#endif
    glTexCoord3dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3dv");
#endif
}

// void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r);
static inline void qglTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3f(s=%f, t=%f, r=%f)\n", s, t, r);
#endif
    glTexCoord3f(s, t, r);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3f");
#endif
}

// void glTexCoord3fv (const GLfloat *v);
static inline void qglTexCoord3fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3fv(v=%p)\n", v);
#endif
    glTexCoord3fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3fv");
#endif
}

// void glTexCoord3i (GLint s, GLint t, GLint r);
static inline void qglTexCoord3i(GLint s, GLint t, GLint r)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3i(s=%ld, t=%ld, r=%ld)\n", s, t, r);
#endif
    glTexCoord3i(s, t, r);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3i");
#endif
}

// void glTexCoord3iv (const GLint *v);
static inline void qglTexCoord3iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3iv(v=%p)\n", v);
#endif
    glTexCoord3iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3iv");
#endif
}

// void glTexCoord3s (GLshort s, GLshort t, GLshort r);
static inline void qglTexCoord3s(GLshort s, GLshort t, GLshort r)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3s(s=%d, t=%d, r=%d)\n", s, t, r);
#endif
    glTexCoord3s(s, t, r);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3s");
#endif
}

// void glTexCoord3sv (const GLshort *v);
static inline void qglTexCoord3sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord3sv(v=%p)\n", v);
#endif
    glTexCoord3sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord3sv");
#endif
}

// void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q);
static inline void qglTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4d(s=%f, t=%f, r=%f, q=%f)\n", s, t, r, q);
#endif
    glTexCoord4d(s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4d");
#endif
}

// void glTexCoord4dv (const GLdouble *v);
static inline void qglTexCoord4dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4dv(v=%p)\n", v);
#endif
    glTexCoord4dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4dv");
#endif
}

// void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
static inline void qglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4f(s=%f, t=%f, r=%f, q=%f)\n", s, t, r, q);
#endif
    glTexCoord4f(s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4f");
#endif
}

// void glTexCoord4fv (const GLfloat *v);
static inline void qglTexCoord4fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4fv(v=%p)\n", v);
#endif
    glTexCoord4fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4fv");
#endif
}

// void glTexCoord4i (GLint s, GLint t, GLint r, GLint q);
static inline void qglTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4i(s=%ld, t=%ld, r=%ld, q=%ld)\n", s, t, r, q);
#endif
    glTexCoord4i(s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4i");
#endif
}

// void glTexCoord4iv (const GLint *v);
static inline void qglTexCoord4iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4iv(v=%p)\n", v);
#endif
    glTexCoord4iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4iv");
#endif
}

// void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q);
static inline void qglTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4s(s=%d, t=%d, r=%d, q=%d)\n", s, t, r, q);
#endif
    glTexCoord4s(s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4s");
#endif
}

// void glTexCoord4sv (const GLshort *v);
static inline void qglTexCoord4sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoord4sv(v=%p)\n", v);
#endif
    glTexCoord4sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoord4sv");
#endif
}

// void glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static inline void qglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexCoordPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
#endif
    glTexCoordPointer(size, type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoordPointer");
#endif
}

// void glTexEnvf (GLenum target, GLenum pname, GLfloat param);
static inline void qglTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnvf(target=%lu, pname=%lu, param=%f)\n", target, pname, param);
#endif
    glTexEnvf(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvf");
#endif
}

// void glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
static inline void qglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnvfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glTexEnvfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvfv");
#endif
}

// void glTexEnvi (GLenum target, GLenum pname, GLint param);
static inline void qglTexEnvi(GLenum target, GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnvi(target=%lu, pname=%lu, param=%ld)\n", target, pname, param);
#endif
    glTexEnvi(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvi");
#endif
}

// void glTexEnviv (GLenum target, GLenum pname, const GLint *params);
static inline void qglTexEnviv(GLenum target, GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnviv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glTexEnviv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnviv");
#endif
}

// void glTexGend (GLenum coord, GLenum pname, GLdouble param);
static inline void qglTexGend(GLenum coord, GLenum pname, GLdouble param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGend(coord=%lu, pname=%lu, param=%f)\n", coord, pname, param);
#endif
    glTexGend(coord, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGend");
#endif
}

// void glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);
static inline void qglTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGendv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glTexGendv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGendv");
#endif
}

// void glTexGenf (GLenum coord, GLenum pname, GLfloat param);
static inline void qglTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGenf(coord=%lu, pname=%lu, param=%f)\n", coord, pname, param);
#endif
    glTexGenf(coord, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGenf");
#endif
}

// void glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);
static inline void qglTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGenfv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glTexGenfv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGenfv");
#endif
}

// void glTexGeni (GLenum coord, GLenum pname, GLint param);
static inline void qglTexGeni(GLenum coord, GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGeni(coord=%lu, pname=%lu, param=%ld)\n", coord, pname, param);
#endif
    glTexGeni(coord, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGeni");
#endif
}

// void glTexGeniv (GLenum coord, GLenum pname, const GLint *params);
static inline void qglTexGeniv(GLenum coord, GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexGeniv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
#endif
    glTexGeniv(coord, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexGeniv");
#endif
}

// void glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static inline void qglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexImage1D(target=%lu, level=%ld, internalformat=%ld, width=%ld, border=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, internalformat, width, border, format, type, pixels);
#endif
    glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexImage1D");
#endif
}

// void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
static inline void qglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexImage2D(target=%lu, level=%ld, internalformat=%ld, width=%ld, height=%ld, border=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, internalformat, width, height, border, format, type, pixels);
#endif
    glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexImage2D");
#endif
}

// void glTexParameterf (GLenum target, GLenum pname, GLfloat param);
static inline void qglTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameterf(target=%lu, pname=%lu, param=%f)\n", target, pname, param);
#endif
    glTexParameterf(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameterf");
#endif
}

// void glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params);
static inline void qglTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameterfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glTexParameterfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameterfv");
#endif
}

// void glTexParameteri (GLenum target, GLenum pname, GLint param);
static inline void qglTexParameteri(GLenum target, GLenum pname, GLint param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameteri(target=%lu, pname=%lu, param=%ld)\n", target, pname, param);
#endif
    glTexParameteri(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameteri");
#endif
}

// void glTexParameteriv (GLenum target, GLenum pname, const GLint *params);
static inline void qglTexParameteriv(GLenum target, GLenum pname, const GLint *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameteriv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
#endif
    glTexParameteriv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameteriv");
#endif
}

// void glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
static inline void qglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexSubImage1D(target=%lu, level=%ld, xoffset=%ld, width=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, xoffset, width, format, type, pixels);
#endif
    glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexSubImage1D");
#endif
}

// void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
static inline void qglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexSubImage2D(target=%lu, level=%ld, xoffset=%ld, yoffset=%ld, width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
#endif
    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexSubImage2D");
#endif
}

// void glTranslated (GLdouble x, GLdouble y, GLdouble z);
static inline void qglTranslated(GLdouble x, GLdouble y, GLdouble z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTranslated(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glTranslated(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTranslated");
#endif
}

// void glTranslatef (GLfloat x, GLfloat y, GLfloat z);
static inline void qglTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTranslatef(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glTranslatef(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTranslatef");
#endif
}

// void glVertex2d (GLdouble x, GLdouble y);
static inline void qglVertex2d(GLdouble x, GLdouble y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2d(x=%f, y=%f)\n", x, y);
#endif
    glVertex2d(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2d");
#endif
}

// void glVertex2dv (const GLdouble *v);
static inline void qglVertex2dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2dv(v=%p)\n", v);
#endif
    glVertex2dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2dv");
#endif
}

// void glVertex2f (GLfloat x, GLfloat y);
static inline void qglVertex2f(GLfloat x, GLfloat y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2f(x=%f, y=%f)\n", x, y);
#endif
    glVertex2f(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2f");
#endif
}

// void glVertex2fv (const GLfloat *v);
static inline void qglVertex2fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2fv(v=%p)\n", v);
#endif
    glVertex2fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2fv");
#endif
}

// void glVertex2i (GLint x, GLint y);
static inline void qglVertex2i(GLint x, GLint y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2i(x=%ld, y=%ld)\n", x, y);
#endif
    glVertex2i(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2i");
#endif
}

// void glVertex2iv (const GLint *v);
static inline void qglVertex2iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2iv(v=%p)\n", v);
#endif
    glVertex2iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2iv");
#endif
}

// void glVertex2s (GLshort x, GLshort y);
static inline void qglVertex2s(GLshort x, GLshort y)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2s(x=%d, y=%d)\n", x, y);
#endif
    glVertex2s(x, y);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2s");
#endif
}

// void glVertex2sv (const GLshort *v);
static inline void qglVertex2sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex2sv(v=%p)\n", v);
#endif
    glVertex2sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex2sv");
#endif
}

// void glVertex3d (GLdouble x, GLdouble y, GLdouble z);
static inline void qglVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3d(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glVertex3d(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3d");
#endif
}

// void glVertex3dv (const GLdouble *v);
static inline void qglVertex3dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3dv(v=%p)\n", v);
#endif
    glVertex3dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3dv");
#endif
}

// void glVertex3f (GLfloat x, GLfloat y, GLfloat z);
static inline void qglVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3f(x=%f, y=%f, z=%f)\n", x, y, z);
#endif
    glVertex3f(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3f");
#endif
}

// void glVertex3fv (const GLfloat *v);
static inline void qglVertex3fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3fv(v=%p)\n", v);
#endif
    glVertex3fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3fv");
#endif
}

// void glVertex3i (GLint x, GLint y, GLint z);
static inline void qglVertex3i(GLint x, GLint y, GLint z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3i(x=%ld, y=%ld, z=%ld)\n", x, y, z);
#endif
    glVertex3i(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3i");
#endif
}

// void glVertex3iv (const GLint *v);
static inline void qglVertex3iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3iv(v=%p)\n", v);
#endif
    glVertex3iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3iv");
#endif
}

// void glVertex3s (GLshort x, GLshort y, GLshort z);
static inline void qglVertex3s(GLshort x, GLshort y, GLshort z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3s(x=%d, y=%d, z=%d)\n", x, y, z);
#endif
    glVertex3s(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3s");
#endif
}

// void glVertex3sv (const GLshort *v);
static inline void qglVertex3sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex3sv(v=%p)\n", v);
#endif
    glVertex3sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex3sv");
#endif
}

// void glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
static inline void qglVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4d(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
#endif
    glVertex4d(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4d");
#endif
}

// void glVertex4dv (const GLdouble *v);
static inline void qglVertex4dv(const GLdouble *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4dv(v=%p)\n", v);
#endif
    glVertex4dv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4dv");
#endif
}

// void glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
static inline void qglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4f(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
#endif
    glVertex4f(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4f");
#endif
}

// void glVertex4fv (const GLfloat *v);
static inline void qglVertex4fv(const GLfloat *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4fv(v=%p)\n", v);
#endif
    glVertex4fv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4fv");
#endif
}

// void glVertex4i (GLint x, GLint y, GLint z, GLint w);
static inline void qglVertex4i(GLint x, GLint y, GLint z, GLint w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4i(x=%ld, y=%ld, z=%ld, w=%ld)\n", x, y, z, w);
#endif
    glVertex4i(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4i");
#endif
}

// void glVertex4iv (const GLint *v);
static inline void qglVertex4iv(const GLint *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4iv(v=%p)\n", v);
#endif
    glVertex4iv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4iv");
#endif
}

// void glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
static inline void qglVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4s(x=%d, y=%d, z=%d, w=%d)\n", x, y, z, w);
#endif
    glVertex4s(x, y, z, w);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4s");
#endif
}

// void glVertex4sv (const GLshort *v);
static inline void qglVertex4sv(const GLshort *v)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertex4sv(v=%p)\n", v);
#endif
    glVertex4sv(v);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertex4sv");
#endif
}

// void glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
static inline void qglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glVertexPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
#endif
    glVertexPointer(size, type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glVertexPointer");
#endif
}

// void glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
static inline void qglViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glViewport(x=%ld, y=%ld, width=%ld, height=%ld)\n", x, y, width, height);
#endif
    glViewport(x, y, width, height);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glViewport");
#endif
}

// Prevent calls to the 'normal' GL functions
#define glAccum CALL_THE_QGL_VERSION_OF_glAccum
#define glAlphaFunc CALL_THE_QGL_VERSION_OF_glAlphaFunc
#define glAreTexturesResident CALL_THE_QGL_VERSION_OF_glAreTexturesResident
#define glArrayElement CALL_THE_QGL_VERSION_OF_glArrayElement
#define glBegin CALL_THE_QGL_VERSION_OF_glBegin
#define glBindTexture CALL_THE_QGL_VERSION_OF_glBindTexture
#define glBitmap CALL_THE_QGL_VERSION_OF_glBitmap
#define glBlendFunc CALL_THE_QGL_VERSION_OF_glBlendFunc
#define glCallList CALL_THE_QGL_VERSION_OF_glCallList
#define glCallLists CALL_THE_QGL_VERSION_OF_glCallLists
#define glClear CALL_THE_QGL_VERSION_OF_glClear
#define glClearAccum CALL_THE_QGL_VERSION_OF_glClearAccum
#define glClearColor CALL_THE_QGL_VERSION_OF_glClearColor
#define glClearDepth CALL_THE_QGL_VERSION_OF_glClearDepth
#define glClearIndex CALL_THE_QGL_VERSION_OF_glClearIndex
#define glClearStencil CALL_THE_QGL_VERSION_OF_glClearStencil
#define glClipPlane CALL_THE_QGL_VERSION_OF_glClipPlane
#define glColor3b CALL_THE_QGL_VERSION_OF_glColor3b
#define glColor3bv CALL_THE_QGL_VERSION_OF_glColor3bv
#define glColor3d CALL_THE_QGL_VERSION_OF_glColor3d
#define glColor3dv CALL_THE_QGL_VERSION_OF_glColor3dv
#define glColor3f CALL_THE_QGL_VERSION_OF_glColor3f
#define glColor3fv CALL_THE_QGL_VERSION_OF_glColor3fv
#define glColor3i CALL_THE_QGL_VERSION_OF_glColor3i
#define glColor3iv CALL_THE_QGL_VERSION_OF_glColor3iv
#define glColor3s CALL_THE_QGL_VERSION_OF_glColor3s
#define glColor3sv CALL_THE_QGL_VERSION_OF_glColor3sv
#define glColor3ub CALL_THE_QGL_VERSION_OF_glColor3ub
#define glColor3ubv CALL_THE_QGL_VERSION_OF_glColor3ubv
#define glColor3ui CALL_THE_QGL_VERSION_OF_glColor3ui
#define glColor3uiv CALL_THE_QGL_VERSION_OF_glColor3uiv
#define glColor3us CALL_THE_QGL_VERSION_OF_glColor3us
#define glColor3usv CALL_THE_QGL_VERSION_OF_glColor3usv
#define glColor4b CALL_THE_QGL_VERSION_OF_glColor4b
#define glColor4bv CALL_THE_QGL_VERSION_OF_glColor4bv
#define glColor4d CALL_THE_QGL_VERSION_OF_glColor4d
#define glColor4dv CALL_THE_QGL_VERSION_OF_glColor4dv
#define glColor4f CALL_THE_QGL_VERSION_OF_glColor4f
#define glColor4fv CALL_THE_QGL_VERSION_OF_glColor4fv
#define glColor4i CALL_THE_QGL_VERSION_OF_glColor4i
#define glColor4iv CALL_THE_QGL_VERSION_OF_glColor4iv
#define glColor4s CALL_THE_QGL_VERSION_OF_glColor4s
#define glColor4sv CALL_THE_QGL_VERSION_OF_glColor4sv
#define glColor4ub CALL_THE_QGL_VERSION_OF_glColor4ub
#define glColor4ubv CALL_THE_QGL_VERSION_OF_glColor4ubv
#define glColor4ui CALL_THE_QGL_VERSION_OF_glColor4ui
#define glColor4uiv CALL_THE_QGL_VERSION_OF_glColor4uiv
#define glColor4us CALL_THE_QGL_VERSION_OF_glColor4us
#define glColor4usv CALL_THE_QGL_VERSION_OF_glColor4usv
#define glColorMask CALL_THE_QGL_VERSION_OF_glColorMask
#define glColorMaterial CALL_THE_QGL_VERSION_OF_glColorMaterial
#define glColorPointer CALL_THE_QGL_VERSION_OF_glColorPointer
#define glCopyPixels CALL_THE_QGL_VERSION_OF_glCopyPixels
#define glCopyTexImage1D CALL_THE_QGL_VERSION_OF_glCopyTexImage1D
#define glCopyTexImage2D CALL_THE_QGL_VERSION_OF_glCopyTexImage2D
#define glCopyTexSubImage1D CALL_THE_QGL_VERSION_OF_glCopyTexSubImage1D
#define glCopyTexSubImage2D CALL_THE_QGL_VERSION_OF_glCopyTexSubImage2D
#define glCullFace CALL_THE_QGL_VERSION_OF_glCullFace
#define glDeleteLists CALL_THE_QGL_VERSION_OF_glDeleteLists
#define glDeleteTextures CALL_THE_QGL_VERSION_OF_glDeleteTextures
#define glDepthFunc CALL_THE_QGL_VERSION_OF_glDepthFunc
#define glDepthMask CALL_THE_QGL_VERSION_OF_glDepthMask
#define glDepthRange CALL_THE_QGL_VERSION_OF_glDepthRange
#define glDisable CALL_THE_QGL_VERSION_OF_glDisable
#define glDisableClientState CALL_THE_QGL_VERSION_OF_glDisableClientState
#define glDrawArrays CALL_THE_QGL_VERSION_OF_glDrawArrays
#define glDrawBuffer CALL_THE_QGL_VERSION_OF_glDrawBuffer
#define glDrawElements CALL_THE_QGL_VERSION_OF_glDrawElements
#define glDrawPixels CALL_THE_QGL_VERSION_OF_glDrawPixels
#define glEdgeFlag CALL_THE_QGL_VERSION_OF_glEdgeFlag
#define glEdgeFlagPointer CALL_THE_QGL_VERSION_OF_glEdgeFlagPointer
#define glEdgeFlagv CALL_THE_QGL_VERSION_OF_glEdgeFlagv
#define glEnable CALL_THE_QGL_VERSION_OF_glEnable
#define glEnableClientState CALL_THE_QGL_VERSION_OF_glEnableClientState
#define glEnd CALL_THE_QGL_VERSION_OF_glEnd
#define glEndList CALL_THE_QGL_VERSION_OF_glEndList
#define glEvalCoord1d CALL_THE_QGL_VERSION_OF_glEvalCoord1d
#define glEvalCoord1dv CALL_THE_QGL_VERSION_OF_glEvalCoord1dv
#define glEvalCoord1f CALL_THE_QGL_VERSION_OF_glEvalCoord1f
#define glEvalCoord1fv CALL_THE_QGL_VERSION_OF_glEvalCoord1fv
#define glEvalCoord2d CALL_THE_QGL_VERSION_OF_glEvalCoord2d
#define glEvalCoord2dv CALL_THE_QGL_VERSION_OF_glEvalCoord2dv
#define glEvalCoord2f CALL_THE_QGL_VERSION_OF_glEvalCoord2f
#define glEvalCoord2fv CALL_THE_QGL_VERSION_OF_glEvalCoord2fv
#define glEvalMesh1 CALL_THE_QGL_VERSION_OF_glEvalMesh1
#define glEvalMesh2 CALL_THE_QGL_VERSION_OF_glEvalMesh2
#define glEvalPoint1 CALL_THE_QGL_VERSION_OF_glEvalPoint1
#define glEvalPoint2 CALL_THE_QGL_VERSION_OF_glEvalPoint2
#define glFeedbackBuffer CALL_THE_QGL_VERSION_OF_glFeedbackBuffer
#define glFinish CALL_THE_QGL_VERSION_OF_glFinish
#define glFlush CALL_THE_QGL_VERSION_OF_glFlush
#define glFogf CALL_THE_QGL_VERSION_OF_glFogf
#define glFogfv CALL_THE_QGL_VERSION_OF_glFogfv
#define glFogi CALL_THE_QGL_VERSION_OF_glFogi
#define glFogiv CALL_THE_QGL_VERSION_OF_glFogiv
#define glFrontFace CALL_THE_QGL_VERSION_OF_glFrontFace
#define glFrustum CALL_THE_QGL_VERSION_OF_glFrustum
#define glGenLists CALL_THE_QGL_VERSION_OF_glGenLists
#define glGenTextures CALL_THE_QGL_VERSION_OF_glGenTextures
#define glGetBooleanv CALL_THE_QGL_VERSION_OF_glGetBooleanv
#define glGetClipPlane CALL_THE_QGL_VERSION_OF_glGetClipPlane
#define glGetDoublev CALL_THE_QGL_VERSION_OF_glGetDoublev
#define glGetError CALL_THE_QGL_VERSION_OF_glGetError
#define glGetFloatv CALL_THE_QGL_VERSION_OF_glGetFloatv
#define glGetIntegerv CALL_THE_QGL_VERSION_OF_glGetIntegerv
#define glGetLightfv CALL_THE_QGL_VERSION_OF_glGetLightfv
#define glGetLightiv CALL_THE_QGL_VERSION_OF_glGetLightiv
#define glGetMapdv CALL_THE_QGL_VERSION_OF_glGetMapdv
#define glGetMapfv CALL_THE_QGL_VERSION_OF_glGetMapfv
#define glGetMapiv CALL_THE_QGL_VERSION_OF_glGetMapiv
#define glGetMaterialfv CALL_THE_QGL_VERSION_OF_glGetMaterialfv
#define glGetMaterialiv CALL_THE_QGL_VERSION_OF_glGetMaterialiv
#define glGetPixelMapfv CALL_THE_QGL_VERSION_OF_glGetPixelMapfv
#define glGetPixelMapuiv CALL_THE_QGL_VERSION_OF_glGetPixelMapuiv
#define glGetPixelMapusv CALL_THE_QGL_VERSION_OF_glGetPixelMapusv
#define glGetPointerv CALL_THE_QGL_VERSION_OF_glGetPointerv
#define glGetPolygonStipple CALL_THE_QGL_VERSION_OF_glGetPolygonStipple
#define glGetString CALL_THE_QGL_VERSION_OF_glGetString
#define glGetTexEnvfv CALL_THE_QGL_VERSION_OF_glGetTexEnvfv
#define glGetTexEnviv CALL_THE_QGL_VERSION_OF_glGetTexEnviv
#define glGetTexGendv CALL_THE_QGL_VERSION_OF_glGetTexGendv
#define glGetTexGenfv CALL_THE_QGL_VERSION_OF_glGetTexGenfv
#define glGetTexGeniv CALL_THE_QGL_VERSION_OF_glGetTexGeniv
#define glGetTexImage CALL_THE_QGL_VERSION_OF_glGetTexImage
#define glGetTexLevelParameterfv CALL_THE_QGL_VERSION_OF_glGetTexLevelParameterfv
#define glGetTexLevelParameteriv CALL_THE_QGL_VERSION_OF_glGetTexLevelParameteriv
#define glGetTexParameterfv CALL_THE_QGL_VERSION_OF_glGetTexParameterfv
#define glGetTexParameteriv CALL_THE_QGL_VERSION_OF_glGetTexParameteriv
#define glHint CALL_THE_QGL_VERSION_OF_glHint
#define glIndexMask CALL_THE_QGL_VERSION_OF_glIndexMask
#define glIndexPointer CALL_THE_QGL_VERSION_OF_glIndexPointer
#define glIndexd CALL_THE_QGL_VERSION_OF_glIndexd
#define glIndexdv CALL_THE_QGL_VERSION_OF_glIndexdv
#define glIndexf CALL_THE_QGL_VERSION_OF_glIndexf
#define glIndexfv CALL_THE_QGL_VERSION_OF_glIndexfv
#define glIndexi CALL_THE_QGL_VERSION_OF_glIndexi
#define glIndexiv CALL_THE_QGL_VERSION_OF_glIndexiv
#define glIndexs CALL_THE_QGL_VERSION_OF_glIndexs
#define glIndexsv CALL_THE_QGL_VERSION_OF_glIndexsv
#define glIndexub CALL_THE_QGL_VERSION_OF_glIndexub
#define glIndexubv CALL_THE_QGL_VERSION_OF_glIndexubv
#define glInitNames CALL_THE_QGL_VERSION_OF_glInitNames
#define glInterleavedArrays CALL_THE_QGL_VERSION_OF_glInterleavedArrays
#define glIsEnabled CALL_THE_QGL_VERSION_OF_glIsEnabled
#define glIsList CALL_THE_QGL_VERSION_OF_glIsList
#define glIsTexture CALL_THE_QGL_VERSION_OF_glIsTexture
#define glLightModelf CALL_THE_QGL_VERSION_OF_glLightModelf
#define glLightModelfv CALL_THE_QGL_VERSION_OF_glLightModelfv
#define glLightModeli CALL_THE_QGL_VERSION_OF_glLightModeli
#define glLightModeliv CALL_THE_QGL_VERSION_OF_glLightModeliv
#define glLightf CALL_THE_QGL_VERSION_OF_glLightf
#define glLightfv CALL_THE_QGL_VERSION_OF_glLightfv
#define glLighti CALL_THE_QGL_VERSION_OF_glLighti
#define glLightiv CALL_THE_QGL_VERSION_OF_glLightiv
#define glLineStipple CALL_THE_QGL_VERSION_OF_glLineStipple
#define glLineWidth CALL_THE_QGL_VERSION_OF_glLineWidth
#define glListBase CALL_THE_QGL_VERSION_OF_glListBase
#define glLoadIdentity CALL_THE_QGL_VERSION_OF_glLoadIdentity
#define glLoadMatrixd CALL_THE_QGL_VERSION_OF_glLoadMatrixd
#define glLoadMatrixf CALL_THE_QGL_VERSION_OF_glLoadMatrixf
#define glLoadName CALL_THE_QGL_VERSION_OF_glLoadName
#define glLogicOp CALL_THE_QGL_VERSION_OF_glLogicOp
#define glMap1d CALL_THE_QGL_VERSION_OF_glMap1d
#define glMap1f CALL_THE_QGL_VERSION_OF_glMap1f
#define glMap2d CALL_THE_QGL_VERSION_OF_glMap2d
#define glMap2f CALL_THE_QGL_VERSION_OF_glMap2f
#define glMapGrid1d CALL_THE_QGL_VERSION_OF_glMapGrid1d
#define glMapGrid1f CALL_THE_QGL_VERSION_OF_glMapGrid1f
#define glMapGrid2d CALL_THE_QGL_VERSION_OF_glMapGrid2d
#define glMapGrid2f CALL_THE_QGL_VERSION_OF_glMapGrid2f
#define glMaterialf CALL_THE_QGL_VERSION_OF_glMaterialf
#define glMaterialfv CALL_THE_QGL_VERSION_OF_glMaterialfv
#define glMateriali CALL_THE_QGL_VERSION_OF_glMateriali
#define glMaterialiv CALL_THE_QGL_VERSION_OF_glMaterialiv
#define glMatrixMode CALL_THE_QGL_VERSION_OF_glMatrixMode
#define glMultMatrixd CALL_THE_QGL_VERSION_OF_glMultMatrixd
#define glMultMatrixf CALL_THE_QGL_VERSION_OF_glMultMatrixf
#define glNewList CALL_THE_QGL_VERSION_OF_glNewList
#define glNormal3b CALL_THE_QGL_VERSION_OF_glNormal3b
#define glNormal3bv CALL_THE_QGL_VERSION_OF_glNormal3bv
#define glNormal3d CALL_THE_QGL_VERSION_OF_glNormal3d
#define glNormal3dv CALL_THE_QGL_VERSION_OF_glNormal3dv
#define glNormal3f CALL_THE_QGL_VERSION_OF_glNormal3f
#define glNormal3fv CALL_THE_QGL_VERSION_OF_glNormal3fv
#define glNormal3i CALL_THE_QGL_VERSION_OF_glNormal3i
#define glNormal3iv CALL_THE_QGL_VERSION_OF_glNormal3iv
#define glNormal3s CALL_THE_QGL_VERSION_OF_glNormal3s
#define glNormal3sv CALL_THE_QGL_VERSION_OF_glNormal3sv
#define glNormalPointer CALL_THE_QGL_VERSION_OF_glNormalPointer
#define glOrtho CALL_THE_QGL_VERSION_OF_glOrtho
#define glPassThrough CALL_THE_QGL_VERSION_OF_glPassThrough
#define glPixelMapfv CALL_THE_QGL_VERSION_OF_glPixelMapfv
#define glPixelMapuiv CALL_THE_QGL_VERSION_OF_glPixelMapuiv
#define glPixelMapusv CALL_THE_QGL_VERSION_OF_glPixelMapusv
#define glPixelStoref CALL_THE_QGL_VERSION_OF_glPixelStoref
#define glPixelStorei CALL_THE_QGL_VERSION_OF_glPixelStorei
#define glPixelTransferf CALL_THE_QGL_VERSION_OF_glPixelTransferf
#define glPixelTransferi CALL_THE_QGL_VERSION_OF_glPixelTransferi
#define glPixelZoom CALL_THE_QGL_VERSION_OF_glPixelZoom
#define glPointSize CALL_THE_QGL_VERSION_OF_glPointSize
#define glPolygonMode CALL_THE_QGL_VERSION_OF_glPolygonMode
#define glPolygonOffset CALL_THE_QGL_VERSION_OF_glPolygonOffset
#define glPolygonStipple CALL_THE_QGL_VERSION_OF_glPolygonStipple
#define glPopAttrib CALL_THE_QGL_VERSION_OF_glPopAttrib
#define glPopClientAttrib CALL_THE_QGL_VERSION_OF_glPopClientAttrib
#define glPopMatrix CALL_THE_QGL_VERSION_OF_glPopMatrix
#define glPopName CALL_THE_QGL_VERSION_OF_glPopName
#define glPrioritizeTextures CALL_THE_QGL_VERSION_OF_glPrioritizeTextures
#define glPushAttrib CALL_THE_QGL_VERSION_OF_glPushAttrib
#define glPushClientAttrib CALL_THE_QGL_VERSION_OF_glPushClientAttrib
#define glPushMatrix CALL_THE_QGL_VERSION_OF_glPushMatrix
#define glPushName CALL_THE_QGL_VERSION_OF_glPushName
#define glRasterPos2d CALL_THE_QGL_VERSION_OF_glRasterPos2d
#define glRasterPos2dv CALL_THE_QGL_VERSION_OF_glRasterPos2dv
#define glRasterPos2f CALL_THE_QGL_VERSION_OF_glRasterPos2f
#define glRasterPos2fv CALL_THE_QGL_VERSION_OF_glRasterPos2fv
#define glRasterPos2i CALL_THE_QGL_VERSION_OF_glRasterPos2i
#define glRasterPos2iv CALL_THE_QGL_VERSION_OF_glRasterPos2iv
#define glRasterPos2s CALL_THE_QGL_VERSION_OF_glRasterPos2s
#define glRasterPos2sv CALL_THE_QGL_VERSION_OF_glRasterPos2sv
#define glRasterPos3d CALL_THE_QGL_VERSION_OF_glRasterPos3d
#define glRasterPos3dv CALL_THE_QGL_VERSION_OF_glRasterPos3dv
#define glRasterPos3f CALL_THE_QGL_VERSION_OF_glRasterPos3f
#define glRasterPos3fv CALL_THE_QGL_VERSION_OF_glRasterPos3fv
#define glRasterPos3i CALL_THE_QGL_VERSION_OF_glRasterPos3i
#define glRasterPos3iv CALL_THE_QGL_VERSION_OF_glRasterPos3iv
#define glRasterPos3s CALL_THE_QGL_VERSION_OF_glRasterPos3s
#define glRasterPos3sv CALL_THE_QGL_VERSION_OF_glRasterPos3sv
#define glRasterPos4d CALL_THE_QGL_VERSION_OF_glRasterPos4d
#define glRasterPos4dv CALL_THE_QGL_VERSION_OF_glRasterPos4dv
#define glRasterPos4f CALL_THE_QGL_VERSION_OF_glRasterPos4f
#define glRasterPos4fv CALL_THE_QGL_VERSION_OF_glRasterPos4fv
#define glRasterPos4i CALL_THE_QGL_VERSION_OF_glRasterPos4i
#define glRasterPos4iv CALL_THE_QGL_VERSION_OF_glRasterPos4iv
#define glRasterPos4s CALL_THE_QGL_VERSION_OF_glRasterPos4s
#define glRasterPos4sv CALL_THE_QGL_VERSION_OF_glRasterPos4sv
#define glReadBuffer CALL_THE_QGL_VERSION_OF_glReadBuffer
#define glReadPixels CALL_THE_QGL_VERSION_OF_glReadPixels
#define glRectd CALL_THE_QGL_VERSION_OF_glRectd
#define glRectdv CALL_THE_QGL_VERSION_OF_glRectdv
#define glRectf CALL_THE_QGL_VERSION_OF_glRectf
#define glRectfv CALL_THE_QGL_VERSION_OF_glRectfv
#define glRecti CALL_THE_QGL_VERSION_OF_glRecti
#define glRectiv CALL_THE_QGL_VERSION_OF_glRectiv
#define glRects CALL_THE_QGL_VERSION_OF_glRects
#define glRectsv CALL_THE_QGL_VERSION_OF_glRectsv
#define glRenderMode CALL_THE_QGL_VERSION_OF_glRenderMode
#define glRotated CALL_THE_QGL_VERSION_OF_glRotated
#define glRotatef CALL_THE_QGL_VERSION_OF_glRotatef
#define glScaled CALL_THE_QGL_VERSION_OF_glScaled
#define glScalef CALL_THE_QGL_VERSION_OF_glScalef
#define glScissor CALL_THE_QGL_VERSION_OF_glScissor
#define glSelectBuffer CALL_THE_QGL_VERSION_OF_glSelectBuffer
#define glShadeModel CALL_THE_QGL_VERSION_OF_glShadeModel
#define glStencilFunc CALL_THE_QGL_VERSION_OF_glStencilFunc
#define glStencilMask CALL_THE_QGL_VERSION_OF_glStencilMask
#define glStencilOp CALL_THE_QGL_VERSION_OF_glStencilOp
#define glTexCoord1d CALL_THE_QGL_VERSION_OF_glTexCoord1d
#define glTexCoord1dv CALL_THE_QGL_VERSION_OF_glTexCoord1dv
#define glTexCoord1f CALL_THE_QGL_VERSION_OF_glTexCoord1f
#define glTexCoord1fv CALL_THE_QGL_VERSION_OF_glTexCoord1fv
#define glTexCoord1i CALL_THE_QGL_VERSION_OF_glTexCoord1i
#define glTexCoord1iv CALL_THE_QGL_VERSION_OF_glTexCoord1iv
#define glTexCoord1s CALL_THE_QGL_VERSION_OF_glTexCoord1s
#define glTexCoord1sv CALL_THE_QGL_VERSION_OF_glTexCoord1sv
#define glTexCoord2d CALL_THE_QGL_VERSION_OF_glTexCoord2d
#define glTexCoord2dv CALL_THE_QGL_VERSION_OF_glTexCoord2dv
#define glTexCoord2f CALL_THE_QGL_VERSION_OF_glTexCoord2f
#define glTexCoord2fv CALL_THE_QGL_VERSION_OF_glTexCoord2fv
#define glTexCoord2i CALL_THE_QGL_VERSION_OF_glTexCoord2i
#define glTexCoord2iv CALL_THE_QGL_VERSION_OF_glTexCoord2iv
#define glTexCoord2s CALL_THE_QGL_VERSION_OF_glTexCoord2s
#define glTexCoord2sv CALL_THE_QGL_VERSION_OF_glTexCoord2sv
#define glTexCoord3d CALL_THE_QGL_VERSION_OF_glTexCoord3d
#define glTexCoord3dv CALL_THE_QGL_VERSION_OF_glTexCoord3dv
#define glTexCoord3f CALL_THE_QGL_VERSION_OF_glTexCoord3f
#define glTexCoord3fv CALL_THE_QGL_VERSION_OF_glTexCoord3fv
#define glTexCoord3i CALL_THE_QGL_VERSION_OF_glTexCoord3i
#define glTexCoord3iv CALL_THE_QGL_VERSION_OF_glTexCoord3iv
#define glTexCoord3s CALL_THE_QGL_VERSION_OF_glTexCoord3s
#define glTexCoord3sv CALL_THE_QGL_VERSION_OF_glTexCoord3sv
#define glTexCoord4d CALL_THE_QGL_VERSION_OF_glTexCoord4d
#define glTexCoord4dv CALL_THE_QGL_VERSION_OF_glTexCoord4dv
#define glTexCoord4f CALL_THE_QGL_VERSION_OF_glTexCoord4f
#define glTexCoord4fv CALL_THE_QGL_VERSION_OF_glTexCoord4fv
#define glTexCoord4i CALL_THE_QGL_VERSION_OF_glTexCoord4i
#define glTexCoord4iv CALL_THE_QGL_VERSION_OF_glTexCoord4iv
#define glTexCoord4s CALL_THE_QGL_VERSION_OF_glTexCoord4s
#define glTexCoord4sv CALL_THE_QGL_VERSION_OF_glTexCoord4sv
#define glTexCoordPointer CALL_THE_QGL_VERSION_OF_glTexCoordPointer
#define glTexEnvf CALL_THE_QGL_VERSION_OF_glTexEnvf
#define glTexEnvfv CALL_THE_QGL_VERSION_OF_glTexEnvfv
#define glTexEnvi CALL_THE_QGL_VERSION_OF_glTexEnvi
#define glTexEnviv CALL_THE_QGL_VERSION_OF_glTexEnviv
#define glTexGend CALL_THE_QGL_VERSION_OF_glTexGend
#define glTexGendv CALL_THE_QGL_VERSION_OF_glTexGendv
#define glTexGenf CALL_THE_QGL_VERSION_OF_glTexGenf
#define glTexGenfv CALL_THE_QGL_VERSION_OF_glTexGenfv
#define glTexGeni CALL_THE_QGL_VERSION_OF_glTexGeni
#define glTexGeniv CALL_THE_QGL_VERSION_OF_glTexGeniv
#define glTexImage1D CALL_THE_QGL_VERSION_OF_glTexImage1D
#define glTexImage2D CALL_THE_QGL_VERSION_OF_glTexImage2D
#define glTexParameterf CALL_THE_QGL_VERSION_OF_glTexParameterf
#define glTexParameterfv CALL_THE_QGL_VERSION_OF_glTexParameterfv
#define glTexParameteri CALL_THE_QGL_VERSION_OF_glTexParameteri
#define glTexParameteriv CALL_THE_QGL_VERSION_OF_glTexParameteriv
#define glTexSubImage1D CALL_THE_QGL_VERSION_OF_glTexSubImage1D
#define glTexSubImage2D CALL_THE_QGL_VERSION_OF_glTexSubImage2D
#define glTranslated CALL_THE_QGL_VERSION_OF_glTranslated
#define glTranslatef CALL_THE_QGL_VERSION_OF_glTranslatef
#define glVertex2d CALL_THE_QGL_VERSION_OF_glVertex2d
#define glVertex2dv CALL_THE_QGL_VERSION_OF_glVertex2dv
#define glVertex2f CALL_THE_QGL_VERSION_OF_glVertex2f
#define glVertex2fv CALL_THE_QGL_VERSION_OF_glVertex2fv
#define glVertex2i CALL_THE_QGL_VERSION_OF_glVertex2i
#define glVertex2iv CALL_THE_QGL_VERSION_OF_glVertex2iv
#define glVertex2s CALL_THE_QGL_VERSION_OF_glVertex2s
#define glVertex2sv CALL_THE_QGL_VERSION_OF_glVertex2sv
#define glVertex3d CALL_THE_QGL_VERSION_OF_glVertex3d
#define glVertex3dv CALL_THE_QGL_VERSION_OF_glVertex3dv
#define glVertex3f CALL_THE_QGL_VERSION_OF_glVertex3f
#define glVertex3fv CALL_THE_QGL_VERSION_OF_glVertex3fv
#define glVertex3i CALL_THE_QGL_VERSION_OF_glVertex3i
#define glVertex3iv CALL_THE_QGL_VERSION_OF_glVertex3iv
#define glVertex3s CALL_THE_QGL_VERSION_OF_glVertex3s
#define glVertex3sv CALL_THE_QGL_VERSION_OF_glVertex3sv
#define glVertex4d CALL_THE_QGL_VERSION_OF_glVertex4d
#define glVertex4dv CALL_THE_QGL_VERSION_OF_glVertex4dv
#define glVertex4f CALL_THE_QGL_VERSION_OF_glVertex4f
#define glVertex4fv CALL_THE_QGL_VERSION_OF_glVertex4fv
#define glVertex4i CALL_THE_QGL_VERSION_OF_glVertex4i
#define glVertex4iv CALL_THE_QGL_VERSION_OF_glVertex4iv
#define glVertex4s CALL_THE_QGL_VERSION_OF_glVertex4s
#define glVertex4sv CALL_THE_QGL_VERSION_OF_glVertex4sv
#define glVertexPointer CALL_THE_QGL_VERSION_OF_glVertexPointer
#define glViewport CALL_THE_QGL_VERSION_OF_glViewport