[PATCH v3 1/5] opengl32: Create a unixlib interface for GL functions.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/Makefile.in   |    2 +
 dlls/opengl32/make_opengl   |  233 ++-
 dlls/opengl32/opengl_norm.c | 2340 ---------------------------
 dlls/opengl32/thunks.c      | 2695 +++++++++++++++++++++++++++++++
 dlls/opengl32/unix_thunks.c | 3013 +++++++++++++++++++++++++++++++++++
 dlls/opengl32/unixlib.h     | 2486 +++++++++++++++++++++++++++++
 6 files changed, 8402 insertions(+), 2367 deletions(-)
 create mode 100644 dlls/opengl32/thunks.c
 create mode 100644 dlls/opengl32/unix_thunks.c
 create mode 100644 dlls/opengl32/unixlib.h

diff --git a/dlls/opengl32/Makefile.in b/dlls/opengl32/Makefile.in
index 37986c7a33e..1ae5c4bc773 100644
--- a/dlls/opengl32/Makefile.in
+++ b/dlls/opengl32/Makefile.in
@@ -9,6 +9,8 @@ EXTRADLLFLAGS = -Wl,--image-base,0x7a800000 -mcygwin
 C_SRCS = \
    opengl_ext.c \
    opengl_norm.c \
+	thunks.c \
+	unix_thunks.c \
    wgl.c

RC_SRCS = version.rc
diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index cb6882b3774..4c1fb10f0ef 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -171,9 +171,9 @@ sub ConvertType($)
     return $ret;
 }

-sub get_func_trace($$)
+sub get_func_trace($$$)
 {
-    my ($name, $func) = @_;
+    my ($name, $func, $param_names) = @_;
     my $trace_fmt = "";
     my $trace_arg = "";
     foreach my $arg (@{$func->[1]})
@@ -183,24 +183,29 @@ sub get_func_trace($$)
         my $param = $arg->textContent();
         if ($param =~ /*/ || $param =~ /[/)
         {
-            $trace_fmt .= ", %p";
+            $trace_fmt .= ", ";
+            $trace_fmt .= "$pname " if $param_names;
+            $trace_fmt .= "%p";
             $trace_arg .= ", $pname";
         }
         elsif (defined $arg_types{$ptype})
         {
             my $format = ${$arg_types{$ptype}}[1];
-            $trace_fmt .= ", " . ($format =~ /^%/ ? $format : "%s");
+            $trace_fmt .= ", ";
+            $trace_fmt .= "$pname " if $param_names;
+            $trace_fmt .= ($format =~ /^%/ ? $format : "%s");
             $trace_arg .= ", " . (sprintf $format =~ /^%/ ? "%s" : $format, $pname);
         }
         else { printf "Unknown type %s in %s\n", $param, $name; }
     }
     $trace_fmt =~ s/^, //;
-    return "TRACE( "($trace_fmt)\n"$trace_arg );\n";
+    $trace_fmt = "($trace_fmt)" unless $param_names;
+    return "TRACE( "$trace_fmt\n"$trace_arg );\n";
 }

-sub get_func_args($$$)
+sub get_func_args($$$$)
 {
-    my ($func, $decl_args, $convert_args) = @_;
+    my ($func, $decl_args, $convert_args, $prefix) = @_;
     my $ret = "";
     foreach my $arg (@{$func->[1]})
     {
@@ -211,7 +216,7 @@ sub get_func_args($$$)
         }
         else
         {
-            $ret .= " $pname,";
+            $ret .= " $prefix$pname,";
         }
     }
     $ret =~ s/,$/ /;
@@ -233,8 +238,8 @@ sub get_func_ret($$)
 sub GenerateThunk($$$)
 {
     my ($name, $func, $prefix) = @_;
-    my $call_args = get_func_args( $func, 0, 0 );
-    my $decl_args = get_func_args( $func, 1, 0 );
+    my $call_args = get_func_args( $func, 0, 0, "" );
+    my $decl_args = get_func_args( $func, 1, 0, "" );
     my $func_ret = get_func_ret( $func, 0 );
     my $ret = "";

@@ -245,7 +250,7 @@ sub GenerateThunk($$$)
     {
         my $pname = get_arg_name( ${$func->[1]}[0] );
         $ret .= "  const struct opengl_funcs *funcs = get_dc_funcs( $pname );\n";
-        $ret .= "  " . get_func_trace( $name, $func ) if $gen_traces;
+        $ret .= "  " . get_func_trace( $name, $func, 0 ) if $gen_traces;
         $ret .= "  if (!funcs || !funcs->$prefix.p_$name) return";
         $ret .= " 0" unless is_void_func( $func );
         $ret .= ";\n";
@@ -253,7 +258,7 @@ sub GenerateThunk($$$)
     else
     {
         $ret .= "  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
-        $ret .= "  " . get_func_trace( $name, $func ) if $gen_traces;
+        $ret .= "  " . get_func_trace( $name, $func, 0 ) if $gen_traces;
     }
     $ret .= "  ";
     $ret .= "return " unless is_void_func( $func );
@@ -262,10 +267,67 @@ sub GenerateThunk($$$)
     return $ret;
 }

+sub generate_unix_thunk($$$)
+{
+    my ($name, $func, $prefix) = @_;
+    my $call_args = get_func_args( $func, 0, 0, "params->" );
+    my $func_ret = get_func_ret( $func, 0 );
+    my $ret = "";
+
+    $ret .= "static NTSTATUS $prefix_$name( void *args )\n";
+    $ret .= "{\n";
+    $ret .= "    struct $name_params *params = args;\n" unless !$call_args && is_void_func( $func );
+    # special case for functions that take an HDC as first parameter
+    if (@{$func->[1]} && get_arg_type( ${$func->[1]}[0] ) eq "HDC")
+    {
+        my $pname = get_arg_name( ${$func->[1]}[0] );
+        $ret .= "    const struct opengl_funcs *funcs = get_dc_funcs( params->$pname );\n";
+        $ret .= "    if (!funcs || !funcs->$prefix.p_$name) return STATUS_NOT_IMPLEMENTED;\n";
+    }
+    else
+    {
+        $ret .= "    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
+    }
+    $ret .= "    ";
+    $ret .= "params->ret = " unless is_void_func( $func );
+    $ret .= "funcs->$prefix.p_$name($call_args);\n";
+    $ret .= "    return STATUS_SUCCESS;\n";
+    $ret .= "}\n\n";
+
+    return $ret;
+}
+
+sub generate_win_thunk($$)
+{
+    my ($name, $func) = @_;
+    my $decl_args = get_func_args( $func, 1, 0, "" );
+    my $func_ret = get_func_ret( $func, 0 );
+    my $params = "";
+    my $ret = "";
+
+    $ret .= "$func_ret WINAPI $name($decl_args)\n";
+    $ret .= "{\n";
+    $ret .= "    struct $name_params args";
+    foreach my $arg (@{$func->[1]})
+    {
+        my $pname = get_arg_name( $arg );
+        $params .= " .$pname = $pname,";
+    }
+    $ret .= ($params ? " = {$params }" : is_void_func( $func ) ? "" : " = {0}");
+    $ret .= ";\n";
+    $ret .= "    NTSTATUS status;\n";
+    $ret .= "    " . get_func_trace( $name, $func, 1 ) if $gen_traces;
+    $ret .= "    if ((status = UNIX_CALL( $name, &args ))) WARN( "$name returned %#x\n", status );\n";
+    $ret .= "    return args.ret;\n" unless is_void_func($func);
+    $ret .= "}\n";
+
+    return $ret;
+}
+
 sub generate_null_func($$$)
 {
     my ($name, $func, $callconv) = @_;
-    my $decl_args = get_func_args( $func, 1, 1 );
+    my $decl_args = get_func_args( $func, 1, 1, "" );
     my $func_ret = get_func_ret( $func, 1 );
     my $ret = "";

@@ -305,6 +367,20 @@ sub generate_spec_entry($$)
     return "@ stdcall $_($args)";
 }

+sub generate_func_params($$)
+{
+    my ($name, $func) = @_;
+    my $ret = "";
+    $ret .= sprintf "struct %s_params\n{\n", $name;
+    foreach my $arg (@{$func->[1]})
+    {
+        $ret .= sprintf "    %s;\n", $arg->textContent();
+    }
+    $ret .= sprintf "    %sret;\n", $func->[0]->textContent() unless is_void_func($func);
+    $ret .= "};\n\n";
+    return $ret;
+}
+
 sub is_void_func($)
 {
     my $func = shift;
@@ -648,7 +724,7 @@ print HEADER "    struct\n    {\n";
 foreach (sort keys %wgl_functions)
 {
     next if defined $manual_win_functions{$_};
-    my $decl_args = get_func_args( $wgl_functions{$_}, 1, 1 );
+    my $decl_args = get_func_args( $wgl_functions{$_}, 1, 1, "" );
     my $func_ret = get_func_ret( $wgl_functions{$_}, 1 );
     printf HEADER "        %-10s (WINAPI *p_$_)($decl_args);\n", $func_ret;
 }
@@ -658,7 +734,7 @@ print HEADER "    struct\n    {\n";
 foreach (sort keys %norm_functions)
 {
     next if defined $manual_win_functions{$_};
-    my $decl_args = get_func_args( $norm_functions{$_}, 1, 1 );
+    my $decl_args = get_func_args( $norm_functions{$_}, 1, 1, "" );
     my $func_ret = get_func_ret( $norm_functions{$_}, 1 );
     printf HEADER "        %-10s (WINE_GLAPI *p_$_)($decl_args);\n", $func_ret;
 }
@@ -668,7 +744,7 @@ print HEADER "    struct\n    {\n";
 foreach (sort keys %ext_functions)
 {
     next if defined $manual_win_functions{$_};
-    my $decl_args = get_func_args( $ext_functions{$_}, 1, 1 );
+    my $decl_args = get_func_args( $ext_functions{$_}, 1, 1, "" );
     my $func_ret = get_func_ret( $ext_functions{$_}, 1 );
     printf HEADER "        %-10s (WINE_GLAPI *p_$_)($decl_args);\n", $func_ret;
 }
@@ -717,7 +793,7 @@ print HEADER "\n";

foreach (sort keys %norm_functions)
 {
-    my $decl_args = get_func_args( $norm_functions{$_}, 1, 0 );
+    my $decl_args = get_func_args( $norm_functions{$_}, 1, 0, "" );
     my $func_ret = get_func_ret( $norm_functions{$_}, 0 );
     printf HEADER "%-10s GLAPIENTRY $_($decl_args);\n", $func_ret;
 }
@@ -749,21 +825,12 @@ my $file_header =
 "#include "opengl_ext.h"\n" .
 "#include "wine/debug.h"\n\n";

-$file_header .= "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n\n" if $gen_traces;
-
 #
 # After the spec file, the opengl_norm.c file
 #
 open(NORM, ">$norm_file") or die "cannot create $norm_file";
 print NORM $file_header;

-foreach (sort keys %norm_functions)
-{
-    next if defined $manual_win_functions{$_};
-    next if needs_wrapper( $_, $norm_functions{$_} );
-    print NORM GenerateThunk($_, $norm_functions{$_}, "gl");
-}
-
 foreach (sort keys %wgl_functions)
 {
     next if defined $manual_win_functions{$_};
@@ -802,6 +869,8 @@ print NORM "    }\n};\n";

close(NORM);

+$file_header .= "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n\n" if $gen_traces;
+
 #
 # Finally, more complex, the opengl_ext.c file
 #
@@ -815,7 +884,7 @@ print EXT "const int extension_registry_size = $count;\n\n";
 foreach (sort keys %ext_functions) {
     if (needs_wrapper( $_, $ext_functions{$_} ))
     {
-        my $decl_args = get_func_args( $ext_functions{$_}, 1, 0 );
+        my $decl_args = get_func_args( $ext_functions{$_}, 1, 0, "" );
         my $func_ret = get_func_ret( $ext_functions{$_}, 0 );
         $wrappers .= "extern $func_ret WINAPI $_($decl_args) DECLSPEC_HIDDEN;\n";
     }
@@ -841,3 +910,113 @@ foreach (sort keys %ext_functions) {
 print EXT "};\n";

close(EXT);
+
+
+#
+# Generate the unixlib.h file
+#
+open OUT, ">unixlib.h" or die "cannot create unixlib.h";
+print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
+print OUT "#ifndef __WINE_OPENGL32_UNIXLIB_H\n";
+print OUT "#define __WINE_OPENGL32_UNIXLIB_H\n\n";
+
+print OUT "#include <stdarg.h>\n";
+print OUT "#include <stddef.h>\n\n";
+
+print OUT "#include "ntstatus.h"\n";
+print OUT "#define WIN32_NO_STATUS\n";
+print OUT "#include "windef.h"\n";
+print OUT "#include "winbase.h"\n";
+print OUT "#include "winternl.h"\n";
+print OUT "#include "wingdi.h"\n\n";
+print OUT "#include "wine/wgl.h"\n";
+print OUT "#include "wine/unixlib.h"\n\n";
+
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
+    print OUT generate_func_params($_, $norm_functions{$_});
+}
+
+print OUT "enum unix_funcs\n";
+print OUT "{\n";
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
+    printf OUT "    unix_%s,\n", $_;
+}
+print OUT "};\n\n";
+
+print OUT "typedef NTSTATUS (*unixlib_function_t)( void *args );\n";
+print OUT "extern const unixlib_function_t __wine_unix_call_funcs[] DECLSPEC_HIDDEN;\n";
+print OUT "#define UNIX_CALL( func, params ) __wine_unix_call_funcs[unix_ ## func]( params )\n";
+
+print OUT "\n#endif /* __WINE_OPENGL32_UNIXLIB_H */\n";
+close OUT;
+
+#
+# Generate the thunks.c file
+#
+open OUT, ">thunks.c" or die "cannot create thunks.c";
+print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
+
+print OUT "#include <stdarg.h>\n";
+print OUT "#include <stddef.h>\n\n";
+
+print OUT "#include "ntstatus.h"\n";
+print OUT "#define WIN32_NO_STATUS\n";
+print OUT "#include "windef.h"\n";
+print OUT "#include "winbase.h"\n";
+print OUT "#include "wingdi.h"\n\n";
+
+print OUT "#include "unixlib.h"\n\n";
+print OUT "#include "wine/debug.h"\n\n";
+print OUT "WINE_DEFAULT_DEBUG_CHANNEL(opengl);\n";
+
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
+    print OUT "\n" . generate_win_thunk($_, $norm_functions{$_});
+}
+
+close OUT;
+
+#
+# Generate the unix_thunks.c file
+#
+open OUT, ">unix_thunks.c" or die "cannot create unix_thunks.c";
+print OUT "/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */\n\n";
+
+print OUT "#include <stdarg.h>\n";
+print OUT "#include <stddef.h>\n\n";
+
+print OUT "#include "ntstatus.h"\n";
+print OUT "#define WIN32_NO_STATUS\n";
+print OUT "#include "windef.h"\n";
+print OUT "#include "winbase.h"\n";
+print OUT "#include "wingdi.h"\n\n";
+
+print OUT "#include "unixlib.h"\n\n";
+print OUT "#include "opengl_ext.h"\n\n";
+
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
+    print OUT generate_unix_thunk($_, $norm_functions{$_}, "gl");
+}
+
+print OUT "const unixlib_function_t __wine_unix_call_funcs[] =\n";
+print OUT "{\n";
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
+    printf OUT "    &gl_%s,\n", $_;
+}
+print OUT "};\n";
+
+close OUT;
diff --git a/dlls/opengl32/opengl_norm.c b/dlls/opengl32/opengl_norm.c
index 8b1b9c77287..3d77a47c8c7 100644
--- a/dlls/opengl32/opengl_norm.c
+++ b/dlls/opengl32/opengl_norm.c
@@ -6,2346 +6,6 @@
 #include "opengl_ext.h"
 #include "wine/debug.h"

-WINE_DEFAULT_DEBUG_CHANNEL(opengl);
-
-void WINAPI glAccum( GLenum op, GLfloat value )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", op, value );
-  funcs->gl.p_glAccum( op, value );
-}
-
-void WINAPI glAlphaFunc( GLenum func, GLfloat ref )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", func, ref );
-  funcs->gl.p_glAlphaFunc( func, ref );
-}
-
-GLboolean WINAPI glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p, %p)\n", n, textures, residences );
-  return funcs->gl.p_glAreTexturesResident( n, textures, residences );
-}
-
-void WINAPI glArrayElement( GLint i )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", i );
-  funcs->gl.p_glArrayElement( i );
-}
-
-void WINAPI glBegin( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  funcs->gl.p_glBegin( mode );
-}
-
-void WINAPI glBindTexture( GLenum target, GLuint texture )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", target, texture );
-  funcs->gl.p_glBindTexture( target, texture );
-}
-
-void WINAPI glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
-  funcs->gl.p_glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
-}
-
-void WINAPI glBlendFunc( GLenum sfactor, GLenum dfactor )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", sfactor, dfactor );
-  funcs->gl.p_glBlendFunc( sfactor, dfactor );
-}
-
-void WINAPI glCallList( GLuint list )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", list );
-  funcs->gl.p_glCallList( list );
-}
-
-void WINAPI glCallLists( GLsizei n, GLenum type, const void *lists )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", n, type, lists );
-  funcs->gl.p_glCallLists( n, type, lists );
-}
-
-void WINAPI glClear( GLbitfield mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mask );
-  funcs->gl.p_glClear( mask );
-}
-
-void WINAPI glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
-  funcs->gl.p_glClearAccum( red, green, blue, alpha );
-}
-
-void WINAPI glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
-  funcs->gl.p_glClearColor( red, green, blue, alpha );
-}
-
-void WINAPI glClearDepth( GLdouble depth )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", depth );
-  funcs->gl.p_glClearDepth( depth );
-}
-
-void WINAPI glClearIndex( GLfloat c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", c );
-  funcs->gl.p_glClearIndex( c );
-}
-
-void WINAPI glClearStencil( GLint s )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", s );
-  funcs->gl.p_glClearStencil( s );
-}
-
-void WINAPI glClipPlane( GLenum plane, const GLdouble *equation )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", plane, equation );
-  funcs->gl.p_glClipPlane( plane, equation );
-}
-
-void WINAPI glColor3b( GLbyte red, GLbyte green, GLbyte blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3b( red, green, blue );
-}
-
-void WINAPI glColor3bv( const GLbyte *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3bv( v );
-}
-
-void WINAPI glColor3d( GLdouble red, GLdouble green, GLdouble blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", red, green, blue );
-  funcs->gl.p_glColor3d( red, green, blue );
-}
-
-void WINAPI glColor3dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3dv( v );
-}
-
-void WINAPI glColor3f( GLfloat red, GLfloat green, GLfloat blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", red, green, blue );
-  funcs->gl.p_glColor3f( red, green, blue );
-}
-
-void WINAPI glColor3fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3fv( v );
-}
-
-void WINAPI glColor3i( GLint red, GLint green, GLint blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3i( red, green, blue );
-}
-
-void WINAPI glColor3iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3iv( v );
-}
-
-void WINAPI glColor3s( GLshort red, GLshort green, GLshort blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3s( red, green, blue );
-}
-
-void WINAPI glColor3sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3sv( v );
-}
-
-void WINAPI glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3ub( red, green, blue );
-}
-
-void WINAPI glColor3ubv( const GLubyte *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3ubv( v );
-}
-
-void WINAPI glColor3ui( GLuint red, GLuint green, GLuint blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3ui( red, green, blue );
-}
-
-void WINAPI glColor3uiv( const GLuint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3uiv( v );
-}
-
-void WINAPI glColor3us( GLushort red, GLushort green, GLushort blue )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", red, green, blue );
-  funcs->gl.p_glColor3us( red, green, blue );
-}
-
-void WINAPI glColor3usv( const GLushort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor3usv( v );
-}
-
-void WINAPI glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4b( red, green, blue, alpha );
-}
-
-void WINAPI glColor4bv( const GLbyte *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4bv( v );
-}
-
-void WINAPI glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4d( red, green, blue, alpha );
-}
-
-void WINAPI glColor4dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4dv( v );
-}
-
-void WINAPI glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4f( red, green, blue, alpha );
-}
-
-void WINAPI glColor4fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4fv( v );
-}
-
-void WINAPI glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4i( red, green, blue, alpha );
-}
-
-void WINAPI glColor4iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4iv( v );
-}
-
-void WINAPI glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4s( red, green, blue, alpha );
-}
-
-void WINAPI glColor4sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4sv( v );
-}
-
-void WINAPI glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4ub( red, green, blue, alpha );
-}
-
-void WINAPI glColor4ubv( const GLubyte *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4ubv( v );
-}
-
-void WINAPI glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4ui( red, green, blue, alpha );
-}
-
-void WINAPI glColor4uiv( const GLuint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4uiv( v );
-}
-
-void WINAPI glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColor4us( red, green, blue, alpha );
-}
-
-void WINAPI glColor4usv( const GLushort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glColor4usv( v );
-}
-
-void WINAPI glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
-  funcs->gl.p_glColorMask( red, green, blue, alpha );
-}
-
-void WINAPI glColorMaterial( GLenum face, GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", face, mode );
-  funcs->gl.p_glColorMaterial( face, mode );
-}
-
-void WINAPI glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
-  funcs->gl.p_glColorPointer( size, type, stride, pointer );
-}
-
-void WINAPI glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d)\n", x, y, width, height, type );
-  funcs->gl.p_glCopyPixels( x, y, width, height, type );
-}
-
-void WINAPI glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
-  funcs->gl.p_glCopyTexImage1D( target, level, internalformat, x, y, width, border );
-}
-
-void WINAPI glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
-  funcs->gl.p_glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
-}
-
-void WINAPI glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
-  funcs->gl.p_glCopyTexSubImage1D( target, level, xoffset, x, y, width );
-}
-
-void WINAPI glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
-  funcs->gl.p_glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
-}
-
-void WINAPI glCullFace( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  funcs->gl.p_glCullFace( mode );
-}
-
-void WINAPI glDeleteLists( GLuint list, GLsizei range )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", list, range );
-  funcs->gl.p_glDeleteLists( list, range );
-}
-
-void WINAPI glDeleteTextures( GLsizei n, const GLuint *textures )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", n, textures );
-  funcs->gl.p_glDeleteTextures( n, textures );
-}
-
-void WINAPI glDepthFunc( GLenum func )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", func );
-  funcs->gl.p_glDepthFunc( func );
-}
-
-void WINAPI glDepthMask( GLboolean flag )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", flag );
-  funcs->gl.p_glDepthMask( flag );
-}
-
-void WINAPI glDepthRange( GLdouble n, GLdouble f )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", n, f );
-  funcs->gl.p_glDepthRange( n, f );
-}
-
-void WINAPI glDisable( GLenum cap )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", cap );
-  funcs->gl.p_glDisable( cap );
-}
-
-void WINAPI glDisableClientState( GLenum array )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", array );
-  funcs->gl.p_glDisableClientState( array );
-}
-
-void WINAPI glDrawArrays( GLenum mode, GLint first, GLsizei count )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", mode, first, count );
-  funcs->gl.p_glDrawArrays( mode, first, count );
-}
-
-void WINAPI glDrawBuffer( GLenum buf )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", buf );
-  funcs->gl.p_glDrawBuffer( buf );
-}
-
-void WINAPI glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", mode, count, type, indices );
-  funcs->gl.p_glDrawElements( mode, count, type, indices );
-}
-
-void WINAPI glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %p)\n", width, height, format, type, pixels );
-  funcs->gl.p_glDrawPixels( width, height, format, type, pixels );
-}
-
-void WINAPI glEdgeFlag( GLboolean flag )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", flag );
-  funcs->gl.p_glEdgeFlag( flag );
-}
-
-void WINAPI glEdgeFlagPointer( GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", stride, pointer );
-  funcs->gl.p_glEdgeFlagPointer( stride, pointer );
-}
-
-void WINAPI glEdgeFlagv( const GLboolean *flag )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", flag );
-  funcs->gl.p_glEdgeFlagv( flag );
-}
-
-void WINAPI glEnable( GLenum cap )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", cap );
-  funcs->gl.p_glEnable( cap );
-}
-
-void WINAPI glEnableClientState( GLenum array )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", array );
-  funcs->gl.p_glEnableClientState( array );
-}
-
-void WINAPI glEnd(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glEnd();
-}
-
-void WINAPI glEndList(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glEndList();
-}
-
-void WINAPI glEvalCoord1d( GLdouble u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", u );
-  funcs->gl.p_glEvalCoord1d( u );
-}
-
-void WINAPI glEvalCoord1dv( const GLdouble *u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", u );
-  funcs->gl.p_glEvalCoord1dv( u );
-}
-
-void WINAPI glEvalCoord1f( GLfloat u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", u );
-  funcs->gl.p_glEvalCoord1f( u );
-}
-
-void WINAPI glEvalCoord1fv( const GLfloat *u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", u );
-  funcs->gl.p_glEvalCoord1fv( u );
-}
-
-void WINAPI glEvalCoord2d( GLdouble u, GLdouble v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", u, v );
-  funcs->gl.p_glEvalCoord2d( u, v );
-}
-
-void WINAPI glEvalCoord2dv( const GLdouble *u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", u );
-  funcs->gl.p_glEvalCoord2dv( u );
-}
-
-void WINAPI glEvalCoord2f( GLfloat u, GLfloat v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", u, v );
-  funcs->gl.p_glEvalCoord2f( u, v );
-}
-
-void WINAPI glEvalCoord2fv( const GLfloat *u )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", u );
-  funcs->gl.p_glEvalCoord2fv( u );
-}
-
-void WINAPI glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", mode, i1, i2 );
-  funcs->gl.p_glEvalMesh1( mode, i1, i2 );
-}
-
-void WINAPI glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2 );
-  funcs->gl.p_glEvalMesh2( mode, i1, i2, j1, j2 );
-}
-
-void WINAPI glEvalPoint1( GLint i )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", i );
-  funcs->gl.p_glEvalPoint1( i );
-}
-
-void WINAPI glEvalPoint2( GLint i, GLint j )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", i, j );
-  funcs->gl.p_glEvalPoint2( i, j );
-}
-
-void WINAPI glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", size, type, buffer );
-  funcs->gl.p_glFeedbackBuffer( size, type, buffer );
-}
-
-void WINAPI glFinish(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glFinish();
-}
-
-void WINAPI glFlush(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glFlush();
-}
-
-void WINAPI glFogf( GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", pname, param );
-  funcs->gl.p_glFogf( pname, param );
-}
-
-void WINAPI glFogfv( GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, params );
-  funcs->gl.p_glFogfv( pname, params );
-}
-
-void WINAPI glFogi( GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", pname, param );
-  funcs->gl.p_glFogi( pname, param );
-}
-
-void WINAPI glFogiv( GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, params );
-  funcs->gl.p_glFogiv( pname, params );
-}
-
-void WINAPI glFrontFace( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  funcs->gl.p_glFrontFace( mode );
-}
-
-void WINAPI glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
-  funcs->gl.p_glFrustum( left, right, bottom, top, zNear, zFar );
-}
-
-GLuint WINAPI glGenLists( GLsizei range )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", range );
-  return funcs->gl.p_glGenLists( range );
-}
-
-void WINAPI glGenTextures( GLsizei n, GLuint *textures )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", n, textures );
-  funcs->gl.p_glGenTextures( n, textures );
-}
-
-void WINAPI glGetBooleanv( GLenum pname, GLboolean *data )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, data );
-  funcs->gl.p_glGetBooleanv( pname, data );
-}
-
-void WINAPI glGetClipPlane( GLenum plane, GLdouble *equation )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", plane, equation );
-  funcs->gl.p_glGetClipPlane( plane, equation );
-}
-
-void WINAPI glGetDoublev( GLenum pname, GLdouble *data )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, data );
-  funcs->gl.p_glGetDoublev( pname, data );
-}
-
-GLenum WINAPI glGetError(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  return funcs->gl.p_glGetError();
-}
-
-void WINAPI glGetFloatv( GLenum pname, GLfloat *data )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, data );
-  funcs->gl.p_glGetFloatv( pname, data );
-}
-
-void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", light, pname, params );
-  funcs->gl.p_glGetLightfv( light, pname, params );
-}
-
-void WINAPI glGetLightiv( GLenum light, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", light, pname, params );
-  funcs->gl.p_glGetLightiv( light, pname, params );
-}
-
-void WINAPI glGetMapdv( GLenum target, GLenum query, GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, query, v );
-  funcs->gl.p_glGetMapdv( target, query, v );
-}
-
-void WINAPI glGetMapfv( GLenum target, GLenum query, GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, query, v );
-  funcs->gl.p_glGetMapfv( target, query, v );
-}
-
-void WINAPI glGetMapiv( GLenum target, GLenum query, GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, query, v );
-  funcs->gl.p_glGetMapiv( target, query, v );
-}
-
-void WINAPI glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", face, pname, params );
-  funcs->gl.p_glGetMaterialfv( face, pname, params );
-}
-
-void WINAPI glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", face, pname, params );
-  funcs->gl.p_glGetMaterialiv( face, pname, params );
-}
-
-void WINAPI glGetPixelMapfv( GLenum map, GLfloat *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", map, values );
-  funcs->gl.p_glGetPixelMapfv( map, values );
-}
-
-void WINAPI glGetPixelMapuiv( GLenum map, GLuint *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", map, values );
-  funcs->gl.p_glGetPixelMapuiv( map, values );
-}
-
-void WINAPI glGetPixelMapusv( GLenum map, GLushort *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", map, values );
-  funcs->gl.p_glGetPixelMapusv( map, values );
-}
-
-void WINAPI glGetPointerv( GLenum pname, void **params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, params );
-  funcs->gl.p_glGetPointerv( pname, params );
-}
-
-void WINAPI glGetPolygonStipple( GLubyte *mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", mask );
-  funcs->gl.p_glGetPolygonStipple( mask );
-}
-
-void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glGetTexEnvfv( target, pname, params );
-}
-
-void WINAPI glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glGetTexEnviv( target, pname, params );
-}
-
-void WINAPI glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glGetTexGendv( coord, pname, params );
-}
-
-void WINAPI glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glGetTexGenfv( coord, pname, params );
-}
-
-void WINAPI glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glGetTexGeniv( coord, pname, params );
-}
-
-void WINAPI glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %p)\n", target, level, format, type, pixels );
-  funcs->gl.p_glGetTexImage( target, level, format, type, pixels );
-}
-
-void WINAPI glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", target, level, pname, params );
-  funcs->gl.p_glGetTexLevelParameterfv( target, level, pname, params );
-}
-
-void WINAPI glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", target, level, pname, params );
-  funcs->gl.p_glGetTexLevelParameteriv( target, level, pname, params );
-}
-
-void WINAPI glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glGetTexParameterfv( target, pname, params );
-}
-
-void WINAPI glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glGetTexParameteriv( target, pname, params );
-}
-
-void WINAPI glHint( GLenum target, GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", target, mode );
-  funcs->gl.p_glHint( target, mode );
-}
-
-void WINAPI glIndexMask( GLuint mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mask );
-  funcs->gl.p_glIndexMask( mask );
-}
-
-void WINAPI glIndexPointer( GLenum type, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
-  funcs->gl.p_glIndexPointer( type, stride, pointer );
-}
-
-void WINAPI glIndexd( GLdouble c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", c );
-  funcs->gl.p_glIndexd( c );
-}
-
-void WINAPI glIndexdv( const GLdouble *c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", c );
-  funcs->gl.p_glIndexdv( c );
-}
-
-void WINAPI glIndexf( GLfloat c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", c );
-  funcs->gl.p_glIndexf( c );
-}
-
-void WINAPI glIndexfv( const GLfloat *c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", c );
-  funcs->gl.p_glIndexfv( c );
-}
-
-void WINAPI glIndexi( GLint c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", c );
-  funcs->gl.p_glIndexi( c );
-}
-
-void WINAPI glIndexiv( const GLint *c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", c );
-  funcs->gl.p_glIndexiv( c );
-}
-
-void WINAPI glIndexs( GLshort c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", c );
-  funcs->gl.p_glIndexs( c );
-}
-
-void WINAPI glIndexsv( const GLshort *c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", c );
-  funcs->gl.p_glIndexsv( c );
-}
-
-void WINAPI glIndexub( GLubyte c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", c );
-  funcs->gl.p_glIndexub( c );
-}
-
-void WINAPI glIndexubv( const GLubyte *c )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", c );
-  funcs->gl.p_glIndexubv( c );
-}
-
-void WINAPI glInitNames(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glInitNames();
-}
-
-void WINAPI glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", format, stride, pointer );
-  funcs->gl.p_glInterleavedArrays( format, stride, pointer );
-}
-
-GLboolean WINAPI glIsEnabled( GLenum cap )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", cap );
-  return funcs->gl.p_glIsEnabled( cap );
-}
-
-GLboolean WINAPI glIsList( GLuint list )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", list );
-  return funcs->gl.p_glIsList( list );
-}
-
-GLboolean WINAPI glIsTexture( GLuint texture )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", texture );
-  return funcs->gl.p_glIsTexture( texture );
-}
-
-void WINAPI glLightModelf( GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", pname, param );
-  funcs->gl.p_glLightModelf( pname, param );
-}
-
-void WINAPI glLightModelfv( GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, params );
-  funcs->gl.p_glLightModelfv( pname, params );
-}
-
-void WINAPI glLightModeli( GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", pname, param );
-  funcs->gl.p_glLightModeli( pname, param );
-}
-
-void WINAPI glLightModeliv( GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", pname, params );
-  funcs->gl.p_glLightModeliv( pname, params );
-}
-
-void WINAPI glLightf( GLenum light, GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", light, pname, param );
-  funcs->gl.p_glLightf( light, pname, param );
-}
-
-void WINAPI glLightfv( GLenum light, GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", light, pname, params );
-  funcs->gl.p_glLightfv( light, pname, params );
-}
-
-void WINAPI glLighti( GLenum light, GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", light, pname, param );
-  funcs->gl.p_glLighti( light, pname, param );
-}
-
-void WINAPI glLightiv( GLenum light, GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", light, pname, params );
-  funcs->gl.p_glLightiv( light, pname, params );
-}
-
-void WINAPI glLineStipple( GLint factor, GLushort pattern )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", factor, pattern );
-  funcs->gl.p_glLineStipple( factor, pattern );
-}
-
-void WINAPI glLineWidth( GLfloat width )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", width );
-  funcs->gl.p_glLineWidth( width );
-}
-
-void WINAPI glListBase( GLuint base )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", base );
-  funcs->gl.p_glListBase( base );
-}
-
-void WINAPI glLoadIdentity(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glLoadIdentity();
-}
-
-void WINAPI glLoadMatrixd( const GLdouble *m )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", m );
-  funcs->gl.p_glLoadMatrixd( m );
-}
-
-void WINAPI glLoadMatrixf( const GLfloat *m )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", m );
-  funcs->gl.p_glLoadMatrixf( m );
-}
-
-void WINAPI glLoadName( GLuint name )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", name );
-  funcs->gl.p_glLoadName( name );
-}
-
-void WINAPI glLogicOp( GLenum opcode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", opcode );
-  funcs->gl.p_glLogicOp( opcode );
-}
-
-void WINAPI glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
-  funcs->gl.p_glMap1d( target, u1, u2, stride, order, points );
-}
-
-void WINAPI glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
-  funcs->gl.p_glMap1f( target, u1, u2, stride, order, points );
-}
-
-void WINAPI glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
-  funcs->gl.p_glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
-}
-
-void WINAPI glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
-  funcs->gl.p_glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
-}
-
-void WINAPI glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f)\n", un, u1, u2 );
-  funcs->gl.p_glMapGrid1d( un, u1, u2 );
-}
-
-void WINAPI glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f)\n", un, u1, u2 );
-  funcs->gl.p_glMapGrid1f( un, u1, u2 );
-}
-
-void WINAPI glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
-  funcs->gl.p_glMapGrid2d( un, u1, u2, vn, v1, v2 );
-}
-
-void WINAPI glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
-  funcs->gl.p_glMapGrid2f( un, u1, u2, vn, v1, v2 );
-}
-
-void WINAPI glMaterialf( GLenum face, GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", face, pname, param );
-  funcs->gl.p_glMaterialf( face, pname, param );
-}
-
-void WINAPI glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", face, pname, params );
-  funcs->gl.p_glMaterialfv( face, pname, params );
-}
-
-void WINAPI glMateriali( GLenum face, GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", face, pname, param );
-  funcs->gl.p_glMateriali( face, pname, param );
-}
-
-void WINAPI glMaterialiv( GLenum face, GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", face, pname, params );
-  funcs->gl.p_glMaterialiv( face, pname, params );
-}
-
-void WINAPI glMatrixMode( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  funcs->gl.p_glMatrixMode( mode );
-}
-
-void WINAPI glMultMatrixd( const GLdouble *m )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", m );
-  funcs->gl.p_glMultMatrixd( m );
-}
-
-void WINAPI glMultMatrixf( const GLfloat *m )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", m );
-  funcs->gl.p_glMultMatrixf( m );
-}
-
-void WINAPI glNewList( GLuint list, GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", list, mode );
-  funcs->gl.p_glNewList( list, mode );
-}
-
-void WINAPI glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
-  funcs->gl.p_glNormal3b( nx, ny, nz );
-}
-
-void WINAPI glNormal3bv( const GLbyte *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glNormal3bv( v );
-}
-
-void WINAPI glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", nx, ny, nz );
-  funcs->gl.p_glNormal3d( nx, ny, nz );
-}
-
-void WINAPI glNormal3dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glNormal3dv( v );
-}
-
-void WINAPI glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", nx, ny, nz );
-  funcs->gl.p_glNormal3f( nx, ny, nz );
-}
-
-void WINAPI glNormal3fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glNormal3fv( v );
-}
-
-void WINAPI glNormal3i( GLint nx, GLint ny, GLint nz )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
-  funcs->gl.p_glNormal3i( nx, ny, nz );
-}
-
-void WINAPI glNormal3iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glNormal3iv( v );
-}
-
-void WINAPI glNormal3s( GLshort nx, GLshort ny, GLshort nz )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
-  funcs->gl.p_glNormal3s( nx, ny, nz );
-}
-
-void WINAPI glNormal3sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glNormal3sv( v );
-}
-
-void WINAPI glNormalPointer( GLenum type, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
-  funcs->gl.p_glNormalPointer( type, stride, pointer );
-}
-
-void WINAPI glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
-  funcs->gl.p_glOrtho( left, right, bottom, top, zNear, zFar );
-}
-
-void WINAPI glPassThrough( GLfloat token )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", token );
-  funcs->gl.p_glPassThrough( token );
-}
-
-void WINAPI glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
-  funcs->gl.p_glPixelMapfv( map, mapsize, values );
-}
-
-void WINAPI glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
-  funcs->gl.p_glPixelMapuiv( map, mapsize, values );
-}
-
-void WINAPI glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
-  funcs->gl.p_glPixelMapusv( map, mapsize, values );
-}
-
-void WINAPI glPixelStoref( GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", pname, param );
-  funcs->gl.p_glPixelStoref( pname, param );
-}
-
-void WINAPI glPixelStorei( GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", pname, param );
-  funcs->gl.p_glPixelStorei( pname, param );
-}
-
-void WINAPI glPixelTransferf( GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %f)\n", pname, param );
-  funcs->gl.p_glPixelTransferf( pname, param );
-}
-
-void WINAPI glPixelTransferi( GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", pname, param );
-  funcs->gl.p_glPixelTransferi( pname, param );
-}
-
-void WINAPI glPixelZoom( GLfloat xfactor, GLfloat yfactor )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", xfactor, yfactor );
-  funcs->gl.p_glPixelZoom( xfactor, yfactor );
-}
-
-void WINAPI glPointSize( GLfloat size )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", size );
-  funcs->gl.p_glPointSize( size );
-}
-
-void WINAPI glPolygonMode( GLenum face, GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", face, mode );
-  funcs->gl.p_glPolygonMode( face, mode );
-}
-
-void WINAPI glPolygonOffset( GLfloat factor, GLfloat units )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", factor, units );
-  funcs->gl.p_glPolygonOffset( factor, units );
-}
-
-void WINAPI glPolygonStipple( const GLubyte *mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", mask );
-  funcs->gl.p_glPolygonStipple( mask );
-}
-
-void WINAPI glPopAttrib(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glPopAttrib();
-}
-
-void WINAPI glPopClientAttrib(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glPopClientAttrib();
-}
-
-void WINAPI glPopMatrix(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glPopMatrix();
-}
-
-void WINAPI glPopName(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glPopName();
-}
-
-void WINAPI glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p, %p)\n", n, textures, priorities );
-  funcs->gl.p_glPrioritizeTextures( n, textures, priorities );
-}
-
-void WINAPI glPushAttrib( GLbitfield mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mask );
-  funcs->gl.p_glPushAttrib( mask );
-}
-
-void WINAPI glPushClientAttrib( GLbitfield mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mask );
-  funcs->gl.p_glPushClientAttrib( mask );
-}
-
-void WINAPI glPushMatrix(void)
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "()\n" );
-  funcs->gl.p_glPushMatrix();
-}
-
-void WINAPI glPushName( GLuint name )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", name );
-  funcs->gl.p_glPushName( name );
-}
-
-void WINAPI glRasterPos2d( GLdouble x, GLdouble y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", x, y );
-  funcs->gl.p_glRasterPos2d( x, y );
-}
-
-void WINAPI glRasterPos2dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos2dv( v );
-}
-
-void WINAPI glRasterPos2f( GLfloat x, GLfloat y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", x, y );
-  funcs->gl.p_glRasterPos2f( x, y );
-}
-
-void WINAPI glRasterPos2fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos2fv( v );
-}
-
-void WINAPI glRasterPos2i( GLint x, GLint y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", x, y );
-  funcs->gl.p_glRasterPos2i( x, y );
-}
-
-void WINAPI glRasterPos2iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos2iv( v );
-}
-
-void WINAPI glRasterPos2s( GLshort x, GLshort y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", x, y );
-  funcs->gl.p_glRasterPos2s( x, y );
-}
-
-void WINAPI glRasterPos2sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos2sv( v );
-}
-
-void WINAPI glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glRasterPos3d( x, y, z );
-}
-
-void WINAPI glRasterPos3dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos3dv( v );
-}
-
-void WINAPI glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glRasterPos3f( x, y, z );
-}
-
-void WINAPI glRasterPos3fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos3fv( v );
-}
-
-void WINAPI glRasterPos3i( GLint x, GLint y, GLint z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", x, y, z );
-  funcs->gl.p_glRasterPos3i( x, y, z );
-}
-
-void WINAPI glRasterPos3iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos3iv( v );
-}
-
-void WINAPI glRasterPos3s( GLshort x, GLshort y, GLshort z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", x, y, z );
-  funcs->gl.p_glRasterPos3s( x, y, z );
-}
-
-void WINAPI glRasterPos3sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos3sv( v );
-}
-
-void WINAPI glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
-  funcs->gl.p_glRasterPos4d( x, y, z, w );
-}
-
-void WINAPI glRasterPos4dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos4dv( v );
-}
-
-void WINAPI glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
-  funcs->gl.p_glRasterPos4f( x, y, z, w );
-}
-
-void WINAPI glRasterPos4fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos4fv( v );
-}
-
-void WINAPI glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
-  funcs->gl.p_glRasterPos4i( x, y, z, w );
-}
-
-void WINAPI glRasterPos4iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos4iv( v );
-}
-
-void WINAPI glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
-  funcs->gl.p_glRasterPos4s( x, y, z, w );
-}
-
-void WINAPI glRasterPos4sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glRasterPos4sv( v );
-}
-
-void WINAPI glReadBuffer( GLenum src )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", src );
-  funcs->gl.p_glReadBuffer( src );
-}
-
-void WINAPI glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, pixels );
-  funcs->gl.p_glReadPixels( x, y, width, height, format, type, pixels );
-}
-
-void WINAPI glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
-  funcs->gl.p_glRectd( x1, y1, x2, y2 );
-}
-
-void WINAPI glRectdv( const GLdouble *v1, const GLdouble *v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p, %p)\n", v1, v2 );
-  funcs->gl.p_glRectdv( v1, v2 );
-}
-
-void WINAPI glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
-  funcs->gl.p_glRectf( x1, y1, x2, y2 );
-}
-
-void WINAPI glRectfv( const GLfloat *v1, const GLfloat *v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p, %p)\n", v1, v2 );
-  funcs->gl.p_glRectfv( v1, v2 );
-}
-
-void WINAPI glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
-  funcs->gl.p_glRecti( x1, y1, x2, y2 );
-}
-
-void WINAPI glRectiv( const GLint *v1, const GLint *v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p, %p)\n", v1, v2 );
-  funcs->gl.p_glRectiv( v1, v2 );
-}
-
-void WINAPI glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
-  funcs->gl.p_glRects( x1, y1, x2, y2 );
-}
-
-void WINAPI glRectsv( const GLshort *v1, const GLshort *v2 )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p, %p)\n", v1, v2 );
-  funcs->gl.p_glRectsv( v1, v2 );
-}
-
-GLint WINAPI glRenderMode( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  return funcs->gl.p_glRenderMode( mode );
-}
-
-void WINAPI glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", angle, x, y, z );
-  funcs->gl.p_glRotated( angle, x, y, z );
-}
-
-void WINAPI glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", angle, x, y, z );
-  funcs->gl.p_glRotatef( angle, x, y, z );
-}
-
-void WINAPI glScaled( GLdouble x, GLdouble y, GLdouble z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glScaled( x, y, z );
-}
-
-void WINAPI glScalef( GLfloat x, GLfloat y, GLfloat z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glScalef( x, y, z );
-}
-
-void WINAPI glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, width, height );
-  funcs->gl.p_glScissor( x, y, width, height );
-}
-
-void WINAPI glSelectBuffer( GLsizei size, GLuint *buffer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %p)\n", size, buffer );
-  funcs->gl.p_glSelectBuffer( size, buffer );
-}
-
-void WINAPI glShadeModel( GLenum mode )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mode );
-  funcs->gl.p_glShadeModel( mode );
-}
-
-void WINAPI glStencilFunc( GLenum func, GLint ref, GLuint mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", func, ref, mask );
-  funcs->gl.p_glStencilFunc( func, ref, mask );
-}
-
-void WINAPI glStencilMask( GLuint mask )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", mask );
-  funcs->gl.p_glStencilMask( mask );
-}
-
-void WINAPI glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", fail, zfail, zpass );
-  funcs->gl.p_glStencilOp( fail, zfail, zpass );
-}
-
-void WINAPI glTexCoord1d( GLdouble s )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", s );
-  funcs->gl.p_glTexCoord1d( s );
-}
-
-void WINAPI glTexCoord1dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord1dv( v );
-}
-
-void WINAPI glTexCoord1f( GLfloat s )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f)\n", s );
-  funcs->gl.p_glTexCoord1f( s );
-}
-
-void WINAPI glTexCoord1fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord1fv( v );
-}
-
-void WINAPI glTexCoord1i( GLint s )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", s );
-  funcs->gl.p_glTexCoord1i( s );
-}
-
-void WINAPI glTexCoord1iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord1iv( v );
-}
-
-void WINAPI glTexCoord1s( GLshort s )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d)\n", s );
-  funcs->gl.p_glTexCoord1s( s );
-}
-
-void WINAPI glTexCoord1sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord1sv( v );
-}
-
-void WINAPI glTexCoord2d( GLdouble s, GLdouble t )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", s, t );
-  funcs->gl.p_glTexCoord2d( s, t );
-}
-
-void WINAPI glTexCoord2dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord2dv( v );
-}
-
-void WINAPI glTexCoord2f( GLfloat s, GLfloat t )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", s, t );
-  funcs->gl.p_glTexCoord2f( s, t );
-}
-
-void WINAPI glTexCoord2fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord2fv( v );
-}
-
-void WINAPI glTexCoord2i( GLint s, GLint t )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", s, t );
-  funcs->gl.p_glTexCoord2i( s, t );
-}
-
-void WINAPI glTexCoord2iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord2iv( v );
-}
-
-void WINAPI glTexCoord2s( GLshort s, GLshort t )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", s, t );
-  funcs->gl.p_glTexCoord2s( s, t );
-}
-
-void WINAPI glTexCoord2sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord2sv( v );
-}
-
-void WINAPI glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", s, t, r );
-  funcs->gl.p_glTexCoord3d( s, t, r );
-}
-
-void WINAPI glTexCoord3dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord3dv( v );
-}
-
-void WINAPI glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", s, t, r );
-  funcs->gl.p_glTexCoord3f( s, t, r );
-}
-
-void WINAPI glTexCoord3fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord3fv( v );
-}
-
-void WINAPI glTexCoord3i( GLint s, GLint t, GLint r )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", s, t, r );
-  funcs->gl.p_glTexCoord3i( s, t, r );
-}
-
-void WINAPI glTexCoord3iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord3iv( v );
-}
-
-void WINAPI glTexCoord3s( GLshort s, GLshort t, GLshort r )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", s, t, r );
-  funcs->gl.p_glTexCoord3s( s, t, r );
-}
-
-void WINAPI glTexCoord3sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord3sv( v );
-}
-
-void WINAPI glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", s, t, r, q );
-  funcs->gl.p_glTexCoord4d( s, t, r, q );
-}
-
-void WINAPI glTexCoord4dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord4dv( v );
-}
-
-void WINAPI glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", s, t, r, q );
-  funcs->gl.p_glTexCoord4f( s, t, r, q );
-}
-
-void WINAPI glTexCoord4fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord4fv( v );
-}
-
-void WINAPI glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
-  funcs->gl.p_glTexCoord4i( s, t, r, q );
-}
-
-void WINAPI glTexCoord4iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord4iv( v );
-}
-
-void WINAPI glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
-  funcs->gl.p_glTexCoord4s( s, t, r, q );
-}
-
-void WINAPI glTexCoord4sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glTexCoord4sv( v );
-}
-
-void WINAPI glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
-  funcs->gl.p_glTexCoordPointer( size, type, stride, pointer );
-}
-
-void WINAPI glTexEnvf( GLenum target, GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", target, pname, param );
-  funcs->gl.p_glTexEnvf( target, pname, param );
-}
-
-void WINAPI glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glTexEnvfv( target, pname, params );
-}
-
-void WINAPI glTexEnvi( GLenum target, GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", target, pname, param );
-  funcs->gl.p_glTexEnvi( target, pname, param );
-}
-
-void WINAPI glTexEnviv( GLenum target, GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glTexEnviv( target, pname, params );
-}
-
-void WINAPI glTexGend( GLenum coord, GLenum pname, GLdouble param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", coord, pname, param );
-  funcs->gl.p_glTexGend( coord, pname, param );
-}
-
-void WINAPI glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glTexGendv( coord, pname, params );
-}
-
-void WINAPI glTexGenf( GLenum coord, GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", coord, pname, param );
-  funcs->gl.p_glTexGenf( coord, pname, param );
-}
-
-void WINAPI glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glTexGenfv( coord, pname, params );
-}
-
-void WINAPI glTexGeni( GLenum coord, GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", coord, pname, param );
-  funcs->gl.p_glTexGeni( coord, pname, param );
-}
-
-void WINAPI glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", coord, pname, params );
-  funcs->gl.p_glTexGeniv( coord, pname, params );
-}
-
-void WINAPI glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, format, type, pixels );
-  funcs->gl.p_glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
-}
-
-void WINAPI glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, format, type, pixels );
-  funcs->gl.p_glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
-}
-
-void WINAPI glTexParameterf( GLenum target, GLenum pname, GLfloat param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %f)\n", target, pname, param );
-  funcs->gl.p_glTexParameterf( target, pname, param );
-}
-
-void WINAPI glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glTexParameterfv( target, pname, params );
-}
-
-void WINAPI glTexParameteri( GLenum target, GLenum pname, GLint param )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", target, pname, param );
-  funcs->gl.p_glTexParameteri( target, pname, param );
-}
-
-void WINAPI glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %p)\n", target, pname, params );
-  funcs->gl.p_glTexParameteriv( target, pname, params );
-}
-
-void WINAPI glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
-  funcs->gl.p_glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
-}
-
-void WINAPI glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
-  funcs->gl.p_glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
-}
-
-void WINAPI glTranslated( GLdouble x, GLdouble y, GLdouble z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glTranslated( x, y, z );
-}
-
-void WINAPI glTranslatef( GLfloat x, GLfloat y, GLfloat z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glTranslatef( x, y, z );
-}
-
-void WINAPI glVertex2d( GLdouble x, GLdouble y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", x, y );
-  funcs->gl.p_glVertex2d( x, y );
-}
-
-void WINAPI glVertex2dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex2dv( v );
-}
-
-void WINAPI glVertex2f( GLfloat x, GLfloat y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f)\n", x, y );
-  funcs->gl.p_glVertex2f( x, y );
-}
-
-void WINAPI glVertex2fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex2fv( v );
-}
-
-void WINAPI glVertex2i( GLint x, GLint y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", x, y );
-  funcs->gl.p_glVertex2i( x, y );
-}
-
-void WINAPI glVertex2iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex2iv( v );
-}
-
-void WINAPI glVertex2s( GLshort x, GLshort y )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d)\n", x, y );
-  funcs->gl.p_glVertex2s( x, y );
-}
-
-void WINAPI glVertex2sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex2sv( v );
-}
-
-void WINAPI glVertex3d( GLdouble x, GLdouble y, GLdouble z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glVertex3d( x, y, z );
-}
-
-void WINAPI glVertex3dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex3dv( v );
-}
-
-void WINAPI glVertex3f( GLfloat x, GLfloat y, GLfloat z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f)\n", x, y, z );
-  funcs->gl.p_glVertex3f( x, y, z );
-}
-
-void WINAPI glVertex3fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex3fv( v );
-}
-
-void WINAPI glVertex3i( GLint x, GLint y, GLint z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", x, y, z );
-  funcs->gl.p_glVertex3i( x, y, z );
-}
-
-void WINAPI glVertex3iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex3iv( v );
-}
-
-void WINAPI glVertex3s( GLshort x, GLshort y, GLshort z )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d)\n", x, y, z );
-  funcs->gl.p_glVertex3s( x, y, z );
-}
-
-void WINAPI glVertex3sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex3sv( v );
-}
-
-void WINAPI glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
-  funcs->gl.p_glVertex4d( x, y, z, w );
-}
-
-void WINAPI glVertex4dv( const GLdouble *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex4dv( v );
-}
-
-void WINAPI glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
-  funcs->gl.p_glVertex4f( x, y, z, w );
-}
-
-void WINAPI glVertex4fv( const GLfloat *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex4fv( v );
-}
-
-void WINAPI glVertex4i( GLint x, GLint y, GLint z, GLint w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
-  funcs->gl.p_glVertex4i( x, y, z, w );
-}
-
-void WINAPI glVertex4iv( const GLint *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex4iv( v );
-}
-
-void WINAPI glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
-  funcs->gl.p_glVertex4s( x, y, z, w );
-}
-
-void WINAPI glVertex4sv( const GLshort *v )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%p)\n", v );
-  funcs->gl.p_glVertex4sv( v );
-}
-
-void WINAPI glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
-  funcs->gl.p_glVertexPointer( size, type, stride, pointer );
-}
-
-void WINAPI glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
-{
-  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE( "(%d, %d, %d, %d)\n", x, y, width, height );
-  funcs->gl.p_glViewport( x, y, width, height );
-}
-
 static BOOL WINAPI null_wglCopyContext( struct wgl_context * hglrcSrc, struct wgl_context * hglrcDst, UINT mask ) { return 0; }
 static struct wgl_context * WINAPI null_wglCreateContext( HDC hDc ) { return 0; }
 static BOOL WINAPI null_wglDeleteContext( struct wgl_context * oldContext ) { return 0; }
diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c
new file mode 100644
index 00000000000..d488d592f86
--- /dev/null
+++ b/dlls/opengl32/thunks.c
@@ -0,0 +1,2695 @@
+/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+
+#include "unixlib.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(opengl);
+
+void WINAPI glAccum( GLenum op, GLfloat value )
+{
+    struct glAccum_params args = { .op = op, .value = value, };
+    NTSTATUS status;
+    TRACE( "op %d, value %f\n", op, value );
+    if ((status = UNIX_CALL( glAccum, &args ))) WARN( "glAccum returned %#x\n", status );
+}
+
+void WINAPI glAlphaFunc( GLenum func, GLfloat ref )
+{
+    struct glAlphaFunc_params args = { .func = func, .ref = ref, };
+    NTSTATUS status;
+    TRACE( "func %d, ref %f\n", func, ref );
+    if ((status = UNIX_CALL( glAlphaFunc, &args ))) WARN( "glAlphaFunc returned %#x\n", status );
+}
+
+GLboolean WINAPI glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
+{
+    struct glAreTexturesResident_params args = { .n = n, .textures = textures, .residences = residences, };
+    NTSTATUS status;
+    TRACE( "n %d, textures %p, residences %p\n", n, textures, residences );
+    if ((status = UNIX_CALL( glAreTexturesResident, &args ))) WARN( "glAreTexturesResident returned %#x\n", status );
+    return args.ret;
+}
+
+void WINAPI glArrayElement( GLint i )
+{
+    struct glArrayElement_params args = { .i = i, };
+    NTSTATUS status;
+    TRACE( "i %d\n", i );
+    if ((status = UNIX_CALL( glArrayElement, &args ))) WARN( "glArrayElement returned %#x\n", status );
+}
+
+void WINAPI glBegin( GLenum mode )
+{
+    struct glBegin_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glBegin, &args ))) WARN( "glBegin returned %#x\n", status );
+}
+
+void WINAPI glBindTexture( GLenum target, GLuint texture )
+{
+    struct glBindTexture_params args = { .target = target, .texture = texture, };
+    NTSTATUS status;
+    TRACE( "target %d, texture %d\n", target, texture );
+    if ((status = UNIX_CALL( glBindTexture, &args ))) WARN( "glBindTexture returned %#x\n", status );
+}
+
+void WINAPI glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
+{
+    struct glBitmap_params args = { .width = width, .height = height, .xorig = xorig, .yorig = yorig, .xmove = xmove, .ymove = ymove, .bitmap = bitmap, };
+    NTSTATUS status;
+    TRACE( "width %d, height %d, xorig %f, yorig %f, xmove %f, ymove %f, bitmap %p\n", width, height, xorig, yorig, xmove, ymove, bitmap );
+    if ((status = UNIX_CALL( glBitmap, &args ))) WARN( "glBitmap returned %#x\n", status );
+}
+
+void WINAPI glBlendFunc( GLenum sfactor, GLenum dfactor )
+{
+    struct glBlendFunc_params args = { .sfactor = sfactor, .dfactor = dfactor, };
+    NTSTATUS status;
+    TRACE( "sfactor %d, dfactor %d\n", sfactor, dfactor );
+    if ((status = UNIX_CALL( glBlendFunc, &args ))) WARN( "glBlendFunc returned %#x\n", status );
+}
+
+void WINAPI glCallList( GLuint list )
+{
+    struct glCallList_params args = { .list = list, };
+    NTSTATUS status;
+    TRACE( "list %d\n", list );
+    if ((status = UNIX_CALL( glCallList, &args ))) WARN( "glCallList returned %#x\n", status );
+}
+
+void WINAPI glCallLists( GLsizei n, GLenum type, const void *lists )
+{
+    struct glCallLists_params args = { .n = n, .type = type, .lists = lists, };
+    NTSTATUS status;
+    TRACE( "n %d, type %d, lists %p\n", n, type, lists );
+    if ((status = UNIX_CALL( glCallLists, &args ))) WARN( "glCallLists returned %#x\n", status );
+}
+
+void WINAPI glClear( GLbitfield mask )
+{
+    struct glClear_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %d\n", mask );
+    if ((status = UNIX_CALL( glClear, &args ))) WARN( "glClear returned %#x\n", status );
+}
+
+void WINAPI glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+    struct glClearAccum_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glClearAccum, &args ))) WARN( "glClearAccum returned %#x\n", status );
+}
+
+void WINAPI glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+    struct glClearColor_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glClearColor, &args ))) WARN( "glClearColor returned %#x\n", status );
+}
+
+void WINAPI glClearDepth( GLdouble depth )
+{
+    struct glClearDepth_params args = { .depth = depth, };
+    NTSTATUS status;
+    TRACE( "depth %f\n", depth );
+    if ((status = UNIX_CALL( glClearDepth, &args ))) WARN( "glClearDepth returned %#x\n", status );
+}
+
+void WINAPI glClearIndex( GLfloat c )
+{
+    struct glClearIndex_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %f\n", c );
+    if ((status = UNIX_CALL( glClearIndex, &args ))) WARN( "glClearIndex returned %#x\n", status );
+}
+
+void WINAPI glClearStencil( GLint s )
+{
+    struct glClearStencil_params args = { .s = s, };
+    NTSTATUS status;
+    TRACE( "s %d\n", s );
+    if ((status = UNIX_CALL( glClearStencil, &args ))) WARN( "glClearStencil returned %#x\n", status );
+}
+
+void WINAPI glClipPlane( GLenum plane, const GLdouble *equation )
+{
+    struct glClipPlane_params args = { .plane = plane, .equation = equation, };
+    NTSTATUS status;
+    TRACE( "plane %d, equation %p\n", plane, equation );
+    if ((status = UNIX_CALL( glClipPlane, &args ))) WARN( "glClipPlane returned %#x\n", status );
+}
+
+void WINAPI glColor3b( GLbyte red, GLbyte green, GLbyte blue )
+{
+    struct glColor3b_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3b, &args ))) WARN( "glColor3b returned %#x\n", status );
+}
+
+void WINAPI glColor3bv( const GLbyte *v )
+{
+    struct glColor3bv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3bv, &args ))) WARN( "glColor3bv returned %#x\n", status );
+}
+
+void WINAPI glColor3d( GLdouble red, GLdouble green, GLdouble blue )
+{
+    struct glColor3d_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3d, &args ))) WARN( "glColor3d returned %#x\n", status );
+}
+
+void WINAPI glColor3dv( const GLdouble *v )
+{
+    struct glColor3dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3dv, &args ))) WARN( "glColor3dv returned %#x\n", status );
+}
+
+void WINAPI glColor3f( GLfloat red, GLfloat green, GLfloat blue )
+{
+    struct glColor3f_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3f, &args ))) WARN( "glColor3f returned %#x\n", status );
+}
+
+void WINAPI glColor3fv( const GLfloat *v )
+{
+    struct glColor3fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3fv, &args ))) WARN( "glColor3fv returned %#x\n", status );
+}
+
+void WINAPI glColor3i( GLint red, GLint green, GLint blue )
+{
+    struct glColor3i_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3i, &args ))) WARN( "glColor3i returned %#x\n", status );
+}
+
+void WINAPI glColor3iv( const GLint *v )
+{
+    struct glColor3iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3iv, &args ))) WARN( "glColor3iv returned %#x\n", status );
+}
+
+void WINAPI glColor3s( GLshort red, GLshort green, GLshort blue )
+{
+    struct glColor3s_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3s, &args ))) WARN( "glColor3s returned %#x\n", status );
+}
+
+void WINAPI glColor3sv( const GLshort *v )
+{
+    struct glColor3sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3sv, &args ))) WARN( "glColor3sv returned %#x\n", status );
+}
+
+void WINAPI glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
+{
+    struct glColor3ub_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3ub, &args ))) WARN( "glColor3ub returned %#x\n", status );
+}
+
+void WINAPI glColor3ubv( const GLubyte *v )
+{
+    struct glColor3ubv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3ubv, &args ))) WARN( "glColor3ubv returned %#x\n", status );
+}
+
+void WINAPI glColor3ui( GLuint red, GLuint green, GLuint blue )
+{
+    struct glColor3ui_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3ui, &args ))) WARN( "glColor3ui returned %#x\n", status );
+}
+
+void WINAPI glColor3uiv( const GLuint *v )
+{
+    struct glColor3uiv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3uiv, &args ))) WARN( "glColor3uiv returned %#x\n", status );
+}
+
+void WINAPI glColor3us( GLushort red, GLushort green, GLushort blue )
+{
+    struct glColor3us_params args = { .red = red, .green = green, .blue = blue, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d\n", red, green, blue );
+    if ((status = UNIX_CALL( glColor3us, &args ))) WARN( "glColor3us returned %#x\n", status );
+}
+
+void WINAPI glColor3usv( const GLushort *v )
+{
+    struct glColor3usv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor3usv, &args ))) WARN( "glColor3usv returned %#x\n", status );
+}
+
+void WINAPI glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
+{
+    struct glColor4b_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4b, &args ))) WARN( "glColor4b returned %#x\n", status );
+}
+
+void WINAPI glColor4bv( const GLbyte *v )
+{
+    struct glColor4bv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4bv, &args ))) WARN( "glColor4bv returned %#x\n", status );
+}
+
+void WINAPI glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
+{
+    struct glColor4d_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4d, &args ))) WARN( "glColor4d returned %#x\n", status );
+}
+
+void WINAPI glColor4dv( const GLdouble *v )
+{
+    struct glColor4dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4dv, &args ))) WARN( "glColor4dv returned %#x\n", status );
+}
+
+void WINAPI glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
+    struct glColor4f_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %f, green %f, blue %f, alpha %f\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4f, &args ))) WARN( "glColor4f returned %#x\n", status );
+}
+
+void WINAPI glColor4fv( const GLfloat *v )
+{
+    struct glColor4fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4fv, &args ))) WARN( "glColor4fv returned %#x\n", status );
+}
+
+void WINAPI glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
+{
+    struct glColor4i_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4i, &args ))) WARN( "glColor4i returned %#x\n", status );
+}
+
+void WINAPI glColor4iv( const GLint *v )
+{
+    struct glColor4iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4iv, &args ))) WARN( "glColor4iv returned %#x\n", status );
+}
+
+void WINAPI glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
+{
+    struct glColor4s_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4s, &args ))) WARN( "glColor4s returned %#x\n", status );
+}
+
+void WINAPI glColor4sv( const GLshort *v )
+{
+    struct glColor4sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4sv, &args ))) WARN( "glColor4sv returned %#x\n", status );
+}
+
+void WINAPI glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
+{
+    struct glColor4ub_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4ub, &args ))) WARN( "glColor4ub returned %#x\n", status );
+}
+
+void WINAPI glColor4ubv( const GLubyte *v )
+{
+    struct glColor4ubv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4ubv, &args ))) WARN( "glColor4ubv returned %#x\n", status );
+}
+
+void WINAPI glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
+    struct glColor4ui_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4ui, &args ))) WARN( "glColor4ui returned %#x\n", status );
+}
+
+void WINAPI glColor4uiv( const GLuint *v )
+{
+    struct glColor4uiv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4uiv, &args ))) WARN( "glColor4uiv returned %#x\n", status );
+}
+
+void WINAPI glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
+{
+    struct glColor4us_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColor4us, &args ))) WARN( "glColor4us returned %#x\n", status );
+}
+
+void WINAPI glColor4usv( const GLushort *v )
+{
+    struct glColor4usv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glColor4usv, &args ))) WARN( "glColor4usv returned %#x\n", status );
+}
+
+void WINAPI glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+{
+    struct glColorMask_params args = { .red = red, .green = green, .blue = blue, .alpha = alpha, };
+    NTSTATUS status;
+    TRACE( "red %d, green %d, blue %d, alpha %d\n", red, green, blue, alpha );
+    if ((status = UNIX_CALL( glColorMask, &args ))) WARN( "glColorMask returned %#x\n", status );
+}
+
+void WINAPI glColorMaterial( GLenum face, GLenum mode )
+{
+    struct glColorMaterial_params args = { .face = face, .mode = mode, };
+    NTSTATUS status;
+    TRACE( "face %d, mode %d\n", face, mode );
+    if ((status = UNIX_CALL( glColorMaterial, &args ))) WARN( "glColorMaterial returned %#x\n", status );
+}
+
+void WINAPI glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
+    struct glColorPointer_params args = { .size = size, .type = type, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
+    if ((status = UNIX_CALL( glColorPointer, &args ))) WARN( "glColorPointer returned %#x\n", status );
+}
+
+void WINAPI glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
+{
+    struct glCopyPixels_params args = { .x = x, .y = y, .width = width, .height = height, .type = type, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, width %d, height %d, type %d\n", x, y, width, height, type );
+    if ((status = UNIX_CALL( glCopyPixels, &args ))) WARN( "glCopyPixels returned %#x\n", status );
+}
+
+void WINAPI glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
+{
+    struct glCopyTexImage1D_params args = { .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .border = border, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, border %d\n", target, level, internalformat, x, y, width, border );
+    if ((status = UNIX_CALL( glCopyTexImage1D, &args ))) WARN( "glCopyTexImage1D returned %#x\n", status );
+}
+
+void WINAPI glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+{
+    struct glCopyTexImage2D_params args = { .target = target, .level = level, .internalformat = internalformat, .x = x, .y = y, .width = width, .height = height, .border = border, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, internalformat %d, x %d, y %d, width %d, height %d, border %d\n", target, level, internalformat, x, y, width, height, border );
+    if ((status = UNIX_CALL( glCopyTexImage2D, &args ))) WARN( "glCopyTexImage2D returned %#x\n", status );
+}
+
+void WINAPI glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
+    struct glCopyTexSubImage1D_params args = { .target = target, .level = level, .xoffset = xoffset, .x = x, .y = y, .width = width, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, xoffset %d, x %d, y %d, width %d\n", target, level, xoffset, x, y, width );
+    if ((status = UNIX_CALL( glCopyTexSubImage1D, &args ))) WARN( "glCopyTexSubImage1D returned %#x\n", status );
+}
+
+void WINAPI glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
+    struct glCopyTexSubImage2D_params args = { .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .x = x, .y = y, .width = width, .height = height, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, xoffset %d, yoffset %d, x %d, y %d, width %d, height %d\n", target, level, xoffset, yoffset, x, y, width, height );
+    if ((status = UNIX_CALL( glCopyTexSubImage2D, &args ))) WARN( "glCopyTexSubImage2D returned %#x\n", status );
+}
+
+void WINAPI glCullFace( GLenum mode )
+{
+    struct glCullFace_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glCullFace, &args ))) WARN( "glCullFace returned %#x\n", status );
+}
+
+void WINAPI glDeleteLists( GLuint list, GLsizei range )
+{
+    struct glDeleteLists_params args = { .list = list, .range = range, };
+    NTSTATUS status;
+    TRACE( "list %d, range %d\n", list, range );
+    if ((status = UNIX_CALL( glDeleteLists, &args ))) WARN( "glDeleteLists returned %#x\n", status );
+}
+
+void WINAPI glDeleteTextures( GLsizei n, const GLuint *textures )
+{
+    struct glDeleteTextures_params args = { .n = n, .textures = textures, };
+    NTSTATUS status;
+    TRACE( "n %d, textures %p\n", n, textures );
+    if ((status = UNIX_CALL( glDeleteTextures, &args ))) WARN( "glDeleteTextures returned %#x\n", status );
+}
+
+void WINAPI glDepthFunc( GLenum func )
+{
+    struct glDepthFunc_params args = { .func = func, };
+    NTSTATUS status;
+    TRACE( "func %d\n", func );
+    if ((status = UNIX_CALL( glDepthFunc, &args ))) WARN( "glDepthFunc returned %#x\n", status );
+}
+
+void WINAPI glDepthMask( GLboolean flag )
+{
+    struct glDepthMask_params args = { .flag = flag, };
+    NTSTATUS status;
+    TRACE( "flag %d\n", flag );
+    if ((status = UNIX_CALL( glDepthMask, &args ))) WARN( "glDepthMask returned %#x\n", status );
+}
+
+void WINAPI glDepthRange( GLdouble n, GLdouble f )
+{
+    struct glDepthRange_params args = { .n = n, .f = f, };
+    NTSTATUS status;
+    TRACE( "n %f, f %f\n", n, f );
+    if ((status = UNIX_CALL( glDepthRange, &args ))) WARN( "glDepthRange returned %#x\n", status );
+}
+
+void WINAPI glDisable( GLenum cap )
+{
+    struct glDisable_params args = { .cap = cap, };
+    NTSTATUS status;
+    TRACE( "cap %d\n", cap );
+    if ((status = UNIX_CALL( glDisable, &args ))) WARN( "glDisable returned %#x\n", status );
+}
+
+void WINAPI glDisableClientState( GLenum array )
+{
+    struct glDisableClientState_params args = { .array = array, };
+    NTSTATUS status;
+    TRACE( "array %d\n", array );
+    if ((status = UNIX_CALL( glDisableClientState, &args ))) WARN( "glDisableClientState returned %#x\n", status );
+}
+
+void WINAPI glDrawArrays( GLenum mode, GLint first, GLsizei count )
+{
+    struct glDrawArrays_params args = { .mode = mode, .first = first, .count = count, };
+    NTSTATUS status;
+    TRACE( "mode %d, first %d, count %d\n", mode, first, count );
+    if ((status = UNIX_CALL( glDrawArrays, &args ))) WARN( "glDrawArrays returned %#x\n", status );
+}
+
+void WINAPI glDrawBuffer( GLenum buf )
+{
+    struct glDrawBuffer_params args = { .buf = buf, };
+    NTSTATUS status;
+    TRACE( "buf %d\n", buf );
+    if ((status = UNIX_CALL( glDrawBuffer, &args ))) WARN( "glDrawBuffer returned %#x\n", status );
+}
+
+void WINAPI glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices )
+{
+    struct glDrawElements_params args = { .mode = mode, .count = count, .type = type, .indices = indices, };
+    NTSTATUS status;
+    TRACE( "mode %d, count %d, type %d, indices %p\n", mode, count, type, indices );
+    if ((status = UNIX_CALL( glDrawElements, &args ))) WARN( "glDrawElements returned %#x\n", status );
+}
+
+void WINAPI glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
+    struct glDrawPixels_params args = { .width = width, .height = height, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "width %d, height %d, format %d, type %d, pixels %p\n", width, height, format, type, pixels );
+    if ((status = UNIX_CALL( glDrawPixels, &args ))) WARN( "glDrawPixels returned %#x\n", status );
+}
+
+void WINAPI glEdgeFlag( GLboolean flag )
+{
+    struct glEdgeFlag_params args = { .flag = flag, };
+    NTSTATUS status;
+    TRACE( "flag %d\n", flag );
+    if ((status = UNIX_CALL( glEdgeFlag, &args ))) WARN( "glEdgeFlag returned %#x\n", status );
+}
+
+void WINAPI glEdgeFlagPointer( GLsizei stride, const void *pointer )
+{
+    struct glEdgeFlagPointer_params args = { .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "stride %d, pointer %p\n", stride, pointer );
+    if ((status = UNIX_CALL( glEdgeFlagPointer, &args ))) WARN( "glEdgeFlagPointer returned %#x\n", status );
+}
+
+void WINAPI glEdgeFlagv( const GLboolean *flag )
+{
+    struct glEdgeFlagv_params args = { .flag = flag, };
+    NTSTATUS status;
+    TRACE( "flag %p\n", flag );
+    if ((status = UNIX_CALL( glEdgeFlagv, &args ))) WARN( "glEdgeFlagv returned %#x\n", status );
+}
+
+void WINAPI glEnable( GLenum cap )
+{
+    struct glEnable_params args = { .cap = cap, };
+    NTSTATUS status;
+    TRACE( "cap %d\n", cap );
+    if ((status = UNIX_CALL( glEnable, &args ))) WARN( "glEnable returned %#x\n", status );
+}
+
+void WINAPI glEnableClientState( GLenum array )
+{
+    struct glEnableClientState_params args = { .array = array, };
+    NTSTATUS status;
+    TRACE( "array %d\n", array );
+    if ((status = UNIX_CALL( glEnableClientState, &args ))) WARN( "glEnableClientState returned %#x\n", status );
+}
+
+void WINAPI glEnd(void)
+{
+    struct glEnd_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glEnd, &args ))) WARN( "glEnd returned %#x\n", status );
+}
+
+void WINAPI glEndList(void)
+{
+    struct glEndList_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glEndList, &args ))) WARN( "glEndList returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord1d( GLdouble u )
+{
+    struct glEvalCoord1d_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %f\n", u );
+    if ((status = UNIX_CALL( glEvalCoord1d, &args ))) WARN( "glEvalCoord1d returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord1dv( const GLdouble *u )
+{
+    struct glEvalCoord1dv_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %p\n", u );
+    if ((status = UNIX_CALL( glEvalCoord1dv, &args ))) WARN( "glEvalCoord1dv returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord1f( GLfloat u )
+{
+    struct glEvalCoord1f_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %f\n", u );
+    if ((status = UNIX_CALL( glEvalCoord1f, &args ))) WARN( "glEvalCoord1f returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord1fv( const GLfloat *u )
+{
+    struct glEvalCoord1fv_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %p\n", u );
+    if ((status = UNIX_CALL( glEvalCoord1fv, &args ))) WARN( "glEvalCoord1fv returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord2d( GLdouble u, GLdouble v )
+{
+    struct glEvalCoord2d_params args = { .u = u, .v = v, };
+    NTSTATUS status;
+    TRACE( "u %f, v %f\n", u, v );
+    if ((status = UNIX_CALL( glEvalCoord2d, &args ))) WARN( "glEvalCoord2d returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord2dv( const GLdouble *u )
+{
+    struct glEvalCoord2dv_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %p\n", u );
+    if ((status = UNIX_CALL( glEvalCoord2dv, &args ))) WARN( "glEvalCoord2dv returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord2f( GLfloat u, GLfloat v )
+{
+    struct glEvalCoord2f_params args = { .u = u, .v = v, };
+    NTSTATUS status;
+    TRACE( "u %f, v %f\n", u, v );
+    if ((status = UNIX_CALL( glEvalCoord2f, &args ))) WARN( "glEvalCoord2f returned %#x\n", status );
+}
+
+void WINAPI glEvalCoord2fv( const GLfloat *u )
+{
+    struct glEvalCoord2fv_params args = { .u = u, };
+    NTSTATUS status;
+    TRACE( "u %p\n", u );
+    if ((status = UNIX_CALL( glEvalCoord2fv, &args ))) WARN( "glEvalCoord2fv returned %#x\n", status );
+}
+
+void WINAPI glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
+{
+    struct glEvalMesh1_params args = { .mode = mode, .i1 = i1, .i2 = i2, };
+    NTSTATUS status;
+    TRACE( "mode %d, i1 %d, i2 %d\n", mode, i1, i2 );
+    if ((status = UNIX_CALL( glEvalMesh1, &args ))) WARN( "glEvalMesh1 returned %#x\n", status );
+}
+
+void WINAPI glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
+{
+    struct glEvalMesh2_params args = { .mode = mode, .i1 = i1, .i2 = i2, .j1 = j1, .j2 = j2, };
+    NTSTATUS status;
+    TRACE( "mode %d, i1 %d, i2 %d, j1 %d, j2 %d\n", mode, i1, i2, j1, j2 );
+    if ((status = UNIX_CALL( glEvalMesh2, &args ))) WARN( "glEvalMesh2 returned %#x\n", status );
+}
+
+void WINAPI glEvalPoint1( GLint i )
+{
+    struct glEvalPoint1_params args = { .i = i, };
+    NTSTATUS status;
+    TRACE( "i %d\n", i );
+    if ((status = UNIX_CALL( glEvalPoint1, &args ))) WARN( "glEvalPoint1 returned %#x\n", status );
+}
+
+void WINAPI glEvalPoint2( GLint i, GLint j )
+{
+    struct glEvalPoint2_params args = { .i = i, .j = j, };
+    NTSTATUS status;
+    TRACE( "i %d, j %d\n", i, j );
+    if ((status = UNIX_CALL( glEvalPoint2, &args ))) WARN( "glEvalPoint2 returned %#x\n", status );
+}
+
+void WINAPI glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
+{
+    struct glFeedbackBuffer_params args = { .size = size, .type = type, .buffer = buffer, };
+    NTSTATUS status;
+    TRACE( "size %d, type %d, buffer %p\n", size, type, buffer );
+    if ((status = UNIX_CALL( glFeedbackBuffer, &args ))) WARN( "glFeedbackBuffer returned %#x\n", status );
+}
+
+void WINAPI glFinish(void)
+{
+    struct glFinish_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glFinish, &args ))) WARN( "glFinish returned %#x\n", status );
+}
+
+void WINAPI glFlush(void)
+{
+    struct glFlush_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glFlush, &args ))) WARN( "glFlush returned %#x\n", status );
+}
+
+void WINAPI glFogf( GLenum pname, GLfloat param )
+{
+    struct glFogf_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %f\n", pname, param );
+    if ((status = UNIX_CALL( glFogf, &args ))) WARN( "glFogf returned %#x\n", status );
+}
+
+void WINAPI glFogfv( GLenum pname, const GLfloat *params )
+{
+    struct glFogfv_params args = { .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "pname %d, params %p\n", pname, params );
+    if ((status = UNIX_CALL( glFogfv, &args ))) WARN( "glFogfv returned %#x\n", status );
+}
+
+void WINAPI glFogi( GLenum pname, GLint param )
+{
+    struct glFogi_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %d\n", pname, param );
+    if ((status = UNIX_CALL( glFogi, &args ))) WARN( "glFogi returned %#x\n", status );
+}
+
+void WINAPI glFogiv( GLenum pname, const GLint *params )
+{
+    struct glFogiv_params args = { .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "pname %d, params %p\n", pname, params );
+    if ((status = UNIX_CALL( glFogiv, &args ))) WARN( "glFogiv returned %#x\n", status );
+}
+
+void WINAPI glFrontFace( GLenum mode )
+{
+    struct glFrontFace_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glFrontFace, &args ))) WARN( "glFrontFace returned %#x\n", status );
+}
+
+void WINAPI glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
+    struct glFrustum_params args = { .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar, };
+    NTSTATUS status;
+    TRACE( "left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", left, right, bottom, top, zNear, zFar );
+    if ((status = UNIX_CALL( glFrustum, &args ))) WARN( "glFrustum returned %#x\n", status );
+}
+
+GLuint WINAPI glGenLists( GLsizei range )
+{
+    struct glGenLists_params args = { .range = range, };
+    NTSTATUS status;
+    TRACE( "range %d\n", range );
+    if ((status = UNIX_CALL( glGenLists, &args ))) WARN( "glGenLists returned %#x\n", status );
+    return args.ret;
+}
+
+void WINAPI glGenTextures( GLsizei n, GLuint *textures )
+{
+    struct glGenTextures_params args = { .n = n, .textures = textures, };
+    NTSTATUS status;
+    TRACE( "n %d, textures %p\n", n, textures );
+    if ((status = UNIX_CALL( glGenTextures, &args ))) WARN( "glGenTextures returned %#x\n", status );
+}
+
+void WINAPI glGetBooleanv( GLenum pname, GLboolean *data )
+{
+    struct glGetBooleanv_params args = { .pname = pname, .data = data, };
+    NTSTATUS status;
+    TRACE( "pname %d, data %p\n", pname, data );
+    if ((status = UNIX_CALL( glGetBooleanv, &args ))) WARN( "glGetBooleanv returned %#x\n", status );
+}
+
+void WINAPI glGetClipPlane( GLenum plane, GLdouble *equation )
+{
+    struct glGetClipPlane_params args = { .plane = plane, .equation = equation, };
+    NTSTATUS status;
+    TRACE( "plane %d, equation %p\n", plane, equation );
+    if ((status = UNIX_CALL( glGetClipPlane, &args ))) WARN( "glGetClipPlane returned %#x\n", status );
+}
+
+void WINAPI glGetDoublev( GLenum pname, GLdouble *data )
+{
+    struct glGetDoublev_params args = { .pname = pname, .data = data, };
+    NTSTATUS status;
+    TRACE( "pname %d, data %p\n", pname, data );
+    if ((status = UNIX_CALL( glGetDoublev, &args ))) WARN( "glGetDoublev returned %#x\n", status );
+}
+
+GLenum WINAPI glGetError(void)
+{
+    struct glGetError_params args = {0};
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glGetError, &args ))) WARN( "glGetError returned %#x\n", status );
+    return args.ret;
+}
+
+void WINAPI glGetFloatv( GLenum pname, GLfloat *data )
+{
+    struct glGetFloatv_params args = { .pname = pname, .data = data, };
+    NTSTATUS status;
+    TRACE( "pname %d, data %p\n", pname, data );
+    if ((status = UNIX_CALL( glGetFloatv, &args ))) WARN( "glGetFloatv returned %#x\n", status );
+}
+
+void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
+{
+    struct glGetLightfv_params args = { .light = light, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
+    if ((status = UNIX_CALL( glGetLightfv, &args ))) WARN( "glGetLightfv returned %#x\n", status );
+}
+
+void WINAPI glGetLightiv( GLenum light, GLenum pname, GLint *params )
+{
+    struct glGetLightiv_params args = { .light = light, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
+    if ((status = UNIX_CALL( glGetLightiv, &args ))) WARN( "glGetLightiv returned %#x\n", status );
+}
+
+void WINAPI glGetMapdv( GLenum target, GLenum query, GLdouble *v )
+{
+    struct glGetMapdv_params args = { .target = target, .query = query, .v = v, };
+    NTSTATUS status;
+    TRACE( "target %d, query %d, v %p\n", target, query, v );
+    if ((status = UNIX_CALL( glGetMapdv, &args ))) WARN( "glGetMapdv returned %#x\n", status );
+}
+
+void WINAPI glGetMapfv( GLenum target, GLenum query, GLfloat *v )
+{
+    struct glGetMapfv_params args = { .target = target, .query = query, .v = v, };
+    NTSTATUS status;
+    TRACE( "target %d, query %d, v %p\n", target, query, v );
+    if ((status = UNIX_CALL( glGetMapfv, &args ))) WARN( "glGetMapfv returned %#x\n", status );
+}
+
+void WINAPI glGetMapiv( GLenum target, GLenum query, GLint *v )
+{
+    struct glGetMapiv_params args = { .target = target, .query = query, .v = v, };
+    NTSTATUS status;
+    TRACE( "target %d, query %d, v %p\n", target, query, v );
+    if ((status = UNIX_CALL( glGetMapiv, &args ))) WARN( "glGetMapiv returned %#x\n", status );
+}
+
+void WINAPI glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
+{
+    struct glGetMaterialfv_params args = { .face = face, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
+    if ((status = UNIX_CALL( glGetMaterialfv, &args ))) WARN( "glGetMaterialfv returned %#x\n", status );
+}
+
+void WINAPI glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
+{
+    struct glGetMaterialiv_params args = { .face = face, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
+    if ((status = UNIX_CALL( glGetMaterialiv, &args ))) WARN( "glGetMaterialiv returned %#x\n", status );
+}
+
+void WINAPI glGetPixelMapfv( GLenum map, GLfloat *values )
+{
+    struct glGetPixelMapfv_params args = { .map = map, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, values %p\n", map, values );
+    if ((status = UNIX_CALL( glGetPixelMapfv, &args ))) WARN( "glGetPixelMapfv returned %#x\n", status );
+}
+
+void WINAPI glGetPixelMapuiv( GLenum map, GLuint *values )
+{
+    struct glGetPixelMapuiv_params args = { .map = map, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, values %p\n", map, values );
+    if ((status = UNIX_CALL( glGetPixelMapuiv, &args ))) WARN( "glGetPixelMapuiv returned %#x\n", status );
+}
+
+void WINAPI glGetPixelMapusv( GLenum map, GLushort *values )
+{
+    struct glGetPixelMapusv_params args = { .map = map, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, values %p\n", map, values );
+    if ((status = UNIX_CALL( glGetPixelMapusv, &args ))) WARN( "glGetPixelMapusv returned %#x\n", status );
+}
+
+void WINAPI glGetPointerv( GLenum pname, void **params )
+{
+    struct glGetPointerv_params args = { .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "pname %d, params %p\n", pname, params );
+    if ((status = UNIX_CALL( glGetPointerv, &args ))) WARN( "glGetPointerv returned %#x\n", status );
+}
+
+void WINAPI glGetPolygonStipple( GLubyte *mask )
+{
+    struct glGetPolygonStipple_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %p\n", mask );
+    if ((status = UNIX_CALL( glGetPolygonStipple, &args ))) WARN( "glGetPolygonStipple returned %#x\n", status );
+}
+
+void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
+{
+    struct glGetTexEnvfv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glGetTexEnvfv, &args ))) WARN( "glGetTexEnvfv returned %#x\n", status );
+}
+
+void WINAPI glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
+{
+    struct glGetTexEnviv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glGetTexEnviv, &args ))) WARN( "glGetTexEnviv returned %#x\n", status );
+}
+
+void WINAPI glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
+{
+    struct glGetTexGendv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glGetTexGendv, &args ))) WARN( "glGetTexGendv returned %#x\n", status );
+}
+
+void WINAPI glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
+{
+    struct glGetTexGenfv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glGetTexGenfv, &args ))) WARN( "glGetTexGenfv returned %#x\n", status );
+}
+
+void WINAPI glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
+{
+    struct glGetTexGeniv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glGetTexGeniv, &args ))) WARN( "glGetTexGeniv returned %#x\n", status );
+}
+
+void WINAPI glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
+{
+    struct glGetTexImage_params args = { .target = target, .level = level, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, format %d, type %d, pixels %p\n", target, level, format, type, pixels );
+    if ((status = UNIX_CALL( glGetTexImage, &args ))) WARN( "glGetTexImage returned %#x\n", status );
+}
+
+void WINAPI glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
+    struct glGetTexLevelParameterfv_params args = { .target = target, .level = level, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, pname %d, params %p\n", target, level, pname, params );
+    if ((status = UNIX_CALL( glGetTexLevelParameterfv, &args ))) WARN( "glGetTexLevelParameterfv returned %#x\n", status );
+}
+
+void WINAPI glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
+{
+    struct glGetTexLevelParameteriv_params args = { .target = target, .level = level, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, pname %d, params %p\n", target, level, pname, params );
+    if ((status = UNIX_CALL( glGetTexLevelParameteriv, &args ))) WARN( "glGetTexLevelParameteriv returned %#x\n", status );
+}
+
+void WINAPI glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
+    struct glGetTexParameterfv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glGetTexParameterfv, &args ))) WARN( "glGetTexParameterfv returned %#x\n", status );
+}
+
+void WINAPI glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
+{
+    struct glGetTexParameteriv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glGetTexParameteriv, &args ))) WARN( "glGetTexParameteriv returned %#x\n", status );
+}
+
+void WINAPI glHint( GLenum target, GLenum mode )
+{
+    struct glHint_params args = { .target = target, .mode = mode, };
+    NTSTATUS status;
+    TRACE( "target %d, mode %d\n", target, mode );
+    if ((status = UNIX_CALL( glHint, &args ))) WARN( "glHint returned %#x\n", status );
+}
+
+void WINAPI glIndexMask( GLuint mask )
+{
+    struct glIndexMask_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %d\n", mask );
+    if ((status = UNIX_CALL( glIndexMask, &args ))) WARN( "glIndexMask returned %#x\n", status );
+}
+
+void WINAPI glIndexPointer( GLenum type, GLsizei stride, const void *pointer )
+{
+    struct glIndexPointer_params args = { .type = type, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
+    if ((status = UNIX_CALL( glIndexPointer, &args ))) WARN( "glIndexPointer returned %#x\n", status );
+}
+
+void WINAPI glIndexd( GLdouble c )
+{
+    struct glIndexd_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %f\n", c );
+    if ((status = UNIX_CALL( glIndexd, &args ))) WARN( "glIndexd returned %#x\n", status );
+}
+
+void WINAPI glIndexdv( const GLdouble *c )
+{
+    struct glIndexdv_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %p\n", c );
+    if ((status = UNIX_CALL( glIndexdv, &args ))) WARN( "glIndexdv returned %#x\n", status );
+}
+
+void WINAPI glIndexf( GLfloat c )
+{
+    struct glIndexf_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %f\n", c );
+    if ((status = UNIX_CALL( glIndexf, &args ))) WARN( "glIndexf returned %#x\n", status );
+}
+
+void WINAPI glIndexfv( const GLfloat *c )
+{
+    struct glIndexfv_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %p\n", c );
+    if ((status = UNIX_CALL( glIndexfv, &args ))) WARN( "glIndexfv returned %#x\n", status );
+}
+
+void WINAPI glIndexi( GLint c )
+{
+    struct glIndexi_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %d\n", c );
+    if ((status = UNIX_CALL( glIndexi, &args ))) WARN( "glIndexi returned %#x\n", status );
+}
+
+void WINAPI glIndexiv( const GLint *c )
+{
+    struct glIndexiv_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %p\n", c );
+    if ((status = UNIX_CALL( glIndexiv, &args ))) WARN( "glIndexiv returned %#x\n", status );
+}
+
+void WINAPI glIndexs( GLshort c )
+{
+    struct glIndexs_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %d\n", c );
+    if ((status = UNIX_CALL( glIndexs, &args ))) WARN( "glIndexs returned %#x\n", status );
+}
+
+void WINAPI glIndexsv( const GLshort *c )
+{
+    struct glIndexsv_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %p\n", c );
+    if ((status = UNIX_CALL( glIndexsv, &args ))) WARN( "glIndexsv returned %#x\n", status );
+}
+
+void WINAPI glIndexub( GLubyte c )
+{
+    struct glIndexub_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %d\n", c );
+    if ((status = UNIX_CALL( glIndexub, &args ))) WARN( "glIndexub returned %#x\n", status );
+}
+
+void WINAPI glIndexubv( const GLubyte *c )
+{
+    struct glIndexubv_params args = { .c = c, };
+    NTSTATUS status;
+    TRACE( "c %p\n", c );
+    if ((status = UNIX_CALL( glIndexubv, &args ))) WARN( "glIndexubv returned %#x\n", status );
+}
+
+void WINAPI glInitNames(void)
+{
+    struct glInitNames_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glInitNames, &args ))) WARN( "glInitNames returned %#x\n", status );
+}
+
+void WINAPI glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer )
+{
+    struct glInterleavedArrays_params args = { .format = format, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "format %d, stride %d, pointer %p\n", format, stride, pointer );
+    if ((status = UNIX_CALL( glInterleavedArrays, &args ))) WARN( "glInterleavedArrays returned %#x\n", status );
+}
+
+GLboolean WINAPI glIsEnabled( GLenum cap )
+{
+    struct glIsEnabled_params args = { .cap = cap, };
+    NTSTATUS status;
+    TRACE( "cap %d\n", cap );
+    if ((status = UNIX_CALL( glIsEnabled, &args ))) WARN( "glIsEnabled returned %#x\n", status );
+    return args.ret;
+}
+
+GLboolean WINAPI glIsList( GLuint list )
+{
+    struct glIsList_params args = { .list = list, };
+    NTSTATUS status;
+    TRACE( "list %d\n", list );
+    if ((status = UNIX_CALL( glIsList, &args ))) WARN( "glIsList returned %#x\n", status );
+    return args.ret;
+}
+
+GLboolean WINAPI glIsTexture( GLuint texture )
+{
+    struct glIsTexture_params args = { .texture = texture, };
+    NTSTATUS status;
+    TRACE( "texture %d\n", texture );
+    if ((status = UNIX_CALL( glIsTexture, &args ))) WARN( "glIsTexture returned %#x\n", status );
+    return args.ret;
+}
+
+void WINAPI glLightModelf( GLenum pname, GLfloat param )
+{
+    struct glLightModelf_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %f\n", pname, param );
+    if ((status = UNIX_CALL( glLightModelf, &args ))) WARN( "glLightModelf returned %#x\n", status );
+}
+
+void WINAPI glLightModelfv( GLenum pname, const GLfloat *params )
+{
+    struct glLightModelfv_params args = { .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "pname %d, params %p\n", pname, params );
+    if ((status = UNIX_CALL( glLightModelfv, &args ))) WARN( "glLightModelfv returned %#x\n", status );
+}
+
+void WINAPI glLightModeli( GLenum pname, GLint param )
+{
+    struct glLightModeli_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %d\n", pname, param );
+    if ((status = UNIX_CALL( glLightModeli, &args ))) WARN( "glLightModeli returned %#x\n", status );
+}
+
+void WINAPI glLightModeliv( GLenum pname, const GLint *params )
+{
+    struct glLightModeliv_params args = { .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "pname %d, params %p\n", pname, params );
+    if ((status = UNIX_CALL( glLightModeliv, &args ))) WARN( "glLightModeliv returned %#x\n", status );
+}
+
+void WINAPI glLightf( GLenum light, GLenum pname, GLfloat param )
+{
+    struct glLightf_params args = { .light = light, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, param %f\n", light, pname, param );
+    if ((status = UNIX_CALL( glLightf, &args ))) WARN( "glLightf returned %#x\n", status );
+}
+
+void WINAPI glLightfv( GLenum light, GLenum pname, const GLfloat *params )
+{
+    struct glLightfv_params args = { .light = light, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
+    if ((status = UNIX_CALL( glLightfv, &args ))) WARN( "glLightfv returned %#x\n", status );
+}
+
+void WINAPI glLighti( GLenum light, GLenum pname, GLint param )
+{
+    struct glLighti_params args = { .light = light, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, param %d\n", light, pname, param );
+    if ((status = UNIX_CALL( glLighti, &args ))) WARN( "glLighti returned %#x\n", status );
+}
+
+void WINAPI glLightiv( GLenum light, GLenum pname, const GLint *params )
+{
+    struct glLightiv_params args = { .light = light, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "light %d, pname %d, params %p\n", light, pname, params );
+    if ((status = UNIX_CALL( glLightiv, &args ))) WARN( "glLightiv returned %#x\n", status );
+}
+
+void WINAPI glLineStipple( GLint factor, GLushort pattern )
+{
+    struct glLineStipple_params args = { .factor = factor, .pattern = pattern, };
+    NTSTATUS status;
+    TRACE( "factor %d, pattern %d\n", factor, pattern );
+    if ((status = UNIX_CALL( glLineStipple, &args ))) WARN( "glLineStipple returned %#x\n", status );
+}
+
+void WINAPI glLineWidth( GLfloat width )
+{
+    struct glLineWidth_params args = { .width = width, };
+    NTSTATUS status;
+    TRACE( "width %f\n", width );
+    if ((status = UNIX_CALL( glLineWidth, &args ))) WARN( "glLineWidth returned %#x\n", status );
+}
+
+void WINAPI glListBase( GLuint base )
+{
+    struct glListBase_params args = { .base = base, };
+    NTSTATUS status;
+    TRACE( "base %d\n", base );
+    if ((status = UNIX_CALL( glListBase, &args ))) WARN( "glListBase returned %#x\n", status );
+}
+
+void WINAPI glLoadIdentity(void)
+{
+    struct glLoadIdentity_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glLoadIdentity, &args ))) WARN( "glLoadIdentity returned %#x\n", status );
+}
+
+void WINAPI glLoadMatrixd( const GLdouble *m )
+{
+    struct glLoadMatrixd_params args = { .m = m, };
+    NTSTATUS status;
+    TRACE( "m %p\n", m );
+    if ((status = UNIX_CALL( glLoadMatrixd, &args ))) WARN( "glLoadMatrixd returned %#x\n", status );
+}
+
+void WINAPI glLoadMatrixf( const GLfloat *m )
+{
+    struct glLoadMatrixf_params args = { .m = m, };
+    NTSTATUS status;
+    TRACE( "m %p\n", m );
+    if ((status = UNIX_CALL( glLoadMatrixf, &args ))) WARN( "glLoadMatrixf returned %#x\n", status );
+}
+
+void WINAPI glLoadName( GLuint name )
+{
+    struct glLoadName_params args = { .name = name, };
+    NTSTATUS status;
+    TRACE( "name %d\n", name );
+    if ((status = UNIX_CALL( glLoadName, &args ))) WARN( "glLoadName returned %#x\n", status );
+}
+
+void WINAPI glLogicOp( GLenum opcode )
+{
+    struct glLogicOp_params args = { .opcode = opcode, };
+    NTSTATUS status;
+    TRACE( "opcode %d\n", opcode );
+    if ((status = UNIX_CALL( glLogicOp, &args ))) WARN( "glLogicOp returned %#x\n", status );
+}
+
+void WINAPI glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
+{
+    struct glMap1d_params args = { .target = target, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points, };
+    NTSTATUS status;
+    TRACE( "target %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", target, u1, u2, stride, order, points );
+    if ((status = UNIX_CALL( glMap1d, &args ))) WARN( "glMap1d returned %#x\n", status );
+}
+
+void WINAPI glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
+{
+    struct glMap1f_params args = { .target = target, .u1 = u1, .u2 = u2, .stride = stride, .order = order, .points = points, };
+    NTSTATUS status;
+    TRACE( "target %d, u1 %f, u2 %f, stride %d, order %d, points %p\n", target, u1, u2, stride, order, points );
+    if ((status = UNIX_CALL( glMap1f, &args ))) WARN( "glMap1f returned %#x\n", status );
+}
+
+void WINAPI glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
+{
+    struct glMap2d_params args = { .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points, };
+    NTSTATUS status;
+    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+    if ((status = UNIX_CALL( glMap2d, &args ))) WARN( "glMap2d returned %#x\n", status );
+}
+
+void WINAPI glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
+{
+    struct glMap2f_params args = { .target = target, .u1 = u1, .u2 = u2, .ustride = ustride, .uorder = uorder, .v1 = v1, .v2 = v2, .vstride = vstride, .vorder = vorder, .points = points, };
+    NTSTATUS status;
+    TRACE( "target %d, u1 %f, u2 %f, ustride %d, uorder %d, v1 %f, v2 %f, vstride %d, vorder %d, points %p\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+    if ((status = UNIX_CALL( glMap2f, &args ))) WARN( "glMap2f returned %#x\n", status );
+}
+
+void WINAPI glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
+{
+    struct glMapGrid1d_params args = { .un = un, .u1 = u1, .u2 = u2, };
+    NTSTATUS status;
+    TRACE( "un %d, u1 %f, u2 %f\n", un, u1, u2 );
+    if ((status = UNIX_CALL( glMapGrid1d, &args ))) WARN( "glMapGrid1d returned %#x\n", status );
+}
+
+void WINAPI glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
+{
+    struct glMapGrid1f_params args = { .un = un, .u1 = u1, .u2 = u2, };
+    NTSTATUS status;
+    TRACE( "un %d, u1 %f, u2 %f\n", un, u1, u2 );
+    if ((status = UNIX_CALL( glMapGrid1f, &args ))) WARN( "glMapGrid1f returned %#x\n", status );
+}
+
+void WINAPI glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
+{
+    struct glMapGrid2d_params args = { .un = un, .u1 = u1, .u2 = u2, .vn = vn, .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "un %d, u1 %f, u2 %f, vn %d, v1 %f, v2 %f\n", un, u1, u2, vn, v1, v2 );
+    if ((status = UNIX_CALL( glMapGrid2d, &args ))) WARN( "glMapGrid2d returned %#x\n", status );
+}
+
+void WINAPI glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
+{
+    struct glMapGrid2f_params args = { .un = un, .u1 = u1, .u2 = u2, .vn = vn, .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "un %d, u1 %f, u2 %f, vn %d, v1 %f, v2 %f\n", un, u1, u2, vn, v1, v2 );
+    if ((status = UNIX_CALL( glMapGrid2f, &args ))) WARN( "glMapGrid2f returned %#x\n", status );
+}
+
+void WINAPI glMaterialf( GLenum face, GLenum pname, GLfloat param )
+{
+    struct glMaterialf_params args = { .face = face, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, param %f\n", face, pname, param );
+    if ((status = UNIX_CALL( glMaterialf, &args ))) WARN( "glMaterialf returned %#x\n", status );
+}
+
+void WINAPI glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
+{
+    struct glMaterialfv_params args = { .face = face, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
+    if ((status = UNIX_CALL( glMaterialfv, &args ))) WARN( "glMaterialfv returned %#x\n", status );
+}
+
+void WINAPI glMateriali( GLenum face, GLenum pname, GLint param )
+{
+    struct glMateriali_params args = { .face = face, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, param %d\n", face, pname, param );
+    if ((status = UNIX_CALL( glMateriali, &args ))) WARN( "glMateriali returned %#x\n", status );
+}
+
+void WINAPI glMaterialiv( GLenum face, GLenum pname, const GLint *params )
+{
+    struct glMaterialiv_params args = { .face = face, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "face %d, pname %d, params %p\n", face, pname, params );
+    if ((status = UNIX_CALL( glMaterialiv, &args ))) WARN( "glMaterialiv returned %#x\n", status );
+}
+
+void WINAPI glMatrixMode( GLenum mode )
+{
+    struct glMatrixMode_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glMatrixMode, &args ))) WARN( "glMatrixMode returned %#x\n", status );
+}
+
+void WINAPI glMultMatrixd( const GLdouble *m )
+{
+    struct glMultMatrixd_params args = { .m = m, };
+    NTSTATUS status;
+    TRACE( "m %p\n", m );
+    if ((status = UNIX_CALL( glMultMatrixd, &args ))) WARN( "glMultMatrixd returned %#x\n", status );
+}
+
+void WINAPI glMultMatrixf( const GLfloat *m )
+{
+    struct glMultMatrixf_params args = { .m = m, };
+    NTSTATUS status;
+    TRACE( "m %p\n", m );
+    if ((status = UNIX_CALL( glMultMatrixf, &args ))) WARN( "glMultMatrixf returned %#x\n", status );
+}
+
+void WINAPI glNewList( GLuint list, GLenum mode )
+{
+    struct glNewList_params args = { .list = list, .mode = mode, };
+    NTSTATUS status;
+    TRACE( "list %d, mode %d\n", list, mode );
+    if ((status = UNIX_CALL( glNewList, &args ))) WARN( "glNewList returned %#x\n", status );
+}
+
+void WINAPI glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
+{
+    struct glNormal3b_params args = { .nx = nx, .ny = ny, .nz = nz, };
+    NTSTATUS status;
+    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
+    if ((status = UNIX_CALL( glNormal3b, &args ))) WARN( "glNormal3b returned %#x\n", status );
+}
+
+void WINAPI glNormal3bv( const GLbyte *v )
+{
+    struct glNormal3bv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glNormal3bv, &args ))) WARN( "glNormal3bv returned %#x\n", status );
+}
+
+void WINAPI glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
+{
+    struct glNormal3d_params args = { .nx = nx, .ny = ny, .nz = nz, };
+    NTSTATUS status;
+    TRACE( "nx %f, ny %f, nz %f\n", nx, ny, nz );
+    if ((status = UNIX_CALL( glNormal3d, &args ))) WARN( "glNormal3d returned %#x\n", status );
+}
+
+void WINAPI glNormal3dv( const GLdouble *v )
+{
+    struct glNormal3dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glNormal3dv, &args ))) WARN( "glNormal3dv returned %#x\n", status );
+}
+
+void WINAPI glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
+{
+    struct glNormal3f_params args = { .nx = nx, .ny = ny, .nz = nz, };
+    NTSTATUS status;
+    TRACE( "nx %f, ny %f, nz %f\n", nx, ny, nz );
+    if ((status = UNIX_CALL( glNormal3f, &args ))) WARN( "glNormal3f returned %#x\n", status );
+}
+
+void WINAPI glNormal3fv( const GLfloat *v )
+{
+    struct glNormal3fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glNormal3fv, &args ))) WARN( "glNormal3fv returned %#x\n", status );
+}
+
+void WINAPI glNormal3i( GLint nx, GLint ny, GLint nz )
+{
+    struct glNormal3i_params args = { .nx = nx, .ny = ny, .nz = nz, };
+    NTSTATUS status;
+    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
+    if ((status = UNIX_CALL( glNormal3i, &args ))) WARN( "glNormal3i returned %#x\n", status );
+}
+
+void WINAPI glNormal3iv( const GLint *v )
+{
+    struct glNormal3iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glNormal3iv, &args ))) WARN( "glNormal3iv returned %#x\n", status );
+}
+
+void WINAPI glNormal3s( GLshort nx, GLshort ny, GLshort nz )
+{
+    struct glNormal3s_params args = { .nx = nx, .ny = ny, .nz = nz, };
+    NTSTATUS status;
+    TRACE( "nx %d, ny %d, nz %d\n", nx, ny, nz );
+    if ((status = UNIX_CALL( glNormal3s, &args ))) WARN( "glNormal3s returned %#x\n", status );
+}
+
+void WINAPI glNormal3sv( const GLshort *v )
+{
+    struct glNormal3sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glNormal3sv, &args ))) WARN( "glNormal3sv returned %#x\n", status );
+}
+
+void WINAPI glNormalPointer( GLenum type, GLsizei stride, const void *pointer )
+{
+    struct glNormalPointer_params args = { .type = type, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "type %d, stride %d, pointer %p\n", type, stride, pointer );
+    if ((status = UNIX_CALL( glNormalPointer, &args ))) WARN( "glNormalPointer returned %#x\n", status );
+}
+
+void WINAPI glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
+    struct glOrtho_params args = { .left = left, .right = right, .bottom = bottom, .top = top, .zNear = zNear, .zFar = zFar, };
+    NTSTATUS status;
+    TRACE( "left %f, right %f, bottom %f, top %f, zNear %f, zFar %f\n", left, right, bottom, top, zNear, zFar );
+    if ((status = UNIX_CALL( glOrtho, &args ))) WARN( "glOrtho returned %#x\n", status );
+}
+
+void WINAPI glPassThrough( GLfloat token )
+{
+    struct glPassThrough_params args = { .token = token, };
+    NTSTATUS status;
+    TRACE( "token %f\n", token );
+    if ((status = UNIX_CALL( glPassThrough, &args ))) WARN( "glPassThrough returned %#x\n", status );
+}
+
+void WINAPI glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
+{
+    struct glPixelMapfv_params args = { .map = map, .mapsize = mapsize, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
+    if ((status = UNIX_CALL( glPixelMapfv, &args ))) WARN( "glPixelMapfv returned %#x\n", status );
+}
+
+void WINAPI glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
+{
+    struct glPixelMapuiv_params args = { .map = map, .mapsize = mapsize, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
+    if ((status = UNIX_CALL( glPixelMapuiv, &args ))) WARN( "glPixelMapuiv returned %#x\n", status );
+}
+
+void WINAPI glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
+{
+    struct glPixelMapusv_params args = { .map = map, .mapsize = mapsize, .values = values, };
+    NTSTATUS status;
+    TRACE( "map %d, mapsize %d, values %p\n", map, mapsize, values );
+    if ((status = UNIX_CALL( glPixelMapusv, &args ))) WARN( "glPixelMapusv returned %#x\n", status );
+}
+
+void WINAPI glPixelStoref( GLenum pname, GLfloat param )
+{
+    struct glPixelStoref_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %f\n", pname, param );
+    if ((status = UNIX_CALL( glPixelStoref, &args ))) WARN( "glPixelStoref returned %#x\n", status );
+}
+
+void WINAPI glPixelStorei( GLenum pname, GLint param )
+{
+    struct glPixelStorei_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %d\n", pname, param );
+    if ((status = UNIX_CALL( glPixelStorei, &args ))) WARN( "glPixelStorei returned %#x\n", status );
+}
+
+void WINAPI glPixelTransferf( GLenum pname, GLfloat param )
+{
+    struct glPixelTransferf_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %f\n", pname, param );
+    if ((status = UNIX_CALL( glPixelTransferf, &args ))) WARN( "glPixelTransferf returned %#x\n", status );
+}
+
+void WINAPI glPixelTransferi( GLenum pname, GLint param )
+{
+    struct glPixelTransferi_params args = { .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "pname %d, param %d\n", pname, param );
+    if ((status = UNIX_CALL( glPixelTransferi, &args ))) WARN( "glPixelTransferi returned %#x\n", status );
+}
+
+void WINAPI glPixelZoom( GLfloat xfactor, GLfloat yfactor )
+{
+    struct glPixelZoom_params args = { .xfactor = xfactor, .yfactor = yfactor, };
+    NTSTATUS status;
+    TRACE( "xfactor %f, yfactor %f\n", xfactor, yfactor );
+    if ((status = UNIX_CALL( glPixelZoom, &args ))) WARN( "glPixelZoom returned %#x\n", status );
+}
+
+void WINAPI glPointSize( GLfloat size )
+{
+    struct glPointSize_params args = { .size = size, };
+    NTSTATUS status;
+    TRACE( "size %f\n", size );
+    if ((status = UNIX_CALL( glPointSize, &args ))) WARN( "glPointSize returned %#x\n", status );
+}
+
+void WINAPI glPolygonMode( GLenum face, GLenum mode )
+{
+    struct glPolygonMode_params args = { .face = face, .mode = mode, };
+    NTSTATUS status;
+    TRACE( "face %d, mode %d\n", face, mode );
+    if ((status = UNIX_CALL( glPolygonMode, &args ))) WARN( "glPolygonMode returned %#x\n", status );
+}
+
+void WINAPI glPolygonOffset( GLfloat factor, GLfloat units )
+{
+    struct glPolygonOffset_params args = { .factor = factor, .units = units, };
+    NTSTATUS status;
+    TRACE( "factor %f, units %f\n", factor, units );
+    if ((status = UNIX_CALL( glPolygonOffset, &args ))) WARN( "glPolygonOffset returned %#x\n", status );
+}
+
+void WINAPI glPolygonStipple( const GLubyte *mask )
+{
+    struct glPolygonStipple_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %p\n", mask );
+    if ((status = UNIX_CALL( glPolygonStipple, &args ))) WARN( "glPolygonStipple returned %#x\n", status );
+}
+
+void WINAPI glPopAttrib(void)
+{
+    struct glPopAttrib_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glPopAttrib, &args ))) WARN( "glPopAttrib returned %#x\n", status );
+}
+
+void WINAPI glPopClientAttrib(void)
+{
+    struct glPopClientAttrib_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glPopClientAttrib, &args ))) WARN( "glPopClientAttrib returned %#x\n", status );
+}
+
+void WINAPI glPopMatrix(void)
+{
+    struct glPopMatrix_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glPopMatrix, &args ))) WARN( "glPopMatrix returned %#x\n", status );
+}
+
+void WINAPI glPopName(void)
+{
+    struct glPopName_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glPopName, &args ))) WARN( "glPopName returned %#x\n", status );
+}
+
+void WINAPI glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities )
+{
+    struct glPrioritizeTextures_params args = { .n = n, .textures = textures, .priorities = priorities, };
+    NTSTATUS status;
+    TRACE( "n %d, textures %p, priorities %p\n", n, textures, priorities );
+    if ((status = UNIX_CALL( glPrioritizeTextures, &args ))) WARN( "glPrioritizeTextures returned %#x\n", status );
+}
+
+void WINAPI glPushAttrib( GLbitfield mask )
+{
+    struct glPushAttrib_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %d\n", mask );
+    if ((status = UNIX_CALL( glPushAttrib, &args ))) WARN( "glPushAttrib returned %#x\n", status );
+}
+
+void WINAPI glPushClientAttrib( GLbitfield mask )
+{
+    struct glPushClientAttrib_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %d\n", mask );
+    if ((status = UNIX_CALL( glPushClientAttrib, &args ))) WARN( "glPushClientAttrib returned %#x\n", status );
+}
+
+void WINAPI glPushMatrix(void)
+{
+    struct glPushMatrix_params args;
+    NTSTATUS status;
+    TRACE( "\n" );
+    if ((status = UNIX_CALL( glPushMatrix, &args ))) WARN( "glPushMatrix returned %#x\n", status );
+}
+
+void WINAPI glPushName( GLuint name )
+{
+    struct glPushName_params args = { .name = name, };
+    NTSTATUS status;
+    TRACE( "name %d\n", name );
+    if ((status = UNIX_CALL( glPushName, &args ))) WARN( "glPushName returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2d( GLdouble x, GLdouble y )
+{
+    struct glRasterPos2d_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f\n", x, y );
+    if ((status = UNIX_CALL( glRasterPos2d, &args ))) WARN( "glRasterPos2d returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2dv( const GLdouble *v )
+{
+    struct glRasterPos2dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos2dv, &args ))) WARN( "glRasterPos2dv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2f( GLfloat x, GLfloat y )
+{
+    struct glRasterPos2f_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f\n", x, y );
+    if ((status = UNIX_CALL( glRasterPos2f, &args ))) WARN( "glRasterPos2f returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2fv( const GLfloat *v )
+{
+    struct glRasterPos2fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos2fv, &args ))) WARN( "glRasterPos2fv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2i( GLint x, GLint y )
+{
+    struct glRasterPos2i_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d\n", x, y );
+    if ((status = UNIX_CALL( glRasterPos2i, &args ))) WARN( "glRasterPos2i returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2iv( const GLint *v )
+{
+    struct glRasterPos2iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos2iv, &args ))) WARN( "glRasterPos2iv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2s( GLshort x, GLshort y )
+{
+    struct glRasterPos2s_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d\n", x, y );
+    if ((status = UNIX_CALL( glRasterPos2s, &args ))) WARN( "glRasterPos2s returned %#x\n", status );
+}
+
+void WINAPI glRasterPos2sv( const GLshort *v )
+{
+    struct glRasterPos2sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos2sv, &args ))) WARN( "glRasterPos2sv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
+{
+    struct glRasterPos3d_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glRasterPos3d, &args ))) WARN( "glRasterPos3d returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3dv( const GLdouble *v )
+{
+    struct glRasterPos3dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos3dv, &args ))) WARN( "glRasterPos3dv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
+{
+    struct glRasterPos3f_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glRasterPos3f, &args ))) WARN( "glRasterPos3f returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3fv( const GLfloat *v )
+{
+    struct glRasterPos3fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos3fv, &args ))) WARN( "glRasterPos3fv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3i( GLint x, GLint y, GLint z )
+{
+    struct glRasterPos3i_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d\n", x, y, z );
+    if ((status = UNIX_CALL( glRasterPos3i, &args ))) WARN( "glRasterPos3i returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3iv( const GLint *v )
+{
+    struct glRasterPos3iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos3iv, &args ))) WARN( "glRasterPos3iv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3s( GLshort x, GLshort y, GLshort z )
+{
+    struct glRasterPos3s_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d\n", x, y, z );
+    if ((status = UNIX_CALL( glRasterPos3s, &args ))) WARN( "glRasterPos3s returned %#x\n", status );
+}
+
+void WINAPI glRasterPos3sv( const GLshort *v )
+{
+    struct glRasterPos3sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos3sv, &args ))) WARN( "glRasterPos3sv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
+    struct glRasterPos4d_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
+    if ((status = UNIX_CALL( glRasterPos4d, &args ))) WARN( "glRasterPos4d returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4dv( const GLdouble *v )
+{
+    struct glRasterPos4dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos4dv, &args ))) WARN( "glRasterPos4dv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+    struct glRasterPos4f_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
+    if ((status = UNIX_CALL( glRasterPos4f, &args ))) WARN( "glRasterPos4f returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4fv( const GLfloat *v )
+{
+    struct glRasterPos4fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos4fv, &args ))) WARN( "glRasterPos4fv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
+{
+    struct glRasterPos4i_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
+    if ((status = UNIX_CALL( glRasterPos4i, &args ))) WARN( "glRasterPos4i returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4iv( const GLint *v )
+{
+    struct glRasterPos4iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos4iv, &args ))) WARN( "glRasterPos4iv returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
+{
+    struct glRasterPos4s_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
+    if ((status = UNIX_CALL( glRasterPos4s, &args ))) WARN( "glRasterPos4s returned %#x\n", status );
+}
+
+void WINAPI glRasterPos4sv( const GLshort *v )
+{
+    struct glRasterPos4sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glRasterPos4sv, &args ))) WARN( "glRasterPos4sv returned %#x\n", status );
+}
+
+void WINAPI glReadBuffer( GLenum src )
+{
+    struct glReadBuffer_params args = { .src = src, };
+    NTSTATUS status;
+    TRACE( "src %d\n", src );
+    if ((status = UNIX_CALL( glReadBuffer, &args ))) WARN( "glReadBuffer returned %#x\n", status );
+}
+
+void WINAPI glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels )
+{
+    struct glReadPixels_params args = { .x = x, .y = y, .width = width, .height = height, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, width %d, height %d, format %d, type %d, pixels %p\n", x, y, width, height, format, type, pixels );
+    if ((status = UNIX_CALL( glReadPixels, &args ))) WARN( "glReadPixels returned %#x\n", status );
+}
+
+void WINAPI glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
+{
+    struct glRectd_params args = { .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, };
+    NTSTATUS status;
+    TRACE( "x1 %f, y1 %f, x2 %f, y2 %f\n", x1, y1, x2, y2 );
+    if ((status = UNIX_CALL( glRectd, &args ))) WARN( "glRectd returned %#x\n", status );
+}
+
+void WINAPI glRectdv( const GLdouble *v1, const GLdouble *v2 )
+{
+    struct glRectdv_params args = { .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "v1 %p, v2 %p\n", v1, v2 );
+    if ((status = UNIX_CALL( glRectdv, &args ))) WARN( "glRectdv returned %#x\n", status );
+}
+
+void WINAPI glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+    struct glRectf_params args = { .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, };
+    NTSTATUS status;
+    TRACE( "x1 %f, y1 %f, x2 %f, y2 %f\n", x1, y1, x2, y2 );
+    if ((status = UNIX_CALL( glRectf, &args ))) WARN( "glRectf returned %#x\n", status );
+}
+
+void WINAPI glRectfv( const GLfloat *v1, const GLfloat *v2 )
+{
+    struct glRectfv_params args = { .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "v1 %p, v2 %p\n", v1, v2 );
+    if ((status = UNIX_CALL( glRectfv, &args ))) WARN( "glRectfv returned %#x\n", status );
+}
+
+void WINAPI glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
+{
+    struct glRecti_params args = { .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, };
+    NTSTATUS status;
+    TRACE( "x1 %d, y1 %d, x2 %d, y2 %d\n", x1, y1, x2, y2 );
+    if ((status = UNIX_CALL( glRecti, &args ))) WARN( "glRecti returned %#x\n", status );
+}
+
+void WINAPI glRectiv( const GLint *v1, const GLint *v2 )
+{
+    struct glRectiv_params args = { .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "v1 %p, v2 %p\n", v1, v2 );
+    if ((status = UNIX_CALL( glRectiv, &args ))) WARN( "glRectiv returned %#x\n", status );
+}
+
+void WINAPI glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
+{
+    struct glRects_params args = { .x1 = x1, .y1 = y1, .x2 = x2, .y2 = y2, };
+    NTSTATUS status;
+    TRACE( "x1 %d, y1 %d, x2 %d, y2 %d\n", x1, y1, x2, y2 );
+    if ((status = UNIX_CALL( glRects, &args ))) WARN( "glRects returned %#x\n", status );
+}
+
+void WINAPI glRectsv( const GLshort *v1, const GLshort *v2 )
+{
+    struct glRectsv_params args = { .v1 = v1, .v2 = v2, };
+    NTSTATUS status;
+    TRACE( "v1 %p, v2 %p\n", v1, v2 );
+    if ((status = UNIX_CALL( glRectsv, &args ))) WARN( "glRectsv returned %#x\n", status );
+}
+
+GLint WINAPI glRenderMode( GLenum mode )
+{
+    struct glRenderMode_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glRenderMode, &args ))) WARN( "glRenderMode returned %#x\n", status );
+    return args.ret;
+}
+
+void WINAPI glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
+{
+    struct glRotated_params args = { .angle = angle, .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "angle %f, x %f, y %f, z %f\n", angle, x, y, z );
+    if ((status = UNIX_CALL( glRotated, &args ))) WARN( "glRotated returned %#x\n", status );
+}
+
+void WINAPI glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
+{
+    struct glRotatef_params args = { .angle = angle, .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "angle %f, x %f, y %f, z %f\n", angle, x, y, z );
+    if ((status = UNIX_CALL( glRotatef, &args ))) WARN( "glRotatef returned %#x\n", status );
+}
+
+void WINAPI glScaled( GLdouble x, GLdouble y, GLdouble z )
+{
+    struct glScaled_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glScaled, &args ))) WARN( "glScaled returned %#x\n", status );
+}
+
+void WINAPI glScalef( GLfloat x, GLfloat y, GLfloat z )
+{
+    struct glScalef_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glScalef, &args ))) WARN( "glScalef returned %#x\n", status );
+}
+
+void WINAPI glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
+{
+    struct glScissor_params args = { .x = x, .y = y, .width = width, .height = height, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, width %d, height %d\n", x, y, width, height );
+    if ((status = UNIX_CALL( glScissor, &args ))) WARN( "glScissor returned %#x\n", status );
+}
+
+void WINAPI glSelectBuffer( GLsizei size, GLuint *buffer )
+{
+    struct glSelectBuffer_params args = { .size = size, .buffer = buffer, };
+    NTSTATUS status;
+    TRACE( "size %d, buffer %p\n", size, buffer );
+    if ((status = UNIX_CALL( glSelectBuffer, &args ))) WARN( "glSelectBuffer returned %#x\n", status );
+}
+
+void WINAPI glShadeModel( GLenum mode )
+{
+    struct glShadeModel_params args = { .mode = mode, };
+    NTSTATUS status;
+    TRACE( "mode %d\n", mode );
+    if ((status = UNIX_CALL( glShadeModel, &args ))) WARN( "glShadeModel returned %#x\n", status );
+}
+
+void WINAPI glStencilFunc( GLenum func, GLint ref, GLuint mask )
+{
+    struct glStencilFunc_params args = { .func = func, .ref = ref, .mask = mask, };
+    NTSTATUS status;
+    TRACE( "func %d, ref %d, mask %d\n", func, ref, mask );
+    if ((status = UNIX_CALL( glStencilFunc, &args ))) WARN( "glStencilFunc returned %#x\n", status );
+}
+
+void WINAPI glStencilMask( GLuint mask )
+{
+    struct glStencilMask_params args = { .mask = mask, };
+    NTSTATUS status;
+    TRACE( "mask %d\n", mask );
+    if ((status = UNIX_CALL( glStencilMask, &args ))) WARN( "glStencilMask returned %#x\n", status );
+}
+
+void WINAPI glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
+{
+    struct glStencilOp_params args = { .fail = fail, .zfail = zfail, .zpass = zpass, };
+    NTSTATUS status;
+    TRACE( "fail %d, zfail %d, zpass %d\n", fail, zfail, zpass );
+    if ((status = UNIX_CALL( glStencilOp, &args ))) WARN( "glStencilOp returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1d( GLdouble s )
+{
+    struct glTexCoord1d_params args = { .s = s, };
+    NTSTATUS status;
+    TRACE( "s %f\n", s );
+    if ((status = UNIX_CALL( glTexCoord1d, &args ))) WARN( "glTexCoord1d returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1dv( const GLdouble *v )
+{
+    struct glTexCoord1dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord1dv, &args ))) WARN( "glTexCoord1dv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1f( GLfloat s )
+{
+    struct glTexCoord1f_params args = { .s = s, };
+    NTSTATUS status;
+    TRACE( "s %f\n", s );
+    if ((status = UNIX_CALL( glTexCoord1f, &args ))) WARN( "glTexCoord1f returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1fv( const GLfloat *v )
+{
+    struct glTexCoord1fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord1fv, &args ))) WARN( "glTexCoord1fv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1i( GLint s )
+{
+    struct glTexCoord1i_params args = { .s = s, };
+    NTSTATUS status;
+    TRACE( "s %d\n", s );
+    if ((status = UNIX_CALL( glTexCoord1i, &args ))) WARN( "glTexCoord1i returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1iv( const GLint *v )
+{
+    struct glTexCoord1iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord1iv, &args ))) WARN( "glTexCoord1iv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1s( GLshort s )
+{
+    struct glTexCoord1s_params args = { .s = s, };
+    NTSTATUS status;
+    TRACE( "s %d\n", s );
+    if ((status = UNIX_CALL( glTexCoord1s, &args ))) WARN( "glTexCoord1s returned %#x\n", status );
+}
+
+void WINAPI glTexCoord1sv( const GLshort *v )
+{
+    struct glTexCoord1sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord1sv, &args ))) WARN( "glTexCoord1sv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2d( GLdouble s, GLdouble t )
+{
+    struct glTexCoord2d_params args = { .s = s, .t = t, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f\n", s, t );
+    if ((status = UNIX_CALL( glTexCoord2d, &args ))) WARN( "glTexCoord2d returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2dv( const GLdouble *v )
+{
+    struct glTexCoord2dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord2dv, &args ))) WARN( "glTexCoord2dv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2f( GLfloat s, GLfloat t )
+{
+    struct glTexCoord2f_params args = { .s = s, .t = t, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f\n", s, t );
+    if ((status = UNIX_CALL( glTexCoord2f, &args ))) WARN( "glTexCoord2f returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2fv( const GLfloat *v )
+{
+    struct glTexCoord2fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord2fv, &args ))) WARN( "glTexCoord2fv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2i( GLint s, GLint t )
+{
+    struct glTexCoord2i_params args = { .s = s, .t = t, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d\n", s, t );
+    if ((status = UNIX_CALL( glTexCoord2i, &args ))) WARN( "glTexCoord2i returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2iv( const GLint *v )
+{
+    struct glTexCoord2iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord2iv, &args ))) WARN( "glTexCoord2iv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2s( GLshort s, GLshort t )
+{
+    struct glTexCoord2s_params args = { .s = s, .t = t, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d\n", s, t );
+    if ((status = UNIX_CALL( glTexCoord2s, &args ))) WARN( "glTexCoord2s returned %#x\n", status );
+}
+
+void WINAPI glTexCoord2sv( const GLshort *v )
+{
+    struct glTexCoord2sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord2sv, &args ))) WARN( "glTexCoord2sv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
+{
+    struct glTexCoord3d_params args = { .s = s, .t = t, .r = r, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f, r %f\n", s, t, r );
+    if ((status = UNIX_CALL( glTexCoord3d, &args ))) WARN( "glTexCoord3d returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3dv( const GLdouble *v )
+{
+    struct glTexCoord3dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord3dv, &args ))) WARN( "glTexCoord3dv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
+{
+    struct glTexCoord3f_params args = { .s = s, .t = t, .r = r, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f, r %f\n", s, t, r );
+    if ((status = UNIX_CALL( glTexCoord3f, &args ))) WARN( "glTexCoord3f returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3fv( const GLfloat *v )
+{
+    struct glTexCoord3fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord3fv, &args ))) WARN( "glTexCoord3fv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3i( GLint s, GLint t, GLint r )
+{
+    struct glTexCoord3i_params args = { .s = s, .t = t, .r = r, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d, r %d\n", s, t, r );
+    if ((status = UNIX_CALL( glTexCoord3i, &args ))) WARN( "glTexCoord3i returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3iv( const GLint *v )
+{
+    struct glTexCoord3iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord3iv, &args ))) WARN( "glTexCoord3iv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3s( GLshort s, GLshort t, GLshort r )
+{
+    struct glTexCoord3s_params args = { .s = s, .t = t, .r = r, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d, r %d\n", s, t, r );
+    if ((status = UNIX_CALL( glTexCoord3s, &args ))) WARN( "glTexCoord3s returned %#x\n", status );
+}
+
+void WINAPI glTexCoord3sv( const GLshort *v )
+{
+    struct glTexCoord3sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord3sv, &args ))) WARN( "glTexCoord3sv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
+    struct glTexCoord4d_params args = { .s = s, .t = t, .r = r, .q = q, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f, r %f, q %f\n", s, t, r, q );
+    if ((status = UNIX_CALL( glTexCoord4d, &args ))) WARN( "glTexCoord4d returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4dv( const GLdouble *v )
+{
+    struct glTexCoord4dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord4dv, &args ))) WARN( "glTexCoord4dv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
+    struct glTexCoord4f_params args = { .s = s, .t = t, .r = r, .q = q, };
+    NTSTATUS status;
+    TRACE( "s %f, t %f, r %f, q %f\n", s, t, r, q );
+    if ((status = UNIX_CALL( glTexCoord4f, &args ))) WARN( "glTexCoord4f returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4fv( const GLfloat *v )
+{
+    struct glTexCoord4fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord4fv, &args ))) WARN( "glTexCoord4fv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
+{
+    struct glTexCoord4i_params args = { .s = s, .t = t, .r = r, .q = q, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
+    if ((status = UNIX_CALL( glTexCoord4i, &args ))) WARN( "glTexCoord4i returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4iv( const GLint *v )
+{
+    struct glTexCoord4iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord4iv, &args ))) WARN( "glTexCoord4iv returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
+{
+    struct glTexCoord4s_params args = { .s = s, .t = t, .r = r, .q = q, };
+    NTSTATUS status;
+    TRACE( "s %d, t %d, r %d, q %d\n", s, t, r, q );
+    if ((status = UNIX_CALL( glTexCoord4s, &args ))) WARN( "glTexCoord4s returned %#x\n", status );
+}
+
+void WINAPI glTexCoord4sv( const GLshort *v )
+{
+    struct glTexCoord4sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glTexCoord4sv, &args ))) WARN( "glTexCoord4sv returned %#x\n", status );
+}
+
+void WINAPI glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
+    struct glTexCoordPointer_params args = { .size = size, .type = type, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
+    if ((status = UNIX_CALL( glTexCoordPointer, &args ))) WARN( "glTexCoordPointer returned %#x\n", status );
+}
+
+void WINAPI glTexEnvf( GLenum target, GLenum pname, GLfloat param )
+{
+    struct glTexEnvf_params args = { .target = target, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
+    if ((status = UNIX_CALL( glTexEnvf, &args ))) WARN( "glTexEnvf returned %#x\n", status );
+}
+
+void WINAPI glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
+{
+    struct glTexEnvfv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glTexEnvfv, &args ))) WARN( "glTexEnvfv returned %#x\n", status );
+}
+
+void WINAPI glTexEnvi( GLenum target, GLenum pname, GLint param )
+{
+    struct glTexEnvi_params args = { .target = target, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
+    if ((status = UNIX_CALL( glTexEnvi, &args ))) WARN( "glTexEnvi returned %#x\n", status );
+}
+
+void WINAPI glTexEnviv( GLenum target, GLenum pname, const GLint *params )
+{
+    struct glTexEnviv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glTexEnviv, &args ))) WARN( "glTexEnviv returned %#x\n", status );
+}
+
+void WINAPI glTexGend( GLenum coord, GLenum pname, GLdouble param )
+{
+    struct glTexGend_params args = { .coord = coord, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, param %f\n", coord, pname, param );
+    if ((status = UNIX_CALL( glTexGend, &args ))) WARN( "glTexGend returned %#x\n", status );
+}
+
+void WINAPI glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
+{
+    struct glTexGendv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glTexGendv, &args ))) WARN( "glTexGendv returned %#x\n", status );
+}
+
+void WINAPI glTexGenf( GLenum coord, GLenum pname, GLfloat param )
+{
+    struct glTexGenf_params args = { .coord = coord, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, param %f\n", coord, pname, param );
+    if ((status = UNIX_CALL( glTexGenf, &args ))) WARN( "glTexGenf returned %#x\n", status );
+}
+
+void WINAPI glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
+{
+    struct glTexGenfv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glTexGenfv, &args ))) WARN( "glTexGenfv returned %#x\n", status );
+}
+
+void WINAPI glTexGeni( GLenum coord, GLenum pname, GLint param )
+{
+    struct glTexGeni_params args = { .coord = coord, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, param %d\n", coord, pname, param );
+    if ((status = UNIX_CALL( glTexGeni, &args ))) WARN( "glTexGeni returned %#x\n", status );
+}
+
+void WINAPI glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
+{
+    struct glTexGeniv_params args = { .coord = coord, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "coord %d, pname %d, params %p\n", coord, pname, params );
+    if ((status = UNIX_CALL( glTexGeniv, &args ))) WARN( "glTexGeniv returned %#x\n", status );
+}
+
+void WINAPI glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
+{
+    struct glTexImage1D_params args = { .target = target, .level = level, .internalformat = internalformat, .width = width, .border = border, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, internalformat %d, width %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, border, format, type, pixels );
+    if ((status = UNIX_CALL( glTexImage1D, &args ))) WARN( "glTexImage1D returned %#x\n", status );
+}
+
+void WINAPI glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
+{
+    struct glTexImage2D_params args = { .target = target, .level = level, .internalformat = internalformat, .width = width, .height = height, .border = border, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, internalformat %d, width %d, height %d, border %d, format %d, type %d, pixels %p\n", target, level, internalformat, width, height, border, format, type, pixels );
+    if ((status = UNIX_CALL( glTexImage2D, &args ))) WARN( "glTexImage2D returned %#x\n", status );
+}
+
+void WINAPI glTexParameterf( GLenum target, GLenum pname, GLfloat param )
+{
+    struct glTexParameterf_params args = { .target = target, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, param %f\n", target, pname, param );
+    if ((status = UNIX_CALL( glTexParameterf, &args ))) WARN( "glTexParameterf returned %#x\n", status );
+}
+
+void WINAPI glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
+{
+    struct glTexParameterfv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glTexParameterfv, &args ))) WARN( "glTexParameterfv returned %#x\n", status );
+}
+
+void WINAPI glTexParameteri( GLenum target, GLenum pname, GLint param )
+{
+    struct glTexParameteri_params args = { .target = target, .pname = pname, .param = param, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, param %d\n", target, pname, param );
+    if ((status = UNIX_CALL( glTexParameteri, &args ))) WARN( "glTexParameteri returned %#x\n", status );
+}
+
+void WINAPI glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
+{
+    struct glTexParameteriv_params args = { .target = target, .pname = pname, .params = params, };
+    NTSTATUS status;
+    TRACE( "target %d, pname %d, params %p\n", target, pname, params );
+    if ((status = UNIX_CALL( glTexParameteriv, &args ))) WARN( "glTexParameteriv returned %#x\n", status );
+}
+
+void WINAPI glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
+    struct glTexSubImage1D_params args = { .target = target, .level = level, .xoffset = xoffset, .width = width, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, xoffset %d, width %d, format %d, type %d, pixels %p\n", target, level, xoffset, width, format, type, pixels );
+    if ((status = UNIX_CALL( glTexSubImage1D, &args ))) WARN( "glTexSubImage1D returned %#x\n", status );
+}
+
+void WINAPI glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
+    struct glTexSubImage2D_params args = { .target = target, .level = level, .xoffset = xoffset, .yoffset = yoffset, .width = width, .height = height, .format = format, .type = type, .pixels = pixels, };
+    NTSTATUS status;
+    TRACE( "target %d, level %d, xoffset %d, yoffset %d, width %d, height %d, format %d, type %d, pixels %p\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
+    if ((status = UNIX_CALL( glTexSubImage2D, &args ))) WARN( "glTexSubImage2D returned %#x\n", status );
+}
+
+void WINAPI glTranslated( GLdouble x, GLdouble y, GLdouble z )
+{
+    struct glTranslated_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glTranslated, &args ))) WARN( "glTranslated returned %#x\n", status );
+}
+
+void WINAPI glTranslatef( GLfloat x, GLfloat y, GLfloat z )
+{
+    struct glTranslatef_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glTranslatef, &args ))) WARN( "glTranslatef returned %#x\n", status );
+}
+
+void WINAPI glVertex2d( GLdouble x, GLdouble y )
+{
+    struct glVertex2d_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f\n", x, y );
+    if ((status = UNIX_CALL( glVertex2d, &args ))) WARN( "glVertex2d returned %#x\n", status );
+}
+
+void WINAPI glVertex2dv( const GLdouble *v )
+{
+    struct glVertex2dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex2dv, &args ))) WARN( "glVertex2dv returned %#x\n", status );
+}
+
+void WINAPI glVertex2f( GLfloat x, GLfloat y )
+{
+    struct glVertex2f_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f\n", x, y );
+    if ((status = UNIX_CALL( glVertex2f, &args ))) WARN( "glVertex2f returned %#x\n", status );
+}
+
+void WINAPI glVertex2fv( const GLfloat *v )
+{
+    struct glVertex2fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex2fv, &args ))) WARN( "glVertex2fv returned %#x\n", status );
+}
+
+void WINAPI glVertex2i( GLint x, GLint y )
+{
+    struct glVertex2i_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d\n", x, y );
+    if ((status = UNIX_CALL( glVertex2i, &args ))) WARN( "glVertex2i returned %#x\n", status );
+}
+
+void WINAPI glVertex2iv( const GLint *v )
+{
+    struct glVertex2iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex2iv, &args ))) WARN( "glVertex2iv returned %#x\n", status );
+}
+
+void WINAPI glVertex2s( GLshort x, GLshort y )
+{
+    struct glVertex2s_params args = { .x = x, .y = y, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d\n", x, y );
+    if ((status = UNIX_CALL( glVertex2s, &args ))) WARN( "glVertex2s returned %#x\n", status );
+}
+
+void WINAPI glVertex2sv( const GLshort *v )
+{
+    struct glVertex2sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex2sv, &args ))) WARN( "glVertex2sv returned %#x\n", status );
+}
+
+void WINAPI glVertex3d( GLdouble x, GLdouble y, GLdouble z )
+{
+    struct glVertex3d_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glVertex3d, &args ))) WARN( "glVertex3d returned %#x\n", status );
+}
+
+void WINAPI glVertex3dv( const GLdouble *v )
+{
+    struct glVertex3dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex3dv, &args ))) WARN( "glVertex3dv returned %#x\n", status );
+}
+
+void WINAPI glVertex3f( GLfloat x, GLfloat y, GLfloat z )
+{
+    struct glVertex3f_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f\n", x, y, z );
+    if ((status = UNIX_CALL( glVertex3f, &args ))) WARN( "glVertex3f returned %#x\n", status );
+}
+
+void WINAPI glVertex3fv( const GLfloat *v )
+{
+    struct glVertex3fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex3fv, &args ))) WARN( "glVertex3fv returned %#x\n", status );
+}
+
+void WINAPI glVertex3i( GLint x, GLint y, GLint z )
+{
+    struct glVertex3i_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d\n", x, y, z );
+    if ((status = UNIX_CALL( glVertex3i, &args ))) WARN( "glVertex3i returned %#x\n", status );
+}
+
+void WINAPI glVertex3iv( const GLint *v )
+{
+    struct glVertex3iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex3iv, &args ))) WARN( "glVertex3iv returned %#x\n", status );
+}
+
+void WINAPI glVertex3s( GLshort x, GLshort y, GLshort z )
+{
+    struct glVertex3s_params args = { .x = x, .y = y, .z = z, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d\n", x, y, z );
+    if ((status = UNIX_CALL( glVertex3s, &args ))) WARN( "glVertex3s returned %#x\n", status );
+}
+
+void WINAPI glVertex3sv( const GLshort *v )
+{
+    struct glVertex3sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex3sv, &args ))) WARN( "glVertex3sv returned %#x\n", status );
+}
+
+void WINAPI glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
+    struct glVertex4d_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
+    if ((status = UNIX_CALL( glVertex4d, &args ))) WARN( "glVertex4d returned %#x\n", status );
+}
+
+void WINAPI glVertex4dv( const GLdouble *v )
+{
+    struct glVertex4dv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex4dv, &args ))) WARN( "glVertex4dv returned %#x\n", status );
+}
+
+void WINAPI glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
+    struct glVertex4f_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %f, y %f, z %f, w %f\n", x, y, z, w );
+    if ((status = UNIX_CALL( glVertex4f, &args ))) WARN( "glVertex4f returned %#x\n", status );
+}
+
+void WINAPI glVertex4fv( const GLfloat *v )
+{
+    struct glVertex4fv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex4fv, &args ))) WARN( "glVertex4fv returned %#x\n", status );
+}
+
+void WINAPI glVertex4i( GLint x, GLint y, GLint z, GLint w )
+{
+    struct glVertex4i_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
+    if ((status = UNIX_CALL( glVertex4i, &args ))) WARN( "glVertex4i returned %#x\n", status );
+}
+
+void WINAPI glVertex4iv( const GLint *v )
+{
+    struct glVertex4iv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex4iv, &args ))) WARN( "glVertex4iv returned %#x\n", status );
+}
+
+void WINAPI glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
+{
+    struct glVertex4s_params args = { .x = x, .y = y, .z = z, .w = w, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, z %d, w %d\n", x, y, z, w );
+    if ((status = UNIX_CALL( glVertex4s, &args ))) WARN( "glVertex4s returned %#x\n", status );
+}
+
+void WINAPI glVertex4sv( const GLshort *v )
+{
+    struct glVertex4sv_params args = { .v = v, };
+    NTSTATUS status;
+    TRACE( "v %p\n", v );
+    if ((status = UNIX_CALL( glVertex4sv, &args ))) WARN( "glVertex4sv returned %#x\n", status );
+}
+
+void WINAPI glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
+    struct glVertexPointer_params args = { .size = size, .type = type, .stride = stride, .pointer = pointer, };
+    NTSTATUS status;
+    TRACE( "size %d, type %d, stride %d, pointer %p\n", size, type, stride, pointer );
+    if ((status = UNIX_CALL( glVertexPointer, &args ))) WARN( "glVertexPointer returned %#x\n", status );
+}
+
+void WINAPI glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
+{
+    struct glViewport_params args = { .x = x, .y = y, .width = width, .height = height, };
+    NTSTATUS status;
+    TRACE( "x %d, y %d, width %d, height %d\n", x, y, width, height );
+    if ((status = UNIX_CALL( glViewport, &args ))) WARN( "glViewport returned %#x\n", status );
+}
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
new file mode 100644
index 00000000000..45bff7f40c0
--- /dev/null
+++ b/dlls/opengl32/unix_thunks.c
@@ -0,0 +1,3013 @@
+/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+
+#include "unixlib.h"
+
+#include "opengl_ext.h"
+
+static NTSTATUS gl_glAccum( void *args )
+{
+    struct glAccum_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glAccum( params->op, params->value );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glAlphaFunc( void *args )
+{
+    struct glAlphaFunc_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glAlphaFunc( params->func, params->ref );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glAreTexturesResident( void *args )
+{
+    struct glAreTexturesResident_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glAreTexturesResident( params->n, params->textures, params->residences );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glArrayElement( void *args )
+{
+    struct glArrayElement_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glArrayElement( params->i );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glBegin( void *args )
+{
+    struct glBegin_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glBegin( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glBindTexture( void *args )
+{
+    struct glBindTexture_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glBindTexture( params->target, params->texture );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glBitmap( void *args )
+{
+    struct glBitmap_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glBitmap( params->width, params->height, params->xorig, params->yorig, params->xmove, params->ymove, params->bitmap );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glBlendFunc( void *args )
+{
+    struct glBlendFunc_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glBlendFunc( params->sfactor, params->dfactor );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCallList( void *args )
+{
+    struct glCallList_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCallList( params->list );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCallLists( void *args )
+{
+    struct glCallLists_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCallLists( params->n, params->type, params->lists );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClear( void *args )
+{
+    struct glClear_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClear( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClearAccum( void *args )
+{
+    struct glClearAccum_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClearAccum( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClearColor( void *args )
+{
+    struct glClearColor_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClearColor( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClearDepth( void *args )
+{
+    struct glClearDepth_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClearDepth( params->depth );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClearIndex( void *args )
+{
+    struct glClearIndex_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClearIndex( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClearStencil( void *args )
+{
+    struct glClearStencil_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClearStencil( params->s );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glClipPlane( void *args )
+{
+    struct glClipPlane_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glClipPlane( params->plane, params->equation );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3b( void *args )
+{
+    struct glColor3b_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3b( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3bv( void *args )
+{
+    struct glColor3bv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3bv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3d( void *args )
+{
+    struct glColor3d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3d( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3dv( void *args )
+{
+    struct glColor3dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3f( void *args )
+{
+    struct glColor3f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3f( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3fv( void *args )
+{
+    struct glColor3fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3i( void *args )
+{
+    struct glColor3i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3i( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3iv( void *args )
+{
+    struct glColor3iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3s( void *args )
+{
+    struct glColor3s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3s( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3sv( void *args )
+{
+    struct glColor3sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3ub( void *args )
+{
+    struct glColor3ub_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3ub( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3ubv( void *args )
+{
+    struct glColor3ubv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3ubv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3ui( void *args )
+{
+    struct glColor3ui_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3ui( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3uiv( void *args )
+{
+    struct glColor3uiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3uiv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3us( void *args )
+{
+    struct glColor3us_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3us( params->red, params->green, params->blue );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor3usv( void *args )
+{
+    struct glColor3usv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor3usv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4b( void *args )
+{
+    struct glColor4b_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4b( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4bv( void *args )
+{
+    struct glColor4bv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4bv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4d( void *args )
+{
+    struct glColor4d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4d( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4dv( void *args )
+{
+    struct glColor4dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4f( void *args )
+{
+    struct glColor4f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4f( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4fv( void *args )
+{
+    struct glColor4fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4i( void *args )
+{
+    struct glColor4i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4i( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4iv( void *args )
+{
+    struct glColor4iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4s( void *args )
+{
+    struct glColor4s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4s( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4sv( void *args )
+{
+    struct glColor4sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4ub( void *args )
+{
+    struct glColor4ub_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4ub( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4ubv( void *args )
+{
+    struct glColor4ubv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4ubv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4ui( void *args )
+{
+    struct glColor4ui_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4ui( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4uiv( void *args )
+{
+    struct glColor4uiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4uiv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4us( void *args )
+{
+    struct glColor4us_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4us( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColor4usv( void *args )
+{
+    struct glColor4usv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColor4usv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColorMask( void *args )
+{
+    struct glColorMask_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColorMask( params->red, params->green, params->blue, params->alpha );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColorMaterial( void *args )
+{
+    struct glColorMaterial_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColorMaterial( params->face, params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glColorPointer( void *args )
+{
+    struct glColorPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glColorPointer( params->size, params->type, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCopyPixels( void *args )
+{
+    struct glCopyPixels_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCopyPixels( params->x, params->y, params->width, params->height, params->type );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCopyTexImage1D( void *args )
+{
+    struct glCopyTexImage1D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCopyTexImage1D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->border );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCopyTexImage2D( void *args )
+{
+    struct glCopyTexImage2D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCopyTexImage2D( params->target, params->level, params->internalformat, params->x, params->y, params->width, params->height, params->border );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCopyTexSubImage1D( void *args )
+{
+    struct glCopyTexSubImage1D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCopyTexSubImage1D( params->target, params->level, params->xoffset, params->x, params->y, params->width );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCopyTexSubImage2D( void *args )
+{
+    struct glCopyTexSubImage2D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCopyTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->x, params->y, params->width, params->height );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glCullFace( void *args )
+{
+    struct glCullFace_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glCullFace( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDeleteLists( void *args )
+{
+    struct glDeleteLists_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDeleteLists( params->list, params->range );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDeleteTextures( void *args )
+{
+    struct glDeleteTextures_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDeleteTextures( params->n, params->textures );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDepthFunc( void *args )
+{
+    struct glDepthFunc_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDepthFunc( params->func );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDepthMask( void *args )
+{
+    struct glDepthMask_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDepthMask( params->flag );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDepthRange( void *args )
+{
+    struct glDepthRange_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDepthRange( params->n, params->f );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDisable( void *args )
+{
+    struct glDisable_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDisable( params->cap );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDisableClientState( void *args )
+{
+    struct glDisableClientState_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDisableClientState( params->array );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDrawArrays( void *args )
+{
+    struct glDrawArrays_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDrawArrays( params->mode, params->first, params->count );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDrawBuffer( void *args )
+{
+    struct glDrawBuffer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDrawBuffer( params->buf );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDrawElements( void *args )
+{
+    struct glDrawElements_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDrawElements( params->mode, params->count, params->type, params->indices );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glDrawPixels( void *args )
+{
+    struct glDrawPixels_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glDrawPixels( params->width, params->height, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEdgeFlag( void *args )
+{
+    struct glEdgeFlag_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEdgeFlag( params->flag );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEdgeFlagPointer( void *args )
+{
+    struct glEdgeFlagPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEdgeFlagPointer( params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEdgeFlagv( void *args )
+{
+    struct glEdgeFlagv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEdgeFlagv( params->flag );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEnable( void *args )
+{
+    struct glEnable_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEnable( params->cap );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEnableClientState( void *args )
+{
+    struct glEnableClientState_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEnableClientState( params->array );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEnd( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEnd();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEndList( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEndList();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord1d( void *args )
+{
+    struct glEvalCoord1d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord1d( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord1dv( void *args )
+{
+    struct glEvalCoord1dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord1dv( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord1f( void *args )
+{
+    struct glEvalCoord1f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord1f( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord1fv( void *args )
+{
+    struct glEvalCoord1fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord1fv( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord2d( void *args )
+{
+    struct glEvalCoord2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord2d( params->u, params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord2dv( void *args )
+{
+    struct glEvalCoord2dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord2dv( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord2f( void *args )
+{
+    struct glEvalCoord2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord2f( params->u, params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalCoord2fv( void *args )
+{
+    struct glEvalCoord2fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalCoord2fv( params->u );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalMesh1( void *args )
+{
+    struct glEvalMesh1_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalMesh1( params->mode, params->i1, params->i2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalMesh2( void *args )
+{
+    struct glEvalMesh2_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalMesh2( params->mode, params->i1, params->i2, params->j1, params->j2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalPoint1( void *args )
+{
+    struct glEvalPoint1_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalPoint1( params->i );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glEvalPoint2( void *args )
+{
+    struct glEvalPoint2_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glEvalPoint2( params->i, params->j );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFeedbackBuffer( void *args )
+{
+    struct glFeedbackBuffer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFeedbackBuffer( params->size, params->type, params->buffer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFinish( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFinish();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFlush( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFlush();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFogf( void *args )
+{
+    struct glFogf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFogf( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFogfv( void *args )
+{
+    struct glFogfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFogfv( params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFogi( void *args )
+{
+    struct glFogi_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFogi( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFogiv( void *args )
+{
+    struct glFogiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFogiv( params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFrontFace( void *args )
+{
+    struct glFrontFace_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFrontFace( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glFrustum( void *args )
+{
+    struct glFrustum_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glFrustum( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGenLists( void *args )
+{
+    struct glGenLists_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glGenLists( params->range );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGenTextures( void *args )
+{
+    struct glGenTextures_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGenTextures( params->n, params->textures );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetBooleanv( void *args )
+{
+    struct glGetBooleanv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetBooleanv( params->pname, params->data );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetClipPlane( void *args )
+{
+    struct glGetClipPlane_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetClipPlane( params->plane, params->equation );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetDoublev( void *args )
+{
+    struct glGetDoublev_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetDoublev( params->pname, params->data );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetError( void *args )
+{
+    struct glGetError_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glGetError();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetFloatv( void *args )
+{
+    struct glGetFloatv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetFloatv( params->pname, params->data );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetLightfv( void *args )
+{
+    struct glGetLightfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetLightfv( params->light, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetLightiv( void *args )
+{
+    struct glGetLightiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetLightiv( params->light, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetMapdv( void *args )
+{
+    struct glGetMapdv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetMapdv( params->target, params->query, params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetMapfv( void *args )
+{
+    struct glGetMapfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetMapfv( params->target, params->query, params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetMapiv( void *args )
+{
+    struct glGetMapiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetMapiv( params->target, params->query, params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetMaterialfv( void *args )
+{
+    struct glGetMaterialfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetMaterialfv( params->face, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetMaterialiv( void *args )
+{
+    struct glGetMaterialiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetMaterialiv( params->face, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetPixelMapfv( void *args )
+{
+    struct glGetPixelMapfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetPixelMapfv( params->map, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetPixelMapuiv( void *args )
+{
+    struct glGetPixelMapuiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetPixelMapuiv( params->map, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetPixelMapusv( void *args )
+{
+    struct glGetPixelMapusv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetPixelMapusv( params->map, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetPointerv( void *args )
+{
+    struct glGetPointerv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetPointerv( params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetPolygonStipple( void *args )
+{
+    struct glGetPolygonStipple_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetPolygonStipple( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexEnvfv( void *args )
+{
+    struct glGetTexEnvfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexEnvfv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexEnviv( void *args )
+{
+    struct glGetTexEnviv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexEnviv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexGendv( void *args )
+{
+    struct glGetTexGendv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexGendv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexGenfv( void *args )
+{
+    struct glGetTexGenfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexGenfv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexGeniv( void *args )
+{
+    struct glGetTexGeniv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexGeniv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexImage( void *args )
+{
+    struct glGetTexImage_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexImage( params->target, params->level, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexLevelParameterfv( void *args )
+{
+    struct glGetTexLevelParameterfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexLevelParameterfv( params->target, params->level, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexLevelParameteriv( void *args )
+{
+    struct glGetTexLevelParameteriv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexLevelParameteriv( params->target, params->level, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexParameterfv( void *args )
+{
+    struct glGetTexParameterfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexParameterfv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glGetTexParameteriv( void *args )
+{
+    struct glGetTexParameteriv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glGetTexParameteriv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glHint( void *args )
+{
+    struct glHint_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glHint( params->target, params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexMask( void *args )
+{
+    struct glIndexMask_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexMask( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexPointer( void *args )
+{
+    struct glIndexPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexPointer( params->type, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexd( void *args )
+{
+    struct glIndexd_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexd( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexdv( void *args )
+{
+    struct glIndexdv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexdv( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexf( void *args )
+{
+    struct glIndexf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexf( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexfv( void *args )
+{
+    struct glIndexfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexfv( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexi( void *args )
+{
+    struct glIndexi_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexi( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexiv( void *args )
+{
+    struct glIndexiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexiv( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexs( void *args )
+{
+    struct glIndexs_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexs( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexsv( void *args )
+{
+    struct glIndexsv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexsv( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexub( void *args )
+{
+    struct glIndexub_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexub( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIndexubv( void *args )
+{
+    struct glIndexubv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glIndexubv( params->c );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glInitNames( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glInitNames();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glInterleavedArrays( void *args )
+{
+    struct glInterleavedArrays_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glInterleavedArrays( params->format, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIsEnabled( void *args )
+{
+    struct glIsEnabled_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glIsEnabled( params->cap );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIsList( void *args )
+{
+    struct glIsList_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glIsList( params->list );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glIsTexture( void *args )
+{
+    struct glIsTexture_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glIsTexture( params->texture );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightModelf( void *args )
+{
+    struct glLightModelf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightModelf( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightModelfv( void *args )
+{
+    struct glLightModelfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightModelfv( params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightModeli( void *args )
+{
+    struct glLightModeli_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightModeli( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightModeliv( void *args )
+{
+    struct glLightModeliv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightModeliv( params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightf( void *args )
+{
+    struct glLightf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightf( params->light, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightfv( void *args )
+{
+    struct glLightfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightfv( params->light, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLighti( void *args )
+{
+    struct glLighti_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLighti( params->light, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLightiv( void *args )
+{
+    struct glLightiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLightiv( params->light, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLineStipple( void *args )
+{
+    struct glLineStipple_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLineStipple( params->factor, params->pattern );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLineWidth( void *args )
+{
+    struct glLineWidth_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLineWidth( params->width );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glListBase( void *args )
+{
+    struct glListBase_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glListBase( params->base );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLoadIdentity( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLoadIdentity();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLoadMatrixd( void *args )
+{
+    struct glLoadMatrixd_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLoadMatrixd( params->m );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLoadMatrixf( void *args )
+{
+    struct glLoadMatrixf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLoadMatrixf( params->m );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLoadName( void *args )
+{
+    struct glLoadName_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLoadName( params->name );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glLogicOp( void *args )
+{
+    struct glLogicOp_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glLogicOp( params->opcode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMap1d( void *args )
+{
+    struct glMap1d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMap1d( params->target, params->u1, params->u2, params->stride, params->order, params->points );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMap1f( void *args )
+{
+    struct glMap1f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMap1f( params->target, params->u1, params->u2, params->stride, params->order, params->points );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMap2d( void *args )
+{
+    struct glMap2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMap2d( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMap2f( void *args )
+{
+    struct glMap2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMap2f( params->target, params->u1, params->u2, params->ustride, params->uorder, params->v1, params->v2, params->vstride, params->vorder, params->points );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMapGrid1d( void *args )
+{
+    struct glMapGrid1d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMapGrid1d( params->un, params->u1, params->u2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMapGrid1f( void *args )
+{
+    struct glMapGrid1f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMapGrid1f( params->un, params->u1, params->u2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMapGrid2d( void *args )
+{
+    struct glMapGrid2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMapGrid2d( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMapGrid2f( void *args )
+{
+    struct glMapGrid2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMapGrid2f( params->un, params->u1, params->u2, params->vn, params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMaterialf( void *args )
+{
+    struct glMaterialf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMaterialf( params->face, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMaterialfv( void *args )
+{
+    struct glMaterialfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMaterialfv( params->face, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMateriali( void *args )
+{
+    struct glMateriali_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMateriali( params->face, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMaterialiv( void *args )
+{
+    struct glMaterialiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMaterialiv( params->face, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMatrixMode( void *args )
+{
+    struct glMatrixMode_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMatrixMode( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMultMatrixd( void *args )
+{
+    struct glMultMatrixd_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMultMatrixd( params->m );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glMultMatrixf( void *args )
+{
+    struct glMultMatrixf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glMultMatrixf( params->m );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNewList( void *args )
+{
+    struct glNewList_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNewList( params->list, params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3b( void *args )
+{
+    struct glNormal3b_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3b( params->nx, params->ny, params->nz );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3bv( void *args )
+{
+    struct glNormal3bv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3bv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3d( void *args )
+{
+    struct glNormal3d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3d( params->nx, params->ny, params->nz );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3dv( void *args )
+{
+    struct glNormal3dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3f( void *args )
+{
+    struct glNormal3f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3f( params->nx, params->ny, params->nz );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3fv( void *args )
+{
+    struct glNormal3fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3i( void *args )
+{
+    struct glNormal3i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3i( params->nx, params->ny, params->nz );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3iv( void *args )
+{
+    struct glNormal3iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3s( void *args )
+{
+    struct glNormal3s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3s( params->nx, params->ny, params->nz );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormal3sv( void *args )
+{
+    struct glNormal3sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormal3sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glNormalPointer( void *args )
+{
+    struct glNormalPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glNormalPointer( params->type, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glOrtho( void *args )
+{
+    struct glOrtho_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glOrtho( params->left, params->right, params->bottom, params->top, params->zNear, params->zFar );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPassThrough( void *args )
+{
+    struct glPassThrough_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPassThrough( params->token );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelMapfv( void *args )
+{
+    struct glPixelMapfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelMapfv( params->map, params->mapsize, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelMapuiv( void *args )
+{
+    struct glPixelMapuiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelMapuiv( params->map, params->mapsize, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelMapusv( void *args )
+{
+    struct glPixelMapusv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelMapusv( params->map, params->mapsize, params->values );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelStoref( void *args )
+{
+    struct glPixelStoref_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelStoref( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelStorei( void *args )
+{
+    struct glPixelStorei_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelStorei( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelTransferf( void *args )
+{
+    struct glPixelTransferf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelTransferf( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelTransferi( void *args )
+{
+    struct glPixelTransferi_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelTransferi( params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPixelZoom( void *args )
+{
+    struct glPixelZoom_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPixelZoom( params->xfactor, params->yfactor );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPointSize( void *args )
+{
+    struct glPointSize_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPointSize( params->size );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPolygonMode( void *args )
+{
+    struct glPolygonMode_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPolygonMode( params->face, params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPolygonOffset( void *args )
+{
+    struct glPolygonOffset_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPolygonOffset( params->factor, params->units );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPolygonStipple( void *args )
+{
+    struct glPolygonStipple_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPolygonStipple( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPopAttrib( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPopAttrib();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPopClientAttrib( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPopClientAttrib();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPopMatrix( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPopMatrix();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPopName( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPopName();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPrioritizeTextures( void *args )
+{
+    struct glPrioritizeTextures_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPrioritizeTextures( params->n, params->textures, params->priorities );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPushAttrib( void *args )
+{
+    struct glPushAttrib_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPushAttrib( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPushClientAttrib( void *args )
+{
+    struct glPushClientAttrib_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPushClientAttrib( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPushMatrix( void *args )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPushMatrix();
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glPushName( void *args )
+{
+    struct glPushName_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glPushName( params->name );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2d( void *args )
+{
+    struct glRasterPos2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2d( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2dv( void *args )
+{
+    struct glRasterPos2dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2f( void *args )
+{
+    struct glRasterPos2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2f( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2fv( void *args )
+{
+    struct glRasterPos2fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2i( void *args )
+{
+    struct glRasterPos2i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2i( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2iv( void *args )
+{
+    struct glRasterPos2iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2s( void *args )
+{
+    struct glRasterPos2s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2s( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos2sv( void *args )
+{
+    struct glRasterPos2sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos2sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3d( void *args )
+{
+    struct glRasterPos3d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3d( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3dv( void *args )
+{
+    struct glRasterPos3dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3f( void *args )
+{
+    struct glRasterPos3f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3f( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3fv( void *args )
+{
+    struct glRasterPos3fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3i( void *args )
+{
+    struct glRasterPos3i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3i( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3iv( void *args )
+{
+    struct glRasterPos3iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3s( void *args )
+{
+    struct glRasterPos3s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3s( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos3sv( void *args )
+{
+    struct glRasterPos3sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos3sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4d( void *args )
+{
+    struct glRasterPos4d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4d( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4dv( void *args )
+{
+    struct glRasterPos4dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4f( void *args )
+{
+    struct glRasterPos4f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4f( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4fv( void *args )
+{
+    struct glRasterPos4fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4i( void *args )
+{
+    struct glRasterPos4i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4i( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4iv( void *args )
+{
+    struct glRasterPos4iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4s( void *args )
+{
+    struct glRasterPos4s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4s( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRasterPos4sv( void *args )
+{
+    struct glRasterPos4sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRasterPos4sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glReadBuffer( void *args )
+{
+    struct glReadBuffer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glReadBuffer( params->src );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glReadPixels( void *args )
+{
+    struct glReadPixels_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glReadPixels( params->x, params->y, params->width, params->height, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectd( void *args )
+{
+    struct glRectd_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectd( params->x1, params->y1, params->x2, params->y2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectdv( void *args )
+{
+    struct glRectdv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectdv( params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectf( void *args )
+{
+    struct glRectf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectf( params->x1, params->y1, params->x2, params->y2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectfv( void *args )
+{
+    struct glRectfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectfv( params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRecti( void *args )
+{
+    struct glRecti_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRecti( params->x1, params->y1, params->x2, params->y2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectiv( void *args )
+{
+    struct glRectiv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectiv( params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRects( void *args )
+{
+    struct glRects_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRects( params->x1, params->y1, params->x2, params->y2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRectsv( void *args )
+{
+    struct glRectsv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRectsv( params->v1, params->v2 );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRenderMode( void *args )
+{
+    struct glRenderMode_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    params->ret = funcs->gl.p_glRenderMode( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRotated( void *args )
+{
+    struct glRotated_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRotated( params->angle, params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glRotatef( void *args )
+{
+    struct glRotatef_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glRotatef( params->angle, params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glScaled( void *args )
+{
+    struct glScaled_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glScaled( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glScalef( void *args )
+{
+    struct glScalef_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glScalef( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glScissor( void *args )
+{
+    struct glScissor_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glScissor( params->x, params->y, params->width, params->height );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glSelectBuffer( void *args )
+{
+    struct glSelectBuffer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glSelectBuffer( params->size, params->buffer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glShadeModel( void *args )
+{
+    struct glShadeModel_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glShadeModel( params->mode );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glStencilFunc( void *args )
+{
+    struct glStencilFunc_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glStencilFunc( params->func, params->ref, params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glStencilMask( void *args )
+{
+    struct glStencilMask_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glStencilMask( params->mask );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glStencilOp( void *args )
+{
+    struct glStencilOp_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glStencilOp( params->fail, params->zfail, params->zpass );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1d( void *args )
+{
+    struct glTexCoord1d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1d( params->s );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1dv( void *args )
+{
+    struct glTexCoord1dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1f( void *args )
+{
+    struct glTexCoord1f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1f( params->s );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1fv( void *args )
+{
+    struct glTexCoord1fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1i( void *args )
+{
+    struct glTexCoord1i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1i( params->s );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1iv( void *args )
+{
+    struct glTexCoord1iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1s( void *args )
+{
+    struct glTexCoord1s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1s( params->s );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord1sv( void *args )
+{
+    struct glTexCoord1sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord1sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2d( void *args )
+{
+    struct glTexCoord2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2d( params->s, params->t );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2dv( void *args )
+{
+    struct glTexCoord2dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2f( void *args )
+{
+    struct glTexCoord2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2f( params->s, params->t );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2fv( void *args )
+{
+    struct glTexCoord2fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2i( void *args )
+{
+    struct glTexCoord2i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2i( params->s, params->t );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2iv( void *args )
+{
+    struct glTexCoord2iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2s( void *args )
+{
+    struct glTexCoord2s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2s( params->s, params->t );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord2sv( void *args )
+{
+    struct glTexCoord2sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord2sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3d( void *args )
+{
+    struct glTexCoord3d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3d( params->s, params->t, params->r );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3dv( void *args )
+{
+    struct glTexCoord3dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3f( void *args )
+{
+    struct glTexCoord3f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3f( params->s, params->t, params->r );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3fv( void *args )
+{
+    struct glTexCoord3fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3i( void *args )
+{
+    struct glTexCoord3i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3i( params->s, params->t, params->r );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3iv( void *args )
+{
+    struct glTexCoord3iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3s( void *args )
+{
+    struct glTexCoord3s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3s( params->s, params->t, params->r );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord3sv( void *args )
+{
+    struct glTexCoord3sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord3sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4d( void *args )
+{
+    struct glTexCoord4d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4d( params->s, params->t, params->r, params->q );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4dv( void *args )
+{
+    struct glTexCoord4dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4f( void *args )
+{
+    struct glTexCoord4f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4f( params->s, params->t, params->r, params->q );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4fv( void *args )
+{
+    struct glTexCoord4fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4i( void *args )
+{
+    struct glTexCoord4i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4i( params->s, params->t, params->r, params->q );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4iv( void *args )
+{
+    struct glTexCoord4iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4s( void *args )
+{
+    struct glTexCoord4s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4s( params->s, params->t, params->r, params->q );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoord4sv( void *args )
+{
+    struct glTexCoord4sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoord4sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexCoordPointer( void *args )
+{
+    struct glTexCoordPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexCoordPointer( params->size, params->type, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexEnvf( void *args )
+{
+    struct glTexEnvf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexEnvf( params->target, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexEnvfv( void *args )
+{
+    struct glTexEnvfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexEnvfv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexEnvi( void *args )
+{
+    struct glTexEnvi_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexEnvi( params->target, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexEnviv( void *args )
+{
+    struct glTexEnviv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexEnviv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGend( void *args )
+{
+    struct glTexGend_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGend( params->coord, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGendv( void *args )
+{
+    struct glTexGendv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGendv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGenf( void *args )
+{
+    struct glTexGenf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGenf( params->coord, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGenfv( void *args )
+{
+    struct glTexGenfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGenfv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGeni( void *args )
+{
+    struct glTexGeni_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGeni( params->coord, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexGeniv( void *args )
+{
+    struct glTexGeniv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexGeniv( params->coord, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexImage1D( void *args )
+{
+    struct glTexImage1D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexImage1D( params->target, params->level, params->internalformat, params->width, params->border, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexImage2D( void *args )
+{
+    struct glTexImage2D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexImage2D( params->target, params->level, params->internalformat, params->width, params->height, params->border, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexParameterf( void *args )
+{
+    struct glTexParameterf_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexParameterf( params->target, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexParameterfv( void *args )
+{
+    struct glTexParameterfv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexParameterfv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexParameteri( void *args )
+{
+    struct glTexParameteri_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexParameteri( params->target, params->pname, params->param );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexParameteriv( void *args )
+{
+    struct glTexParameteriv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexParameteriv( params->target, params->pname, params->params );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexSubImage1D( void *args )
+{
+    struct glTexSubImage1D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexSubImage1D( params->target, params->level, params->xoffset, params->width, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTexSubImage2D( void *args )
+{
+    struct glTexSubImage2D_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTexSubImage2D( params->target, params->level, params->xoffset, params->yoffset, params->width, params->height, params->format, params->type, params->pixels );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTranslated( void *args )
+{
+    struct glTranslated_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTranslated( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glTranslatef( void *args )
+{
+    struct glTranslatef_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glTranslatef( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2d( void *args )
+{
+    struct glVertex2d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2d( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2dv( void *args )
+{
+    struct glVertex2dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2f( void *args )
+{
+    struct glVertex2f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2f( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2fv( void *args )
+{
+    struct glVertex2fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2i( void *args )
+{
+    struct glVertex2i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2i( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2iv( void *args )
+{
+    struct glVertex2iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2s( void *args )
+{
+    struct glVertex2s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2s( params->x, params->y );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex2sv( void *args )
+{
+    struct glVertex2sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex2sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3d( void *args )
+{
+    struct glVertex3d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3d( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3dv( void *args )
+{
+    struct glVertex3dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3f( void *args )
+{
+    struct glVertex3f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3f( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3fv( void *args )
+{
+    struct glVertex3fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3i( void *args )
+{
+    struct glVertex3i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3i( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3iv( void *args )
+{
+    struct glVertex3iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3s( void *args )
+{
+    struct glVertex3s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3s( params->x, params->y, params->z );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex3sv( void *args )
+{
+    struct glVertex3sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex3sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4d( void *args )
+{
+    struct glVertex4d_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4d( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4dv( void *args )
+{
+    struct glVertex4dv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4dv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4f( void *args )
+{
+    struct glVertex4f_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4f( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4fv( void *args )
+{
+    struct glVertex4fv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4fv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4i( void *args )
+{
+    struct glVertex4i_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4i( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4iv( void *args )
+{
+    struct glVertex4iv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4iv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4s( void *args )
+{
+    struct glVertex4s_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4s( params->x, params->y, params->z, params->w );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertex4sv( void *args )
+{
+    struct glVertex4sv_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertex4sv( params->v );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glVertexPointer( void *args )
+{
+    struct glVertexPointer_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glVertexPointer( params->size, params->type, params->stride, params->pointer );
+    return STATUS_SUCCESS;
+}
+
+static NTSTATUS gl_glViewport( void *args )
+{
+    struct glViewport_params *params = args;
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    funcs->gl.p_glViewport( params->x, params->y, params->width, params->height );
+    return STATUS_SUCCESS;
+}
+
+const unixlib_function_t __wine_unix_call_funcs[] =
+{
+    &gl_glAccum,
+    &gl_glAlphaFunc,
+    &gl_glAreTexturesResident,
+    &gl_glArrayElement,
+    &gl_glBegin,
+    &gl_glBindTexture,
+    &gl_glBitmap,
+    &gl_glBlendFunc,
+    &gl_glCallList,
+    &gl_glCallLists,
+    &gl_glClear,
+    &gl_glClearAccum,
+    &gl_glClearColor,
+    &gl_glClearDepth,
+    &gl_glClearIndex,
+    &gl_glClearStencil,
+    &gl_glClipPlane,
+    &gl_glColor3b,
+    &gl_glColor3bv,
+    &gl_glColor3d,
+    &gl_glColor3dv,
+    &gl_glColor3f,
+    &gl_glColor3fv,
+    &gl_glColor3i,
+    &gl_glColor3iv,
+    &gl_glColor3s,
+    &gl_glColor3sv,
+    &gl_glColor3ub,
+    &gl_glColor3ubv,
+    &gl_glColor3ui,
+    &gl_glColor3uiv,
+    &gl_glColor3us,
+    &gl_glColor3usv,
+    &gl_glColor4b,
+    &gl_glColor4bv,
+    &gl_glColor4d,
+    &gl_glColor4dv,
+    &gl_glColor4f,
+    &gl_glColor4fv,
+    &gl_glColor4i,
+    &gl_glColor4iv,
+    &gl_glColor4s,
+    &gl_glColor4sv,
+    &gl_glColor4ub,
+    &gl_glColor4ubv,
+    &gl_glColor4ui,
+    &gl_glColor4uiv,
+    &gl_glColor4us,
+    &gl_glColor4usv,
+    &gl_glColorMask,
+    &gl_glColorMaterial,
+    &gl_glColorPointer,
+    &gl_glCopyPixels,
+    &gl_glCopyTexImage1D,
+    &gl_glCopyTexImage2D,
+    &gl_glCopyTexSubImage1D,
+    &gl_glCopyTexSubImage2D,
+    &gl_glCullFace,
+    &gl_glDeleteLists,
+    &gl_glDeleteTextures,
+    &gl_glDepthFunc,
+    &gl_glDepthMask,
+    &gl_glDepthRange,
+    &gl_glDisable,
+    &gl_glDisableClientState,
+    &gl_glDrawArrays,
+    &gl_glDrawBuffer,
+    &gl_glDrawElements,
+    &gl_glDrawPixels,
+    &gl_glEdgeFlag,
+    &gl_glEdgeFlagPointer,
+    &gl_glEdgeFlagv,
+    &gl_glEnable,
+    &gl_glEnableClientState,
+    &gl_glEnd,
+    &gl_glEndList,
+    &gl_glEvalCoord1d,
+    &gl_glEvalCoord1dv,
+    &gl_glEvalCoord1f,
+    &gl_glEvalCoord1fv,
+    &gl_glEvalCoord2d,
+    &gl_glEvalCoord2dv,
+    &gl_glEvalCoord2f,
+    &gl_glEvalCoord2fv,
+    &gl_glEvalMesh1,
+    &gl_glEvalMesh2,
+    &gl_glEvalPoint1,
+    &gl_glEvalPoint2,
+    &gl_glFeedbackBuffer,
+    &gl_glFinish,
+    &gl_glFlush,
+    &gl_glFogf,
+    &gl_glFogfv,
+    &gl_glFogi,
+    &gl_glFogiv,
+    &gl_glFrontFace,
+    &gl_glFrustum,
+    &gl_glGenLists,
+    &gl_glGenTextures,
+    &gl_glGetBooleanv,
+    &gl_glGetClipPlane,
+    &gl_glGetDoublev,
+    &gl_glGetError,
+    &gl_glGetFloatv,
+    &gl_glGetLightfv,
+    &gl_glGetLightiv,
+    &gl_glGetMapdv,
+    &gl_glGetMapfv,
+    &gl_glGetMapiv,
+    &gl_glGetMaterialfv,
+    &gl_glGetMaterialiv,
+    &gl_glGetPixelMapfv,
+    &gl_glGetPixelMapuiv,
+    &gl_glGetPixelMapusv,
+    &gl_glGetPointerv,
+    &gl_glGetPolygonStipple,
+    &gl_glGetTexEnvfv,
+    &gl_glGetTexEnviv,
+    &gl_glGetTexGendv,
+    &gl_glGetTexGenfv,
+    &gl_glGetTexGeniv,
+    &gl_glGetTexImage,
+    &gl_glGetTexLevelParameterfv,
+    &gl_glGetTexLevelParameteriv,
+    &gl_glGetTexParameterfv,
+    &gl_glGetTexParameteriv,
+    &gl_glHint,
+    &gl_glIndexMask,
+    &gl_glIndexPointer,
+    &gl_glIndexd,
+    &gl_glIndexdv,
+    &gl_glIndexf,
+    &gl_glIndexfv,
+    &gl_glIndexi,
+    &gl_glIndexiv,
+    &gl_glIndexs,
+    &gl_glIndexsv,
+    &gl_glIndexub,
+    &gl_glIndexubv,
+    &gl_glInitNames,
+    &gl_glInterleavedArrays,
+    &gl_glIsEnabled,
+    &gl_glIsList,
+    &gl_glIsTexture,
+    &gl_glLightModelf,
+    &gl_glLightModelfv,
+    &gl_glLightModeli,
+    &gl_glLightModeliv,
+    &gl_glLightf,
+    &gl_glLightfv,
+    &gl_glLighti,
+    &gl_glLightiv,
+    &gl_glLineStipple,
+    &gl_glLineWidth,
+    &gl_glListBase,
+    &gl_glLoadIdentity,
+    &gl_glLoadMatrixd,
+    &gl_glLoadMatrixf,
+    &gl_glLoadName,
+    &gl_glLogicOp,
+    &gl_glMap1d,
+    &gl_glMap1f,
+    &gl_glMap2d,
+    &gl_glMap2f,
+    &gl_glMapGrid1d,
+    &gl_glMapGrid1f,
+    &gl_glMapGrid2d,
+    &gl_glMapGrid2f,
+    &gl_glMaterialf,
+    &gl_glMaterialfv,
+    &gl_glMateriali,
+    &gl_glMaterialiv,
+    &gl_glMatrixMode,
+    &gl_glMultMatrixd,
+    &gl_glMultMatrixf,
+    &gl_glNewList,
+    &gl_glNormal3b,
+    &gl_glNormal3bv,
+    &gl_glNormal3d,
+    &gl_glNormal3dv,
+    &gl_glNormal3f,
+    &gl_glNormal3fv,
+    &gl_glNormal3i,
+    &gl_glNormal3iv,
+    &gl_glNormal3s,
+    &gl_glNormal3sv,
+    &gl_glNormalPointer,
+    &gl_glOrtho,
+    &gl_glPassThrough,
+    &gl_glPixelMapfv,
+    &gl_glPixelMapuiv,
+    &gl_glPixelMapusv,
+    &gl_glPixelStoref,
+    &gl_glPixelStorei,
+    &gl_glPixelTransferf,
+    &gl_glPixelTransferi,
+    &gl_glPixelZoom,
+    &gl_glPointSize,
+    &gl_glPolygonMode,
+    &gl_glPolygonOffset,
+    &gl_glPolygonStipple,
+    &gl_glPopAttrib,
+    &gl_glPopClientAttrib,
+    &gl_glPopMatrix,
+    &gl_glPopName,
+    &gl_glPrioritizeTextures,
+    &gl_glPushAttrib,
+    &gl_glPushClientAttrib,
+    &gl_glPushMatrix,
+    &gl_glPushName,
+    &gl_glRasterPos2d,
+    &gl_glRasterPos2dv,
+    &gl_glRasterPos2f,
+    &gl_glRasterPos2fv,
+    &gl_glRasterPos2i,
+    &gl_glRasterPos2iv,
+    &gl_glRasterPos2s,
+    &gl_glRasterPos2sv,
+    &gl_glRasterPos3d,
+    &gl_glRasterPos3dv,
+    &gl_glRasterPos3f,
+    &gl_glRasterPos3fv,
+    &gl_glRasterPos3i,
+    &gl_glRasterPos3iv,
+    &gl_glRasterPos3s,
+    &gl_glRasterPos3sv,
+    &gl_glRasterPos4d,
+    &gl_glRasterPos4dv,
+    &gl_glRasterPos4f,
+    &gl_glRasterPos4fv,
+    &gl_glRasterPos4i,
+    &gl_glRasterPos4iv,
+    &gl_glRasterPos4s,
+    &gl_glRasterPos4sv,
+    &gl_glReadBuffer,
+    &gl_glReadPixels,
+    &gl_glRectd,
+    &gl_glRectdv,
+    &gl_glRectf,
+    &gl_glRectfv,
+    &gl_glRecti,
+    &gl_glRectiv,
+    &gl_glRects,
+    &gl_glRectsv,
+    &gl_glRenderMode,
+    &gl_glRotated,
+    &gl_glRotatef,
+    &gl_glScaled,
+    &gl_glScalef,
+    &gl_glScissor,
+    &gl_glSelectBuffer,
+    &gl_glShadeModel,
+    &gl_glStencilFunc,
+    &gl_glStencilMask,
+    &gl_glStencilOp,
+    &gl_glTexCoord1d,
+    &gl_glTexCoord1dv,
+    &gl_glTexCoord1f,
+    &gl_glTexCoord1fv,
+    &gl_glTexCoord1i,
+    &gl_glTexCoord1iv,
+    &gl_glTexCoord1s,
+    &gl_glTexCoord1sv,
+    &gl_glTexCoord2d,
+    &gl_glTexCoord2dv,
+    &gl_glTexCoord2f,
+    &gl_glTexCoord2fv,
+    &gl_glTexCoord2i,
+    &gl_glTexCoord2iv,
+    &gl_glTexCoord2s,
+    &gl_glTexCoord2sv,
+    &gl_glTexCoord3d,
+    &gl_glTexCoord3dv,
+    &gl_glTexCoord3f,
+    &gl_glTexCoord3fv,
+    &gl_glTexCoord3i,
+    &gl_glTexCoord3iv,
+    &gl_glTexCoord3s,
+    &gl_glTexCoord3sv,
+    &gl_glTexCoord4d,
+    &gl_glTexCoord4dv,
+    &gl_glTexCoord4f,
+    &gl_glTexCoord4fv,
+    &gl_glTexCoord4i,
+    &gl_glTexCoord4iv,
+    &gl_glTexCoord4s,
+    &gl_glTexCoord4sv,
+    &gl_glTexCoordPointer,
+    &gl_glTexEnvf,
+    &gl_glTexEnvfv,
+    &gl_glTexEnvi,
+    &gl_glTexEnviv,
+    &gl_glTexGend,
+    &gl_glTexGendv,
+    &gl_glTexGenf,
+    &gl_glTexGenfv,
+    &gl_glTexGeni,
+    &gl_glTexGeniv,
+    &gl_glTexImage1D,
+    &gl_glTexImage2D,
+    &gl_glTexParameterf,
+    &gl_glTexParameterfv,
+    &gl_glTexParameteri,
+    &gl_glTexParameteriv,
+    &gl_glTexSubImage1D,
+    &gl_glTexSubImage2D,
+    &gl_glTranslated,
+    &gl_glTranslatef,
+    &gl_glVertex2d,
+    &gl_glVertex2dv,
+    &gl_glVertex2f,
+    &gl_glVertex2fv,
+    &gl_glVertex2i,
+    &gl_glVertex2iv,
+    &gl_glVertex2s,
+    &gl_glVertex2sv,
+    &gl_glVertex3d,
+    &gl_glVertex3dv,
+    &gl_glVertex3f,
+    &gl_glVertex3fv,
+    &gl_glVertex3i,
+    &gl_glVertex3iv,
+    &gl_glVertex3s,
+    &gl_glVertex3sv,
+    &gl_glVertex4d,
+    &gl_glVertex4dv,
+    &gl_glVertex4f,
+    &gl_glVertex4fv,
+    &gl_glVertex4i,
+    &gl_glVertex4iv,
+    &gl_glVertex4s,
+    &gl_glVertex4sv,
+    &gl_glVertexPointer,
+    &gl_glViewport,
+};
diff --git a/dlls/opengl32/unixlib.h b/dlls/opengl32/unixlib.h
new file mode 100644
index 00000000000..59de686daa7
--- /dev/null
+++ b/dlls/opengl32/unixlib.h
@@ -0,0 +1,2486 @@
+/* Automatically generated from http://www.opengl.org/registry files; DO NOT EDIT! */
+
+#ifndef __WINE_OPENGL32_UNIXLIB_H
+#define __WINE_OPENGL32_UNIXLIB_H
+
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "ntstatus.h"
+#define WIN32_NO_STATUS
+#include "windef.h"
+#include "winbase.h"
+#include "winternl.h"
+#include "wingdi.h"
+
+#include "wine/wgl.h"
+#include "wine/unixlib.h"
+
+struct glAccum_params
+{
+    GLenum op;
+    GLfloat value;
+};
+
+struct glAlphaFunc_params
+{
+    GLenum func;
+    GLfloat ref;
+};
+
+struct glAreTexturesResident_params
+{
+    GLsizei n;
+    const GLuint *textures;
+    GLboolean *residences;
+    GLboolean ret;
+};
+
+struct glArrayElement_params
+{
+    GLint i;
+};
+
+struct glBegin_params
+{
+    GLenum mode;
+};
+
+struct glBindTexture_params
+{
+    GLenum target;
+    GLuint texture;
+};
+
+struct glBitmap_params
+{
+    GLsizei width;
+    GLsizei height;
+    GLfloat xorig;
+    GLfloat yorig;
+    GLfloat xmove;
+    GLfloat ymove;
+    const GLubyte *bitmap;
+};
+
+struct glBlendFunc_params
+{
+    GLenum sfactor;
+    GLenum dfactor;
+};
+
+struct glCallList_params
+{
+    GLuint list;
+};
+
+struct glCallLists_params
+{
+    GLsizei n;
+    GLenum type;
+    const void *lists;
+};
+
+struct glClear_params
+{
+    GLbitfield mask;
+};
+
+struct glClearAccum_params
+{
+    GLfloat red;
+    GLfloat green;
+    GLfloat blue;
+    GLfloat alpha;
+};
+
+struct glClearColor_params
+{
+    GLfloat red;
+    GLfloat green;
+    GLfloat blue;
+    GLfloat alpha;
+};
+
+struct glClearDepth_params
+{
+    GLdouble depth;
+};
+
+struct glClearIndex_params
+{
+    GLfloat c;
+};
+
+struct glClearStencil_params
+{
+    GLint s;
+};
+
+struct glClipPlane_params
+{
+    GLenum plane;
+    const GLdouble *equation;
+};
+
+struct glColor3b_params
+{
+    GLbyte red;
+    GLbyte green;
+    GLbyte blue;
+};
+
+struct glColor3bv_params
+{
+    const GLbyte *v;
+};
+
+struct glColor3d_params
+{
+    GLdouble red;
+    GLdouble green;
+    GLdouble blue;
+};
+
+struct glColor3dv_params
+{
+    const GLdouble *v;
+};
+
+struct glColor3f_params
+{
+    GLfloat red;
+    GLfloat green;
+    GLfloat blue;
+};
+
+struct glColor3fv_params
+{
+    const GLfloat *v;
+};
+
+struct glColor3i_params
+{
+    GLint red;
+    GLint green;
+    GLint blue;
+};
+
+struct glColor3iv_params
+{
+    const GLint *v;
+};
+
+struct glColor3s_params
+{
+    GLshort red;
+    GLshort green;
+    GLshort blue;
+};
+
+struct glColor3sv_params
+{
+    const GLshort *v;
+};
+
+struct glColor3ub_params
+{
+    GLubyte red;
+    GLubyte green;
+    GLubyte blue;
+};
+
+struct glColor3ubv_params
+{
+    const GLubyte *v;
+};
+
+struct glColor3ui_params
+{
+    GLuint red;
+    GLuint green;
+    GLuint blue;
+};
+
+struct glColor3uiv_params
+{
+    const GLuint *v;
+};
+
+struct glColor3us_params
+{
+    GLushort red;
+    GLushort green;
+    GLushort blue;
+};
+
+struct glColor3usv_params
+{
+    const GLushort *v;
+};
+
+struct glColor4b_params
+{
+    GLbyte red;
+    GLbyte green;
+    GLbyte blue;
+    GLbyte alpha;
+};
+
+struct glColor4bv_params
+{
+    const GLbyte *v;
+};
+
+struct glColor4d_params
+{
+    GLdouble red;
+    GLdouble green;
+    GLdouble blue;
+    GLdouble alpha;
+};
+
+struct glColor4dv_params
+{
+    const GLdouble *v;
+};
+
+struct glColor4f_params
+{
+    GLfloat red;
+    GLfloat green;
+    GLfloat blue;
+    GLfloat alpha;
+};
+
+struct glColor4fv_params
+{
+    const GLfloat *v;
+};
+
+struct glColor4i_params
+{
+    GLint red;
+    GLint green;
+    GLint blue;
+    GLint alpha;
+};
+
+struct glColor4iv_params
+{
+    const GLint *v;
+};
+
+struct glColor4s_params
+{
+    GLshort red;
+    GLshort green;
+    GLshort blue;
+    GLshort alpha;
+};
+
+struct glColor4sv_params
+{
+    const GLshort *v;
+};
+
+struct glColor4ub_params
+{
+    GLubyte red;
+    GLubyte green;
+    GLubyte blue;
+    GLubyte alpha;
+};
+
+struct glColor4ubv_params
+{
+    const GLubyte *v;
+};
+
+struct glColor4ui_params
+{
+    GLuint red;
+    GLuint green;
+    GLuint blue;
+    GLuint alpha;
+};
+
+struct glColor4uiv_params
+{
+    const GLuint *v;
+};
+
+struct glColor4us_params
+{
+    GLushort red;
+    GLushort green;
+    GLushort blue;
+    GLushort alpha;
+};
+
+struct glColor4usv_params
+{
+    const GLushort *v;
+};
+
+struct glColorMask_params
+{
+    GLboolean red;
+    GLboolean green;
+    GLboolean blue;
+    GLboolean alpha;
+};
+
+struct glColorMaterial_params
+{
+    GLenum face;
+    GLenum mode;
+};
+
+struct glColorPointer_params
+{
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glCopyPixels_params
+{
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+    GLenum type;
+};
+
+struct glCopyTexImage1D_params
+{
+    GLenum target;
+    GLint level;
+    GLenum internalformat;
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLint border;
+};
+
+struct glCopyTexImage2D_params
+{
+    GLenum target;
+    GLint level;
+    GLenum internalformat;
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+    GLint border;
+};
+
+struct glCopyTexSubImage1D_params
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint x;
+    GLint y;
+    GLsizei width;
+};
+
+struct glCopyTexSubImage2D_params
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint yoffset;
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+};
+
+struct glCullFace_params
+{
+    GLenum mode;
+};
+
+struct glDeleteLists_params
+{
+    GLuint list;
+    GLsizei range;
+};
+
+struct glDeleteTextures_params
+{
+    GLsizei n;
+    const GLuint *textures;
+};
+
+struct glDepthFunc_params
+{
+    GLenum func;
+};
+
+struct glDepthMask_params
+{
+    GLboolean flag;
+};
+
+struct glDepthRange_params
+{
+    GLdouble n;
+    GLdouble f;
+};
+
+struct glDisable_params
+{
+    GLenum cap;
+};
+
+struct glDisableClientState_params
+{
+    GLenum array;
+};
+
+struct glDrawArrays_params
+{
+    GLenum mode;
+    GLint first;
+    GLsizei count;
+};
+
+struct glDrawBuffer_params
+{
+    GLenum buf;
+};
+
+struct glDrawElements_params
+{
+    GLenum mode;
+    GLsizei count;
+    GLenum type;
+    const void *indices;
+};
+
+struct glDrawPixels_params
+{
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+    const void *pixels;
+};
+
+struct glEdgeFlag_params
+{
+    GLboolean flag;
+};
+
+struct glEdgeFlagPointer_params
+{
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glEdgeFlagv_params
+{
+    const GLboolean *flag;
+};
+
+struct glEnable_params
+{
+    GLenum cap;
+};
+
+struct glEnableClientState_params
+{
+    GLenum array;
+};
+
+struct glEnd_params
+{
+};
+
+struct glEndList_params
+{
+};
+
+struct glEvalCoord1d_params
+{
+    GLdouble u;
+};
+
+struct glEvalCoord1dv_params
+{
+    const GLdouble *u;
+};
+
+struct glEvalCoord1f_params
+{
+    GLfloat u;
+};
+
+struct glEvalCoord1fv_params
+{
+    const GLfloat *u;
+};
+
+struct glEvalCoord2d_params
+{
+    GLdouble u;
+    GLdouble v;
+};
+
+struct glEvalCoord2dv_params
+{
+    const GLdouble *u;
+};
+
+struct glEvalCoord2f_params
+{
+    GLfloat u;
+    GLfloat v;
+};
+
+struct glEvalCoord2fv_params
+{
+    const GLfloat *u;
+};
+
+struct glEvalMesh1_params
+{
+    GLenum mode;
+    GLint i1;
+    GLint i2;
+};
+
+struct glEvalMesh2_params
+{
+    GLenum mode;
+    GLint i1;
+    GLint i2;
+    GLint j1;
+    GLint j2;
+};
+
+struct glEvalPoint1_params
+{
+    GLint i;
+};
+
+struct glEvalPoint2_params
+{
+    GLint i;
+    GLint j;
+};
+
+struct glFeedbackBuffer_params
+{
+    GLsizei size;
+    GLenum type;
+    GLfloat *buffer;
+};
+
+struct glFinish_params
+{
+};
+
+struct glFlush_params
+{
+};
+
+struct glFogf_params
+{
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glFogfv_params
+{
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glFogi_params
+{
+    GLenum pname;
+    GLint param;
+};
+
+struct glFogiv_params
+{
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glFrontFace_params
+{
+    GLenum mode;
+};
+
+struct glFrustum_params
+{
+    GLdouble left;
+    GLdouble right;
+    GLdouble bottom;
+    GLdouble top;
+    GLdouble zNear;
+    GLdouble zFar;
+};
+
+struct glGenLists_params
+{
+    GLsizei range;
+    GLuint ret;
+};
+
+struct glGenTextures_params
+{
+    GLsizei n;
+    GLuint *textures;
+};
+
+struct glGetBooleanv_params
+{
+    GLenum pname;
+    GLboolean *data;
+};
+
+struct glGetClipPlane_params
+{
+    GLenum plane;
+    GLdouble *equation;
+};
+
+struct glGetDoublev_params
+{
+    GLenum pname;
+    GLdouble *data;
+};
+
+struct glGetError_params
+{
+    GLenum ret;
+};
+
+struct glGetFloatv_params
+{
+    GLenum pname;
+    GLfloat *data;
+};
+
+struct glGetLightfv_params
+{
+    GLenum light;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetLightiv_params
+{
+    GLenum light;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glGetMapdv_params
+{
+    GLenum target;
+    GLenum query;
+    GLdouble *v;
+};
+
+struct glGetMapfv_params
+{
+    GLenum target;
+    GLenum query;
+    GLfloat *v;
+};
+
+struct glGetMapiv_params
+{
+    GLenum target;
+    GLenum query;
+    GLint *v;
+};
+
+struct glGetMaterialfv_params
+{
+    GLenum face;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetMaterialiv_params
+{
+    GLenum face;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glGetPixelMapfv_params
+{
+    GLenum map;
+    GLfloat *values;
+};
+
+struct glGetPixelMapuiv_params
+{
+    GLenum map;
+    GLuint *values;
+};
+
+struct glGetPixelMapusv_params
+{
+    GLenum map;
+    GLushort *values;
+};
+
+struct glGetPointerv_params
+{
+    GLenum pname;
+    void **params;
+};
+
+struct glGetPolygonStipple_params
+{
+    GLubyte *mask;
+};
+
+struct glGetTexEnvfv_params
+{
+    GLenum target;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetTexEnviv_params
+{
+    GLenum target;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glGetTexGendv_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLdouble *params;
+};
+
+struct glGetTexGenfv_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetTexGeniv_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glGetTexImage_params
+{
+    GLenum target;
+    GLint level;
+    GLenum format;
+    GLenum type;
+    void *pixels;
+};
+
+struct glGetTexLevelParameterfv_params
+{
+    GLenum target;
+    GLint level;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetTexLevelParameteriv_params
+{
+    GLenum target;
+    GLint level;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glGetTexParameterfv_params
+{
+    GLenum target;
+    GLenum pname;
+    GLfloat *params;
+};
+
+struct glGetTexParameteriv_params
+{
+    GLenum target;
+    GLenum pname;
+    GLint *params;
+};
+
+struct glHint_params
+{
+    GLenum target;
+    GLenum mode;
+};
+
+struct glIndexMask_params
+{
+    GLuint mask;
+};
+
+struct glIndexPointer_params
+{
+    GLenum type;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glIndexd_params
+{
+    GLdouble c;
+};
+
+struct glIndexdv_params
+{
+    const GLdouble *c;
+};
+
+struct glIndexf_params
+{
+    GLfloat c;
+};
+
+struct glIndexfv_params
+{
+    const GLfloat *c;
+};
+
+struct glIndexi_params
+{
+    GLint c;
+};
+
+struct glIndexiv_params
+{
+    const GLint *c;
+};
+
+struct glIndexs_params
+{
+    GLshort c;
+};
+
+struct glIndexsv_params
+{
+    const GLshort *c;
+};
+
+struct glIndexub_params
+{
+    GLubyte c;
+};
+
+struct glIndexubv_params
+{
+    const GLubyte *c;
+};
+
+struct glInitNames_params
+{
+};
+
+struct glInterleavedArrays_params
+{
+    GLenum format;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glIsEnabled_params
+{
+    GLenum cap;
+    GLboolean ret;
+};
+
+struct glIsList_params
+{
+    GLuint list;
+    GLboolean ret;
+};
+
+struct glIsTexture_params
+{
+    GLuint texture;
+    GLboolean ret;
+};
+
+struct glLightModelf_params
+{
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glLightModelfv_params
+{
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glLightModeli_params
+{
+    GLenum pname;
+    GLint param;
+};
+
+struct glLightModeliv_params
+{
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glLightf_params
+{
+    GLenum light;
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glLightfv_params
+{
+    GLenum light;
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glLighti_params
+{
+    GLenum light;
+    GLenum pname;
+    GLint param;
+};
+
+struct glLightiv_params
+{
+    GLenum light;
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glLineStipple_params
+{
+    GLint factor;
+    GLushort pattern;
+};
+
+struct glLineWidth_params
+{
+    GLfloat width;
+};
+
+struct glListBase_params
+{
+    GLuint base;
+};
+
+struct glLoadIdentity_params
+{
+};
+
+struct glLoadMatrixd_params
+{
+    const GLdouble *m;
+};
+
+struct glLoadMatrixf_params
+{
+    const GLfloat *m;
+};
+
+struct glLoadName_params
+{
+    GLuint name;
+};
+
+struct glLogicOp_params
+{
+    GLenum opcode;
+};
+
+struct glMap1d_params
+{
+    GLenum target;
+    GLdouble u1;
+    GLdouble u2;
+    GLint stride;
+    GLint order;
+    const GLdouble *points;
+};
+
+struct glMap1f_params
+{
+    GLenum target;
+    GLfloat u1;
+    GLfloat u2;
+    GLint stride;
+    GLint order;
+    const GLfloat *points;
+};
+
+struct glMap2d_params
+{
+    GLenum target;
+    GLdouble u1;
+    GLdouble u2;
+    GLint ustride;
+    GLint uorder;
+    GLdouble v1;
+    GLdouble v2;
+    GLint vstride;
+    GLint vorder;
+    const GLdouble *points;
+};
+
+struct glMap2f_params
+{
+    GLenum target;
+    GLfloat u1;
+    GLfloat u2;
+    GLint ustride;
+    GLint uorder;
+    GLfloat v1;
+    GLfloat v2;
+    GLint vstride;
+    GLint vorder;
+    const GLfloat *points;
+};
+
+struct glMapGrid1d_params
+{
+    GLint un;
+    GLdouble u1;
+    GLdouble u2;
+};
+
+struct glMapGrid1f_params
+{
+    GLint un;
+    GLfloat u1;
+    GLfloat u2;
+};
+
+struct glMapGrid2d_params
+{
+    GLint un;
+    GLdouble u1;
+    GLdouble u2;
+    GLint vn;
+    GLdouble v1;
+    GLdouble v2;
+};
+
+struct glMapGrid2f_params
+{
+    GLint un;
+    GLfloat u1;
+    GLfloat u2;
+    GLint vn;
+    GLfloat v1;
+    GLfloat v2;
+};
+
+struct glMaterialf_params
+{
+    GLenum face;
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glMaterialfv_params
+{
+    GLenum face;
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glMateriali_params
+{
+    GLenum face;
+    GLenum pname;
+    GLint param;
+};
+
+struct glMaterialiv_params
+{
+    GLenum face;
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glMatrixMode_params
+{
+    GLenum mode;
+};
+
+struct glMultMatrixd_params
+{
+    const GLdouble *m;
+};
+
+struct glMultMatrixf_params
+{
+    const GLfloat *m;
+};
+
+struct glNewList_params
+{
+    GLuint list;
+    GLenum mode;
+};
+
+struct glNormal3b_params
+{
+    GLbyte nx;
+    GLbyte ny;
+    GLbyte nz;
+};
+
+struct glNormal3bv_params
+{
+    const GLbyte *v;
+};
+
+struct glNormal3d_params
+{
+    GLdouble nx;
+    GLdouble ny;
+    GLdouble nz;
+};
+
+struct glNormal3dv_params
+{
+    const GLdouble *v;
+};
+
+struct glNormal3f_params
+{
+    GLfloat nx;
+    GLfloat ny;
+    GLfloat nz;
+};
+
+struct glNormal3fv_params
+{
+    const GLfloat *v;
+};
+
+struct glNormal3i_params
+{
+    GLint nx;
+    GLint ny;
+    GLint nz;
+};
+
+struct glNormal3iv_params
+{
+    const GLint *v;
+};
+
+struct glNormal3s_params
+{
+    GLshort nx;
+    GLshort ny;
+    GLshort nz;
+};
+
+struct glNormal3sv_params
+{
+    const GLshort *v;
+};
+
+struct glNormalPointer_params
+{
+    GLenum type;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glOrtho_params
+{
+    GLdouble left;
+    GLdouble right;
+    GLdouble bottom;
+    GLdouble top;
+    GLdouble zNear;
+    GLdouble zFar;
+};
+
+struct glPassThrough_params
+{
+    GLfloat token;
+};
+
+struct glPixelMapfv_params
+{
+    GLenum map;
+    GLsizei mapsize;
+    const GLfloat *values;
+};
+
+struct glPixelMapuiv_params
+{
+    GLenum map;
+    GLsizei mapsize;
+    const GLuint *values;
+};
+
+struct glPixelMapusv_params
+{
+    GLenum map;
+    GLsizei mapsize;
+    const GLushort *values;
+};
+
+struct glPixelStoref_params
+{
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glPixelStorei_params
+{
+    GLenum pname;
+    GLint param;
+};
+
+struct glPixelTransferf_params
+{
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glPixelTransferi_params
+{
+    GLenum pname;
+    GLint param;
+};
+
+struct glPixelZoom_params
+{
+    GLfloat xfactor;
+    GLfloat yfactor;
+};
+
+struct glPointSize_params
+{
+    GLfloat size;
+};
+
+struct glPolygonMode_params
+{
+    GLenum face;
+    GLenum mode;
+};
+
+struct glPolygonOffset_params
+{
+    GLfloat factor;
+    GLfloat units;
+};
+
+struct glPolygonStipple_params
+{
+    const GLubyte *mask;
+};
+
+struct glPopAttrib_params
+{
+};
+
+struct glPopClientAttrib_params
+{
+};
+
+struct glPopMatrix_params
+{
+};
+
+struct glPopName_params
+{
+};
+
+struct glPrioritizeTextures_params
+{
+    GLsizei n;
+    const GLuint *textures;
+    const GLfloat *priorities;
+};
+
+struct glPushAttrib_params
+{
+    GLbitfield mask;
+};
+
+struct glPushClientAttrib_params
+{
+    GLbitfield mask;
+};
+
+struct glPushMatrix_params
+{
+};
+
+struct glPushName_params
+{
+    GLuint name;
+};
+
+struct glRasterPos2d_params
+{
+    GLdouble x;
+    GLdouble y;
+};
+
+struct glRasterPos2dv_params
+{
+    const GLdouble *v;
+};
+
+struct glRasterPos2f_params
+{
+    GLfloat x;
+    GLfloat y;
+};
+
+struct glRasterPos2fv_params
+{
+    const GLfloat *v;
+};
+
+struct glRasterPos2i_params
+{
+    GLint x;
+    GLint y;
+};
+
+struct glRasterPos2iv_params
+{
+    const GLint *v;
+};
+
+struct glRasterPos2s_params
+{
+    GLshort x;
+    GLshort y;
+};
+
+struct glRasterPos2sv_params
+{
+    const GLshort *v;
+};
+
+struct glRasterPos3d_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+};
+
+struct glRasterPos3dv_params
+{
+    const GLdouble *v;
+};
+
+struct glRasterPos3f_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+};
+
+struct glRasterPos3fv_params
+{
+    const GLfloat *v;
+};
+
+struct glRasterPos3i_params
+{
+    GLint x;
+    GLint y;
+    GLint z;
+};
+
+struct glRasterPos3iv_params
+{
+    const GLint *v;
+};
+
+struct glRasterPos3s_params
+{
+    GLshort x;
+    GLshort y;
+    GLshort z;
+};
+
+struct glRasterPos3sv_params
+{
+    const GLshort *v;
+};
+
+struct glRasterPos4d_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+    GLdouble w;
+};
+
+struct glRasterPos4dv_params
+{
+    const GLdouble *v;
+};
+
+struct glRasterPos4f_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+    GLfloat w;
+};
+
+struct glRasterPos4fv_params
+{
+    const GLfloat *v;
+};
+
+struct glRasterPos4i_params
+{
+    GLint x;
+    GLint y;
+    GLint z;
+    GLint w;
+};
+
+struct glRasterPos4iv_params
+{
+    const GLint *v;
+};
+
+struct glRasterPos4s_params
+{
+    GLshort x;
+    GLshort y;
+    GLshort z;
+    GLshort w;
+};
+
+struct glRasterPos4sv_params
+{
+    const GLshort *v;
+};
+
+struct glReadBuffer_params
+{
+    GLenum src;
+};
+
+struct glReadPixels_params
+{
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+    void *pixels;
+};
+
+struct glRectd_params
+{
+    GLdouble x1;
+    GLdouble y1;
+    GLdouble x2;
+    GLdouble y2;
+};
+
+struct glRectdv_params
+{
+    const GLdouble *v1;
+    const GLdouble *v2;
+};
+
+struct glRectf_params
+{
+    GLfloat x1;
+    GLfloat y1;
+    GLfloat x2;
+    GLfloat y2;
+};
+
+struct glRectfv_params
+{
+    const GLfloat *v1;
+    const GLfloat *v2;
+};
+
+struct glRecti_params
+{
+    GLint x1;
+    GLint y1;
+    GLint x2;
+    GLint y2;
+};
+
+struct glRectiv_params
+{
+    const GLint *v1;
+    const GLint *v2;
+};
+
+struct glRects_params
+{
+    GLshort x1;
+    GLshort y1;
+    GLshort x2;
+    GLshort y2;
+};
+
+struct glRectsv_params
+{
+    const GLshort *v1;
+    const GLshort *v2;
+};
+
+struct glRenderMode_params
+{
+    GLenum mode;
+    GLint ret;
+};
+
+struct glRotated_params
+{
+    GLdouble angle;
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+};
+
+struct glRotatef_params
+{
+    GLfloat angle;
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+};
+
+struct glScaled_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+};
+
+struct glScalef_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+};
+
+struct glScissor_params
+{
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+};
+
+struct glSelectBuffer_params
+{
+    GLsizei size;
+    GLuint *buffer;
+};
+
+struct glShadeModel_params
+{
+    GLenum mode;
+};
+
+struct glStencilFunc_params
+{
+    GLenum func;
+    GLint ref;
+    GLuint mask;
+};
+
+struct glStencilMask_params
+{
+    GLuint mask;
+};
+
+struct glStencilOp_params
+{
+    GLenum fail;
+    GLenum zfail;
+    GLenum zpass;
+};
+
+struct glTexCoord1d_params
+{
+    GLdouble s;
+};
+
+struct glTexCoord1dv_params
+{
+    const GLdouble *v;
+};
+
+struct glTexCoord1f_params
+{
+    GLfloat s;
+};
+
+struct glTexCoord1fv_params
+{
+    const GLfloat *v;
+};
+
+struct glTexCoord1i_params
+{
+    GLint s;
+};
+
+struct glTexCoord1iv_params
+{
+    const GLint *v;
+};
+
+struct glTexCoord1s_params
+{
+    GLshort s;
+};
+
+struct glTexCoord1sv_params
+{
+    const GLshort *v;
+};
+
+struct glTexCoord2d_params
+{
+    GLdouble s;
+    GLdouble t;
+};
+
+struct glTexCoord2dv_params
+{
+    const GLdouble *v;
+};
+
+struct glTexCoord2f_params
+{
+    GLfloat s;
+    GLfloat t;
+};
+
+struct glTexCoord2fv_params
+{
+    const GLfloat *v;
+};
+
+struct glTexCoord2i_params
+{
+    GLint s;
+    GLint t;
+};
+
+struct glTexCoord2iv_params
+{
+    const GLint *v;
+};
+
+struct glTexCoord2s_params
+{
+    GLshort s;
+    GLshort t;
+};
+
+struct glTexCoord2sv_params
+{
+    const GLshort *v;
+};
+
+struct glTexCoord3d_params
+{
+    GLdouble s;
+    GLdouble t;
+    GLdouble r;
+};
+
+struct glTexCoord3dv_params
+{
+    const GLdouble *v;
+};
+
+struct glTexCoord3f_params
+{
+    GLfloat s;
+    GLfloat t;
+    GLfloat r;
+};
+
+struct glTexCoord3fv_params
+{
+    const GLfloat *v;
+};
+
+struct glTexCoord3i_params
+{
+    GLint s;
+    GLint t;
+    GLint r;
+};
+
+struct glTexCoord3iv_params
+{
+    const GLint *v;
+};
+
+struct glTexCoord3s_params
+{
+    GLshort s;
+    GLshort t;
+    GLshort r;
+};
+
+struct glTexCoord3sv_params
+{
+    const GLshort *v;
+};
+
+struct glTexCoord4d_params
+{
+    GLdouble s;
+    GLdouble t;
+    GLdouble r;
+    GLdouble q;
+};
+
+struct glTexCoord4dv_params
+{
+    const GLdouble *v;
+};
+
+struct glTexCoord4f_params
+{
+    GLfloat s;
+    GLfloat t;
+    GLfloat r;
+    GLfloat q;
+};
+
+struct glTexCoord4fv_params
+{
+    const GLfloat *v;
+};
+
+struct glTexCoord4i_params
+{
+    GLint s;
+    GLint t;
+    GLint r;
+    GLint q;
+};
+
+struct glTexCoord4iv_params
+{
+    const GLint *v;
+};
+
+struct glTexCoord4s_params
+{
+    GLshort s;
+    GLshort t;
+    GLshort r;
+    GLshort q;
+};
+
+struct glTexCoord4sv_params
+{
+    const GLshort *v;
+};
+
+struct glTexCoordPointer_params
+{
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glTexEnvf_params
+{
+    GLenum target;
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glTexEnvfv_params
+{
+    GLenum target;
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glTexEnvi_params
+{
+    GLenum target;
+    GLenum pname;
+    GLint param;
+};
+
+struct glTexEnviv_params
+{
+    GLenum target;
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glTexGend_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLdouble param;
+};
+
+struct glTexGendv_params
+{
+    GLenum coord;
+    GLenum pname;
+    const GLdouble *params;
+};
+
+struct glTexGenf_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glTexGenfv_params
+{
+    GLenum coord;
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glTexGeni_params
+{
+    GLenum coord;
+    GLenum pname;
+    GLint param;
+};
+
+struct glTexGeniv_params
+{
+    GLenum coord;
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glTexImage1D_params
+{
+    GLenum target;
+    GLint level;
+    GLint internalformat;
+    GLsizei width;
+    GLint border;
+    GLenum format;
+    GLenum type;
+    const void *pixels;
+};
+
+struct glTexImage2D_params
+{
+    GLenum target;
+    GLint level;
+    GLint internalformat;
+    GLsizei width;
+    GLsizei height;
+    GLint border;
+    GLenum format;
+    GLenum type;
+    const void *pixels;
+};
+
+struct glTexParameterf_params
+{
+    GLenum target;
+    GLenum pname;
+    GLfloat param;
+};
+
+struct glTexParameterfv_params
+{
+    GLenum target;
+    GLenum pname;
+    const GLfloat *params;
+};
+
+struct glTexParameteri_params
+{
+    GLenum target;
+    GLenum pname;
+    GLint param;
+};
+
+struct glTexParameteriv_params
+{
+    GLenum target;
+    GLenum pname;
+    const GLint *params;
+};
+
+struct glTexSubImage1D_params
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLsizei width;
+    GLenum format;
+    GLenum type;
+    const void *pixels;
+};
+
+struct glTexSubImage2D_params
+{
+    GLenum target;
+    GLint level;
+    GLint xoffset;
+    GLint yoffset;
+    GLsizei width;
+    GLsizei height;
+    GLenum format;
+    GLenum type;
+    const void *pixels;
+};
+
+struct glTranslated_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+};
+
+struct glTranslatef_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+};
+
+struct glVertex2d_params
+{
+    GLdouble x;
+    GLdouble y;
+};
+
+struct glVertex2dv_params
+{
+    const GLdouble *v;
+};
+
+struct glVertex2f_params
+{
+    GLfloat x;
+    GLfloat y;
+};
+
+struct glVertex2fv_params
+{
+    const GLfloat *v;
+};
+
+struct glVertex2i_params
+{
+    GLint x;
+    GLint y;
+};
+
+struct glVertex2iv_params
+{
+    const GLint *v;
+};
+
+struct glVertex2s_params
+{
+    GLshort x;
+    GLshort y;
+};
+
+struct glVertex2sv_params
+{
+    const GLshort *v;
+};
+
+struct glVertex3d_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+};
+
+struct glVertex3dv_params
+{
+    const GLdouble *v;
+};
+
+struct glVertex3f_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+};
+
+struct glVertex3fv_params
+{
+    const GLfloat *v;
+};
+
+struct glVertex3i_params
+{
+    GLint x;
+    GLint y;
+    GLint z;
+};
+
+struct glVertex3iv_params
+{
+    const GLint *v;
+};
+
+struct glVertex3s_params
+{
+    GLshort x;
+    GLshort y;
+    GLshort z;
+};
+
+struct glVertex3sv_params
+{
+    const GLshort *v;
+};
+
+struct glVertex4d_params
+{
+    GLdouble x;
+    GLdouble y;
+    GLdouble z;
+    GLdouble w;
+};
+
+struct glVertex4dv_params
+{
+    const GLdouble *v;
+};
+
+struct glVertex4f_params
+{
+    GLfloat x;
+    GLfloat y;
+    GLfloat z;
+    GLfloat w;
+};
+
+struct glVertex4fv_params
+{
+    const GLfloat *v;
+};
+
+struct glVertex4i_params
+{
+    GLint x;
+    GLint y;
+    GLint z;
+    GLint w;
+};
+
+struct glVertex4iv_params
+{
+    const GLint *v;
+};
+
+struct glVertex4s_params
+{
+    GLshort x;
+    GLshort y;
+    GLshort z;
+    GLshort w;
+};
+
+struct glVertex4sv_params
+{
+    const GLshort *v;
+};
+
+struct glVertexPointer_params
+{
+    GLint size;
+    GLenum type;
+    GLsizei stride;
+    const void *pointer;
+};
+
+struct glViewport_params
+{
+    GLint x;
+    GLint y;
+    GLsizei width;
+    GLsizei height;
+};
+
+enum unix_funcs
+{
+    unix_glAccum,
+    unix_glAlphaFunc,
+    unix_glAreTexturesResident,
+    unix_glArrayElement,
+    unix_glBegin,
+    unix_glBindTexture,
+    unix_glBitmap,
+    unix_glBlendFunc,
+    unix_glCallList,
+    unix_glCallLists,
+    unix_glClear,
+    unix_glClearAccum,
+    unix_glClearColor,
+    unix_glClearDepth,
+    unix_glClearIndex,
+    unix_glClearStencil,
+    unix_glClipPlane,
+    unix_glColor3b,
+    unix_glColor3bv,
+    unix_glColor3d,
+    unix_glColor3dv,
+    unix_glColor3f,
+    unix_glColor3fv,
+    unix_glColor3i,
+    unix_glColor3iv,
+    unix_glColor3s,
+    unix_glColor3sv,
+    unix_glColor3ub,
+    unix_glColor3ubv,
+    unix_glColor3ui,
+    unix_glColor3uiv,
+    unix_glColor3us,
+    unix_glColor3usv,
+    unix_glColor4b,
+    unix_glColor4bv,
+    unix_glColor4d,
+    unix_glColor4dv,
+    unix_glColor4f,
+    unix_glColor4fv,
+    unix_glColor4i,
+    unix_glColor4iv,
+    unix_glColor4s,
+    unix_glColor4sv,
+    unix_glColor4ub,
+    unix_glColor4ubv,
+    unix_glColor4ui,
+    unix_glColor4uiv,
+    unix_glColor4us,
+    unix_glColor4usv,
+    unix_glColorMask,
+    unix_glColorMaterial,
+    unix_glColorPointer,
+    unix_glCopyPixels,
+    unix_glCopyTexImage1D,
+    unix_glCopyTexImage2D,
+    unix_glCopyTexSubImage1D,
+    unix_glCopyTexSubImage2D,
+    unix_glCullFace,
+    unix_glDeleteLists,
+    unix_glDeleteTextures,
+    unix_glDepthFunc,
+    unix_glDepthMask,
+    unix_glDepthRange,
+    unix_glDisable,
+    unix_glDisableClientState,
+    unix_glDrawArrays,
+    unix_glDrawBuffer,
+    unix_glDrawElements,
+    unix_glDrawPixels,
+    unix_glEdgeFlag,
+    unix_glEdgeFlagPointer,
+    unix_glEdgeFlagv,
+    unix_glEnable,
+    unix_glEnableClientState,
+    unix_glEnd,
+    unix_glEndList,
+    unix_glEvalCoord1d,
+    unix_glEvalCoord1dv,
+    unix_glEvalCoord1f,
+    unix_glEvalCoord1fv,
+    unix_glEvalCoord2d,
+    unix_glEvalCoord2dv,
+    unix_glEvalCoord2f,
+    unix_glEvalCoord2fv,
+    unix_glEvalMesh1,
+    unix_glEvalMesh2,
+    unix_glEvalPoint1,
+    unix_glEvalPoint2,
+    unix_glFeedbackBuffer,
+    unix_glFinish,
+    unix_glFlush,
+    unix_glFogf,
+    unix_glFogfv,
+    unix_glFogi,
+    unix_glFogiv,
+    unix_glFrontFace,
+    unix_glFrustum,
+    unix_glGenLists,
+    unix_glGenTextures,
+    unix_glGetBooleanv,
+    unix_glGetClipPlane,
+    unix_glGetDoublev,
+    unix_glGetError,
+    unix_glGetFloatv,
+    unix_glGetLightfv,
+    unix_glGetLightiv,
+    unix_glGetMapdv,
+    unix_glGetMapfv,
+    unix_glGetMapiv,
+    unix_glGetMaterialfv,
+    unix_glGetMaterialiv,
+    unix_glGetPixelMapfv,
+    unix_glGetPixelMapuiv,
+    unix_glGetPixelMapusv,
+    unix_glGetPointerv,
+    unix_glGetPolygonStipple,
+    unix_glGetTexEnvfv,
+    unix_glGetTexEnviv,
+    unix_glGetTexGendv,
+    unix_glGetTexGenfv,
+    unix_glGetTexGeniv,
+    unix_glGetTexImage,
+    unix_glGetTexLevelParameterfv,
+    unix_glGetTexLevelParameteriv,
+    unix_glGetTexParameterfv,
+    unix_glGetTexParameteriv,
+    unix_glHint,
+    unix_glIndexMask,
+    unix_glIndexPointer,
+    unix_glIndexd,
+    unix_glIndexdv,
+    unix_glIndexf,
+    unix_glIndexfv,
+    unix_glIndexi,
+    unix_glIndexiv,
+    unix_glIndexs,
+    unix_glIndexsv,
+    unix_glIndexub,
+    unix_glIndexubv,
+    unix_glInitNames,
+    unix_glInterleavedArrays,
+    unix_glIsEnabled,
+    unix_glIsList,
+    unix_glIsTexture,
+    unix_glLightModelf,
+    unix_glLightModelfv,
+    unix_glLightModeli,
+    unix_glLightModeliv,
+    unix_glLightf,
+    unix_glLightfv,
+    unix_glLighti,
+    unix_glLightiv,
+    unix_glLineStipple,
+    unix_glLineWidth,
+    unix_glListBase,
+    unix_glLoadIdentity,
+    unix_glLoadMatrixd,
+    unix_glLoadMatrixf,
+    unix_glLoadName,
+    unix_glLogicOp,
+    unix_glMap1d,
+    unix_glMap1f,
+    unix_glMap2d,
+    unix_glMap2f,
+    unix_glMapGrid1d,
+    unix_glMapGrid1f,
+    unix_glMapGrid2d,
+    unix_glMapGrid2f,
+    unix_glMaterialf,
+    unix_glMaterialfv,
+    unix_glMateriali,
+    unix_glMaterialiv,
+    unix_glMatrixMode,
+    unix_glMultMatrixd,
+    unix_glMultMatrixf,
+    unix_glNewList,
+    unix_glNormal3b,
+    unix_glNormal3bv,
+    unix_glNormal3d,
+    unix_glNormal3dv,
+    unix_glNormal3f,
+    unix_glNormal3fv,
+    unix_glNormal3i,
+    unix_glNormal3iv,
+    unix_glNormal3s,
+    unix_glNormal3sv,
+    unix_glNormalPointer,
+    unix_glOrtho,
+    unix_glPassThrough,
+    unix_glPixelMapfv,
+    unix_glPixelMapuiv,
+    unix_glPixelMapusv,
+    unix_glPixelStoref,
+    unix_glPixelStorei,
+    unix_glPixelTransferf,
+    unix_glPixelTransferi,
+    unix_glPixelZoom,
+    unix_glPointSize,
+    unix_glPolygonMode,
+    unix_glPolygonOffset,
+    unix_glPolygonStipple,
+    unix_glPopAttrib,
+    unix_glPopClientAttrib,
+    unix_glPopMatrix,
+    unix_glPopName,
+    unix_glPrioritizeTextures,
+    unix_glPushAttrib,
+    unix_glPushClientAttrib,
+    unix_glPushMatrix,
+    unix_glPushName,
+    unix_glRasterPos2d,
+    unix_glRasterPos2dv,
+    unix_glRasterPos2f,
+    unix_glRasterPos2fv,
+    unix_glRasterPos2i,
+    unix_glRasterPos2iv,
+    unix_glRasterPos2s,
+    unix_glRasterPos2sv,
+    unix_glRasterPos3d,
+    unix_glRasterPos3dv,
+    unix_glRasterPos3f,
+    unix_glRasterPos3fv,
+    unix_glRasterPos3i,
+    unix_glRasterPos3iv,
+    unix_glRasterPos3s,
+    unix_glRasterPos3sv,
+    unix_glRasterPos4d,
+    unix_glRasterPos4dv,
+    unix_glRasterPos4f,
+    unix_glRasterPos4fv,
+    unix_glRasterPos4i,
+    unix_glRasterPos4iv,
+    unix_glRasterPos4s,
+    unix_glRasterPos4sv,
+    unix_glReadBuffer,
+    unix_glReadPixels,
+    unix_glRectd,
+    unix_glRectdv,
+    unix_glRectf,
+    unix_glRectfv,
+    unix_glRecti,
+    unix_glRectiv,
+    unix_glRects,
+    unix_glRectsv,
+    unix_glRenderMode,
+    unix_glRotated,
+    unix_glRotatef,
+    unix_glScaled,
+    unix_glScalef,
+    unix_glScissor,
+    unix_glSelectBuffer,
+    unix_glShadeModel,
+    unix_glStencilFunc,
+    unix_glStencilMask,
+    unix_glStencilOp,
+    unix_glTexCoord1d,
+    unix_glTexCoord1dv,
+    unix_glTexCoord1f,
+    unix_glTexCoord1fv,
+    unix_glTexCoord1i,
+    unix_glTexCoord1iv,
+    unix_glTexCoord1s,
+    unix_glTexCoord1sv,
+    unix_glTexCoord2d,
+    unix_glTexCoord2dv,
+    unix_glTexCoord2f,
+    unix_glTexCoord2fv,
+    unix_glTexCoord2i,
+    unix_glTexCoord2iv,
+    unix_glTexCoord2s,
+    unix_glTexCoord2sv,
+    unix_glTexCoord3d,
+    unix_glTexCoord3dv,
+    unix_glTexCoord3f,
+    unix_glTexCoord3fv,
+    unix_glTexCoord3i,
+    unix_glTexCoord3iv,
+    unix_glTexCoord3s,
+    unix_glTexCoord3sv,
+    unix_glTexCoord4d,
+    unix_glTexCoord4dv,
+    unix_glTexCoord4f,
+    unix_glTexCoord4fv,
+    unix_glTexCoord4i,
+    unix_glTexCoord4iv,
+    unix_glTexCoord4s,
+    unix_glTexCoord4sv,
+    unix_glTexCoordPointer,
+    unix_glTexEnvf,
+    unix_glTexEnvfv,
+    unix_glTexEnvi,
+    unix_glTexEnviv,
+    unix_glTexGend,
+    unix_glTexGendv,
+    unix_glTexGenf,
+    unix_glTexGenfv,
+    unix_glTexGeni,
+    unix_glTexGeniv,
+    unix_glTexImage1D,
+    unix_glTexImage2D,
+    unix_glTexParameterf,
+    unix_glTexParameterfv,
+    unix_glTexParameteri,
+    unix_glTexParameteriv,
+    unix_glTexSubImage1D,
+    unix_glTexSubImage2D,
+    unix_glTranslated,
+    unix_glTranslatef,
+    unix_glVertex2d,
+    unix_glVertex2dv,
+    unix_glVertex2f,
+    unix_glVertex2fv,
+    unix_glVertex2i,
+    unix_glVertex2iv,
+    unix_glVertex2s,
+    unix_glVertex2sv,
+    unix_glVertex3d,
+    unix_glVertex3dv,
+    unix_glVertex3f,
+    unix_glVertex3fv,
+    unix_glVertex3i,
+    unix_glVertex3iv,
+    unix_glVertex3s,
+    unix_glVertex3sv,
+    unix_glVertex4d,
+    unix_glVertex4dv,
+    unix_glVertex4f,
+    unix_glVertex4fv,
+    unix_glVertex4i,
+    unix_glVertex4iv,
+    unix_glVertex4s,
+    unix_glVertex4sv,
+    unix_glVertexPointer,
+    unix_glViewport,
+};
+
+typedef NTSTATUS (*unixlib_function_t)( void *args );
+extern const unixlib_function_t __wine_unix_call_funcs[] DECLSPEC_HIDDEN;
+#define UNIX_CALL( func, params ) __wine_unix_call_funcs[unix_ ## func]( params )
+
+#endif /* __WINE_OPENGL32_UNIXLIB_H */