neo/sys/win32/gl_logfuncs.cpp

   1 /*
   2 ===========================================================================
   3
   4 Doom 3 GPL Source Code
   5 Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
   6
   7 This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
   8
   9 Doom 3 Source Code is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 Doom 3 Source Code is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.
  23
  24 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
  25
  26 ===========================================================================
  27 */
  28
  29 static void APIENTRY logAccum(GLenum op, GLfloat value) {
  30         fprintf( tr.logFile, "glAccum %s %g\n", EnumString(op), value );
  31         dllAccum(op, value);
  32 }
  33
  34 static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref) {
  35         fprintf( tr.logFile, "glAlphaFunc %s %g\n", EnumString(func), ref );
  36         dllAlphaFunc(func, ref);
  37 }
  38
  39 static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) {
  40 // unknown type: "const GLuint *" name: "textures"
  41 // unknown type: "GLboolean *" name: "residences"
  42         fprintf( tr.logFile, "glAreTexturesResident %d 'const GLuint * textures' 'GLboolean * residences'\n", n );
  43         return dllAreTexturesResident(n, textures, residences);
  44 }
  45
  46 static void APIENTRY logArrayElement(GLint i) {
  47         fprintf( tr.logFile, "glArrayElement %d\n", i );
  48         dllArrayElement(i);
  49 }
  50
  51 static void APIENTRY logBegin(GLenum mode) {
  52         fprintf( tr.logFile, "glBegin %s\n", EnumString(mode) );
  53         dllBegin(mode);
  54 }
  55
  56 static void APIENTRY logBindTexture(GLenum target, GLuint texture) {
  57         fprintf( tr.logFile, "glBindTexture %s %d\n", EnumString(target), texture );
  58         dllBindTexture(target, texture);
  59 }
  60
  61 static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {
  62 // unknown type: "const GLubyte *" name: "bitmap"
  63         fprintf( tr.logFile, "glBitmap %d %d %g %g %g %g 'const GLubyte * bitmap'\n", width, height, xorig, yorig, xmove, ymove );
  64         dllBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
  65 }
  66
  67 static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor) {
  68         fprintf( tr.logFile, "glBlendFunc %s %s\n", EnumString(sfactor), EnumString(dfactor) );
  69         dllBlendFunc(sfactor, dfactor);
  70 }
  71
  72 static void APIENTRY logCallList(GLuint list) {
  73         fprintf( tr.logFile, "glCallList %d\n", list );
  74         dllCallList(list);
  75 }
  76
  77 static void APIENTRY logCallLists(GLsizei n, GLenum type, const GLvoid *lists) {
  78 // unknown type: "const GLvoid *" name: "lists"
  79         fprintf( tr.logFile, "glCallLists %d %s 'const GLvoid * lists'\n", n, EnumString(type) );
  80         dllCallLists(n, type, lists);
  81 }
  82
  83 static void APIENTRY logClear(GLbitfield mask) {
  84 // unknown type: "GLbitfield" name: "mask"
  85         fprintf( tr.logFile, "glClear 'GLbitfield mask'\n" );
  86         dllClear(mask);
  87 }
  88
  89 static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
  90         fprintf( tr.logFile, "glClearAccum %g %g %g %g\n", red, green, blue, alpha );
  91         dllClearAccum(red, green, blue, alpha);
  92 }
  93
  94 static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
  95         fprintf( tr.logFile, "glClearColor %g %g %g %g\n", red, green, blue, alpha );
  96         dllClearColor(red, green, blue, alpha);
  97 }
  98
  99 static void APIENTRY logClearDepth(GLclampd depth) {
 100 // unknown type: "GLclampd" name: "depth"
 101         fprintf( tr.logFile, "glClearDepth 'GLclampd depth'\n" );
 102         dllClearDepth(depth);
 103 }
 104
 105 static void APIENTRY logClearIndex(GLfloat c) {
 106         fprintf( tr.logFile, "glClearIndex %g\n", c );
 107         dllClearIndex(c);
 108 }
 109
 110 static void APIENTRY logClearStencil(GLint s) {
 111         fprintf( tr.logFile, "glClearStencil %d\n", s );
 112         dllClearStencil(s);
 113 }
 114
 115 static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation) {
 116 // unknown type: "const GLdouble *" name: "equation"
 117         fprintf( tr.logFile, "glClipPlane %s 'const GLdouble * equation'\n", EnumString(plane) );
 118         dllClipPlane(plane, equation);
 119 }
 120
 121 static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue) {
 122         fprintf( tr.logFile, "glColor3b %d %d %d\n", red, green, blue );
 123         dllColor3b(red, green, blue);
 124 }
 125
 126 static void APIENTRY logColor3bv(const GLbyte *v) {
 127 // unknown type: "const GLbyte *" name: "v"
 128         fprintf( tr.logFile, "glColor3bv 'const GLbyte * v'\n" );
 129         dllColor3bv(v);
 130 }
 131
 132 static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue) {
 133         fprintf( tr.logFile, "glColor3d %g %g %g\n", red, green, blue );
 134         dllColor3d(red, green, blue);
 135 }
 136
 137 static void APIENTRY logColor3dv(const GLdouble *v) {
 138 // unknown type: "const GLdouble *" name: "v"
 139         fprintf( tr.logFile, "glColor3dv 'const GLdouble * v'\n" );
 140         dllColor3dv(v);
 141 }
 142
 143 static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue) {
 144         fprintf( tr.logFile, "glColor3f %g %g %g\n", red, green, blue );
 145         dllColor3f(red, green, blue);
 146 }
 147
 148 static void APIENTRY logColor3fv(const GLfloat *v) {
 149 // unknown type: "const GLfloat *" name: "v"
 150         fprintf( tr.logFile, "glColor3fv 'const GLfloat * v'\n" );
 151         dllColor3fv(v);
 152 }
 153
 154 static void APIENTRY logColor3i(GLint red, GLint green, GLint blue) {
 155         fprintf( tr.logFile, "glColor3i %d %d %d\n", red, green, blue );
 156         dllColor3i(red, green, blue);
 157 }
 158
 159 static void APIENTRY logColor3iv(const GLint *v) {
 160 // unknown type: "const GLint *" name: "v"
 161         fprintf( tr.logFile, "glColor3iv 'const GLint * v'\n" );
 162         dllColor3iv(v);
 163 }
 164
 165 static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue) {
 166         fprintf( tr.logFile, "glColor3s %d %d %d\n", red, green, blue );
 167         dllColor3s(red, green, blue);
 168 }
 169
 170 static void APIENTRY logColor3sv(const GLshort *v) {
 171 // unknown type: "const GLshort *" name: "v"
 172         fprintf( tr.logFile, "glColor3sv 'const GLshort * v'\n" );
 173         dllColor3sv(v);
 174 }
 175
 176 static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
 177         fprintf( tr.logFile, "glColor3ub %d %d %d\n", red, green, blue );
 178         dllColor3ub(red, green, blue);
 179 }
 180
 181 static void APIENTRY logColor3ubv(const GLubyte *v) {
 182 // unknown type: "const GLubyte *" name: "v"
 183         fprintf( tr.logFile, "glColor3ubv 'const GLubyte * v'\n" );
 184         dllColor3ubv(v);
 185 }
 186
 187 static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue) {
 188         fprintf( tr.logFile, "glColor3ui %d %d %d\n", red, green, blue );
 189         dllColor3ui(red, green, blue);
 190 }
 191
 192 static void APIENTRY logColor3uiv(const GLuint *v) {
 193 // unknown type: "const GLuint *" name: "v"
 194         fprintf( tr.logFile, "glColor3uiv 'const GLuint * v'\n" );
 195         dllColor3uiv(v);
 196 }
 197
 198 static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue) {
 199         fprintf( tr.logFile, "glColor3us %d %d %d\n", red, green, blue );
 200         dllColor3us(red, green, blue);
 201 }
 202
 203 static void APIENTRY logColor3usv(const GLushort *v) {
 204 // unknown type: "const GLushort *" name: "v"
 205         fprintf( tr.logFile, "glColor3usv 'const GLushort * v'\n" );
 206         dllColor3usv(v);
 207 }
 208
 209 static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
 210         fprintf( tr.logFile, "glColor4b %d %d %d %d\n", red, green, blue, alpha );
 211         dllColor4b(red, green, blue, alpha);
 212 }
 213
 214 static void APIENTRY logColor4bv(const GLbyte *v) {
 215 // unknown type: "const GLbyte *" name: "v"
 216         fprintf( tr.logFile, "glColor4bv 'const GLbyte * v'\n" );
 217         dllColor4bv(v);
 218 }
 219
 220 static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
 221         fprintf( tr.logFile, "glColor4d %g %g %g %g\n", red, green, blue, alpha );
 222         dllColor4d(red, green, blue, alpha);
 223 }
 224
 225 static void APIENTRY logColor4dv(const GLdouble *v) {
 226 // unknown type: "const GLdouble *" name: "v"
 227         fprintf( tr.logFile, "glColor4dv 'const GLdouble * v'\n" );
 228         dllColor4dv(v);
 229 }
 230
 231 static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
 232         fprintf( tr.logFile, "glColor4f %g %g %g %g\n", red, green, blue, alpha );
 233         dllColor4f(red, green, blue, alpha);
 234 }
 235
 236 static void APIENTRY logColor4fv(const GLfloat *v) {
 237 // unknown type: "const GLfloat *" name: "v"
 238         fprintf( tr.logFile, "glColor4fv 'const GLfloat * v'\n" );
 239         dllColor4fv(v);
 240 }
 241
 242 static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
 243         fprintf( tr.logFile, "glColor4i %d %d %d %d\n", red, green, blue, alpha );
 244         dllColor4i(red, green, blue, alpha);
 245 }
 246
 247 static void APIENTRY logColor4iv(const GLint *v) {
 248 // unknown type: "const GLint *" name: "v"
 249         fprintf( tr.logFile, "glColor4iv 'const GLint * v'\n" );
 250         dllColor4iv(v);
 251 }
 252
 253 static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
 254         fprintf( tr.logFile, "glColor4s %d %d %d %d\n", red, green, blue, alpha );
 255         dllColor4s(red, green, blue, alpha);
 256 }
 257
 258 static void APIENTRY logColor4sv(const GLshort *v) {
 259 // unknown type: "const GLshort *" name: "v"
 260         fprintf( tr.logFile, "glColor4sv 'const GLshort * v'\n" );
 261         dllColor4sv(v);
 262 }
 263
 264 static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
 265         fprintf( tr.logFile, "glColor4ub %d %d %d %d\n", red, green, blue, alpha );
 266         dllColor4ub(red, green, blue, alpha);
 267 }
 268
 269 static void APIENTRY logColor4ubv(const GLubyte *v) {
 270 // unknown type: "const GLubyte *" name: "v"
 271         fprintf( tr.logFile, "glColor4ubv 'const GLubyte * v'\n" );
 272         dllColor4ubv(v);
 273 }
 274
 275 static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
 276         fprintf( tr.logFile, "glColor4ui %d %d %d %d\n", red, green, blue, alpha );
 277         dllColor4ui(red, green, blue, alpha);
 278 }
 279
 280 static void APIENTRY logColor4uiv(const GLuint *v) {
 281 // unknown type: "const GLuint *" name: "v"
 282         fprintf( tr.logFile, "glColor4uiv 'const GLuint * v'\n" );
 283         dllColor4uiv(v);
 284 }
 285
 286 static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
 287         fprintf( tr.logFile, "glColor4us %d %d %d %d\n", red, green, blue, alpha );
 288         dllColor4us(red, green, blue, alpha);
 289 }
 290
 291 static void APIENTRY logColor4usv(const GLushort *v) {
 292 // unknown type: "const GLushort *" name: "v"
 293         fprintf( tr.logFile, "glColor4usv 'const GLushort * v'\n" );
 294         dllColor4usv(v);
 295 }
 296
 297 static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
 298         fprintf( tr.logFile, "glColorMask %s %s %s %s\n", red ? "Y" : "N", green ? "Y" : "N", blue ? "Y" : "N", alpha ? "Y" : "N" );
 299         dllColorMask(red, green, blue, alpha);
 300 }
 301
 302 static void APIENTRY logColorMaterial(GLenum face, GLenum mode) {
 303         fprintf( tr.logFile, "glColorMaterial %s %s\n", EnumString(face), EnumString(mode) );
 304         dllColorMaterial(face, mode);
 305 }
 306
 307 static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
 308 // unknown type: "const GLvoid *" name: "pointer"
 309         fprintf( tr.logFile, "glColorPointer %d %s %d 'const GLvoid * pointer'\n", size, EnumString(type), stride );
 310         dllColorPointer(size, type, stride, pointer);
 311 }
 312
 313 static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {
 314         fprintf( tr.logFile, "glCopyPixels %d %d %d %d %s\n", x, y, width, height, EnumString(type) );
 315         dllCopyPixels(x, y, width, height, type);
 316 }
 317
 318 static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) {
 319         fprintf( tr.logFile, "glCopyTexImage1D %s %d %s %d %d %d %d\n", EnumString(target), level, EnumString(internalFormat), x, y, width, border );
 320         dllCopyTexImage1D(target, level, internalFormat, x, y, width, border);
 321 }
 322
 323 static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
 324         fprintf( tr.logFile, "glCopyTexImage2D %s %d %s %d %d %d %d %d\n", EnumString(target), level, EnumString(internalFormat), x, y, width, height, border );
 325         dllCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
 326 }
 327
 328 static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
 329         fprintf( tr.logFile, "glCopyTexSubImage1D %s %d %d %d %d %d\n", EnumString(target), level, xoffset, x, y, width );
 330         dllCopyTexSubImage1D(target, level, xoffset, x, y, width);
 331 }
 332
 333 static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
 334         fprintf( tr.logFile, "glCopyTexSubImage2D %s %d %d %d %d %d %d %d\n", EnumString(target), level, xoffset, yoffset, x, y, width, height );
 335         dllCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 336 }
 337
 338 static void APIENTRY logCullFace(GLenum mode) {
 339         fprintf( tr.logFile, "glCullFace %s\n", EnumString(mode) );
 340         dllCullFace(mode);
 341 }
 342
 343 static void APIENTRY logDeleteLists(GLuint list, GLsizei range) {
 344         fprintf( tr.logFile, "glDeleteLists %d %d\n", list, range );
 345         dllDeleteLists(list, range);
 346 }
 347
 348 static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures) {
 349 // unknown type: "const GLuint *" name: "textures"
 350         fprintf( tr.logFile, "glDeleteTextures %d 'const GLuint * textures'\n", n );
 351         dllDeleteTextures(n, textures);
 352 }
 353
 354 static void APIENTRY logDepthFunc(GLenum func) {
 355         fprintf( tr.logFile, "glDepthFunc %s\n", EnumString(func) );
 356         dllDepthFunc(func);
 357 }
 358
 359 static void APIENTRY logDepthMask(GLboolean flag) {
 360         fprintf( tr.logFile, "glDepthMask %s\n", flag ? "Y" : "N" );
 361         dllDepthMask(flag);
 362 }
 363
 364 static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar) {
 365 // unknown type: "GLclampd" name: "zNear"
 366 // unknown type: "GLclampd" name: "zFar"
 367         fprintf( tr.logFile, "glDepthRange 'GLclampd zNear' 'GLclampd zFar'\n" );
 368         dllDepthRange(zNear, zFar);
 369 }
 370
 371 static void APIENTRY logDisable(GLenum cap) {
 372         fprintf( tr.logFile, "glDisable %s\n", EnumString(cap) );
 373         dllDisable(cap);
 374 }
 375
 376 static void APIENTRY logDisableClientState(GLenum array) {
 377         fprintf( tr.logFile, "glDisableClientState %s\n", EnumString(array) );
 378         dllDisableClientState(array);
 379 }
 380
 381 static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count) {
 382         fprintf( tr.logFile, "glDrawArrays %s %d %d\n", EnumString(mode), first, count );
 383         dllDrawArrays(mode, first, count);
 384 }
 385
 386 static void APIENTRY logDrawBuffer(GLenum mode) {
 387         fprintf( tr.logFile, "glDrawBuffer %s\n", EnumString(mode) );
 388         dllDrawBuffer(mode);
 389 }
 390
 391 static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {
 392 // unknown type: "const GLvoid *" name: "indices"
 393         fprintf( tr.logFile, "glDrawElements %s %d %s 'const GLvoid * indices'\n", EnumString(mode), count, EnumString(type) );
 394         dllDrawElements(mode, count, type, indices);
 395 }
 396
 397 static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
 398 // unknown type: "const GLvoid *" name: "pixels"
 399         fprintf( tr.logFile, "glDrawPixels %d %d %s %s 'const GLvoid * pixels'\n", width, height, EnumString(format), EnumString(type) );
 400         dllDrawPixels(width, height, format, type, pixels);
 401 }
 402
 403 static void APIENTRY logEdgeFlag(GLboolean flag) {
 404         fprintf( tr.logFile, "glEdgeFlag %s\n", flag ? "Y" : "N" );
 405         dllEdgeFlag(flag);
 406 }
 407
 408 static void APIENTRY logEdgeFlagPointer(GLsizei stride, const GLvoid *pointer) {
 409 // unknown type: "const GLvoid *" name: "pointer"
 410         fprintf( tr.logFile, "glEdgeFlagPointer %d 'const GLvoid * pointer'\n", stride );
 411         dllEdgeFlagPointer(stride, pointer);
 412 }
 413
 414 static void APIENTRY logEdgeFlagv(const GLboolean *flag) {
 415 // unknown type: "const GLboolean *" name: "flag"
 416         fprintf( tr.logFile, "glEdgeFlagv 'const GLboolean * flag'\n" );
 417         dllEdgeFlagv(flag);
 418 }
 419
 420 static void APIENTRY logEnable(GLenum cap) {
 421         fprintf( tr.logFile, "glEnable %s\n", EnumString(cap) );
 422         dllEnable(cap);
 423 }
 424
 425 static void APIENTRY logEnableClientState(GLenum array) {
 426         fprintf( tr.logFile, "glEnableClientState %s\n", EnumString(array) );
 427         dllEnableClientState(array);
 428 }
 429
 430 static void APIENTRY logEnd(void) {
 431         fprintf( tr.logFile, "glEnd\n" );
 432         dllEnd();
 433 }
 434
 435 static void APIENTRY logEndList(void) {
 436         fprintf( tr.logFile, "glEndList\n" );
 437         dllEndList();
 438 }
 439
 440 static void APIENTRY logEvalCoord1d(GLdouble u) {
 441         fprintf( tr.logFile, "glEvalCoord1d %g\n", u );
 442         dllEvalCoord1d(u);
 443 }
 444
 445 static void APIENTRY logEvalCoord1dv(const GLdouble *u) {
 446 // unknown type: "const GLdouble *" name: "u"
 447         fprintf( tr.logFile, "glEvalCoord1dv 'const GLdouble * u'\n" );
 448         dllEvalCoord1dv(u);
 449 }
 450
 451 static void APIENTRY logEvalCoord1f(GLfloat u) {
 452         fprintf( tr.logFile, "glEvalCoord1f %g\n", u );
 453         dllEvalCoord1f(u);
 454 }
 455
 456 static void APIENTRY logEvalCoord1fv(const GLfloat *u) {
 457 // unknown type: "const GLfloat *" name: "u"
 458         fprintf( tr.logFile, "glEvalCoord1fv 'const GLfloat * u'\n" );
 459         dllEvalCoord1fv(u);
 460 }
 461
 462 static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v) {
 463         fprintf( tr.logFile, "glEvalCoord2d %g %g\n", u, v );
 464         dllEvalCoord2d(u, v);
 465 }
 466
 467 static void APIENTRY logEvalCoord2dv(const GLdouble *u) {
 468 // unknown type: "const GLdouble *" name: "u"
 469         fprintf( tr.logFile, "glEvalCoord2dv 'const GLdouble * u'\n" );
 470         dllEvalCoord2dv(u);
 471 }
 472
 473 static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v) {
 474         fprintf( tr.logFile, "glEvalCoord2f %g %g\n", u, v );
 475         dllEvalCoord2f(u, v);
 476 }
 477
 478 static void APIENTRY logEvalCoord2fv(const GLfloat *u) {
 479 // unknown type: "const GLfloat *" name: "u"
 480         fprintf( tr.logFile, "glEvalCoord2fv 'const GLfloat * u'\n" );
 481         dllEvalCoord2fv(u);
 482 }
 483
 484 static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2) {
 485         fprintf( tr.logFile, "glEvalMesh1 %s %d %d\n", EnumString(mode), i1, i2 );
 486         dllEvalMesh1(mode, i1, i2);
 487 }
 488
 489 static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {
 490         fprintf( tr.logFile, "glEvalMesh2 %s %d %d %d %d\n", EnumString(mode), i1, i2, j1, j2 );
 491         dllEvalMesh2(mode, i1, i2, j1, j2);
 492 }
 493
 494 static void APIENTRY logEvalPoint1(GLint i) {
 495         fprintf( tr.logFile, "glEvalPoint1 %d\n", i );
 496         dllEvalPoint1(i);
 497 }
 498
 499 static void APIENTRY logEvalPoint2(GLint i, GLint j) {
 500         fprintf( tr.logFile, "glEvalPoint2 %d %d\n", i, j );
 501         dllEvalPoint2(i, j);
 502 }
 503
 504 static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {
 505 // unknown type: "GLfloat *" name: "buffer"
 506         fprintf( tr.logFile, "glFeedbackBuffer %d %s 'GLfloat * buffer'\n", size, EnumString(type) );
 507         dllFeedbackBuffer(size, type, buffer);
 508 }
 509
 510 static void APIENTRY logFinish(void) {
 511         fprintf( tr.logFile, "glFinish\n" );
 512         dllFinish();
 513 }
 514
 515 static void APIENTRY logFlush(void) {
 516         fprintf( tr.logFile, "glFlush\n" );
 517         dllFlush();
 518 }
 519
 520 static void APIENTRY logFogf(GLenum pname, GLfloat param) {
 521         fprintf( tr.logFile, "glFogf %s %g\n", EnumString(pname), param );
 522         dllFogf(pname, param);
 523 }
 524
 525 static void APIENTRY logFogfv(GLenum pname, const GLfloat *params) {
 526 // unknown type: "const GLfloat *" name: "params"
 527         fprintf( tr.logFile, "glFogfv %s 'const GLfloat * params'\n", EnumString(pname) );
 528         dllFogfv(pname, params);
 529 }
 530
 531 static void APIENTRY logFogi(GLenum pname, GLint param) {
 532         fprintf( tr.logFile, "glFogi %s %d\n", EnumString(pname), param );
 533         dllFogi(pname, param);
 534 }
 535
 536 static void APIENTRY logFogiv(GLenum pname, const GLint *params) {
 537 // unknown type: "const GLint *" name: "params"
 538         fprintf( tr.logFile, "glFogiv %s 'const GLint * params'\n", EnumString(pname) );
 539         dllFogiv(pname, params);
 540 }
 541
 542 static void APIENTRY logFrontFace(GLenum mode) {
 543         fprintf( tr.logFile, "glFrontFace %s\n", EnumString(mode) );
 544         dllFrontFace(mode);
 545 }
 546
 547 static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
 548         fprintf( tr.logFile, "glFrustum %g %g %g %g %g %g\n", left, right, bottom, top, zNear, zFar );
 549         dllFrustum(left, right, bottom, top, zNear, zFar);
 550 }
 551
 552 static GLuint APIENTRY logGenLists(GLsizei range) {
 553         fprintf( tr.logFile, "glGenLists %d\n", range );
 554         return dllGenLists(range);
 555 }
 556
 557 static void APIENTRY logGenTextures(GLsizei n, GLuint *textures) {
 558 // unknown type: "GLuint *" name: "textures"
 559         fprintf( tr.logFile, "glGenTextures %d 'GLuint * textures'\n", n );
 560         dllGenTextures(n, textures);
 561 }
 562
 563 static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params) {
 564 // unknown type: "GLboolean *" name: "params"
 565         fprintf( tr.logFile, "glGetBooleanv %s 'GLboolean * params'\n", EnumString(pname) );
 566         dllGetBooleanv(pname, params);
 567 }
 568
 569 static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation) {
 570 // unknown type: "GLdouble *" name: "equation"
 571         fprintf( tr.logFile, "glGetClipPlane %s 'GLdouble * equation'\n", EnumString(plane) );
 572         dllGetClipPlane(plane, equation);
 573 }
 574
 575 static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params) {
 576 // unknown type: "GLdouble *" name: "params"
 577         fprintf( tr.logFile, "glGetDoublev %s 'GLdouble * params'\n", EnumString(pname) );
 578         dllGetDoublev(pname, params);
 579 }
 580
 581 static GLenum APIENTRY logGetError(void) {
 582         fprintf( tr.logFile, "glGetError\n" );
 583         return dllGetError();
 584 }
 585
 586 static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params) {
 587 // unknown type: "GLfloat *" name: "params"
 588         fprintf( tr.logFile, "glGetFloatv %s 'GLfloat * params'\n", EnumString(pname) );
 589         dllGetFloatv(pname, params);
 590 }
 591
 592 static void APIENTRY logGetIntegerv(GLenum pname, GLint *params) {
 593 // unknown type: "GLint *" name: "params"
 594         fprintf( tr.logFile, "glGetIntegerv %s 'GLint * params'\n", EnumString(pname) );
 595         dllGetIntegerv(pname, params);
 596 }
 597
 598 static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
 599 // unknown type: "GLfloat *" name: "params"
 600         fprintf( tr.logFile, "glGetLightfv %s %s 'GLfloat * params'\n", EnumString(light), EnumString(pname) );
 601         dllGetLightfv(light, pname, params);
 602 }
 603
 604 static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params) {
 605 // unknown type: "GLint *" name: "params"
 606         fprintf( tr.logFile, "glGetLightiv %s %s 'GLint * params'\n", EnumString(light), EnumString(pname) );
 607         dllGetLightiv(light, pname, params);
 608 }
 609
 610 static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v) {
 611 // unknown type: "GLdouble *" name: "v"
 612         fprintf( tr.logFile, "glGetMapdv %s %s 'GLdouble * v'\n", EnumString(target), EnumString(query) );
 613         dllGetMapdv(target, query, v);
 614 }
 615
 616 static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v) {
 617 // unknown type: "GLfloat *" name: "v"
 618         fprintf( tr.logFile, "glGetMapfv %s %s 'GLfloat * v'\n", EnumString(target), EnumString(query) );
 619         dllGetMapfv(target, query, v);
 620 }
 621
 622 static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v) {
 623 // unknown type: "GLint *" name: "v"
 624         fprintf( tr.logFile, "glGetMapiv %s %s 'GLint * v'\n", EnumString(target), EnumString(query) );
 625         dllGetMapiv(target, query, v);
 626 }
 627
 628 static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
 629 // unknown type: "GLfloat *" name: "params"
 630         fprintf( tr.logFile, "glGetMaterialfv %s %s 'GLfloat * params'\n", EnumString(face), EnumString(pname) );
 631         dllGetMaterialfv(face, pname, params);
 632 }
 633
 634 static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
 635 // unknown type: "GLint *" name: "params"
 636         fprintf( tr.logFile, "glGetMaterialiv %s %s 'GLint * params'\n", EnumString(face), EnumString(pname) );
 637         dllGetMaterialiv(face, pname, params);
 638 }
 639
 640 static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values) {
 641 // unknown type: "GLfloat *" name: "values"
 642         fprintf( tr.logFile, "glGetPixelMapfv %s 'GLfloat * values'\n", EnumString(map) );
 643         dllGetPixelMapfv(map, values);
 644 }
 645
 646 static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values) {
 647 // unknown type: "GLuint *" name: "values"
 648         fprintf( tr.logFile, "glGetPixelMapuiv %s 'GLuint * values'\n", EnumString(map) );
 649         dllGetPixelMapuiv(map, values);
 650 }
 651
 652 static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values) {
 653 // unknown type: "GLushort *" name: "values"
 654         fprintf( tr.logFile, "glGetPixelMapusv %s 'GLushort * values'\n", EnumString(map) );
 655         dllGetPixelMapusv(map, values);
 656 }
 657
 658 static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params) {
 659 // unknown type: "GLvoid* *" name: "params"
 660         fprintf( tr.logFile, "glGetPointerv %s 'GLvoid* * params'\n", EnumString(pname) );
 661         dllGetPointerv(pname, params);
 662 }
 663
 664 static void APIENTRY logGetPolygonStipple(GLubyte *mask) {
 665 // unknown type: "GLubyte *" name: "mask"
 666         fprintf( tr.logFile, "glGetPolygonStipple 'GLubyte * mask'\n" );
 667         dllGetPolygonStipple(mask);
 668 }
 669
 670 static const GLubyte * APIENTRY logGetString(GLenum name) {
 671         fprintf( tr.logFile, "glGetString %s\n", EnumString(name) );
 672         return dllGetString(name);
 673 }
 674
 675 static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
 676 // unknown type: "GLfloat *" name: "params"
 677         fprintf( tr.logFile, "glGetTexEnvfv %s %s 'GLfloat * params'\n", EnumString(target), EnumString(pname) );
 678         dllGetTexEnvfv(target, pname, params);
 679 }
 680
 681 static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
 682 // unknown type: "GLint *" name: "params"
 683         fprintf( tr.logFile, "glGetTexEnviv %s %s 'GLint * params'\n", EnumString(target), EnumString(pname) );
 684         dllGetTexEnviv(target, pname, params);
 685 }
 686
 687 static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
 688 // unknown type: "GLdouble *" name: "params"
 689         fprintf( tr.logFile, "glGetTexGendv %s %s 'GLdouble * params'\n", EnumString(coord), EnumString(pname) );
 690         dllGetTexGendv(coord, pname, params);
 691 }
 692
 693 static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
 694 // unknown type: "GLfloat *" name: "params"
 695         fprintf( tr.logFile, "glGetTexGenfv %s %s 'GLfloat * params'\n", EnumString(coord), EnumString(pname) );
 696         dllGetTexGenfv(coord, pname, params);
 697 }
 698
 699 static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
 700 // unknown type: "GLint *" name: "params"
 701         fprintf( tr.logFile, "glGetTexGeniv %s %s 'GLint * params'\n", EnumString(coord), EnumString(pname) );
 702         dllGetTexGeniv(coord, pname, params);
 703 }
 704
 705 static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {
 706 // unknown type: "GLvoid *" name: "pixels"
 707         fprintf( tr.logFile, "glGetTexImage %s %d %s %s 'GLvoid * pixels'\n", EnumString(target), level, EnumString(format), EnumString(type) );
 708         dllGetTexImage(target, level, format, type, pixels);
 709 }
 710
 711 static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
 712 // unknown type: "GLfloat *" name: "params"
 713         fprintf( tr.logFile, "glGetTexLevelParameterfv %s %d %s 'GLfloat * params'\n", EnumString(target), level, EnumString(pname) );
 714         dllGetTexLevelParameterfv(target, level, pname, params);
 715 }
 716
 717 static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
 718 // unknown type: "GLint *" name: "params"
 719         fprintf( tr.logFile, "glGetTexLevelParameteriv %s %d %s 'GLint * params'\n", EnumString(target), level, EnumString(pname) );
 720         dllGetTexLevelParameteriv(target, level, pname, params);
 721 }
 722
 723 static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
 724 // unknown type: "GLfloat *" name: "params"
 725         fprintf( tr.logFile, "glGetTexParameterfv %s %s 'GLfloat * params'\n", EnumString(target), EnumString(pname) );
 726         dllGetTexParameterfv(target, pname, params);
 727 }
 728
 729 static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
 730 // unknown type: "GLint *" name: "params"
 731         fprintf( tr.logFile, "glGetTexParameteriv %s %s 'GLint * params'\n", EnumString(target), EnumString(pname) );
 732         dllGetTexParameteriv(target, pname, params);
 733 }
 734
 735 static void APIENTRY logHint(GLenum target, GLenum mode) {
 736         fprintf( tr.logFile, "glHint %s %s\n", EnumString(target), EnumString(mode) );
 737         dllHint(target, mode);
 738 }
 739
 740 static void APIENTRY logIndexMask(GLuint mask) {
 741         fprintf( tr.logFile, "glIndexMask %d\n", mask );
 742         dllIndexMask(mask);
 743 }
 744
 745 static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
 746 // unknown type: "const GLvoid *" name: "pointer"
 747         fprintf( tr.logFile, "glIndexPointer %s %d 'const GLvoid * pointer'\n", EnumString(type), stride );
 748         dllIndexPointer(type, stride, pointer);
 749 }
 750
 751 static void APIENTRY logIndexd(GLdouble c) {
 752         fprintf( tr.logFile, "glIndexd %g\n", c );
 753         dllIndexd(c);
 754 }
 755
 756 static void APIENTRY logIndexdv(const GLdouble *c) {
 757 // unknown type: "const GLdouble *" name: "c"
 758         fprintf( tr.logFile, "glIndexdv 'const GLdouble * c'\n" );
 759         dllIndexdv(c);
 760 }
 761
 762 static void APIENTRY logIndexf(GLfloat c) {
 763         fprintf( tr.logFile, "glIndexf %g\n", c );
 764         dllIndexf(c);
 765 }
 766
 767 static void APIENTRY logIndexfv(const GLfloat *c) {
 768 // unknown type: "const GLfloat *" name: "c"
 769         fprintf( tr.logFile, "glIndexfv 'const GLfloat * c'\n" );
 770         dllIndexfv(c);
 771 }
 772
 773 static void APIENTRY logIndexi(GLint c) {
 774         fprintf( tr.logFile, "glIndexi %d\n", c );
 775         dllIndexi(c);
 776 }
 777
 778 static void APIENTRY logIndexiv(const GLint *c) {
 779 // unknown type: "const GLint *" name: "c"
 780         fprintf( tr.logFile, "glIndexiv 'const GLint * c'\n" );
 781         dllIndexiv(c);
 782 }
 783
 784 static void APIENTRY logIndexs(GLshort c) {
 785         fprintf( tr.logFile, "glIndexs %d\n", c );
 786         dllIndexs(c);
 787 }
 788
 789 static void APIENTRY logIndexsv(const GLshort *c) {
 790 // unknown type: "const GLshort *" name: "c"
 791         fprintf( tr.logFile, "glIndexsv 'const GLshort * c'\n" );
 792         dllIndexsv(c);
 793 }
 794
 795 static void APIENTRY logIndexub(GLubyte c) {
 796         fprintf( tr.logFile, "glIndexub %d\n", c );
 797         dllIndexub(c);
 798 }
 799
 800 static void APIENTRY logIndexubv(const GLubyte *c) {
 801 // unknown type: "const GLubyte *" name: "c"
 802         fprintf( tr.logFile, "glIndexubv 'const GLubyte * c'\n" );
 803         dllIndexubv(c);
 804 }
 805
 806 static void APIENTRY logInitNames(void) {
 807         fprintf( tr.logFile, "glInitNames\n" );
 808         dllInitNames();
 809 }
 810
 811 static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) {
 812 // unknown type: "const GLvoid *" name: "pointer"
 813         fprintf( tr.logFile, "glInterleavedArrays %s %d 'const GLvoid * pointer'\n", EnumString(format), stride );
 814         dllInterleavedArrays(format, stride, pointer);
 815 }
 816
 817 static GLboolean APIENTRY logIsEnabled(GLenum cap) {
 818         fprintf( tr.logFile, "glIsEnabled %s\n", EnumString(cap) );
 819         return dllIsEnabled(cap);
 820 }
 821
 822 static GLboolean APIENTRY logIsList(GLuint list) {
 823         fprintf( tr.logFile, "glIsList %d\n", list );
 824         return dllIsList(list);
 825 }
 826
 827 static GLboolean APIENTRY logIsTexture(GLuint texture) {
 828         fprintf( tr.logFile, "glIsTexture %d\n", texture );
 829         return dllIsTexture(texture);
 830 }
 831
 832 static void APIENTRY logLightModelf(GLenum pname, GLfloat param) {
 833         fprintf( tr.logFile, "glLightModelf %s %g\n", EnumString(pname), param );
 834         dllLightModelf(pname, param);
 835 }
 836
 837 static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params) {
 838 // unknown type: "const GLfloat *" name: "params"
 839         fprintf( tr.logFile, "glLightModelfv %s 'const GLfloat * params'\n", EnumString(pname) );
 840         dllLightModelfv(pname, params);
 841 }
 842
 843 static void APIENTRY logLightModeli(GLenum pname, GLint param) {
 844         fprintf( tr.logFile, "glLightModeli %s %d\n", EnumString(pname), param );
 845         dllLightModeli(pname, param);
 846 }
 847
 848 static void APIENTRY logLightModeliv(GLenum pname, const GLint *params) {
 849 // unknown type: "const GLint *" name: "params"
 850         fprintf( tr.logFile, "glLightModeliv %s 'const GLint * params'\n", EnumString(pname) );
 851         dllLightModeliv(pname, params);
 852 }
 853
 854 static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param) {
 855         fprintf( tr.logFile, "glLightf %s %s %g\n", EnumString(light), EnumString(pname), param );
 856         dllLightf(light, pname, param);
 857 }
 858
 859 static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params) {
 860 // unknown type: "const GLfloat *" name: "params"
 861         fprintf( tr.logFile, "glLightfv %s %s 'const GLfloat * params'\n", EnumString(light), EnumString(pname) );
 862         dllLightfv(light, pname, params);
 863 }
 864
 865 static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param) {
 866         fprintf( tr.logFile, "glLighti %s %s %d\n", EnumString(light), EnumString(pname), param );
 867         dllLighti(light, pname, param);
 868 }
 869
 870 static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params) {
 871 // unknown type: "const GLint *" name: "params"
 872         fprintf( tr.logFile, "glLightiv %s %s 'const GLint * params'\n", EnumString(light), EnumString(pname) );
 873         dllLightiv(light, pname, params);
 874 }
 875
 876 static void APIENTRY logLineStipple(GLint factor, GLushort pattern) {
 877         fprintf( tr.logFile, "glLineStipple %d %d\n", factor, pattern );
 878         dllLineStipple(factor, pattern);
 879 }
 880
 881 static void APIENTRY logLineWidth(GLfloat width) {
 882         fprintf( tr.logFile, "glLineWidth %g\n", width );
 883         dllLineWidth(width);
 884 }
 885
 886 static void APIENTRY logListBase(GLuint base) {
 887         fprintf( tr.logFile, "glListBase %d\n", base );
 888         dllListBase(base);
 889 }
 890
 891 static void APIENTRY logLoadIdentity(void) {
 892         fprintf( tr.logFile, "glLoadIdentity\n" );
 893         dllLoadIdentity();
 894 }
 895
 896 static void APIENTRY logLoadMatrixd(const GLdouble *m) {
 897 // unknown type: "const GLdouble *" name: "m"
 898         fprintf( tr.logFile, "glLoadMatrixd 'const GLdouble * m'\n" );
 899         dllLoadMatrixd(m);
 900 }
 901
 902 static void APIENTRY logLoadMatrixf(const GLfloat *m) {
 903 // unknown type: "const GLfloat *" name: "m"
 904         fprintf( tr.logFile, "glLoadMatrixf 'const GLfloat * m'\n" );
 905         dllLoadMatrixf(m);
 906 }
 907
 908 static void APIENTRY logLoadName(GLuint name) {
 909         fprintf( tr.logFile, "glLoadName %d\n", name );
 910         dllLoadName(name);
 911 }
 912
 913 static void APIENTRY logLogicOp(GLenum opcode) {
 914         fprintf( tr.logFile, "glLogicOp %s\n", EnumString(opcode) );
 915         dllLogicOp(opcode);
 916 }
 917
 918 static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) {
 919 // unknown type: "const GLdouble *" name: "points"
 920         fprintf( tr.logFile, "glMap1d %s %g %g %d %d 'const GLdouble * points'\n", EnumString(target), u1, u2, stride, order );
 921         dllMap1d(target, u1, u2, stride, order, points);
 922 }
 923
 924 static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {
 925 // unknown type: "const GLfloat *" name: "points"
 926         fprintf( tr.logFile, "glMap1f %s %g %g %d %d 'const GLfloat * points'\n", EnumString(target), u1, u2, stride, order );
 927         dllMap1f(target, u1, u2, stride, order, points);
 928 }
 929
 930 static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {
 931 // unknown type: "const GLdouble *" name: "points"
 932         fprintf( tr.logFile, "glMap2d %s %g %g %d %d %g %g %d %d 'const GLdouble * points'\n", EnumString(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder );
 933         dllMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 934 }
 935
 936 static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {
 937 // unknown type: "const GLfloat *" name: "points"
 938         fprintf( tr.logFile, "glMap2f %s %g %g %d %d %g %g %d %d 'const GLfloat * points'\n", EnumString(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder );
 939         dllMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 940 }
 941
 942 static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {
 943         fprintf( tr.logFile, "glMapGrid1d %d %g %g\n", un, u1, u2 );
 944         dllMapGrid1d(un, u1, u2);
 945 }
 946
 947 static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {
 948         fprintf( tr.logFile, "glMapGrid1f %d %g %g\n", un, u1, u2 );
 949         dllMapGrid1f(un, u1, u2);
 950 }
 951
 952 static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {
 953         fprintf( tr.logFile, "glMapGrid2d %d %g %g %d %g %g\n", un, u1, u2, vn, v1, v2 );
 954         dllMapGrid2d(un, u1, u2, vn, v1, v2);
 955 }
 956
 957 static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {
 958         fprintf( tr.logFile, "glMapGrid2f %d %g %g %d %g %g\n", un, u1, u2, vn, v1, v2 );
 959         dllMapGrid2f(un, u1, u2, vn, v1, v2);
 960 }
 961
 962 static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param) {
 963         fprintf( tr.logFile, "glMaterialf %s %s %g\n", EnumString(face), EnumString(pname), param );
 964         dllMaterialf(face, pname, param);
 965 }
 966
 967 static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
 968 // unknown type: "const GLfloat *" name: "params"
 969         fprintf( tr.logFile, "glMaterialfv %s %s 'const GLfloat * params'\n", EnumString(face), EnumString(pname) );
 970         dllMaterialfv(face, pname, params);
 971 }
 972
 973 static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param) {
 974         fprintf( tr.logFile, "glMateriali %s %s %d\n", EnumString(face), EnumString(pname), param );
 975         dllMateriali(face, pname, param);
 976 }
 977
 978 static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params) {
 979 // unknown type: "const GLint *" name: "params"
 980         fprintf( tr.logFile, "glMaterialiv %s %s 'const GLint * params'\n", EnumString(face), EnumString(pname) );
 981         dllMaterialiv(face, pname, params);
 982 }
 983
 984 static void APIENTRY logMatrixMode(GLenum mode) {
 985         fprintf( tr.logFile, "glMatrixMode %s\n", EnumString(mode) );
 986         dllMatrixMode(mode);
 987 }
 988
 989 static void APIENTRY logMultMatrixd(const GLdouble *m) {
 990 // unknown type: "const GLdouble *" name: "m"
 991         fprintf( tr.logFile, "glMultMatrixd 'const GLdouble * m'\n" );
 992         dllMultMatrixd(m);
 993 }
 994
 995 static void APIENTRY logMultMatrixf(const GLfloat *m) {
 996 // unknown type: "const GLfloat *" name: "m"
 997         fprintf( tr.logFile, "glMultMatrixf 'const GLfloat * m'\n" );
 998         dllMultMatrixf(m);
 999 }
1000
1001 static void APIENTRY logNewList(GLuint list, GLenum mode) {
1002         fprintf( tr.logFile, "glNewList %d %s\n", list, EnumString(mode) );
1003         dllNewList(list, mode);
1004 }
1005
1006 static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
1007         fprintf( tr.logFile, "glNormal3b %d %d %d\n", nx, ny, nz );
1008         dllNormal3b(nx, ny, nz);
1009 }
1010
1011 static void APIENTRY logNormal3bv(const GLbyte *v) {
1012 // unknown type: "const GLbyte *" name: "v"
1013         fprintf( tr.logFile, "glNormal3bv 'const GLbyte * v'\n" );
1014         dllNormal3bv(v);
1015 }
1016
1017 static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
1018         fprintf( tr.logFile, "glNormal3d %g %g %g\n", nx, ny, nz );
1019         dllNormal3d(nx, ny, nz);
1020 }
1021
1022 static void APIENTRY logNormal3dv(const GLdouble *v) {
1023 // unknown type: "const GLdouble *" name: "v"
1024         fprintf( tr.logFile, "glNormal3dv 'const GLdouble * v'\n" );
1025         dllNormal3dv(v);
1026 }
1027
1028 static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
1029         fprintf( tr.logFile, "glNormal3f %g %g %g\n", nx, ny, nz );
1030         dllNormal3f(nx, ny, nz);
1031 }
1032
1033 static void APIENTRY logNormal3fv(const GLfloat *v) {
1034 // unknown type: "const GLfloat *" name: "v"
1035         fprintf( tr.logFile, "glNormal3fv 'const GLfloat * v'\n" );
1036         dllNormal3fv(v);
1037 }
1038
1039 static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz) {
1040         fprintf( tr.logFile, "glNormal3i %d %d %d\n", nx, ny, nz );
1041         dllNormal3i(nx, ny, nz);
1042 }
1043
1044 static void APIENTRY logNormal3iv(const GLint *v) {
1045 // unknown type: "const GLint *" name: "v"
1046         fprintf( tr.logFile, "glNormal3iv 'const GLint * v'\n" );
1047         dllNormal3iv(v);
1048 }
1049
1050 static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz) {
1051         fprintf( tr.logFile, "glNormal3s %d %d %d\n", nx, ny, nz );
1052         dllNormal3s(nx, ny, nz);
1053 }
1054
1055 static void APIENTRY logNormal3sv(const GLshort *v) {
1056 // unknown type: "const GLshort *" name: "v"
1057         fprintf( tr.logFile, "glNormal3sv 'const GLshort * v'\n" );
1058         dllNormal3sv(v);
1059 }
1060
1061 static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
1062 // unknown type: "const GLvoid *" name: "pointer"
1063         fprintf( tr.logFile, "glNormalPointer %s %d 'const GLvoid * pointer'\n", EnumString(type), stride );
1064         dllNormalPointer(type, stride, pointer);
1065 }
1066
1067 static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
1068         fprintf( tr.logFile, "glOrtho %g %g %g %g %g %g\n", left, right, bottom, top, zNear, zFar );
1069         dllOrtho(left, right, bottom, top, zNear, zFar);
1070 }
1071
1072 static void APIENTRY logPassThrough(GLfloat token) {
1073         fprintf( tr.logFile, "glPassThrough %g\n", token );
1074         dllPassThrough(token);
1075 }
1076
1077 static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) {
1078 // unknown type: "const GLfloat *" name: "values"
1079         fprintf( tr.logFile, "glPixelMapfv %s %d 'const GLfloat * values'\n", EnumString(map), mapsize );
1080         dllPixelMapfv(map, mapsize, values);
1081 }
1082
1083 static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) {
1084 // unknown type: "const GLuint *" name: "values"
1085         fprintf( tr.logFile, "glPixelMapuiv %s %d 'const GLuint * values'\n", EnumString(map), mapsize );
1086         dllPixelMapuiv(map, mapsize, values);
1087 }
1088
1089 static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) {
1090 // unknown type: "const GLushort *" name: "values"
1091         fprintf( tr.logFile, "glPixelMapusv %s %d 'const GLushort * values'\n", EnumString(map), mapsize );
1092         dllPixelMapusv(map, mapsize, values);
1093 }
1094
1095 static void APIENTRY logPixelStoref(GLenum pname, GLfloat param) {
1096         fprintf( tr.logFile, "glPixelStoref %s %g\n", EnumString(pname), param );
1097         dllPixelStoref(pname, param);
1098 }
1099
1100 static void APIENTRY logPixelStorei(GLenum pname, GLint param) {
1101         fprintf( tr.logFile, "glPixelStorei %s %d\n", EnumString(pname), param );
1102         dllPixelStorei(pname, param);
1103 }
1104
1105 static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param) {
1106         fprintf( tr.logFile, "glPixelTransferf %s %g\n", EnumString(pname), param );
1107         dllPixelTransferf(pname, param);
1108 }
1109
1110 static void APIENTRY logPixelTransferi(GLenum pname, GLint param) {
1111         fprintf( tr.logFile, "glPixelTransferi %s %d\n", EnumString(pname), param );
1112         dllPixelTransferi(pname, param);
1113 }
1114
1115 static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor) {
1116         fprintf( tr.logFile, "glPixelZoom %g %g\n", xfactor, yfactor );
1117         dllPixelZoom(xfactor, yfactor);
1118 }
1119
1120 static void APIENTRY logPointSize(GLfloat size) {
1121         fprintf( tr.logFile, "glPointSize %g\n", size );
1122         dllPointSize(size);
1123 }
1124
1125 static void APIENTRY logPolygonMode(GLenum face, GLenum mode) {
1126         fprintf( tr.logFile, "glPolygonMode %s %s\n", EnumString(face), EnumString(mode) );
1127         dllPolygonMode(face, mode);
1128 }
1129
1130 static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units) {
1131         fprintf( tr.logFile, "glPolygonOffset %g %g\n", factor, units );
1132         dllPolygonOffset(factor, units);
1133 }
1134
1135 static void APIENTRY logPolygonStipple(const GLubyte *mask) {
1136 // unknown type: "const GLubyte *" name: "mask"
1137         fprintf( tr.logFile, "glPolygonStipple 'const GLubyte * mask'\n" );
1138         dllPolygonStipple(mask);
1139 }
1140
1141 static void APIENTRY logPopAttrib(void) {
1142         fprintf( tr.logFile, "glPopAttrib\n" );
1143         dllPopAttrib();
1144 }
1145
1146 static void APIENTRY logPopClientAttrib(void) {
1147         fprintf( tr.logFile, "glPopClientAttrib\n" );
1148         dllPopClientAttrib();
1149 }
1150
1151 static void APIENTRY logPopMatrix(void) {
1152         fprintf( tr.logFile, "glPopMatrix\n" );
1153         dllPopMatrix();
1154 }
1155
1156 static void APIENTRY logPopName(void) {
1157         fprintf( tr.logFile, "glPopName\n" );
1158         dllPopName();
1159 }
1160
1161 static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
1162 // unknown type: "const GLuint *" name: "textures"
1163 // unknown type: "const GLclampf *" name: "priorities"
1164         fprintf( tr.logFile, "glPrioritizeTextures %d 'const GLuint * textures' 'const GLclampf * priorities'\n", n );
1165         dllPrioritizeTextures(n, textures, priorities);
1166 }
1167
1168 static void APIENTRY logPushAttrib(GLbitfield mask) {
1169 // unknown type: "GLbitfield" name: "mask"
1170         fprintf( tr.logFile, "glPushAttrib 'GLbitfield mask'\n" );
1171         dllPushAttrib(mask);
1172 }
1173
1174 static void APIENTRY logPushClientAttrib(GLbitfield mask) {
1175 // unknown type: "GLbitfield" name: "mask"
1176         fprintf( tr.logFile, "glPushClientAttrib 'GLbitfield mask'\n" );
1177         dllPushClientAttrib(mask);
1178 }
1179
1180 static void APIENTRY logPushMatrix(void) {
1181         fprintf( tr.logFile, "glPushMatrix\n" );
1182         dllPushMatrix();
1183 }
1184
1185 static void APIENTRY logPushName(GLuint name) {
1186         fprintf( tr.logFile, "glPushName %d\n", name );
1187         dllPushName(name);
1188 }
1189
1190 static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y) {
1191         fprintf( tr.logFile, "glRasterPos2d %g %g\n", x, y );
1192         dllRasterPos2d(x, y);
1193 }
1194
1195 static void APIENTRY logRasterPos2dv(const GLdouble *v) {
1196 // unknown type: "const GLdouble *" name: "v"
1197         fprintf( tr.logFile, "glRasterPos2dv 'const GLdouble * v'\n" );
1198         dllRasterPos2dv(v);
1199 }
1200
1201 static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y) {
1202         fprintf( tr.logFile, "glRasterPos2f %g %g\n", x, y );
1203         dllRasterPos2f(x, y);
1204 }
1205
1206 static void APIENTRY logRasterPos2fv(const GLfloat *v) {
1207 // unknown type: "const GLfloat *" name: "v"
1208         fprintf( tr.logFile, "glRasterPos2fv 'const GLfloat * v'\n" );
1209         dllRasterPos2fv(v);
1210 }
1211
1212 static void APIENTRY logRasterPos2i(GLint x, GLint y) {
1213         fprintf( tr.logFile, "glRasterPos2i %d %d\n", x, y );
1214         dllRasterPos2i(x, y);
1215 }
1216
1217 static void APIENTRY logRasterPos2iv(const GLint *v) {
1218 // unknown type: "const GLint *" name: "v"
1219         fprintf( tr.logFile, "glRasterPos2iv 'const GLint * v'\n" );
1220         dllRasterPos2iv(v);
1221 }
1222
1223 static void APIENTRY logRasterPos2s(GLshort x, GLshort y) {
1224         fprintf( tr.logFile, "glRasterPos2s %d %d\n", x, y );
1225         dllRasterPos2s(x, y);
1226 }
1227
1228 static void APIENTRY logRasterPos2sv(const GLshort *v) {
1229 // unknown type: "const GLshort *" name: "v"
1230         fprintf( tr.logFile, "glRasterPos2sv 'const GLshort * v'\n" );
1231         dllRasterPos2sv(v);
1232 }
1233
1234 static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {
1235         fprintf( tr.logFile, "glRasterPos3d %g %g %g\n", x, y, z );
1236         dllRasterPos3d(x, y, z);
1237 }
1238
1239 static void APIENTRY logRasterPos3dv(const GLdouble *v) {
1240 // unknown type: "const GLdouble *" name: "v"
1241         fprintf( tr.logFile, "glRasterPos3dv 'const GLdouble * v'\n" );
1242         dllRasterPos3dv(v);
1243 }
1244
1245 static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {
1246         fprintf( tr.logFile, "glRasterPos3f %g %g %g\n", x, y, z );
1247         dllRasterPos3f(x, y, z);
1248 }
1249
1250 static void APIENTRY logRasterPos3fv(const GLfloat *v) {
1251 // unknown type: "const GLfloat *" name: "v"
1252         fprintf( tr.logFile, "glRasterPos3fv 'const GLfloat * v'\n" );
1253         dllRasterPos3fv(v);
1254 }
1255
1256 static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z) {
1257         fprintf( tr.logFile, "glRasterPos3i %d %d %d\n", x, y, z );
1258         dllRasterPos3i(x, y, z);
1259 }
1260
1261 static void APIENTRY logRasterPos3iv(const GLint *v) {
1262 // unknown type: "const GLint *" name: "v"
1263         fprintf( tr.logFile, "glRasterPos3iv 'const GLint * v'\n" );
1264         dllRasterPos3iv(v);
1265 }
1266
1267 static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z) {
1268         fprintf( tr.logFile, "glRasterPos3s %d %d %d\n", x, y, z );
1269         dllRasterPos3s(x, y, z);
1270 }
1271
1272 static void APIENTRY logRasterPos3sv(const GLshort *v) {
1273 // unknown type: "const GLshort *" name: "v"
1274         fprintf( tr.logFile, "glRasterPos3sv 'const GLshort * v'\n" );
1275         dllRasterPos3sv(v);
1276 }
1277
1278 static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
1279         fprintf( tr.logFile, "glRasterPos4d %g %g %g %g\n", x, y, z, w );
1280         dllRasterPos4d(x, y, z, w);
1281 }
1282
1283 static void APIENTRY logRasterPos4dv(const GLdouble *v) {
1284 // unknown type: "const GLdouble *" name: "v"
1285         fprintf( tr.logFile, "glRasterPos4dv 'const GLdouble * v'\n" );
1286         dllRasterPos4dv(v);
1287 }
1288
1289 static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1290         fprintf( tr.logFile, "glRasterPos4f %g %g %g %g\n", x, y, z, w );
1291         dllRasterPos4f(x, y, z, w);
1292 }
1293
1294 static void APIENTRY logRasterPos4fv(const GLfloat *v) {
1295 // unknown type: "const GLfloat *" name: "v"
1296         fprintf( tr.logFile, "glRasterPos4fv 'const GLfloat * v'\n" );
1297         dllRasterPos4fv(v);
1298 }
1299
1300 static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w) {
1301         fprintf( tr.logFile, "glRasterPos4i %d %d %d %d\n", x, y, z, w );
1302         dllRasterPos4i(x, y, z, w);
1303 }
1304
1305 static void APIENTRY logRasterPos4iv(const GLint *v) {
1306 // unknown type: "const GLint *" name: "v"
1307         fprintf( tr.logFile, "glRasterPos4iv 'const GLint * v'\n" );
1308         dllRasterPos4iv(v);
1309 }
1310
1311 static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {
1312         fprintf( tr.logFile, "glRasterPos4s %d %d %d %d\n", x, y, z, w );
1313         dllRasterPos4s(x, y, z, w);
1314 }
1315
1316 static void APIENTRY logRasterPos4sv(const GLshort *v) {
1317 // unknown type: "const GLshort *" name: "v"
1318         fprintf( tr.logFile, "glRasterPos4sv 'const GLshort * v'\n" );
1319         dllRasterPos4sv(v);
1320 }
1321
1322 static void APIENTRY logReadBuffer(GLenum mode) {
1323         fprintf( tr.logFile, "glReadBuffer %s\n", EnumString(mode) );
1324         dllReadBuffer(mode);
1325 }
1326
1327 static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {
1328 // unknown type: "GLvoid *" name: "pixels"
1329         fprintf( tr.logFile, "glReadPixels %d %d %d %d %s %s 'GLvoid * pixels'\n", x, y, width, height, EnumString(format), EnumString(type) );
1330         dllReadPixels(x, y, width, height, format, type, pixels);
1331 }
1332
1333 static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
1334         fprintf( tr.logFile, "glRectd %g %g %g %g\n", x1, y1, x2, y2 );
1335         dllRectd(x1, y1, x2, y2);
1336 }
1337
1338 static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2) {
1339 // unknown type: "const GLdouble *" name: "v1"
1340 // unknown type: "const GLdouble *" name: "v2"
1341         fprintf( tr.logFile, "glRectdv 'const GLdouble * v1' 'const GLdouble * v2'\n" );
1342         dllRectdv(v1, v2);
1343 }
1344
1345 static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
1346         fprintf( tr.logFile, "glRectf %g %g %g %g\n", x1, y1, x2, y2 );
1347         dllRectf(x1, y1, x2, y2);
1348 }
1349
1350 static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2) {
1351 // unknown type: "const GLfloat *" name: "v1"
1352 // unknown type: "const GLfloat *" name: "v2"
1353         fprintf( tr.logFile, "glRectfv 'const GLfloat * v1' 'const GLfloat * v2'\n" );
1354         dllRectfv(v1, v2);
1355 }
1356
1357 static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
1358         fprintf( tr.logFile, "glRecti %d %d %d %d\n", x1, y1, x2, y2 );
1359         dllRecti(x1, y1, x2, y2);
1360 }
1361
1362 static void APIENTRY logRectiv(const GLint *v1, const GLint *v2) {
1363 // unknown type: "const GLint *" name: "v1"
1364 // unknown type: "const GLint *" name: "v2"
1365         fprintf( tr.logFile, "glRectiv 'const GLint * v1' 'const GLint * v2'\n" );
1366         dllRectiv(v1, v2);
1367 }
1368
1369 static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
1370         fprintf( tr.logFile, "glRects %d %d %d %d\n", x1, y1, x2, y2 );
1371         dllRects(x1, y1, x2, y2);
1372 }
1373
1374 static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2) {
1375 // unknown type: "const GLshort *" name: "v1"
1376 // unknown type: "const GLshort *" name: "v2"
1377         fprintf( tr.logFile, "glRectsv 'const GLshort * v1' 'const GLshort * v2'\n" );
1378         dllRectsv(v1, v2);
1379 }
1380
1381 static GLint APIENTRY logRenderMode(GLenum mode) {
1382         fprintf( tr.logFile, "glRenderMode %s\n", EnumString(mode) );
1383         return dllRenderMode(mode);
1384 }
1385
1386 static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
1387         fprintf( tr.logFile, "glRotated %g %g %g %g\n", angle, x, y, z );
1388         dllRotated(angle, x, y, z);
1389 }
1390
1391 static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
1392         fprintf( tr.logFile, "glRotatef %g %g %g %g\n", angle, x, y, z );
1393         dllRotatef(angle, x, y, z);
1394 }
1395
1396 static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z) {
1397         fprintf( tr.logFile, "glScaled %g %g %g\n", x, y, z );
1398         dllScaled(x, y, z);
1399 }
1400
1401 static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z) {
1402         fprintf( tr.logFile, "glScalef %g %g %g\n", x, y, z );
1403         dllScalef(x, y, z);
1404 }
1405
1406 static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
1407         fprintf( tr.logFile, "glScissor %d %d %d %d\n", x, y, width, height );
1408         dllScissor(x, y, width, height);
1409 }
1410
1411 static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer) {
1412 // unknown type: "GLuint *" name: "buffer"
1413         fprintf( tr.logFile, "glSelectBuffer %d 'GLuint * buffer'\n", size );
1414         dllSelectBuffer(size, buffer);
1415 }
1416
1417 static void APIENTRY logShadeModel(GLenum mode) {
1418         fprintf( tr.logFile, "glShadeModel %s\n", EnumString(mode) );
1419         dllShadeModel(mode);
1420 }
1421
1422 static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask) {
1423         fprintf( tr.logFile, "glStencilFunc %s %d %d\n", EnumString(func), ref, mask );
1424         dllStencilFunc(func, ref, mask);
1425 }
1426
1427 static void APIENTRY logStencilMask(GLuint mask) {
1428         fprintf( tr.logFile, "glStencilMask %d\n", mask );
1429         dllStencilMask(mask);
1430 }
1431
1432 static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1433         fprintf( tr.logFile, "glStencilOp %s %s %s\n", EnumString(fail), EnumString(zfail), EnumString(zpass) );
1434         dllStencilOp(fail, zfail, zpass);
1435 }
1436
1437 static void APIENTRY logTexCoord1d(GLdouble s) {
1438         fprintf( tr.logFile, "glTexCoord1d %g\n", s );
1439         dllTexCoord1d(s);
1440 }
1441
1442 static void APIENTRY logTexCoord1dv(const GLdouble *v) {
1443 // unknown type: "const GLdouble *" name: "v"
1444         fprintf( tr.logFile, "glTexCoord1dv 'const GLdouble * v'\n" );
1445         dllTexCoord1dv(v);
1446 }
1447
1448 static void APIENTRY logTexCoord1f(GLfloat s) {
1449         fprintf( tr.logFile, "glTexCoord1f %g\n", s );
1450         dllTexCoord1f(s);
1451 }
1452
1453 static void APIENTRY logTexCoord1fv(const GLfloat *v) {
1454 // unknown type: "const GLfloat *" name: "v"
1455         fprintf( tr.logFile, "glTexCoord1fv 'const GLfloat * v'\n" );
1456         dllTexCoord1fv(v);
1457 }
1458
1459 static void APIENTRY logTexCoord1i(GLint s) {
1460         fprintf( tr.logFile, "glTexCoord1i %d\n", s );
1461         dllTexCoord1i(s);
1462 }
1463
1464 static void APIENTRY logTexCoord1iv(const GLint *v) {
1465 // unknown type: "const GLint *" name: "v"
1466         fprintf( tr.logFile, "glTexCoord1iv 'const GLint * v'\n" );
1467         dllTexCoord1iv(v);
1468 }
1469
1470 static void APIENTRY logTexCoord1s(GLshort s) {
1471         fprintf( tr.logFile, "glTexCoord1s %d\n", s );
1472         dllTexCoord1s(s);
1473 }
1474
1475 static void APIENTRY logTexCoord1sv(const GLshort *v) {
1476 // unknown type: "const GLshort *" name: "v"
1477         fprintf( tr.logFile, "glTexCoord1sv 'const GLshort * v'\n" );
1478         dllTexCoord1sv(v);
1479 }
1480
1481 static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t) {
1482         fprintf( tr.logFile, "glTexCoord2d %g %g\n", s, t );
1483         dllTexCoord2d(s, t);
1484 }
1485
1486 static void APIENTRY logTexCoord2dv(const GLdouble *v) {
1487 // unknown type: "const GLdouble *" name: "v"
1488         fprintf( tr.logFile, "glTexCoord2dv 'const GLdouble * v'\n" );
1489         dllTexCoord2dv(v);
1490 }
1491
1492 static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t) {
1493         fprintf( tr.logFile, "glTexCoord2f %g %g\n", s, t );
1494         dllTexCoord2f(s, t);
1495 }
1496
1497 static void APIENTRY logTexCoord2fv(const GLfloat *v) {
1498 // unknown type: "const GLfloat *" name: "v"
1499         fprintf( tr.logFile, "glTexCoord2fv 'const GLfloat * v'\n" );
1500         dllTexCoord2fv(v);
1501 }
1502
1503 static void APIENTRY logTexCoord2i(GLint s, GLint t) {
1504         fprintf( tr.logFile, "glTexCoord2i %d %d\n", s, t );
1505         dllTexCoord2i(s, t);
1506 }
1507
1508 static void APIENTRY logTexCoord2iv(const GLint *v) {
1509 // unknown type: "const GLint *" name: "v"
1510         fprintf( tr.logFile, "glTexCoord2iv 'const GLint * v'\n" );
1511         dllTexCoord2iv(v);
1512 }
1513
1514 static void APIENTRY logTexCoord2s(GLshort s, GLshort t) {
1515         fprintf( tr.logFile, "glTexCoord2s %d %d\n", s, t );
1516         dllTexCoord2s(s, t);
1517 }
1518
1519 static void APIENTRY logTexCoord2sv(const GLshort *v) {
1520 // unknown type: "const GLshort *" name: "v"
1521         fprintf( tr.logFile, "glTexCoord2sv 'const GLshort * v'\n" );
1522         dllTexCoord2sv(v);
1523 }
1524
1525 static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
1526         fprintf( tr.logFile, "glTexCoord3d %g %g %g\n", s, t, r );
1527         dllTexCoord3d(s, t, r);
1528 }
1529
1530 static void APIENTRY logTexCoord3dv(const GLdouble *v) {
1531 // unknown type: "const GLdouble *" name: "v"
1532         fprintf( tr.logFile, "glTexCoord3dv 'const GLdouble * v'\n" );
1533         dllTexCoord3dv(v);
1534 }
1535
1536 static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
1537         fprintf( tr.logFile, "glTexCoord3f %g %g %g\n", s, t, r );
1538         dllTexCoord3f(s, t, r);
1539 }
1540
1541 static void APIENTRY logTexCoord3fv(const GLfloat *v) {
1542 // unknown type: "const GLfloat *" name: "v"
1543         fprintf( tr.logFile, "glTexCoord3fv 'const GLfloat * v'\n" );
1544         dllTexCoord3fv(v);
1545 }
1546
1547 static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r) {
1548         fprintf( tr.logFile, "glTexCoord3i %d %d %d\n", s, t, r );
1549         dllTexCoord3i(s, t, r);
1550 }
1551
1552 static void APIENTRY logTexCoord3iv(const GLint *v) {
1553 // unknown type: "const GLint *" name: "v"
1554         fprintf( tr.logFile, "glTexCoord3iv 'const GLint * v'\n" );
1555         dllTexCoord3iv(v);
1556 }
1557
1558 static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r) {
1559         fprintf( tr.logFile, "glTexCoord3s %d %d %d\n", s, t, r );
1560         dllTexCoord3s(s, t, r);
1561 }
1562
1563 static void APIENTRY logTexCoord3sv(const GLshort *v) {
1564 // unknown type: "const GLshort *" name: "v"
1565         fprintf( tr.logFile, "glTexCoord3sv 'const GLshort * v'\n" );
1566         dllTexCoord3sv(v);
1567 }
1568
1569 static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
1570         fprintf( tr.logFile, "glTexCoord4d %g %g %g %g\n", s, t, r, q );
1571         dllTexCoord4d(s, t, r, q);
1572 }
1573
1574 static void APIENTRY logTexCoord4dv(const GLdouble *v) {
1575 // unknown type: "const GLdouble *" name: "v"
1576         fprintf( tr.logFile, "glTexCoord4dv 'const GLdouble * v'\n" );
1577         dllTexCoord4dv(v);
1578 }
1579
1580 static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
1581         fprintf( tr.logFile, "glTexCoord4f %g %g %g %g\n", s, t, r, q );
1582         dllTexCoord4f(s, t, r, q);
1583 }
1584
1585 static void APIENTRY logTexCoord4fv(const GLfloat *v) {
1586 // unknown type: "const GLfloat *" name: "v"
1587         fprintf( tr.logFile, "glTexCoord4fv 'const GLfloat * v'\n" );
1588         dllTexCoord4fv(v);
1589 }
1590
1591 static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
1592         fprintf( tr.logFile, "glTexCoord4i %d %d %d %d\n", s, t, r, q );
1593         dllTexCoord4i(s, t, r, q);
1594 }
1595
1596 static void APIENTRY logTexCoord4iv(const GLint *v) {
1597 // unknown type: "const GLint *" name: "v"
1598         fprintf( tr.logFile, "glTexCoord4iv 'const GLint * v'\n" );
1599         dllTexCoord4iv(v);
1600 }
1601
1602 static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
1603         fprintf( tr.logFile, "glTexCoord4s %d %d %d %d\n", s, t, r, q );
1604         dllTexCoord4s(s, t, r, q);
1605 }
1606
1607 static void APIENTRY logTexCoord4sv(const GLshort *v) {
1608 // unknown type: "const GLshort *" name: "v"
1609         fprintf( tr.logFile, "glTexCoord4sv 'const GLshort * v'\n" );
1610         dllTexCoord4sv(v);
1611 }
1612
1613 static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
1614 // unknown type: "const GLvoid *" name: "pointer"
1615         fprintf( tr.logFile, "glTexCoordPointer %d %s %d 'const GLvoid * pointer'\n", size, EnumString(type), stride );
1616         dllTexCoordPointer(size, type, stride, pointer);
1617 }
1618
1619 static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param) {
1620         fprintf( tr.logFile, "glTexEnvf %s %s %g\n", EnumString(target), EnumString(pname), param );
1621         dllTexEnvf(target, pname, param);
1622 }
1623
1624 static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
1625 // unknown type: "const GLfloat *" name: "params"
1626         fprintf( tr.logFile, "glTexEnvfv %s %s 'const GLfloat * params'\n", EnumString(target), EnumString(pname) );
1627         dllTexEnvfv(target, pname, params);
1628 }
1629
1630 static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param) {
1631         fprintf( tr.logFile, "glTexEnvi %s %s %d\n", EnumString(target), EnumString(pname), param );
1632         dllTexEnvi(target, pname, param);
1633 }
1634
1635 static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params) {
1636 // unknown type: "const GLint *" name: "params"
1637         fprintf( tr.logFile, "glTexEnviv %s %s 'const GLint * params'\n", EnumString(target), EnumString(pname) );
1638         dllTexEnviv(target, pname, params);
1639 }
1640
1641 static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param) {
1642         fprintf( tr.logFile, "glTexGend %s %s %g\n", EnumString(coord), EnumString(pname), param );
1643         dllTexGend(coord, pname, param);
1644 }
1645
1646 static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
1647 // unknown type: "const GLdouble *" name: "params"
1648         fprintf( tr.logFile, "glTexGendv %s %s 'const GLdouble * params'\n", EnumString(coord), EnumString(pname) );
1649         dllTexGendv(coord, pname, params);
1650 }
1651
1652 static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param) {
1653         fprintf( tr.logFile, "glTexGenf %s %s %g\n", EnumString(coord), EnumString(pname), param );
1654         dllTexGenf(coord, pname, param);
1655 }
1656
1657 static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
1658 // unknown type: "const GLfloat *" name: "params"
1659         fprintf( tr.logFile, "glTexGenfv %s %s 'const GLfloat * params'\n", EnumString(coord), EnumString(pname) );
1660         dllTexGenfv(coord, pname, params);
1661 }
1662
1663 static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param) {
1664         fprintf( tr.logFile, "glTexGeni %s %s %d\n", EnumString(coord), EnumString(pname), param );
1665         dllTexGeni(coord, pname, param);
1666 }
1667
1668 static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
1669 // unknown type: "const GLint *" name: "params"
1670         fprintf( tr.logFile, "glTexGeniv %s %s 'const GLint * params'\n", EnumString(coord), EnumString(pname) );
1671         dllTexGeniv(coord, pname, params);
1672 }
1673
1674 static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
1675 // unknown type: "const GLvoid *" name: "pixels"
1676         fprintf( tr.logFile, "glTexImage1D %s %d %d %d %d %s %s 'const GLvoid * pixels'\n", EnumString(target), level, internalformat, width, border, EnumString(format), EnumString(type) );
1677         dllTexImage1D(target, level, internalformat, width, border, format, type, pixels);
1678 }
1679
1680 static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
1681 // unknown type: "const GLvoid *" name: "pixels"
1682         fprintf( tr.logFile, "glTexImage2D %s %d %d %d %d %d %s %s 'const GLvoid * pixels'\n", EnumString(target), level, internalformat, width, height, border, EnumString(format), EnumString(type) );
1683         dllTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
1684 }
1685
1686 static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param) {
1687         fprintf( tr.logFile, "glTexParameterf %s %s %g\n", EnumString(target), EnumString(pname), param );
1688         dllTexParameterf(target, pname, param);
1689 }
1690
1691 static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
1692 // unknown type: "const GLfloat *" name: "params"
1693         fprintf( tr.logFile, "glTexParameterfv %s %s 'const GLfloat * params'\n", EnumString(target), EnumString(pname) );
1694         dllTexParameterfv(target, pname, params);
1695 }
1696
1697 static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param) {
1698         fprintf( tr.logFile, "glTexParameteri %s %s %d\n", EnumString(target), EnumString(pname), param );
1699         dllTexParameteri(target, pname, param);
1700 }
1701
1702 static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
1703 // unknown type: "const GLint *" name: "params"
1704         fprintf( tr.logFile, "glTexParameteriv %s %s 'const GLint * params'\n", EnumString(target), EnumString(pname) );
1705         dllTexParameteriv(target, pname, params);
1706 }
1707
1708 static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) {
1709 // unknown type: "const GLvoid *" name: "pixels"
1710         fprintf( tr.logFile, "glTexSubImage1D %s %d %d %d %s %s 'const GLvoid * pixels'\n", EnumString(target), level, xoffset, width, EnumString(format), EnumString(type) );
1711         dllTexSubImage1D(target, level, xoffset, width, format, type, pixels);
1712 }
1713
1714 static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {
1715 // unknown type: "const GLvoid *" name: "pixels"
1716         fprintf( tr.logFile, "glTexSubImage2D %s %d %d %d %d %d %s %s 'const GLvoid * pixels'\n", EnumString(target), level, xoffset, yoffset, width, height, EnumString(format), EnumString(type) );
1717         dllTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1718 }
1719
1720 static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z) {
1721         fprintf( tr.logFile, "glTranslated %g %g %g\n", x, y, z );
1722         dllTranslated(x, y, z);
1723 }
1724
1725 static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z) {
1726         fprintf( tr.logFile, "glTranslatef %g %g %g\n", x, y, z );
1727         dllTranslatef(x, y, z);
1728 }
1729
1730 static void APIENTRY logVertex2d(GLdouble x, GLdouble y) {
1731         fprintf( tr.logFile, "glVertex2d %g %g\n", x, y );
1732         dllVertex2d(x, y);
1733 }
1734
1735 static void APIENTRY logVertex2dv(const GLdouble *v) {
1736 // unknown type: "const GLdouble *" name: "v"
1737         fprintf( tr.logFile, "glVertex2dv 'const GLdouble * v'\n" );
1738         dllVertex2dv(v);
1739 }
1740
1741 static void APIENTRY logVertex2f(GLfloat x, GLfloat y) {
1742         fprintf( tr.logFile, "glVertex2f %g %g\n", x, y );
1743         dllVertex2f(x, y);
1744 }
1745
1746 static void APIENTRY logVertex2fv(const GLfloat *v) {
1747 // unknown type: "const GLfloat *" name: "v"
1748         fprintf( tr.logFile, "glVertex2fv 'const GLfloat * v'\n" );
1749         dllVertex2fv(v);
1750 }
1751
1752 static void APIENTRY logVertex2i(GLint x, GLint y) {
1753         fprintf( tr.logFile, "glVertex2i %d %d\n", x, y );
1754         dllVertex2i(x, y);
1755 }
1756
1757 static void APIENTRY logVertex2iv(const GLint *v) {
1758 // unknown type: "const GLint *" name: "v"
1759         fprintf( tr.logFile, "glVertex2iv 'const GLint * v'\n" );
1760         dllVertex2iv(v);
1761 }
1762
1763 static void APIENTRY logVertex2s(GLshort x, GLshort y) {
1764         fprintf( tr.logFile, "glVertex2s %d %d\n", x, y );
1765         dllVertex2s(x, y);
1766 }
1767
1768 static void APIENTRY logVertex2sv(const GLshort *v) {
1769 // unknown type: "const GLshort *" name: "v"
1770         fprintf( tr.logFile, "glVertex2sv 'const GLshort * v'\n" );
1771         dllVertex2sv(v);
1772 }
1773
1774 static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z) {
1775         fprintf( tr.logFile, "glVertex3d %g %g %g\n", x, y, z );
1776         dllVertex3d(x, y, z);
1777 }
1778
1779 static void APIENTRY logVertex3dv(const GLdouble *v) {
1780 // unknown type: "const GLdouble *" name: "v"
1781         fprintf( tr.logFile, "glVertex3dv 'const GLdouble * v'\n" );
1782         dllVertex3dv(v);
1783 }
1784
1785 static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z) {
1786         fprintf( tr.logFile, "glVertex3f %g %g %g\n", x, y, z );
1787         dllVertex3f(x, y, z);
1788 }
1789
1790 static void APIENTRY logVertex3fv(const GLfloat *v) {
1791 // unknown type: "const GLfloat *" name: "v"
1792         fprintf( tr.logFile, "glVertex3fv 'const GLfloat * v'\n" );
1793         dllVertex3fv(v);
1794 }
1795
1796 static void APIENTRY logVertex3i(GLint x, GLint y, GLint z) {
1797         fprintf( tr.logFile, "glVertex3i %d %d %d\n", x, y, z );
1798         dllVertex3i(x, y, z);
1799 }
1800
1801 static void APIENTRY logVertex3iv(const GLint *v) {
1802 // unknown type: "const GLint *" name: "v"
1803         fprintf( tr.logFile, "glVertex3iv 'const GLint * v'\n" );
1804         dllVertex3iv(v);
1805 }
1806
1807 static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z) {
1808         fprintf( tr.logFile, "glVertex3s %d %d %d\n", x, y, z );
1809         dllVertex3s(x, y, z);
1810 }
1811
1812 static void APIENTRY logVertex3sv(const GLshort *v) {
1813 // unknown type: "const GLshort *" name: "v"
1814         fprintf( tr.logFile, "glVertex3sv 'const GLshort * v'\n" );
1815         dllVertex3sv(v);
1816 }
1817
1818 static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
1819         fprintf( tr.logFile, "glVertex4d %g %g %g %g\n", x, y, z, w );
1820         dllVertex4d(x, y, z, w);
1821 }
1822
1823 static void APIENTRY logVertex4dv(const GLdouble *v) {
1824 // unknown type: "const GLdouble *" name: "v"
1825         fprintf( tr.logFile, "glVertex4dv 'const GLdouble * v'\n" );
1826         dllVertex4dv(v);
1827 }
1828
1829 static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1830         fprintf( tr.logFile, "glVertex4f %g %g %g %g\n", x, y, z, w );
1831         dllVertex4f(x, y, z, w);
1832 }
1833
1834 static void APIENTRY logVertex4fv(const GLfloat *v) {
1835 // unknown type: "const GLfloat *" name: "v"
1836         fprintf( tr.logFile, "glVertex4fv 'const GLfloat * v'\n" );
1837         dllVertex4fv(v);
1838 }
1839
1840 static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w) {
1841         fprintf( tr.logFile, "glVertex4i %d %d %d %d\n", x, y, z, w );
1842         dllVertex4i(x, y, z, w);
1843 }
1844
1845 static void APIENTRY logVertex4iv(const GLint *v) {
1846 // unknown type: "const GLint *" name: "v"
1847         fprintf( tr.logFile, "glVertex4iv 'const GLint * v'\n" );
1848         dllVertex4iv(v);
1849 }
1850
1851 static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
1852         fprintf( tr.logFile, "glVertex4s %d %d %d %d\n", x, y, z, w );
1853         dllVertex4s(x, y, z, w);
1854 }
1855
1856 static void APIENTRY logVertex4sv(const GLshort *v) {
1857 // unknown type: "const GLshort *" name: "v"
1858         fprintf( tr.logFile, "glVertex4sv 'const GLshort * v'\n" );
1859         dllVertex4sv(v);
1860 }
1861
1862 static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
1863 // unknown type: "const GLvoid *" name: "pointer"
1864         fprintf( tr.logFile, "glVertexPointer %d %s %d 'const GLvoid * pointer'\n", size, EnumString(type), stride );
1865         dllVertexPointer(size, type, stride, pointer);
1866 }
1867
1868 static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
1869         fprintf( tr.logFile, "glViewport %d %d %d %d\n", x, y, width, height );
1870         dllViewport(x, y, width, height);
1871 }
1872
1873
1874 #ifdef __linux__
1875
1876 static XVisualInfo * APIENTRY logChooseVisual(Display *dpy, int screen, int *attribList) {
1877 // unknown type: "Display *" name: "dpy"
1878 // unknown type: "int" name: "screen"
1879 // unknown type: "int *" name: "attribList"
1880         fprintf( tr.logFile, "glXChooseVisual 'Display * dpy' 'int screen' 'int * attribList'\n" );
1881         return dllChooseVisual(dpy, screen, attribList);
1882 }
1883
1884 static GLXContext APIENTRY logCreateContext(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct) {
1885 // unknown type: "Display *" name: "dpy"
1886 // unknown type: "XVisualInfo *" name: "vis"
1887 // unknown type: "GLXContext" name: "shareList"
1888 // unknown type: "Bool" name: "direct"
1889         fprintf( tr.logFile, "glXCreateContext 'Display * dpy' 'XVisualInfo * vis' 'GLXContext shareList' 'Bool direct'\n" );
1890         return dllCreateContext(dpy, vis, shareList, direct);
1891 }
1892
1893 static void APIENTRY logDestroyContext(Display *dpy, GLXContext ctx) {
1894 // unknown type: "Display *" name: "dpy"
1895 // unknown type: "GLXContext" name: "ctx"
1896         fprintf( tr.logFile, "glXDestroyContext 'Display * dpy' 'GLXContext ctx'\n" );
1897         dllDestroyContext(dpy, ctx);
1898 }
1899
1900 static Bool APIENTRY logMakeCurrent(Display *dpy, GLXDrawable drawable, GLXContext ctx) {
1901 // unknown type: "Display *" name: "dpy"
1902 // unknown type: "GLXDrawable" name: "drawable"
1903 // unknown type: "GLXContext" name: "ctx"
1904         fprintf( tr.logFile, "glXMakeCurrent 'Display * dpy' 'GLXDrawable drawable' 'GLXContext ctx'\n" );
1905         return dllMakeCurrent(dpy, drawable, ctx);
1906 }
1907
1908 static void APIENTRY logSwapBuffers(Display *dpy, GLXDrawable drawable) {
1909 // unknown type: "Display *" name: "dpy"
1910 // unknown type: "GLXDrawable" name: "drawable"
1911         fprintf( tr.logFile, "glXSwapBuffers 'Display * dpy' 'GLXDrawable drawable'\n" );
1912         dllSwapBuffers(dpy, drawable);
1913 }
1914
1915
1916 #endif
1917
1918
1919 #ifdef WIN32
1920
1921
1922 #endif
1923