XGL/xgl.c

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