Lib/XGL/xgl.c

   1 #ifdef HAVE_CONFIG_H
   2 #  include <config.h>
   3 #endif
   4
   5 #ifdef HAVE_WINDOWS_H
   6 #  include <windows.h>
   7 #endif
   8
   9 #include "xgl.h"
  10 #include <GL/glut.h>
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14
  15 #ifdef HAVE_UNISTD_H
  16 #  include <unistd.h>
  17 #endif
  18
  19
  20 #ifdef XGL_TRACE
  21
  22 #ifndef TRUE
  23 #define TRUE  1
  24 #define FALSE 0
  25 #endif
  26
  27 GLboolean xglIsEnabled ( GLenum cap )
  28 {
  29   if ( xglTraceIsEnabled("glIsEnabled") )
  30     fprintf ( xglTraceFd, "  /* glIsEnabled ( (GLenum)%s ) ; */\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
  31
  32   return glIsEnabled ( cap ) ;
  33 }
  34
  35 GLboolean xglIsList ( GLuint list )
  36 {
  37   if ( xglTraceIsEnabled("glIsList") )
  38     fprintf ( xglTraceFd, "  /* glIsList ( (GLuint)%u ) ; */\n" , list ) ;
  39
  40   return glIsList ( list ) ;
  41 }
  42
  43 GLenum xglGetError (  )
  44 {
  45   if ( xglTraceIsEnabled("glGetError") )
  46     fprintf ( xglTraceFd, "  /* glGetError (  ) ; */\n"  ) ;
  47
  48   return glGetError (  ) ;
  49 }
  50
  51 GLint xglRenderMode ( GLenum mode )
  52 {
  53   if ( xglTraceIsEnabled("glRenderMode") )
  54     fprintf ( xglTraceFd, "  glRenderMode ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
  55
  56   return glRenderMode ( mode ) ;
  57 }
  58
  59 GLuint xglGenLists ( GLsizei range )
  60 {
  61   if ( xglTraceIsEnabled("glGenLists") )
  62     fprintf ( xglTraceFd, "  glGenLists ( (GLsizei)%d ) ;\n" , range ) ;
  63
  64   return glGenLists ( range ) ;
  65 }
  66
  67 const GLubyte* xglGetString ( GLenum name )
  68 {
  69   if ( xglTraceIsEnabled("glGetString") )
  70     fprintf ( xglTraceFd, "  /* glGetString ( (GLenum)%s ) ; */\n" , xglExpandGLenum ( (GLenum) name ) ) ;
  71
  72   return glGetString ( name ) ;
  73 }
  74
  75 void xglAccum ( GLenum op, GLfloat value )
  76 {
  77   if ( xglTraceIsEnabled("glAccum") )
  78     fprintf ( xglTraceFd, "  glAccum ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) op ), value ) ;
  79   if ( xglExecuteIsEnabled("glAccum") )
  80     glAccum ( op, value ) ;
  81 }
  82
  83 void xglAlphaFunc ( GLenum func, GLclampf ref )
  84 {
  85   if ( xglTraceIsEnabled("glAlphaFunc") )
  86     fprintf ( xglTraceFd, "  glAlphaFunc ( (GLenum)%s, (GLclampf)%ff ) ;\n" , xglExpandGLenum ( (GLenum) func ), ref ) ;
  87   if ( xglExecuteIsEnabled("glAlphaFunc") )
  88     glAlphaFunc ( func, ref ) ;
  89 }
  90
  91 void xglArrayElementEXT ( GLint i )
  92 {
  93   if ( xglTraceIsEnabled("glArrayElementEXT") )
  94     fprintf ( xglTraceFd, "  glArrayElementEXT ( (GLint)%d ) ;\n" , i ) ;
  95 #ifdef GL_VERSION_1_1
  96     glArrayElement ( i ) ;
  97 #else
  98 #ifdef GL_EXT_vertex_array
  99   if ( xglExecuteIsEnabled("glArrayElementEXT") )
 100     glArrayElementEXT ( i ) ;
 101 #else
 102   fprintf ( xglTraceFd, "  glArrayElementEXT isn't supported on this OpenGL!\n" ) ;
 103 #endif
 104 #endif
 105 }
 106
 107 void xglBegin ( GLenum mode )
 108 {
 109   if ( xglTraceIsEnabled("glBegin") )
 110     fprintf ( xglTraceFd, "  glBegin ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
 111   if ( xglExecuteIsEnabled("glBegin") )
 112     glBegin ( mode ) ;
 113 }
 114
 115 void xglBitmap ( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte* bitmap )
 116 {
 117   if ( xglTraceIsEnabled("glBitmap") )
 118     fprintf ( xglTraceFd, "  glBitmap ( (GLsizei)%d, (GLsizei)%d, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLubyte *)0x%08x ) ;\n" , width, height, xorig, yorig, xmove, ymove, bitmap ) ;
 119   if ( xglExecuteIsEnabled("glBitmap") )
 120     glBitmap ( width, height, xorig, yorig, xmove, ymove, bitmap ) ;
 121 }
 122
 123 void xglBlendColorEXT ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 124 {
 125   if ( xglTraceIsEnabled("glBlendColorEXT") )
 126     fprintf ( xglTraceFd, "  glBlendColorEXT ( (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff ) ;\n" , red, green, blue, alpha ) ;
 127 #ifdef GL_EXT_blend_color
 128   if ( xglExecuteIsEnabled("glBlendColorEXT") )
 129     glBlendColorEXT ( red, green, blue, alpha ) ;
 130 #else
 131   fprintf ( xglTraceFd, "  glBlendColorEXT isn't supported on this OpenGL!\n" ) ;
 132 #endif
 133 }
 134
 135 void xglBlendEquationEXT ( GLenum mode )
 136 {
 137   if ( xglTraceIsEnabled("glBlendEquationEXT") )
 138     fprintf ( xglTraceFd, "  glBlendEquationEXT ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
 139 #ifdef GL_EXT_blend_minmax
 140   if ( xglExecuteIsEnabled("glBlendEquationEXT") )
 141     glBlendEquationEXT ( mode ) ;
 142 #else
 143   fprintf ( xglTraceFd, "  glBlendEquationEXT isn't supported on this OpenGL!\n" ) ;
 144 #endif
 145 }
 146
 147 void xglBlendFunc ( GLenum sfactor, GLenum dfactor )
 148 {
 149   if ( xglTraceIsEnabled("glBlendFunc") )
 150     fprintf ( xglTraceFd, "  glBlendFunc ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) sfactor ), xglExpandGLenum ( (GLenum) dfactor ) ) ;
 151   if ( xglExecuteIsEnabled("glBlendFunc") )
 152     glBlendFunc ( sfactor, dfactor ) ;
 153 }
 154
 155 void xglCallList ( GLuint list )
 156 {
 157   if ( xglTraceIsEnabled("glCallList") )
 158     fprintf ( xglTraceFd, "  glCallList ( (GLuint)%u ) ;\n" , list ) ;
 159   if ( xglExecuteIsEnabled("glCallList") )
 160     glCallList ( list ) ;
 161 }
 162
 163 void xglCallLists ( GLsizei n, GLenum type, GLvoid* lists )
 164 {
 165   if ( xglTraceIsEnabled("glCallLists") )
 166     fprintf ( xglTraceFd, "  glCallLists ( (GLsizei)%d, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , n, xglExpandGLenum ( (GLenum) type ), lists ) ;
 167   if ( xglExecuteIsEnabled("glCallLists") )
 168     glCallLists ( n, type, lists ) ;
 169 }
 170
 171
 172 void xglClear ( GLbitfield mask )
 173 {
 174   if ( xglTraceIsEnabled("glClear") )
 175     switch ( mask )
 176     {
 177       case GL_COLOR_BUFFER_BIT :
 178         fprintf ( xglTraceFd, "  glClear ( GL_COLOR_BUFFER_BIT ) ;\n" ) ;
 179         break ;
 180       case GL_DEPTH_BUFFER_BIT :
 181         fprintf ( xglTraceFd, "  glClear ( GL_DEPTH_BUFFER_BIT ) ;\n" ) ;
 182         break ;
 183       case GL_ACCUM_BUFFER_BIT :
 184         fprintf ( xglTraceFd, "  glClear ( GL_ACCUM_BUFFER_BIT ) ;\n" ) ;
 185         break ;
 186       case GL_STENCIL_BUFFER_BIT :
 187         fprintf ( xglTraceFd, "  glClear ( GL_STENCIL_BUFFER_BIT ) ;\n" ) ;
 188         break ;
 189       case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) :
 190         fprintf ( xglTraceFd, "  glClear ( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT ) ;\n" ) ;
 191         break ;
 192
 193       default :
 194         fprintf ( xglTraceFd, "  glClear ( (GLbitfield)0x%08x ) ;\n" , mask ) ; break ;
 195     }
 196
 197   if ( xglExecuteIsEnabled("glClear") )
 198     glClear ( mask ) ;
 199 }
 200
 201
 202 void xglClearAccum ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
 203 {
 204   if ( xglTraceIsEnabled("glClearAccum") )
 205     fprintf ( xglTraceFd, "  glClearAccum ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue, alpha ) ;
 206   if ( xglExecuteIsEnabled("glClearAccum") )
 207     glClearAccum ( red, green, blue, alpha ) ;
 208 }
 209
 210 void xglClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 211 {
 212   if ( xglTraceIsEnabled("glClearColor") )
 213     fprintf ( xglTraceFd, "  glClearColor ( (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff ) ;\n" , red, green, blue, alpha ) ;
 214   if ( xglExecuteIsEnabled("glClearColor") )
 215     glClearColor ( red, green, blue, alpha ) ;
 216 }
 217
 218 void xglClearDepth ( GLclampd depth )
 219 {
 220   if ( xglTraceIsEnabled("glClearDepth") )
 221     fprintf ( xglTraceFd, "  glClearDepth ( (GLclampd)%f ) ;\n" , depth ) ;
 222   if ( xglExecuteIsEnabled("glClearDepth") )
 223     glClearDepth ( depth ) ;
 224 }
 225
 226 void xglClearIndex ( GLfloat c )
 227 {
 228   if ( xglTraceIsEnabled("glClearIndex") )
 229     fprintf ( xglTraceFd, "  glClearIndex ( (GLfloat)%ff ) ;\n" , c ) ;
 230   if ( xglExecuteIsEnabled("glClearIndex") )
 231     glClearIndex ( c ) ;
 232 }
 233
 234 void xglClearStencil ( GLint s )
 235 {
 236   if ( xglTraceIsEnabled("glClearStencil") )
 237     fprintf ( xglTraceFd, "  glClearStencil ( (GLint)%d ) ;\n" , s ) ;
 238   if ( xglExecuteIsEnabled("glClearStencil") )
 239     glClearStencil ( s ) ;
 240 }
 241
 242 void xglClipPlane ( GLenum plane, GLdouble* equation )
 243 {
 244   if ( xglTraceIsEnabled("glClipPlane") )
 245     fprintf ( xglTraceFd, "  glClipPlane ( (GLenum)%s, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) plane ), equation ) ;
 246   if ( xglExecuteIsEnabled("glClipPlane") )
 247     glClipPlane ( plane, equation ) ;
 248 }
 249
 250 void xglColor3b ( GLbyte red, GLbyte green, GLbyte blue )
 251 {
 252   if ( xglTraceIsEnabled("glColor3b") )
 253     fprintf ( xglTraceFd, "  glColor3b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , red, green, blue ) ;
 254   if ( xglExecuteIsEnabled("glColor3b") )
 255     glColor3b ( red, green, blue ) ;
 256 }
 257
 258 void xglColor3bv ( GLbyte* v )
 259 {
 260   if ( xglTraceIsEnabled("glColor3bv") )
 261     fprintf ( xglTraceFd, "  glColor3bv ( xglBuild3bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 262   if ( xglExecuteIsEnabled("glColor3bv") )
 263     glColor3bv ( v ) ;
 264 }
 265
 266 void xglColor3d ( GLdouble red, GLdouble green, GLdouble blue )
 267 {
 268   if ( xglTraceIsEnabled("glColor3d") )
 269     fprintf ( xglTraceFd, "  glColor3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , red, green, blue ) ;
 270   if ( xglExecuteIsEnabled("glColor3d") )
 271     glColor3d ( red, green, blue ) ;
 272 }
 273
 274 void xglColor3dv ( GLdouble* v )
 275 {
 276   if ( xglTraceIsEnabled("glColor3dv") )
 277     fprintf ( xglTraceFd, "  glColor3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
 278   if ( xglExecuteIsEnabled("glColor3dv") )
 279     glColor3dv ( v ) ;
 280 }
 281
 282 void xglColor3f ( GLfloat red, GLfloat green, GLfloat blue )
 283 {
 284   if ( xglTraceIsEnabled("glColor3f") )
 285     fprintf ( xglTraceFd, "  glColor3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue ) ;
 286   if ( xglExecuteIsEnabled("glColor3f") )
 287     glColor3f ( red, green, blue ) ;
 288 }
 289
 290 void xglColor3fv ( GLfloat* v )
 291 {
 292   if ( xglTraceIsEnabled("glColor3fv") )
 293     fprintf ( xglTraceFd, "  glColor3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
 294   if ( xglExecuteIsEnabled("glColor3fv") )
 295     glColor3fv ( v ) ;
 296 }
 297
 298 void xglColor3i ( GLint red, GLint green, GLint blue )
 299 {
 300   if ( xglTraceIsEnabled("glColor3i") )
 301     fprintf ( xglTraceFd, "  glColor3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , red, green, blue ) ;
 302   if ( xglExecuteIsEnabled("glColor3i") )
 303     glColor3i ( red, green, blue ) ;
 304 }
 305
 306 void xglColor3iv ( GLint* v )
 307 {
 308   if ( xglTraceIsEnabled("glColor3iv") )
 309     fprintf ( xglTraceFd, "  glColor3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 310   if ( xglExecuteIsEnabled("glColor3iv") )
 311     glColor3iv ( v ) ;
 312 }
 313
 314 void xglColor3s ( GLshort red, GLshort green, GLshort blue )
 315 {
 316   if ( xglTraceIsEnabled("glColor3s") )
 317     fprintf ( xglTraceFd, "  glColor3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , red, green, blue ) ;
 318   if ( xglExecuteIsEnabled("glColor3s") )
 319     glColor3s ( red, green, blue ) ;
 320 }
 321
 322 void xglColor3sv ( GLshort* v )
 323 {
 324   if ( xglTraceIsEnabled("glColor3sv") )
 325     fprintf ( xglTraceFd, "  glColor3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 326   if ( xglExecuteIsEnabled("glColor3sv") )
 327     glColor3sv ( v ) ;
 328 }
 329
 330 void xglColor3ub ( GLubyte red, GLubyte green, GLubyte blue )
 331 {
 332   if ( xglTraceIsEnabled("glColor3ub") )
 333     fprintf ( xglTraceFd, "  glColor3ub ( (GLubyte)%u, (GLubyte)%u, (GLubyte)%u ) ;\n" , red, green, blue ) ;
 334   if ( xglExecuteIsEnabled("glColor3ub") )
 335     glColor3ub ( red, green, blue ) ;
 336 }
 337
 338 void xglColor3ubv ( GLubyte* v )
 339 {
 340   if ( xglTraceIsEnabled("glColor3ubv") )
 341     fprintf ( xglTraceFd, "  glColor3ubv ( xglBuild3ubv((GLubyte)%d,(GLubyte)%d,(GLubyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 342   if ( xglExecuteIsEnabled("glColor3ubv") )
 343     glColor3ubv ( v ) ;
 344 }
 345
 346 void xglColor3ui ( GLuint red, GLuint green, GLuint blue )
 347 {
 348   if ( xglTraceIsEnabled("glColor3ui") )
 349     fprintf ( xglTraceFd, "  glColor3ui ( (GLuint)%u, (GLuint)%u, (GLuint)%u ) ;\n" , red, green, blue ) ;
 350   if ( xglExecuteIsEnabled("glColor3ui") )
 351     glColor3ui ( red, green, blue ) ;
 352 }
 353
 354 void xglColor3uiv ( GLuint* v )
 355 {
 356   if ( xglTraceIsEnabled("glColor3uiv") )
 357     fprintf ( xglTraceFd, "  glColor3uiv ( xglBuild3uiv((GLuint)%d,(GLuint)%d,(GLuint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 358   if ( xglExecuteIsEnabled("glColor3uiv") )
 359     glColor3uiv ( v ) ;
 360 }
 361
 362 void xglColor3us ( GLushort red, GLushort green, GLushort blue )
 363 {
 364   if ( xglTraceIsEnabled("glColor3us") )
 365     fprintf ( xglTraceFd, "  glColor3us ( (GLushort)%u, (GLushort)%u, (GLushort)%u ) ;\n" , red, green, blue ) ;
 366   if ( xglExecuteIsEnabled("glColor3us") )
 367     glColor3us ( red, green, blue ) ;
 368 }
 369
 370 void xglColor3usv ( GLushort* v )
 371 {
 372   if ( xglTraceIsEnabled("glColor3usv") )
 373     fprintf ( xglTraceFd, "  glColor3usv ( xglBuild3usv((GLushort)%d,(GLushort)%d,(GLushort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
 374   if ( xglExecuteIsEnabled("glColor3usv") )
 375     glColor3usv ( v ) ;
 376 }
 377
 378 void xglColor4b ( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
 379 {
 380   if ( xglTraceIsEnabled("glColor4b") )
 381     fprintf ( xglTraceFd, "  glColor4b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , red, green, blue, alpha ) ;
 382   if ( xglExecuteIsEnabled("glColor4b") )
 383     glColor4b ( red, green, blue, alpha ) ;
 384 }
 385
 386 void xglColor4bv ( GLbyte* v )
 387 {
 388   if ( xglTraceIsEnabled("glColor4bv") )
 389     fprintf ( xglTraceFd, "  glColor4bv ( xglBuild4bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 390   if ( xglExecuteIsEnabled("glColor4bv") )
 391     glColor4bv ( v ) ;
 392 }
 393
 394 void xglColor4d ( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
 395 {
 396   if ( xglTraceIsEnabled("glColor4d") )
 397     fprintf ( xglTraceFd, "  glColor4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , red, green, blue, alpha ) ;
 398   if ( xglExecuteIsEnabled("glColor4d") )
 399     glColor4d ( red, green, blue, alpha ) ;
 400 }
 401
 402 void xglColor4dv ( GLdouble* v )
 403 {
 404   if ( xglTraceIsEnabled("glColor4dv") )
 405     fprintf ( xglTraceFd, "  glColor4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 406   if ( xglExecuteIsEnabled("glColor4dv") )
 407     glColor4dv ( v ) ;
 408 }
 409
 410 void xglColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
 411 {
 412   if ( xglTraceIsEnabled("glColor4f") )
 413     fprintf ( xglTraceFd, "  glColor4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue, alpha ) ;
 414   if ( xglExecuteIsEnabled("glColor4f") )
 415     glColor4f ( red, green, blue, alpha ) ;
 416 }
 417
 418 void xglColor4fv ( GLfloat* v )
 419 {
 420   if ( xglTraceIsEnabled("glColor4fv") )
 421     fprintf ( xglTraceFd, "  glColor4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 422   if ( xglExecuteIsEnabled("glColor4fv") )
 423     glColor4fv ( v ) ;
 424 }
 425
 426 void xglColor4i ( GLint red, GLint green, GLint blue, GLint alpha )
 427 {
 428   if ( xglTraceIsEnabled("glColor4i") )
 429     fprintf ( xglTraceFd, "  glColor4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , red, green, blue, alpha ) ;
 430   if ( xglExecuteIsEnabled("glColor4i") )
 431     glColor4i ( red, green, blue, alpha ) ;
 432 }
 433
 434 void xglColor4iv ( GLint* v )
 435 {
 436   if ( xglTraceIsEnabled("glColor4iv") )
 437     fprintf ( xglTraceFd, "  glColor4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 438   if ( xglExecuteIsEnabled("glColor4iv") )
 439     glColor4iv ( v ) ;
 440 }
 441
 442 void xglColor4s ( GLshort red, GLshort green, GLshort blue, GLshort alpha )
 443 {
 444   if ( xglTraceIsEnabled("glColor4s") )
 445     fprintf ( xglTraceFd, "  glColor4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , red, green, blue, alpha ) ;
 446   if ( xglExecuteIsEnabled("glColor4s") )
 447     glColor4s ( red, green, blue, alpha ) ;
 448 }
 449
 450 void xglColor4sv ( GLshort* v )
 451 {
 452   if ( xglTraceIsEnabled("glColor4sv") )
 453     fprintf ( xglTraceFd, "  glColor4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 454   if ( xglExecuteIsEnabled("glColor4sv") )
 455     glColor4sv ( v ) ;
 456 }
 457
 458 void xglColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
 459 {
 460   if ( xglTraceIsEnabled("glColor4ub") )
 461     fprintf ( xglTraceFd, "  glColor4ub ( (GLubyte)%u, (GLubyte)%u, (GLubyte)%u, (GLubyte)%u ) ;\n" , red, green, blue, alpha ) ;
 462   if ( xglExecuteIsEnabled("glColor4ub") )
 463     glColor4ub ( red, green, blue, alpha ) ;
 464 }
 465
 466 void xglColor4ubv ( GLubyte* v )
 467 {
 468   if ( xglTraceIsEnabled("glColor4ubv") )
 469     fprintf ( xglTraceFd, "  glColor4ubv ( xglBuild4ubv((GLubyte)%d,(GLubyte)%d,(GLubyte)%d,(GLubyte)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 470   if ( xglExecuteIsEnabled("glColor4ubv") )
 471     glColor4ubv ( v ) ;
 472 }
 473
 474 void xglColor4ui ( GLuint red, GLuint green, GLuint blue, GLuint alpha )
 475 {
 476   if ( xglTraceIsEnabled("glColor4ui") )
 477     fprintf ( xglTraceFd, "  glColor4ui ( (GLuint)%u, (GLuint)%u, (GLuint)%u, (GLuint)%u ) ;\n" , red, green, blue, alpha ) ;
 478   if ( xglExecuteIsEnabled("glColor4ui") )
 479     glColor4ui ( red, green, blue, alpha ) ;
 480 }
 481
 482 void xglColor4uiv ( GLuint* v )
 483 {
 484   if ( xglTraceIsEnabled("glColor4uiv") )
 485     fprintf ( xglTraceFd, "  glColor4uiv ( xglBuild4uiv((GLuint)%d,(GLuint)%d,(GLuint)%d,(GLuint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 486   if ( xglExecuteIsEnabled("glColor4uiv") )
 487     glColor4uiv ( v ) ;
 488 }
 489
 490 void xglColor4us ( GLushort red, GLushort green, GLushort blue, GLushort alpha )
 491 {
 492   if ( xglTraceIsEnabled("glColor4us") )
 493     fprintf ( xglTraceFd, "  glColor4us ( (GLushort)%u, (GLushort)%u, (GLushort)%u, (GLushort)%u ) ;\n" , red, green, blue, alpha ) ;
 494   if ( xglExecuteIsEnabled("glColor4us") )
 495     glColor4us ( red, green, blue, alpha ) ;
 496 }
 497
 498 void xglColor4usv ( GLushort* v )
 499 {
 500   if ( xglTraceIsEnabled("glColor4usv") )
 501     fprintf ( xglTraceFd, "  glColor4usv ( xglBuild4usv((GLushort)%d,(GLushort)%d,(GLushort)%d,(GLushort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
 502   if ( xglExecuteIsEnabled("glColor4usv") )
 503     glColor4usv ( v ) ;
 504 }
 505
 506 void xglColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
 507 {
 508   if ( xglTraceIsEnabled("glColorMask") )
 509     fprintf ( xglTraceFd, "  glColorMask ( (GLboolean)%d, (GLboolean)%d, (GLboolean)%d, (GLboolean)%d ) ;\n" , red, green, blue, alpha ) ;
 510   if ( xglExecuteIsEnabled("glColorMask") )
 511     glColorMask ( red, green, blue, alpha ) ;
 512 }
 513
 514 void xglColorMaterial ( GLenum face, GLenum mode )
 515 {
 516   if ( xglTraceIsEnabled("glColorMaterial") )
 517     fprintf ( xglTraceFd, "  glColorMaterial ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) mode ) ) ;
 518   if ( xglExecuteIsEnabled("glColorMaterial") )
 519     glColorMaterial ( face, mode ) ;
 520 }
 521
 522 void xglColorPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
 523 {
 524   if ( xglTraceIsEnabled("glColorPointerEXT") )
 525     fprintf ( xglTraceFd, "  glColorPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
 526 #ifdef GL_VERSION_1_1
 527     glColorPointer ( size, type, stride, ptr ) ;
 528 #else
 529 #ifdef GL_EXT_vertex_array
 530   if ( xglExecuteIsEnabled("glColorPointerEXT") )
 531     glColorPointerEXT ( size, type, stride, count, ptr ) ;
 532 #else
 533   fprintf ( xglTraceFd, "  glColorPointerEXT isn't supported on this OpenGL!\n" ) ;
 534 #endif
 535 #endif
 536 }
 537
 538 void xglCopyPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
 539 {
 540   if ( xglTraceIsEnabled("glCopyPixels") )
 541     fprintf ( xglTraceFd, "  glCopyPixels ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d, (GLenum)%s ) ;\n" , x, y, width, height, xglExpandGLenum ( (GLenum) type ) ) ;
 542   if ( xglExecuteIsEnabled("glCopyPixels") )
 543     glCopyPixels ( x, y, width, height, type ) ;
 544 }
 545
 546 void xglCullFace ( GLenum mode )
 547 {
 548   if ( xglTraceIsEnabled("glCullFace") )
 549     fprintf ( xglTraceFd, "  glCullFace ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
 550   if ( xglExecuteIsEnabled("glCullFace") )
 551     glCullFace ( mode ) ;
 552 }
 553
 554 void xglDeleteLists ( GLuint list, GLsizei range )
 555 {
 556   if ( xglTraceIsEnabled("glDeleteLists") )
 557     fprintf ( xglTraceFd, "  glDeleteLists ( (GLuint)%u, (GLsizei)%d ) ;\n" , list, range ) ;
 558   if ( xglExecuteIsEnabled("glDeleteLists") )
 559     glDeleteLists ( list, range ) ;
 560 }
 561
 562 void xglDepthFunc ( GLenum func )
 563 {
 564   if ( xglTraceIsEnabled("glDepthFunc") )
 565     fprintf ( xglTraceFd, "  glDepthFunc ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) func ) ) ;
 566   if ( xglExecuteIsEnabled("glDepthFunc") )
 567     glDepthFunc ( func ) ;
 568 }
 569
 570 void xglDepthMask ( GLboolean flag )
 571 {
 572   if ( xglTraceIsEnabled("glDepthMask") )
 573     fprintf ( xglTraceFd, "  glDepthMask ( (GLboolean)%d ) ;\n" , flag ) ;
 574   if ( xglExecuteIsEnabled("glDepthMask") )
 575     glDepthMask ( flag ) ;
 576 }
 577
 578 void xglDepthRange ( GLclampd near_val, GLclampd far_val )
 579 {
 580   if ( xglTraceIsEnabled("glDepthRange") )
 581     fprintf ( xglTraceFd, "  glDepthRange ( (GLclampd)%f, (GLclampd)%f ) ;\n" , near_val, far_val ) ;
 582   if ( xglExecuteIsEnabled("glDepthRange") )
 583     glDepthRange ( near_val, far_val ) ;
 584 }
 585
 586 void xglDisable ( GLenum cap )
 587 {
 588   if ( xglTraceIsEnabled("glDisable") )
 589     fprintf ( xglTraceFd, "  glDisable ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
 590   if ( xglExecuteIsEnabled("glDisable") )
 591     glDisable ( cap ) ;
 592 }
 593
 594 void xglDrawArraysEXT ( GLenum mode, GLint first, GLsizei count )
 595 {
 596   if ( xglTraceIsEnabled("glDrawArraysEXT") )
 597     fprintf ( xglTraceFd, "  glDrawArraysEXT ( (GLenum)%s, (GLint)%d, (GLsizei)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), first, count ) ;
 598 #ifdef GL_VERSION_1_1
 599     glDrawArrays ( mode, first, count ) ;
 600 #else
 601 #ifdef GL_EXT_vertex_array
 602   if ( xglExecuteIsEnabled("glDrawArraysEXT") )
 603     glDrawArraysEXT ( mode, first, count ) ;
 604 #else
 605   fprintf ( xglTraceFd, "  glDrawArraysEXT isn't supported on this OpenGL!\n" ) ;
 606 #endif
 607 #endif
 608 }
 609
 610 void xglDrawBuffer ( GLenum mode )
 611 {
 612   if ( xglTraceIsEnabled("glDrawBuffer") )
 613     fprintf ( xglTraceFd, "  glDrawBuffer ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
 614   if ( xglExecuteIsEnabled("glDrawBuffer") )
 615     glDrawBuffer ( mode ) ;
 616 }
 617
 618 void xglDrawPixels ( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels )
 619 {
 620   if ( xglTraceIsEnabled("glDrawPixels") )
 621     fprintf ( xglTraceFd, "  glDrawPixels ( (GLsizei)%d, (GLsizei)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , width, height, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
 622   if ( xglExecuteIsEnabled("glDrawPixels") )
 623     glDrawPixels ( width, height, format, type, pixels ) ;
 624 }
 625
 626 void xglEdgeFlag ( GLboolean flag )
 627 {
 628   if ( xglTraceIsEnabled("glEdgeFlag") )
 629     fprintf ( xglTraceFd, "  glEdgeFlag ( (GLboolean)%d ) ;\n" , flag ) ;
 630   if ( xglExecuteIsEnabled("glEdgeFlag") )
 631     glEdgeFlag ( flag ) ;
 632 }
 633
 634 void xglEdgeFlagPointerEXT ( GLsizei stride, GLsizei count, GLboolean* ptr )
 635 {
 636   if ( xglTraceIsEnabled("glEdgeFlagPointerEXT") )
 637     fprintf ( xglTraceFd, "  glEdgeFlagPointerEXT ( (GLsizei)%d, (GLsizei)%d, (GLboolean *)0x%08x ) ;\n" , stride, count, ptr ) ;
 638 #ifdef GL_VERSION_1_1
 639     glEdgeFlagPointer ( stride, ptr ) ;
 640 #else
 641 #ifdef GL_EXT_vertex_array
 642   if ( xglExecuteIsEnabled("glEdgeFlagPointerEXT") )
 643     glEdgeFlagPointerEXT ( stride, count, ptr ) ;
 644 #else
 645   fprintf ( xglTraceFd, "  glEdgeFlagPointerEXT isn't supported on this OpenGL!\n" ) ;
 646 #endif
 647 #endif
 648 }
 649
 650 void xglEdgeFlagv ( GLboolean* flag )
 651 {
 652   if ( xglTraceIsEnabled("glEdgeFlagv") )
 653     fprintf ( xglTraceFd, "  glEdgeFlagv ( (GLboolean *)0x%08x ) ;\n" , flag ) ;
 654   if ( xglExecuteIsEnabled("glEdgeFlagv") )
 655     glEdgeFlagv ( flag ) ;
 656 }
 657
 658 void xglEnable ( GLenum cap )
 659 {
 660   if ( xglTraceIsEnabled("glEnable") )
 661     fprintf ( xglTraceFd, "  glEnable ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
 662   if ( xglExecuteIsEnabled("glEnable") )
 663     glEnable ( cap ) ;
 664 }
 665
 666 void xglEnd (  )
 667 {
 668   if ( xglTraceIsEnabled("glEnd") )
 669     fprintf ( xglTraceFd, "  glEnd (  ) ;\n"  ) ;
 670   if ( xglExecuteIsEnabled("glEnd") )
 671     glEnd (  ) ;
 672 }
 673
 674 void xglEndList (  )
 675 {
 676   if ( xglTraceIsEnabled("glEndList") )
 677     fprintf ( xglTraceFd, "  glEndList (  ) ;\n"  ) ;
 678   if ( xglExecuteIsEnabled("glEndList") )
 679     glEndList (  ) ;
 680 }
 681
 682 void xglEvalCoord1d ( GLdouble u )
 683 {
 684   if ( xglTraceIsEnabled("glEvalCoord1d") )
 685     fprintf ( xglTraceFd, "  glEvalCoord1d ( (GLdouble)%f ) ;\n" , u ) ;
 686   if ( xglExecuteIsEnabled("glEvalCoord1d") )
 687     glEvalCoord1d ( u ) ;
 688 }
 689
 690 void xglEvalCoord1dv ( GLdouble* u )
 691 {
 692   if ( xglTraceIsEnabled("glEvalCoord1dv") )
 693     fprintf ( xglTraceFd, "  glEvalCoord1dv ( xglBuild1dv((GLdouble)%f) ) ;\n" , u[0] ) ;
 694   if ( xglExecuteIsEnabled("glEvalCoord1dv") )
 695     glEvalCoord1dv ( u ) ;
 696 }
 697
 698 void xglEvalCoord1f ( GLfloat u )
 699 {
 700   if ( xglTraceIsEnabled("glEvalCoord1f") )
 701     fprintf ( xglTraceFd, "  glEvalCoord1f ( (GLfloat)%ff ) ;\n" , u ) ;
 702   if ( xglExecuteIsEnabled("glEvalCoord1f") )
 703     glEvalCoord1f ( u ) ;
 704 }
 705
 706 void xglEvalCoord1fv ( GLfloat* u )
 707 {
 708   if ( xglTraceIsEnabled("glEvalCoord1fv") )
 709     fprintf ( xglTraceFd, "  glEvalCoord1fv ( xglBuild1fv((GLfloat)%ff) ) ;\n" , u[0] ) ;
 710   if ( xglExecuteIsEnabled("glEvalCoord1fv") )
 711     glEvalCoord1fv ( u ) ;
 712 }
 713
 714 void xglEvalCoord2d ( GLdouble u, GLdouble v )
 715 {
 716   if ( xglTraceIsEnabled("glEvalCoord2d") )
 717     fprintf ( xglTraceFd, "  glEvalCoord2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , u, v ) ;
 718   if ( xglExecuteIsEnabled("glEvalCoord2d") )
 719     glEvalCoord2d ( u, v ) ;
 720 }
 721
 722 void xglEvalCoord2dv ( GLdouble* u )
 723 {
 724   if ( xglTraceIsEnabled("glEvalCoord2dv") )
 725     fprintf ( xglTraceFd, "  glEvalCoord2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , u[0], u[1] ) ;
 726   if ( xglExecuteIsEnabled("glEvalCoord2dv") )
 727     glEvalCoord2dv ( u ) ;
 728 }
 729
 730 void xglEvalCoord2f ( GLfloat u, GLfloat v )
 731 {
 732   if ( xglTraceIsEnabled("glEvalCoord2f") )
 733     fprintf ( xglTraceFd, "  glEvalCoord2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , u, v ) ;
 734   if ( xglExecuteIsEnabled("glEvalCoord2f") )
 735     glEvalCoord2f ( u, v ) ;
 736 }
 737
 738 void xglEvalCoord2fv ( GLfloat* u )
 739 {
 740   if ( xglTraceIsEnabled("glEvalCoord2fv") )
 741     fprintf ( xglTraceFd, "  glEvalCoord2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , u[0], u[1] ) ;
 742   if ( xglExecuteIsEnabled("glEvalCoord2fv") )
 743     glEvalCoord2fv ( u ) ;
 744 }
 745
 746 void xglEvalMesh1 ( GLenum mode, GLint i1, GLint i2 )
 747 {
 748   if ( xglTraceIsEnabled("glEvalMesh1") )
 749     fprintf ( xglTraceFd, "  glEvalMesh1 ( (GLenum)%s, (GLint)%d, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), i1, i2 ) ;
 750   if ( xglExecuteIsEnabled("glEvalMesh1") )
 751     glEvalMesh1 ( mode, i1, i2 ) ;
 752 }
 753
 754 void xglEvalMesh2 ( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
 755 {
 756   if ( xglTraceIsEnabled("glEvalMesh2") )
 757     fprintf ( xglTraceFd, "  glEvalMesh2 ( (GLenum)%s, (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), i1, i2, j1, j2 ) ;
 758   if ( xglExecuteIsEnabled("glEvalMesh2") )
 759     glEvalMesh2 ( mode, i1, i2, j1, j2 ) ;
 760 }
 761
 762 void xglEvalPoint1 ( GLint i )
 763 {
 764   if ( xglTraceIsEnabled("glEvalPoint1") )
 765     fprintf ( xglTraceFd, "  glEvalPoint1 ( (GLint)%d ) ;\n" , i ) ;
 766   if ( xglExecuteIsEnabled("glEvalPoint1") )
 767     glEvalPoint1 ( i ) ;
 768 }
 769
 770 void xglEvalPoint2 ( GLint i, GLint j )
 771 {
 772   if ( xglTraceIsEnabled("glEvalPoint2") )
 773     fprintf ( xglTraceFd, "  glEvalPoint2 ( (GLint)%d, (GLint)%d ) ;\n" , i, j ) ;
 774   if ( xglExecuteIsEnabled("glEvalPoint2") )
 775     glEvalPoint2 ( i, j ) ;
 776 }
 777
 778 void xglFeedbackBuffer ( GLsizei size, GLenum type, GLfloat* buffer )
 779 {
 780   if ( xglTraceIsEnabled("glFeedbackBuffer") )
 781     fprintf ( xglTraceFd, "  glFeedbackBuffer ( (GLsizei)%d, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), buffer ) ;
 782   if ( xglExecuteIsEnabled("glFeedbackBuffer") )
 783     glFeedbackBuffer ( size, type, buffer ) ;
 784 }
 785
 786 void xglFinish (  )
 787 {
 788   if ( xglTraceIsEnabled("glFinish") )
 789     fprintf ( xglTraceFd, "  glFinish (  ) ;\n"  ) ;
 790   if ( xglExecuteIsEnabled("glFinish") )
 791     glFinish (  ) ;
 792 }
 793
 794 void xglFlush (  )
 795 {
 796   if ( xglTraceIsEnabled("glFlush") )
 797     fprintf ( xglTraceFd, "  glFlush (  ) ;\n"  ) ;
 798   if ( xglExecuteIsEnabled("glFlush") )
 799     glFlush (  ) ;
 800 }
 801
 802 void xglFogf ( GLenum pname, GLfloat param )
 803 {
 804   if ( xglTraceIsEnabled("glFogf") )
 805     fprintf ( xglTraceFd, "  glFogf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
 806   if ( xglExecuteIsEnabled("glFogf") )
 807     glFogf ( pname, param ) ;
 808 }
 809
 810 void xglFogfv ( GLenum pname, GLfloat* params )
 811 {
 812   if ( xglTraceIsEnabled("glFogfv") )
 813     fprintf ( xglTraceFd, "  glFogfv ( (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 814   if ( xglExecuteIsEnabled("glFogfv") )
 815     glFogfv ( pname, params ) ;
 816 }
 817
 818 void xglFogi ( GLenum pname, GLint param )
 819 {
 820   if ( xglTraceIsEnabled("glFogi") )
 821     fprintf ( xglTraceFd, "  glFogi ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
 822   if ( xglExecuteIsEnabled("glFogi") )
 823     glFogi ( pname, param ) ;
 824 }
 825
 826 void xglFogiv ( GLenum pname, GLint* params )
 827 {
 828   if ( xglTraceIsEnabled("glFogiv") )
 829     fprintf ( xglTraceFd, "  glFogiv ( (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 830   if ( xglExecuteIsEnabled("glFogiv") )
 831     glFogiv ( pname, params ) ;
 832 }
 833
 834 void xglFrontFace ( GLenum mode )
 835 {
 836   if ( xglTraceIsEnabled("glFrontFace") )
 837     fprintf ( xglTraceFd, "  glFrontFace ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
 838   if ( xglExecuteIsEnabled("glFrontFace") )
 839     glFrontFace ( mode ) ;
 840 }
 841
 842 void xglFrustum ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
 843 {
 844   if ( xglTraceIsEnabled("glFrustum") )
 845     fprintf ( xglTraceFd, "  glFrustum ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , left, right, bottom, top, near_val, far_val ) ;
 846   if ( xglExecuteIsEnabled("glFrustum") )
 847     glFrustum ( left, right, bottom, top, near_val, far_val ) ;
 848 }
 849
 850 void xglGetBooleanv ( GLenum pname, GLboolean* params )
 851 {
 852   if ( xglTraceIsEnabled("glGetBooleanv") )
 853     fprintf ( xglTraceFd, "  /* glGetBooleanv ( (GLenum)%s, (GLboolean *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 854   if ( xglExecuteIsEnabled("glGetBooleanv") )
 855     glGetBooleanv ( pname, params ) ;
 856 }
 857
 858 void xglGetClipPlane ( GLenum plane, GLdouble* equation )
 859 {
 860   if ( xglTraceIsEnabled("glGetClipPlane") )
 861     fprintf ( xglTraceFd, "  /* glGetClipPlane ( (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) plane ), equation ) ;
 862   if ( xglExecuteIsEnabled("glGetClipPlane") )
 863     glGetClipPlane ( plane, equation ) ;
 864 }
 865
 866 void xglGetDoublev ( GLenum pname, GLdouble* params )
 867 {
 868   if ( xglTraceIsEnabled("glGetDoublev") )
 869     fprintf ( xglTraceFd, "  /* glGetDoublev ( (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 870   if ( xglExecuteIsEnabled("glGetDoublev") )
 871     glGetDoublev ( pname, params ) ;
 872 }
 873
 874 void xglGetFloatv ( GLenum pname, GLfloat* params )
 875 {
 876   if ( xglTraceIsEnabled("glGetFloatv") )
 877     fprintf ( xglTraceFd, "  /* glGetFloatv ( (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 878   if ( xglExecuteIsEnabled("glGetFloatv") )
 879     glGetFloatv ( pname, params ) ;
 880 }
 881
 882 void xglGetIntegerv ( GLenum pname, GLint* params )
 883 {
 884   if ( xglTraceIsEnabled("glGetIntegerv") )
 885     fprintf ( xglTraceFd, "  /* glGetIntegerv ( (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 886   if ( xglExecuteIsEnabled("glGetIntegerv") )
 887     glGetIntegerv ( pname, params ) ;
 888 }
 889
 890 void xglGetLightfv ( GLenum light, GLenum pname, GLfloat* params )
 891 {
 892   if ( xglTraceIsEnabled("glGetLightfv") )
 893     fprintf ( xglTraceFd, "  /* glGetLightfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
 894   if ( xglExecuteIsEnabled("glGetLightfv") )
 895     glGetLightfv ( light, pname, params ) ;
 896 }
 897
 898 void xglGetLightiv ( GLenum light, GLenum pname, GLint* params )
 899 {
 900   if ( xglTraceIsEnabled("glGetLightiv") )
 901     fprintf ( xglTraceFd, "  /* glGetLightiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
 902   if ( xglExecuteIsEnabled("glGetLightiv") )
 903     glGetLightiv ( light, pname, params ) ;
 904 }
 905
 906 void xglGetMapdv ( GLenum target, GLenum query, GLdouble* v )
 907 {
 908   if ( xglTraceIsEnabled("glGetMapdv") )
 909     fprintf ( xglTraceFd, "  /* glGetMapdv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
 910   if ( xglExecuteIsEnabled("glGetMapdv") )
 911     glGetMapdv ( target, query, v ) ;
 912 }
 913
 914 void xglGetMapfv ( GLenum target, GLenum query, GLfloat* v )
 915 {
 916   if ( xglTraceIsEnabled("glGetMapfv") )
 917     fprintf ( xglTraceFd, "  /* glGetMapfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
 918   if ( xglExecuteIsEnabled("glGetMapfv") )
 919     glGetMapfv ( target, query, v ) ;
 920 }
 921
 922 void xglGetMapiv ( GLenum target, GLenum query, GLint* v )
 923 {
 924   if ( xglTraceIsEnabled("glGetMapiv") )
 925     fprintf ( xglTraceFd, "  /* glGetMapiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
 926   if ( xglExecuteIsEnabled("glGetMapiv") )
 927     glGetMapiv ( target, query, v ) ;
 928 }
 929
 930 void xglGetMaterialfv ( GLenum face, GLenum pname, GLfloat* params )
 931 {
 932   if ( xglTraceIsEnabled("glGetMaterialfv") )
 933     fprintf ( xglTraceFd, "  /* glGetMaterialfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
 934   if ( xglExecuteIsEnabled("glGetMaterialfv") )
 935     glGetMaterialfv ( face, pname, params ) ;
 936 }
 937
 938 void xglGetMaterialiv ( GLenum face, GLenum pname, GLint* params )
 939 {
 940   if ( xglTraceIsEnabled("glGetMaterialiv") )
 941     fprintf ( xglTraceFd, "  /* glGetMaterialiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
 942   if ( xglExecuteIsEnabled("glGetMaterialiv") )
 943     glGetMaterialiv ( face, pname, params ) ;
 944 }
 945
 946 void xglGetPixelMapfv ( GLenum map, GLfloat* values )
 947 {
 948   if ( xglTraceIsEnabled("glGetPixelMapfv") )
 949     fprintf ( xglTraceFd, "  /* glGetPixelMapfv ( (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
 950   if ( xglExecuteIsEnabled("glGetPixelMapfv") )
 951     glGetPixelMapfv ( map, values ) ;
 952 }
 953
 954 void xglGetPixelMapuiv ( GLenum map, GLuint* values )
 955 {
 956   if ( xglTraceIsEnabled("glGetPixelMapuiv") )
 957     fprintf ( xglTraceFd, "  /* glGetPixelMapuiv ( (GLenum)%s, (GLuint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
 958   if ( xglExecuteIsEnabled("glGetPixelMapuiv") )
 959     glGetPixelMapuiv ( map, values ) ;
 960 }
 961
 962 void xglGetPixelMapusv ( GLenum map, GLushort* values )
 963 {
 964   if ( xglTraceIsEnabled("glGetPixelMapusv") )
 965     fprintf ( xglTraceFd, "  /* glGetPixelMapusv ( (GLenum)%s, (GLushort *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
 966   if ( xglExecuteIsEnabled("glGetPixelMapusv") )
 967     glGetPixelMapusv ( map, values ) ;
 968 }
 969
 970 void xglGetPointervEXT ( GLenum pname, void** params )
 971 {
 972   if ( xglTraceIsEnabled("glGetPointervEXT") )
 973     fprintf ( xglTraceFd, "  /* glGetPointervEXT ( (GLenum)%s, (void **)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
 974 #ifdef GL_VERSION_1_1
 975     glGetPointerv ( pname, params ) ;
 976 #else
 977 #ifdef GL_EXT_vertex_array
 978   if ( xglExecuteIsEnabled("glGetPointervEXT") )
 979     glGetPointervEXT ( pname, params ) ;
 980 #else
 981   fprintf ( xglTraceFd, "  glGetPointervEXT isn't supported on this OpenGL!\n" ) ;
 982 #endif
 983 #endif
 984 }
 985
 986 void xglGetPolygonStipple ( GLubyte* mask )
 987 {
 988   if ( xglTraceIsEnabled("glGetPolygonStipple") )
 989     fprintf ( xglTraceFd, "  /* glGetPolygonStipple ( (GLubyte *)0x%08x ) ; */\n" , mask ) ;
 990   if ( xglExecuteIsEnabled("glGetPolygonStipple") )
 991     glGetPolygonStipple ( mask ) ;
 992 }
 993
 994 void xglGetTexEnvfv ( GLenum target, GLenum pname, GLfloat* params )
 995 {
 996   if ( xglTraceIsEnabled("glGetTexEnvfv") )
 997     fprintf ( xglTraceFd, "  /* glGetTexEnvfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
 998   if ( xglExecuteIsEnabled("glGetTexEnvfv") )
 999     glGetTexEnvfv ( target, pname, params ) ;
1000 }
1001
1002 void xglGetTexEnviv ( GLenum target, GLenum pname, GLint* params )
1003 {
1004   if ( xglTraceIsEnabled("glGetTexEnviv") )
1005     fprintf ( xglTraceFd, "  /* glGetTexEnviv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1006   if ( xglExecuteIsEnabled("glGetTexEnviv") )
1007     glGetTexEnviv ( target, pname, params ) ;
1008 }
1009
1010 void xglGetTexGendv ( GLenum coord, GLenum pname, GLdouble* params )
1011 {
1012   if ( xglTraceIsEnabled("glGetTexGendv") )
1013     fprintf ( xglTraceFd, "  /* glGetTexGendv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1014   if ( xglExecuteIsEnabled("glGetTexGendv") )
1015     glGetTexGendv ( coord, pname, params ) ;
1016 }
1017
1018 void xglGetTexGenfv ( GLenum coord, GLenum pname, GLfloat* params )
1019 {
1020   if ( xglTraceIsEnabled("glGetTexGenfv") )
1021     fprintf ( xglTraceFd, "  /* glGetTexGenfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1022   if ( xglExecuteIsEnabled("glGetTexGenfv") )
1023     glGetTexGenfv ( coord, pname, params ) ;
1024 }
1025
1026 void xglGetTexGeniv ( GLenum coord, GLenum pname, GLint* params )
1027 {
1028   if ( xglTraceIsEnabled("glGetTexGeniv") )
1029     fprintf ( xglTraceFd, "  /* glGetTexGeniv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1030   if ( xglExecuteIsEnabled("glGetTexGeniv") )
1031     glGetTexGeniv ( coord, pname, params ) ;
1032 }
1033
1034 void xglGetTexImage ( GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels )
1035 {
1036   if ( xglTraceIsEnabled("glGetTexImage") )
1037     fprintf ( xglTraceFd, "  /* glGetTexImage ( (GLenum)%s, (GLint)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), level, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
1038   if ( xglExecuteIsEnabled("glGetTexImage") )
1039     glGetTexImage ( target, level, format, type, pixels ) ;
1040 }
1041
1042 void xglGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat* params )
1043 {
1044   if ( xglTraceIsEnabled("glGetTexLevelParameterfv") )
1045     fprintf ( xglTraceFd, "  /* glGetTexLevelParameterfv ( (GLenum)%s, (GLint)%d, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), level, xglExpandGLenum ( (GLenum) pname ), params ) ;
1046   if ( xglExecuteIsEnabled("glGetTexLevelParameterfv") )
1047     glGetTexLevelParameterfv ( target, level, pname, params ) ;
1048 }
1049
1050 void xglGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint* params )
1051 {
1052   if ( xglTraceIsEnabled("glGetTexLevelParameteriv") )
1053     fprintf ( xglTraceFd, "  /* glGetTexLevelParameteriv ( (GLenum)%s, (GLint)%d, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), level, xglExpandGLenum ( (GLenum) pname ), params ) ;
1054   if ( xglExecuteIsEnabled("glGetTexLevelParameteriv") )
1055     glGetTexLevelParameteriv ( target, level, pname, params ) ;
1056 }
1057
1058 void xglGetTexParameterfv ( GLenum target, GLenum pname, GLfloat* params )
1059 {
1060   if ( xglTraceIsEnabled("glGetTexParameterfv") )
1061     fprintf ( xglTraceFd, "  /* glGetTexParameterfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1062   if ( xglExecuteIsEnabled("glGetTexParameterfv") )
1063     glGetTexParameterfv ( target, pname, params ) ;
1064 }
1065
1066 void xglGetTexParameteriv ( GLenum target, GLenum pname, GLint* params )
1067 {
1068   if ( xglTraceIsEnabled("glGetTexParameteriv") )
1069     fprintf ( xglTraceFd, "  /* glGetTexParameteriv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1070   if ( xglExecuteIsEnabled("glGetTexParameteriv") )
1071     glGetTexParameteriv ( target, pname, params ) ;
1072 }
1073
1074 void xglHint ( GLenum target, GLenum mode )
1075 {
1076   if ( xglTraceIsEnabled("glHint") )
1077     fprintf ( xglTraceFd, "  glHint ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) mode ) ) ;
1078   if ( xglExecuteIsEnabled("glHint") )
1079     glHint ( target, mode ) ;
1080 }
1081
1082 void xglIndexMask ( GLuint mask )
1083 {
1084   if ( xglTraceIsEnabled("glIndexMask") )
1085     fprintf ( xglTraceFd, "  glIndexMask ( (GLuint)%u ) ;\n" , mask ) ;
1086   if ( xglExecuteIsEnabled("glIndexMask") )
1087     glIndexMask ( mask ) ;
1088 }
1089
1090 void xglIndexPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void* ptr )
1091 {
1092   if ( xglTraceIsEnabled("glIndexPointerEXT") )
1093     fprintf ( xglTraceFd, "  glIndexPointerEXT ( (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
1094 #ifdef GL_VERSION_1_1
1095     glIndexPointer ( type, stride, ptr ) ;
1096 #else
1097 #ifdef GL_EXT_vertex_array
1098   if ( xglExecuteIsEnabled("glIndexPointerEXT") )
1099     glIndexPointerEXT ( type, stride, count, ptr ) ;
1100 #else
1101   fprintf ( xglTraceFd, "  glIndexPointerEXT isn't supported on this OpenGL!\n" ) ;
1102 #endif
1103 #endif
1104 }
1105
1106 void xglIndexd ( GLdouble c )
1107 {
1108   if ( xglTraceIsEnabled("glIndexd") )
1109     fprintf ( xglTraceFd, "  glIndexd ( (GLdouble)%f ) ;\n" , c ) ;
1110   if ( xglExecuteIsEnabled("glIndexd") )
1111     glIndexd ( c ) ;
1112 }
1113
1114 void xglIndexdv ( GLdouble* c )
1115 {
1116   if ( xglTraceIsEnabled("glIndexdv") )
1117     fprintf ( xglTraceFd, "  glIndexdv ( (GLdouble *)0x%08x ) ;\n" , c ) ;
1118   if ( xglExecuteIsEnabled("glIndexdv") )
1119     glIndexdv ( c ) ;
1120 }
1121
1122 void xglIndexf ( GLfloat c )
1123 {
1124   if ( xglTraceIsEnabled("glIndexf") )
1125     fprintf ( xglTraceFd, "  glIndexf ( (GLfloat)%ff ) ;\n" , c ) ;
1126   if ( xglExecuteIsEnabled("glIndexf") )
1127     glIndexf ( c ) ;
1128 }
1129
1130 void xglIndexfv ( GLfloat* c )
1131 {
1132   if ( xglTraceIsEnabled("glIndexfv") )
1133     fprintf ( xglTraceFd, "  glIndexfv ( (GLfloat *)0x%08x ) ;\n" , c ) ;
1134   if ( xglExecuteIsEnabled("glIndexfv") )
1135     glIndexfv ( c ) ;
1136 }
1137
1138 void xglIndexi ( GLint c )
1139 {
1140   if ( xglTraceIsEnabled("glIndexi") )
1141     fprintf ( xglTraceFd, "  glIndexi ( (GLint)%d ) ;\n" , c ) ;
1142   if ( xglExecuteIsEnabled("glIndexi") )
1143     glIndexi ( c ) ;
1144 }
1145
1146 void xglIndexiv ( GLint* c )
1147 {
1148   if ( xglTraceIsEnabled("glIndexiv") )
1149     fprintf ( xglTraceFd, "  glIndexiv ( (GLint *)0x%08x ) ;\n" , c ) ;
1150   if ( xglExecuteIsEnabled("glIndexiv") )
1151     glIndexiv ( c ) ;
1152 }
1153
1154 void xglIndexs ( GLshort c )
1155 {
1156   if ( xglTraceIsEnabled("glIndexs") )
1157     fprintf ( xglTraceFd, "  glIndexs ( (GLshort)%d ) ;\n" , c ) ;
1158   if ( xglExecuteIsEnabled("glIndexs") )
1159     glIndexs ( c ) ;
1160 }
1161
1162 void xglIndexsv ( GLshort* c )
1163 {
1164   if ( xglTraceIsEnabled("glIndexsv") )
1165     fprintf ( xglTraceFd, "  glIndexsv ( (GLshort *)0x%08x ) ;\n" , c ) ;
1166   if ( xglExecuteIsEnabled("glIndexsv") )
1167     glIndexsv ( c ) ;
1168 }
1169
1170 void xglInitNames (  )
1171 {
1172   if ( xglTraceIsEnabled("glInitNames") )
1173     fprintf ( xglTraceFd, "  glInitNames (  ) ;\n"  ) ;
1174   if ( xglExecuteIsEnabled("glInitNames") )
1175     glInitNames (  ) ;
1176 }
1177
1178 void xglLightModelf ( GLenum pname, GLfloat param )
1179 {
1180   if ( xglTraceIsEnabled("glLightModelf") )
1181     fprintf ( xglTraceFd, "  glLightModelf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1182   if ( xglExecuteIsEnabled("glLightModelf") )
1183     glLightModelf ( pname, param ) ;
1184 }
1185
1186 void xglLightModelfv ( GLenum pname, GLfloat* params )
1187 {
1188   if ( xglTraceIsEnabled("glLightModelfv") )
1189     fprintf ( xglTraceFd, "  glLightModelfv ( (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
1190   if ( xglExecuteIsEnabled("glLightModelfv") )
1191     glLightModelfv ( pname, params ) ;
1192 }
1193
1194 void xglLightModeli ( GLenum pname, GLint param )
1195 {
1196   if ( xglTraceIsEnabled("glLightModeli") )
1197     fprintf ( xglTraceFd, "  glLightModeli ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1198   if ( xglExecuteIsEnabled("glLightModeli") )
1199     glLightModeli ( pname, param ) ;
1200 }
1201
1202 void xglLightModeliv ( GLenum pname, GLint* params )
1203 {
1204   if ( xglTraceIsEnabled("glLightModeliv") )
1205     fprintf ( xglTraceFd, "  glLightModeliv ( (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
1206   if ( xglExecuteIsEnabled("glLightModeliv") )
1207     glLightModeliv ( pname, params ) ;
1208 }
1209
1210 void xglLightf ( GLenum light, GLenum pname, GLfloat param )
1211 {
1212   if ( xglTraceIsEnabled("glLightf") )
1213     fprintf ( xglTraceFd, "  glLightf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), param ) ;
1214   if ( xglExecuteIsEnabled("glLightf") )
1215     glLightf ( light, pname, param ) ;
1216 }
1217
1218 void xglLightfv ( GLenum light, GLenum pname, GLfloat* params )
1219 {
1220   if ( xglTraceIsEnabled("glLightfv") )
1221     fprintf ( xglTraceFd, "  glLightfv ( (GLenum)%s, (GLenum)%s, xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n",
1222         xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params[0], params[1], params[2], params[3] ) ;
1223   if ( xglExecuteIsEnabled("glLightfv") )
1224     glLightfv ( light, pname, params ) ;
1225 }
1226
1227 void xglLighti ( GLenum light, GLenum pname, GLint param )
1228 {
1229   if ( xglTraceIsEnabled("glLighti") )
1230     fprintf ( xglTraceFd, "  glLighti ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), param ) ;
1231   if ( xglExecuteIsEnabled("glLighti") )
1232     glLighti ( light, pname, param ) ;
1233 }
1234
1235 void xglLightiv ( GLenum light, GLenum pname, GLint* params )
1236 {
1237   if ( xglTraceIsEnabled("glLightiv") )
1238     fprintf ( xglTraceFd, "  glLightiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1239   if ( xglExecuteIsEnabled("glLightiv") )
1240     glLightiv ( light, pname, params ) ;
1241 }
1242
1243 void xglLineStipple ( GLint factor, GLushort pattern )
1244 {
1245   if ( xglTraceIsEnabled("glLineStipple") )
1246     fprintf ( xglTraceFd, "  glLineStipple ( (GLint)%d, (GLushort)%u ) ;\n" , factor, pattern ) ;
1247   if ( xglExecuteIsEnabled("glLineStipple") )
1248     glLineStipple ( factor, pattern ) ;
1249 }
1250
1251 void xglLineWidth ( GLfloat width )
1252 {
1253   if ( xglTraceIsEnabled("glLineWidth") )
1254     fprintf ( xglTraceFd, "  glLineWidth ( (GLfloat)%ff ) ;\n" , width ) ;
1255   if ( xglExecuteIsEnabled("glLineWidth") )
1256     glLineWidth ( width ) ;
1257 }
1258
1259 void xglListBase ( GLuint base )
1260 {
1261   if ( xglTraceIsEnabled("glListBase") )
1262     fprintf ( xglTraceFd, "  glListBase ( (GLuint)%u ) ;\n" , base ) ;
1263   if ( xglExecuteIsEnabled("glListBase") )
1264     glListBase ( base ) ;
1265 }
1266
1267 void xglLoadIdentity (  )
1268 {
1269   if ( xglTraceIsEnabled("glLoadIdentity") )
1270     fprintf ( xglTraceFd, "  glLoadIdentity (  ) ;\n"  ) ;
1271   if ( xglExecuteIsEnabled("glLoadIdentity") )
1272     glLoadIdentity (  ) ;
1273 }
1274
1275 void xglLoadMatrixd ( GLdouble* m )
1276 {
1277   if ( xglTraceIsEnabled("glLoadMatrixd") )
1278   {
1279     fprintf ( xglTraceFd, "  glLoadMatrixd ( xglBuildMatrixd(%f,%f,%f,%f,\n"    , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
1280     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f,\n"    , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
1281     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f,\n"    , m[ 8],m[ 9],m[10],m[11] ) ;
1282     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f) ) ;\n", m[12],m[13],m[14],m[15] ) ;
1283   }
1284
1285   if ( xglExecuteIsEnabled("glLoadMatrixd") )
1286     glLoadMatrixd ( m ) ;
1287 }
1288
1289 void xglLoadMatrixf ( GLfloat* m )
1290 {
1291   if ( xglTraceIsEnabled("glLoadMatrixf") )
1292   {
1293     fprintf ( xglTraceFd, "  glLoadMatrixf ( xglBuildMatrixf(%ff,%ff,%ff,%ff,\n"    , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
1294     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff,\n"    , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
1295     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff,\n"    , m[ 8],m[ 9],m[10],m[11] ) ;
1296     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff) ) ;\n", m[12],m[13],m[14],m[15] ) ;
1297   }
1298
1299   if ( xglExecuteIsEnabled("glLoadMatrixf") )
1300     glLoadMatrixf ( m ) ;
1301 }
1302
1303 void xglLoadName ( GLuint name )
1304 {
1305   if ( xglTraceIsEnabled("glLoadName") )
1306     fprintf ( xglTraceFd, "  glLoadName ( (GLuint)%u ) ;\n" , name ) ;
1307   if ( xglExecuteIsEnabled("glLoadName") )
1308     glLoadName ( name ) ;
1309 }
1310
1311 void xglLogicOp ( GLenum opcode )
1312 {
1313   if ( xglTraceIsEnabled("glLogicOp") )
1314     fprintf ( xglTraceFd, "  glLogicOp ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) opcode ) ) ;
1315   if ( xglExecuteIsEnabled("glLogicOp") )
1316     glLogicOp ( opcode ) ;
1317 }
1318
1319 void xglMap1d ( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points )
1320 {
1321   if ( xglTraceIsEnabled("glMap1d") )
1322     fprintf ( xglTraceFd, "  glMap1d ( (GLenum)%s, (GLdouble)%f, (GLdouble)%f, (GLint)%d, (GLint)%d, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), u1, u2, stride, order, points ) ;
1323   if ( xglExecuteIsEnabled("glMap1d") )
1324     glMap1d ( target, u1, u2, stride, order, points ) ;
1325 }
1326
1327 void xglMap1f ( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points )
1328 {
1329   if ( xglTraceIsEnabled("glMap1f") )
1330     fprintf ( xglTraceFd, "  glMap1f ( (GLenum)%s, (GLfloat)%ff, (GLfloat)%ff, (GLint)%d, (GLint)%d, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), u1, u2, stride, order, points ) ;
1331   if ( xglExecuteIsEnabled("glMap1f") )
1332     glMap1f ( target, u1, u2, stride, order, points ) ;
1333 }
1334
1335 void xglMap2d ( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points )
1336 {
1337   if ( xglTraceIsEnabled("glMap2d") )
1338     fprintf ( xglTraceFd, "  glMap2d ( (GLenum)%s, (GLdouble)%f, (GLdouble)%f, (GLint)%d, (GLint)%d, (GLdouble)%f, (GLdouble)%f, (GLint)%d, (GLint)%d, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
1339   if ( xglExecuteIsEnabled("glMap2d") )
1340     glMap2d ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
1341 }
1342
1343 void xglMap2f ( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points )
1344 {
1345   if ( xglTraceIsEnabled("glMap2f") )
1346     fprintf ( xglTraceFd, "  glMap2f ( (GLenum)%s, (GLfloat)%ff, (GLfloat)%ff, (GLint)%d, (GLint)%d, (GLfloat)%ff, (GLfloat)%ff, (GLint)%d, (GLint)%d, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
1347   if ( xglExecuteIsEnabled("glMap2f") )
1348     glMap2f ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
1349 }
1350
1351 void xglMapGrid1d ( GLint un, GLdouble u1, GLdouble u2 )
1352 {
1353   if ( xglTraceIsEnabled("glMapGrid1d") )
1354     fprintf ( xglTraceFd, "  glMapGrid1d ( (GLint)%d, (GLdouble)%f, (GLdouble)%f ) ;\n" , un, u1, u2 ) ;
1355   if ( xglExecuteIsEnabled("glMapGrid1d") )
1356     glMapGrid1d ( un, u1, u2 ) ;
1357 }
1358
1359 void xglMapGrid1f ( GLint un, GLfloat u1, GLfloat u2 )
1360 {
1361   if ( xglTraceIsEnabled("glMapGrid1f") )
1362     fprintf ( xglTraceFd, "  glMapGrid1f ( (GLint)%d, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , un, u1, u2 ) ;
1363   if ( xglExecuteIsEnabled("glMapGrid1f") )
1364     glMapGrid1f ( un, u1, u2 ) ;
1365 }
1366
1367 void xglMapGrid2d ( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
1368 {
1369   if ( xglTraceIsEnabled("glMapGrid2d") )
1370     fprintf ( xglTraceFd, "  glMapGrid2d ( (GLint)%d, (GLdouble)%f, (GLdouble)%f, (GLint)%d, (GLdouble)%f, (GLdouble)%f ) ;\n" , un, u1, u2, vn, v1, v2 ) ;
1371   if ( xglExecuteIsEnabled("glMapGrid2d") )
1372     glMapGrid2d ( un, u1, u2, vn, v1, v2 ) ;
1373 }
1374
1375 void xglMapGrid2f ( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
1376 {
1377   if ( xglTraceIsEnabled("glMapGrid2f") )
1378     fprintf ( xglTraceFd, "  glMapGrid2f ( (GLint)%d, (GLfloat)%ff, (GLfloat)%ff, (GLint)%d, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , un, u1, u2, vn, v1, v2 ) ;
1379   if ( xglExecuteIsEnabled("glMapGrid2f") )
1380     glMapGrid2f ( un, u1, u2, vn, v1, v2 ) ;
1381 }
1382
1383 void xglMaterialf ( GLenum face, GLenum pname, GLfloat param )
1384 {
1385   if ( xglTraceIsEnabled("glMaterialf") )
1386     fprintf ( xglTraceFd, "  glMaterialf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), param ) ;
1387   if ( xglExecuteIsEnabled("glMaterialf") )
1388     glMaterialf ( face, pname, param ) ;
1389 }
1390
1391 void xglMaterialfv ( GLenum face, GLenum pname, GLfloat* params )
1392 {
1393   if ( xglTraceIsEnabled("glMaterialfv") )
1394     fprintf ( xglTraceFd, "  glMaterialfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1395   if ( xglExecuteIsEnabled("glMaterialfv") )
1396     glMaterialfv ( face, pname, params ) ;
1397 }
1398
1399 void xglMateriali ( GLenum face, GLenum pname, GLint param )
1400 {
1401   if ( xglTraceIsEnabled("glMateriali") )
1402     fprintf ( xglTraceFd, "  glMateriali ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), param ) ;
1403   if ( xglExecuteIsEnabled("glMateriali") )
1404     glMateriali ( face, pname, param ) ;
1405 }
1406
1407 void xglMaterialiv ( GLenum face, GLenum pname, GLint* params )
1408 {
1409   if ( xglTraceIsEnabled("glMaterialiv") )
1410     fprintf ( xglTraceFd, "  glMaterialiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
1411   if ( xglExecuteIsEnabled("glMaterialiv") )
1412     glMaterialiv ( face, pname, params ) ;
1413 }
1414
1415 void xglMatrixMode ( GLenum mode )
1416 {
1417   if ( xglTraceIsEnabled("glMatrixMode") )
1418     fprintf ( xglTraceFd, "  glMatrixMode ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
1419   if ( xglExecuteIsEnabled("glMatrixMode") )
1420     glMatrixMode ( mode ) ;
1421 }
1422
1423
1424 void xglMultMatrixd ( GLdouble* m )
1425 {
1426   if ( xglTraceIsEnabled("glMultMatrixd") )
1427   {
1428     fprintf ( xglTraceFd, "  glMultMatrixd ( xglBuildMatrixd(%f,%f,%f,%f,\n"    , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
1429     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f,\n"    , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
1430     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f,\n"    , m[ 8],m[ 9],m[10],m[11] ) ;
1431     fprintf ( xglTraceFd, "                                  %f,%f,%f,%f) ) ;\n", m[12],m[13],m[14],m[15] ) ;
1432   }
1433
1434   if ( xglExecuteIsEnabled("glMultMatrixd") )
1435     glMultMatrixd ( m ) ;
1436 }
1437
1438 void xglMultMatrixf ( GLfloat* m )
1439 {
1440   if ( xglTraceIsEnabled("glMultMatrixf") )
1441   {
1442     fprintf ( xglTraceFd, "  glMultMatrixf ( xglBuildMatrixf(%ff,%ff,%ff,%ff,\n"    , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
1443     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff,\n"    , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
1444     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff,\n"    , m[ 8],m[ 9],m[10],m[11] ) ;
1445     fprintf ( xglTraceFd, "                                  %ff,%ff,%ff,%ff) ) ;\n", m[12],m[13],m[14],m[15] ) ;
1446   }
1447
1448   if ( xglExecuteIsEnabled("glMultMatrixf") )
1449     glMultMatrixf ( m ) ;
1450 }
1451
1452 void xglNewList ( GLuint list, GLenum mode )
1453 {
1454   if ( xglTraceIsEnabled("glNewList") )
1455     fprintf ( xglTraceFd, "  glNewList ( (GLuint)%u, (GLenum)%s ) ;\n" , list, xglExpandGLenum ( (GLenum) mode ) ) ;
1456   if ( xglExecuteIsEnabled("glNewList") )
1457     glNewList ( list, mode ) ;
1458 }
1459
1460 void xglNormal3b ( GLbyte nx, GLbyte ny, GLbyte nz )
1461 {
1462   if ( xglTraceIsEnabled("glNormal3b") )
1463     fprintf ( xglTraceFd, "  glNormal3b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , nx, ny, nz ) ;
1464   if ( xglExecuteIsEnabled("glNormal3b") )
1465     glNormal3b ( nx, ny, nz ) ;
1466 }
1467
1468 void xglNormal3bv ( GLbyte* v )
1469 {
1470   if ( xglTraceIsEnabled("glNormal3bv") )
1471     fprintf ( xglTraceFd, "  glNormal3bv ( xglBuild3bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
1472   if ( xglExecuteIsEnabled("glNormal3bv") )
1473     glNormal3bv ( v ) ;
1474 }
1475
1476 void xglNormal3d ( GLdouble nx, GLdouble ny, GLdouble nz )
1477 {
1478   if ( xglTraceIsEnabled("glNormal3d") )
1479     fprintf ( xglTraceFd, "  glNormal3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , nx, ny, nz ) ;
1480   if ( xglExecuteIsEnabled("glNormal3d") )
1481     glNormal3d ( nx, ny, nz ) ;
1482 }
1483
1484 void xglNormal3dv ( GLdouble* v )
1485 {
1486   if ( xglTraceIsEnabled("glNormal3dv") )
1487     fprintf ( xglTraceFd, "  glNormal3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
1488   if ( xglExecuteIsEnabled("glNormal3dv") )
1489     glNormal3dv ( v ) ;
1490 }
1491
1492 void xglNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz )
1493 {
1494   if ( xglTraceIsEnabled("glNormal3f") )
1495     fprintf ( xglTraceFd, "  glNormal3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , nx, ny, nz ) ;
1496   if ( xglExecuteIsEnabled("glNormal3f") )
1497     glNormal3f ( nx, ny, nz ) ;
1498 }
1499
1500 void xglNormal3fv ( GLfloat* v )
1501 {
1502   if ( xglTraceIsEnabled("glNormal3fv") )
1503     fprintf ( xglTraceFd, "  glNormal3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
1504   if ( xglExecuteIsEnabled("glNormal3fv") )
1505     glNormal3fv ( v ) ;
1506 }
1507
1508 void xglNormal3i ( GLint nx, GLint ny, GLint nz )
1509 {
1510   if ( xglTraceIsEnabled("glNormal3i") )
1511     fprintf ( xglTraceFd, "  glNormal3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , nx, ny, nz ) ;
1512   if ( xglExecuteIsEnabled("glNormal3i") )
1513     glNormal3i ( nx, ny, nz ) ;
1514 }
1515
1516 void xglNormal3iv ( GLint* v )
1517 {
1518   if ( xglTraceIsEnabled("glNormal3iv") )
1519     fprintf ( xglTraceFd, "  glNormal3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
1520   if ( xglExecuteIsEnabled("glNormal3iv") )
1521     glNormal3iv ( v ) ;
1522 }
1523
1524 void xglNormal3s ( GLshort nx, GLshort ny, GLshort nz )
1525 {
1526   if ( xglTraceIsEnabled("glNormal3s") )
1527     fprintf ( xglTraceFd, "  glNormal3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , nx, ny, nz ) ;
1528   if ( xglExecuteIsEnabled("glNormal3s") )
1529     glNormal3s ( nx, ny, nz ) ;
1530 }
1531
1532 void xglNormal3sv ( GLshort* v )
1533 {
1534   if ( xglTraceIsEnabled("glNormal3sv") )
1535     fprintf ( xglTraceFd, "  glNormal3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
1536   if ( xglExecuteIsEnabled("glNormal3sv") )
1537     glNormal3sv ( v ) ;
1538 }
1539
1540 void xglNormalPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void* ptr )
1541 {
1542   if ( xglTraceIsEnabled("glNormalPointerEXT") )
1543     fprintf ( xglTraceFd, "  glNormalPointerEXT ( (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
1544 #ifdef GL_VERSION_1_1
1545     glNormalPointer ( type, stride, ptr ) ;
1546 #else
1547 #ifdef GL_EXT_vertex_array
1548   if ( xglExecuteIsEnabled("glNormalPointerEXT") )
1549     glNormalPointerEXT ( type, stride, count, ptr ) ;
1550 #else
1551   fprintf ( xglTraceFd, "  glNormalPointerEXT isn't supported on this OpenGL!\n" ) ;
1552 #endif
1553 #endif
1554 }
1555
1556 void xglOrtho ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
1557 {
1558   if ( xglTraceIsEnabled("glOrtho") )
1559     fprintf ( xglTraceFd, "  glOrtho ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , left, right, bottom, top, near_val, far_val ) ;
1560   if ( xglExecuteIsEnabled("glOrtho") )
1561     glOrtho ( left, right, bottom, top, near_val, far_val ) ;
1562 }
1563
1564 void xglPassThrough ( GLfloat token )
1565 {
1566   if ( xglTraceIsEnabled("glPassThrough") )
1567     fprintf ( xglTraceFd, "  glPassThrough ( (GLfloat)%ff ) ;\n" , token ) ;
1568   if ( xglExecuteIsEnabled("glPassThrough") )
1569     glPassThrough ( token ) ;
1570 }
1571
1572 void xglPixelMapfv ( GLenum map, GLint mapsize, GLfloat* values )
1573 {
1574   if ( xglTraceIsEnabled("glPixelMapfv") )
1575     fprintf ( xglTraceFd, "  glPixelMapfv ( (GLenum)%s, (GLint)%d, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
1576   if ( xglExecuteIsEnabled("glPixelMapfv") )
1577     glPixelMapfv ( map, mapsize, values ) ;
1578 }
1579
1580 void xglPixelMapuiv ( GLenum map, GLint mapsize, GLuint* values )
1581 {
1582   if ( xglTraceIsEnabled("glPixelMapuiv") )
1583     fprintf ( xglTraceFd, "  glPixelMapuiv ( (GLenum)%s, (GLint)%d, (GLuint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
1584   if ( xglExecuteIsEnabled("glPixelMapuiv") )
1585     glPixelMapuiv ( map, mapsize, values ) ;
1586 }
1587
1588 void xglPixelMapusv ( GLenum map, GLint mapsize, GLushort* values )
1589 {
1590   if ( xglTraceIsEnabled("glPixelMapusv") )
1591     fprintf ( xglTraceFd, "  glPixelMapusv ( (GLenum)%s, (GLint)%d, (GLushort *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
1592   if ( xglExecuteIsEnabled("glPixelMapusv") )
1593     glPixelMapusv ( map, mapsize, values ) ;
1594 }
1595
1596 void xglPixelStoref ( GLenum pname, GLfloat param )
1597 {
1598   if ( xglTraceIsEnabled("glPixelStoref") )
1599     fprintf ( xglTraceFd, "  glPixelStoref ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1600   if ( xglExecuteIsEnabled("glPixelStoref") )
1601     glPixelStoref ( pname, param ) ;
1602 }
1603
1604 void xglPixelStorei ( GLenum pname, GLint param )
1605 {
1606   if ( xglTraceIsEnabled("glPixelStorei") )
1607     fprintf ( xglTraceFd, "  glPixelStorei ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1608   if ( xglExecuteIsEnabled("glPixelStorei") )
1609     glPixelStorei ( pname, param ) ;
1610 }
1611
1612 void xglPixelTransferf ( GLenum pname, GLfloat param )
1613 {
1614   if ( xglTraceIsEnabled("glPixelTransferf") )
1615     fprintf ( xglTraceFd, "  glPixelTransferf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1616   if ( xglExecuteIsEnabled("glPixelTransferf") )
1617     glPixelTransferf ( pname, param ) ;
1618 }
1619
1620 void xglPixelTransferi ( GLenum pname, GLint param )
1621 {
1622   if ( xglTraceIsEnabled("glPixelTransferi") )
1623     fprintf ( xglTraceFd, "  glPixelTransferi ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
1624   if ( xglExecuteIsEnabled("glPixelTransferi") )
1625     glPixelTransferi ( pname, param ) ;
1626 }
1627
1628 void xglPixelZoom ( GLfloat xfactor, GLfloat yfactor )
1629 {
1630   if ( xglTraceIsEnabled("glPixelZoom") )
1631     fprintf ( xglTraceFd, "  glPixelZoom ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , xfactor, yfactor ) ;
1632   if ( xglExecuteIsEnabled("glPixelZoom") )
1633     glPixelZoom ( xfactor, yfactor ) ;
1634 }
1635
1636 void xglPointSize ( GLfloat size )
1637 {
1638   if ( xglTraceIsEnabled("glPointSize") )
1639     fprintf ( xglTraceFd, "  glPointSize ( (GLfloat)%ff ) ;\n" , size ) ;
1640   if ( xglExecuteIsEnabled("glPointSize") )
1641     glPointSize ( size ) ;
1642 }
1643
1644 void xglPolygonMode ( GLenum face, GLenum mode )
1645 {
1646   if ( xglTraceIsEnabled("glPolygonMode") )
1647     fprintf ( xglTraceFd, "  glPolygonMode ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) mode ) ) ;
1648   if ( xglExecuteIsEnabled("glPolygonMode") )
1649     glPolygonMode ( face, mode ) ;
1650 }
1651
1652 void xglPolygonOffsetEXT ( GLfloat factor, GLfloat bias )
1653 {
1654   if ( xglTraceIsEnabled("glPolygonOffsetEXT") )
1655     fprintf ( xglTraceFd, "  glPolygonOffsetEXT ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , factor, bias ) ;
1656
1657 #ifdef GL_VERSION_1_1
1658   if ( xglExecuteIsEnabled("glPolygonOffsetEXT") )
1659     glPolygonOffset ( factor, bias ) ;
1660 #else
1661 #ifdef GL_EXT_polygon_offset
1662   if ( xglExecuteIsEnabled("glPolygonOffsetEXT") )
1663     glPolygonOffsetEXT ( factor, bias ) ;
1664 #else
1665   fprintf ( xglTraceFd, "  glPolygonOffsetEXT isn't supported on this OpenGL!\n" ) ;
1666 #endif
1667 #endif
1668 }
1669
1670 void xglPolygonOffset ( GLfloat factor, GLfloat bias )
1671 {
1672   if ( xglTraceIsEnabled("glPolygonOffset") )
1673     fprintf ( xglTraceFd, "  glPolygonOffset ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , factor, bias ) ;
1674 #ifdef GL_VERSION_1_1
1675   if ( xglExecuteIsEnabled("glPolygonOffset") )
1676     glPolygonOffset ( factor, bias ) ;
1677 #else
1678 #ifdef GL_EXT_polygon_offset
1679   if ( xglExecuteIsEnabled("glPolygonOffset") )
1680     glPolygonOffsetEXT ( factor, bias ) ;
1681 #else
1682   fprintf ( xglTraceFd, "  glPolygonOffsetEXT isn't supported on this OpenGL!\n" ) ;
1683 #endif
1684 #endif
1685 }
1686
1687 void xglPolygonStipple ( GLubyte* mask )
1688 {
1689   if ( xglTraceIsEnabled("glPolygonStipple") )
1690     fprintf ( xglTraceFd, "  glPolygonStipple ( (GLubyte *)0x%08x ) ;\n" , mask ) ;
1691   if ( xglExecuteIsEnabled("glPolygonStipple") )
1692     glPolygonStipple ( mask ) ;
1693 }
1694
1695 void xglPopAttrib (  )
1696 {
1697   if ( xglTraceIsEnabled("glPopAttrib") )
1698     fprintf ( xglTraceFd, "  glPopAttrib (  ) ;\n"  ) ;
1699   if ( xglExecuteIsEnabled("glPopAttrib") )
1700     glPopAttrib (  ) ;
1701 }
1702
1703 void xglPopMatrix (  )
1704 {
1705   if ( xglTraceIsEnabled("glPopMatrix") )
1706     fprintf ( xglTraceFd, "  glPopMatrix (  ) ;\n"  ) ;
1707   if ( xglExecuteIsEnabled("glPopMatrix") )
1708     glPopMatrix (  ) ;
1709 }
1710
1711 void xglPopName (  )
1712 {
1713   if ( xglTraceIsEnabled("glPopName") )
1714     fprintf ( xglTraceFd, "  glPopName (  ) ;\n"  ) ;
1715   if ( xglExecuteIsEnabled("glPopName") )
1716     glPopName (  ) ;
1717 }
1718
1719 void xglPushAttrib ( GLbitfield mask )
1720 {
1721   if ( xglTraceIsEnabled("glPushAttrib") )
1722     fprintf ( xglTraceFd, "  glPushAttrib ( (GLbitfield)0x%08x ) ;\n" , mask ) ;
1723   if ( xglExecuteIsEnabled("glPushAttrib") )
1724     glPushAttrib ( mask ) ;
1725 }
1726
1727 void xglPushMatrix (  )
1728 {
1729   if ( xglTraceIsEnabled("glPushMatrix") )
1730     fprintf ( xglTraceFd, "  glPushMatrix (  ) ;\n"  ) ;
1731   if ( xglExecuteIsEnabled("glPushMatrix") )
1732     glPushMatrix (  ) ;
1733 }
1734
1735 void xglPushName ( GLuint name )
1736 {
1737   if ( xglTraceIsEnabled("glPushName") )
1738     fprintf ( xglTraceFd, "  glPushName ( (GLuint)%u ) ;\n" , name ) ;
1739   if ( xglExecuteIsEnabled("glPushName") )
1740     glPushName ( name ) ;
1741 }
1742
1743 void xglRasterPos2d ( GLdouble x, GLdouble y )
1744 {
1745   if ( xglTraceIsEnabled("glRasterPos2d") )
1746     fprintf ( xglTraceFd, "  glRasterPos2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y ) ;
1747   if ( xglExecuteIsEnabled("glRasterPos2d") )
1748     glRasterPos2d ( x, y ) ;
1749 }
1750
1751 void xglRasterPos2dv ( GLdouble* v )
1752 {
1753   if ( xglTraceIsEnabled("glRasterPos2dv") )
1754     fprintf ( xglTraceFd, "  glRasterPos2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
1755   if ( xglExecuteIsEnabled("glRasterPos2dv") )
1756     glRasterPos2dv ( v ) ;
1757 }
1758
1759 void xglRasterPos2f ( GLfloat x, GLfloat y )
1760 {
1761   if ( xglTraceIsEnabled("glRasterPos2f") )
1762     fprintf ( xglTraceFd, "  glRasterPos2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y ) ;
1763   if ( xglExecuteIsEnabled("glRasterPos2f") )
1764     glRasterPos2f ( x, y ) ;
1765 }
1766
1767 void xglRasterPos2fv ( GLfloat* v )
1768 {
1769   if ( xglTraceIsEnabled("glRasterPos2fv") )
1770     fprintf ( xglTraceFd, "  glRasterPos2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
1771   if ( xglExecuteIsEnabled("glRasterPos2fv") )
1772     glRasterPos2fv ( v ) ;
1773 }
1774
1775 void xglRasterPos2i ( GLint x, GLint y )
1776 {
1777   if ( xglTraceIsEnabled("glRasterPos2i") )
1778     fprintf ( xglTraceFd, "  glRasterPos2i ( (GLint)%d, (GLint)%d ) ;\n" , x, y ) ;
1779   if ( xglExecuteIsEnabled("glRasterPos2i") )
1780     glRasterPos2i ( x, y ) ;
1781 }
1782
1783 void xglRasterPos2iv ( GLint* v )
1784 {
1785   if ( xglTraceIsEnabled("glRasterPos2iv") )
1786     fprintf ( xglTraceFd, "  glRasterPos2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
1787   if ( xglExecuteIsEnabled("glRasterPos2iv") )
1788     glRasterPos2iv ( v ) ;
1789 }
1790
1791 void xglRasterPos2s ( GLshort x, GLshort y )
1792 {
1793   if ( xglTraceIsEnabled("glRasterPos2s") )
1794     fprintf ( xglTraceFd, "  glRasterPos2s ( (GLshort)%d, (GLshort)%d ) ;\n" , x, y ) ;
1795   if ( xglExecuteIsEnabled("glRasterPos2s") )
1796     glRasterPos2s ( x, y ) ;
1797 }
1798
1799 void xglRasterPos2sv ( GLshort* v )
1800 {
1801   if ( xglTraceIsEnabled("glRasterPos2sv") )
1802     fprintf ( xglTraceFd, "  glRasterPos2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
1803   if ( xglExecuteIsEnabled("glRasterPos2sv") )
1804     glRasterPos2sv ( v ) ;
1805 }
1806
1807 void xglRasterPos3d ( GLdouble x, GLdouble y, GLdouble z )
1808 {
1809   if ( xglTraceIsEnabled("glRasterPos3d") )
1810     fprintf ( xglTraceFd, "  glRasterPos3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
1811   if ( xglExecuteIsEnabled("glRasterPos3d") )
1812     glRasterPos3d ( x, y, z ) ;
1813 }
1814
1815 void xglRasterPos3dv ( GLdouble* v )
1816 {
1817   if ( xglTraceIsEnabled("glRasterPos3dv") )
1818     fprintf ( xglTraceFd, "  glRasterPos3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
1819   if ( xglExecuteIsEnabled("glRasterPos3dv") )
1820     glRasterPos3dv ( v ) ;
1821 }
1822
1823 void xglRasterPos3f ( GLfloat x, GLfloat y, GLfloat z )
1824 {
1825   if ( xglTraceIsEnabled("glRasterPos3f") )
1826     fprintf ( xglTraceFd, "  glRasterPos3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
1827   if ( xglExecuteIsEnabled("glRasterPos3f") )
1828     glRasterPos3f ( x, y, z ) ;
1829 }
1830
1831 void xglRasterPos3fv ( GLfloat* v )
1832 {
1833   if ( xglTraceIsEnabled("glRasterPos3fv") )
1834     fprintf ( xglTraceFd, "  glRasterPos3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
1835   if ( xglExecuteIsEnabled("glRasterPos3fv") )
1836     glRasterPos3fv ( v ) ;
1837 }
1838
1839 void xglRasterPos3i ( GLint x, GLint y, GLint z )
1840 {
1841   if ( xglTraceIsEnabled("glRasterPos3i") )
1842     fprintf ( xglTraceFd, "  glRasterPos3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z ) ;
1843   if ( xglExecuteIsEnabled("glRasterPos3i") )
1844     glRasterPos3i ( x, y, z ) ;
1845 }
1846
1847 void xglRasterPos3iv ( GLint* v )
1848 {
1849   if ( xglTraceIsEnabled("glRasterPos3iv") )
1850     fprintf ( xglTraceFd, "  glRasterPos3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
1851   if ( xglExecuteIsEnabled("glRasterPos3iv") )
1852     glRasterPos3iv ( v ) ;
1853 }
1854
1855 void xglRasterPos3s ( GLshort x, GLshort y, GLshort z )
1856 {
1857   if ( xglTraceIsEnabled("glRasterPos3s") )
1858     fprintf ( xglTraceFd, "  glRasterPos3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z ) ;
1859   if ( xglExecuteIsEnabled("glRasterPos3s") )
1860     glRasterPos3s ( x, y, z ) ;
1861 }
1862
1863 void xglRasterPos3sv ( GLshort* v )
1864 {
1865   if ( xglTraceIsEnabled("glRasterPos3sv") )
1866     fprintf ( xglTraceFd, "  glRasterPos3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
1867   if ( xglExecuteIsEnabled("glRasterPos3sv") )
1868     glRasterPos3sv ( v ) ;
1869 }
1870
1871 void xglRasterPos4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
1872 {
1873   if ( xglTraceIsEnabled("glRasterPos4d") )
1874     fprintf ( xglTraceFd, "  glRasterPos4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z, w ) ;
1875   if ( xglExecuteIsEnabled("glRasterPos4d") )
1876     glRasterPos4d ( x, y, z, w ) ;
1877 }
1878
1879 void xglRasterPos4dv ( GLdouble* v )
1880 {
1881   if ( xglTraceIsEnabled("glRasterPos4dv") )
1882     fprintf ( xglTraceFd, "  glRasterPos4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
1883   if ( xglExecuteIsEnabled("glRasterPos4dv") )
1884     glRasterPos4dv ( v ) ;
1885 }
1886
1887 void xglRasterPos4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
1888 {
1889   if ( xglTraceIsEnabled("glRasterPos4f") )
1890     fprintf ( xglTraceFd, "  glRasterPos4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z, w ) ;
1891   if ( xglExecuteIsEnabled("glRasterPos4f") )
1892     glRasterPos4f ( x, y, z, w ) ;
1893 }
1894
1895 void xglRasterPos4fv ( GLfloat* v )
1896 {
1897   if ( xglTraceIsEnabled("glRasterPos4fv") )
1898     fprintf ( xglTraceFd, "  glRasterPos4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
1899   if ( xglExecuteIsEnabled("glRasterPos4fv") )
1900     glRasterPos4fv ( v ) ;
1901 }
1902
1903 void xglRasterPos4i ( GLint x, GLint y, GLint z, GLint w )
1904 {
1905   if ( xglTraceIsEnabled("glRasterPos4i") )
1906     fprintf ( xglTraceFd, "  glRasterPos4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z, w ) ;
1907   if ( xglExecuteIsEnabled("glRasterPos4i") )
1908     glRasterPos4i ( x, y, z, w ) ;
1909 }
1910
1911 void xglRasterPos4iv ( GLint* v )
1912 {
1913   if ( xglTraceIsEnabled("glRasterPos4iv") )
1914     fprintf ( xglTraceFd, "  glRasterPos4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
1915   if ( xglExecuteIsEnabled("glRasterPos4iv") )
1916     glRasterPos4iv ( v ) ;
1917 }
1918
1919 void xglRasterPos4s ( GLshort x, GLshort y, GLshort z, GLshort w )
1920 {
1921   if ( xglTraceIsEnabled("glRasterPos4s") )
1922     fprintf ( xglTraceFd, "  glRasterPos4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z, w ) ;
1923   if ( xglExecuteIsEnabled("glRasterPos4s") )
1924     glRasterPos4s ( x, y, z, w ) ;
1925 }
1926
1927 void xglRasterPos4sv ( GLshort* v )
1928 {
1929   if ( xglTraceIsEnabled("glRasterPos4sv") )
1930     fprintf ( xglTraceFd, "  glRasterPos4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
1931   if ( xglExecuteIsEnabled("glRasterPos4sv") )
1932     glRasterPos4sv ( v ) ;
1933 }
1934
1935 void xglReadBuffer ( GLenum mode )
1936 {
1937   if ( xglTraceIsEnabled("glReadBuffer") )
1938     fprintf ( xglTraceFd, "  glReadBuffer ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
1939   if ( xglExecuteIsEnabled("glReadBuffer") )
1940     glReadBuffer ( mode ) ;
1941 }
1942
1943 void xglReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels )
1944 {
1945   if ( xglTraceIsEnabled("glReadPixels") )
1946     fprintf ( xglTraceFd, "  glReadPixels ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , x, y, width, height, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
1947   if ( xglExecuteIsEnabled("glReadPixels") )
1948     glReadPixels ( x, y, width, height, format, type, pixels ) ;
1949 }
1950
1951 void xglRectd ( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
1952 {
1953   if ( xglTraceIsEnabled("glRectd") )
1954     fprintf ( xglTraceFd, "  glRectd ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x1, y1, x2, y2 ) ;
1955   if ( xglExecuteIsEnabled("glRectd") )
1956     glRectd ( x1, y1, x2, y2 ) ;
1957 }
1958
1959 void xglRectdv ( GLdouble* v1, GLdouble* v2 )
1960 {
1961   if ( xglTraceIsEnabled("glRectdv") )
1962     fprintf ( xglTraceFd, "  glRectdv ( (GLdouble *)0x%08x, (GLdouble *)0x%08x ) ;\n" , v1, v2 ) ;
1963   if ( xglExecuteIsEnabled("glRectdv") )
1964     glRectdv ( v1, v2 ) ;
1965 }
1966
1967 void xglRectf ( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
1968 {
1969   if ( xglTraceIsEnabled("glRectf") )
1970     fprintf ( xglTraceFd, "  glRectf ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x1, y1, x2, y2 ) ;
1971   if ( xglExecuteIsEnabled("glRectf") )
1972     glRectf ( x1, y1, x2, y2 ) ;
1973 }
1974
1975 void xglRectfv ( GLfloat* v1, GLfloat* v2 )
1976 {
1977   if ( xglTraceIsEnabled("glRectfv") )
1978     fprintf ( xglTraceFd, "  glRectfv ( (GLfloat *)0x%08x, (GLfloat *)0x%08x ) ;\n" , v1, v2 ) ;
1979   if ( xglExecuteIsEnabled("glRectfv") )
1980     glRectfv ( v1, v2 ) ;
1981 }
1982
1983 void xglRecti ( GLint x1, GLint y1, GLint x2, GLint y2 )
1984 {
1985   if ( xglTraceIsEnabled("glRecti") )
1986     fprintf ( xglTraceFd, "  glRecti ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x1, y1, x2, y2 ) ;
1987   if ( xglExecuteIsEnabled("glRecti") )
1988     glRecti ( x1, y1, x2, y2 ) ;
1989 }
1990
1991 void xglRectiv ( GLint* v1, GLint* v2 )
1992 {
1993   if ( xglTraceIsEnabled("glRectiv") )
1994     fprintf ( xglTraceFd, "  glRectiv ( (GLint *)0x%08x, (GLint *)0x%08x ) ;\n" , v1, v2 ) ;
1995   if ( xglExecuteIsEnabled("glRectiv") )
1996     glRectiv ( v1, v2 ) ;
1997 }
1998
1999 void xglRects ( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
2000 {
2001   if ( xglTraceIsEnabled("glRects") )
2002     fprintf ( xglTraceFd, "  glRects ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x1, y1, x2, y2 ) ;
2003   if ( xglExecuteIsEnabled("glRects") )
2004     glRects ( x1, y1, x2, y2 ) ;
2005 }
2006
2007 void xglRectsv ( GLshort* v1, GLshort* v2 )
2008 {
2009   if ( xglTraceIsEnabled("glRectsv") )
2010     fprintf ( xglTraceFd, "  glRectsv ( (GLshort *)0x%08x, (GLshort *)0x%08x ) ;\n" , v1, v2 ) ;
2011   if ( xglExecuteIsEnabled("glRectsv") )
2012     glRectsv ( v1, v2 ) ;
2013 }
2014
2015 void xglRotated ( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
2016 {
2017   if ( xglTraceIsEnabled("glRotated") )
2018     fprintf ( xglTraceFd, "  glRotated ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , angle, x, y, z ) ;
2019   if ( xglExecuteIsEnabled("glRotated") )
2020     glRotated ( angle, x, y, z ) ;
2021 }
2022
2023 void xglRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
2024 {
2025   if ( xglTraceIsEnabled("glRotatef") )
2026     fprintf ( xglTraceFd, "  glRotatef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , angle, x, y, z ) ;
2027   if ( xglExecuteIsEnabled("glRotatef") )
2028     glRotatef ( angle, x, y, z ) ;
2029 }
2030
2031 void xglScaled ( GLdouble x, GLdouble y, GLdouble z )
2032 {
2033   if ( xglTraceIsEnabled("glScaled") )
2034     fprintf ( xglTraceFd, "  glScaled ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
2035   if ( xglExecuteIsEnabled("glScaled") )
2036     glScaled ( x, y, z ) ;
2037 }
2038
2039 void xglScalef ( GLfloat x, GLfloat y, GLfloat z )
2040 {
2041   if ( xglTraceIsEnabled("glScalef") )
2042     fprintf ( xglTraceFd, "  glScalef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
2043   if ( xglExecuteIsEnabled("glScalef") )
2044     glScalef ( x, y, z ) ;
2045 }
2046
2047 void xglScissor ( GLint x, GLint y, GLsizei width, GLsizei height )
2048 {
2049   if ( xglTraceIsEnabled("glScissor") )
2050     fprintf ( xglTraceFd, "  glScissor ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d ) ;\n" , x, y, width, height ) ;
2051   if ( xglExecuteIsEnabled("glScissor") )
2052     glScissor ( x, y, width, height ) ;
2053 }
2054
2055 void xglSelectBuffer ( GLsizei size, GLuint* buffer )
2056 {
2057   if ( xglTraceIsEnabled("glSelectBuffer") )
2058     fprintf ( xglTraceFd, "  glSelectBuffer ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , size, buffer ) ;
2059   if ( xglExecuteIsEnabled("glSelectBuffer") )
2060     glSelectBuffer ( size, buffer ) ;
2061 }
2062
2063 void xglShadeModel ( GLenum mode )
2064 {
2065   if ( xglTraceIsEnabled("glShadeModel") )
2066     fprintf ( xglTraceFd, "  glShadeModel ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
2067   if ( xglExecuteIsEnabled("glShadeModel") )
2068     glShadeModel ( mode ) ;
2069 }
2070
2071 void xglStencilFunc ( GLenum func, GLint ref, GLuint mask )
2072 {
2073   if ( xglTraceIsEnabled("glStencilFunc") )
2074     fprintf ( xglTraceFd, "  glStencilFunc ( (GLenum)%s, (GLint)%d, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) func ), ref, mask ) ;
2075   if ( xglExecuteIsEnabled("glStencilFunc") )
2076     glStencilFunc ( func, ref, mask ) ;
2077 }
2078
2079 void xglStencilMask ( GLuint mask )
2080 {
2081   if ( xglTraceIsEnabled("glStencilMask") )
2082     fprintf ( xglTraceFd, "  glStencilMask ( (GLuint)%u ) ;\n" , mask ) ;
2083   if ( xglExecuteIsEnabled("glStencilMask") )
2084     glStencilMask ( mask ) ;
2085 }
2086
2087 void xglStencilOp ( GLenum fail, GLenum zfail, GLenum zpass )
2088 {
2089   if ( xglTraceIsEnabled("glStencilOp") )
2090     fprintf ( xglTraceFd, "  glStencilOp ( (GLenum)%s, (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) fail ), xglExpandGLenum ( (GLenum) zfail ), xglExpandGLenum ( (GLenum) zpass ) ) ;
2091   if ( xglExecuteIsEnabled("glStencilOp") )
2092     glStencilOp ( fail, zfail, zpass ) ;
2093 }
2094
2095 void xglTexCoord1d ( GLdouble s )
2096 {
2097   if ( xglTraceIsEnabled("glTexCoord1d") )
2098     fprintf ( xglTraceFd, "  glTexCoord1d ( (GLdouble)%f ) ;\n" , s ) ;
2099   if ( xglExecuteIsEnabled("glTexCoord1d") )
2100     glTexCoord1d ( s ) ;
2101 }
2102
2103 void xglTexCoord1dv ( GLdouble* v )
2104 {
2105   if ( xglTraceIsEnabled("glTexCoord1dv") )
2106     fprintf ( xglTraceFd, "  glTexCoord1dv ( xglBuild1dv((GLdouble)%f) ) ;\n" , v[0] ) ;
2107   if ( xglExecuteIsEnabled("glTexCoord1dv") )
2108     glTexCoord1dv ( v ) ;
2109 }
2110
2111 void xglTexCoord1f ( GLfloat s )
2112 {
2113   if ( xglTraceIsEnabled("glTexCoord1f") )
2114     fprintf ( xglTraceFd, "  glTexCoord1f ( (GLfloat)%ff ) ;\n" , s ) ;
2115   if ( xglExecuteIsEnabled("glTexCoord1f") )
2116     glTexCoord1f ( s ) ;
2117 }
2118
2119 void xglTexCoord1fv ( GLfloat* v )
2120 {
2121   if ( xglTraceIsEnabled("glTexCoord1fv") )
2122     fprintf ( xglTraceFd, "  glTexCoord1fv ( xglBuild1fv((GLfloat)%ff) ) ;\n" , v[0] ) ;
2123   if ( xglExecuteIsEnabled("glTexCoord1fv") )
2124     glTexCoord1fv ( v ) ;
2125 }
2126
2127 void xglTexCoord1i ( GLint s )
2128 {
2129   if ( xglTraceIsEnabled("glTexCoord1i") )
2130     fprintf ( xglTraceFd, "  glTexCoord1i ( (GLint)%d ) ;\n" , s ) ;
2131   if ( xglExecuteIsEnabled("glTexCoord1i") )
2132     glTexCoord1i ( s ) ;
2133 }
2134
2135 void xglTexCoord1iv ( GLint* v )
2136 {
2137   if ( xglTraceIsEnabled("glTexCoord1iv") )
2138     fprintf ( xglTraceFd, "  glTexCoord1iv ( xglBuild1iv((GLint)%d) ) ;\n" , v[0] ) ;
2139   if ( xglExecuteIsEnabled("glTexCoord1iv") )
2140     glTexCoord1iv ( v ) ;
2141 }
2142
2143 void xglTexCoord1s ( GLshort s )
2144 {
2145   if ( xglTraceIsEnabled("glTexCoord1s") )
2146     fprintf ( xglTraceFd, "  glTexCoord1s ( (GLshort)%d ) ;\n" , s ) ;
2147   if ( xglExecuteIsEnabled("glTexCoord1s") )
2148     glTexCoord1s ( s ) ;
2149 }
2150
2151 void xglTexCoord1sv ( GLshort* v )
2152 {
2153   if ( xglTraceIsEnabled("glTexCoord1sv") )
2154     fprintf ( xglTraceFd, "  glTexCoord1sv ( xglBuild1sv((GLshort)%d) ) ;\n" , v[0] ) ;
2155   if ( xglExecuteIsEnabled("glTexCoord1sv") )
2156     glTexCoord1sv ( v ) ;
2157 }
2158
2159 void xglTexCoord2d ( GLdouble s, GLdouble t )
2160 {
2161   if ( xglTraceIsEnabled("glTexCoord2d") )
2162     fprintf ( xglTraceFd, "  glTexCoord2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t ) ;
2163   if ( xglExecuteIsEnabled("glTexCoord2d") )
2164     glTexCoord2d ( s, t ) ;
2165 }
2166
2167 void xglTexCoord2dv ( GLdouble* v )
2168 {
2169   if ( xglTraceIsEnabled("glTexCoord2dv") )
2170     fprintf ( xglTraceFd, "  glTexCoord2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
2171   if ( xglExecuteIsEnabled("glTexCoord2dv") )
2172     glTexCoord2dv ( v ) ;
2173 }
2174
2175 void xglTexCoord2f ( GLfloat s, GLfloat t )
2176 {
2177   if ( xglTraceIsEnabled("glTexCoord2f") )
2178     fprintf ( xglTraceFd, "  glTexCoord2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t ) ;
2179   if ( xglExecuteIsEnabled("glTexCoord2f") )
2180     glTexCoord2f ( s, t ) ;
2181 }
2182
2183 void xglTexCoord2fv ( GLfloat* v )
2184 {
2185   if ( xglTraceIsEnabled("glTexCoord2fv") )
2186     fprintf ( xglTraceFd, "  glTexCoord2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
2187   if ( xglExecuteIsEnabled("glTexCoord2fv") )
2188     glTexCoord2fv ( v ) ;
2189 }
2190
2191 void xglTexCoord2i ( GLint s, GLint t )
2192 {
2193   if ( xglTraceIsEnabled("glTexCoord2i") )
2194     fprintf ( xglTraceFd, "  glTexCoord2i ( (GLint)%d, (GLint)%d ) ;\n" , s, t ) ;
2195   if ( xglExecuteIsEnabled("glTexCoord2i") )
2196     glTexCoord2i ( s, t ) ;
2197 }
2198
2199 void xglTexCoord2iv ( GLint* v )
2200 {
2201   if ( xglTraceIsEnabled("glTexCoord2iv") )
2202     fprintf ( xglTraceFd, "  glTexCoord2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
2203   if ( xglExecuteIsEnabled("glTexCoord2iv") )
2204     glTexCoord2iv ( v ) ;
2205 }
2206
2207 void xglTexCoord2s ( GLshort s, GLshort t )
2208 {
2209   if ( xglTraceIsEnabled("glTexCoord2s") )
2210     fprintf ( xglTraceFd, "  glTexCoord2s ( (GLshort)%d, (GLshort)%d ) ;\n" , s, t ) ;
2211   if ( xglExecuteIsEnabled("glTexCoord2s") )
2212     glTexCoord2s ( s, t ) ;
2213 }
2214
2215 void xglTexCoord2sv ( GLshort* v )
2216 {
2217   if ( xglTraceIsEnabled("glTexCoord2sv") )
2218     fprintf ( xglTraceFd, "  glTexCoord2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
2219   if ( xglExecuteIsEnabled("glTexCoord2sv") )
2220     glTexCoord2sv ( v ) ;
2221 }
2222
2223 void xglTexCoord3d ( GLdouble s, GLdouble t, GLdouble r )
2224 {
2225   if ( xglTraceIsEnabled("glTexCoord3d") )
2226     fprintf ( xglTraceFd, "  glTexCoord3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t, r ) ;
2227   if ( xglExecuteIsEnabled("glTexCoord3d") )
2228     glTexCoord3d ( s, t, r ) ;
2229 }
2230
2231 void xglTexCoord3dv ( GLdouble* v )
2232 {
2233   if ( xglTraceIsEnabled("glTexCoord3dv") )
2234     fprintf ( xglTraceFd, "  glTexCoord3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
2235   if ( xglExecuteIsEnabled("glTexCoord3dv") )
2236     glTexCoord3dv ( v ) ;
2237 }
2238
2239 void xglTexCoord3f ( GLfloat s, GLfloat t, GLfloat r )
2240 {
2241   if ( xglTraceIsEnabled("glTexCoord3f") )
2242     fprintf ( xglTraceFd, "  glTexCoord3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t, r ) ;
2243   if ( xglExecuteIsEnabled("glTexCoord3f") )
2244     glTexCoord3f ( s, t, r ) ;
2245 }
2246
2247 void xglTexCoord3fv ( GLfloat* v )
2248 {
2249   if ( xglTraceIsEnabled("glTexCoord3fv") )
2250     fprintf ( xglTraceFd, "  glTexCoord3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
2251   if ( xglExecuteIsEnabled("glTexCoord3fv") )
2252     glTexCoord3fv ( v ) ;
2253 }
2254
2255 void xglTexCoord3i ( GLint s, GLint t, GLint r )
2256 {
2257   if ( xglTraceIsEnabled("glTexCoord3i") )
2258     fprintf ( xglTraceFd, "  glTexCoord3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , s, t, r ) ;
2259   if ( xglExecuteIsEnabled("glTexCoord3i") )
2260     glTexCoord3i ( s, t, r ) ;
2261 }
2262
2263 void xglTexCoord3iv ( GLint* v )
2264 {
2265   if ( xglTraceIsEnabled("glTexCoord3iv") )
2266     fprintf ( xglTraceFd, "  glTexCoord3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
2267   if ( xglExecuteIsEnabled("glTexCoord3iv") )
2268     glTexCoord3iv ( v ) ;
2269 }
2270
2271 void xglTexCoord3s ( GLshort s, GLshort t, GLshort r )
2272 {
2273   if ( xglTraceIsEnabled("glTexCoord3s") )
2274     fprintf ( xglTraceFd, "  glTexCoord3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , s, t, r ) ;
2275   if ( xglExecuteIsEnabled("glTexCoord3s") )
2276     glTexCoord3s ( s, t, r ) ;
2277 }
2278
2279 void xglTexCoord3sv ( GLshort* v )
2280 {
2281   if ( xglTraceIsEnabled("glTexCoord3sv") )
2282     fprintf ( xglTraceFd, "  glTexCoord3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
2283   if ( xglExecuteIsEnabled("glTexCoord3sv") )
2284     glTexCoord3sv ( v ) ;
2285 }
2286
2287 void xglTexCoord4d ( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
2288 {
2289   if ( xglTraceIsEnabled("glTexCoord4d") )
2290     fprintf ( xglTraceFd, "  glTexCoord4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t, r, q ) ;
2291   if ( xglExecuteIsEnabled("glTexCoord4d") )
2292     glTexCoord4d ( s, t, r, q ) ;
2293 }
2294
2295 void xglTexCoord4dv ( GLdouble* v )
2296 {
2297   if ( xglTraceIsEnabled("glTexCoord4dv") )
2298     fprintf ( xglTraceFd, "  glTexCoord4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2299   if ( xglExecuteIsEnabled("glTexCoord4dv") )
2300     glTexCoord4dv ( v ) ;
2301 }
2302
2303 void xglTexCoord4f ( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
2304 {
2305   if ( xglTraceIsEnabled("glTexCoord4f") )
2306     fprintf ( xglTraceFd, "  glTexCoord4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t, r, q ) ;
2307   if ( xglExecuteIsEnabled("glTexCoord4f") )
2308     glTexCoord4f ( s, t, r, q ) ;
2309 }
2310
2311 void xglTexCoord4fv ( GLfloat* v )
2312 {
2313   if ( xglTraceIsEnabled("glTexCoord4fv") )
2314     fprintf ( xglTraceFd, "  glTexCoord4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2315   if ( xglExecuteIsEnabled("glTexCoord4fv") )
2316     glTexCoord4fv ( v ) ;
2317 }
2318
2319 void xglTexCoord4i ( GLint s, GLint t, GLint r, GLint q )
2320 {
2321   if ( xglTraceIsEnabled("glTexCoord4i") )
2322     fprintf ( xglTraceFd, "  glTexCoord4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , s, t, r, q ) ;
2323   if ( xglExecuteIsEnabled("glTexCoord4i") )
2324     glTexCoord4i ( s, t, r, q ) ;
2325 }
2326
2327 void xglTexCoord4iv ( GLint* v )
2328 {
2329   if ( xglTraceIsEnabled("glTexCoord4iv") )
2330     fprintf ( xglTraceFd, "  glTexCoord4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2331   if ( xglExecuteIsEnabled("glTexCoord4iv") )
2332     glTexCoord4iv ( v ) ;
2333 }
2334
2335 void xglTexCoord4s ( GLshort s, GLshort t, GLshort r, GLshort q )
2336 {
2337   if ( xglTraceIsEnabled("glTexCoord4s") )
2338     fprintf ( xglTraceFd, "  glTexCoord4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , s, t, r, q ) ;
2339   if ( xglExecuteIsEnabled("glTexCoord4s") )
2340     glTexCoord4s ( s, t, r, q ) ;
2341 }
2342
2343 void xglTexCoord4sv ( GLshort* v )
2344 {
2345   if ( xglTraceIsEnabled("glTexCoord4sv") )
2346     fprintf ( xglTraceFd, "  glTexCoord4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2347   if ( xglExecuteIsEnabled("glTexCoord4sv") )
2348     glTexCoord4sv ( v ) ;
2349 }
2350
2351 void xglTexCoordPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
2352 {
2353   if ( xglTraceIsEnabled("glTexCoordPointerEXT") )
2354     fprintf ( xglTraceFd, "  glTexCoordPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
2355 #ifdef GL_VERSION_1_1
2356     glTexCoordPointer ( size, type, stride, ptr ) ;
2357 #else
2358 #ifdef GL_EXT_vertex_array
2359   if ( xglExecuteIsEnabled("glTexCoordPointerEXT") )
2360     glTexCoordPointerEXT ( size, type, stride, count, ptr ) ;
2361 #else
2362   fprintf ( xglTraceFd, "  glTexCoordPointerEXT isn't supported on this OpenGL!\n" ) ;
2363 #endif
2364 #endif
2365 }
2366
2367 void xglTexEnvf ( GLenum target, GLenum pname, GLfloat param )
2368 {
2369   if ( xglTraceIsEnabled("glTexEnvf") )
2370     fprintf ( xglTraceFd, "  glTexEnvf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2371   if ( xglExecuteIsEnabled("glTexEnvf") )
2372     glTexEnvf ( target, pname, param ) ;
2373 }
2374
2375 void xglTexEnvfv ( GLenum target, GLenum pname, GLfloat* params )
2376 {
2377   if ( xglTraceIsEnabled("glTexEnvfv") )
2378     fprintf ( xglTraceFd, "  glTexEnvfv ( (GLenum)%s, (GLenum)%s, xglBuild4fv(%ff,%ff,%ff,%ff) ) ;\n",
2379                           xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params[0], params[1], params[2], params[3] ) ;
2380   if ( xglExecuteIsEnabled("glTexEnvfv") )
2381     glTexEnvfv ( target, pname, params ) ;
2382 }
2383
2384 void xglTexEnvi ( GLenum target, GLenum pname, GLint param )
2385 {
2386   if ( xglTraceIsEnabled("glTexEnvi") )
2387     fprintf ( xglTraceFd, "  glTexEnvi ( (GLenum)%s, (GLenum)%s, (GLint)%s ) ;\n",
2388             xglExpandGLenum ( (GLenum) target ),
2389             xglExpandGLenum ( (GLenum) pname ),
2390             xglExpandGLenum ( (GLenum) param ) ) ;
2391
2392   if ( xglExecuteIsEnabled("glTexEnvi") )
2393     glTexEnvi ( target, pname, param ) ;
2394 }
2395
2396 void xglTexEnviv ( GLenum target, GLenum pname, GLint* params )
2397 {
2398   if ( xglTraceIsEnabled("glTexEnviv") )
2399     fprintf ( xglTraceFd, "  glTexEnviv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2400   if ( xglExecuteIsEnabled("glTexEnviv") )
2401     glTexEnviv ( target, pname, params ) ;
2402 }
2403
2404 void xglTexGend ( GLenum coord, GLenum pname, GLdouble param )
2405 {
2406   if ( xglTraceIsEnabled("glTexGend") )
2407     fprintf ( xglTraceFd, "  glTexGend ( (GLenum)%s, (GLenum)%s, (GLdouble)%f ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2408   if ( xglExecuteIsEnabled("glTexGend") )
2409     glTexGend ( coord, pname, param ) ;
2410 }
2411
2412 void xglTexGendv ( GLenum coord, GLenum pname, GLdouble* params )
2413 {
2414   if ( xglTraceIsEnabled("glTexGendv") )
2415     fprintf ( xglTraceFd, "  glTexGendv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2416   if ( xglExecuteIsEnabled("glTexGendv") )
2417     glTexGendv ( coord, pname, params ) ;
2418 }
2419
2420 void xglTexGenf ( GLenum coord, GLenum pname, GLfloat param )
2421 {
2422   if ( xglTraceIsEnabled("glTexGenf") )
2423     fprintf ( xglTraceFd, "  glTexGenf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2424   if ( xglExecuteIsEnabled("glTexGenf") )
2425     glTexGenf ( coord, pname, param ) ;
2426 }
2427
2428 void xglTexGenfv ( GLenum coord, GLenum pname, GLfloat* params )
2429 {
2430   if ( xglTraceIsEnabled("glTexGenfv") )
2431     fprintf ( xglTraceFd, "  glTexGenfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2432   if ( xglExecuteIsEnabled("glTexGenfv") )
2433     glTexGenfv ( coord, pname, params ) ;
2434 }
2435
2436 void xglTexGeni ( GLenum coord, GLenum pname, GLint param )
2437 {
2438   if ( xglTraceIsEnabled("glTexGeni") )
2439     fprintf ( xglTraceFd, "  glTexGeni ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2440   if ( xglExecuteIsEnabled("glTexGeni") )
2441     glTexGeni ( coord, pname, param ) ;
2442 }
2443
2444 void xglTexGeniv ( GLenum coord, GLenum pname, GLint* params )
2445 {
2446   if ( xglTraceIsEnabled("glTexGeniv") )
2447     fprintf ( xglTraceFd, "  glTexGeniv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2448   if ( xglExecuteIsEnabled("glTexGeniv") )
2449     glTexGeniv ( coord, pname, params ) ;
2450 }
2451
2452 void xglTexImage1D ( GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid* pixels )
2453 {
2454   if ( xglTraceIsEnabled("glTexImage1D") )
2455     fprintf ( xglTraceFd, "  glTexImage1D ( (GLenum)%s, (GLint)%d, (GLint)%d, (GLsizei)%d, (GLint)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), level, components, width, border, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
2456   if ( xglExecuteIsEnabled("glTexImage1D") )
2457     glTexImage1D ( target, level, components, width, border, format, type, pixels ) ;
2458 }
2459
2460 void xglTexImage2D ( GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels )
2461 {
2462   if ( xglTraceIsEnabled("glTexImage2D") )
2463     fprintf ( xglTraceFd, "  glTexImage2D ( (GLenum)%s, (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d, (GLint)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), level, components, width, height, border, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
2464   if ( xglExecuteIsEnabled("glTexImage2D") )
2465     glTexImage2D ( target, level, components, width, height, border, format, type, pixels ) ;
2466 }
2467
2468 void xglTexParameterf ( GLenum target, GLenum pname, GLfloat param )
2469 {
2470   if ( xglTraceIsEnabled("glTexParameterf") )
2471     fprintf ( xglTraceFd, "  glTexParameterf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2472   if ( xglExecuteIsEnabled("glTexParameterf") )
2473     glTexParameterf ( target, pname, param ) ;
2474 }
2475
2476 void xglTexParameterfv ( GLenum target, GLenum pname, GLfloat* params )
2477 {
2478   if ( xglTraceIsEnabled("glTexParameterfv") )
2479     fprintf ( xglTraceFd, "  glTexParameterfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2480   if ( xglExecuteIsEnabled("glTexParameterfv") )
2481     glTexParameterfv ( target, pname, params ) ;
2482 }
2483
2484 void xglTexParameteri ( GLenum target, GLenum pname, GLint param )
2485 {
2486   if ( xglTraceIsEnabled("glTexParameteri") )
2487     fprintf ( xglTraceFd, "  glTexParameteri ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
2488   if ( xglExecuteIsEnabled("glTexParameteri") )
2489     glTexParameteri ( target, pname, param ) ;
2490 }
2491
2492 void xglTexParameteriv ( GLenum target, GLenum pname, GLint* params )
2493 {
2494   if ( xglTraceIsEnabled("glTexParameteriv") )
2495     fprintf ( xglTraceFd, "  glTexParameteriv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
2496   if ( xglExecuteIsEnabled("glTexParameteriv") )
2497     glTexParameteriv ( target, pname, params ) ;
2498 }
2499
2500 void xglTranslated ( GLdouble x, GLdouble y, GLdouble z )
2501 {
2502   if ( xglTraceIsEnabled("glTranslated") )
2503     fprintf ( xglTraceFd, "  glTranslated ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
2504   if ( xglExecuteIsEnabled("glTranslated") )
2505     glTranslated ( x, y, z ) ;
2506 }
2507
2508 void xglTranslatef ( GLfloat x, GLfloat y, GLfloat z )
2509 {
2510   if ( xglTraceIsEnabled("glTranslatef") )
2511     fprintf ( xglTraceFd, "  glTranslatef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
2512   if ( xglExecuteIsEnabled("glTranslatef") )
2513     glTranslatef ( x, y, z ) ;
2514 }
2515
2516 void xglVertex2d ( GLdouble x, GLdouble y )
2517 {
2518   if ( xglTraceIsEnabled("glVertex2d") )
2519     fprintf ( xglTraceFd, "  glVertex2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y ) ;
2520   if ( xglExecuteIsEnabled("glVertex2d") )
2521     glVertex2d ( x, y ) ;
2522 }
2523
2524 void xglVertex2dv ( GLdouble* v )
2525 {
2526   if ( xglTraceIsEnabled("glVertex2dv") )
2527     fprintf ( xglTraceFd, "  glVertex2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
2528   if ( xglExecuteIsEnabled("glVertex2dv") )
2529     glVertex2dv ( v ) ;
2530 }
2531
2532 void xglVertex2f ( GLfloat x, GLfloat y )
2533 {
2534   if ( xglTraceIsEnabled("glVertex2f") )
2535     fprintf ( xglTraceFd, "  glVertex2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y ) ;
2536   if ( xglExecuteIsEnabled("glVertex2f") )
2537     glVertex2f ( x, y ) ;
2538 }
2539
2540 void xglVertex2fv ( GLfloat* v )
2541 {
2542   if ( xglTraceIsEnabled("glVertex2fv") )
2543     fprintf ( xglTraceFd, "  glVertex2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
2544   if ( xglExecuteIsEnabled("glVertex2fv") )
2545     glVertex2fv ( v ) ;
2546 }
2547
2548 void xglVertex2i ( GLint x, GLint y )
2549 {
2550   if ( xglTraceIsEnabled("glVertex2i") )
2551     fprintf ( xglTraceFd, "  glVertex2i ( (GLint)%d, (GLint)%d ) ;\n" , x, y ) ;
2552   if ( xglExecuteIsEnabled("glVertex2i") )
2553     glVertex2i ( x, y ) ;
2554 }
2555
2556 void xglVertex2iv ( GLint* v )
2557 {
2558   if ( xglTraceIsEnabled("glVertex2iv") )
2559     fprintf ( xglTraceFd, "  glVertex2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
2560   if ( xglExecuteIsEnabled("glVertex2iv") )
2561     glVertex2iv ( v ) ;
2562 }
2563
2564 void xglVertex2s ( GLshort x, GLshort y )
2565 {
2566   if ( xglTraceIsEnabled("glVertex2s") )
2567     fprintf ( xglTraceFd, "  glVertex2s ( (GLshort)%d, (GLshort)%d ) ;\n" , x, y ) ;
2568   if ( xglExecuteIsEnabled("glVertex2s") )
2569     glVertex2s ( x, y ) ;
2570 }
2571
2572 void xglVertex2sv ( GLshort* v )
2573 {
2574   if ( xglTraceIsEnabled("glVertex2sv") )
2575     fprintf ( xglTraceFd, "  glVertex2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
2576   if ( xglExecuteIsEnabled("glVertex2sv") )
2577     glVertex2sv ( v ) ;
2578 }
2579
2580 void xglVertex3d ( GLdouble x, GLdouble y, GLdouble z )
2581 {
2582   if ( xglTraceIsEnabled("glVertex3d") )
2583     fprintf ( xglTraceFd, "  glVertex3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
2584   if ( xglExecuteIsEnabled("glVertex3d") )
2585     glVertex3d ( x, y, z ) ;
2586 }
2587
2588 void xglVertex3dv ( GLdouble* v )
2589 {
2590   if ( xglTraceIsEnabled("glVertex3dv") )
2591     fprintf ( xglTraceFd, "  glVertex3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
2592   if ( xglExecuteIsEnabled("glVertex3dv") )
2593     glVertex3dv ( v ) ;
2594 }
2595
2596 void xglVertex3f ( GLfloat x, GLfloat y, GLfloat z )
2597 {
2598   if ( xglTraceIsEnabled("glVertex3f") )
2599     fprintf ( xglTraceFd, "  glVertex3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
2600   if ( xglExecuteIsEnabled("glVertex3f") )
2601     glVertex3f ( x, y, z ) ;
2602 }
2603
2604 void xglVertex3fv ( GLfloat* v )
2605 {
2606   if ( xglTraceIsEnabled("glVertex3fv") )
2607     fprintf ( xglTraceFd, "  glVertex3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
2608   if ( xglExecuteIsEnabled("glVertex3fv") )
2609     glVertex3fv ( v ) ;
2610 }
2611
2612 void xglVertex3i ( GLint x, GLint y, GLint z )
2613 {
2614   if ( xglTraceIsEnabled("glVertex3i") )
2615     fprintf ( xglTraceFd, "  glVertex3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z ) ;
2616   if ( xglExecuteIsEnabled("glVertex3i") )
2617     glVertex3i ( x, y, z ) ;
2618 }
2619
2620 void xglVertex3iv ( GLint* v )
2621 {
2622   if ( xglTraceIsEnabled("glVertex3iv") )
2623     fprintf ( xglTraceFd, "  glVertex3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
2624   if ( xglExecuteIsEnabled("glVertex3iv") )
2625     glVertex3iv ( v ) ;
2626 }
2627
2628 void xglVertex3s ( GLshort x, GLshort y, GLshort z )
2629 {
2630   if ( xglTraceIsEnabled("glVertex3s") )
2631     fprintf ( xglTraceFd, "  glVertex3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z ) ;
2632   if ( xglExecuteIsEnabled("glVertex3s") )
2633     glVertex3s ( x, y, z ) ;
2634 }
2635
2636 void xglVertex3sv ( GLshort* v )
2637 {
2638   if ( xglTraceIsEnabled("glVertex3sv") )
2639     fprintf ( xglTraceFd, "  glVertex3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
2640   if ( xglExecuteIsEnabled("glVertex3sv") )
2641     glVertex3sv ( v ) ;
2642 }
2643
2644 void xglVertex4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
2645 {
2646   if ( xglTraceIsEnabled("glVertex4d") )
2647     fprintf ( xglTraceFd, "  glVertex4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z, w ) ;
2648   if ( xglExecuteIsEnabled("glVertex4d") )
2649     glVertex4d ( x, y, z, w ) ;
2650 }
2651
2652 void xglVertex4dv ( GLdouble* v )
2653 {
2654   if ( xglTraceIsEnabled("glVertex4dv") )
2655     fprintf ( xglTraceFd, "  glVertex4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2656   if ( xglExecuteIsEnabled("glVertex4dv") )
2657     glVertex4dv ( v ) ;
2658 }
2659
2660 void xglVertex4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
2661 {
2662   if ( xglTraceIsEnabled("glVertex4f") )
2663     fprintf ( xglTraceFd, "  glVertex4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z, w ) ;
2664   if ( xglExecuteIsEnabled("glVertex4f") )
2665     glVertex4f ( x, y, z, w ) ;
2666 }
2667
2668 void xglVertex4fv ( GLfloat* v )
2669 {
2670   if ( xglTraceIsEnabled("glVertex4fv") )
2671     fprintf ( xglTraceFd, "  glVertex4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2672   if ( xglExecuteIsEnabled("glVertex4fv") )
2673     glVertex4fv ( v ) ;
2674 }
2675
2676 void xglVertex4i ( GLint x, GLint y, GLint z, GLint w )
2677 {
2678   if ( xglTraceIsEnabled("glVertex4i") )
2679     fprintf ( xglTraceFd, "  glVertex4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z, w ) ;
2680   if ( xglExecuteIsEnabled("glVertex4i") )
2681     glVertex4i ( x, y, z, w ) ;
2682 }
2683
2684 void xglVertex4iv ( GLint* v )
2685 {
2686   if ( xglTraceIsEnabled("glVertex4iv") )
2687     fprintf ( xglTraceFd, "  glVertex4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2688   if ( xglExecuteIsEnabled("glVertex4iv") )
2689     glVertex4iv ( v ) ;
2690 }
2691
2692 void xglVertex4s ( GLshort x, GLshort y, GLshort z, GLshort w )
2693 {
2694   if ( xglTraceIsEnabled("glVertex4s") )
2695     fprintf ( xglTraceFd, "  glVertex4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z, w ) ;
2696   if ( xglExecuteIsEnabled("glVertex4s") )
2697     glVertex4s ( x, y, z, w ) ;
2698 }
2699
2700 void xglVertex4sv ( GLshort* v )
2701 {
2702   if ( xglTraceIsEnabled("glVertex4sv") )
2703     fprintf ( xglTraceFd, "  glVertex4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
2704   if ( xglExecuteIsEnabled("glVertex4sv") )
2705     glVertex4sv ( v ) ;
2706 }
2707
2708 void xglVertexPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
2709 {
2710   if ( xglTraceIsEnabled("glVertexPointerEXT") )
2711     fprintf ( xglTraceFd, "  glVertexPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
2712 #ifdef GL_VERSION_1_1
2713     glVertexPointer ( size, type, stride, ptr ) ;
2714 #else
2715 #ifdef GL_EXT_vertex_array
2716   if ( xglExecuteIsEnabled("glVertexPointerEXT") )
2717     glVertexPointerEXT ( size, type, stride, count, ptr ) ;
2718 #else
2719   fprintf ( xglTraceFd, "  glVertexPointerEXT isn't supported on this OpenGL!\n" ) ;
2720 #endif
2721 #endif
2722 }
2723
2724 void xglViewport ( GLint x, GLint y, GLsizei width, GLsizei height )
2725 {
2726   if ( xglTraceIsEnabled("glViewport") )
2727     fprintf ( xglTraceFd, "  glViewport ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d ) ;\n" , x, y, width, height ) ;
2728   if ( xglExecuteIsEnabled("glViewport") )
2729     glViewport ( x, y, width, height ) ;
2730 }
2731
2732 void xglutAddMenuEntry ( char* label, int value )
2733 {
2734   if ( xglTraceIsEnabled("glutAddMenuEntry") )
2735     fprintf ( xglTraceFd, "  /* glutAddMenuEntry ( \"%s\", %d ) ; */\n" , label, value ) ;
2736   if ( xglExecuteIsEnabled("glutAddMenuEntry") )
2737     glutAddMenuEntry ( label, value ) ;
2738 }
2739
2740 void xglutAttachMenu ( int button )
2741 {
2742   if ( xglTraceIsEnabled("glutAttachMenu") )
2743     fprintf ( xglTraceFd, "  /* glutAttachMenu ( %d ) ; */\n" , button ) ;
2744   if ( xglExecuteIsEnabled("glutAttachMenu") )
2745     glutAttachMenu ( button ) ;
2746 }
2747
2748 int xglutCreateMenu ( void (*func)(int) )
2749 {
2750   if ( xglTraceIsEnabled("glutCreateMenu") )
2751     fprintf ( xglTraceFd, "  /* glutCreateMenu ( 0x%08x ) ; */\n" , func ) ;
2752
2753   return glutCreateMenu ( func ) ;
2754 }
2755
2756 int xglutCreateWindow ( char* title )
2757 {
2758   if ( xglTraceIsEnabled("glutCreateWindow") )
2759     fprintf ( xglTraceFd, "  /* glutCreateWindow ( \"%s\" ) ; */\n" , title ) ;
2760
2761   return glutCreateWindow ( title ) ;
2762 }
2763
2764 void xglutDisplayFunc ( void (*func)(void) )
2765 {
2766   if ( xglTraceIsEnabled("glutDisplayFunc") )
2767     fprintf ( xglTraceFd, "  /* glutDisplayFunc ( 0x%08x ) ; */\n" , func ) ;
2768   if ( xglExecuteIsEnabled("glutDisplayFunc") )
2769     glutDisplayFunc ( func ) ;
2770 }
2771
2772 void xglutIdleFunc ( void (*func)(void) )
2773 {
2774   if ( xglTraceIsEnabled("glutIdleFunc") )
2775     fprintf ( xglTraceFd, "  /* glutIdleFunc ( 0x%08x ) ; */\n" , func ) ;
2776   if ( xglExecuteIsEnabled("glutIdleFunc") )
2777     glutIdleFunc ( func ) ;
2778 }
2779
2780 void xglutInit ( int* argcp, char** argv )
2781 {
2782   if(!xglTraceFd ) {     // Not defined by any other means, must be here
2783     xglTraceFd = stdout; // avoid a crash from a NULL ptr.
2784     }
2785   if ( xglTraceIsEnabled("glutInit") )
2786     fprintf ( xglTraceFd,
2787               "  /* glutInit ( (int *)0x%08x, (char **)0x%08x ) ; */\n" ,
2788               argcp, argv ) ;
2789   if ( xglExecuteIsEnabled("glutInit") )
2790     glutInit ( argcp, argv ) ;
2791 }
2792
2793 void xglutInitDisplayMode ( unsigned int mode )
2794 {
2795   if ( xglTraceIsEnabled("glutInitDisplayMode") )
2796     fprintf ( xglTraceFd, "  /* glutInitDisplayMode ( %u ) ; */\n" , mode ) ;
2797   if ( xglExecuteIsEnabled("glutInitDisplayMode") )
2798     glutInitDisplayMode ( mode ) ;
2799 }
2800
2801 void xglutInitWindowPosition ( int x, int y )
2802 {
2803   if ( xglTraceIsEnabled("glutInitWindowPosition") )
2804     fprintf ( xglTraceFd, "  /* glutInitWindowPosition ( %d, %d ) ; */\n" , x, y ) ;
2805   if ( xglExecuteIsEnabled("glutInitWindowPosition") )
2806     glutInitWindowPosition ( x, y ) ;
2807 }
2808
2809 void xglutInitWindowSize ( int width, int height )
2810 {
2811   if ( xglTraceIsEnabled("glutInitWindowSize") )
2812     fprintf ( xglTraceFd, "  /* glutInitWindowSize ( %d, %d ) ; */\n" , width, height ) ;
2813   if ( xglExecuteIsEnabled("glutInitWindowSize") )
2814     glutInitWindowSize ( width, height ) ;
2815 }
2816
2817 void xglutKeyboardFunc ( void (*func)(unsigned char key, int x, int y) )
2818 {
2819   if ( xglTraceIsEnabled("glutKeyboardFunc") )
2820     fprintf ( xglTraceFd, "  /* glutKeyboardFunc ( 0x%08x ) ; */\n" , func ) ;
2821   if ( xglExecuteIsEnabled("glutKeyboardFunc") )
2822     glutKeyboardFunc ( func ) ;
2823 }
2824
2825 void xglutMainLoopUpdate (  )
2826 {
2827   if ( xglTraceIsEnabled("glutMainLoopUpdate") )
2828     fprintf ( xglTraceFd, "  /* glutMainLoopUpdate (  ) ; */\n"  ) ;
2829   if ( xglExecuteIsEnabled("glutMainLoopUpdate") )
2830     /* glutMainLoopUpdate (  ) ; */
2831     printf("Steves glutMainLoopUpdate() hack not executed!!!!\n");
2832 }
2833
2834 void xglutPostRedisplay (  )
2835 {
2836   if ( xglTraceIsEnabled("glutPostRedisplay") )
2837     fprintf ( xglTraceFd, "  /* glutPostRedisplay (  ) ; */\n"  ) ;
2838   if ( xglExecuteIsEnabled("glutPostRedisplay") )
2839     glutPostRedisplay (  ) ;
2840 }
2841
2842 void xglutPreMainLoop (  )
2843 {
2844   if ( xglTraceIsEnabled("glutPreMainLoop") )
2845     fprintf ( xglTraceFd, "  /* glutPreMainLoop (  ) ; */\n"  ) ;
2846   if ( xglExecuteIsEnabled("glutPreMainLoop") )
2847     /* glutPreMainLoop (  ) ; */
2848     printf("Steves glutPreLoopUpdate() hack not executed!!!!\n");
2849
2850 }
2851
2852 void xglutReshapeFunc ( void (*func)(int width, int height) )
2853 {
2854   if ( xglTraceIsEnabled("glutReshapeFunc") )
2855     fprintf ( xglTraceFd, "  /* glutReshapeFunc ( 0x%08x ) ; */\n" , func ) ;
2856   if ( xglExecuteIsEnabled("glutReshapeFunc") )
2857     glutReshapeFunc ( func ) ;
2858 }
2859
2860 void xglutSwapBuffers ()
2861 {
2862   if ( xglTraceIsEnabled("glutSwapBuffers") )
2863     fprintf ( xglTraceFd, "  /* glutSwapBuffers (  ) ; */\n"  ) ;
2864   if ( xglExecuteIsEnabled("glutSwapBuffers") )
2865     glutSwapBuffers () ;
2866 }
2867
2868 GLboolean xglAreTexturesResidentEXT ( GLsizei n, GLuint* textures, GLboolean* residences )
2869 {
2870   if ( xglTraceIsEnabled("glAreTexturesResidentEXT") )
2871     fprintf ( xglTraceFd, "  /* glAreTexturesResidentEXT ( (GLsizei)%d, (GLuint *)0x%08x, (GLboolean *)0x%08x ) ; */\n" , n, textures, residences ) ;
2872
2873 #ifdef GL_TEXTURE_2D_BINDING_EXT
2874   if ( xglExecuteIsEnabled("glAreTexturesResidentEXT") )
2875     return glAreTexturesResidentEXT ( n, textures, residences ) ;
2876 #else
2877   fprintf ( xglTraceFd, "  glAreTexturesResidentEXT isn't supported on this OpenGL!\n" ) ;
2878 #endif
2879
2880   return TRUE ;
2881 }
2882
2883 GLboolean xglIsTextureEXT ( GLuint texture )
2884 {
2885   if ( xglTraceIsEnabled("glIsTextureEXT") )
2886     fprintf ( xglTraceFd, "  /* glIsTextureEXT ( (GLuint)%u ) ; */\n" , texture ) ;
2887
2888 #ifdef GL_TEXTURE_2D_BINDING_EXT
2889   if ( xglExecuteIsEnabled("glIsTextureEXT") )
2890     return glIsTextureEXT ( texture ) ;
2891 #else
2892   fprintf ( xglTraceFd, "  glIsTextureEXT isn't supported on this OpenGL!\n" ) ;
2893 #endif
2894
2895   return TRUE ;
2896 }
2897
2898 void xglBindTextureEXT ( GLenum target, GLuint texture )
2899 {
2900   if ( xglTraceIsEnabled("glBindTextureEXT") )
2901     fprintf ( xglTraceFd, "  glBindTextureEXT ( (GLenum)%s, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) target ), texture ) ;
2902
2903 #ifdef GL_TEXTURE_2D_BINDING_EXT
2904   if ( xglExecuteIsEnabled("glBindTextureEXT") )
2905     glBindTextureEXT ( target, texture ) ;
2906 #else
2907   fprintf ( xglTraceFd, "  glBindTextureEXT isn't supported on this OpenGL!\n" ) ;
2908 #endif
2909 }
2910
2911 void xglDeleteTexturesEXT ( GLsizei n, GLuint* textures )
2912 {
2913   if ( xglTraceIsEnabled("glDeleteTexturesEXT") )
2914     fprintf ( xglTraceFd, "  glDeleteTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
2915
2916 #ifdef GL_TEXTURE_2D_BINDING_EXT
2917   if ( xglExecuteIsEnabled("glDeleteTexturesEXT") )
2918     glDeleteTexturesEXT ( n, textures ) ;
2919 #else
2920   fprintf ( xglTraceFd, "  glDeleteTextures isn't supported on this OpenGL!\n" ) ;
2921 #endif
2922 }
2923
2924 void xglGenTexturesEXT ( GLsizei n, GLuint* textures )
2925 {
2926   if ( xglTraceIsEnabled("glGenTexturesEXT") )
2927     fprintf ( xglTraceFd, "  glGenTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
2928
2929 #ifdef GL_TEXTURE_2D_BINDING_EXT
2930   if ( xglExecuteIsEnabled("glGenTexturesEXT") )
2931     glGenTexturesEXT ( n, textures ) ;
2932 #else
2933   fprintf ( xglTraceFd, "  glDeleteTexturesEXT isn't supported on this OpenGL!\n" ) ;
2934 #endif
2935 }
2936
2937 void xglPrioritizeTexturesEXT ( GLsizei n, GLuint* textures, GLclampf* priorities )
2938 {
2939   if ( xglTraceIsEnabled("glPrioritizeTexturesEXT") )
2940     fprintf ( xglTraceFd, "  glPrioritizeTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x, (GLclampf *)0x%08x ) ;\n" , n, textures, priorities ) ;
2941
2942 #ifdef GL_TEXTURE_2D_BINDING_EXT
2943   if ( xglExecuteIsEnabled("glPrioritizeTexturesEXT") )
2944     glPrioritizeTexturesEXT ( n, textures, priorities ) ;
2945 #else
2946   fprintf ( xglTraceFd, "  glPrioritizeTexturesEXT isn't supported on this OpenGL!\n" ) ;
2947 #endif
2948 }
2949
2950
2951 GLboolean xglAreTexturesResident ( GLsizei n, GLuint* textures, GLboolean* residences )
2952 {
2953   if ( xglTraceIsEnabled("glAreTexturesResident") )
2954     fprintf ( xglTraceFd, "  /* glAreTexturesResident ( (GLsizei)%d, (GLuint *)0x%08x, (GLboolean *)0x%08x ) ; */\n" , n, textures, residences ) ;
2955
2956 #ifdef GL_VERSION_1_1
2957   if ( xglExecuteIsEnabled("glAreTexturesResident") )
2958     return glAreTexturesResident ( n, textures, residences ) ;
2959 #else
2960   fprintf ( xglTraceFd, "  glAreTexturesResident isn't supported on this OpenGL!\n" ) ;
2961 #endif
2962
2963   return TRUE ;
2964 }
2965
2966 GLboolean xglIsTexture ( GLuint texture )
2967 {
2968   if ( xglTraceIsEnabled("glIsTexture") )
2969     fprintf ( xglTraceFd, "  /* glIsTexture ( (GLuint)%u ) ; */\n" , texture ) ;
2970
2971 #ifdef GL_VERSION_1_1
2972   if ( xglExecuteIsEnabled("glIsTexture") )
2973     return glIsTexture ( texture ) ;
2974 #else
2975   fprintf ( xglTraceFd, "  glIsTexture isn't supported on this OpenGL!\n" ) ;
2976 #endif
2977
2978   return TRUE ;
2979 }
2980
2981 void xglBindTexture ( GLenum target, GLuint texture )
2982 {
2983   if ( xglTraceIsEnabled("glBindTexture") )
2984     fprintf ( xglTraceFd, "  glBindTexture ( (GLenum)%s, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) target ), texture ) ;
2985
2986 #ifdef GL_VERSION_1_1
2987   if ( xglExecuteIsEnabled("glBindTexture") )
2988     glBindTexture ( target, texture ) ;
2989 #else
2990   fprintf ( xglTraceFd, "  glBindTexture isn't supported on this OpenGL!\n" ) ;
2991 #endif
2992 }
2993
2994 void xglDeleteTextures ( GLsizei n, GLuint* textures )
2995 {
2996   if ( xglTraceIsEnabled("glDeleteTextures") )
2997     fprintf ( xglTraceFd, "  glDeleteTextures ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
2998
2999 #ifdef GL_VERSION_1_1
3000   if ( xglExecuteIsEnabled("glDeleteTextures") )
3001     glDeleteTextures ( n, textures ) ;
3002 #else
3003   fprintf ( xglTraceFd, "  glDeleteTextures isn't supported on this OpenGL!\n" ) ;
3004 #endif
3005 }
3006
3007 void xglGenTextures ( GLsizei n, GLuint* textures )
3008 {
3009   if ( xglTraceIsEnabled("glGenTextures") )
3010     fprintf ( xglTraceFd, "  glGenTextures ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
3011
3012 #ifdef GL_VERSION_1_1
3013   if ( xglExecuteIsEnabled("glGenTextures") )
3014     glGenTextures ( n, textures ) ;
3015 #else
3016   fprintf ( xglTraceFd, "  glDeleteTextures isn't supported on this OpenGL!\n" ) ;
3017 #endif
3018 }
3019
3020 void xglPrioritizeTextures ( GLsizei n, GLuint* textures, GLclampf* priorities )
3021 {
3022   if ( xglTraceIsEnabled("glPrioritizeTextures") )
3023     fprintf ( xglTraceFd, "  glPrioritizeTextures ( (GLsizei)%d, (GLuint *)0x%08x, (GLclampf *)0x%08x ) ;\n" , n, textures, priorities ) ;
3024
3025 #ifdef GL_VERSION_1_1
3026   if ( xglExecuteIsEnabled("glPrioritizeTextures") )
3027     glPrioritizeTextures ( n, textures, priorities ) ;
3028 #else
3029   fprintf ( xglTraceFd, "  glPrioritizeTextures isn't supported on this OpenGL!\n" ) ;
3030 #endif
3031 }
3032
3033 #endif
3034