mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-12-13 21:51:09 +00:00
5095 lines
168 KiB
C
Executable file
5095 lines
168 KiB
C
Executable file
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
/**** This file is autogenerated. Run GenerateQGL.pl to update it ****/
|
|
|
|
#ifdef QGL_LOG_GL_CALLS
|
|
extern unsigned int QGLLogGLCalls;
|
|
extern FILE *QGLDebugFile(void);
|
|
#endif
|
|
|
|
extern void QGLCheckError(const char *message);
|
|
extern unsigned int QGLBeginStarted;
|
|
|
|
// This has to be done to avoid infinite recursion between our glGetError wrapper and QGLCheckError()
|
|
static inline GLenum _glGetError(void) {
|
|
return glGetError();
|
|
}
|
|
|
|
// void glAccum (GLenum op, GLfloat value);
|
|
static inline void qglAccum(GLenum op, GLfloat value)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glAccum(op=%lu, value=%f)\n", op, value);
|
|
#endif
|
|
glAccum(op, value);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glAccum");
|
|
#endif
|
|
}
|
|
|
|
// void glAlphaFunc (GLenum func, GLclampf ref);
|
|
static inline void qglAlphaFunc(GLenum func, GLclampf ref)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glAlphaFunc(func=%lu, ref=%f)\n", func, ref);
|
|
#endif
|
|
glAlphaFunc(func, ref);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glAlphaFunc");
|
|
#endif
|
|
}
|
|
|
|
// GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences);
|
|
static inline GLboolean qglAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
|
|
{
|
|
GLboolean returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glAreTexturesResident(n=%ld, textures=%p, residences=%p)\n", n, textures, residences);
|
|
#endif
|
|
returnValue = glAreTexturesResident(n, textures, residences);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glAreTexturesResident");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glArrayElement (GLint i);
|
|
static inline void qglArrayElement(GLint i)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glArrayElement(i=%ld)\n", i);
|
|
#endif
|
|
glArrayElement(i);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glArrayElement");
|
|
#endif
|
|
}
|
|
|
|
// void glBegin (GLenum mode);
|
|
static inline void qglBegin(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glBegin(mode=%lu)\n", mode);
|
|
#endif
|
|
glBegin(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
QGLBeginStarted++;
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glBegin");
|
|
#endif
|
|
}
|
|
|
|
// void glBindTexture (GLenum target, GLuint texture);
|
|
static inline void qglBindTexture(GLenum target, GLuint texture)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glBindTexture(target=%lu, texture=%lu)\n", target, texture);
|
|
#endif
|
|
glBindTexture(target, texture);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glBindTexture");
|
|
#endif
|
|
}
|
|
|
|
// void glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
|
|
static inline void qglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glBitmap(width=%ld, height=%ld, xorig=%f, yorig=%f, xmove=%f, ymove=%f, bitmap=%p)\n", width, height, xorig, yorig, xmove, ymove, bitmap);
|
|
#endif
|
|
glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glBitmap");
|
|
#endif
|
|
}
|
|
|
|
// void glBlendFunc (GLenum sfactor, GLenum dfactor);
|
|
static inline void qglBlendFunc(GLenum sfactor, GLenum dfactor)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glBlendFunc(sfactor=%lu, dfactor=%lu)\n", sfactor, dfactor);
|
|
#endif
|
|
glBlendFunc(sfactor, dfactor);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glBlendFunc");
|
|
#endif
|
|
}
|
|
|
|
// void glCallList (GLuint list);
|
|
static inline void qglCallList(GLuint list)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCallList(list=%lu)\n", list);
|
|
#endif
|
|
glCallList(list);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCallList");
|
|
#endif
|
|
}
|
|
|
|
// void glCallLists (GLsizei n, GLenum type, const GLvoid *lists);
|
|
static inline void qglCallLists(GLsizei n, GLenum type, const GLvoid *lists)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCallLists(n=%ld, type=%lu, lists=%p)\n", n, type, lists);
|
|
#endif
|
|
glCallLists(n, type, lists);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCallLists");
|
|
#endif
|
|
}
|
|
|
|
// void glClear (GLbitfield mask);
|
|
static inline void qglClear(GLbitfield mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClear(mask=%lu)\n", mask);
|
|
#endif
|
|
glClear(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClear");
|
|
#endif
|
|
}
|
|
|
|
// void glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
|
|
static inline void qglClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClearAccum(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
|
|
#endif
|
|
glClearAccum(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClearAccum");
|
|
#endif
|
|
}
|
|
|
|
// void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
|
|
static inline void qglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClearColor(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
|
|
#endif
|
|
glClearColor(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClearColor");
|
|
#endif
|
|
}
|
|
|
|
// void glClearDepth (GLclampd depth);
|
|
static inline void qglClearDepth(GLclampd depth)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClearDepth(depth=%f)\n", depth);
|
|
#endif
|
|
glClearDepth(depth);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClearDepth");
|
|
#endif
|
|
}
|
|
|
|
// void glClearIndex (GLfloat c);
|
|
static inline void qglClearIndex(GLfloat c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClearIndex(c=%f)\n", c);
|
|
#endif
|
|
glClearIndex(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClearIndex");
|
|
#endif
|
|
}
|
|
|
|
// void glClearStencil (GLint s);
|
|
static inline void qglClearStencil(GLint s)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClearStencil(s=%ld)\n", s);
|
|
#endif
|
|
glClearStencil(s);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClearStencil");
|
|
#endif
|
|
}
|
|
|
|
// void glClipPlane (GLenum plane, const GLdouble *equation);
|
|
static inline void qglClipPlane(GLenum plane, const GLdouble *equation)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glClipPlane(plane=%lu, equation=%p)\n", plane, equation);
|
|
#endif
|
|
glClipPlane(plane, equation);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glClipPlane");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3b (GLbyte red, GLbyte green, GLbyte blue);
|
|
static inline void qglColor3b(GLbyte red, GLbyte green, GLbyte blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3b(red=%d, green=%d, blue=%d)\n", red, green, blue);
|
|
#endif
|
|
glColor3b(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3b");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3bv (const GLbyte *v);
|
|
static inline void qglColor3bv(const GLbyte *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3bv(v=%p)\n", v);
|
|
#endif
|
|
glColor3bv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3bv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3d (GLdouble red, GLdouble green, GLdouble blue);
|
|
static inline void qglColor3d(GLdouble red, GLdouble green, GLdouble blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3d(red=%f, green=%f, blue=%f)\n", red, green, blue);
|
|
#endif
|
|
glColor3d(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3d");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3dv (const GLdouble *v);
|
|
static inline void qglColor3dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3dv(v=%p)\n", v);
|
|
#endif
|
|
glColor3dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3dv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3f (GLfloat red, GLfloat green, GLfloat blue);
|
|
static inline void qglColor3f(GLfloat red, GLfloat green, GLfloat blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3f(red=%f, green=%f, blue=%f)\n", red, green, blue);
|
|
#endif
|
|
glColor3f(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3f");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3fv (const GLfloat *v);
|
|
static inline void qglColor3fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3fv(v=%p)\n", v);
|
|
#endif
|
|
glColor3fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3fv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3i (GLint red, GLint green, GLint blue);
|
|
static inline void qglColor3i(GLint red, GLint green, GLint blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3i(red=%ld, green=%ld, blue=%ld)\n", red, green, blue);
|
|
#endif
|
|
glColor3i(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3i");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3iv (const GLint *v);
|
|
static inline void qglColor3iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3iv(v=%p)\n", v);
|
|
#endif
|
|
glColor3iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3iv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3s (GLshort red, GLshort green, GLshort blue);
|
|
static inline void qglColor3s(GLshort red, GLshort green, GLshort blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3s(red=%d, green=%d, blue=%d)\n", red, green, blue);
|
|
#endif
|
|
glColor3s(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3s");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3sv (const GLshort *v);
|
|
static inline void qglColor3sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3sv(v=%p)\n", v);
|
|
#endif
|
|
glColor3sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3sv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3ub (GLubyte red, GLubyte green, GLubyte blue);
|
|
static inline void qglColor3ub(GLubyte red, GLubyte green, GLubyte blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3ub(red=%u, green=%u, blue=%u)\n", red, green, blue);
|
|
#endif
|
|
glColor3ub(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3ub");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3ubv (const GLubyte *v);
|
|
static inline void qglColor3ubv(const GLubyte *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3ubv(v=%p)\n", v);
|
|
#endif
|
|
glColor3ubv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3ubv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3ui (GLuint red, GLuint green, GLuint blue);
|
|
static inline void qglColor3ui(GLuint red, GLuint green, GLuint blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3ui(red=%lu, green=%lu, blue=%lu)\n", red, green, blue);
|
|
#endif
|
|
glColor3ui(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3ui");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3uiv (const GLuint *v);
|
|
static inline void qglColor3uiv(const GLuint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3uiv(v=%p)\n", v);
|
|
#endif
|
|
glColor3uiv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3uiv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3us (GLushort red, GLushort green, GLushort blue);
|
|
static inline void qglColor3us(GLushort red, GLushort green, GLushort blue)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3us(red=%u, green=%u, blue=%u)\n", red, green, blue);
|
|
#endif
|
|
glColor3us(red, green, blue);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3us");
|
|
#endif
|
|
}
|
|
|
|
// void glColor3usv (const GLushort *v);
|
|
static inline void qglColor3usv(const GLushort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor3usv(v=%p)\n", v);
|
|
#endif
|
|
glColor3usv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor3usv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
|
|
static inline void qglColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4b(red=%d, green=%d, blue=%d, alpha=%d)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4b(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4b");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4bv (const GLbyte *v);
|
|
static inline void qglColor4bv(const GLbyte *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4bv(v=%p)\n", v);
|
|
#endif
|
|
glColor4bv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4bv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
|
|
static inline void qglColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4d(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4d(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4d");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4dv (const GLdouble *v);
|
|
static inline void qglColor4dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4dv(v=%p)\n", v);
|
|
#endif
|
|
glColor4dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4dv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
|
|
static inline void qglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4f(red=%f, green=%f, blue=%f, alpha=%f)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4f(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4f");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4fv (const GLfloat *v);
|
|
static inline void qglColor4fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4fv(v=%p)\n", v);
|
|
#endif
|
|
glColor4fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4fv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4i (GLint red, GLint green, GLint blue, GLint alpha);
|
|
static inline void qglColor4i(GLint red, GLint green, GLint blue, GLint alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4i(red=%ld, green=%ld, blue=%ld, alpha=%ld)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4i(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4i");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4iv (const GLint *v);
|
|
static inline void qglColor4iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4iv(v=%p)\n", v);
|
|
#endif
|
|
glColor4iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4iv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha);
|
|
static inline void qglColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4s(red=%d, green=%d, blue=%d, alpha=%d)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4s(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4s");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4sv (const GLshort *v);
|
|
static inline void qglColor4sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4sv(v=%p)\n", v);
|
|
#endif
|
|
glColor4sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4sv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
|
|
static inline void qglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4ub(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4ub(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4ub");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4ubv (const GLubyte *v);
|
|
static inline void qglColor4ubv(const GLubyte *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4ubv(v=%p)\n", v);
|
|
#endif
|
|
glColor4ubv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4ubv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha);
|
|
static inline void qglColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4ui(red=%lu, green=%lu, blue=%lu, alpha=%lu)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4ui(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4ui");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4uiv (const GLuint *v);
|
|
static inline void qglColor4uiv(const GLuint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4uiv(v=%p)\n", v);
|
|
#endif
|
|
glColor4uiv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4uiv");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha);
|
|
static inline void qglColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4us(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColor4us(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4us");
|
|
#endif
|
|
}
|
|
|
|
// void glColor4usv (const GLushort *v);
|
|
static inline void qglColor4usv(const GLushort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColor4usv(v=%p)\n", v);
|
|
#endif
|
|
glColor4usv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColor4usv");
|
|
#endif
|
|
}
|
|
|
|
// void glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
|
|
static inline void qglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColorMask(red=%u, green=%u, blue=%u, alpha=%u)\n", red, green, blue, alpha);
|
|
#endif
|
|
glColorMask(red, green, blue, alpha);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColorMask");
|
|
#endif
|
|
}
|
|
|
|
// void glColorMaterial (GLenum face, GLenum mode);
|
|
static inline void qglColorMaterial(GLenum face, GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColorMaterial(face=%lu, mode=%lu)\n", face, mode);
|
|
#endif
|
|
glColorMaterial(face, mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColorMaterial");
|
|
#endif
|
|
}
|
|
|
|
// void glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glColorPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
|
|
#endif
|
|
glColorPointer(size, type, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glColorPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
|
|
static inline void qglCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCopyPixels(x=%ld, y=%ld, width=%ld, height=%ld, type=%lu)\n", x, y, width, height, type);
|
|
#endif
|
|
glCopyPixels(x, y, width, height, type);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCopyPixels");
|
|
#endif
|
|
}
|
|
|
|
// void glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
|
|
static inline void qglCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCopyTexImage1D(target=%lu, level=%ld, internalFormat=%lu, x=%ld, y=%ld, width=%ld, border=%ld)\n", target, level, internalFormat, x, y, width, border);
|
|
#endif
|
|
glCopyTexImage1D(target, level, internalFormat, x, y, width, border);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCopyTexImage1D");
|
|
#endif
|
|
}
|
|
|
|
// void glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
|
|
static inline void qglCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCopyTexImage2D(target=%lu, level=%ld, internalFormat=%lu, x=%ld, y=%ld, width=%ld, height=%ld, border=%ld)\n", target, level, internalFormat, x, y, width, height, border);
|
|
#endif
|
|
glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCopyTexImage2D");
|
|
#endif
|
|
}
|
|
|
|
// void glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
|
|
static inline void qglCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCopyTexSubImage1D(target=%lu, level=%ld, xoffset=%ld, x=%ld, y=%ld, width=%ld)\n", target, level, xoffset, x, y, width);
|
|
#endif
|
|
glCopyTexSubImage1D(target, level, xoffset, x, y, width);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCopyTexSubImage1D");
|
|
#endif
|
|
}
|
|
|
|
// void glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
|
|
static inline void qglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCopyTexSubImage2D(target=%lu, level=%ld, xoffset=%ld, yoffset=%ld, x=%ld, y=%ld, width=%ld, height=%ld)\n", target, level, xoffset, yoffset, x, y, width, height);
|
|
#endif
|
|
glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCopyTexSubImage2D");
|
|
#endif
|
|
}
|
|
|
|
// void glCullFace (GLenum mode);
|
|
static inline void qglCullFace(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glCullFace(mode=%lu)\n", mode);
|
|
#endif
|
|
glCullFace(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glCullFace");
|
|
#endif
|
|
}
|
|
|
|
// void glDeleteLists (GLuint list, GLsizei range);
|
|
static inline void qglDeleteLists(GLuint list, GLsizei range)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDeleteLists(list=%lu, range=%ld)\n", list, range);
|
|
#endif
|
|
glDeleteLists(list, range);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDeleteLists");
|
|
#endif
|
|
}
|
|
|
|
// void glDeleteTextures (GLsizei n, const GLuint *textures);
|
|
static inline void qglDeleteTextures(GLsizei n, const GLuint *textures)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDeleteTextures(n=%ld, textures=%p)\n", n, textures);
|
|
#endif
|
|
glDeleteTextures(n, textures);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDeleteTextures");
|
|
#endif
|
|
}
|
|
|
|
// void glDepthFunc (GLenum func);
|
|
static inline void qglDepthFunc(GLenum func)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDepthFunc(func=%lu)\n", func);
|
|
#endif
|
|
glDepthFunc(func);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDepthFunc");
|
|
#endif
|
|
}
|
|
|
|
// void glDepthMask (GLboolean flag);
|
|
static inline void qglDepthMask(GLboolean flag)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDepthMask(flag=%u)\n", flag);
|
|
#endif
|
|
glDepthMask(flag);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDepthMask");
|
|
#endif
|
|
}
|
|
|
|
// void glDepthRange (GLclampd zNear, GLclampd zFar);
|
|
static inline void qglDepthRange(GLclampd zNear, GLclampd zFar)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDepthRange(zNear=%f, zFar=%f)\n", zNear, zFar);
|
|
#endif
|
|
glDepthRange(zNear, zFar);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDepthRange");
|
|
#endif
|
|
}
|
|
|
|
// void glDisable (GLenum cap);
|
|
static inline void qglDisable(GLenum cap)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDisable(cap=%lu)\n", cap);
|
|
#endif
|
|
glDisable(cap);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDisable");
|
|
#endif
|
|
}
|
|
|
|
// void glDisableClientState (GLenum array);
|
|
static inline void qglDisableClientState(GLenum array)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDisableClientState(array=%lu)\n", array);
|
|
#endif
|
|
glDisableClientState(array);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDisableClientState");
|
|
#endif
|
|
}
|
|
|
|
// void glDrawArrays (GLenum mode, GLint first, GLsizei count);
|
|
static inline void qglDrawArrays(GLenum mode, GLint first, GLsizei count)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDrawArrays(mode=%lu, first=%ld, count=%ld)\n", mode, first, count);
|
|
#endif
|
|
glDrawArrays(mode, first, count);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDrawArrays");
|
|
#endif
|
|
}
|
|
|
|
// void glDrawBuffer (GLenum mode);
|
|
static inline void qglDrawBuffer(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDrawBuffer(mode=%lu)\n", mode);
|
|
#endif
|
|
glDrawBuffer(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDrawBuffer");
|
|
#endif
|
|
}
|
|
|
|
// void glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
|
|
static inline void qglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDrawElements(mode=%lu, count=%ld, type=%lu, indices=%p)\n", mode, count, type, indices);
|
|
#endif
|
|
glDrawElements(mode, count, type, indices);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDrawElements");
|
|
#endif
|
|
}
|
|
|
|
// void glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
|
|
static inline void qglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glDrawPixels(width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", width, height, format, type, pixels);
|
|
#endif
|
|
glDrawPixels(width, height, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glDrawPixels");
|
|
#endif
|
|
}
|
|
|
|
// void glEdgeFlag (GLboolean flag);
|
|
static inline void qglEdgeFlag(GLboolean flag)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEdgeFlag(flag=%u)\n", flag);
|
|
#endif
|
|
glEdgeFlag(flag);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEdgeFlag");
|
|
#endif
|
|
}
|
|
|
|
// void glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEdgeFlagPointer(stride=%ld, pointer=%p)\n", stride, pointer);
|
|
#endif
|
|
glEdgeFlagPointer(stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEdgeFlagPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glEdgeFlagv (const GLboolean *flag);
|
|
static inline void qglEdgeFlagv(const GLboolean *flag)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEdgeFlagv(flag=%p)\n", flag);
|
|
#endif
|
|
glEdgeFlagv(flag);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEdgeFlagv");
|
|
#endif
|
|
}
|
|
|
|
// void glEnable (GLenum cap);
|
|
static inline void qglEnable(GLenum cap)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEnable(cap=%lu)\n", cap);
|
|
#endif
|
|
glEnable(cap);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEnable");
|
|
#endif
|
|
}
|
|
|
|
// void glEnableClientState (GLenum array);
|
|
static inline void qglEnableClientState(GLenum array)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEnableClientState(array=%lu)\n", array);
|
|
#endif
|
|
glEnableClientState(array);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEnableClientState");
|
|
#endif
|
|
}
|
|
|
|
// void glEnd (void);
|
|
static inline void qglEnd(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEnd(void)\n");
|
|
#endif
|
|
glEnd();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
QGLBeginStarted--;
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEnd");
|
|
#endif
|
|
}
|
|
|
|
// void glEndList (void);
|
|
static inline void qglEndList(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEndList(void)\n");
|
|
#endif
|
|
glEndList();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEndList");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord1d (GLdouble u);
|
|
static inline void qglEvalCoord1d(GLdouble u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord1d(u=%f)\n", u);
|
|
#endif
|
|
glEvalCoord1d(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord1d");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord1dv (const GLdouble *u);
|
|
static inline void qglEvalCoord1dv(const GLdouble *u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord1dv(u=%p)\n", u);
|
|
#endif
|
|
glEvalCoord1dv(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord1dv");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord1f (GLfloat u);
|
|
static inline void qglEvalCoord1f(GLfloat u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord1f(u=%f)\n", u);
|
|
#endif
|
|
glEvalCoord1f(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord1f");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord1fv (const GLfloat *u);
|
|
static inline void qglEvalCoord1fv(const GLfloat *u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord1fv(u=%p)\n", u);
|
|
#endif
|
|
glEvalCoord1fv(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord1fv");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord2d (GLdouble u, GLdouble v);
|
|
static inline void qglEvalCoord2d(GLdouble u, GLdouble v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord2d(u=%f, v=%f)\n", u, v);
|
|
#endif
|
|
glEvalCoord2d(u, v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord2d");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord2dv (const GLdouble *u);
|
|
static inline void qglEvalCoord2dv(const GLdouble *u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord2dv(u=%p)\n", u);
|
|
#endif
|
|
glEvalCoord2dv(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord2dv");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord2f (GLfloat u, GLfloat v);
|
|
static inline void qglEvalCoord2f(GLfloat u, GLfloat v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord2f(u=%f, v=%f)\n", u, v);
|
|
#endif
|
|
glEvalCoord2f(u, v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord2f");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalCoord2fv (const GLfloat *u);
|
|
static inline void qglEvalCoord2fv(const GLfloat *u)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalCoord2fv(u=%p)\n", u);
|
|
#endif
|
|
glEvalCoord2fv(u);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalCoord2fv");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalMesh1 (GLenum mode, GLint i1, GLint i2);
|
|
static inline void qglEvalMesh1(GLenum mode, GLint i1, GLint i2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalMesh1(mode=%lu, i1=%ld, i2=%ld)\n", mode, i1, i2);
|
|
#endif
|
|
glEvalMesh1(mode, i1, i2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalMesh1");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
|
|
static inline void qglEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalMesh2(mode=%lu, i1=%ld, i2=%ld, j1=%ld, j2=%ld)\n", mode, i1, i2, j1, j2);
|
|
#endif
|
|
glEvalMesh2(mode, i1, i2, j1, j2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalMesh2");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalPoint1 (GLint i);
|
|
static inline void qglEvalPoint1(GLint i)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalPoint1(i=%ld)\n", i);
|
|
#endif
|
|
glEvalPoint1(i);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalPoint1");
|
|
#endif
|
|
}
|
|
|
|
// void glEvalPoint2 (GLint i, GLint j);
|
|
static inline void qglEvalPoint2(GLint i, GLint j)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glEvalPoint2(i=%ld, j=%ld)\n", i, j);
|
|
#endif
|
|
glEvalPoint2(i, j);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glEvalPoint2");
|
|
#endif
|
|
}
|
|
|
|
// void glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer);
|
|
static inline void qglFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFeedbackBuffer(size=%ld, type=%lu, buffer=%p)\n", size, type, buffer);
|
|
#endif
|
|
glFeedbackBuffer(size, type, buffer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFeedbackBuffer");
|
|
#endif
|
|
}
|
|
|
|
// void glFinish (void);
|
|
static inline void qglFinish(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFinish(void)\n");
|
|
#endif
|
|
glFinish();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFinish");
|
|
#endif
|
|
}
|
|
|
|
// void glFlush (void);
|
|
static inline void qglFlush(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFlush(void)\n");
|
|
#endif
|
|
glFlush();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFlush");
|
|
#endif
|
|
}
|
|
|
|
// void glFogf (GLenum pname, GLfloat param);
|
|
static inline void qglFogf(GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFogf(pname=%lu, param=%f)\n", pname, param);
|
|
#endif
|
|
glFogf(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFogf");
|
|
#endif
|
|
}
|
|
|
|
// void glFogfv (GLenum pname, const GLfloat *params);
|
|
static inline void qglFogfv(GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFogfv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glFogfv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFogfv");
|
|
#endif
|
|
}
|
|
|
|
// void glFogi (GLenum pname, GLint param);
|
|
static inline void qglFogi(GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFogi(pname=%lu, param=%ld)\n", pname, param);
|
|
#endif
|
|
glFogi(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFogi");
|
|
#endif
|
|
}
|
|
|
|
// void glFogiv (GLenum pname, const GLint *params);
|
|
static inline void qglFogiv(GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFogiv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glFogiv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFogiv");
|
|
#endif
|
|
}
|
|
|
|
// void glFrontFace (GLenum mode);
|
|
static inline void qglFrontFace(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFrontFace(mode=%lu)\n", mode);
|
|
#endif
|
|
glFrontFace(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFrontFace");
|
|
#endif
|
|
}
|
|
|
|
// void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
|
|
static inline void qglFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glFrustum(left=%f, right=%f, bottom=%f, top=%f, zNear=%f, zFar=%f)\n", left, right, bottom, top, zNear, zFar);
|
|
#endif
|
|
glFrustum(left, right, bottom, top, zNear, zFar);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glFrustum");
|
|
#endif
|
|
}
|
|
|
|
// GLuint glGenLists (GLsizei range);
|
|
static inline GLuint qglGenLists(GLsizei range)
|
|
{
|
|
GLuint returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGenLists(range=%ld)\n", range);
|
|
#endif
|
|
returnValue = glGenLists(range);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGenLists");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glGenTextures (GLsizei n, GLuint *textures);
|
|
static inline void qglGenTextures(GLsizei n, GLuint *textures)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGenTextures(n=%ld, textures=%p)\n", n, textures);
|
|
#endif
|
|
glGenTextures(n, textures);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGenTextures");
|
|
#endif
|
|
}
|
|
|
|
// void glGetBooleanv (GLenum pname, GLboolean *params);
|
|
static inline void qglGetBooleanv(GLenum pname, GLboolean *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetBooleanv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glGetBooleanv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetBooleanv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetClipPlane (GLenum plane, GLdouble *equation);
|
|
static inline void qglGetClipPlane(GLenum plane, GLdouble *equation)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetClipPlane(plane=%lu, equation=%p)\n", plane, equation);
|
|
#endif
|
|
glGetClipPlane(plane, equation);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetClipPlane");
|
|
#endif
|
|
}
|
|
|
|
// void glGetDoublev (GLenum pname, GLdouble *params);
|
|
static inline void qglGetDoublev(GLenum pname, GLdouble *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetDoublev(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glGetDoublev(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetDoublev");
|
|
#endif
|
|
}
|
|
|
|
// GLenum glGetError (void);
|
|
static inline GLenum qglGetError(void)
|
|
{
|
|
GLenum returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetError(void)\n");
|
|
#endif
|
|
returnValue = glGetError();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetError");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glGetFloatv (GLenum pname, GLfloat *params);
|
|
static inline void qglGetFloatv(GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetFloatv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glGetFloatv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetFloatv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetIntegerv (GLenum pname, GLint *params);
|
|
static inline void qglGetIntegerv(GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetIntegerv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glGetIntegerv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetIntegerv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetLightfv (GLenum light, GLenum pname, GLfloat *params);
|
|
static inline void qglGetLightfv(GLenum light, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetLightfv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
|
|
#endif
|
|
glGetLightfv(light, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetLightfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetLightiv (GLenum light, GLenum pname, GLint *params);
|
|
static inline void qglGetLightiv(GLenum light, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetLightiv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
|
|
#endif
|
|
glGetLightiv(light, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetLightiv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetMapdv (GLenum target, GLenum query, GLdouble *v);
|
|
static inline void qglGetMapdv(GLenum target, GLenum query, GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetMapdv(target=%lu, query=%lu, v=%p)\n", target, query, v);
|
|
#endif
|
|
glGetMapdv(target, query, v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetMapdv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetMapfv (GLenum target, GLenum query, GLfloat *v);
|
|
static inline void qglGetMapfv(GLenum target, GLenum query, GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetMapfv(target=%lu, query=%lu, v=%p)\n", target, query, v);
|
|
#endif
|
|
glGetMapfv(target, query, v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetMapfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetMapiv (GLenum target, GLenum query, GLint *v);
|
|
static inline void qglGetMapiv(GLenum target, GLenum query, GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetMapiv(target=%lu, query=%lu, v=%p)\n", target, query, v);
|
|
#endif
|
|
glGetMapiv(target, query, v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetMapiv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params);
|
|
static inline void qglGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetMaterialfv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
|
|
#endif
|
|
glGetMaterialfv(face, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetMaterialfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetMaterialiv (GLenum face, GLenum pname, GLint *params);
|
|
static inline void qglGetMaterialiv(GLenum face, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetMaterialiv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
|
|
#endif
|
|
glGetMaterialiv(face, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetMaterialiv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetPixelMapfv (GLenum map, GLfloat *values);
|
|
static inline void qglGetPixelMapfv(GLenum map, GLfloat *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetPixelMapfv(map=%lu, values=%p)\n", map, values);
|
|
#endif
|
|
glGetPixelMapfv(map, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetPixelMapfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetPixelMapuiv (GLenum map, GLuint *values);
|
|
static inline void qglGetPixelMapuiv(GLenum map, GLuint *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetPixelMapuiv(map=%lu, values=%p)\n", map, values);
|
|
#endif
|
|
glGetPixelMapuiv(map, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetPixelMapuiv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetPixelMapusv (GLenum map, GLushort *values);
|
|
static inline void qglGetPixelMapusv(GLenum map, GLushort *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetPixelMapusv(map=%lu, values=%p)\n", map, values);
|
|
#endif
|
|
glGetPixelMapusv(map, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetPixelMapusv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetPointerv (GLenum pname, GLvoid* *params);
|
|
static inline void qglGetPointerv(GLenum pname, GLvoid* *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetPointerv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glGetPointerv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetPointerv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetPolygonStipple (GLubyte *mask);
|
|
static inline void qglGetPolygonStipple(GLubyte *mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetPolygonStipple(mask=%p)\n", mask);
|
|
#endif
|
|
glGetPolygonStipple(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetPolygonStipple");
|
|
#endif
|
|
}
|
|
|
|
// const GLubyte * glGetString (GLenum name);
|
|
static inline const GLubyte * qglGetString(GLenum name)
|
|
{
|
|
const GLubyte * returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetString(name=%lu)\n", name);
|
|
#endif
|
|
returnValue = glGetString(name);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetString");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);
|
|
static inline void qglGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexEnvfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glGetTexEnvfv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexEnvfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexEnviv (GLenum target, GLenum pname, GLint *params);
|
|
static inline void qglGetTexEnviv(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexEnviv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glGetTexEnviv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexEnviv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);
|
|
static inline void qglGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexGendv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glGetTexGendv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexGendv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);
|
|
static inline void qglGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexGenfv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glGetTexGenfv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexGenfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);
|
|
static inline void qglGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexGeniv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glGetTexGeniv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexGeniv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
|
|
static inline void qglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexImage(target=%lu, level=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, format, type, pixels);
|
|
#endif
|
|
glGetTexImage(target, level, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexImage");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
|
|
static inline void qglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexLevelParameterfv(target=%lu, level=%ld, pname=%lu, params=%p)\n", target, level, pname, params);
|
|
#endif
|
|
glGetTexLevelParameterfv(target, level, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexLevelParameterfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
|
|
static inline void qglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexLevelParameteriv(target=%lu, level=%ld, pname=%lu, params=%p)\n", target, level, pname, params);
|
|
#endif
|
|
glGetTexLevelParameteriv(target, level, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexLevelParameteriv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params);
|
|
static inline void qglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexParameterfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glGetTexParameterfv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexParameterfv");
|
|
#endif
|
|
}
|
|
|
|
// void glGetTexParameteriv (GLenum target, GLenum pname, GLint *params);
|
|
static inline void qglGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glGetTexParameteriv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glGetTexParameteriv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glGetTexParameteriv");
|
|
#endif
|
|
}
|
|
|
|
// void glHint (GLenum target, GLenum mode);
|
|
static inline void qglHint(GLenum target, GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glHint(target=%lu, mode=%lu)\n", target, mode);
|
|
#endif
|
|
glHint(target, mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glHint");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexMask (GLuint mask);
|
|
static inline void qglIndexMask(GLuint mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexMask(mask=%lu)\n", mask);
|
|
#endif
|
|
glIndexMask(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexMask");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexPointer(type=%lu, stride=%ld, pointer=%p)\n", type, stride, pointer);
|
|
#endif
|
|
glIndexPointer(type, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexd (GLdouble c);
|
|
static inline void qglIndexd(GLdouble c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexd(c=%f)\n", c);
|
|
#endif
|
|
glIndexd(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexd");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexdv (const GLdouble *c);
|
|
static inline void qglIndexdv(const GLdouble *c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexdv(c=%p)\n", c);
|
|
#endif
|
|
glIndexdv(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexdv");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexf (GLfloat c);
|
|
static inline void qglIndexf(GLfloat c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexf(c=%f)\n", c);
|
|
#endif
|
|
glIndexf(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexf");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexfv (const GLfloat *c);
|
|
static inline void qglIndexfv(const GLfloat *c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexfv(c=%p)\n", c);
|
|
#endif
|
|
glIndexfv(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexfv");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexi (GLint c);
|
|
static inline void qglIndexi(GLint c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexi(c=%ld)\n", c);
|
|
#endif
|
|
glIndexi(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexi");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexiv (const GLint *c);
|
|
static inline void qglIndexiv(const GLint *c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexiv(c=%p)\n", c);
|
|
#endif
|
|
glIndexiv(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexiv");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexs (GLshort c);
|
|
static inline void qglIndexs(GLshort c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexs(c=%d)\n", c);
|
|
#endif
|
|
glIndexs(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexs");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexsv (const GLshort *c);
|
|
static inline void qglIndexsv(const GLshort *c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexsv(c=%p)\n", c);
|
|
#endif
|
|
glIndexsv(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexsv");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexub (GLubyte c);
|
|
static inline void qglIndexub(GLubyte c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexub(c=%u)\n", c);
|
|
#endif
|
|
glIndexub(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexub");
|
|
#endif
|
|
}
|
|
|
|
// void glIndexubv (const GLubyte *c);
|
|
static inline void qglIndexubv(const GLubyte *c)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIndexubv(c=%p)\n", c);
|
|
#endif
|
|
glIndexubv(c);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIndexubv");
|
|
#endif
|
|
}
|
|
|
|
// void glInitNames (void);
|
|
static inline void qglInitNames(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glInitNames(void)\n");
|
|
#endif
|
|
glInitNames();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glInitNames");
|
|
#endif
|
|
}
|
|
|
|
// void glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glInterleavedArrays(format=%lu, stride=%ld, pointer=%p)\n", format, stride, pointer);
|
|
#endif
|
|
glInterleavedArrays(format, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glInterleavedArrays");
|
|
#endif
|
|
}
|
|
|
|
// GLboolean glIsEnabled (GLenum cap);
|
|
static inline GLboolean qglIsEnabled(GLenum cap)
|
|
{
|
|
GLboolean returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIsEnabled(cap=%lu)\n", cap);
|
|
#endif
|
|
returnValue = glIsEnabled(cap);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIsEnabled");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// GLboolean glIsList (GLuint list);
|
|
static inline GLboolean qglIsList(GLuint list)
|
|
{
|
|
GLboolean returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIsList(list=%lu)\n", list);
|
|
#endif
|
|
returnValue = glIsList(list);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIsList");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// GLboolean glIsTexture (GLuint texture);
|
|
static inline GLboolean qglIsTexture(GLuint texture)
|
|
{
|
|
GLboolean returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glIsTexture(texture=%lu)\n", texture);
|
|
#endif
|
|
returnValue = glIsTexture(texture);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glIsTexture");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glLightModelf (GLenum pname, GLfloat param);
|
|
static inline void qglLightModelf(GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightModelf(pname=%lu, param=%f)\n", pname, param);
|
|
#endif
|
|
glLightModelf(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightModelf");
|
|
#endif
|
|
}
|
|
|
|
// void glLightModelfv (GLenum pname, const GLfloat *params);
|
|
static inline void qglLightModelfv(GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightModelfv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glLightModelfv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightModelfv");
|
|
#endif
|
|
}
|
|
|
|
// void glLightModeli (GLenum pname, GLint param);
|
|
static inline void qglLightModeli(GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightModeli(pname=%lu, param=%ld)\n", pname, param);
|
|
#endif
|
|
glLightModeli(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightModeli");
|
|
#endif
|
|
}
|
|
|
|
// void glLightModeliv (GLenum pname, const GLint *params);
|
|
static inline void qglLightModeliv(GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightModeliv(pname=%lu, params=%p)\n", pname, params);
|
|
#endif
|
|
glLightModeliv(pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightModeliv");
|
|
#endif
|
|
}
|
|
|
|
// void glLightf (GLenum light, GLenum pname, GLfloat param);
|
|
static inline void qglLightf(GLenum light, GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightf(light=%lu, pname=%lu, param=%f)\n", light, pname, param);
|
|
#endif
|
|
glLightf(light, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightf");
|
|
#endif
|
|
}
|
|
|
|
// void glLightfv (GLenum light, GLenum pname, const GLfloat *params);
|
|
static inline void qglLightfv(GLenum light, GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightfv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
|
|
#endif
|
|
glLightfv(light, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightfv");
|
|
#endif
|
|
}
|
|
|
|
// void glLighti (GLenum light, GLenum pname, GLint param);
|
|
static inline void qglLighti(GLenum light, GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLighti(light=%lu, pname=%lu, param=%ld)\n", light, pname, param);
|
|
#endif
|
|
glLighti(light, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLighti");
|
|
#endif
|
|
}
|
|
|
|
// void glLightiv (GLenum light, GLenum pname, const GLint *params);
|
|
static inline void qglLightiv(GLenum light, GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLightiv(light=%lu, pname=%lu, params=%p)\n", light, pname, params);
|
|
#endif
|
|
glLightiv(light, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLightiv");
|
|
#endif
|
|
}
|
|
|
|
// void glLineStipple (GLint factor, GLushort pattern);
|
|
static inline void qglLineStipple(GLint factor, GLushort pattern)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLineStipple(factor=%ld, pattern=%u)\n", factor, pattern);
|
|
#endif
|
|
glLineStipple(factor, pattern);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLineStipple");
|
|
#endif
|
|
}
|
|
|
|
// void glLineWidth (GLfloat width);
|
|
static inline void qglLineWidth(GLfloat width)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLineWidth(width=%f)\n", width);
|
|
#endif
|
|
glLineWidth(width);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLineWidth");
|
|
#endif
|
|
}
|
|
|
|
// void glListBase (GLuint base);
|
|
static inline void qglListBase(GLuint base)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glListBase(base=%lu)\n", base);
|
|
#endif
|
|
glListBase(base);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glListBase");
|
|
#endif
|
|
}
|
|
|
|
// void glLoadIdentity (void);
|
|
static inline void qglLoadIdentity(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLoadIdentity(void)\n");
|
|
#endif
|
|
glLoadIdentity();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLoadIdentity");
|
|
#endif
|
|
}
|
|
|
|
// void glLoadMatrixd (const GLdouble *m);
|
|
static inline void qglLoadMatrixd(const GLdouble *m)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLoadMatrixd(m=%p)\n", m);
|
|
#endif
|
|
glLoadMatrixd(m);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLoadMatrixd");
|
|
#endif
|
|
}
|
|
|
|
// void glLoadMatrixf (const GLfloat *m);
|
|
static inline void qglLoadMatrixf(const GLfloat *m)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLoadMatrixf(m=%p)\n", m);
|
|
#endif
|
|
glLoadMatrixf(m);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLoadMatrixf");
|
|
#endif
|
|
}
|
|
|
|
// void glLoadName (GLuint name);
|
|
static inline void qglLoadName(GLuint name)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLoadName(name=%lu)\n", name);
|
|
#endif
|
|
glLoadName(name);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLoadName");
|
|
#endif
|
|
}
|
|
|
|
// void glLogicOp (GLenum opcode);
|
|
static inline void qglLogicOp(GLenum opcode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glLogicOp(opcode=%lu)\n", opcode);
|
|
#endif
|
|
glLogicOp(opcode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glLogicOp");
|
|
#endif
|
|
}
|
|
|
|
// void glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
|
|
static inline void qglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMap1d(target=%lu, u1=%f, u2=%f, stride=%ld, order=%ld, points=%p)\n", target, u1, u2, stride, order, points);
|
|
#endif
|
|
glMap1d(target, u1, u2, stride, order, points);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMap1d");
|
|
#endif
|
|
}
|
|
|
|
// void glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
|
|
static inline void qglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMap1f(target=%lu, u1=%f, u2=%f, stride=%ld, order=%ld, points=%p)\n", target, u1, u2, stride, order, points);
|
|
#endif
|
|
glMap1f(target, u1, u2, stride, order, points);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMap1f");
|
|
#endif
|
|
}
|
|
|
|
// void glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
|
|
static inline void qglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMap2d(target=%lu, u1=%f, u2=%f, ustride=%ld, uorder=%ld, v1=%f, v2=%f, vstride=%ld, vorder=%ld, points=%p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
#endif
|
|
glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMap2d");
|
|
#endif
|
|
}
|
|
|
|
// void glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
|
|
static inline void qglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMap2f(target=%lu, u1=%f, u2=%f, ustride=%ld, uorder=%ld, v1=%f, v2=%f, vstride=%ld, vorder=%ld, points=%p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
#endif
|
|
glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMap2f");
|
|
#endif
|
|
}
|
|
|
|
// void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2);
|
|
static inline void qglMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMapGrid1d(un=%ld, u1=%f, u2=%f)\n", un, u1, u2);
|
|
#endif
|
|
glMapGrid1d(un, u1, u2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMapGrid1d");
|
|
#endif
|
|
}
|
|
|
|
// void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2);
|
|
static inline void qglMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMapGrid1f(un=%ld, u1=%f, u2=%f)\n", un, u1, u2);
|
|
#endif
|
|
glMapGrid1f(un, u1, u2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMapGrid1f");
|
|
#endif
|
|
}
|
|
|
|
// void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
|
|
static inline void qglMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMapGrid2d(un=%ld, u1=%f, u2=%f, vn=%ld, v1=%f, v2=%f)\n", un, u1, u2, vn, v1, v2);
|
|
#endif
|
|
glMapGrid2d(un, u1, u2, vn, v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMapGrid2d");
|
|
#endif
|
|
}
|
|
|
|
// void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
|
|
static inline void qglMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMapGrid2f(un=%ld, u1=%f, u2=%f, vn=%ld, v1=%f, v2=%f)\n", un, u1, u2, vn, v1, v2);
|
|
#endif
|
|
glMapGrid2f(un, u1, u2, vn, v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMapGrid2f");
|
|
#endif
|
|
}
|
|
|
|
// void glMaterialf (GLenum face, GLenum pname, GLfloat param);
|
|
static inline void qglMaterialf(GLenum face, GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMaterialf(face=%lu, pname=%lu, param=%f)\n", face, pname, param);
|
|
#endif
|
|
glMaterialf(face, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMaterialf");
|
|
#endif
|
|
}
|
|
|
|
// void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
|
|
static inline void qglMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMaterialfv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
|
|
#endif
|
|
glMaterialfv(face, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMaterialfv");
|
|
#endif
|
|
}
|
|
|
|
// void glMateriali (GLenum face, GLenum pname, GLint param);
|
|
static inline void qglMateriali(GLenum face, GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMateriali(face=%lu, pname=%lu, param=%ld)\n", face, pname, param);
|
|
#endif
|
|
glMateriali(face, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMateriali");
|
|
#endif
|
|
}
|
|
|
|
// void glMaterialiv (GLenum face, GLenum pname, const GLint *params);
|
|
static inline void qglMaterialiv(GLenum face, GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMaterialiv(face=%lu, pname=%lu, params=%p)\n", face, pname, params);
|
|
#endif
|
|
glMaterialiv(face, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMaterialiv");
|
|
#endif
|
|
}
|
|
|
|
// void glMatrixMode (GLenum mode);
|
|
static inline void qglMatrixMode(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMatrixMode(mode=%lu)\n", mode);
|
|
#endif
|
|
glMatrixMode(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMatrixMode");
|
|
#endif
|
|
}
|
|
|
|
// void glMultMatrixd (const GLdouble *m);
|
|
static inline void qglMultMatrixd(const GLdouble *m)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMultMatrixd(m=%p)\n", m);
|
|
#endif
|
|
glMultMatrixd(m);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMultMatrixd");
|
|
#endif
|
|
}
|
|
|
|
// void glMultMatrixf (const GLfloat *m);
|
|
static inline void qglMultMatrixf(const GLfloat *m)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glMultMatrixf(m=%p)\n", m);
|
|
#endif
|
|
glMultMatrixf(m);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glMultMatrixf");
|
|
#endif
|
|
}
|
|
|
|
// void glNewList (GLuint list, GLenum mode);
|
|
static inline void qglNewList(GLuint list, GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNewList(list=%lu, mode=%lu)\n", list, mode);
|
|
#endif
|
|
glNewList(list, mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNewList");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz);
|
|
static inline void qglNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3b(nx=%d, ny=%d, nz=%d)\n", nx, ny, nz);
|
|
#endif
|
|
glNormal3b(nx, ny, nz);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3b");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3bv (const GLbyte *v);
|
|
static inline void qglNormal3bv(const GLbyte *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3bv(v=%p)\n", v);
|
|
#endif
|
|
glNormal3bv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3bv");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz);
|
|
static inline void qglNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3d(nx=%f, ny=%f, nz=%f)\n", nx, ny, nz);
|
|
#endif
|
|
glNormal3d(nx, ny, nz);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3d");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3dv (const GLdouble *v);
|
|
static inline void qglNormal3dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3dv(v=%p)\n", v);
|
|
#endif
|
|
glNormal3dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3dv");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz);
|
|
static inline void qglNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3f(nx=%f, ny=%f, nz=%f)\n", nx, ny, nz);
|
|
#endif
|
|
glNormal3f(nx, ny, nz);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3f");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3fv (const GLfloat *v);
|
|
static inline void qglNormal3fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3fv(v=%p)\n", v);
|
|
#endif
|
|
glNormal3fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3fv");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3i (GLint nx, GLint ny, GLint nz);
|
|
static inline void qglNormal3i(GLint nx, GLint ny, GLint nz)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3i(nx=%ld, ny=%ld, nz=%ld)\n", nx, ny, nz);
|
|
#endif
|
|
glNormal3i(nx, ny, nz);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3i");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3iv (const GLint *v);
|
|
static inline void qglNormal3iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3iv(v=%p)\n", v);
|
|
#endif
|
|
glNormal3iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3iv");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3s (GLshort nx, GLshort ny, GLshort nz);
|
|
static inline void qglNormal3s(GLshort nx, GLshort ny, GLshort nz)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3s(nx=%d, ny=%d, nz=%d)\n", nx, ny, nz);
|
|
#endif
|
|
glNormal3s(nx, ny, nz);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3s");
|
|
#endif
|
|
}
|
|
|
|
// void glNormal3sv (const GLshort *v);
|
|
static inline void qglNormal3sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormal3sv(v=%p)\n", v);
|
|
#endif
|
|
glNormal3sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormal3sv");
|
|
#endif
|
|
}
|
|
|
|
// void glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glNormalPointer(type=%lu, stride=%ld, pointer=%p)\n", type, stride, pointer);
|
|
#endif
|
|
glNormalPointer(type, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glNormalPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
|
|
static inline void qglOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glOrtho(left=%f, right=%f, bottom=%f, top=%f, zNear=%f, zFar=%f)\n", left, right, bottom, top, zNear, zFar);
|
|
#endif
|
|
glOrtho(left, right, bottom, top, zNear, zFar);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glOrtho");
|
|
#endif
|
|
}
|
|
|
|
// void glPassThrough (GLfloat token);
|
|
static inline void qglPassThrough(GLfloat token)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPassThrough(token=%f)\n", token);
|
|
#endif
|
|
glPassThrough(token);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPassThrough");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values);
|
|
static inline void qglPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelMapfv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
|
|
#endif
|
|
glPixelMapfv(map, mapsize, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelMapfv");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values);
|
|
static inline void qglPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelMapuiv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
|
|
#endif
|
|
glPixelMapuiv(map, mapsize, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelMapuiv");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values);
|
|
static inline void qglPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelMapusv(map=%lu, mapsize=%ld, values=%p)\n", map, mapsize, values);
|
|
#endif
|
|
glPixelMapusv(map, mapsize, values);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelMapusv");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelStoref (GLenum pname, GLfloat param);
|
|
static inline void qglPixelStoref(GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelStoref(pname=%lu, param=%f)\n", pname, param);
|
|
#endif
|
|
glPixelStoref(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelStoref");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelStorei (GLenum pname, GLint param);
|
|
static inline void qglPixelStorei(GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelStorei(pname=%lu, param=%ld)\n", pname, param);
|
|
#endif
|
|
glPixelStorei(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelStorei");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelTransferf (GLenum pname, GLfloat param);
|
|
static inline void qglPixelTransferf(GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelTransferf(pname=%lu, param=%f)\n", pname, param);
|
|
#endif
|
|
glPixelTransferf(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelTransferf");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelTransferi (GLenum pname, GLint param);
|
|
static inline void qglPixelTransferi(GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelTransferi(pname=%lu, param=%ld)\n", pname, param);
|
|
#endif
|
|
glPixelTransferi(pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelTransferi");
|
|
#endif
|
|
}
|
|
|
|
// void glPixelZoom (GLfloat xfactor, GLfloat yfactor);
|
|
static inline void qglPixelZoom(GLfloat xfactor, GLfloat yfactor)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPixelZoom(xfactor=%f, yfactor=%f)\n", xfactor, yfactor);
|
|
#endif
|
|
glPixelZoom(xfactor, yfactor);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPixelZoom");
|
|
#endif
|
|
}
|
|
|
|
// void glPointSize (GLfloat size);
|
|
static inline void qglPointSize(GLfloat size)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPointSize(size=%f)\n", size);
|
|
#endif
|
|
glPointSize(size);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPointSize");
|
|
#endif
|
|
}
|
|
|
|
// void glPolygonMode (GLenum face, GLenum mode);
|
|
static inline void qglPolygonMode(GLenum face, GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPolygonMode(face=%lu, mode=%lu)\n", face, mode);
|
|
#endif
|
|
glPolygonMode(face, mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPolygonMode");
|
|
#endif
|
|
}
|
|
|
|
// void glPolygonOffset (GLfloat factor, GLfloat units);
|
|
static inline void qglPolygonOffset(GLfloat factor, GLfloat units)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPolygonOffset(factor=%f, units=%f)\n", factor, units);
|
|
#endif
|
|
glPolygonOffset(factor, units);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPolygonOffset");
|
|
#endif
|
|
}
|
|
|
|
// void glPolygonStipple (const GLubyte *mask);
|
|
static inline void qglPolygonStipple(const GLubyte *mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPolygonStipple(mask=%p)\n", mask);
|
|
#endif
|
|
glPolygonStipple(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPolygonStipple");
|
|
#endif
|
|
}
|
|
|
|
// void glPopAttrib (void);
|
|
static inline void qglPopAttrib(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPopAttrib(void)\n");
|
|
#endif
|
|
glPopAttrib();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPopAttrib");
|
|
#endif
|
|
}
|
|
|
|
// void glPopClientAttrib (void);
|
|
static inline void qglPopClientAttrib(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPopClientAttrib(void)\n");
|
|
#endif
|
|
glPopClientAttrib();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPopClientAttrib");
|
|
#endif
|
|
}
|
|
|
|
// void glPopMatrix (void);
|
|
static inline void qglPopMatrix(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPopMatrix(void)\n");
|
|
#endif
|
|
glPopMatrix();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPopMatrix");
|
|
#endif
|
|
}
|
|
|
|
// void glPopName (void);
|
|
static inline void qglPopName(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPopName(void)\n");
|
|
#endif
|
|
glPopName();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPopName");
|
|
#endif
|
|
}
|
|
|
|
// void glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities);
|
|
static inline void qglPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPrioritizeTextures(n=%ld, textures=%p, priorities=%p)\n", n, textures, priorities);
|
|
#endif
|
|
glPrioritizeTextures(n, textures, priorities);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPrioritizeTextures");
|
|
#endif
|
|
}
|
|
|
|
// void glPushAttrib (GLbitfield mask);
|
|
static inline void qglPushAttrib(GLbitfield mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPushAttrib(mask=%lu)\n", mask);
|
|
#endif
|
|
glPushAttrib(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPushAttrib");
|
|
#endif
|
|
}
|
|
|
|
// void glPushClientAttrib (GLbitfield mask);
|
|
static inline void qglPushClientAttrib(GLbitfield mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPushClientAttrib(mask=%lu)\n", mask);
|
|
#endif
|
|
glPushClientAttrib(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPushClientAttrib");
|
|
#endif
|
|
}
|
|
|
|
// void glPushMatrix (void);
|
|
static inline void qglPushMatrix(void)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPushMatrix(void)\n");
|
|
#endif
|
|
glPushMatrix();
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPushMatrix");
|
|
#endif
|
|
}
|
|
|
|
// void glPushName (GLuint name);
|
|
static inline void qglPushName(GLuint name)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glPushName(name=%lu)\n", name);
|
|
#endif
|
|
glPushName(name);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glPushName");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2d (GLdouble x, GLdouble y);
|
|
static inline void qglRasterPos2d(GLdouble x, GLdouble y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2d(x=%f, y=%f)\n", x, y);
|
|
#endif
|
|
glRasterPos2d(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2d");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2dv (const GLdouble *v);
|
|
static inline void qglRasterPos2dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2dv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos2dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2dv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2f (GLfloat x, GLfloat y);
|
|
static inline void qglRasterPos2f(GLfloat x, GLfloat y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2f(x=%f, y=%f)\n", x, y);
|
|
#endif
|
|
glRasterPos2f(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2f");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2fv (const GLfloat *v);
|
|
static inline void qglRasterPos2fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2fv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos2fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2fv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2i (GLint x, GLint y);
|
|
static inline void qglRasterPos2i(GLint x, GLint y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2i(x=%ld, y=%ld)\n", x, y);
|
|
#endif
|
|
glRasterPos2i(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2i");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2iv (const GLint *v);
|
|
static inline void qglRasterPos2iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2iv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos2iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2iv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2s (GLshort x, GLshort y);
|
|
static inline void qglRasterPos2s(GLshort x, GLshort y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2s(x=%d, y=%d)\n", x, y);
|
|
#endif
|
|
glRasterPos2s(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2s");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos2sv (const GLshort *v);
|
|
static inline void qglRasterPos2sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos2sv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos2sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos2sv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z);
|
|
static inline void qglRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3d(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glRasterPos3d(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3d");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3dv (const GLdouble *v);
|
|
static inline void qglRasterPos3dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3dv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos3dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3dv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);
|
|
static inline void qglRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3f(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glRasterPos3f(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3f");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3fv (const GLfloat *v);
|
|
static inline void qglRasterPos3fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3fv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos3fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3fv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3i (GLint x, GLint y, GLint z);
|
|
static inline void qglRasterPos3i(GLint x, GLint y, GLint z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3i(x=%ld, y=%ld, z=%ld)\n", x, y, z);
|
|
#endif
|
|
glRasterPos3i(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3i");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3iv (const GLint *v);
|
|
static inline void qglRasterPos3iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3iv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos3iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3iv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3s (GLshort x, GLshort y, GLshort z);
|
|
static inline void qglRasterPos3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3s(x=%d, y=%d, z=%d)\n", x, y, z);
|
|
#endif
|
|
glRasterPos3s(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3s");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos3sv (const GLshort *v);
|
|
static inline void qglRasterPos3sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos3sv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos3sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos3sv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
|
|
static inline void qglRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4d(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
|
|
#endif
|
|
glRasterPos4d(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4d");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4dv (const GLdouble *v);
|
|
static inline void qglRasterPos4dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4dv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos4dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4dv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
|
static inline void qglRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4f(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
|
|
#endif
|
|
glRasterPos4f(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4f");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4fv (const GLfloat *v);
|
|
static inline void qglRasterPos4fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4fv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos4fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4fv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4i (GLint x, GLint y, GLint z, GLint w);
|
|
static inline void qglRasterPos4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4i(x=%ld, y=%ld, z=%ld, w=%ld)\n", x, y, z, w);
|
|
#endif
|
|
glRasterPos4i(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4i");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4iv (const GLint *v);
|
|
static inline void qglRasterPos4iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4iv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos4iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4iv");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w);
|
|
static inline void qglRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4s(x=%d, y=%d, z=%d, w=%d)\n", x, y, z, w);
|
|
#endif
|
|
glRasterPos4s(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4s");
|
|
#endif
|
|
}
|
|
|
|
// void glRasterPos4sv (const GLshort *v);
|
|
static inline void qglRasterPos4sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRasterPos4sv(v=%p)\n", v);
|
|
#endif
|
|
glRasterPos4sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRasterPos4sv");
|
|
#endif
|
|
}
|
|
|
|
// void glReadBuffer (GLenum mode);
|
|
static inline void qglReadBuffer(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glReadBuffer(mode=%lu)\n", mode);
|
|
#endif
|
|
glReadBuffer(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glReadBuffer");
|
|
#endif
|
|
}
|
|
|
|
// void glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
|
|
static inline void qglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glReadPixels(x=%ld, y=%ld, width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", x, y, width, height, format, type, pixels);
|
|
#endif
|
|
glReadPixels(x, y, width, height, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glReadPixels");
|
|
#endif
|
|
}
|
|
|
|
// void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
|
|
static inline void qglRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectd(x1=%f, y1=%f, x2=%f, y2=%f)\n", x1, y1, x2, y2);
|
|
#endif
|
|
glRectd(x1, y1, x2, y2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectd");
|
|
#endif
|
|
}
|
|
|
|
// void glRectdv (const GLdouble *v1, const GLdouble *v2);
|
|
static inline void qglRectdv(const GLdouble *v1, const GLdouble *v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectdv(v1=%p, v2=%p)\n", v1, v2);
|
|
#endif
|
|
glRectdv(v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectdv");
|
|
#endif
|
|
}
|
|
|
|
// void glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
|
|
static inline void qglRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectf(x1=%f, y1=%f, x2=%f, y2=%f)\n", x1, y1, x2, y2);
|
|
#endif
|
|
glRectf(x1, y1, x2, y2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectf");
|
|
#endif
|
|
}
|
|
|
|
// void glRectfv (const GLfloat *v1, const GLfloat *v2);
|
|
static inline void qglRectfv(const GLfloat *v1, const GLfloat *v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectfv(v1=%p, v2=%p)\n", v1, v2);
|
|
#endif
|
|
glRectfv(v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectfv");
|
|
#endif
|
|
}
|
|
|
|
// void glRecti (GLint x1, GLint y1, GLint x2, GLint y2);
|
|
static inline void qglRecti(GLint x1, GLint y1, GLint x2, GLint y2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRecti(x1=%ld, y1=%ld, x2=%ld, y2=%ld)\n", x1, y1, x2, y2);
|
|
#endif
|
|
glRecti(x1, y1, x2, y2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRecti");
|
|
#endif
|
|
}
|
|
|
|
// void glRectiv (const GLint *v1, const GLint *v2);
|
|
static inline void qglRectiv(const GLint *v1, const GLint *v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectiv(v1=%p, v2=%p)\n", v1, v2);
|
|
#endif
|
|
glRectiv(v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectiv");
|
|
#endif
|
|
}
|
|
|
|
// void glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2);
|
|
static inline void qglRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRects(x1=%d, y1=%d, x2=%d, y2=%d)\n", x1, y1, x2, y2);
|
|
#endif
|
|
glRects(x1, y1, x2, y2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRects");
|
|
#endif
|
|
}
|
|
|
|
// void glRectsv (const GLshort *v1, const GLshort *v2);
|
|
static inline void qglRectsv(const GLshort *v1, const GLshort *v2)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRectsv(v1=%p, v2=%p)\n", v1, v2);
|
|
#endif
|
|
glRectsv(v1, v2);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRectsv");
|
|
#endif
|
|
}
|
|
|
|
// GLint glRenderMode (GLenum mode);
|
|
static inline GLint qglRenderMode(GLenum mode)
|
|
{
|
|
GLint returnValue;
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRenderMode(mode=%lu)\n", mode);
|
|
#endif
|
|
returnValue = glRenderMode(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRenderMode");
|
|
#endif
|
|
return returnValue;
|
|
}
|
|
|
|
// void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
|
|
static inline void qglRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRotated(angle=%f, x=%f, y=%f, z=%f)\n", angle, x, y, z);
|
|
#endif
|
|
glRotated(angle, x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRotated");
|
|
#endif
|
|
}
|
|
|
|
// void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
|
|
static inline void qglRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glRotatef(angle=%f, x=%f, y=%f, z=%f)\n", angle, x, y, z);
|
|
#endif
|
|
glRotatef(angle, x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glRotatef");
|
|
#endif
|
|
}
|
|
|
|
// void glScaled (GLdouble x, GLdouble y, GLdouble z);
|
|
static inline void qglScaled(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glScaled(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glScaled(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glScaled");
|
|
#endif
|
|
}
|
|
|
|
// void glScalef (GLfloat x, GLfloat y, GLfloat z);
|
|
static inline void qglScalef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glScalef(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glScalef(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glScalef");
|
|
#endif
|
|
}
|
|
|
|
// void glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
|
|
static inline void qglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glScissor(x=%ld, y=%ld, width=%ld, height=%ld)\n", x, y, width, height);
|
|
#endif
|
|
glScissor(x, y, width, height);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glScissor");
|
|
#endif
|
|
}
|
|
|
|
// void glSelectBuffer (GLsizei size, GLuint *buffer);
|
|
static inline void qglSelectBuffer(GLsizei size, GLuint *buffer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glSelectBuffer(size=%ld, buffer=%p)\n", size, buffer);
|
|
#endif
|
|
glSelectBuffer(size, buffer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glSelectBuffer");
|
|
#endif
|
|
}
|
|
|
|
// void glShadeModel (GLenum mode);
|
|
static inline void qglShadeModel(GLenum mode)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glShadeModel(mode=%lu)\n", mode);
|
|
#endif
|
|
glShadeModel(mode);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glShadeModel");
|
|
#endif
|
|
}
|
|
|
|
// void glStencilFunc (GLenum func, GLint ref, GLuint mask);
|
|
static inline void qglStencilFunc(GLenum func, GLint ref, GLuint mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glStencilFunc(func=%lu, ref=%ld, mask=%lu)\n", func, ref, mask);
|
|
#endif
|
|
glStencilFunc(func, ref, mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glStencilFunc");
|
|
#endif
|
|
}
|
|
|
|
// void glStencilMask (GLuint mask);
|
|
static inline void qglStencilMask(GLuint mask)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glStencilMask(mask=%lu)\n", mask);
|
|
#endif
|
|
glStencilMask(mask);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glStencilMask");
|
|
#endif
|
|
}
|
|
|
|
// void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
|
|
static inline void qglStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glStencilOp(fail=%lu, zfail=%lu, zpass=%lu)\n", fail, zfail, zpass);
|
|
#endif
|
|
glStencilOp(fail, zfail, zpass);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glStencilOp");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1d (GLdouble s);
|
|
static inline void qglTexCoord1d(GLdouble s)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1d(s=%f)\n", s);
|
|
#endif
|
|
glTexCoord1d(s);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1d");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1dv (const GLdouble *v);
|
|
static inline void qglTexCoord1dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1dv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord1dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1dv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1f (GLfloat s);
|
|
static inline void qglTexCoord1f(GLfloat s)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1f(s=%f)\n", s);
|
|
#endif
|
|
glTexCoord1f(s);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1f");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1fv (const GLfloat *v);
|
|
static inline void qglTexCoord1fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1fv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord1fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1fv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1i (GLint s);
|
|
static inline void qglTexCoord1i(GLint s)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1i(s=%ld)\n", s);
|
|
#endif
|
|
glTexCoord1i(s);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1i");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1iv (const GLint *v);
|
|
static inline void qglTexCoord1iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1iv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord1iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1iv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1s (GLshort s);
|
|
static inline void qglTexCoord1s(GLshort s)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1s(s=%d)\n", s);
|
|
#endif
|
|
glTexCoord1s(s);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1s");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord1sv (const GLshort *v);
|
|
static inline void qglTexCoord1sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord1sv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord1sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord1sv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2d (GLdouble s, GLdouble t);
|
|
static inline void qglTexCoord2d(GLdouble s, GLdouble t)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2d(s=%f, t=%f)\n", s, t);
|
|
#endif
|
|
glTexCoord2d(s, t);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2d");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2dv (const GLdouble *v);
|
|
static inline void qglTexCoord2dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2dv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord2dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2dv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2f (GLfloat s, GLfloat t);
|
|
static inline void qglTexCoord2f(GLfloat s, GLfloat t)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2f(s=%f, t=%f)\n", s, t);
|
|
#endif
|
|
glTexCoord2f(s, t);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2f");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2fv (const GLfloat *v);
|
|
static inline void qglTexCoord2fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2fv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord2fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2fv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2i (GLint s, GLint t);
|
|
static inline void qglTexCoord2i(GLint s, GLint t)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2i(s=%ld, t=%ld)\n", s, t);
|
|
#endif
|
|
glTexCoord2i(s, t);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2i");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2iv (const GLint *v);
|
|
static inline void qglTexCoord2iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2iv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord2iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2iv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2s (GLshort s, GLshort t);
|
|
static inline void qglTexCoord2s(GLshort s, GLshort t)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2s(s=%d, t=%d)\n", s, t);
|
|
#endif
|
|
glTexCoord2s(s, t);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2s");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord2sv (const GLshort *v);
|
|
static inline void qglTexCoord2sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord2sv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord2sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord2sv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r);
|
|
static inline void qglTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3d(s=%f, t=%f, r=%f)\n", s, t, r);
|
|
#endif
|
|
glTexCoord3d(s, t, r);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3d");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3dv (const GLdouble *v);
|
|
static inline void qglTexCoord3dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3dv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord3dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3dv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r);
|
|
static inline void qglTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3f(s=%f, t=%f, r=%f)\n", s, t, r);
|
|
#endif
|
|
glTexCoord3f(s, t, r);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3f");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3fv (const GLfloat *v);
|
|
static inline void qglTexCoord3fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3fv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord3fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3fv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3i (GLint s, GLint t, GLint r);
|
|
static inline void qglTexCoord3i(GLint s, GLint t, GLint r)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3i(s=%ld, t=%ld, r=%ld)\n", s, t, r);
|
|
#endif
|
|
glTexCoord3i(s, t, r);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3i");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3iv (const GLint *v);
|
|
static inline void qglTexCoord3iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3iv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord3iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3iv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3s (GLshort s, GLshort t, GLshort r);
|
|
static inline void qglTexCoord3s(GLshort s, GLshort t, GLshort r)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3s(s=%d, t=%d, r=%d)\n", s, t, r);
|
|
#endif
|
|
glTexCoord3s(s, t, r);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3s");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord3sv (const GLshort *v);
|
|
static inline void qglTexCoord3sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord3sv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord3sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord3sv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q);
|
|
static inline void qglTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4d(s=%f, t=%f, r=%f, q=%f)\n", s, t, r, q);
|
|
#endif
|
|
glTexCoord4d(s, t, r, q);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4d");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4dv (const GLdouble *v);
|
|
static inline void qglTexCoord4dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4dv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord4dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4dv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
|
|
static inline void qglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4f(s=%f, t=%f, r=%f, q=%f)\n", s, t, r, q);
|
|
#endif
|
|
glTexCoord4f(s, t, r, q);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4f");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4fv (const GLfloat *v);
|
|
static inline void qglTexCoord4fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4fv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord4fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4fv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4i (GLint s, GLint t, GLint r, GLint q);
|
|
static inline void qglTexCoord4i(GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4i(s=%ld, t=%ld, r=%ld, q=%ld)\n", s, t, r, q);
|
|
#endif
|
|
glTexCoord4i(s, t, r, q);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4i");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4iv (const GLint *v);
|
|
static inline void qglTexCoord4iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4iv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord4iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4iv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q);
|
|
static inline void qglTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4s(s=%d, t=%d, r=%d, q=%d)\n", s, t, r, q);
|
|
#endif
|
|
glTexCoord4s(s, t, r, q);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4s");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoord4sv (const GLshort *v);
|
|
static inline void qglTexCoord4sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoord4sv(v=%p)\n", v);
|
|
#endif
|
|
glTexCoord4sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoord4sv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexCoordPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
|
|
#endif
|
|
glTexCoordPointer(size, type, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexCoordPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glTexEnvf (GLenum target, GLenum pname, GLfloat param);
|
|
static inline void qglTexEnvf(GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexEnvf(target=%lu, pname=%lu, param=%f)\n", target, pname, param);
|
|
#endif
|
|
glTexEnvf(target, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexEnvf");
|
|
#endif
|
|
}
|
|
|
|
// void glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
|
|
static inline void qglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexEnvfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glTexEnvfv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexEnvfv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexEnvi (GLenum target, GLenum pname, GLint param);
|
|
static inline void qglTexEnvi(GLenum target, GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexEnvi(target=%lu, pname=%lu, param=%ld)\n", target, pname, param);
|
|
#endif
|
|
glTexEnvi(target, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexEnvi");
|
|
#endif
|
|
}
|
|
|
|
// void glTexEnviv (GLenum target, GLenum pname, const GLint *params);
|
|
static inline void qglTexEnviv(GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexEnviv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glTexEnviv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexEnviv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGend (GLenum coord, GLenum pname, GLdouble param);
|
|
static inline void qglTexGend(GLenum coord, GLenum pname, GLdouble param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGend(coord=%lu, pname=%lu, param=%f)\n", coord, pname, param);
|
|
#endif
|
|
glTexGend(coord, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGend");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);
|
|
static inline void qglTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGendv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glTexGendv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGendv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGenf (GLenum coord, GLenum pname, GLfloat param);
|
|
static inline void qglTexGenf(GLenum coord, GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGenf(coord=%lu, pname=%lu, param=%f)\n", coord, pname, param);
|
|
#endif
|
|
glTexGenf(coord, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGenf");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);
|
|
static inline void qglTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGenfv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glTexGenfv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGenfv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGeni (GLenum coord, GLenum pname, GLint param);
|
|
static inline void qglTexGeni(GLenum coord, GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGeni(coord=%lu, pname=%lu, param=%ld)\n", coord, pname, param);
|
|
#endif
|
|
glTexGeni(coord, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGeni");
|
|
#endif
|
|
}
|
|
|
|
// void glTexGeniv (GLenum coord, GLenum pname, const GLint *params);
|
|
static inline void qglTexGeniv(GLenum coord, GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexGeniv(coord=%lu, pname=%lu, params=%p)\n", coord, pname, params);
|
|
#endif
|
|
glTexGeniv(coord, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexGeniv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
|
|
static inline void qglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexImage1D(target=%lu, level=%ld, internalformat=%ld, width=%ld, border=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, internalformat, width, border, format, type, pixels);
|
|
#endif
|
|
glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexImage1D");
|
|
#endif
|
|
}
|
|
|
|
// void glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
|
|
static inline void qglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexImage2D(target=%lu, level=%ld, internalformat=%ld, width=%ld, height=%ld, border=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, internalformat, width, height, border, format, type, pixels);
|
|
#endif
|
|
glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexImage2D");
|
|
#endif
|
|
}
|
|
|
|
// void glTexParameterf (GLenum target, GLenum pname, GLfloat param);
|
|
static inline void qglTexParameterf(GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexParameterf(target=%lu, pname=%lu, param=%f)\n", target, pname, param);
|
|
#endif
|
|
glTexParameterf(target, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexParameterf");
|
|
#endif
|
|
}
|
|
|
|
// void glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params);
|
|
static inline void qglTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexParameterfv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glTexParameterfv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexParameterfv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexParameteri (GLenum target, GLenum pname, GLint param);
|
|
static inline void qglTexParameteri(GLenum target, GLenum pname, GLint param)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexParameteri(target=%lu, pname=%lu, param=%ld)\n", target, pname, param);
|
|
#endif
|
|
glTexParameteri(target, pname, param);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexParameteri");
|
|
#endif
|
|
}
|
|
|
|
// void glTexParameteriv (GLenum target, GLenum pname, const GLint *params);
|
|
static inline void qglTexParameteriv(GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexParameteriv(target=%lu, pname=%lu, params=%p)\n", target, pname, params);
|
|
#endif
|
|
glTexParameteriv(target, pname, params);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexParameteriv");
|
|
#endif
|
|
}
|
|
|
|
// void glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
|
|
static inline void qglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexSubImage1D(target=%lu, level=%ld, xoffset=%ld, width=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, xoffset, width, format, type, pixels);
|
|
#endif
|
|
glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexSubImage1D");
|
|
#endif
|
|
}
|
|
|
|
// void glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
|
|
static inline void qglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTexSubImage2D(target=%lu, level=%ld, xoffset=%ld, yoffset=%ld, width=%ld, height=%ld, format=%lu, type=%lu, pixels=%p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels);
|
|
#endif
|
|
glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTexSubImage2D");
|
|
#endif
|
|
}
|
|
|
|
// void glTranslated (GLdouble x, GLdouble y, GLdouble z);
|
|
static inline void qglTranslated(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTranslated(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glTranslated(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTranslated");
|
|
#endif
|
|
}
|
|
|
|
// void glTranslatef (GLfloat x, GLfloat y, GLfloat z);
|
|
static inline void qglTranslatef(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glTranslatef(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glTranslatef(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glTranslatef");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2d (GLdouble x, GLdouble y);
|
|
static inline void qglVertex2d(GLdouble x, GLdouble y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2d(x=%f, y=%f)\n", x, y);
|
|
#endif
|
|
glVertex2d(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2d");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2dv (const GLdouble *v);
|
|
static inline void qglVertex2dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2dv(v=%p)\n", v);
|
|
#endif
|
|
glVertex2dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2dv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2f (GLfloat x, GLfloat y);
|
|
static inline void qglVertex2f(GLfloat x, GLfloat y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2f(x=%f, y=%f)\n", x, y);
|
|
#endif
|
|
glVertex2f(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2f");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2fv (const GLfloat *v);
|
|
static inline void qglVertex2fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2fv(v=%p)\n", v);
|
|
#endif
|
|
glVertex2fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2fv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2i (GLint x, GLint y);
|
|
static inline void qglVertex2i(GLint x, GLint y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2i(x=%ld, y=%ld)\n", x, y);
|
|
#endif
|
|
glVertex2i(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2i");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2iv (const GLint *v);
|
|
static inline void qglVertex2iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2iv(v=%p)\n", v);
|
|
#endif
|
|
glVertex2iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2iv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2s (GLshort x, GLshort y);
|
|
static inline void qglVertex2s(GLshort x, GLshort y)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2s(x=%d, y=%d)\n", x, y);
|
|
#endif
|
|
glVertex2s(x, y);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2s");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex2sv (const GLshort *v);
|
|
static inline void qglVertex2sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex2sv(v=%p)\n", v);
|
|
#endif
|
|
glVertex2sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex2sv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3d (GLdouble x, GLdouble y, GLdouble z);
|
|
static inline void qglVertex3d(GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3d(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glVertex3d(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3d");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3dv (const GLdouble *v);
|
|
static inline void qglVertex3dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3dv(v=%p)\n", v);
|
|
#endif
|
|
glVertex3dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3dv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3f (GLfloat x, GLfloat y, GLfloat z);
|
|
static inline void qglVertex3f(GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3f(x=%f, y=%f, z=%f)\n", x, y, z);
|
|
#endif
|
|
glVertex3f(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3f");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3fv (const GLfloat *v);
|
|
static inline void qglVertex3fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3fv(v=%p)\n", v);
|
|
#endif
|
|
glVertex3fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3fv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3i (GLint x, GLint y, GLint z);
|
|
static inline void qglVertex3i(GLint x, GLint y, GLint z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3i(x=%ld, y=%ld, z=%ld)\n", x, y, z);
|
|
#endif
|
|
glVertex3i(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3i");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3iv (const GLint *v);
|
|
static inline void qglVertex3iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3iv(v=%p)\n", v);
|
|
#endif
|
|
glVertex3iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3iv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3s (GLshort x, GLshort y, GLshort z);
|
|
static inline void qglVertex3s(GLshort x, GLshort y, GLshort z)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3s(x=%d, y=%d, z=%d)\n", x, y, z);
|
|
#endif
|
|
glVertex3s(x, y, z);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3s");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex3sv (const GLshort *v);
|
|
static inline void qglVertex3sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex3sv(v=%p)\n", v);
|
|
#endif
|
|
glVertex3sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex3sv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
|
|
static inline void qglVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4d(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
|
|
#endif
|
|
glVertex4d(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4d");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4dv (const GLdouble *v);
|
|
static inline void qglVertex4dv(const GLdouble *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4dv(v=%p)\n", v);
|
|
#endif
|
|
glVertex4dv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4dv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
|
|
static inline void qglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4f(x=%f, y=%f, z=%f, w=%f)\n", x, y, z, w);
|
|
#endif
|
|
glVertex4f(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4f");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4fv (const GLfloat *v);
|
|
static inline void qglVertex4fv(const GLfloat *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4fv(v=%p)\n", v);
|
|
#endif
|
|
glVertex4fv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4fv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4i (GLint x, GLint y, GLint z, GLint w);
|
|
static inline void qglVertex4i(GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4i(x=%ld, y=%ld, z=%ld, w=%ld)\n", x, y, z, w);
|
|
#endif
|
|
glVertex4i(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4i");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4iv (const GLint *v);
|
|
static inline void qglVertex4iv(const GLint *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4iv(v=%p)\n", v);
|
|
#endif
|
|
glVertex4iv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4iv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
|
|
static inline void qglVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4s(x=%d, y=%d, z=%d, w=%d)\n", x, y, z, w);
|
|
#endif
|
|
glVertex4s(x, y, z, w);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4s");
|
|
#endif
|
|
}
|
|
|
|
// void glVertex4sv (const GLshort *v);
|
|
static inline void qglVertex4sv(const GLshort *v)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertex4sv(v=%p)\n", v);
|
|
#endif
|
|
glVertex4sv(v);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertex4sv");
|
|
#endif
|
|
}
|
|
|
|
// void glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
|
|
static inline void qglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glVertexPointer(size=%ld, type=%lu, stride=%ld, pointer=%p)\n", size, type, stride, pointer);
|
|
#endif
|
|
glVertexPointer(size, type, stride, pointer);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glVertexPointer");
|
|
#endif
|
|
}
|
|
|
|
// void glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
|
|
static inline void qglViewport(GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
#if !defined(NDEBUG) && defined(QGL_LOG_GL_CALLS)
|
|
if (QGLLogGLCalls)
|
|
fprintf(QGLDebugFile(), "glViewport(x=%ld, y=%ld, width=%ld, height=%ld)\n", x, y, width, height);
|
|
#endif
|
|
glViewport(x, y, width, height);
|
|
#if !defined(NDEBUG) && defined(QGL_CHECK_GL_ERRORS)
|
|
if (!QGLBeginStarted)
|
|
QGLCheckError("glViewport");
|
|
#endif
|
|
}
|
|
|
|
// Prevent calls to the 'normal' GL functions
|
|
#define glAccum CALL_THE_QGL_VERSION_OF_glAccum
|
|
#define glAlphaFunc CALL_THE_QGL_VERSION_OF_glAlphaFunc
|
|
#define glAreTexturesResident CALL_THE_QGL_VERSION_OF_glAreTexturesResident
|
|
#define glArrayElement CALL_THE_QGL_VERSION_OF_glArrayElement
|
|
#define glBegin CALL_THE_QGL_VERSION_OF_glBegin
|
|
#define glBindTexture CALL_THE_QGL_VERSION_OF_glBindTexture
|
|
#define glBitmap CALL_THE_QGL_VERSION_OF_glBitmap
|
|
#define glBlendFunc CALL_THE_QGL_VERSION_OF_glBlendFunc
|
|
#define glCallList CALL_THE_QGL_VERSION_OF_glCallList
|
|
#define glCallLists CALL_THE_QGL_VERSION_OF_glCallLists
|
|
#define glClear CALL_THE_QGL_VERSION_OF_glClear
|
|
#define glClearAccum CALL_THE_QGL_VERSION_OF_glClearAccum
|
|
#define glClearColor CALL_THE_QGL_VERSION_OF_glClearColor
|
|
#define glClearDepth CALL_THE_QGL_VERSION_OF_glClearDepth
|
|
#define glClearIndex CALL_THE_QGL_VERSION_OF_glClearIndex
|
|
#define glClearStencil CALL_THE_QGL_VERSION_OF_glClearStencil
|
|
#define glClipPlane CALL_THE_QGL_VERSION_OF_glClipPlane
|
|
#define glColor3b CALL_THE_QGL_VERSION_OF_glColor3b
|
|
#define glColor3bv CALL_THE_QGL_VERSION_OF_glColor3bv
|
|
#define glColor3d CALL_THE_QGL_VERSION_OF_glColor3d
|
|
#define glColor3dv CALL_THE_QGL_VERSION_OF_glColor3dv
|
|
#define glColor3f CALL_THE_QGL_VERSION_OF_glColor3f
|
|
#define glColor3fv CALL_THE_QGL_VERSION_OF_glColor3fv
|
|
#define glColor3i CALL_THE_QGL_VERSION_OF_glColor3i
|
|
#define glColor3iv CALL_THE_QGL_VERSION_OF_glColor3iv
|
|
#define glColor3s CALL_THE_QGL_VERSION_OF_glColor3s
|
|
#define glColor3sv CALL_THE_QGL_VERSION_OF_glColor3sv
|
|
#define glColor3ub CALL_THE_QGL_VERSION_OF_glColor3ub
|
|
#define glColor3ubv CALL_THE_QGL_VERSION_OF_glColor3ubv
|
|
#define glColor3ui CALL_THE_QGL_VERSION_OF_glColor3ui
|
|
#define glColor3uiv CALL_THE_QGL_VERSION_OF_glColor3uiv
|
|
#define glColor3us CALL_THE_QGL_VERSION_OF_glColor3us
|
|
#define glColor3usv CALL_THE_QGL_VERSION_OF_glColor3usv
|
|
#define glColor4b CALL_THE_QGL_VERSION_OF_glColor4b
|
|
#define glColor4bv CALL_THE_QGL_VERSION_OF_glColor4bv
|
|
#define glColor4d CALL_THE_QGL_VERSION_OF_glColor4d
|
|
#define glColor4dv CALL_THE_QGL_VERSION_OF_glColor4dv
|
|
#define glColor4f CALL_THE_QGL_VERSION_OF_glColor4f
|
|
#define glColor4fv CALL_THE_QGL_VERSION_OF_glColor4fv
|
|
#define glColor4i CALL_THE_QGL_VERSION_OF_glColor4i
|
|
#define glColor4iv CALL_THE_QGL_VERSION_OF_glColor4iv
|
|
#define glColor4s CALL_THE_QGL_VERSION_OF_glColor4s
|
|
#define glColor4sv CALL_THE_QGL_VERSION_OF_glColor4sv
|
|
#define glColor4ub CALL_THE_QGL_VERSION_OF_glColor4ub
|
|
#define glColor4ubv CALL_THE_QGL_VERSION_OF_glColor4ubv
|
|
#define glColor4ui CALL_THE_QGL_VERSION_OF_glColor4ui
|
|
#define glColor4uiv CALL_THE_QGL_VERSION_OF_glColor4uiv
|
|
#define glColor4us CALL_THE_QGL_VERSION_OF_glColor4us
|
|
#define glColor4usv CALL_THE_QGL_VERSION_OF_glColor4usv
|
|
#define glColorMask CALL_THE_QGL_VERSION_OF_glColorMask
|
|
#define glColorMaterial CALL_THE_QGL_VERSION_OF_glColorMaterial
|
|
#define glColorPointer CALL_THE_QGL_VERSION_OF_glColorPointer
|
|
#define glCopyPixels CALL_THE_QGL_VERSION_OF_glCopyPixels
|
|
#define glCopyTexImage1D CALL_THE_QGL_VERSION_OF_glCopyTexImage1D
|
|
#define glCopyTexImage2D CALL_THE_QGL_VERSION_OF_glCopyTexImage2D
|
|
#define glCopyTexSubImage1D CALL_THE_QGL_VERSION_OF_glCopyTexSubImage1D
|
|
#define glCopyTexSubImage2D CALL_THE_QGL_VERSION_OF_glCopyTexSubImage2D
|
|
#define glCullFace CALL_THE_QGL_VERSION_OF_glCullFace
|
|
#define glDeleteLists CALL_THE_QGL_VERSION_OF_glDeleteLists
|
|
#define glDeleteTextures CALL_THE_QGL_VERSION_OF_glDeleteTextures
|
|
#define glDepthFunc CALL_THE_QGL_VERSION_OF_glDepthFunc
|
|
#define glDepthMask CALL_THE_QGL_VERSION_OF_glDepthMask
|
|
#define glDepthRange CALL_THE_QGL_VERSION_OF_glDepthRange
|
|
#define glDisable CALL_THE_QGL_VERSION_OF_glDisable
|
|
#define glDisableClientState CALL_THE_QGL_VERSION_OF_glDisableClientState
|
|
#define glDrawArrays CALL_THE_QGL_VERSION_OF_glDrawArrays
|
|
#define glDrawBuffer CALL_THE_QGL_VERSION_OF_glDrawBuffer
|
|
#define glDrawElements CALL_THE_QGL_VERSION_OF_glDrawElements
|
|
#define glDrawPixels CALL_THE_QGL_VERSION_OF_glDrawPixels
|
|
#define glEdgeFlag CALL_THE_QGL_VERSION_OF_glEdgeFlag
|
|
#define glEdgeFlagPointer CALL_THE_QGL_VERSION_OF_glEdgeFlagPointer
|
|
#define glEdgeFlagv CALL_THE_QGL_VERSION_OF_glEdgeFlagv
|
|
#define glEnable CALL_THE_QGL_VERSION_OF_glEnable
|
|
#define glEnableClientState CALL_THE_QGL_VERSION_OF_glEnableClientState
|
|
#define glEnd CALL_THE_QGL_VERSION_OF_glEnd
|
|
#define glEndList CALL_THE_QGL_VERSION_OF_glEndList
|
|
#define glEvalCoord1d CALL_THE_QGL_VERSION_OF_glEvalCoord1d
|
|
#define glEvalCoord1dv CALL_THE_QGL_VERSION_OF_glEvalCoord1dv
|
|
#define glEvalCoord1f CALL_THE_QGL_VERSION_OF_glEvalCoord1f
|
|
#define glEvalCoord1fv CALL_THE_QGL_VERSION_OF_glEvalCoord1fv
|
|
#define glEvalCoord2d CALL_THE_QGL_VERSION_OF_glEvalCoord2d
|
|
#define glEvalCoord2dv CALL_THE_QGL_VERSION_OF_glEvalCoord2dv
|
|
#define glEvalCoord2f CALL_THE_QGL_VERSION_OF_glEvalCoord2f
|
|
#define glEvalCoord2fv CALL_THE_QGL_VERSION_OF_glEvalCoord2fv
|
|
#define glEvalMesh1 CALL_THE_QGL_VERSION_OF_glEvalMesh1
|
|
#define glEvalMesh2 CALL_THE_QGL_VERSION_OF_glEvalMesh2
|
|
#define glEvalPoint1 CALL_THE_QGL_VERSION_OF_glEvalPoint1
|
|
#define glEvalPoint2 CALL_THE_QGL_VERSION_OF_glEvalPoint2
|
|
#define glFeedbackBuffer CALL_THE_QGL_VERSION_OF_glFeedbackBuffer
|
|
#define glFinish CALL_THE_QGL_VERSION_OF_glFinish
|
|
#define glFlush CALL_THE_QGL_VERSION_OF_glFlush
|
|
#define glFogf CALL_THE_QGL_VERSION_OF_glFogf
|
|
#define glFogfv CALL_THE_QGL_VERSION_OF_glFogfv
|
|
#define glFogi CALL_THE_QGL_VERSION_OF_glFogi
|
|
#define glFogiv CALL_THE_QGL_VERSION_OF_glFogiv
|
|
#define glFrontFace CALL_THE_QGL_VERSION_OF_glFrontFace
|
|
#define glFrustum CALL_THE_QGL_VERSION_OF_glFrustum
|
|
#define glGenLists CALL_THE_QGL_VERSION_OF_glGenLists
|
|
#define glGenTextures CALL_THE_QGL_VERSION_OF_glGenTextures
|
|
#define glGetBooleanv CALL_THE_QGL_VERSION_OF_glGetBooleanv
|
|
#define glGetClipPlane CALL_THE_QGL_VERSION_OF_glGetClipPlane
|
|
#define glGetDoublev CALL_THE_QGL_VERSION_OF_glGetDoublev
|
|
#define glGetError CALL_THE_QGL_VERSION_OF_glGetError
|
|
#define glGetFloatv CALL_THE_QGL_VERSION_OF_glGetFloatv
|
|
#define glGetIntegerv CALL_THE_QGL_VERSION_OF_glGetIntegerv
|
|
#define glGetLightfv CALL_THE_QGL_VERSION_OF_glGetLightfv
|
|
#define glGetLightiv CALL_THE_QGL_VERSION_OF_glGetLightiv
|
|
#define glGetMapdv CALL_THE_QGL_VERSION_OF_glGetMapdv
|
|
#define glGetMapfv CALL_THE_QGL_VERSION_OF_glGetMapfv
|
|
#define glGetMapiv CALL_THE_QGL_VERSION_OF_glGetMapiv
|
|
#define glGetMaterialfv CALL_THE_QGL_VERSION_OF_glGetMaterialfv
|
|
#define glGetMaterialiv CALL_THE_QGL_VERSION_OF_glGetMaterialiv
|
|
#define glGetPixelMapfv CALL_THE_QGL_VERSION_OF_glGetPixelMapfv
|
|
#define glGetPixelMapuiv CALL_THE_QGL_VERSION_OF_glGetPixelMapuiv
|
|
#define glGetPixelMapusv CALL_THE_QGL_VERSION_OF_glGetPixelMapusv
|
|
#define glGetPointerv CALL_THE_QGL_VERSION_OF_glGetPointerv
|
|
#define glGetPolygonStipple CALL_THE_QGL_VERSION_OF_glGetPolygonStipple
|
|
#define glGetString CALL_THE_QGL_VERSION_OF_glGetString
|
|
#define glGetTexEnvfv CALL_THE_QGL_VERSION_OF_glGetTexEnvfv
|
|
#define glGetTexEnviv CALL_THE_QGL_VERSION_OF_glGetTexEnviv
|
|
#define glGetTexGendv CALL_THE_QGL_VERSION_OF_glGetTexGendv
|
|
#define glGetTexGenfv CALL_THE_QGL_VERSION_OF_glGetTexGenfv
|
|
#define glGetTexGeniv CALL_THE_QGL_VERSION_OF_glGetTexGeniv
|
|
#define glGetTexImage CALL_THE_QGL_VERSION_OF_glGetTexImage
|
|
#define glGetTexLevelParameterfv CALL_THE_QGL_VERSION_OF_glGetTexLevelParameterfv
|
|
#define glGetTexLevelParameteriv CALL_THE_QGL_VERSION_OF_glGetTexLevelParameteriv
|
|
#define glGetTexParameterfv CALL_THE_QGL_VERSION_OF_glGetTexParameterfv
|
|
#define glGetTexParameteriv CALL_THE_QGL_VERSION_OF_glGetTexParameteriv
|
|
#define glHint CALL_THE_QGL_VERSION_OF_glHint
|
|
#define glIndexMask CALL_THE_QGL_VERSION_OF_glIndexMask
|
|
#define glIndexPointer CALL_THE_QGL_VERSION_OF_glIndexPointer
|
|
#define glIndexd CALL_THE_QGL_VERSION_OF_glIndexd
|
|
#define glIndexdv CALL_THE_QGL_VERSION_OF_glIndexdv
|
|
#define glIndexf CALL_THE_QGL_VERSION_OF_glIndexf
|
|
#define glIndexfv CALL_THE_QGL_VERSION_OF_glIndexfv
|
|
#define glIndexi CALL_THE_QGL_VERSION_OF_glIndexi
|
|
#define glIndexiv CALL_THE_QGL_VERSION_OF_glIndexiv
|
|
#define glIndexs CALL_THE_QGL_VERSION_OF_glIndexs
|
|
#define glIndexsv CALL_THE_QGL_VERSION_OF_glIndexsv
|
|
#define glIndexub CALL_THE_QGL_VERSION_OF_glIndexub
|
|
#define glIndexubv CALL_THE_QGL_VERSION_OF_glIndexubv
|
|
#define glInitNames CALL_THE_QGL_VERSION_OF_glInitNames
|
|
#define glInterleavedArrays CALL_THE_QGL_VERSION_OF_glInterleavedArrays
|
|
#define glIsEnabled CALL_THE_QGL_VERSION_OF_glIsEnabled
|
|
#define glIsList CALL_THE_QGL_VERSION_OF_glIsList
|
|
#define glIsTexture CALL_THE_QGL_VERSION_OF_glIsTexture
|
|
#define glLightModelf CALL_THE_QGL_VERSION_OF_glLightModelf
|
|
#define glLightModelfv CALL_THE_QGL_VERSION_OF_glLightModelfv
|
|
#define glLightModeli CALL_THE_QGL_VERSION_OF_glLightModeli
|
|
#define glLightModeliv CALL_THE_QGL_VERSION_OF_glLightModeliv
|
|
#define glLightf CALL_THE_QGL_VERSION_OF_glLightf
|
|
#define glLightfv CALL_THE_QGL_VERSION_OF_glLightfv
|
|
#define glLighti CALL_THE_QGL_VERSION_OF_glLighti
|
|
#define glLightiv CALL_THE_QGL_VERSION_OF_glLightiv
|
|
#define glLineStipple CALL_THE_QGL_VERSION_OF_glLineStipple
|
|
#define glLineWidth CALL_THE_QGL_VERSION_OF_glLineWidth
|
|
#define glListBase CALL_THE_QGL_VERSION_OF_glListBase
|
|
#define glLoadIdentity CALL_THE_QGL_VERSION_OF_glLoadIdentity
|
|
#define glLoadMatrixd CALL_THE_QGL_VERSION_OF_glLoadMatrixd
|
|
#define glLoadMatrixf CALL_THE_QGL_VERSION_OF_glLoadMatrixf
|
|
#define glLoadName CALL_THE_QGL_VERSION_OF_glLoadName
|
|
#define glLogicOp CALL_THE_QGL_VERSION_OF_glLogicOp
|
|
#define glMap1d CALL_THE_QGL_VERSION_OF_glMap1d
|
|
#define glMap1f CALL_THE_QGL_VERSION_OF_glMap1f
|
|
#define glMap2d CALL_THE_QGL_VERSION_OF_glMap2d
|
|
#define glMap2f CALL_THE_QGL_VERSION_OF_glMap2f
|
|
#define glMapGrid1d CALL_THE_QGL_VERSION_OF_glMapGrid1d
|
|
#define glMapGrid1f CALL_THE_QGL_VERSION_OF_glMapGrid1f
|
|
#define glMapGrid2d CALL_THE_QGL_VERSION_OF_glMapGrid2d
|
|
#define glMapGrid2f CALL_THE_QGL_VERSION_OF_glMapGrid2f
|
|
#define glMaterialf CALL_THE_QGL_VERSION_OF_glMaterialf
|
|
#define glMaterialfv CALL_THE_QGL_VERSION_OF_glMaterialfv
|
|
#define glMateriali CALL_THE_QGL_VERSION_OF_glMateriali
|
|
#define glMaterialiv CALL_THE_QGL_VERSION_OF_glMaterialiv
|
|
#define glMatrixMode CALL_THE_QGL_VERSION_OF_glMatrixMode
|
|
#define glMultMatrixd CALL_THE_QGL_VERSION_OF_glMultMatrixd
|
|
#define glMultMatrixf CALL_THE_QGL_VERSION_OF_glMultMatrixf
|
|
#define glNewList CALL_THE_QGL_VERSION_OF_glNewList
|
|
#define glNormal3b CALL_THE_QGL_VERSION_OF_glNormal3b
|
|
#define glNormal3bv CALL_THE_QGL_VERSION_OF_glNormal3bv
|
|
#define glNormal3d CALL_THE_QGL_VERSION_OF_glNormal3d
|
|
#define glNormal3dv CALL_THE_QGL_VERSION_OF_glNormal3dv
|
|
#define glNormal3f CALL_THE_QGL_VERSION_OF_glNormal3f
|
|
#define glNormal3fv CALL_THE_QGL_VERSION_OF_glNormal3fv
|
|
#define glNormal3i CALL_THE_QGL_VERSION_OF_glNormal3i
|
|
#define glNormal3iv CALL_THE_QGL_VERSION_OF_glNormal3iv
|
|
#define glNormal3s CALL_THE_QGL_VERSION_OF_glNormal3s
|
|
#define glNormal3sv CALL_THE_QGL_VERSION_OF_glNormal3sv
|
|
#define glNormalPointer CALL_THE_QGL_VERSION_OF_glNormalPointer
|
|
#define glOrtho CALL_THE_QGL_VERSION_OF_glOrtho
|
|
#define glPassThrough CALL_THE_QGL_VERSION_OF_glPassThrough
|
|
#define glPixelMapfv CALL_THE_QGL_VERSION_OF_glPixelMapfv
|
|
#define glPixelMapuiv CALL_THE_QGL_VERSION_OF_glPixelMapuiv
|
|
#define glPixelMapusv CALL_THE_QGL_VERSION_OF_glPixelMapusv
|
|
#define glPixelStoref CALL_THE_QGL_VERSION_OF_glPixelStoref
|
|
#define glPixelStorei CALL_THE_QGL_VERSION_OF_glPixelStorei
|
|
#define glPixelTransferf CALL_THE_QGL_VERSION_OF_glPixelTransferf
|
|
#define glPixelTransferi CALL_THE_QGL_VERSION_OF_glPixelTransferi
|
|
#define glPixelZoom CALL_THE_QGL_VERSION_OF_glPixelZoom
|
|
#define glPointSize CALL_THE_QGL_VERSION_OF_glPointSize
|
|
#define glPolygonMode CALL_THE_QGL_VERSION_OF_glPolygonMode
|
|
#define glPolygonOffset CALL_THE_QGL_VERSION_OF_glPolygonOffset
|
|
#define glPolygonStipple CALL_THE_QGL_VERSION_OF_glPolygonStipple
|
|
#define glPopAttrib CALL_THE_QGL_VERSION_OF_glPopAttrib
|
|
#define glPopClientAttrib CALL_THE_QGL_VERSION_OF_glPopClientAttrib
|
|
#define glPopMatrix CALL_THE_QGL_VERSION_OF_glPopMatrix
|
|
#define glPopName CALL_THE_QGL_VERSION_OF_glPopName
|
|
#define glPrioritizeTextures CALL_THE_QGL_VERSION_OF_glPrioritizeTextures
|
|
#define glPushAttrib CALL_THE_QGL_VERSION_OF_glPushAttrib
|
|
#define glPushClientAttrib CALL_THE_QGL_VERSION_OF_glPushClientAttrib
|
|
#define glPushMatrix CALL_THE_QGL_VERSION_OF_glPushMatrix
|
|
#define glPushName CALL_THE_QGL_VERSION_OF_glPushName
|
|
#define glRasterPos2d CALL_THE_QGL_VERSION_OF_glRasterPos2d
|
|
#define glRasterPos2dv CALL_THE_QGL_VERSION_OF_glRasterPos2dv
|
|
#define glRasterPos2f CALL_THE_QGL_VERSION_OF_glRasterPos2f
|
|
#define glRasterPos2fv CALL_THE_QGL_VERSION_OF_glRasterPos2fv
|
|
#define glRasterPos2i CALL_THE_QGL_VERSION_OF_glRasterPos2i
|
|
#define glRasterPos2iv CALL_THE_QGL_VERSION_OF_glRasterPos2iv
|
|
#define glRasterPos2s CALL_THE_QGL_VERSION_OF_glRasterPos2s
|
|
#define glRasterPos2sv CALL_THE_QGL_VERSION_OF_glRasterPos2sv
|
|
#define glRasterPos3d CALL_THE_QGL_VERSION_OF_glRasterPos3d
|
|
#define glRasterPos3dv CALL_THE_QGL_VERSION_OF_glRasterPos3dv
|
|
#define glRasterPos3f CALL_THE_QGL_VERSION_OF_glRasterPos3f
|
|
#define glRasterPos3fv CALL_THE_QGL_VERSION_OF_glRasterPos3fv
|
|
#define glRasterPos3i CALL_THE_QGL_VERSION_OF_glRasterPos3i
|
|
#define glRasterPos3iv CALL_THE_QGL_VERSION_OF_glRasterPos3iv
|
|
#define glRasterPos3s CALL_THE_QGL_VERSION_OF_glRasterPos3s
|
|
#define glRasterPos3sv CALL_THE_QGL_VERSION_OF_glRasterPos3sv
|
|
#define glRasterPos4d CALL_THE_QGL_VERSION_OF_glRasterPos4d
|
|
#define glRasterPos4dv CALL_THE_QGL_VERSION_OF_glRasterPos4dv
|
|
#define glRasterPos4f CALL_THE_QGL_VERSION_OF_glRasterPos4f
|
|
#define glRasterPos4fv CALL_THE_QGL_VERSION_OF_glRasterPos4fv
|
|
#define glRasterPos4i CALL_THE_QGL_VERSION_OF_glRasterPos4i
|
|
#define glRasterPos4iv CALL_THE_QGL_VERSION_OF_glRasterPos4iv
|
|
#define glRasterPos4s CALL_THE_QGL_VERSION_OF_glRasterPos4s
|
|
#define glRasterPos4sv CALL_THE_QGL_VERSION_OF_glRasterPos4sv
|
|
#define glReadBuffer CALL_THE_QGL_VERSION_OF_glReadBuffer
|
|
#define glReadPixels CALL_THE_QGL_VERSION_OF_glReadPixels
|
|
#define glRectd CALL_THE_QGL_VERSION_OF_glRectd
|
|
#define glRectdv CALL_THE_QGL_VERSION_OF_glRectdv
|
|
#define glRectf CALL_THE_QGL_VERSION_OF_glRectf
|
|
#define glRectfv CALL_THE_QGL_VERSION_OF_glRectfv
|
|
#define glRecti CALL_THE_QGL_VERSION_OF_glRecti
|
|
#define glRectiv CALL_THE_QGL_VERSION_OF_glRectiv
|
|
#define glRects CALL_THE_QGL_VERSION_OF_glRects
|
|
#define glRectsv CALL_THE_QGL_VERSION_OF_glRectsv
|
|
#define glRenderMode CALL_THE_QGL_VERSION_OF_glRenderMode
|
|
#define glRotated CALL_THE_QGL_VERSION_OF_glRotated
|
|
#define glRotatef CALL_THE_QGL_VERSION_OF_glRotatef
|
|
#define glScaled CALL_THE_QGL_VERSION_OF_glScaled
|
|
#define glScalef CALL_THE_QGL_VERSION_OF_glScalef
|
|
#define glScissor CALL_THE_QGL_VERSION_OF_glScissor
|
|
#define glSelectBuffer CALL_THE_QGL_VERSION_OF_glSelectBuffer
|
|
#define glShadeModel CALL_THE_QGL_VERSION_OF_glShadeModel
|
|
#define glStencilFunc CALL_THE_QGL_VERSION_OF_glStencilFunc
|
|
#define glStencilMask CALL_THE_QGL_VERSION_OF_glStencilMask
|
|
#define glStencilOp CALL_THE_QGL_VERSION_OF_glStencilOp
|
|
#define glTexCoord1d CALL_THE_QGL_VERSION_OF_glTexCoord1d
|
|
#define glTexCoord1dv CALL_THE_QGL_VERSION_OF_glTexCoord1dv
|
|
#define glTexCoord1f CALL_THE_QGL_VERSION_OF_glTexCoord1f
|
|
#define glTexCoord1fv CALL_THE_QGL_VERSION_OF_glTexCoord1fv
|
|
#define glTexCoord1i CALL_THE_QGL_VERSION_OF_glTexCoord1i
|
|
#define glTexCoord1iv CALL_THE_QGL_VERSION_OF_glTexCoord1iv
|
|
#define glTexCoord1s CALL_THE_QGL_VERSION_OF_glTexCoord1s
|
|
#define glTexCoord1sv CALL_THE_QGL_VERSION_OF_glTexCoord1sv
|
|
#define glTexCoord2d CALL_THE_QGL_VERSION_OF_glTexCoord2d
|
|
#define glTexCoord2dv CALL_THE_QGL_VERSION_OF_glTexCoord2dv
|
|
#define glTexCoord2f CALL_THE_QGL_VERSION_OF_glTexCoord2f
|
|
#define glTexCoord2fv CALL_THE_QGL_VERSION_OF_glTexCoord2fv
|
|
#define glTexCoord2i CALL_THE_QGL_VERSION_OF_glTexCoord2i
|
|
#define glTexCoord2iv CALL_THE_QGL_VERSION_OF_glTexCoord2iv
|
|
#define glTexCoord2s CALL_THE_QGL_VERSION_OF_glTexCoord2s
|
|
#define glTexCoord2sv CALL_THE_QGL_VERSION_OF_glTexCoord2sv
|
|
#define glTexCoord3d CALL_THE_QGL_VERSION_OF_glTexCoord3d
|
|
#define glTexCoord3dv CALL_THE_QGL_VERSION_OF_glTexCoord3dv
|
|
#define glTexCoord3f CALL_THE_QGL_VERSION_OF_glTexCoord3f
|
|
#define glTexCoord3fv CALL_THE_QGL_VERSION_OF_glTexCoord3fv
|
|
#define glTexCoord3i CALL_THE_QGL_VERSION_OF_glTexCoord3i
|
|
#define glTexCoord3iv CALL_THE_QGL_VERSION_OF_glTexCoord3iv
|
|
#define glTexCoord3s CALL_THE_QGL_VERSION_OF_glTexCoord3s
|
|
#define glTexCoord3sv CALL_THE_QGL_VERSION_OF_glTexCoord3sv
|
|
#define glTexCoord4d CALL_THE_QGL_VERSION_OF_glTexCoord4d
|
|
#define glTexCoord4dv CALL_THE_QGL_VERSION_OF_glTexCoord4dv
|
|
#define glTexCoord4f CALL_THE_QGL_VERSION_OF_glTexCoord4f
|
|
#define glTexCoord4fv CALL_THE_QGL_VERSION_OF_glTexCoord4fv
|
|
#define glTexCoord4i CALL_THE_QGL_VERSION_OF_glTexCoord4i
|
|
#define glTexCoord4iv CALL_THE_QGL_VERSION_OF_glTexCoord4iv
|
|
#define glTexCoord4s CALL_THE_QGL_VERSION_OF_glTexCoord4s
|
|
#define glTexCoord4sv CALL_THE_QGL_VERSION_OF_glTexCoord4sv
|
|
#define glTexCoordPointer CALL_THE_QGL_VERSION_OF_glTexCoordPointer
|
|
#define glTexEnvf CALL_THE_QGL_VERSION_OF_glTexEnvf
|
|
#define glTexEnvfv CALL_THE_QGL_VERSION_OF_glTexEnvfv
|
|
#define glTexEnvi CALL_THE_QGL_VERSION_OF_glTexEnvi
|
|
#define glTexEnviv CALL_THE_QGL_VERSION_OF_glTexEnviv
|
|
#define glTexGend CALL_THE_QGL_VERSION_OF_glTexGend
|
|
#define glTexGendv CALL_THE_QGL_VERSION_OF_glTexGendv
|
|
#define glTexGenf CALL_THE_QGL_VERSION_OF_glTexGenf
|
|
#define glTexGenfv CALL_THE_QGL_VERSION_OF_glTexGenfv
|
|
#define glTexGeni CALL_THE_QGL_VERSION_OF_glTexGeni
|
|
#define glTexGeniv CALL_THE_QGL_VERSION_OF_glTexGeniv
|
|
#define glTexImage1D CALL_THE_QGL_VERSION_OF_glTexImage1D
|
|
#define glTexImage2D CALL_THE_QGL_VERSION_OF_glTexImage2D
|
|
#define glTexParameterf CALL_THE_QGL_VERSION_OF_glTexParameterf
|
|
#define glTexParameterfv CALL_THE_QGL_VERSION_OF_glTexParameterfv
|
|
#define glTexParameteri CALL_THE_QGL_VERSION_OF_glTexParameteri
|
|
#define glTexParameteriv CALL_THE_QGL_VERSION_OF_glTexParameteriv
|
|
#define glTexSubImage1D CALL_THE_QGL_VERSION_OF_glTexSubImage1D
|
|
#define glTexSubImage2D CALL_THE_QGL_VERSION_OF_glTexSubImage2D
|
|
#define glTranslated CALL_THE_QGL_VERSION_OF_glTranslated
|
|
#define glTranslatef CALL_THE_QGL_VERSION_OF_glTranslatef
|
|
#define glVertex2d CALL_THE_QGL_VERSION_OF_glVertex2d
|
|
#define glVertex2dv CALL_THE_QGL_VERSION_OF_glVertex2dv
|
|
#define glVertex2f CALL_THE_QGL_VERSION_OF_glVertex2f
|
|
#define glVertex2fv CALL_THE_QGL_VERSION_OF_glVertex2fv
|
|
#define glVertex2i CALL_THE_QGL_VERSION_OF_glVertex2i
|
|
#define glVertex2iv CALL_THE_QGL_VERSION_OF_glVertex2iv
|
|
#define glVertex2s CALL_THE_QGL_VERSION_OF_glVertex2s
|
|
#define glVertex2sv CALL_THE_QGL_VERSION_OF_glVertex2sv
|
|
#define glVertex3d CALL_THE_QGL_VERSION_OF_glVertex3d
|
|
#define glVertex3dv CALL_THE_QGL_VERSION_OF_glVertex3dv
|
|
#define glVertex3f CALL_THE_QGL_VERSION_OF_glVertex3f
|
|
#define glVertex3fv CALL_THE_QGL_VERSION_OF_glVertex3fv
|
|
#define glVertex3i CALL_THE_QGL_VERSION_OF_glVertex3i
|
|
#define glVertex3iv CALL_THE_QGL_VERSION_OF_glVertex3iv
|
|
#define glVertex3s CALL_THE_QGL_VERSION_OF_glVertex3s
|
|
#define glVertex3sv CALL_THE_QGL_VERSION_OF_glVertex3sv
|
|
#define glVertex4d CALL_THE_QGL_VERSION_OF_glVertex4d
|
|
#define glVertex4dv CALL_THE_QGL_VERSION_OF_glVertex4dv
|
|
#define glVertex4f CALL_THE_QGL_VERSION_OF_glVertex4f
|
|
#define glVertex4fv CALL_THE_QGL_VERSION_OF_glVertex4fv
|
|
#define glVertex4i CALL_THE_QGL_VERSION_OF_glVertex4i
|
|
#define glVertex4iv CALL_THE_QGL_VERSION_OF_glVertex4iv
|
|
#define glVertex4s CALL_THE_QGL_VERSION_OF_glVertex4s
|
|
#define glVertex4sv CALL_THE_QGL_VERSION_OF_glVertex4sv
|
|
#define glVertexPointer CALL_THE_QGL_VERSION_OF_glVertexPointer
|
|
#define glViewport CALL_THE_QGL_VERSION_OF_glViewport
|