--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef WIN32
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+
+#include "xgl.h"
+#include <GL/glut.h>
+
+#ifdef XGL_TRACE
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+GLboolean xglIsEnabled ( GLenum cap )
+{
+ if ( xglTraceIsEnabled("glIsEnabled") )
+ fprintf ( xglTraceFd, " /* glIsEnabled ( (GLenum)%s ) ; */\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
+
+ return glIsEnabled ( cap ) ;
+}
+
+GLboolean xglIsList ( GLuint list )
+{
+ if ( xglTraceIsEnabled("glIsList") )
+ fprintf ( xglTraceFd, " /* glIsList ( (GLuint)%u ) ; */\n" , list ) ;
+
+ return glIsList ( list ) ;
+}
+
+GLenum xglGetError ( )
+{
+ if ( xglTraceIsEnabled("glGetError") )
+ fprintf ( xglTraceFd, " /* glGetError ( ) ; */\n" ) ;
+
+ return glGetError ( ) ;
+}
+
+GLint xglRenderMode ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glRenderMode") )
+ fprintf ( xglTraceFd, " glRenderMode ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+
+ return glRenderMode ( mode ) ;
+}
+
+GLuint xglGenLists ( GLsizei range )
+{
+ if ( xglTraceIsEnabled("glGenLists") )
+ fprintf ( xglTraceFd, " glGenLists ( (GLsizei)%d ) ;\n" , range ) ;
+
+ return glGenLists ( range ) ;
+}
+
+const GLubyte* xglGetString ( GLenum name )
+{
+ if ( xglTraceIsEnabled("glGetString") )
+ fprintf ( xglTraceFd, " /* glGetString ( (GLenum)%s ) ; */\n" , xglExpandGLenum ( (GLenum) name ) ) ;
+
+ return glGetString ( name ) ;
+}
+
+void xglAccum ( GLenum op, GLfloat value )
+{
+ if ( xglTraceIsEnabled("glAccum") )
+ fprintf ( xglTraceFd, " glAccum ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) op ), value ) ;
+ if ( xglExecuteIsEnabled("glAccum") )
+ glAccum ( op, value ) ;
+}
+
+void xglAlphaFunc ( GLenum func, GLclampf ref )
+{
+ if ( xglTraceIsEnabled("glAlphaFunc") )
+ fprintf ( xglTraceFd, " glAlphaFunc ( (GLenum)%s, (GLclampf)%ff ) ;\n" , xglExpandGLenum ( (GLenum) func ), ref ) ;
+ if ( xglExecuteIsEnabled("glAlphaFunc") )
+ glAlphaFunc ( func, ref ) ;
+}
+
+void xglArrayElementEXT ( GLint i )
+{
+ if ( xglTraceIsEnabled("glArrayElementEXT") )
+ fprintf ( xglTraceFd, " glArrayElementEXT ( (GLint)%d ) ;\n" , i ) ;
+#ifdef GL_VERSION_1_1
+ glArrayElement ( i ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glArrayElementEXT") )
+ glArrayElementEXT ( i ) ;
+#else
+ fprintf ( xglTraceFd, " glArrayElementEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglBegin ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glBegin") )
+ fprintf ( xglTraceFd, " glBegin ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glBegin") )
+ glBegin ( mode ) ;
+}
+
+void xglBitmap ( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte* bitmap )
+{
+ if ( xglTraceIsEnabled("glBitmap") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glBitmap") )
+ glBitmap ( width, height, xorig, yorig, xmove, ymove, bitmap ) ;
+}
+
+void xglBlendColorEXT ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+{
+ if ( xglTraceIsEnabled("glBlendColorEXT") )
+ fprintf ( xglTraceFd, " glBlendColorEXT ( (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff ) ;\n" , red, green, blue, alpha ) ;
+#ifdef GL_EXT_blend_color
+ if ( xglExecuteIsEnabled("glBlendColorEXT") )
+ glBlendColorEXT ( red, green, blue, alpha ) ;
+#else
+ fprintf ( xglTraceFd, " glBlendColorEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglBlendEquationEXT ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glBlendEquationEXT") )
+ fprintf ( xglTraceFd, " glBlendEquationEXT ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+#ifdef GL_EXT_blend_minmax
+ if ( xglExecuteIsEnabled("glBlendEquationEXT") )
+ glBlendEquationEXT ( mode ) ;
+#else
+ fprintf ( xglTraceFd, " glBlendEquationEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglBlendFunc ( GLenum sfactor, GLenum dfactor )
+{
+ if ( xglTraceIsEnabled("glBlendFunc") )
+ fprintf ( xglTraceFd, " glBlendFunc ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) sfactor ), xglExpandGLenum ( (GLenum) dfactor ) ) ;
+ if ( xglExecuteIsEnabled("glBlendFunc") )
+ glBlendFunc ( sfactor, dfactor ) ;
+}
+
+void xglCallList ( GLuint list )
+{
+ if ( xglTraceIsEnabled("glCallList") )
+ fprintf ( xglTraceFd, " glCallList ( (GLuint)%u ) ;\n" , list ) ;
+ if ( xglExecuteIsEnabled("glCallList") )
+ glCallList ( list ) ;
+}
+
+void xglCallLists ( GLsizei n, GLenum type, GLvoid* lists )
+{
+ if ( xglTraceIsEnabled("glCallLists") )
+ fprintf ( xglTraceFd, " glCallLists ( (GLsizei)%d, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , n, xglExpandGLenum ( (GLenum) type ), lists ) ;
+ if ( xglExecuteIsEnabled("glCallLists") )
+ glCallLists ( n, type, lists ) ;
+}
+
+
+void xglClear ( GLbitfield mask )
+{
+ if ( xglTraceIsEnabled("glClear") )
+ switch ( mask )
+ {
+ case GL_COLOR_BUFFER_BIT :
+ fprintf ( xglTraceFd, " glClear ( GL_COLOR_BUFFER_BIT ) ;\n" ) ;
+ break ;
+ case GL_DEPTH_BUFFER_BIT :
+ fprintf ( xglTraceFd, " glClear ( GL_DEPTH_BUFFER_BIT ) ;\n" ) ;
+ break ;
+ case GL_ACCUM_BUFFER_BIT :
+ fprintf ( xglTraceFd, " glClear ( GL_ACCUM_BUFFER_BIT ) ;\n" ) ;
+ break ;
+ case GL_STENCIL_BUFFER_BIT :
+ fprintf ( xglTraceFd, " glClear ( GL_STENCIL_BUFFER_BIT ) ;\n" ) ;
+ break ;
+ case (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) :
+ fprintf ( xglTraceFd, " glClear ( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT ) ;\n" ) ;
+ break ;
+
+ default :
+ fprintf ( xglTraceFd, " glClear ( (GLbitfield)0x%08x ) ;\n" , mask ) ; break ;
+ }
+
+ if ( xglExecuteIsEnabled("glClear") )
+ glClear ( mask ) ;
+}
+
+
+void xglClearAccum ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+ if ( xglTraceIsEnabled("glClearAccum") )
+ fprintf ( xglTraceFd, " glClearAccum ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glClearAccum") )
+ glClearAccum ( red, green, blue, alpha ) ;
+}
+
+void xglClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+{
+ if ( xglTraceIsEnabled("glClearColor") )
+ fprintf ( xglTraceFd, " glClearColor ( (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff, (GLclampf)%ff ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glClearColor") )
+ glClearColor ( red, green, blue, alpha ) ;
+}
+
+void xglClearDepth ( GLclampd depth )
+{
+ if ( xglTraceIsEnabled("glClearDepth") )
+ fprintf ( xglTraceFd, " glClearDepth ( (GLclampd)%f ) ;\n" , depth ) ;
+ if ( xglExecuteIsEnabled("glClearDepth") )
+ glClearDepth ( depth ) ;
+}
+
+void xglClearIndex ( GLfloat c )
+{
+ if ( xglTraceIsEnabled("glClearIndex") )
+ fprintf ( xglTraceFd, " glClearIndex ( (GLfloat)%ff ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glClearIndex") )
+ glClearIndex ( c ) ;
+}
+
+void xglClearStencil ( GLint s )
+{
+ if ( xglTraceIsEnabled("glClearStencil") )
+ fprintf ( xglTraceFd, " glClearStencil ( (GLint)%d ) ;\n" , s ) ;
+ if ( xglExecuteIsEnabled("glClearStencil") )
+ glClearStencil ( s ) ;
+}
+
+void xglClipPlane ( GLenum plane, GLdouble* equation )
+{
+ if ( xglTraceIsEnabled("glClipPlane") )
+ fprintf ( xglTraceFd, " glClipPlane ( (GLenum)%s, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) plane ), equation ) ;
+ if ( xglExecuteIsEnabled("glClipPlane") )
+ glClipPlane ( plane, equation ) ;
+}
+
+void xglColor3b ( GLbyte red, GLbyte green, GLbyte blue )
+{
+ if ( xglTraceIsEnabled("glColor3b") )
+ fprintf ( xglTraceFd, " glColor3b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3b") )
+ glColor3b ( red, green, blue ) ;
+}
+
+void xglColor3bv ( GLbyte* v )
+{
+ if ( xglTraceIsEnabled("glColor3bv") )
+ fprintf ( xglTraceFd, " glColor3bv ( xglBuild3bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3bv") )
+ glColor3bv ( v ) ;
+}
+
+void xglColor3d ( GLdouble red, GLdouble green, GLdouble blue )
+{
+ if ( xglTraceIsEnabled("glColor3d") )
+ fprintf ( xglTraceFd, " glColor3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3d") )
+ glColor3d ( red, green, blue ) ;
+}
+
+void xglColor3dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glColor3dv") )
+ fprintf ( xglTraceFd, " glColor3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3dv") )
+ glColor3dv ( v ) ;
+}
+
+void xglColor3f ( GLfloat red, GLfloat green, GLfloat blue )
+{
+ if ( xglTraceIsEnabled("glColor3f") )
+ fprintf ( xglTraceFd, " glColor3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3f") )
+ glColor3f ( red, green, blue ) ;
+}
+
+void xglColor3fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glColor3fv") )
+ fprintf ( xglTraceFd, " glColor3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3fv") )
+ glColor3fv ( v ) ;
+}
+
+void xglColor3i ( GLint red, GLint green, GLint blue )
+{
+ if ( xglTraceIsEnabled("glColor3i") )
+ fprintf ( xglTraceFd, " glColor3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3i") )
+ glColor3i ( red, green, blue ) ;
+}
+
+void xglColor3iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glColor3iv") )
+ fprintf ( xglTraceFd, " glColor3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3iv") )
+ glColor3iv ( v ) ;
+}
+
+void xglColor3s ( GLshort red, GLshort green, GLshort blue )
+{
+ if ( xglTraceIsEnabled("glColor3s") )
+ fprintf ( xglTraceFd, " glColor3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3s") )
+ glColor3s ( red, green, blue ) ;
+}
+
+void xglColor3sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glColor3sv") )
+ fprintf ( xglTraceFd, " glColor3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3sv") )
+ glColor3sv ( v ) ;
+}
+
+void xglColor3ub ( GLubyte red, GLubyte green, GLubyte blue )
+{
+ if ( xglTraceIsEnabled("glColor3ub") )
+ fprintf ( xglTraceFd, " glColor3ub ( (GLubyte)%u, (GLubyte)%u, (GLubyte)%u ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3ub") )
+ glColor3ub ( red, green, blue ) ;
+}
+
+void xglColor3ubv ( GLubyte* v )
+{
+ if ( xglTraceIsEnabled("glColor3ubv") )
+ fprintf ( xglTraceFd, " glColor3ubv ( xglBuild3ubv((GLubyte)%d,(GLubyte)%d,(GLubyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3ubv") )
+ glColor3ubv ( v ) ;
+}
+
+void xglColor3ui ( GLuint red, GLuint green, GLuint blue )
+{
+ if ( xglTraceIsEnabled("glColor3ui") )
+ fprintf ( xglTraceFd, " glColor3ui ( (GLuint)%u, (GLuint)%u, (GLuint)%u ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3ui") )
+ glColor3ui ( red, green, blue ) ;
+}
+
+void xglColor3uiv ( GLuint* v )
+{
+ if ( xglTraceIsEnabled("glColor3uiv") )
+ fprintf ( xglTraceFd, " glColor3uiv ( xglBuild3uiv((GLuint)%d,(GLuint)%d,(GLuint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3uiv") )
+ glColor3uiv ( v ) ;
+}
+
+void xglColor3us ( GLushort red, GLushort green, GLushort blue )
+{
+ if ( xglTraceIsEnabled("glColor3us") )
+ fprintf ( xglTraceFd, " glColor3us ( (GLushort)%u, (GLushort)%u, (GLushort)%u ) ;\n" , red, green, blue ) ;
+ if ( xglExecuteIsEnabled("glColor3us") )
+ glColor3us ( red, green, blue ) ;
+}
+
+void xglColor3usv ( GLushort* v )
+{
+ if ( xglTraceIsEnabled("glColor3usv") )
+ fprintf ( xglTraceFd, " glColor3usv ( xglBuild3usv((GLushort)%d,(GLushort)%d,(GLushort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glColor3usv") )
+ glColor3usv ( v ) ;
+}
+
+void xglColor4b ( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
+{
+ if ( xglTraceIsEnabled("glColor4b") )
+ fprintf ( xglTraceFd, " glColor4b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4b") )
+ glColor4b ( red, green, blue, alpha ) ;
+}
+
+void xglColor4bv ( GLbyte* v )
+{
+ if ( xglTraceIsEnabled("glColor4bv") )
+ fprintf ( xglTraceFd, " glColor4bv ( xglBuild4bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4bv") )
+ glColor4bv ( v ) ;
+}
+
+void xglColor4d ( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
+{
+ if ( xglTraceIsEnabled("glColor4d") )
+ fprintf ( xglTraceFd, " glColor4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4d") )
+ glColor4d ( red, green, blue, alpha ) ;
+}
+
+void xglColor4dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glColor4dv") )
+ fprintf ( xglTraceFd, " glColor4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4dv") )
+ glColor4dv ( v ) ;
+}
+
+void xglColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+ if ( xglTraceIsEnabled("glColor4f") )
+ fprintf ( xglTraceFd, " glColor4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4f") )
+ glColor4f ( red, green, blue, alpha ) ;
+}
+
+void xglColor4fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glColor4fv") )
+ fprintf ( xglTraceFd, " glColor4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4fv") )
+ glColor4fv ( v ) ;
+}
+
+void xglColor4i ( GLint red, GLint green, GLint blue, GLint alpha )
+{
+ if ( xglTraceIsEnabled("glColor4i") )
+ fprintf ( xglTraceFd, " glColor4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4i") )
+ glColor4i ( red, green, blue, alpha ) ;
+}
+
+void xglColor4iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glColor4iv") )
+ fprintf ( xglTraceFd, " glColor4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4iv") )
+ glColor4iv ( v ) ;
+}
+
+void xglColor4s ( GLshort red, GLshort green, GLshort blue, GLshort alpha )
+{
+ if ( xglTraceIsEnabled("glColor4s") )
+ fprintf ( xglTraceFd, " glColor4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4s") )
+ glColor4s ( red, green, blue, alpha ) ;
+}
+
+void xglColor4sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glColor4sv") )
+ fprintf ( xglTraceFd, " glColor4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4sv") )
+ glColor4sv ( v ) ;
+}
+
+void xglColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
+{
+ if ( xglTraceIsEnabled("glColor4ub") )
+ fprintf ( xglTraceFd, " glColor4ub ( (GLubyte)%u, (GLubyte)%u, (GLubyte)%u, (GLubyte)%u ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4ub") )
+ glColor4ub ( red, green, blue, alpha ) ;
+}
+
+void xglColor4ubv ( GLubyte* v )
+{
+ if ( xglTraceIsEnabled("glColor4ubv") )
+ fprintf ( xglTraceFd, " glColor4ubv ( xglBuild4ubv((GLubyte)%d,(GLubyte)%d,(GLubyte)%d,(GLubyte)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4ubv") )
+ glColor4ubv ( v ) ;
+}
+
+void xglColor4ui ( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
+ if ( xglTraceIsEnabled("glColor4ui") )
+ fprintf ( xglTraceFd, " glColor4ui ( (GLuint)%u, (GLuint)%u, (GLuint)%u, (GLuint)%u ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4ui") )
+ glColor4ui ( red, green, blue, alpha ) ;
+}
+
+void xglColor4uiv ( GLuint* v )
+{
+ if ( xglTraceIsEnabled("glColor4uiv") )
+ fprintf ( xglTraceFd, " glColor4uiv ( xglBuild4uiv((GLuint)%d,(GLuint)%d,(GLuint)%d,(GLuint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4uiv") )
+ glColor4uiv ( v ) ;
+}
+
+void xglColor4us ( GLushort red, GLushort green, GLushort blue, GLushort alpha )
+{
+ if ( xglTraceIsEnabled("glColor4us") )
+ fprintf ( xglTraceFd, " glColor4us ( (GLushort)%u, (GLushort)%u, (GLushort)%u, (GLushort)%u ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColor4us") )
+ glColor4us ( red, green, blue, alpha ) ;
+}
+
+void xglColor4usv ( GLushort* v )
+{
+ if ( xglTraceIsEnabled("glColor4usv") )
+ fprintf ( xglTraceFd, " glColor4usv ( xglBuild4usv((GLushort)%d,(GLushort)%d,(GLushort)%d,(GLushort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glColor4usv") )
+ glColor4usv ( v ) ;
+}
+
+void xglColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+{
+ if ( xglTraceIsEnabled("glColorMask") )
+ fprintf ( xglTraceFd, " glColorMask ( (GLboolean)%d, (GLboolean)%d, (GLboolean)%d, (GLboolean)%d ) ;\n" , red, green, blue, alpha ) ;
+ if ( xglExecuteIsEnabled("glColorMask") )
+ glColorMask ( red, green, blue, alpha ) ;
+}
+
+void xglColorMaterial ( GLenum face, GLenum mode )
+{
+ if ( xglTraceIsEnabled("glColorMaterial") )
+ fprintf ( xglTraceFd, " glColorMaterial ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glColorMaterial") )
+ glColorMaterial ( face, mode ) ;
+}
+
+void xglColorPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
+{
+ if ( xglTraceIsEnabled("glColorPointerEXT") )
+ fprintf ( xglTraceFd, " glColorPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glColorPointer ( size, type, stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glColorPointerEXT") )
+ glColorPointerEXT ( size, type, stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glColorPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglCopyPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
+{
+ if ( xglTraceIsEnabled("glCopyPixels") )
+ fprintf ( xglTraceFd, " glCopyPixels ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d, (GLenum)%s ) ;\n" , x, y, width, height, xglExpandGLenum ( (GLenum) type ) ) ;
+ if ( xglExecuteIsEnabled("glCopyPixels") )
+ glCopyPixels ( x, y, width, height, type ) ;
+}
+
+void xglCullFace ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glCullFace") )
+ fprintf ( xglTraceFd, " glCullFace ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glCullFace") )
+ glCullFace ( mode ) ;
+}
+
+void xglDeleteLists ( GLuint list, GLsizei range )
+{
+ if ( xglTraceIsEnabled("glDeleteLists") )
+ fprintf ( xglTraceFd, " glDeleteLists ( (GLuint)%u, (GLsizei)%d ) ;\n" , list, range ) ;
+ if ( xglExecuteIsEnabled("glDeleteLists") )
+ glDeleteLists ( list, range ) ;
+}
+
+void xglDepthFunc ( GLenum func )
+{
+ if ( xglTraceIsEnabled("glDepthFunc") )
+ fprintf ( xglTraceFd, " glDepthFunc ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) func ) ) ;
+ if ( xglExecuteIsEnabled("glDepthFunc") )
+ glDepthFunc ( func ) ;
+}
+
+void xglDepthMask ( GLboolean flag )
+{
+ if ( xglTraceIsEnabled("glDepthMask") )
+ fprintf ( xglTraceFd, " glDepthMask ( (GLboolean)%d ) ;\n" , flag ) ;
+ if ( xglExecuteIsEnabled("glDepthMask") )
+ glDepthMask ( flag ) ;
+}
+
+void xglDepthRange ( GLclampd near_val, GLclampd far_val )
+{
+ if ( xglTraceIsEnabled("glDepthRange") )
+ fprintf ( xglTraceFd, " glDepthRange ( (GLclampd)%f, (GLclampd)%f ) ;\n" , near_val, far_val ) ;
+ if ( xglExecuteIsEnabled("glDepthRange") )
+ glDepthRange ( near_val, far_val ) ;
+}
+
+void xglDisable ( GLenum cap )
+{
+ if ( xglTraceIsEnabled("glDisable") )
+ fprintf ( xglTraceFd, " glDisable ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
+ if ( xglExecuteIsEnabled("glDisable") )
+ glDisable ( cap ) ;
+}
+
+void xglDrawArraysEXT ( GLenum mode, GLint first, GLsizei count )
+{
+ if ( xglTraceIsEnabled("glDrawArraysEXT") )
+ fprintf ( xglTraceFd, " glDrawArraysEXT ( (GLenum)%s, (GLint)%d, (GLsizei)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), first, count ) ;
+#ifdef GL_VERSION_1_1
+ glDrawArrays ( mode, first, count ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glDrawArraysEXT") )
+ glDrawArraysEXT ( mode, first, count ) ;
+#else
+ fprintf ( xglTraceFd, " glDrawArraysEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglDrawBuffer ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glDrawBuffer") )
+ fprintf ( xglTraceFd, " glDrawBuffer ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glDrawBuffer") )
+ glDrawBuffer ( mode ) ;
+}
+
+void xglDrawPixels ( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels )
+{
+ if ( xglTraceIsEnabled("glDrawPixels") )
+ fprintf ( xglTraceFd, " glDrawPixels ( (GLsizei)%d, (GLsizei)%d, (GLenum)%s, (GLenum)%s, (GLvoid *)0x%08x ) ;\n" , width, height, xglExpandGLenum ( (GLenum) format ), xglExpandGLenum ( (GLenum) type ), pixels ) ;
+ if ( xglExecuteIsEnabled("glDrawPixels") )
+ glDrawPixels ( width, height, format, type, pixels ) ;
+}
+
+void xglEdgeFlag ( GLboolean flag )
+{
+ if ( xglTraceIsEnabled("glEdgeFlag") )
+ fprintf ( xglTraceFd, " glEdgeFlag ( (GLboolean)%d ) ;\n" , flag ) ;
+ if ( xglExecuteIsEnabled("glEdgeFlag") )
+ glEdgeFlag ( flag ) ;
+}
+
+void xglEdgeFlagPointerEXT ( GLsizei stride, GLsizei count, GLboolean* ptr )
+{
+ if ( xglTraceIsEnabled("glEdgeFlagPointerEXT") )
+ fprintf ( xglTraceFd, " glEdgeFlagPointerEXT ( (GLsizei)%d, (GLsizei)%d, (GLboolean *)0x%08x ) ;\n" , stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glEdgeFlagPointer ( stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glEdgeFlagPointerEXT") )
+ glEdgeFlagPointerEXT ( stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glEdgeFlagPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglEdgeFlagv ( GLboolean* flag )
+{
+ if ( xglTraceIsEnabled("glEdgeFlagv") )
+ fprintf ( xglTraceFd, " glEdgeFlagv ( (GLboolean *)0x%08x ) ;\n" , flag ) ;
+ if ( xglExecuteIsEnabled("glEdgeFlagv") )
+ glEdgeFlagv ( flag ) ;
+}
+
+void xglEnable ( GLenum cap )
+{
+ if ( xglTraceIsEnabled("glEnable") )
+ fprintf ( xglTraceFd, " glEnable ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) cap ) ) ;
+ if ( xglExecuteIsEnabled("glEnable") )
+ glEnable ( cap ) ;
+}
+
+void xglEnd ( )
+{
+ if ( xglTraceIsEnabled("glEnd") )
+ fprintf ( xglTraceFd, " glEnd ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glEnd") )
+ glEnd ( ) ;
+}
+
+void xglEndList ( )
+{
+ if ( xglTraceIsEnabled("glEndList") )
+ fprintf ( xglTraceFd, " glEndList ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glEndList") )
+ glEndList ( ) ;
+}
+
+void xglEvalCoord1d ( GLdouble u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord1d") )
+ fprintf ( xglTraceFd, " glEvalCoord1d ( (GLdouble)%f ) ;\n" , u ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord1d") )
+ glEvalCoord1d ( u ) ;
+}
+
+void xglEvalCoord1dv ( GLdouble* u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord1dv") )
+ fprintf ( xglTraceFd, " glEvalCoord1dv ( xglBuild1dv((GLdouble)%f) ) ;\n" , u[0] ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord1dv") )
+ glEvalCoord1dv ( u ) ;
+}
+
+void xglEvalCoord1f ( GLfloat u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord1f") )
+ fprintf ( xglTraceFd, " glEvalCoord1f ( (GLfloat)%ff ) ;\n" , u ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord1f") )
+ glEvalCoord1f ( u ) ;
+}
+
+void xglEvalCoord1fv ( GLfloat* u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord1fv") )
+ fprintf ( xglTraceFd, " glEvalCoord1fv ( xglBuild1fv((GLfloat)%ff) ) ;\n" , u[0] ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord1fv") )
+ glEvalCoord1fv ( u ) ;
+}
+
+void xglEvalCoord2d ( GLdouble u, GLdouble v )
+{
+ if ( xglTraceIsEnabled("glEvalCoord2d") )
+ fprintf ( xglTraceFd, " glEvalCoord2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , u, v ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord2d") )
+ glEvalCoord2d ( u, v ) ;
+}
+
+void xglEvalCoord2dv ( GLdouble* u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord2dv") )
+ fprintf ( xglTraceFd, " glEvalCoord2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , u[0], u[1] ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord2dv") )
+ glEvalCoord2dv ( u ) ;
+}
+
+void xglEvalCoord2f ( GLfloat u, GLfloat v )
+{
+ if ( xglTraceIsEnabled("glEvalCoord2f") )
+ fprintf ( xglTraceFd, " glEvalCoord2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , u, v ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord2f") )
+ glEvalCoord2f ( u, v ) ;
+}
+
+void xglEvalCoord2fv ( GLfloat* u )
+{
+ if ( xglTraceIsEnabled("glEvalCoord2fv") )
+ fprintf ( xglTraceFd, " glEvalCoord2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , u[0], u[1] ) ;
+ if ( xglExecuteIsEnabled("glEvalCoord2fv") )
+ glEvalCoord2fv ( u ) ;
+}
+
+void xglEvalMesh1 ( GLenum mode, GLint i1, GLint i2 )
+{
+ if ( xglTraceIsEnabled("glEvalMesh1") )
+ fprintf ( xglTraceFd, " glEvalMesh1 ( (GLenum)%s, (GLint)%d, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), i1, i2 ) ;
+ if ( xglExecuteIsEnabled("glEvalMesh1") )
+ glEvalMesh1 ( mode, i1, i2 ) ;
+}
+
+void xglEvalMesh2 ( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
+{
+ if ( xglTraceIsEnabled("glEvalMesh2") )
+ fprintf ( xglTraceFd, " glEvalMesh2 ( (GLenum)%s, (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) mode ), i1, i2, j1, j2 ) ;
+ if ( xglExecuteIsEnabled("glEvalMesh2") )
+ glEvalMesh2 ( mode, i1, i2, j1, j2 ) ;
+}
+
+void xglEvalPoint1 ( GLint i )
+{
+ if ( xglTraceIsEnabled("glEvalPoint1") )
+ fprintf ( xglTraceFd, " glEvalPoint1 ( (GLint)%d ) ;\n" , i ) ;
+ if ( xglExecuteIsEnabled("glEvalPoint1") )
+ glEvalPoint1 ( i ) ;
+}
+
+void xglEvalPoint2 ( GLint i, GLint j )
+{
+ if ( xglTraceIsEnabled("glEvalPoint2") )
+ fprintf ( xglTraceFd, " glEvalPoint2 ( (GLint)%d, (GLint)%d ) ;\n" , i, j ) ;
+ if ( xglExecuteIsEnabled("glEvalPoint2") )
+ glEvalPoint2 ( i, j ) ;
+}
+
+void xglFeedbackBuffer ( GLsizei size, GLenum type, GLfloat* buffer )
+{
+ if ( xglTraceIsEnabled("glFeedbackBuffer") )
+ fprintf ( xglTraceFd, " glFeedbackBuffer ( (GLsizei)%d, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), buffer ) ;
+ if ( xglExecuteIsEnabled("glFeedbackBuffer") )
+ glFeedbackBuffer ( size, type, buffer ) ;
+}
+
+void xglFinish ( )
+{
+ if ( xglTraceIsEnabled("glFinish") )
+ fprintf ( xglTraceFd, " glFinish ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glFinish") )
+ glFinish ( ) ;
+}
+
+void xglFlush ( )
+{
+ if ( xglTraceIsEnabled("glFlush") )
+ fprintf ( xglTraceFd, " glFlush ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glFlush") )
+ glFlush ( ) ;
+}
+
+void xglFogf ( GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glFogf") )
+ fprintf ( xglTraceFd, " glFogf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glFogf") )
+ glFogf ( pname, param ) ;
+}
+
+void xglFogfv ( GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glFogfv") )
+ fprintf ( xglTraceFd, " glFogfv ( (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glFogfv") )
+ glFogfv ( pname, params ) ;
+}
+
+void xglFogi ( GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glFogi") )
+ fprintf ( xglTraceFd, " glFogi ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glFogi") )
+ glFogi ( pname, param ) ;
+}
+
+void xglFogiv ( GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glFogiv") )
+ fprintf ( xglTraceFd, " glFogiv ( (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glFogiv") )
+ glFogiv ( pname, params ) ;
+}
+
+void xglFrontFace ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glFrontFace") )
+ fprintf ( xglTraceFd, " glFrontFace ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glFrontFace") )
+ glFrontFace ( mode ) ;
+}
+
+void xglFrustum ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
+{
+ if ( xglTraceIsEnabled("glFrustum") )
+ fprintf ( xglTraceFd, " glFrustum ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , left, right, bottom, top, near_val, far_val ) ;
+ if ( xglExecuteIsEnabled("glFrustum") )
+ glFrustum ( left, right, bottom, top, near_val, far_val ) ;
+}
+
+void xglGetBooleanv ( GLenum pname, GLboolean* params )
+{
+ if ( xglTraceIsEnabled("glGetBooleanv") )
+ fprintf ( xglTraceFd, " /* glGetBooleanv ( (GLenum)%s, (GLboolean *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetBooleanv") )
+ glGetBooleanv ( pname, params ) ;
+}
+
+void xglGetClipPlane ( GLenum plane, GLdouble* equation )
+{
+ if ( xglTraceIsEnabled("glGetClipPlane") )
+ fprintf ( xglTraceFd, " /* glGetClipPlane ( (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) plane ), equation ) ;
+ if ( xglExecuteIsEnabled("glGetClipPlane") )
+ glGetClipPlane ( plane, equation ) ;
+}
+
+void xglGetDoublev ( GLenum pname, GLdouble* params )
+{
+ if ( xglTraceIsEnabled("glGetDoublev") )
+ fprintf ( xglTraceFd, " /* glGetDoublev ( (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetDoublev") )
+ glGetDoublev ( pname, params ) ;
+}
+
+void xglGetFloatv ( GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetFloatv") )
+ fprintf ( xglTraceFd, " /* glGetFloatv ( (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetFloatv") )
+ glGetFloatv ( pname, params ) ;
+}
+
+void xglGetIntegerv ( GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetIntegerv") )
+ fprintf ( xglTraceFd, " /* glGetIntegerv ( (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetIntegerv") )
+ glGetIntegerv ( pname, params ) ;
+}
+
+void xglGetLightfv ( GLenum light, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetLightfv") )
+ fprintf ( xglTraceFd, " /* glGetLightfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetLightfv") )
+ glGetLightfv ( light, pname, params ) ;
+}
+
+void xglGetLightiv ( GLenum light, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetLightiv") )
+ fprintf ( xglTraceFd, " /* glGetLightiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetLightiv") )
+ glGetLightiv ( light, pname, params ) ;
+}
+
+void xglGetMapdv ( GLenum target, GLenum query, GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glGetMapdv") )
+ fprintf ( xglTraceFd, " /* glGetMapdv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
+ if ( xglExecuteIsEnabled("glGetMapdv") )
+ glGetMapdv ( target, query, v ) ;
+}
+
+void xglGetMapfv ( GLenum target, GLenum query, GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glGetMapfv") )
+ fprintf ( xglTraceFd, " /* glGetMapfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
+ if ( xglExecuteIsEnabled("glGetMapfv") )
+ glGetMapfv ( target, query, v ) ;
+}
+
+void xglGetMapiv ( GLenum target, GLenum query, GLint* v )
+{
+ if ( xglTraceIsEnabled("glGetMapiv") )
+ fprintf ( xglTraceFd, " /* glGetMapiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) query ), v ) ;
+ if ( xglExecuteIsEnabled("glGetMapiv") )
+ glGetMapiv ( target, query, v ) ;
+}
+
+void xglGetMaterialfv ( GLenum face, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetMaterialfv") )
+ fprintf ( xglTraceFd, " /* glGetMaterialfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetMaterialfv") )
+ glGetMaterialfv ( face, pname, params ) ;
+}
+
+void xglGetMaterialiv ( GLenum face, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetMaterialiv") )
+ fprintf ( xglTraceFd, " /* glGetMaterialiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetMaterialiv") )
+ glGetMaterialiv ( face, pname, params ) ;
+}
+
+void xglGetPixelMapfv ( GLenum map, GLfloat* values )
+{
+ if ( xglTraceIsEnabled("glGetPixelMapfv") )
+ fprintf ( xglTraceFd, " /* glGetPixelMapfv ( (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
+ if ( xglExecuteIsEnabled("glGetPixelMapfv") )
+ glGetPixelMapfv ( map, values ) ;
+}
+
+void xglGetPixelMapuiv ( GLenum map, GLuint* values )
+{
+ if ( xglTraceIsEnabled("glGetPixelMapuiv") )
+ fprintf ( xglTraceFd, " /* glGetPixelMapuiv ( (GLenum)%s, (GLuint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
+ if ( xglExecuteIsEnabled("glGetPixelMapuiv") )
+ glGetPixelMapuiv ( map, values ) ;
+}
+
+void xglGetPixelMapusv ( GLenum map, GLushort* values )
+{
+ if ( xglTraceIsEnabled("glGetPixelMapusv") )
+ fprintf ( xglTraceFd, " /* glGetPixelMapusv ( (GLenum)%s, (GLushort *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) map ), values ) ;
+ if ( xglExecuteIsEnabled("glGetPixelMapusv") )
+ glGetPixelMapusv ( map, values ) ;
+}
+
+void xglGetPointervEXT ( GLenum pname, void** params )
+{
+ if ( xglTraceIsEnabled("glGetPointervEXT") )
+ fprintf ( xglTraceFd, " /* glGetPointervEXT ( (GLenum)%s, (void **)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+#ifdef GL_VERSION_1_1
+ glGetPointerv ( pname, params ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glGetPointervEXT") )
+ glGetPointervEXT ( pname, params ) ;
+#else
+ fprintf ( xglTraceFd, " glGetPointervEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglGetPolygonStipple ( GLubyte* mask )
+{
+ if ( xglTraceIsEnabled("glGetPolygonStipple") )
+ fprintf ( xglTraceFd, " /* glGetPolygonStipple ( (GLubyte *)0x%08x ) ; */\n" , mask ) ;
+ if ( xglExecuteIsEnabled("glGetPolygonStipple") )
+ glGetPolygonStipple ( mask ) ;
+}
+
+void xglGetTexEnvfv ( GLenum target, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetTexEnvfv") )
+ fprintf ( xglTraceFd, " /* glGetTexEnvfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexEnvfv") )
+ glGetTexEnvfv ( target, pname, params ) ;
+}
+
+void xglGetTexEnviv ( GLenum target, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetTexEnviv") )
+ fprintf ( xglTraceFd, " /* glGetTexEnviv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexEnviv") )
+ glGetTexEnviv ( target, pname, params ) ;
+}
+
+void xglGetTexGendv ( GLenum coord, GLenum pname, GLdouble* params )
+{
+ if ( xglTraceIsEnabled("glGetTexGendv") )
+ fprintf ( xglTraceFd, " /* glGetTexGendv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexGendv") )
+ glGetTexGendv ( coord, pname, params ) ;
+}
+
+void xglGetTexGenfv ( GLenum coord, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetTexGenfv") )
+ fprintf ( xglTraceFd, " /* glGetTexGenfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexGenfv") )
+ glGetTexGenfv ( coord, pname, params ) ;
+}
+
+void xglGetTexGeniv ( GLenum coord, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetTexGeniv") )
+ fprintf ( xglTraceFd, " /* glGetTexGeniv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexGeniv") )
+ glGetTexGeniv ( coord, pname, params ) ;
+}
+
+void xglGetTexImage ( GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels )
+{
+ if ( xglTraceIsEnabled("glGetTexImage") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glGetTexImage") )
+ glGetTexImage ( target, level, format, type, pixels ) ;
+}
+
+void xglGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetTexLevelParameterfv") )
+ fprintf ( xglTraceFd, " /* glGetTexLevelParameterfv ( (GLenum)%s, (GLint)%d, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), level, xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexLevelParameterfv") )
+ glGetTexLevelParameterfv ( target, level, pname, params ) ;
+}
+
+void xglGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetTexLevelParameteriv") )
+ fprintf ( xglTraceFd, " /* glGetTexLevelParameteriv ( (GLenum)%s, (GLint)%d, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), level, xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexLevelParameteriv") )
+ glGetTexLevelParameteriv ( target, level, pname, params ) ;
+}
+
+void xglGetTexParameterfv ( GLenum target, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glGetTexParameterfv") )
+ fprintf ( xglTraceFd, " /* glGetTexParameterfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexParameterfv") )
+ glGetTexParameterfv ( target, pname, params ) ;
+}
+
+void xglGetTexParameteriv ( GLenum target, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glGetTexParameteriv") )
+ fprintf ( xglTraceFd, " /* glGetTexParameteriv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ; */\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glGetTexParameteriv") )
+ glGetTexParameteriv ( target, pname, params ) ;
+}
+
+void xglHint ( GLenum target, GLenum mode )
+{
+ if ( xglTraceIsEnabled("glHint") )
+ fprintf ( xglTraceFd, " glHint ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glHint") )
+ glHint ( target, mode ) ;
+}
+
+void xglIndexMask ( GLuint mask )
+{
+ if ( xglTraceIsEnabled("glIndexMask") )
+ fprintf ( xglTraceFd, " glIndexMask ( (GLuint)%u ) ;\n" , mask ) ;
+ if ( xglExecuteIsEnabled("glIndexMask") )
+ glIndexMask ( mask ) ;
+}
+
+void xglIndexPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void* ptr )
+{
+ if ( xglTraceIsEnabled("glIndexPointerEXT") )
+ fprintf ( xglTraceFd, " glIndexPointerEXT ( (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glIndexPointer ( type, stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glIndexPointerEXT") )
+ glIndexPointerEXT ( type, stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glIndexPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglIndexd ( GLdouble c )
+{
+ if ( xglTraceIsEnabled("glIndexd") )
+ fprintf ( xglTraceFd, " glIndexd ( (GLdouble)%f ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexd") )
+ glIndexd ( c ) ;
+}
+
+void xglIndexdv ( GLdouble* c )
+{
+ if ( xglTraceIsEnabled("glIndexdv") )
+ fprintf ( xglTraceFd, " glIndexdv ( (GLdouble *)0x%08x ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexdv") )
+ glIndexdv ( c ) ;
+}
+
+void xglIndexf ( GLfloat c )
+{
+ if ( xglTraceIsEnabled("glIndexf") )
+ fprintf ( xglTraceFd, " glIndexf ( (GLfloat)%ff ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexf") )
+ glIndexf ( c ) ;
+}
+
+void xglIndexfv ( GLfloat* c )
+{
+ if ( xglTraceIsEnabled("glIndexfv") )
+ fprintf ( xglTraceFd, " glIndexfv ( (GLfloat *)0x%08x ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexfv") )
+ glIndexfv ( c ) ;
+}
+
+void xglIndexi ( GLint c )
+{
+ if ( xglTraceIsEnabled("glIndexi") )
+ fprintf ( xglTraceFd, " glIndexi ( (GLint)%d ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexi") )
+ glIndexi ( c ) ;
+}
+
+void xglIndexiv ( GLint* c )
+{
+ if ( xglTraceIsEnabled("glIndexiv") )
+ fprintf ( xglTraceFd, " glIndexiv ( (GLint *)0x%08x ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexiv") )
+ glIndexiv ( c ) ;
+}
+
+void xglIndexs ( GLshort c )
+{
+ if ( xglTraceIsEnabled("glIndexs") )
+ fprintf ( xglTraceFd, " glIndexs ( (GLshort)%d ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexs") )
+ glIndexs ( c ) ;
+}
+
+void xglIndexsv ( GLshort* c )
+{
+ if ( xglTraceIsEnabled("glIndexsv") )
+ fprintf ( xglTraceFd, " glIndexsv ( (GLshort *)0x%08x ) ;\n" , c ) ;
+ if ( xglExecuteIsEnabled("glIndexsv") )
+ glIndexsv ( c ) ;
+}
+
+void xglInitNames ( )
+{
+ if ( xglTraceIsEnabled("glInitNames") )
+ fprintf ( xglTraceFd, " glInitNames ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glInitNames") )
+ glInitNames ( ) ;
+}
+
+void xglLightModelf ( GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glLightModelf") )
+ fprintf ( xglTraceFd, " glLightModelf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glLightModelf") )
+ glLightModelf ( pname, param ) ;
+}
+
+void xglLightModelfv ( GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glLightModelfv") )
+ fprintf ( xglTraceFd, " glLightModelfv ( (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glLightModelfv") )
+ glLightModelfv ( pname, params ) ;
+}
+
+void xglLightModeli ( GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glLightModeli") )
+ fprintf ( xglTraceFd, " glLightModeli ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glLightModeli") )
+ glLightModeli ( pname, param ) ;
+}
+
+void xglLightModeliv ( GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glLightModeliv") )
+ fprintf ( xglTraceFd, " glLightModeliv ( (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glLightModeliv") )
+ glLightModeliv ( pname, params ) ;
+}
+
+void xglLightf ( GLenum light, GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glLightf") )
+ fprintf ( xglTraceFd, " glLightf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glLightf") )
+ glLightf ( light, pname, param ) ;
+}
+
+void xglLightfv ( GLenum light, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glLightfv") )
+ fprintf ( xglTraceFd, " glLightfv ( (GLenum)%s, (GLenum)%s, xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n",
+ xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params[0], params[1], params[2], params[3] ) ;
+ if ( xglExecuteIsEnabled("glLightfv") )
+ glLightfv ( light, pname, params ) ;
+}
+
+void xglLighti ( GLenum light, GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glLighti") )
+ fprintf ( xglTraceFd, " glLighti ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glLighti") )
+ glLighti ( light, pname, param ) ;
+}
+
+void xglLightiv ( GLenum light, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glLightiv") )
+ fprintf ( xglTraceFd, " glLightiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) light ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glLightiv") )
+ glLightiv ( light, pname, params ) ;
+}
+
+void xglLineStipple ( GLint factor, GLushort pattern )
+{
+ if ( xglTraceIsEnabled("glLineStipple") )
+ fprintf ( xglTraceFd, " glLineStipple ( (GLint)%d, (GLushort)%u ) ;\n" , factor, pattern ) ;
+ if ( xglExecuteIsEnabled("glLineStipple") )
+ glLineStipple ( factor, pattern ) ;
+}
+
+void xglLineWidth ( GLfloat width )
+{
+ if ( xglTraceIsEnabled("glLineWidth") )
+ fprintf ( xglTraceFd, " glLineWidth ( (GLfloat)%ff ) ;\n" , width ) ;
+ if ( xglExecuteIsEnabled("glLineWidth") )
+ glLineWidth ( width ) ;
+}
+
+void xglListBase ( GLuint base )
+{
+ if ( xglTraceIsEnabled("glListBase") )
+ fprintf ( xglTraceFd, " glListBase ( (GLuint)%u ) ;\n" , base ) ;
+ if ( xglExecuteIsEnabled("glListBase") )
+ glListBase ( base ) ;
+}
+
+void xglLoadIdentity ( )
+{
+ if ( xglTraceIsEnabled("glLoadIdentity") )
+ fprintf ( xglTraceFd, " glLoadIdentity ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glLoadIdentity") )
+ glLoadIdentity ( ) ;
+}
+
+void xglLoadMatrixd ( GLdouble* m )
+{
+ if ( xglTraceIsEnabled("glLoadMatrixd") )
+ {
+ fprintf ( xglTraceFd, " glLoadMatrixd ( xglBuildMatrixd(%f,%f,%f,%f,\n" , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f,\n" , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f,\n" , m[ 8],m[ 9],m[10],m[11] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f) ) ;\n", m[12],m[13],m[14],m[15] ) ;
+ }
+
+ if ( xglExecuteIsEnabled("glLoadMatrixd") )
+ glLoadMatrixd ( m ) ;
+}
+
+void xglLoadMatrixf ( GLfloat* m )
+{
+ if ( xglTraceIsEnabled("glLoadMatrixf") )
+ {
+ fprintf ( xglTraceFd, " glLoadMatrixf ( xglBuildMatrixf(%ff,%ff,%ff,%ff,\n" , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff,\n" , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff,\n" , m[ 8],m[ 9],m[10],m[11] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff) ) ;\n", m[12],m[13],m[14],m[15] ) ;
+ }
+
+ if ( xglExecuteIsEnabled("glLoadMatrixf") )
+ glLoadMatrixf ( m ) ;
+}
+
+void xglLoadName ( GLuint name )
+{
+ if ( xglTraceIsEnabled("glLoadName") )
+ fprintf ( xglTraceFd, " glLoadName ( (GLuint)%u ) ;\n" , name ) ;
+ if ( xglExecuteIsEnabled("glLoadName") )
+ glLoadName ( name ) ;
+}
+
+void xglLogicOp ( GLenum opcode )
+{
+ if ( xglTraceIsEnabled("glLogicOp") )
+ fprintf ( xglTraceFd, " glLogicOp ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) opcode ) ) ;
+ if ( xglExecuteIsEnabled("glLogicOp") )
+ glLogicOp ( opcode ) ;
+}
+
+void xglMap1d ( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points )
+{
+ if ( xglTraceIsEnabled("glMap1d") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glMap1d") )
+ glMap1d ( target, u1, u2, stride, order, points ) ;
+}
+
+void xglMap1f ( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points )
+{
+ if ( xglTraceIsEnabled("glMap1f") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glMap1f") )
+ glMap1f ( target, u1, u2, stride, order, points ) ;
+}
+
+void xglMap2d ( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points )
+{
+ if ( xglTraceIsEnabled("glMap2d") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glMap2d") )
+ glMap2d ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
+}
+
+void xglMap2f ( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points )
+{
+ if ( xglTraceIsEnabled("glMap2f") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glMap2f") )
+ glMap2f ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ) ;
+}
+
+void xglMapGrid1d ( GLint un, GLdouble u1, GLdouble u2 )
+{
+ if ( xglTraceIsEnabled("glMapGrid1d") )
+ fprintf ( xglTraceFd, " glMapGrid1d ( (GLint)%d, (GLdouble)%f, (GLdouble)%f ) ;\n" , un, u1, u2 ) ;
+ if ( xglExecuteIsEnabled("glMapGrid1d") )
+ glMapGrid1d ( un, u1, u2 ) ;
+}
+
+void xglMapGrid1f ( GLint un, GLfloat u1, GLfloat u2 )
+{
+ if ( xglTraceIsEnabled("glMapGrid1f") )
+ fprintf ( xglTraceFd, " glMapGrid1f ( (GLint)%d, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , un, u1, u2 ) ;
+ if ( xglExecuteIsEnabled("glMapGrid1f") )
+ glMapGrid1f ( un, u1, u2 ) ;
+}
+
+void xglMapGrid2d ( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
+{
+ if ( xglTraceIsEnabled("glMapGrid2d") )
+ fprintf ( xglTraceFd, " glMapGrid2d ( (GLint)%d, (GLdouble)%f, (GLdouble)%f, (GLint)%d, (GLdouble)%f, (GLdouble)%f ) ;\n" , un, u1, u2, vn, v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glMapGrid2d") )
+ glMapGrid2d ( un, u1, u2, vn, v1, v2 ) ;
+}
+
+void xglMapGrid2f ( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
+{
+ if ( xglTraceIsEnabled("glMapGrid2f") )
+ fprintf ( xglTraceFd, " glMapGrid2f ( (GLint)%d, (GLfloat)%ff, (GLfloat)%ff, (GLint)%d, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , un, u1, u2, vn, v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glMapGrid2f") )
+ glMapGrid2f ( un, u1, u2, vn, v1, v2 ) ;
+}
+
+void xglMaterialf ( GLenum face, GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glMaterialf") )
+ fprintf ( xglTraceFd, " glMaterialf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glMaterialf") )
+ glMaterialf ( face, pname, param ) ;
+}
+
+void xglMaterialfv ( GLenum face, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glMaterialfv") )
+ fprintf ( xglTraceFd, " glMaterialfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glMaterialfv") )
+ glMaterialfv ( face, pname, params ) ;
+}
+
+void xglMateriali ( GLenum face, GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glMateriali") )
+ fprintf ( xglTraceFd, " glMateriali ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glMateriali") )
+ glMateriali ( face, pname, param ) ;
+}
+
+void xglMaterialiv ( GLenum face, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glMaterialiv") )
+ fprintf ( xglTraceFd, " glMaterialiv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glMaterialiv") )
+ glMaterialiv ( face, pname, params ) ;
+}
+
+void xglMatrixMode ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glMatrixMode") )
+ fprintf ( xglTraceFd, " glMatrixMode ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glMatrixMode") )
+ glMatrixMode ( mode ) ;
+}
+
+
+void xglMultMatrixd ( GLdouble* m )
+{
+ if ( xglTraceIsEnabled("glMultMatrixd") )
+ {
+ fprintf ( xglTraceFd, " glMultMatrixd ( xglBuildMatrixd(%f,%f,%f,%f,\n" , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f,\n" , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f,\n" , m[ 8],m[ 9],m[10],m[11] ) ;
+ fprintf ( xglTraceFd, " %f,%f,%f,%f) ) ;\n", m[12],m[13],m[14],m[15] ) ;
+ }
+
+ if ( xglExecuteIsEnabled("glMultMatrixd") )
+ glMultMatrixd ( m ) ;
+}
+
+void xglMultMatrixf ( GLfloat* m )
+{
+ if ( xglTraceIsEnabled("glMultMatrixf") )
+ {
+ fprintf ( xglTraceFd, " glMultMatrixf ( xglBuildMatrixf(%ff,%ff,%ff,%ff,\n" , m[ 0],m[ 1],m[ 2],m[ 3] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff,\n" , m[ 4],m[ 5],m[ 6],m[ 7] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff,\n" , m[ 8],m[ 9],m[10],m[11] ) ;
+ fprintf ( xglTraceFd, " %ff,%ff,%ff,%ff) ) ;\n", m[12],m[13],m[14],m[15] ) ;
+ }
+
+ if ( xglExecuteIsEnabled("glMultMatrixf") )
+ glMultMatrixf ( m ) ;
+}
+
+void xglNewList ( GLuint list, GLenum mode )
+{
+ if ( xglTraceIsEnabled("glNewList") )
+ fprintf ( xglTraceFd, " glNewList ( (GLuint)%u, (GLenum)%s ) ;\n" , list, xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glNewList") )
+ glNewList ( list, mode ) ;
+}
+
+void xglNormal3b ( GLbyte nx, GLbyte ny, GLbyte nz )
+{
+ if ( xglTraceIsEnabled("glNormal3b") )
+ fprintf ( xglTraceFd, " glNormal3b ( (GLbyte)%d, (GLbyte)%d, (GLbyte)%d ) ;\n" , nx, ny, nz ) ;
+ if ( xglExecuteIsEnabled("glNormal3b") )
+ glNormal3b ( nx, ny, nz ) ;
+}
+
+void xglNormal3bv ( GLbyte* v )
+{
+ if ( xglTraceIsEnabled("glNormal3bv") )
+ fprintf ( xglTraceFd, " glNormal3bv ( xglBuild3bv((GLbyte)%d,(GLbyte)%d,(GLbyte)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glNormal3bv") )
+ glNormal3bv ( v ) ;
+}
+
+void xglNormal3d ( GLdouble nx, GLdouble ny, GLdouble nz )
+{
+ if ( xglTraceIsEnabled("glNormal3d") )
+ fprintf ( xglTraceFd, " glNormal3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , nx, ny, nz ) ;
+ if ( xglExecuteIsEnabled("glNormal3d") )
+ glNormal3d ( nx, ny, nz ) ;
+}
+
+void xglNormal3dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glNormal3dv") )
+ fprintf ( xglTraceFd, " glNormal3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glNormal3dv") )
+ glNormal3dv ( v ) ;
+}
+
+void xglNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz )
+{
+ if ( xglTraceIsEnabled("glNormal3f") )
+ fprintf ( xglTraceFd, " glNormal3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , nx, ny, nz ) ;
+ if ( xglExecuteIsEnabled("glNormal3f") )
+ glNormal3f ( nx, ny, nz ) ;
+}
+
+void xglNormal3fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glNormal3fv") )
+ fprintf ( xglTraceFd, " glNormal3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glNormal3fv") )
+ glNormal3fv ( v ) ;
+}
+
+void xglNormal3i ( GLint nx, GLint ny, GLint nz )
+{
+ if ( xglTraceIsEnabled("glNormal3i") )
+ fprintf ( xglTraceFd, " glNormal3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , nx, ny, nz ) ;
+ if ( xglExecuteIsEnabled("glNormal3i") )
+ glNormal3i ( nx, ny, nz ) ;
+}
+
+void xglNormal3iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glNormal3iv") )
+ fprintf ( xglTraceFd, " glNormal3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glNormal3iv") )
+ glNormal3iv ( v ) ;
+}
+
+void xglNormal3s ( GLshort nx, GLshort ny, GLshort nz )
+{
+ if ( xglTraceIsEnabled("glNormal3s") )
+ fprintf ( xglTraceFd, " glNormal3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , nx, ny, nz ) ;
+ if ( xglExecuteIsEnabled("glNormal3s") )
+ glNormal3s ( nx, ny, nz ) ;
+}
+
+void xglNormal3sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glNormal3sv") )
+ fprintf ( xglTraceFd, " glNormal3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glNormal3sv") )
+ glNormal3sv ( v ) ;
+}
+
+void xglNormalPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void* ptr )
+{
+ if ( xglTraceIsEnabled("glNormalPointerEXT") )
+ fprintf ( xglTraceFd, " glNormalPointerEXT ( (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glNormalPointer ( type, stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glNormalPointerEXT") )
+ glNormalPointerEXT ( type, stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glNormalPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglOrtho ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )
+{
+ if ( xglTraceIsEnabled("glOrtho") )
+ fprintf ( xglTraceFd, " glOrtho ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , left, right, bottom, top, near_val, far_val ) ;
+ if ( xglExecuteIsEnabled("glOrtho") )
+ glOrtho ( left, right, bottom, top, near_val, far_val ) ;
+}
+
+void xglPassThrough ( GLfloat token )
+{
+ if ( xglTraceIsEnabled("glPassThrough") )
+ fprintf ( xglTraceFd, " glPassThrough ( (GLfloat)%ff ) ;\n" , token ) ;
+ if ( xglExecuteIsEnabled("glPassThrough") )
+ glPassThrough ( token ) ;
+}
+
+void xglPixelMapfv ( GLenum map, GLint mapsize, GLfloat* values )
+{
+ if ( xglTraceIsEnabled("glPixelMapfv") )
+ fprintf ( xglTraceFd, " glPixelMapfv ( (GLenum)%s, (GLint)%d, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
+ if ( xglExecuteIsEnabled("glPixelMapfv") )
+ glPixelMapfv ( map, mapsize, values ) ;
+}
+
+void xglPixelMapuiv ( GLenum map, GLint mapsize, GLuint* values )
+{
+ if ( xglTraceIsEnabled("glPixelMapuiv") )
+ fprintf ( xglTraceFd, " glPixelMapuiv ( (GLenum)%s, (GLint)%d, (GLuint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
+ if ( xglExecuteIsEnabled("glPixelMapuiv") )
+ glPixelMapuiv ( map, mapsize, values ) ;
+}
+
+void xglPixelMapusv ( GLenum map, GLint mapsize, GLushort* values )
+{
+ if ( xglTraceIsEnabled("glPixelMapusv") )
+ fprintf ( xglTraceFd, " glPixelMapusv ( (GLenum)%s, (GLint)%d, (GLushort *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) map ), mapsize, values ) ;
+ if ( xglExecuteIsEnabled("glPixelMapusv") )
+ glPixelMapusv ( map, mapsize, values ) ;
+}
+
+void xglPixelStoref ( GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glPixelStoref") )
+ fprintf ( xglTraceFd, " glPixelStoref ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glPixelStoref") )
+ glPixelStoref ( pname, param ) ;
+}
+
+void xglPixelStorei ( GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glPixelStorei") )
+ fprintf ( xglTraceFd, " glPixelStorei ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glPixelStorei") )
+ glPixelStorei ( pname, param ) ;
+}
+
+void xglPixelTransferf ( GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glPixelTransferf") )
+ fprintf ( xglTraceFd, " glPixelTransferf ( (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glPixelTransferf") )
+ glPixelTransferf ( pname, param ) ;
+}
+
+void xglPixelTransferi ( GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glPixelTransferi") )
+ fprintf ( xglTraceFd, " glPixelTransferi ( (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glPixelTransferi") )
+ glPixelTransferi ( pname, param ) ;
+}
+
+void xglPixelZoom ( GLfloat xfactor, GLfloat yfactor )
+{
+ if ( xglTraceIsEnabled("glPixelZoom") )
+ fprintf ( xglTraceFd, " glPixelZoom ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , xfactor, yfactor ) ;
+ if ( xglExecuteIsEnabled("glPixelZoom") )
+ glPixelZoom ( xfactor, yfactor ) ;
+}
+
+void xglPointSize ( GLfloat size )
+{
+ if ( xglTraceIsEnabled("glPointSize") )
+ fprintf ( xglTraceFd, " glPointSize ( (GLfloat)%ff ) ;\n" , size ) ;
+ if ( xglExecuteIsEnabled("glPointSize") )
+ glPointSize ( size ) ;
+}
+
+void xglPolygonMode ( GLenum face, GLenum mode )
+{
+ if ( xglTraceIsEnabled("glPolygonMode") )
+ fprintf ( xglTraceFd, " glPolygonMode ( (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) face ), xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glPolygonMode") )
+ glPolygonMode ( face, mode ) ;
+}
+
+void xglPolygonOffsetEXT ( GLfloat factor, GLfloat bias )
+{
+ if ( xglTraceIsEnabled("glPolygonOffsetEXT") )
+ fprintf ( xglTraceFd, " glPolygonOffsetEXT ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , factor, bias ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glPolygonOffsetEXT") )
+ glPolygonOffset ( factor, bias ) ;
+#else
+#ifdef GL_EXT_polygon_offset
+ if ( xglExecuteIsEnabled("glPolygonOffsetEXT") )
+ glPolygonOffsetEXT ( factor, bias ) ;
+#else
+ fprintf ( xglTraceFd, " glPolygonOffsetEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglPolygonOffset ( GLfloat factor, GLfloat bias )
+{
+ if ( xglTraceIsEnabled("glPolygonOffset") )
+ fprintf ( xglTraceFd, " glPolygonOffset ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , factor, bias ) ;
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glPolygonOffset") )
+ glPolygonOffset ( factor, bias ) ;
+#else
+#ifdef GL_EXT_polygon_offset
+ if ( xglExecuteIsEnabled("glPolygonOffset") )
+ glPolygonOffsetEXT ( factor, bias ) ;
+#else
+ fprintf ( xglTraceFd, " glPolygonOffsetEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglPolygonStipple ( GLubyte* mask )
+{
+ if ( xglTraceIsEnabled("glPolygonStipple") )
+ fprintf ( xglTraceFd, " glPolygonStipple ( (GLubyte *)0x%08x ) ;\n" , mask ) ;
+ if ( xglExecuteIsEnabled("glPolygonStipple") )
+ glPolygonStipple ( mask ) ;
+}
+
+void xglPopAttrib ( )
+{
+ if ( xglTraceIsEnabled("glPopAttrib") )
+ fprintf ( xglTraceFd, " glPopAttrib ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glPopAttrib") )
+ glPopAttrib ( ) ;
+}
+
+void xglPopMatrix ( )
+{
+ if ( xglTraceIsEnabled("glPopMatrix") )
+ fprintf ( xglTraceFd, " glPopMatrix ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glPopMatrix") )
+ glPopMatrix ( ) ;
+}
+
+void xglPopName ( )
+{
+ if ( xglTraceIsEnabled("glPopName") )
+ fprintf ( xglTraceFd, " glPopName ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glPopName") )
+ glPopName ( ) ;
+}
+
+void xglPushAttrib ( GLbitfield mask )
+{
+ if ( xglTraceIsEnabled("glPushAttrib") )
+ fprintf ( xglTraceFd, " glPushAttrib ( (GLbitfield)0x%08x ) ;\n" , mask ) ;
+ if ( xglExecuteIsEnabled("glPushAttrib") )
+ glPushAttrib ( mask ) ;
+}
+
+void xglPushMatrix ( )
+{
+ if ( xglTraceIsEnabled("glPushMatrix") )
+ fprintf ( xglTraceFd, " glPushMatrix ( ) ;\n" ) ;
+ if ( xglExecuteIsEnabled("glPushMatrix") )
+ glPushMatrix ( ) ;
+}
+
+void xglPushName ( GLuint name )
+{
+ if ( xglTraceIsEnabled("glPushName") )
+ fprintf ( xglTraceFd, " glPushName ( (GLuint)%u ) ;\n" , name ) ;
+ if ( xglExecuteIsEnabled("glPushName") )
+ glPushName ( name ) ;
+}
+
+void xglRasterPos2d ( GLdouble x, GLdouble y )
+{
+ if ( xglTraceIsEnabled("glRasterPos2d") )
+ fprintf ( xglTraceFd, " glRasterPos2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2d") )
+ glRasterPos2d ( x, y ) ;
+}
+
+void xglRasterPos2dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos2dv") )
+ fprintf ( xglTraceFd, " glRasterPos2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2dv") )
+ glRasterPos2dv ( v ) ;
+}
+
+void xglRasterPos2f ( GLfloat x, GLfloat y )
+{
+ if ( xglTraceIsEnabled("glRasterPos2f") )
+ fprintf ( xglTraceFd, " glRasterPos2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2f") )
+ glRasterPos2f ( x, y ) ;
+}
+
+void xglRasterPos2fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos2fv") )
+ fprintf ( xglTraceFd, " glRasterPos2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2fv") )
+ glRasterPos2fv ( v ) ;
+}
+
+void xglRasterPos2i ( GLint x, GLint y )
+{
+ if ( xglTraceIsEnabled("glRasterPos2i") )
+ fprintf ( xglTraceFd, " glRasterPos2i ( (GLint)%d, (GLint)%d ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2i") )
+ glRasterPos2i ( x, y ) ;
+}
+
+void xglRasterPos2iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos2iv") )
+ fprintf ( xglTraceFd, " glRasterPos2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2iv") )
+ glRasterPos2iv ( v ) ;
+}
+
+void xglRasterPos2s ( GLshort x, GLshort y )
+{
+ if ( xglTraceIsEnabled("glRasterPos2s") )
+ fprintf ( xglTraceFd, " glRasterPos2s ( (GLshort)%d, (GLshort)%d ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2s") )
+ glRasterPos2s ( x, y ) ;
+}
+
+void xglRasterPos2sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos2sv") )
+ fprintf ( xglTraceFd, " glRasterPos2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos2sv") )
+ glRasterPos2sv ( v ) ;
+}
+
+void xglRasterPos3d ( GLdouble x, GLdouble y, GLdouble z )
+{
+ if ( xglTraceIsEnabled("glRasterPos3d") )
+ fprintf ( xglTraceFd, " glRasterPos3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3d") )
+ glRasterPos3d ( x, y, z ) ;
+}
+
+void xglRasterPos3dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos3dv") )
+ fprintf ( xglTraceFd, " glRasterPos3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3dv") )
+ glRasterPos3dv ( v ) ;
+}
+
+void xglRasterPos3f ( GLfloat x, GLfloat y, GLfloat z )
+{
+ if ( xglTraceIsEnabled("glRasterPos3f") )
+ fprintf ( xglTraceFd, " glRasterPos3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3f") )
+ glRasterPos3f ( x, y, z ) ;
+}
+
+void xglRasterPos3fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos3fv") )
+ fprintf ( xglTraceFd, " glRasterPos3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3fv") )
+ glRasterPos3fv ( v ) ;
+}
+
+void xglRasterPos3i ( GLint x, GLint y, GLint z )
+{
+ if ( xglTraceIsEnabled("glRasterPos3i") )
+ fprintf ( xglTraceFd, " glRasterPos3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3i") )
+ glRasterPos3i ( x, y, z ) ;
+}
+
+void xglRasterPos3iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos3iv") )
+ fprintf ( xglTraceFd, " glRasterPos3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3iv") )
+ glRasterPos3iv ( v ) ;
+}
+
+void xglRasterPos3s ( GLshort x, GLshort y, GLshort z )
+{
+ if ( xglTraceIsEnabled("glRasterPos3s") )
+ fprintf ( xglTraceFd, " glRasterPos3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3s") )
+ glRasterPos3s ( x, y, z ) ;
+}
+
+void xglRasterPos3sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos3sv") )
+ fprintf ( xglTraceFd, " glRasterPos3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos3sv") )
+ glRasterPos3sv ( v ) ;
+}
+
+void xglRasterPos4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
+ if ( xglTraceIsEnabled("glRasterPos4d") )
+ fprintf ( xglTraceFd, " glRasterPos4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4d") )
+ glRasterPos4d ( x, y, z, w ) ;
+}
+
+void xglRasterPos4dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos4dv") )
+ fprintf ( xglTraceFd, " glRasterPos4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4dv") )
+ glRasterPos4dv ( v ) ;
+}
+
+void xglRasterPos4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+ if ( xglTraceIsEnabled("glRasterPos4f") )
+ fprintf ( xglTraceFd, " glRasterPos4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4f") )
+ glRasterPos4f ( x, y, z, w ) ;
+}
+
+void xglRasterPos4fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos4fv") )
+ fprintf ( xglTraceFd, " glRasterPos4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4fv") )
+ glRasterPos4fv ( v ) ;
+}
+
+void xglRasterPos4i ( GLint x, GLint y, GLint z, GLint w )
+{
+ if ( xglTraceIsEnabled("glRasterPos4i") )
+ fprintf ( xglTraceFd, " glRasterPos4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4i") )
+ glRasterPos4i ( x, y, z, w ) ;
+}
+
+void xglRasterPos4iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos4iv") )
+ fprintf ( xglTraceFd, " glRasterPos4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4iv") )
+ glRasterPos4iv ( v ) ;
+}
+
+void xglRasterPos4s ( GLshort x, GLshort y, GLshort z, GLshort w )
+{
+ if ( xglTraceIsEnabled("glRasterPos4s") )
+ fprintf ( xglTraceFd, " glRasterPos4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4s") )
+ glRasterPos4s ( x, y, z, w ) ;
+}
+
+void xglRasterPos4sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glRasterPos4sv") )
+ fprintf ( xglTraceFd, " glRasterPos4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glRasterPos4sv") )
+ glRasterPos4sv ( v ) ;
+}
+
+void xglReadBuffer ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glReadBuffer") )
+ fprintf ( xglTraceFd, " glReadBuffer ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glReadBuffer") )
+ glReadBuffer ( mode ) ;
+}
+
+void xglReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels )
+{
+ if ( xglTraceIsEnabled("glReadPixels") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glReadPixels") )
+ glReadPixels ( x, y, width, height, format, type, pixels ) ;
+}
+
+void xglRectd ( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
+{
+ if ( xglTraceIsEnabled("glRectd") )
+ fprintf ( xglTraceFd, " glRectd ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x1, y1, x2, y2 ) ;
+ if ( xglExecuteIsEnabled("glRectd") )
+ glRectd ( x1, y1, x2, y2 ) ;
+}
+
+void xglRectdv ( GLdouble* v1, GLdouble* v2 )
+{
+ if ( xglTraceIsEnabled("glRectdv") )
+ fprintf ( xglTraceFd, " glRectdv ( (GLdouble *)0x%08x, (GLdouble *)0x%08x ) ;\n" , v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glRectdv") )
+ glRectdv ( v1, v2 ) ;
+}
+
+void xglRectf ( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+ if ( xglTraceIsEnabled("glRectf") )
+ fprintf ( xglTraceFd, " glRectf ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x1, y1, x2, y2 ) ;
+ if ( xglExecuteIsEnabled("glRectf") )
+ glRectf ( x1, y1, x2, y2 ) ;
+}
+
+void xglRectfv ( GLfloat* v1, GLfloat* v2 )
+{
+ if ( xglTraceIsEnabled("glRectfv") )
+ fprintf ( xglTraceFd, " glRectfv ( (GLfloat *)0x%08x, (GLfloat *)0x%08x ) ;\n" , v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glRectfv") )
+ glRectfv ( v1, v2 ) ;
+}
+
+void xglRecti ( GLint x1, GLint y1, GLint x2, GLint y2 )
+{
+ if ( xglTraceIsEnabled("glRecti") )
+ fprintf ( xglTraceFd, " glRecti ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x1, y1, x2, y2 ) ;
+ if ( xglExecuteIsEnabled("glRecti") )
+ glRecti ( x1, y1, x2, y2 ) ;
+}
+
+void xglRectiv ( GLint* v1, GLint* v2 )
+{
+ if ( xglTraceIsEnabled("glRectiv") )
+ fprintf ( xglTraceFd, " glRectiv ( (GLint *)0x%08x, (GLint *)0x%08x ) ;\n" , v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glRectiv") )
+ glRectiv ( v1, v2 ) ;
+}
+
+void xglRects ( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
+{
+ if ( xglTraceIsEnabled("glRects") )
+ fprintf ( xglTraceFd, " glRects ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x1, y1, x2, y2 ) ;
+ if ( xglExecuteIsEnabled("glRects") )
+ glRects ( x1, y1, x2, y2 ) ;
+}
+
+void xglRectsv ( GLshort* v1, GLshort* v2 )
+{
+ if ( xglTraceIsEnabled("glRectsv") )
+ fprintf ( xglTraceFd, " glRectsv ( (GLshort *)0x%08x, (GLshort *)0x%08x ) ;\n" , v1, v2 ) ;
+ if ( xglExecuteIsEnabled("glRectsv") )
+ glRectsv ( v1, v2 ) ;
+}
+
+void xglRotated ( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
+{
+ if ( xglTraceIsEnabled("glRotated") )
+ fprintf ( xglTraceFd, " glRotated ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , angle, x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRotated") )
+ glRotated ( angle, x, y, z ) ;
+}
+
+void xglRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
+{
+ if ( xglTraceIsEnabled("glRotatef") )
+ fprintf ( xglTraceFd, " glRotatef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , angle, x, y, z ) ;
+ if ( xglExecuteIsEnabled("glRotatef") )
+ glRotatef ( angle, x, y, z ) ;
+}
+
+void xglScaled ( GLdouble x, GLdouble y, GLdouble z )
+{
+ if ( xglTraceIsEnabled("glScaled") )
+ fprintf ( xglTraceFd, " glScaled ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glScaled") )
+ glScaled ( x, y, z ) ;
+}
+
+void xglScalef ( GLfloat x, GLfloat y, GLfloat z )
+{
+ if ( xglTraceIsEnabled("glScalef") )
+ fprintf ( xglTraceFd, " glScalef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glScalef") )
+ glScalef ( x, y, z ) ;
+}
+
+void xglScissor ( GLint x, GLint y, GLsizei width, GLsizei height )
+{
+ if ( xglTraceIsEnabled("glScissor") )
+ fprintf ( xglTraceFd, " glScissor ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d ) ;\n" , x, y, width, height ) ;
+ if ( xglExecuteIsEnabled("glScissor") )
+ glScissor ( x, y, width, height ) ;
+}
+
+void xglSelectBuffer ( GLsizei size, GLuint* buffer )
+{
+ if ( xglTraceIsEnabled("glSelectBuffer") )
+ fprintf ( xglTraceFd, " glSelectBuffer ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , size, buffer ) ;
+ if ( xglExecuteIsEnabled("glSelectBuffer") )
+ glSelectBuffer ( size, buffer ) ;
+}
+
+void xglShadeModel ( GLenum mode )
+{
+ if ( xglTraceIsEnabled("glShadeModel") )
+ fprintf ( xglTraceFd, " glShadeModel ( (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) mode ) ) ;
+ if ( xglExecuteIsEnabled("glShadeModel") )
+ glShadeModel ( mode ) ;
+}
+
+void xglStencilFunc ( GLenum func, GLint ref, GLuint mask )
+{
+ if ( xglTraceIsEnabled("glStencilFunc") )
+ fprintf ( xglTraceFd, " glStencilFunc ( (GLenum)%s, (GLint)%d, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) func ), ref, mask ) ;
+ if ( xglExecuteIsEnabled("glStencilFunc") )
+ glStencilFunc ( func, ref, mask ) ;
+}
+
+void xglStencilMask ( GLuint mask )
+{
+ if ( xglTraceIsEnabled("glStencilMask") )
+ fprintf ( xglTraceFd, " glStencilMask ( (GLuint)%u ) ;\n" , mask ) ;
+ if ( xglExecuteIsEnabled("glStencilMask") )
+ glStencilMask ( mask ) ;
+}
+
+void xglStencilOp ( GLenum fail, GLenum zfail, GLenum zpass )
+{
+ if ( xglTraceIsEnabled("glStencilOp") )
+ fprintf ( xglTraceFd, " glStencilOp ( (GLenum)%s, (GLenum)%s, (GLenum)%s ) ;\n" , xglExpandGLenum ( (GLenum) fail ), xglExpandGLenum ( (GLenum) zfail ), xglExpandGLenum ( (GLenum) zpass ) ) ;
+ if ( xglExecuteIsEnabled("glStencilOp") )
+ glStencilOp ( fail, zfail, zpass ) ;
+}
+
+void xglTexCoord1d ( GLdouble s )
+{
+ if ( xglTraceIsEnabled("glTexCoord1d") )
+ fprintf ( xglTraceFd, " glTexCoord1d ( (GLdouble)%f ) ;\n" , s ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1d") )
+ glTexCoord1d ( s ) ;
+}
+
+void xglTexCoord1dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord1dv") )
+ fprintf ( xglTraceFd, " glTexCoord1dv ( xglBuild1dv((GLdouble)%f) ) ;\n" , v[0] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1dv") )
+ glTexCoord1dv ( v ) ;
+}
+
+void xglTexCoord1f ( GLfloat s )
+{
+ if ( xglTraceIsEnabled("glTexCoord1f") )
+ fprintf ( xglTraceFd, " glTexCoord1f ( (GLfloat)%ff ) ;\n" , s ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1f") )
+ glTexCoord1f ( s ) ;
+}
+
+void xglTexCoord1fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord1fv") )
+ fprintf ( xglTraceFd, " glTexCoord1fv ( xglBuild1fv((GLfloat)%ff) ) ;\n" , v[0] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1fv") )
+ glTexCoord1fv ( v ) ;
+}
+
+void xglTexCoord1i ( GLint s )
+{
+ if ( xglTraceIsEnabled("glTexCoord1i") )
+ fprintf ( xglTraceFd, " glTexCoord1i ( (GLint)%d ) ;\n" , s ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1i") )
+ glTexCoord1i ( s ) ;
+}
+
+void xglTexCoord1iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord1iv") )
+ fprintf ( xglTraceFd, " glTexCoord1iv ( xglBuild1iv((GLint)%d) ) ;\n" , v[0] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1iv") )
+ glTexCoord1iv ( v ) ;
+}
+
+void xglTexCoord1s ( GLshort s )
+{
+ if ( xglTraceIsEnabled("glTexCoord1s") )
+ fprintf ( xglTraceFd, " glTexCoord1s ( (GLshort)%d ) ;\n" , s ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1s") )
+ glTexCoord1s ( s ) ;
+}
+
+void xglTexCoord1sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord1sv") )
+ fprintf ( xglTraceFd, " glTexCoord1sv ( xglBuild1sv((GLshort)%d) ) ;\n" , v[0] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord1sv") )
+ glTexCoord1sv ( v ) ;
+}
+
+void xglTexCoord2d ( GLdouble s, GLdouble t )
+{
+ if ( xglTraceIsEnabled("glTexCoord2d") )
+ fprintf ( xglTraceFd, " glTexCoord2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2d") )
+ glTexCoord2d ( s, t ) ;
+}
+
+void xglTexCoord2dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord2dv") )
+ fprintf ( xglTraceFd, " glTexCoord2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2dv") )
+ glTexCoord2dv ( v ) ;
+}
+
+void xglTexCoord2f ( GLfloat s, GLfloat t )
+{
+ if ( xglTraceIsEnabled("glTexCoord2f") )
+ fprintf ( xglTraceFd, " glTexCoord2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2f") )
+ glTexCoord2f ( s, t ) ;
+}
+
+void xglTexCoord2fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord2fv") )
+ fprintf ( xglTraceFd, " glTexCoord2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2fv") )
+ glTexCoord2fv ( v ) ;
+}
+
+void xglTexCoord2i ( GLint s, GLint t )
+{
+ if ( xglTraceIsEnabled("glTexCoord2i") )
+ fprintf ( xglTraceFd, " glTexCoord2i ( (GLint)%d, (GLint)%d ) ;\n" , s, t ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2i") )
+ glTexCoord2i ( s, t ) ;
+}
+
+void xglTexCoord2iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord2iv") )
+ fprintf ( xglTraceFd, " glTexCoord2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2iv") )
+ glTexCoord2iv ( v ) ;
+}
+
+void xglTexCoord2s ( GLshort s, GLshort t )
+{
+ if ( xglTraceIsEnabled("glTexCoord2s") )
+ fprintf ( xglTraceFd, " glTexCoord2s ( (GLshort)%d, (GLshort)%d ) ;\n" , s, t ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2s") )
+ glTexCoord2s ( s, t ) ;
+}
+
+void xglTexCoord2sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord2sv") )
+ fprintf ( xglTraceFd, " glTexCoord2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord2sv") )
+ glTexCoord2sv ( v ) ;
+}
+
+void xglTexCoord3d ( GLdouble s, GLdouble t, GLdouble r )
+{
+ if ( xglTraceIsEnabled("glTexCoord3d") )
+ fprintf ( xglTraceFd, " glTexCoord3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t, r ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3d") )
+ glTexCoord3d ( s, t, r ) ;
+}
+
+void xglTexCoord3dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord3dv") )
+ fprintf ( xglTraceFd, " glTexCoord3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3dv") )
+ glTexCoord3dv ( v ) ;
+}
+
+void xglTexCoord3f ( GLfloat s, GLfloat t, GLfloat r )
+{
+ if ( xglTraceIsEnabled("glTexCoord3f") )
+ fprintf ( xglTraceFd, " glTexCoord3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t, r ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3f") )
+ glTexCoord3f ( s, t, r ) ;
+}
+
+void xglTexCoord3fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord3fv") )
+ fprintf ( xglTraceFd, " glTexCoord3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3fv") )
+ glTexCoord3fv ( v ) ;
+}
+
+void xglTexCoord3i ( GLint s, GLint t, GLint r )
+{
+ if ( xglTraceIsEnabled("glTexCoord3i") )
+ fprintf ( xglTraceFd, " glTexCoord3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , s, t, r ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3i") )
+ glTexCoord3i ( s, t, r ) ;
+}
+
+void xglTexCoord3iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord3iv") )
+ fprintf ( xglTraceFd, " glTexCoord3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3iv") )
+ glTexCoord3iv ( v ) ;
+}
+
+void xglTexCoord3s ( GLshort s, GLshort t, GLshort r )
+{
+ if ( xglTraceIsEnabled("glTexCoord3s") )
+ fprintf ( xglTraceFd, " glTexCoord3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , s, t, r ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3s") )
+ glTexCoord3s ( s, t, r ) ;
+}
+
+void xglTexCoord3sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord3sv") )
+ fprintf ( xglTraceFd, " glTexCoord3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord3sv") )
+ glTexCoord3sv ( v ) ;
+}
+
+void xglTexCoord4d ( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
+ if ( xglTraceIsEnabled("glTexCoord4d") )
+ fprintf ( xglTraceFd, " glTexCoord4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , s, t, r, q ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4d") )
+ glTexCoord4d ( s, t, r, q ) ;
+}
+
+void xglTexCoord4dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord4dv") )
+ fprintf ( xglTraceFd, " glTexCoord4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4dv") )
+ glTexCoord4dv ( v ) ;
+}
+
+void xglTexCoord4f ( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+ if ( xglTraceIsEnabled("glTexCoord4f") )
+ fprintf ( xglTraceFd, " glTexCoord4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , s, t, r, q ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4f") )
+ glTexCoord4f ( s, t, r, q ) ;
+}
+
+void xglTexCoord4fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord4fv") )
+ fprintf ( xglTraceFd, " glTexCoord4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4fv") )
+ glTexCoord4fv ( v ) ;
+}
+
+void xglTexCoord4i ( GLint s, GLint t, GLint r, GLint q )
+{
+ if ( xglTraceIsEnabled("glTexCoord4i") )
+ fprintf ( xglTraceFd, " glTexCoord4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , s, t, r, q ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4i") )
+ glTexCoord4i ( s, t, r, q ) ;
+}
+
+void xglTexCoord4iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord4iv") )
+ fprintf ( xglTraceFd, " glTexCoord4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4iv") )
+ glTexCoord4iv ( v ) ;
+}
+
+void xglTexCoord4s ( GLshort s, GLshort t, GLshort r, GLshort q )
+{
+ if ( xglTraceIsEnabled("glTexCoord4s") )
+ fprintf ( xglTraceFd, " glTexCoord4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , s, t, r, q ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4s") )
+ glTexCoord4s ( s, t, r, q ) ;
+}
+
+void xglTexCoord4sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glTexCoord4sv") )
+ fprintf ( xglTraceFd, " glTexCoord4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glTexCoord4sv") )
+ glTexCoord4sv ( v ) ;
+}
+
+void xglTexCoordPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
+{
+ if ( xglTraceIsEnabled("glTexCoordPointerEXT") )
+ fprintf ( xglTraceFd, " glTexCoordPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glTexCoordPointer ( size, type, stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glTexCoordPointerEXT") )
+ glTexCoordPointerEXT ( size, type, stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glTexCoordPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglTexEnvf ( GLenum target, GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glTexEnvf") )
+ fprintf ( xglTraceFd, " glTexEnvf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexEnvf") )
+ glTexEnvf ( target, pname, param ) ;
+}
+
+void xglTexEnvfv ( GLenum target, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glTexEnvfv") )
+ fprintf ( xglTraceFd, " glTexEnvfv ( (GLenum)%s, (GLenum)%s, xglBuild4fv(%ff,%ff,%ff,%ff) ) ;\n",
+ xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params[0], params[1], params[2], params[3] ) ;
+ if ( xglExecuteIsEnabled("glTexEnvfv") )
+ glTexEnvfv ( target, pname, params ) ;
+}
+
+void xglTexEnvi ( GLenum target, GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glTexEnvi") )
+ fprintf ( xglTraceFd, " glTexEnvi ( (GLenum)%s, (GLenum)%s, (GLint)%s ) ;\n",
+ xglExpandGLenum ( (GLenum) target ),
+ xglExpandGLenum ( (GLenum) pname ),
+ xglExpandGLenum ( (GLenum) param ) ) ;
+
+ if ( xglExecuteIsEnabled("glTexEnvi") )
+ glTexEnvi ( target, pname, param ) ;
+}
+
+void xglTexEnviv ( GLenum target, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glTexEnviv") )
+ fprintf ( xglTraceFd, " glTexEnviv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexEnviv") )
+ glTexEnviv ( target, pname, params ) ;
+}
+
+void xglTexGend ( GLenum coord, GLenum pname, GLdouble param )
+{
+ if ( xglTraceIsEnabled("glTexGend") )
+ fprintf ( xglTraceFd, " glTexGend ( (GLenum)%s, (GLenum)%s, (GLdouble)%f ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexGend") )
+ glTexGend ( coord, pname, param ) ;
+}
+
+void xglTexGendv ( GLenum coord, GLenum pname, GLdouble* params )
+{
+ if ( xglTraceIsEnabled("glTexGendv") )
+ fprintf ( xglTraceFd, " glTexGendv ( (GLenum)%s, (GLenum)%s, (GLdouble *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexGendv") )
+ glTexGendv ( coord, pname, params ) ;
+}
+
+void xglTexGenf ( GLenum coord, GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glTexGenf") )
+ fprintf ( xglTraceFd, " glTexGenf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexGenf") )
+ glTexGenf ( coord, pname, param ) ;
+}
+
+void xglTexGenfv ( GLenum coord, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glTexGenfv") )
+ fprintf ( xglTraceFd, " glTexGenfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexGenfv") )
+ glTexGenfv ( coord, pname, params ) ;
+}
+
+void xglTexGeni ( GLenum coord, GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glTexGeni") )
+ fprintf ( xglTraceFd, " glTexGeni ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexGeni") )
+ glTexGeni ( coord, pname, param ) ;
+}
+
+void xglTexGeniv ( GLenum coord, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glTexGeniv") )
+ fprintf ( xglTraceFd, " glTexGeniv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) coord ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexGeniv") )
+ glTexGeniv ( coord, pname, params ) ;
+}
+
+void xglTexImage1D ( GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid* pixels )
+{
+ if ( xglTraceIsEnabled("glTexImage1D") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glTexImage1D") )
+ glTexImage1D ( target, level, components, width, border, format, type, pixels ) ;
+}
+
+void xglTexImage2D ( GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels )
+{
+ if ( xglTraceIsEnabled("glTexImage2D") )
+ 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 ) ;
+ if ( xglExecuteIsEnabled("glTexImage2D") )
+ glTexImage2D ( target, level, components, width, height, border, format, type, pixels ) ;
+}
+
+void xglTexParameterf ( GLenum target, GLenum pname, GLfloat param )
+{
+ if ( xglTraceIsEnabled("glTexParameterf") )
+ fprintf ( xglTraceFd, " glTexParameterf ( (GLenum)%s, (GLenum)%s, (GLfloat)%ff ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexParameterf") )
+ glTexParameterf ( target, pname, param ) ;
+}
+
+void xglTexParameterfv ( GLenum target, GLenum pname, GLfloat* params )
+{
+ if ( xglTraceIsEnabled("glTexParameterfv") )
+ fprintf ( xglTraceFd, " glTexParameterfv ( (GLenum)%s, (GLenum)%s, (GLfloat *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexParameterfv") )
+ glTexParameterfv ( target, pname, params ) ;
+}
+
+void xglTexParameteri ( GLenum target, GLenum pname, GLint param )
+{
+ if ( xglTraceIsEnabled("glTexParameteri") )
+ fprintf ( xglTraceFd, " glTexParameteri ( (GLenum)%s, (GLenum)%s, (GLint)%d ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), param ) ;
+ if ( xglExecuteIsEnabled("glTexParameteri") )
+ glTexParameteri ( target, pname, param ) ;
+}
+
+void xglTexParameteriv ( GLenum target, GLenum pname, GLint* params )
+{
+ if ( xglTraceIsEnabled("glTexParameteriv") )
+ fprintf ( xglTraceFd, " glTexParameteriv ( (GLenum)%s, (GLenum)%s, (GLint *)0x%08x ) ;\n" , xglExpandGLenum ( (GLenum) target ), xglExpandGLenum ( (GLenum) pname ), params ) ;
+ if ( xglExecuteIsEnabled("glTexParameteriv") )
+ glTexParameteriv ( target, pname, params ) ;
+}
+
+void xglTranslated ( GLdouble x, GLdouble y, GLdouble z )
+{
+ if ( xglTraceIsEnabled("glTranslated") )
+ fprintf ( xglTraceFd, " glTranslated ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glTranslated") )
+ glTranslated ( x, y, z ) ;
+}
+
+void xglTranslatef ( GLfloat x, GLfloat y, GLfloat z )
+{
+ if ( xglTraceIsEnabled("glTranslatef") )
+ fprintf ( xglTraceFd, " glTranslatef ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glTranslatef") )
+ glTranslatef ( x, y, z ) ;
+}
+
+void xglVertex2d ( GLdouble x, GLdouble y )
+{
+ if ( xglTraceIsEnabled("glVertex2d") )
+ fprintf ( xglTraceFd, " glVertex2d ( (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glVertex2d") )
+ glVertex2d ( x, y ) ;
+}
+
+void xglVertex2dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glVertex2dv") )
+ fprintf ( xglTraceFd, " glVertex2dv ( xglBuild2dv((GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glVertex2dv") )
+ glVertex2dv ( v ) ;
+}
+
+void xglVertex2f ( GLfloat x, GLfloat y )
+{
+ if ( xglTraceIsEnabled("glVertex2f") )
+ fprintf ( xglTraceFd, " glVertex2f ( (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glVertex2f") )
+ glVertex2f ( x, y ) ;
+}
+
+void xglVertex2fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glVertex2fv") )
+ fprintf ( xglTraceFd, " glVertex2fv ( xglBuild2fv((GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glVertex2fv") )
+ glVertex2fv ( v ) ;
+}
+
+void xglVertex2i ( GLint x, GLint y )
+{
+ if ( xglTraceIsEnabled("glVertex2i") )
+ fprintf ( xglTraceFd, " glVertex2i ( (GLint)%d, (GLint)%d ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glVertex2i") )
+ glVertex2i ( x, y ) ;
+}
+
+void xglVertex2iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glVertex2iv") )
+ fprintf ( xglTraceFd, " glVertex2iv ( xglBuild2iv((GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glVertex2iv") )
+ glVertex2iv ( v ) ;
+}
+
+void xglVertex2s ( GLshort x, GLshort y )
+{
+ if ( xglTraceIsEnabled("glVertex2s") )
+ fprintf ( xglTraceFd, " glVertex2s ( (GLshort)%d, (GLshort)%d ) ;\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glVertex2s") )
+ glVertex2s ( x, y ) ;
+}
+
+void xglVertex2sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glVertex2sv") )
+ fprintf ( xglTraceFd, " glVertex2sv ( xglBuild2sv((GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1] ) ;
+ if ( xglExecuteIsEnabled("glVertex2sv") )
+ glVertex2sv ( v ) ;
+}
+
+void xglVertex3d ( GLdouble x, GLdouble y, GLdouble z )
+{
+ if ( xglTraceIsEnabled("glVertex3d") )
+ fprintf ( xglTraceFd, " glVertex3d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glVertex3d") )
+ glVertex3d ( x, y, z ) ;
+}
+
+void xglVertex3dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glVertex3dv") )
+ fprintf ( xglTraceFd, " glVertex3dv ( xglBuild3dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glVertex3dv") )
+ glVertex3dv ( v ) ;
+}
+
+void xglVertex3f ( GLfloat x, GLfloat y, GLfloat z )
+{
+ if ( xglTraceIsEnabled("glVertex3f") )
+ fprintf ( xglTraceFd, " glVertex3f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glVertex3f") )
+ glVertex3f ( x, y, z ) ;
+}
+
+void xglVertex3fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glVertex3fv") )
+ fprintf ( xglTraceFd, " glVertex3fv ( xglBuild3fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glVertex3fv") )
+ glVertex3fv ( v ) ;
+}
+
+void xglVertex3i ( GLint x, GLint y, GLint z )
+{
+ if ( xglTraceIsEnabled("glVertex3i") )
+ fprintf ( xglTraceFd, " glVertex3i ( (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glVertex3i") )
+ glVertex3i ( x, y, z ) ;
+}
+
+void xglVertex3iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glVertex3iv") )
+ fprintf ( xglTraceFd, " glVertex3iv ( xglBuild3iv((GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glVertex3iv") )
+ glVertex3iv ( v ) ;
+}
+
+void xglVertex3s ( GLshort x, GLshort y, GLshort z )
+{
+ if ( xglTraceIsEnabled("glVertex3s") )
+ fprintf ( xglTraceFd, " glVertex3s ( (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z ) ;
+ if ( xglExecuteIsEnabled("glVertex3s") )
+ glVertex3s ( x, y, z ) ;
+}
+
+void xglVertex3sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glVertex3sv") )
+ fprintf ( xglTraceFd, " glVertex3sv ( xglBuild3sv((GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2] ) ;
+ if ( xglExecuteIsEnabled("glVertex3sv") )
+ glVertex3sv ( v ) ;
+}
+
+void xglVertex4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
+ if ( xglTraceIsEnabled("glVertex4d") )
+ fprintf ( xglTraceFd, " glVertex4d ( (GLdouble)%f, (GLdouble)%f, (GLdouble)%f, (GLdouble)%f ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glVertex4d") )
+ glVertex4d ( x, y, z, w ) ;
+}
+
+void xglVertex4dv ( GLdouble* v )
+{
+ if ( xglTraceIsEnabled("glVertex4dv") )
+ fprintf ( xglTraceFd, " glVertex4dv ( xglBuild4dv((GLdouble)%f,(GLdouble)%f,(GLdouble)%f,(GLdouble)%f) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glVertex4dv") )
+ glVertex4dv ( v ) ;
+}
+
+void xglVertex4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+ if ( xglTraceIsEnabled("glVertex4f") )
+ fprintf ( xglTraceFd, " glVertex4f ( (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff, (GLfloat)%ff ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glVertex4f") )
+ glVertex4f ( x, y, z, w ) ;
+}
+
+void xglVertex4fv ( GLfloat* v )
+{
+ if ( xglTraceIsEnabled("glVertex4fv") )
+ fprintf ( xglTraceFd, " glVertex4fv ( xglBuild4fv((GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff,(GLfloat)%ff) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glVertex4fv") )
+ glVertex4fv ( v ) ;
+}
+
+void xglVertex4i ( GLint x, GLint y, GLint z, GLint w )
+{
+ if ( xglTraceIsEnabled("glVertex4i") )
+ fprintf ( xglTraceFd, " glVertex4i ( (GLint)%d, (GLint)%d, (GLint)%d, (GLint)%d ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glVertex4i") )
+ glVertex4i ( x, y, z, w ) ;
+}
+
+void xglVertex4iv ( GLint* v )
+{
+ if ( xglTraceIsEnabled("glVertex4iv") )
+ fprintf ( xglTraceFd, " glVertex4iv ( xglBuild4iv((GLint)%d,(GLint)%d,(GLint)%d,(GLint)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glVertex4iv") )
+ glVertex4iv ( v ) ;
+}
+
+void xglVertex4s ( GLshort x, GLshort y, GLshort z, GLshort w )
+{
+ if ( xglTraceIsEnabled("glVertex4s") )
+ fprintf ( xglTraceFd, " glVertex4s ( (GLshort)%d, (GLshort)%d, (GLshort)%d, (GLshort)%d ) ;\n" , x, y, z, w ) ;
+ if ( xglExecuteIsEnabled("glVertex4s") )
+ glVertex4s ( x, y, z, w ) ;
+}
+
+void xglVertex4sv ( GLshort* v )
+{
+ if ( xglTraceIsEnabled("glVertex4sv") )
+ fprintf ( xglTraceFd, " glVertex4sv ( xglBuild4sv((GLshort)%d,(GLshort)%d,(GLshort)%d,(GLshort)%d) ) ;\n" , v[0], v[1], v[2], v[3] ) ;
+ if ( xglExecuteIsEnabled("glVertex4sv") )
+ glVertex4sv ( v ) ;
+}
+
+void xglVertexPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void* ptr )
+{
+ if ( xglTraceIsEnabled("glVertexPointerEXT") )
+ fprintf ( xglTraceFd, " glVertexPointerEXT ( (GLint)%d, (GLenum)%s, (GLsizei)%d, (GLsizei)%d, (void *)0x%08x ) ;\n" , size, xglExpandGLenum ( (GLenum) type ), stride, count, ptr ) ;
+#ifdef GL_VERSION_1_1
+ glVertexPointer ( size, type, stride, ptr ) ;
+#else
+#ifdef GL_EXT_vertex_array
+ if ( xglExecuteIsEnabled("glVertexPointerEXT") )
+ glVertexPointerEXT ( size, type, stride, count, ptr ) ;
+#else
+ fprintf ( xglTraceFd, " glVertexPointerEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+#endif
+}
+
+void xglViewport ( GLint x, GLint y, GLsizei width, GLsizei height )
+{
+ if ( xglTraceIsEnabled("glViewport") )
+ fprintf ( xglTraceFd, " glViewport ( (GLint)%d, (GLint)%d, (GLsizei)%d, (GLsizei)%d ) ;\n" , x, y, width, height ) ;
+ if ( xglExecuteIsEnabled("glViewport") )
+ glViewport ( x, y, width, height ) ;
+}
+
+void xglutAddMenuEntry ( char* label, int value )
+{
+ if ( xglTraceIsEnabled("glutAddMenuEntry") )
+ fprintf ( xglTraceFd, " /* glutAddMenuEntry ( \"%s\", %d ) ; */\n" , label, value ) ;
+ if ( xglExecuteIsEnabled("glutAddMenuEntry") )
+ glutAddMenuEntry ( label, value ) ;
+}
+
+void xglutAttachMenu ( int button )
+{
+ if ( xglTraceIsEnabled("glutAttachMenu") )
+ fprintf ( xglTraceFd, " /* glutAttachMenu ( %d ) ; */\n" , button ) ;
+ if ( xglExecuteIsEnabled("glutAttachMenu") )
+ glutAttachMenu ( button ) ;
+}
+
+int xglutCreateMenu ( void (*func)(int) )
+{
+ if ( xglTraceIsEnabled("glutCreateMenu") )
+ fprintf ( xglTraceFd, " /* glutCreateMenu ( 0x%08x ) ; */\n" , func ) ;
+
+ return glutCreateMenu ( func ) ;
+}
+
+int xglutCreateWindow ( char* title )
+{
+ if ( xglTraceIsEnabled("glutCreateWindow") )
+ fprintf ( xglTraceFd, " /* glutCreateWindow ( \"%s\" ) ; */\n" , title ) ;
+
+ return glutCreateWindow ( title ) ;
+}
+
+void xglutDisplayFunc ( void (*func)(void) )
+{
+ if ( xglTraceIsEnabled("glutDisplayFunc") )
+ fprintf ( xglTraceFd, " /* glutDisplayFunc ( 0x%08x ) ; */\n" , func ) ;
+ if ( xglExecuteIsEnabled("glutDisplayFunc") )
+ glutDisplayFunc ( func ) ;
+}
+
+void xglutIdleFunc ( void (*func)(void) )
+{
+ if ( xglTraceIsEnabled("glutIdleFunc") )
+ fprintf ( xglTraceFd, " /* glutIdleFunc ( 0x%08x ) ; */\n" , func ) ;
+ if ( xglExecuteIsEnabled("glutIdleFunc") )
+ glutIdleFunc ( func ) ;
+}
+
+void xglutInit ( int* argcp, char** argv )
+{
+ if ( xglTraceIsEnabled("glutInit") )
+ fprintf ( xglTraceFd, " /* glutInit ( (int *)0x%08x, (char **)0x%08x ) ; */\n" , argcp, argv ) ;
+ if ( xglExecuteIsEnabled("glutInit") )
+ glutInit ( argcp, argv ) ;
+}
+
+void xglutInitDisplayMode ( unsigned int mode )
+{
+ if ( xglTraceIsEnabled("glutInitDisplayMode") )
+ fprintf ( xglTraceFd, " /* glutInitDisplayMode ( %u ) ; */\n" , mode ) ;
+ if ( xglExecuteIsEnabled("glutInitDisplayMode") )
+ glutInitDisplayMode ( mode ) ;
+}
+
+void xglutInitWindowPosition ( int x, int y )
+{
+ if ( xglTraceIsEnabled("glutInitWindowPosition") )
+ fprintf ( xglTraceFd, " /* glutInitWindowPosition ( %d, %d ) ; */\n" , x, y ) ;
+ if ( xglExecuteIsEnabled("glutInitWindowPosition") )
+ glutInitWindowPosition ( x, y ) ;
+}
+
+void xglutInitWindowSize ( int width, int height )
+{
+ if ( xglTraceIsEnabled("glutInitWindowSize") )
+ fprintf ( xglTraceFd, " /* glutInitWindowSize ( %d, %d ) ; */\n" , width, height ) ;
+ if ( xglExecuteIsEnabled("glutInitWindowSize") )
+ glutInitWindowSize ( width, height ) ;
+}
+
+void xglutKeyboardFunc ( void (*func)(unsigned char key, int x, int y) )
+{
+ if ( xglTraceIsEnabled("glutKeyboardFunc") )
+ fprintf ( xglTraceFd, " /* glutKeyboardFunc ( 0x%08x ) ; */\n" , func ) ;
+ if ( xglExecuteIsEnabled("glutKeyboardFunc") )
+ glutKeyboardFunc ( func ) ;
+}
+
+void xglutMainLoopUpdate ( )
+{
+ if ( xglTraceIsEnabled("glutMainLoopUpdate") )
+ fprintf ( xglTraceFd, " /* glutMainLoopUpdate ( ) ; */\n" ) ;
+ if ( xglExecuteIsEnabled("glutMainLoopUpdate") )
+ /* glutMainLoopUpdate ( ) ; */
+ printf("Steves glutMainLoopUpdate() hack not executed!!!!\n");
+}
+
+void xglutPostRedisplay ( )
+{
+ if ( xglTraceIsEnabled("glutPostRedisplay") )
+ fprintf ( xglTraceFd, " /* glutPostRedisplay ( ) ; */\n" ) ;
+ if ( xglExecuteIsEnabled("glutPostRedisplay") )
+ glutPostRedisplay ( ) ;
+}
+
+void xglutPreMainLoop ( )
+{
+ if ( xglTraceIsEnabled("glutPreMainLoop") )
+ fprintf ( xglTraceFd, " /* glutPreMainLoop ( ) ; */\n" ) ;
+ if ( xglExecuteIsEnabled("glutPreMainLoop") )
+ /* glutPreMainLoop ( ) ; */
+ printf("Steves glutPreLoopUpdate() hack not executed!!!!\n");
+
+}
+
+void xglutReshapeFunc ( void (*func)(int width, int height) )
+{
+ if ( xglTraceIsEnabled("glutReshapeFunc") )
+ fprintf ( xglTraceFd, " /* glutReshapeFunc ( 0x%08x ) ; */\n" , func ) ;
+ if ( xglExecuteIsEnabled("glutReshapeFunc") )
+ glutReshapeFunc ( func ) ;
+}
+
+void xglutSwapBuffers ()
+{
+ if ( xglTraceIsEnabled("glutSwapBuffers") )
+ fprintf ( xglTraceFd, " /* glutSwapBuffers ( ) ; */\n" ) ;
+ if ( xglExecuteIsEnabled("glutSwapBuffers") )
+ glutSwapBuffers () ;
+}
+
+GLboolean xglAreTexturesResidentEXT ( GLsizei n, GLuint* textures, GLboolean* residences )
+{
+ if ( xglTraceIsEnabled("glAreTexturesResidentEXT") )
+ fprintf ( xglTraceFd, " /* glAreTexturesResidentEXT ( (GLsizei)%d, (GLuint *)0x%08x, (GLboolean *)0x%08x ) ; */\n" , n, textures, residences ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glAreTexturesResidentEXT") )
+ return glAreTexturesResidentEXT ( n, textures, residences ) ;
+#else
+ fprintf ( xglTraceFd, " glAreTexturesResidentEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+
+ return TRUE ;
+}
+
+GLboolean xglIsTextureEXT ( GLuint texture )
+{
+ if ( xglTraceIsEnabled("glIsTextureEXT") )
+ fprintf ( xglTraceFd, " /* glIsTextureEXT ( (GLuint)%u ) ; */\n" , texture ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glIsTextureEXT") )
+ return glIsTextureEXT ( texture ) ;
+#else
+ fprintf ( xglTraceFd, " glIsTextureEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+
+ return TRUE ;
+}
+
+void xglBindTextureEXT ( GLenum target, GLuint texture )
+{
+ if ( xglTraceIsEnabled("glBindTextureEXT") )
+ fprintf ( xglTraceFd, " glBindTextureEXT ( (GLenum)%s, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) target ), texture ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glBindTextureEXT") )
+ glBindTextureEXT ( target, texture ) ;
+#else
+ fprintf ( xglTraceFd, " glBindTextureEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglDeleteTexturesEXT ( GLsizei n, GLuint* textures )
+{
+ if ( xglTraceIsEnabled("glDeleteTexturesEXT") )
+ fprintf ( xglTraceFd, " glDeleteTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glDeleteTexturesEXT") )
+ glDeleteTexturesEXT ( n, textures ) ;
+#else
+ fprintf ( xglTraceFd, " glDeleteTextures isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglGenTexturesEXT ( GLsizei n, GLuint* textures )
+{
+ if ( xglTraceIsEnabled("glGenTexturesEXT") )
+ fprintf ( xglTraceFd, " glGenTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glGenTexturesEXT") )
+ glGenTexturesEXT ( n, textures ) ;
+#else
+ fprintf ( xglTraceFd, " glDeleteTexturesEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglPrioritizeTexturesEXT ( GLsizei n, GLuint* textures, GLclampf* priorities )
+{
+ if ( xglTraceIsEnabled("glPrioritizeTexturesEXT") )
+ fprintf ( xglTraceFd, " glPrioritizeTexturesEXT ( (GLsizei)%d, (GLuint *)0x%08x, (GLclampf *)0x%08x ) ;\n" , n, textures, priorities ) ;
+
+#ifdef GL_TEXTURE_2D_BINDING_EXT
+ if ( xglExecuteIsEnabled("glPrioritizeTexturesEXT") )
+ glPrioritizeTexturesEXT ( n, textures, priorities ) ;
+#else
+ fprintf ( xglTraceFd, " glPrioritizeTexturesEXT isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+
+GLboolean xglAreTexturesResident ( GLsizei n, GLuint* textures, GLboolean* residences )
+{
+ if ( xglTraceIsEnabled("glAreTexturesResident") )
+ fprintf ( xglTraceFd, " /* glAreTexturesResident ( (GLsizei)%d, (GLuint *)0x%08x, (GLboolean *)0x%08x ) ; */\n" , n, textures, residences ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glAreTexturesResident") )
+ return glAreTexturesResident ( n, textures, residences ) ;
+#else
+ fprintf ( xglTraceFd, " glAreTexturesResident isn't supported on this OpenGL!\n" ) ;
+#endif
+
+ return TRUE ;
+}
+
+GLboolean xglIsTexture ( GLuint texture )
+{
+ if ( xglTraceIsEnabled("glIsTexture") )
+ fprintf ( xglTraceFd, " /* glIsTexture ( (GLuint)%u ) ; */\n" , texture ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glIsTexture") )
+ return glIsTexture ( texture ) ;
+#else
+ fprintf ( xglTraceFd, " glIsTexture isn't supported on this OpenGL!\n" ) ;
+#endif
+
+ return TRUE ;
+}
+
+void xglBindTexture ( GLenum target, GLuint texture )
+{
+ if ( xglTraceIsEnabled("glBindTexture") )
+ fprintf ( xglTraceFd, " glBindTexture ( (GLenum)%s, (GLuint)%u ) ;\n" , xglExpandGLenum ( (GLenum) target ), texture ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glBindTexture") )
+ glBindTexture ( target, texture ) ;
+#else
+ fprintf ( xglTraceFd, " glBindTexture isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglDeleteTextures ( GLsizei n, GLuint* textures )
+{
+ if ( xglTraceIsEnabled("glDeleteTextures") )
+ fprintf ( xglTraceFd, " glDeleteTextures ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glDeleteTextures") )
+ glDeleteTextures ( n, textures ) ;
+#else
+ fprintf ( xglTraceFd, " glDeleteTextures isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglGenTextures ( GLsizei n, GLuint* textures )
+{
+ if ( xglTraceIsEnabled("glGenTextures") )
+ fprintf ( xglTraceFd, " glGenTextures ( (GLsizei)%d, (GLuint *)0x%08x ) ;\n" , n, textures ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glGenTextures") )
+ glGenTextures ( n, textures ) ;
+#else
+ fprintf ( xglTraceFd, " glDeleteTextures isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+void xglPrioritizeTextures ( GLsizei n, GLuint* textures, GLclampf* priorities )
+{
+ if ( xglTraceIsEnabled("glPrioritizeTextures") )
+ fprintf ( xglTraceFd, " glPrioritizeTextures ( (GLsizei)%d, (GLuint *)0x%08x, (GLclampf *)0x%08x ) ;\n" , n, textures, priorities ) ;
+
+#ifdef GL_VERSION_1_1
+ if ( xglExecuteIsEnabled("glPrioritizeTextures") )
+ glPrioritizeTextures ( n, textures, priorities ) ;
+#else
+ fprintf ( xglTraceFd, " glPrioritizeTextures isn't supported on this OpenGL!\n" ) ;
+#endif
+}
+
+#endif
+
--- /dev/null
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <stdio.h>
+
+/* xgl Utilities */
+
+extern FILE *xglTraceFd ;
+
+int xglTraceIsEnabled ( char *gl_function_name ) ;
+int xglExecuteIsEnabled ( char *gl_function_name ) ;
+char *xglExpandGLenum ( GLenum x ) ;
+
+GLdouble *xglBuild1dv ( GLdouble v ) ;
+GLfloat *xglBuild1fv ( GLfloat v ) ;
+GLbyte *xglBuild1bv ( GLbyte v ) ;
+GLint *xglBuild1iv ( GLint v ) ;
+GLshort *xglBuild1sv ( GLshort v ) ;
+GLubyte *xglBuild1ubv ( GLubyte v ) ;
+GLuint *xglBuild1uiv ( GLuint v ) ;
+GLushort *xglBuild1usv ( GLushort v ) ;
+
+GLdouble *xglBuild2dv ( GLdouble v0, GLdouble v1 ) ;
+GLfloat *xglBuild2fv ( GLfloat v0, GLfloat v1 ) ;
+GLbyte *xglBuild2bv ( GLbyte v0, GLbyte v1 ) ;
+GLint *xglBuild2iv ( GLint v0, GLint v1 ) ;
+GLshort *xglBuild2sv ( GLshort v0, GLshort v1 ) ;
+GLubyte *xglBuild2ubv ( GLubyte v0, GLubyte v1 ) ;
+GLuint *xglBuild2uiv ( GLuint v0, GLuint v1 ) ;
+GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) ;
+
+GLdouble *xglBuild3dv ( GLdouble v0, GLdouble v1, GLdouble v2 ) ;
+GLfloat *xglBuild3fv ( GLfloat v0, GLfloat v1, GLfloat v2 ) ;
+GLbyte *xglBuild3bv ( GLbyte v0, GLbyte v1, GLbyte v2 ) ;
+GLint *xglBuild3iv ( GLint v0, GLint v1, GLint v2 ) ;
+GLshort *xglBuild3sv ( GLshort v0, GLshort v1, GLshort v2 ) ;
+GLubyte *xglBuild3ubv ( GLubyte v0, GLubyte v1, GLubyte v2 ) ;
+GLuint *xglBuild3uiv ( GLuint v0, GLuint v1, GLuint v2 ) ;
+GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) ;
+
+GLdouble *xglBuild4dv ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) ;
+GLfloat *xglBuild4fv ( GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) ;
+GLbyte *xglBuild4bv ( GLbyte v0, GLbyte v1, GLbyte v2, GLbyte v3 ) ;
+GLint *xglBuild4iv ( GLint v0, GLint v1, GLint v2, GLint v3 ) ;
+GLshort *xglBuild4sv ( GLshort v0, GLshort v1, GLshort v2, GLshort v3 ) ;
+GLubyte *xglBuild4ubv ( GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3 ) ;
+GLuint *xglBuild4uiv ( GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) ;
+GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) ;
+
+GLfloat *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
+ GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
+ GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
+ GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 ) ;
+
+GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
+ GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
+ GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
+ GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 ) ;
+
+/*
+ Conditionally compile all 'xgl' calls into standard 'gl' calls...
+
+ OR
+
+ Declare all possible 'xgl' calls as 'extern'.
+*/
+
+#ifndef XGL_TRACE
+
+#define xglAccum glAccum
+#define xglAlphaFunc glAlphaFunc
+#ifdef GL_EXT_vertex_array
+#define xglArrayElementEXT glArrayElementEXT
+#endif
+#define xglBegin glBegin
+#define xglBitmap glBitmap
+#ifdef GL_EXT_blend_color
+#define xglBlendColorEXT glBlendColorEXT
+#endif
+#ifdef GL_EXT_blend_minmax
+#define xglBlendEquationEXT glBlendEquationEXT
+#endif
+#define xglBlendFunc glBlendFunc
+#define xglCallList glCallList
+#define xglCallLists glCallLists
+#define xglClear glClear
+#define xglClearAccum glClearAccum
+#define xglClearColor glClearColor
+#define xglClearDepth glClearDepth
+#define xglClearIndex glClearIndex
+#define xglClearStencil glClearStencil
+#define xglClipPlane glClipPlane
+#define xglColor3b glColor3b
+#define xglColor3bv glColor3bv
+#define xglColor3d glColor3d
+#define xglColor3dv glColor3dv
+#define xglColor3f glColor3f
+#define xglColor3fv glColor3fv
+#define xglColor3i glColor3i
+#define xglColor3iv glColor3iv
+#define xglColor3s glColor3s
+#define xglColor3sv glColor3sv
+#define xglColor3ub glColor3ub
+#define xglColor3ubv glColor3ubv
+#define xglColor3ui glColor3ui
+#define xglColor3uiv glColor3uiv
+#define xglColor3us glColor3us
+#define xglColor3usv glColor3usv
+#define xglColor4b glColor4b
+#define xglColor4bv glColor4bv
+#define xglColor4d glColor4d
+#define xglColor4dv glColor4dv
+#define xglColor4f glColor4f
+#define xglColor4fv glColor4fv
+#define xglColor4i glColor4i
+#define xglColor4iv glColor4iv
+#define xglColor4s glColor4s
+#define xglColor4sv glColor4sv
+#define xglColor4ub glColor4ub
+#define xglColor4ubv glColor4ubv
+#define xglColor4ui glColor4ui
+#define xglColor4uiv glColor4uiv
+#define xglColor4us glColor4us
+#define xglColor4usv glColor4usv
+#define xglColorMask glColorMask
+#define xglColorMaterial glColorMaterial
+#ifdef GL_EXT_vertex_array
+#define xglColorPointerEXT glColorPointerEXT
+#endif
+#define xglCopyPixels glCopyPixels
+#define xglCullFace glCullFace
+#define xglDeleteLists glDeleteLists
+#define xglDepthFunc glDepthFunc
+#define xglDepthMask glDepthMask
+#define xglDepthRange glDepthRange
+#define xglDisable glDisable
+#ifdef GL_EXT_vertex_array
+#define xglDrawArraysEXT glDrawArraysEXT
+#endif
+#define xglDrawBuffer glDrawBuffer
+#define xglDrawPixels glDrawPixels
+#define xglEdgeFlag glEdgeFlag
+#ifdef GL_EXT_vertex_array
+#define xglEdgeFlagPointerEXT glEdgeFlagPointerEXT
+#endif
+#define xglEdgeFlagv glEdgeFlagv
+#define xglEnable glEnable
+#define xglEnd glEnd
+#define xglEndList glEndList
+#define xglEvalCoord1d glEvalCoord1d
+#define xglEvalCoord1dv glEvalCoord1dv
+#define xglEvalCoord1f glEvalCoord1f
+#define xglEvalCoord1fv glEvalCoord1fv
+#define xglEvalCoord2d glEvalCoord2d
+#define xglEvalCoord2dv glEvalCoord2dv
+#define xglEvalCoord2f glEvalCoord2f
+#define xglEvalCoord2fv glEvalCoord2fv
+#define xglEvalMesh1 glEvalMesh1
+#define xglEvalMesh2 glEvalMesh2
+#define xglEvalPoint1 glEvalPoint1
+#define xglEvalPoint2 glEvalPoint2
+#define xglFeedbackBuffer glFeedbackBuffer
+#define xglFinish glFinish
+#define xglFlush glFlush
+#define xglFogf glFogf
+#define xglFogfv glFogfv
+#define xglFogi glFogi
+#define xglFogiv glFogiv
+#define xglFrontFace glFrontFace
+#define xglFrustum glFrustum
+#define xglGenLists glGenLists
+#define xglGetBooleanv glGetBooleanv
+#define xglGetClipPlane glGetClipPlane
+#define xglGetDoublev glGetDoublev
+#define xglGetError glGetError
+#define xglGetFloatv glGetFloatv
+#define xglGetIntegerv glGetIntegerv
+#define xglGetLightfv glGetLightfv
+#define xglGetLightiv glGetLightiv
+#define xglGetMapdv glGetMapdv
+#define xglGetMapfv glGetMapfv
+#define xglGetMapiv glGetMapiv
+#define xglGetMaterialfv glGetMaterialfv
+#define xglGetMaterialiv glGetMaterialiv
+#define xglGetPixelMapfv glGetPixelMapfv
+#define xglGetPixelMapuiv glGetPixelMapuiv
+#define xglGetPixelMapusv glGetPixelMapusv
+#ifdef GL_EXT_vertex_array
+#define xglGetPointervEXT glGetPointervEXT
+#endif
+#define xglGetPolygonStipple glGetPolygonStipple
+#define xglGetString glGetString
+#define xglGetTexEnvfv glGetTexEnvfv
+#define xglGetTexEnviv glGetTexEnviv
+#define xglGetTexGendv glGetTexGendv
+#define xglGetTexGenfv glGetTexGenfv
+#define xglGetTexGeniv glGetTexGeniv
+#define xglGetTexImage glGetTexImage
+#define xglGetTexLevelParameterfv glGetTexLevelParameterfv
+#define xglGetTexLevelParameteriv glGetTexLevelParameteriv
+#define xglGetTexParameterfv glGetTexParameterfv
+#define xglGetTexParameteriv glGetTexParameteriv
+#define xglHint glHint
+#define xglIndexMask glIndexMask
+#ifdef GL_EXT_vertex_array
+#define xglIndexPointerEXT glIndexPointerEXT
+#endif
+#define xglIndexd glIndexd
+#define xglIndexdv glIndexdv
+#define xglIndexf glIndexf
+#define xglIndexfv glIndexfv
+#define xglIndexi glIndexi
+#define xglIndexiv glIndexiv
+#define xglIndexs glIndexs
+#define xglIndexsv glIndexsv
+#define xglInitNames glInitNames
+#define xglIsEnabled glIsEnabled
+#define xglIsList glIsList
+#define xglLightModelf glLightModelf
+#define xglLightModelfv glLightModelfv
+#define xglLightModeli glLightModeli
+#define xglLightModeliv glLightModeliv
+#define xglLightf glLightf
+#define xglLightfv glLightfv
+#define xglLighti glLighti
+#define xglLightiv glLightiv
+#define xglLineStipple glLineStipple
+#define xglLineWidth glLineWidth
+#define xglListBase glListBase
+#define xglLoadIdentity glLoadIdentity
+#define xglLoadMatrixd glLoadMatrixd
+#define xglLoadMatrixf glLoadMatrixf
+#define xglLoadName glLoadName
+#define xglLogicOp glLogicOp
+#define xglMap1d glMap1d
+#define xglMap1f glMap1f
+#define xglMap2d glMap2d
+#define xglMap2f glMap2f
+#define xglMapGrid1d glMapGrid1d
+#define xglMapGrid1f glMapGrid1f
+#define xglMapGrid2d glMapGrid2d
+#define xglMapGrid2f glMapGrid2f
+#define xglMaterialf glMaterialf
+#define xglMaterialfv glMaterialfv
+#define xglMateriali glMateriali
+#define xglMaterialiv glMaterialiv
+#define xglMatrixMode glMatrixMode
+#define xglMultMatrixd glMultMatrixd
+#define xglMultMatrixf glMultMatrixf
+#define xglNewList glNewList
+#define xglNormal3b glNormal3b
+#define xglNormal3bv glNormal3bv
+#define xglNormal3d glNormal3d
+#define xglNormal3dv glNormal3dv
+#define xglNormal3f glNormal3f
+#ifdef DEBUGGING_NORMALS
+#define xglNormal3fv(f) {\
+float ff = (f)[0]*(f)[0]+(f)[1]*(f)[1]+(f)[2]*(f)[2];\
+if ( ff < 0.9 || ff > 1.1 )\
+{\
+fprintf(stderr,"glNormal3fv Overflow: %f, %f, %f -> %f [%s,%s,%s]\n",\
+(f)[0],(f)[1],(f)[2],ff,str1,str2,str3);\
+normal_bombed = 1 ;\
+}\
+glNormal3fv(f);\
+}
+#else
+#define xglNormal3fv glNormal3fv
+#endif
+#define xglNormal3i glNormal3i
+#define xglNormal3iv glNormal3iv
+#define xglNormal3s glNormal3s
+#define xglNormal3sv glNormal3sv
+#ifdef GL_EXT_vertex_array
+#define xglNormalPointerEXT glNormalPointerEXT
+#endif
+#define xglOrtho glOrtho
+#define xglPassThrough glPassThrough
+#define xglPixelMapfv glPixelMapfv
+#define xglPixelMapuiv glPixelMapuiv
+#define xglPixelMapusv glPixelMapusv
+#define xglPixelStoref glPixelStoref
+#define xglPixelStorei glPixelStorei
+#define xglPixelTransferf glPixelTransferf
+#define xglPixelTransferi glPixelTransferi
+#define xglPixelZoom glPixelZoom
+#define xglPointSize glPointSize
+#define xglPolygonMode glPolygonMode
+#ifdef GL_EXT_polygon_offset
+#define xglPolygonOffsetEXT glPolygonOffsetEXT
+#endif
+#define xglPolygonOffset glPolygonOffset
+#define xglPolygonStipple glPolygonStipple
+#define xglPopAttrib glPopAttrib
+#define xglPopMatrix glPopMatrix
+#define xglPopName glPopName
+#define xglPushAttrib glPushAttrib
+#define xglPushMatrix glPushMatrix
+#define xglPushName glPushName
+#define xglRasterPos2d glRasterPos2d
+#define xglRasterPos2dv glRasterPos2dv
+#define xglRasterPos2f glRasterPos2f
+#define xglRasterPos2fv glRasterPos2fv
+#define xglRasterPos2i glRasterPos2i
+#define xglRasterPos2iv glRasterPos2iv
+#define xglRasterPos2s glRasterPos2s
+#define xglRasterPos2sv glRasterPos2sv
+#define xglRasterPos3d glRasterPos3d
+#define xglRasterPos3dv glRasterPos3dv
+#define xglRasterPos3f glRasterPos3f
+#define xglRasterPos3fv glRasterPos3fv
+#define xglRasterPos3i glRasterPos3i
+#define xglRasterPos3iv glRasterPos3iv
+#define xglRasterPos3s glRasterPos3s
+#define xglRasterPos3sv glRasterPos3sv
+#define xglRasterPos4d glRasterPos4d
+#define xglRasterPos4dv glRasterPos4dv
+#define xglRasterPos4f glRasterPos4f
+#define xglRasterPos4fv glRasterPos4fv
+#define xglRasterPos4i glRasterPos4i
+#define xglRasterPos4iv glRasterPos4iv
+#define xglRasterPos4s glRasterPos4s
+#define xglRasterPos4sv glRasterPos4sv
+#define xglReadBuffer glReadBuffer
+#define xglReadPixels glReadPixels
+#define xglRectd glRectd
+#define xglRectdv glRectdv
+#define xglRectf glRectf
+#define xglRectfv glRectfv
+#define xglRecti glRecti
+#define xglRectiv glRectiv
+#define xglRects glRects
+#define xglRectsv glRectsv
+#define xglRenderMode glRenderMode
+#define xglRotated glRotated
+#define xglRotatef glRotatef
+#define xglScaled glScaled
+#define xglScalef glScalef
+#define xglScissor glScissor
+#define xglSelectBuffer glSelectBuffer
+#define xglShadeModel glShadeModel
+#define xglStencilFunc glStencilFunc
+#define xglStencilMask glStencilMask
+#define xglStencilOp glStencilOp
+#define xglTexCoord1d glTexCoord1d
+#define xglTexCoord1dv glTexCoord1dv
+#define xglTexCoord1f glTexCoord1f
+#define xglTexCoord1fv glTexCoord1fv
+#define xglTexCoord1i glTexCoord1i
+#define xglTexCoord1iv glTexCoord1iv
+#define xglTexCoord1s glTexCoord1s
+#define xglTexCoord1sv glTexCoord1sv
+#define xglTexCoord2d glTexCoord2d
+#define xglTexCoord2dv glTexCoord2dv
+#define xglTexCoord2f glTexCoord2f
+#define xglTexCoord2fv glTexCoord2fv
+#define xglTexCoord2i glTexCoord2i
+#define xglTexCoord2iv glTexCoord2iv
+#define xglTexCoord2s glTexCoord2s
+#define xglTexCoord2sv glTexCoord2sv
+#define xglTexCoord3d glTexCoord3d
+#define xglTexCoord3dv glTexCoord3dv
+#define xglTexCoord3f glTexCoord3f
+#define xglTexCoord3fv glTexCoord3fv
+#define xglTexCoord3i glTexCoord3i
+#define xglTexCoord3iv glTexCoord3iv
+#define xglTexCoord3s glTexCoord3s
+#define xglTexCoord3sv glTexCoord3sv
+#define xglTexCoord4d glTexCoord4d
+#define xglTexCoord4dv glTexCoord4dv
+#define xglTexCoord4f glTexCoord4f
+#define xglTexCoord4fv glTexCoord4fv
+#define xglTexCoord4i glTexCoord4i
+#define xglTexCoord4iv glTexCoord4iv
+#define xglTexCoord4s glTexCoord4s
+#define xglTexCoord4sv glTexCoord4sv
+#ifdef GL_EXT_vertex_array
+#define xglTexCoordPointerEXT glTexCoordPointerEXT
+#endif
+#define xglTexEnvf glTexEnvf
+#define xglTexEnvfv glTexEnvfv
+#define xglTexEnvi glTexEnvi
+#define xglTexEnviv glTexEnviv
+#define xglTexGend glTexGend
+#define xglTexGendv glTexGendv
+#define xglTexGenf glTexGenf
+#define xglTexGenfv glTexGenfv
+#define xglTexGeni glTexGeni
+#define xglTexGeniv glTexGeniv
+#define xglTexImage1D glTexImage1D
+#define xglTexImage2D glTexImage2D
+#define xglTexParameterf glTexParameterf
+#define xglTexParameterfv glTexParameterfv
+#define xglTexParameteri glTexParameteri
+#define xglTexParameteriv glTexParameteriv
+#define xglTranslated glTranslated
+#define xglTranslatef glTranslatef
+#define xglVertex2d glVertex2d
+#define xglVertex2dv glVertex2dv
+#define xglVertex2f glVertex2f
+#define xglVertex2fv glVertex2fv
+#define xglVertex2i glVertex2i
+#define xglVertex2iv glVertex2iv
+#define xglVertex2s glVertex2s
+#define xglVertex2sv glVertex2sv
+#define xglVertex3d glVertex3d
+#define xglVertex3dv glVertex3dv
+#define xglVertex3f glVertex3f
+#define xglVertex3fv glVertex3fv
+#define xglVertex3i glVertex3i
+#define xglVertex3iv glVertex3iv
+#define xglVertex3s glVertex3s
+#define xglVertex3sv glVertex3sv
+#define xglVertex4d glVertex4d
+#define xglVertex4dv glVertex4dv
+#define xglVertex4f glVertex4f
+#define xglVertex4fv glVertex4fv
+#define xglVertex4i glVertex4i
+#define xglVertex4iv glVertex4iv
+#define xglVertex4s glVertex4s
+#define xglVertex4sv glVertex4sv
+#ifdef GL_EXT_vertex_array
+#define xglVertexPointerEXT glVertexPointerEXT
+#endif
+#define xglViewport glViewport
+
+#ifdef GL_VERSION_1_1
+#define xglAreTexturesResident glAreTexturesResident
+#define xglIsTexture glIsTexture
+#define xglBindTexture glBindTexture
+#define xglDeleteTextures glDeleteTextures
+#define xglGenTextures glGenTextures
+#define xglPrioritizeTextures glPrioritizeTextures
+#endif
+
+#ifdef GL_EXT_texture_object
+#define xglAreTexturesResidentEXT glAreTexturesResidentEXT
+#define xglIsTextureEXT glIsTextureEXT
+#define xglBindTextureEXT glBindTextureEXT
+#define xglDeleteTexturesEXT glDeleteTexturesEXT
+#define xglGenTexturesEXT glGenTexturesEXT
+#define xglPrioritizeTexturesEXT glPrioritizeTexturesEXT
+#endif
+
+#define xglutAddMenuEntry glutAddMenuEntry
+#define xglutAttachMenu glutAttachMenu
+#define xglutCreateMenu glutCreateMenu
+#define xglutCreateWindow glutCreateWindow
+#define xglutDisplayFunc glutDisplayFunc
+#define xglutIdleFunc glutIdleFunc
+#define xglutInit glutInit
+#define xglutInitDisplayMode glutInitDisplayMode
+#define xglutInitWindowPosition glutInitWindowPosition
+#define xglutInitWindowSize glutInitWindowSize
+#define xglutKeyboardFunc glutKeyboardFunc
+#define xglutMainLoopUpdate glutMainLoopUpdate
+#define xglutPostRedisplay glutPostRedisplay
+#define xglutPreMainLoop glutPreMainLoop
+#define xglutReshapeFunc glutReshapeFunc
+#define xglutSwapBuffers glutSwapBuffers
+
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+GLboolean xglIsEnabled ( GLenum cap ) ;
+GLboolean xglIsList ( GLuint list ) ;
+GLenum xglGetError () ;
+GLint xglRenderMode ( GLenum mode ) ;
+GLuint xglGenLists ( GLsizei range ) ;
+const GLubyte *xglGetString ( GLenum name ) ;
+
+void xglAccum ( GLenum op, GLfloat value ) ;
+void xglAlphaFunc ( GLenum func, GLclampf ref ) ;
+void xglArrayElementEXT ( GLint i ) ;
+void xglBegin ( GLenum mode ) ;
+void xglBitmap ( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte *bitmap ) ;
+void xglBlendColorEXT ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
+void xglBlendEquationEXT( GLenum mode ) ;
+void xglBlendFunc ( GLenum sfactor, GLenum dfactor ) ;
+void xglCallList ( GLuint list ) ;
+void xglCallLists ( GLsizei n, GLenum type, GLvoid *lists ) ;
+void xglClear ( GLbitfield mask ) ;
+void xglClearAccum ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
+void xglClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) ;
+void xglClearDepth ( GLclampd depth ) ;
+void xglClearIndex ( GLfloat c ) ;
+void xglClearStencil ( GLint s ) ;
+void xglClipPlane ( GLenum plane, GLdouble *equation ) ;
+void xglColor3b ( GLbyte red, GLbyte green, GLbyte blue ) ;
+void xglColor3bv ( GLbyte *v ) ;
+void xglColor3d ( GLdouble red, GLdouble green, GLdouble blue ) ;
+void xglColor3dv ( GLdouble *v ) ;
+void xglColor3f ( GLfloat red, GLfloat green, GLfloat blue ) ;
+void xglColor3fv ( GLfloat *v ) ;
+void xglColor3i ( GLint red, GLint green, GLint blue ) ;
+void xglColor3iv ( GLint *v ) ;
+void xglColor3s ( GLshort red, GLshort green, GLshort blue ) ;
+void xglColor3sv ( GLshort *v ) ;
+void xglColor3ub ( GLubyte red, GLubyte green, GLubyte blue ) ;
+void xglColor3ubv ( GLubyte *v ) ;
+void xglColor3ui ( GLuint red, GLuint green, GLuint blue ) ;
+void xglColor3uiv ( GLuint *v ) ;
+void xglColor3us ( GLushort red, GLushort green, GLushort blue ) ;
+void xglColor3usv ( GLushort *v ) ;
+void xglColor4b ( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) ;
+void xglColor4bv ( GLbyte *v ) ;
+void xglColor4d ( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) ;
+void xglColor4dv ( GLdouble *v ) ;
+void xglColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) ;
+void xglColor4fv ( GLfloat *v ) ;
+void xglColor4i ( GLint red, GLint green, GLint blue, GLint alpha ) ;
+void xglColor4iv ( GLint *v ) ;
+void xglColor4s ( GLshort red, GLshort green, GLshort blue, GLshort alpha ) ;
+void xglColor4sv ( GLshort *v ) ;
+void xglColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) ;
+void xglColor4ubv ( GLubyte *v ) ;
+void xglColor4ui ( GLuint red, GLuint green, GLuint blue, GLuint alpha ) ;
+void xglColor4uiv ( GLuint *v ) ;
+void xglColor4us ( GLushort red, GLushort green, GLushort blue, GLushort alpha ) ;
+void xglColor4usv ( GLushort *v ) ;
+void xglColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) ;
+void xglColorMaterial ( GLenum face, GLenum mode ) ;
+void xglColorPointerEXT ( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglCopyPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) ;
+void xglCullFace ( GLenum mode ) ;
+void xglDeleteLists ( GLuint list, GLsizei range ) ;
+void xglDepthFunc ( GLenum func ) ;
+void xglDepthMask ( GLboolean flag ) ;
+void xglDepthRange ( GLclampd near_val, GLclampd far_val ) ;
+void xglDisable ( GLenum cap ) ;
+void xglDrawArraysEXT ( GLenum mode, GLint first, GLsizei count ) ;
+void xglDrawBuffer ( GLenum mode ) ;
+void xglDrawPixels ( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglEdgeFlag ( GLboolean flag ) ;
+void xglEdgeFlagPointerEXT( GLsizei stride, GLsizei count, GLboolean *ptr ) ;
+void xglEdgeFlagv ( GLboolean *flag ) ;
+void xglEnable ( GLenum cap ) ;
+void xglEnd () ;
+void xglEndList () ;
+void xglEvalCoord1d ( GLdouble u ) ;
+void xglEvalCoord1dv ( GLdouble *u ) ;
+void xglEvalCoord1f ( GLfloat u ) ;
+void xglEvalCoord1fv ( GLfloat *u ) ;
+void xglEvalCoord2d ( GLdouble u, GLdouble v ) ;
+void xglEvalCoord2dv ( GLdouble *u ) ;
+void xglEvalCoord2f ( GLfloat u, GLfloat v ) ;
+void xglEvalCoord2fv ( GLfloat *u ) ;
+void xglEvalMesh1 ( GLenum mode, GLint i1, GLint i2 ) ;
+void xglEvalMesh2 ( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) ;
+void xglEvalPoint1 ( GLint i ) ;
+void xglEvalPoint2 ( GLint i, GLint j ) ;
+void xglFeedbackBuffer ( GLsizei size, GLenum type, GLfloat *buffer ) ;
+void xglFinish () ;
+void xglFlush () ;
+void xglFogf ( GLenum pname, GLfloat param ) ;
+void xglFogfv ( GLenum pname, GLfloat *params ) ;
+void xglFogi ( GLenum pname, GLint param ) ;
+void xglFogiv ( GLenum pname, GLint *params ) ;
+void xglFrontFace ( GLenum mode ) ;
+void xglFrustum ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
+void xglGetBooleanv ( GLenum pname, GLboolean *params ) ;
+void xglGetClipPlane ( GLenum plane, GLdouble *equation ) ;
+void xglGetDoublev ( GLenum pname, GLdouble *params ) ;
+void xglGetFloatv ( GLenum pname, GLfloat *params ) ;
+void xglGetIntegerv ( GLenum pname, GLint *params ) ;
+void xglGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) ;
+void xglGetLightiv ( GLenum light, GLenum pname, GLint *params ) ;
+void xglGetMapdv ( GLenum target, GLenum query, GLdouble *v ) ;
+void xglGetMapfv ( GLenum target, GLenum query, GLfloat *v ) ;
+void xglGetMapiv ( GLenum target, GLenum query, GLint *v ) ;
+void xglGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) ;
+void xglGetMaterialiv ( GLenum face, GLenum pname, GLint *params ) ;
+void xglGetPixelMapfv ( GLenum map, GLfloat *values ) ;
+void xglGetPixelMapuiv ( GLenum map, GLuint *values ) ;
+void xglGetPixelMapusv ( GLenum map, GLushort *values ) ;
+void xglGetPointervEXT ( GLenum pname, void **params ) ;
+void xglGetPolygonStipple( GLubyte *mask ) ;
+void xglGetTexEnvfv ( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglGetTexEnviv ( GLenum target, GLenum pname, GLint *params ) ;
+void xglGetTexGendv ( GLenum coord, GLenum pname, GLdouble *params ) ;
+void xglGetTexGenfv ( GLenum coord, GLenum pname, GLfloat *params ) ;
+void xglGetTexGeniv ( GLenum coord, GLenum pname, GLint *params ) ;
+void xglGetTexImage ( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglGetTexLevelParameterfv ( GLenum target, GLint level, GLenum pname, GLfloat *params ) ;
+void xglGetTexLevelParameteriv ( GLenum target, GLint level, GLenum pname, GLint *params ) ;
+void xglGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params) ;
+void xglGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) ;
+void xglHint ( GLenum target, GLenum mode ) ;
+void xglIndexMask ( GLuint mask ) ;
+void xglIndexPointerEXT ( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglIndexd ( GLdouble c ) ;
+void xglIndexdv ( GLdouble *c ) ;
+void xglIndexf ( GLfloat c ) ;
+void xglIndexfv ( GLfloat *c ) ;
+void xglIndexi ( GLint c ) ;
+void xglIndexiv ( GLint *c ) ;
+void xglIndexs ( GLshort c ) ;
+void xglIndexsv ( GLshort *c ) ;
+void xglInitNames () ;
+void xglLightModelf ( GLenum pname, GLfloat param ) ;
+void xglLightModelfv ( GLenum pname, GLfloat *params ) ;
+void xglLightModeli ( GLenum pname, GLint param ) ;
+void xglLightModeliv ( GLenum pname, GLint *params ) ;
+void xglLightf ( GLenum light, GLenum pname, GLfloat param ) ;
+void xglLightfv ( GLenum light, GLenum pname, GLfloat *params ) ;
+void xglLighti ( GLenum light, GLenum pname, GLint param ) ;
+void xglLightiv ( GLenum light, GLenum pname, GLint *params ) ;
+void xglLineStipple ( GLint factor, GLushort pattern ) ;
+void xglLineWidth ( GLfloat width ) ;
+void xglListBase ( GLuint base ) ;
+void xglLoadIdentity () ;
+void xglLoadMatrixd ( GLdouble *m ) ;
+void xglLoadMatrixf ( GLfloat *m ) ;
+void xglLoadName ( GLuint name ) ;
+void xglLogicOp ( GLenum opcode ) ;
+void xglMap1d ( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble *points ) ;
+void xglMap1f ( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat *points ) ;
+void xglMap2d ( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble *points ) ;
+void xglMap2f ( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat *points ) ;
+void xglMapGrid1d ( GLint un, GLdouble u1, GLdouble u2 ) ;
+void xglMapGrid1f ( GLint un, GLfloat u1, GLfloat u2 ) ;
+void xglMapGrid2d ( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) ;
+void xglMapGrid2f ( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) ;
+void xglMaterialf ( GLenum face, GLenum pname, GLfloat param ) ;
+void xglMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) ;
+void xglMateriali ( GLenum face, GLenum pname, GLint param ) ;
+void xglMaterialiv ( GLenum face, GLenum pname, GLint *params ) ;
+void xglMatrixMode ( GLenum mode ) ;
+void xglMultMatrixd ( GLdouble *m ) ;
+void xglMultMatrixf ( GLfloat *m ) ;
+void xglNewList ( GLuint list, GLenum mode ) ;
+void xglNormal3b ( GLbyte nx, GLbyte ny, GLbyte nz ) ;
+void xglNormal3bv ( GLbyte *v ) ;
+void xglNormal3d ( GLdouble nx, GLdouble ny, GLdouble nz ) ;
+void xglNormal3dv ( GLdouble *v ) ;
+void xglNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) ;
+void xglNormal3fv ( GLfloat *v ) ;
+void xglNormal3i ( GLint nx, GLint ny, GLint nz ) ;
+void xglNormal3iv ( GLint *v ) ;
+void xglNormal3s ( GLshort nx, GLshort ny, GLshort nz ) ;
+void xglNormal3sv ( GLshort *v ) ;
+void xglNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglOrtho ( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) ;
+void xglPassThrough ( GLfloat token ) ;
+void xglPixelMapfv ( GLenum map, GLint mapsize, GLfloat *values ) ;
+void xglPixelMapuiv ( GLenum map, GLint mapsize, GLuint *values ) ;
+void xglPixelMapusv ( GLenum map, GLint mapsize, GLushort *values ) ;
+void xglPixelStoref ( GLenum pname, GLfloat param ) ;
+void xglPixelStorei ( GLenum pname, GLint param ) ;
+void xglPixelTransferf ( GLenum pname, GLfloat param ) ;
+void xglPixelTransferi ( GLenum pname, GLint param ) ;
+void xglPixelZoom ( GLfloat xfactor, GLfloat yfactor ) ;
+void xglPointSize ( GLfloat size ) ;
+void xglPolygonMode ( GLenum face, GLenum mode ) ;
+void xglPolygonOffsetEXT( GLfloat factor, GLfloat bias ) ;
+void xglPolygonOffset ( GLfloat factor, GLfloat bias ) ;
+void xglPolygonStipple ( GLubyte *mask ) ;
+void xglPopAttrib () ;
+void xglPopMatrix () ;
+void xglPopName () ;
+void xglPushAttrib ( GLbitfield mask ) ;
+void xglPushMatrix () ;
+void xglPushName ( GLuint name ) ;
+void xglRasterPos2d ( GLdouble x, GLdouble y ) ;
+void xglRasterPos2dv ( GLdouble *v ) ;
+void xglRasterPos2f ( GLfloat x, GLfloat y ) ;
+void xglRasterPos2fv ( GLfloat *v ) ;
+void xglRasterPos2i ( GLint x, GLint y ) ;
+void xglRasterPos2iv ( GLint *v ) ;
+void xglRasterPos2s ( GLshort x, GLshort y ) ;
+void xglRasterPos2sv ( GLshort *v ) ;
+void xglRasterPos3d ( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglRasterPos3dv ( GLdouble *v ) ;
+void xglRasterPos3f ( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglRasterPos3fv ( GLfloat *v ) ;
+void xglRasterPos3i ( GLint x, GLint y, GLint z ) ;
+void xglRasterPos3iv ( GLint *v ) ;
+void xglRasterPos3s ( GLshort x, GLshort y, GLshort z ) ;
+void xglRasterPos3sv ( GLshort *v ) ;
+void xglRasterPos4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
+void xglRasterPos4dv ( GLdouble *v ) ;
+void xglRasterPos4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
+void xglRasterPos4fv ( GLfloat *v ) ;
+void xglRasterPos4i ( GLint x, GLint y, GLint z, GLint w ) ;
+void xglRasterPos4iv ( GLint *v ) ;
+void xglRasterPos4s ( GLshort x, GLshort y, GLshort z, GLshort w ) ;
+void xglRasterPos4sv ( GLshort *v ) ;
+void xglReadBuffer ( GLenum mode ) ;
+void xglReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglRectd ( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) ;
+void xglRectdv ( GLdouble *v1, GLdouble *v2 ) ;
+void xglRectf ( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) ;
+void xglRectfv ( GLfloat *v1, GLfloat *v2 ) ;
+void xglRecti ( GLint x1, GLint y1, GLint x2, GLint y2 ) ;
+void xglRectiv ( GLint *v1, GLint *v2 ) ;
+void xglRects ( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) ;
+void xglRectsv ( GLshort *v1, GLshort *v2 ) ;
+void xglRotated ( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) ;
+void xglRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) ;
+void xglScaled ( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglScalef ( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglScissor ( GLint x, GLint y, GLsizei width, GLsizei height) ;
+void xglSelectBuffer ( GLsizei size, GLuint *buffer ) ;
+void xglShadeModel ( GLenum mode ) ;
+void xglStencilFunc ( GLenum func, GLint ref, GLuint mask ) ;
+void xglStencilMask ( GLuint mask ) ;
+void xglStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) ;
+void xglTexCoord1d ( GLdouble s ) ;
+void xglTexCoord1dv ( GLdouble *v ) ;
+void xglTexCoord1f ( GLfloat s ) ;
+void xglTexCoord1fv ( GLfloat *v ) ;
+void xglTexCoord1i ( GLint s ) ;
+void xglTexCoord1iv ( GLint *v ) ;
+void xglTexCoord1s ( GLshort s ) ;
+void xglTexCoord1sv ( GLshort *v ) ;
+void xglTexCoord2d ( GLdouble s, GLdouble t ) ;
+void xglTexCoord2dv ( GLdouble *v ) ;
+void xglTexCoord2f ( GLfloat s, GLfloat t ) ;
+void xglTexCoord2fv ( GLfloat *v ) ;
+void xglTexCoord2i ( GLint s, GLint t ) ;
+void xglTexCoord2iv ( GLint *v ) ;
+void xglTexCoord2s ( GLshort s, GLshort t ) ;
+void xglTexCoord2sv ( GLshort *v ) ;
+void xglTexCoord3d ( GLdouble s, GLdouble t, GLdouble r ) ;
+void xglTexCoord3dv ( GLdouble *v ) ;
+void xglTexCoord3f ( GLfloat s, GLfloat t, GLfloat r ) ;
+void xglTexCoord3fv ( GLfloat *v ) ;
+void xglTexCoord3i ( GLint s, GLint t, GLint r ) ;
+void xglTexCoord3iv ( GLint *v ) ;
+void xglTexCoord3s ( GLshort s, GLshort t, GLshort r ) ;
+void xglTexCoord3sv ( GLshort *v ) ;
+void xglTexCoord4d ( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) ;
+void xglTexCoord4dv ( GLdouble *v ) ;
+void xglTexCoord4f ( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) ;
+void xglTexCoord4fv ( GLfloat *v ) ;
+void xglTexCoord4i ( GLint s, GLint t, GLint r, GLint q ) ;
+void xglTexCoord4iv ( GLint *v ) ;
+void xglTexCoord4s ( GLshort s, GLshort t, GLshort r, GLshort q ) ;
+void xglTexCoord4sv ( GLshort *v ) ;
+void xglTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglTexEnvf ( GLenum target, GLenum pname, GLfloat param ) ;
+void xglTexEnvfv ( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglTexEnvi ( GLenum target, GLenum pname, GLint param ) ;
+void xglTexEnviv ( GLenum target, GLenum pname, GLint *params ) ;
+void xglTexGend ( GLenum coord, GLenum pname, GLdouble param ) ;
+void xglTexGendv ( GLenum coord, GLenum pname, GLdouble *params ) ;
+void xglTexGenf ( GLenum coord, GLenum pname, GLfloat param ) ;
+void xglTexGenfv ( GLenum coord, GLenum pname, GLfloat *params ) ;
+void xglTexGeni ( GLenum coord, GLenum pname, GLint param ) ;
+void xglTexGeniv ( GLenum coord, GLenum pname, GLint *params ) ;
+void xglTexImage1D ( GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglTexImage2D ( GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid *pixels ) ;
+void xglTexParameterf ( GLenum target, GLenum pname, GLfloat param ) ;
+void xglTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) ;
+void xglTexParameteri ( GLenum target, GLenum pname, GLint param ) ;
+void xglTexParameteriv ( GLenum target, GLenum pname, GLint *params ) ;
+void xglTranslated ( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglTranslatef ( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglVertex2d ( GLdouble x, GLdouble y ) ;
+void xglVertex2dv ( GLdouble *v ) ;
+void xglVertex2f ( GLfloat x, GLfloat y ) ;
+void xglVertex2fv ( GLfloat *v ) ;
+void xglVertex2i ( GLint x, GLint y ) ;
+void xglVertex2iv ( GLint *v ) ;
+void xglVertex2s ( GLshort x, GLshort y ) ;
+void xglVertex2sv ( GLshort *v ) ;
+void xglVertex3d ( GLdouble x, GLdouble y, GLdouble z ) ;
+void xglVertex3dv ( GLdouble *v ) ;
+void xglVertex3f ( GLfloat x, GLfloat y, GLfloat z ) ;
+void xglVertex3fv ( GLfloat *v ) ;
+void xglVertex3i ( GLint x, GLint y, GLint z ) ;
+void xglVertex3iv ( GLint *v ) ;
+void xglVertex3s ( GLshort x, GLshort y, GLshort z ) ;
+void xglVertex3sv ( GLshort *v ) ;
+void xglVertex4d ( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) ;
+void xglVertex4dv ( GLdouble *v ) ;
+void xglVertex4f ( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) ;
+void xglVertex4fv ( GLfloat *v ) ;
+void xglVertex4i ( GLint x, GLint y, GLint z, GLint w ) ;
+void xglVertex4iv ( GLint *v ) ;
+void xglVertex4s ( GLshort x, GLshort y, GLshort z, GLshort w ) ;
+void xglVertex4sv ( GLshort *v ) ;
+void xglVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, void *ptr ) ;
+void xglViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) ;
+
+void xglutAddMenuEntry ( char *label, int value ) ;
+void xglutAttachMenu ( int button ) ;
+int xglutCreateMenu ( void (*)(int) ) ;
+int xglutCreateWindow ( char *title ) ;
+void xglutDisplayFunc ( void (*)(void) ) ;
+void xglutIdleFunc ( void (*)(void) ) ;
+void xglutInit ( int *argcp, char **argv ) ;
+void xglutInitDisplayMode ( unsigned int mode ) ;
+void xglutInitWindowPosition ( int x, int y ) ;
+void xglutInitWindowSize ( int width, int height ) ;
+void xglutKeyboardFunc ( void (*)(unsigned char key, int x, int y) ) ;
+void xglutMainLoopUpdate () ;
+void xglutPostRedisplay () ;
+void xglutPreMainLoop () ;
+void xglutReshapeFunc ( void (*)(int width, int height) ) ;
+void xglutSwapBuffers () ;
+
+GLboolean xglAreTexturesResident( GLsizei n, GLuint *textures, GLboolean *residences ) ;
+GLboolean xglIsTexture ( GLuint texture ) ;
+void xglBindTexture ( GLenum target, GLuint texture ) ;
+void xglDeleteTextures ( GLsizei n, GLuint *textures ) ;
+void xglGenTextures ( GLsizei n, GLuint *textures ) ;
+void xglPrioritizeTextures ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
+
+GLboolean xglAreTexturesResidentEXT ( GLsizei n, GLuint *textures, GLboolean *residences ) ;
+GLboolean xglIsTextureEXT ( GLuint texture ) ;
+void xglBindTextureEXT ( GLenum target, GLuint texture ) ;
+void xglDeleteTexturesEXT ( GLsizei n, GLuint *textures ) ;
+void xglGenTexturesEXT ( GLsizei n, GLuint *textures ) ;
+void xglPrioritizeTexturesEXT ( GLsizei n, GLuint *textures, GLclampf *priorities ) ;
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif
+
--- /dev/null
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef __CYGWIN32__
+# include <malloc.h>
+#endif
+
+#ifdef WIN32
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+
+#include "xgl.h"
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+int xglTraceOn = TRUE ;
+FILE *xglTraceFd = stdout ;
+
+struct GLenumLookup
+{
+ GLenum val ;
+ char *name ;
+} ;
+
+static struct GLenumLookup glenum_string [] =
+{
+/*
+ Due to ambiguity - these are not in the table...
+
+ GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
+ GL_ONE = , GL_TRUE = GL_LINES = 1
+*/
+ { GL_2D ,"GL_2D" },
+ { GL_2_BYTES ,"GL_2_BYTES" },
+ { GL_3D ,"GL_3D" },
+ { GL_3D_COLOR ,"GL_3D_COLOR" },
+ { GL_3D_COLOR_TEXTURE ,"GL_3D_COLOR_TEXTURE" },
+ { GL_3_BYTES ,"GL_3_BYTES" },
+ { GL_4D_COLOR_TEXTURE ,"GL_4D_COLOR_TEXTURE" },
+ { GL_4_BYTES ,"GL_4_BYTES" },
+ { GL_ACCUM ,"GL_ACCUM" },
+ { GL_ACCUM_ALPHA_BITS ,"GL_ACCUM_ALPHA_BITS" },
+ { GL_ACCUM_BLUE_BITS ,"GL_ACCUM_BLUE_BITS" },
+ { GL_ACCUM_CLEAR_VALUE ,"GL_ACCUM_CLEAR_VALUE" },
+ { GL_ACCUM_GREEN_BITS ,"GL_ACCUM_GREEN_BITS" },
+ { GL_ACCUM_RED_BITS ,"GL_ACCUM_RED_BITS" },
+ { GL_ADD ,"GL_ADD" },
+ { GL_ALPHA ,"GL_ALPHA" },
+ { GL_ALPHA_BIAS ,"GL_ALPHA_BIAS" },
+ { GL_ALPHA_BITS ,"GL_ALPHA_BITS" },
+ { GL_ALPHA_SCALE ,"GL_ALPHA_SCALE" },
+ { GL_ALPHA_TEST ,"GL_ALPHA_TEST" },
+ { GL_ALPHA_TEST_FUNC ,"GL_ALPHA_TEST_FUNC" },
+ { GL_ALPHA_TEST_REF ,"GL_ALPHA_TEST_REF" },
+ { GL_ALWAYS ,"GL_ALWAYS" },
+ { GL_AMBIENT ,"GL_AMBIENT" },
+ { GL_AMBIENT_AND_DIFFUSE ,"GL_AMBIENT_AND_DIFFUSE" },
+ { GL_AND ,"GL_AND" },
+ { GL_AND_INVERTED ,"GL_AND_INVERTED" },
+ { GL_AND_REVERSE ,"GL_AND_REVERSE" },
+ { GL_ATTRIB_STACK_DEPTH ,"GL_ATTRIB_STACK_DEPTH" },
+ { GL_AUTO_NORMAL ,"GL_AUTO_NORMAL" },
+ { GL_AUX0 ,"GL_AUX0" },
+ { GL_AUX1 ,"GL_AUX1" },
+ { GL_AUX2 ,"GL_AUX2" },
+ { GL_AUX3 ,"GL_AUX3" },
+ { GL_AUX_BUFFERS ,"GL_AUX_BUFFERS" },
+ { GL_BACK ,"GL_BACK" },
+ { GL_BACK_LEFT ,"GL_BACK_LEFT" },
+ { GL_BACK_RIGHT ,"GL_BACK_RIGHT" },
+ { GL_BITMAP ,"GL_BITMAP" },
+ { GL_BITMAP_TOKEN ,"GL_BITMAP_TOKEN" },
+ { GL_BLEND ,"GL_BLEND" },
+ { GL_BLEND_DST ,"GL_BLEND_DST" },
+#ifdef GL_BLEND_COLOR_EXT
+ { GL_BLEND_COLOR_EXT ,"GL_BLEND_COLOR_EXT" },
+#endif
+#ifdef GL_BLEND_EQUATION_EXT
+ { GL_BLEND_EQUATION_EXT ,"GL_BLEND_EQUATION_EXT" },
+#endif
+ { GL_BLEND_SRC ,"GL_BLEND_SRC" },
+ { GL_BLUE ,"GL_BLUE" },
+ { GL_BLUE_BIAS ,"GL_BLUE_BIAS" },
+ { GL_BLUE_BITS ,"GL_BLUE_BITS" },
+ { GL_BLUE_SCALE ,"GL_BLUE_SCALE" },
+ { GL_BYTE ,"GL_BYTE" },
+ { GL_CCW ,"GL_CCW" },
+ { GL_CLAMP ,"GL_CLAMP" },
+ { GL_CLEAR ,"GL_CLEAR" },
+ { GL_CLIP_PLANE0 ,"GL_CLIP_PLANE0" },
+ { GL_CLIP_PLANE1 ,"GL_CLIP_PLANE1" },
+ { GL_CLIP_PLANE2 ,"GL_CLIP_PLANE2" },
+ { GL_CLIP_PLANE3 ,"GL_CLIP_PLANE3" },
+ { GL_CLIP_PLANE4 ,"GL_CLIP_PLANE4" },
+ { GL_CLIP_PLANE5 ,"GL_CLIP_PLANE5" },
+ { GL_COEFF ,"GL_COEFF" },
+ { GL_COLOR ,"GL_COLOR" },
+#ifdef GL_COLOR_ARRAY_EXT
+ { GL_COLOR_ARRAY_COUNT_EXT ,"GL_COLOR_ARRAY_COUNT_EXT" },
+ { GL_COLOR_ARRAY_EXT ,"GL_COLOR_ARRAY_EXT" },
+ { GL_COLOR_ARRAY_POINTER_EXT ,"GL_COLOR_ARRAY_POINTER_EXT" },
+ { GL_COLOR_ARRAY_SIZE_EXT ,"GL_COLOR_ARRAY_SIZE_EXT" },
+ { GL_COLOR_ARRAY_STRIDE_EXT ,"GL_COLOR_ARRAY_STRIDE_EXT" },
+ { GL_COLOR_ARRAY_TYPE_EXT ,"GL_COLOR_ARRAY_TYPE_EXT" },
+#endif
+ { GL_COLOR_CLEAR_VALUE ,"GL_COLOR_CLEAR_VALUE" },
+ { GL_COLOR_INDEX ,"GL_COLOR_INDEX" },
+ { GL_COLOR_INDEXES ,"GL_COLOR_INDEXES" },
+ { GL_COLOR_MATERIAL ,"GL_COLOR_MATERIAL" },
+ { GL_COLOR_MATERIAL_FACE ,"GL_COLOR_MATERIAL_FACE" },
+ { GL_COLOR_MATERIAL_PARAMETER ,"GL_COLOR_MATERIAL_PARAMETER" },
+ { GL_COLOR_WRITEMASK ,"GL_COLOR_WRITEMASK" },
+ { GL_COMPILE ,"GL_COMPILE" },
+ { GL_COMPILE_AND_EXECUTE ,"GL_COMPILE_AND_EXECUTE" },
+#ifdef GL_CONSTANT_ALPHA_EXT
+ { GL_CONSTANT_ALPHA_EXT ,"GL_CONSTANT_ALPHA_EXT" },
+#endif
+ { GL_CONSTANT_ATTENUATION ,"GL_CONSTANT_ATTENUATION" },
+#ifdef GL_CONSTANT_COLOR_EXT
+ { GL_CONSTANT_COLOR_EXT ,"GL_CONSTANT_COLOR_EXT" },
+#endif
+ { GL_COPY ,"GL_COPY" },
+ { GL_COPY_INVERTED ,"GL_COPY_INVERTED" },
+ { GL_COPY_PIXEL_TOKEN ,"GL_COPY_PIXEL_TOKEN" },
+ { GL_CULL_FACE ,"GL_CULL_FACE" },
+ { GL_CULL_FACE_MODE ,"GL_CULL_FACE_MODE" },
+ { GL_CURRENT_COLOR ,"GL_CURRENT_COLOR" },
+ { GL_CURRENT_INDEX ,"GL_CURRENT_INDEX" },
+ { GL_CURRENT_NORMAL ,"GL_CURRENT_NORMAL" },
+ { GL_CURRENT_RASTER_COLOR ,"GL_CURRENT_RASTER_COLOR" },
+ { GL_CURRENT_RASTER_DISTANCE ,"GL_CURRENT_RASTER_DISTANCE" },
+ { GL_CURRENT_RASTER_INDEX ,"GL_CURRENT_RASTER_INDEX" },
+ { GL_CURRENT_RASTER_POSITION ,"GL_CURRENT_RASTER_POSITION" },
+ { GL_CURRENT_RASTER_POSITION_VALID,"GL_CURRENT_RASTER_POSITION_VALID" },
+ { GL_CURRENT_RASTER_TEXTURE_COORDS,"GL_CURRENT_RASTER_TEXTURE_COORDS" },
+ { GL_CURRENT_TEXTURE_COORDS ,"GL_CURRENT_TEXTURE_COORDS" },
+ { GL_CW ,"GL_CW" },
+ { GL_DECAL ,"GL_DECAL" },
+ { GL_DECR ,"GL_DECR" },
+ { GL_DEPTH ,"GL_DEPTH" },
+ { GL_DEPTH_BIAS ,"GL_DEPTH_BIAS" },
+ { GL_DEPTH_BITS ,"GL_DEPTH_BITS" },
+ { GL_DEPTH_CLEAR_VALUE ,"GL_DEPTH_CLEAR_VALUE" },
+ { GL_DEPTH_COMPONENT ,"GL_DEPTH_COMPONENT" },
+ { GL_DEPTH_FUNC ,"GL_DEPTH_FUNC" },
+ { GL_DEPTH_RANGE ,"GL_DEPTH_RANGE" },
+ { GL_DEPTH_SCALE ,"GL_DEPTH_SCALE" },
+ { GL_DEPTH_TEST ,"GL_DEPTH_TEST" },
+ { GL_DEPTH_WRITEMASK ,"GL_DEPTH_WRITEMASK" },
+ { GL_DIFFUSE ,"GL_DIFFUSE" },
+ { GL_DITHER ,"GL_DITHER" },
+ { GL_DOMAIN ,"GL_DOMAIN" },
+ { GL_DONT_CARE ,"GL_DONT_CARE" },
+ { GL_DOUBLEBUFFER ,"GL_DOUBLEBUFFER" },
+#ifdef GL_DOUBLE_EXT
+ { GL_DOUBLE_EXT ,"GL_DOUBLE_EXT" },
+#endif
+ { GL_DRAW_BUFFER ,"GL_DRAW_BUFFER" },
+ { GL_DRAW_PIXEL_TOKEN ,"GL_DRAW_PIXEL_TOKEN" },
+ { GL_DST_ALPHA ,"GL_DST_ALPHA" },
+ { GL_DST_COLOR ,"GL_DST_COLOR" },
+ { GL_EDGE_FLAG ,"GL_EDGE_FLAG" },
+#ifdef GL_EDGE_FLAG_ARRAY_EXT
+ { GL_EDGE_FLAG_ARRAY_COUNT_EXT,"GL_EDGE_FLAG_ARRAY_COUNT_EXT" },
+ { GL_EDGE_FLAG_ARRAY_EXT ,"GL_EDGE_FLAG_ARRAY_EXT" },
+ { GL_EDGE_FLAG_ARRAY_POINTER_EXT,"GL_EDGE_FLAG_ARRAY_POINTER_EXT" },
+ { GL_EDGE_FLAG_ARRAY_STRIDE_EXT,"GL_EDGE_FLAG_ARRAY_STRIDE_EXT" },
+#endif
+ { GL_EMISSION ,"GL_EMISSION" },
+ { GL_EQUAL ,"GL_EQUAL" },
+ { GL_EQUIV ,"GL_EQUIV" },
+ { GL_EXP ,"GL_EXP" },
+ { GL_EXP2 ,"GL_EXP2" },
+ { GL_EXTENSIONS ,"GL_EXTENSIONS" },
+ { GL_EYE_LINEAR ,"GL_EYE_LINEAR" },
+ { GL_EYE_PLANE ,"GL_EYE_PLANE" },
+ { GL_FASTEST ,"GL_FASTEST" },
+ { GL_FEEDBACK ,"GL_FEEDBACK" },
+ { GL_FILL ,"GL_FILL" },
+ { GL_FLAT ,"GL_FLAT" },
+ { GL_FLOAT ,"GL_FLOAT" },
+ { GL_FOG ,"GL_FOG" },
+ { GL_FOG_COLOR ,"GL_FOG_COLOR" },
+ { GL_FOG_DENSITY ,"GL_FOG_DENSITY" },
+ { GL_FOG_END ,"GL_FOG_END" },
+ { GL_FOG_HINT ,"GL_FOG_HINT" },
+ { GL_FOG_INDEX ,"GL_FOG_INDEX" },
+ { GL_FOG_MODE ,"GL_FOG_MODE" },
+ { GL_FOG_START ,"GL_FOG_START" },
+ { GL_FRONT ,"GL_FRONT" },
+ { GL_FRONT_AND_BACK ,"GL_FRONT_AND_BACK" },
+ { GL_FRONT_FACE ,"GL_FRONT_FACE" },
+ { GL_FRONT_LEFT ,"GL_FRONT_LEFT" },
+ { GL_FRONT_RIGHT ,"GL_FRONT_RIGHT" },
+#ifdef GL_FUNC_ADD_EXT
+ { GL_FUNC_ADD_EXT ,"GL_FUNC_ADD_EXT" },
+ { GL_FUNC_REVERSE_SUBTRACT_EXT,"GL_FUNC_REVERSE_SUBTRACT_EXT" },
+ { GL_FUNC_SUBTRACT_EXT ,"GL_FUNC_SUBTRACT_EXT" },
+#endif
+ { GL_GEQUAL ,"GL_GEQUAL" },
+ { GL_GREATER ,"GL_GREATER" },
+ { GL_GREEN ,"GL_GREEN" },
+ { GL_GREEN_BIAS ,"GL_GREEN_BIAS" },
+ { GL_GREEN_BITS ,"GL_GREEN_BITS" },
+ { GL_GREEN_SCALE ,"GL_GREEN_SCALE" },
+ { GL_INCR ,"GL_INCR" },
+#ifdef GL_INDEX_ARRAY_EXT
+ { GL_INDEX_ARRAY_COUNT_EXT ,"GL_INDEX_ARRAY_COUNT_EXT" },
+ { GL_INDEX_ARRAY_EXT ,"GL_INDEX_ARRAY_EXT" },
+ { GL_INDEX_ARRAY_POINTER_EXT ,"GL_INDEX_ARRAY_POINTER_EXT" },
+ { GL_INDEX_ARRAY_STRIDE_EXT ,"GL_INDEX_ARRAY_STRIDE_EXT" },
+ { GL_INDEX_ARRAY_TYPE_EXT ,"GL_INDEX_ARRAY_TYPE_EXT" },
+#endif
+ { GL_INDEX_BITS ,"GL_INDEX_BITS" },
+ { GL_INDEX_CLEAR_VALUE ,"GL_INDEX_CLEAR_VALUE" },
+ { GL_INDEX_MODE ,"GL_INDEX_MODE" },
+ { GL_INDEX_OFFSET ,"GL_INDEX_OFFSET" },
+ { GL_INDEX_SHIFT ,"GL_INDEX_SHIFT" },
+ { GL_INDEX_WRITEMASK ,"GL_INDEX_WRITEMASK" },
+ { GL_INT ,"GL_INT" },
+ { GL_INVALID_ENUM ,"GL_INVALID_ENUM" },
+ { GL_INVALID_OPERATION ,"GL_INVALID_OPERATION" },
+ { GL_INVALID_VALUE ,"GL_INVALID_VALUE" },
+ { GL_INVERT ,"GL_INVERT" },
+ { GL_KEEP ,"GL_KEEP" },
+ { GL_LEFT ,"GL_LEFT" },
+ { GL_LEQUAL ,"GL_LEQUAL" },
+ { GL_LESS ,"GL_LESS" },
+ { GL_LIGHT0 ,"GL_LIGHT0" },
+ { GL_LIGHT1 ,"GL_LIGHT1" },
+ { GL_LIGHT2 ,"GL_LIGHT2" },
+ { GL_LIGHT3 ,"GL_LIGHT3" },
+ { GL_LIGHT4 ,"GL_LIGHT4" },
+ { GL_LIGHT5 ,"GL_LIGHT5" },
+ { GL_LIGHT6 ,"GL_LIGHT6" },
+ { GL_LIGHT7 ,"GL_LIGHT7" },
+ { GL_LIGHTING ,"GL_LIGHTING" },
+ { GL_LIGHT_MODEL_AMBIENT ,"GL_LIGHT_MODEL_AMBIENT" },
+ { GL_LIGHT_MODEL_LOCAL_VIEWER ,"GL_LIGHT_MODEL_LOCAL_VIEWER" },
+ { GL_LIGHT_MODEL_TWO_SIDE ,"GL_LIGHT_MODEL_TWO_SIDE" },
+ { GL_LINE ,"GL_LINE" },
+ { GL_LINEAR ,"GL_LINEAR" },
+ { GL_LINEAR_ATTENUATION ,"GL_LINEAR_ATTENUATION" },
+ { GL_LINEAR_MIPMAP_LINEAR ,"GL_LINEAR_MIPMAP_LINEAR" },
+ { GL_LINEAR_MIPMAP_NEAREST ,"GL_LINEAR_MIPMAP_NEAREST" },
+ { GL_LINE_LOOP ,"GL_LINE_LOOP" },
+ { GL_LINE_RESET_TOKEN ,"GL_LINE_RESET_TOKEN" },
+ { GL_LINE_SMOOTH ,"GL_LINE_SMOOTH" },
+ { GL_LINE_SMOOTH_HINT ,"GL_LINE_SMOOTH_HINT" },
+ { GL_LINE_STIPPLE ,"GL_LINE_STIPPLE" },
+ { GL_LINE_STIPPLE_PATTERN ,"GL_LINE_STIPPLE_PATTERN" },
+ { GL_LINE_STIPPLE_REPEAT ,"GL_LINE_STIPPLE_REPEAT" },
+ { GL_LINE_STRIP ,"GL_LINE_STRIP" },
+ { GL_LINE_TOKEN ,"GL_LINE_TOKEN" },
+ { GL_LINE_WIDTH ,"GL_LINE_WIDTH" },
+ { GL_LINE_WIDTH_GRANULARITY ,"GL_LINE_WIDTH_GRANULARITY" },
+ { GL_LINE_WIDTH_RANGE ,"GL_LINE_WIDTH_RANGE" },
+ { GL_LIST_BASE ,"GL_LIST_BASE" },
+ { GL_LIST_INDEX ,"GL_LIST_INDEX" },
+ { GL_LIST_MODE ,"GL_LIST_MODE" },
+ { GL_LOAD ,"GL_LOAD" },
+ { GL_LOGIC_OP ,"GL_LOGIC_OP" },
+ { GL_LOGIC_OP_MODE ,"GL_LOGIC_OP_MODE" },
+ { GL_LUMINANCE ,"GL_LUMINANCE" },
+ { GL_LUMINANCE_ALPHA ,"GL_LUMINANCE_ALPHA" },
+ { GL_MAP1_COLOR_4 ,"GL_MAP1_COLOR_4" },
+ { GL_MAP1_GRID_DOMAIN ,"GL_MAP1_GRID_DOMAIN" },
+ { GL_MAP1_GRID_SEGMENTS ,"GL_MAP1_GRID_SEGMENTS" },
+ { GL_MAP1_INDEX ,"GL_MAP1_INDEX" },
+ { GL_MAP1_NORMAL ,"GL_MAP1_NORMAL" },
+ { GL_MAP1_TEXTURE_COORD_1 ,"GL_MAP1_TEXTURE_COORD_1" },
+ { GL_MAP1_TEXTURE_COORD_2 ,"GL_MAP1_TEXTURE_COORD_2" },
+ { GL_MAP1_TEXTURE_COORD_3 ,"GL_MAP1_TEXTURE_COORD_3" },
+ { GL_MAP1_TEXTURE_COORD_4 ,"GL_MAP1_TEXTURE_COORD_4" },
+ { GL_MAP1_VERTEX_3 ,"GL_MAP1_VERTEX_3" },
+ { GL_MAP1_VERTEX_4 ,"GL_MAP1_VERTEX_4" },
+ { GL_MAP2_COLOR_4 ,"GL_MAP2_COLOR_4" },
+ { GL_MAP2_GRID_DOMAIN ,"GL_MAP2_GRID_DOMAIN" },
+ { GL_MAP2_GRID_SEGMENTS ,"GL_MAP2_GRID_SEGMENTS" },
+ { GL_MAP2_INDEX ,"GL_MAP2_INDEX" },
+ { GL_MAP2_NORMAL ,"GL_MAP2_NORMAL" },
+ { GL_MAP2_TEXTURE_COORD_1 ,"GL_MAP2_TEXTURE_COORD_1" },
+ { GL_MAP2_TEXTURE_COORD_2 ,"GL_MAP2_TEXTURE_COORD_2" },
+ { GL_MAP2_TEXTURE_COORD_3 ,"GL_MAP2_TEXTURE_COORD_3" },
+ { GL_MAP2_TEXTURE_COORD_4 ,"GL_MAP2_TEXTURE_COORD_4" },
+ { GL_MAP2_VERTEX_3 ,"GL_MAP2_VERTEX_3" },
+ { GL_MAP2_VERTEX_4 ,"GL_MAP2_VERTEX_4" },
+ { GL_MAP_COLOR ,"GL_MAP_COLOR" },
+ { GL_MAP_STENCIL ,"GL_MAP_STENCIL" },
+ { GL_MATRIX_MODE ,"GL_MATRIX_MODE" },
+ { GL_MAX_ATTRIB_STACK_DEPTH ,"GL_MAX_ATTRIB_STACK_DEPTH" },
+ { GL_MAX_CLIP_PLANES ,"GL_MAX_CLIP_PLANES" },
+ { GL_MAX_EVAL_ORDER ,"GL_MAX_EVAL_ORDER" },
+#ifdef GL_MAX_EXT
+ { GL_MAX_EXT ,"GL_MAX_EXT" },
+#endif
+ { GL_MAX_LIGHTS ,"GL_MAX_LIGHTS" },
+ { GL_MAX_LIST_NESTING ,"GL_MAX_LIST_NESTING" },
+ { GL_MAX_MODELVIEW_STACK_DEPTH,"GL_MAX_MODELVIEW_STACK_DEPTH" },
+ { GL_MAX_NAME_STACK_DEPTH ,"GL_MAX_NAME_STACK_DEPTH" },
+ { GL_MAX_PIXEL_MAP_TABLE ,"GL_MAX_PIXEL_MAP_TABLE" },
+ { GL_MAX_PROJECTION_STACK_DEPTH,"GL_MAX_PROJECTION_STACK_DEPTH" },
+ { GL_MAX_TEXTURE_SIZE ,"GL_MAX_TEXTURE_SIZE" },
+ { GL_MAX_TEXTURE_STACK_DEPTH ,"GL_MAX_TEXTURE_STACK_DEPTH" },
+ { GL_MAX_VIEWPORT_DIMS ,"GL_MAX_VIEWPORT_DIMS" },
+#ifdef GL_MIN_EXT
+ { GL_MIN_EXT ,"GL_MIN_EXT" },
+#endif
+ { GL_MODELVIEW ,"GL_MODELVIEW" },
+ { GL_MODELVIEW_MATRIX ,"GL_MODELVIEW_MATRIX" },
+ { GL_MODELVIEW_STACK_DEPTH ,"GL_MODELVIEW_STACK_DEPTH" },
+ { GL_MODULATE ,"GL_MODULATE" },
+ { GL_MULT ,"GL_MULT" },
+ { GL_NAME_STACK_DEPTH ,"GL_NAME_STACK_DEPTH" },
+ { GL_NAND ,"GL_NAND" },
+ { GL_NEAREST ,"GL_NEAREST" },
+ { GL_NEAREST_MIPMAP_LINEAR ,"GL_NEAREST_MIPMAP_LINEAR" },
+ { GL_NEAREST_MIPMAP_NEAREST ,"GL_NEAREST_MIPMAP_NEAREST" },
+ { GL_NEVER ,"GL_NEVER" },
+ { GL_NICEST ,"GL_NICEST" },
+ { GL_NOOP ,"GL_NOOP" },
+ { GL_NOR ,"GL_NOR" },
+ { GL_NORMALIZE ,"GL_NORMALIZE" },
+#ifdef GL_NORMAL_ARRAY_EXT
+ { GL_NORMAL_ARRAY_COUNT_EXT ,"GL_NORMAL_ARRAY_COUNT_EXT" },
+ { GL_NORMAL_ARRAY_EXT ,"GL_NORMAL_ARRAY_EXT" },
+ { GL_NORMAL_ARRAY_POINTER_EXT ,"GL_NORMAL_ARRAY_POINTER_EXT" },
+ { GL_NORMAL_ARRAY_STRIDE_EXT ,"GL_NORMAL_ARRAY_STRIDE_EXT" },
+ { GL_NORMAL_ARRAY_TYPE_EXT ,"GL_NORMAL_ARRAY_TYPE_EXT" },
+#endif
+ { GL_NOTEQUAL ,"GL_NOTEQUAL" },
+ { GL_OBJECT_LINEAR ,"GL_OBJECT_LINEAR" },
+ { GL_OBJECT_PLANE ,"GL_OBJECT_PLANE" },
+#ifdef GL_ONE_MINUS_CONSTANT_ALPHA_EXT
+ { GL_ONE_MINUS_CONSTANT_ALPHA_EXT,"GL_ONE_MINUS_CONSTANT_ALPHA_EXT" },
+ { GL_ONE_MINUS_CONSTANT_COLOR_EXT,"GL_ONE_MINUS_CONSTANT_COLOR_EXT" },
+#endif
+ { GL_ONE_MINUS_DST_ALPHA ,"GL_ONE_MINUS_DST_ALPHA" },
+ { GL_ONE_MINUS_DST_COLOR ,"GL_ONE_MINUS_DST_COLOR" },
+ { GL_ONE_MINUS_SRC_ALPHA ,"GL_ONE_MINUS_SRC_ALPHA" },
+ { GL_ONE_MINUS_SRC_COLOR ,"GL_ONE_MINUS_SRC_COLOR" },
+ { GL_OR ,"GL_OR" },
+ { GL_ORDER ,"GL_ORDER" },
+ { GL_OR_INVERTED ,"GL_OR_INVERTED" },
+ { GL_OR_REVERSE ,"GL_OR_REVERSE" },
+ { GL_OUT_OF_MEMORY ,"GL_OUT_OF_MEMORY" },
+ { GL_PACK_ALIGNMENT ,"GL_PACK_ALIGNMENT" },
+ { GL_PACK_LSB_FIRST ,"GL_PACK_LSB_FIRST" },
+ { GL_PACK_ROW_LENGTH ,"GL_PACK_ROW_LENGTH" },
+ { GL_PACK_SKIP_PIXELS ,"GL_PACK_SKIP_PIXELS" },
+ { GL_PACK_SKIP_ROWS ,"GL_PACK_SKIP_ROWS" },
+ { GL_PACK_SWAP_BYTES ,"GL_PACK_SWAP_BYTES" },
+ { GL_PASS_THROUGH_TOKEN ,"GL_PASS_THROUGH_TOKEN" },
+ { GL_PERSPECTIVE_CORRECTION_HINT,"GL_PERSPECTIVE_CORRECTION_HINT" },
+ { GL_PIXEL_MAP_A_TO_A ,"GL_PIXEL_MAP_A_TO_A" },
+ { GL_PIXEL_MAP_A_TO_A_SIZE ,"GL_PIXEL_MAP_A_TO_A_SIZE" },
+ { GL_PIXEL_MAP_B_TO_B ,"GL_PIXEL_MAP_B_TO_B" },
+ { GL_PIXEL_MAP_B_TO_B_SIZE ,"GL_PIXEL_MAP_B_TO_B_SIZE" },
+ { GL_PIXEL_MAP_G_TO_G ,"GL_PIXEL_MAP_G_TO_G" },
+ { GL_PIXEL_MAP_G_TO_G_SIZE ,"GL_PIXEL_MAP_G_TO_G_SIZE" },
+ { GL_PIXEL_MAP_I_TO_A ,"GL_PIXEL_MAP_I_TO_A" },
+ { GL_PIXEL_MAP_I_TO_A_SIZE ,"GL_PIXEL_MAP_I_TO_A_SIZE" },
+ { GL_PIXEL_MAP_I_TO_B ,"GL_PIXEL_MAP_I_TO_B" },
+ { GL_PIXEL_MAP_I_TO_B_SIZE ,"GL_PIXEL_MAP_I_TO_B_SIZE" },
+ { GL_PIXEL_MAP_I_TO_G ,"GL_PIXEL_MAP_I_TO_G" },
+ { GL_PIXEL_MAP_I_TO_G_SIZE ,"GL_PIXEL_MAP_I_TO_G_SIZE" },
+ { GL_PIXEL_MAP_I_TO_I ,"GL_PIXEL_MAP_I_TO_I" },
+ { GL_PIXEL_MAP_I_TO_I_SIZE ,"GL_PIXEL_MAP_I_TO_I_SIZE" },
+ { GL_PIXEL_MAP_I_TO_R ,"GL_PIXEL_MAP_I_TO_R" },
+ { GL_PIXEL_MAP_I_TO_R_SIZE ,"GL_PIXEL_MAP_I_TO_R_SIZE" },
+ { GL_PIXEL_MAP_R_TO_R ,"GL_PIXEL_MAP_R_TO_R" },
+ { GL_PIXEL_MAP_R_TO_R_SIZE ,"GL_PIXEL_MAP_R_TO_R_SIZE" },
+ { GL_PIXEL_MAP_S_TO_S ,"GL_PIXEL_MAP_S_TO_S" },
+ { GL_PIXEL_MAP_S_TO_S_SIZE ,"GL_PIXEL_MAP_S_TO_S_SIZE" },
+ { GL_POINT ,"GL_POINT" },
+ { GL_POINT_SIZE ,"GL_POINT_SIZE" },
+ { GL_POINT_SIZE_GRANULARITY ,"GL_POINT_SIZE_GRANULARITY" },
+ { GL_POINT_SIZE_RANGE ,"GL_POINT_SIZE_RANGE" },
+ { GL_POINT_SMOOTH ,"GL_POINT_SMOOTH" },
+ { GL_POINT_SMOOTH_HINT ,"GL_POINT_SMOOTH_HINT" },
+ { GL_POINT_TOKEN ,"GL_POINT_TOKEN" },
+ { GL_POLYGON ,"GL_POLYGON" },
+ { GL_POLYGON_MODE ,"GL_POLYGON_MODE" },
+ { GL_POLYGON_SMOOTH ,"GL_POLYGON_SMOOTH" },
+ { GL_POLYGON_SMOOTH_HINT ,"GL_POLYGON_SMOOTH_HINT" },
+ { GL_POLYGON_STIPPLE ,"GL_POLYGON_STIPPLE" },
+#ifdef GL_POLYGON_OFFSET_EXT
+ { GL_POLYGON_OFFSET_BIAS_EXT ,"GL_POLYGON_OFFSET_BIAS_EXT" },
+ { GL_POLYGON_OFFSET_EXT ,"GL_POLYGON_OFFSET_EXT" },
+ { GL_POLYGON_OFFSET_FACTOR_EXT,"GL_POLYGON_OFFSET_FACTOR_EXT" },
+#endif
+ { GL_POLYGON_TOKEN ,"GL_POLYGON_TOKEN" },
+ { GL_POSITION ,"GL_POSITION" },
+ { GL_PROJECTION ,"GL_PROJECTION" },
+ { GL_PROJECTION_MATRIX ,"GL_PROJECTION_MATRIX" },
+ { GL_PROJECTION_STACK_DEPTH ,"GL_PROJECTION_STACK_DEPTH" },
+ { GL_Q ,"GL_Q" },
+ { GL_QUADRATIC_ATTENUATION ,"GL_QUADRATIC_ATTENUATION" },
+ { GL_QUADS ,"GL_QUADS" },
+ { GL_QUAD_STRIP ,"GL_QUAD_STRIP" },
+ { GL_R ,"GL_R" },
+ { GL_READ_BUFFER ,"GL_READ_BUFFER" },
+ { GL_RED ,"GL_RED" },
+ { GL_RED_BIAS ,"GL_RED_BIAS" },
+ { GL_RED_BITS ,"GL_RED_BITS" },
+ { GL_RED_SCALE ,"GL_RED_SCALE" },
+ { GL_RENDER ,"GL_RENDER" },
+ { GL_RENDERER ,"GL_RENDERER" },
+ { GL_RENDER_MODE ,"GL_RENDER_MODE" },
+ { GL_REPEAT ,"GL_REPEAT" },
+ { GL_REPLACE ,"GL_REPLACE" },
+#ifdef GL_REPLACE_EXT
+ { GL_REPLACE_EXT ,"GL_REPLACE_EXT" },
+#endif
+ { GL_RETURN ,"GL_RETURN" },
+ { GL_RGB ,"GL_RGB" },
+ { GL_RGBA ,"GL_RGBA" },
+ { GL_RGBA_MODE ,"GL_RGBA_MODE" },
+ { GL_RIGHT ,"GL_RIGHT" },
+ { GL_S ,"GL_S" },
+ { GL_SCISSOR_BOX ,"GL_SCISSOR_BOX" },
+ { GL_SCISSOR_TEST ,"GL_SCISSOR_TEST" },
+ { GL_SELECT ,"GL_SELECT" },
+ { GL_SET ,"GL_SET" },
+ { GL_SHADE_MODEL ,"GL_SHADE_MODEL" },
+ { GL_SHININESS ,"GL_SHININESS" },
+ { GL_SHORT ,"GL_SHORT" },
+ { GL_SMOOTH ,"GL_SMOOTH" },
+ { GL_SPECULAR ,"GL_SPECULAR" },
+ { GL_SPHERE_MAP ,"GL_SPHERE_MAP" },
+ { GL_SPOT_CUTOFF ,"GL_SPOT_CUTOFF" },
+ { GL_SPOT_DIRECTION ,"GL_SPOT_DIRECTION" },
+ { GL_SPOT_EXPONENT ,"GL_SPOT_EXPONENT" },
+ { GL_SRC_ALPHA ,"GL_SRC_ALPHA" },
+ { GL_SRC_ALPHA_SATURATE ,"GL_SRC_ALPHA_SATURATE" },
+ { GL_SRC_COLOR ,"GL_SRC_COLOR" },
+ { GL_STACK_OVERFLOW ,"GL_STACK_OVERFLOW" },
+ { GL_STACK_UNDERFLOW ,"GL_STACK_UNDERFLOW" },
+ { GL_STENCIL ,"GL_STENCIL" },
+ { GL_STENCIL_BITS ,"GL_STENCIL_BITS" },
+ { GL_STENCIL_CLEAR_VALUE ,"GL_STENCIL_CLEAR_VALUE" },
+ { GL_STENCIL_FAIL ,"GL_STENCIL_FAIL" },
+ { GL_STENCIL_FUNC ,"GL_STENCIL_FUNC" },
+ { GL_STENCIL_INDEX ,"GL_STENCIL_INDEX" },
+ { GL_STENCIL_PASS_DEPTH_FAIL ,"GL_STENCIL_PASS_DEPTH_FAIL" },
+ { GL_STENCIL_PASS_DEPTH_PASS ,"GL_STENCIL_PASS_DEPTH_PASS" },
+ { GL_STENCIL_REF ,"GL_STENCIL_REF" },
+ { GL_STENCIL_TEST ,"GL_STENCIL_TEST" },
+ { GL_STENCIL_VALUE_MASK ,"GL_STENCIL_VALUE_MASK" },
+ { GL_STENCIL_WRITEMASK ,"GL_STENCIL_WRITEMASK" },
+ { GL_STEREO ,"GL_STEREO" },
+ { GL_SUBPIXEL_BITS ,"GL_SUBPIXEL_BITS" },
+ { GL_T ,"GL_T" },
+ { GL_TEXTURE ,"GL_TEXTURE" },
+ { GL_TEXTURE_1D ,"GL_TEXTURE_1D" },
+ { GL_TEXTURE_2D ,"GL_TEXTURE_2D" },
+ { GL_TEXTURE_BORDER ,"GL_TEXTURE_BORDER" },
+ { GL_TEXTURE_BORDER_COLOR ,"GL_TEXTURE_BORDER_COLOR" },
+ { GL_TEXTURE_COMPONENTS ,"GL_TEXTURE_COMPONENTS" },
+#ifdef GL_TEXTURE_COORD_ARRAY_EXT
+ { GL_TEXTURE_COORD_ARRAY_COUNT_EXT,"GL_TEXTURE_COORD_ARRAY_COUNT_EXT" },
+ { GL_TEXTURE_COORD_ARRAY_EXT ,"GL_TEXTURE_COORD_ARRAY_EXT" },
+ { GL_TEXTURE_COORD_ARRAY_POINTER_EXT,"GL_TEXTURE_COORD_ARRAY_POINTER_EXT" },
+ { GL_TEXTURE_COORD_ARRAY_SIZE_EXT,"GL_TEXTURE_COORD_ARRAY_SIZE_EXT" },
+ { GL_TEXTURE_COORD_ARRAY_STRIDE_EXT,"GL_TEXTURE_COORD_ARRAY_STRIDE_EXT" },
+ { GL_TEXTURE_COORD_ARRAY_TYPE_EXT,"GL_TEXTURE_COORD_ARRAY_TYPE_EXT" },
+#endif
+ { GL_TEXTURE_ENV ,"GL_TEXTURE_ENV" },
+ { GL_TEXTURE_ENV_COLOR ,"GL_TEXTURE_ENV_COLOR" },
+ { GL_TEXTURE_ENV_MODE ,"GL_TEXTURE_ENV_MODE" },
+ { GL_TEXTURE_GEN_MODE ,"GL_TEXTURE_GEN_MODE" },
+ { GL_TEXTURE_GEN_Q ,"GL_TEXTURE_GEN_Q" },
+ { GL_TEXTURE_GEN_R ,"GL_TEXTURE_GEN_R" },
+ { GL_TEXTURE_GEN_S ,"GL_TEXTURE_GEN_S" },
+ { GL_TEXTURE_GEN_T ,"GL_TEXTURE_GEN_T" },
+ { GL_TEXTURE_HEIGHT ,"GL_TEXTURE_HEIGHT" },
+ { GL_TEXTURE_MAG_FILTER ,"GL_TEXTURE_MAG_FILTER" },
+ { GL_TEXTURE_MATRIX ,"GL_TEXTURE_MATRIX" },
+ { GL_TEXTURE_MIN_FILTER ,"GL_TEXTURE_MIN_FILTER" },
+ { GL_TEXTURE_STACK_DEPTH ,"GL_TEXTURE_STACK_DEPTH" },
+ { GL_TEXTURE_WIDTH ,"GL_TEXTURE_WIDTH" },
+ { GL_TEXTURE_WRAP_S ,"GL_TEXTURE_WRAP_S" },
+ { GL_TEXTURE_WRAP_T ,"GL_TEXTURE_WRAP_T" },
+ { GL_TRIANGLES ,"GL_TRIANGLES" },
+ { GL_TRIANGLE_FAN ,"GL_TRIANGLE_FAN" },
+ { GL_TRIANGLE_STRIP ,"GL_TRIANGLE_STRIP" },
+ { GL_UNPACK_ALIGNMENT ,"GL_UNPACK_ALIGNMENT" },
+ { GL_UNPACK_LSB_FIRST ,"GL_UNPACK_LSB_FIRST" },
+ { GL_UNPACK_ROW_LENGTH ,"GL_UNPACK_ROW_LENGTH" },
+ { GL_UNPACK_SKIP_PIXELS ,"GL_UNPACK_SKIP_PIXELS" },
+ { GL_UNPACK_SKIP_ROWS ,"GL_UNPACK_SKIP_ROWS" },
+ { GL_UNPACK_SWAP_BYTES ,"GL_UNPACK_SWAP_BYTES" },
+ { GL_UNSIGNED_BYTE ,"GL_UNSIGNED_BYTE" },
+ { GL_UNSIGNED_INT ,"GL_UNSIGNED_INT" },
+ { GL_UNSIGNED_SHORT ,"GL_UNSIGNED_SHORT" },
+ { GL_VENDOR ,"GL_VENDOR" },
+ { GL_VERSION ,"GL_VERSION" },
+#ifdef GL_VERTEX_ARRAY_EXT
+ { GL_VERTEX_ARRAY_COUNT_EXT ,"GL_VERTEX_ARRAY_COUNT_EXT" },
+ { GL_VERTEX_ARRAY_EXT ,"GL_VERTEX_ARRAY_EXT" },
+ { GL_VERTEX_ARRAY_POINTER_EXT ,"GL_VERTEX_ARRAY_POINTER_EXT" },
+ { GL_VERTEX_ARRAY_SIZE_EXT ,"GL_VERTEX_ARRAY_SIZE_EXT" },
+ { GL_VERTEX_ARRAY_STRIDE_EXT ,"GL_VERTEX_ARRAY_STRIDE_EXT" },
+ { GL_VERTEX_ARRAY_TYPE_EXT ,"GL_VERTEX_ARRAY_TYPE_EXT" },
+#endif
+ { GL_VIEWPORT ,"GL_VIEWPORT" },
+ { GL_XOR ,"GL_XOR" },
+ { GL_ZOOM_X ,"GL_ZOOM_X" },
+ { GL_ZOOM_Y ,"GL_ZOOM_Y" },
+
+ /* Magic end-marker - do not remove! */
+ { GL_ZERO, NULL }
+} ;
+
+
+int xglTraceIsEnabled ( char *gl_function_name )
+{
+ static int frameno = 0 ;
+ static int countdown = 0 ;
+
+ if ( strcmp ( gl_function_name, "glutSwapBuffers" ) == 0 )
+ {
+ if ( countdown == 0 )
+ {
+ char s [ 100 ] ;
+
+ fprintf ( stderr, "\nContinue Tracing after frame %d [Yes,No,Countdown,eXit] ?", ++frameno ) ;
+ gets ( s ) ;
+
+ if ( s[0] == 'x' )
+ exit ( 1 ) ;
+
+ xglTraceOn = ( s[0] != 'n' && s[0] != 'c' ) ;
+
+ if ( s[0] == 'c' )
+ {
+ fprintf ( stderr, "\nHow many frames should I wait until I ask again?" ) ;
+ gets ( s ) ;
+ countdown = atoi(s) ;
+ }
+
+ fprintf ( xglTraceFd, "/* Frame %d - tracing %s */\n", frameno, xglTraceOn ? "ON" : "OFF" ) ;
+ }
+ else
+ countdown-- ;
+ }
+
+ return xglTraceOn ;
+}
+
+
+int xglExecuteIsEnabled ( char *gl_function_name )
+{
+ return TRUE ;
+}
+
+char *xglExpandGLenum ( GLenum x )
+{
+ static GLenum last_val = GL_NONE ;
+ static char *last_str = NULL ;
+ char *error_message;
+ int i;
+
+ /* Due to ambiguity - these are output as numbers...
+
+ GL_NONE = , GL_ZERO = GL_FALSE = GL_POINTS = 0
+ GL_ONE = , GL_TRUE = GL_LINES = 1
+ */
+
+ if ( (int) x == 0 ) return "(GLenum) 0" ;
+ if ( (int) x == 1 ) return "(GLenum) 1" ;
+
+ if ( last_val == x ) return last_str ;
+
+ for ( i = 0 ; glenum_string [i].name != NULL ; i++ )
+ if ( glenum_string [i].val == x )
+ return glenum_string [i].name ;
+
+ /*
+ WARNING - this will leak memory - but it is an error condition,
+ so I suppose it's acceptable.
+ You can't declare the 'error_message' string as a
+ static - or else double errors will go mis-reported.
+ */
+
+ error_message = (char *)malloc( 100 * sizeof(char) ) ;
+
+ sprintf ( error_message, "(GLenum) 0x%04x /* Illegal? */", (int) x ) ;
+
+ return error_message ;
+}
+
+static GLbyte b1 [ 1 ], b2 [ 2 ], b3 [ 3 ], b4 [ 4 ] ;
+static GLdouble d1 [ 1 ], d2 [ 2 ], d3 [ 3 ], d4 [ 4 ] ;
+static GLfloat f1 [ 1 ], f2 [ 2 ], f3 [ 3 ], f4 [ 4 ] ;
+static GLint i1 [ 1 ], i2 [ 2 ], i3 [ 3 ], i4 [ 4 ] ;
+static GLshort s1 [ 1 ], s2 [ 2 ], s3 [ 3 ], s4 [ 4 ] ;
+static GLubyte ub1 [ 1 ], ub2 [ 2 ], ub3 [ 3 ], ub4 [ 4 ] ;
+static GLuint ui1 [ 1 ], ui2 [ 2 ], ui3 [ 3 ], ui4 [ 4 ] ;
+static GLushort us1 [ 1 ], us2 [ 2 ], us3 [ 3 ], us4 [ 4 ] ;
+
+static GLdouble md [ 16 ] ;
+static GLfloat mf [ 16 ] ;
+
+GLdouble *xglBuild1dv ( GLdouble v ) { d1[0] = v ; return d1 ; }
+GLfloat *xglBuild1fv ( GLfloat v ) { f1[0] = v ; return f1 ; }
+GLbyte *xglBuild1bv ( GLbyte v ) { b1[0] = v ; return b1 ; }
+GLint *xglBuild1iv ( GLint v ) { i1[0] = v ; return i1 ; }
+GLshort *xglBuild1sv ( GLshort v ) { s1[0] = v ; return s1 ; }
+GLubyte *xglBuild1ubv ( GLubyte v ) { ub1[0] = v ; return ub1 ; }
+GLuint *xglBuild1uiv ( GLuint v ) { ui1[0] = v ; return ui1 ; }
+GLushort *xglBuild1usv ( GLushort v ) { us1[0] = v ; return us1 ; }
+
+GLdouble *xglBuild2dv ( GLdouble v0, GLdouble v1 ) { d2[0] = v0 ; d2[1] = v1 ; return d2 ; }
+GLfloat *xglBuild2fv ( GLfloat v0, GLfloat v1 ) { f2[0] = v0 ; f2[1] = v1 ; return f2 ; }
+GLbyte *xglBuild2bv ( GLbyte v0, GLbyte v1 ) { b2[0] = v0 ; b2[1] = v1 ; return b2 ; }
+GLint *xglBuild2iv ( GLint v0, GLint v1 ) { i2[0] = v0 ; i2[1] = v1 ; return i2 ; }
+GLshort *xglBuild2sv ( GLshort v0, GLshort v1 ) { s2[0] = v0 ; s2[1] = v1 ; return s2 ; }
+GLubyte *xglBuild2ubv ( GLubyte v0, GLubyte v1 ) { ub2[0] = v0 ; ub2[1] = v1 ; return ub2 ; }
+GLuint *xglBuild2uiv ( GLuint v0, GLuint v1 ) { ui2[0] = v0 ; ui2[1] = v1 ; return ui2 ; }
+GLushort *xglBuild2usv ( GLushort v0, GLushort v1 ) { us2[0] = v0 ; us2[1] = v1 ; return us2 ; }
+
+GLdouble *xglBuild3dv ( GLdouble v0, GLdouble v1, GLdouble v2 ) { d3[0] = v0 ; d3[1] = v1 ; d3[2] = v2 ; return d3 ; }
+GLfloat *xglBuild3fv ( GLfloat v0, GLfloat v1, GLfloat v2 ) { f3[0] = v0 ; f3[1] = v1 ; f3[2] = v2 ; return f3 ; }
+GLbyte *xglBuild3bv ( GLbyte v0, GLbyte v1, GLbyte v2 ) { b3[0] = v0 ; b3[1] = v1 ; b3[2] = v2 ; return b3 ; }
+GLint *xglBuild3iv ( GLint v0, GLint v1, GLint v2 ) { i3[0] = v0 ; i3[1] = v1 ; i3[2] = v2 ; return i3 ; }
+GLshort *xglBuild3sv ( GLshort v0, GLshort v1, GLshort v2 ) { s3[0] = v0 ; s3[1] = v1 ; s3[2] = v2 ; return s3 ; }
+GLubyte *xglBuild3ubv ( GLubyte v0, GLubyte v1, GLubyte v2 ) { ub3[0] = v0 ; ub3[1] = v1 ; ub3[2] = v2 ; return ub3 ; }
+GLuint *xglBuild3uiv ( GLuint v0, GLuint v1, GLuint v2 ) { ui3[0] = v0 ; ui3[1] = v1 ; ui3[2] = v2 ; return ui3 ; }
+GLushort *xglBuild3usv ( GLushort v0, GLushort v1, GLushort v2 ) { us3[0] = v0 ; us3[1] = v1 ; us3[2] = v2 ; return us3 ; }
+
+
+GLdouble *xglBuild4dv ( GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) { d4[0] = v0 ; d4[1] = v1 ; d4[2] = v2 ; d4[3] = v3 ; return d4 ; }
+GLfloat *xglBuild4fv ( GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { f4[0] = v0 ; f4[1] = v1 ; f4[2] = v2 ; f4[3] = v3 ; return f4 ; }
+GLbyte *xglBuild4bv ( GLbyte v0, GLbyte v1, GLbyte v2, GLbyte v3 ) { b4[0] = v0 ; b4[1] = v1 ; b4[2] = v2 ; b4[3] = v3 ; return b4 ; }
+GLint *xglBuild4iv ( GLint v0, GLint v1, GLint v2, GLint v3 ) { i4[0] = v0 ; i4[1] = v1 ; i4[2] = v2 ; i4[3] = v3 ; return i4 ; }
+GLshort *xglBuild4sv ( GLshort v0, GLshort v1, GLshort v2, GLshort v3 ) { s4[0] = v0 ; s4[1] = v1 ; s4[2] = v2 ; s4[3] = v3 ; return s4 ; }
+GLubyte *xglBuild4ubv ( GLubyte v0, GLubyte v1, GLubyte v2, GLubyte v3 ) { ub4[0] = v0 ; ub4[1] = v1 ; ub4[2] = v2 ; ub4[3] = v3 ; return ub4 ; }
+GLuint *xglBuild4uiv ( GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { ui4[0] = v0 ; ui4[1] = v1 ; ui4[2] = v2 ; ui4[3] = v3 ; return ui4 ; }
+GLushort *xglBuild4usv ( GLushort v0, GLushort v1, GLushort v2, GLushort v3 ) { us4[0] = v0 ; us4[1] = v1 ; us4[2] = v2 ; us4[3] = v3 ; return us4 ; }
+
+GLdouble *xglBuildMatrixd ( GLdouble m0 , GLdouble m1 , GLdouble m2 , GLdouble m3 ,
+ GLdouble m4 , GLdouble m5 , GLdouble m6 , GLdouble m7 ,
+ GLdouble m8 , GLdouble m9 , GLdouble m10, GLdouble m11,
+ GLdouble m12, GLdouble m13, GLdouble m14, GLdouble m15 )
+{
+ md[ 0] = m0 ; md[ 1] = m1 ; md[ 2] = m2 ; md[ 3] = m3 ;
+ md[ 4] = m4 ; md[ 5] = m5 ; md[ 6] = m6 ; md[ 7] = m7 ;
+ md[ 8] = m8 ; md[ 9] = m9 ; md[10] = m10 ; md[11] = m11 ;
+ md[12] = m12 ; md[13] = m13 ; md[14] = m14 ; md[15] = m15 ;
+
+ return md ;
+}
+
+
+GLfloat *xglBuildMatrixf ( GLfloat m0 , GLfloat m1 , GLfloat m2 , GLfloat m3 ,
+ GLfloat m4 , GLfloat m5 , GLfloat m6 , GLfloat m7 ,
+ GLfloat m8 , GLfloat m9 , GLfloat m10, GLfloat m11,
+ GLfloat m12, GLfloat m13, GLfloat m14, GLfloat m15 )
+{
+ mf[ 0] = m0 ; mf[ 1] = m1 ; mf[ 2] = m2 ; mf[ 3] = m3 ;
+ mf[ 4] = m4 ; mf[ 5] = m5 ; mf[ 6] = m6 ; mf[ 7] = m7 ;
+ mf[ 8] = m8 ; mf[ 9] = m9 ; mf[10] = m10 ; mf[11] = m11 ;
+ mf[12] = m12 ; mf[13] = m13 ; mf[14] = m14 ; mf[15] = m15 ;
+
+ return mf ;
+}
+
projects / flightgear.git / commitdiff