macosx_qgl.h

quakeIII源码这个不用我多说吧

/*
===========================================================================
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)
{