simgear/xgl/xgl.c

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