From fe4f9070998491c66799c85b26373aaed33e6947 Mon Sep 17 00:00:00 2001 From: ehofman Date: Sun, 30 Oct 2005 15:02:58 +0000 Subject: [PATCH] Remove some unused code. --- configure.ac | 1 - simgear/xgl/.cvsignore | 3 - simgear/xgl/Makefile.am | 9 - simgear/xgl/xgl.c | 3035 --------------------------------------- simgear/xgl/xgl.h | 847 ----------- simgear/xgl/xglUtils.c | 681 --------- 6 files changed, 4576 deletions(-) delete mode 100644 simgear/xgl/.cvsignore delete mode 100644 simgear/xgl/Makefile.am delete mode 100644 simgear/xgl/xgl.c delete mode 100644 simgear/xgl/xgl.h delete mode 100644 simgear/xgl/xglUtils.c diff --git a/configure.ac b/configure.ac index 0c1206dd..8995695f 100644 --- a/configure.ac +++ b/configure.ac @@ -433,7 +433,6 @@ AC_CONFIG_FILES([ \ simgear/structure/Makefile \ simgear/threads/Makefile \ simgear/timing/Makefile \ - simgear/xgl/Makefile \ simgear/xml/Makefile \ ]) AC_OUTPUT diff --git a/simgear/xgl/.cvsignore b/simgear/xgl/.cvsignore deleted file mode 100644 index e9955884..00000000 --- a/simgear/xgl/.cvsignore +++ /dev/null @@ -1,3 +0,0 @@ -.deps -Makefile -Makefile.in diff --git a/simgear/xgl/Makefile.am b/simgear/xgl/Makefile.am deleted file mode 100644 index 9729a1c3..00000000 --- a/simgear/xgl/Makefile.am +++ /dev/null @@ -1,9 +0,0 @@ -includedir = @includedir@/xgl - -lib_LIBRARIES = libsgxgl.a - -include_HEADERS = xgl.h - -libsgxgl_a_SOURCES = xgl.c xglUtils.c - -INCLUDES = -I$(top_srcdir) diff --git a/simgear/xgl/xgl.c b/simgear/xgl/xgl.c deleted file mode 100644 index 2e711957..00000000 --- a/simgear/xgl/xgl.c +++ /dev/null @@ -1,3035 +0,0 @@ -#ifdef HAVE_CONFIG_H -# include -#endif - -#include "xgl.h" - -#ifdef USING_GLUT -#include GLUT_H -#endif - -#include -#include - -#ifdef HAVE_UNISTD_H -# include -#endif - - -#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 ) ; -} - -#ifdef USING_GLUT -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(!xglTraceFd ) { // Not defined by any other means, must be here - xglTraceFd = stdout; // avoid a crash from a NULL ptr. - } - 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 () ; -} -#endif - -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 - diff --git a/simgear/xgl/xgl.h b/simgear/xgl/xgl.h deleted file mode 100644 index bb371247..00000000 --- a/simgear/xgl/xgl.h +++ /dev/null @@ -1,847 +0,0 @@ -#ifndef _XGL_H -#define _XGL_H - - -#ifdef HAVE_CONFIG_H -# include -#endif - -#if defined(__CYGWIN__) /* && !defined(USING_X) */ -#define WIN32 -#endif - -#if defined(WIN32) /* MINGW and MSC predefine WIN32 */ -# include -#endif - -#include -#include SG_GLU_H -#include SG_GL_H - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -/* 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 - -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 ) ; - -#endif - - -#ifdef __cplusplus -} -#endif - - -#endif /* _XGL_H */ diff --git a/simgear/xgl/xglUtils.c b/simgear/xgl/xglUtils.c deleted file mode 100644 index 9fb05be1..00000000 --- a/simgear/xgl/xglUtils.c +++ /dev/null @@ -1,681 +0,0 @@ - -#include -#include -#include - -#if !defined( WIN32 ) -# if !defined( HAVE_STL_SGI_PORT ) && !defined( __MWERKS__ ) && !defined( __APPLE__ ) -// Avoid malloc with STLport and MSL -# ifdef HAVE_MALLOC_H -// Avoid malloc if system doesn't have it. :-) -# include -# endif -# endif -#endif - -#ifdef HAVE_UNISTD_H -# include -#endif - - -#include "xgl.h" - -#ifndef TRUE -#define TRUE 1 -#define FALSE 0 -#endif - -int xglTraceOn = TRUE ; - -FILE *xglTraceFd = NULL; - -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 ; -} -