DOOM-iOS/code/iphone/iphone_qgl.h

/**** This file is autogenerated.  Run GenerateQGL.pl to update it ****/
/*
 
 Copyright (C) 2009 Id Software, Inc.
 
 This program 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.
 
 This program 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 this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 */


#ifndef _IPHONE_QGL_H_
#define _IPHONE_QGL_H_

#ifdef QGL_LOG_GL_CALLS
extern unsigned int QGLLogGLCalls;
#ifdef __cplusplus 
extern "C" {
#endif
	FILE *QGLDebugFile(void);
#ifdef __cplusplus
}
#endif
#endif

#include "iphone_qgl_enumerants.h"


#ifdef __cplusplus 
extern "C" {
#endif
	void QGLCheckError(const char *message);
#ifdef __cplusplus
}
#endif
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  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=%s, ref=%f)\n", StringFromGLEnumerant( func ), ref);
#endif
    glAlphaFunc(func, ref);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glAlphaFunc");
#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  glClearDepthf (GLclampf depth);
static inline void  qglClearDepthf(GLclampf depth)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearDepthf(depth=%f)\n", depth);
#endif
    glClearDepthf(depth);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearDepthf");
#endif
}

// void  glClipPlanef (GLenum plane, const GLfloat *equation);
static inline void  qglClipPlanef(GLenum plane, const GLfloat *equation)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClipPlanef(plane=%s, equation=%p)\n", StringFromGLEnumerant( plane ), equation);
#endif
    glClipPlanef(plane, equation);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClipPlanef");
#endif
}

// void  glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
// void  glDepthRangef (GLclampf zNear, GLclampf zFar);
static inline void  qglDepthRangef(GLclampf zNear, GLclampf zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthRangef(zNear=%f, zFar=%f)\n", zNear, zFar);
#endif
    glDepthRangef(zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDepthRangef");
#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=%s, param=%f)\n", StringFromGLEnumerant( 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=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glFogfv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogfv");
#endif
}

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

// void  glGetClipPlanef (GLenum pname, GLfloat *equation);
static inline void  qglGetClipPlanef(GLenum pname, GLfloat *equation)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetClipPlanef(pname=%s, equation=%p)\n", StringFromGLEnumerant( pname ), equation);
#endif
    glGetClipPlanef(pname, equation);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetClipPlanef");
#endif
}

// 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=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glGetFloatv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetFloatv");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( light ), StringFromGLEnumerant( pname ), params);
#endif
    glGetLightfv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetLightfv");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( pname ), params);
#endif
    glGetMaterialfv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMaterialfv");
#endif
}

// void  glGetTexEnvfv (GLenum env, GLenum pname, GLfloat *params);
static inline void  qglGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexEnvfv(env=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( env ), StringFromGLEnumerant( pname ), params);
#endif
    glGetTexEnvfv(env, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexEnvfv");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glGetTexParameterfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexParameterfv");
#endif
}

// 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=%s, param=%f)\n", StringFromGLEnumerant( 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=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glLightModelfv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModelfv");
#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=%s, pname=%s, param=%f)\n", StringFromGLEnumerant( light ), StringFromGLEnumerant( 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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( light ), StringFromGLEnumerant( pname ), params);
#endif
    glLightfv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightfv");
#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  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  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=%s, pname=%s, param=%f)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( 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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( pname ), params);
#endif
    glMaterialfv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialfv");
#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  glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
static inline void  qglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMultiTexCoord4f(target=%s, s=%f, t=%f, r=%f, q=%f)\n", StringFromGLEnumerant( target ), s, t, r, q);
#endif
    glMultiTexCoord4f(target, s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMultiTexCoord4f");
#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  glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
static inline void  qglOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glOrthof(left=%f, right=%f, bottom=%f, top=%f, zNear=%f, zFar=%f)\n", left, right, bottom, top, zNear, zFar);
#endif
    glOrthof(left, right, bottom, top, zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glOrthof");
#endif
}

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

// void  glPointParameterfv (GLenum pname, const GLfloat *params);
static inline void  qglPointParameterfv(GLenum pname, const GLfloat *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPointParameterfv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glPointParameterfv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPointParameterfv");
#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  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  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  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  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=%s, pname=%s, param=%f)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( 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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexEnvfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvfv");
#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=%s, pname=%s, param=%f)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( 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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexParameterfv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameterfv");
#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  glActiveTexture (GLenum texture);
static inline void  qglActiveTexture(GLenum texture)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glActiveTexture(texture=%s)\n", StringFromGLEnumerant( texture ));
#endif
    glActiveTexture(texture);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glActiveTexture");
#endif
}

// void  glAlphaFuncx (GLenum func, GLclampx ref);
static inline void  qglAlphaFuncx(GLenum func, GLclampx ref)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glAlphaFuncx(func=%s, ref=%ld)\n", StringFromGLEnumerant( func ), ref);
#endif
    glAlphaFuncx(func, ref);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glAlphaFuncx");
#endif
}

// void  glBindBuffer (GLenum target, GLuint buffer);
static inline void  qglBindBuffer(GLenum target, GLuint buffer)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBindBuffer(target=%s, buffer=%lu)\n", StringFromGLEnumerant( target ), buffer);
#endif
    glBindBuffer(target, buffer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBindBuffer");
#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=%s, texture=%lu)\n", StringFromGLEnumerant( target ), texture);
#endif
    glBindTexture(target, texture);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBindTexture");
#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=%s, dfactor=%s)\n", StringFromGLEnumerant( sfactor ), StringFromGLEnumerant( dfactor ));
#endif
    glBlendFunc(sfactor, dfactor);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBlendFunc");
#endif
}

// void  glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
static inline void  qglBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBufferData(target=%s, size=%ld, data=%p, usage=%s)\n", StringFromGLEnumerant( target ), size, data, StringFromGLEnumerant( usage ));
#endif
    glBufferData(target, size, data, usage);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBufferData");
#endif
}

// void  glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
static inline void  qglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glBufferSubData(target=%s, offset=%ld, size=%ld, data=%p)\n", StringFromGLEnumerant( target ), offset, size, data);
#endif
    glBufferSubData(target, offset, size, data);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glBufferSubData");
#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  glClearColorx (GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
static inline void  qglClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearColorx(red=%ld, green=%ld, blue=%ld, alpha=%ld)\n", red, green, blue, alpha);
#endif
    glClearColorx(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearColorx");
#endif
}

// void  glClearDepthx (GLclampx depth);
static inline void  qglClearDepthx(GLclampx depth)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClearDepthx(depth=%ld)\n", depth);
#endif
    glClearDepthx(depth);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClearDepthx");
#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  glClientActiveTexture (GLenum texture);
static inline void  qglClientActiveTexture(GLenum texture)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClientActiveTexture(texture=%s)\n", StringFromGLEnumerant( texture ));
#endif
    glClientActiveTexture(texture);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClientActiveTexture");
#endif
}

// void  glClipPlanex (GLenum plane, const GLfixed *equation);
static inline void  qglClipPlanex(GLenum plane, const GLfixed *equation)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glClipPlanex(plane=%s, equation=%p)\n", StringFromGLEnumerant( plane ), equation);
#endif
    glClipPlanex(plane, equation);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glClipPlanex");
#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  glColor4x (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
static inline void  qglColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glColor4x(red=%ld, green=%ld, blue=%ld, alpha=%ld)\n", red, green, blue, alpha);
#endif
    glColor4x(red, green, blue, alpha);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColor4x");
#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  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=%s, stride=%ld, pointer=%p)\n", size, StringFromGLEnumerant( type ), stride, pointer);
#endif
    glColorPointer(size, type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glColorPointer");
#endif
}

// void  glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
static inline void  qglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCompressedTexImage2D(target=%s, level=%ld, internalformat=%s, width=%ld, height=%ld, border=%ld, imageSize=%ld, data=%p)\n", StringFromGLEnumerant( target ), level, StringFromGLEnumerant( internalformat ), width, height, border, imageSize, data);
#endif
    glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCompressedTexImage2D");
#endif
}

// void  glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
static inline void  qglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glCompressedTexSubImage2D(target=%s, level=%ld, xoffset=%ld, yoffset=%ld, width=%ld, height=%ld, format=%s, imageSize=%ld, data=%p)\n", StringFromGLEnumerant( target ), level, xoffset, yoffset, width, height, StringFromGLEnumerant( format ), imageSize, data);
#endif
    glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCompressedTexSubImage2D");
#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=%s, level=%ld, internalformat=%s, x=%ld, y=%ld, width=%ld, height=%ld, border=%ld)\n", StringFromGLEnumerant( target ), level, StringFromGLEnumerant( 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  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=%s, level=%ld, xoffset=%ld, yoffset=%ld, x=%ld, y=%ld, width=%ld, height=%ld)\n", StringFromGLEnumerant( 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=%s)\n", StringFromGLEnumerant( mode ));
#endif
    glCullFace(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glCullFace");
#endif
}

// void  glDeleteBuffers (GLsizei n, const GLuint *buffers);
static inline void  qglDeleteBuffers(GLsizei n, const GLuint *buffers)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDeleteBuffers(n=%ld, buffers=%p)\n", n, buffers);
#endif
    glDeleteBuffers(n, buffers);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDeleteBuffers");
#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)
{
	func = GL_ALWAYS;
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthFunc(func=%s)\n", StringFromGLEnumerant( 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  glDepthRangex (GLclampx zNear, GLclampx zFar);
static inline void  qglDepthRangex(GLclampx zNear, GLclampx zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glDepthRangex(zNear=%ld, zFar=%ld)\n", zNear, zFar);
#endif
    glDepthRangex(zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDepthRangex");
#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=%s)\n", StringFromGLEnumerant( 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=%s)\n", StringFromGLEnumerant( 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=%s, first=%ld, count=%ld)\n", StringFromGLEnumerant( mode ), first, count);
#endif
    glDrawArrays(mode, first, count);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawArrays");
#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=%s, count=%ld, type=%s, indices=%p)\n", StringFromGLEnumerant( mode ), count, StringFromGLEnumerant( type ), indices);
#endif
    glDrawElements(mode, count, type, indices);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glDrawElements");
#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=%s)\n", StringFromGLEnumerant( 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=%s)\n", StringFromGLEnumerant( array ));
#endif
    glEnableClientState(array);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glEnableClientState");
#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  glFogx (GLenum pname, GLfixed param);
static inline void  qglFogx(GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogx(pname=%s, param=%ld)\n", StringFromGLEnumerant( pname ), param);
#endif
    glFogx(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogx");
#endif
}

// void  glFogxv (GLenum pname, const GLfixed *params);
static inline void  qglFogxv(GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFogxv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glFogxv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFogxv");
#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=%s)\n", StringFromGLEnumerant( mode ));
#endif
    glFrontFace(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFrontFace");
#endif
}

// void  glFrustumx (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
static inline void  qglFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glFrustumx(left=%ld, right=%ld, bottom=%ld, top=%ld, zNear=%ld, zFar=%ld)\n", left, right, bottom, top, zNear, zFar);
#endif
    glFrustumx(left, right, bottom, top, zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glFrustumx");
#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=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glGetBooleanv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetBooleanv");
#endif
}

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

// void  glGetClipPlanex (GLenum pname, GLfixed eqn[4]);
static inline void  qglGetClipPlanex(GLenum pname, GLfixed eqn[4])
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetClipPlanex(pname=%s, eqn=%ld)\n", StringFromGLEnumerant( pname ), eqn);
#endif
    glGetClipPlanex(pname, eqn);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetClipPlanex");
#endif
}

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

// 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
}

// 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  glGetFixedv (GLenum pname, GLfixed *params);
static inline void  qglGetFixedv(GLenum pname, GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetFixedv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glGetFixedv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetFixedv");
#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=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glGetIntegerv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetIntegerv");
#endif
}

// void  glGetLightxv (GLenum light, GLenum pname, GLfixed *params);
static inline void  qglGetLightxv(GLenum light, GLenum pname, GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetLightxv(light=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( light ), StringFromGLEnumerant( pname ), params);
#endif
    glGetLightxv(light, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetLightxv");
#endif
}

// void  glGetMaterialxv (GLenum face, GLenum pname, GLfixed *params);
static inline void  qglGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetMaterialxv(face=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( pname ), params);
#endif
    glGetMaterialxv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetMaterialxv");
#endif
}

// void  glGetPointerv (GLenum pname, void **params);
static inline void  qglGetPointerv(GLenum pname, void **params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetPointerv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glGetPointerv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetPointerv");
#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=%s)\n", StringFromGLEnumerant( name ));
#endif
    returnValue = glGetString(name);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetString");
#endif
    return returnValue;
}

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

// void  glGetTexEnvxv (GLenum env, GLenum pname, GLfixed *params);
static inline void  qglGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexEnvxv(env=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( env ), StringFromGLEnumerant( pname ), params);
#endif
    glGetTexEnvxv(env, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexEnvxv");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glGetTexParameteriv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexParameteriv");
#endif
}

// void  glGetTexParameterxv (GLenum target, GLenum pname, GLfixed *params);
static inline void  qglGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glGetTexParameterxv(target=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glGetTexParameterxv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glGetTexParameterxv");
#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=%s, mode=%s)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( mode ));
#endif
    glHint(target, mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glHint");
#endif
}

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

// 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=%s)\n", StringFromGLEnumerant( cap ));
#endif
    returnValue = glIsEnabled(cap);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glIsEnabled");
#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  glLightModelx (GLenum pname, GLfixed param);
static inline void  qglLightModelx(GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModelx(pname=%s, param=%ld)\n", StringFromGLEnumerant( pname ), param);
#endif
    glLightModelx(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModelx");
#endif
}

// void  glLightModelxv (GLenum pname, const GLfixed *params);
static inline void  qglLightModelxv(GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightModelxv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glLightModelxv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightModelxv");
#endif
}

// void  glLightx (GLenum light, GLenum pname, GLfixed param);
static inline void  qglLightx(GLenum light, GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLightx(light=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( light ), StringFromGLEnumerant( pname ), param);
#endif
    glLightx(light, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLightx");
#endif
}

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

// void  glLineWidthx (GLfixed width);
static inline void  qglLineWidthx(GLfixed width)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLineWidthx(width=%ld)\n", width);
#endif
    glLineWidthx(width);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLineWidthx");
#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  glLoadMatrixx (const GLfixed *m);
static inline void  qglLoadMatrixx(const GLfixed *m)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glLoadMatrixx(m=%p)\n", m);
#endif
    glLoadMatrixx(m);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLoadMatrixx");
#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=%s)\n", StringFromGLEnumerant( opcode ));
#endif
    glLogicOp(opcode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glLogicOp");
#endif
}

// void  glMaterialx (GLenum face, GLenum pname, GLfixed param);
static inline void  qglMaterialx(GLenum face, GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMaterialx(face=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( pname ), param);
#endif
    glMaterialx(face, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialx");
#endif
}

// void  glMaterialxv (GLenum face, GLenum pname, const GLfixed *params);
static inline void  qglMaterialxv(GLenum face, GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMaterialxv(face=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( face ), StringFromGLEnumerant( pname ), params);
#endif
    glMaterialxv(face, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMaterialxv");
#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=%s)\n", StringFromGLEnumerant( mode ));
#endif
    glMatrixMode(mode);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMatrixMode");
#endif
}

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

// void  glMultiTexCoord4x (GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
static inline void  qglMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glMultiTexCoord4x(target=%s, s=%ld, t=%ld, r=%ld, q=%ld)\n", StringFromGLEnumerant( target ), s, t, r, q);
#endif
    glMultiTexCoord4x(target, s, t, r, q);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glMultiTexCoord4x");
#endif
}

// void  glNormal3x (GLfixed nx, GLfixed ny, GLfixed nz);
static inline void  qglNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glNormal3x(nx=%ld, ny=%ld, nz=%ld)\n", nx, ny, nz);
#endif
    glNormal3x(nx, ny, nz);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormal3x");
#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=%s, stride=%ld, pointer=%p)\n", StringFromGLEnumerant( type ), stride, pointer);
#endif
    glNormalPointer(type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glNormalPointer");
#endif
}

// void  glOrthox (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
static inline void  qglOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glOrthox(left=%ld, right=%ld, bottom=%ld, top=%ld, zNear=%ld, zFar=%ld)\n", left, right, bottom, top, zNear, zFar);
#endif
    glOrthox(left, right, bottom, top, zNear, zFar);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glOrthox");
#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=%s, param=%ld)\n", StringFromGLEnumerant( pname ), param);
#endif
    glPixelStorei(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPixelStorei");
#endif
}

// void  glPointParameterx (GLenum pname, GLfixed param);
static inline void  qglPointParameterx(GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPointParameterx(pname=%s, param=%ld)\n", StringFromGLEnumerant( pname ), param);
#endif
    glPointParameterx(pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPointParameterx");
#endif
}

// void  glPointParameterxv (GLenum pname, const GLfixed *params);
static inline void  qglPointParameterxv(GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPointParameterxv(pname=%s, params=%p)\n", StringFromGLEnumerant( pname ), params);
#endif
    glPointParameterxv(pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPointParameterxv");
#endif
}

// void  glPointSizex (GLfixed size);
static inline void  qglPointSizex(GLfixed size)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPointSizex(size=%ld)\n", size);
#endif
    glPointSizex(size);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPointSizex");
#endif
}

// void  glPolygonOffsetx (GLfixed factor, GLfixed units);
static inline void  qglPolygonOffsetx(GLfixed factor, GLfixed units)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glPolygonOffsetx(factor=%ld, units=%ld)\n", factor, units);
#endif
    glPolygonOffsetx(factor, units);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glPolygonOffsetx");
#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  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  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=%s, type=%s, pixels=%p)\n", x, y, width, height, StringFromGLEnumerant( format ), StringFromGLEnumerant( 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  glRotatex (GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
static inline void  qglRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glRotatex(angle=%ld, x=%ld, y=%ld, z=%ld)\n", angle, x, y, z);
#endif
    glRotatex(angle, x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glRotatex");
#endif
}

// void  glSampleCoverage (GLclampf value, GLboolean invert);
static inline void  qglSampleCoverage(GLclampf value, GLboolean invert)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glSampleCoverage(value=%f, invert=%u)\n", value, invert);
#endif
    glSampleCoverage(value, invert);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glSampleCoverage");
#endif
}

// void  glSampleCoveragex (GLclampx value, GLboolean invert);
static inline void  qglSampleCoveragex(GLclampx value, GLboolean invert)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glSampleCoveragex(value=%ld, invert=%u)\n", value, invert);
#endif
    glSampleCoveragex(value, invert);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glSampleCoveragex");
#endif
}

// void  glScalex (GLfixed x, GLfixed y, GLfixed z);
static inline void  qglScalex(GLfixed x, GLfixed y, GLfixed z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glScalex(x=%ld, y=%ld, z=%ld)\n", x, y, z);
#endif
    glScalex(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glScalex");
#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
	// fixme
	int vidHeight = 320;
glScissor(vidHeight - y - height, x, height, width);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glScissor");
#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=%s)\n", StringFromGLEnumerant( 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=%s, ref=%ld, mask=%lu)\n", StringFromGLEnumerant( 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=%s, zfail=%s, zpass=%s)\n", StringFromGLEnumerant( fail ), StringFromGLEnumerant( zfail ), StringFromGLEnumerant( zpass ));
#endif
    glStencilOp(fail, zfail, zpass);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glStencilOp");
#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=%s, stride=%ld, pointer=%p)\n", size, StringFromGLEnumerant( type ), stride, pointer);
#endif
    glTexCoordPointer(size, type, stride, pointer);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexCoordPointer");
#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=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), param);
#endif
    glTexEnvi(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvi");
#endif
}

// void  glTexEnvx (GLenum target, GLenum pname, GLfixed param);
static inline void  qglTexEnvx(GLenum target, GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnvx(target=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), param);
#endif
    glTexEnvx(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvx");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexEnviv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnviv");
#endif
}

// void  glTexEnvxv (GLenum target, GLenum pname, const GLfixed *params);
static inline void  qglTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexEnvxv(target=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexEnvxv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexEnvxv");
#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=%s, level=%ld, internalformat=%ld, width=%ld, height=%ld, border=%ld, format=%s, type=%s, pixels=%p)\n", StringFromGLEnumerant( target ), level, internalformat, width, height, border, StringFromGLEnumerant( format ), StringFromGLEnumerant( 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  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=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), param);
#endif
    glTexParameteri(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameteri");
#endif
}

// void  glTexParameterx (GLenum target, GLenum pname, GLfixed param);
static inline void  qglTexParameterx(GLenum target, GLenum pname, GLfixed param)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameterx(target=%s, pname=%s, param=%ld)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), param);
#endif
    glTexParameterx(target, pname, param);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameterx");
#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=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexParameteriv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameteriv");
#endif
}

// void  glTexParameterxv (GLenum target, GLenum pname, const GLfixed *params);
static inline void  qglTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTexParameterxv(target=%s, pname=%s, params=%p)\n", StringFromGLEnumerant( target ), StringFromGLEnumerant( pname ), params);
#endif
    glTexParameterxv(target, pname, params);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTexParameterxv");
#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=%s, level=%ld, xoffset=%ld, yoffset=%ld, width=%ld, height=%ld, format=%s, type=%s, pixels=%p)\n", StringFromGLEnumerant( target ), level, xoffset, yoffset, width, height, StringFromGLEnumerant( format ), StringFromGLEnumerant( 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  glTranslatex (GLfixed x, GLfixed y, GLfixed z);
static inline void  qglTranslatex(GLfixed x, GLfixed y, GLfixed z)
{
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
    if (QGLLogGLCalls)
        fprintf(QGLDebugFile(), "glTranslatex(x=%ld, y=%ld, z=%ld)\n", x, y, z);
#endif
    glTranslatex(x, y, z);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glTranslatex");
#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=%s, stride=%ld, pointer=%p)\n", size, StringFromGLEnumerant( 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
//extern glconfig_t glConfig;
	int vidHeight = 320;
	glViewport(vidHeight - y - height, x, height, width);
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
    if (!QGLBeginStarted)
        QGLCheckError("glViewport");
#endif
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Prevent calls to the 'normal' GL functions
#define glAlphaFunc CALL_THE_QGL_VERSION_OF_glAlphaFunc
#define glClearColor CALL_THE_QGL_VERSION_OF_glClearColor
#define glClearDepthf CALL_THE_QGL_VERSION_OF_glClearDepthf
#define glClipPlanef CALL_THE_QGL_VERSION_OF_glClipPlanef
#define glDepthRangef CALL_THE_QGL_VERSION_OF_glDepthRangef
#define glFogf CALL_THE_QGL_VERSION_OF_glFogf
#define glFogfv CALL_THE_QGL_VERSION_OF_glFogfv
#define glFrustumf CALL_THE_QGL_VERSION_OF_glFrustumf
#define glGetClipPlanef CALL_THE_QGL_VERSION_OF_glGetClipPlanef
#define glGetFloatv CALL_THE_QGL_VERSION_OF_glGetFloatv
#define glGetLightfv CALL_THE_QGL_VERSION_OF_glGetLightfv
#define glGetMaterialfv CALL_THE_QGL_VERSION_OF_glGetMaterialfv
#define glGetTexEnvfv CALL_THE_QGL_VERSION_OF_glGetTexEnvfv
#define glGetTexParameterfv CALL_THE_QGL_VERSION_OF_glGetTexParameterfv
#define glLightModelf CALL_THE_QGL_VERSION_OF_glLightModelf
#define glLightModelfv CALL_THE_QGL_VERSION_OF_glLightModelfv
#define glLightf CALL_THE_QGL_VERSION_OF_glLightf
#define glLightfv CALL_THE_QGL_VERSION_OF_glLightfv
#define glLineWidth CALL_THE_QGL_VERSION_OF_glLineWidth
#define glLoadMatrixf CALL_THE_QGL_VERSION_OF_glLoadMatrixf
#define glMaterialf CALL_THE_QGL_VERSION_OF_glMaterialf
#define glMaterialfv CALL_THE_QGL_VERSION_OF_glMaterialfv
#define glMultMatrixf CALL_THE_QGL_VERSION_OF_glMultMatrixf
#define glMultiTexCoord4f CALL_THE_QGL_VERSION_OF_glMultiTexCoord4f
#define glNormal3f CALL_THE_QGL_VERSION_OF_glNormal3f
#define glOrthof CALL_THE_QGL_VERSION_OF_glOrthof
#define glPointParameterf CALL_THE_QGL_VERSION_OF_glPointParameterf
#define glPointParameterfv CALL_THE_QGL_VERSION_OF_glPointParameterfv
#define glPointSize CALL_THE_QGL_VERSION_OF_glPointSize
#define glPolygonOffset CALL_THE_QGL_VERSION_OF_glPolygonOffset
#define glRotatef CALL_THE_QGL_VERSION_OF_glRotatef
#define glScalef CALL_THE_QGL_VERSION_OF_glScalef
#define glTexEnvf CALL_THE_QGL_VERSION_OF_glTexEnvf
#define glTexEnvfv CALL_THE_QGL_VERSION_OF_glTexEnvfv
#define glTexParameterf CALL_THE_QGL_VERSION_OF_glTexParameterf
#define glTexParameterfv CALL_THE_QGL_VERSION_OF_glTexParameterfv
#define glTranslatef CALL_THE_QGL_VERSION_OF_glTranslatef
#define glActiveTexture CALL_THE_QGL_VERSION_OF_glActiveTexture
#define glAlphaFuncx CALL_THE_QGL_VERSION_OF_glAlphaFuncx
#define glBindBuffer CALL_THE_QGL_VERSION_OF_glBindBuffer
#define glBindTexture CALL_THE_QGL_VERSION_OF_glBindTexture
#define glBlendFunc CALL_THE_QGL_VERSION_OF_glBlendFunc
#define glBufferData CALL_THE_QGL_VERSION_OF_glBufferData
#define glBufferSubData CALL_THE_QGL_VERSION_OF_glBufferSubData
#define glClear CALL_THE_QGL_VERSION_OF_glClear
#define glClearColorx CALL_THE_QGL_VERSION_OF_glClearColorx
#define glClearDepthx CALL_THE_QGL_VERSION_OF_glClearDepthx
#define glClearStencil CALL_THE_QGL_VERSION_OF_glClearStencil
#define glClientActiveTexture CALL_THE_QGL_VERSION_OF_glClientActiveTexture
#define glClipPlanex CALL_THE_QGL_VERSION_OF_glClipPlanex
#define glColor4ub CALL_THE_QGL_VERSION_OF_glColor4ub
#define glColor4x CALL_THE_QGL_VERSION_OF_glColor4x
#define glColorMask CALL_THE_QGL_VERSION_OF_glColorMask
#define glColorPointer CALL_THE_QGL_VERSION_OF_glColorPointer
#define glCompressedTexImage2D CALL_THE_QGL_VERSION_OF_glCompressedTexImage2D
#define glCompressedTexSubImage2D CALL_THE_QGL_VERSION_OF_glCompressedTexSubImage2D
#define glCopyTexImage2D CALL_THE_QGL_VERSION_OF_glCopyTexImage2D
#define glCopyTexSubImage2D CALL_THE_QGL_VERSION_OF_glCopyTexSubImage2D
#define glCullFace CALL_THE_QGL_VERSION_OF_glCullFace
#define glDeleteBuffers CALL_THE_QGL_VERSION_OF_glDeleteBuffers
#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 glDepthRangex CALL_THE_QGL_VERSION_OF_glDepthRangex
#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 glDrawElements CALL_THE_QGL_VERSION_OF_glDrawElements
#define glEnable CALL_THE_QGL_VERSION_OF_glEnable
#define glEnableClientState CALL_THE_QGL_VERSION_OF_glEnableClientState
#define glFinish CALL_THE_QGL_VERSION_OF_glFinish
#define glFlush CALL_THE_QGL_VERSION_OF_glFlush
#define glFogx CALL_THE_QGL_VERSION_OF_glFogx
#define glFogxv CALL_THE_QGL_VERSION_OF_glFogxv
#define glFrontFace CALL_THE_QGL_VERSION_OF_glFrontFace
#define glFrustumx CALL_THE_QGL_VERSION_OF_glFrustumx
#define glGetBooleanv CALL_THE_QGL_VERSION_OF_glGetBooleanv
#define glGetBufferParameteriv CALL_THE_QGL_VERSION_OF_glGetBufferParameteriv
#define glGetClipPlanex CALL_THE_QGL_VERSION_OF_glGetClipPlanex
#define glGenBuffers CALL_THE_QGL_VERSION_OF_glGenBuffers
#define glGenTextures CALL_THE_QGL_VERSION_OF_glGenTextures
#define glGetError CALL_THE_QGL_VERSION_OF_glGetError
#define glGetFixedv CALL_THE_QGL_VERSION_OF_glGetFixedv
#define glGetIntegerv CALL_THE_QGL_VERSION_OF_glGetIntegerv
#define glGetLightxv CALL_THE_QGL_VERSION_OF_glGetLightxv
#define glGetMaterialxv CALL_THE_QGL_VERSION_OF_glGetMaterialxv
#define glGetPointerv CALL_THE_QGL_VERSION_OF_glGetPointerv
#define glGetString CALL_THE_QGL_VERSION_OF_glGetString
#define glGetTexEnviv CALL_THE_QGL_VERSION_OF_glGetTexEnviv
#define glGetTexEnvxv CALL_THE_QGL_VERSION_OF_glGetTexEnvxv
#define glGetTexParameteriv CALL_THE_QGL_VERSION_OF_glGetTexParameteriv
#define glGetTexParameterxv CALL_THE_QGL_VERSION_OF_glGetTexParameterxv
#define glHint CALL_THE_QGL_VERSION_OF_glHint
#define glIsBuffer CALL_THE_QGL_VERSION_OF_glIsBuffer
#define glIsEnabled CALL_THE_QGL_VERSION_OF_glIsEnabled
#define glIsTexture CALL_THE_QGL_VERSION_OF_glIsTexture
#define glLightModelx CALL_THE_QGL_VERSION_OF_glLightModelx
#define glLightModelxv CALL_THE_QGL_VERSION_OF_glLightModelxv
#define glLightx CALL_THE_QGL_VERSION_OF_glLightx
#define glLightxv CALL_THE_QGL_VERSION_OF_glLightxv
#define glLineWidthx CALL_THE_QGL_VERSION_OF_glLineWidthx
#define glLoadIdentity CALL_THE_QGL_VERSION_OF_glLoadIdentity
#define glLoadMatrixx CALL_THE_QGL_VERSION_OF_glLoadMatrixx
#define glLogicOp CALL_THE_QGL_VERSION_OF_glLogicOp
#define glMaterialx CALL_THE_QGL_VERSION_OF_glMaterialx
#define glMaterialxv CALL_THE_QGL_VERSION_OF_glMaterialxv
#define glMatrixMode CALL_THE_QGL_VERSION_OF_glMatrixMode
#define glMultMatrixx CALL_THE_QGL_VERSION_OF_glMultMatrixx
#define glMultiTexCoord4x CALL_THE_QGL_VERSION_OF_glMultiTexCoord4x
#define glNormal3x CALL_THE_QGL_VERSION_OF_glNormal3x
#define glNormalPointer CALL_THE_QGL_VERSION_OF_glNormalPointer
#define glOrthox CALL_THE_QGL_VERSION_OF_glOrthox
#define glPixelStorei CALL_THE_QGL_VERSION_OF_glPixelStorei
#define glPointParameterx CALL_THE_QGL_VERSION_OF_glPointParameterx
#define glPointParameterxv CALL_THE_QGL_VERSION_OF_glPointParameterxv
#define glPointSizex CALL_THE_QGL_VERSION_OF_glPointSizex
#define glPolygonOffsetx CALL_THE_QGL_VERSION_OF_glPolygonOffsetx
#define glPopMatrix CALL_THE_QGL_VERSION_OF_glPopMatrix
#define glPushMatrix CALL_THE_QGL_VERSION_OF_glPushMatrix
#define glReadPixels CALL_THE_QGL_VERSION_OF_glReadPixels
#define glRotatex CALL_THE_QGL_VERSION_OF_glRotatex
#define glSampleCoverage CALL_THE_QGL_VERSION_OF_glSampleCoverage
#define glSampleCoveragex CALL_THE_QGL_VERSION_OF_glSampleCoveragex
#define glScalex CALL_THE_QGL_VERSION_OF_glScalex
#define glScissor CALL_THE_QGL_VERSION_OF_glScissor
#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 glTexCoordPointer CALL_THE_QGL_VERSION_OF_glTexCoordPointer
#define glTexEnvi CALL_THE_QGL_VERSION_OF_glTexEnvi
#define glTexEnvx CALL_THE_QGL_VERSION_OF_glTexEnvx
#define glTexEnviv CALL_THE_QGL_VERSION_OF_glTexEnviv
#define glTexEnvxv CALL_THE_QGL_VERSION_OF_glTexEnvxv
#define glTexImage2D CALL_THE_QGL_VERSION_OF_glTexImage2D
#define glTexParameteri CALL_THE_QGL_VERSION_OF_glTexParameteri
#define glTexParameterx CALL_THE_QGL_VERSION_OF_glTexParameterx
#define glTexParameteriv CALL_THE_QGL_VERSION_OF_glTexParameteriv
#define glTexParameterxv CALL_THE_QGL_VERSION_OF_glTexParameterxv
#define glTexSubImage2D CALL_THE_QGL_VERSION_OF_glTexSubImage2D
#define glTranslatex CALL_THE_QGL_VERSION_OF_glTranslatex
#define glVertexPointer CALL_THE_QGL_VERSION_OF_glVertexPointer
#define glViewport CALL_THE_QGL_VERSION_OF_glViewport
#define glCurrentPaletteMatrixOES CALL_THE_QGL_VERSION_OF_glCurrentPaletteMatrixOES
#define glLoadPaletteFromModelViewMatrixOES CALL_THE_QGL_VERSION_OF_glLoadPaletteFromModelViewMatrixOES
#define glMatrixIndexPointerOES CALL_THE_QGL_VERSION_OF_glMatrixIndexPointerOES
#define glWeightPointerOES CALL_THE_QGL_VERSION_OF_glWeightPointerOES
#define glPointSizePointerOES CALL_THE_QGL_VERSION_OF_glPointSizePointerOES
#define glDrawTexsOES CALL_THE_QGL_VERSION_OF_glDrawTexsOES
#define glDrawTexiOES CALL_THE_QGL_VERSION_OF_glDrawTexiOES
#define glDrawTexxOES CALL_THE_QGL_VERSION_OF_glDrawTexxOES
#define glDrawTexsvOES CALL_THE_QGL_VERSION_OF_glDrawTexsvOES
#define glDrawTexivOES CALL_THE_QGL_VERSION_OF_glDrawTexivOES
#define glDrawTexxvOES CALL_THE_QGL_VERSION_OF_glDrawTexxvOES
#define glDrawTexfOES CALL_THE_QGL_VERSION_OF_glDrawTexfOES
#define glDrawTexfvOES CALL_THE_QGL_VERSION_OF_glDrawTexfvOES

#endif // _IPHONE_QGL_H_