Skip to content

W
wine-winehq
Commit 7dcc6ccf authored by Rémi Bernon's avatar Rémi Bernon Committed by Alexandre Julliard
Browse files
Options

opengl32: Create a unixlib interface for GL functions.

parent ed666db8
Hide whitespace changes
Inline Side-by-side
Showing with 5707 additions and 2367 deletions
dlls/opengl32/Makefile.in
View file @ 7dcc6ccf
......@@ -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
dlls/opengl32/make_opengl
View file @ 7dcc6ccf
......@@ -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;
dlls/opengl32/opengl_norm.c
View file @ 7dcc6ccf
......@@ -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; }
......
dlls/opengl32/thunks.c 0 → 100644
View file @ 7dcc6ccf
This source diff could not be displayed because it is too large. You can view the blob instead.
dlls/opengl32/unix_thunks.c 0 → 100644
View file @ 7dcc6ccf
/* 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,
};
dlls/opengl32/unixlib.h 0 → 100644
View file @ 7dcc6ccf
/* 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 */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment