xorg-server-1.4/hw/xgl/glxext/xglglxlog.c

   1 /*
   2  * Copyright © 2005 Novell, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software
   5  * and its documentation for any purpose is hereby granted without
   6  * fee, provided that the above copyright notice appear in all copies
   7  * and that both that copyright notice and this permission notice
   8  * appear in supporting documentation, and that the name of
   9  * Novell, Inc. not be used in advertising or publicity pertaining to
  10  * distribution of the software without specific, written prior permission.
  11  * Novell, Inc. makes no representations about the suitability of this
  12  * software for any purpose. It is provided "as is" without express or
  13  * implied warranty.
  14  *
  15  * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  17  * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  19  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  20  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  21  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Author: David Reveman <davidr@novell.com>
  24  */
  25
  26 #include "xglglx.h"
  27 #include "xglglxext.h"
  28 #include "glapitable.h"
  29
  30 #ifndef NGLXEXTLOG
  31
  32 static struct _glapi_table *nativeRenderTable = 0;
  33
  34 static FILE *logFp = 0;
  35
  36 static Bool logVertexAttribs = FALSE;
  37
  38 static struct VertexAttribCount {
  39     int  n;
  40     char *name;
  41 } vCnt[] = {
  42     { 0, "glArrayElement"       },
  43     { 0, "glCallList"           },
  44     { 0, "glCallLists"          },
  45     { 0, "glColor3bv"           },
  46     { 0, "glColor3dv"           },
  47     { 0, "glColor3fv"           },
  48     { 0, "glColor3iv"           },
  49     { 0, "glColor3sv"           },
  50     { 0, "glColor3ubv"          },
  51     { 0, "glColor3uiv"          },
  52     { 0, "glColor3usv"          },
  53     { 0, "glColor4bv"           },
  54     { 0, "glColor4dv"           },
  55     { 0, "glColor4fv"           },
  56     { 0, "glColor4iv"           },
  57     { 0, "glColor4sv"           },
  58     { 0, "glColor4ubv"          },
  59     { 0, "glColor4uiv"          },
  60     { 0, "glColor4usv"          },
  61     { 0, "glEdgeFlagv"          },
  62     { 0, "glEvalCoord1dv"       },
  63     { 0, "glEvalCoord1fv"       },
  64     { 0, "glEvalCoord2dv"       },
  65     { 0, "glEvalCoord2fv"       },
  66     { 0, "glEvalPoint1"         },
  67     { 0, "glEvalPoint2"         },
  68     { 0, "glIndexdv"            },
  69     { 0, "glIndexfv"            },
  70     { 0, "glIndexiv"            },
  71     { 0, "glIndexsv"            },
  72     { 0, "glIndexubv"           },
  73     { 0, "glMaterialf"          },
  74     { 0, "glMaterialfv"         },
  75     { 0, "glMateriali"          },
  76     { 0, "glMaterialiv"         },
  77     { 0, "glNormal3bv"          },
  78     { 0, "glNormal3dv"          },
  79     { 0, "glNormal3fv"          },
  80     { 0, "glNormal3iv"          },
  81     { 0, "glNormal3sv"          },
  82     { 0, "glTexCoord1dv"        },
  83     { 0, "glTexCoord1fv"        },
  84     { 0, "glTexCoord1iv"        },
  85     { 0, "glTexCoord1sv"        },
  86     { 0, "glTexCoord2dv"        },
  87     { 0, "glTexCoord2fv"        },
  88     { 0, "glTexCoord2iv"        },
  89     { 0, "glTexCoord2sv"        },
  90     { 0, "glTexCoord3dv"        },
  91     { 0, "glTexCoord3fv"        },
  92     { 0, "glTexCoord3iv"        },
  93     { 0, "glTexCoord3sv"        },
  94     { 0, "glTexCoord4dv"        },
  95     { 0, "glTexCoord4fv"        },
  96     { 0, "glTexCoord4iv"        },
  97     { 0, "glTexCoord4sv"        },
  98     { 0, "glVertex2dv"          },
  99     { 0, "glVertex2fv"          },
 100     { 0, "glVertex2iv"          },
 101     { 0, "glVertex2sv"          },
 102     { 0, "glVertex3dv"          },
 103     { 0, "glVertex3fv"          },
 104     { 0, "glVertex3iv"          },
 105     { 0, "glVertex3sv"          },
 106     { 0, "glVertex4dv"          },
 107     { 0, "glVertex4fv"          },
 108     { 0, "glVertex4iv"          },
 109     { 0, "glVertex4sv"          },
 110     { 0, "glMultiTexCoord1dv"   },
 111     { 0, "glMultiTexCoord1fv"   },
 112     { 0, "glMultiTexCoord1iv"   },
 113     { 0, "glMultiTexCoord1sv"   },
 114     { 0, "glMultiTexCoord2dv"   },
 115     { 0, "glMultiTexCoord2fv"   },
 116     { 0, "glMultiTexCoord2iv"   },
 117     { 0, "glMultiTexCoord2sv"   },
 118     { 0, "glMultiTexCoord3dv"   },
 119     { 0, "glMultiTexCoord3fv"   },
 120     { 0, "glMultiTexCoord3iv"   },
 121     { 0, "glMultiTexCoord3sv"   },
 122     { 0, "glMultiTexCoord4dv"   },
 123     { 0, "glMultiTexCoord4fv"   },
 124     { 0, "glMultiTexCoord4iv"   },
 125     { 0, "glMultiTexCoord4sv"   },
 126     { 0, "glFogCoordfv"         },
 127     { 0, "glFogCoorddv"         },
 128     { 0, "glSecondaryColor3bv"  },
 129     { 0, "glSecondaryColor3dv"  },
 130     { 0, "glSecondaryColor3fv"  },
 131     { 0, "glSecondaryColor3iv"  },
 132     { 0, "glSecondaryColor3sv"  },
 133     { 0, "glSecondaryColor3ubv" },
 134     { 0, "glSecondaryColor3uiv" },
 135     { 0, "glSecondaryColor3usv" }
 136 };
 137
 138 #define arrayElementIndex       0
 139 #define callListIndex           1
 140 #define callListsIndex          2
 141 #define color3bvIndex           3
 142 #define color3dvIndex           4
 143 #define color3fvIndex           5
 144 #define color3ivIndex           6
 145 #define color3svIndex           7
 146 #define color3ubvIndex          8
 147 #define color3uivIndex          9
 148 #define color3usvIndex          10
 149 #define color4bvIndex           11
 150 #define color4dvIndex           12
 151 #define color4fvIndex           13
 152 #define color4ivIndex           14
 153 #define color4svIndex           15
 154 #define color4ubvIndex          16
 155 #define color4uivIndex          17
 156 #define color4usvIndex          18
 157 #define edgeFlagvIndex          19
 158 #define evalCoord1dvIndex       20
 159 #define evalCoord1fvIndex       21
 160 #define evalCoord2dvIndex       22
 161 #define evalCoord2fvIndex       23
 162 #define evalPoint1Index         24
 163 #define evalPoint2Index         25
 164 #define indexdvIndex            26
 165 #define indexfvIndex            27
 166 #define indexivIndex            28
 167 #define indexsvIndex            29
 168 #define indexubvIndex           30
 169 #define materialfIndex          31
 170 #define materialfvIndex         32
 171 #define materialiIndex          33
 172 #define materialivIndex         34
 173 #define normal3bvIndex          35
 174 #define normal3dvIndex          36
 175 #define normal3fvIndex          37
 176 #define normal3ivIndex          38
 177 #define normal3svIndex          39
 178 #define texCoord1dvIndex        40
 179 #define texCoord1fvIndex        41
 180 #define texCoord1ivIndex        42
 181 #define texCoord1svIndex        43
 182 #define texCoord2dvIndex        44
 183 #define texCoord2fvIndex        45
 184 #define texCoord2ivIndex        46
 185 #define texCoord2svIndex        47
 186 #define texCoord3dvIndex        48
 187 #define texCoord3fvIndex        49
 188 #define texCoord3ivIndex        50
 189 #define texCoord3svIndex        51
 190 #define texCoord4dvIndex        52
 191 #define texCoord4fvIndex        53
 192 #define texCoord4ivIndex        54
 193 #define texCoord4svIndex        55
 194 #define vertex2dvIndex          56
 195 #define vertex2fvIndex          57
 196 #define vertex2ivIndex          58
 197 #define vertex2svIndex          59
 198 #define vertex3dvIndex          60
 199 #define vertex3fvIndex          61
 200 #define vertex3ivIndex          62
 201 #define vertex3svIndex          63
 202 #define vertex4dvIndex          64
 203 #define vertex4fvIndex          65
 204 #define vertex4ivIndex          66
 205 #define vertex4svIndex          67
 206 #define multiTexCoord1dvIndex   68
 207 #define multiTexCoord1fvIndex   69
 208 #define multiTexCoord1ivIndex   70
 209 #define multiTexCoord1svIndex   71
 210 #define multiTexCoord2dvIndex   72
 211 #define multiTexCoord2fvIndex   73
 212 #define multiTexCoord2ivIndex   74
 213 #define multiTexCoord2svIndex   75
 214 #define multiTexCoord3dvIndex   76
 215 #define multiTexCoord3fvIndex   77
 216 #define multiTexCoord3ivIndex   78
 217 #define multiTexCoord3svIndex   79
 218 #define multiTexCoord4dvIndex   80
 219 #define multiTexCoord4fvIndex   81
 220 #define multiTexCoord4ivIndex   82
 221 #define multiTexCoord4svIndex   83
 222 #define fogCoordfvIndex         84
 223 #define fogCoorddvIndex         85
 224 #define secondaryColor3bvIndex  86
 225 #define secondaryColor3dvIndex  87
 226 #define secondaryColor3fvIndex  88
 227 #define secondaryColor3ivIndex  89
 228 #define secondaryColor3svIndex  90
 229 #define secondaryColor3ubvIndex 91
 230 #define secondaryColor3uivIndex 92
 231 #define secondaryColor3usvIndex 93
 232
 233 static void
 234 logAccum (GLenum  op,
 235           GLfloat value)
 236 {
 237     fprintf (logFp, "glAccum (0x%x, %f)\n", op, value);
 238     (*nativeRenderTable->Accum) (op, value);
 239 }
 240
 241 static void
 242 logAlphaFunc (GLenum   func,
 243               GLclampf ref)
 244 {
 245     fprintf (logFp, "glAlphaFunc (0x%x, %f)\n", func, ref);
 246     (*nativeRenderTable->AlphaFunc) (func, ref);
 247 }
 248
 249 static GLboolean
 250 logAreTexturesResident (GLsizei      n,
 251                         const GLuint *textures,
 252                         GLboolean    *residences)
 253 {
 254     fprintf (logFp, "glAreTexturesResident (%d, %p, %p)\n", n, textures,
 255              residences);
 256     return (*nativeRenderTable->AreTexturesResident) (n, textures,
 257                                                       residences);
 258 }
 259
 260 static void
 261 logArrayElement (GLint i)
 262 {
 263     vCnt[arrayElementIndex].n++;
 264     if (logVertexAttribs)
 265         fprintf (logFp, "glArrayElement (%d)\n", i);
 266     (*nativeRenderTable->ArrayElement) (i);
 267 }
 268
 269 static void
 270 logBegin (GLenum mode)
 271 {
 272     fprintf (logFp, "glBegin (0x%x)\n", mode);
 273     (*nativeRenderTable->Begin) (mode);
 274 }
 275
 276 static void
 277 logBindTexture (GLenum target,
 278                 GLuint texture)
 279 {
 280     fprintf (logFp, "glBindTexture (0x%x, %u)\n", target, texture);
 281     (*nativeRenderTable->BindTexture) (target, texture);
 282 }
 283
 284 static void
 285 logBitmap (GLsizei       width,
 286            GLsizei       height,
 287            GLfloat       xorig,
 288            GLfloat       yorig,
 289            GLfloat       xmove,
 290            GLfloat       ymove,
 291            const GLubyte *bitmap)
 292 {
 293     fprintf (logFp, "glBitmap (%d, %d, %f, %f, %f, %f, %p)\n",
 294              width, height, xorig, yorig, xmove, ymove, bitmap);
 295     (*nativeRenderTable->Bitmap) (width, height, xorig, yorig,
 296                                   xmove, ymove, bitmap);
 297 }
 298
 299 static void
 300 logBlendFunc (GLenum sfactor,
 301               GLenum dfactor)
 302 {
 303     fprintf (logFp, "glBlendFunc (0x%x, 0x%x)\n", sfactor, dfactor);
 304     (*nativeRenderTable->BlendFunc) (sfactor, dfactor);
 305 }
 306
 307 static void
 308 logCallList (GLuint list)
 309 {
 310     vCnt[callListIndex].n++;
 311     if (logVertexAttribs)
 312         fprintf (logFp, "glCallList (%u)\n", list);
 313     (*nativeRenderTable->CallList) (list);
 314 }
 315
 316 static void
 317 logCallLists (GLsizei    n,
 318               GLenum     type,
 319               const void *lists)
 320 {
 321     vCnt[callListsIndex].n++;
 322     if (logVertexAttribs)
 323         fprintf (logFp, "glCallLists (%d, 0x%x, %p)\n", n, type, lists);
 324     (*nativeRenderTable->CallLists) (n, type, lists);
 325 }
 326
 327 static void
 328 logClear (GLbitfield mask)
 329 {
 330     fprintf (logFp, "glClear (0x%x)\n", mask);
 331     (*nativeRenderTable->Clear) (mask);
 332 }
 333
 334 static void
 335 logClearAccum (GLfloat red,
 336                GLfloat green,
 337                GLfloat blue,
 338                GLfloat alpha)
 339 {
 340     fprintf (logFp, "glClearAccum (%f, %f, %f, %f)\n",
 341              red, green, blue, alpha);
 342     (*nativeRenderTable->ClearAccum) (red, green, blue, alpha);
 343 }
 344
 345 static void
 346 logClearColor (GLclampf red,
 347                GLclampf green,
 348                GLclampf blue,
 349                GLclampf alpha)
 350 {
 351     fprintf (logFp, "glClearColor (%f, %f, %f, %f)\n",
 352              red, green, blue, alpha);
 353     (*nativeRenderTable->ClearColor) (red, green, blue, alpha);
 354 }
 355
 356 static void
 357 logClearDepth (GLclampd depth)
 358 {
 359     fprintf (logFp, "glClearDepth (%f)\n", depth);
 360     (*nativeRenderTable->ClearDepth) (depth);
 361 }
 362
 363 static void
 364 logClearIndex (GLfloat c)
 365 {
 366     fprintf (logFp, "glClearIndex (%f)\n", c);
 367     (*nativeRenderTable->ClearIndex) (c);
 368 }
 369
 370 static void
 371 logClearStencil (GLint s)
 372 {
 373     fprintf (logFp, "glClearStencil (%d)\n", s);
 374     (*nativeRenderTable->ClearStencil) (s);
 375 }
 376
 377 static void
 378 logClipPlane (GLenum         plane,
 379               const GLdouble *equation)
 380 {
 381     fprintf (logFp, "glClipPlane (0x%x, %p)\n", plane, equation);
 382     (*nativeRenderTable->ClipPlane) (plane, equation);
 383 }
 384
 385 static void
 386 logColor3bv (const GLbyte *v)
 387 {
 388     vCnt[color3bvIndex].n++;
 389     if (logVertexAttribs)
 390         fprintf (logFp, "glColor3bv (%p)\n", v);
 391     (*nativeRenderTable->Color3bv) (v);
 392 }
 393
 394 static void
 395 logColor3dv (const GLdouble *v)
 396 {
 397     vCnt[color3dvIndex].n++;
 398     if (logVertexAttribs)
 399         fprintf (logFp, "glColor3dv (%p)\n", v);
 400     (*nativeRenderTable->Color3dv) (v);
 401 }
 402
 403 static void
 404 logColor3fv (const GLfloat *v)
 405 {
 406     vCnt[color3fvIndex].n++;
 407     if (logVertexAttribs)
 408         fprintf (logFp, "glColor3fv (%p)\n", v);
 409     (*nativeRenderTable->Color3fv) (v);
 410 }
 411
 412 static void
 413 logColor3iv (const GLint *v)
 414 {
 415     vCnt[color3ivIndex].n++;
 416     if (logVertexAttribs)
 417         fprintf (logFp, "glColor3iv (%p)\n", v);
 418     (*nativeRenderTable->Color3iv) (v);
 419 }
 420
 421 static void
 422 logColor3sv (const GLshort *v)
 423 {
 424     vCnt[color3svIndex].n++;
 425     if (logVertexAttribs)
 426         fprintf (logFp, "glColor3sv (%p)\n", v);
 427     (*nativeRenderTable->Color3sv) (v);
 428 }
 429
 430 static void
 431 logColor3ubv (const GLubyte *v)
 432 {
 433     vCnt[color3ubvIndex].n++;
 434     if (logVertexAttribs)
 435         fprintf (logFp, "glColor3ubv (%p)\n", v);
 436     (*nativeRenderTable->Color3ubv) (v);
 437 }
 438
 439 static void
 440 logColor3uiv (const GLuint *v)
 441 {
 442     vCnt[color3uivIndex].n++;
 443     if (logVertexAttribs)
 444         fprintf (logFp, "glColor3uiv (%p)\n", v);
 445     (*nativeRenderTable->Color3uiv) (v);
 446 }
 447
 448 static void
 449 logColor3usv (const GLushort *v)
 450 {
 451     vCnt[color3usvIndex].n++;
 452     if (logVertexAttribs)
 453         fprintf (logFp, "glColor3usv (%p)\n", v);
 454     (*nativeRenderTable->Color3usv) (v);
 455 }
 456
 457 static void
 458 logColor4bv (const GLbyte *v)
 459 {
 460     vCnt[color4bvIndex].n++;
 461     if (logVertexAttribs)
 462         fprintf (logFp, "glColor4bv (%p)\n", v);
 463     (*nativeRenderTable->Color4bv) (v);
 464 }
 465
 466 static void
 467 logColor4dv (const GLdouble *v)
 468 {
 469     vCnt[color4dvIndex].n++;
 470     if (logVertexAttribs)
 471         fprintf (logFp, "glColor4dv (%p)\n", v);
 472     (*nativeRenderTable->Color4dv) (v);
 473 }
 474
 475 static void
 476 logColor4fv (const GLfloat *v)
 477 {
 478     vCnt[color4fvIndex].n++;
 479     if (logVertexAttribs)
 480         fprintf (logFp, "glColor4fv (%p)\n", v);
 481     (*nativeRenderTable->Color4fv) (v);
 482 }
 483
 484 static void
 485 logColor4iv (const GLint *v)
 486 {
 487     vCnt[color4ivIndex].n++;
 488     if (logVertexAttribs)
 489         fprintf (logFp, "glColor4iv (%p)\n", v);
 490     (*nativeRenderTable->Color4iv) (v);
 491 }
 492
 493 static void
 494 logColor4sv (const GLshort *v)
 495 {
 496     vCnt[color4svIndex].n++;
 497     if (logVertexAttribs)
 498         fprintf (logFp, "glColor4sv (%p)\n", v);
 499     (*nativeRenderTable->Color4sv) (v);
 500 }
 501
 502 static void
 503 logColor4ubv (const GLubyte *v)
 504 {
 505     vCnt[color4ubvIndex].n++;
 506     if (logVertexAttribs)
 507         fprintf (logFp, "glColor4ubv (%p)\n", v);
 508     (*nativeRenderTable->Color4ubv) (v);
 509 }
 510
 511 static void
 512 logColor4uiv(const GLuint *v)
 513 {
 514     vCnt[color4uivIndex].n++;
 515     if (logVertexAttribs)
 516         fprintf (logFp, "glColor4uiv (%p)\n", v);
 517     (*nativeRenderTable->Color4uiv) (v);
 518 }
 519
 520 static void
 521 logColor4usv (const GLushort *v)
 522 {
 523     vCnt[color4usvIndex].n++;
 524     if (logVertexAttribs)
 525         fprintf (logFp, "glColor4usv (%p)\n", v);
 526     (*nativeRenderTable->Color4usv) (v);
 527 }
 528
 529 static void
 530 logColorMask (GLboolean red,
 531               GLboolean green,
 532               GLboolean blue,
 533               GLboolean alpha)
 534 {
 535     fprintf (logFp, "glColorMask (%d, %d, %d, %d)\n", red, green, blue, alpha);
 536     (*nativeRenderTable->ColorMask) (red, green, blue, alpha);
 537 }
 538
 539 static void
 540 logColorMaterial (GLenum face,
 541                   GLenum mode)
 542 {
 543     fprintf (logFp, "glColorMaterial (0x%x, 0x%x)\n", face, mode);
 544     (*nativeRenderTable->ColorMaterial) (face, mode);
 545 }
 546
 547 static void
 548 logColorPointer (GLint      size,
 549                  GLenum     type,
 550                  GLsizei    stride,
 551                  const void *pointer)
 552 {
 553     fprintf (logFp, "glColorPointer (%d, 0x%x, %d, %p)\n",
 554              size, type, stride, pointer);
 555     (*nativeRenderTable->ColorPointer) (size, type, stride, pointer);
 556 }
 557
 558 static void
 559 logCopyPixels (GLint   x,
 560                GLint   y,
 561                GLsizei width,
 562                GLsizei height,
 563                GLenum  type)
 564 {
 565     fprintf (logFp, "glCopyPixels (%d, %d, %d, %d, 0x%x)\n",
 566              x, y, width, height, type);
 567     (*nativeRenderTable->CopyPixels) (x, y, width, height, type);
 568 }
 569
 570 static void
 571 logCopyTexImage1D (GLenum  target,
 572                    GLint   level,
 573                    GLenum  internalFormat,
 574                    GLint   x,
 575                    GLint   y,
 576                    GLsizei width,
 577                    GLint   border)
 578 {
 579     fprintf (logFp, "glCopyTexImage1D (0x%x, %d, 0x%x, %d, %d, %d, %d)\n",
 580              target, level, internalFormat, x, y, width, border);
 581     (*nativeRenderTable->CopyTexImage1D) (target, level, internalFormat,
 582                                           x, y, width, border);
 583 }
 584
 585 static void
 586 logCopyTexImage2D (GLenum  target,
 587                    GLint   level,
 588                    GLenum  internalFormat,
 589                    GLint   x,
 590                    GLint   y,
 591                    GLsizei width,
 592                    GLsizei height,
 593                    GLint   border)
 594 {
 595     fprintf (logFp, "glCopyTexImage2D (0x%x, %d, 0x%x, %d, %d, %d, %d, %d)\n",
 596              target, level, internalFormat, x, y, width, height, border);
 597     (*nativeRenderTable->CopyTexImage2D) (target, level, internalFormat,
 598                                           x, y, width, height, border);
 599 }
 600
 601 static void
 602 logCopyTexSubImage1D (GLenum  target,
 603                       GLint   level,
 604                       GLint   xoffset,
 605                       GLint   x,
 606                       GLint   y,
 607                       GLsizei width)
 608 {
 609     fprintf (logFp, "glCopyTexSubImage1D (0x%x, %d, %d, %d, %d, %d)\n",
 610              target, level, xoffset, x, y, width);
 611     (*nativeRenderTable->CopyTexSubImage1D) (target, level, xoffset, x, y,
 612                                              width);
 613 }
 614
 615 static void
 616 logCopyTexSubImage2D (GLenum  target,
 617                       GLint   level,
 618                       GLint   xoffset,
 619                       GLint   yoffset,
 620                       GLint   x,
 621                       GLint   y,
 622                       GLsizei width,
 623                       GLsizei height)
 624 {
 625     fprintf (logFp, "glCopyTexSubImage2D (0x%x, %d, %d, %d, %d, %d, %d, %d)\n",
 626              target, level, xoffset, yoffset, x, y, width, height);
 627     (*nativeRenderTable->CopyTexSubImage2D) (target, level,
 628                                              xoffset, yoffset, x, y,
 629                                              width, height);
 630 }
 631
 632 static void
 633 logCullFace (GLenum mode)
 634 {
 635     fprintf (logFp, "glCullFace (0x%x)\n", mode);
 636     (*nativeRenderTable->CullFace) (mode);
 637 }
 638
 639 static void
 640 logDeleteLists (GLuint  list,
 641                 GLsizei range)
 642 {
 643     fprintf (logFp, "glDeleteLists (%d, %d)\n", list, range);
 644     (*nativeRenderTable->DeleteLists) (list, range);
 645 }
 646
 647 static void
 648 logDeleteTextures (GLsizei n, const GLuint *textures)
 649 {
 650     fprintf (logFp, "glDeleteTextures (%d, %p)\n", n, textures);
 651     (*nativeRenderTable->DeleteTextures) (n, textures);
 652 }
 653
 654 static void
 655 logDepthFunc (GLenum func)
 656 {
 657     fprintf (logFp, "glDepthFunc (0x%x)\n", func);
 658     (*nativeRenderTable->DepthFunc) (func);
 659 }
 660
 661 static void
 662 logDepthMask (GLboolean flag)
 663 {
 664     fprintf (logFp, "glDepthMask (%d)\n", flag);
 665     (*nativeRenderTable->DepthMask) (flag);
 666 }
 667
 668 static void
 669 logDepthRange (GLclampd zNear,
 670                GLclampd zFar)
 671 {
 672     fprintf (logFp, "glDepthRange (%f, %f)\n", zNear, zFar);
 673     (*nativeRenderTable->DepthRange) (zNear, zFar);
 674 }
 675
 676 static void
 677 logDisable (GLenum cap)
 678 {
 679     fprintf (logFp, "glDisable (0x%x)\n", cap);
 680     (*nativeRenderTable->Disable) (cap);
 681 }
 682
 683 static void
 684 logDisableClientState (GLenum array)
 685 {
 686     fprintf (logFp, "glDisableClientState (0x%x)\n", array);
 687     (*nativeRenderTable->DisableClientState) (array);
 688 }
 689
 690 static void
 691 logDrawArrays (GLenum  mode,
 692                GLint   first,
 693                GLsizei count)
 694 {
 695     fprintf (logFp, "glDrawArrays (0x%x, %d, %d)\n", mode, first, count);
 696     (*nativeRenderTable->DrawArrays) (mode, first, count);
 697 }
 698
 699 static void
 700 logDrawBuffer (GLenum mode)
 701 {
 702     fprintf (logFp, "glDrawBuffer (0x%x)\n", mode);
 703     (*nativeRenderTable->DrawBuffer) (mode);
 704 }
 705
 706 static void
 707 logDrawElements (GLenum     mode,
 708                  GLsizei    count,
 709                  GLenum     type,
 710                  const void *indices)
 711 {
 712     fprintf (logFp, "glDrawElements (0x%x, %d, 0x%x, %p)\n",
 713              mode, count, type, indices);
 714     (*nativeRenderTable->DrawElements) (mode, count, type, indices);
 715 }
 716
 717 static void
 718 logDrawPixels (GLsizei    width,
 719                GLsizei    height,
 720                GLenum     format,
 721                GLenum     type,
 722                const void *pixels)
 723 {
 724     fprintf (logFp, "glDrawPixels (%d, %d, 0x%x, 0x%x, %p)\n",
 725              width, height, format, type, pixels);
 726     (*nativeRenderTable->DrawPixels) (width, height, format, type, pixels);
 727 }
 728
 729 static void
 730 logEdgeFlagPointer (GLsizei    stride,
 731                     const void *pointer)
 732 {
 733     fprintf (logFp, "glEdgeFlagPointer (%d, %p)", stride, pointer);
 734     (*nativeRenderTable->EdgeFlagPointer) (stride, pointer);
 735 }
 736
 737 static void
 738 logEdgeFlagv (const GLboolean *flag)
 739 {
 740     vCnt[edgeFlagvIndex].n++;
 741     if (logVertexAttribs)
 742         fprintf (logFp, "glEdgeFlagv (%p)\n", flag);
 743     (*nativeRenderTable->EdgeFlagv) (flag);
 744 }
 745
 746 static void
 747 logEnable (GLenum cap)
 748 {
 749     fprintf (logFp, "glEnable (0x%x)\n", cap);
 750     (*nativeRenderTable->Enable) (cap);
 751 }
 752
 753 static void
 754 logEnableClientState (GLenum array)
 755 {
 756     fprintf (logFp, "glEnableClientState (0x%x)\n", array);
 757     (*nativeRenderTable->EnableClientState) (array);
 758 }
 759
 760 static void
 761 logEnd (void)
 762 {
 763     int i;
 764
 765     for (i = 0; i < sizeof (vCnt) / sizeof (vCnt[0]); i++)
 766     {
 767         if (vCnt[i].n)
 768         {
 769             fprintf (logFp, "  %s: %d\n", vCnt[i].name, vCnt[i].n);
 770             vCnt[i].n = 0;
 771         }
 772     }
 773
 774     fprintf (logFp, "glEnd ()\n" );
 775     (*nativeRenderTable->End) ();
 776 }
 777
 778 static void
 779 logEndList (void)
 780 {
 781     fprintf (logFp, "glEndList ()\n" );
 782     (*nativeRenderTable->EndList) ();
 783 }
 784
 785 static void
 786 logEvalCoord1dv (const GLdouble *u)
 787 {
 788     vCnt[evalCoord1dvIndex].n++;
 789     if (logVertexAttribs)
 790         fprintf (logFp, "glEvalCoord1dv (%p)\n", u);
 791     (*nativeRenderTable->EvalCoord1dv) (u);
 792 }
 793
 794 static void
 795 logEvalCoord1fv (const GLfloat *u)
 796 {
 797     vCnt[evalCoord1fvIndex].n++;
 798     if (logVertexAttribs)
 799         fprintf (logFp, "glEvalCoord1fv (%p)\n", u);
 800     (*nativeRenderTable->EvalCoord1fv) (u);
 801 }
 802
 803 static void
 804 logEvalCoord2dv (const GLdouble *u)
 805 {
 806     vCnt[evalCoord2dvIndex].n++;
 807     if (logVertexAttribs)
 808         fprintf (logFp, "glEvalCoord2dv (%p)\n", u);
 809     (*nativeRenderTable->EvalCoord2dv) (u);
 810 }
 811
 812 static void
 813 logEvalCoord2fv (const GLfloat *u)
 814 {
 815     vCnt[evalCoord1fvIndex].n++;
 816     if (logVertexAttribs)
 817         fprintf (logFp, "glEvalCoord2fv (%p)\n", u);
 818     (*nativeRenderTable->EvalCoord2fv) (u);
 819 }
 820
 821 static void
 822 logEvalMesh1 (GLenum mode,
 823               GLint  i1,
 824               GLint  i2)
 825 {
 826     fprintf (logFp, "glEvalMesh1 (0x%x, %d, %d)\n", mode, i1, i2);
 827     (*nativeRenderTable->EvalMesh1) (mode, i1, i2 );
 828 }
 829
 830 static void
 831 logEvalMesh2 (GLenum mode,
 832               GLint  i1,
 833               GLint  i2,
 834               GLint  j1,
 835               GLint  j2)
 836 {
 837     fprintf (logFp, "glEvalMesh2 (0x%x, %d, %d, %d, %d)\n",
 838              mode, i1, i2, j1, j2);
 839     (*nativeRenderTable->EvalMesh2) (mode, i1, i2, j1, j2);
 840 }
 841
 842 static void
 843 logEvalPoint1 (GLint i)
 844 {
 845     vCnt[evalPoint1Index].n++;
 846     if (logVertexAttribs)
 847         fprintf (logFp, "glEvalPoint1 (%d)\n", i);
 848     (*nativeRenderTable->EvalPoint1) (i);
 849 }
 850
 851 static void
 852 logEvalPoint2 (GLint i, GLint j)
 853 {
 854     vCnt[evalPoint2Index].n++;
 855     if (logVertexAttribs)
 856         fprintf (logFp, "glEvalPoint2 (%d, %d)\n", i, j);
 857     (*nativeRenderTable->EvalPoint2) (i, j);
 858 }
 859
 860 static void
 861 logFeedbackBuffer (GLsizei size,
 862                    GLenum  type,
 863                    GLfloat *buffer)
 864 {
 865     fprintf (logFp, "glFeedbackBuffer (%d, 0x%x, %p)\n", size, type, buffer);
 866     (*nativeRenderTable->FeedbackBuffer) (size, type, buffer);
 867 }
 868
 869 static void
 870 logFinish (void)
 871 {
 872     fprintf (logFp, "glFinish ()\n");
 873     (*nativeRenderTable->Finish) ();
 874 }
 875
 876 static void
 877 logFlush (void)
 878 {
 879     fprintf (logFp, "glFlush ()\n");
 880     (*nativeRenderTable->Flush) ();
 881 }
 882
 883 static void
 884 logFogf (GLenum  pname,
 885          GLfloat param)
 886 {
 887     fprintf (logFp, "glFogf (0x%x, %f)\n", pname, param);
 888     (*nativeRenderTable->Fogf) (pname, param);
 889 }
 890
 891 static void
 892 logFogfv (GLenum        pname,
 893           const GLfloat *params)
 894 {
 895     fprintf (logFp, "glFogfv (0x%x, %p)\n", pname, params);
 896     (*nativeRenderTable->Fogfv) (pname, params);
 897 }
 898
 899 static void
 900 logFogi (GLenum pname,
 901          GLint  param)
 902 {
 903     fprintf (logFp, "glFogi (0x%x, %d)\n", pname, param);
 904     (*nativeRenderTable->Fogi) (pname, param);
 905 }
 906
 907 static void
 908 logFogiv (GLenum      pname,
 909           const GLint *params)
 910 {
 911     fprintf (logFp, "glFogiv (0x%x, %p)\n", pname, params);
 912     (*nativeRenderTable->Fogiv) (pname, params);
 913 }
 914
 915 static void
 916 logFrontFace (GLenum mode)
 917 {
 918     fprintf (logFp, "glFrontFace (0x%x)\n", mode);
 919     (*nativeRenderTable->FrontFace) (mode);
 920 }
 921
 922 static void
 923 logFrustum (GLdouble left,
 924             GLdouble right,
 925             GLdouble bottom,
 926             GLdouble top,
 927             GLdouble zNear,
 928             GLdouble zFar)
 929 {
 930     fprintf (logFp, "glFrustum (%f, %f, %f, %f, %f, %f)\n",
 931              left, right, bottom, top, zNear, zFar);
 932     (*nativeRenderTable->Frustum) (left, right, bottom, top, zNear, zFar);
 933 }
 934
 935 static GLuint
 936 logGenLists (GLsizei range)
 937 {
 938     fprintf (logFp, "glGenLists (%d)\n", range);
 939     return (*nativeRenderTable->GenLists) (range);
 940 }
 941
 942 static void
 943 logGenTextures (GLsizei n,
 944                 GLuint *textures)
 945 {
 946     fprintf (logFp, "glGenTextures (%d, %p)\n", n, textures);
 947     (*nativeRenderTable->GenTextures) (n, textures);
 948 }
 949 static void
 950 logGetBooleanv (GLenum    pname,
 951                 GLboolean *params)
 952 {
 953     fprintf (logFp, "glGetBooleanv (0x%x, %p)\n", pname, params);
 954     (*nativeRenderTable->GetBooleanv) (pname, params);
 955 }
 956
 957 static void
 958 logGetClipPlane (GLenum   plane,
 959                  GLdouble *equation)
 960 {
 961     fprintf (logFp, "glGetClipPlane (0x%x, %p)\n", plane, equation);
 962     (*nativeRenderTable->GetClipPlane) (plane, equation);
 963 }
 964
 965 static void
 966 logGetDoublev (GLenum   pname,
 967                GLdouble *params)
 968 {
 969     fprintf (logFp, "glGetDoublev (0x%x, %p)\n", pname, params);
 970     (*nativeRenderTable->GetDoublev) (pname, params);
 971 }
 972
 973 static GLenum
 974 logGetError (void)
 975 {
 976     fprintf (logFp, "glGetError ()\n");
 977     return (*nativeRenderTable->GetError) ();
 978 }
 979
 980 static void
 981 logGetFloatv (GLenum  pname,
 982               GLfloat *params)
 983 {
 984     fprintf (logFp, "glGetFloatv (0x%x, %p)\n", pname, params);
 985     (*nativeRenderTable->GetFloatv) (pname, params);
 986 }
 987
 988 static void
 989 logGetIntegerv (GLenum pname,
 990                 GLint  *params)
 991 {
 992     fprintf (logFp, "glGetIntegerv (0x%x, %p)\n", pname, params);
 993     (*nativeRenderTable->GetIntegerv) (pname, params);
 994 }
 995
 996 static void
 997 logGetLightfv (GLenum  light,
 998                GLenum  pname,
 999                GLfloat *params)
1000 {
1001     fprintf (logFp, "glGetLightfv (0x%x, 0x%x, %p)\n", light, pname, params);
1002     (*nativeRenderTable->GetLightfv) (light, pname, params);
1003 }
1004
1005 static void
1006 logGetLightiv (GLenum light,
1007                GLenum pname,
1008                GLint  *params)
1009 {
1010     fprintf (logFp, "glGetLightiv (0x%x, 0x%x, %p)\n",
1011              light, pname, params);
1012     (*nativeRenderTable->GetLightiv) (light, pname, params);
1013 }
1014
1015 static void
1016 logGetMapdv (GLenum   target,
1017              GLenum   query,
1018              GLdouble *v)
1019 {
1020     fprintf (logFp, "glGetMapdv (0x%x, 0x%x, %p)\n", target, query, v);
1021     (*nativeRenderTable->GetMapdv) (target, query, v);
1022 }
1023
1024 static void
1025 logGetMapfv (GLenum  target,
1026              GLenum  query,
1027              GLfloat *v)
1028 {
1029     fprintf (logFp, "glGetMapfv (0x%x, 0x%x, %p)\n", target, query, v);
1030     (*nativeRenderTable->GetMapfv) (target, query, v);
1031 }
1032
1033 static void
1034 logGetMapiv (GLenum target,
1035              GLenum query,
1036              GLint  *v)
1037 {
1038     fprintf (logFp, "glGetMapiv (0x%x, 0x%x, %p)\n", target, query, v);
1039     (*nativeRenderTable->GetMapiv) (target, query, v);
1040 }
1041
1042 static void
1043 logGetMaterialfv (GLenum  face,
1044                   GLenum  pname,
1045                   GLfloat *params)
1046 {
1047     fprintf (logFp, "glGetMaterialfv (0x%x, 0x%x, %p)\n", face, pname, params);
1048     (*nativeRenderTable->GetMaterialfv) (face, pname, params);
1049 }
1050
1051 static void
1052 logGetMaterialiv (GLenum face,
1053                   GLenum pname,
1054                   GLint  *params)
1055 {
1056     fprintf (logFp, "glGetMaterialiv (0x%x, 0x%x, %p)\n", face, pname, params);
1057     (*nativeRenderTable->GetMaterialiv) (face, pname, params);
1058 }
1059
1060 static void
1061 logGetPixelMapfv (GLenum  map,
1062                   GLfloat *values)
1063 {
1064     fprintf (logFp, "glGetPixelMapfv (0x%x, %p)\n", map, values);
1065     (*nativeRenderTable->GetPixelMapfv) (map, values);
1066 }
1067
1068 static void
1069 logGetPixelMapuiv (GLenum map,
1070                    GLuint *values)
1071 {
1072     fprintf (logFp, "glGetPixelMapuiv (0x%x, %p)\n", map, values);
1073     (*nativeRenderTable->GetPixelMapuiv) (map, values);
1074 }
1075
1076 static void
1077 logGetPixelMapusv (GLenum   map,
1078                    GLushort *values)
1079 {
1080     fprintf (logFp, "glGetPixelMapusv (0x%x, %p)\n", map, values);
1081     (*nativeRenderTable->GetPixelMapusv) (map, values);
1082 }
1083
1084 static void
1085 logGetPointerv (GLenum pname,
1086                 GLvoid **params)
1087 {
1088     fprintf (logFp, "glGetPointerv (0x%x, %p)\n", pname, params);
1089     (*nativeRenderTable->GetPointerv) (pname, params);
1090 }
1091
1092 static void
1093 logGetPolygonStipple (GLubyte *mask)
1094 {
1095     fprintf (logFp, "glGetPolygonStipple (%p)\n", mask);
1096     (*nativeRenderTable->GetPolygonStipple) (mask);
1097 }
1098
1099 static const GLubyte *
1100 logGetString (GLenum name)
1101 {
1102     fprintf (logFp, "glGetString (0x%x)\n", name);
1103     return (*nativeRenderTable->GetString) (name);
1104 }
1105
1106 static void
1107 logGetTexEnvfv (GLenum  target,
1108                 GLenum  pname,
1109                 GLfloat *params)
1110 {
1111     fprintf (logFp, "glGetTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params);
1112     (*nativeRenderTable->GetTexEnvfv) (target, pname, params);
1113 }
1114
1115 static void
1116 logGetTexEnviv (GLenum target,
1117                 GLenum pname,
1118                 GLint  *params)
1119 {
1120     fprintf (logFp, "glGetTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params);
1121     (*nativeRenderTable->GetTexEnviv) (target, pname, params);
1122 }
1123
1124 static void
1125 logGetTexGendv (GLenum   coord,
1126                 GLenum   pname,
1127                 GLdouble *params)
1128 {
1129     fprintf (logFp, "glGetTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params);
1130     (*nativeRenderTable->GetTexGendv) (coord, pname, params);
1131 }
1132
1133 static void
1134 logGetTexGenfv (GLenum  coord,
1135                 GLenum  pname,
1136                 GLfloat *params)
1137 {
1138     fprintf (logFp, "glGetTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params);
1139     (*nativeRenderTable->GetTexGenfv) (coord, pname, params);
1140 }
1141
1142 static void
1143 logGetTexGeniv (GLenum coord,
1144                 GLenum pname,
1145                 GLint  *params)
1146 {
1147     fprintf (logFp, "glGetTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params);
1148     (*nativeRenderTable->GetTexGeniv) (coord, pname, params);
1149 }
1150
1151 static void
1152 logGetTexImage (GLenum target,
1153                 GLint  level,
1154                 GLenum format,
1155                 GLenum type,
1156                 void   *pixels)
1157 {
1158     fprintf (logFp, "glGetTexImage (0x%x, %d, 0x%x, 0x%x, %p)\n",
1159              target, level, format, type, pixels);
1160     (*nativeRenderTable->GetTexImage) (target, level, format, type,
1161                                        pixels);
1162 }
1163 static void
1164 logGetTexLevelParameterfv (GLenum  target,
1165                            GLint   level,
1166                            GLenum  pname,
1167                            GLfloat *params)
1168 {
1169     fprintf (logFp, "glGetTexLevelParameterfv (0x%x, %d, 0x%x, %p)\n",
1170              target, level, pname, params);
1171     (*nativeRenderTable->GetTexLevelParameterfv) (target, level,
1172                                                   pname, params);
1173 }
1174
1175 static void
1176 logGetTexLevelParameteriv (GLenum target,
1177                            GLint  level,
1178                            GLenum pname,
1179                            GLint  *params)
1180 {
1181     fprintf (logFp, "glGetTexLevelParameteriv (0x%x, %d, 0x%x, %p)\n",
1182              target, level, pname, params);
1183     (*nativeRenderTable->GetTexLevelParameteriv) (target, level,
1184                                                   pname, params);
1185 }
1186
1187 static void
1188 logGetTexParameterfv (GLenum  target,
1189                       GLenum  pname,
1190                       GLfloat *params)
1191 {
1192     fprintf (logFp, "glGetTexParameterfv (0x%x, 0x%x, %p)\n",
1193              target, pname, params);
1194     (*nativeRenderTable->GetTexParameterfv) (target, pname, params);
1195 }
1196
1197 static void
1198 logGetTexParameteriv (GLenum target,
1199                       GLenum pname,
1200                       GLint  *params)
1201 {
1202     fprintf (logFp, "glGetTexParameteriv (0x%x, 0x%x, %p)\n",
1203              target, pname, params);
1204     (*nativeRenderTable->GetTexParameteriv) (target, pname, params);
1205 }
1206
1207 static void
1208 logHint (GLenum target,
1209          GLenum mode)
1210 {
1211     fprintf (logFp, "glHint (0x%x, 0x%x)\n", target, mode);
1212     (*nativeRenderTable->Hint) (target, mode);
1213 }
1214
1215 static void
1216 logIndexMask (GLuint mask)
1217 {
1218     fprintf (logFp, "glIndexMask (%d)\n", mask);
1219     (*nativeRenderTable->IndexMask) (mask);
1220 }
1221
1222 static void
1223 logIndexPointer (GLenum     type,
1224                  GLsizei    stride,
1225                  const void *pointer)
1226 {
1227     fprintf (logFp, "glIndexPointer (0x%x, %d, %p)\n", type, stride, pointer);
1228     (*nativeRenderTable->IndexPointer) (type, stride, pointer);
1229 }
1230
1231 static void
1232 logIndexdv (const GLdouble *c)
1233 {
1234     vCnt[indexdvIndex].n++;
1235     if (logVertexAttribs)
1236         fprintf (logFp, "glIndexdv (%p)\n", c);
1237     (*nativeRenderTable->Indexdv) (c);
1238 }
1239
1240 static void
1241 logIndexfv (const GLfloat *c)
1242 {
1243     vCnt[indexfvIndex].n++;
1244     if (logVertexAttribs)
1245         fprintf (logFp, "glIndexfv (%p)\n", c);
1246     (*nativeRenderTable->Indexfv) (c);
1247 }
1248
1249 static void
1250 logIndexiv (const GLint *c)
1251 {
1252     vCnt[indexivIndex].n++;
1253     if (logVertexAttribs)
1254         fprintf (logFp, "glIndexiv (%p)\n", c);
1255     (*nativeRenderTable->Indexiv) (c);
1256 }
1257
1258 static void
1259 logIndexsv (const GLshort *c)
1260 {
1261     vCnt[indexsvIndex].n++;
1262     if (logVertexAttribs)
1263         fprintf (logFp, "glIndexsv (%p)\n", c);
1264     (*nativeRenderTable->Indexsv) (c);
1265 }
1266
1267 static void
1268 logIndexubv (const GLubyte *c)
1269 {
1270     vCnt[indexubvIndex].n++;
1271     if (logVertexAttribs)
1272         fprintf (logFp, "glIndexubv (%p)\n", c);
1273     (*nativeRenderTable->Indexubv) (c);
1274 }
1275
1276 static void
1277 logInitNames (void)
1278 {
1279     fprintf (logFp, "glInitNames ()\n" );
1280     (*nativeRenderTable->InitNames) ();
1281 }
1282
1283 static void
1284 logInterleavedArrays (GLenum     format,
1285                       GLsizei    stride,
1286                       const void *pointer)
1287 {
1288     fprintf (logFp, "glInterleavedArrays (0x%x, %d, %p)\n",
1289              format, stride, pointer);
1290     (*nativeRenderTable->InterleavedArrays) (format, stride, pointer);
1291 }
1292
1293 static GLboolean
1294 logIsEnabled (GLenum cap)
1295 {
1296     fprintf (logFp, "glIsEnabled (0x%x)\n", cap);
1297     return (*nativeRenderTable->IsEnabled) (cap);
1298 }
1299
1300 static GLboolean
1301 logIsList (GLuint list)
1302 {
1303     fprintf (logFp, "glIsList (%d)\n", list);
1304     return (*nativeRenderTable->IsList) (list);
1305 }
1306
1307 static GLboolean
1308 logIsTexture (GLuint texture)
1309 {
1310     fprintf (logFp, "glIsTexture (%d)\n", texture);
1311     return (*nativeRenderTable->IsTexture) (texture);
1312 }
1313
1314 static void
1315 logLightModelf (GLenum  pname,
1316                 GLfloat param)
1317 {
1318     fprintf (logFp, "glLightModelf (0x%x, %f)\n", pname, param);
1319     (*nativeRenderTable->LightModelf) (pname, param);
1320 }
1321
1322 static void
1323 logLightModelfv (GLenum        pname,
1324                  const GLfloat *params)
1325 {
1326     fprintf (logFp, "glLightModelfv (0x%x, %p)\n", pname, params);
1327     (*nativeRenderTable->LightModelfv) (pname, params);
1328 }
1329
1330 static void
1331 logLightModeli (GLenum pname,
1332                 GLint  param)
1333 {
1334     fprintf (logFp, "glLightModeli (0x%x, %d)\n", pname, param);
1335     (*nativeRenderTable->LightModeli) (pname, param);
1336 }
1337
1338 static void
1339 logLightModeliv (GLenum      pname,
1340                  const GLint *params)
1341 {
1342     fprintf (logFp, "glLightModeliv (0x%x, %p)\n", pname, params);
1343     (*nativeRenderTable->LightModeliv) (pname, params);
1344 }
1345
1346 static void
1347 logLightf (GLenum  light,
1348            GLenum  pname,
1349            GLfloat param)
1350 {
1351     fprintf (logFp, "glLightf (0x%x, 0x%x, %f)\n", light, pname, param);
1352     (*nativeRenderTable->Lightf) (light, pname, param);
1353 }
1354
1355 static void
1356 logLightfv (GLenum        light,
1357             GLenum        pname,
1358             const GLfloat *params)
1359 {
1360     fprintf (logFp, "glLightfv (0x%x, 0x%x, %p)\n", light, pname, params);
1361     (*nativeRenderTable->Lightfv) (light, pname, params);
1362 }
1363
1364 static void
1365 logLighti (GLenum light,
1366            GLenum pname,
1367            GLint  param)
1368 {
1369     fprintf (logFp, "glLighti (0x%x, 0x%x, %d)\n", light, pname, param);
1370     (*nativeRenderTable->Lighti) (light, pname, param);
1371 }
1372
1373 static void
1374 logLightiv (GLenum      light,
1375             GLenum      pname,
1376             const GLint *params)
1377 {
1378     fprintf (logFp, "glLightiv (0x%x, 0x%x, %p)\n", light, pname, params);
1379     (*nativeRenderTable->Lightiv) (light, pname, params);
1380 }
1381
1382 static void
1383 logLineStipple (GLint    factor,
1384                 GLushort pattern)
1385 {
1386     fprintf (logFp, "glLineStipple (%d, %d)\n", factor, pattern);
1387     (*nativeRenderTable->LineStipple) (factor, pattern);
1388 }
1389
1390 static void
1391 logLineWidth (GLfloat width)
1392 {
1393     fprintf (logFp, "glLineWidth (%f)\n", width);
1394     (*nativeRenderTable->LineWidth) (width);
1395 }
1396
1397 static void
1398 logListBase (GLuint base)
1399 {
1400     fprintf (logFp, "glListBase (%d)\n", base);
1401     (*nativeRenderTable->ListBase) (base);
1402 }
1403
1404 static void
1405 logLoadIdentity (void)
1406 {
1407     fprintf (logFp, "glLoadIdentity ()\n");
1408     (*nativeRenderTable->LoadIdentity) ();
1409 }
1410
1411 static void
1412 logLoadMatrixd (const GLdouble *m)
1413 {
1414     fprintf (logFp, "glLoadMatrixd (%p)\n", m);
1415     (*nativeRenderTable->LoadMatrixd) (m);
1416 }
1417
1418 static void
1419 logLoadMatrixf (const GLfloat *m)
1420 {
1421     fprintf (logFp, "glLoadMatrixf (%p)\n", m);
1422     (*nativeRenderTable->LoadMatrixf) (m);
1423 }
1424
1425 static void
1426 logLoadName (GLuint name)
1427 {
1428     fprintf (logFp, "glLoadName (%d)\n", name);
1429     (*nativeRenderTable->LoadName) (name);
1430 }
1431
1432 static void
1433 logLogicOp (GLenum opcode)
1434 {
1435     fprintf (logFp, "glLogicOp(0x%x)\n", opcode);
1436     (*nativeRenderTable->LogicOp) (opcode);
1437 }
1438
1439 static void
1440 logMap1d (GLenum         target,
1441           GLdouble       u1,
1442           GLdouble       u2,
1443           GLint          stride,
1444           GLint          order,
1445           const GLdouble *points)
1446 {
1447     fprintf (logFp, "glMap1d (0x%x, %f, %f, %d, %d, %p)\n",
1448              target, u1, u2, stride, order, points);
1449     (*nativeRenderTable->Map1d) (target, u1, u2, stride, order, points);
1450 }
1451
1452 static void
1453 logMap1f (GLenum        target,
1454           GLfloat       u1,
1455           GLfloat       u2,
1456           GLint         stride,
1457           GLint         order,
1458           const GLfloat *points)
1459 {
1460     fprintf (logFp, "glMap1f (0x%x, %f, %f, %d, %d, %p)\n",
1461              target, u1, u2, stride, order, points);
1462     (*nativeRenderTable->Map1f) (target, u1, u2, stride, order, points);
1463 }
1464
1465 static void
1466 logMap2d (GLenum         target,
1467           GLdouble       u1,
1468           GLdouble       u2,
1469           GLint          ustride,
1470           GLint          uorder,
1471           GLdouble       v1,
1472           GLdouble       v2,
1473           GLint          vstride,
1474           GLint          vorder,
1475           const GLdouble *points)
1476 {
1477     fprintf (logFp, "glMap2d (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n",
1478              target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1479     (*nativeRenderTable->Map2d) (target, u1, u2, ustride, uorder, v1, v2,
1480                                  vstride, vorder, points);
1481 }
1482
1483 static void
1484 logMap2f (GLenum        target,
1485           GLfloat       u1,
1486           GLfloat       u2,
1487           GLint         ustride,
1488           GLint         uorder,
1489           GLfloat       v1,
1490           GLfloat       v2,
1491           GLint         vstride,
1492           GLint         vorder,
1493           const GLfloat *points)
1494 {
1495     fprintf (logFp, "glMap2f (0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n",
1496              target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1497     (*nativeRenderTable->Map2f) (target, u1, u2, ustride, uorder, v1, v2,
1498                                  vstride, vorder, points);
1499 }
1500
1501 static void
1502 logMapGrid1d (GLint    un,
1503               GLdouble u1,
1504               GLdouble u2)
1505 {
1506     fprintf (logFp, "glMapGrid1d (%d, %f, %f)\n", un, u1, u2);
1507     (*nativeRenderTable->MapGrid1d) (un, u1, u2);
1508 }
1509
1510 static void
1511 logMapGrid1f (GLint   un,
1512               GLfloat u1,
1513               GLfloat u2)
1514 {
1515     fprintf (logFp, "glMapGrid1f (%d, %f, %f)\n", un, u1, u2);
1516     (*nativeRenderTable->MapGrid1f) (un, u1, u2);
1517 }
1518
1519 static void
1520 logMapGrid2d (GLint    un,
1521               GLdouble u1,
1522               GLdouble u2,
1523               GLint    vn,
1524               GLdouble v1,
1525               GLdouble v2)
1526 {
1527     fprintf (logFp, "glMapGrid2d (%d, %f, %f, %d, %f, %f)\n",
1528              un, u1, u2, vn, v1, v2);
1529     (*nativeRenderTable->MapGrid2d) (un, u1, u2, vn, v1, v2);
1530 }
1531
1532 static void
1533 logMapGrid2f (GLint   un,
1534               GLfloat u1,
1535               GLfloat u2,
1536               GLint   vn,
1537               GLfloat v1,
1538               GLfloat v2)
1539 {
1540     fprintf (logFp, "glMapGrid2f (%d, %f, %f, %d, %f, %f)\n",
1541              un, u1, u2, vn, v1, v2);
1542     (*nativeRenderTable->MapGrid2f) (un, u1, u2, vn, v1, v2);
1543 }
1544
1545 static void
1546 logMaterialf (GLenum  face,
1547               GLenum  pname,
1548               GLfloat param)
1549 {
1550     vCnt[materialfIndex].n++;
1551     if (logVertexAttribs)
1552         fprintf (logFp, "glMaterialf (0x%x, 0x%x, %f)\n", face, pname, param);
1553     (*nativeRenderTable->Materialf) (face, pname, param);
1554 }
1555
1556 static void
1557 logMaterialfv (GLenum        face,
1558                GLenum        pname,
1559                const GLfloat *params)
1560 {
1561     vCnt[materialfvIndex].n++;
1562     if (logVertexAttribs)
1563         fprintf (logFp, "glMaterialfv (0x%x, 0x%x, %p)\n",
1564                  face, pname, params);
1565     (*nativeRenderTable->Materialfv) (face, pname, params);
1566 }
1567
1568 static void
1569 logMateriali (GLenum face,
1570               GLenum pname,
1571               GLint  param)
1572 {
1573     vCnt[materialiIndex].n++;
1574     if (logVertexAttribs)
1575         fprintf (logFp, "glMateriali (0x%x, 0x%x, %d)\n", face, pname, param);
1576     (*nativeRenderTable->Materiali) (face, pname, param);
1577 }
1578
1579 static void
1580 logMaterialiv (GLenum      face,
1581                GLenum      pname,
1582                const GLint *params)
1583 {
1584     vCnt[materialivIndex].n++;
1585     if (logVertexAttribs)
1586         fprintf (logFp, "glMaterialiv (0x%x, 0x%x, %p)\n",
1587                  face, pname, params);
1588     (*nativeRenderTable->Materialiv) (face, pname, params);
1589 }
1590
1591 static void
1592 logMatrixMode (GLenum mode)
1593 {
1594     fprintf (logFp, "glMatrixMode (0x%x)\n", mode);
1595     (*nativeRenderTable->MatrixMode) (mode);
1596 }
1597
1598 static void
1599 logMultMatrixd (const GLdouble *m)
1600 {
1601     fprintf (logFp, "glMultMatrixd (%p)\n", m);
1602     (*nativeRenderTable->MultMatrixd) (m);
1603 }
1604
1605 static void
1606 logMultMatrixf (const GLfloat *m)
1607 {
1608     fprintf (logFp, "glMultMatrixf (%p)\n", m);
1609     (*nativeRenderTable->MultMatrixf) (m);
1610 }
1611
1612 static void
1613 logNewList (GLuint list,
1614             GLenum mode)
1615 {
1616     fprintf (logFp, "glNewList (%d, 0x%x)\n", list, mode);
1617     (*nativeRenderTable->NewList) (list, mode);
1618 }
1619
1620 static void
1621 logNormal3bv (const GLbyte *v)
1622 {
1623     vCnt[normal3bvIndex].n++;
1624     if (logVertexAttribs)
1625         fprintf (logFp, "glNormal3bv (%p)\n", v);
1626     (*nativeRenderTable->Normal3bv) (v);
1627 }
1628
1629 static void
1630 logNormal3dv (const GLdouble *v)
1631 {
1632     vCnt[normal3dvIndex].n++;
1633     if (logVertexAttribs)
1634         fprintf (logFp, "glNormal3dv (%p)\n", v);
1635     (*nativeRenderTable->Normal3dv) (v);
1636 }
1637
1638 static void
1639 logNormal3fv (const GLfloat *v)
1640 {
1641     vCnt[normal3fvIndex].n++;
1642     if (logVertexAttribs)
1643         fprintf (logFp, "glNormal3fv (%p)\n", v);
1644     (*nativeRenderTable->Normal3fv) (v);
1645 }
1646
1647 static void
1648 logNormal3iv (const GLint *v)
1649 {
1650     vCnt[normal3ivIndex].n++;
1651     if (logVertexAttribs)
1652         fprintf (logFp, "glNormal3iv (%p)\n", v);
1653     (*nativeRenderTable->Normal3iv) (v);
1654 }
1655
1656 static void
1657 logNormal3sv (const GLshort *v)
1658 {
1659     vCnt[normal3svIndex].n++;
1660     if (logVertexAttribs)
1661         fprintf (logFp, "glNormal3sv (%p)\n", v);
1662     (*nativeRenderTable->Normal3sv) (v);
1663 }
1664
1665 static void
1666 logNormalPointer (GLenum     type,
1667                   GLsizei    stride,
1668                   const void *pointer)
1669 {
1670     fprintf (logFp, "glNormalPointer (0x%x, %d, %p)\n", type, stride, pointer);
1671     (*nativeRenderTable->NormalPointer) (type, stride, pointer);
1672 }
1673
1674 static void
1675 logOrtho (GLdouble left,
1676           GLdouble right,
1677           GLdouble bottom,
1678           GLdouble top,
1679           GLdouble zNear,
1680           GLdouble zFar)
1681 {
1682     fprintf (logFp, "glOrtho (%f, %f, %f, %f, %f, %f)\n",
1683              left, right, bottom, top, zNear, zFar);
1684     (*nativeRenderTable->Ortho) (left, right, bottom, top, zNear, zFar);
1685 }
1686
1687 static void
1688 logPassThrough (GLfloat token)
1689 {
1690     fprintf (logFp, "glPassThrough (%f)\n", token);
1691     (*nativeRenderTable->PassThrough) (token);
1692 }
1693
1694 static void
1695 logPixelMapfv (GLenum        map,
1696                GLsizei       mapsize,
1697                const GLfloat *values)
1698 {
1699     fprintf (logFp, "glPixelMapfv (0x%x, %d, %p)\n", map, mapsize, values);
1700     (*nativeRenderTable->PixelMapfv) (map, mapsize, values);
1701 }
1702
1703 static void
1704 logPixelMapuiv (GLenum       map,
1705                 GLsizei      mapsize,
1706                 const GLuint *values)
1707 {
1708     fprintf (logFp, "glPixelMapuiv (0x%x, %d, %p)\n", map, mapsize, values);
1709     (*nativeRenderTable->PixelMapuiv) (map, mapsize, values);
1710 }
1711
1712 static void
1713 logPixelMapusv (GLenum         map,
1714                 GLsizei        mapsize,
1715                 const GLushort *values)
1716 {
1717     fprintf (logFp, "glPixelMapusv (0x%x, %d, %p)\n", map, mapsize, values);
1718     (*nativeRenderTable->PixelMapusv) (map, mapsize, values);
1719 }
1720
1721 static void
1722 logPixelStoref (GLenum  pname,
1723                 GLfloat param)
1724 {
1725     fprintf (logFp, "glPixelStoref (0x%x, %f)\n", pname, param);
1726     (*nativeRenderTable->PixelStoref) (pname, param);
1727 }
1728
1729 static void
1730 logPixelStorei (GLenum pname,
1731                 GLint  param)
1732 {
1733     fprintf (logFp, "glPixelStorei (0x%x, %d)\n", pname, param);
1734     (*nativeRenderTable->PixelStorei) (pname, param);
1735 }
1736
1737 static void
1738 logPixelTransferf (GLenum pname, GLfloat param)
1739 {
1740     fprintf (logFp, "glPixelTransferf (0x%x, %f)\n", pname, param);
1741     (*nativeRenderTable->PixelTransferf) (pname, param);
1742 }
1743
1744 static void
1745 logPixelTransferi (GLenum pname,
1746                    GLint  param)
1747 {
1748     fprintf (logFp, "glPixelTransferi (0x%x, %d)\n", pname, param);
1749     (*nativeRenderTable->PixelTransferi) (pname, param);
1750 }
1751
1752 static void
1753 logPixelZoom (GLfloat xfactor,
1754               GLfloat yfactor)
1755 {
1756     fprintf (logFp, "glPixelZoom (%f, %f)\n", xfactor, yfactor);
1757     (*nativeRenderTable->PixelZoom) (xfactor, yfactor);
1758 }
1759
1760 static void
1761 logPointSize (GLfloat size)
1762 {
1763     fprintf (logFp, "glPointSize" );
1764     (*nativeRenderTable->PointSize) (size);
1765 }
1766
1767 static void
1768 logPolygonMode (GLenum face,
1769                 GLenum mode)
1770 {
1771     fprintf (logFp, "glPolygonMode (0x%x, 0x%x)\n", face, mode );
1772     (*nativeRenderTable->PolygonMode) (face, mode);
1773 }
1774
1775 static void
1776 logPolygonOffset (GLfloat factor,
1777                   GLfloat units)
1778 {
1779     fprintf (logFp, "glPolygonOffset (%f, %f)\n", factor, units);
1780     (*nativeRenderTable->PolygonOffset) (factor, units);
1781 }
1782
1783 static void
1784 logPolygonStipple (const GLubyte *mask)
1785 {
1786     fprintf (logFp, "glPolygonStipple (%p)\n", mask);
1787     (*nativeRenderTable->PolygonStipple) (mask);
1788 }
1789
1790 static void
1791 logPopAttrib (void)
1792 {
1793     fprintf (logFp, "glPopAttrib ()\n");
1794     (*nativeRenderTable->PopAttrib) ();
1795 }
1796
1797 static void
1798 logPopClientAttrib (void)
1799 {
1800     fprintf (logFp, "glPopClientAttrib ()\n" );
1801     (*nativeRenderTable->PopClientAttrib) ();
1802 }
1803
1804 static void
1805 logPopMatrix (void)
1806 {
1807     fprintf (logFp, "glPopMatrix ()\n" );
1808     (*nativeRenderTable->PopMatrix) ();
1809 }
1810
1811 static void
1812 logPopName (void)
1813 {
1814     fprintf (logFp, "glPopName ()\n");
1815     (*nativeRenderTable->PopName) ();
1816 }
1817
1818 static void
1819 logPrioritizeTextures (GLsizei        n,
1820                        const GLuint   *textures,
1821                        const GLclampf *priorities)
1822 {
1823     fprintf (logFp, "glPrioritizeTextures (%d, %p, %p)\n",
1824              n, textures, priorities);
1825     (*nativeRenderTable->PrioritizeTextures) (n, textures, priorities);
1826 }
1827
1828 static void
1829 logPushAttrib (GLbitfield mask)
1830 {
1831     fprintf (logFp, "glPushAttrib (0x%x)\n", mask);
1832     (*nativeRenderTable->PushAttrib) (mask);
1833 }
1834
1835 static void
1836 logPushClientAttrib (GLbitfield mask)
1837 {
1838     fprintf (logFp, "glPushClientAttrib (0x%x)\n", mask);
1839     (*nativeRenderTable->PushClientAttrib) (mask);
1840 }
1841
1842 static void
1843 logPushMatrix (void)
1844 {
1845     fprintf (logFp, "glPushMatrix ()\n" );
1846     (*nativeRenderTable->PushMatrix) ();
1847 }
1848
1849 static void
1850 logPushName (GLuint name)
1851 {
1852     fprintf (logFp, "glPushName (%d)\n", name);
1853     (*nativeRenderTable->PushName) (name);
1854 }
1855
1856 static void
1857 logRasterPos2dv (const GLdouble *v)
1858 {
1859     fprintf (logFp, "glRasterPos2dv (%p)\n", v);
1860     (*nativeRenderTable->RasterPos2dv) (v);
1861 }
1862
1863 static void
1864 logRasterPos2fv (const GLfloat *v)
1865 {
1866     fprintf (logFp, "glRasterPos2dv (%p)\n", v);
1867     (*nativeRenderTable->RasterPos2fv) (v);
1868 }
1869
1870 static void
1871 logRasterPos2iv (const GLint *v)
1872 {
1873     fprintf (logFp, "glRasterPos2iv (%p)\n", v);
1874     (*nativeRenderTable->RasterPos2iv) (v);
1875 }
1876
1877 static void
1878 logRasterPos2sv (const GLshort *v)
1879 {
1880     fprintf (logFp, "glRasterPos2sv (%p)\n", v);
1881     (*nativeRenderTable->RasterPos2sv) (v);
1882 }
1883
1884 static void
1885 logRasterPos3dv (const GLdouble *v)
1886 {
1887     fprintf (logFp, "glRasterPos3dv (%p)\n", v);
1888     (*nativeRenderTable->RasterPos3dv) (v);
1889 }
1890
1891 static void
1892 logRasterPos3fv (const GLfloat *v)
1893 {
1894     fprintf (logFp, "glRasterPos3fv (%p)\n", v);
1895     (*nativeRenderTable->RasterPos3fv) (v);
1896 }
1897
1898 static void
1899 logRasterPos3iv (const GLint *v)
1900 {
1901     fprintf (logFp, "glRasterPos3iv (%p)\n", v);
1902     (*nativeRenderTable->RasterPos3iv) (v);
1903 }
1904
1905 static void
1906 logRasterPos3sv (const GLshort *v)
1907 {
1908     fprintf (logFp, "glRasterPos3sv (%p)\n", v);
1909     (*nativeRenderTable->RasterPos3sv) (v);
1910 }
1911
1912 static void
1913 logRasterPos4dv (const GLdouble *v)
1914 {
1915     fprintf (logFp, "glRasterPos4dv (%p)\n", v);
1916     (*nativeRenderTable->RasterPos4dv) (v);
1917 }
1918
1919 static void
1920 logRasterPos4fv (const GLfloat *v)
1921 {
1922     fprintf (logFp, "glRasterPos4fv (%p)\n", v);
1923     (*nativeRenderTable->RasterPos4fv) (v);
1924 }
1925
1926 static void
1927 logRasterPos4iv (const GLint *v)
1928 {
1929     fprintf (logFp, "glRasterPos4iv (%p)\n", v);
1930     (*nativeRenderTable->RasterPos4iv) (v);
1931 }
1932
1933 static void
1934 logRasterPos4sv (const GLshort *v)
1935 {
1936     fprintf (logFp, "glRasterPos4sv (%p)\n", v);
1937     (*nativeRenderTable->RasterPos4sv) (v);
1938 }
1939
1940 static void
1941 logReadBuffer (GLenum mode)
1942 {
1943     fprintf (logFp, "glReadBuffer (0x%x)\n", mode);
1944     (*nativeRenderTable->ReadBuffer) (mode);
1945 }
1946
1947 static void
1948 logReadPixels (GLint   x,
1949                GLint   y,
1950                GLsizei width,
1951                GLsizei height,
1952                GLenum  format,
1953                GLenum  type,
1954                void    *pixels)
1955 {
1956     fprintf (logFp, "glReadPixels (%d, %d, %d, %d, 0x%x, 0x%x, %p)\n",
1957              x, y, width, height, format, type, pixels);
1958     (*nativeRenderTable->ReadPixels) (x, y, width, height, format, type,
1959                                       pixels);
1960 }
1961
1962 static void
1963 logRectdv (const GLdouble *v1,
1964            const GLdouble *v2)
1965 {
1966     fprintf (logFp, "glRectdv (%p, %p)\n", v1, v2);
1967     (*nativeRenderTable->Rectdv) (v1, v2);
1968 }
1969
1970 static void
1971 logRectfv (const GLfloat *v1,
1972            const GLfloat *v2)
1973 {
1974     fprintf (logFp, "glRectfv (%p, %p)\n", v1, v2);
1975     (*nativeRenderTable->Rectfv) (v1, v2);
1976 }
1977
1978 static void
1979 logRectiv (const GLint *v1,
1980            const GLint *v2)
1981 {
1982     fprintf (logFp, "glRectiv (%p, %p)\n", v1, v2);
1983     (*nativeRenderTable->Rectiv) (v1, v2);
1984 }
1985
1986 static void
1987 logRectsv (const GLshort *v1,
1988            const GLshort *v2)
1989 {
1990     fprintf (logFp, "glRectsv (%p, %p)\n", v1, v2);
1991     (*nativeRenderTable->Rectsv) (v1, v2);
1992 }
1993
1994 static GLint
1995 logRenderMode (GLenum mode)
1996 {
1997     fprintf (logFp, "glRenderMode (0x%x)\n", mode);
1998     return (*nativeRenderTable->RenderMode) (mode);
1999 }
2000
2001 static void
2002 logRotated (GLdouble angle,
2003             GLdouble x,
2004             GLdouble y,
2005             GLdouble z)
2006 {
2007     fprintf (logFp, "glRotated (%f, %f, %f, %f)\n", angle, x, y, z);
2008     (*nativeRenderTable->Rotated) (angle, x, y, z);
2009 }
2010
2011 static void
2012 logRotatef (GLfloat angle,
2013             GLfloat x,
2014             GLfloat y,
2015             GLfloat z)
2016 {
2017     fprintf (logFp, "glRotatef (%f, %f, %f, %f)\n", angle, x, y, z);
2018     (*nativeRenderTable->Rotatef) (angle, x, y, z);
2019 }
2020
2021 static void
2022 logScaled (GLdouble x,
2023            GLdouble y,
2024            GLdouble z)
2025 {
2026     fprintf (logFp, "glScaled (%f, %f, %f)\n", x, y, z);
2027     (*nativeRenderTable->Scaled) (x, y, z);
2028 }
2029
2030 static void
2031 logScalef (GLfloat x,
2032            GLfloat y,
2033            GLfloat z)
2034 {
2035     fprintf (logFp, "glScalef (%f, %f, %f)\n", x, y, z);
2036     (*nativeRenderTable->Scalef) (x, y, z);
2037 }
2038
2039 static void
2040 logScissor (GLint   x,
2041             GLint   y,
2042             GLsizei width,
2043             GLsizei height)
2044 {
2045     fprintf (logFp, "glScissor (%d, %d, %d, %d)\n", x, y, width, height);
2046     (*nativeRenderTable->Scissor) (x, y, width, height);
2047 }
2048
2049 static void
2050 logSelectBuffer (GLsizei size,
2051                  GLuint  *buffer)
2052 {
2053     fprintf (logFp, "glSelectBuffer (%d, %p)\n", size, buffer);
2054     (*nativeRenderTable->SelectBuffer) (size, buffer);
2055 }
2056
2057 static void
2058 logShadeModel (GLenum mode)
2059 {
2060     fprintf (logFp, "glShadeModel (0x%x)\n", mode);
2061     (*nativeRenderTable->ShadeModel) (mode);
2062 }
2063
2064 static void
2065 logStencilFunc (GLenum func,
2066                 GLint  ref,
2067                 GLuint mask)
2068 {
2069     fprintf (logFp, "glStencilFunc (0x%x, %d, %d)\n", func, ref, mask);
2070     (*nativeRenderTable->StencilFunc) (func, ref, mask);
2071 }
2072
2073 static void
2074 logStencilMask (GLuint mask)
2075 {
2076     fprintf (logFp, "glStencilMask (0x%x)\n", mask);
2077     (*nativeRenderTable->StencilMask) (mask);
2078 }
2079
2080 static void
2081 logStencilOp (GLenum fail,
2082               GLenum zfail,
2083               GLenum zpass)
2084 {
2085     fprintf (logFp, "glStencilOp (0x%x, 0x%x, 0x%x)\n", fail, zfail, zpass);
2086     (*nativeRenderTable->StencilOp) (fail, zfail, zpass);
2087 }
2088
2089 static void
2090 logTexCoord1dv (const GLdouble *v)
2091 {
2092     vCnt[texCoord1dvIndex].n++;
2093     if (logVertexAttribs)
2094         fprintf (logFp, "glTexCoord1dv (%p)\n", v);
2095     (*nativeRenderTable->TexCoord1dv) (v);
2096 }
2097
2098 static void
2099 logTexCoord1fv (const GLfloat *v)
2100 {
2101     vCnt[texCoord1fvIndex].n++;
2102     if (logVertexAttribs)
2103         fprintf (logFp, "glTexCoord1fv (%p)\n", v);
2104     (*nativeRenderTable->TexCoord1fv) (v);
2105 }
2106
2107 static void
2108 logTexCoord1iv (const GLint *v)
2109 {
2110     vCnt[texCoord1ivIndex].n++;
2111     if (logVertexAttribs)
2112         fprintf (logFp, "glTexCoord1iv (%p)\n", v);
2113     (*nativeRenderTable->TexCoord1iv) (v);
2114 }
2115
2116 static void
2117 logTexCoord1sv (const GLshort *v)
2118 {
2119     vCnt[texCoord1svIndex].n++;
2120     if (logVertexAttribs)
2121         fprintf (logFp, "glTexCoord1sv (%p)\n", v);
2122     (*nativeRenderTable->TexCoord1sv) (v);
2123 }
2124
2125 static void
2126 logTexCoord2dv (const GLdouble *v)
2127 {
2128     vCnt[texCoord2dvIndex].n++;
2129     if (logVertexAttribs)
2130         fprintf (logFp, "glTexCoord2dv (%p)\n", v);
2131     (*nativeRenderTable->TexCoord2dv) (v);
2132 }
2133
2134 static void
2135 logTexCoord2fv (const GLfloat *v)
2136 {
2137     vCnt[texCoord2fvIndex].n++;
2138     if (logVertexAttribs)
2139         fprintf (logFp, "glTexCoord2fv (%p)\n", v);
2140     (*nativeRenderTable->TexCoord2fv) (v);
2141 }
2142
2143 static void
2144 logTexCoord2iv (const GLint *v)
2145 {
2146     vCnt[texCoord2ivIndex].n++;
2147     if (logVertexAttribs)
2148         fprintf (logFp, "glTexCoord2iv (%p)\n", v);
2149     (*nativeRenderTable->TexCoord2iv) (v);
2150 }
2151
2152 static void
2153 logTexCoord2sv (const GLshort *v)
2154 {
2155     vCnt[texCoord2svIndex].n++;
2156     if (logVertexAttribs)
2157         fprintf (logFp, "glTexCoord2sv (%p)\n", v);
2158     (*nativeRenderTable->TexCoord2sv) (v);
2159 }
2160
2161
2162 static void
2163 logTexCoord3dv (const GLdouble *v)
2164 {
2165     vCnt[texCoord3dvIndex].n++;
2166     if (logVertexAttribs)
2167         fprintf (logFp, "glTexCoord3dv (%p)\n", v);
2168     (*nativeRenderTable->TexCoord3dv) (v);
2169 }
2170
2171 static void
2172 logTexCoord3fv (const GLfloat *v)
2173 {
2174     vCnt[texCoord3fvIndex].n++;
2175     if (logVertexAttribs)
2176         fprintf (logFp, "glTexCoord3fv (%p)\n", v);
2177     (*nativeRenderTable->TexCoord3fv) (v);
2178 }
2179
2180 static void
2181 logTexCoord3iv (const GLint *v)
2182 {
2183     vCnt[texCoord3ivIndex].n++;
2184     if (logVertexAttribs)
2185         fprintf (logFp, "glTexCoord3iv (%p)\n", v);
2186     (*nativeRenderTable->TexCoord3iv) (v);
2187 }
2188
2189 static void
2190 logTexCoord3sv (const GLshort *v)
2191 {
2192     vCnt[texCoord3svIndex].n++;
2193     if (logVertexAttribs)
2194         fprintf (logFp, "glTexCoord3sv (%p)\n", v);
2195     (*nativeRenderTable->TexCoord3sv) (v);
2196 }
2197
2198 static void
2199 logTexCoord4dv (const GLdouble *v)
2200 {
2201     vCnt[texCoord4dvIndex].n++;
2202     if (logVertexAttribs)
2203         fprintf (logFp, "glTexCoord4dv (%p)\n", v);
2204     (*nativeRenderTable->TexCoord4dv) (v);
2205 }
2206
2207 static void
2208 logTexCoord4fv (const GLfloat *v)
2209 {
2210     vCnt[texCoord4fvIndex].n++;
2211     if (logVertexAttribs)
2212         fprintf (logFp, "glTexCoord4fv (%p)\n", v);
2213     (*nativeRenderTable->TexCoord4fv) (v);
2214 }
2215
2216 static void
2217 logTexCoord4iv (const GLint *v)
2218 {
2219     vCnt[texCoord4ivIndex].n++;
2220     if (logVertexAttribs)
2221         fprintf (logFp, "glTexCoord4iv (%p)\n", v);
2222     (*nativeRenderTable->TexCoord4iv) (v);
2223 }
2224
2225 static void
2226 logTexCoord4sv (const GLshort *v)
2227 {
2228     vCnt[texCoord4svIndex].n++;
2229     if (logVertexAttribs)
2230         fprintf (logFp, "glTexCoord4sv (%p)\n", v);
2231     (*nativeRenderTable->TexCoord4sv) (v);
2232 }
2233
2234 static void
2235 logTexCoordPointer (GLint      size,
2236                     GLenum     type,
2237                     GLsizei    stride,
2238                     const void *pointer)
2239 {
2240     fprintf (logFp, "glTexCoordPointer (%d, 0x%x, %d, %p)\n",
2241              size, type, stride, pointer);
2242     (*nativeRenderTable->TexCoordPointer) (size, type, stride, pointer);
2243 }
2244
2245 static void
2246 logTexEnvf (GLenum  target,
2247             GLenum  pname,
2248             GLfloat param)
2249 {
2250     fprintf (logFp, "glTexEnvf (0x%x, 0x%x, %f)\n", target, pname, param);
2251     (*nativeRenderTable->TexEnvf) (target, pname, param);
2252 }
2253
2254 static void
2255 logTexEnvfv (GLenum        target,
2256              GLenum        pname,
2257              const GLfloat *params)
2258 {
2259     fprintf (logFp, "glTexEnvfv (0x%x, 0x%x, %p)\n", target, pname, params);
2260     (*nativeRenderTable->TexEnvfv) (target, pname, params);
2261 }
2262
2263 static void
2264 logTexEnvi (GLenum target,
2265             GLenum pname,
2266             GLint  param)
2267 {
2268     fprintf (logFp, "glTexEnvi (0x%x, 0x%x, %d)\n", target, pname, param);
2269     (*nativeRenderTable->TexEnvi) (target, pname, param);
2270 }
2271
2272 static void
2273 logTexEnviv (GLenum      target,
2274              GLenum      pname,
2275              const GLint *params)
2276 {
2277     fprintf (logFp, "glTexEnviv (0x%x, 0x%x, %p)\n", target, pname, params);
2278     (*nativeRenderTable->TexEnviv) (target, pname, params);
2279 }
2280
2281 static void
2282 logTexGend (GLenum   coord,
2283             GLenum   pname,
2284             GLdouble param)
2285 {
2286     fprintf (logFp, "glTexGend (0x%x, 0x%x, %f)\n", coord, pname, param);
2287     (*nativeRenderTable->TexGend) (coord, pname, param);
2288 }
2289
2290 static void
2291 logTexGendv (GLenum         coord,
2292              GLenum         pname,
2293              const GLdouble *params)
2294 {
2295     fprintf (logFp, "glTexGendv (0x%x, 0x%x, %p)\n", coord, pname, params);
2296     (*nativeRenderTable->TexGendv) (coord, pname, params);
2297 }
2298
2299 static void
2300 logTexGenf (GLenum  coord,
2301             GLenum  pname,
2302             GLfloat param)
2303 {
2304     fprintf (logFp, "glTexGenf (0x%x, 0x%x, %f)\n", coord, pname, param);
2305     (*nativeRenderTable->TexGenf) (coord, pname, param);
2306 }
2307
2308 static void
2309 logTexGenfv (GLenum        coord,
2310              GLenum        pname,
2311              const GLfloat *params)
2312 {
2313     fprintf (logFp, "glTexGenfv (0x%x, 0x%x, %p)\n", coord, pname, params);
2314     (*nativeRenderTable->TexGenfv) (coord, pname, params);
2315 }
2316
2317 static void
2318 logTexGeni (GLenum coord,
2319             GLenum pname,
2320             GLint  param)
2321 {
2322     fprintf (logFp, "glTexGeni (0x%x, 0x%x, %d)\n", coord, pname, param);
2323     (*nativeRenderTable->TexGeni) (coord, pname, param);
2324 }
2325
2326 static void
2327 logTexGeniv (GLenum      coord,
2328              GLenum      pname,
2329              const GLint *params)
2330 {
2331     fprintf (logFp, "glTexGeniv (0x%x, 0x%x, %p)\n", coord, pname, params);
2332     (*nativeRenderTable->TexGeniv) (coord, pname, params);
2333 }
2334
2335 static void
2336 logTexImage1D (GLenum     target,
2337                GLint      level,
2338                GLint      internalformat,
2339                GLsizei    width,
2340                GLint      border,
2341                GLenum     format,
2342                GLenum     type,
2343                const void *pixels)
2344 {
2345     fprintf (logFp, "glTexImage1D (0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)\n",
2346              target, level, internalformat, width, border, format, type,
2347              pixels);
2348     (*nativeRenderTable->TexImage1D) (target, level, internalformat,
2349                                       width, border, format, type,
2350                                       pixels);
2351 }
2352
2353 static void
2354 logTexImage2D (GLenum     target,
2355                GLint      level,
2356                GLint      internalformat,
2357                GLsizei    width,
2358                GLsizei    height,
2359                GLint      border,
2360                GLenum     format,
2361                GLenum     type,
2362                const void *pixels)
2363 {
2364     fprintf (logFp, "glTexImage2D (0x%x, %d, %d, %d, %d, %d, "
2365              "0x%x, 0x%x, %p)\n", target, level, internalformat,
2366              width, height, border, format, type, pixels);
2367     (*nativeRenderTable->TexImage2D) (target, level, internalformat,
2368                                       width, height, border, format, type,
2369                                       pixels);
2370 }
2371
2372 static void
2373 logTexParameterf (GLenum  target,
2374                   GLenum  pname,
2375                   GLfloat param)
2376 {
2377     fprintf (logFp, "glTexParameterf (0x%x, 0x%x, %f)\n",
2378              target, pname, param);
2379     (*nativeRenderTable->TexParameterf) (target, pname, param);
2380 }
2381
2382 static void
2383 logTexParameterfv (GLenum        target,
2384                    GLenum        pname,
2385                    const GLfloat *params)
2386 {
2387     fprintf (logFp, "glTexParameterfv (0x%x, 0x%x, %p)\n",
2388              target, pname, params);
2389     (*nativeRenderTable->TexParameterfv) (target, pname, params);
2390 }
2391
2392 static void
2393 logTexParameteri (GLenum target,
2394                   GLenum pname,
2395                   GLint  param)
2396 {
2397     fprintf (logFp, "glTexParameteri (0x%x, 0x%x, 0x%x)\n",
2398              target, pname, param);
2399     (*nativeRenderTable->TexParameteri) (target, pname, param);
2400 }
2401
2402 static void
2403 logTexParameteriv (GLenum      target,
2404                    GLenum      pname,
2405                    const GLint *params)
2406 {
2407     fprintf (logFp, "glTexParameteriv (0x%x, 0x%x, %p)\n",
2408              target, pname, params);
2409     (*nativeRenderTable->TexParameteriv) (target, pname, params);
2410 }
2411
2412 static void
2413 logTexSubImage1D (GLenum     target,
2414                   GLint      level,
2415                   GLint      xoffset,
2416                   GLsizei    width,
2417                   GLenum     format,
2418                   GLenum     type,
2419                   const void *pixels)
2420 {
2421     fprintf (logFp, "glTexSubImage1D (0x%x, %d, %d, %d, 0x%x, 0x%x, %p)\n",
2422              target, level, xoffset, width, format, type, pixels);
2423     (*nativeRenderTable->TexSubImage1D) (target, level, xoffset, width,
2424                                          format, type, pixels);
2425 }
2426
2427 static void
2428 logTexSubImage2D (GLenum     target,
2429                   GLint      level,
2430                   GLint      xoffset,
2431                   GLint      yoffset,
2432                   GLsizei    width,
2433                   GLsizei    height,
2434                   GLenum     format,
2435                   GLenum     type,
2436                   const void *pixels)
2437 {
2438     fprintf (logFp, "glTexSubImage2D (0x%x, %d, %d, %d, %d, %d, "
2439              "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset,
2440              width, height, format, type, pixels);
2441     (*nativeRenderTable->TexSubImage2D) (target, level, xoffset, yoffset,
2442                                          width, height, format, type,
2443                                          pixels);
2444 }
2445
2446 static void
2447 logTranslated (GLdouble x,
2448                GLdouble y,
2449                GLdouble z)
2450 {
2451     fprintf (logFp, "glTranslated (%f, %f, %f)\n", x, y, z);
2452     (*nativeRenderTable->Translated) (x, y, z);
2453 }
2454
2455 static void
2456 logTranslatef (GLfloat x,
2457                GLfloat y,
2458                GLfloat z)
2459 {
2460     fprintf (logFp, "glTranslatef (%f, %f, %f)\n", x, y, z);
2461     (*nativeRenderTable->Translatef) (x, y, z);
2462 }
2463
2464 static void
2465 logVertex2dv (const GLdouble *v)
2466 {
2467     vCnt[vertex2dvIndex].n++;
2468     if (logVertexAttribs)
2469         fprintf (logFp, "glVertex2dv (%p)\n", v);
2470     (*nativeRenderTable->Vertex2dv) (v);
2471 }
2472
2473 static void
2474 logVertex2fv (const GLfloat *v)
2475 {
2476     vCnt[vertex2fvIndex].n++;
2477     if (logVertexAttribs)
2478         fprintf (logFp, "glVertex2dv (%p)\n", v);
2479     (*nativeRenderTable->Vertex2fv) (v);
2480 }
2481
2482 static void
2483 logVertex2iv (const GLint *v)
2484 {
2485     vCnt[vertex2ivIndex].n++;
2486     if (logVertexAttribs)
2487         fprintf (logFp, "glVertex2iv (%p)\n", v);
2488     (*nativeRenderTable->Vertex2iv) (v);
2489 }
2490
2491 static void
2492 logVertex2sv (const GLshort *v)
2493 {
2494     vCnt[vertex2svIndex].n++;
2495     if (logVertexAttribs)
2496         fprintf (logFp, "glVertex2sv (%p)\n", v);
2497     (*nativeRenderTable->Vertex2sv) (v);
2498 }
2499
2500 static void
2501 logVertex3dv (const GLdouble *v)
2502 {
2503     vCnt[vertex3dvIndex].n++;
2504     if (logVertexAttribs)
2505         fprintf (logFp, "glVertex3dv (%p)\n", v);
2506     (*nativeRenderTable->Vertex3dv) (v);
2507 }
2508
2509 static void
2510 logVertex3fv (const GLfloat *v)
2511 {
2512     vCnt[vertex3fvIndex].n++;
2513     if (logVertexAttribs)
2514         fprintf (logFp, "glVertex3fv (%p)\n", v);
2515     (*nativeRenderTable->Vertex3fv) (v);
2516 }
2517
2518 static void
2519 logVertex3iv (const GLint *v)
2520 {
2521     vCnt[vertex3ivIndex].n++;
2522     if (logVertexAttribs)
2523         fprintf (logFp, "glVertex3iv (%p)\n", v);
2524     (*nativeRenderTable->Vertex3iv) (v);
2525 }
2526
2527 static void
2528 logVertex3sv (const GLshort *v)
2529 {
2530     vCnt[vertex3svIndex].n++;
2531     if (logVertexAttribs)
2532         fprintf (logFp, "glVertex3sv (%p)\n", v);
2533     (*nativeRenderTable->Vertex3sv) (v);
2534 }
2535
2536 static void
2537 logVertex4dv (const GLdouble *v)
2538 {
2539     vCnt[vertex4dvIndex].n++;
2540     if (logVertexAttribs)
2541         fprintf (logFp, "glVertex4dv (%p)\n", v);
2542     (*nativeRenderTable->Vertex4dv) (v);
2543 }
2544
2545 static void
2546 logVertex4fv (const GLfloat *v)
2547 {
2548     vCnt[vertex4fvIndex].n++;
2549     if (logVertexAttribs)
2550         fprintf (logFp, "glVertex4fv (%p)\n", v);
2551     (*nativeRenderTable->Vertex4fv) (v);
2552 }
2553
2554 static void
2555 logVertex4iv (const GLint *v)
2556 {
2557     vCnt[vertex4ivIndex].n++;
2558     if (logVertexAttribs)
2559         fprintf (logFp, "glVertex4iv (%p)\n", v);
2560     (*nativeRenderTable->Vertex4iv) (v);
2561 }
2562
2563 static void
2564 logVertex4sv (const GLshort *v)
2565 {
2566     vCnt[vertex4svIndex].n++;
2567     if (logVertexAttribs)
2568         fprintf (logFp, "glVertex4sv (%p)\n", v);
2569     (*nativeRenderTable->Vertex4sv) (v);
2570 }
2571
2572 static void
2573 logVertexPointer (GLint      size,
2574                   GLenum     type,
2575                   GLsizei    stride,
2576                   const void *pointer)
2577 {
2578     fprintf (logFp, "glVertexPointer (%d, 0x%x, %d, %p)\n",
2579              size, type, stride, pointer);
2580     (*nativeRenderTable->VertexPointer) (size, type, stride, pointer);
2581 }
2582
2583 static void
2584 logViewport (GLint   x,
2585              GLint   y,
2586              GLsizei width,
2587              GLsizei height)
2588 {
2589     fprintf (logFp, "glViewport (%d %d %d %d)\n", x, y, width, height);
2590     (*nativeRenderTable->Viewport) (x, y, width, height);
2591 }
2592
2593 static void
2594 logBlendColor (GLclampf red,
2595                GLclampf green,
2596                GLclampf blue,
2597                GLclampf alpha)
2598 {
2599     fprintf (logFp, "glBlendColor (%f, %f, %f, %f)\n",
2600              red, green, blue, alpha);
2601     (*nativeRenderTable->BlendColor) (red, green, blue, alpha);
2602 }
2603
2604 static void
2605 logBlendEquation (GLenum mode)
2606 {
2607     fprintf (logFp, "glBlendEquation (0x%x)\n", mode);
2608     (*nativeRenderTable->BlendEquation) (mode);
2609 }
2610
2611 static void
2612 logColorTable (GLenum       target,
2613                GLenum       internalformat,
2614                GLsizei      width,
2615                GLenum       format,
2616                GLenum       type,
2617                const GLvoid *table)
2618 {
2619     fprintf (logFp, "glColorTable (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n",
2620              target, internalformat, width, format, type, table);
2621     (*nativeRenderTable->ColorTable) (target, internalformat, width,
2622                                       format, type, table);
2623 }
2624
2625 static void
2626 logColorTableParameterfv (GLenum        target,
2627                           GLenum        pname,
2628                           const GLfloat *params)
2629 {
2630     fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n",
2631              target, pname, params);
2632     (*nativeRenderTable->ColorTableParameterfv) (target, pname, params);
2633 }
2634
2635 static void
2636 logColorTableParameteriv (GLenum      target,
2637                           GLenum      pname,
2638                           const GLint *params)
2639 {
2640     fprintf (logFp, "glColorTableParameterfv (0x%x, 0x%x, %p)\n",
2641              target, pname, params);
2642     (*nativeRenderTable->ColorTableParameteriv) (target, pname, params);
2643 }
2644
2645 static void
2646 logCopyColorTable (GLenum  target,
2647                    GLenum  internalformat,
2648                    GLint   x,
2649                    GLint   y,
2650                    GLsizei width)
2651 {
2652     fprintf (logFp, "glCopyColorTable (0x%x, 0x%x, %d, %d, %d)\n",
2653              target, internalformat, x, y, width);
2654     (*nativeRenderTable->CopyColorTable) (target, internalformat,
2655                                           x, y, width);
2656 }
2657
2658 static void
2659 logGetColorTable (GLenum target,
2660                   GLenum format,
2661                   GLenum type,
2662                   GLvoid *table)
2663 {
2664     fprintf (logFp, "glGetColorTable (0x%x, 0x%x, 0x%x, %p)\n",
2665              target, format, type, table);
2666     (*nativeRenderTable->GetColorTable) (target, format, type, table);
2667 }
2668
2669 static void
2670 logGetColorTableParameterfv (GLenum  target,
2671                              GLenum  pname,
2672                              GLfloat *params)
2673 {
2674     fprintf (logFp, "glGetColorTableParameterfv (0x%x, 0x%x, %p)\n",
2675              target, pname, params);
2676     (*nativeRenderTable->GetColorTableParameterfv) (target, pname, params);
2677 }
2678
2679 static void
2680 logGetColorTableParameteriv (GLenum target,
2681                              GLenum pname,
2682                              GLint  *params)
2683 {
2684     fprintf (logFp, "glGetColorTableParameteriv (0x%x, 0x%x, %p)\n",
2685              target, pname, params);
2686     (*nativeRenderTable->GetColorTableParameteriv) (target, pname, params);
2687 }
2688
2689 static void
2690 logColorSubTable (GLenum       target,
2691                   GLsizei      start,
2692                   GLsizei      count,
2693                   GLenum       format,
2694                   GLenum       type,
2695                   const GLvoid *data)
2696 {
2697     fprintf (logFp, "glColorSubTable (0x%x, %d, %d, 0x%x, 0x%x, %p)\n",
2698              target, start, count, format, type, data);
2699     (*nativeRenderTable->ColorSubTable) (target, start, count,
2700                                          format, type, data);
2701 }
2702
2703 static void
2704 logCopyColorSubTable (GLenum  target,
2705                       GLsizei start,
2706                       GLint   x,
2707                       GLint   y,
2708                       GLsizei width)
2709 {
2710     fprintf (logFp, "glCopyColorSubTable (0x%x, %d, %d, %d, %d)\n",
2711              target, start, x, y, width);
2712     (*nativeRenderTable->CopyColorSubTable) (target, start, x, y, width);
2713 }
2714
2715 static void
2716 logConvolutionFilter1D (GLenum       target,
2717                         GLenum       internalformat,
2718                         GLsizei      width,
2719                         GLenum       format,
2720                         GLenum       type,
2721                         const GLvoid *image)
2722 {
2723     fprintf (logFp, "glConvolutionFilter1D (0x%x, 0x%x, %d, 0x%x, 0x%x, %p)\n",
2724              target, internalformat, width, format, type, image);
2725     (*nativeRenderTable->ConvolutionFilter1D) (target, internalformat,
2726                                                width, format, type, image);
2727 }
2728
2729 static void
2730 logConvolutionFilter2D (GLenum       target,
2731                         GLenum       internalformat,
2732                         GLsizei      width,
2733                         GLsizei      height,
2734                         GLenum       format,
2735                         GLenum       type,
2736                         const GLvoid *image)
2737 {
2738     fprintf (logFp, "glConvolutionFilter2D (0x%x, 0x%x, %d, %d, "
2739              "0x%x, 0x%x, %p)\n", target, internalformat, width, height,
2740              format, type, image);
2741     (*nativeRenderTable->ConvolutionFilter2D) (target, internalformat,
2742                                                width, height, format,
2743                                                type, image);
2744 }
2745
2746 static void
2747 logConvolutionParameterf (GLenum  target,
2748                           GLenum  pname,
2749                           GLfloat param)
2750 {
2751     fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %f)\n",
2752              target, pname, param);
2753     (*nativeRenderTable->ConvolutionParameterf) (target, pname, param);
2754 }
2755
2756 static void
2757 logConvolutionParameterfv (GLenum        target,
2758                            GLenum        pname,
2759                            const GLfloat *params)
2760 {
2761     fprintf (logFp, "glConvolutionParameterfv (0x%x, 0x%x, %p)\n",
2762              target, pname, params);
2763     (*nativeRenderTable->ConvolutionParameterfv) (target, pname, params);
2764 }
2765
2766 static void
2767 logConvolutionParameteri (GLenum target,
2768                           GLenum pname,
2769                           GLint  param)
2770 {
2771     fprintf (logFp, "glConvolutionParameterf (0x%x, 0x%x, %d)\n",
2772              target, pname, param);
2773     (*nativeRenderTable->ConvolutionParameteri) (target, pname, param);
2774 }
2775
2776 static void
2777 logConvolutionParameteriv (GLenum      target,
2778                            GLenum      pname,
2779                            const GLint *params)
2780 {
2781     fprintf (logFp, "glConvolutionParameteriv (0x%x, 0x%x, %p)\n",
2782              target, pname, params);
2783     (*nativeRenderTable->ConvolutionParameteriv) (target, pname, params);
2784 }
2785
2786 static void
2787 logCopyConvolutionFilter1D (GLenum  target,
2788                             GLenum  internalformat,
2789                             GLint   x,
2790                             GLint   y,
2791                             GLsizei width)
2792 {
2793     fprintf (logFp, "glCopyConvolutionFilter1D (0x%x, 0x%x, %d, %d, %d)\n",
2794              target, internalformat, x, y, width);
2795     (*nativeRenderTable->CopyConvolutionFilter1D) (target, internalformat,
2796                                                    x, y, width);
2797 }
2798
2799 static void
2800 logCopyConvolutionFilter2D (GLenum  target,
2801                             GLenum  internalformat,
2802                             GLint   x,
2803                             GLint   y,
2804                             GLsizei width,
2805                             GLsizei height)
2806 {
2807     fprintf (logFp, "glCopyConvolutionFilter2D (0x%x, 0x%x, %d, %d, %d, %d)\n",
2808              target, internalformat, x, y, width, height);
2809     (*nativeRenderTable->CopyConvolutionFilter2D) (target, internalformat,
2810                                                    x, y, width, height);
2811 }
2812
2813 static void
2814 logGetConvolutionFilter (GLenum target,
2815                          GLenum format,
2816                          GLenum type,
2817                          GLvoid *image)
2818 {
2819     fprintf (logFp, "glGetConvolutionFilter (0x%x, 0x%x, 0x%x, %p)\n",
2820              target, format, type, image);
2821     (*nativeRenderTable->GetConvolutionFilter) (target, format, type,
2822                                                 image);
2823 }
2824
2825 static void
2826 logGetConvolutionParameterfv (GLenum  target,
2827                               GLenum  pname,
2828                               GLfloat *params)
2829 {
2830     fprintf (logFp, "glGetConvolutionParameterfv (0x%x, 0x%x, %p)\n",
2831              target, pname, params);
2832     (*nativeRenderTable->GetConvolutionParameterfv) (target, pname,
2833                                                      params);
2834 }
2835
2836 static void
2837 logGetConvolutionParameteriv (GLenum target,
2838                               GLenum pname,
2839                               GLint  *params)
2840 {
2841     fprintf (logFp, "glGetConvolutionParameteriv (0x%x, 0x%x, %p)\n",
2842              target, pname, params);
2843     (*nativeRenderTable->GetConvolutionParameteriv) (target, pname,
2844                                                      params);
2845 }
2846
2847 static void
2848 logGetSeparableFilter (GLenum target,
2849                        GLenum format,
2850                        GLenum type,
2851                        GLvoid *row,
2852                        GLvoid *column,
2853                        GLvoid *span)
2854 {
2855     fprintf (logFp, "glGetSeparableFilter (0x%x, 0x%x, 0x%x, %p, %p, %p)\n",
2856              target, format, type, row, column, span);
2857     (*nativeRenderTable->GetSeparableFilter) (target, format, type,
2858                                               row, column, span);
2859 }
2860
2861 static void
2862 logSeparableFilter2D (GLenum       target,
2863                       GLenum       internalformat,
2864                       GLsizei      width,
2865                       GLsizei      height,
2866                       GLenum       format,
2867                       GLenum       type,
2868                       const GLvoid *row,
2869                       const GLvoid *column)
2870 {
2871     fprintf (logFp, "glSeparableFilter2D (0x%x, 0x%x, %d, %d, "
2872              "0x%x, 0x%x, %p, %p)\n", target, internalformat, width, height,
2873              format, type, row, column);
2874     (*nativeRenderTable->SeparableFilter2D) (target, internalformat,
2875                                              width, height, format,
2876                                              type, row, column);
2877 }
2878
2879 static void
2880 logGetHistogram (GLenum    target,
2881                  GLboolean reset,
2882                  GLenum    format,
2883                  GLenum    type,
2884                  GLvoid    *values)
2885 {
2886     fprintf (logFp, "glGetHistogram (0x%x, %d, 0x%x, 0x%x, %p)\n",
2887              target, reset, format, type, values);
2888     (*nativeRenderTable->GetHistogram) (target, reset, format, type,
2889                                         values);
2890 }
2891
2892 static void
2893 logGetHistogramParameterfv (GLenum  target,
2894                             GLenum  pname,
2895                             GLfloat *params)
2896 {
2897     fprintf (logFp, "glGetHistogramParameterfv (0x%x, 0x%x, %p)\n",
2898              target, pname, params);
2899     (*nativeRenderTable->GetHistogramParameterfv) (target, pname, params);
2900 }
2901
2902 static void
2903 logGetHistogramParameteriv (GLenum target,
2904                             GLenum pname,
2905                             GLint  *params)
2906 {
2907     fprintf (logFp, "glGetHistogramParameteriv (0x%x, 0x%x, %p)\n",
2908              target, pname, params);
2909     (*nativeRenderTable->GetHistogramParameteriv) (target, pname, params);
2910 }
2911
2912 static void
2913 logGetMinmax (GLenum    target,
2914               GLboolean reset,
2915               GLenum    format,
2916               GLenum    type,
2917               GLvoid    *values)
2918 {
2919     fprintf (logFp, "glGetMinmax (0x%x, %d, 0x%x, 0x%x, %p)\n",
2920              target, reset, format, type, values);
2921     (*nativeRenderTable->GetMinmax) (target, reset, format, type, values);
2922 }
2923
2924 static void
2925 logGetMinmaxParameterfv (GLenum  target,
2926                          GLenum  pname,
2927                          GLfloat *params)
2928 {
2929     fprintf (logFp, "GetMinmaxParameterfv (0x%x, 0x%x, %p)\n",
2930              target, pname, params);
2931     (*nativeRenderTable->GetMinmaxParameterfv) (target, pname, params);
2932 }
2933
2934 static void
2935 logGetMinmaxParameteriv (GLenum target,
2936                          GLenum pname,
2937                          GLint  *params)
2938 {
2939     fprintf (logFp, "GetMinmaxParameteriv (0x%x, 0x%x, %p)\n",
2940              target, pname, params);
2941     (*nativeRenderTable->GetMinmaxParameteriv) (target, pname, params);
2942 }
2943
2944 static void
2945 logHistogram (GLenum    target,
2946               GLsizei   width,
2947               GLenum    internalformat,
2948               GLboolean sink)
2949 {
2950     fprintf (logFp, "glHistogram (0x%x, %d, 0x%x, %d)\n",
2951              target, width, internalformat, sink);
2952     (*nativeRenderTable->Histogram) (target, width, internalformat, sink);
2953 }
2954
2955 static void
2956 logMinmax (GLenum    target,
2957            GLenum    internalformat,
2958            GLboolean sink)
2959 {
2960     fprintf (logFp, "glMinmax (0x%x, 0x%x, %d)\n",
2961              target, internalformat, sink);
2962     (*nativeRenderTable->Minmax) (target, internalformat, sink);
2963 }
2964
2965 static void
2966 logResetHistogram (GLenum target)
2967 {
2968     fprintf (logFp, "glResetHistogram (0x%x)\n", target);
2969     (*nativeRenderTable->ResetHistogram) (target);
2970 }
2971
2972 static void
2973 logResetMinmax (GLenum target)
2974 {
2975     fprintf (logFp, "glResetMinmax (0x%x)\n", target);
2976     (*nativeRenderTable->ResetMinmax) (target);
2977 }
2978
2979 static void
2980 logCopyTexSubImage3D (GLenum  target,
2981                       GLint   level,
2982                       GLint   xoffset,
2983                       GLint   yoffset,
2984                       GLint   zoffset,
2985                       GLint   x,
2986                       GLint   y,
2987                       GLsizei width,
2988                       GLsizei height)
2989 {
2990     fprintf (logFp, "glCopyTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, "
2991              "%d, %d)\n", target, level, xoffset, yoffset, zoffset,
2992              x, y, width, height);
2993     (*nativeRenderTable->CopyTexSubImage3D) (target, level,
2994                                              xoffset, yoffset, zoffset,
2995                                              x, y, width, height);
2996 }
2997
2998 static void
2999 logTexImage3D (GLenum       target,
3000                GLint        level,
3001                GLint        internalformat,
3002                GLsizei      width,
3003                GLsizei      height,
3004                GLsizei      depth,
3005                GLint        border,
3006                GLenum       format,
3007                GLenum       type,
3008                const GLvoid *pixels)
3009 {
3010     fprintf (logFp, "glTexImage3D (0x%x, %d, %d, %d, %d, %d, %d, "
3011              "0x%x, 0x%x, %p)\n", target, level, internalformat,
3012              width, height, depth, border, format, type, pixels);
3013     (*nativeRenderTable->TexImage3D) (target, level, internalformat,
3014                                       width, height, depth, border,
3015                                       format, type, pixels);
3016 }
3017
3018 static void
3019 logTexSubImage3D (GLenum       target,
3020                   GLint        level,
3021                   GLint        xoffset,
3022                   GLint        yoffset,
3023                   GLint        zoffset,
3024                   GLsizei      width,
3025                   GLsizei      height,
3026                   GLsizei      depth,
3027                   GLenum       format,
3028                   GLenum       type,
3029                   const GLvoid *pixels)
3030 {
3031     fprintf (logFp, "glTexSubImage3D (0x%x, %d, %d, %d, %d, %d, %d, %d, "
3032              "0x%x, 0x%x, %p)\n", target, level, xoffset, yoffset, zoffset,
3033              width, height, depth, format, type, pixels);
3034     (*nativeRenderTable->TexSubImage3D) (target, level,
3035                                          xoffset, yoffset, zoffset,
3036                                          width, height, depth,
3037                                          format, type, pixels);
3038 }
3039
3040 /* GL_ARB_multitexture */
3041
3042 static void
3043 logActiveTextureARB (GLenum texture)
3044 {
3045     fprintf (logFp, "glActiveTextureARB (0x%x)\n", texture);
3046     (*nativeRenderTable->ActiveTextureARB) (texture);
3047 }
3048
3049 static void
3050 logClientActiveTextureARB (GLenum texture)
3051 {
3052     fprintf (logFp, "glClientActiveTextureARB (0x%x)\n", texture);
3053     (*nativeRenderTable->ClientActiveTextureARB) (texture);
3054 }
3055
3056 static void
3057 logMultiTexCoord1dvARB (GLenum         target,
3058                         const GLdouble *v)
3059 {
3060     vCnt[multiTexCoord1dvIndex].n++;
3061     if (logVertexAttribs)
3062         fprintf (logFp, "glMultiTexCoord1dvARB (0x%x, %p)\n", target, v);
3063     (*nativeRenderTable->MultiTexCoord1dvARB) (target, v);
3064 }
3065
3066 static void
3067 logMultiTexCoord1fvARB (GLenum        target,
3068                         const GLfloat *v)
3069 {
3070     vCnt[multiTexCoord1fvIndex].n++;
3071     if (logVertexAttribs)
3072         fprintf (logFp, "glMultiTexCoord1fvARB (0x%x, %p)\n", target, v);
3073     (*nativeRenderTable->MultiTexCoord1fvARB) (target, v);
3074 }
3075
3076 static void
3077 logMultiTexCoord1ivARB (GLenum      target,
3078                         const GLint *v)
3079 {
3080     vCnt[multiTexCoord1ivIndex].n++;
3081     if (logVertexAttribs)
3082         fprintf (logFp, "glMultiTexCoord1ivARB (0x%x, %p)\n", target, v);
3083     (*nativeRenderTable->MultiTexCoord1ivARB) (target, v);
3084 }
3085
3086 static void
3087 logMultiTexCoord1svARB (GLenum        target,
3088                         const GLshort *v)
3089 {
3090     vCnt[multiTexCoord1svIndex].n++;
3091     if (logVertexAttribs)
3092         fprintf (logFp, "glMultiTexCoord1svARB (0x%x, %p)\n", target, v);
3093     (*nativeRenderTable->MultiTexCoord1svARB) (target, v);
3094 }
3095
3096 static void
3097 logMultiTexCoord2dvARB (GLenum         target,
3098                         const GLdouble *v)
3099 {
3100     vCnt[multiTexCoord2dvIndex].n++;
3101     if (logVertexAttribs)
3102         fprintf (logFp, "glMultiTexCoord2dvARB (0x%x, %p)\n", target, v);
3103     (*nativeRenderTable->MultiTexCoord2dvARB) (target, v);
3104 }
3105
3106 static void
3107 logMultiTexCoord2fvARB (GLenum        target,
3108                         const GLfloat *v)
3109 {
3110     vCnt[multiTexCoord2fvIndex].n++;
3111     if (logVertexAttribs)
3112         fprintf (logFp, "glMultiTexCoord2fvARB (0x%x, %p)\n", target, v);
3113     (*nativeRenderTable->MultiTexCoord2fvARB) (target, v);
3114 }
3115
3116 static void
3117 logMultiTexCoord2ivARB (GLenum      target,
3118                         const GLint *v)
3119 {
3120     vCnt[multiTexCoord2ivIndex].n++;
3121     if (logVertexAttribs)
3122         fprintf (logFp, "glMultiTexCoord2ivARB (0x%x, %p)\n", target, v);
3123     (*nativeRenderTable->MultiTexCoord2ivARB) (target, v);
3124 }
3125
3126 static void
3127 logMultiTexCoord2svARB (GLenum        target,
3128                         const GLshort *v)
3129 {
3130     vCnt[multiTexCoord2svIndex].n++;
3131     if (logVertexAttribs)
3132         fprintf (logFp, "glMultiTexCoord2svARB (0x%x, %p)\n", target, v);
3133     (*nativeRenderTable->MultiTexCoord2svARB) (target, v);
3134 }
3135
3136 static void
3137 logMultiTexCoord3dvARB (GLenum         target,
3138                         const GLdouble *v)
3139 {
3140     vCnt[multiTexCoord3dvIndex].n++;
3141     if (logVertexAttribs)
3142         fprintf (logFp, "glMultiTexCoord3dvARB (0x%x, %p)\n", target, v);
3143     (*nativeRenderTable->MultiTexCoord3dvARB) (target, v);
3144 }
3145
3146 static void
3147 logMultiTexCoord3fvARB (GLenum        target,
3148                         const GLfloat *v)
3149 {
3150     vCnt[multiTexCoord3fvIndex].n++;
3151     if (logVertexAttribs)
3152         fprintf (logFp, "glMultiTexCoord3fvARB (0x%x, %p)\n", target, v);
3153     (*nativeRenderTable->MultiTexCoord3fvARB) (target, v);
3154 }
3155
3156 static void
3157 logMultiTexCoord3ivARB (GLenum      target,
3158                         const GLint *v)
3159 {
3160     vCnt[multiTexCoord3ivIndex].n++;
3161     if (logVertexAttribs)
3162         fprintf (logFp, "glMultiTexCoord3ivARB (0x%x, %p)\n", target, v);
3163     (*nativeRenderTable->MultiTexCoord3ivARB) (target, v);
3164 }
3165
3166 static void
3167 logMultiTexCoord3svARB (GLenum        target,
3168                         const GLshort *v)
3169 {
3170     vCnt[multiTexCoord3svIndex].n++;
3171     if (logVertexAttribs)
3172         fprintf (logFp, "glMultiTexCoord3svARB (0x%x, %p)\n", target, v);
3173     (*nativeRenderTable->MultiTexCoord3svARB) (target, v);
3174 }
3175
3176 static void
3177 logMultiTexCoord4dvARB (GLenum         target,
3178                         const GLdouble *v)
3179 {
3180     vCnt[multiTexCoord4dvIndex].n++;
3181     if (logVertexAttribs)
3182         fprintf (logFp, "glMultiTexCoord4dvARB (0x%x, %p)\n", target, v);
3183     (*nativeRenderTable->MultiTexCoord4dvARB) (target, v);
3184 }
3185
3186 static void
3187 logMultiTexCoord4fvARB (GLenum        target,
3188                         const GLfloat *v)
3189 {
3190     vCnt[multiTexCoord4fvIndex].n++;
3191     if (logVertexAttribs)
3192         fprintf (logFp, "glMultiTexCoord4fvARB (0x%x, %p)\n", target, v);
3193     (*nativeRenderTable->MultiTexCoord4fvARB) (target, v);
3194 }
3195
3196 static void
3197 logMultiTexCoord4ivARB (GLenum      target,
3198                         const GLint *v)
3199 {
3200     vCnt[multiTexCoord4ivIndex].n++;
3201     if (logVertexAttribs)
3202         fprintf (logFp, "glMultiTexCoord4ivARB (0x%x, %p)\n", target, v);
3203     (*nativeRenderTable->MultiTexCoord4ivARB) (target, v);
3204 }
3205
3206 static void
3207 logMultiTexCoord4svARB (GLenum        target,
3208                         const GLshort *v)
3209 {
3210     vCnt[multiTexCoord4svIndex].n++;
3211     if (logVertexAttribs)
3212         fprintf (logFp, "glMultiTexCoord4svARB (0x%x, %p)\n", target, v);
3213     (*nativeRenderTable->MultiTexCoord4svARB) (target, v);
3214 }
3215
3216
3217 /* GL_ARB_multisample */
3218
3219 static void
3220 logSampleCoverageARB (GLclampf  value,
3221                       GLboolean invert)
3222 {
3223     fprintf (logFp, "glSampleCoverageARB (%f, %d)\n", value, invert);
3224     (*nativeRenderTable->SampleCoverageARB) (value, invert);
3225 }
3226
3227
3228 /* GL_EXT_texture_object */
3229
3230 static GLboolean
3231 logAreTexturesResidentEXT (GLsizei      n,
3232                            const GLuint *textures,
3233                            GLboolean    *residences)
3234 {
3235     fprintf (logFp, "glAreTexturesResidentEXT (%d, %p, %p)\n",
3236              n, textures, residences);
3237     return (*nativeRenderTable->AreTexturesResidentEXT) (n, textures,
3238                                                          residences);
3239 }
3240 static void
3241 logGenTexturesEXT (GLsizei n,
3242                    GLuint  *textures)
3243 {
3244     fprintf (logFp, "glGenTexturesEXT (%d, %p)\n", n, textures);
3245     (*nativeRenderTable->GenTexturesEXT) (n, textures);
3246 }
3247
3248 static GLboolean
3249 logIsTextureEXT (GLuint texture)
3250 {
3251     fprintf (logFp, "glIsTextureEXT (%d)\n", texture);
3252     return (*nativeRenderTable->IsTextureEXT) (texture);
3253 }
3254
3255
3256 /* GL_SGIS_multisample */
3257
3258 static void
3259 logSampleMaskSGIS (GLclampf  value,
3260                    GLboolean invert)
3261 {
3262     fprintf (logFp, "glSampleMaskSGIS (%f, %d)\n", value, invert);
3263     (*nativeRenderTable->SampleMaskSGIS) (value, invert);
3264 }
3265
3266 static void
3267 logSamplePatternSGIS (GLenum pattern)
3268 {
3269     fprintf (logFp, "glSamplePatternSGIS (0x%x)\n", pattern);
3270     (*nativeRenderTable->SamplePatternSGIS) (pattern);
3271 }
3272
3273
3274 /* GL_EXT_point_parameters */
3275
3276 static void
3277 logPointParameterfEXT (GLenum  pname,
3278                        GLfloat param)
3279 {
3280     fprintf (logFp, "glPointParameterfEXT (0x%x, %f)\n", pname, param);
3281     (*nativeRenderTable->PointParameterfEXT) (pname, param);
3282 }
3283
3284 static void
3285 logPointParameterfvEXT (GLenum        pname,
3286                         const GLfloat *params)
3287 {
3288     fprintf (logFp, "glPointParameterfvEXT (0x%x, %p)\n", pname, params);
3289     (*nativeRenderTable->PointParameterfvEXT) (pname, params);
3290 }
3291
3292
3293 /* GL_MESA_window_pos */
3294
3295 static void
3296 logWindowPos3fMESA (GLfloat x,
3297                     GLfloat y,
3298                     GLfloat z)
3299 {
3300     fprintf (logFp, "glWindowPos3fMESA (%f, %f, %f)\n", x, y, z);
3301     (*nativeRenderTable->WindowPos3fMESA) (x, y, z);
3302 }
3303
3304
3305 /* GL_EXT_blend_func_separate */
3306
3307 static void
3308 logBlendFuncSeparateEXT (GLenum sfactorRGB,
3309                          GLenum dfactorRGB,
3310                          GLenum sfactorAlpha,
3311                          GLenum dfactorAlpha)
3312 {
3313     fprintf (logFp, "glBlendFuncSeparateEXT (0x%x, 0x%x, 0x%x, 0x%x)\n",
3314              sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
3315     (*nativeRenderTable->BlendFuncSeparateEXT) (sfactorRGB,
3316                                                 dfactorRGB,
3317                                                 sfactorAlpha,
3318                                                 dfactorAlpha);
3319 }
3320
3321
3322 /* GL_EXT_fog_coord */
3323
3324 static void
3325 logFogCoordfvEXT (const GLfloat *coord)
3326 {
3327     vCnt[fogCoordfvIndex].n++;
3328     if (logVertexAttribs)
3329         fprintf (logFp, "glFogCoordfvEXT (%p)\n", coord);
3330     (*nativeRenderTable->FogCoordfvEXT) (coord);
3331 }
3332
3333 static void
3334 logFogCoorddvEXT (const GLdouble *coord)
3335 {
3336     vCnt[fogCoorddvIndex].n++;
3337     if (logVertexAttribs)
3338         fprintf (logFp, "glFogCoorddvEXT (%p)\n", coord);
3339     (*nativeRenderTable->FogCoorddvEXT) (coord);
3340 }
3341
3342 static void
3343 logFogCoordPointerEXT (GLenum       type,
3344                        GLsizei      stride,
3345                        const GLvoid *pointer)
3346 {
3347     fprintf (logFp, "glFogCoordPointerEXT (0x%x, %d, %p)\n",
3348              type, stride, pointer);
3349     (*nativeRenderTable->FogCoordPointerEXT) (type, stride, pointer);
3350 }
3351
3352
3353 /* GL_EXT_secondary_color */
3354
3355 static void
3356 logSecondaryColor3bvEXT (const GLbyte *v)
3357 {
3358     vCnt[secondaryColor3bvIndex].n++;
3359     if (logVertexAttribs)
3360         fprintf (logFp, "glSecondaryColor3bvEXT (%p)\n", v);
3361     (*nativeRenderTable->SecondaryColor3bvEXT) (v);
3362 }
3363
3364 static void
3365 logSecondaryColor3dvEXT (const GLdouble *v)
3366 {
3367     vCnt[secondaryColor3dvIndex].n++;
3368     if (logVertexAttribs)
3369         fprintf (logFp, "glSecondaryColor3dvEXT (%p)\n", v);
3370     (*nativeRenderTable->SecondaryColor3dvEXT) (v);
3371 }
3372
3373 static void
3374 logSecondaryColor3fvEXT (const GLfloat *v)
3375 {
3376     vCnt[secondaryColor3fvIndex].n++;
3377     if (logVertexAttribs)
3378         fprintf (logFp, "glSecondaryColor3fvEXT (%p)\n", v);
3379     (*nativeRenderTable->SecondaryColor3fvEXT) (v);
3380 }
3381
3382 static void
3383 logSecondaryColor3ivEXT (const GLint *v)
3384 {
3385     vCnt[secondaryColor3ivIndex].n++;
3386     if (logVertexAttribs)
3387         fprintf (logFp, "glSecondaryColor3ivEXT (%p)\n", v);
3388     (*nativeRenderTable->SecondaryColor3ivEXT) (v);
3389 }
3390
3391 static void
3392 logSecondaryColor3svEXT (const GLshort *v)
3393 {
3394     vCnt[secondaryColor3svIndex].n++;
3395     if (logVertexAttribs)
3396         fprintf (logFp, "glSecondaryColor3svEXT (%p)\n", v);
3397     (*nativeRenderTable->SecondaryColor3svEXT) (v);
3398 }
3399
3400 static void
3401 logSecondaryColor3ubvEXT (const GLubyte *v)
3402 {
3403     vCnt[secondaryColor3ubvIndex].n++;
3404     if (logVertexAttribs)
3405         fprintf (logFp, "glSecondaryColor3ubvEXT (%p)\n", v);
3406     (*nativeRenderTable->SecondaryColor3ubvEXT) (v);
3407 }
3408
3409 static void
3410 logSecondaryColor3uivEXT (const GLuint *v)
3411 {
3412     vCnt[secondaryColor3uivIndex].n++;
3413     if (logVertexAttribs)
3414         fprintf (logFp, "glSecondaryColor3uivEXT (%p)\n", v);
3415     (*nativeRenderTable->SecondaryColor3uivEXT) (v);
3416 }
3417
3418 static void
3419 logSecondaryColor3usvEXT (const GLushort *v)
3420 {
3421     vCnt[secondaryColor3usvIndex].n++;
3422     if (logVertexAttribs)
3423         fprintf (logFp, "glSecondaryColor3usvEXT (%p)\n", v);
3424     (*nativeRenderTable->SecondaryColor3usvEXT) (v);
3425 }
3426
3427 static void
3428 logSecondaryColorPointerEXT (GLint        size,
3429                              GLenum       type,
3430                              GLsizei      stride,
3431                              const GLvoid *pointer)
3432 {
3433     fprintf (logFp, "glSecondaryColorPointerEXT (%d, 0x%x, %d, %p)\n",
3434              size, type, stride, pointer);
3435     (*nativeRenderTable->SecondaryColorPointerEXT) (size, type,
3436                                                     stride, pointer);
3437 }
3438
3439
3440 /* GL_NV_point_sprite */
3441
3442 static void
3443 logPointParameteriNV (GLenum pname,
3444                       GLint  param)
3445 {
3446     fprintf (logFp, "glPointParameteriNV (0x%x, %d)\n", pname, param);
3447     (*nativeRenderTable->PointParameteriNV) (pname, param);
3448 }
3449
3450 static void
3451 logPointParameterivNV (GLenum      pname,
3452                        const GLint *params)
3453 {
3454     fprintf (logFp, "glPointParameterivNV (0x%x, %p)\n", pname, params);
3455     (*nativeRenderTable->PointParameterivNV) (pname, params);
3456 }
3457
3458
3459 /* GL_EXT_stencil_two_side */
3460
3461 static void
3462 logActiveStencilFaceEXT (GLenum face)
3463 {
3464     fprintf (logFp, "glActiveStencilFaceEXT (0x%x)\n", face);
3465     (*nativeRenderTable->ActiveStencilFaceEXT) (face);
3466 }
3467
3468
3469 /* GL_EXT_framebuffer_object */
3470
3471 static GLboolean
3472 logIsRenderbufferEXT (GLuint renderbuffer)
3473 {
3474     fprintf (logFp, "glIsRenderbufferEXT (%d)\n", renderbuffer);
3475     return (*nativeRenderTable->IsRenderbufferEXT) (renderbuffer);
3476 }
3477
3478 static void
3479 logBindRenderbufferEXT (GLenum target,
3480                         GLuint renderbuffer)
3481 {
3482     fprintf (logFp, "glBindRenderbufferEXT (0x%x, %d)\n",
3483              target, renderbuffer);
3484     (*nativeRenderTable->BindRenderbufferEXT) (target, renderbuffer);
3485 }
3486
3487 static void
3488 logDeleteRenderbuffersEXT (GLsizei      n,
3489                            const GLuint *renderbuffers)
3490 {
3491     fprintf (logFp, "glDeleteRenderbuffersEXT (%d, %p)\n", n, renderbuffers);
3492     (*nativeRenderTable->DeleteRenderbuffersEXT) (n, renderbuffers);
3493 }
3494
3495 static void
3496 logGenRenderbuffersEXT (GLsizei n,
3497                         GLuint  *renderbuffers)
3498 {
3499     fprintf (logFp, "glGenRenderbuffersEXT (%d, %p)\n", n, renderbuffers);
3500     (*nativeRenderTable->GenRenderbuffersEXT) (n, renderbuffers);
3501 }
3502
3503 static void
3504 logRenderbufferStorageEXT (GLenum  target,
3505                            GLenum  internalformat,
3506                            GLsizei width,
3507                            GLsizei height)
3508 {
3509     fprintf (logFp, "glRenderbufferStorageEXT (0x%x, 0x%x, %d, %d)\n",
3510              target, internalformat, width, height);
3511     (*nativeRenderTable->RenderbufferStorageEXT) (target,
3512                                                   internalformat,
3513                                                   width, height);
3514 }
3515
3516 static void
3517 logGetRenderbufferParameterivEXT (GLenum target,
3518                                   GLenum pname,
3519                                   GLint  *params)
3520 {
3521     fprintf (logFp, "glGetRenderbufferParameterivEXT (0x%x, 0x%x, %p)\n",
3522              target, pname, params);
3523     (*nativeRenderTable->GetRenderbufferParameterivEXT) (target,
3524                                                          pname,
3525                                                          params);
3526 }
3527
3528 static GLboolean
3529 logIsFramebufferEXT (GLuint framebuffer)
3530 {
3531     fprintf (logFp, "glIsFramebufferEXT (%d)\n", framebuffer);
3532     return (*nativeRenderTable->IsFramebufferEXT) (framebuffer);
3533 }
3534
3535 static void
3536 logBindFramebufferEXT (GLenum target,
3537                        GLuint framebuffer)
3538 {
3539     fprintf (logFp, "glBindFramebufferEXT (0x%x, %d)\n", target, framebuffer);
3540     (*nativeRenderTable->BindFramebufferEXT) (target, framebuffer);
3541 }
3542
3543 static void
3544 logDeleteFramebuffersEXT (GLsizei      n,
3545                           const GLuint *framebuffers)
3546 {
3547     fprintf (logFp, "glDeleteFramebuffersEXT (%d, %p)\n", n, framebuffers);
3548     (*nativeRenderTable->DeleteFramebuffersEXT) (n, framebuffers);
3549 }
3550
3551 static void
3552 logGenFramebuffersEXT (GLsizei n,
3553                        GLuint  *framebuffers)
3554 {
3555     fprintf (logFp, "glGenFramebuffersEXT (%d, %p)\n", n, framebuffers);
3556     (*nativeRenderTable->GenFramebuffersEXT) (n, framebuffers);
3557 }
3558
3559 static GLenum
3560 logCheckFramebufferStatusEXT (GLenum target)
3561 {
3562     fprintf (logFp, "glCheckFramebufferStatusEXT (0x%x)\n", target);
3563     return (*nativeRenderTable->CheckFramebufferStatusEXT) (target);
3564 }
3565
3566 static void
3567 logFramebufferTexture1DEXT (GLenum target,
3568                             GLenum attachment,
3569                             GLenum textarget,
3570                             GLuint texture,
3571                             GLint  level)
3572 {
3573     fprintf (logFp, "glFramebufferTexture1DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n",
3574              target, attachment, textarget, texture, level);
3575     (*nativeRenderTable->FramebufferTexture1DEXT) (target, attachment,
3576                                                    textarget, texture,
3577                                                    level);
3578 }
3579
3580 static void
3581 logFramebufferTexture2DEXT (GLenum target,
3582                             GLenum attachment,
3583                             GLenum textarget,
3584                             GLuint texture,
3585                             GLint  level)
3586 {
3587     fprintf (logFp, "glFramebufferTexture2DEXT (0x%x, 0x%x, 0x%x, %d, %d)\n",
3588              target, attachment, textarget, texture, level);
3589     (*nativeRenderTable->FramebufferTexture2DEXT) (target, attachment,
3590                                                    textarget, texture,
3591                                                    level);
3592 }
3593
3594 static void
3595 logFramebufferTexture3DEXT (GLenum target,
3596                             GLenum attachment,
3597                             GLenum textarget,
3598                             GLuint texture,
3599                             GLint  level,
3600                             GLint  zoffset)
3601 {
3602     fprintf (logFp, "glFramebufferTexture3DEXT (0x%x, 0x%x, 0x%x, "
3603              "%d, %d, %d)\n", target, attachment, textarget, texture,
3604              level, zoffset);
3605     (*nativeRenderTable->FramebufferTexture3DEXT) (target, attachment,
3606                                                    textarget, texture,
3607                                                    level, zoffset);
3608 }
3609
3610 static void
3611 logFramebufferRenderbufferEXT (GLenum target,
3612                                GLenum attachment,
3613                                GLenum buffertarget,
3614                                GLuint renderbuffer)
3615 {
3616     fprintf (logFp, "glFramebufferRenderbufferEXT (0x%x, 0x%x, 0x%x, %d)\n",
3617              target, attachment, buffertarget, renderbuffer);
3618     (*nativeRenderTable->FramebufferRenderbufferEXT) (target,
3619                                                       attachment,
3620                                                       buffertarget,
3621                                                       renderbuffer);
3622 }
3623
3624 static void
3625 logGetFramebufferAttachmentParameterivEXT (GLenum target,
3626                                            GLenum attach,
3627                                            GLenum pname,
3628                                            GLint  *params)
3629 {
3630     fprintf (logFp, "glGetFramebufferAttachmentParameterivEXT (0x%x, "
3631              "0x%x, 0x%x, %p)\n", target, attach, pname, params);
3632     (*nativeRenderTable->GetFramebufferAttachmentParameterivEXT) (target,
3633                                                                   attach,
3634                                                                   pname,
3635                                                                   params);
3636 }
3637
3638 static void
3639 logGenerateMipmapEXT (GLenum target)
3640 {
3641     fprintf (logFp, "glGenerateMipmapEXT (0x%x)\n", target);
3642     (*nativeRenderTable->GenerateMipmapEXT) (target);
3643 }
3644
3645 static struct _glapi_table __logRenderTable = {
3646     logNewList,
3647     logEndList,
3648     logCallList,
3649     logCallLists,
3650     logDeleteLists,
3651     logGenLists,
3652     logListBase,
3653     logBegin,
3654     logBitmap,
3655     0, /* glColor3b */
3656     logColor3bv,
3657     0, /* glColor3d */
3658     logColor3dv,
3659     0, /* glColor3f */
3660     logColor3fv,
3661     0, /* glColor3i */
3662     logColor3iv,
3663     0, /* glColor3s */
3664     logColor3sv,
3665     0, /* glColor3ub */
3666     logColor3ubv,
3667     0, /* glColor3ui */
3668     logColor3uiv,
3669     0, /* glColor3us */
3670     logColor3usv,
3671     0, /* glColor4b */
3672     logColor4bv,
3673     0, /* glColor4d */
3674     logColor4dv,
3675     0, /* glColor4f */
3676     logColor4fv,
3677     0, /* glColor4i */
3678     logColor4iv,
3679     0, /* glColor4s */
3680     logColor4sv,
3681     0, /* glColor4ub */
3682     logColor4ubv,
3683     0, /* glColor4ui */
3684     logColor4uiv,
3685     0, /* glColor4us */
3686     logColor4usv,
3687     0, /* glEdgeFlag */
3688     logEdgeFlagv,
3689     logEnd,
3690     0, /* glIndexd */
3691     logIndexdv,
3692     0, /* glIndexf */
3693     logIndexfv,
3694     0, /* glIndexi */
3695     logIndexiv,
3696     0, /* glIndexs */
3697     logIndexsv,
3698     0, /* glNormal3b */
3699     logNormal3bv,
3700     0, /* glNormal3d */
3701     logNormal3dv,
3702     0, /* glNormal3f */
3703     logNormal3fv,
3704     0, /* glNormal3i */
3705     logNormal3iv,
3706     0, /* glNormal3s */
3707     logNormal3sv,
3708     0, /* glRasterPos2d */
3709     logRasterPos2dv,
3710     0, /* glRasterPos2f */
3711     logRasterPos2fv,
3712     0, /* glRasterPos2i */
3713     logRasterPos2iv,
3714     0, /* glRasterPos2s */
3715     logRasterPos2sv,
3716     0, /* glRasterPos3d */
3717     logRasterPos3dv,
3718     0, /* glRasterPos3f */
3719     logRasterPos3fv,
3720     0, /* glRasterPos3i */
3721     logRasterPos3iv,
3722     0, /* glRasterPos3s */
3723     logRasterPos3sv,
3724     0, /* glRasterPos4d */
3725     logRasterPos4dv,
3726     0, /* glRasterPos4f */
3727     logRasterPos4fv,
3728     0, /* glRasterPos4i */
3729     logRasterPos4iv,
3730     0, /* glRasterPos4s */
3731     logRasterPos4sv,
3732     0, /* glRectd */
3733     logRectdv,
3734     0, /* glRectf */
3735     logRectfv,
3736     0, /* glRecti */
3737     logRectiv,
3738     0, /* glRects */
3739     logRectsv,
3740     0, /* glTexCoord1d */
3741     logTexCoord1dv,
3742     0, /* glTexCoord1f */
3743     logTexCoord1fv,
3744     0, /* glTexCoord1i */
3745     logTexCoord1iv,
3746     0, /* glTexCoord1s */
3747     logTexCoord1sv,
3748     0, /* glTexCoord2d */
3749     logTexCoord2dv,
3750     0, /* glTexCoord2f */
3751     logTexCoord2fv,
3752     0, /* glTexCoord2i */
3753     logTexCoord2iv,
3754     0, /* glTexCoord2s */
3755     logTexCoord2sv,
3756     0, /* glTexCoord3d */
3757     logTexCoord3dv,
3758     0, /* glTexCoord3f */
3759     logTexCoord3fv,
3760     0, /* glTexCoord3i */
3761     logTexCoord3iv,
3762     0, /* glTexCoord3s */
3763     logTexCoord3sv,
3764     0, /* glTexCoord4d */
3765     logTexCoord4dv,
3766     0, /* glTexCoord4f */
3767     logTexCoord4fv,
3768     0, /* glTexCoord4i */
3769     logTexCoord4iv,
3770     0, /* glTexCoord4s */
3771     logTexCoord4sv,
3772     0, /* glVertex2d */
3773     logVertex2dv,
3774     0, /* glVertex2f */
3775     logVertex2fv,
3776     0, /* glVertex2i */
3777     logVertex2iv,
3778     0, /* glVertex2s */
3779     logVertex2sv,
3780     0, /* glVertex3d */
3781     logVertex3dv,
3782     0, /* glVertex3f */
3783     logVertex3fv,
3784     0, /* glVertex3i */
3785     logVertex3iv,
3786     0, /* glVertex3s */
3787     logVertex3sv,
3788     0, /* glVertex4d */
3789     logVertex4dv,
3790     0, /* glVertex4f */
3791     logVertex4fv,
3792     0, /* glVertex4i */
3793     logVertex4iv,
3794     0, /* glVertex4s */
3795     logVertex4sv,
3796     logClipPlane,
3797     logColorMaterial,
3798     logCullFace,
3799     logFogf,
3800     logFogfv,
3801     logFogi,
3802     logFogiv,
3803     logFrontFace,
3804     logHint,
3805     logLightf,
3806     logLightfv,
3807     logLighti,
3808     logLightiv,
3809     logLightModelf,
3810     logLightModelfv,
3811     logLightModeli,
3812     logLightModeliv,
3813     logLineStipple,
3814     logLineWidth,
3815     logMaterialf,
3816     logMaterialfv,
3817     logMateriali,
3818     logMaterialiv,
3819     logPointSize,
3820     logPolygonMode,
3821     logPolygonStipple,
3822     logScissor,
3823     logShadeModel,
3824     logTexParameterf,
3825     logTexParameterfv,
3826     logTexParameteri,
3827     logTexParameteriv,
3828     logTexImage1D,
3829     logTexImage2D,
3830     logTexEnvf,
3831     logTexEnvfv,
3832     logTexEnvi,
3833     logTexEnviv,
3834     logTexGend,
3835     logTexGendv,
3836     logTexGenf,
3837     logTexGenfv,
3838     logTexGeni,
3839     logTexGeniv,
3840     logFeedbackBuffer,
3841     logSelectBuffer,
3842     logRenderMode,
3843     logInitNames,
3844     logLoadName,
3845     logPassThrough,
3846     logPopName,
3847     logPushName,
3848     logDrawBuffer,
3849     logClear,
3850     logClearAccum,
3851     logClearIndex,
3852     logClearColor,
3853     logClearStencil,
3854     logClearDepth,
3855     logStencilMask,
3856     logColorMask,
3857     logDepthMask,
3858     logIndexMask,
3859     logAccum,
3860     logDisable,
3861     logEnable,
3862     logFinish,
3863     logFlush,
3864     logPopAttrib,
3865     logPushAttrib,
3866     logMap1d,
3867     logMap1f,
3868     logMap2d,
3869     logMap2f,
3870     logMapGrid1d,
3871     logMapGrid1f,
3872     logMapGrid2d,
3873     logMapGrid2f,
3874     0, /* glEvalCoord1d */
3875     logEvalCoord1dv,
3876     0, /* glEvalCoord1f */
3877     logEvalCoord1fv,
3878     0, /* glEvalCoord2d */
3879     logEvalCoord2dv,
3880     0, /* glEvalCoord2f */
3881     logEvalCoord2fv,
3882     logEvalMesh1,
3883     logEvalPoint1,
3884     logEvalMesh2,
3885     logEvalPoint2,
3886     logAlphaFunc,
3887     logBlendFunc,
3888     logLogicOp,
3889     logStencilFunc,
3890     logStencilOp,
3891     logDepthFunc,
3892     logPixelZoom,
3893     logPixelTransferf,
3894     logPixelTransferi,
3895     logPixelStoref,
3896     logPixelStorei,
3897     logPixelMapfv,
3898     logPixelMapuiv,
3899     logPixelMapusv,
3900     logReadBuffer,
3901     logCopyPixels,
3902     logReadPixels,
3903     logDrawPixels,
3904     logGetBooleanv,
3905     logGetClipPlane,
3906     logGetDoublev,
3907     logGetError,
3908     logGetFloatv,
3909     logGetIntegerv,
3910     logGetLightfv,
3911     logGetLightiv,
3912     logGetMapdv,
3913     logGetMapfv,
3914     logGetMapiv,
3915     logGetMaterialfv,
3916     logGetMaterialiv,
3917     logGetPixelMapfv,
3918     logGetPixelMapuiv,
3919     logGetPixelMapusv,
3920     logGetPolygonStipple,
3921     logGetString,
3922     logGetTexEnvfv,
3923     logGetTexEnviv,
3924     logGetTexGendv,
3925     logGetTexGenfv,
3926     logGetTexGeniv,
3927     logGetTexImage,
3928     logGetTexParameterfv,
3929     logGetTexParameteriv,
3930     logGetTexLevelParameterfv,
3931     logGetTexLevelParameteriv,
3932     logIsEnabled,
3933     logIsList,
3934     logDepthRange,
3935     logFrustum,
3936     logLoadIdentity,
3937     logLoadMatrixf,
3938     logLoadMatrixd,
3939     logMatrixMode,
3940     logMultMatrixf,
3941     logMultMatrixd,
3942     logOrtho,
3943     logPopMatrix,
3944     logPushMatrix,
3945     logRotated,
3946     logRotatef,
3947     logScaled,
3948     logScalef,
3949     logTranslated,
3950     logTranslatef,
3951     logViewport,
3952     logArrayElement,
3953     logBindTexture,
3954     logColorPointer,
3955     logDisableClientState,
3956     logDrawArrays,
3957     logDrawElements,
3958     logEdgeFlagPointer,
3959     logEnableClientState,
3960     logIndexPointer,
3961     0, /* glIndexub */
3962     logIndexubv,
3963     logInterleavedArrays,
3964     logNormalPointer,
3965     logPolygonOffset,
3966     logTexCoordPointer,
3967     logVertexPointer,
3968     logAreTexturesResident,
3969     logCopyTexImage1D,
3970     logCopyTexImage2D,
3971     logCopyTexSubImage1D,
3972     logCopyTexSubImage2D,
3973     logDeleteTextures,
3974     logGenTextures,
3975     logGetPointerv,
3976     logIsTexture,
3977     logPrioritizeTextures,
3978     logTexSubImage1D,
3979     logTexSubImage2D,
3980     logPopClientAttrib,
3981     logPushClientAttrib,
3982     logBlendColor,
3983     logBlendEquation,
3984     0, /* glDrawRangeElements */
3985     logColorTable,
3986     logColorTableParameterfv,
3987     logColorTableParameteriv,
3988     logCopyColorTable,
3989     logGetColorTable,
3990     logGetColorTableParameterfv,
3991     logGetColorTableParameteriv,
3992     logColorSubTable,
3993     logCopyColorSubTable,
3994     logConvolutionFilter1D,
3995     logConvolutionFilter2D,
3996     logConvolutionParameterf,
3997     logConvolutionParameterfv,
3998     logConvolutionParameteri,
3999     logConvolutionParameteriv,
4000     logCopyConvolutionFilter1D,
4001     logCopyConvolutionFilter2D,
4002     logGetConvolutionFilter,
4003     logGetConvolutionParameterfv,
4004     logGetConvolutionParameteriv,
4005     logGetSeparableFilter,
4006     logSeparableFilter2D,
4007     logGetHistogram,
4008     logGetHistogramParameterfv,
4009     logGetHistogramParameteriv,
4010     logGetMinmax,
4011     logGetMinmaxParameterfv,
4012     logGetMinmaxParameteriv,
4013     logHistogram,
4014     logMinmax,
4015     logResetHistogram,
4016     logResetMinmax,
4017     logTexImage3D,
4018     logTexSubImage3D,
4019     logCopyTexSubImage3D,
4020     logActiveTextureARB,
4021     logClientActiveTextureARB,
4022     0, /* glMultiTexCoord1dARB */
4023     logMultiTexCoord1dvARB,
4024     0, /* glMultiTexCoord1fARB */
4025     logMultiTexCoord1fvARB,
4026     0, /* glMultiTexCoord1iARB */
4027     logMultiTexCoord1ivARB,
4028     0, /* glMultiTexCoord1sARB */
4029     logMultiTexCoord1svARB,
4030     0, /* glMultiTexCoord2dARB */
4031     logMultiTexCoord2dvARB,
4032     0, /* glMultiTexCoord2fARB */
4033     logMultiTexCoord2fvARB,
4034     0, /* glMultiTexCoord2iARB */
4035     logMultiTexCoord2ivARB,
4036     0, /* glMultiTexCoord2sARB */
4037     logMultiTexCoord2svARB,
4038     0, /* glMultiTexCoord3dARB */
4039     logMultiTexCoord3dvARB,
4040     0, /* glMultiTexCoord3fARB */
4041     logMultiTexCoord3fvARB,
4042     0, /* glMultiTexCoord3iARB */
4043     logMultiTexCoord3ivARB,
4044     0, /* glMultiTexCoord3sARB */
4045     logMultiTexCoord3svARB,
4046     0, /* glMultiTexCoord4dARB */
4047     logMultiTexCoord4dvARB,
4048     0, /* glMultiTexCoord4fARB */
4049     logMultiTexCoord4fvARB,
4050     0, /* glMultiTexCoord4iARB */
4051     logMultiTexCoord4ivARB,
4052     0, /* glMultiTexCoord4sARB */
4053     logMultiTexCoord4svARB,
4054     0, /* glLoadTransposeMatrixfARB */
4055     0, /* glLoadTransposeMatrixdARB */
4056     0, /* glMultTransposeMatrixfARB */
4057     0, /* glMultTransposeMatrixdARB */
4058     logSampleCoverageARB,
4059     0, /* glDrawBuffersARB */
4060     0, /* glPolygonOffsetEXT */
4061     0, /* glGetTexFilterFuncSGIS */
4062     0, /* glTexFilterFuncSGIS */
4063     0, /* glGetHistogramEXT */
4064     0, /* glGetHistogramParameterfvEXT */
4065     0, /* glGetHistogramParameterivEXT */
4066     0, /* glGetMinmaxEXT */
4067     0, /* glGetMinmaxParameterfvEXT */
4068     0, /* glGetMinmaxParameterivEXT */
4069     0, /* glGetConvolutionFilterEXT */
4070     0, /* glGetConvolutionParameterfvEXT */
4071     0, /* glGetConvolutionParameterivEXT */
4072     0, /* glGetSeparableFilterEXT */
4073     0, /* glGetColorTableSGI */
4074     0, /* glGetColorTableParameterfvSGI */
4075     0, /* glGetColorTableParameterivSGI */
4076     0, /* glPixelTexGenSGIX */
4077     0, /* glPixelTexGenParameteriSGIS */
4078     0, /* glPixelTexGenParameterivSGIS */
4079     0, /* glPixelTexGenParameterfSGIS */
4080     0, /* glPixelTexGenParameterfvSGIS */
4081     0, /* glGetPixelTexGenParameterivSGIS */
4082     0, /* glGetPixelTexGenParameterfvSGIS */
4083     0, /* glTexImage4DSGIS */
4084     0, /* glTexSubImage4DSGIS */
4085     logAreTexturesResidentEXT,
4086     logGenTexturesEXT,
4087     logIsTextureEXT,
4088     0, /* glDetailTexFuncSGIS */
4089     0, /* glGetDetailTexFuncSGIS */
4090     0, /* glSharpenTexFuncSGIS */
4091     0, /* glGetSharpenTexFuncSGIS */
4092     logSampleMaskSGIS,
4093     logSamplePatternSGIS,
4094     0, /* glColorPointerEXT */
4095     0, /* glEdgeFlagPointerEXT */
4096     0, /* glIndexPointerEXT */
4097     0, /* glNormalPointerEXT */
4098     0, /* glTexCoordPointerEXT */
4099     0, /* glVertexPointerEXT */
4100     0, /* glSpriteParameterfSGIX */
4101     0, /* glSpriteParameterfvSGIX */
4102     0, /* glSpriteParameteriSGIX */
4103     0, /* glSpriteParameterivSGIX */
4104     logPointParameterfEXT,
4105     logPointParameterfvEXT,
4106     0, /* glGetInstrumentsSGIX */
4107     0, /* glInstrumentsBufferSGIX */
4108     0, /* glPollInstrumentsSGIX */
4109     0, /* glReadInstrumentsSGIX */
4110     0, /* glStartInstrumentsSGIX */
4111     0, /* glStopInstrumentsSGIX */
4112     0, /* glFrameZoomSGIX */
4113     0, /* glTagSampleBufferSGIX */
4114     0, /* glReferencePlaneSGIX */
4115     0, /* glFlushRasterSGIX */
4116     0, /* glGetListParameterfvSGIX */
4117     0, /* glGetListParameterivSGIX */
4118     0, /* glListParameterfSGIX */
4119     0, /* glListParameterfvSGIX */
4120     0, /* glListParameteriSGIX */
4121     0, /* glListParameterivSGIX */
4122     0, /* glFragmentColorMaterialSGIX */
4123     0, /* glFragmentLightfSGIX */
4124     0, /* glFragmentLightfvSGIX */
4125     0, /* glFragmentLightiSGIX */
4126     0, /* glFragmentLightivSGIX */
4127     0, /* glFragmentLightModelfSGIX */
4128     0, /* glFragmentLightModelfvSGIX */
4129     0, /* glFragmentLightModeliSGIX */
4130     0, /* glFragmentLightModelivSGIX */
4131     0, /* glFragmentMaterialfSGIX */
4132     0, /* glFragmentMaterialfvSGIX */
4133     0, /* glFragmentMaterialiSGIX */
4134     0, /* glFragmentMaterialivSGIX */
4135     0, /* glGetFragmentLightfvSGIX */
4136     0, /* glGetFragmentLightivSGIX */
4137     0, /* glGetFragmentMaterialfvSGIX */
4138     0, /* glGetFragmentMaterialivSGIX */
4139     0, /* glLightEnviSGIX */
4140     0, /* glVertexWeightfEXT */
4141     0, /* glVertexWeightfvEXT */
4142     0, /* glVertexWeightPointerEXT */
4143     0, /* glFlushVertexArrayRangeNV */
4144     0, /* glVertexArrayRangeNV */
4145     0, /* glCombinerParameterfvNV */
4146     0, /* glCombinerParameterfNV */
4147     0, /* glCombinerParameterivNV */
4148     0, /* glCombinerParameteriNV */
4149     0, /* glCombinerInputNV */
4150     0, /* glCombinerOutputNV */
4151     0, /* glFinalCombinerInputNV */
4152     0, /* glGetCombinerInputParameterfvNV */
4153     0, /* glGetCombinerInputParameterivNV */
4154     0, /* glGetCombinerOutputParameterfvNV */
4155     0, /* glGetCombinerOutputParameterivNV */
4156     0, /* glGetFinalCombinerInputParameterfvNV */
4157     0, /* glGetFinalCombinerInputParameterivNV */
4158     0, /* glResizeBuffersMESA */
4159     0, /* glWindowPos2dMESA */
4160     0, /* glWindowPos2dvMESA */
4161     0, /* glWindowPos2fMESA */
4162     0, /* glWindowPos2fvMESA */
4163     0, /* glWindowPos2iMESA */
4164     0, /* glWindowPos2ivMESA */
4165     0, /* glWindowPos2sMESA */
4166     0, /* glWindowPos2svMESA */
4167     0, /* glWindowPos3dMESA */
4168     0, /* glWindowPos3dvMESA */
4169     logWindowPos3fMESA,
4170     0, /* glWindowPos3fvMESA */
4171     0, /* glWindowPos3iMESA */
4172     0, /* glWindowPos3ivMESA */
4173     0, /* glWindowPos3sMESA */
4174     0, /* glWindowPos3svMESA */
4175     0, /* glWindowPos4dMESA */
4176     0, /* glWindowPos4dvMESA */
4177     0, /* glWindowPos4fMESA */
4178     0, /* glWindowPos4fvMESA */
4179     0, /* glWindowPos4iMESA */
4180     0, /* glWindowPos4ivMESA */
4181     0, /* glWindowPos4sMESA */
4182     0, /* glWindowPos4svMESA */
4183     logBlendFuncSeparateEXT,
4184     0, /* glIndexMaterialEXT */
4185     0, /* glIndexFuncEXT */
4186     0, /* glLockArraysEXT */
4187     0, /* glUnlockArraysEXT */
4188     0, /* glCullParameterdvEXT */
4189     0, /* glCullParameterfvEXT */
4190     0, /* glHintPGI */
4191     0, /* glFogCoordfEXT */
4192     logFogCoordfvEXT,
4193     0, /* glFogCoorddEXT */
4194     logFogCoorddvEXT,
4195     logFogCoordPointerEXT,
4196     0, /* glGetColorTableEXT */
4197     0, /* glGetColorTableParameterivEXT */
4198     0, /* glGetColorTableParameterfvEXT */
4199     0, /* glTbufferMask3DFX */
4200     0, /* glCompressedTexImage3DARB */
4201     0, /* glCompressedTexImage2DARB */
4202     0, /* glCompressedTexImage1DARB */
4203     0, /* glCompressedTexSubImage3DARB */
4204     0, /* glCompressedTexSubImage2DARB */
4205     0, /* glCompressedTexSubImage1DARB */
4206     0, /* glGetCompressedTexImageARB */
4207     0, /* glSecondaryColor3bEXT */
4208     logSecondaryColor3bvEXT,
4209     0, /* glSecondaryColor3dEXT */
4210     logSecondaryColor3dvEXT,
4211     0, /* glSecondaryColor3fEXT */
4212     logSecondaryColor3fvEXT,
4213     0, /* glSecondaryColor3iEXT */
4214     logSecondaryColor3ivEXT,
4215     0, /* glSecondaryColor3sEXT */
4216     logSecondaryColor3svEXT,
4217     0, /* glSecondaryColor3ubEXT */
4218     logSecondaryColor3ubvEXT,
4219     0, /* glSecondaryColor3uiEXT */
4220     logSecondaryColor3uivEXT,
4221     0, /* glSecondaryColor3usEXT */
4222     logSecondaryColor3usvEXT,
4223     logSecondaryColorPointerEXT,
4224     0, /* glAreProgramsResidentNV */
4225     0, /* glBindProgramNV */
4226     0, /* glDeleteProgramsNV */
4227     0, /* glExecuteProgramNV */
4228     0, /* glGenProgramsNV */
4229     0, /* glGetProgramParameterdvNV */
4230     0, /* glGetProgramParameterfvNV */
4231     0, /* glGetProgramivNV */
4232     0, /* glGetProgramStringNV */
4233     0, /* glGetTrackMatrixivNV */
4234     0, /* glGetVertexAttribdvARB */
4235     0, /* glGetVertexAttribfvARB */
4236     0, /* glGetVertexAttribivARB */
4237     0, /* glGetVertexAttribPointervNV */
4238     0, /* glIsProgramNV */
4239     0, /* glLoadProgramNV */
4240     0, /* glProgramParameter4dNV */
4241     0, /* glProgramParameter4dvNV */
4242     0, /* glProgramParameter4fNV */
4243     0, /* glProgramParameter4fvNV */
4244     0, /* glProgramParameters4dvNV */
4245     0, /* glProgramParameters4fvNV */
4246     0, /* glRequestResidentProgramsNV */
4247     0, /* glTrackMatrixNV */
4248     0, /* glVertexAttribPointerNV */
4249     0, /* glVertexAttrib1dARB */
4250     0, /* glVertexAttrib1dvARB */
4251     0, /* glVertexAttrib1fARB */
4252     0, /* glVertexAttrib1fvARB */
4253     0, /* glVertexAttrib1sARB */
4254     0, /* glVertexAttrib1svARB */
4255     0, /* glVertexAttrib2dARB */
4256     0, /* glVertexAttrib2dvARB */
4257     0, /* glVertexAttrib2fARB */
4258     0, /* glVertexAttrib2fvARB */
4259     0, /* glVertexAttrib2sARB */
4260     0, /* glVertexAttrib2svARB */
4261     0, /* glVertexAttrib3dARB */
4262     0, /* glVertexAttrib3dvARB */
4263     0, /* glVertexAttrib3fARB */
4264     0, /* glVertexAttrib3fvARB */
4265     0, /* glVertexAttrib3sARB */
4266     0, /* glVertexAttrib3svARB */
4267     0, /* glVertexAttrib4dARB */
4268     0, /* glVertexAttrib4dvARB */
4269     0, /* glVertexAttrib4fARB */
4270     0, /* glVertexAttrib4fvARB */
4271     0, /* glVertexAttrib4sARB */
4272     0, /* glVertexAttrib4svARB */
4273     0, /* glVertexAttrib4NubARB */
4274     0, /* glVertexAttrib4NubvARB */
4275     0, /* glVertexAttribs1dvNV */
4276     0, /* glVertexAttribs1fvNV */
4277     0, /* glVertexAttribs1svNV */
4278     0, /* glVertexAttribs2dvNV */
4279     0, /* glVertexAttribs2fvNV */
4280     0, /* glVertexAttribs2svNV */
4281     0, /* glVertexAttribs3dvNV */
4282     0, /* glVertexAttribs3fvNV */
4283     0, /* glVertexAttribs3svNV */
4284     0, /* glVertexAttribs4dvNV */
4285     0, /* glVertexAttribs4fvNV */
4286     0, /* glVertexAttribs4svNV */
4287     0, /* glVertexAttribs4ubvNV */
4288     logPointParameteriNV,
4289     logPointParameterivNV,
4290     0, /* glMultiDrawArraysEXT */
4291     0, /* glMultiDrawElementsEXT */
4292     logActiveStencilFaceEXT,
4293     0, /* glDeleteFencesNV */
4294     0, /* glGenFencesNV */
4295     0, /* glIsFenceNV */
4296     0, /* glTestFenceNV */
4297     0, /* glGetFenceivNV */
4298     0, /* glFinishFenceNV */
4299     0, /* glSetFenceNV */
4300     0, /* glVertexAttrib4bvARB */
4301     0, /* glVertexAttrib4ivARB */
4302     0, /* glVertexAttrib4ubvARB */
4303     0, /* glVertexAttrib4usvARB */
4304     0, /* glVertexAttrib4uivARB */
4305     0, /* glVertexAttrib4NbvARB */
4306     0, /* glVertexAttrib4NsvARB */
4307     0, /* glVertexAttrib4NivARB */
4308     0, /* glVertexAttrib4NusvARB */
4309     0, /* glVertexAttrib4NuivARB */
4310     0, /* glVertexAttribPointerARB */
4311     0, /* glEnableVertexAttribArrayARB */
4312     0, /* glDisableVertexAttribArrayARB */
4313     0, /* glProgramStringARB */
4314     0, /* glProgramEnvParameter4dARB */
4315     0, /* glProgramEnvParameter4dvARB */
4316     0, /* glProgramEnvParameter4fARB */
4317     0, /* glProgramEnvParameter4fvARB */
4318     0, /* glProgramLocalParameter4dARB */
4319     0, /* glProgramLocalParameter4dvARB */
4320     0, /* glProgramLocalParameter4fARB */
4321     0, /* glProgramLocalParameter4fvARB */
4322     0, /* glGetProgramEnvParameterdvARB */
4323     0, /* glGetProgramEnvParameterfvARB */
4324     0, /* glGetProgramLocalParameterdvARB */
4325     0, /* glGetProgramLocalParameterfvARB */
4326     0, /* glGetProgramivARB */
4327     0, /* glGetProgramStringARB */
4328     0, /* glProgramNamedParameter4fNV */
4329     0, /* glProgramNamedParameter4dNV */
4330     0, /* glProgramNamedParameter4fvNV */
4331     0, /* glProgramNamedParameter4dvNV */
4332     0, /* glGetProgramNamedParameterfvNV */
4333     0, /* glGetProgramNamedParameterdvNV */
4334     0, /* glBindBufferARB */
4335     0, /* glBufferDataARB */
4336     0, /* glBufferSubDataARB */
4337     0, /* glDeleteBuffersARB */
4338     0, /* glGenBuffersARB */
4339     0, /* glGetBufferParameterivARB */
4340     0, /* glGetBufferPointervARB */
4341     0, /* glGetBufferSubDataARB */
4342     0, /* glIsBufferARB */
4343     0, /* glMapBufferARB */
4344     0, /* glUnmapBufferARB */
4345     0, /* glDepthBoundsEXT */
4346     0, /* glGenQueriesARB */
4347     0, /* glDeleteQueriesARB */
4348     0, /* glIsQueryARB */
4349     0, /* glBeginQueryARB */
4350     0, /* glEndQueryARB */
4351     0, /* glGetQueryivARB */
4352     0, /* glGetQueryObjectivARB */
4353     0, /* glGetQueryObjectuivARB */
4354     0, /* glMultiModeDrawArraysIBM */
4355     0, /* glMultiModeDrawElementsIBM */
4356     0, /* glBlendEquationSeparateEXT */
4357     0, /* glDeleteObjectARB */
4358     0, /* glGetHandleARB */
4359     0, /* glDetachObjectARB */
4360     0, /* glCreateShaderObjectARB */
4361     0, /* glShaderSourceARB */
4362     0, /* glCompileShaderARB */
4363     0, /* glCreateProgramObjectARB */
4364     0, /* glAttachObjectARB */
4365     0, /* glLinkProgramARB */
4366     0, /* glUseProgramObjectARB */
4367     0, /* glValidateProgramARB */
4368     0, /* glUniform1fARB */
4369     0, /* glUniform2fARB */
4370     0, /* glUniform3fARB */
4371     0, /* glUniform4fARB */
4372     0, /* glUniform1iARB */
4373     0, /* glUniform2iARB */
4374     0, /* glUniform3iARB */
4375     0, /* glUniform4iARB */
4376     0, /* glUniform1fvARB */
4377     0, /* glUniform2fvARB */
4378     0, /* glUniform3fvARB */
4379     0, /* glUniform4fvARB */
4380     0, /* glUniform1ivARB */
4381     0, /* glUniform2ivARB */
4382     0, /* glUniform3ivARB */
4383     0, /* glUniform4ivARB */
4384     0, /* glUniformMatrix2fvARB */
4385     0, /* glUniformMatrix3fvARB */
4386     0, /* glUniformMatrix4fvARB */
4387     0, /* glGetObjectParameterfvARB */
4388     0, /* glGetObjectParameterivARB */
4389     0, /* glGetInfoLogARB */
4390     0, /* glGetAttachedObjectsARB */
4391     0, /* glGetUniformLocationARB */
4392     0, /* glGetActiveUniformARB */
4393     0, /* glGetUniformfvARB */
4394     0, /* glGetUniformivARB */
4395     0, /* glGetShaderSourceARB */
4396     0, /* glBindAttribLocationARB */
4397     0, /* glGetActiveAttribARB */
4398     0, /* glGetAttribLocationARB */
4399     0, /* glGetVertexAttribdvNV */
4400     0, /* glGetVertexAttribfvNV */
4401     0, /* glGetVertexAttribivNV */
4402     0, /* glVertexAttrib1dNV */
4403     0, /* glVertexAttrib1dvNV */
4404     0, /* glVertexAttrib1fNV */
4405     0, /* glVertexAttrib1fvNV */
4406     0, /* glVertexAttrib1sNV */
4407     0, /* glVertexAttrib1svNV */
4408     0, /* glVertexAttrib2dNV */
4409     0, /* glVertexAttrib2dvNV */
4410     0, /* glVertexAttrib2fNV */
4411     0, /* glVertexAttrib2fvNV */
4412     0, /* glVertexAttrib2sNV */
4413     0, /* glVertexAttrib2svNV */
4414     0, /* glVertexAttrib3dNV */
4415     0, /* glVertexAttrib3dvNV */
4416     0, /* glVertexAttrib3fNV */
4417     0, /* glVertexAttrib3fvNV */
4418     0, /* glVertexAttrib3sNV */
4419     0, /* glVertexAttrib3svNV */
4420     0, /* glVertexAttrib4dNV */
4421     0, /* glVertexAttrib4dvNV */
4422     0, /* glVertexAttrib4fNV */
4423     0, /* glVertexAttrib4fvNV */
4424     0, /* glVertexAttrib4sNV */
4425     0, /* glVertexAttrib4svNV */
4426     0, /* glVertexAttrib4ubNV */
4427     0, /* glVertexAttrib4ubvNV */
4428     0, /* glGenFragmentShadersATI */
4429     0, /* glBindFragmentShaderATI */
4430     0, /* glDeleteFragmentShaderATI */
4431     0, /* glBeginFragmentShaderATI */
4432     0, /* glEndFragmentShaderATI */
4433     0, /* glPassTexCoordATI */
4434     0, /* glSampleMapATI */
4435     0, /* glColorFragmentOp1ATI */
4436     0, /* glColorFragmentOp2ATI */
4437     0, /* glColorFragmentOp3ATI */
4438     0, /* glAlphaFragmentOp1ATI */
4439     0, /* glAlphaFragmentOp2ATI */
4440     0, /* glAlphaFragmentOp3ATI */
4441     0, /* glSetFragmentShaderConstantATI */
4442     logIsRenderbufferEXT,
4443     logBindRenderbufferEXT,
4444     logDeleteRenderbuffersEXT,
4445     logGenRenderbuffersEXT,
4446     logRenderbufferStorageEXT,
4447     logGetRenderbufferParameterivEXT,
4448     logIsFramebufferEXT,
4449     logBindFramebufferEXT,
4450     logDeleteFramebuffersEXT,
4451     logGenFramebuffersEXT,
4452     logCheckFramebufferStatusEXT,
4453     logFramebufferTexture1DEXT,
4454     logFramebufferTexture2DEXT,
4455     logFramebufferTexture3DEXT,
4456     logFramebufferRenderbufferEXT,
4457     logGetFramebufferAttachmentParameterivEXT,
4458     logGenerateMipmapEXT,
4459     0, /* glStencilFuncSeparate */
4460     0, /* glStencilOpSeparate */
4461     0, /* glStencilMaskSeparate */
4462     0, /* glGetQueryObjecti64vEXT */
4463     0  /* glGetQueryObjectui64vEXT */
4464 };
4465
4466 static Bool isCurrent = FALSE;
4467
4468 static void (*flushContextCache) (void);
4469 static void (*setRenderTables)   (struct _glapi_table *table);
4470
4471 static void
4472 GlxLogFlushContextCache (void)
4473 {
4474     if (isCurrent)
4475     {
4476         fprintf (logFp, "LOSE CURRENT\n");
4477         isCurrent = FALSE;
4478     }
4479
4480     (*flushContextCache) ();
4481 }
4482
4483 static void
4484 GlxLogSetRenderTables (struct _glapi_table *table)
4485 {
4486     nativeRenderTable = table;
4487
4488     if (table)
4489     {
4490         fprintf (logFp, "FORCE CURRENT\n");
4491         isCurrent = TRUE;
4492
4493         (*setRenderTables) (&__logRenderTable);
4494     }
4495     else
4496     {
4497         (*setRenderTables) (0);
4498     }
4499 }
4500
4501 void
4502 xglInitGlxLog (void)
4503 {
4504     if (logFp)
4505         return;
4506
4507     if (__xglGLXLogFp)
4508     {
4509         logFp = __xglGLXLogFp;
4510
4511         flushContextCache = __xglGLXFunc.flushContextCache;
4512         setRenderTables   = __xglGLXFunc.setRenderTables;
4513
4514         __xglGLXFunc.flushContextCache = GlxLogFlushContextCache;
4515         __xglGLXFunc.setRenderTables   = GlxLogSetRenderTables;
4516     }
4517 }
4518
4519 #endif