/* * Copyright © 2005 Novell, Inc. * * Permission to use, copy, modify, distribute, and sell this software * and its documentation for any purpose is hereby granted without * fee, provided that the above copyright notice appear in all copies * and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of * Novell, Inc. not be used in advertising or publicity pertaining to * distribution of the software without specific, written prior permission. * Novell, Inc. makes no representations about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. * * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: David Reveman */ #include "xglglx.h" #include "xglglxext.h" #include "glapitable.h" #ifndef NGLXEXTLOG static struct _glapi_table *nativeRenderTable = 0; static FILE *logFp = 0; static Bool logVertexAttribs = FALSE; static struct VertexAttribCount { int n; char *name; } vCnt[] = { { 0, "glArrayElement" }, { 0, "glCallList" }, { 0, "glCallLists" }, { 0, "glColor3bv" }, { 0, "glColor3dv" }, { 0, "glColor3fv" }, { 0, "glColor3iv" }, { 0, "glColor3sv" }, { 0, "glColor3ubv" }, { 0, "glColor3uiv" }, { 0, "glColor3usv" }, { 0, "glColor4bv" }, { 0, "glColor4dv" }, { 0, "glColor4fv" }, { 0, "glColor4iv" }, { 0, "glColor4sv" }, { 0, "glColor4ubv" }, { 0, "glColor4uiv" }, { 0, "glColor4usv" }, { 0, "glEdgeFlagv" }, { 0, "glEvalCoord1dv" }, { 0, "glEvalCoord1fv" }, { 0, "glEvalCoord2dv" }, { 0, "glEvalCoord2fv" }, { 0, "glEvalPoint1" }, { 0, "glEvalPoint2" }, { 0, "glIndexdv" }, { 0, "glIndexfv" }, { 0, "glIndexiv" }, { 0, "glIndexsv" }, { 0, "glIndexubv" }, { 0, "glMaterialf" }, { 0, "glMaterialfv" }, { 0, "glMateriali" }, { 0, "glMaterialiv" }, { 0, "glNormal3bv" }, { 0, "glNormal3dv" }, { 0, "glNormal3fv" }, { 0, "glNormal3iv" }, { 0, "glNormal3sv" }, { 0, "glTexCoord1dv" }, { 0, "glTexCoord1fv" }, { 0, "glTexCoord1iv" }, { 0, "glTexCoord1sv" }, { 0, "glTexCoord2dv" }, { 0, "glTexCoord2fv" }, { 0, "glTexCoord2iv" }, { 0, "glTexCoord2sv" }, { 0, "glTexCoord3dv" }, { 0, "glTexCoord3fv" }, { 0, "glTexCoord3iv" }, { 0, "glTexCoord3sv" }, { 0, "glTexCoord4dv" }, { 0, "glTexCoord4fv" }, { 0, "glTexCoord4iv" }, { 0, "glTexCoord4sv" }, { 0, "glVertex2dv" }, { 0, "glVertex2fv" }, { 0, "glVertex2iv" }, { 0, "glVertex2sv" }, { 0, "glVertex3dv" }, { 0, "glVertex3fv" }, { 0, "glVertex3iv" }, { 0, "glVertex3sv" }, { 0, "glVertex4dv" }, { 0, "glVertex4fv" }, { 0, "glVertex4iv" }, { 0, "glVertex4sv" }, { 0, "glMultiTexCoord1dv" }, { 0, "glMultiTexCoord1fv" }, { 0, "glMultiTexCoord1iv" }, { 0, "glMultiTexCoord1sv" }, { 0, "glMultiTexCoord2dv" }, { 0, "glMultiTexCoord2fv" }, { 0, "glMultiTexCoord2iv" }, { 0, "glMultiTexCoord2sv" }, { 0, "glMultiTexCoord3dv" }, { 0, "glMultiTexCoord3fv" }, { 0, "glMultiTexCoord3iv" }, { 0, "glMultiTexCoord3sv" }, { 0, "glMultiTexCoord4dv" }, { 0, "glMultiTexCoord4fv" }, { 0, "glMultiTexCoord4iv" }, { 0, "glMultiTexCoord4sv" }, { 0, "glFogCoordfv" }, { 0, "glFogCoorddv" }, { 0, "glSecondaryColor3bv" }, { 0, "glSecondaryColor3dv" }, { 0, "glSecondaryColor3fv" }, { 0, "glSecondaryColor3iv" }, { 0, "glSecondaryColor3sv" }, { 0, "glSecondaryColor3ubv" }, { 0, "glSecondaryColor3uiv" }, { 0, "glSecondaryColor3usv" } }; #define arrayElementIndex 0 #define callListIndex 1 #define callListsIndex 2 #define color3bvIndex 3 #define color3dvIndex 4 #define color3fvIndex 5 #define color3ivIndex 6 #define color3svIndex 7 #define color3ubvIndex 8 #define color3uivIndex 9 #define color3usvIndex 10 #define color4bvIndex 11 #define color4dvIndex 12 #define color4fvIndex 13 #define color4ivIndex 14 #define color4svIndex 15 #define color4ubvIndex 16 #define color4uivIndex 17 #define color4usvIndex 18 #define edgeFlagvIndex 19 #define evalCoord1dvIndex 20 #define evalCoord1fvIndex 21 #define evalCoord2dvIndex 22 #define evalCoord2fvIndex 23 #define evalPoint1Index 24 #define evalPoint2Index 25 #define indexdvIndex 26 #define indexfvIndex 27 #define indexivIndex 28 #define indexsvIndex 29 #define indexubvIndex 30 #define materialfIndex 31 #define materialfvIndex 32 #define materialiIndex 33 #define materialivIndex 34 #define normal3bvIndex 35 #define normal3dvIndex 36 #define normal3fvIndex 37 #define normal3ivIndex 38 #define normal3svIndex 39 #define texCoord1dvIndex 40 #define texCoord1fvIndex 41 #define texCoord1ivIndex 42 #define texCoord1svIndex 43 #define texCoord2dvIndex 44 #define texCoord2fvIndex 45 #define texCoord2ivIndex 46 #define texCoord2svIndex 47 #define texCoord3dvIndex 48 #define texCoord3fvIndex 49 #define texCoord3ivIndex 50 #define texCoord3svIndex 51 #define texCoord4dvIndex 52 #define texCoord4fvIndex 53 #define texCoord4ivIndex 54 #define texCoord4svIndex 55 #define vertex2dvIndex 56 #define vertex2fvIndex 57 #define vertex2ivIndex 58 #define vertex2svIndex 59 #define vertex3dvIndex 60 #define vertex3fvIndex 61 #define vertex3ivIndex 62 #define vertex3svIndex 63 #define vertex4dvIndex 64 #define vertex4fvIndex 65 #define vertex4ivIndex 66 #define vertex4svIndex 67 #define multiTexCoord1dvIndex 68 #define multiTexCoord1fvIndex 69 #define multiTexCoord1ivIndex 70 #define multiTexCoord1svIndex 71 #define multiTexCoord2dvIndex 72 #define multiTexCoord2fvIndex 73 #define multiTexCoord2ivIndex 74 #define multiTexCoord2svIndex 75 #define multiTexCoord3dvIndex 76 #define multiTexCoord3fvIndex 77 #define multiTexCoord3ivIndex 78 #define multiTexCoord3svIndex 79 #define multiTexCoord4dvIndex 80 #define multiTexCoord4fvIndex 81 #define multiTexCoord4ivIndex 82 #define multiTexCoord4svIndex 83 #define fogCoordfvIndex 84 #define fogCoorddvIndex 85 #define secondaryColor3bvIndex 86 #define secondaryColor3dvIndex 87 #define secondaryColor3fvIndex 88 #define secondaryColor3ivIndex 89 #define secondaryColor3svIndex 90 #define secondaryColor3ubvIndex 91 #define secondaryColor3uivIndex 92 #define secondaryColor3usvIndex 93 static void logAccum (GLenum op, GLfloat value) { fprintf (logFp, "glAccum (0x%x, %f)\n", op, value); (*nativeRenderTable->Accum) (op, value); } static void logAlphaFunc (GLenum func, GLclampf ref) { fprintf (logFp, "glAlphaFunc (0x%x, %f)\n", func, ref); (*nativeRenderTable->AlphaFunc) (func, ref); } static GLboolean logAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences) { fprintf (logFp, "glAreTexturesResident (%d, %p, %p)\n", n, textures, residences); return (*nativeRenderTable->AreTexturesResident) (n, textures, residences); } static void logArrayElement (GLint i) { vCnt[arrayElementIndex].n++; if (logVertexAttribs) fprintf (logFp, "glArrayElement (%d)\n", i); (*nativeRenderTable->ArrayElement) (i); } static void logBegin (GLenum mode) { fprintf (logFp, "glBegin (0x%x)\n", mode); (*nativeRenderTable->Begin) (mode); } static void logBindTexture (GLenum target, GLuint texture) { fprintf (logFp, "glBindTexture (0x%x, %u)\n", target, texture); (*nativeRenderTable->BindTexture) (target, texture); } static void logBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) { fprintf (logFp, "glBitmap (%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap); (*nativeRenderTable->Bitmap) (width, height, xorig, yorig, xmove, ymove, bitmap); } static void logBlendFunc (GLenum sfactor, GLenum dfactor) { fprintf (logFp, "glBlendFunc (0x%x, 0x%x)\n", sfactor, dfactor); (*nativeRenderTable->BlendFunc) (sfactor, dfactor); } static void logCallList (GLuint list) { vCnt[callListIndex].n++; if (logVertexAttribs) fprintf (logFp, "glCallList (%u)\n", list); (*nativeRenderTable->CallList) (list); } static void logCallLists (GLsizei n, GLenum type, const void *lists) { vCnt[callListsIndex].n++; if (logVertexAttribs) fprintf (logFp, "glCallLists (%d, 0x%x, %p)\n", n, type, lists); (*nativeRenderTable->CallLists) (n, type, lists); } static void logClear (GLbitfield mask) { fprintf (logFp, "glClear (0x%x)\n", mask); (*nativeRenderTable->Clear) (mask); } static void logClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { fprintf (logFp, "glClearAccum (%f, %f, %f, %f)\n", red, green, blue, alpha); (*nativeRenderTable->ClearAccum) (red, green, blue, alpha); } static void logClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { fprintf (logFp, "glClearColor (%f, %f, %f, %f)\n", red, green, blue, alpha); (*nativeRenderTable->ClearColor) (red, green, blue, alpha); } static void logClearDepth (GLclampd depth) { fprintf (logFp, "glClearDepth (%f)\n", depth); (*nativeRenderTable->ClearDepth) (depth); } static void logClearIndex (GLfloat c) { fprintf (logFp, "glClearIndex (%f)\n", c); (*nativeRenderTable->ClearIndex) (c); } static void logClearStencil (GLint s) { fprintf (logFp, "glClearStencil (%d)\n", s); (*nativeRenderTable->ClearStencil) (s); } static void logClipPlane (GLenum plane, const GLdouble *equation) { fprintf (logFp, "glClipPlane (0x%x, %p)\n", plane, equation); (*nativeRenderTable->ClipPlane) (plane, equation); } static void logColor3bv (const GLbyte *v) { vCnt[color3bvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3bv (%p)\n", v); (*nativeRenderTable->Color3bv) (v); } static void logColor3dv (const GLdouble *v) { vCnt[color3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3dv (%p)\n", v); (*nativeRenderTable->Color3dv) (v); } static void logColor3fv (const GLfloat *v) { vCnt[color3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3fv (%p)\n", v); (*nativeRenderTable->Color3fv) (v); } static void logColor3iv (const GLint *v) { vCnt[color3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3iv (%p)\n", v); (*nativeRenderTable->Color3iv) (v); } static void logColor3sv (const GLshort *v) { vCnt[color3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3sv (%p)\n", v); (*nativeRenderTable->Color3sv) (v); } static void logColor3ubv (const GLubyte *v) { vCnt[color3ubvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3ubv (%p)\n", v); (*nativeRenderTable->Color3ubv) (v); } static void logColor3uiv (const GLuint *v) { vCnt[color3uivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3uiv (%p)\n", v); (*nativeRenderTable->Color3uiv) (v); } static void logColor3usv (const GLushort *v) { vCnt[color3usvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor3usv (%p)\n", v); (*nativeRenderTable->Color3usv) (v); } static void logColor4bv (const GLbyte *v) { vCnt[color4bvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4bv (%p)\n", v); (*nativeRenderTable->Color4bv) (v); } static void logColor4dv (const GLdouble *v) { vCnt[color4dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4dv (%p)\n", v); (*nativeRenderTable->Color4dv) (v); } static void logColor4fv (const GLfloat *v) { vCnt[color4fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4fv (%p)\n", v); (*nativeRenderTable->Color4fv) (v); } static void logColor4iv (const GLint *v) { vCnt[color4ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4iv (%p)\n", v); (*nativeRenderTable->Color4iv) (v); } static void logColor4sv (const GLshort *v) { vCnt[color4svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4sv (%p)\n", v); (*nativeRenderTable->Color4sv) (v); } static void logColor4ubv (const GLubyte *v) { vCnt[color4ubvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4ubv (%p)\n", v); (*nativeRenderTable->Color4ubv) (v); } static void logColor4uiv(const GLuint *v) { vCnt[color4uivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4uiv (%p)\n", v); (*nativeRenderTable->Color4uiv) (v); } static void logColor4usv (const GLushort *v) { vCnt[color4usvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glColor4usv (%p)\n", v); (*nativeRenderTable->Color4usv) (v); } static void logColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { fprintf (logFp, "glColorMask (%d, %d, %d, %d)\n", red, green, blue, alpha); (*nativeRenderTable->ColorMask) (red, green, blue, alpha); } static void logColorMaterial (GLenum face, GLenum mode) { fprintf (logFp, "glColorMaterial (0x%x, 0x%x)\n", face, mode); (*nativeRenderTable->ColorMaterial) (face, mode); } static void logColorPointer (GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf (logFp, "glColorPointer (%d, 0x%x, %d, %p)\n", size, type, stride, pointer); (*nativeRenderTable->ColorPointer) (size, type, stride, pointer); } static void logCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) { fprintf (logFp, "glCopyPixels (%d, %d, %d, %d, 0x%x)\n", x, y, width, height, type); (*nativeRenderTable->CopyPixels) (x, y, width, height, type); } static void logCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) { fprintf (logFp, "glCopyTexImage1D (0x%x, %d, 0x%x, %d, %d, %d, %d)\n", target, level, internalFormat, x, y, width, border); (*nativeRenderTable->CopyTexImage1D) (target, level, internalFormat, x, y, width, border); } static void logCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { fprintf (logFp, "glCopyTexImage2D (0x%x, %d, 0x%x, %d, %d, %d, %d, %d)\n", target, level, internalFormat, x, y, width, height, border); (*nativeRenderTable->CopyTexImage2D) (target, level, internalFormat, x, y, width, height, border); } static void logCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { fprintf (logFp, "glCopyTexSubImage1D (0x%x, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width); (*nativeRenderTable->CopyTexSubImage1D) (target, level, xoffset, x, y, width); } static void logCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { fprintf (logFp, "glCopyTexSubImage2D (0x%x, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height); (*nativeRenderTable->CopyTexSubImage2D) (target, level, xoffset, yoffset, x, y, width, height); } static void logCullFace (GLenum mode) { fprintf (logFp, "glCullFace (0x%x)\n", mode); (*nativeRenderTable->CullFace) (mode); } static void logDeleteLists (GLuint list, GLsizei range) { fprintf (logFp, "glDeleteLists (%d, %d)\n", list, range); (*nativeRenderTable->DeleteLists) (list, range); } static void logDeleteTextures (GLsizei n, const GLuint *textures) { fprintf (logFp, "glDeleteTextures (%d, %p)\n", n, textures); (*nativeRenderTable->DeleteTextures) (n, textures); } static void logDepthFunc (GLenum func) { fprintf (logFp, "glDepthFunc (0x%x)\n", func); (*nativeRenderTable->DepthFunc) (func); } static void logDepthMask (GLboolean flag) { fprintf (logFp, "glDepthMask (%d)\n", flag); (*nativeRenderTable->DepthMask) (flag); } static void logDepthRange (GLclampd zNear, GLclampd zFar) { fprintf (logFp, "glDepthRange (%f, %f)\n", zNear, zFar); (*nativeRenderTable->DepthRange) (zNear, zFar); } static void logDisable (GLenum cap) { fprintf (logFp, "glDisable (0x%x)\n", cap); (*nativeRenderTable->Disable) (cap); } static void logDisableClientState (GLenum array) { fprintf (logFp, "glDisableClientState (0x%x)\n", array); (*nativeRenderTable->DisableClientState) (array); } static void logDrawArrays (GLenum mode, GLint first, GLsizei count) { fprintf (logFp, "glDrawArrays (0x%x, %d, %d)\n", mode, first, count); (*nativeRenderTable->DrawArrays) (mode, first, count); } static void logDrawBuffer (GLenum mode) { fprintf (logFp, "glDrawBuffer (0x%x)\n", mode); (*nativeRenderTable->DrawBuffer) (mode); } static void logDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices) { fprintf (logFp, "glDrawElements (0x%x, %d, 0x%x, %p)\n", mode, count, type, indices); (*nativeRenderTable->DrawElements) (mode, count, type, indices); } static void logDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { fprintf (logFp, "glDrawPixels (%d, %d, 0x%x, 0x%x, %p)\n", width, height, format, type, pixels); (*nativeRenderTable->DrawPixels) (width, height, format, type, pixels); } static void logEdgeFlagPointer (GLsizei stride, const void *pointer) { fprintf (logFp, "glEdgeFlagPointer (%d, %p)", stride, pointer); (*nativeRenderTable->EdgeFlagPointer) (stride, pointer); } static void logEdgeFlagv (const GLboolean *flag) { vCnt[edgeFlagvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glEdgeFlagv (%p)\n", flag); (*nativeRenderTable->EdgeFlagv) (flag); } static void logEnable (GLenum cap) { fprintf (logFp, "glEnable (0x%x)\n", cap); (*nativeRenderTable->Enable) (cap); } static void logEnableClientState (GLenum array) { fprintf (logFp, "glEnableClientState (0x%x)\n", array); (*nativeRenderTable->EnableClientState) (array); } static void logEnd (void) { int i; for (i = 0; i < sizeof (vCnt) / sizeof (vCnt[0]); i++) { if (vCnt[i].n) { fprintf (logFp, " %s: %d\n", vCnt[i].name, vCnt[i].n); vCnt[i].n = 0; } } fprintf (logFp, "glEnd ()\n" ); (*nativeRenderTable->End) (); } static void logEndList (void) { fprintf (logFp, "glEndList ()\n" ); (*nativeRenderTable->EndList) (); } static void logEvalCoord1dv (const GLdouble *u) { vCnt[evalCoord1dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glEvalCoord1dv (%p)\n", u); (*nativeRenderTable->EvalCoord1dv) (u); } static void logEvalCoord1fv (const GLfloat *u) { vCnt[evalCoord1fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glEvalCoord1fv (%p)\n", u); (*nativeRenderTable->EvalCoord1fv) (u); } static void logEvalCoord2dv (const GLdouble *u) { vCnt[evalCoord2dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glEvalCoord2dv (%p)\n", u); (*nativeRenderTable->EvalCoord2dv) (u); } static void logEvalCoord2fv (const GLfloat *u) { vCnt[evalCoord1fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glEvalCoord2fv (%p)\n", u); (*nativeRenderTable->EvalCoord2fv) (u); } static void logEvalMesh1 (GLenum mode, GLint i1, GLint i2) { fprintf (logFp, "glEvalMesh1 (0x%x, %d, %d)\n", mode, i1, i2); (*nativeRenderTable->EvalMesh1) (mode, i1, i2 ); } static void logEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { fprintf (logFp, "glEvalMesh2 (0x%x, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2); (*nativeRenderTable->EvalMesh2) (mode, i1, i2, j1, j2); } static void logEvalPoint1 (GLint i) { vCnt[evalPoint1Index].n++; if (logVertexAttribs) fprintf (logFp, "glEvalPoint1 (%d)\n", i); (*nativeRenderTable->EvalPoint1) (i); } static void logEvalPoint2 (GLint i, GLint j) { vCnt[evalPoint2Index].n++; if (logVertexAttribs) fprintf (logFp, "glEvalPoint2 (%d, %d)\n", i, j); (*nativeRenderTable->EvalPoint2) (i, j); } static void logFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer) { fprintf (logFp, "glFeedbackBuffer (%d, 0x%x, %p)\n", size, type, buffer); (*nativeRenderTable->FeedbackBuffer) (size, type, buffer); } static void logFinish (void) { fprintf (logFp, "glFinish ()\n"); (*nativeRenderTable->Finish) (); } static void logFlush (void) { fprintf (logFp, "glFlush ()\n"); (*nativeRenderTable->Flush) (); } static void logFogf (GLenum pname, GLfloat param) { fprintf (logFp, "glFogf (0x%x, %f)\n", pname, param); (*nativeRenderTable->Fogf) (pname, param); } static void logFogfv (GLenum pname, const GLfloat *params) { fprintf (logFp, "glFogfv (0x%x, %p)\n", pname, params); (*nativeRenderTable->Fogfv) (pname, params); } static void logFogi (GLenum pname, GLint param) { fprintf (logFp, "glFogi (0x%x, %d)\n", pname, param); (*nativeRenderTable->Fogi) (pname, param); } static void logFogiv (GLenum pname, const GLint *params) { fprintf (logFp, "glFogiv (0x%x, %p)\n", pname, params); (*nativeRenderTable->Fogiv) (pname, params); } static void logFrontFace (GLenum mode) { fprintf (logFp, "glFrontFace (0x%x)\n", mode); (*nativeRenderTable->FrontFace) (mode); } static void logFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { fprintf (logFp, "glFrustum (%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar); (*nativeRenderTable->Frustum) (left, right, bottom, top, zNear, zFar); } static GLuint logGenLists (GLsizei range) { fprintf (logFp, "glGenLists (%d)\n", range); return (*nativeRenderTable->GenLists) (range); } static void logGenTextures (GLsizei n, GLuint *textures) { fprintf (logFp, "glGenTextures (%d, %p)\n", n, textures); (*nativeRenderTable->GenTextures) (n, textures); } static void logGetBooleanv (GLenum pname, GLboolean *params) { fprintf (logFp, "glGetBooleanv (0x%x, %p)\n", pname, params); (*nativeRenderTable->GetBooleanv) (pname, params); } static void logGetClipPlane (GLenum plane, GLdouble *equation) { fprintf (logFp, "glGetClipPlane (0x%x, %p)\n", plane, equation); (*nativeRenderTable->GetClipPlane) (plane, equation); } static void logGetDoublev (GLenum pname, GLdouble *params) { fprintf (logFp, "glGetDoublev (0x%x, %p)\n", pname, params); (*nativeRenderTable->GetDoublev) (pname, params); } static GLenum logGetError (void) { fprintf (logFp, "glGetError ()\n"); return (*nativeRenderTable->GetError) (); } static void logGetFloatv (GLenum pname, GLfloat *params) { fprintf (logFp, "glGetFloatv (0x%x, %p)\n", pname, params); (*nativeRenderTable->GetFloatv) (pname, params); } static void logGetIntegerv (GLenum pname, GLint *params) { fprintf (logFp, "glGetIntegerv (0x%x, %p)\n", pname, params); (*nativeRenderTable->GetIntegerv) (pname, params); } static void logGetLightfv (GLenum light, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetLightfv (0x%x, 0x%x, %p)\n", light, pname, params); (*nativeRenderTable->GetLightfv) (light, pname, params); } static void logGetLightiv (GLenum light, GLenum pname, GLint *params) { fprintf (logFp, "glGetLightiv (0x%x, 0x%x, %p)\n", light, pname, params); (*nativeRenderTable->GetLightiv) (light, pname, params); } static void logGetMapdv (GLenum target, GLenum query, GLdouble *v) { fprintf (logFp, "glGetMapdv (0x%x, 0x%x, %p)\n", target, query, v); (*nativeRenderTable->GetMapdv) (target, query, v); } static void logGetMapfv (GLenum target, GLenum query, GLfloat *v) { fprintf (logFp, "glGetMapfv (0x%x, 0x%x, %p)\n", target, query, v); (*nativeRenderTable->GetMapfv) (target, query, v); } static void logGetMapiv (GLenum target, GLenum query, GLint *v) { fprintf (logFp, "glGetMapiv (0x%x, 0x%x, %p)\n", target, query, v); (*nativeRenderTable->GetMapiv) (target, query, v); } static void logGetMaterialfv (GLenum face, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetMaterialfv (0x%x, 0x%x, %p)\n", face, pname, params); (*nativeRenderTable->GetMaterialfv) (face, pname, params); } static void logGetMaterialiv (GLenum face, GLenum pname, GLint *params) { fprintf (logFp, "glGetMaterialiv (0x%x, 0x%x, %p)\n", face, pname, params); (*nativeRenderTable->GetMaterialiv) (face, pname, params); } static void logGetPixelMapfv (GLenum map, GLfloat *values) { fprintf (logFp, "glGetPixelMapfv (0x%x, %p)\n", map, values); (*nativeRenderTable->GetPixelMapfv) (map, values); } static void logGetPixelMapuiv (GLenum map, GLuint *values) { fprintf (logFp, "glGetPixelMapuiv (0x%x, %p)\n", map, values); (*nativeRenderTable->GetPixelMapuiv) (map, values); } static void logGetPixelMapusv (GLenum map, GLushort *values) { fprintf (logFp, "glGetPixelMapusv (0x%x, %p)\n", map, values); (*nativeRenderTable->GetPixelMapusv) (map, values); } static void logGetPointerv (GLenum pname, GLvoid **params) { fprintf (logFp, "glGetPointerv (0x%x, %p)\n", pname, params); (*nativeRenderTable->GetPointerv) (pname, params); } static void logGetPolygonStipple (GLubyte *mask) { fprintf (logFp, "glGetPolygonStipple (%p)\n", mask); (*nativeRenderTable->GetPolygonStipple) (mask); } static const GLubyte * logGetString (GLenum name) { fprintf (logFp, "glGetString (0x%x)\n", name); return (*nativeRenderTable->GetString) (name); } static void logGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetTexEnvfv) (target, pname, params); } static void logGetTexEnviv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetTexEnviv) (target, pname, params); } static void logGetTexGendv (GLenum coord, GLenum pname, GLdouble *params) { fprintf (logFp, "glGetTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->GetTexGendv) (coord, pname, params); } static void logGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->GetTexGenfv) (coord, pname, params); } static void logGetTexGeniv (GLenum coord, GLenum pname, GLint *params) { fprintf (logFp, "glGetTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->GetTexGeniv) (coord, pname, params); } static void logGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels) { fprintf (logFp, "glGetTexImage (0x%x, %d, 0x%x, 0x%x, %p)\n", target, level, format, type, pixels); (*nativeRenderTable->GetTexImage) (target, level, format, type, pixels); } static void logGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetTexLevelParameterfv (0x%x, %d, 0x%x, %p)\n", target, level, pname, params); (*nativeRenderTable->GetTexLevelParameterfv) (target, level, pname, params); } static void logGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params) { fprintf (logFp, "glGetTexLevelParameteriv (0x%x, %d, 0x%x, %p)\n", target, level, pname, params); (*nativeRenderTable->GetTexLevelParameteriv) (target, level, pname, params); } static void logGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetTexParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetTexParameterfv) (target, pname, params); } static void logGetTexParameteriv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetTexParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetTexParameteriv) (target, pname, params); } static void logHint (GLenum target, GLenum mode) { fprintf (logFp, "glHint (0x%x, 0x%x)\n", target, mode); (*nativeRenderTable->Hint) (target, mode); } static void logIndexMask (GLuint mask) { fprintf (logFp, "glIndexMask (%d)\n", mask); (*nativeRenderTable->IndexMask) (mask); } static void logIndexPointer (GLenum type, GLsizei stride, const void *pointer) { fprintf (logFp, "glIndexPointer (0x%x, %d, %p)\n", type, stride, pointer); (*nativeRenderTable->IndexPointer) (type, stride, pointer); } static void logIndexdv (const GLdouble *c) { vCnt[indexdvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glIndexdv (%p)\n", c); (*nativeRenderTable->Indexdv) (c); } static void logIndexfv (const GLfloat *c) { vCnt[indexfvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glIndexfv (%p)\n", c); (*nativeRenderTable->Indexfv) (c); } static void logIndexiv (const GLint *c) { vCnt[indexivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glIndexiv (%p)\n", c); (*nativeRenderTable->Indexiv) (c); } static void logIndexsv (const GLshort *c) { vCnt[indexsvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glIndexsv (%p)\n", c); (*nativeRenderTable->Indexsv) (c); } static void logIndexubv (const GLubyte *c) { vCnt[indexubvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glIndexubv (%p)\n", c); (*nativeRenderTable->Indexubv) (c); } static void logInitNames (void) { fprintf (logFp, "glInitNames ()\n" ); (*nativeRenderTable->InitNames) (); } static void logInterleavedArrays (GLenum format, GLsizei stride, const void *pointer) { fprintf (logFp, "glInterleavedArrays (0x%x, %d, %p)\n", format, stride, pointer); (*nativeRenderTable->InterleavedArrays) (format, stride, pointer); } static GLboolean logIsEnabled (GLenum cap) { fprintf (logFp, "glIsEnabled (0x%x)\n", cap); return (*nativeRenderTable->IsEnabled) (cap); } static GLboolean logIsList (GLuint list) { fprintf (logFp, "glIsList (%d)\n", list); return (*nativeRenderTable->IsList) (list); } static GLboolean logIsTexture (GLuint texture) { fprintf (logFp, "glIsTexture (%d)\n", texture); return (*nativeRenderTable->IsTexture) (texture); } static void logLightModelf (GLenum pname, GLfloat param) { fprintf (logFp, "glLightModelf (0x%x, %f)\n", pname, param); (*nativeRenderTable->LightModelf) (pname, param); } static void logLightModelfv (GLenum pname, const GLfloat *params) { fprintf (logFp, "glLightModelfv (0x%x, %p)\n", pname, params); (*nativeRenderTable->LightModelfv) (pname, params); } static void logLightModeli (GLenum pname, GLint param) { fprintf (logFp, "glLightModeli (0x%x, %d)\n", pname, param); (*nativeRenderTable->LightModeli) (pname, param); } static void logLightModeliv (GLenum pname, const GLint *params) { fprintf (logFp, "glLightModeliv (0x%x, %p)\n", pname, params); (*nativeRenderTable->LightModeliv) (pname, params); } static void logLightf (GLenum light, GLenum pname, GLfloat param) { fprintf (logFp, "glLightf (0x%x, 0x%x, %f)\n", light, pname, param); (*nativeRenderTable->Lightf) (light, pname, param); } static void logLightfv (GLenum light, GLenum pname, const GLfloat *params) { fprintf (logFp, "glLightfv (0x%x, 0x%x, %p)\n", light, pname, params); (*nativeRenderTable->Lightfv) (light, pname, params); } static void logLighti (GLenum light, GLenum pname, GLint param) { fprintf (logFp, "glLighti (0x%x, 0x%x, %d)\n", light, pname, param); (*nativeRenderTable->Lighti) (light, pname, param); } static void logLightiv (GLenum light, GLenum pname, const GLint *params) { fprintf (logFp, "glLightiv (0x%x, 0x%x, %p)\n", light, pname, params); (*nativeRenderTable->Lightiv) (light, pname, params); } static void logLineStipple (GLint factor, GLushort pattern) { fprintf (logFp, "glLineStipple (%d, %d)\n", factor, pattern); (*nativeRenderTable->LineStipple) (factor, pattern); } static void logLineWidth (GLfloat width) { fprintf (logFp, "glLineWidth (%f)\n", width); (*nativeRenderTable->LineWidth) (width); } static void logListBase (GLuint base) { fprintf (logFp, "glListBase (%d)\n", base); (*nativeRenderTable->ListBase) (base); } static void logLoadIdentity (void) { fprintf (logFp, "glLoadIdentity ()\n"); (*nativeRenderTable->LoadIdentity) (); } static void logLoadMatrixd (const GLdouble *m) { fprintf (logFp, "glLoadMatrixd (%p)\n", m); (*nativeRenderTable->LoadMatrixd) (m); } static void logLoadMatrixf (const GLfloat *m) { fprintf (logFp, "glLoadMatrixf (%p)\n", m); (*nativeRenderTable->LoadMatrixf) (m); } static void logLoadName (GLuint name) { fprintf (logFp, "glLoadName (%d)\n", name); (*nativeRenderTable->LoadName) (name); } static void logLogicOp (GLenum opcode) { fprintf (logFp, "glLogicOp(0x%x)\n", opcode); (*nativeRenderTable->LogicOp) (opcode); } static void logMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) { fprintf (logFp, "glMap1d (0x%x, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points); (*nativeRenderTable->Map1d) (target, u1, u2, stride, order, points); } static void logMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) { fprintf (logFp, "glMap1f (0x%x, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points); (*nativeRenderTable->Map1f) (target, u1, u2, stride, order, points); } static void logMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) { fprintf (logFp, "glMap2d (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); (*nativeRenderTable->Map2d) (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); } static void logMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) { fprintf (logFp, "glMap2f (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); (*nativeRenderTable->Map2f) (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); } static void logMapGrid1d (GLint un, GLdouble u1, GLdouble u2) { fprintf (logFp, "glMapGrid1d (%d, %f, %f)\n", un, u1, u2); (*nativeRenderTable->MapGrid1d) (un, u1, u2); } static void logMapGrid1f (GLint un, GLfloat u1, GLfloat u2) { fprintf (logFp, "glMapGrid1f (%d, %f, %f)\n", un, u1, u2); (*nativeRenderTable->MapGrid1f) (un, u1, u2); } static void logMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) { fprintf (logFp, "glMapGrid2d (%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2); (*nativeRenderTable->MapGrid2d) (un, u1, u2, vn, v1, v2); } static void logMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { fprintf (logFp, "glMapGrid2f (%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2); (*nativeRenderTable->MapGrid2f) (un, u1, u2, vn, v1, v2); } static void logMaterialf (GLenum face, GLenum pname, GLfloat param) { vCnt[materialfIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMaterialf (0x%x, 0x%x, %f)\n", face, pname, param); (*nativeRenderTable->Materialf) (face, pname, param); } static void logMaterialfv (GLenum face, GLenum pname, const GLfloat *params) { vCnt[materialfvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMaterialfv (0x%x, 0x%x, %p)\n", face, pname, params); (*nativeRenderTable->Materialfv) (face, pname, params); } static void logMateriali (GLenum face, GLenum pname, GLint param) { vCnt[materialiIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMateriali (0x%x, 0x%x, %d)\n", face, pname, param); (*nativeRenderTable->Materiali) (face, pname, param); } static void logMaterialiv (GLenum face, GLenum pname, const GLint *params) { vCnt[materialivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMaterialiv (0x%x, 0x%x, %p)\n", face, pname, params); (*nativeRenderTable->Materialiv) (face, pname, params); } static void logMatrixMode (GLenum mode) { fprintf (logFp, "glMatrixMode (0x%x)\n", mode); (*nativeRenderTable->MatrixMode) (mode); } static void logMultMatrixd (const GLdouble *m) { fprintf (logFp, "glMultMatrixd (%p)\n", m); (*nativeRenderTable->MultMatrixd) (m); } static void logMultMatrixf (const GLfloat *m) { fprintf (logFp, "glMultMatrixf (%p)\n", m); (*nativeRenderTable->MultMatrixf) (m); } static void logNewList (GLuint list, GLenum mode) { fprintf (logFp, "glNewList (%d, 0x%x)\n", list, mode); (*nativeRenderTable->NewList) (list, mode); } static void logNormal3bv (const GLbyte *v) { vCnt[normal3bvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glNormal3bv (%p)\n", v); (*nativeRenderTable->Normal3bv) (v); } static void logNormal3dv (const GLdouble *v) { vCnt[normal3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glNormal3dv (%p)\n", v); (*nativeRenderTable->Normal3dv) (v); } static void logNormal3fv (const GLfloat *v) { vCnt[normal3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glNormal3fv (%p)\n", v); (*nativeRenderTable->Normal3fv) (v); } static void logNormal3iv (const GLint *v) { vCnt[normal3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glNormal3iv (%p)\n", v); (*nativeRenderTable->Normal3iv) (v); } static void logNormal3sv (const GLshort *v) { vCnt[normal3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glNormal3sv (%p)\n", v); (*nativeRenderTable->Normal3sv) (v); } static void logNormalPointer (GLenum type, GLsizei stride, const void *pointer) { fprintf (logFp, "glNormalPointer (0x%x, %d, %p)\n", type, stride, pointer); (*nativeRenderTable->NormalPointer) (type, stride, pointer); } static void logOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { fprintf (logFp, "glOrtho (%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar); (*nativeRenderTable->Ortho) (left, right, bottom, top, zNear, zFar); } static void logPassThrough (GLfloat token) { fprintf (logFp, "glPassThrough (%f)\n", token); (*nativeRenderTable->PassThrough) (token); } static void logPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values) { fprintf (logFp, "glPixelMapfv (0x%x, %d, %p)\n", map, mapsize, values); (*nativeRenderTable->PixelMapfv) (map, mapsize, values); } static void logPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values) { fprintf (logFp, "glPixelMapuiv (0x%x, %d, %p)\n", map, mapsize, values); (*nativeRenderTable->PixelMapuiv) (map, mapsize, values); } static void logPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values) { fprintf (logFp, "glPixelMapusv (0x%x, %d, %p)\n", map, mapsize, values); (*nativeRenderTable->PixelMapusv) (map, mapsize, values); } static void logPixelStoref (GLenum pname, GLfloat param) { fprintf (logFp, "glPixelStoref (0x%x, %f)\n", pname, param); (*nativeRenderTable->PixelStoref) (pname, param); } static void logPixelStorei (GLenum pname, GLint param) { fprintf (logFp, "glPixelStorei (0x%x, %d)\n", pname, param); (*nativeRenderTable->PixelStorei) (pname, param); } static void logPixelTransferf (GLenum pname, GLfloat param) { fprintf (logFp, "glPixelTransferf (0x%x, %f)\n", pname, param); (*nativeRenderTable->PixelTransferf) (pname, param); } static void logPixelTransferi (GLenum pname, GLint param) { fprintf (logFp, "glPixelTransferi (0x%x, %d)\n", pname, param); (*nativeRenderTable->PixelTransferi) (pname, param); } static void logPixelZoom (GLfloat xfactor, GLfloat yfactor) { fprintf (logFp, "glPixelZoom (%f, %f)\n", xfactor, yfactor); (*nativeRenderTable->PixelZoom) (xfactor, yfactor); } static void logPointSize (GLfloat size) { fprintf (logFp, "glPointSize" ); (*nativeRenderTable->PointSize) (size); } static void logPolygonMode (GLenum face, GLenum mode) { fprintf (logFp, "glPolygonMode (0x%x, 0x%x)\n", face, mode ); (*nativeRenderTable->PolygonMode) (face, mode); } static void logPolygonOffset (GLfloat factor, GLfloat units) { fprintf (logFp, "glPolygonOffset (%f, %f)\n", factor, units); (*nativeRenderTable->PolygonOffset) (factor, units); } static void logPolygonStipple (const GLubyte *mask) { fprintf (logFp, "glPolygonStipple (%p)\n", mask); (*nativeRenderTable->PolygonStipple) (mask); } static void logPopAttrib (void) { fprintf (logFp, "glPopAttrib ()\n"); (*nativeRenderTable->PopAttrib) (); } static void logPopClientAttrib (void) { fprintf (logFp, "glPopClientAttrib ()\n" ); (*nativeRenderTable->PopClientAttrib) (); } static void logPopMatrix (void) { fprintf (logFp, "glPopMatrix ()\n" ); (*nativeRenderTable->PopMatrix) (); } static void logPopName (void) { fprintf (logFp, "glPopName ()\n"); (*nativeRenderTable->PopName) (); } static void logPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities) { fprintf (logFp, "glPrioritizeTextures (%d, %p, %p)\n", n, textures, priorities); (*nativeRenderTable->PrioritizeTextures) (n, textures, priorities); } static void logPushAttrib (GLbitfield mask) { fprintf (logFp, "glPushAttrib (0x%x)\n", mask); (*nativeRenderTable->PushAttrib) (mask); } static void logPushClientAttrib (GLbitfield mask) { fprintf (logFp, "glPushClientAttrib (0x%x)\n", mask); (*nativeRenderTable->PushClientAttrib) (mask); } static void logPushMatrix (void) { fprintf (logFp, "glPushMatrix ()\n" ); (*nativeRenderTable->PushMatrix) (); } static void logPushName (GLuint name) { fprintf (logFp, "glPushName (%d)\n", name); (*nativeRenderTable->PushName) (name); } static void logRasterPos2dv (const GLdouble *v) { fprintf (logFp, "glRasterPos2dv (%p)\n", v); (*nativeRenderTable->RasterPos2dv) (v); } static void logRasterPos2fv (const GLfloat *v) { fprintf (logFp, "glRasterPos2dv (%p)\n", v); (*nativeRenderTable->RasterPos2fv) (v); } static void logRasterPos2iv (const GLint *v) { fprintf (logFp, "glRasterPos2iv (%p)\n", v); (*nativeRenderTable->RasterPos2iv) (v); } static void logRasterPos2sv (const GLshort *v) { fprintf (logFp, "glRasterPos2sv (%p)\n", v); (*nativeRenderTable->RasterPos2sv) (v); } static void logRasterPos3dv (const GLdouble *v) { fprintf (logFp, "glRasterPos3dv (%p)\n", v); (*nativeRenderTable->RasterPos3dv) (v); } static void logRasterPos3fv (const GLfloat *v) { fprintf (logFp, "glRasterPos3fv (%p)\n", v); (*nativeRenderTable->RasterPos3fv) (v); } static void logRasterPos3iv (const GLint *v) { fprintf (logFp, "glRasterPos3iv (%p)\n", v); (*nativeRenderTable->RasterPos3iv) (v); } static void logRasterPos3sv (const GLshort *v) { fprintf (logFp, "glRasterPos3sv (%p)\n", v); (*nativeRenderTable->RasterPos3sv) (v); } static void logRasterPos4dv (const GLdouble *v) { fprintf (logFp, "glRasterPos4dv (%p)\n", v); (*nativeRenderTable->RasterPos4dv) (v); } static void logRasterPos4fv (const GLfloat *v) { fprintf (logFp, "glRasterPos4fv (%p)\n", v); (*nativeRenderTable->RasterPos4fv) (v); } static void logRasterPos4iv (const GLint *v) { fprintf (logFp, "glRasterPos4iv (%p)\n", v); (*nativeRenderTable->RasterPos4iv) (v); } static void logRasterPos4sv (const GLshort *v) { fprintf (logFp, "glRasterPos4sv (%p)\n", v); (*nativeRenderTable->RasterPos4sv) (v); } static void logReadBuffer (GLenum mode) { fprintf (logFp, "glReadBuffer (0x%x)\n", mode); (*nativeRenderTable->ReadBuffer) (mode); } static void logReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) { fprintf (logFp, "glReadPixels (%d, %d, %d, %d, 0x%x, 0x%x, %p)\n", x, y, width, height, format, type, pixels); (*nativeRenderTable->ReadPixels) (x, y, width, height, format, type, pixels); } static void logRectdv (const GLdouble *v1, const GLdouble *v2) { fprintf (logFp, "glRectdv (%p, %p)\n", v1, v2); (*nativeRenderTable->Rectdv) (v1, v2); } static void logRectfv (const GLfloat *v1, const GLfloat *v2) { fprintf (logFp, "glRectfv (%p, %p)\n", v1, v2); (*nativeRenderTable->Rectfv) (v1, v2); } static void logRectiv (const GLint *v1, const GLint *v2) { fprintf (logFp, "glRectiv (%p, %p)\n", v1, v2); (*nativeRenderTable->Rectiv) (v1, v2); } static void logRectsv (const GLshort *v1, const GLshort *v2) { fprintf (logFp, "glRectsv (%p, %p)\n", v1, v2); (*nativeRenderTable->Rectsv) (v1, v2); } static GLint logRenderMode (GLenum mode) { fprintf (logFp, "glRenderMode (0x%x)\n", mode); return (*nativeRenderTable->RenderMode) (mode); } static void logRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { fprintf (logFp, "glRotated (%f, %f, %f, %f)\n", angle, x, y, z); (*nativeRenderTable->Rotated) (angle, x, y, z); } static void logRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { fprintf (logFp, "glRotatef (%f, %f, %f, %f)\n", angle, x, y, z); (*nativeRenderTable->Rotatef) (angle, x, y, z); } static void logScaled (GLdouble x, GLdouble y, GLdouble z) { fprintf (logFp, "glScaled (%f, %f, %f)\n", x, y, z); (*nativeRenderTable->Scaled) (x, y, z); } static void logScalef (GLfloat x, GLfloat y, GLfloat z) { fprintf (logFp, "glScalef (%f, %f, %f)\n", x, y, z); (*nativeRenderTable->Scalef) (x, y, z); } static void logScissor (GLint x, GLint y, GLsizei width, GLsizei height) { fprintf (logFp, "glScissor (%d, %d, %d, %d)\n", x, y, width, height); (*nativeRenderTable->Scissor) (x, y, width, height); } static void logSelectBuffer (GLsizei size, GLuint *buffer) { fprintf (logFp, "glSelectBuffer (%d, %p)\n", size, buffer); (*nativeRenderTable->SelectBuffer) (size, buffer); } static void logShadeModel (GLenum mode) { fprintf (logFp, "glShadeModel (0x%x)\n", mode); (*nativeRenderTable->ShadeModel) (mode); } static void logStencilFunc (GLenum func, GLint ref, GLuint mask) { fprintf (logFp, "glStencilFunc (0x%x, %d, %d)\n", func, ref, mask); (*nativeRenderTable->StencilFunc) (func, ref, mask); } static void logStencilMask (GLuint mask) { fprintf (logFp, "glStencilMask (0x%x)\n", mask); (*nativeRenderTable->StencilMask) (mask); } static void logStencilOp (GLenum fail, GLenum zfail, GLenum zpass) { fprintf (logFp, "glStencilOp (0x%x, 0x%x, 0x%x)\n", fail, zfail, zpass); (*nativeRenderTable->StencilOp) (fail, zfail, zpass); } static void logTexCoord1dv (const GLdouble *v) { vCnt[texCoord1dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord1dv (%p)\n", v); (*nativeRenderTable->TexCoord1dv) (v); } static void logTexCoord1fv (const GLfloat *v) { vCnt[texCoord1fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord1fv (%p)\n", v); (*nativeRenderTable->TexCoord1fv) (v); } static void logTexCoord1iv (const GLint *v) { vCnt[texCoord1ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord1iv (%p)\n", v); (*nativeRenderTable->TexCoord1iv) (v); } static void logTexCoord1sv (const GLshort *v) { vCnt[texCoord1svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord1sv (%p)\n", v); (*nativeRenderTable->TexCoord1sv) (v); } static void logTexCoord2dv (const GLdouble *v) { vCnt[texCoord2dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord2dv (%p)\n", v); (*nativeRenderTable->TexCoord2dv) (v); } static void logTexCoord2fv (const GLfloat *v) { vCnt[texCoord2fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord2fv (%p)\n", v); (*nativeRenderTable->TexCoord2fv) (v); } static void logTexCoord2iv (const GLint *v) { vCnt[texCoord2ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord2iv (%p)\n", v); (*nativeRenderTable->TexCoord2iv) (v); } static void logTexCoord2sv (const GLshort *v) { vCnt[texCoord2svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord2sv (%p)\n", v); (*nativeRenderTable->TexCoord2sv) (v); } static void logTexCoord3dv (const GLdouble *v) { vCnt[texCoord3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord3dv (%p)\n", v); (*nativeRenderTable->TexCoord3dv) (v); } static void logTexCoord3fv (const GLfloat *v) { vCnt[texCoord3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord3fv (%p)\n", v); (*nativeRenderTable->TexCoord3fv) (v); } static void logTexCoord3iv (const GLint *v) { vCnt[texCoord3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord3iv (%p)\n", v); (*nativeRenderTable->TexCoord3iv) (v); } static void logTexCoord3sv (const GLshort *v) { vCnt[texCoord3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord3sv (%p)\n", v); (*nativeRenderTable->TexCoord3sv) (v); } static void logTexCoord4dv (const GLdouble *v) { vCnt[texCoord4dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord4dv (%p)\n", v); (*nativeRenderTable->TexCoord4dv) (v); } static void logTexCoord4fv (const GLfloat *v) { vCnt[texCoord4fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord4fv (%p)\n", v); (*nativeRenderTable->TexCoord4fv) (v); } static void logTexCoord4iv (const GLint *v) { vCnt[texCoord4ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord4iv (%p)\n", v); (*nativeRenderTable->TexCoord4iv) (v); } static void logTexCoord4sv (const GLshort *v) { vCnt[texCoord4svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glTexCoord4sv (%p)\n", v); (*nativeRenderTable->TexCoord4sv) (v); } static void logTexCoordPointer (GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf (logFp, "glTexCoordPointer (%d, 0x%x, %d, %p)\n", size, type, stride, pointer); (*nativeRenderTable->TexCoordPointer) (size, type, stride, pointer); } static void logTexEnvf (GLenum target, GLenum pname, GLfloat param) { fprintf (logFp, "glTexEnvf (0x%x, 0x%x, %f)\n", target, pname, param); (*nativeRenderTable->TexEnvf) (target, pname, param); } static void logTexEnvfv (GLenum target, GLenum pname, const GLfloat *params) { fprintf (logFp, "glTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->TexEnvfv) (target, pname, params); } static void logTexEnvi (GLenum target, GLenum pname, GLint param) { fprintf (logFp, "glTexEnvi (0x%x, 0x%x, %d)\n", target, pname, param); (*nativeRenderTable->TexEnvi) (target, pname, param); } static void logTexEnviv (GLenum target, GLenum pname, const GLint *params) { fprintf (logFp, "glTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->TexEnviv) (target, pname, params); } static void logTexGend (GLenum coord, GLenum pname, GLdouble param) { fprintf (logFp, "glTexGend (0x%x, 0x%x, %f)\n", coord, pname, param); (*nativeRenderTable->TexGend) (coord, pname, param); } static void logTexGendv (GLenum coord, GLenum pname, const GLdouble *params) { fprintf (logFp, "glTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->TexGendv) (coord, pname, params); } static void logTexGenf (GLenum coord, GLenum pname, GLfloat param) { fprintf (logFp, "glTexGenf (0x%x, 0x%x, %f)\n", coord, pname, param); (*nativeRenderTable->TexGenf) (coord, pname, param); } static void logTexGenfv (GLenum coord, GLenum pname, const GLfloat *params) { fprintf (logFp, "glTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->TexGenfv) (coord, pname, params); } static void logTexGeni (GLenum coord, GLenum pname, GLint param) { fprintf (logFp, "glTexGeni (0x%x, 0x%x, %d)\n", coord, pname, param); (*nativeRenderTable->TexGeni) (coord, pname, param); } static void logTexGeniv (GLenum coord, GLenum pname, const GLint *params) { fprintf (logFp, "glTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params); (*nativeRenderTable->TexGeniv) (coord, pname, params); } static void logTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) { fprintf (logFp, "glTexImage1D (0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)\n", target, level, internalformat, width, border, format, type, pixels); (*nativeRenderTable->TexImage1D) (target, level, internalformat, width, border, format, type, pixels); } static void logTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { fprintf (logFp, "glTexImage2D (0x%x, %d, %d, %d, %d, %d, " "0x%x, 0x%x, %p)\n", target, level, internalformat, width, height, border, format, type, pixels); (*nativeRenderTable->TexImage2D) (target, level, internalformat, width, height, border, format, type, pixels); } static void logTexParameterf (GLenum target, GLenum pname, GLfloat param) { fprintf (logFp, "glTexParameterf (0x%x, 0x%x, %f)\n", target, pname, param); (*nativeRenderTable->TexParameterf) (target, pname, param); } static void logTexParameterfv (GLenum target, GLenum pname, const GLfloat *params) { fprintf (logFp, "glTexParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->TexParameterfv) (target, pname, params); } static void logTexParameteri (GLenum target, GLenum pname, GLint param) { fprintf (logFp, "glTexParameteri (0x%x, 0x%x, 0x%x)\n", target, pname, param); (*nativeRenderTable->TexParameteri) (target, pname, param); } static void logTexParameteriv (GLenum target, GLenum pname, const GLint *params) { fprintf (logFp, "glTexParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->TexParameteriv) (target, pname, params); } static void logTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { fprintf (logFp, "glTexSubImage1D (0x%x, %d, %d, %d, 0x%x, 0x%x, %p)\n", target, level, xoffset, width, format, type, pixels); (*nativeRenderTable->TexSubImage1D) (target, level, xoffset, width, format, type, pixels); } static void logTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { fprintf (logFp, "glTexSubImage2D (0x%x, %d, %d, %d, %d, %d, " "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels); (*nativeRenderTable->TexSubImage2D) (target, level, xoffset, yoffset, width, height, format, type, pixels); } static void logTranslated (GLdouble x, GLdouble y, GLdouble z) { fprintf (logFp, "glTranslated (%f, %f, %f)\n", x, y, z); (*nativeRenderTable->Translated) (x, y, z); } static void logTranslatef (GLfloat x, GLfloat y, GLfloat z) { fprintf (logFp, "glTranslatef (%f, %f, %f)\n", x, y, z); (*nativeRenderTable->Translatef) (x, y, z); } static void logVertex2dv (const GLdouble *v) { vCnt[vertex2dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex2dv (%p)\n", v); (*nativeRenderTable->Vertex2dv) (v); } static void logVertex2fv (const GLfloat *v) { vCnt[vertex2fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex2dv (%p)\n", v); (*nativeRenderTable->Vertex2fv) (v); } static void logVertex2iv (const GLint *v) { vCnt[vertex2ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex2iv (%p)\n", v); (*nativeRenderTable->Vertex2iv) (v); } static void logVertex2sv (const GLshort *v) { vCnt[vertex2svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex2sv (%p)\n", v); (*nativeRenderTable->Vertex2sv) (v); } static void logVertex3dv (const GLdouble *v) { vCnt[vertex3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex3dv (%p)\n", v); (*nativeRenderTable->Vertex3dv) (v); } static void logVertex3fv (const GLfloat *v) { vCnt[vertex3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex3fv (%p)\n", v); (*nativeRenderTable->Vertex3fv) (v); } static void logVertex3iv (const GLint *v) { vCnt[vertex3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex3iv (%p)\n", v); (*nativeRenderTable->Vertex3iv) (v); } static void logVertex3sv (const GLshort *v) { vCnt[vertex3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex3sv (%p)\n", v); (*nativeRenderTable->Vertex3sv) (v); } static void logVertex4dv (const GLdouble *v) { vCnt[vertex4dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex4dv (%p)\n", v); (*nativeRenderTable->Vertex4dv) (v); } static void logVertex4fv (const GLfloat *v) { vCnt[vertex4fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex4fv (%p)\n", v); (*nativeRenderTable->Vertex4fv) (v); } static void logVertex4iv (const GLint *v) { vCnt[vertex4ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex4iv (%p)\n", v); (*nativeRenderTable->Vertex4iv) (v); } static void logVertex4sv (const GLshort *v) { vCnt[vertex4svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glVertex4sv (%p)\n", v); (*nativeRenderTable->Vertex4sv) (v); } static void logVertexPointer (GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf (logFp, "glVertexPointer (%d, 0x%x, %d, %p)\n", size, type, stride, pointer); (*nativeRenderTable->VertexPointer) (size, type, stride, pointer); } static void logViewport (GLint x, GLint y, GLsizei width, GLsizei height) { fprintf (logFp, "glViewport (%d %d %d %d)\n", x, y, width, height); (*nativeRenderTable->Viewport) (x, y, width, height); } static void logBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { fprintf (logFp, "glBlendColor (%f, %f, %f, %f)\n", red, green, blue, alpha); (*nativeRenderTable->BlendColor) (red, green, blue, alpha); } static void logBlendEquation (GLenum mode) { fprintf (logFp, "glBlendEquation (0x%x)\n", mode); (*nativeRenderTable->BlendEquation) (mode); } static void logColorTable (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) { fprintf (logFp, "glColorTable (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n", target, internalformat, width, format, type, table); (*nativeRenderTable->ColorTable) (target, internalformat, width, format, type, table); } static void logColorTableParameterfv (GLenum target, GLenum pname, const GLfloat *params) { fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->ColorTableParameterfv) (target, pname, params); } static void logColorTableParameteriv (GLenum target, GLenum pname, const GLint *params) { fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->ColorTableParameteriv) (target, pname, params); } static void logCopyColorTable (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { fprintf (logFp, "glCopyColorTable (0x%x, 0x%x, %d, %d, %d)\n", target, internalformat, x, y, width); (*nativeRenderTable->CopyColorTable) (target, internalformat, x, y, width); } static void logGetColorTable (GLenum target, GLenum format, GLenum type, GLvoid *table) { fprintf (logFp, "glGetColorTable (0x%x, 0x%x, 0x%x, %p)\n", target, format, type, table); (*nativeRenderTable->GetColorTable) (target, format, type, table); } static void logGetColorTableParameterfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetColorTableParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetColorTableParameterfv) (target, pname, params); } static void logGetColorTableParameteriv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetColorTableParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetColorTableParameteriv) (target, pname, params); } static void logColorSubTable (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) { fprintf (logFp, "glColorSubTable (0x%x, %d, %d, 0x%x, 0x%x, %p)\n", target, start, count, format, type, data); (*nativeRenderTable->ColorSubTable) (target, start, count, format, type, data); } static void logCopyColorSubTable (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) { fprintf (logFp, "glCopyColorSubTable (0x%x, %d, %d, %d, %d)\n", target, start, x, y, width); (*nativeRenderTable->CopyColorSubTable) (target, start, x, y, width); } static void logConvolutionFilter1D (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) { fprintf (logFp, "glConvolutionFilter1D (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n", target, internalformat, width, format, type, image); (*nativeRenderTable->ConvolutionFilter1D) (target, internalformat, width, format, type, image); } static void logConvolutionFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) { fprintf (logFp, "glConvolutionFilter2D (0x%x, 0x%x, %d, %d, " "0x%x, 0x%x, %p)\n", target, internalformat, width, height, format, type, image); (*nativeRenderTable->ConvolutionFilter2D) (target, internalformat, width, height, format, type, image); } static void logConvolutionParameterf (GLenum target, GLenum pname, GLfloat param) { fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %f)\n", target, pname, param); (*nativeRenderTable->ConvolutionParameterf) (target, pname, param); } static void logConvolutionParameterfv (GLenum target, GLenum pname, const GLfloat *params) { fprintf (logFp, "glConvolutionParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->ConvolutionParameterfv) (target, pname, params); } static void logConvolutionParameteri (GLenum target, GLenum pname, GLint param) { fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %d)\n", target, pname, param); (*nativeRenderTable->ConvolutionParameteri) (target, pname, param); } static void logConvolutionParameteriv (GLenum target, GLenum pname, const GLint *params) { fprintf (logFp, "glConvolutionParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->ConvolutionParameteriv) (target, pname, params); } static void logCopyConvolutionFilter1D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) { fprintf (logFp, "glCopyConvolutionFilter1D (0x%x, 0x%x, %d, %d, %d)\n", target, internalformat, x, y, width); (*nativeRenderTable->CopyConvolutionFilter1D) (target, internalformat, x, y, width); } static void logCopyConvolutionFilter2D (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) { fprintf (logFp, "glCopyConvolutionFilter2D (0x%x, 0x%x, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height); (*nativeRenderTable->CopyConvolutionFilter2D) (target, internalformat, x, y, width, height); } static void logGetConvolutionFilter (GLenum target, GLenum format, GLenum type, GLvoid *image) { fprintf (logFp, "glGetConvolutionFilter (0x%x, 0x%x, 0x%x, %p)\n", target, format, type, image); (*nativeRenderTable->GetConvolutionFilter) (target, format, type, image); } static void logGetConvolutionParameterfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetConvolutionParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetConvolutionParameterfv) (target, pname, params); } static void logGetConvolutionParameteriv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetConvolutionParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetConvolutionParameteriv) (target, pname, params); } static void logGetSeparableFilter (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) { fprintf (logFp, "glGetSeparableFilter (0x%x, 0x%x, 0x%x, %p, %p, %p)\n", target, format, type, row, column, span); (*nativeRenderTable->GetSeparableFilter) (target, format, type, row, column, span); } static void logSeparableFilter2D (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) { fprintf (logFp, "glSeparableFilter2D (0x%x, 0x%x, %d, %d, " "0x%x, 0x%x, %p, %p)\n", target, internalformat, width, height, format, type, row, column); (*nativeRenderTable->SeparableFilter2D) (target, internalformat, width, height, format, type, row, column); } static void logGetHistogram (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) { fprintf (logFp, "glGetHistogram (0x%x, %d, 0x%x, 0x%x, %p)\n", target, reset, format, type, values); (*nativeRenderTable->GetHistogram) (target, reset, format, type, values); } static void logGetHistogramParameterfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "glGetHistogramParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetHistogramParameterfv) (target, pname, params); } static void logGetHistogramParameteriv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetHistogramParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetHistogramParameteriv) (target, pname, params); } static void logGetMinmax (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) { fprintf (logFp, "glGetMinmax (0x%x, %d, 0x%x, 0x%x, %p)\n", target, reset, format, type, values); (*nativeRenderTable->GetMinmax) (target, reset, format, type, values); } static void logGetMinmaxParameterfv (GLenum target, GLenum pname, GLfloat *params) { fprintf (logFp, "GetMinmaxParameterfv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetMinmaxParameterfv) (target, pname, params); } static void logGetMinmaxParameteriv (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "GetMinmaxParameteriv (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetMinmaxParameteriv) (target, pname, params); } static void logHistogram (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) { fprintf (logFp, "glHistogram (0x%x, %d, 0x%x, %d)\n", target, width, internalformat, sink); (*nativeRenderTable->Histogram) (target, width, internalformat, sink); } static void logMinmax (GLenum target, GLenum internalformat, GLboolean sink) { fprintf (logFp, "glMinmax (0x%x, 0x%x, %d)\n", target, internalformat, sink); (*nativeRenderTable->Minmax) (target, internalformat, sink); } static void logResetHistogram (GLenum target) { fprintf (logFp, "glResetHistogram (0x%x)\n", target); (*nativeRenderTable->ResetHistogram) (target); } static void logResetMinmax (GLenum target) { fprintf (logFp, "glResetMinmax (0x%x)\n", target); (*nativeRenderTable->ResetMinmax) (target); } static void logCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { fprintf (logFp, "glCopyTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, " "%d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height); (*nativeRenderTable->CopyTexSubImage3D) (target, level, xoffset, yoffset, zoffset, x, y, width, height); } static void logTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { fprintf (logFp, "glTexImage3D (0x%x, %d, %d, %d, %d, %d, %d, " "0x%x, 0x%x, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels); (*nativeRenderTable->TexImage3D) (target, level, internalformat, width, height, depth, border, format, type, pixels); } static void logTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) { fprintf (logFp, "glTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, %d, " "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); (*nativeRenderTable->TexSubImage3D) (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); } /* GL_ARB_multitexture */ static void logActiveTextureARB (GLenum texture) { fprintf (logFp, "glActiveTextureARB (0x%x)\n", texture); (*nativeRenderTable->ActiveTextureARB) (texture); } static void logClientActiveTextureARB (GLenum texture) { fprintf (logFp, "glClientActiveTextureARB (0x%x)\n", texture); (*nativeRenderTable->ClientActiveTextureARB) (texture); } static void logMultiTexCoord1dvARB (GLenum target, const GLdouble *v) { vCnt[multiTexCoord1dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord1dvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord1dvARB) (target, v); } static void logMultiTexCoord1fvARB (GLenum target, const GLfloat *v) { vCnt[multiTexCoord1fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord1fvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord1fvARB) (target, v); } static void logMultiTexCoord1ivARB (GLenum target, const GLint *v) { vCnt[multiTexCoord1ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord1ivARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord1ivARB) (target, v); } static void logMultiTexCoord1svARB (GLenum target, const GLshort *v) { vCnt[multiTexCoord1svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord1svARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord1svARB) (target, v); } static void logMultiTexCoord2dvARB (GLenum target, const GLdouble *v) { vCnt[multiTexCoord2dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord2dvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord2dvARB) (target, v); } static void logMultiTexCoord2fvARB (GLenum target, const GLfloat *v) { vCnt[multiTexCoord2fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord2fvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord2fvARB) (target, v); } static void logMultiTexCoord2ivARB (GLenum target, const GLint *v) { vCnt[multiTexCoord2ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord2ivARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord2ivARB) (target, v); } static void logMultiTexCoord2svARB (GLenum target, const GLshort *v) { vCnt[multiTexCoord2svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord2svARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord2svARB) (target, v); } static void logMultiTexCoord3dvARB (GLenum target, const GLdouble *v) { vCnt[multiTexCoord3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord3dvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord3dvARB) (target, v); } static void logMultiTexCoord3fvARB (GLenum target, const GLfloat *v) { vCnt[multiTexCoord3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord3fvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord3fvARB) (target, v); } static void logMultiTexCoord3ivARB (GLenum target, const GLint *v) { vCnt[multiTexCoord3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord3ivARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord3ivARB) (target, v); } static void logMultiTexCoord3svARB (GLenum target, const GLshort *v) { vCnt[multiTexCoord3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord3svARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord3svARB) (target, v); } static void logMultiTexCoord4dvARB (GLenum target, const GLdouble *v) { vCnt[multiTexCoord4dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord4dvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord4dvARB) (target, v); } static void logMultiTexCoord4fvARB (GLenum target, const GLfloat *v) { vCnt[multiTexCoord4fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord4fvARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord4fvARB) (target, v); } static void logMultiTexCoord4ivARB (GLenum target, const GLint *v) { vCnt[multiTexCoord4ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord4ivARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord4ivARB) (target, v); } static void logMultiTexCoord4svARB (GLenum target, const GLshort *v) { vCnt[multiTexCoord4svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glMultiTexCoord4svARB (0x%x, %p)\n", target, v); (*nativeRenderTable->MultiTexCoord4svARB) (target, v); } /* GL_ARB_multisample */ static void logSampleCoverageARB (GLclampf value, GLboolean invert) { fprintf (logFp, "glSampleCoverageARB (%f, %d)\n", value, invert); (*nativeRenderTable->SampleCoverageARB) (value, invert); } /* GL_EXT_texture_object */ static GLboolean logAreTexturesResidentEXT (GLsizei n, const GLuint *textures, GLboolean *residences) { fprintf (logFp, "glAreTexturesResidentEXT (%d, %p, %p)\n", n, textures, residences); return (*nativeRenderTable->AreTexturesResidentEXT) (n, textures, residences); } static void logGenTexturesEXT (GLsizei n, GLuint *textures) { fprintf (logFp, "glGenTexturesEXT (%d, %p)\n", n, textures); (*nativeRenderTable->GenTexturesEXT) (n, textures); } static GLboolean logIsTextureEXT (GLuint texture) { fprintf (logFp, "glIsTextureEXT (%d)\n", texture); return (*nativeRenderTable->IsTextureEXT) (texture); } /* GL_SGIS_multisample */ static void logSampleMaskSGIS (GLclampf value, GLboolean invert) { fprintf (logFp, "glSampleMaskSGIS (%f, %d)\n", value, invert); (*nativeRenderTable->SampleMaskSGIS) (value, invert); } static void logSamplePatternSGIS (GLenum pattern) { fprintf (logFp, "glSamplePatternSGIS (0x%x)\n", pattern); (*nativeRenderTable->SamplePatternSGIS) (pattern); } /* GL_EXT_point_parameters */ static void logPointParameterfEXT (GLenum pname, GLfloat param) { fprintf (logFp, "glPointParameterfEXT (0x%x, %f)\n", pname, param); (*nativeRenderTable->PointParameterfEXT) (pname, param); } static void logPointParameterfvEXT (GLenum pname, const GLfloat *params) { fprintf (logFp, "glPointParameterfvEXT (0x%x, %p)\n", pname, params); (*nativeRenderTable->PointParameterfvEXT) (pname, params); } /* GL_MESA_window_pos */ static void logWindowPos3fMESA (GLfloat x, GLfloat y, GLfloat z) { fprintf (logFp, "glWindowPos3fMESA (%f, %f, %f)\n", x, y, z); (*nativeRenderTable->WindowPos3fMESA) (x, y, z); } /* GL_EXT_blend_func_separate */ static void logBlendFuncSeparateEXT (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { fprintf (logFp, "glBlendFuncSeparateEXT (0x%x, 0x%x, 0x%x, 0x%x)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); (*nativeRenderTable->BlendFuncSeparateEXT) (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } /* GL_EXT_fog_coord */ static void logFogCoordfvEXT (const GLfloat *coord) { vCnt[fogCoordfvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glFogCoordfvEXT (%p)\n", coord); (*nativeRenderTable->FogCoordfvEXT) (coord); } static void logFogCoorddvEXT (const GLdouble *coord) { vCnt[fogCoorddvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glFogCoorddvEXT (%p)\n", coord); (*nativeRenderTable->FogCoorddvEXT) (coord); } static void logFogCoordPointerEXT (GLenum type, GLsizei stride, const GLvoid *pointer) { fprintf (logFp, "glFogCoordPointerEXT (0x%x, %d, %p)\n", type, stride, pointer); (*nativeRenderTable->FogCoordPointerEXT) (type, stride, pointer); } /* GL_EXT_secondary_color */ static void logSecondaryColor3bvEXT (const GLbyte *v) { vCnt[secondaryColor3bvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3bvEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3bvEXT) (v); } static void logSecondaryColor3dvEXT (const GLdouble *v) { vCnt[secondaryColor3dvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3dvEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3dvEXT) (v); } static void logSecondaryColor3fvEXT (const GLfloat *v) { vCnt[secondaryColor3fvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3fvEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3fvEXT) (v); } static void logSecondaryColor3ivEXT (const GLint *v) { vCnt[secondaryColor3ivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3ivEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3ivEXT) (v); } static void logSecondaryColor3svEXT (const GLshort *v) { vCnt[secondaryColor3svIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3svEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3svEXT) (v); } static void logSecondaryColor3ubvEXT (const GLubyte *v) { vCnt[secondaryColor3ubvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3ubvEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3ubvEXT) (v); } static void logSecondaryColor3uivEXT (const GLuint *v) { vCnt[secondaryColor3uivIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3uivEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3uivEXT) (v); } static void logSecondaryColor3usvEXT (const GLushort *v) { vCnt[secondaryColor3usvIndex].n++; if (logVertexAttribs) fprintf (logFp, "glSecondaryColor3usvEXT (%p)\n", v); (*nativeRenderTable->SecondaryColor3usvEXT) (v); } static void logSecondaryColorPointerEXT (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { fprintf (logFp, "glSecondaryColorPointerEXT (%d, 0x%x, %d, %p)\n", size, type, stride, pointer); (*nativeRenderTable->SecondaryColorPointerEXT) (size, type, stride, pointer); } /* GL_NV_point_sprite */ static void logPointParameteriNV (GLenum pname, GLint param) { fprintf (logFp, "glPointParameteriNV (0x%x, %d)\n", pname, param); (*nativeRenderTable->PointParameteriNV) (pname, param); } static void logPointParameterivNV (GLenum pname, const GLint *params) { fprintf (logFp, "glPointParameterivNV (0x%x, %p)\n", pname, params); (*nativeRenderTable->PointParameterivNV) (pname, params); } /* GL_EXT_stencil_two_side */ static void logActiveStencilFaceEXT (GLenum face) { fprintf (logFp, "glActiveStencilFaceEXT (0x%x)\n", face); (*nativeRenderTable->ActiveStencilFaceEXT) (face); } /* GL_EXT_framebuffer_object */ static GLboolean logIsRenderbufferEXT (GLuint renderbuffer) { fprintf (logFp, "glIsRenderbufferEXT (%d)\n", renderbuffer); return (*nativeRenderTable->IsRenderbufferEXT) (renderbuffer); } static void logBindRenderbufferEXT (GLenum target, GLuint renderbuffer) { fprintf (logFp, "glBindRenderbufferEXT (0x%x, %d)\n", target, renderbuffer); (*nativeRenderTable->BindRenderbufferEXT) (target, renderbuffer); } static void logDeleteRenderbuffersEXT (GLsizei n, const GLuint *renderbuffers) { fprintf (logFp, "glDeleteRenderbuffersEXT (%d, %p)\n", n, renderbuffers); (*nativeRenderTable->DeleteRenderbuffersEXT) (n, renderbuffers); } static void logGenRenderbuffersEXT (GLsizei n, GLuint *renderbuffers) { fprintf (logFp, "glGenRenderbuffersEXT (%d, %p)\n", n, renderbuffers); (*nativeRenderTable->GenRenderbuffersEXT) (n, renderbuffers); } static void logRenderbufferStorageEXT (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { fprintf (logFp, "glRenderbufferStorageEXT (0x%x, 0x%x, %d, %d)\n", target, internalformat, width, height); (*nativeRenderTable->RenderbufferStorageEXT) (target, internalformat, width, height); } static void logGetRenderbufferParameterivEXT (GLenum target, GLenum pname, GLint *params) { fprintf (logFp, "glGetRenderbufferParameterivEXT (0x%x, 0x%x, %p)\n", target, pname, params); (*nativeRenderTable->GetRenderbufferParameterivEXT) (target, pname, params); } static GLboolean logIsFramebufferEXT (GLuint framebuffer) { fprintf (logFp, "glIsFramebufferEXT (%d)\n", framebuffer); return (*nativeRenderTable->IsFramebufferEXT) (framebuffer); } static void logBindFramebufferEXT (GLenum target, GLuint framebuffer) { fprintf (logFp, "glBindFramebufferEXT (0x%x, %d)\n", target, framebuffer); (*nativeRenderTable->BindFramebufferEXT) (target, framebuffer); } static void logDeleteFramebuffersEXT (GLsizei n, const GLuint *framebuffers) { fprintf (logFp, "glDeleteFramebuffersEXT (%d, %p)\n", n, framebuffers); (*nativeRenderTable->DeleteFramebuffersEXT) (n, framebuffers); } static void logGenFramebuffersEXT (GLsizei n, GLuint *framebuffers) { fprintf (logFp, "glGenFramebuffersEXT (%d, %p)\n", n, framebuffers); (*nativeRenderTable->GenFramebuffersEXT) (n, framebuffers); } static GLenum logCheckFramebufferStatusEXT (GLenum target) { fprintf (logFp, "glCheckFramebufferStatusEXT (0x%x)\n", target); return (*nativeRenderTable->CheckFramebufferStatusEXT) (target); } static void logFramebufferTexture1DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { fprintf (logFp, "glFramebufferTexture1DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n", target, attachment, textarget, texture, level); (*nativeRenderTable->FramebufferTexture1DEXT) (target, attachment, textarget, texture, level); } static void logFramebufferTexture2DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { fprintf (logFp, "glFramebufferTexture2DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n", target, attachment, textarget, texture, level); (*nativeRenderTable->FramebufferTexture2DEXT) (target, attachment, textarget, texture, level); } static void logFramebufferTexture3DEXT (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { fprintf (logFp, "glFramebufferTexture3DEXT (0x%x, 0x%x, 0x%x, " "%d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset); (*nativeRenderTable->FramebufferTexture3DEXT) (target, attachment, textarget, texture, level, zoffset); } static void logFramebufferRenderbufferEXT (GLenum target, GLenum attachment, GLenum buffertarget, GLuint renderbuffer) { fprintf (logFp, "glFramebufferRenderbufferEXT (0x%x, 0x%x, 0x%x, %d)\n", target, attachment, buffertarget, renderbuffer); (*nativeRenderTable->FramebufferRenderbufferEXT) (target, attachment, buffertarget, renderbuffer); } static void logGetFramebufferAttachmentParameterivEXT (GLenum target, GLenum attach, GLenum pname, GLint *params) { fprintf (logFp, "glGetFramebufferAttachmentParameterivEXT (0x%x, " "0x%x, 0x%x, %p)\n", target, attach, pname, params); (*nativeRenderTable->GetFramebufferAttachmentParameterivEXT) (target, attach, pname, params); } static void logGenerateMipmapEXT (GLenum target) { fprintf (logFp, "glGenerateMipmapEXT (0x%x)\n", target); (*nativeRenderTable->GenerateMipmapEXT) (target); } static struct _glapi_table __logRenderTable = { logNewList, logEndList, logCallList, logCallLists, logDeleteLists, logGenLists, logListBase, logBegin, logBitmap, 0, /* glColor3b */ logColor3bv, 0, /* glColor3d */ logColor3dv, 0, /* glColor3f */ logColor3fv, 0, /* glColor3i */ logColor3iv, 0, /* glColor3s */ logColor3sv, 0, /* glColor3ub */ logColor3ubv, 0, /* glColor3ui */ logColor3uiv, 0, /* glColor3us */ logColor3usv, 0, /* glColor4b */ logColor4bv, 0, /* glColor4d */ logColor4dv, 0, /* glColor4f */ logColor4fv, 0, /* glColor4i */ logColor4iv, 0, /* glColor4s */ logColor4sv, 0, /* glColor4ub */ logColor4ubv, 0, /* glColor4ui */ logColor4uiv, 0, /* glColor4us */ logColor4usv, 0, /* glEdgeFlag */ logEdgeFlagv, logEnd, 0, /* glIndexd */ logIndexdv, 0, /* glIndexf */ logIndexfv, 0, /* glIndexi */ logIndexiv, 0, /* glIndexs */ logIndexsv, 0, /* glNormal3b */ logNormal3bv, 0, /* glNormal3d */ logNormal3dv, 0, /* glNormal3f */ logNormal3fv, 0, /* glNormal3i */ logNormal3iv, 0, /* glNormal3s */ logNormal3sv, 0, /* glRasterPos2d */ logRasterPos2dv, 0, /* glRasterPos2f */ logRasterPos2fv, 0, /* glRasterPos2i */ logRasterPos2iv, 0, /* glRasterPos2s */ logRasterPos2sv, 0, /* glRasterPos3d */ logRasterPos3dv, 0, /* glRasterPos3f */ logRasterPos3fv, 0, /* glRasterPos3i */ logRasterPos3iv, 0, /* glRasterPos3s */ logRasterPos3sv, 0, /* glRasterPos4d */ logRasterPos4dv, 0, /* glRasterPos4f */ logRasterPos4fv, 0, /* glRasterPos4i */ logRasterPos4iv, 0, /* glRasterPos4s */ logRasterPos4sv, 0, /* glRectd */ logRectdv, 0, /* glRectf */ logRectfv, 0, /* glRecti */ logRectiv, 0, /* glRects */ logRectsv, 0, /* glTexCoord1d */ logTexCoord1dv, 0, /* glTexCoord1f */ logTexCoord1fv, 0, /* glTexCoord1i */ logTexCoord1iv, 0, /* glTexCoord1s */ logTexCoord1sv, 0, /* glTexCoord2d */ logTexCoord2dv, 0, /* glTexCoord2f */ logTexCoord2fv, 0, /* glTexCoord2i */ logTexCoord2iv, 0, /* glTexCoord2s */ logTexCoord2sv, 0, /* glTexCoord3d */ logTexCoord3dv, 0, /* glTexCoord3f */ logTexCoord3fv, 0, /* glTexCoord3i */ logTexCoord3iv, 0, /* glTexCoord3s */ logTexCoord3sv, 0, /* glTexCoord4d */ logTexCoord4dv, 0, /* glTexCoord4f */ logTexCoord4fv, 0, /* glTexCoord4i */ logTexCoord4iv, 0, /* glTexCoord4s */ logTexCoord4sv, 0, /* glVertex2d */ logVertex2dv, 0, /* glVertex2f */ logVertex2fv, 0, /* glVertex2i */ logVertex2iv, 0, /* glVertex2s */ logVertex2sv, 0, /* glVertex3d */ logVertex3dv, 0, /* glVertex3f */ logVertex3fv, 0, /* glVertex3i */ logVertex3iv, 0, /* glVertex3s */ logVertex3sv, 0, /* glVertex4d */ logVertex4dv, 0, /* glVertex4f */ logVertex4fv, 0, /* glVertex4i */ logVertex4iv, 0, /* glVertex4s */ logVertex4sv, logClipPlane, logColorMaterial, logCullFace, logFogf, logFogfv, logFogi, logFogiv, logFrontFace, logHint, logLightf, logLightfv, logLighti, logLightiv, logLightModelf, logLightModelfv, logLightModeli, logLightModeliv, logLineStipple, logLineWidth, logMaterialf, logMaterialfv, logMateriali, logMaterialiv, logPointSize, logPolygonMode, logPolygonStipple, logScissor, logShadeModel, logTexParameterf, logTexParameterfv, logTexParameteri, logTexParameteriv, logTexImage1D, logTexImage2D, logTexEnvf, logTexEnvfv, logTexEnvi, logTexEnviv, logTexGend, logTexGendv, logTexGenf, logTexGenfv, logTexGeni, logTexGeniv, logFeedbackBuffer, logSelectBuffer, logRenderMode, logInitNames, logLoadName, logPassThrough, logPopName, logPushName, logDrawBuffer, logClear, logClearAccum, logClearIndex, logClearColor, logClearStencil, logClearDepth, logStencilMask, logColorMask, logDepthMask, logIndexMask, logAccum, logDisable, logEnable, logFinish, logFlush, logPopAttrib, logPushAttrib, logMap1d, logMap1f, logMap2d, logMap2f, logMapGrid1d, logMapGrid1f, logMapGrid2d, logMapGrid2f, 0, /* glEvalCoord1d */ logEvalCoord1dv, 0, /* glEvalCoord1f */ logEvalCoord1fv, 0, /* glEvalCoord2d */ logEvalCoord2dv, 0, /* glEvalCoord2f */ logEvalCoord2fv, logEvalMesh1, logEvalPoint1, logEvalMesh2, logEvalPoint2, logAlphaFunc, logBlendFunc, logLogicOp, logStencilFunc, logStencilOp, logDepthFunc, logPixelZoom, logPixelTransferf, logPixelTransferi, logPixelStoref, logPixelStorei, logPixelMapfv, logPixelMapuiv, logPixelMapusv, logReadBuffer, logCopyPixels, logReadPixels, logDrawPixels, logGetBooleanv, logGetClipPlane, logGetDoublev, logGetError, logGetFloatv, logGetIntegerv, logGetLightfv, logGetLightiv, logGetMapdv, logGetMapfv, logGetMapiv, logGetMaterialfv, logGetMaterialiv, logGetPixelMapfv, logGetPixelMapuiv, logGetPixelMapusv, logGetPolygonStipple, logGetString, logGetTexEnvfv, logGetTexEnviv, logGetTexGendv, logGetTexGenfv, logGetTexGeniv, logGetTexImage, logGetTexParameterfv, logGetTexParameteriv, logGetTexLevelParameterfv, logGetTexLevelParameteriv, logIsEnabled, logIsList, logDepthRange, logFrustum, logLoadIdentity, logLoadMatrixf, logLoadMatrixd, logMatrixMode, logMultMatrixf, logMultMatrixd, logOrtho, logPopMatrix, logPushMatrix, logRotated, logRotatef, logScaled, logScalef, logTranslated, logTranslatef, logViewport, logArrayElement, logBindTexture, logColorPointer, logDisableClientState, logDrawArrays, logDrawElements, logEdgeFlagPointer, logEnableClientState, logIndexPointer, 0, /* glIndexub */ logIndexubv, logInterleavedArrays, logNormalPointer, logPolygonOffset, logTexCoordPointer, logVertexPointer, logAreTexturesResident, logCopyTexImage1D, logCopyTexImage2D, logCopyTexSubImage1D, logCopyTexSubImage2D, logDeleteTextures, logGenTextures, logGetPointerv, logIsTexture, logPrioritizeTextures, logTexSubImage1D, logTexSubImage2D, logPopClientAttrib, logPushClientAttrib, logBlendColor, logBlendEquation, 0, /* glDrawRangeElements */ logColorTable, logColorTableParameterfv, logColorTableParameteriv, logCopyColorTable, logGetColorTable, logGetColorTableParameterfv, logGetColorTableParameteriv, logColorSubTable, logCopyColorSubTable, logConvolutionFilter1D, logConvolutionFilter2D, logConvolutionParameterf, logConvolutionParameterfv, logConvolutionParameteri, logConvolutionParameteriv, logCopyConvolutionFilter1D, logCopyConvolutionFilter2D, logGetConvolutionFilter, logGetConvolutionParameterfv, logGetConvolutionParameteriv, logGetSeparableFilter, logSeparableFilter2D, logGetHistogram, logGetHistogramParameterfv, logGetHistogramParameteriv, logGetMinmax, logGetMinmaxParameterfv, logGetMinmaxParameteriv, logHistogram, logMinmax, logResetHistogram, logResetMinmax, logTexImage3D, logTexSubImage3D, logCopyTexSubImage3D, logActiveTextureARB, logClientActiveTextureARB, 0, /* glMultiTexCoord1dARB */ logMultiTexCoord1dvARB, 0, /* glMultiTexCoord1fARB */ logMultiTexCoord1fvARB, 0, /* glMultiTexCoord1iARB */ logMultiTexCoord1ivARB, 0, /* glMultiTexCoord1sARB */ logMultiTexCoord1svARB, 0, /* glMultiTexCoord2dARB */ logMultiTexCoord2dvARB, 0, /* glMultiTexCoord2fARB */ logMultiTexCoord2fvARB, 0, /* glMultiTexCoord2iARB */ logMultiTexCoord2ivARB, 0, /* glMultiTexCoord2sARB */ logMultiTexCoord2svARB, 0, /* glMultiTexCoord3dARB */ logMultiTexCoord3dvARB, 0, /* glMultiTexCoord3fARB */ logMultiTexCoord3fvARB, 0, /* glMultiTexCoord3iARB */ logMultiTexCoord3ivARB, 0, /* glMultiTexCoord3sARB */ logMultiTexCoord3svARB, 0, /* glMultiTexCoord4dARB */ logMultiTexCoord4dvARB, 0, /* glMultiTexCoord4fARB */ logMultiTexCoord4fvARB, 0, /* glMultiTexCoord4iARB */ logMultiTexCoord4ivARB, 0, /* glMultiTexCoord4sARB */ logMultiTexCoord4svARB, 0, /* glLoadTransposeMatrixfARB */ 0, /* glLoadTransposeMatrixdARB */ 0, /* glMultTransposeMatrixfARB */ 0, /* glMultTransposeMatrixdARB */ logSampleCoverageARB, 0, /* glDrawBuffersARB */ 0, /* glPolygonOffsetEXT */ 0, /* glGetTexFilterFuncSGIS */ 0, /* glTexFilterFuncSGIS */ 0, /* glGetHistogramEXT */ 0, /* glGetHistogramParameterfvEXT */ 0, /* glGetHistogramParameterivEXT */ 0, /* glGetMinmaxEXT */ 0, /* glGetMinmaxParameterfvEXT */ 0, /* glGetMinmaxParameterivEXT */ 0, /* glGetConvolutionFilterEXT */ 0, /* glGetConvolutionParameterfvEXT */ 0, /* glGetConvolutionParameterivEXT */ 0, /* glGetSeparableFilterEXT */ 0, /* glGetColorTableSGI */ 0, /* glGetColorTableParameterfvSGI */ 0, /* glGetColorTableParameterivSGI */ 0, /* glPixelTexGenSGIX */ 0, /* glPixelTexGenParameteriSGIS */ 0, /* glPixelTexGenParameterivSGIS */ 0, /* glPixelTexGenParameterfSGIS */ 0, /* glPixelTexGenParameterfvSGIS */ 0, /* glGetPixelTexGenParameterivSGIS */ 0, /* glGetPixelTexGenParameterfvSGIS */ 0, /* glTexImage4DSGIS */ 0, /* glTexSubImage4DSGIS */ logAreTexturesResidentEXT, logGenTexturesEXT, logIsTextureEXT, 0, /* glDetailTexFuncSGIS */ 0, /* glGetDetailTexFuncSGIS */ 0, /* glSharpenTexFuncSGIS */ 0, /* glGetSharpenTexFuncSGIS */ logSampleMaskSGIS, logSamplePatternSGIS, 0, /* glColorPointerEXT */ 0, /* glEdgeFlagPointerEXT */ 0, /* glIndexPointerEXT */ 0, /* glNormalPointerEXT */ 0, /* glTexCoordPointerEXT */ 0, /* glVertexPointerEXT */ 0, /* glSpriteParameterfSGIX */ 0, /* glSpriteParameterfvSGIX */ 0, /* glSpriteParameteriSGIX */ 0, /* glSpriteParameterivSGIX */ logPointParameterfEXT, logPointParameterfvEXT, 0, /* glGetInstrumentsSGIX */ 0, /* glInstrumentsBufferSGIX */ 0, /* glPollInstrumentsSGIX */ 0, /* glReadInstrumentsSGIX */ 0, /* glStartInstrumentsSGIX */ 0, /* glStopInstrumentsSGIX */ 0, /* glFrameZoomSGIX */ 0, /* glTagSampleBufferSGIX */ 0, /* glReferencePlaneSGIX */ 0, /* glFlushRasterSGIX */ 0, /* glGetListParameterfvSGIX */ 0, /* glGetListParameterivSGIX */ 0, /* glListParameterfSGIX */ 0, /* glListParameterfvSGIX */ 0, /* glListParameteriSGIX */ 0, /* glListParameterivSGIX */ 0, /* glFragmentColorMaterialSGIX */ 0, /* glFragmentLightfSGIX */ 0, /* glFragmentLightfvSGIX */ 0, /* glFragmentLightiSGIX */ 0, /* glFragmentLightivSGIX */ 0, /* glFragmentLightModelfSGIX */ 0, /* glFragmentLightModelfvSGIX */ 0, /* glFragmentLightModeliSGIX */ 0, /* glFragmentLightModelivSGIX */ 0, /* glFragmentMaterialfSGIX */ 0, /* glFragmentMaterialfvSGIX */ 0, /* glFragmentMaterialiSGIX */ 0, /* glFragmentMaterialivSGIX */ 0, /* glGetFragmentLightfvSGIX */ 0, /* glGetFragmentLightivSGIX */ 0, /* glGetFragmentMaterialfvSGIX */ 0, /* glGetFragmentMaterialivSGIX */ 0, /* glLightEnviSGIX */ 0, /* glVertexWeightfEXT */ 0, /* glVertexWeightfvEXT */ 0, /* glVertexWeightPointerEXT */ 0, /* glFlushVertexArrayRangeNV */ 0, /* glVertexArrayRangeNV */ 0, /* glCombinerParameterfvNV */ 0, /* glCombinerParameterfNV */ 0, /* glCombinerParameterivNV */ 0, /* glCombinerParameteriNV */ 0, /* glCombinerInputNV */ 0, /* glCombinerOutputNV */ 0, /* glFinalCombinerInputNV */ 0, /* glGetCombinerInputParameterfvNV */ 0, /* glGetCombinerInputParameterivNV */ 0, /* glGetCombinerOutputParameterfvNV */ 0, /* glGetCombinerOutputParameterivNV */ 0, /* glGetFinalCombinerInputParameterfvNV */ 0, /* glGetFinalCombinerInputParameterivNV */ 0, /* glResizeBuffersMESA */ 0, /* glWindowPos2dMESA */ 0, /* glWindowPos2dvMESA */ 0, /* glWindowPos2fMESA */ 0, /* glWindowPos2fvMESA */ 0, /* glWindowPos2iMESA */ 0, /* glWindowPos2ivMESA */ 0, /* glWindowPos2sMESA */ 0, /* glWindowPos2svMESA */ 0, /* glWindowPos3dMESA */ 0, /* glWindowPos3dvMESA */ logWindowPos3fMESA, 0, /* glWindowPos3fvMESA */ 0, /* glWindowPos3iMESA */ 0, /* glWindowPos3ivMESA */ 0, /* glWindowPos3sMESA */ 0, /* glWindowPos3svMESA */ 0, /* glWindowPos4dMESA */ 0, /* glWindowPos4dvMESA */ 0, /* glWindowPos4fMESA */ 0, /* glWindowPos4fvMESA */ 0, /* glWindowPos4iMESA */ 0, /* glWindowPos4ivMESA */ 0, /* glWindowPos4sMESA */ 0, /* glWindowPos4svMESA */ logBlendFuncSeparateEXT, 0, /* glIndexMaterialEXT */ 0, /* glIndexFuncEXT */ 0, /* glLockArraysEXT */ 0, /* glUnlockArraysEXT */ 0, /* glCullParameterdvEXT */ 0, /* glCullParameterfvEXT */ 0, /* glHintPGI */ 0, /* glFogCoordfEXT */ logFogCoordfvEXT, 0, /* glFogCoorddEXT */ logFogCoorddvEXT, logFogCoordPointerEXT, 0, /* glGetColorTableEXT */ 0, /* glGetColorTableParameterivEXT */ 0, /* glGetColorTableParameterfvEXT */ 0, /* glTbufferMask3DFX */ 0, /* glCompressedTexImage3DARB */ 0, /* glCompressedTexImage2DARB */ 0, /* glCompressedTexImage1DARB */ 0, /* glCompressedTexSubImage3DARB */ 0, /* glCompressedTexSubImage2DARB */ 0, /* glCompressedTexSubImage1DARB */ 0, /* glGetCompressedTexImageARB */ 0, /* glSecondaryColor3bEXT */ logSecondaryColor3bvEXT, 0, /* glSecondaryColor3dEXT */ logSecondaryColor3dvEXT, 0, /* glSecondaryColor3fEXT */ logSecondaryColor3fvEXT, 0, /* glSecondaryColor3iEXT */ logSecondaryColor3ivEXT, 0, /* glSecondaryColor3sEXT */ logSecondaryColor3svEXT, 0, /* glSecondaryColor3ubEXT */ logSecondaryColor3ubvEXT, 0, /* glSecondaryColor3uiEXT */ logSecondaryColor3uivEXT, 0, /* glSecondaryColor3usEXT */ logSecondaryColor3usvEXT, logSecondaryColorPointerEXT, 0, /* glAreProgramsResidentNV */ 0, /* glBindProgramNV */ 0, /* glDeleteProgramsNV */ 0, /* glExecuteProgramNV */ 0, /* glGenProgramsNV */ 0, /* glGetProgramParameterdvNV */ 0, /* glGetProgramParameterfvNV */ 0, /* glGetProgramivNV */ 0, /* glGetProgramStringNV */ 0, /* glGetTrackMatrixivNV */ 0, /* glGetVertexAttribdvARB */ 0, /* glGetVertexAttribfvARB */ 0, /* glGetVertexAttribivARB */ 0, /* glGetVertexAttribPointervNV */ 0, /* glIsProgramNV */ 0, /* glLoadProgramNV */ 0, /* glProgramParameter4dNV */ 0, /* glProgramParameter4dvNV */ 0, /* glProgramParameter4fNV */ 0, /* glProgramParameter4fvNV */ 0, /* glProgramParameters4dvNV */ 0, /* glProgramParameters4fvNV */ 0, /* glRequestResidentProgramsNV */ 0, /* glTrackMatrixNV */ 0, /* glVertexAttribPointerNV */ 0, /* glVertexAttrib1dARB */ 0, /* glVertexAttrib1dvARB */ 0, /* glVertexAttrib1fARB */ 0, /* glVertexAttrib1fvARB */ 0, /* glVertexAttrib1sARB */ 0, /* glVertexAttrib1svARB */ 0, /* glVertexAttrib2dARB */ 0, /* glVertexAttrib2dvARB */ 0, /* glVertexAttrib2fARB */ 0, /* glVertexAttrib2fvARB */ 0, /* glVertexAttrib2sARB */ 0, /* glVertexAttrib2svARB */ 0, /* glVertexAttrib3dARB */ 0, /* glVertexAttrib3dvARB */ 0, /* glVertexAttrib3fARB */ 0, /* glVertexAttrib3fvARB */ 0, /* glVertexAttrib3sARB */ 0, /* glVertexAttrib3svARB */ 0, /* glVertexAttrib4dARB */ 0, /* glVertexAttrib4dvARB */ 0, /* glVertexAttrib4fARB */ 0, /* glVertexAttrib4fvARB */ 0, /* glVertexAttrib4sARB */ 0, /* glVertexAttrib4svARB */ 0, /* glVertexAttrib4NubARB */ 0, /* glVertexAttrib4NubvARB */ 0, /* glVertexAttribs1dvNV */ 0, /* glVertexAttribs1fvNV */ 0, /* glVertexAttribs1svNV */ 0, /* glVertexAttribs2dvNV */ 0, /* glVertexAttribs2fvNV */ 0, /* glVertexAttribs2svNV */ 0, /* glVertexAttribs3dvNV */ 0, /* glVertexAttribs3fvNV */ 0, /* glVertexAttribs3svNV */ 0, /* glVertexAttribs4dvNV */ 0, /* glVertexAttribs4fvNV */ 0, /* glVertexAttribs4svNV */ 0, /* glVertexAttribs4ubvNV */ logPointParameteriNV, logPointParameterivNV, 0, /* glMultiDrawArraysEXT */ 0, /* glMultiDrawElementsEXT */ logActiveStencilFaceEXT, 0, /* glDeleteFencesNV */ 0, /* glGenFencesNV */ 0, /* glIsFenceNV */ 0, /* glTestFenceNV */ 0, /* glGetFenceivNV */ 0, /* glFinishFenceNV */ 0, /* glSetFenceNV */ 0, /* glVertexAttrib4bvARB */ 0, /* glVertexAttrib4ivARB */ 0, /* glVertexAttrib4ubvARB */ 0, /* glVertexAttrib4usvARB */ 0, /* glVertexAttrib4uivARB */ 0, /* glVertexAttrib4NbvARB */ 0, /* glVertexAttrib4NsvARB */ 0, /* glVertexAttrib4NivARB */ 0, /* glVertexAttrib4NusvARB */ 0, /* glVertexAttrib4NuivARB */ 0, /* glVertexAttribPointerARB */ 0, /* glEnableVertexAttribArrayARB */ 0, /* glDisableVertexAttribArrayARB */ 0, /* glProgramStringARB */ 0, /* glProgramEnvParameter4dARB */ 0, /* glProgramEnvParameter4dvARB */ 0, /* glProgramEnvParameter4fARB */ 0, /* glProgramEnvParameter4fvARB */ 0, /* glProgramLocalParameter4dARB */ 0, /* glProgramLocalParameter4dvARB */ 0, /* glProgramLocalParameter4fARB */ 0, /* glProgramLocalParameter4fvARB */ 0, /* glGetProgramEnvParameterdvARB */ 0, /* glGetProgramEnvParameterfvARB */ 0, /* glGetProgramLocalParameterdvARB */ 0, /* glGetProgramLocalParameterfvARB */ 0, /* glGetProgramivARB */ 0, /* glGetProgramStringARB */ 0, /* glProgramNamedParameter4fNV */ 0, /* glProgramNamedParameter4dNV */ 0, /* glProgramNamedParameter4fvNV */ 0, /* glProgramNamedParameter4dvNV */ 0, /* glGetProgramNamedParameterfvNV */ 0, /* glGetProgramNamedParameterdvNV */ 0, /* glBindBufferARB */ 0, /* glBufferDataARB */ 0, /* glBufferSubDataARB */ 0, /* glDeleteBuffersARB */ 0, /* glGenBuffersARB */ 0, /* glGetBufferParameterivARB */ 0, /* glGetBufferPointervARB */ 0, /* glGetBufferSubDataARB */ 0, /* glIsBufferARB */ 0, /* glMapBufferARB */ 0, /* glUnmapBufferARB */ 0, /* glDepthBoundsEXT */ 0, /* glGenQueriesARB */ 0, /* glDeleteQueriesARB */ 0, /* glIsQueryARB */ 0, /* glBeginQueryARB */ 0, /* glEndQueryARB */ 0, /* glGetQueryivARB */ 0, /* glGetQueryObjectivARB */ 0, /* glGetQueryObjectuivARB */ 0, /* glMultiModeDrawArraysIBM */ 0, /* glMultiModeDrawElementsIBM */ 0, /* glBlendEquationSeparateEXT */ 0, /* glDeleteObjectARB */ 0, /* glGetHandleARB */ 0, /* glDetachObjectARB */ 0, /* glCreateShaderObjectARB */ 0, /* glShaderSourceARB */ 0, /* glCompileShaderARB */ 0, /* glCreateProgramObjectARB */ 0, /* glAttachObjectARB */ 0, /* glLinkProgramARB */ 0, /* glUseProgramObjectARB */ 0, /* glValidateProgramARB */ 0, /* glUniform1fARB */ 0, /* glUniform2fARB */ 0, /* glUniform3fARB */ 0, /* glUniform4fARB */ 0, /* glUniform1iARB */ 0, /* glUniform2iARB */ 0, /* glUniform3iARB */ 0, /* glUniform4iARB */ 0, /* glUniform1fvARB */ 0, /* glUniform2fvARB */ 0, /* glUniform3fvARB */ 0, /* glUniform4fvARB */ 0, /* glUniform1ivARB */ 0, /* glUniform2ivARB */ 0, /* glUniform3ivARB */ 0, /* glUniform4ivARB */ 0, /* glUniformMatrix2fvARB */ 0, /* glUniformMatrix3fvARB */ 0, /* glUniformMatrix4fvARB */ 0, /* glGetObjectParameterfvARB */ 0, /* glGetObjectParameterivARB */ 0, /* glGetInfoLogARB */ 0, /* glGetAttachedObjectsARB */ 0, /* glGetUniformLocationARB */ 0, /* glGetActiveUniformARB */ 0, /* glGetUniformfvARB */ 0, /* glGetUniformivARB */ 0, /* glGetShaderSourceARB */ 0, /* glBindAttribLocationARB */ 0, /* glGetActiveAttribARB */ 0, /* glGetAttribLocationARB */ 0, /* glGetVertexAttribdvNV */ 0, /* glGetVertexAttribfvNV */ 0, /* glGetVertexAttribivNV */ 0, /* glVertexAttrib1dNV */ 0, /* glVertexAttrib1dvNV */ 0, /* glVertexAttrib1fNV */ 0, /* glVertexAttrib1fvNV */ 0, /* glVertexAttrib1sNV */ 0, /* glVertexAttrib1svNV */ 0, /* glVertexAttrib2dNV */ 0, /* glVertexAttrib2dvNV */ 0, /* glVertexAttrib2fNV */ 0, /* glVertexAttrib2fvNV */ 0, /* glVertexAttrib2sNV */ 0, /* glVertexAttrib2svNV */ 0, /* glVertexAttrib3dNV */ 0, /* glVertexAttrib3dvNV */ 0, /* glVertexAttrib3fNV */ 0, /* glVertexAttrib3fvNV */ 0, /* glVertexAttrib3sNV */ 0, /* glVertexAttrib3svNV */ 0, /* glVertexAttrib4dNV */ 0, /* glVertexAttrib4dvNV */ 0, /* glVertexAttrib4fNV */ 0, /* glVertexAttrib4fvNV */ 0, /* glVertexAttrib4sNV */ 0, /* glVertexAttrib4svNV */ 0, /* glVertexAttrib4ubNV */ 0, /* glVertexAttrib4ubvNV */ 0, /* glGenFragmentShadersATI */ 0, /* glBindFragmentShaderATI */ 0, /* glDeleteFragmentShaderATI */ 0, /* glBeginFragmentShaderATI */ 0, /* glEndFragmentShaderATI */ 0, /* glPassTexCoordATI */ 0, /* glSampleMapATI */ 0, /* glColorFragmentOp1ATI */ 0, /* glColorFragmentOp2ATI */ 0, /* glColorFragmentOp3ATI */ 0, /* glAlphaFragmentOp1ATI */ 0, /* glAlphaFragmentOp2ATI */ 0, /* glAlphaFragmentOp3ATI */ 0, /* glSetFragmentShaderConstantATI */ logIsRenderbufferEXT, logBindRenderbufferEXT, logDeleteRenderbuffersEXT, logGenRenderbuffersEXT, logRenderbufferStorageEXT, logGetRenderbufferParameterivEXT, logIsFramebufferEXT, logBindFramebufferEXT, logDeleteFramebuffersEXT, logGenFramebuffersEXT, logCheckFramebufferStatusEXT, logFramebufferTexture1DEXT, logFramebufferTexture2DEXT, logFramebufferTexture3DEXT, logFramebufferRenderbufferEXT, logGetFramebufferAttachmentParameterivEXT, logGenerateMipmapEXT, 0, /* glStencilFuncSeparate */ 0, /* glStencilOpSeparate */ 0, /* glStencilMaskSeparate */ 0, /* glGetQueryObjecti64vEXT */ 0 /* glGetQueryObjectui64vEXT */ }; static Bool isCurrent = FALSE; static void (*flushContextCache) (void); static void (*setRenderTables) (struct _glapi_table *table); static void GlxLogFlushContextCache (void) { if (isCurrent) { fprintf (logFp, "LOSE CURRENT\n"); isCurrent = FALSE; } (*flushContextCache) (); } static void GlxLogSetRenderTables (struct _glapi_table *table) { nativeRenderTable = table; if (table) { fprintf (logFp, "FORCE CURRENT\n"); isCurrent = TRUE; (*setRenderTables) (&__logRenderTable); } else { (*setRenderTables) (0); } } void xglInitGlxLog (void) { if (logFp) return; if (__xglGLXLogFp) { logFp = __xglGLXLogFp; flushContextCache = __xglGLXFunc.flushContextCache; setRenderTables = __xglGLXFunc.setRenderTables; __xglGLXFunc.flushContextCache = GlxLogFlushContextCache; __xglGLXFunc.setRenderTables = GlxLogSetRenderTables; } } #endif