//----------------------------------------------------------------------------- // Torque Game Engine // Copyright (C) GarageGames.com, Inc. //----------------------------------------------------------------------------- // These are a bunch of auxilary functions for logging and computing performance. // They don't really have anything to do with GL loading, so let's put them // in a serperate file. #include "platformWin32/platformWin32.h" #include "platform/platformGL.h" #include "console/consoleTypes.h" #include "console/console.h" #include static bool loggingEnabled = false; static bool outlineEnabled = false; static bool perfEnabled = false; #define GL_FUNCTION(fn_type, fn_name, fn_args, fn_body) extern fn_type (APIENTRY * dll##fn_name)fn_args; #define WGL_FUNCTION(fn_type, fn_name, fn_args, fn_body) extern fn_type (APIENTRY * dlld##fn_name)fn_args; #define WGLD3D_FUNCTION(fn_type, fn_name, fn_args, fn_body) extern fn_type (APIENTRY * dlldwgl##fn_name)fn_args; //includes... #include "platform/GLCoreFunc.h" #include "platform/GLExtFunc.h" #include "platform/GLUFunc.h" #include "platformWin32/GLWinFunc.h" //undefs... #undef GL_FUNCTION #undef WGL_FUNCTION #undef WGLD3D_FUNCTION static const char * BooleanToString( GLboolean b ) { if ( b == GL_FALSE ) return "GL_FALSE"; else if ( b == GL_TRUE ) return "GL_TRUE"; else return "OUT OF RANGE FOR BOOLEAN"; } static const char * FuncToString( GLenum f ) { switch ( f ) { case GL_ALWAYS: return "GL_ALWAYS"; case GL_NEVER: return "GL_NEVER"; case GL_LEQUAL: return "GL_LEQUAL"; case GL_LESS: return "GL_LESS"; case GL_EQUAL: return "GL_EQUAL"; case GL_GREATER: return "GL_GREATER"; case GL_GEQUAL: return "GL_GEQUAL"; case GL_NOTEQUAL: return "GL_NOTEQUAL"; default: return "!!! UNKNOWN !!!"; } } static const char* CoordToString( GLenum coord) { if (coord == GL_S) return "GL_S"; else if (coord == GL_T) return "GL_T"; else return "INVALID_COORD"; } static const char * PrimToString( GLenum mode ) { static char prim[1024]; if ( mode == GL_TRIANGLES ) strcpy( prim, "GL_TRIANGLES" ); else if ( mode == GL_TRIANGLE_STRIP ) strcpy( prim, "GL_TRIANGLE_STRIP" ); else if ( mode == GL_TRIANGLE_FAN ) strcpy( prim, "GL_TRIANGLE_FAN" ); else if ( mode == GL_QUADS ) strcpy( prim, "GL_QUADS" ); else if ( mode == GL_QUAD_STRIP ) strcpy( prim, "GL_QUAD_STRIP" ); else if ( mode == GL_POLYGON ) strcpy( prim, "GL_POLYGON" ); else if ( mode == GL_POINTS ) strcpy( prim, "GL_POINTS" ); else if ( mode == GL_LINES ) strcpy( prim, "GL_LINES" ); else if ( mode == GL_LINE_STRIP ) strcpy( prim, "GL_LINE_STRIP" ); else if ( mode == GL_LINE_LOOP ) strcpy( prim, "GL_LINE_LOOP" ); else sprintf( prim, "0x%x", mode ); return prim; } static const char * CapToString( GLenum cap ) { static char buffer[1024]; switch ( cap ) { case GL_TEXTURE_2D: return "GL_TEXTURE_2D"; case GL_BLEND: return "GL_BLEND"; case GL_DEPTH_TEST: return "GL_DEPTH_TEST"; case GL_CULL_FACE: return "GL_CULL_FACE"; case GL_CLIP_PLANE0: return "GL_CLIP_PLANE0"; case GL_COLOR_ARRAY: return "GL_COLOR_ARRAY"; case GL_TEXTURE_COORD_ARRAY: return "GL_TEXTURE_COORD_ARRAY"; case GL_VERTEX_ARRAY: return "GL_VERTEX_ARRAY"; case GL_ALPHA_TEST: return "GL_ALPHA_TEST"; case GL_STENCIL_TEST: return "GL_STENCIL_TEST"; case GL_TEXTURE_GEN_S: return "GL_TEXTURE_GEN_S"; case GL_TEXTURE_GEN_T: return "GL_TEXTURE_GEN_T"; default: sprintf( buffer, "0x%x", cap ); } return buffer; } static const char * TypeToString( GLenum t ) { switch ( t ) { case GL_BYTE: return "GL_BYTE"; case GL_UNSIGNED_BYTE: return "GL_UNSIGNED_BYTE"; case GL_SHORT: return "GL_SHORT"; case GL_UNSIGNED_SHORT: return "GL_UNSIGNED_SHORT"; case GL_INT: return "GL_INT"; case GL_UNSIGNED_INT: return "GL_UNSIGNED_INT"; case GL_FLOAT: return "GL_FLOAT"; case GL_DOUBLE: return "GL_DOUBLE"; default: return "!!! UNKNOWN !!!"; } } //------------------------------------------------------------------------------ // GLU Log Functions static void APIENTRY loggluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top) { fprintf(winState.log_fp, "gluOrtho2D( %d, %d, %d, %d )\n", left, right, bottom, top); fflush(winState.log_fp); dllgluOrtho2D(left, right, bottom, top); } static void APIENTRY loggluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar) { fprintf(winState.log_fp, "gluPerspective( %d, %d, %d, %d )\n", fovy, aspect, zNear, zFar); fflush(winState.log_fp); dllgluPerspective(fovy, aspect, zNear, zFar); } static void APIENTRY loggluPickMatrix(GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4]) { fprintf(winState.log_fp, "gluPickMatrix(%d, %d, %d, %d, VIEW)\n", x, y, width, height); fflush(winState.log_fp); dllgluPickMatrix(x, y, width, height, viewport); } static void APIENTRY loggluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz) { fprintf(winState.log_fp, "gluLookAt(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n",eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz); fflush(winState.log_fp); dllgluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz); } static int APIENTRY loggluProject(GLdouble objx, GLdouble objy, GLdouble objz, const GLdouble modelMatrix[16], const GLdouble projMatrix[16], const GLint viewport[4], GLdouble *winx, GLdouble *winy, GLdouble *winz) { fprintf(winState.log_fp, "gluProject\n"); fflush(winState.log_fp); return dllgluProject(objx, objy, objz, modelMatrix, projMatrix, viewport, winx, winy, winz); } static int APIENTRY loggluUnProject(GLdouble winx, GLdouble winy, GLdouble winz, const GLdouble modelMatrix[16], const GLdouble projMatrix[16], const GLint viewport[4], GLdouble *objx, GLdouble *objy, GLdouble *objz) { fprintf(winState.log_fp, "gluUnProject\n"); fflush(winState.log_fp); return dllgluUnProject(winx, winy, winz, modelMatrix, projMatrix, viewport, objx, objy, objz); } static int APIENTRY loggluScaleImage(GLenum format, GLint widthin, GLint heightin, GLenum typein, const void *datain, GLint widthout, GLint heightout, GLenum typeout, void *dataout) { fprintf(winState.log_fp, "gluScaleImage\n"); fflush(winState.log_fp); return dllgluScaleImage(format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout); } static int APIENTRY loggluBuild1DMipmaps(GLenum target, GLint components, GLint width, GLenum format, GLenum type, const void *data) { fprintf(winState.log_fp, "gluBuild1DMipmaps\n"); fflush(winState.log_fp); return dllgluBuild1DMipmaps(target, components, width, format, type, data); } static int APIENTRY loggluBuild2DMipmaps(GLenum target, GLint components, GLint width, GLint height, GLenum format, GLenum type, const void *data) { fprintf(winState.log_fp, "gluBuild2DMipmaps\n"); fflush(winState.log_fp); return dllgluBuild2DMipmaps(target, components, width, height, format, type, data); } //------------------------------------------------------------------------------ // GL LOG Functions static void APIENTRY logglAccum(GLenum op, GLfloat value) { fprintf( winState.log_fp, "glAccum\n" ); fflush(winState.log_fp); dllglAccum( op, value ); } static void APIENTRY logglAlphaFunc(GLenum func, GLclampf ref) { fprintf( winState.log_fp, "glAlphaFunc( 0x%x, %g )\n", func, ref ); fflush(winState.log_fp); dllglAlphaFunc( func, ref ); } static GLboolean APIENTRY logglAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) { fprintf( winState.log_fp, "glAreTexturesResident\n" ); fflush(winState.log_fp); return dllglAreTexturesResident( n, textures, residences ); } static void APIENTRY logglArrayElement(GLint i) { fprintf( winState.log_fp, "glArrayElement\n" ); fflush(winState.log_fp); dllglArrayElement( i ); } static void APIENTRY logglBegin(GLenum mode) { fprintf( winState.log_fp, "glBegin( %s )\n", PrimToString( mode )); fflush(winState.log_fp); dllglBegin( mode ); } static void APIENTRY logglBindTexture(GLenum target, GLuint texture) { fprintf( winState.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture ); fflush(winState.log_fp); dllglBindTexture( target, texture ); } static void APIENTRY logglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) { fprintf( winState.log_fp, "glBitmap\n" ); fflush(winState.log_fp); dllglBitmap( width, height, xorig, yorig, xmove, ymove, bitmap ); } static void BlendToName( char *n, GLenum f ) { switch ( f ) { case GL_ONE: strcpy( n, "GL_ONE" ); break; case GL_ZERO: strcpy( n, "GL_ZERO" ); break; case GL_SRC_ALPHA: strcpy( n, "GL_SRC_ALPHA" ); break; case GL_ONE_MINUS_SRC_ALPHA: strcpy( n, "GL_ONE_MINUS_SRC_ALPHA" ); break; case GL_SRC_COLOR: strcpy( n, "GL_SRC_COLOR" ); break; case GL_ONE_MINUS_SRC_COLOR: strcpy( n, "GL_ONE_MINUS_SRC_COLOR" ); break; case GL_DST_COLOR: strcpy( n, "GL_DST_COLOR" ); break; case GL_ONE_MINUS_DST_COLOR: strcpy( n, "GL_ONE_MINUS_DST_COLOR" ); break; case GL_DST_ALPHA: strcpy( n, "GL_DST_ALPHA" ); break; default: sprintf( n, "0x%x", f ); } } static void APIENTRY logglBlendFunc(GLenum sfactor, GLenum dfactor) { char sf[128], df[128]; BlendToName( sf, sfactor ); BlendToName( df, dfactor ); fprintf( winState.log_fp, "glBlendFunc( %s, %s )\n", sf, df ); fflush(winState.log_fp); dllglBlendFunc( sfactor, dfactor ); } static void APIENTRY logglCallList(GLuint list) { fprintf( winState.log_fp, "glCallList( %u )\n", list ); fflush(winState.log_fp); dllglCallList( list ); } static void APIENTRY logglCallLists(GLsizei n, GLenum type, const void *lists) { fprintf( winState.log_fp, "glCallLists\n" ); fflush(winState.log_fp); dllglCallLists( n, type, lists ); } static void APIENTRY logglClear(GLbitfield mask) { fprintf( winState.log_fp, "glClear( 0x%x = ", mask ); if ( mask & GL_COLOR_BUFFER_BIT ) fprintf( winState.log_fp, "GL_COLOR_BUFFER_BIT " ); if ( mask & GL_DEPTH_BUFFER_BIT ) fprintf( winState.log_fp, "GL_DEPTH_BUFFER_BIT " ); if ( mask & GL_STENCIL_BUFFER_BIT ) fprintf( winState.log_fp, "GL_STENCIL_BUFFER_BIT " ); if ( mask & GL_ACCUM_BUFFER_BIT ) fprintf( winState.log_fp, "GL_ACCUM_BUFFER_BIT " ); fprintf( winState.log_fp, ")\n" ); fflush(winState.log_fp); dllglClear( mask ); } static void APIENTRY logglClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { fprintf( winState.log_fp, "glClearAccum\n" ); fflush(winState.log_fp); dllglClearAccum( red, green, blue, alpha ); } static void APIENTRY logglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { fprintf( winState.log_fp, "glClearColor\n" ); fflush(winState.log_fp); dllglClearColor( red, green, blue, alpha ); } static void APIENTRY logglClearDepth(GLclampd depth) { fprintf( winState.log_fp, "glClearDepth( %g )\n", ( F32 ) depth ); fflush(winState.log_fp); dllglClearDepth( depth ); } static void APIENTRY logglClearIndex(GLfloat c) { fprintf( winState.log_fp, "glClearIndex\n" ); fflush(winState.log_fp); dllglClearIndex( c ); } static void APIENTRY logglClearStencil(GLint s) { fprintf( winState.log_fp, "glClearStencil( %d )\n", s ); fflush(winState.log_fp); dllglClearStencil( s ); } static void APIENTRY logglClipPlane(GLenum plane, const GLdouble *equation) { fprintf( winState.log_fp, "glClipPlane\n" ); fflush(winState.log_fp); dllglClipPlane( plane, equation ); } static void APIENTRY logglColor3b(GLbyte red, GLbyte green, GLbyte blue) { fprintf( winState.log_fp, "glColor3b\n" ); fflush(winState.log_fp); dllglColor3b( red, green, blue ); } static void APIENTRY logglColor3bv(const GLbyte *v) { fprintf( winState.log_fp, "glColor3bv\n" ); fflush(winState.log_fp); dllglColor3bv( v ); } static void APIENTRY logglColor3d(GLdouble red, GLdouble green, GLdouble blue) { fprintf( winState.log_fp, "glColor3d\n" ); fflush(winState.log_fp); dllglColor3d( red, green, blue ); } static void APIENTRY logglColor3dv(const GLdouble *v) { fprintf( winState.log_fp, "glColor3dv\n" ); fflush(winState.log_fp); dllglColor3dv( v ); } static void APIENTRY logglColor3f(GLfloat red, GLfloat green, GLfloat blue) { fprintf( winState.log_fp, "glColor3f\n" ); fflush(winState.log_fp); dllglColor3f( red, green, blue ); } static void APIENTRY logglColor3fv(const GLfloat *v) { fprintf( winState.log_fp, "glColor3fv\n" ); fflush(winState.log_fp); dllglColor3fv( v ); } static void APIENTRY logglColor3i(GLint red, GLint green, GLint blue) { fprintf( winState.log_fp, "glColor3i\n" ); fflush(winState.log_fp); dllglColor3i( red, green, blue ); } static void APIENTRY logglColor3iv(const GLint *v) { fprintf( winState.log_fp, "glColor3iv\n" ); fflush(winState.log_fp); dllglColor3iv( v ); } static void APIENTRY logglColor3s(GLshort red, GLshort green, GLshort blue) { fprintf( winState.log_fp, "glColor3s\n" ); fflush(winState.log_fp); dllglColor3s( red, green, blue ); } static void APIENTRY logglColor3sv(const GLshort *v) { fprintf( winState.log_fp, "glColor3sv\n" ); fflush(winState.log_fp); dllglColor3sv( v ); } static void APIENTRY logglColor3ub(GLubyte red, GLubyte green, GLubyte blue) { fprintf( winState.log_fp, "glColor3ub\n" ); fflush(winState.log_fp); dllglColor3ub( red, green, blue ); } static void APIENTRY logglColor3ubv(const GLubyte *v) { fprintf( winState.log_fp, "glColor3ubv\n" ); fflush(winState.log_fp); dllglColor3ubv( v ); } #define SIG( x ) fprintf( winState.log_fp, x "\n" ); fflush(winState.log_fp) static void APIENTRY logglColor3ui(GLuint red, GLuint green, GLuint blue) { SIG( "glColor3ui" ); dllglColor3ui( red, green, blue ); } static void APIENTRY logglColor3uiv(const GLuint *v) { SIG( "glColor3uiv" ); dllglColor3uiv( v ); } static void APIENTRY logglColor3us(GLushort red, GLushort green, GLushort blue) { SIG( "glColor3us" ); dllglColor3us( red, green, blue ); } static void APIENTRY logglColor3usv(const GLushort *v) { SIG( "glColor3usv" ); dllglColor3usv( v ); } static void APIENTRY logglColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) { SIG( "glColor4b" ); dllglColor4b( red, green, blue, alpha ); } static void APIENTRY logglColor4bv(const GLbyte *v) { SIG( "glColor4bv" ); dllglColor4bv( v ); } static void APIENTRY logglColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) { SIG( "glColor4d" ); dllglColor4d( red, green, blue, alpha ); } static void APIENTRY logglColor4dv(const GLdouble *v) { SIG( "glColor4dv" ); dllglColor4dv( v ); } static void APIENTRY logglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { fprintf( winState.log_fp, "glColor4f( %g,%g,%g,%g )\n", red, green, blue, alpha ); fflush(winState.log_fp); dllglColor4f( red, green, blue, alpha ); } static void APIENTRY logglColor4fv(const GLfloat *v) { fprintf( winState.log_fp, "glColor4fv( %g,%g,%g,%g )\n", v[0], v[1], v[2], v[3] ); fflush(winState.log_fp); dllglColor4fv( v ); } static void APIENTRY logglColor4i(GLint red, GLint green, GLint blue, GLint alpha) { SIG( "glColor4i" ); dllglColor4i( red, green, blue, alpha ); } static void APIENTRY logglColor4iv(const GLint *v) { SIG( "glColor4iv" ); dllglColor4iv( v ); } static void APIENTRY logglColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) { SIG( "glColor4s" ); dllglColor4s( red, green, blue, alpha ); } static void APIENTRY logglColor4sv(const GLshort *v) { SIG( "glColor4sv" ); dllglColor4sv( v ); } static void APIENTRY logglColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { SIG( "glColor4ub" ); dllglColor4b( red, green, blue, alpha ); } static void APIENTRY logglColor4ubv(const GLubyte *v) { SIG( "glColor4ubv" ); dllglColor4ubv( v ); } static void APIENTRY logglColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) { SIG( "glColor4ui" ); dllglColor4ui( red, green, blue, alpha ); } static void APIENTRY logglColor4uiv(const GLuint *v) { SIG( "glColor4uiv" ); dllglColor4uiv( v ); } static void APIENTRY logglColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) { SIG( "glColor4us" ); dllglColor4us( red, green, blue, alpha ); } static void APIENTRY logglColor4usv(const GLushort *v) { SIG( "glColor4usv" ); dllglColor4usv( v ); } static void APIENTRY logglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { SIG( "glColorMask" ); dllglColorMask( red, green, blue, alpha ); } static void APIENTRY logglColorMaterial(GLenum face, GLenum mode) { SIG( "glColorMaterial" ); dllglColorMaterial( face, mode ); } static void APIENTRY logglColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf( winState.log_fp, "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride ); fflush(winState.log_fp); dllglColorPointer( size, type, stride, pointer ); } static void APIENTRY logglCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) { SIG( "glCopyPixels" ); dllglCopyPixels( x, y, width, height, type ); } static void APIENTRY logglCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) { SIG( "glCopyTexImage1D" ); dllglCopyTexImage1D( target, level, internalFormat, x, y, width, border ); } static void APIENTRY logglCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { SIG( "glCopyTexImage2D" ); dllglCopyTexImage2D( target, level, internalFormat, x, y, width, height, border ); } static void APIENTRY logglCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { SIG( "glCopyTexSubImage1D" ); dllglCopyTexSubImage1D( target, level, xoffset, x, y, width ); } static void APIENTRY logglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { SIG( "glCopyTexSubImage2D" ); dllglCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height ); } static void APIENTRY logglCullFace(GLenum mode) { fprintf( winState.log_fp, "glCullFace( %s )\n", ( mode == GL_FRONT ) ? "GL_FRONT" : "GL_BACK" ); fflush(winState.log_fp); dllglCullFace( mode ); } static void APIENTRY logglDeleteLists(GLuint list, GLsizei range) { SIG( "glDeleteLists" ); dllglDeleteLists( list, range ); } static void APIENTRY logglDeleteTextures(GLsizei n, const GLuint *textures) { SIG( "glDeleteTextures" ); dllglDeleteTextures( n, textures ); } static void APIENTRY logglDepthFunc(GLenum func) { fprintf( winState.log_fp, "glDepthFunc( %s )\n", FuncToString( func ) ); fflush(winState.log_fp); dllglDepthFunc( func ); } static void APIENTRY logglDepthMask(GLboolean flag) { fprintf( winState.log_fp, "glDepthMask( %s )\n", BooleanToString( flag ) ); fflush(winState.log_fp); dllglDepthMask( flag ); } static void APIENTRY logglDepthRange(GLclampd zNear, GLclampd zFar) { fprintf( winState.log_fp, "glDepthRange( %g, %g )\n", ( F32 ) zNear, ( F32 ) zFar ); fflush(winState.log_fp); dllglDepthRange( zNear, zFar ); } static void APIENTRY logglDisable(GLenum cap) { fprintf( winState.log_fp, "glDisable( %s )\n", CapToString( cap ) ); fflush(winState.log_fp); dllglDisable( cap ); } static void APIENTRY logglDisableClientState(GLenum array) { fprintf( winState.log_fp, "glDisableClientState( %s )\n", CapToString( array ) ); fflush(winState.log_fp); dllglDisableClientState( array ); } static void APIENTRY logglDrawArrays(GLenum mode, GLint first, GLsizei count) { SIG( "glDrawArrays" ); dllglDrawArrays( mode, first, count ); } static void APIENTRY logglDrawBuffer(GLenum mode) { SIG( "glDrawBuffer" ); dllglDrawBuffer( mode ); } static void APIENTRY logglDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { fprintf( winState.log_fp, "glDrawElements( %s, %d, %s, MEM )\n", PrimToString( mode ), count, TypeToString( type ) ); fflush(winState.log_fp); dllglDrawElements( mode, count, type, indices ); } static void APIENTRY logglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { SIG( "glDrawPixels" ); dllglDrawPixels( width, height, format, type, pixels ); } static void APIENTRY logglEdgeFlag(GLboolean flag) { SIG( "glEdgeFlag" ); dllglEdgeFlag( flag ); } static void APIENTRY logglEdgeFlagPointer(GLsizei stride, const GLvoid *pointer) { SIG( "glEdgeFlagPointer" ); dllglEdgeFlagPointer( stride, pointer ); } static void APIENTRY logglEdgeFlagv(const GLboolean *flag) { SIG( "glEdgeFlagv" ); dllglEdgeFlagv( flag ); } static void APIENTRY logglEnable(GLenum cap) { fprintf( winState.log_fp, "glEnable( %s )\n", CapToString( cap ) ); fflush(winState.log_fp); dllglEnable( cap ); } static void APIENTRY logglEnableClientState(GLenum array) { fprintf( winState.log_fp, "glEnableClientState( %s )\n", CapToString( array ) ); fflush(winState.log_fp); dllglEnableClientState( array ); } static void APIENTRY logglEnd(void) { SIG( "glEnd" ); dllglEnd(); } static void APIENTRY logglEndList(void) { SIG( "glEndList" ); dllglEndList(); } static void APIENTRY logglEvalCoord1d(GLdouble u) { SIG( "glEvalCoord1d" ); dllglEvalCoord1d( u ); } static void APIENTRY logglEvalCoord1dv(const GLdouble *u) { SIG( "glEvalCoord1dv" ); dllglEvalCoord1dv( u ); } static void APIENTRY logglEvalCoord1f(GLfloat u) { SIG( "glEvalCoord1f" ); dllglEvalCoord1f( u ); } static void APIENTRY logglEvalCoord1fv(const GLfloat *u) { SIG( "glEvalCoord1fv" ); dllglEvalCoord1fv( u ); } static void APIENTRY logglEvalCoord2d(GLdouble u, GLdouble v) { SIG( "glEvalCoord2d" ); dllglEvalCoord2d( u, v ); } static void APIENTRY logglEvalCoord2dv(const GLdouble *u) { SIG( "glEvalCoord2dv" ); dllglEvalCoord2dv( u ); } static void APIENTRY logglEvalCoord2f(GLfloat u, GLfloat v) { SIG( "glEvalCoord2f" ); dllglEvalCoord2f( u, v ); } static void APIENTRY logglEvalCoord2fv(const GLfloat *u) { SIG( "glEvalCoord2fv" ); dllglEvalCoord2fv( u ); } static void APIENTRY logglEvalMesh1(GLenum mode, GLint i1, GLint i2) { SIG( "glEvalMesh1" ); dllglEvalMesh1( mode, i1, i2 ); } static void APIENTRY logglEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { SIG( "glEvalMesh2" ); dllglEvalMesh2( mode, i1, i2, j1, j2 ); } static void APIENTRY logglEvalPoint1(GLint i) { SIG( "glEvalPoint1" ); dllglEvalPoint1( i ); } static void APIENTRY logglEvalPoint2(GLint i, GLint j) { SIG( "glEvalPoint2" ); dllglEvalPoint2( i, j ); } static void APIENTRY logglFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) { SIG( "glFeedbackBuffer" ); dllglFeedbackBuffer( size, type, buffer ); } static void APIENTRY logglFinish(void) { SIG( "glFinish" ); dllglFinish(); } static void APIENTRY logglFlush(void) { SIG( "glFlush" ); dllglFlush(); } static void APIENTRY logglFogf(GLenum pname, GLfloat param) { SIG( "glFogf" ); dllglFogf( pname, param ); } static void APIENTRY logglFogfv(GLenum pname, const GLfloat *params) { SIG( "glFogfv" ); dllglFogfv( pname, params ); } static void APIENTRY logglFogi(GLenum pname, GLint param) { SIG( "glFogi" ); dllglFogi( pname, param ); } static void APIENTRY logglFogiv(GLenum pname, const GLint *params) { SIG( "glFogiv" ); dllglFogiv( pname, params ); } static void APIENTRY logglFrontFace(GLenum mode) { SIG( "glFrontFace" ); dllglFrontFace( mode ); } static void APIENTRY logglFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { SIG( "glFrustum" ); dllglFrustum( left, right, bottom, top, zNear, zFar ); } static GLuint APIENTRY logglGenLists(GLsizei range) { SIG( "glGenLists" ); return dllglGenLists( range ); } static void APIENTRY logglGenTextures(GLsizei n, GLuint *textures) { SIG( "glGenTextures" ); dllglGenTextures( n, textures ); } static void APIENTRY logglGetBooleanv(GLenum pname, GLboolean *params) { SIG( "glGetBooleanv" ); dllglGetBooleanv( pname, params ); } static void APIENTRY logglGetClipPlane(GLenum plane, GLdouble *equation) { SIG( "glGetClipPlane" ); dllglGetClipPlane( plane, equation ); } static void APIENTRY logglGetDoublev(GLenum pname, GLdouble *params) { SIG( "glGetDoublev" ); dllglGetDoublev( pname, params ); } static GLenum APIENTRY logglGetError(void) { SIG( "glGetError" ); return dllglGetError(); } static void APIENTRY logglGetFloatv(GLenum pname, GLfloat *params) { SIG( "glGetFloatv" ); dllglGetFloatv( pname, params ); } static void APIENTRY logglGetIntegerv(GLenum pname, GLint *params) { SIG( "glGetIntegerv" ); dllglGetIntegerv( pname, params ); } static void APIENTRY logglGetLightfv(GLenum light, GLenum pname, GLfloat *params) { SIG( "glGetLightfv" ); dllglGetLightfv( light, pname, params ); } static void APIENTRY logglGetLightiv(GLenum light, GLenum pname, GLint *params) { SIG( "glGetLightiv" ); dllglGetLightiv( light, pname, params ); } static void APIENTRY logglGetMapdv(GLenum target, GLenum query, GLdouble *v) { SIG( "glGetMapdv" ); dllglGetMapdv( target, query, v ); } static void APIENTRY logglGetMapfv(GLenum target, GLenum query, GLfloat *v) { SIG( "glGetMapfv" ); dllglGetMapfv( target, query, v ); } static void APIENTRY logglGetMapiv(GLenum target, GLenum query, GLint *v) { SIG( "glGetMapiv" ); dllglGetMapiv( target, query, v ); } static void APIENTRY logglGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) { SIG( "glGetMaterialfv" ); dllglGetMaterialfv( face, pname, params ); } static void APIENTRY logglGetMaterialiv(GLenum face, GLenum pname, GLint *params) { SIG( "glGetMaterialiv" ); dllglGetMaterialiv( face, pname, params ); } static void APIENTRY logglGetPixelMapfv(GLenum map, GLfloat *values) { SIG( "glGetPixelMapfv" ); dllglGetPixelMapfv( map, values ); } static void APIENTRY logglGetPixelMapuiv(GLenum map, GLuint *values) { SIG( "glGetPixelMapuiv" ); dllglGetPixelMapuiv( map, values ); } static void APIENTRY logglGetPixelMapusv(GLenum map, GLushort *values) { SIG( "glGetPixelMapusv" ); dllglGetPixelMapusv( map, values ); } static void APIENTRY logglGetPointerv(GLenum pname, GLvoid* *params) { SIG( "glGetPointerv" ); dllglGetPointerv( pname, params ); } static void APIENTRY logglGetPolygonStipple(GLubyte *mask) { SIG( "glGetPolygonStipple" ); dllglGetPolygonStipple( mask ); } static const GLubyte * APIENTRY logglGetString(GLenum name) { SIG( "glGetString" ); return dllglGetString( name ); } static void APIENTRY logglGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) { SIG( "glGetTexEnvfv" ); dllglGetTexEnvfv( target, pname, params ); } static void APIENTRY logglGetTexEnviv(GLenum target, GLenum pname, GLint *params) { SIG( "glGetTexEnviv" ); dllglGetTexEnviv( target, pname, params ); } static void APIENTRY logglGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) { SIG( "glGetTexGendv" ); dllglGetTexGendv( coord, pname, params ); } static void APIENTRY logglGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) { SIG( "glGetTexGenfv" ); dllglGetTexGenfv( coord, pname, params ); } static void APIENTRY logglGetTexGeniv(GLenum coord, GLenum pname, GLint *params) { SIG( "glGetTexGeniv" ); dllglGetTexGeniv( coord, pname, params ); } static void APIENTRY logglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) { SIG( "glGetTexImage" ); dllglGetTexImage( target, level, format, type, pixels ); } static void APIENTRY logglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params ) { SIG( "glGetTexLevelParameterfv" ); dllglGetTexLevelParameterfv( target, level, pname, params ); } static void APIENTRY logglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) { SIG( "glGetTexLevelParameteriv" ); dllglGetTexLevelParameteriv( target, level, pname, params ); } static void APIENTRY logglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) { SIG( "glGetTexParameterfv" ); dllglGetTexParameterfv( target, pname, params ); } static void APIENTRY logglGetTexParameteriv(GLenum target, GLenum pname, GLint *params) { SIG( "glGetTexParameteriv" ); dllglGetTexParameteriv( target, pname, params ); } static void APIENTRY logglHint(GLenum target, GLenum mode) { fprintf( winState.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode ); fflush(winState.log_fp); dllglHint( target, mode ); } static void APIENTRY logglIndexMask(GLuint mask) { SIG( "glIndexMask" ); dllglIndexMask( mask ); } static void APIENTRY logglIndexPointer(GLenum type, GLsizei stride, const void *pointer) { SIG( "glIndexPointer" ); dllglIndexPointer( type, stride, pointer ); } static void APIENTRY logglIndexd(GLdouble c) { SIG( "glIndexd" ); dllglIndexd( c ); } static void APIENTRY logglIndexdv(const GLdouble *c) { SIG( "glIndexdv" ); dllglIndexdv( c ); } static void APIENTRY logglIndexf(GLfloat c) { SIG( "glIndexf" ); dllglIndexf( c ); } static void APIENTRY logglIndexfv(const GLfloat *c) { SIG( "glIndexfv" ); dllglIndexfv( c ); } static void APIENTRY logglIndexi(GLint c) { SIG( "glIndexi" ); dllglIndexi( c ); } static void APIENTRY logglIndexiv(const GLint *c) { SIG( "glIndexiv" ); dllglIndexiv( c ); } static void APIENTRY logglIndexs(GLshort c) { SIG( "glIndexs" ); dllglIndexs( c ); } static void APIENTRY logglIndexsv(const GLshort *c) { SIG( "glIndexsv" ); dllglIndexsv( c ); } static void APIENTRY logglIndexub(GLubyte c) { SIG( "glIndexub" ); dllglIndexub( c ); } static void APIENTRY logglIndexubv(const GLubyte *c) { SIG( "glIndexubv" ); dllglIndexubv( c ); } static void APIENTRY logglInitNames(void) { SIG( "glInitNames" ); dllglInitNames(); } static void APIENTRY logglInterleavedArrays(GLenum format, GLsizei stride, const void *pointer) { SIG( "glInterleavedArrays" ); dllglInterleavedArrays( format, stride, pointer ); } static GLboolean APIENTRY logglIsEnabled(GLenum cap) { SIG( "glIsEnabled" ); return dllglIsEnabled( cap ); } static GLboolean APIENTRY logglIsList(GLuint list) { SIG( "glIsList" ); return dllglIsList( list ); } static GLboolean APIENTRY logglIsTexture(GLuint texture) { SIG( "glIsTexture" ); return dllglIsTexture( texture ); } static void APIENTRY logglLightModelf(GLenum pname, GLfloat param) { SIG( "glLightModelf" ); dllglLightModelf( pname, param ); } static void APIENTRY logglLightModelfv(GLenum pname, const GLfloat *params) { SIG( "glLightModelfv" ); dllglLightModelfv( pname, params ); } static void APIENTRY logglLightModeli(GLenum pname, GLint param) { SIG( "glLightModeli" ); dllglLightModeli( pname, param ); } static void APIENTRY logglLightModeliv(GLenum pname, const GLint *params) { SIG( "glLightModeliv" ); dllglLightModeliv( pname, params ); } static void APIENTRY logglLightf(GLenum light, GLenum pname, GLfloat param) { SIG( "glLightf" ); dllglLightf( light, pname, param ); } static void APIENTRY logglLightfv(GLenum light, GLenum pname, const GLfloat *params) { SIG( "glLightfv" ); dllglLightfv( light, pname, params ); } static void APIENTRY logglLighti(GLenum light, GLenum pname, GLint param) { SIG( "glLighti" ); dllglLighti( light, pname, param ); } static void APIENTRY logglLightiv(GLenum light, GLenum pname, const GLint *params) { SIG( "glLightiv" ); dllglLightiv( light, pname, params ); } static void APIENTRY logglLineStipple(GLint factor, GLushort pattern) { SIG( "glLineStipple" ); dllglLineStipple( factor, pattern ); } static void APIENTRY logglLineWidth(GLfloat width) { SIG( "glLineWidth" ); dllglLineWidth( width ); } static void APIENTRY logglListBase(GLuint base) { SIG( "glListBase" ); dllglListBase( base ); } static void APIENTRY logglLoadIdentity(void) { SIG( "glLoadIdentity" ); dllglLoadIdentity(); } static void APIENTRY logglLoadMatrixd(const GLdouble *m) { SIG( "glLoadMatrixd" ); dllglLoadMatrixd( m ); } static void APIENTRY logglLoadMatrixf(const GLfloat *m) { SIG( "glLoadMatrixf" ); dllglLoadMatrixf( m ); } static void APIENTRY logglLoadName(GLuint name) { SIG( "glLoadName" ); dllglLoadName( name ); } static void APIENTRY logglLogicOp(GLenum opcode) { SIG( "glLogicOp" ); dllglLogicOp( opcode ); } static void APIENTRY logglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) { SIG( "glMap1d" ); dllglMap1d( target, u1, u2, stride, order, points ); } static void APIENTRY logglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) { SIG( "glMap1f" ); dllglMap1f( target, u1, u2, stride, order, points ); } static void APIENTRY logglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) { SIG( "glMap2d" ); dllglMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); } static void APIENTRY logglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) { SIG( "glMap2f" ); dllglMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); } static void APIENTRY logglMapGrid1d(GLint un, GLdouble u1, GLdouble u2) { SIG( "glMapGrid1d" ); dllglMapGrid1d( un, u1, u2 ); } static void APIENTRY logglMapGrid1f(GLint un, GLfloat u1, GLfloat u2) { SIG( "glMapGrid1f" ); dllglMapGrid1f( un, u1, u2 ); } static void APIENTRY logglMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) { SIG( "glMapGrid2d" ); dllglMapGrid2d( un, u1, u2, vn, v1, v2 ); } static void APIENTRY logglMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { SIG( "glMapGrid2f" ); dllglMapGrid2f( un, u1, u2, vn, v1, v2 ); } static void APIENTRY logglMaterialf(GLenum face, GLenum pname, GLfloat param) { SIG( "glMaterialf" ); dllglMaterialf( face, pname, param ); } static void APIENTRY logglMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { SIG( "glMaterialfv" ); dllglMaterialfv( face, pname, params ); } static void APIENTRY logglMateriali(GLenum face, GLenum pname, GLint param) { SIG( "glMateriali" ); dllglMateriali( face, pname, param ); } static void APIENTRY logglMaterialiv(GLenum face, GLenum pname, const GLint *params) { SIG( "glMaterialiv" ); dllglMaterialiv( face, pname, params ); } static void APIENTRY logglMatrixMode(GLenum mode) { SIG( "glMatrixMode" ); dllglMatrixMode( mode ); } static void APIENTRY logglMultMatrixd(const GLdouble *m) { SIG( "glMultMatrixd" ); dllglMultMatrixd( m ); } static void APIENTRY logglMultMatrixf(const GLfloat *m) { SIG( "glMultMatrixf" ); dllglMultMatrixf( m ); } static void APIENTRY logglNewList(GLuint list, GLenum mode) { SIG( "glNewList" ); dllglNewList( list, mode ); } static void APIENTRY logglNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) { SIG ("glNormal3b" ); dllglNormal3b( nx, ny, nz ); } static void APIENTRY logglNormal3bv(const GLbyte *v) { SIG( "glNormal3bv" ); dllglNormal3bv( v ); } static void APIENTRY logglNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) { SIG( "glNormal3d" ); dllglNormal3d( nx, ny, nz ); } static void APIENTRY logglNormal3dv(const GLdouble *v) { SIG( "glNormal3dv" ); dllglNormal3dv( v ); } static void APIENTRY logglNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { SIG( "glNormal3f" ); dllglNormal3f( nx, ny, nz ); } static void APIENTRY logglNormal3fv(const GLfloat *v) { SIG( "glNormal3fv" ); dllglNormal3fv( v ); } static void APIENTRY logglNormal3i(GLint nx, GLint ny, GLint nz) { SIG( "glNormal3i" ); dllglNormal3i( nx, ny, nz ); } static void APIENTRY logglNormal3iv(const GLint *v) { SIG( "glNormal3iv" ); dllglNormal3iv( v ); } static void APIENTRY logglNormal3s(GLshort nx, GLshort ny, GLshort nz) { SIG( "glNormal3s" ); dllglNormal3s( nx, ny, nz ); } static void APIENTRY logglNormal3sv(const GLshort *v) { SIG( "glNormal3sv" ); dllglNormal3sv( v ); } static void APIENTRY logglNormalPointer(GLenum type, GLsizei stride, const void *pointer) { SIG( "glNormalPointer" ); dllglNormalPointer( type, stride, pointer ); } static void APIENTRY logglOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { SIG( "glOrtho" ); dllglOrtho( left, right, bottom, top, zNear, zFar ); } static void APIENTRY logglPassThrough(GLfloat token) { SIG( "glPassThrough" ); dllglPassThrough( token ); } static void APIENTRY logglPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) { SIG( "glPixelMapfv" ); dllglPixelMapfv( map, mapsize, values ); } static void APIENTRY logglPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) { SIG( "glPixelMapuiv" ); dllglPixelMapuiv( map, mapsize, values ); } static void APIENTRY logglPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) { SIG( "glPixelMapusv" ); dllglPixelMapusv( map, mapsize, values ); } static void APIENTRY logglPixelStoref(GLenum pname, GLfloat param) { SIG( "glPixelStoref" ); dllglPixelStoref( pname, param ); } static void APIENTRY logglPixelStorei(GLenum pname, GLint param) { SIG( "glPixelStorei" ); dllglPixelStorei( pname, param ); } static void APIENTRY logglPixelTransferf(GLenum pname, GLfloat param) { SIG( "glPixelTransferf" ); dllglPixelTransferf( pname, param ); } static void APIENTRY logglPixelTransferi(GLenum pname, GLint param) { SIG( "glPixelTransferi" ); dllglPixelTransferi( pname, param ); } static void APIENTRY logglPixelZoom(GLfloat xfactor, GLfloat yfactor) { SIG( "glPixelZoom" ); dllglPixelZoom( xfactor, yfactor ); } static void APIENTRY logglPointSize(GLfloat size) { SIG( "glPointSize" ); dllglPointSize( size ); } static void APIENTRY logglPolygonMode(GLenum face, GLenum mode) { fprintf( winState.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode ); fflush(winState.log_fp); dllglPolygonMode( face, mode ); } static void APIENTRY logglPolygonOffset(GLfloat factor, GLfloat units) { SIG( "glPolygonOffset" ); dllglPolygonOffset( factor, units ); } static void APIENTRY logglPolygonStipple(const GLubyte *mask ) { SIG( "glPolygonStipple" ); dllglPolygonStipple( mask ); } static void APIENTRY logglPopAttrib(void) { SIG( "glPopAttrib" ); dllglPopAttrib(); } static void APIENTRY logglPopClientAttrib(void) { SIG( "glPopClientAttrib" ); dllglPopClientAttrib(); } static void APIENTRY logglPopMatrix(void) { SIG( "glPopMatrix" ); dllglPopMatrix(); } static void APIENTRY logglPopName(void) { SIG( "glPopName" ); dllglPopName(); } static void APIENTRY logglPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) { SIG( "glPrioritizeTextures" ); dllglPrioritizeTextures( n, textures, priorities ); } static void APIENTRY logglPushAttrib(GLbitfield mask) { SIG( "glPushAttrib" ); dllglPushAttrib( mask ); } static void APIENTRY logglPushClientAttrib(GLbitfield mask) { SIG( "glPushClientAttrib" ); dllglPushClientAttrib( mask ); } static void APIENTRY logglPushMatrix(void) { SIG( "glPushMatrix" ); dllglPushMatrix(); } static void APIENTRY logglPushName(GLuint name) { SIG( "glPushName" ); dllglPushName( name ); } static void APIENTRY logglRasterPos2d(GLdouble x, GLdouble y) { SIG ("glRasterPot2d" ); dllglRasterPos2d( x, y ); } static void APIENTRY logglRasterPos2dv(const GLdouble *v) { SIG( "glRasterPos2dv" ); dllglRasterPos2dv( v ); } static void APIENTRY logglRasterPos2f(GLfloat x, GLfloat y) { SIG( "glRasterPos2f" ); dllglRasterPos2f( x, y ); } static void APIENTRY logglRasterPos2fv(const GLfloat *v) { SIG( "glRasterPos2dv" ); dllglRasterPos2fv( v ); } static void APIENTRY logglRasterPos2i(GLint x, GLint y) { SIG( "glRasterPos2if" ); dllglRasterPos2i( x, y ); } static void APIENTRY logglRasterPos2iv(const GLint *v) { SIG( "glRasterPos2iv" ); dllglRasterPos2iv( v ); } static void APIENTRY logglRasterPos2s(GLshort x, GLshort y) { SIG( "glRasterPos2s" ); dllglRasterPos2s( x, y ); } static void APIENTRY logglRasterPos2sv(const GLshort *v) { SIG( "glRasterPos2sv" ); dllglRasterPos2sv( v ); } static void APIENTRY logglRasterPos3d(GLdouble x, GLdouble y, GLdouble z) { SIG( "glRasterPos3d" ); dllglRasterPos3d( x, y, z ); } static void APIENTRY logglRasterPos3dv(const GLdouble *v) { SIG( "glRasterPos3dv" ); dllglRasterPos3dv( v ); } static void APIENTRY logglRasterPos3f(GLfloat x, GLfloat y, GLfloat z) { SIG( "glRasterPos3f" ); dllglRasterPos3f( x, y, z ); } static void APIENTRY logglRasterPos3fv(const GLfloat *v) { SIG( "glRasterPos3fv" ); dllglRasterPos3fv( v ); } static void APIENTRY logglRasterPos3i(GLint x, GLint y, GLint z) { SIG( "glRasterPos3i" ); dllglRasterPos3i( x, y, z ); } static void APIENTRY logglRasterPos3iv(const GLint *v) { SIG( "glRasterPos3iv" ); dllglRasterPos3iv( v ); } static void APIENTRY logglRasterPos3s(GLshort x, GLshort y, GLshort z) { SIG( "glRasterPos3s" ); dllglRasterPos3s( x, y, z ); } static void APIENTRY logglRasterPos3sv(const GLshort *v) { SIG( "glRasterPos3sv" ); dllglRasterPos3sv( v ); } static void APIENTRY logglRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { SIG( "glRasterPos4d" ); dllglRasterPos4d( x, y, z, w ); } static void APIENTRY logglRasterPos4dv(const GLdouble *v) { SIG( "glRasterPos4dv" ); dllglRasterPos4dv( v ); } static void APIENTRY logglRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { SIG( "glRasterPos4f" ); dllglRasterPos4f( x, y, z, w ); } static void APIENTRY logglRasterPos4fv(const GLfloat *v) { SIG( "glRasterPos4fv" ); dllglRasterPos4fv( v ); } static void APIENTRY logglRasterPos4i(GLint x, GLint y, GLint z, GLint w) { SIG( "glRasterPos4i" ); dllglRasterPos4i( x, y, z, w ); } static void APIENTRY logglRasterPos4iv(const GLint *v) { SIG( "glRasterPos4iv" ); dllglRasterPos4iv( v ); } static void APIENTRY logglRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) { SIG( "glRasterPos4s" ); dllglRasterPos4s( x, y, z, w ); } static void APIENTRY logglRasterPos4sv(const GLshort *v) { SIG( "glRasterPos4sv" ); dllglRasterPos4sv( v ); } static void APIENTRY logglReadBuffer(GLenum mode) { SIG( "glReadBuffer" ); dllglReadBuffer( mode ); } static void APIENTRY logglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) { SIG( "glReadPixels" ); dllglReadPixels( x, y, width, height, format, type, pixels ); } static void APIENTRY logglRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) { SIG( "glRectd" ); dllglRectd( x1, y1, x2, y2 ); } static void APIENTRY logglRectdv(const GLdouble *v1, const GLdouble *v2) { SIG( "glRectdv" ); dllglRectdv( v1, v2 ); } static void APIENTRY logglRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) { SIG( "glRectf" ); dllglRectf( x1, y1, x2, y2 ); } static void APIENTRY logglRectfv(const GLfloat *v1, const GLfloat *v2) { SIG( "glRectfv" ); dllglRectfv( v1, v2 ); } static void APIENTRY logglRecti(GLint x1, GLint y1, GLint x2, GLint y2) { SIG( "glRecti" ); dllglRecti( x1, y1, x2, y2 ); } static void APIENTRY logglRectiv(const GLint *v1, const GLint *v2) { SIG( "glRectiv" ); dllglRectiv( v1, v2 ); } static void APIENTRY logglRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) { SIG( "glRects" ); dllglRects( x1, y1, x2, y2 ); } static void APIENTRY logglRectsv(const GLshort *v1, const GLshort *v2) { SIG( "glRectsv" ); dllglRectsv( v1, v2 ); } static GLint APIENTRY logglRenderMode(GLenum mode) { SIG( "glRenderMode" ); return dllglRenderMode( mode ); } static void APIENTRY logglRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { SIG( "glRotated" ); dllglRotated( angle, x, y, z ); } static void APIENTRY logglRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { SIG( "glRotatef" ); dllglRotatef( angle, x, y, z ); } static void APIENTRY logglScaled(GLdouble x, GLdouble y, GLdouble z) { SIG( "glScaled" ); dllglScaled( x, y, z ); } static void APIENTRY logglScalef(GLfloat x, GLfloat y, GLfloat z) { SIG( "glScalef" ); dllglScalef( x, y, z ); } static void APIENTRY logglScissor(GLint x, GLint y, GLsizei width, GLsizei height) { fprintf( winState.log_fp, "glScissor( %d, %d, %d, %d )\n", x, y, width, height ); fflush(winState.log_fp); dllglScissor( x, y, width, height ); } static void APIENTRY logglSelectBuffer(GLsizei size, GLuint *buffer) { SIG( "glSelectBuffer" ); dllglSelectBuffer( size, buffer ); } static void APIENTRY logglShadeModel(GLenum mode) { SIG( "glShadeModel" ); dllglShadeModel( mode ); } static void APIENTRY logglStencilFunc(GLenum func, GLint ref, GLuint mask) { SIG( "glStencilFunc" ); dllglStencilFunc( func, ref, mask ); } static void APIENTRY logglStencilMask(GLuint mask) { SIG( "glStencilMask" ); dllglStencilMask( mask ); } static void APIENTRY logglStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { SIG( "glStencilOp" ); dllglStencilOp( fail, zfail, zpass ); } static void APIENTRY logglTexCoord1d(GLdouble s) { SIG( "glTexCoord1d" ); dllglTexCoord1d( s ); } static void APIENTRY logglTexCoord1dv(const GLdouble *v) { SIG( "glTexCoord1dv" ); dllglTexCoord1dv( v ); } static void APIENTRY logglTexCoord1f(GLfloat s) { SIG( "glTexCoord1f" ); dllglTexCoord1f( s ); } static void APIENTRY logglTexCoord1fv(const GLfloat *v) { SIG( "glTexCoord1fv" ); dllglTexCoord1fv( v ); } static void APIENTRY logglTexCoord1i(GLint s) { SIG( "glTexCoord1i" ); dllglTexCoord1i( s ); } static void APIENTRY logglTexCoord1iv(const GLint *v) { SIG( "glTexCoord1iv" ); dllglTexCoord1iv( v ); } static void APIENTRY logglTexCoord1s(GLshort s) { SIG( "glTexCoord1s" ); dllglTexCoord1s( s ); } static void APIENTRY logglTexCoord1sv(const GLshort *v) { SIG( "glTexCoord1sv" ); dllglTexCoord1sv( v ); } static void APIENTRY logglTexCoord2d(GLdouble s, GLdouble t) { SIG( "glTexCoord2d" ); dllglTexCoord2d( s, t ); } static void APIENTRY logglTexCoord2dv(const GLdouble *v) { SIG( "glTexCoord2dv" ); dllglTexCoord2dv( v ); } static void APIENTRY logglTexCoord2f(GLfloat s, GLfloat t) { SIG( "glTexCoord2f" ); dllglTexCoord2f( s, t ); } static void APIENTRY logglTexCoord2fv(const GLfloat *v) { SIG( "glTexCoord2fv" ); dllglTexCoord2fv( v ); } static void APIENTRY logglTexCoord2i(GLint s, GLint t) { SIG( "glTexCoord2i" ); dllglTexCoord2i( s, t ); } static void APIENTRY logglTexCoord2iv(const GLint *v) { SIG( "glTexCoord2iv" ); dllglTexCoord2iv( v ); } static void APIENTRY logglTexCoord2s(GLshort s, GLshort t) { SIG( "glTexCoord2s" ); dllglTexCoord2s( s, t ); } static void APIENTRY logglTexCoord2sv(const GLshort *v) { SIG( "glTexCoord2sv" ); dllglTexCoord2sv( v ); } static void APIENTRY logglTexCoord3d(GLdouble s, GLdouble t, GLdouble r) { SIG( "glTexCoord3d" ); dllglTexCoord3d( s, t, r ); } static void APIENTRY logglTexCoord3dv(const GLdouble *v) { SIG( "glTexCoord3dv" ); dllglTexCoord3dv( v ); } static void APIENTRY logglTexCoord3f(GLfloat s, GLfloat t, GLfloat r) { SIG( "glTexCoord3f" ); dllglTexCoord3f( s, t, r ); } static void APIENTRY logglTexCoord3fv(const GLfloat *v) { SIG( "glTexCoord3fv" ); dllglTexCoord3fv( v ); } static void APIENTRY logglTexCoord3i(GLint s, GLint t, GLint r) { SIG( "glTexCoord3i" ); dllglTexCoord3i( s, t, r ); } static void APIENTRY logglTexCoord3iv(const GLint *v) { SIG( "glTexCoord3iv" ); dllglTexCoord3iv( v ); } static void APIENTRY logglTexCoord3s(GLshort s, GLshort t, GLshort r) { SIG( "glTexCoord3s" ); dllglTexCoord3s( s, t, r ); } static void APIENTRY logglTexCoord3sv(const GLshort *v) { SIG( "glTexCoord3sv" ); dllglTexCoord3sv( v ); } static void APIENTRY logglTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) { SIG( "glTexCoord4d" ); dllglTexCoord4d( s, t, r, q ); } static void APIENTRY logglTexCoord4dv(const GLdouble *v) { SIG( "glTexCoord4dv" ); dllglTexCoord4dv( v ); } static void APIENTRY logglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) { SIG( "glTexCoord4f" ); dllglTexCoord4f( s, t, r, q ); } static void APIENTRY logglTexCoord4fv(const GLfloat *v) { SIG( "glTexCoord4fv" ); dllglTexCoord4fv( v ); } static void APIENTRY logglTexCoord4i(GLint s, GLint t, GLint r, GLint q) { SIG( "glTexCoord4i" ); dllglTexCoord4i( s, t, r, q ); } static void APIENTRY logglTexCoord4iv(const GLint *v) { SIG( "glTexCoord4iv" ); dllglTexCoord4iv( v ); } static void APIENTRY logglTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) { SIG( "glTexCoord4s" ); dllglTexCoord4s( s, t, r, q ); } static void APIENTRY logglTexCoord4sv(const GLshort *v) { SIG( "glTexCoord4sv" ); dllglTexCoord4sv( v ); } static void APIENTRY logglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf( winState.log_fp, "glTexCoordPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride ); fflush(winState.log_fp); dllglTexCoordPointer( size, type, stride, pointer ); } static void APIENTRY logglTexEnvf(GLenum target, GLenum pname, GLfloat param) { fprintf( winState.log_fp, "glTexEnvf( 0x%x, 0x%x, %g )\n", target, pname, param ); fflush(winState.log_fp); dllglTexEnvf( target, pname, param ); } static void APIENTRY logglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) { SIG( "glTexEnvfv" ); dllglTexEnvfv( target, pname, params ); } static void APIENTRY logglTexEnvi(GLenum target, GLenum pname, GLint param) { fprintf( winState.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param ); fflush(winState.log_fp); dllglTexEnvi( target, pname, param ); } static void APIENTRY logglTexEnviv(GLenum target, GLenum pname, const GLint *params) { SIG( "glTexEnviv" ); dllglTexEnviv( target, pname, params ); } static void APIENTRY logglTexGend(GLenum coord, GLenum pname, GLdouble param) { SIG( "glTexGend" ); dllglTexGend( coord, pname, param ); } static void APIENTRY logglTexGendv(GLenum coord, GLenum pname, const GLdouble *params) { SIG( "glTexGendv" ); dllglTexGendv( coord, pname, params ); } static void APIENTRY logglTexGenf(GLenum coord, GLenum pname, GLfloat param) { SIG( "glTexGenf" ); dllglTexGenf( coord, pname, param ); } static void APIENTRY logglTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) { // fprintf( winState.log_fp, "glTexGenfv( %s, (%g, %g, %g, %g) )\n", CoordToString( coord ), params[0], params[1], params[2], params[3]); fflush(winState.log_fp); fprintf( winState.log_fp, "glTexGenfv( %s, MEM )\n", CoordToString( coord )); fflush(winState.log_fp); dllglTexGenfv( coord, pname, params ); } static void APIENTRY logglTexGeni(GLenum coord, GLenum pname, GLint param) { SIG( "glTexGeni" ); dllglTexGeni( coord, pname, param ); } static void APIENTRY logglTexGeniv(GLenum coord, GLenum pname, const GLint *params) { SIG( "glTexGeniv" ); dllglTexGeniv( coord, pname, params ); } static void APIENTRY logglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) { SIG( "glTexImage1D" ); dllglTexImage1D( target, level, internalformat, width, border, format, type, pixels ); } static void APIENTRY logglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { SIG( "glTexImage2D" ); dllglTexImage2D( target, level, internalformat, width, height, border, format, type, pixels ); } static void APIENTRY logglTexParameterf(GLenum target, GLenum pname, GLfloat param) { fprintf( winState.log_fp, "glTexParameterf( 0x%x, 0x%x, %g )\n", target, pname, param ); fflush(winState.log_fp); dllglTexParameterf( target, pname, param ); } static void APIENTRY logglTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { SIG( "glTexParameterfv" ); dllglTexParameterfv( target, pname, params ); } static void APIENTRY logglTexParameteri(GLenum target, GLenum pname, GLint param) { fprintf( winState.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param ); fflush(winState.log_fp); dllglTexParameteri( target, pname, param ); } static void APIENTRY logglTexParameteriv(GLenum target, GLenum pname, const GLint *params) { SIG( "glTexParameteriv" ); dllglTexParameteriv( target, pname, params ); } static void APIENTRY logglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { SIG( "glTexSubImage1D" ); dllglTexSubImage1D( target, level, xoffset, width, format, type, pixels ); } static void APIENTRY logglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { SIG( "glTexSubImage2D" ); dllglTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels ); } static void APIENTRY logglTranslated(GLdouble x, GLdouble y, GLdouble z) { SIG( "glTranslated" ); dllglTranslated( x, y, z ); } static void APIENTRY logglTranslatef(GLfloat x, GLfloat y, GLfloat z) { SIG( "glTranslatef" ); dllglTranslatef( x, y, z ); } static void APIENTRY logglVertex2d(GLdouble x, GLdouble y) { SIG( "glVertex2d" ); dllglVertex2d( x, y ); } static void APIENTRY logglVertex2dv(const GLdouble *v) { SIG( "glVertex2dv" ); dllglVertex2dv( v ); } static void APIENTRY logglVertex2f(GLfloat x, GLfloat y) { SIG( "glVertex2f" ); dllglVertex2f( x, y ); } static void APIENTRY logglVertex2fv(const GLfloat *v) { SIG( "glVertex2fv" ); dllglVertex2fv( v ); } static void APIENTRY logglVertex2i(GLint x, GLint y) { SIG( "glVertex2i" ); dllglVertex2i( x, y ); } static void APIENTRY logglVertex2iv(const GLint *v) { SIG( "glVertex2iv" ); dllglVertex2iv( v ); } static void APIENTRY logglVertex2s(GLshort x, GLshort y) { SIG( "glVertex2s" ); dllglVertex2s( x, y ); } static void APIENTRY logglVertex2sv(const GLshort *v) { SIG( "glVertex2sv" ); dllglVertex2sv( v ); } static void APIENTRY logglVertex3d(GLdouble x, GLdouble y, GLdouble z) { SIG( "glVertex3d" ); dllglVertex3d( x, y, z ); } static void APIENTRY logglVertex3dv(const GLdouble *v) { SIG( "glVertex3dv" ); dllglVertex3dv( v ); } static void APIENTRY logglVertex3f(GLfloat x, GLfloat y, GLfloat z) { SIG( "glVertex3f" ); dllglVertex3f( x, y, z ); } static void APIENTRY logglVertex3fv(const GLfloat *v) { SIG( "glVertex3fv" ); dllglVertex3fv( v ); } static void APIENTRY logglVertex3i(GLint x, GLint y, GLint z) { SIG( "glVertex3i" ); dllglVertex3i( x, y, z ); } static void APIENTRY logglVertex3iv(const GLint *v) { SIG( "glVertex3iv" ); dllglVertex3iv( v ); } static void APIENTRY logglVertex3s(GLshort x, GLshort y, GLshort z) { SIG( "glVertex3s" ); dllglVertex3s( x, y, z ); } static void APIENTRY logglVertex3sv(const GLshort *v) { SIG( "glVertex3sv" ); dllglVertex3sv( v ); } static void APIENTRY logglVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) { SIG( "glVertex4d" ); dllglVertex4d( x, y, z, w ); } static void APIENTRY logglVertex4dv(const GLdouble *v) { SIG( "glVertex4dv" ); dllglVertex4dv( v ); } static void APIENTRY logglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) { SIG( "glVertex4f" ); dllglVertex4f( x, y, z, w ); } static void APIENTRY logglVertex4fv(const GLfloat *v) { SIG( "glVertex4fv" ); dllglVertex4fv( v ); } static void APIENTRY logglVertex4i(GLint x, GLint y, GLint z, GLint w) { SIG( "glVertex4i" ); dllglVertex4i( x, y, z, w ); } static void APIENTRY logglVertex4iv(const GLint *v) { SIG( "glVertex4iv" ); dllglVertex4iv( v ); } static void APIENTRY logglVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) { SIG( "glVertex4s" ); dllglVertex4s( x, y, z, w ); } static void APIENTRY logglVertex4sv(const GLshort *v) { SIG( "glVertex4sv" ); dllglVertex4sv( v ); } static void APIENTRY logglVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { fprintf( winState.log_fp, "glVertexPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride ); fflush(winState.log_fp); dllglVertexPointer( size, type, stride, pointer ); } static void APIENTRY logglViewport(GLint x, GLint y, GLsizei width, GLsizei height) { fprintf( winState.log_fp, "glViewport( %d, %d, %d, %d )\n", x, y, width, height ); fflush(winState.log_fp); dllglViewport( x, y, width, height ); } static void APIENTRY logglColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* data) { AssertFatal(dllglColorTableEXT != NULL, "Error, shouldn't have called unsupported paletted_texture extension"); fprintf(winState.log_fp, "glColorTableEXT(%d, %d, %d, %d, %d, )\n", target, internalFormat, width, format, type); fflush(winState.log_fp); dllglColorTableEXT(target, internalFormat, width, format, type, data); } static void APIENTRY logglLockArraysEXT(GLint first, GLsizei count) { AssertFatal(dllglLockArraysEXT != NULL, "Error, shouldn't have called unsupported compiled_vertex_array extension"); fprintf( winState.log_fp, "glLockArraysEXT( %d, %d )\n", first, count); fflush(winState.log_fp); dllglLockArraysEXT(first, count); } static void APIENTRY logglUnlockArraysEXT() { AssertFatal(dllglLockArraysEXT != NULL, "Error, shouldn't have called unsupported compiled_vertex_array extension"); SIG("glUnlockArraysEXT"); dllglUnlockArraysEXT(); } /* ARB_multitexture */ static const char* gARBMTenums[] = { "GL_TEXTURE0_ARB", "GL_TEXTURE1_ARB", "GL_TEXTURE2_ARB", "GL_TEXTURE3_ARB", "GL_TEXTURE4_ARB", "GL_TEXTURE5_ARB", "GL_TEXTURE6_ARB", "GL_TEXTURE7_ARB", "GL_TEXTURE8_ARB", "GL_TEXTURE9_ARB", "GL_TEXTURE10_ARB", "GL_TEXTURE11_ARB", "GL_TEXTURE12_ARB", "GL_TEXTURE13_ARB", "GL_TEXTURE14_ARB", "GL_TEXTURE15_ARB", "GL_TEXTURE16_ARB", "GL_TEXTURE17_ARB", "GL_TEXTURE18_ARB", "GL_TEXTURE19_ARB", "GL_TEXTURE20_ARB", "GL_TEXTURE21_ARB", "GL_TEXTURE22_ARB", "GL_TEXTURE23_ARB", "GL_TEXTURE24_ARB", "GL_TEXTURE25_ARB", "GL_TEXTURE26_ARB", "GL_TEXTURE27_ARB", "GL_TEXTURE28_ARB", "GL_TEXTURE29_ARB", "GL_TEXTURE30_ARB", "GL_TEXTURE31_ARB" }; static void APIENTRY logglActiveTextureARB(GLenum target) { U32 index = target - GL_TEXTURE0_ARB; fprintf( winState.log_fp, "glActiveTexturesARB( %s )\n", gARBMTenums[index]); fflush(winState.log_fp); dllglActiveTextureARB(target); } static void APIENTRY logglClientActiveTextureARB(GLenum target) { U32 index = target - GL_TEXTURE0_ARB; fprintf( winState.log_fp, "glClientActiveTexturesARB( %s )\n", gARBMTenums[index]); fflush(winState.log_fp); dllglClientActiveTextureARB(target); } static void APIENTRY logglMultiTexCoord2fARB(GLenum texture, GLfloat x, GLfloat y) { U32 index = texture - GL_TEXTURE0_ARB; fprintf( winState.log_fp, "glMultiTexCoord2fARB( %s, %g, %g )\n", gARBMTenums[index], x, y); fflush(winState.log_fp); dllglMultiTexCoord2fARB(texture, x, y); } static void APIENTRY logglMultiTexCoord2fvARB(GLenum texture, const GLfloat* p) { U32 index = texture - GL_TEXTURE0_ARB; fprintf( winState.log_fp, "glMultiTexCoord2fARB( %s, [%g, %g] )\n", gARBMTenums[index], p[0], p[1]); fflush(winState.log_fp); dllglMultiTexCoord2fvARB(texture, p); } /* NV_vertex_array_range */ static void APIENTRY logglVertexArrayRangeNV(GLsizei length, void* pointer) { fprintf(winState.log_fp, "glVertexArrayRangeNV( %d, MEMORY )", length); fflush(winState.log_fp); dllglVertexArrayRangeNV(length, pointer); } static void APIENTRY logglFlushVertexArrayRangeNV() { SIG("glFlushVertexArrayRangeNV"); dllglFlushVertexArrayRangeNV(); } static void* APIENTRY logwglAllocateMemoryNV(GLsizei length, GLfloat read, GLfloat write, GLfloat priority) { fprintf(winState.log_fp, "wglAllocateMemoryNV( %d, %g, %g, %g)", length, read, write, priority); fflush(winState.log_fp); return dllwglAllocateMemoryNV(length, read, write, priority); } static void APIENTRY logwglFreeMemoryNV(void* pointer) { SIG("glFreeMemoryNV(MEM)"); dllwglFreeMemoryNV(pointer); } /* EXT_fog_coord */ static void APIENTRY logglFogCoordfEXT(GLfloat coord) { fprintf( winState.log_fp, "glFogCoordEXT(%g)\n", coord); fflush(winState.log_fp); dllglFogCoordfEXT(coord); } static void APIENTRY logglFogCoordPointerEXT(GLenum type, GLsizei stride, void *pointer) { fprintf( winState.log_fp, "glFogCoordPointerEXT(%s, %d, MEMORY)\n", TypeToString(type), stride); fflush(winState.log_fp); dllglFogCoordPointerEXT(type, stride, pointer); } /* ARB_texture_compression */ static void APIENTRY logglCompressedTexImage3DARB(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexImage3DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data); } static void APIENTRY logglCompressedTexImage2DARB(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexImage3DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data); } static void APIENTRY logglCompressedTexImage1DARB(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexImage3DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data); } static void APIENTRY logglCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexSubImage3DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); } static void APIENTRY logglCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexSubImage2DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data); } static void APIENTRY logglCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data) { fprintf( winState.log_fp, "glCompressedTexSubImage1DARB(...)\n"); fflush(winState.log_fp); dllglCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data); } static void APIENTRY logglGetCompressedTexImageARB(GLenum target, GLint lod, void* img) { fprintf( winState.log_fp, "glGetCompressedTexImage3DARB(...)\n"); fflush(winState.log_fp); dllglGetCompressedTexImageARB(target, lod, img); } /* EXT_vertex_buffer */ static GLboolean APIENTRY logglAvailableVertexBufferEXT() { fprintf( winState.log_fp, "glAvailableVertexBufferEXT(...)\n"); fflush(winState.log_fp); return dllglAvailableVertexBufferEXT(); } static GLint APIENTRY logglAllocateVertexBufferEXT(GLsizei size, GLint format, GLboolean preserve) { fprintf( winState.log_fp, "glAllocateVertexBufferEXT(...)\n"); fflush(winState.log_fp); return dllglAllocateVertexBufferEXT(size, format, preserve); } static void * APIENTRY logglLockVertexBufferEXT(GLint handle, GLsizei size) { fprintf( winState.log_fp, "glLockVertexBufferEXT(...)\n"); fflush(winState.log_fp); return dllglLockVertexBufferEXT(handle, size); } static void APIENTRY logglUnlockVertexBufferEXT(GLint handle) { fprintf( winState.log_fp, "glUnlockVertexBufferEXT(...)\n"); fflush(winState.log_fp); dllglUnlockVertexBufferEXT(handle); } static void APIENTRY logglSetVertexBufferEXT(GLint handle) { fprintf( winState.log_fp, "glSetVertexBufferEXT(...)\n"); fflush(winState.log_fp); dllglSetVertexBufferEXT(handle); } static void APIENTRY logglOffsetVertexBufferEXT(GLint handle, GLuint offset) { fprintf( winState.log_fp, "glOffsetVertexBufferEXT(...)\n"); fflush(winState.log_fp); dllglOffsetVertexBufferEXT(handle, offset); } static void APIENTRY logglFillVertexBufferEXT(GLint handle, GLint first, GLsizei count) { fprintf( winState.log_fp, "glFillVertexBufferEXT(...)\n"); fflush(winState.log_fp); dllglFillVertexBufferEXT(handle, first, count); } static void APIENTRY logglFreeVertexBufferEXT(GLint handle) { fprintf( winState.log_fp, "glFreeVertexBufferEXT(...)\n"); fflush(winState.log_fp); dllglFreeVertexBufferEXT(handle); } static void APIENTRY logglBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { fprintf( winState.log_fp, "glBlendColorEXT( %g, %g, %g, %g )\n", red, green, blue, alpha ); fflush(winState.log_fp); dllglBlendColorEXT(red, green, blue, alpha); } static void APIENTRY logglBlendEquationEXT(GLenum mode) { fprintf( winState.log_fp, "glBlendEquationEXT( %d )\n", mode ); fflush(winState.log_fp); dllglBlendEquationEXT(mode); } //------------------------------------------------------- static U32 getIndex(GLenum type, const void *indices, U32 i) { if(type == GL_UNSIGNED_BYTE) return ((U8 *) indices)[i]; else if(type == GL_UNSIGNED_SHORT) return ((U16 *) indices)[i]; else return ((U32 *) indices)[i]; } static BOOL WINAPI outlineSwapBuffers(HDC dc) { bool ret = dlldwglSwapBuffers(dc); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); return ret; } static void APIENTRY outlineDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { if(mode == GL_POLYGON) mode = GL_LINE_LOOP; if(mode == GL_POINTS || mode == GL_LINE_STRIP || mode == GL_LINE_LOOP || mode == GL_LINES) dllglDrawElements( mode, count, type, indices ); else { glBegin(GL_LINES); if(mode == GL_TRIANGLE_STRIP) { U32 i; for(i = 0; i < count - 1; i++) { dllglArrayElement(getIndex(type, indices, i)); dllglArrayElement(getIndex(type, indices, i + 1)); if(i + 2 != count) { dllglArrayElement(getIndex(type, indices, i)); dllglArrayElement(getIndex(type, indices, i + 2)); } } } else if(mode == GL_TRIANGLE_FAN) { for(U32 i = 1; i < count; i ++) { dllglArrayElement(getIndex(type, indices, 0)); dllglArrayElement(getIndex(type, indices, i)); if(i != count - 1) { dllglArrayElement(getIndex(type, indices, i)); dllglArrayElement(getIndex(type, indices, i + 1)); } } } else if(mode == GL_TRIANGLES) { for(U32 i = 3; i <= count; i += 3) { dllglArrayElement(getIndex(type, indices, i - 3)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 1)); dllglArrayElement(getIndex(type, indices, i - 3)); dllglArrayElement(getIndex(type, indices, i - 1)); } } else if(mode == GL_QUADS) { for(U32 i = 4; i <= count; i += 4) { dllglArrayElement(getIndex(type, indices, i - 4)); dllglArrayElement(getIndex(type, indices, i - 3)); dllglArrayElement(getIndex(type, indices, i - 3)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 1)); dllglArrayElement(getIndex(type, indices, i - 4)); dllglArrayElement(getIndex(type, indices, i - 1)); } } else if(mode == GL_QUAD_STRIP) { if(count < 4) return; dllglArrayElement(getIndex(type, indices, 0)); dllglArrayElement(getIndex(type, indices, 1)); for(U32 i = 4; i <= count; i += 2) { dllglArrayElement(getIndex(type, indices, i - 4)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 3)); dllglArrayElement(getIndex(type, indices, i - 1)); dllglArrayElement(getIndex(type, indices, i - 2)); dllglArrayElement(getIndex(type, indices, i - 1)); } } glEnd(); } } static void APIENTRY outlineDrawArrays(GLenum mode, GLint first, GLsizei count) { if(mode == GL_POLYGON) mode = GL_LINE_LOOP; if(mode == GL_POINTS || mode == GL_LINE_STRIP || mode == GL_LINE_LOOP || mode == GL_LINES) dllglDrawArrays( mode, first, count ); else { glBegin(GL_LINES); if(mode == GL_TRIANGLE_STRIP) { U32 i; for(i = 0; i < count - 1; i++) { dllglArrayElement(first + i); dllglArrayElement(first + i + 1); if(i + 2 != count) { dllglArrayElement(first + i); dllglArrayElement(first + i + 2); } } } else if(mode == GL_TRIANGLE_FAN) { for(U32 i = 1; i < count; i ++) { dllglArrayElement(first); dllglArrayElement(first + i); if(i != count - 1) { dllglArrayElement(first + i); dllglArrayElement(first + i + 1); } } } else if(mode == GL_TRIANGLES) { for(U32 i = 3; i <= count; i += 3) { dllglArrayElement(first + i - 3); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 1); dllglArrayElement(first + i - 3); dllglArrayElement(first + i - 1); } } else if(mode == GL_QUADS) { for(U32 i = 4; i <= count; i += 4) { dllglArrayElement(first + i - 4); dllglArrayElement(first + i - 3); dllglArrayElement(first + i - 3); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 1); dllglArrayElement(first + i - 4); dllglArrayElement(first + i - 1); } } else if(mode == GL_QUAD_STRIP) { if(count < 4) return; dllglArrayElement(first + 0); dllglArrayElement(first + 1); for(U32 i = 4; i <= count; i += 2) { dllglArrayElement(first + i - 4); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 3); dllglArrayElement(first + i - 1); dllglArrayElement(first + i - 2); dllglArrayElement(first + i - 1); } } glEnd(); } } static void APIENTRY perfDrawArrays(GLenum mode, GLint first, GLsizei count) { gGLState.primCount[gGLState.primMode]++; U32 tc = 0; if(mode == GL_TRIANGLES) tc = count / 3; else if(mode == GL_TRIANGLE_FAN || mode == GL_TRIANGLE_STRIP) tc = count - 2; gGLState.triCount[gGLState.primMode] += tc; dllglDrawArrays( mode, first, count ); } static void APIENTRY perfDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { gGLState.primCount[gGLState.primMode]++; U32 tc = 0; if(mode == GL_TRIANGLES) tc = count / 3; else if(mode == GL_TRIANGLE_FAN || mode == GL_TRIANGLE_STRIP) tc = count - 2; gGLState.triCount[gGLState.primMode] += tc; dllglDrawElements( mode, count, type, indices ); } #if defined (TORQUE_DEBUG) || defined(INTERNAL_RELEASE) ConsoleFunction(GLEnableLogging, void, 2, 2, "GLEnableLogging(bool);") { argc; bool enable = dAtob(argv[1]); if(loggingEnabled == enable) return; if(enable && (outlineEnabled || perfEnabled)) return; loggingEnabled = enable; if ( enable ) { if ( !winState.log_fp ) { struct tm *newtime; time_t aclock; time( &aclock ); newtime = localtime( &aclock ); asctime( newtime ); winState.log_fp = fopen( "gl_log.txt", "wt" ); fprintf( winState.log_fp, "%s\n", asctime( newtime ) ); fflush(winState.log_fp); } #define GL_FUNCTION(fn_type, fn_name, fn_args, fn_body) fn_name = log##fn_name; #include "platform/GLCoreFunc.h" #include "platform/GLExtFunc.h" #include "platform/GLUFunc.h" #undef GL_FUNCTION } else { if ( winState.log_fp ) { fprintf( winState.log_fp, "*** CLOSING LOG ***\n" ); fflush(winState.log_fp); fclose( winState.log_fp ); winState.log_fp = NULL; } #define GL_FUNCTION(fn_type, fn_name, fn_args, fn_body) fn_name = dll##fn_name; #include "platform/GLCoreFunc.h" #include "platform/GLExtFunc.h" #include "platform/GLUFunc.h" #undef GL_FUNCTION } } #endif ConsoleFunction(GLEnableOutline, void, 2, 2, "GLEnableOutline(bool);") { argc; bool enable = dAtob(argv[1]); if(outlineEnabled == enable) return; if(enable && (loggingEnabled || perfEnabled)) return; outlineEnabled = enable; if ( enable ) { glDrawElements = outlineDrawElements; glDrawArrays = outlineDrawArrays; dwglSwapBuffers = outlineSwapBuffers; } else { glDrawElements = dllglDrawElements; glDrawArrays = dllglDrawArrays; dwglSwapBuffers = dlldwglSwapBuffers; } } ConsoleFunction(GLEnableMetrics, void, 2, 2, "GLEnableMetrics(bool);") { argc; static bool varsAdded = false; if(!varsAdded) { Con::addVariable("OpenGL::triCount0", TypeS32, &gGLState.triCount[0]); Con::addVariable("OpenGL::triCount1", TypeS32, &gGLState.triCount[1]); Con::addVariable("OpenGL::triCount2", TypeS32, &gGLState.triCount[2]); Con::addVariable("OpenGL::triCount3", TypeS32, &gGLState.triCount[3]); Con::addVariable("OpenGL::primCount0", TypeS32, &gGLState.primCount[0]); Con::addVariable("OpenGL::primCount1", TypeS32, &gGLState.primCount[1]); Con::addVariable("OpenGL::primCount2", TypeS32, &gGLState.primCount[2]); Con::addVariable("OpenGL::primCount3", TypeS32, &gGLState.primCount[3]); varsAdded = true; } bool enable = dAtob(argv[1]); if(perfEnabled == enable) return; if(enable && (loggingEnabled || outlineEnabled)) return; perfEnabled = enable; if ( enable ) { glDrawElements = perfDrawElements; glDrawArrays = perfDrawArrays; } else { glDrawElements = dllglDrawElements; glDrawArrays = dllglDrawArrays; } }