simgear/xgl/xgl.c

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