diff options
Diffstat (limited to 'xorg-server/hw/xgl/glxext/xglglxlog.c')
| -rw-r--r-- | xorg-server/hw/xgl/glxext/xglglxlog.c | 4519 |
1 files changed, 4519 insertions, 0 deletions
diff --git a/xorg-server/hw/xgl/glxext/xglglxlog.c b/xorg-server/hw/xgl/glxext/xglglxlog.c new file mode 100644 index 000000000..0f194c9ed --- /dev/null +++ b/xorg-server/hw/xgl/glxext/xglglxlog.c @@ -0,0 +1,4519 @@ +/* + * 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 <davidr@novell.com> + */ + +#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 |