diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 47eef49..5edbbc4 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -8,6 +8,8 @@
 #       spec files are located. These files are part of the OpenGL
 #       sample implementation CVS tree and are located in
 #       CVS_ROOT/projects/ogl-sample/main/doc/registry/specs.
+#       You can find them on the web at the following URL :
+#         http://oss.sgi.com/cgi-bin/cvsweb.cgi/projects/ogl-sample/main/doc/registry/specs/
 #
 #     - opengl_version is the OpenGL version emulated by the library
 #       (can be 1.0 to 1.2).
@@ -34,56 +36,63 @@
 #
 
 #
-# This functions generates the thunk for a given function.
+# Files to generate
 #
-sub GenerateThunk {
-    my ($func_ref, $comment, $prefix, $thread_safe) = @_;
-    my ($ret) = ("");
-    my ($call_arg) = ("");
+$spec_file = "opengl32.spec";
+$norm_file = "opengl_norm.c";
+$ext_file  = "opengl_ext.c";
 
-    # If for opengl_norm.c, generate a nice heading otherwise Patrik won't be happy :-)
-    if ($comment eq 1) {
-	$ret = $ret . "/***********************************************************************\n";
-	$ret = $ret . " *              " . $func_ref->[0] . "\n";
-	$ret = $ret . " */\n";
-    }
-    $ret = $ret . $func_ref->[1] . " WINAPI wine_" . $func_ref->[0] . "( ";
-    for ($i = 0; $i <= $#{@{$func_ref->[2]}}; $i++) {
-	$type = $func_ref->[2]->[$i]->[0];
-	$name = $func_ref->[2]->[$i]->[1];
-	$ret = $ret . "$type $name";
-	$call_arg = $call_arg . "$name";
-	if ($i != $#{@{$func_ref->[2]}}) {
-	    $ret = $ret . ", ";
-	    $call_arg = $call_arg . ", ";
-	} else {
-	    $ret = $ret . " ";
-	    $call_arg = $call_arg . " ";
-	}
-    }
-    $ret = $ret . ") {\n";
-    if ($func_ref->[1] ne "void") {
-	$ret = $ret . "  " . $func_ref->[1] . " ret_value;\n";
-    }
-    if ($thread_safe) {
-	$ret = $ret . "  ENTER_GL();\n";
-    }
-    $ret = $ret . "  ";
-    if ($func_ref->[1] ne "void") {
-	$ret = $ret . "ret_value = ";
-    }
-    $ret = $ret . $prefix . $func_ref->[0] . "( " . $call_arg . ");\n";
-    if ($thread_safe) {
-	$ret = $ret . "  LEAVE_GL();\n";
-    }
-    if ($func_ref->[1] ne "void") {
-	$ret = $ret . "  return ret_value;\n"
-    }
-    $ret = $ret . "}\n";
+# Set to 0 for removing the ENTER / LEAVE GL calls
+$gen_thread_safe = 1;
+# Prefix used for the local variables
+$ext_prefix = "func_";
+# If set to 1, generate TRACEs for each OpenGL function
+$gen_traces = 1;
 
-    # Return this string....
-    $ret;
-}
+#
+# List of categories to put in the 'opengl_norm.c' file
+#
+%cat_1_0 = ( "display-list" => 1, 
+	     "drawing" => 1, 
+	     "drawing-control" => 1, 
+	     "feedback" => 1, 
+	     "framebuf" => 1, 
+	     "misc" => 1, 
+	     "modeling" => 1, 
+	     "pixel-op" => 1, 
+	     "pixel-rw" => 1, 
+	     "state-req" => 1, 
+	     "xform" => 1 );
+%cat_1_1 = ( %cat_1_0, 
+	     "1_1" => 1 );
+%cat_1_2 = ( %cat_1_1, 
+	     "VERSION_1_2" => 1, 
+	     "ARB_multitexture" => 1 );
+
+%norm_categories = ();
+
+#
+# This hash table gives the conversion between OpenGL types and what
+# is used by the TRACE printfs
+#
+%debug_conv = 
+    ("GLbitfield" => "%d",
+     "GLboolean" => "%d",
+     "GLbyte" => "%d",
+     "GLclampd" => "%f",
+     "GLclampf" => "%f",
+     "GLdouble" => "%f",
+     "GLenum" => "%d",
+     "GLfloat" => "%f",
+     "GLint" => "%d",
+     "GLshort" => "%d",
+     "GLsizei" => "%d",
+     "GLstring" => "%s",
+     "GLubyte" => "%d",
+     "GLuint" => "%d",
+     "GLushort" => "%d",
+     "GLvoid" => "(void)",
+     "_GLfuncptr" => "%p");
 
 #
 # This hash table gives the conversion between OpenGL types and what
@@ -109,38 +118,70 @@
      "_GLfuncptr" => [ "ptr", 4 ]);
 
 #
-# Files to generate
+# This functions generates the thunk for a given function.
 #
-$spec_file = "opengl32.spec";
-$norm_file = "opengl_norm.c";
-$ext_file  = "opengl_ext.c";
+sub GenerateThunk {
+    my ($func_ref, $comment, $prefix, $thread_safe) = @_;
+    my ($ret) = ("");
+    my ($call_arg) = ("");
+    my ($trace_arg) = ("");
 
-# Set to 0 for removing the ENTER / LEAVE GL calls
-$gen_thread_safe = 1;
-# Prefix used for the local variables
-$ext_prefix = "func_";
+    # If for opengl_norm.c, generate a nice heading otherwise Patrik won't be happy :-)
+    if ($comment eq 1) {
+	$ret = $ret . "/***********************************************************************\n";
+	$ret = $ret . " *              " . $func_ref->[0] . "\n";
+	$ret = $ret . " */\n";
+    }
+    $ret = $ret . $func_ref->[1] . " WINAPI wine_" . $func_ref->[0] . "( ";
+    for ($i = 0; $i <= $#{@{$func_ref->[2]}}; $i++) {
+	$type = $func_ref->[2]->[$i]->[0];
+	$name = $func_ref->[2]->[$i]->[1];
+	$ret = $ret . "$type $name";
+	$call_arg = $call_arg . "$name";
+	if ($type =~ /\*/) {
+	    $trace_arg = $trace_arg . "%p";
+	} else {
+	    $trace_arg = $trace_arg . $debug_conv{$type};
+	}
+	if ($i != $#{@{$func_ref->[2]}}) {
+	    $ret = $ret . ", ";
+	    $call_arg = $call_arg . ", ";
+	    $trace_arg = $trace_arg . ", ";
+	} else {
+	    $ret = $ret . " ";
+	    $call_arg = $call_arg . " ";
+	}
+    }
+    $ret = $ret . ") {\n";
+    if ($func_ref->[1] ne "void") {
+	$ret = $ret . "  " . $func_ref->[1] . " ret_value;\n";
+    }
+    if ($gen_traces) {
+	$ret = $ret . "  TRACE(\"(" . $trace_arg . ")\\n\"";
+	if ($trace_arg ne "") {
+	    $ret = $ret . ", " . $call_arg;
+	}
+	$ret = $ret . ");\n";
+    }
+    if ($thread_safe) {
+	$ret = $ret . "  ENTER_GL();\n";
+    }
+    $ret = $ret . "  ";
+    if ($func_ref->[1] ne "void") {
+	$ret = $ret . "ret_value = ";
+    }
+    $ret = $ret . $prefix . $func_ref->[0] . "( " . $call_arg . ");\n";
+    if ($thread_safe) {
+	$ret = $ret . "  LEAVE_GL();\n";
+    }
+    if ($func_ref->[1] ne "void") {
+	$ret = $ret . "  return ret_value;\n"
+    }
+    $ret = $ret . "}\n";
 
-#
-# List of categories to put in the 'opengl_norm.c' file
-#
-%cat_1_0 = ( "display-list" => 1, 
-	     "drawing" => 1, 
-	     "drawing-control" => 1, 
-	     "feedback" => 1, 
-	     "framebuf" => 1, 
-	     "misc" => 1, 
-	     "modeling" => 1, 
-	     "pixel-op" => 1, 
-	     "pixel-rw" => 1, 
-	     "state-req" => 1, 
-	     "xform" => 1 );
-%cat_1_1 = ( %cat_1_0, 
-	     "1_1" => 1 );
-%cat_1_2 = ( %cat_1_1, 
-	     "VERSION_1_2" => 1, 
-	     "ARB_multitexture" => 1 );
-
-%norm_categories = ();
+    # Return this string....
+    $ret;
+}
 
 #
 # Extract and checks the number of arguments
@@ -177,6 +218,11 @@
 }
 # This is to override the 'void' -> '*' bogus conversion
 $pseudo_to_opengl{"void"} = "void";
+# This is a bug in the spec file...
+$pseudo_to_opengl{"FfdTargetSGIX"} = "GLint";
+$pseudo_to_opengl{"FfdMaskSGIX"} = "GLint";
+$pseudo_to_opengl{"IglooFunctionSelectSGIX"} = "GLint";
+$pseudo_to_opengl{"IglooParameterSGIX"} = "GLint";
 
 #
 # Then, create the list of all OpenGL functions using the 'gl.spec'
@@ -322,8 +368,12 @@
 print SPEC "
 name opengl32
 type win32
+
 init OpenGL32_Init
 import x11drv
+import kernel32
+
+debug_channels (opengl)
 
 @  stdcall wglCreateContext(long) wglCreateContext
 @  stdcall wglCreateLayerContext(long long) wglCreateLayerContext
@@ -378,9 +428,12 @@
 
 #include \"config.h\"
 #include \"wine_gl.h\"
+#include \"debugtools.h\"
 
 typedef const GLubyte * GLstring;
 
+DEFAULT_DEBUG_CHANNEL(opengl);
+
 ";
 foreach (sort keys %norm_functions) {
     $string = GenerateThunk($norm_functions{$_}, 1, "", $gen_thread_safe);
@@ -398,11 +451,14 @@
 
 #include \"config.h\"
 #include \"wine_gl.h\"
+#include \"debugtools.h\"
 
 typedef const GLubyte * GLstring;
 
 #include \"opengl_ext.h\"
 
+DEFAULT_DEBUG_CHANNEL(opengl);
+
 ";
 
 # First, generate the function pointers
diff --git a/dlls/opengl32/opengl32.spec b/dlls/opengl32/opengl32.spec
index ac7588f..2596a79 100644
--- a/dlls/opengl32/opengl32.spec
+++ b/dlls/opengl32/opengl32.spec
@@ -1,7 +1,8 @@
+
 name opengl32
 type win32
-init OpenGL32_Init
 
+init OpenGL32_Init
 import x11drv
 import kernel32
 
diff --git a/dlls/opengl32/opengl_ext.c b/dlls/opengl32/opengl_ext.c
index f79ef33..79dfd03 100644
--- a/dlls/opengl32/opengl_ext.c
+++ b/dlls/opengl32/opengl_ext.c
@@ -3,14 +3,18 @@
 
 #include "config.h"
 #include "wine_gl.h"
+#include "debugtools.h"
 
 typedef const GLubyte * GLstring;
 
 #include "opengl_ext.h"
 
+DEFAULT_DEBUG_CHANNEL(opengl);
+
 void (*func_glApplyTextureEXT)( GLenum ) = (void *) 0xdeadbeef;
 GLboolean (*func_glAreTexturesResidentEXT)( GLsizei, GLuint*, GLboolean* ) = (void *) 0xdeadbeef;
 void (*func_glArrayElementEXT)( GLint ) = (void *) 0xdeadbeef;
+void (*func_glAsyncMarkerSGIX)( GLuint ) = (void *) 0xdeadbeef;
 void (*func_glBindTextureEXT)( GLenum, GLuint ) = (void *) 0xdeadbeef;
 void (*func_glBinormal3bEXT)( GLbyte, GLbyte, GLbyte ) = (void *) 0xdeadbeef;
 void (*func_glBinormal3bvEXT)( GLbyte* ) = (void *) 0xdeadbeef;
@@ -71,6 +75,10 @@
 void (*func_glCopyTexSubImage3DEXT)( GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = (void *) 0xdeadbeef;
 void (*func_glCullParameterdvEXT)( GLenum, GLdouble* ) = (void *) 0xdeadbeef;
 void (*func_glCullParameterfvEXT)( GLenum, GLfloat* ) = (void *) 0xdeadbeef;
+void (*func_glDeformSGIX)( GLint ) = (void *) 0xdeadbeef;
+void (*func_glDeformationMap3dSGIX)( GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble* ) = (void *) 0xdeadbeef;
+void (*func_glDeformationMap3fSGIX)( GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat* ) = (void *) 0xdeadbeef;
+void (*func_glDeleteAsyncMarkersSGIX)( GLuint, GLsizei ) = (void *) 0xdeadbeef;
 void (*func_glDeleteTexturesEXT)( GLsizei, GLuint* ) = (void *) 0xdeadbeef;
 void (*func_glDetailTexFuncSGIS)( GLenum, GLsizei, GLfloat* ) = (void *) 0xdeadbeef;
 void (*func_glDrawArraysEXT)( GLenum, GLint, GLsizei ) = (void *) 0xdeadbeef;
@@ -78,6 +86,7 @@
 void (*func_glEdgeFlagPointerEXT)( GLsizei, GLsizei, GLboolean* ) = (void *) 0xdeadbeef;
 void (*func_glEdgeFlagPointerListIBM)( GLint, GLboolean**, GLint ) = (void *) 0xdeadbeef;
 void (*func_glFinalCombinerInputNV)( GLenum, GLenum, GLenum, GLenum ) = (void *) 0xdeadbeef;
+GLint (*func_glFinishAsyncSGIX)( GLuint* ) = (void *) 0xdeadbeef;
 void (*func_glFinishTextureSUNX)( ) = (void *) 0xdeadbeef;
 void (*func_glFlushRasterSGIX)( ) = (void *) 0xdeadbeef;
 void (*func_glFlushVertexArrayRangeNV)( ) = (void *) 0xdeadbeef;
@@ -102,6 +111,7 @@
 void (*func_glFragmentMaterialiSGIX)( GLenum, GLenum, GLint ) = (void *) 0xdeadbeef;
 void (*func_glFragmentMaterialivSGIX)( GLenum, GLenum, GLint* ) = (void *) 0xdeadbeef;
 void (*func_glFrameZoomSGIX)( GLint ) = (void *) 0xdeadbeef;
+GLuint (*func_glGenAsyncMarkersSGIX)( GLsizei ) = (void *) 0xdeadbeef;
 void (*func_glGenTexturesEXT)( GLsizei, GLuint* ) = (void *) 0xdeadbeef;
 void (*func_glGetColorTableEXT)( GLenum, GLenum, GLenum, GLvoid* ) = (void *) 0xdeadbeef;
 void (*func_glGetColorTableParameterfvEXT)( GLenum, GLenum, GLfloat* ) = (void *) 0xdeadbeef;
@@ -152,6 +162,7 @@
 void (*func_glGlobalAlphaFactorusSUN)( GLushort ) = (void *) 0xdeadbeef;
 void (*func_glHintPGI)( GLenum, GLint ) = (void *) 0xdeadbeef;
 void (*func_glHistogramEXT)( GLenum, GLsizei, GLenum, GLboolean ) = (void *) 0xdeadbeef;
+void (*func_glIglooInterfaceSGIX)( GLint, GLint* ) = (void *) 0xdeadbeef;
 void (*func_glImageTransformParameterfHP)( GLenum, GLenum, GLfloat ) = (void *) 0xdeadbeef;
 void (*func_glImageTransformParameterfvHP)( GLenum, GLenum, GLfloat* ) = (void *) 0xdeadbeef;
 void (*func_glImageTransformParameteriHP)( GLenum, GLenum, GLint ) = (void *) 0xdeadbeef;
@@ -161,12 +172,14 @@
 void (*func_glIndexPointerEXT)( GLenum, GLsizei, GLsizei, GLvoid* ) = (void *) 0xdeadbeef;
 void (*func_glIndexPointerListIBM)( GLenum, GLint, GLvoid**, GLint ) = (void *) 0xdeadbeef;
 void (*func_glInstrumentsBufferSGIX)( GLsizei, GLint* ) = (void *) 0xdeadbeef;
+GLboolean (*func_glIsAsyncMarkerSGIX)( GLuint ) = (void *) 0xdeadbeef;
 GLboolean (*func_glIsTextureEXT)( GLuint ) = (void *) 0xdeadbeef;
 void (*func_glLightEnviSGIX)( GLenum, GLint ) = (void *) 0xdeadbeef;
 void (*func_glListParameterfSGIX)( GLuint, GLenum, GLfloat ) = (void *) 0xdeadbeef;
 void (*func_glListParameterfvSGIX)( GLuint, GLenum, GLfloat* ) = (void *) 0xdeadbeef;
 void (*func_glListParameteriSGIX)( GLuint, GLenum, GLint ) = (void *) 0xdeadbeef;
 void (*func_glListParameterivSGIX)( GLuint, GLenum, GLint* ) = (void *) 0xdeadbeef;
+void (*func_glLoadIdentityDeformationMapSGIX)( GLint ) = (void *) 0xdeadbeef;
 void (*func_glLoadTransposeMatrixdARB)( GLdouble* ) = (void *) 0xdeadbeef;
 void (*func_glLoadTransposeMatrixfARB)( GLfloat* ) = (void *) 0xdeadbeef;
 void (*func_glLockArraysEXT)( GLint, GLsizei ) = (void *) 0xdeadbeef;
@@ -195,6 +208,7 @@
 void (*func_glPointParameterfSGIS)( GLenum, GLfloat ) = (void *) 0xdeadbeef;
 void (*func_glPointParameterfvEXT)( GLenum, GLfloat* ) = (void *) 0xdeadbeef;
 void (*func_glPointParameterfvSGIS)( GLenum, GLfloat* ) = (void *) 0xdeadbeef;
+GLint (*func_glPollAsyncSGIX)( GLuint* ) = (void *) 0xdeadbeef;
 GLint (*func_glPollInstrumentsSGIX)( GLint* ) = (void *) 0xdeadbeef;
 void (*func_glPolygonOffsetEXT)( GLfloat, GLfloat ) = (void *) 0xdeadbeef;
 void (*func_glPrioritizeTexturesEXT)( GLsizei, GLuint*, GLclampf* ) = (void *) 0xdeadbeef;
@@ -337,6 +351,7 @@
 void WINAPI wine_glApplyTextureEXT( GLenum );
 GLboolean WINAPI wine_glAreTexturesResidentEXT( GLsizei, GLuint*, GLboolean* );
 void WINAPI wine_glArrayElementEXT( GLint );
+void WINAPI wine_glAsyncMarkerSGIX( GLuint );
 void WINAPI wine_glBindTextureEXT( GLenum, GLuint );
 void WINAPI wine_glBinormal3bEXT( GLbyte, GLbyte, GLbyte );
 void WINAPI wine_glBinormal3bvEXT( GLbyte* );
@@ -397,6 +412,10 @@
 void WINAPI wine_glCopyTexSubImage3DEXT( GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei );
 void WINAPI wine_glCullParameterdvEXT( GLenum, GLdouble* );
 void WINAPI wine_glCullParameterfvEXT( GLenum, GLfloat* );
+void WINAPI wine_glDeformSGIX( GLint );
+void WINAPI wine_glDeformationMap3dSGIX( GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble* );
+void WINAPI wine_glDeformationMap3fSGIX( GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat* );
+void WINAPI wine_glDeleteAsyncMarkersSGIX( GLuint, GLsizei );
 void WINAPI wine_glDeleteTexturesEXT( GLsizei, GLuint* );
 void WINAPI wine_glDetailTexFuncSGIS( GLenum, GLsizei, GLfloat* );
 void WINAPI wine_glDrawArraysEXT( GLenum, GLint, GLsizei );
@@ -404,6 +423,7 @@
 void WINAPI wine_glEdgeFlagPointerEXT( GLsizei, GLsizei, GLboolean* );
 void WINAPI wine_glEdgeFlagPointerListIBM( GLint, GLboolean**, GLint );
 void WINAPI wine_glFinalCombinerInputNV( GLenum, GLenum, GLenum, GLenum );
+GLint WINAPI wine_glFinishAsyncSGIX( GLuint* );
 void WINAPI wine_glFinishTextureSUNX( );
 void WINAPI wine_glFlushRasterSGIX( );
 void WINAPI wine_glFlushVertexArrayRangeNV( );
@@ -428,6 +448,7 @@
 void WINAPI wine_glFragmentMaterialiSGIX( GLenum, GLenum, GLint );
 void WINAPI wine_glFragmentMaterialivSGIX( GLenum, GLenum, GLint* );
 void WINAPI wine_glFrameZoomSGIX( GLint );
+GLuint WINAPI wine_glGenAsyncMarkersSGIX( GLsizei );
 void WINAPI wine_glGenTexturesEXT( GLsizei, GLuint* );
 void WINAPI wine_glGetColorTableEXT( GLenum, GLenum, GLenum, GLvoid* );
 void WINAPI wine_glGetColorTableParameterfvEXT( GLenum, GLenum, GLfloat* );
@@ -478,6 +499,7 @@
 void WINAPI wine_glGlobalAlphaFactorusSUN( GLushort );
 void WINAPI wine_glHintPGI( GLenum, GLint );
 void WINAPI wine_glHistogramEXT( GLenum, GLsizei, GLenum, GLboolean );
+void WINAPI wine_glIglooInterfaceSGIX( GLint, GLint* );
 void WINAPI wine_glImageTransformParameterfHP( GLenum, GLenum, GLfloat );
 void WINAPI wine_glImageTransformParameterfvHP( GLenum, GLenum, GLfloat* );
 void WINAPI wine_glImageTransformParameteriHP( GLenum, GLenum, GLint );
@@ -487,12 +509,14 @@
 void WINAPI wine_glIndexPointerEXT( GLenum, GLsizei, GLsizei, GLvoid* );
 void WINAPI wine_glIndexPointerListIBM( GLenum, GLint, GLvoid**, GLint );
 void WINAPI wine_glInstrumentsBufferSGIX( GLsizei, GLint* );
+GLboolean WINAPI wine_glIsAsyncMarkerSGIX( GLuint );
 GLboolean WINAPI wine_glIsTextureEXT( GLuint );
 void WINAPI wine_glLightEnviSGIX( GLenum, GLint );
 void WINAPI wine_glListParameterfSGIX( GLuint, GLenum, GLfloat );
 void WINAPI wine_glListParameterfvSGIX( GLuint, GLenum, GLfloat* );
 void WINAPI wine_glListParameteriSGIX( GLuint, GLenum, GLint );
 void WINAPI wine_glListParameterivSGIX( GLuint, GLenum, GLint* );
+void WINAPI wine_glLoadIdentityDeformationMapSGIX( GLint );
 void WINAPI wine_glLoadTransposeMatrixdARB( GLdouble* );
 void WINAPI wine_glLoadTransposeMatrixfARB( GLfloat* );
 void WINAPI wine_glLockArraysEXT( GLint, GLsizei );
@@ -521,6 +545,7 @@
 void WINAPI wine_glPointParameterfSGIS( GLenum, GLfloat );
 void WINAPI wine_glPointParameterfvEXT( GLenum, GLfloat* );
 void WINAPI wine_glPointParameterfvSGIS( GLenum, GLfloat* );
+GLint WINAPI wine_glPollAsyncSGIX( GLuint* );
 GLint WINAPI wine_glPollInstrumentsSGIX( GLint* );
 void WINAPI wine_glPolygonOffsetEXT( GLfloat, GLfloat );
 void WINAPI wine_glPrioritizeTexturesEXT( GLsizei, GLuint*, GLclampf* );
@@ -660,11 +685,12 @@
 
 
 /* The table giving the correspondance between names and functions */
-int extension_registry_size = 323;
-OpenGL_extension extension_registry[323] = {
+int extension_registry_size = 334;
+OpenGL_extension extension_registry[334] = {
   { "glApplyTextureEXT", (void *) wine_glApplyTextureEXT, (void **) (&func_glApplyTextureEXT) },
   { "glAreTexturesResidentEXT", (void *) wine_glAreTexturesResidentEXT, (void **) (&func_glAreTexturesResidentEXT) },
   { "glArrayElementEXT", (void *) wine_glArrayElementEXT, (void **) (&func_glArrayElementEXT) },
+  { "glAsyncMarkerSGIX", (void *) wine_glAsyncMarkerSGIX, (void **) (&func_glAsyncMarkerSGIX) },
   { "glBindTextureEXT", (void *) wine_glBindTextureEXT, (void **) (&func_glBindTextureEXT) },
   { "glBinormal3bEXT", (void *) wine_glBinormal3bEXT, (void **) (&func_glBinormal3bEXT) },
   { "glBinormal3bvEXT", (void *) wine_glBinormal3bvEXT, (void **) (&func_glBinormal3bvEXT) },
@@ -725,6 +751,10 @@
   { "glCopyTexSubImage3DEXT", (void *) wine_glCopyTexSubImage3DEXT, (void **) (&func_glCopyTexSubImage3DEXT) },
   { "glCullParameterdvEXT", (void *) wine_glCullParameterdvEXT, (void **) (&func_glCullParameterdvEXT) },
   { "glCullParameterfvEXT", (void *) wine_glCullParameterfvEXT, (void **) (&func_glCullParameterfvEXT) },
+  { "glDeformSGIX", (void *) wine_glDeformSGIX, (void **) (&func_glDeformSGIX) },
+  { "glDeformationMap3dSGIX", (void *) wine_glDeformationMap3dSGIX, (void **) (&func_glDeformationMap3dSGIX) },
+  { "glDeformationMap3fSGIX", (void *) wine_glDeformationMap3fSGIX, (void **) (&func_glDeformationMap3fSGIX) },
+  { "glDeleteAsyncMarkersSGIX", (void *) wine_glDeleteAsyncMarkersSGIX, (void **) (&func_glDeleteAsyncMarkersSGIX) },
   { "glDeleteTexturesEXT", (void *) wine_glDeleteTexturesEXT, (void **) (&func_glDeleteTexturesEXT) },
   { "glDetailTexFuncSGIS", (void *) wine_glDetailTexFuncSGIS, (void **) (&func_glDetailTexFuncSGIS) },
   { "glDrawArraysEXT", (void *) wine_glDrawArraysEXT, (void **) (&func_glDrawArraysEXT) },
@@ -732,6 +762,7 @@
   { "glEdgeFlagPointerEXT", (void *) wine_glEdgeFlagPointerEXT, (void **) (&func_glEdgeFlagPointerEXT) },
   { "glEdgeFlagPointerListIBM", (void *) wine_glEdgeFlagPointerListIBM, (void **) (&func_glEdgeFlagPointerListIBM) },
   { "glFinalCombinerInputNV", (void *) wine_glFinalCombinerInputNV, (void **) (&func_glFinalCombinerInputNV) },
+  { "glFinishAsyncSGIX", (void *) wine_glFinishAsyncSGIX, (void **) (&func_glFinishAsyncSGIX) },
   { "glFinishTextureSUNX", (void *) wine_glFinishTextureSUNX, (void **) (&func_glFinishTextureSUNX) },
   { "glFlushRasterSGIX", (void *) wine_glFlushRasterSGIX, (void **) (&func_glFlushRasterSGIX) },
   { "glFlushVertexArrayRangeNV", (void *) wine_glFlushVertexArrayRangeNV, (void **) (&func_glFlushVertexArrayRangeNV) },
@@ -756,6 +787,7 @@
   { "glFragmentMaterialiSGIX", (void *) wine_glFragmentMaterialiSGIX, (void **) (&func_glFragmentMaterialiSGIX) },
   { "glFragmentMaterialivSGIX", (void *) wine_glFragmentMaterialivSGIX, (void **) (&func_glFragmentMaterialivSGIX) },
   { "glFrameZoomSGIX", (void *) wine_glFrameZoomSGIX, (void **) (&func_glFrameZoomSGIX) },
+  { "glGenAsyncMarkersSGIX", (void *) wine_glGenAsyncMarkersSGIX, (void **) (&func_glGenAsyncMarkersSGIX) },
   { "glGenTexturesEXT", (void *) wine_glGenTexturesEXT, (void **) (&func_glGenTexturesEXT) },
   { "glGetColorTableEXT", (void *) wine_glGetColorTableEXT, (void **) (&func_glGetColorTableEXT) },
   { "glGetColorTableParameterfvEXT", (void *) wine_glGetColorTableParameterfvEXT, (void **) (&func_glGetColorTableParameterfvEXT) },
@@ -806,6 +838,7 @@
   { "glGlobalAlphaFactorusSUN", (void *) wine_glGlobalAlphaFactorusSUN, (void **) (&func_glGlobalAlphaFactorusSUN) },
   { "glHintPGI", (void *) wine_glHintPGI, (void **) (&func_glHintPGI) },
   { "glHistogramEXT", (void *) wine_glHistogramEXT, (void **) (&func_glHistogramEXT) },
+  { "glIglooInterfaceSGIX", (void *) wine_glIglooInterfaceSGIX, (void **) (&func_glIglooInterfaceSGIX) },
   { "glImageTransformParameterfHP", (void *) wine_glImageTransformParameterfHP, (void **) (&func_glImageTransformParameterfHP) },
   { "glImageTransformParameterfvHP", (void *) wine_glImageTransformParameterfvHP, (void **) (&func_glImageTransformParameterfvHP) },
   { "glImageTransformParameteriHP", (void *) wine_glImageTransformParameteriHP, (void **) (&func_glImageTransformParameteriHP) },
@@ -815,12 +848,14 @@
   { "glIndexPointerEXT", (void *) wine_glIndexPointerEXT, (void **) (&func_glIndexPointerEXT) },
   { "glIndexPointerListIBM", (void *) wine_glIndexPointerListIBM, (void **) (&func_glIndexPointerListIBM) },
   { "glInstrumentsBufferSGIX", (void *) wine_glInstrumentsBufferSGIX, (void **) (&func_glInstrumentsBufferSGIX) },
+  { "glIsAsyncMarkerSGIX", (void *) wine_glIsAsyncMarkerSGIX, (void **) (&func_glIsAsyncMarkerSGIX) },
   { "glIsTextureEXT", (void *) wine_glIsTextureEXT, (void **) (&func_glIsTextureEXT) },
   { "glLightEnviSGIX", (void *) wine_glLightEnviSGIX, (void **) (&func_glLightEnviSGIX) },
   { "glListParameterfSGIX", (void *) wine_glListParameterfSGIX, (void **) (&func_glListParameterfSGIX) },
   { "glListParameterfvSGIX", (void *) wine_glListParameterfvSGIX, (void **) (&func_glListParameterfvSGIX) },
   { "glListParameteriSGIX", (void *) wine_glListParameteriSGIX, (void **) (&func_glListParameteriSGIX) },
   { "glListParameterivSGIX", (void *) wine_glListParameterivSGIX, (void **) (&func_glListParameterivSGIX) },
+  { "glLoadIdentityDeformationMapSGIX", (void *) wine_glLoadIdentityDeformationMapSGIX, (void **) (&func_glLoadIdentityDeformationMapSGIX) },
   { "glLoadTransposeMatrixdARB", (void *) wine_glLoadTransposeMatrixdARB, (void **) (&func_glLoadTransposeMatrixdARB) },
   { "glLoadTransposeMatrixfARB", (void *) wine_glLoadTransposeMatrixfARB, (void **) (&func_glLoadTransposeMatrixfARB) },
   { "glLockArraysEXT", (void *) wine_glLockArraysEXT, (void **) (&func_glLockArraysEXT) },
@@ -849,6 +884,7 @@
   { "glPointParameterfSGIS", (void *) wine_glPointParameterfSGIS, (void **) (&func_glPointParameterfSGIS) },
   { "glPointParameterfvEXT", (void *) wine_glPointParameterfvEXT, (void **) (&func_glPointParameterfvEXT) },
   { "glPointParameterfvSGIS", (void *) wine_glPointParameterfvSGIS, (void **) (&func_glPointParameterfvSGIS) },
+  { "glPollAsyncSGIX", (void *) wine_glPollAsyncSGIX, (void **) (&func_glPollAsyncSGIX) },
   { "glPollInstrumentsSGIX", (void *) wine_glPollInstrumentsSGIX, (void **) (&func_glPollInstrumentsSGIX) },
   { "glPolygonOffsetEXT", (void *) wine_glPolygonOffsetEXT, (void **) (&func_glPolygonOffsetEXT) },
   { "glPrioritizeTexturesEXT", (void *) wine_glPrioritizeTexturesEXT, (void **) (&func_glPrioritizeTexturesEXT) },
@@ -989,6 +1025,7 @@
 
 /* The thunks themselves....*/
 void WINAPI wine_glApplyTextureEXT( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   func_glApplyTextureEXT( mode );
   LEAVE_GL();
@@ -996,6 +1033,7 @@
 
 GLboolean WINAPI wine_glAreTexturesResidentEXT( GLsizei n, GLuint* textures, GLboolean* residences ) {
   GLboolean ret_value;
+  TRACE("(%d, %p, %p)\n", n, textures, residences );
   ENTER_GL();
   ret_value = func_glAreTexturesResidentEXT( n, textures, residences );
   LEAVE_GL();
@@ -1003,720 +1041,893 @@
 }
 
 void WINAPI wine_glArrayElementEXT( GLint i ) {
+  TRACE("(%d)\n", i );
   ENTER_GL();
   func_glArrayElementEXT( i );
   LEAVE_GL();
 }
 
+void WINAPI wine_glAsyncMarkerSGIX( GLuint marker ) {
+  TRACE("(%d)\n", marker );
+  ENTER_GL();
+  func_glAsyncMarkerSGIX( marker );
+  LEAVE_GL();
+}
+
 void WINAPI wine_glBindTextureEXT( GLenum target, GLuint texture ) {
+  TRACE("(%d, %d)\n", target, texture );
   ENTER_GL();
   func_glBindTextureEXT( target, texture );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz ) {
+  TRACE("(%d, %d, %d)\n", bx, by, bz );
   ENTER_GL();
   func_glBinormal3bEXT( bx, by, bz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3bvEXT( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glBinormal3bvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz ) {
+  TRACE("(%f, %f, %f)\n", bx, by, bz );
   ENTER_GL();
   func_glBinormal3dEXT( bx, by, bz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3dvEXT( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glBinormal3dvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz ) {
+  TRACE("(%f, %f, %f)\n", bx, by, bz );
   ENTER_GL();
   func_glBinormal3fEXT( bx, by, bz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3fvEXT( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glBinormal3fvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3iEXT( GLint bx, GLint by, GLint bz ) {
+  TRACE("(%d, %d, %d)\n", bx, by, bz );
   ENTER_GL();
   func_glBinormal3iEXT( bx, by, bz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3ivEXT( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glBinormal3ivEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz ) {
+  TRACE("(%d, %d, %d)\n", bx, by, bz );
   ENTER_GL();
   func_glBinormal3sEXT( bx, by, bz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormal3svEXT( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glBinormal3svEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBinormalPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   func_glBinormalPointerEXT( type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBlendColorEXT( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   func_glBlendColorEXT( red, green, blue, alpha );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBlendEquationEXT( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   func_glBlendEquationEXT( mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) {
+  TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
   ENTER_GL();
   func_glBlendFuncSeparateEXT( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f)\n", r, g, b, x, y, z );
   ENTER_GL();
   func_glColor3fVertex3fSUN( r, g, b, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor3fVertex3fvSUN( GLfloat* c, GLfloat* v ) {
+  TRACE("(%p, %p)\n", c, v );
   ENTER_GL();
   func_glColor3fVertex3fvSUN( c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", r, g, b, a, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glColor4fNormal3fVertex3fSUN( r, g, b, a, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4fNormal3fVertex3fvSUN( GLfloat* c, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", c, n, v );
   ENTER_GL();
   func_glColor4fNormal3fVertex3fvSUN( c, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y ) {
+  TRACE("(%d, %d, %d, %d, %f, %f)\n", r, g, b, a, x, y );
   ENTER_GL();
   func_glColor4ubVertex2fSUN( r, g, b, a, x, y );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4ubVertex2fvSUN( GLubyte* c, GLfloat* v ) {
+  TRACE("(%p, %p)\n", c, v );
   ENTER_GL();
   func_glColor4ubVertex2fvSUN( c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %d, %d, %d, %f, %f, %f)\n", r, g, b, a, x, y, z );
   ENTER_GL();
   func_glColor4ubVertex3fSUN( r, g, b, a, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColor4ubVertex3fvSUN( GLubyte* c, GLfloat* v ) {
+  TRACE("(%p, %p)\n", c, v );
   ENTER_GL();
   func_glColor4ubVertex3fvSUN( c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   ENTER_GL();
   func_glColorPointerEXT( size, type, stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glColorPointerListIBM( size, type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) {
+  TRACE("(%d, %d, %p)\n", size, type, pointer );
   ENTER_GL();
   func_glColorPointervINTEL( size, type, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
   ENTER_GL();
   func_glColorSubTableEXT( target, start, count, format, type, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalFormat, width, format, type, table );
   ENTER_GL();
   func_glColorTableEXT( target, internalFormat, width, format, type, table );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glColorTableParameterfvSGI( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glColorTableParameterivSGI( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
   ENTER_GL();
   func_glColorTableSGI( target, internalformat, width, format, type, table );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) {
+  TRACE("(%d, %d, %d, %d, %d, %d)\n", stage, portion, variable, input, mapping, componentUsage );
   ENTER_GL();
   func_glCombinerInputNV( stage, portion, variable, input, mapping, componentUsage );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
   ENTER_GL();
   func_glCombinerOutputNV( stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerParameterfNV( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glCombinerParameterfNV( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerParameterfvNV( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glCombinerParameterfvNV( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerParameteriNV( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   func_glCombinerParameteriNV( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCombinerParameterivNV( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glCombinerParameterivNV( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data );
   ENTER_GL();
   func_glCompressedTexImage1DARB( target, level, internalformat, width, border, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data );
   ENTER_GL();
   func_glCompressedTexImage2DARB( target, level, internalformat, width, height, border, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data );
   ENTER_GL();
   func_glCompressedTexImage3DARB( target, level, internalformat, width, height, depth, border, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data );
   ENTER_GL();
   func_glCompressedTexSubImage1DARB( target, level, xoffset, width, format, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
   ENTER_GL();
   func_glCompressedTexSubImage2DARB( target, level, xoffset, yoffset, width, height, format, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
   ENTER_GL();
   func_glCompressedTexSubImage3DARB( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
   ENTER_GL();
   func_glConvolutionFilter1DEXT( target, internalformat, width, format, type, image );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
   ENTER_GL();
   func_glConvolutionFilter2DEXT( target, internalformat, width, height, format, type, image );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params ) {
+  TRACE("(%d, %d, %f)\n", target, pname, params );
   ENTER_GL();
   func_glConvolutionParameterfEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glConvolutionParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params ) {
+  TRACE("(%d, %d, %d)\n", target, pname, params );
   ENTER_GL();
   func_glConvolutionParameteriEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glConvolutionParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
   ENTER_GL();
   func_glCopyColorSubTableEXT( target, start, x, y, width );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyColorTableSGI( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   ENTER_GL();
   func_glCopyColorTableSGI( target, internalformat, x, y, width );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   ENTER_GL();
   func_glCopyConvolutionFilter1DEXT( target, internalformat, x, y, width );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
   ENTER_GL();
   func_glCopyConvolutionFilter2DEXT( target, internalformat, x, y, width, height );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyTexImage1DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
   ENTER_GL();
   func_glCopyTexImage1DEXT( target, level, internalformat, x, y, width, border );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyTexImage2DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
   ENTER_GL();
   func_glCopyTexImage2DEXT( target, level, internalformat, x, y, width, height, border );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
   ENTER_GL();
   func_glCopyTexSubImage1DEXT( target, level, xoffset, x, y, width );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
   ENTER_GL();
   func_glCopyTexSubImage2DEXT( target, level, xoffset, yoffset, x, y, width, height );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
   ENTER_GL();
   func_glCopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCullParameterdvEXT( GLenum pname, GLdouble* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glCullParameterdvEXT( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glCullParameterfvEXT( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glCullParameterfvEXT( pname, params );
   LEAVE_GL();
 }
 
+void WINAPI wine_glDeformSGIX( GLint mask ) {
+  TRACE("(%d)\n", mask );
+  ENTER_GL();
+  func_glDeformSGIX( mask );
+  LEAVE_GL();
+}
+
+void WINAPI wine_glDeformationMap3dSGIX( GLint target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  ENTER_GL();
+  func_glDeformationMap3dSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  LEAVE_GL();
+}
+
+void WINAPI wine_glDeformationMap3fSGIX( GLint target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  ENTER_GL();
+  func_glDeformationMap3fSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  LEAVE_GL();
+}
+
+void WINAPI wine_glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range ) {
+  TRACE("(%d, %d)\n", marker, range );
+  ENTER_GL();
+  func_glDeleteAsyncMarkersSGIX( marker, range );
+  LEAVE_GL();
+}
+
 void WINAPI wine_glDeleteTexturesEXT( GLsizei n, GLuint* textures ) {
+  TRACE("(%d, %p)\n", n, textures );
   ENTER_GL();
   func_glDeleteTexturesEXT( n, textures );
   LEAVE_GL();
 }
 
 void WINAPI wine_glDetailTexFuncSGIS( GLenum target, GLsizei n, GLfloat* points ) {
+  TRACE("(%d, %d, %p)\n", target, n, points );
   ENTER_GL();
   func_glDetailTexFuncSGIS( target, n, points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) {
+  TRACE("(%d, %d, %d)\n", mode, first, count );
   ENTER_GL();
   func_glDrawArraysEXT( mode, first, count );
   LEAVE_GL();
 }
 
 void WINAPI wine_glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
   ENTER_GL();
   func_glDrawRangeElementsEXT( mode, start, end, count, type, indices );
   LEAVE_GL();
 }
 
 void WINAPI wine_glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, GLboolean* pointer ) {
+  TRACE("(%d, %d, %p)\n", stride, count, pointer );
   ENTER_GL();
   func_glEdgeFlagPointerEXT( stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glEdgeFlagPointerListIBM( GLint stride, GLboolean** pointer, GLint ptrstride ) {
+  TRACE("(%d, %p, %d)\n", stride, pointer, ptrstride );
   ENTER_GL();
   func_glEdgeFlagPointerListIBM( stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) {
+  TRACE("(%d, %d, %d, %d)\n", variable, input, mapping, componentUsage );
   ENTER_GL();
   func_glFinalCombinerInputNV( variable, input, mapping, componentUsage );
   LEAVE_GL();
 }
 
+GLint WINAPI wine_glFinishAsyncSGIX( GLuint* markerp ) {
+  GLint ret_value;
+  TRACE("(%p)\n", markerp );
+  ENTER_GL();
+  ret_value = func_glFinishAsyncSGIX( markerp );
+  LEAVE_GL();
+  return ret_value;
+}
+
 void WINAPI wine_glFinishTextureSUNX( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glFinishTextureSUNX( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFlushRasterSGIX( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glFlushRasterSGIX( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFlushVertexArrayRangeNV( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glFlushVertexArrayRangeNV( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoordPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   func_glFogCoordPointerEXT( type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoordPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glFogCoordPointerListIBM( type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoorddEXT( GLdouble coord ) {
+  TRACE("(%f)\n", coord );
   ENTER_GL();
   func_glFogCoorddEXT( coord );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoorddvEXT( GLdouble* coord ) {
+  TRACE("(%p)\n", coord );
   ENTER_GL();
   func_glFogCoorddvEXT( coord );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoordfEXT( GLfloat coord ) {
+  TRACE("(%f)\n", coord );
   ENTER_GL();
   func_glFogCoordfEXT( coord );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogCoordfvEXT( GLfloat* coord ) {
+  TRACE("(%p)\n", coord );
   ENTER_GL();
   func_glFogCoordfvEXT( coord );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFogFuncSGIS( GLsizei n, GLfloat* points ) {
+  TRACE("(%d, %p)\n", n, points );
   ENTER_GL();
   func_glFogFuncSGIS( n, points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentColorMaterialSGIX( GLenum face, GLenum mode ) {
+  TRACE("(%d, %d)\n", face, mode );
   ENTER_GL();
   func_glFragmentColorMaterialSGIX( face, mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightModelfSGIX( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glFragmentLightModelfSGIX( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightModelfvSGIX( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glFragmentLightModelfvSGIX( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightModeliSGIX( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   func_glFragmentLightModeliSGIX( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightModelivSGIX( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glFragmentLightModelivSGIX( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", light, pname, param );
   ENTER_GL();
   func_glFragmentLightfSGIX( light, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   func_glFragmentLightfvSGIX( light, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", light, pname, param );
   ENTER_GL();
   func_glFragmentLightiSGIX( light, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   func_glFragmentLightivSGIX( light, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", face, pname, param );
   ENTER_GL();
   func_glFragmentMaterialfSGIX( face, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   func_glFragmentMaterialfvSGIX( face, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", face, pname, param );
   ENTER_GL();
   func_glFragmentMaterialiSGIX( face, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   func_glFragmentMaterialivSGIX( face, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glFrameZoomSGIX( GLint factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glFrameZoomSGIX( factor );
   LEAVE_GL();
 }
 
+GLuint WINAPI wine_glGenAsyncMarkersSGIX( GLsizei range ) {
+  GLuint ret_value;
+  TRACE("(%d)\n", range );
+  ENTER_GL();
+  ret_value = func_glGenAsyncMarkersSGIX( range );
+  LEAVE_GL();
+  return ret_value;
+}
+
 void WINAPI wine_glGenTexturesEXT( GLsizei n, GLuint* textures ) {
+  TRACE("(%d, %p)\n", n, textures );
   ENTER_GL();
   func_glGenTexturesEXT( n, textures );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableEXT( GLenum target, GLenum format, GLenum type, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %p)\n", target, format, type, data );
   ENTER_GL();
   func_glGetColorTableEXT( target, format, type, data );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetColorTableParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetColorTableParameterfvSGI( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetColorTableParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetColorTableParameterivSGI( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetColorTableSGI( GLenum target, GLenum format, GLenum type, GLvoid* table ) {
+  TRACE("(%d, %d, %d, %p)\n", target, format, type, table );
   ENTER_GL();
   func_glGetColorTableSGI( target, format, type, table );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
   ENTER_GL();
   func_glGetCombinerInputParameterfvNV( stage, portion, variable, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
   ENTER_GL();
   func_glGetCombinerInputParameterivNV( stage, portion, variable, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params );
   ENTER_GL();
   func_glGetCombinerOutputParameterfvNV( stage, portion, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params );
   ENTER_GL();
   func_glGetCombinerOutputParameterivNV( stage, portion, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetCompressedTexImageARB( GLenum target, GLint level, void* img ) {
+  TRACE("(%d, %d, %p)\n", target, level, img );
   ENTER_GL();
   func_glGetCompressedTexImageARB( target, level, img );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %p)\n", target, format, type, image );
   ENTER_GL();
   func_glGetConvolutionFilterEXT( target, format, type, image );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetConvolutionParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetConvolutionParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetDetailTexFuncSGIS( GLenum target, GLfloat* points ) {
+  TRACE("(%d, %p)\n", target, points );
   ENTER_GL();
   func_glGetDetailTexFuncSGIS( target, points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", variable, pname, params );
   ENTER_GL();
   func_glGetFinalCombinerInputParameterfvNV( variable, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", variable, pname, params );
   ENTER_GL();
   func_glGetFinalCombinerInputParameterivNV( variable, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFogFuncSGIS( GLfloat* points ) {
+  TRACE("(%p)\n", points );
   ENTER_GL();
   func_glGetFogFuncSGIS( points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   func_glGetFragmentLightfvSGIX( light, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   func_glGetFragmentLightivSGIX( light, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   func_glGetFragmentMaterialfvSGIX( face, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   func_glGetFragmentMaterialivSGIX( face, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   ENTER_GL();
   func_glGetHistogramEXT( target, reset, format, type, values );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetHistogramParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetHistogramParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetImageTransformParameterfvHP( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetImageTransformParameterivHP( target, pname, params );
   LEAVE_GL();
@@ -1724,6 +1935,7 @@
 
 GLint WINAPI wine_glGetInstrumentsSGIX( ) {
   GLint ret_value;
+  TRACE("()\n");
   ENTER_GL();
   ret_value = func_glGetInstrumentsSGIX( );
   LEAVE_GL();
@@ -1731,187 +1943,234 @@
 }
 
 void WINAPI wine_glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", list, pname, params );
   ENTER_GL();
   func_glGetListParameterfvSGIX( list, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", list, pname, params );
   ENTER_GL();
   func_glGetListParameterivSGIX( list, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   ENTER_GL();
   func_glGetMinmaxEXT( target, reset, format, type, values );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetMinmaxParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glGetMinmaxParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glGetPixelTexGenParameterfvSGIS( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glGetPixelTexGenParameterivSGIS( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetPointervEXT( GLenum pname, GLvoid** params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glGetPointervEXT( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, GLvoid* row, GLvoid* column, GLvoid* span ) {
+  TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
   ENTER_GL();
   func_glGetSeparableFilterEXT( target, format, type, row, column, span );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetSharpenTexFuncSGIS( GLenum target, GLfloat* points ) {
+  TRACE("(%d, %p)\n", target, points );
   ENTER_GL();
   func_glGetSharpenTexFuncSGIS( target, points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat* weights ) {
+  TRACE("(%d, %d, %p)\n", target, filter, weights );
   ENTER_GL();
   func_glGetTexFilterFuncSGIS( target, filter, weights );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactorbSUN( GLbyte factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactorbSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactordSUN( GLdouble factor ) {
+  TRACE("(%f)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactordSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactorfSUN( GLfloat factor ) {
+  TRACE("(%f)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactorfSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactoriSUN( GLint factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactoriSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactorsSUN( GLshort factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactorsSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactorubSUN( GLubyte factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactorubSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactoruiSUN( GLuint factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactoruiSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glGlobalAlphaFactorusSUN( GLushort factor ) {
+  TRACE("(%d)\n", factor );
   ENTER_GL();
   func_glGlobalAlphaFactorusSUN( factor );
   LEAVE_GL();
 }
 
 void WINAPI wine_glHintPGI( GLenum target, GLint mode ) {
+  TRACE("(%d, %d)\n", target, mode );
   ENTER_GL();
   func_glHintPGI( target, mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
+  TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink );
   ENTER_GL();
   func_glHistogramEXT( target, width, internalformat, sink );
   LEAVE_GL();
 }
 
+void WINAPI wine_glIglooInterfaceSGIX( GLint pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
+  ENTER_GL();
+  func_glIglooInterfaceSGIX( pname, params );
+  LEAVE_GL();
+}
+
 void WINAPI wine_glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", target, pname, param );
   ENTER_GL();
   func_glImageTransformParameterfHP( target, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glImageTransformParameterfvHP( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", target, pname, param );
   ENTER_GL();
   func_glImageTransformParameteriHP( target, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glImageTransformParameterivHP( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glIndexFuncEXT( GLenum func, GLclampf ref ) {
+  TRACE("(%d, %f)\n", func, ref );
   ENTER_GL();
   func_glIndexFuncEXT( func, ref );
   LEAVE_GL();
 }
 
 void WINAPI wine_glIndexMaterialEXT( GLenum face, GLenum mode ) {
+  TRACE("(%d, %d)\n", face, mode );
   ENTER_GL();
   func_glIndexMaterialEXT( face, mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer );
   ENTER_GL();
   func_glIndexPointerEXT( type, stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glIndexPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glIndexPointerListIBM( type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glInstrumentsBufferSGIX( GLsizei size, GLint* buffer ) {
+  TRACE("(%d, %p)\n", size, buffer );
   ENTER_GL();
   func_glInstrumentsBufferSGIX( size, buffer );
   LEAVE_GL();
 }
 
+GLboolean WINAPI wine_glIsAsyncMarkerSGIX( GLuint marker ) {
+  GLboolean ret_value;
+  TRACE("(%d)\n", marker );
+  ENTER_GL();
+  ret_value = func_glIsAsyncMarkerSGIX( marker );
+  LEAVE_GL();
+  return ret_value;
+}
+
 GLboolean WINAPI wine_glIsTextureEXT( GLuint texture ) {
   GLboolean ret_value;
+  TRACE("(%d)\n", texture );
   ENTER_GL();
   ret_value = func_glIsTextureEXT( texture );
   LEAVE_GL();
@@ -1919,205 +2178,255 @@
 }
 
 void WINAPI wine_glLightEnviSGIX( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   func_glLightEnviSGIX( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", list, pname, param );
   ENTER_GL();
   func_glListParameterfSGIX( list, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", list, pname, params );
   ENTER_GL();
   func_glListParameterfvSGIX( list, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glListParameteriSGIX( GLuint list, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", list, pname, param );
   ENTER_GL();
   func_glListParameteriSGIX( list, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", list, pname, params );
   ENTER_GL();
   func_glListParameterivSGIX( list, pname, params );
   LEAVE_GL();
 }
 
+void WINAPI wine_glLoadIdentityDeformationMapSGIX( GLint mask ) {
+  TRACE("(%d)\n", mask );
+  ENTER_GL();
+  func_glLoadIdentityDeformationMapSGIX( mask );
+  LEAVE_GL();
+}
+
 void WINAPI wine_glLoadTransposeMatrixdARB( GLdouble* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   func_glLoadTransposeMatrixdARB( m );
   LEAVE_GL();
 }
 
 void WINAPI wine_glLoadTransposeMatrixfARB( GLfloat* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   func_glLoadTransposeMatrixfARB( m );
   LEAVE_GL();
 }
 
 void WINAPI wine_glLockArraysEXT( GLint first, GLsizei count ) {
+  TRACE("(%d, %d)\n", first, count );
   ENTER_GL();
   func_glLockArraysEXT( first, count );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink ) {
+  TRACE("(%d, %d, %d)\n", target, internalformat, sink );
   ENTER_GL();
   func_glMinmaxEXT( target, internalformat, sink );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultTransposeMatrixdARB( GLdouble* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   func_glMultTransposeMatrixdARB( m );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultTransposeMatrixfARB( GLfloat* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   func_glMultTransposeMatrixfARB( m );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultiDrawArraysEXT( GLenum mode, GLint* first, GLsizei* count, GLsizei primcount ) {
+  TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount );
   ENTER_GL();
   func_glMultiDrawArraysEXT( mode, first, count, primcount );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultiDrawElementsEXT( GLenum mode, GLsizei* count, GLenum type, GLvoid** indices, GLsizei primcount ) {
+  TRACE("(%d, %p, %d, %p, %d)\n", mode, count, type, indices, primcount );
   ENTER_GL();
   func_glMultiDrawElementsEXT( mode, count, type, indices, primcount );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultiModeDrawArraysIBM( GLenum mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride ) {
+  TRACE("(%d, %p, %p, %d, %d)\n", mode, first, count, primcount, modestride );
   ENTER_GL();
   func_glMultiModeDrawArraysIBM( mode, first, count, primcount, modestride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glMultiModeDrawElementsIBM( GLenum* mode, GLsizei* count, GLenum type, GLvoid** indices, GLsizei primcount, GLint modestride ) {
+  TRACE("(%p, %p, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, modestride );
   ENTER_GL();
   func_glMultiModeDrawElementsIBM( mode, count, type, indices, primcount, modestride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f)\n", nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glNormal3fVertex3fSUN( nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glNormal3fVertex3fvSUN( GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p)\n", n, v );
   ENTER_GL();
   func_glNormal3fVertex3fvSUN( n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer );
   ENTER_GL();
   func_glNormalPointerEXT( type, stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glNormalPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glNormalPointerListIBM( type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glNormalPointervINTEL( GLenum type, GLvoid** pointer ) {
+  TRACE("(%d, %p)\n", type, pointer );
   ENTER_GL();
   func_glNormalPointervINTEL( type, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glPixelTexGenParameterfSGIS( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glPixelTexGenParameterfvSGIS( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTexGenParameteriSGIS( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   func_glPixelTexGenParameteriSGIS( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glPixelTexGenParameterivSGIS( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTexGenSGIX( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   func_glPixelTexGenSGIX( mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", target, pname, param );
   ENTER_GL();
   func_glPixelTransformParameterfEXT( target, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glPixelTransformParameterfvEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", target, pname, param );
   ENTER_GL();
   func_glPixelTransformParameteriEXT( target, pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   func_glPixelTransformParameterivEXT( target, pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPointParameterfEXT( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glPointParameterfEXT( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPointParameterfSGIS( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glPointParameterfSGIS( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPointParameterfvEXT( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glPointParameterfvEXT( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPointParameterfvSGIS( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glPointParameterfvSGIS( pname, params );
   LEAVE_GL();
 }
 
+GLint WINAPI wine_glPollAsyncSGIX( GLuint* markerp ) {
+  GLint ret_value;
+  TRACE("(%p)\n", markerp );
+  ENTER_GL();
+  ret_value = func_glPollAsyncSGIX( markerp );
+  LEAVE_GL();
+  return ret_value;
+}
+
 GLint WINAPI wine_glPollInstrumentsSGIX( GLint* marker_p ) {
   GLint ret_value;
+  TRACE("(%p)\n", marker_p );
   ENTER_GL();
   ret_value = func_glPollInstrumentsSGIX( marker_p );
   LEAVE_GL();
@@ -2125,810 +2434,945 @@
 }
 
 void WINAPI wine_glPolygonOffsetEXT( GLfloat factor, GLfloat bias ) {
+  TRACE("(%f, %f)\n", factor, bias );
   ENTER_GL();
   func_glPolygonOffsetEXT( factor, bias );
   LEAVE_GL();
 }
 
 void WINAPI wine_glPrioritizeTexturesEXT( GLsizei n, GLuint* textures, GLclampf* priorities ) {
+  TRACE("(%d, %p, %p)\n", n, textures, priorities );
   ENTER_GL();
   func_glPrioritizeTexturesEXT( n, textures, priorities );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReadInstrumentsSGIX( GLint marker ) {
+  TRACE("(%d)\n", marker );
   ENTER_GL();
   func_glReadInstrumentsSGIX( marker );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReferencePlaneSGIX( GLdouble* equation ) {
+  TRACE("(%p)\n", equation );
   ENTER_GL();
   func_glReferencePlaneSGIX( equation );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodePointerSUN( GLenum type, GLsizei stride, GLvoid** pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   func_glReplacementCodePointerSUN( type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeubSUN( GLubyte code ) {
+  TRACE("(%d)\n", code );
   ENTER_GL();
   func_glReplacementCodeubSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeubvSUN( GLubyte* code ) {
+  TRACE("(%p)\n", code );
   ENTER_GL();
   func_glReplacementCodeubvSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor3fVertex3fSUN( GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiColor3fVertex3fSUN( rc, r, g, b, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor3fVertex3fvSUN( GLenum* rc, GLfloat* c, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", rc, c, v );
   ENTER_GL();
   func_glReplacementCodeuiColor3fVertex3fvSUN( rc, c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, a, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiColor4fNormal3fVertex3fSUN( rc, r, g, b, a, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( GLenum* rc, GLfloat* c, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p, %p)\n", rc, c, n, v );
   ENTER_GL();
   func_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( rc, c, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor4ubVertex3fSUN( GLenum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %d, %d, %d, %d, %f, %f, %f)\n", rc, r, g, b, a, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiColor4ubVertex3fSUN( rc, r, g, b, a, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiColor4ubVertex3fvSUN( GLenum* rc, GLubyte* c, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", rc, c, v );
   ENTER_GL();
   func_glReplacementCodeuiColor4ubVertex3fvSUN( rc, c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiNormal3fVertex3fSUN( GLenum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiNormal3fVertex3fSUN( rc, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiNormal3fVertex3fvSUN( GLenum* rc, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", rc, n, v );
   ENTER_GL();
   func_glReplacementCodeuiNormal3fVertex3fvSUN( rc, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiSUN( GLuint code ) {
+  TRACE("(%d)\n", code );
   ENTER_GL();
   func_glReplacementCodeuiSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( GLenum* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p, %p, %p)\n", rc, tc, c, n, v );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( rc, tc, c, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( rc, s, t, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( GLenum* rc, GLfloat* tc, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p, %p)\n", rc, tc, n, v );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( rc, tc, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fVertex3fSUN( GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f, %f, %f)\n", rc, s, t, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fVertex3fSUN( rc, s, t, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiTexCoord2fVertex3fvSUN( GLenum* rc, GLfloat* tc, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", rc, tc, v );
   ENTER_GL();
   func_glReplacementCodeuiTexCoord2fVertex3fvSUN( rc, tc, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiVertex3fSUN( GLenum rc, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%d, %f, %f, %f)\n", rc, x, y, z );
   ENTER_GL();
   func_glReplacementCodeuiVertex3fSUN( rc, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuiVertex3fvSUN( GLenum* rc, GLfloat* v ) {
+  TRACE("(%p, %p)\n", rc, v );
   ENTER_GL();
   func_glReplacementCodeuiVertex3fvSUN( rc, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeuivSUN( GLuint* code ) {
+  TRACE("(%p)\n", code );
   ENTER_GL();
   func_glReplacementCodeuivSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeusSUN( GLushort code ) {
+  TRACE("(%d)\n", code );
   ENTER_GL();
   func_glReplacementCodeusSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glReplacementCodeusvSUN( GLushort* code ) {
+  TRACE("(%p)\n", code );
   ENTER_GL();
   func_glReplacementCodeusvSUN( code );
   LEAVE_GL();
 }
 
 void WINAPI wine_glResetHistogramEXT( GLenum target ) {
+  TRACE("(%d)\n", target );
   ENTER_GL();
   func_glResetHistogramEXT( target );
   LEAVE_GL();
 }
 
 void WINAPI wine_glResetMinmaxEXT( GLenum target ) {
+  TRACE("(%d)\n", target );
   ENTER_GL();
   func_glResetMinmaxEXT( target );
   LEAVE_GL();
 }
 
 void WINAPI wine_glResizeBuffersMESA( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glResizeBuffersMESA( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSampleCoverageARB( GLclampf value, GLboolean invert ) {
+  TRACE("(%f, %d)\n", value, invert );
   ENTER_GL();
   func_glSampleCoverageARB( value, invert );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSampleMaskEXT( GLclampf value, GLboolean invert ) {
+  TRACE("(%f, %d)\n", value, invert );
   ENTER_GL();
   func_glSampleMaskEXT( value, invert );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSampleMaskSGIS( GLclampf value, GLboolean invert ) {
+  TRACE("(%f, %d)\n", value, invert );
   ENTER_GL();
   func_glSampleMaskSGIS( value, invert );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSamplePassARB( GLenum pass ) {
+  TRACE("(%d)\n", pass );
   ENTER_GL();
   func_glSamplePassARB( pass );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSamplePatternEXT( GLenum pattern ) {
+  TRACE("(%d)\n", pattern );
   ENTER_GL();
   func_glSamplePatternEXT( pattern );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSamplePatternSGIS( GLenum pattern ) {
+  TRACE("(%d)\n", pattern );
   ENTER_GL();
   func_glSamplePatternSGIS( pattern );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3bEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3bvEXT( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3bvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue ) {
+  TRACE("(%f, %f, %f)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3dEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3dvEXT( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3dvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue ) {
+  TRACE("(%f, %f, %f)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3fEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3fvEXT( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3fvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3iEXT( GLint red, GLint green, GLint blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3iEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3ivEXT( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3ivEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3sEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3svEXT( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3svEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3ubEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3ubvEXT( GLubyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3ubvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3uiEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3uivEXT( GLuint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3uivEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   func_glSecondaryColor3usEXT( red, green, blue );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColor3usvEXT( GLushort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glSecondaryColor3usvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
   ENTER_GL();
   func_glSecondaryColorPointerEXT( size, type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glSecondaryColorPointerListIBM( size, type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* row, GLvoid* column ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
   ENTER_GL();
   func_glSeparableFilter2DEXT( target, internalformat, width, height, format, type, row, column );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSharpenTexFuncSGIS( GLenum target, GLsizei n, GLfloat* points ) {
+  TRACE("(%d, %d, %p)\n", target, n, points );
   ENTER_GL();
   func_glSharpenTexFuncSGIS( target, n, points );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSpriteParameterfSGIX( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   func_glSpriteParameterfSGIX( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSpriteParameterfvSGIX( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glSpriteParameterfvSGIX( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSpriteParameteriSGIX( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   func_glSpriteParameteriSGIX( pname, param );
   LEAVE_GL();
 }
 
 void WINAPI wine_glSpriteParameterivSGIX( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   func_glSpriteParameterivSGIX( pname, params );
   LEAVE_GL();
 }
 
 void WINAPI wine_glStartInstrumentsSGIX( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glStartInstrumentsSGIX( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glStopInstrumentsSGIX( GLint marker ) {
+  TRACE("(%d)\n", marker );
   ENTER_GL();
   func_glStopInstrumentsSGIX( marker );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTagSampleBufferSGIX( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glTagSampleBufferSGIX( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz ) {
+  TRACE("(%d, %d, %d)\n", tx, ty, tz );
   ENTER_GL();
   func_glTangent3bEXT( tx, ty, tz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3bvEXT( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glTangent3bvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz ) {
+  TRACE("(%f, %f, %f)\n", tx, ty, tz );
   ENTER_GL();
   func_glTangent3dEXT( tx, ty, tz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3dvEXT( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glTangent3dvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz ) {
+  TRACE("(%f, %f, %f)\n", tx, ty, tz );
   ENTER_GL();
   func_glTangent3fEXT( tx, ty, tz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3fvEXT( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glTangent3fvEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3iEXT( GLint tx, GLint ty, GLint tz ) {
+  TRACE("(%d, %d, %d)\n", tx, ty, tz );
   ENTER_GL();
   func_glTangent3iEXT( tx, ty, tz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3ivEXT( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glTangent3ivEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz ) {
+  TRACE("(%d, %d, %d)\n", tx, ty, tz );
   ENTER_GL();
   func_glTangent3sEXT( tx, ty, tz );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangent3svEXT( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glTangent3svEXT( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTangentPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   func_glTangentPointerEXT( type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTbufferMask3DFX( GLuint mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   func_glTbufferMask3DFX( mask );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, x, y, z );
   ENTER_GL();
   func_glTexCoord2fColor3fVertex3fSUN( s, t, r, g, b, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor3fVertex3fvSUN( GLfloat* tc, GLfloat* c, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", tc, c, v );
   ENTER_GL();
   func_glTexCoord2fColor3fVertex3fvSUN( tc, c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor4fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, a, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glTexCoord2fColor4fNormal3fVertex3fSUN( s, t, r, g, b, a, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor4fNormal3fVertex3fvSUN( GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p, %p)\n", tc, c, n, v );
   ENTER_GL();
   func_glTexCoord2fColor4fNormal3fVertex3fvSUN( tc, c, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %d, %d, %d, %d, %f, %f, %f)\n", s, t, r, g, b, a, x, y, z );
   ENTER_GL();
   func_glTexCoord2fColor4ubVertex3fSUN( s, t, r, g, b, a, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fColor4ubVertex3fvSUN( GLfloat* tc, GLubyte* c, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", tc, c, v );
   ENTER_GL();
   func_glTexCoord2fColor4ubVertex3fvSUN( tc, c, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, nx, ny, nz, x, y, z );
   ENTER_GL();
   func_glTexCoord2fNormal3fVertex3fSUN( s, t, nx, ny, nz, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fNormal3fVertex3fvSUN( GLfloat* tc, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p)\n", tc, n, v );
   ENTER_GL();
   func_glTexCoord2fNormal3fVertex3fvSUN( tc, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f, %f)\n", s, t, x, y, z );
   ENTER_GL();
   func_glTexCoord2fVertex3fSUN( s, t, x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord2fVertex3fvSUN( GLfloat* tc, GLfloat* v ) {
+  TRACE("(%p, %p)\n", tc, v );
   ENTER_GL();
   func_glTexCoord2fVertex3fvSUN( tc, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord4fColor4fNormal3fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
   ENTER_GL();
   func_glTexCoord4fColor4fNormal3fVertex4fSUN( s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord4fColor4fNormal3fVertex4fvSUN( GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) {
+  TRACE("(%p, %p, %p, %p)\n", tc, c, n, v );
   ENTER_GL();
   func_glTexCoord4fColor4fNormal3fVertex4fvSUN( tc, c, n, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, x, y, z, w );
   ENTER_GL();
   func_glTexCoord4fVertex4fSUN( s, t, p, q, x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoord4fVertex4fvSUN( GLfloat* tc, GLfloat* v ) {
+  TRACE("(%p, %p)\n", tc, v );
   ENTER_GL();
   func_glTexCoord4fVertex4fvSUN( tc, v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   ENTER_GL();
   func_glTexCoordPointerEXT( size, type, stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glTexCoordPointerListIBM( size, type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexCoordPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) {
+  TRACE("(%d, %d, %p)\n", size, type, pointer );
   ENTER_GL();
   func_glTexCoordPointervINTEL( size, type, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, GLfloat* weights ) {
+  TRACE("(%d, %d, %d, %p)\n", target, filter, n, weights );
   ENTER_GL();
   func_glTexFilterFuncSGIS( target, filter, n, weights );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
   ENTER_GL();
   func_glTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
   ENTER_GL();
   func_glTexImage4DSGIS( target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
   ENTER_GL();
   func_glTexSubImage1DEXT( target, level, xoffset, width, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
   ENTER_GL();
   func_glTexSubImage2DEXT( target, level, xoffset, yoffset, width, height, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   ENTER_GL();
   func_glTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
   ENTER_GL();
   func_glTexSubImage4DSGIS( target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   func_glTextureColorMaskSGIS( red, green, blue, alpha );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTextureLightEXT( GLenum pname ) {
+  TRACE("(%d)\n", pname );
   ENTER_GL();
   func_glTextureLightEXT( pname );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTextureMaterialEXT( GLenum face, GLenum mode ) {
+  TRACE("(%d, %d)\n", face, mode );
   ENTER_GL();
   func_glTextureMaterialEXT( face, mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glTextureNormalEXT( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   func_glTextureNormalEXT( mode );
   LEAVE_GL();
 }
 
 void WINAPI wine_glUnlockArraysEXT( ) {
+  TRACE("()\n");
   ENTER_GL();
   func_glUnlockArraysEXT( );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexArrayRangeNV( GLsizei size, GLvoid* pointer ) {
+  TRACE("(%d, %p)\n", size, pointer );
   ENTER_GL();
   func_glVertexArrayRangeNV( size, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   ENTER_GL();
   func_glVertexPointerEXT( size, type, stride, count, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) {
+  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   ENTER_GL();
   func_glVertexPointerListIBM( size, type, stride, pointer, ptrstride );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) {
+  TRACE("(%d, %d, %p)\n", size, type, pointer );
   ENTER_GL();
   func_glVertexPointervINTEL( size, type, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexWeightPointerEXT( GLsizei size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
   ENTER_GL();
   func_glVertexWeightPointerEXT( size, type, stride, pointer );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexWeightfEXT( GLfloat weight ) {
+  TRACE("(%f)\n", weight );
   ENTER_GL();
   func_glVertexWeightfEXT( weight );
   LEAVE_GL();
 }
 
 void WINAPI wine_glVertexWeightfvEXT( GLfloat* weight ) {
+  TRACE("(%p)\n", weight );
   ENTER_GL();
   func_glVertexWeightfvEXT( weight );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2dMESA( GLdouble x, GLdouble y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   func_glWindowPos2dMESA( x, y );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2dvMESA( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos2dvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2fMESA( GLfloat x, GLfloat y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   func_glWindowPos2fMESA( x, y );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2fvMESA( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos2fvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2iMESA( GLint x, GLint y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   func_glWindowPos2iMESA( x, y );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2ivMESA( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos2ivMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2sMESA( GLshort x, GLshort y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   func_glWindowPos2sMESA( x, y );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos2svMESA( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos2svMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   func_glWindowPos3dMESA( x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3dvMESA( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos3dvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   func_glWindowPos3fMESA( x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3fvMESA( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos3fvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3iMESA( GLint x, GLint y, GLint z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   func_glWindowPos3iMESA( x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3ivMESA( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos3ivMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   func_glWindowPos3sMESA( x, y, z );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos3svMESA( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos3svMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   func_glWindowPos4dMESA( x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4dvMESA( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos4dvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   func_glWindowPos4fMESA( x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4fvMESA( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos4fvMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   func_glWindowPos4iMESA( x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4ivMESA( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos4ivMESA( v );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   func_glWindowPos4sMESA( x, y, z, w );
   LEAVE_GL();
 }
 
 void WINAPI wine_glWindowPos4svMESA( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   func_glWindowPos4svMESA( v );
   LEAVE_GL();
diff --git a/dlls/opengl32/opengl_norm.c b/dlls/opengl32/opengl_norm.c
index 1ad6a74..c7b4630 100644
--- a/dlls/opengl32/opengl_norm.c
+++ b/dlls/opengl32/opengl_norm.c
@@ -3,13 +3,17 @@
 
 #include "config.h"
 #include "wine_gl.h"
+#include "debugtools.h"
 
 typedef const GLubyte * GLstring;
 
+DEFAULT_DEBUG_CHANNEL(opengl);
+
 /***********************************************************************
  *              glAccum
  */
 void WINAPI wine_glAccum( GLenum op, GLfloat value ) {
+  TRACE("(%d, %f)\n", op, value );
   ENTER_GL();
   glAccum( op, value );
   LEAVE_GL();
@@ -19,6 +23,7 @@
  *              glActiveTextureARB
  */
 void WINAPI wine_glActiveTextureARB( GLenum texture ) {
+  TRACE("(%d)\n", texture );
   ENTER_GL();
   glActiveTextureARB( texture );
   LEAVE_GL();
@@ -28,6 +33,7 @@
  *              glAlphaFunc
  */
 void WINAPI wine_glAlphaFunc( GLenum func, GLclampf ref ) {
+  TRACE("(%d, %f)\n", func, ref );
   ENTER_GL();
   glAlphaFunc( func, ref );
   LEAVE_GL();
@@ -38,6 +44,7 @@
  */
 GLboolean WINAPI wine_glAreTexturesResident( GLsizei n, GLuint* textures, GLboolean* residences ) {
   GLboolean ret_value;
+  TRACE("(%d, %p, %p)\n", n, textures, residences );
   ENTER_GL();
   ret_value = glAreTexturesResident( n, textures, residences );
   LEAVE_GL();
@@ -48,6 +55,7 @@
  *              glArrayElement
  */
 void WINAPI wine_glArrayElement( GLint i ) {
+  TRACE("(%d)\n", i );
   ENTER_GL();
   glArrayElement( i );
   LEAVE_GL();
@@ -57,6 +65,7 @@
  *              glBegin
  */
 void WINAPI wine_glBegin( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glBegin( mode );
   LEAVE_GL();
@@ -66,6 +75,7 @@
  *              glBindTexture
  */
 void WINAPI wine_glBindTexture( GLenum target, GLuint texture ) {
+  TRACE("(%d, %d)\n", target, texture );
   ENTER_GL();
   glBindTexture( target, texture );
   LEAVE_GL();
@@ -75,6 +85,7 @@
  *              glBitmap
  */
 void WINAPI wine_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte* bitmap ) {
+  TRACE("(%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
   ENTER_GL();
   glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
   LEAVE_GL();
@@ -84,6 +95,7 @@
  *              glBlendColor
  */
 void WINAPI wine_glBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   glBlendColor( red, green, blue, alpha );
   LEAVE_GL();
@@ -93,6 +105,7 @@
  *              glBlendEquation
  */
 void WINAPI wine_glBlendEquation( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glBlendEquation( mode );
   LEAVE_GL();
@@ -102,6 +115,7 @@
  *              glBlendFunc
  */
 void WINAPI wine_glBlendFunc( GLenum sfactor, GLenum dfactor ) {
+  TRACE("(%d, %d)\n", sfactor, dfactor );
   ENTER_GL();
   glBlendFunc( sfactor, dfactor );
   LEAVE_GL();
@@ -111,6 +125,7 @@
  *              glCallList
  */
 void WINAPI wine_glCallList( GLuint list ) {
+  TRACE("(%d)\n", list );
   ENTER_GL();
   glCallList( list );
   LEAVE_GL();
@@ -120,6 +135,7 @@
  *              glCallLists
  */
 void WINAPI wine_glCallLists( GLsizei n, GLenum type, GLvoid* lists ) {
+  TRACE("(%d, %d, %p)\n", n, type, lists );
   ENTER_GL();
   glCallLists( n, type, lists );
   LEAVE_GL();
@@ -129,6 +145,7 @@
  *              glClear
  */
 void WINAPI wine_glClear( GLbitfield mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   glClear( mask );
   LEAVE_GL();
@@ -138,6 +155,7 @@
  *              glClearAccum
  */
 void WINAPI wine_glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   glClearAccum( red, green, blue, alpha );
   LEAVE_GL();
@@ -147,6 +165,7 @@
  *              glClearColor
  */
 void WINAPI wine_glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   glClearColor( red, green, blue, alpha );
   LEAVE_GL();
@@ -156,6 +175,7 @@
  *              glClearDepth
  */
 void WINAPI wine_glClearDepth( GLclampd depth ) {
+  TRACE("(%f)\n", depth );
   ENTER_GL();
   glClearDepth( depth );
   LEAVE_GL();
@@ -165,6 +185,7 @@
  *              glClearIndex
  */
 void WINAPI wine_glClearIndex( GLfloat c ) {
+  TRACE("(%f)\n", c );
   ENTER_GL();
   glClearIndex( c );
   LEAVE_GL();
@@ -174,6 +195,7 @@
  *              glClearStencil
  */
 void WINAPI wine_glClearStencil( GLint s ) {
+  TRACE("(%d)\n", s );
   ENTER_GL();
   glClearStencil( s );
   LEAVE_GL();
@@ -183,6 +205,7 @@
  *              glClientActiveTextureARB
  */
 void WINAPI wine_glClientActiveTextureARB( GLenum texture ) {
+  TRACE("(%d)\n", texture );
   ENTER_GL();
   glClientActiveTextureARB( texture );
   LEAVE_GL();
@@ -192,6 +215,7 @@
  *              glClipPlane
  */
 void WINAPI wine_glClipPlane( GLenum plane, GLdouble* equation ) {
+  TRACE("(%d, %p)\n", plane, equation );
   ENTER_GL();
   glClipPlane( plane, equation );
   LEAVE_GL();
@@ -201,6 +225,7 @@
  *              glColor3b
  */
 void WINAPI wine_glColor3b( GLbyte red, GLbyte green, GLbyte blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3b( red, green, blue );
   LEAVE_GL();
@@ -210,6 +235,7 @@
  *              glColor3bv
  */
 void WINAPI wine_glColor3bv( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3bv( v );
   LEAVE_GL();
@@ -219,6 +245,7 @@
  *              glColor3d
  */
 void WINAPI wine_glColor3d( GLdouble red, GLdouble green, GLdouble blue ) {
+  TRACE("(%f, %f, %f)\n", red, green, blue );
   ENTER_GL();
   glColor3d( red, green, blue );
   LEAVE_GL();
@@ -228,6 +255,7 @@
  *              glColor3dv
  */
 void WINAPI wine_glColor3dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3dv( v );
   LEAVE_GL();
@@ -237,6 +265,7 @@
  *              glColor3f
  */
 void WINAPI wine_glColor3f( GLfloat red, GLfloat green, GLfloat blue ) {
+  TRACE("(%f, %f, %f)\n", red, green, blue );
   ENTER_GL();
   glColor3f( red, green, blue );
   LEAVE_GL();
@@ -246,6 +275,7 @@
  *              glColor3fv
  */
 void WINAPI wine_glColor3fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3fv( v );
   LEAVE_GL();
@@ -255,6 +285,7 @@
  *              glColor3i
  */
 void WINAPI wine_glColor3i( GLint red, GLint green, GLint blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3i( red, green, blue );
   LEAVE_GL();
@@ -264,6 +295,7 @@
  *              glColor3iv
  */
 void WINAPI wine_glColor3iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3iv( v );
   LEAVE_GL();
@@ -273,6 +305,7 @@
  *              glColor3s
  */
 void WINAPI wine_glColor3s( GLshort red, GLshort green, GLshort blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3s( red, green, blue );
   LEAVE_GL();
@@ -282,6 +315,7 @@
  *              glColor3sv
  */
 void WINAPI wine_glColor3sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3sv( v );
   LEAVE_GL();
@@ -291,6 +325,7 @@
  *              glColor3ub
  */
 void WINAPI wine_glColor3ub( GLubyte red, GLubyte green, GLubyte blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3ub( red, green, blue );
   LEAVE_GL();
@@ -300,6 +335,7 @@
  *              glColor3ubv
  */
 void WINAPI wine_glColor3ubv( GLubyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3ubv( v );
   LEAVE_GL();
@@ -309,6 +345,7 @@
  *              glColor3ui
  */
 void WINAPI wine_glColor3ui( GLuint red, GLuint green, GLuint blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3ui( red, green, blue );
   LEAVE_GL();
@@ -318,6 +355,7 @@
  *              glColor3uiv
  */
 void WINAPI wine_glColor3uiv( GLuint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3uiv( v );
   LEAVE_GL();
@@ -327,6 +365,7 @@
  *              glColor3us
  */
 void WINAPI wine_glColor3us( GLushort red, GLushort green, GLushort blue ) {
+  TRACE("(%d, %d, %d)\n", red, green, blue );
   ENTER_GL();
   glColor3us( red, green, blue );
   LEAVE_GL();
@@ -336,6 +375,7 @@
  *              glColor3usv
  */
 void WINAPI wine_glColor3usv( GLushort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor3usv( v );
   LEAVE_GL();
@@ -345,6 +385,7 @@
  *              glColor4b
  */
 void WINAPI wine_glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4b( red, green, blue, alpha );
   LEAVE_GL();
@@ -354,6 +395,7 @@
  *              glColor4bv
  */
 void WINAPI wine_glColor4bv( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4bv( v );
   LEAVE_GL();
@@ -363,6 +405,7 @@
  *              glColor4d
  */
 void WINAPI wine_glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4d( red, green, blue, alpha );
   LEAVE_GL();
@@ -372,6 +415,7 @@
  *              glColor4dv
  */
 void WINAPI wine_glColor4dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4dv( v );
   LEAVE_GL();
@@ -381,6 +425,7 @@
  *              glColor4f
  */
 void WINAPI wine_glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4f( red, green, blue, alpha );
   LEAVE_GL();
@@ -390,6 +435,7 @@
  *              glColor4fv
  */
 void WINAPI wine_glColor4fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4fv( v );
   LEAVE_GL();
@@ -399,6 +445,7 @@
  *              glColor4i
  */
 void WINAPI wine_glColor4i( GLint red, GLint green, GLint blue, GLint alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4i( red, green, blue, alpha );
   LEAVE_GL();
@@ -408,6 +455,7 @@
  *              glColor4iv
  */
 void WINAPI wine_glColor4iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4iv( v );
   LEAVE_GL();
@@ -417,6 +465,7 @@
  *              glColor4s
  */
 void WINAPI wine_glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4s( red, green, blue, alpha );
   LEAVE_GL();
@@ -426,6 +475,7 @@
  *              glColor4sv
  */
 void WINAPI wine_glColor4sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4sv( v );
   LEAVE_GL();
@@ -435,6 +485,7 @@
  *              glColor4ub
  */
 void WINAPI wine_glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4ub( red, green, blue, alpha );
   LEAVE_GL();
@@ -444,6 +495,7 @@
  *              glColor4ubv
  */
 void WINAPI wine_glColor4ubv( GLubyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4ubv( v );
   LEAVE_GL();
@@ -453,6 +505,7 @@
  *              glColor4ui
  */
 void WINAPI wine_glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4ui( red, green, blue, alpha );
   LEAVE_GL();
@@ -462,6 +515,7 @@
  *              glColor4uiv
  */
 void WINAPI wine_glColor4uiv( GLuint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4uiv( v );
   LEAVE_GL();
@@ -471,6 +525,7 @@
  *              glColor4us
  */
 void WINAPI wine_glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColor4us( red, green, blue, alpha );
   LEAVE_GL();
@@ -480,6 +535,7 @@
  *              glColor4usv
  */
 void WINAPI wine_glColor4usv( GLushort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glColor4usv( v );
   LEAVE_GL();
@@ -489,6 +545,7 @@
  *              glColorMask
  */
 void WINAPI wine_glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
+  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
   ENTER_GL();
   glColorMask( red, green, blue, alpha );
   LEAVE_GL();
@@ -498,6 +555,7 @@
  *              glColorMaterial
  */
 void WINAPI wine_glColorMaterial( GLenum face, GLenum mode ) {
+  TRACE("(%d, %d)\n", face, mode );
   ENTER_GL();
   glColorMaterial( face, mode );
   LEAVE_GL();
@@ -507,6 +565,7 @@
  *              glColorPointer
  */
 void WINAPI wine_glColorPointer( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
   ENTER_GL();
   glColorPointer( size, type, stride, pointer );
   LEAVE_GL();
@@ -516,6 +575,7 @@
  *              glColorSubTable
  */
 void WINAPI wine_glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, GLvoid* data ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
   ENTER_GL();
   glColorSubTable( target, start, count, format, type, data );
   LEAVE_GL();
@@ -525,6 +585,7 @@
  *              glColorTable
  */
 void WINAPI wine_glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
   ENTER_GL();
   glColorTable( target, internalformat, width, format, type, table );
   LEAVE_GL();
@@ -534,6 +595,7 @@
  *              glColorTableParameterfv
  */
 void WINAPI wine_glColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glColorTableParameterfv( target, pname, params );
   LEAVE_GL();
@@ -543,6 +605,7 @@
  *              glColorTableParameteriv
  */
 void WINAPI wine_glColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glColorTableParameteriv( target, pname, params );
   LEAVE_GL();
@@ -552,6 +615,7 @@
  *              glConvolutionFilter1D
  */
 void WINAPI wine_glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
   ENTER_GL();
   glConvolutionFilter1D( target, internalformat, width, format, type, image );
   LEAVE_GL();
@@ -561,6 +625,7 @@
  *              glConvolutionFilter2D
  */
 void WINAPI wine_glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
   ENTER_GL();
   glConvolutionFilter2D( target, internalformat, width, height, format, type, image );
   LEAVE_GL();
@@ -570,6 +635,7 @@
  *              glConvolutionParameterf
  */
 void WINAPI wine_glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) {
+  TRACE("(%d, %d, %f)\n", target, pname, params );
   ENTER_GL();
   glConvolutionParameterf( target, pname, params );
   LEAVE_GL();
@@ -579,6 +645,7 @@
  *              glConvolutionParameterfv
  */
 void WINAPI wine_glConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glConvolutionParameterfv( target, pname, params );
   LEAVE_GL();
@@ -588,6 +655,7 @@
  *              glConvolutionParameteri
  */
 void WINAPI wine_glConvolutionParameteri( GLenum target, GLenum pname, GLint params ) {
+  TRACE("(%d, %d, %d)\n", target, pname, params );
   ENTER_GL();
   glConvolutionParameteri( target, pname, params );
   LEAVE_GL();
@@ -597,6 +665,7 @@
  *              glConvolutionParameteriv
  */
 void WINAPI wine_glConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glConvolutionParameteriv( target, pname, params );
   LEAVE_GL();
@@ -606,6 +675,7 @@
  *              glCopyColorSubTable
  */
 void WINAPI wine_glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
   ENTER_GL();
   glCopyColorSubTable( target, start, x, y, width );
   LEAVE_GL();
@@ -615,6 +685,7 @@
  *              glCopyColorTable
  */
 void WINAPI wine_glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   ENTER_GL();
   glCopyColorTable( target, internalformat, x, y, width );
   LEAVE_GL();
@@ -624,6 +695,7 @@
  *              glCopyConvolutionFilter1D
  */
 void WINAPI wine_glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   ENTER_GL();
   glCopyConvolutionFilter1D( target, internalformat, x, y, width );
   LEAVE_GL();
@@ -633,6 +705,7 @@
  *              glCopyConvolutionFilter2D
  */
 void WINAPI wine_glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
   ENTER_GL();
   glCopyConvolutionFilter2D( target, internalformat, x, y, width, height );
   LEAVE_GL();
@@ -642,6 +715,7 @@
  *              glCopyPixels
  */
 void WINAPI wine_glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", x, y, width, height, type );
   ENTER_GL();
   glCopyPixels( x, y, width, height, type );
   LEAVE_GL();
@@ -651,6 +725,7 @@
  *              glCopyTexImage1D
  */
 void WINAPI wine_glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
   ENTER_GL();
   glCopyTexImage1D( target, level, internalformat, x, y, width, border );
   LEAVE_GL();
@@ -660,6 +735,7 @@
  *              glCopyTexImage2D
  */
 void WINAPI wine_glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
   ENTER_GL();
   glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
   LEAVE_GL();
@@ -669,6 +745,7 @@
  *              glCopyTexSubImage1D
  */
 void WINAPI wine_glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
   ENTER_GL();
   glCopyTexSubImage1D( target, level, xoffset, x, y, width );
   LEAVE_GL();
@@ -678,6 +755,7 @@
  *              glCopyTexSubImage2D
  */
 void WINAPI wine_glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
   ENTER_GL();
   glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
   LEAVE_GL();
@@ -687,6 +765,7 @@
  *              glCopyTexSubImage3D
  */
 void WINAPI wine_glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
   ENTER_GL();
   glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
   LEAVE_GL();
@@ -696,6 +775,7 @@
  *              glCullFace
  */
 void WINAPI wine_glCullFace( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glCullFace( mode );
   LEAVE_GL();
@@ -705,6 +785,7 @@
  *              glDeleteLists
  */
 void WINAPI wine_glDeleteLists( GLuint list, GLsizei range ) {
+  TRACE("(%d, %d)\n", list, range );
   ENTER_GL();
   glDeleteLists( list, range );
   LEAVE_GL();
@@ -714,6 +795,7 @@
  *              glDeleteTextures
  */
 void WINAPI wine_glDeleteTextures( GLsizei n, GLuint* textures ) {
+  TRACE("(%d, %p)\n", n, textures );
   ENTER_GL();
   glDeleteTextures( n, textures );
   LEAVE_GL();
@@ -723,6 +805,7 @@
  *              glDepthFunc
  */
 void WINAPI wine_glDepthFunc( GLenum func ) {
+  TRACE("(%d)\n", func );
   ENTER_GL();
   glDepthFunc( func );
   LEAVE_GL();
@@ -732,6 +815,7 @@
  *              glDepthMask
  */
 void WINAPI wine_glDepthMask( GLboolean flag ) {
+  TRACE("(%d)\n", flag );
   ENTER_GL();
   glDepthMask( flag );
   LEAVE_GL();
@@ -741,6 +825,7 @@
  *              glDepthRange
  */
 void WINAPI wine_glDepthRange( GLclampd near, GLclampd far ) {
+  TRACE("(%f, %f)\n", near, far );
   ENTER_GL();
   glDepthRange( near, far );
   LEAVE_GL();
@@ -750,6 +835,7 @@
  *              glDisable
  */
 void WINAPI wine_glDisable( GLenum cap ) {
+  TRACE("(%d)\n", cap );
   ENTER_GL();
   glDisable( cap );
   LEAVE_GL();
@@ -759,6 +845,7 @@
  *              glDisableClientState
  */
 void WINAPI wine_glDisableClientState( GLenum array ) {
+  TRACE("(%d)\n", array );
   ENTER_GL();
   glDisableClientState( array );
   LEAVE_GL();
@@ -768,6 +855,7 @@
  *              glDrawArrays
  */
 void WINAPI wine_glDrawArrays( GLenum mode, GLint first, GLsizei count ) {
+  TRACE("(%d, %d, %d)\n", mode, first, count );
   ENTER_GL();
   glDrawArrays( mode, first, count );
   LEAVE_GL();
@@ -777,6 +865,7 @@
  *              glDrawBuffer
  */
 void WINAPI wine_glDrawBuffer( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glDrawBuffer( mode );
   LEAVE_GL();
@@ -786,6 +875,7 @@
  *              glDrawElements
  */
 void WINAPI wine_glDrawElements( GLenum mode, GLsizei count, GLenum type, GLvoid* indices ) {
+  TRACE("(%d, %d, %d, %p)\n", mode, count, type, indices );
   ENTER_GL();
   glDrawElements( mode, count, type, indices );
   LEAVE_GL();
@@ -795,6 +885,7 @@
  *              glDrawPixels
  */
 void WINAPI wine_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", width, height, format, type, pixels );
   ENTER_GL();
   glDrawPixels( width, height, format, type, pixels );
   LEAVE_GL();
@@ -804,6 +895,7 @@
  *              glDrawRangeElements
  */
 void WINAPI wine_glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices ) {
+  TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
   ENTER_GL();
   glDrawRangeElements( mode, start, end, count, type, indices );
   LEAVE_GL();
@@ -813,6 +905,7 @@
  *              glEdgeFlag
  */
 void WINAPI wine_glEdgeFlag( GLboolean flag ) {
+  TRACE("(%d)\n", flag );
   ENTER_GL();
   glEdgeFlag( flag );
   LEAVE_GL();
@@ -822,6 +915,7 @@
  *              glEdgeFlagPointer
  */
 void WINAPI wine_glEdgeFlagPointer( GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %p)\n", stride, pointer );
   ENTER_GL();
   glEdgeFlagPointer( stride, pointer );
   LEAVE_GL();
@@ -831,6 +925,7 @@
  *              glEdgeFlagv
  */
 void WINAPI wine_glEdgeFlagv( GLboolean* flag ) {
+  TRACE("(%p)\n", flag );
   ENTER_GL();
   glEdgeFlagv( flag );
   LEAVE_GL();
@@ -840,6 +935,7 @@
  *              glEnable
  */
 void WINAPI wine_glEnable( GLenum cap ) {
+  TRACE("(%d)\n", cap );
   ENTER_GL();
   glEnable( cap );
   LEAVE_GL();
@@ -849,6 +945,7 @@
  *              glEnableClientState
  */
 void WINAPI wine_glEnableClientState( GLenum array ) {
+  TRACE("(%d)\n", array );
   ENTER_GL();
   glEnableClientState( array );
   LEAVE_GL();
@@ -858,6 +955,7 @@
  *              glEnd
  */
 void WINAPI wine_glEnd( ) {
+  TRACE("()\n");
   ENTER_GL();
   glEnd( );
   LEAVE_GL();
@@ -867,6 +965,7 @@
  *              glEndList
  */
 void WINAPI wine_glEndList( ) {
+  TRACE("()\n");
   ENTER_GL();
   glEndList( );
   LEAVE_GL();
@@ -876,6 +975,7 @@
  *              glEvalCoord1d
  */
 void WINAPI wine_glEvalCoord1d( GLdouble u ) {
+  TRACE("(%f)\n", u );
   ENTER_GL();
   glEvalCoord1d( u );
   LEAVE_GL();
@@ -885,6 +985,7 @@
  *              glEvalCoord1dv
  */
 void WINAPI wine_glEvalCoord1dv( GLdouble* u ) {
+  TRACE("(%p)\n", u );
   ENTER_GL();
   glEvalCoord1dv( u );
   LEAVE_GL();
@@ -894,6 +995,7 @@
  *              glEvalCoord1f
  */
 void WINAPI wine_glEvalCoord1f( GLfloat u ) {
+  TRACE("(%f)\n", u );
   ENTER_GL();
   glEvalCoord1f( u );
   LEAVE_GL();
@@ -903,6 +1005,7 @@
  *              glEvalCoord1fv
  */
 void WINAPI wine_glEvalCoord1fv( GLfloat* u ) {
+  TRACE("(%p)\n", u );
   ENTER_GL();
   glEvalCoord1fv( u );
   LEAVE_GL();
@@ -912,6 +1015,7 @@
  *              glEvalCoord2d
  */
 void WINAPI wine_glEvalCoord2d( GLdouble u, GLdouble v ) {
+  TRACE("(%f, %f)\n", u, v );
   ENTER_GL();
   glEvalCoord2d( u, v );
   LEAVE_GL();
@@ -921,6 +1025,7 @@
  *              glEvalCoord2dv
  */
 void WINAPI wine_glEvalCoord2dv( GLdouble* u ) {
+  TRACE("(%p)\n", u );
   ENTER_GL();
   glEvalCoord2dv( u );
   LEAVE_GL();
@@ -930,6 +1035,7 @@
  *              glEvalCoord2f
  */
 void WINAPI wine_glEvalCoord2f( GLfloat u, GLfloat v ) {
+  TRACE("(%f, %f)\n", u, v );
   ENTER_GL();
   glEvalCoord2f( u, v );
   LEAVE_GL();
@@ -939,6 +1045,7 @@
  *              glEvalCoord2fv
  */
 void WINAPI wine_glEvalCoord2fv( GLfloat* u ) {
+  TRACE("(%p)\n", u );
   ENTER_GL();
   glEvalCoord2fv( u );
   LEAVE_GL();
@@ -948,6 +1055,7 @@
  *              glEvalMesh1
  */
 void WINAPI wine_glEvalMesh1( GLenum mode, GLint i1, GLint i2 ) {
+  TRACE("(%d, %d, %d)\n", mode, i1, i2 );
   ENTER_GL();
   glEvalMesh1( mode, i1, i2 );
   LEAVE_GL();
@@ -957,6 +1065,7 @@
  *              glEvalMesh2
  */
 void WINAPI wine_glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2 );
   ENTER_GL();
   glEvalMesh2( mode, i1, i2, j1, j2 );
   LEAVE_GL();
@@ -966,6 +1075,7 @@
  *              glEvalPoint1
  */
 void WINAPI wine_glEvalPoint1( GLint i ) {
+  TRACE("(%d)\n", i );
   ENTER_GL();
   glEvalPoint1( i );
   LEAVE_GL();
@@ -975,6 +1085,7 @@
  *              glEvalPoint2
  */
 void WINAPI wine_glEvalPoint2( GLint i, GLint j ) {
+  TRACE("(%d, %d)\n", i, j );
   ENTER_GL();
   glEvalPoint2( i, j );
   LEAVE_GL();
@@ -984,6 +1095,7 @@
  *              glFeedbackBuffer
  */
 void WINAPI wine_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat* buffer ) {
+  TRACE("(%d, %d, %p)\n", size, type, buffer );
   ENTER_GL();
   glFeedbackBuffer( size, type, buffer );
   LEAVE_GL();
@@ -993,6 +1105,7 @@
  *              glFinish
  */
 void WINAPI wine_glFinish( ) {
+  TRACE("()\n");
   ENTER_GL();
   glFinish( );
   LEAVE_GL();
@@ -1002,6 +1115,7 @@
  *              glFlush
  */
 void WINAPI wine_glFlush( ) {
+  TRACE("()\n");
   ENTER_GL();
   glFlush( );
   LEAVE_GL();
@@ -1011,6 +1125,7 @@
  *              glFogf
  */
 void WINAPI wine_glFogf( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   glFogf( pname, param );
   LEAVE_GL();
@@ -1020,6 +1135,7 @@
  *              glFogfv
  */
 void WINAPI wine_glFogfv( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glFogfv( pname, params );
   LEAVE_GL();
@@ -1029,6 +1145,7 @@
  *              glFogi
  */
 void WINAPI wine_glFogi( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   glFogi( pname, param );
   LEAVE_GL();
@@ -1038,6 +1155,7 @@
  *              glFogiv
  */
 void WINAPI wine_glFogiv( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glFogiv( pname, params );
   LEAVE_GL();
@@ -1047,6 +1165,7 @@
  *              glFrontFace
  */
 void WINAPI wine_glFrontFace( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glFrontFace( mode );
   LEAVE_GL();
@@ -1056,6 +1175,7 @@
  *              glFrustum
  */
 void WINAPI wine_glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+  TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
   ENTER_GL();
   glFrustum( left, right, bottom, top, zNear, zFar );
   LEAVE_GL();
@@ -1066,6 +1186,7 @@
  */
 GLuint WINAPI wine_glGenLists( GLsizei range ) {
   GLuint ret_value;
+  TRACE("(%d)\n", range );
   ENTER_GL();
   ret_value = glGenLists( range );
   LEAVE_GL();
@@ -1076,6 +1197,7 @@
  *              glGenTextures
  */
 void WINAPI wine_glGenTextures( GLsizei n, GLuint* textures ) {
+  TRACE("(%d, %p)\n", n, textures );
   ENTER_GL();
   glGenTextures( n, textures );
   LEAVE_GL();
@@ -1085,6 +1207,7 @@
  *              glGetBooleanv
  */
 void WINAPI wine_glGetBooleanv( GLenum pname, GLboolean* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glGetBooleanv( pname, params );
   LEAVE_GL();
@@ -1094,6 +1217,7 @@
  *              glGetClipPlane
  */
 void WINAPI wine_glGetClipPlane( GLenum plane, GLdouble* equation ) {
+  TRACE("(%d, %p)\n", plane, equation );
   ENTER_GL();
   glGetClipPlane( plane, equation );
   LEAVE_GL();
@@ -1103,6 +1227,7 @@
  *              glGetColorTable
  */
 void WINAPI wine_glGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid* table ) {
+  TRACE("(%d, %d, %d, %p)\n", target, format, type, table );
   ENTER_GL();
   glGetColorTable( target, format, type, table );
   LEAVE_GL();
@@ -1112,6 +1237,7 @@
  *              glGetColorTableParameterfv
  */
 void WINAPI wine_glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetColorTableParameterfv( target, pname, params );
   LEAVE_GL();
@@ -1121,6 +1247,7 @@
  *              glGetColorTableParameteriv
  */
 void WINAPI wine_glGetColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetColorTableParameteriv( target, pname, params );
   LEAVE_GL();
@@ -1130,6 +1257,7 @@
  *              glGetConvolutionFilter
  */
 void WINAPI wine_glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid* image ) {
+  TRACE("(%d, %d, %d, %p)\n", target, format, type, image );
   ENTER_GL();
   glGetConvolutionFilter( target, format, type, image );
   LEAVE_GL();
@@ -1139,6 +1267,7 @@
  *              glGetConvolutionParameterfv
  */
 void WINAPI wine_glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetConvolutionParameterfv( target, pname, params );
   LEAVE_GL();
@@ -1148,6 +1277,7 @@
  *              glGetConvolutionParameteriv
  */
 void WINAPI wine_glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetConvolutionParameteriv( target, pname, params );
   LEAVE_GL();
@@ -1157,6 +1287,7 @@
  *              glGetDoublev
  */
 void WINAPI wine_glGetDoublev( GLenum pname, GLdouble* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glGetDoublev( pname, params );
   LEAVE_GL();
@@ -1167,6 +1298,7 @@
  */
 GLenum WINAPI wine_glGetError( ) {
   GLenum ret_value;
+  TRACE("()\n");
   ENTER_GL();
   ret_value = glGetError( );
   LEAVE_GL();
@@ -1177,6 +1309,7 @@
  *              glGetFloatv
  */
 void WINAPI wine_glGetFloatv( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glGetFloatv( pname, params );
   LEAVE_GL();
@@ -1186,6 +1319,7 @@
  *              glGetHistogram
  */
 void WINAPI wine_glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   ENTER_GL();
   glGetHistogram( target, reset, format, type, values );
   LEAVE_GL();
@@ -1195,6 +1329,7 @@
  *              glGetHistogramParameterfv
  */
 void WINAPI wine_glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetHistogramParameterfv( target, pname, params );
   LEAVE_GL();
@@ -1204,6 +1339,7 @@
  *              glGetHistogramParameteriv
  */
 void WINAPI wine_glGetHistogramParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetHistogramParameteriv( target, pname, params );
   LEAVE_GL();
@@ -1213,6 +1349,7 @@
  *              glGetIntegerv
  */
 void WINAPI wine_glGetIntegerv( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glGetIntegerv( pname, params );
   LEAVE_GL();
@@ -1222,6 +1359,7 @@
  *              glGetLightfv
  */
 void WINAPI wine_glGetLightfv( GLenum light, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   glGetLightfv( light, pname, params );
   LEAVE_GL();
@@ -1231,6 +1369,7 @@
  *              glGetLightiv
  */
 void WINAPI wine_glGetLightiv( GLenum light, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   glGetLightiv( light, pname, params );
   LEAVE_GL();
@@ -1240,6 +1379,7 @@
  *              glGetMapdv
  */
 void WINAPI wine_glGetMapdv( GLenum target, GLenum query, GLdouble* v ) {
+  TRACE("(%d, %d, %p)\n", target, query, v );
   ENTER_GL();
   glGetMapdv( target, query, v );
   LEAVE_GL();
@@ -1249,6 +1389,7 @@
  *              glGetMapfv
  */
 void WINAPI wine_glGetMapfv( GLenum target, GLenum query, GLfloat* v ) {
+  TRACE("(%d, %d, %p)\n", target, query, v );
   ENTER_GL();
   glGetMapfv( target, query, v );
   LEAVE_GL();
@@ -1258,6 +1399,7 @@
  *              glGetMapiv
  */
 void WINAPI wine_glGetMapiv( GLenum target, GLenum query, GLint* v ) {
+  TRACE("(%d, %d, %p)\n", target, query, v );
   ENTER_GL();
   glGetMapiv( target, query, v );
   LEAVE_GL();
@@ -1267,6 +1409,7 @@
  *              glGetMaterialfv
  */
 void WINAPI wine_glGetMaterialfv( GLenum face, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   glGetMaterialfv( face, pname, params );
   LEAVE_GL();
@@ -1276,6 +1419,7 @@
  *              glGetMaterialiv
  */
 void WINAPI wine_glGetMaterialiv( GLenum face, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   glGetMaterialiv( face, pname, params );
   LEAVE_GL();
@@ -1285,6 +1429,7 @@
  *              glGetMinmax
  */
 void WINAPI wine_glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   ENTER_GL();
   glGetMinmax( target, reset, format, type, values );
   LEAVE_GL();
@@ -1294,6 +1439,7 @@
  *              glGetMinmaxParameterfv
  */
 void WINAPI wine_glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetMinmaxParameterfv( target, pname, params );
   LEAVE_GL();
@@ -1303,6 +1449,7 @@
  *              glGetMinmaxParameteriv
  */
 void WINAPI wine_glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetMinmaxParameteriv( target, pname, params );
   LEAVE_GL();
@@ -1312,6 +1459,7 @@
  *              glGetPixelMapfv
  */
 void WINAPI wine_glGetPixelMapfv( GLenum map, GLfloat* values ) {
+  TRACE("(%d, %p)\n", map, values );
   ENTER_GL();
   glGetPixelMapfv( map, values );
   LEAVE_GL();
@@ -1321,6 +1469,7 @@
  *              glGetPixelMapuiv
  */
 void WINAPI wine_glGetPixelMapuiv( GLenum map, GLuint* values ) {
+  TRACE("(%d, %p)\n", map, values );
   ENTER_GL();
   glGetPixelMapuiv( map, values );
   LEAVE_GL();
@@ -1330,6 +1479,7 @@
  *              glGetPixelMapusv
  */
 void WINAPI wine_glGetPixelMapusv( GLenum map, GLushort* values ) {
+  TRACE("(%d, %p)\n", map, values );
   ENTER_GL();
   glGetPixelMapusv( map, values );
   LEAVE_GL();
@@ -1339,6 +1489,7 @@
  *              glGetPointerv
  */
 void WINAPI wine_glGetPointerv( GLenum pname, GLvoid** params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glGetPointerv( pname, params );
   LEAVE_GL();
@@ -1348,6 +1499,7 @@
  *              glGetPolygonStipple
  */
 void WINAPI wine_glGetPolygonStipple( GLubyte* mask ) {
+  TRACE("(%p)\n", mask );
   ENTER_GL();
   glGetPolygonStipple( mask );
   LEAVE_GL();
@@ -1357,6 +1509,7 @@
  *              glGetSeparableFilter
  */
 void WINAPI wine_glGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid* row, GLvoid* column, GLvoid* span ) {
+  TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
   ENTER_GL();
   glGetSeparableFilter( target, format, type, row, column, span );
   LEAVE_GL();
@@ -1367,6 +1520,7 @@
  */
 GLstring WINAPI wine_glGetString( GLenum name ) {
   GLstring ret_value;
+  TRACE("(%d)\n", name );
   ENTER_GL();
   ret_value = glGetString( name );
   LEAVE_GL();
@@ -1377,6 +1531,7 @@
  *              glGetTexEnvfv
  */
 void WINAPI wine_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetTexEnvfv( target, pname, params );
   LEAVE_GL();
@@ -1386,6 +1541,7 @@
  *              glGetTexEnviv
  */
 void WINAPI wine_glGetTexEnviv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetTexEnviv( target, pname, params );
   LEAVE_GL();
@@ -1395,6 +1551,7 @@
  *              glGetTexGendv
  */
 void WINAPI wine_glGetTexGendv( GLenum coord, GLenum pname, GLdouble* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glGetTexGendv( coord, pname, params );
   LEAVE_GL();
@@ -1404,6 +1561,7 @@
  *              glGetTexGenfv
  */
 void WINAPI wine_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glGetTexGenfv( coord, pname, params );
   LEAVE_GL();
@@ -1413,6 +1571,7 @@
  *              glGetTexGeniv
  */
 void WINAPI wine_glGetTexGeniv( GLenum coord, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glGetTexGeniv( coord, pname, params );
   LEAVE_GL();
@@ -1422,6 +1581,7 @@
  *              glGetTexImage
  */
 void WINAPI wine_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %p)\n", target, level, format, type, pixels );
   ENTER_GL();
   glGetTexImage( target, level, format, type, pixels );
   LEAVE_GL();
@@ -1431,6 +1591,7 @@
  *              glGetTexLevelParameterfv
  */
 void WINAPI wine_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
   ENTER_GL();
   glGetTexLevelParameterfv( target, level, pname, params );
   LEAVE_GL();
@@ -1440,6 +1601,7 @@
  *              glGetTexLevelParameteriv
  */
 void WINAPI wine_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
   ENTER_GL();
   glGetTexLevelParameteriv( target, level, pname, params );
   LEAVE_GL();
@@ -1449,6 +1611,7 @@
  *              glGetTexParameterfv
  */
 void WINAPI wine_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetTexParameterfv( target, pname, params );
   LEAVE_GL();
@@ -1458,6 +1621,7 @@
  *              glGetTexParameteriv
  */
 void WINAPI wine_glGetTexParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glGetTexParameteriv( target, pname, params );
   LEAVE_GL();
@@ -1467,6 +1631,7 @@
  *              glHint
  */
 void WINAPI wine_glHint( GLenum target, GLenum mode ) {
+  TRACE("(%d, %d)\n", target, mode );
   ENTER_GL();
   glHint( target, mode );
   LEAVE_GL();
@@ -1476,6 +1641,7 @@
  *              glHistogram
  */
 void WINAPI wine_glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
+  TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink );
   ENTER_GL();
   glHistogram( target, width, internalformat, sink );
   LEAVE_GL();
@@ -1485,6 +1651,7 @@
  *              glIndexMask
  */
 void WINAPI wine_glIndexMask( GLuint mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   glIndexMask( mask );
   LEAVE_GL();
@@ -1494,6 +1661,7 @@
  *              glIndexPointer
  */
 void WINAPI wine_glIndexPointer( GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   glIndexPointer( type, stride, pointer );
   LEAVE_GL();
@@ -1503,6 +1671,7 @@
  *              glIndexd
  */
 void WINAPI wine_glIndexd( GLdouble c ) {
+  TRACE("(%f)\n", c );
   ENTER_GL();
   glIndexd( c );
   LEAVE_GL();
@@ -1512,6 +1681,7 @@
  *              glIndexdv
  */
 void WINAPI wine_glIndexdv( GLdouble* c ) {
+  TRACE("(%p)\n", c );
   ENTER_GL();
   glIndexdv( c );
   LEAVE_GL();
@@ -1521,6 +1691,7 @@
  *              glIndexf
  */
 void WINAPI wine_glIndexf( GLfloat c ) {
+  TRACE("(%f)\n", c );
   ENTER_GL();
   glIndexf( c );
   LEAVE_GL();
@@ -1530,6 +1701,7 @@
  *              glIndexfv
  */
 void WINAPI wine_glIndexfv( GLfloat* c ) {
+  TRACE("(%p)\n", c );
   ENTER_GL();
   glIndexfv( c );
   LEAVE_GL();
@@ -1539,6 +1711,7 @@
  *              glIndexi
  */
 void WINAPI wine_glIndexi( GLint c ) {
+  TRACE("(%d)\n", c );
   ENTER_GL();
   glIndexi( c );
   LEAVE_GL();
@@ -1548,6 +1721,7 @@
  *              glIndexiv
  */
 void WINAPI wine_glIndexiv( GLint* c ) {
+  TRACE("(%p)\n", c );
   ENTER_GL();
   glIndexiv( c );
   LEAVE_GL();
@@ -1557,6 +1731,7 @@
  *              glIndexs
  */
 void WINAPI wine_glIndexs( GLshort c ) {
+  TRACE("(%d)\n", c );
   ENTER_GL();
   glIndexs( c );
   LEAVE_GL();
@@ -1566,6 +1741,7 @@
  *              glIndexsv
  */
 void WINAPI wine_glIndexsv( GLshort* c ) {
+  TRACE("(%p)\n", c );
   ENTER_GL();
   glIndexsv( c );
   LEAVE_GL();
@@ -1575,6 +1751,7 @@
  *              glIndexub
  */
 void WINAPI wine_glIndexub( GLubyte c ) {
+  TRACE("(%d)\n", c );
   ENTER_GL();
   glIndexub( c );
   LEAVE_GL();
@@ -1584,6 +1761,7 @@
  *              glIndexubv
  */
 void WINAPI wine_glIndexubv( GLubyte* c ) {
+  TRACE("(%p)\n", c );
   ENTER_GL();
   glIndexubv( c );
   LEAVE_GL();
@@ -1593,6 +1771,7 @@
  *              glInitNames
  */
 void WINAPI wine_glInitNames( ) {
+  TRACE("()\n");
   ENTER_GL();
   glInitNames( );
   LEAVE_GL();
@@ -1602,6 +1781,7 @@
  *              glInterleavedArrays
  */
 void WINAPI wine_glInterleavedArrays( GLenum format, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", format, stride, pointer );
   ENTER_GL();
   glInterleavedArrays( format, stride, pointer );
   LEAVE_GL();
@@ -1612,6 +1792,7 @@
  */
 GLboolean WINAPI wine_glIsEnabled( GLenum cap ) {
   GLboolean ret_value;
+  TRACE("(%d)\n", cap );
   ENTER_GL();
   ret_value = glIsEnabled( cap );
   LEAVE_GL();
@@ -1623,6 +1804,7 @@
  */
 GLboolean WINAPI wine_glIsList( GLuint list ) {
   GLboolean ret_value;
+  TRACE("(%d)\n", list );
   ENTER_GL();
   ret_value = glIsList( list );
   LEAVE_GL();
@@ -1634,6 +1816,7 @@
  */
 GLboolean WINAPI wine_glIsTexture( GLuint texture ) {
   GLboolean ret_value;
+  TRACE("(%d)\n", texture );
   ENTER_GL();
   ret_value = glIsTexture( texture );
   LEAVE_GL();
@@ -1644,6 +1827,7 @@
  *              glLightModelf
  */
 void WINAPI wine_glLightModelf( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   glLightModelf( pname, param );
   LEAVE_GL();
@@ -1653,6 +1837,7 @@
  *              glLightModelfv
  */
 void WINAPI wine_glLightModelfv( GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glLightModelfv( pname, params );
   LEAVE_GL();
@@ -1662,6 +1847,7 @@
  *              glLightModeli
  */
 void WINAPI wine_glLightModeli( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   glLightModeli( pname, param );
   LEAVE_GL();
@@ -1671,6 +1857,7 @@
  *              glLightModeliv
  */
 void WINAPI wine_glLightModeliv( GLenum pname, GLint* params ) {
+  TRACE("(%d, %p)\n", pname, params );
   ENTER_GL();
   glLightModeliv( pname, params );
   LEAVE_GL();
@@ -1680,6 +1867,7 @@
  *              glLightf
  */
 void WINAPI wine_glLightf( GLenum light, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", light, pname, param );
   ENTER_GL();
   glLightf( light, pname, param );
   LEAVE_GL();
@@ -1689,6 +1877,7 @@
  *              glLightfv
  */
 void WINAPI wine_glLightfv( GLenum light, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   glLightfv( light, pname, params );
   LEAVE_GL();
@@ -1698,6 +1887,7 @@
  *              glLighti
  */
 void WINAPI wine_glLighti( GLenum light, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", light, pname, param );
   ENTER_GL();
   glLighti( light, pname, param );
   LEAVE_GL();
@@ -1707,6 +1897,7 @@
  *              glLightiv
  */
 void WINAPI wine_glLightiv( GLenum light, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", light, pname, params );
   ENTER_GL();
   glLightiv( light, pname, params );
   LEAVE_GL();
@@ -1716,6 +1907,7 @@
  *              glLineStipple
  */
 void WINAPI wine_glLineStipple( GLint factor, GLushort pattern ) {
+  TRACE("(%d, %d)\n", factor, pattern );
   ENTER_GL();
   glLineStipple( factor, pattern );
   LEAVE_GL();
@@ -1725,6 +1917,7 @@
  *              glLineWidth
  */
 void WINAPI wine_glLineWidth( GLfloat width ) {
+  TRACE("(%f)\n", width );
   ENTER_GL();
   glLineWidth( width );
   LEAVE_GL();
@@ -1734,6 +1927,7 @@
  *              glListBase
  */
 void WINAPI wine_glListBase( GLuint base ) {
+  TRACE("(%d)\n", base );
   ENTER_GL();
   glListBase( base );
   LEAVE_GL();
@@ -1743,6 +1937,7 @@
  *              glLoadIdentity
  */
 void WINAPI wine_glLoadIdentity( ) {
+  TRACE("()\n");
   ENTER_GL();
   glLoadIdentity( );
   LEAVE_GL();
@@ -1752,6 +1947,7 @@
  *              glLoadMatrixd
  */
 void WINAPI wine_glLoadMatrixd( GLdouble* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   glLoadMatrixd( m );
   LEAVE_GL();
@@ -1761,6 +1957,7 @@
  *              glLoadMatrixf
  */
 void WINAPI wine_glLoadMatrixf( GLfloat* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   glLoadMatrixf( m );
   LEAVE_GL();
@@ -1770,6 +1967,7 @@
  *              glLoadName
  */
 void WINAPI wine_glLoadName( GLuint name ) {
+  TRACE("(%d)\n", name );
   ENTER_GL();
   glLoadName( name );
   LEAVE_GL();
@@ -1779,6 +1977,7 @@
  *              glLogicOp
  */
 void WINAPI wine_glLogicOp( GLenum opcode ) {
+  TRACE("(%d)\n", opcode );
   ENTER_GL();
   glLogicOp( opcode );
   LEAVE_GL();
@@ -1788,6 +1987,7 @@
  *              glMap1d
  */
 void WINAPI wine_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
   ENTER_GL();
   glMap1d( target, u1, u2, stride, order, points );
   LEAVE_GL();
@@ -1797,6 +1997,7 @@
  *              glMap1f
  */
 void WINAPI wine_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
   ENTER_GL();
   glMap1f( target, u1, u2, stride, order, points );
   LEAVE_GL();
@@ -1806,6 +2007,7 @@
  *              glMap2d
  */
 void WINAPI wine_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   ENTER_GL();
   glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   LEAVE_GL();
@@ -1815,6 +2017,7 @@
  *              glMap2f
  */
 void WINAPI wine_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points ) {
+  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   ENTER_GL();
   glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   LEAVE_GL();
@@ -1824,6 +2027,7 @@
  *              glMapGrid1d
  */
 void WINAPI wine_glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) {
+  TRACE("(%d, %f, %f)\n", un, u1, u2 );
   ENTER_GL();
   glMapGrid1d( un, u1, u2 );
   LEAVE_GL();
@@ -1833,6 +2037,7 @@
  *              glMapGrid1f
  */
 void WINAPI wine_glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) {
+  TRACE("(%d, %f, %f)\n", un, u1, u2 );
   ENTER_GL();
   glMapGrid1f( un, u1, u2 );
   LEAVE_GL();
@@ -1842,6 +2047,7 @@
  *              glMapGrid2d
  */
 void WINAPI wine_glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) {
+  TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
   ENTER_GL();
   glMapGrid2d( un, u1, u2, vn, v1, v2 );
   LEAVE_GL();
@@ -1851,6 +2057,7 @@
  *              glMapGrid2f
  */
 void WINAPI wine_glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) {
+  TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
   ENTER_GL();
   glMapGrid2f( un, u1, u2, vn, v1, v2 );
   LEAVE_GL();
@@ -1860,6 +2067,7 @@
  *              glMaterialf
  */
 void WINAPI wine_glMaterialf( GLenum face, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", face, pname, param );
   ENTER_GL();
   glMaterialf( face, pname, param );
   LEAVE_GL();
@@ -1869,6 +2077,7 @@
  *              glMaterialfv
  */
 void WINAPI wine_glMaterialfv( GLenum face, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   glMaterialfv( face, pname, params );
   LEAVE_GL();
@@ -1878,6 +2087,7 @@
  *              glMateriali
  */
 void WINAPI wine_glMateriali( GLenum face, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", face, pname, param );
   ENTER_GL();
   glMateriali( face, pname, param );
   LEAVE_GL();
@@ -1887,6 +2097,7 @@
  *              glMaterialiv
  */
 void WINAPI wine_glMaterialiv( GLenum face, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", face, pname, params );
   ENTER_GL();
   glMaterialiv( face, pname, params );
   LEAVE_GL();
@@ -1896,6 +2107,7 @@
  *              glMatrixMode
  */
 void WINAPI wine_glMatrixMode( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glMatrixMode( mode );
   LEAVE_GL();
@@ -1905,6 +2117,7 @@
  *              glMinmax
  */
 void WINAPI wine_glMinmax( GLenum target, GLenum internalformat, GLboolean sink ) {
+  TRACE("(%d, %d, %d)\n", target, internalformat, sink );
   ENTER_GL();
   glMinmax( target, internalformat, sink );
   LEAVE_GL();
@@ -1914,6 +2127,7 @@
  *              glMultMatrixd
  */
 void WINAPI wine_glMultMatrixd( GLdouble* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   glMultMatrixd( m );
   LEAVE_GL();
@@ -1923,6 +2137,7 @@
  *              glMultMatrixf
  */
 void WINAPI wine_glMultMatrixf( GLfloat* m ) {
+  TRACE("(%p)\n", m );
   ENTER_GL();
   glMultMatrixf( m );
   LEAVE_GL();
@@ -1932,6 +2147,7 @@
  *              glMultiTexCoord1dARB
  */
 void WINAPI wine_glMultiTexCoord1dARB( GLenum target, GLdouble s ) {
+  TRACE("(%d, %f)\n", target, s );
   ENTER_GL();
   glMultiTexCoord1dARB( target, s );
   LEAVE_GL();
@@ -1941,6 +2157,7 @@
  *              glMultiTexCoord1dvARB
  */
 void WINAPI wine_glMultiTexCoord1dvARB( GLenum target, GLdouble* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord1dvARB( target, v );
   LEAVE_GL();
@@ -1950,6 +2167,7 @@
  *              glMultiTexCoord1fARB
  */
 void WINAPI wine_glMultiTexCoord1fARB( GLenum target, GLfloat s ) {
+  TRACE("(%d, %f)\n", target, s );
   ENTER_GL();
   glMultiTexCoord1fARB( target, s );
   LEAVE_GL();
@@ -1959,6 +2177,7 @@
  *              glMultiTexCoord1fvARB
  */
 void WINAPI wine_glMultiTexCoord1fvARB( GLenum target, GLfloat* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord1fvARB( target, v );
   LEAVE_GL();
@@ -1968,6 +2187,7 @@
  *              glMultiTexCoord1iARB
  */
 void WINAPI wine_glMultiTexCoord1iARB( GLenum target, GLint s ) {
+  TRACE("(%d, %d)\n", target, s );
   ENTER_GL();
   glMultiTexCoord1iARB( target, s );
   LEAVE_GL();
@@ -1977,6 +2197,7 @@
  *              glMultiTexCoord1ivARB
  */
 void WINAPI wine_glMultiTexCoord1ivARB( GLenum target, GLint* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord1ivARB( target, v );
   LEAVE_GL();
@@ -1986,6 +2207,7 @@
  *              glMultiTexCoord1sARB
  */
 void WINAPI wine_glMultiTexCoord1sARB( GLenum target, GLshort s ) {
+  TRACE("(%d, %d)\n", target, s );
   ENTER_GL();
   glMultiTexCoord1sARB( target, s );
   LEAVE_GL();
@@ -1995,6 +2217,7 @@
  *              glMultiTexCoord1svARB
  */
 void WINAPI wine_glMultiTexCoord1svARB( GLenum target, GLshort* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord1svARB( target, v );
   LEAVE_GL();
@@ -2004,6 +2227,7 @@
  *              glMultiTexCoord2dARB
  */
 void WINAPI wine_glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t ) {
+  TRACE("(%d, %f, %f)\n", target, s, t );
   ENTER_GL();
   glMultiTexCoord2dARB( target, s, t );
   LEAVE_GL();
@@ -2013,6 +2237,7 @@
  *              glMultiTexCoord2dvARB
  */
 void WINAPI wine_glMultiTexCoord2dvARB( GLenum target, GLdouble* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord2dvARB( target, v );
   LEAVE_GL();
@@ -2022,6 +2247,7 @@
  *              glMultiTexCoord2fARB
  */
 void WINAPI wine_glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t ) {
+  TRACE("(%d, %f, %f)\n", target, s, t );
   ENTER_GL();
   glMultiTexCoord2fARB( target, s, t );
   LEAVE_GL();
@@ -2031,6 +2257,7 @@
  *              glMultiTexCoord2fvARB
  */
 void WINAPI wine_glMultiTexCoord2fvARB( GLenum target, GLfloat* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord2fvARB( target, v );
   LEAVE_GL();
@@ -2040,6 +2267,7 @@
  *              glMultiTexCoord2iARB
  */
 void WINAPI wine_glMultiTexCoord2iARB( GLenum target, GLint s, GLint t ) {
+  TRACE("(%d, %d, %d)\n", target, s, t );
   ENTER_GL();
   glMultiTexCoord2iARB( target, s, t );
   LEAVE_GL();
@@ -2049,6 +2277,7 @@
  *              glMultiTexCoord2ivARB
  */
 void WINAPI wine_glMultiTexCoord2ivARB( GLenum target, GLint* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord2ivARB( target, v );
   LEAVE_GL();
@@ -2058,6 +2287,7 @@
  *              glMultiTexCoord2sARB
  */
 void WINAPI wine_glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t ) {
+  TRACE("(%d, %d, %d)\n", target, s, t );
   ENTER_GL();
   glMultiTexCoord2sARB( target, s, t );
   LEAVE_GL();
@@ -2067,6 +2297,7 @@
  *              glMultiTexCoord2svARB
  */
 void WINAPI wine_glMultiTexCoord2svARB( GLenum target, GLshort* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord2svARB( target, v );
   LEAVE_GL();
@@ -2076,6 +2307,7 @@
  *              glMultiTexCoord3dARB
  */
 void WINAPI wine_glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r ) {
+  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
   ENTER_GL();
   glMultiTexCoord3dARB( target, s, t, r );
   LEAVE_GL();
@@ -2085,6 +2317,7 @@
  *              glMultiTexCoord3dvARB
  */
 void WINAPI wine_glMultiTexCoord3dvARB( GLenum target, GLdouble* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord3dvARB( target, v );
   LEAVE_GL();
@@ -2094,6 +2327,7 @@
  *              glMultiTexCoord3fARB
  */
 void WINAPI wine_glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r ) {
+  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
   ENTER_GL();
   glMultiTexCoord3fARB( target, s, t, r );
   LEAVE_GL();
@@ -2103,6 +2337,7 @@
  *              glMultiTexCoord3fvARB
  */
 void WINAPI wine_glMultiTexCoord3fvARB( GLenum target, GLfloat* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord3fvARB( target, v );
   LEAVE_GL();
@@ -2112,6 +2347,7 @@
  *              glMultiTexCoord3iARB
  */
 void WINAPI wine_glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r ) {
+  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
   ENTER_GL();
   glMultiTexCoord3iARB( target, s, t, r );
   LEAVE_GL();
@@ -2121,6 +2357,7 @@
  *              glMultiTexCoord3ivARB
  */
 void WINAPI wine_glMultiTexCoord3ivARB( GLenum target, GLint* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord3ivARB( target, v );
   LEAVE_GL();
@@ -2130,6 +2367,7 @@
  *              glMultiTexCoord3sARB
  */
 void WINAPI wine_glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r ) {
+  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
   ENTER_GL();
   glMultiTexCoord3sARB( target, s, t, r );
   LEAVE_GL();
@@ -2139,6 +2377,7 @@
  *              glMultiTexCoord3svARB
  */
 void WINAPI wine_glMultiTexCoord3svARB( GLenum target, GLshort* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord3svARB( target, v );
   LEAVE_GL();
@@ -2148,6 +2387,7 @@
  *              glMultiTexCoord4dARB
  */
 void WINAPI wine_glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   ENTER_GL();
   glMultiTexCoord4dARB( target, s, t, r, q );
   LEAVE_GL();
@@ -2157,6 +2397,7 @@
  *              glMultiTexCoord4dvARB
  */
 void WINAPI wine_glMultiTexCoord4dvARB( GLenum target, GLdouble* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord4dvARB( target, v );
   LEAVE_GL();
@@ -2166,6 +2407,7 @@
  *              glMultiTexCoord4fARB
  */
 void WINAPI wine_glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   ENTER_GL();
   glMultiTexCoord4fARB( target, s, t, r, q );
   LEAVE_GL();
@@ -2175,6 +2417,7 @@
  *              glMultiTexCoord4fvARB
  */
 void WINAPI wine_glMultiTexCoord4fvARB( GLenum target, GLfloat* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord4fvARB( target, v );
   LEAVE_GL();
@@ -2184,6 +2427,7 @@
  *              glMultiTexCoord4iARB
  */
 void WINAPI wine_glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   ENTER_GL();
   glMultiTexCoord4iARB( target, s, t, r, q );
   LEAVE_GL();
@@ -2193,6 +2437,7 @@
  *              glMultiTexCoord4ivARB
  */
 void WINAPI wine_glMultiTexCoord4ivARB( GLenum target, GLint* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord4ivARB( target, v );
   LEAVE_GL();
@@ -2202,6 +2447,7 @@
  *              glMultiTexCoord4sARB
  */
 void WINAPI wine_glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) {
+  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   ENTER_GL();
   glMultiTexCoord4sARB( target, s, t, r, q );
   LEAVE_GL();
@@ -2211,6 +2457,7 @@
  *              glMultiTexCoord4svARB
  */
 void WINAPI wine_glMultiTexCoord4svARB( GLenum target, GLshort* v ) {
+  TRACE("(%d, %p)\n", target, v );
   ENTER_GL();
   glMultiTexCoord4svARB( target, v );
   LEAVE_GL();
@@ -2220,6 +2467,7 @@
  *              glNewList
  */
 void WINAPI wine_glNewList( GLuint list, GLenum mode ) {
+  TRACE("(%d, %d)\n", list, mode );
   ENTER_GL();
   glNewList( list, mode );
   LEAVE_GL();
@@ -2229,6 +2477,7 @@
  *              glNormal3b
  */
 void WINAPI wine_glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) {
+  TRACE("(%d, %d, %d)\n", nx, ny, nz );
   ENTER_GL();
   glNormal3b( nx, ny, nz );
   LEAVE_GL();
@@ -2238,6 +2487,7 @@
  *              glNormal3bv
  */
 void WINAPI wine_glNormal3bv( GLbyte* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glNormal3bv( v );
   LEAVE_GL();
@@ -2247,6 +2497,7 @@
  *              glNormal3d
  */
 void WINAPI wine_glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) {
+  TRACE("(%f, %f, %f)\n", nx, ny, nz );
   ENTER_GL();
   glNormal3d( nx, ny, nz );
   LEAVE_GL();
@@ -2256,6 +2507,7 @@
  *              glNormal3dv
  */
 void WINAPI wine_glNormal3dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glNormal3dv( v );
   LEAVE_GL();
@@ -2265,6 +2517,7 @@
  *              glNormal3f
  */
 void WINAPI wine_glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) {
+  TRACE("(%f, %f, %f)\n", nx, ny, nz );
   ENTER_GL();
   glNormal3f( nx, ny, nz );
   LEAVE_GL();
@@ -2274,6 +2527,7 @@
  *              glNormal3fv
  */
 void WINAPI wine_glNormal3fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glNormal3fv( v );
   LEAVE_GL();
@@ -2283,6 +2537,7 @@
  *              glNormal3i
  */
 void WINAPI wine_glNormal3i( GLint nx, GLint ny, GLint nz ) {
+  TRACE("(%d, %d, %d)\n", nx, ny, nz );
   ENTER_GL();
   glNormal3i( nx, ny, nz );
   LEAVE_GL();
@@ -2292,6 +2547,7 @@
  *              glNormal3iv
  */
 void WINAPI wine_glNormal3iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glNormal3iv( v );
   LEAVE_GL();
@@ -2301,6 +2557,7 @@
  *              glNormal3s
  */
 void WINAPI wine_glNormal3s( GLshort nx, GLshort ny, GLshort nz ) {
+  TRACE("(%d, %d, %d)\n", nx, ny, nz );
   ENTER_GL();
   glNormal3s( nx, ny, nz );
   LEAVE_GL();
@@ -2310,6 +2567,7 @@
  *              glNormal3sv
  */
 void WINAPI wine_glNormal3sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glNormal3sv( v );
   LEAVE_GL();
@@ -2319,6 +2577,7 @@
  *              glNormalPointer
  */
 void WINAPI wine_glNormalPointer( GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %p)\n", type, stride, pointer );
   ENTER_GL();
   glNormalPointer( type, stride, pointer );
   LEAVE_GL();
@@ -2328,6 +2587,7 @@
  *              glOrtho
  */
 void WINAPI wine_glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+  TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
   ENTER_GL();
   glOrtho( left, right, bottom, top, zNear, zFar );
   LEAVE_GL();
@@ -2337,6 +2597,7 @@
  *              glPassThrough
  */
 void WINAPI wine_glPassThrough( GLfloat token ) {
+  TRACE("(%f)\n", token );
   ENTER_GL();
   glPassThrough( token );
   LEAVE_GL();
@@ -2346,6 +2607,7 @@
  *              glPixelMapfv
  */
 void WINAPI wine_glPixelMapfv( GLenum map, GLint mapsize, GLfloat* values ) {
+  TRACE("(%d, %d, %p)\n", map, mapsize, values );
   ENTER_GL();
   glPixelMapfv( map, mapsize, values );
   LEAVE_GL();
@@ -2355,6 +2617,7 @@
  *              glPixelMapuiv
  */
 void WINAPI wine_glPixelMapuiv( GLenum map, GLint mapsize, GLuint* values ) {
+  TRACE("(%d, %d, %p)\n", map, mapsize, values );
   ENTER_GL();
   glPixelMapuiv( map, mapsize, values );
   LEAVE_GL();
@@ -2364,6 +2627,7 @@
  *              glPixelMapusv
  */
 void WINAPI wine_glPixelMapusv( GLenum map, GLint mapsize, GLushort* values ) {
+  TRACE("(%d, %d, %p)\n", map, mapsize, values );
   ENTER_GL();
   glPixelMapusv( map, mapsize, values );
   LEAVE_GL();
@@ -2373,6 +2637,7 @@
  *              glPixelStoref
  */
 void WINAPI wine_glPixelStoref( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   glPixelStoref( pname, param );
   LEAVE_GL();
@@ -2382,6 +2647,7 @@
  *              glPixelStorei
  */
 void WINAPI wine_glPixelStorei( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   glPixelStorei( pname, param );
   LEAVE_GL();
@@ -2391,6 +2657,7 @@
  *              glPixelTransferf
  */
 void WINAPI wine_glPixelTransferf( GLenum pname, GLfloat param ) {
+  TRACE("(%d, %f)\n", pname, param );
   ENTER_GL();
   glPixelTransferf( pname, param );
   LEAVE_GL();
@@ -2400,6 +2667,7 @@
  *              glPixelTransferi
  */
 void WINAPI wine_glPixelTransferi( GLenum pname, GLint param ) {
+  TRACE("(%d, %d)\n", pname, param );
   ENTER_GL();
   glPixelTransferi( pname, param );
   LEAVE_GL();
@@ -2409,6 +2677,7 @@
  *              glPixelZoom
  */
 void WINAPI wine_glPixelZoom( GLfloat xfactor, GLfloat yfactor ) {
+  TRACE("(%f, %f)\n", xfactor, yfactor );
   ENTER_GL();
   glPixelZoom( xfactor, yfactor );
   LEAVE_GL();
@@ -2418,6 +2687,7 @@
  *              glPointSize
  */
 void WINAPI wine_glPointSize( GLfloat size ) {
+  TRACE("(%f)\n", size );
   ENTER_GL();
   glPointSize( size );
   LEAVE_GL();
@@ -2427,6 +2697,7 @@
  *              glPolygonMode
  */
 void WINAPI wine_glPolygonMode( GLenum face, GLenum mode ) {
+  TRACE("(%d, %d)\n", face, mode );
   ENTER_GL();
   glPolygonMode( face, mode );
   LEAVE_GL();
@@ -2436,6 +2707,7 @@
  *              glPolygonOffset
  */
 void WINAPI wine_glPolygonOffset( GLfloat factor, GLfloat units ) {
+  TRACE("(%f, %f)\n", factor, units );
   ENTER_GL();
   glPolygonOffset( factor, units );
   LEAVE_GL();
@@ -2445,6 +2717,7 @@
  *              glPolygonStipple
  */
 void WINAPI wine_glPolygonStipple( GLubyte* mask ) {
+  TRACE("(%p)\n", mask );
   ENTER_GL();
   glPolygonStipple( mask );
   LEAVE_GL();
@@ -2454,6 +2727,7 @@
  *              glPopAttrib
  */
 void WINAPI wine_glPopAttrib( ) {
+  TRACE("()\n");
   ENTER_GL();
   glPopAttrib( );
   LEAVE_GL();
@@ -2463,6 +2737,7 @@
  *              glPopClientAttrib
  */
 void WINAPI wine_glPopClientAttrib( ) {
+  TRACE("()\n");
   ENTER_GL();
   glPopClientAttrib( );
   LEAVE_GL();
@@ -2472,6 +2747,7 @@
  *              glPopMatrix
  */
 void WINAPI wine_glPopMatrix( ) {
+  TRACE("()\n");
   ENTER_GL();
   glPopMatrix( );
   LEAVE_GL();
@@ -2481,6 +2757,7 @@
  *              glPopName
  */
 void WINAPI wine_glPopName( ) {
+  TRACE("()\n");
   ENTER_GL();
   glPopName( );
   LEAVE_GL();
@@ -2490,6 +2767,7 @@
  *              glPrioritizeTextures
  */
 void WINAPI wine_glPrioritizeTextures( GLsizei n, GLuint* textures, GLclampf* priorities ) {
+  TRACE("(%d, %p, %p)\n", n, textures, priorities );
   ENTER_GL();
   glPrioritizeTextures( n, textures, priorities );
   LEAVE_GL();
@@ -2499,6 +2777,7 @@
  *              glPushAttrib
  */
 void WINAPI wine_glPushAttrib( GLbitfield mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   glPushAttrib( mask );
   LEAVE_GL();
@@ -2508,6 +2787,7 @@
  *              glPushClientAttrib
  */
 void WINAPI wine_glPushClientAttrib( GLbitfield mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   glPushClientAttrib( mask );
   LEAVE_GL();
@@ -2517,6 +2797,7 @@
  *              glPushMatrix
  */
 void WINAPI wine_glPushMatrix( ) {
+  TRACE("()\n");
   ENTER_GL();
   glPushMatrix( );
   LEAVE_GL();
@@ -2526,6 +2807,7 @@
  *              glPushName
  */
 void WINAPI wine_glPushName( GLuint name ) {
+  TRACE("(%d)\n", name );
   ENTER_GL();
   glPushName( name );
   LEAVE_GL();
@@ -2535,6 +2817,7 @@
  *              glRasterPos2d
  */
 void WINAPI wine_glRasterPos2d( GLdouble x, GLdouble y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   glRasterPos2d( x, y );
   LEAVE_GL();
@@ -2544,6 +2827,7 @@
  *              glRasterPos2dv
  */
 void WINAPI wine_glRasterPos2dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos2dv( v );
   LEAVE_GL();
@@ -2553,6 +2837,7 @@
  *              glRasterPos2f
  */
 void WINAPI wine_glRasterPos2f( GLfloat x, GLfloat y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   glRasterPos2f( x, y );
   LEAVE_GL();
@@ -2562,6 +2847,7 @@
  *              glRasterPos2fv
  */
 void WINAPI wine_glRasterPos2fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos2fv( v );
   LEAVE_GL();
@@ -2571,6 +2857,7 @@
  *              glRasterPos2i
  */
 void WINAPI wine_glRasterPos2i( GLint x, GLint y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   glRasterPos2i( x, y );
   LEAVE_GL();
@@ -2580,6 +2867,7 @@
  *              glRasterPos2iv
  */
 void WINAPI wine_glRasterPos2iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos2iv( v );
   LEAVE_GL();
@@ -2589,6 +2877,7 @@
  *              glRasterPos2s
  */
 void WINAPI wine_glRasterPos2s( GLshort x, GLshort y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   glRasterPos2s( x, y );
   LEAVE_GL();
@@ -2598,6 +2887,7 @@
  *              glRasterPos2sv
  */
 void WINAPI wine_glRasterPos2sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos2sv( v );
   LEAVE_GL();
@@ -2607,6 +2897,7 @@
  *              glRasterPos3d
  */
 void WINAPI wine_glRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glRasterPos3d( x, y, z );
   LEAVE_GL();
@@ -2616,6 +2907,7 @@
  *              glRasterPos3dv
  */
 void WINAPI wine_glRasterPos3dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos3dv( v );
   LEAVE_GL();
@@ -2625,6 +2917,7 @@
  *              glRasterPos3f
  */
 void WINAPI wine_glRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glRasterPos3f( x, y, z );
   LEAVE_GL();
@@ -2634,6 +2927,7 @@
  *              glRasterPos3fv
  */
 void WINAPI wine_glRasterPos3fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos3fv( v );
   LEAVE_GL();
@@ -2643,6 +2937,7 @@
  *              glRasterPos3i
  */
 void WINAPI wine_glRasterPos3i( GLint x, GLint y, GLint z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   glRasterPos3i( x, y, z );
   LEAVE_GL();
@@ -2652,6 +2947,7 @@
  *              glRasterPos3iv
  */
 void WINAPI wine_glRasterPos3iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos3iv( v );
   LEAVE_GL();
@@ -2661,6 +2957,7 @@
  *              glRasterPos3s
  */
 void WINAPI wine_glRasterPos3s( GLshort x, GLshort y, GLshort z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   glRasterPos3s( x, y, z );
   LEAVE_GL();
@@ -2670,6 +2967,7 @@
  *              glRasterPos3sv
  */
 void WINAPI wine_glRasterPos3sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos3sv( v );
   LEAVE_GL();
@@ -2679,6 +2977,7 @@
  *              glRasterPos4d
  */
 void WINAPI wine_glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   glRasterPos4d( x, y, z, w );
   LEAVE_GL();
@@ -2688,6 +2987,7 @@
  *              glRasterPos4dv
  */
 void WINAPI wine_glRasterPos4dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos4dv( v );
   LEAVE_GL();
@@ -2697,6 +2997,7 @@
  *              glRasterPos4f
  */
 void WINAPI wine_glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   glRasterPos4f( x, y, z, w );
   LEAVE_GL();
@@ -2706,6 +3007,7 @@
  *              glRasterPos4fv
  */
 void WINAPI wine_glRasterPos4fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos4fv( v );
   LEAVE_GL();
@@ -2715,6 +3017,7 @@
  *              glRasterPos4i
  */
 void WINAPI wine_glRasterPos4i( GLint x, GLint y, GLint z, GLint w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   glRasterPos4i( x, y, z, w );
   LEAVE_GL();
@@ -2724,6 +3027,7 @@
  *              glRasterPos4iv
  */
 void WINAPI wine_glRasterPos4iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos4iv( v );
   LEAVE_GL();
@@ -2733,6 +3037,7 @@
  *              glRasterPos4s
  */
 void WINAPI wine_glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   glRasterPos4s( x, y, z, w );
   LEAVE_GL();
@@ -2742,6 +3047,7 @@
  *              glRasterPos4sv
  */
 void WINAPI wine_glRasterPos4sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glRasterPos4sv( v );
   LEAVE_GL();
@@ -2751,6 +3057,7 @@
  *              glReadBuffer
  */
 void WINAPI wine_glReadBuffer( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glReadBuffer( mode );
   LEAVE_GL();
@@ -2760,6 +3067,7 @@
  *              glReadPixels
  */
 void WINAPI wine_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, pixels );
   ENTER_GL();
   glReadPixels( x, y, width, height, format, type, pixels );
   LEAVE_GL();
@@ -2769,6 +3077,7 @@
  *              glRectd
  */
 void WINAPI wine_glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) {
+  TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
   ENTER_GL();
   glRectd( x1, y1, x2, y2 );
   LEAVE_GL();
@@ -2778,6 +3087,7 @@
  *              glRectdv
  */
 void WINAPI wine_glRectdv( GLdouble* v1, GLdouble* v2 ) {
+  TRACE("(%p, %p)\n", v1, v2 );
   ENTER_GL();
   glRectdv( v1, v2 );
   LEAVE_GL();
@@ -2787,6 +3097,7 @@
  *              glRectf
  */
 void WINAPI wine_glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) {
+  TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
   ENTER_GL();
   glRectf( x1, y1, x2, y2 );
   LEAVE_GL();
@@ -2796,6 +3107,7 @@
  *              glRectfv
  */
 void WINAPI wine_glRectfv( GLfloat* v1, GLfloat* v2 ) {
+  TRACE("(%p, %p)\n", v1, v2 );
   ENTER_GL();
   glRectfv( v1, v2 );
   LEAVE_GL();
@@ -2805,6 +3117,7 @@
  *              glRecti
  */
 void WINAPI wine_glRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) {
+  TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
   ENTER_GL();
   glRecti( x1, y1, x2, y2 );
   LEAVE_GL();
@@ -2814,6 +3127,7 @@
  *              glRectiv
  */
 void WINAPI wine_glRectiv( GLint* v1, GLint* v2 ) {
+  TRACE("(%p, %p)\n", v1, v2 );
   ENTER_GL();
   glRectiv( v1, v2 );
   LEAVE_GL();
@@ -2823,6 +3137,7 @@
  *              glRects
  */
 void WINAPI wine_glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) {
+  TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
   ENTER_GL();
   glRects( x1, y1, x2, y2 );
   LEAVE_GL();
@@ -2832,6 +3147,7 @@
  *              glRectsv
  */
 void WINAPI wine_glRectsv( GLshort* v1, GLshort* v2 ) {
+  TRACE("(%p, %p)\n", v1, v2 );
   ENTER_GL();
   glRectsv( v1, v2 );
   LEAVE_GL();
@@ -2842,6 +3158,7 @@
  */
 GLint WINAPI wine_glRenderMode( GLenum mode ) {
   GLint ret_value;
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   ret_value = glRenderMode( mode );
   LEAVE_GL();
@@ -2852,6 +3169,7 @@
  *              glResetHistogram
  */
 void WINAPI wine_glResetHistogram( GLenum target ) {
+  TRACE("(%d)\n", target );
   ENTER_GL();
   glResetHistogram( target );
   LEAVE_GL();
@@ -2861,6 +3179,7 @@
  *              glResetMinmax
  */
 void WINAPI wine_glResetMinmax( GLenum target ) {
+  TRACE("(%d)\n", target );
   ENTER_GL();
   glResetMinmax( target );
   LEAVE_GL();
@@ -2870,6 +3189,7 @@
  *              glRotated
  */
 void WINAPI wine_glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
   ENTER_GL();
   glRotated( angle, x, y, z );
   LEAVE_GL();
@@ -2879,6 +3199,7 @@
  *              glRotatef
  */
 void WINAPI wine_glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
   ENTER_GL();
   glRotatef( angle, x, y, z );
   LEAVE_GL();
@@ -2888,6 +3209,7 @@
  *              glScaled
  */
 void WINAPI wine_glScaled( GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glScaled( x, y, z );
   LEAVE_GL();
@@ -2897,6 +3219,7 @@
  *              glScalef
  */
 void WINAPI wine_glScalef( GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glScalef( x, y, z );
   LEAVE_GL();
@@ -2906,6 +3229,7 @@
  *              glScissor
  */
 void WINAPI wine_glScissor( GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
   ENTER_GL();
   glScissor( x, y, width, height );
   LEAVE_GL();
@@ -2915,6 +3239,7 @@
  *              glSelectBuffer
  */
 void WINAPI wine_glSelectBuffer( GLsizei size, GLuint* buffer ) {
+  TRACE("(%d, %p)\n", size, buffer );
   ENTER_GL();
   glSelectBuffer( size, buffer );
   LEAVE_GL();
@@ -2924,6 +3249,7 @@
  *              glSeparableFilter2D
  */
 void WINAPI wine_glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* row, GLvoid* column ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
   ENTER_GL();
   glSeparableFilter2D( target, internalformat, width, height, format, type, row, column );
   LEAVE_GL();
@@ -2933,6 +3259,7 @@
  *              glShadeModel
  */
 void WINAPI wine_glShadeModel( GLenum mode ) {
+  TRACE("(%d)\n", mode );
   ENTER_GL();
   glShadeModel( mode );
   LEAVE_GL();
@@ -2942,6 +3269,7 @@
  *              glStencilFunc
  */
 void WINAPI wine_glStencilFunc( GLenum func, GLint ref, GLuint mask ) {
+  TRACE("(%d, %d, %d)\n", func, ref, mask );
   ENTER_GL();
   glStencilFunc( func, ref, mask );
   LEAVE_GL();
@@ -2951,6 +3279,7 @@
  *              glStencilMask
  */
 void WINAPI wine_glStencilMask( GLuint mask ) {
+  TRACE("(%d)\n", mask );
   ENTER_GL();
   glStencilMask( mask );
   LEAVE_GL();
@@ -2960,6 +3289,7 @@
  *              glStencilOp
  */
 void WINAPI wine_glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {
+  TRACE("(%d, %d, %d)\n", fail, zfail, zpass );
   ENTER_GL();
   glStencilOp( fail, zfail, zpass );
   LEAVE_GL();
@@ -2969,6 +3299,7 @@
  *              glTexCoord1d
  */
 void WINAPI wine_glTexCoord1d( GLdouble s ) {
+  TRACE("(%f)\n", s );
   ENTER_GL();
   glTexCoord1d( s );
   LEAVE_GL();
@@ -2978,6 +3309,7 @@
  *              glTexCoord1dv
  */
 void WINAPI wine_glTexCoord1dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord1dv( v );
   LEAVE_GL();
@@ -2987,6 +3319,7 @@
  *              glTexCoord1f
  */
 void WINAPI wine_glTexCoord1f( GLfloat s ) {
+  TRACE("(%f)\n", s );
   ENTER_GL();
   glTexCoord1f( s );
   LEAVE_GL();
@@ -2996,6 +3329,7 @@
  *              glTexCoord1fv
  */
 void WINAPI wine_glTexCoord1fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord1fv( v );
   LEAVE_GL();
@@ -3005,6 +3339,7 @@
  *              glTexCoord1i
  */
 void WINAPI wine_glTexCoord1i( GLint s ) {
+  TRACE("(%d)\n", s );
   ENTER_GL();
   glTexCoord1i( s );
   LEAVE_GL();
@@ -3014,6 +3349,7 @@
  *              glTexCoord1iv
  */
 void WINAPI wine_glTexCoord1iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord1iv( v );
   LEAVE_GL();
@@ -3023,6 +3359,7 @@
  *              glTexCoord1s
  */
 void WINAPI wine_glTexCoord1s( GLshort s ) {
+  TRACE("(%d)\n", s );
   ENTER_GL();
   glTexCoord1s( s );
   LEAVE_GL();
@@ -3032,6 +3369,7 @@
  *              glTexCoord1sv
  */
 void WINAPI wine_glTexCoord1sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord1sv( v );
   LEAVE_GL();
@@ -3041,6 +3379,7 @@
  *              glTexCoord2d
  */
 void WINAPI wine_glTexCoord2d( GLdouble s, GLdouble t ) {
+  TRACE("(%f, %f)\n", s, t );
   ENTER_GL();
   glTexCoord2d( s, t );
   LEAVE_GL();
@@ -3050,6 +3389,7 @@
  *              glTexCoord2dv
  */
 void WINAPI wine_glTexCoord2dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord2dv( v );
   LEAVE_GL();
@@ -3059,6 +3399,7 @@
  *              glTexCoord2f
  */
 void WINAPI wine_glTexCoord2f( GLfloat s, GLfloat t ) {
+  TRACE("(%f, %f)\n", s, t );
   ENTER_GL();
   glTexCoord2f( s, t );
   LEAVE_GL();
@@ -3068,6 +3409,7 @@
  *              glTexCoord2fv
  */
 void WINAPI wine_glTexCoord2fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord2fv( v );
   LEAVE_GL();
@@ -3077,6 +3419,7 @@
  *              glTexCoord2i
  */
 void WINAPI wine_glTexCoord2i( GLint s, GLint t ) {
+  TRACE("(%d, %d)\n", s, t );
   ENTER_GL();
   glTexCoord2i( s, t );
   LEAVE_GL();
@@ -3086,6 +3429,7 @@
  *              glTexCoord2iv
  */
 void WINAPI wine_glTexCoord2iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord2iv( v );
   LEAVE_GL();
@@ -3095,6 +3439,7 @@
  *              glTexCoord2s
  */
 void WINAPI wine_glTexCoord2s( GLshort s, GLshort t ) {
+  TRACE("(%d, %d)\n", s, t );
   ENTER_GL();
   glTexCoord2s( s, t );
   LEAVE_GL();
@@ -3104,6 +3449,7 @@
  *              glTexCoord2sv
  */
 void WINAPI wine_glTexCoord2sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord2sv( v );
   LEAVE_GL();
@@ -3113,6 +3459,7 @@
  *              glTexCoord3d
  */
 void WINAPI wine_glTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) {
+  TRACE("(%f, %f, %f)\n", s, t, r );
   ENTER_GL();
   glTexCoord3d( s, t, r );
   LEAVE_GL();
@@ -3122,6 +3469,7 @@
  *              glTexCoord3dv
  */
 void WINAPI wine_glTexCoord3dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord3dv( v );
   LEAVE_GL();
@@ -3131,6 +3479,7 @@
  *              glTexCoord3f
  */
 void WINAPI wine_glTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) {
+  TRACE("(%f, %f, %f)\n", s, t, r );
   ENTER_GL();
   glTexCoord3f( s, t, r );
   LEAVE_GL();
@@ -3140,6 +3489,7 @@
  *              glTexCoord3fv
  */
 void WINAPI wine_glTexCoord3fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord3fv( v );
   LEAVE_GL();
@@ -3149,6 +3499,7 @@
  *              glTexCoord3i
  */
 void WINAPI wine_glTexCoord3i( GLint s, GLint t, GLint r ) {
+  TRACE("(%d, %d, %d)\n", s, t, r );
   ENTER_GL();
   glTexCoord3i( s, t, r );
   LEAVE_GL();
@@ -3158,6 +3509,7 @@
  *              glTexCoord3iv
  */
 void WINAPI wine_glTexCoord3iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord3iv( v );
   LEAVE_GL();
@@ -3167,6 +3519,7 @@
  *              glTexCoord3s
  */
 void WINAPI wine_glTexCoord3s( GLshort s, GLshort t, GLshort r ) {
+  TRACE("(%d, %d, %d)\n", s, t, r );
   ENTER_GL();
   glTexCoord3s( s, t, r );
   LEAVE_GL();
@@ -3176,6 +3529,7 @@
  *              glTexCoord3sv
  */
 void WINAPI wine_glTexCoord3sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord3sv( v );
   LEAVE_GL();
@@ -3185,6 +3539,7 @@
  *              glTexCoord4d
  */
 void WINAPI wine_glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+  TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
   ENTER_GL();
   glTexCoord4d( s, t, r, q );
   LEAVE_GL();
@@ -3194,6 +3549,7 @@
  *              glTexCoord4dv
  */
 void WINAPI wine_glTexCoord4dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord4dv( v );
   LEAVE_GL();
@@ -3203,6 +3559,7 @@
  *              glTexCoord4f
  */
 void WINAPI wine_glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+  TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
   ENTER_GL();
   glTexCoord4f( s, t, r, q );
   LEAVE_GL();
@@ -3212,6 +3569,7 @@
  *              glTexCoord4fv
  */
 void WINAPI wine_glTexCoord4fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord4fv( v );
   LEAVE_GL();
@@ -3221,6 +3579,7 @@
  *              glTexCoord4i
  */
 void WINAPI wine_glTexCoord4i( GLint s, GLint t, GLint r, GLint q ) {
+  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
   ENTER_GL();
   glTexCoord4i( s, t, r, q );
   LEAVE_GL();
@@ -3230,6 +3589,7 @@
  *              glTexCoord4iv
  */
 void WINAPI wine_glTexCoord4iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord4iv( v );
   LEAVE_GL();
@@ -3239,6 +3599,7 @@
  *              glTexCoord4s
  */
 void WINAPI wine_glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) {
+  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
   ENTER_GL();
   glTexCoord4s( s, t, r, q );
   LEAVE_GL();
@@ -3248,6 +3609,7 @@
  *              glTexCoord4sv
  */
 void WINAPI wine_glTexCoord4sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glTexCoord4sv( v );
   LEAVE_GL();
@@ -3257,6 +3619,7 @@
  *              glTexCoordPointer
  */
 void WINAPI wine_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
   ENTER_GL();
   glTexCoordPointer( size, type, stride, pointer );
   LEAVE_GL();
@@ -3266,6 +3629,7 @@
  *              glTexEnvf
  */
 void WINAPI wine_glTexEnvf( GLenum target, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", target, pname, param );
   ENTER_GL();
   glTexEnvf( target, pname, param );
   LEAVE_GL();
@@ -3275,6 +3639,7 @@
  *              glTexEnvfv
  */
 void WINAPI wine_glTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glTexEnvfv( target, pname, params );
   LEAVE_GL();
@@ -3284,6 +3649,7 @@
  *              glTexEnvi
  */
 void WINAPI wine_glTexEnvi( GLenum target, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", target, pname, param );
   ENTER_GL();
   glTexEnvi( target, pname, param );
   LEAVE_GL();
@@ -3293,6 +3659,7 @@
  *              glTexEnviv
  */
 void WINAPI wine_glTexEnviv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glTexEnviv( target, pname, params );
   LEAVE_GL();
@@ -3302,6 +3669,7 @@
  *              glTexGend
  */
 void WINAPI wine_glTexGend( GLenum coord, GLenum pname, GLdouble param ) {
+  TRACE("(%d, %d, %f)\n", coord, pname, param );
   ENTER_GL();
   glTexGend( coord, pname, param );
   LEAVE_GL();
@@ -3311,6 +3679,7 @@
  *              glTexGendv
  */
 void WINAPI wine_glTexGendv( GLenum coord, GLenum pname, GLdouble* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glTexGendv( coord, pname, params );
   LEAVE_GL();
@@ -3320,6 +3689,7 @@
  *              glTexGenf
  */
 void WINAPI wine_glTexGenf( GLenum coord, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", coord, pname, param );
   ENTER_GL();
   glTexGenf( coord, pname, param );
   LEAVE_GL();
@@ -3329,6 +3699,7 @@
  *              glTexGenfv
  */
 void WINAPI wine_glTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glTexGenfv( coord, pname, params );
   LEAVE_GL();
@@ -3338,6 +3709,7 @@
  *              glTexGeni
  */
 void WINAPI wine_glTexGeni( GLenum coord, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", coord, pname, param );
   ENTER_GL();
   glTexGeni( coord, pname, param );
   LEAVE_GL();
@@ -3347,6 +3719,7 @@
  *              glTexGeniv
  */
 void WINAPI wine_glTexGeniv( GLenum coord, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", coord, pname, params );
   ENTER_GL();
   glTexGeniv( coord, pname, params );
   LEAVE_GL();
@@ -3356,6 +3729,7 @@
  *              glTexImage1D
  */
 void WINAPI wine_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, format, type, pixels );
   ENTER_GL();
   glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
   LEAVE_GL();
@@ -3365,6 +3739,7 @@
  *              glTexImage2D
  */
 void WINAPI wine_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, format, type, pixels );
   ENTER_GL();
   glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
   LEAVE_GL();
@@ -3374,6 +3749,7 @@
  *              glTexImage3D
  */
 void WINAPI wine_glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
   ENTER_GL();
   glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
   LEAVE_GL();
@@ -3383,6 +3759,7 @@
  *              glTexParameterf
  */
 void WINAPI wine_glTexParameterf( GLenum target, GLenum pname, GLfloat param ) {
+  TRACE("(%d, %d, %f)\n", target, pname, param );
   ENTER_GL();
   glTexParameterf( target, pname, param );
   LEAVE_GL();
@@ -3392,6 +3769,7 @@
  *              glTexParameterfv
  */
 void WINAPI wine_glTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glTexParameterfv( target, pname, params );
   LEAVE_GL();
@@ -3401,6 +3779,7 @@
  *              glTexParameteri
  */
 void WINAPI wine_glTexParameteri( GLenum target, GLenum pname, GLint param ) {
+  TRACE("(%d, %d, %d)\n", target, pname, param );
   ENTER_GL();
   glTexParameteri( target, pname, param );
   LEAVE_GL();
@@ -3410,6 +3789,7 @@
  *              glTexParameteriv
  */
 void WINAPI wine_glTexParameteriv( GLenum target, GLenum pname, GLint* params ) {
+  TRACE("(%d, %d, %p)\n", target, pname, params );
   ENTER_GL();
   glTexParameteriv( target, pname, params );
   LEAVE_GL();
@@ -3419,6 +3799,7 @@
  *              glTexSubImage1D
  */
 void WINAPI wine_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
   ENTER_GL();
   glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
   LEAVE_GL();
@@ -3428,6 +3809,7 @@
  *              glTexSubImage2D
  */
 void WINAPI wine_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
   ENTER_GL();
   glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
   LEAVE_GL();
@@ -3437,6 +3819,7 @@
  *              glTexSubImage3D
  */
 void WINAPI wine_glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) {
+  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   ENTER_GL();
   glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   LEAVE_GL();
@@ -3446,6 +3829,7 @@
  *              glTranslated
  */
 void WINAPI wine_glTranslated( GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glTranslated( x, y, z );
   LEAVE_GL();
@@ -3455,6 +3839,7 @@
  *              glTranslatef
  */
 void WINAPI wine_glTranslatef( GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glTranslatef( x, y, z );
   LEAVE_GL();
@@ -3464,6 +3849,7 @@
  *              glVertex2d
  */
 void WINAPI wine_glVertex2d( GLdouble x, GLdouble y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   glVertex2d( x, y );
   LEAVE_GL();
@@ -3473,6 +3859,7 @@
  *              glVertex2dv
  */
 void WINAPI wine_glVertex2dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex2dv( v );
   LEAVE_GL();
@@ -3482,6 +3869,7 @@
  *              glVertex2f
  */
 void WINAPI wine_glVertex2f( GLfloat x, GLfloat y ) {
+  TRACE("(%f, %f)\n", x, y );
   ENTER_GL();
   glVertex2f( x, y );
   LEAVE_GL();
@@ -3491,6 +3879,7 @@
  *              glVertex2fv
  */
 void WINAPI wine_glVertex2fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex2fv( v );
   LEAVE_GL();
@@ -3500,6 +3889,7 @@
  *              glVertex2i
  */
 void WINAPI wine_glVertex2i( GLint x, GLint y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   glVertex2i( x, y );
   LEAVE_GL();
@@ -3509,6 +3899,7 @@
  *              glVertex2iv
  */
 void WINAPI wine_glVertex2iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex2iv( v );
   LEAVE_GL();
@@ -3518,6 +3909,7 @@
  *              glVertex2s
  */
 void WINAPI wine_glVertex2s( GLshort x, GLshort y ) {
+  TRACE("(%d, %d)\n", x, y );
   ENTER_GL();
   glVertex2s( x, y );
   LEAVE_GL();
@@ -3527,6 +3919,7 @@
  *              glVertex2sv
  */
 void WINAPI wine_glVertex2sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex2sv( v );
   LEAVE_GL();
@@ -3536,6 +3929,7 @@
  *              glVertex3d
  */
 void WINAPI wine_glVertex3d( GLdouble x, GLdouble y, GLdouble z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glVertex3d( x, y, z );
   LEAVE_GL();
@@ -3545,6 +3939,7 @@
  *              glVertex3dv
  */
 void WINAPI wine_glVertex3dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex3dv( v );
   LEAVE_GL();
@@ -3554,6 +3949,7 @@
  *              glVertex3f
  */
 void WINAPI wine_glVertex3f( GLfloat x, GLfloat y, GLfloat z ) {
+  TRACE("(%f, %f, %f)\n", x, y, z );
   ENTER_GL();
   glVertex3f( x, y, z );
   LEAVE_GL();
@@ -3563,6 +3959,7 @@
  *              glVertex3fv
  */
 void WINAPI wine_glVertex3fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex3fv( v );
   LEAVE_GL();
@@ -3572,6 +3969,7 @@
  *              glVertex3i
  */
 void WINAPI wine_glVertex3i( GLint x, GLint y, GLint z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   glVertex3i( x, y, z );
   LEAVE_GL();
@@ -3581,6 +3979,7 @@
  *              glVertex3iv
  */
 void WINAPI wine_glVertex3iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex3iv( v );
   LEAVE_GL();
@@ -3590,6 +3989,7 @@
  *              glVertex3s
  */
 void WINAPI wine_glVertex3s( GLshort x, GLshort y, GLshort z ) {
+  TRACE("(%d, %d, %d)\n", x, y, z );
   ENTER_GL();
   glVertex3s( x, y, z );
   LEAVE_GL();
@@ -3599,6 +3999,7 @@
  *              glVertex3sv
  */
 void WINAPI wine_glVertex3sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex3sv( v );
   LEAVE_GL();
@@ -3608,6 +4009,7 @@
  *              glVertex4d
  */
 void WINAPI wine_glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   glVertex4d( x, y, z, w );
   LEAVE_GL();
@@ -3617,6 +4019,7 @@
  *              glVertex4dv
  */
 void WINAPI wine_glVertex4dv( GLdouble* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex4dv( v );
   LEAVE_GL();
@@ -3626,6 +4029,7 @@
  *              glVertex4f
  */
 void WINAPI wine_glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
   ENTER_GL();
   glVertex4f( x, y, z, w );
   LEAVE_GL();
@@ -3635,6 +4039,7 @@
  *              glVertex4fv
  */
 void WINAPI wine_glVertex4fv( GLfloat* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex4fv( v );
   LEAVE_GL();
@@ -3644,6 +4049,7 @@
  *              glVertex4i
  */
 void WINAPI wine_glVertex4i( GLint x, GLint y, GLint z, GLint w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   glVertex4i( x, y, z, w );
   LEAVE_GL();
@@ -3653,6 +4059,7 @@
  *              glVertex4iv
  */
 void WINAPI wine_glVertex4iv( GLint* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex4iv( v );
   LEAVE_GL();
@@ -3662,6 +4069,7 @@
  *              glVertex4s
  */
 void WINAPI wine_glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
   ENTER_GL();
   glVertex4s( x, y, z, w );
   LEAVE_GL();
@@ -3671,6 +4079,7 @@
  *              glVertex4sv
  */
 void WINAPI wine_glVertex4sv( GLshort* v ) {
+  TRACE("(%p)\n", v );
   ENTER_GL();
   glVertex4sv( v );
   LEAVE_GL();
@@ -3680,6 +4089,7 @@
  *              glVertexPointer
  */
 void WINAPI wine_glVertexPointer( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
   ENTER_GL();
   glVertexPointer( size, type, stride, pointer );
   LEAVE_GL();
@@ -3689,6 +4099,7 @@
  *              glViewport
  */
 void WINAPI wine_glViewport( GLint x, GLint y, GLsizei width, GLsizei height ) {
+  TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
   ENTER_GL();
   glViewport( x, y, width, height );
   LEAVE_GL();