qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
b14d6de7aa
xenocara/xserver/hw/xgl/glxext/xglglxlog.c

4520 lines
110 KiB
C
Raw Normal View History

Importing xserver from X.Org 7.2RC2
2006-11-26 11:13:41 -07:00
/*
* 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
Reference in New Issue Copy Permalink