aboutsummaryrefslogtreecommitdiff
path: root/xorg-server/hw/xgl/glxext/xglglxlog.c
diff options
context:
space:
mode:
Diffstat (limited to 'xorg-server/hw/xgl/glxext/xglglxlog.c')
-rw-r--r--xorg-server/hw/xgl/glxext/xglglxlog.c4519
1 files changed, 0 insertions, 4519 deletions
diff --git a/xorg-server/hw/xgl/glxext/xglglxlog.c b/xorg-server/hw/xgl/glxext/xglglxlog.c
deleted file mode 100644
index 0f194c9ed..000000000
--- a/xorg-server/hw/xgl/glxext/xglglxlog.c
+++ /dev/null
@@ -1,4519 +0,0 @@
-/*
- * 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