dlls/opengl32/opengl_norm.c

   1
   2 /* Auto-generated file... Do not edit ! */
   3
   4 #include "config.h"
   5 #include <stdarg.h>
   6 #include "opengl_ext.h"
   7 #include "winternl.h"
   8 #include "wingdi.h"
   9 #include "wine/wgl_driver.h"
  10 #include "wine/debug.h"
  11
  12 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
  13
  14 /***********************************************************************
  15  *              glAccum (OPENGL32.@)
  16  */
  17 void WINAPI wine_glAccum( GLenum op, GLfloat value ) {
  18   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  19   TRACE("(%d, %f)\n", op, value );
  20   funcs->gl.p_glAccum( op, value );
  21 }
  22
  23 /***********************************************************************
  24  *              glAlphaFunc (OPENGL32.@)
  25  */
  26 void WINAPI wine_glAlphaFunc( GLenum func, GLfloat ref ) {
  27   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  28   TRACE("(%d, %f)\n", func, ref );
  29   funcs->gl.p_glAlphaFunc( func, ref );
  30 }
  31
  32 /***********************************************************************
  33  *              glAreTexturesResident (OPENGL32.@)
  34  */
  35 GLboolean WINAPI wine_glAreTexturesResident( GLsizei n, const GLuint* textures, GLboolean* residences ) {
  36   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  37   TRACE("(%d, %p, %p)\n", n, textures, residences );
  38   return funcs->gl.p_glAreTexturesResident( n, textures, residences );
  39 }
  40
  41 /***********************************************************************
  42  *              glArrayElement (OPENGL32.@)
  43  */
  44 void WINAPI wine_glArrayElement( GLint i ) {
  45   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  46   TRACE("(%d)\n", i );
  47   funcs->gl.p_glArrayElement( i );
  48 }
  49
  50 /***********************************************************************
  51  *              glBegin (OPENGL32.@)
  52  */
  53 void WINAPI wine_glBegin( GLenum mode ) {
  54   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  55   TRACE("(%d)\n", mode );
  56   funcs->gl.p_glBegin( mode );
  57 }
  58
  59 /***********************************************************************
  60  *              glBindTexture (OPENGL32.@)
  61  */
  62 void WINAPI wine_glBindTexture( GLenum target, GLuint texture ) {
  63   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  64   TRACE("(%d, %d)\n", target, texture );
  65   funcs->gl.p_glBindTexture( target, texture );
  66 }
  67
  68 /***********************************************************************
  69  *              glBitmap (OPENGL32.@)
  70  */
  71 void WINAPI wine_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap ) {
  72   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  73   TRACE("(%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
  74   funcs->gl.p_glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
  75 }
  76
  77 /***********************************************************************
  78  *              glBlendFunc (OPENGL32.@)
  79  */
  80 void WINAPI wine_glBlendFunc( GLenum sfactor, GLenum dfactor ) {
  81   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  82   TRACE("(%d, %d)\n", sfactor, dfactor );
  83   funcs->gl.p_glBlendFunc( sfactor, dfactor );
  84 }
  85
  86 /***********************************************************************
  87  *              glCallList (OPENGL32.@)
  88  */
  89 void WINAPI wine_glCallList( GLuint list ) {
  90   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
  91   TRACE("(%d)\n", list );
  92   funcs->gl.p_glCallList( list );
  93 }
  94
  95 /***********************************************************************
  96  *              glCallLists (OPENGL32.@)
  97  */
  98 void WINAPI wine_glCallLists( GLsizei n, GLenum type, const GLvoid* lists ) {
  99   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 100   TRACE("(%d, %d, %p)\n", n, type, lists );
 101   funcs->gl.p_glCallLists( n, type, lists );
 102 }
 103
 104 /***********************************************************************
 105  *              glClear (OPENGL32.@)
 106  */
 107 void WINAPI wine_glClear( GLbitfield mask ) {
 108   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 109   TRACE("(%d)\n", mask );
 110   funcs->gl.p_glClear( mask );
 111 }
 112
 113 /***********************************************************************
 114  *              glClearAccum (OPENGL32.@)
 115  */
 116 void WINAPI wine_glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
 117   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 118   TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
 119   funcs->gl.p_glClearAccum( red, green, blue, alpha );
 120 }
 121
 122 /***********************************************************************
 123  *              glClearColor (OPENGL32.@)
 124  */
 125 void WINAPI wine_glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
 126   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 127   TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
 128   funcs->gl.p_glClearColor( red, green, blue, alpha );
 129 }
 130
 131 /***********************************************************************
 132  *              glClearDepth (OPENGL32.@)
 133  */
 134 void WINAPI wine_glClearDepth( GLdouble depth ) {
 135   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 136   TRACE("(%f)\n", depth );
 137   funcs->gl.p_glClearDepth( depth );
 138 }
 139
 140 /***********************************************************************
 141  *              glClearIndex (OPENGL32.@)
 142  */
 143 void WINAPI wine_glClearIndex( GLfloat c ) {
 144   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 145   TRACE("(%f)\n", c );
 146   funcs->gl.p_glClearIndex( c );
 147 }
 148
 149 /***********************************************************************
 150  *              glClearStencil (OPENGL32.@)
 151  */
 152 void WINAPI wine_glClearStencil( GLint s ) {
 153   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 154   TRACE("(%d)\n", s );
 155   funcs->gl.p_glClearStencil( s );
 156 }
 157
 158 /***********************************************************************
 159  *              glClipPlane (OPENGL32.@)
 160  */
 161 void WINAPI wine_glClipPlane( GLenum plane, const GLdouble* equation ) {
 162   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 163   TRACE("(%d, %p)\n", plane, equation );
 164   funcs->gl.p_glClipPlane( plane, equation );
 165 }
 166
 167 /***********************************************************************
 168  *              glColor3b (OPENGL32.@)
 169  */
 170 void WINAPI wine_glColor3b( GLbyte red, GLbyte green, GLbyte blue ) {
 171   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 172   TRACE("(%d, %d, %d)\n", red, green, blue );
 173   funcs->gl.p_glColor3b( red, green, blue );
 174 }
 175
 176 /***********************************************************************
 177  *              glColor3bv (OPENGL32.@)
 178  */
 179 void WINAPI wine_glColor3bv( const GLbyte* v ) {
 180   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 181   TRACE("(%p)\n", v );
 182   funcs->gl.p_glColor3bv( v );
 183 }
 184
 185 /***********************************************************************
 186  *              glColor3d (OPENGL32.@)
 187  */
 188 void WINAPI wine_glColor3d( GLdouble red, GLdouble green, GLdouble blue ) {
 189   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 190   TRACE("(%f, %f, %f)\n", red, green, blue );
 191   funcs->gl.p_glColor3d( red, green, blue );
 192 }
 193
 194 /***********************************************************************
 195  *              glColor3dv (OPENGL32.@)
 196  */
 197 void WINAPI wine_glColor3dv( const GLdouble* v ) {
 198   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 199   TRACE("(%p)\n", v );
 200   funcs->gl.p_glColor3dv( v );
 201 }
 202
 203 /***********************************************************************
 204  *              glColor3f (OPENGL32.@)
 205  */
 206 void WINAPI wine_glColor3f( GLfloat red, GLfloat green, GLfloat blue ) {
 207   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 208   TRACE("(%f, %f, %f)\n", red, green, blue );
 209   funcs->gl.p_glColor3f( red, green, blue );
 210 }
 211
 212 /***********************************************************************
 213  *              glColor3fv (OPENGL32.@)
 214  */
 215 void WINAPI wine_glColor3fv( const GLfloat* v ) {
 216   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 217   TRACE("(%p)\n", v );
 218   funcs->gl.p_glColor3fv( v );
 219 }
 220
 221 /***********************************************************************
 222  *              glColor3i (OPENGL32.@)
 223  */
 224 void WINAPI wine_glColor3i( GLint red, GLint green, GLint blue ) {
 225   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 226   TRACE("(%d, %d, %d)\n", red, green, blue );
 227   funcs->gl.p_glColor3i( red, green, blue );
 228 }
 229
 230 /***********************************************************************
 231  *              glColor3iv (OPENGL32.@)
 232  */
 233 void WINAPI wine_glColor3iv( const GLint* v ) {
 234   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 235   TRACE("(%p)\n", v );
 236   funcs->gl.p_glColor3iv( v );
 237 }
 238
 239 /***********************************************************************
 240  *              glColor3s (OPENGL32.@)
 241  */
 242 void WINAPI wine_glColor3s( GLshort red, GLshort green, GLshort blue ) {
 243   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 244   TRACE("(%d, %d, %d)\n", red, green, blue );
 245   funcs->gl.p_glColor3s( red, green, blue );
 246 }
 247
 248 /***********************************************************************
 249  *              glColor3sv (OPENGL32.@)
 250  */
 251 void WINAPI wine_glColor3sv( const GLshort* v ) {
 252   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 253   TRACE("(%p)\n", v );
 254   funcs->gl.p_glColor3sv( v );
 255 }
 256
 257 /***********************************************************************
 258  *              glColor3ub (OPENGL32.@)
 259  */
 260 void WINAPI wine_glColor3ub( GLubyte red, GLubyte green, GLubyte blue ) {
 261   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 262   TRACE("(%d, %d, %d)\n", red, green, blue );
 263   funcs->gl.p_glColor3ub( red, green, blue );
 264 }
 265
 266 /***********************************************************************
 267  *              glColor3ubv (OPENGL32.@)
 268  */
 269 void WINAPI wine_glColor3ubv( const GLubyte* v ) {
 270   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 271   TRACE("(%p)\n", v );
 272   funcs->gl.p_glColor3ubv( v );
 273 }
 274
 275 /***********************************************************************
 276  *              glColor3ui (OPENGL32.@)
 277  */
 278 void WINAPI wine_glColor3ui( GLuint red, GLuint green, GLuint blue ) {
 279   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 280   TRACE("(%d, %d, %d)\n", red, green, blue );
 281   funcs->gl.p_glColor3ui( red, green, blue );
 282 }
 283
 284 /***********************************************************************
 285  *              glColor3uiv (OPENGL32.@)
 286  */
 287 void WINAPI wine_glColor3uiv( const GLuint* v ) {
 288   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 289   TRACE("(%p)\n", v );
 290   funcs->gl.p_glColor3uiv( v );
 291 }
 292
 293 /***********************************************************************
 294  *              glColor3us (OPENGL32.@)
 295  */
 296 void WINAPI wine_glColor3us( GLushort red, GLushort green, GLushort blue ) {
 297   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 298   TRACE("(%d, %d, %d)\n", red, green, blue );
 299   funcs->gl.p_glColor3us( red, green, blue );
 300 }
 301
 302 /***********************************************************************
 303  *              glColor3usv (OPENGL32.@)
 304  */
 305 void WINAPI wine_glColor3usv( const GLushort* v ) {
 306   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 307   TRACE("(%p)\n", v );
 308   funcs->gl.p_glColor3usv( v );
 309 }
 310
 311 /***********************************************************************
 312  *              glColor4b (OPENGL32.@)
 313  */
 314 void WINAPI wine_glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) {
 315   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 316   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 317   funcs->gl.p_glColor4b( red, green, blue, alpha );
 318 }
 319
 320 /***********************************************************************
 321  *              glColor4bv (OPENGL32.@)
 322  */
 323 void WINAPI wine_glColor4bv( const GLbyte* v ) {
 324   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 325   TRACE("(%p)\n", v );
 326   funcs->gl.p_glColor4bv( v );
 327 }
 328
 329 /***********************************************************************
 330  *              glColor4d (OPENGL32.@)
 331  */
 332 void WINAPI wine_glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) {
 333   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 334   TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
 335   funcs->gl.p_glColor4d( red, green, blue, alpha );
 336 }
 337
 338 /***********************************************************************
 339  *              glColor4dv (OPENGL32.@)
 340  */
 341 void WINAPI wine_glColor4dv( const GLdouble* v ) {
 342   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 343   TRACE("(%p)\n", v );
 344   funcs->gl.p_glColor4dv( v );
 345 }
 346
 347 /***********************************************************************
 348  *              glColor4f (OPENGL32.@)
 349  */
 350 void WINAPI wine_glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
 351   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 352   TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
 353   funcs->gl.p_glColor4f( red, green, blue, alpha );
 354 }
 355
 356 /***********************************************************************
 357  *              glColor4fv (OPENGL32.@)
 358  */
 359 void WINAPI wine_glColor4fv( const GLfloat* v ) {
 360   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 361   TRACE("(%p)\n", v );
 362   funcs->gl.p_glColor4fv( v );
 363 }
 364
 365 /***********************************************************************
 366  *              glColor4i (OPENGL32.@)
 367  */
 368 void WINAPI wine_glColor4i( GLint red, GLint green, GLint blue, GLint alpha ) {
 369   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 370   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 371   funcs->gl.p_glColor4i( red, green, blue, alpha );
 372 }
 373
 374 /***********************************************************************
 375  *              glColor4iv (OPENGL32.@)
 376  */
 377 void WINAPI wine_glColor4iv( const GLint* v ) {
 378   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 379   TRACE("(%p)\n", v );
 380   funcs->gl.p_glColor4iv( v );
 381 }
 382
 383 /***********************************************************************
 384  *              glColor4s (OPENGL32.@)
 385  */
 386 void WINAPI wine_glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) {
 387   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 388   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 389   funcs->gl.p_glColor4s( red, green, blue, alpha );
 390 }
 391
 392 /***********************************************************************
 393  *              glColor4sv (OPENGL32.@)
 394  */
 395 void WINAPI wine_glColor4sv( const GLshort* v ) {
 396   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 397   TRACE("(%p)\n", v );
 398   funcs->gl.p_glColor4sv( v );
 399 }
 400
 401 /***********************************************************************
 402  *              glColor4ub (OPENGL32.@)
 403  */
 404 void WINAPI wine_glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) {
 405   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 406   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 407   funcs->gl.p_glColor4ub( red, green, blue, alpha );
 408 }
 409
 410 /***********************************************************************
 411  *              glColor4ubv (OPENGL32.@)
 412  */
 413 void WINAPI wine_glColor4ubv( const GLubyte* v ) {
 414   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 415   TRACE("(%p)\n", v );
 416   funcs->gl.p_glColor4ubv( v );
 417 }
 418
 419 /***********************************************************************
 420  *              glColor4ui (OPENGL32.@)
 421  */
 422 void WINAPI wine_glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
 423   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 424   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 425   funcs->gl.p_glColor4ui( red, green, blue, alpha );
 426 }
 427
 428 /***********************************************************************
 429  *              glColor4uiv (OPENGL32.@)
 430  */
 431 void WINAPI wine_glColor4uiv( const GLuint* v ) {
 432   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 433   TRACE("(%p)\n", v );
 434   funcs->gl.p_glColor4uiv( v );
 435 }
 436
 437 /***********************************************************************
 438  *              glColor4us (OPENGL32.@)
 439  */
 440 void WINAPI wine_glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) {
 441   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 442   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 443   funcs->gl.p_glColor4us( red, green, blue, alpha );
 444 }
 445
 446 /***********************************************************************
 447  *              glColor4usv (OPENGL32.@)
 448  */
 449 void WINAPI wine_glColor4usv( const GLushort* v ) {
 450   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 451   TRACE("(%p)\n", v );
 452   funcs->gl.p_glColor4usv( v );
 453 }
 454
 455 /***********************************************************************
 456  *              glColorMask (OPENGL32.@)
 457  */
 458 void WINAPI wine_glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
 459   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 460   TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
 461   funcs->gl.p_glColorMask( red, green, blue, alpha );
 462 }
 463
 464 /***********************************************************************
 465  *              glColorMaterial (OPENGL32.@)
 466  */
 467 void WINAPI wine_glColorMaterial( GLenum face, GLenum mode ) {
 468   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 469   TRACE("(%d, %d)\n", face, mode );
 470   funcs->gl.p_glColorMaterial( face, mode );
 471 }
 472
 473 /***********************************************************************
 474  *              glColorPointer (OPENGL32.@)
 475  */
 476 void WINAPI wine_glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) {
 477   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 478   TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
 479   funcs->gl.p_glColorPointer( size, type, stride, pointer );
 480 }
 481
 482 /***********************************************************************
 483  *              glCopyPixels (OPENGL32.@)
 484  */
 485 void WINAPI wine_glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) {
 486   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 487   TRACE("(%d, %d, %d, %d, %d)\n", x, y, width, height, type );
 488   funcs->gl.p_glCopyPixels( x, y, width, height, type );
 489 }
 490
 491 /***********************************************************************
 492  *              glCopyTexImage1D (OPENGL32.@)
 493  */
 494 void WINAPI wine_glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
 495   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 496   TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
 497   funcs->gl.p_glCopyTexImage1D( target, level, internalformat, x, y, width, border );
 498 }
 499
 500 /***********************************************************************
 501  *              glCopyTexImage2D (OPENGL32.@)
 502  */
 503 void WINAPI wine_glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
 504   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 505   TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
 506   funcs->gl.p_glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
 507 }
 508
 509 /***********************************************************************
 510  *              glCopyTexSubImage1D (OPENGL32.@)
 511  */
 512 void WINAPI wine_glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
 513   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 514   TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
 515   funcs->gl.p_glCopyTexSubImage1D( target, level, xoffset, x, y, width );
 516 }
 517
 518 /***********************************************************************
 519  *              glCopyTexSubImage2D (OPENGL32.@)
 520  */
 521 void WINAPI wine_glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
 522   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 523   TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
 524   funcs->gl.p_glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
 525 }
 526
 527 /***********************************************************************
 528  *              glCullFace (OPENGL32.@)
 529  */
 530 void WINAPI wine_glCullFace( GLenum mode ) {
 531   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 532   TRACE("(%d)\n", mode );
 533   funcs->gl.p_glCullFace( mode );
 534 }
 535
 536 /***********************************************************************
 537  *              glDeleteLists (OPENGL32.@)
 538  */
 539 void WINAPI wine_glDeleteLists( GLuint list, GLsizei range ) {
 540   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 541   TRACE("(%d, %d)\n", list, range );
 542   funcs->gl.p_glDeleteLists( list, range );
 543 }
 544
 545 /***********************************************************************
 546  *              glDeleteTextures (OPENGL32.@)
 547  */
 548 void WINAPI wine_glDeleteTextures( GLsizei n, const GLuint* textures ) {
 549   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 550   TRACE("(%d, %p)\n", n, textures );
 551   funcs->gl.p_glDeleteTextures( n, textures );
 552 }
 553
 554 /***********************************************************************
 555  *              glDepthFunc (OPENGL32.@)
 556  */
 557 void WINAPI wine_glDepthFunc( GLenum func ) {
 558   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 559   TRACE("(%d)\n", func );
 560   funcs->gl.p_glDepthFunc( func );
 561 }
 562
 563 /***********************************************************************
 564  *              glDepthMask (OPENGL32.@)
 565  */
 566 void WINAPI wine_glDepthMask( GLboolean flag ) {
 567   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 568   TRACE("(%d)\n", flag );
 569   funcs->gl.p_glDepthMask( flag );
 570 }
 571
 572 /***********************************************************************
 573  *              glDepthRange (OPENGL32.@)
 574  */
 575 void WINAPI wine_glDepthRange( GLdouble nearParam, GLdouble farParam ) {
 576   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 577   TRACE("(%f, %f)\n", nearParam, farParam );
 578   funcs->gl.p_glDepthRange( nearParam, farParam );
 579 }
 580
 581 /***********************************************************************
 582  *              glDisable (OPENGL32.@)
 583  */
 584 void WINAPI wine_glDisable( GLenum cap ) {
 585   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 586   TRACE("(%d)\n", cap );
 587   funcs->gl.p_glDisable( cap );
 588 }
 589
 590 /***********************************************************************
 591  *              glDisableClientState (OPENGL32.@)
 592  */
 593 void WINAPI wine_glDisableClientState( GLenum array ) {
 594   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 595   TRACE("(%d)\n", array );
 596   funcs->gl.p_glDisableClientState( array );
 597 }
 598
 599 /***********************************************************************
 600  *              glDrawArrays (OPENGL32.@)
 601  */
 602 void WINAPI wine_glDrawArrays( GLenum mode, GLint first, GLsizei count ) {
 603   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 604   TRACE("(%d, %d, %d)\n", mode, first, count );
 605   funcs->gl.p_glDrawArrays( mode, first, count );
 606 }
 607
 608 /***********************************************************************
 609  *              glDrawBuffer (OPENGL32.@)
 610  */
 611 void WINAPI wine_glDrawBuffer( GLenum mode ) {
 612   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 613   TRACE("(%d)\n", mode );
 614   funcs->gl.p_glDrawBuffer( mode );
 615 }
 616
 617 /***********************************************************************
 618  *              glDrawElements (OPENGL32.@)
 619  */
 620 void WINAPI wine_glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices ) {
 621   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 622   TRACE("(%d, %d, %d, %p)\n", mode, count, type, indices );
 623   funcs->gl.p_glDrawElements( mode, count, type, indices );
 624 }
 625
 626 /***********************************************************************
 627  *              glDrawPixels (OPENGL32.@)
 628  */
 629 void WINAPI wine_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels ) {
 630   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 631   TRACE("(%d, %d, %d, %d, %p)\n", width, height, format, type, pixels );
 632   funcs->gl.p_glDrawPixels( width, height, format, type, pixels );
 633 }
 634
 635 /***********************************************************************
 636  *              glEdgeFlag (OPENGL32.@)
 637  */
 638 void WINAPI wine_glEdgeFlag( GLboolean flag ) {
 639   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 640   TRACE("(%d)\n", flag );
 641   funcs->gl.p_glEdgeFlag( flag );
 642 }
 643
 644 /***********************************************************************
 645  *              glEdgeFlagPointer (OPENGL32.@)
 646  */
 647 void WINAPI wine_glEdgeFlagPointer( GLsizei stride, const GLvoid* pointer ) {
 648   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 649   TRACE("(%d, %p)\n", stride, pointer );
 650   funcs->gl.p_glEdgeFlagPointer( stride, pointer );
 651 }
 652
 653 /***********************************************************************
 654  *              glEdgeFlagv (OPENGL32.@)
 655  */
 656 void WINAPI wine_glEdgeFlagv( const GLboolean* flag ) {
 657   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 658   TRACE("(%p)\n", flag );
 659   funcs->gl.p_glEdgeFlagv( flag );
 660 }
 661
 662 /***********************************************************************
 663  *              glEnable (OPENGL32.@)
 664  */
 665 void WINAPI wine_glEnable( GLenum cap ) {
 666   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 667   TRACE("(%d)\n", cap );
 668   funcs->gl.p_glEnable( cap );
 669 }
 670
 671 /***********************************************************************
 672  *              glEnableClientState (OPENGL32.@)
 673  */
 674 void WINAPI wine_glEnableClientState( GLenum array ) {
 675   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 676   TRACE("(%d)\n", array );
 677   funcs->gl.p_glEnableClientState( array );
 678 }
 679
 680 /***********************************************************************
 681  *              glEnd (OPENGL32.@)
 682  */
 683 void WINAPI wine_glEnd( void ) {
 684   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 685   TRACE("()\n");
 686   funcs->gl.p_glEnd( );
 687 }
 688
 689 /***********************************************************************
 690  *              glEndList (OPENGL32.@)
 691  */
 692 void WINAPI wine_glEndList( void ) {
 693   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 694   TRACE("()\n");
 695   funcs->gl.p_glEndList( );
 696 }
 697
 698 /***********************************************************************
 699  *              glEvalCoord1d (OPENGL32.@)
 700  */
 701 void WINAPI wine_glEvalCoord1d( GLdouble u ) {
 702   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 703   TRACE("(%f)\n", u );
 704   funcs->gl.p_glEvalCoord1d( u );
 705 }
 706
 707 /***********************************************************************
 708  *              glEvalCoord1dv (OPENGL32.@)
 709  */
 710 void WINAPI wine_glEvalCoord1dv( const GLdouble* u ) {
 711   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 712   TRACE("(%p)\n", u );
 713   funcs->gl.p_glEvalCoord1dv( u );
 714 }
 715
 716 /***********************************************************************
 717  *              glEvalCoord1f (OPENGL32.@)
 718  */
 719 void WINAPI wine_glEvalCoord1f( GLfloat u ) {
 720   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 721   TRACE("(%f)\n", u );
 722   funcs->gl.p_glEvalCoord1f( u );
 723 }
 724
 725 /***********************************************************************
 726  *              glEvalCoord1fv (OPENGL32.@)
 727  */
 728 void WINAPI wine_glEvalCoord1fv( const GLfloat* u ) {
 729   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 730   TRACE("(%p)\n", u );
 731   funcs->gl.p_glEvalCoord1fv( u );
 732 }
 733
 734 /***********************************************************************
 735  *              glEvalCoord2d (OPENGL32.@)
 736  */
 737 void WINAPI wine_glEvalCoord2d( GLdouble u, GLdouble v ) {
 738   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 739   TRACE("(%f, %f)\n", u, v );
 740   funcs->gl.p_glEvalCoord2d( u, v );
 741 }
 742
 743 /***********************************************************************
 744  *              glEvalCoord2dv (OPENGL32.@)
 745  */
 746 void WINAPI wine_glEvalCoord2dv( const GLdouble* u ) {
 747   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 748   TRACE("(%p)\n", u );
 749   funcs->gl.p_glEvalCoord2dv( u );
 750 }
 751
 752 /***********************************************************************
 753  *              glEvalCoord2f (OPENGL32.@)
 754  */
 755 void WINAPI wine_glEvalCoord2f( GLfloat u, GLfloat v ) {
 756   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 757   TRACE("(%f, %f)\n", u, v );
 758   funcs->gl.p_glEvalCoord2f( u, v );
 759 }
 760
 761 /***********************************************************************
 762  *              glEvalCoord2fv (OPENGL32.@)
 763  */
 764 void WINAPI wine_glEvalCoord2fv( const GLfloat* u ) {
 765   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 766   TRACE("(%p)\n", u );
 767   funcs->gl.p_glEvalCoord2fv( u );
 768 }
 769
 770 /***********************************************************************
 771  *              glEvalMesh1 (OPENGL32.@)
 772  */
 773 void WINAPI wine_glEvalMesh1( GLenum mode, GLint i1, GLint i2 ) {
 774   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 775   TRACE("(%d, %d, %d)\n", mode, i1, i2 );
 776   funcs->gl.p_glEvalMesh1( mode, i1, i2 );
 777 }
 778
 779 /***********************************************************************
 780  *              glEvalMesh2 (OPENGL32.@)
 781  */
 782 void WINAPI wine_glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) {
 783   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 784   TRACE("(%d, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2 );
 785   funcs->gl.p_glEvalMesh2( mode, i1, i2, j1, j2 );
 786 }
 787
 788 /***********************************************************************
 789  *              glEvalPoint1 (OPENGL32.@)
 790  */
 791 void WINAPI wine_glEvalPoint1( GLint i ) {
 792   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 793   TRACE("(%d)\n", i );
 794   funcs->gl.p_glEvalPoint1( i );
 795 }
 796
 797 /***********************************************************************
 798  *              glEvalPoint2 (OPENGL32.@)
 799  */
 800 void WINAPI wine_glEvalPoint2( GLint i, GLint j ) {
 801   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 802   TRACE("(%d, %d)\n", i, j );
 803   funcs->gl.p_glEvalPoint2( i, j );
 804 }
 805
 806 /***********************************************************************
 807  *              glFeedbackBuffer (OPENGL32.@)
 808  */
 809 void WINAPI wine_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat* buffer ) {
 810   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 811   TRACE("(%d, %d, %p)\n", size, type, buffer );
 812   funcs->gl.p_glFeedbackBuffer( size, type, buffer );
 813 }
 814
 815 /***********************************************************************
 816  *              glFinish (OPENGL32.@)
 817  */
 818 void WINAPI wine_glFinish( void ) {
 819   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 820   TRACE("()\n");
 821   funcs->gl.p_glFinish( );
 822 }
 823
 824 /***********************************************************************
 825  *              glFlush (OPENGL32.@)
 826  */
 827 void WINAPI wine_glFlush( void ) {
 828   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 829   TRACE("()\n");
 830   funcs->gl.p_glFlush( );
 831 }
 832
 833 /***********************************************************************
 834  *              glFogf (OPENGL32.@)
 835  */
 836 void WINAPI wine_glFogf( GLenum pname, GLfloat param ) {
 837   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 838   TRACE("(%d, %f)\n", pname, param );
 839   funcs->gl.p_glFogf( pname, param );
 840 }
 841
 842 /***********************************************************************
 843  *              glFogfv (OPENGL32.@)
 844  */
 845 void WINAPI wine_glFogfv( GLenum pname, const GLfloat* params ) {
 846   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 847   TRACE("(%d, %p)\n", pname, params );
 848   funcs->gl.p_glFogfv( pname, params );
 849 }
 850
 851 /***********************************************************************
 852  *              glFogi (OPENGL32.@)
 853  */
 854 void WINAPI wine_glFogi( GLenum pname, GLint param ) {
 855   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 856   TRACE("(%d, %d)\n", pname, param );
 857   funcs->gl.p_glFogi( pname, param );
 858 }
 859
 860 /***********************************************************************
 861  *              glFogiv (OPENGL32.@)
 862  */
 863 void WINAPI wine_glFogiv( GLenum pname, const GLint* params ) {
 864   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 865   TRACE("(%d, %p)\n", pname, params );
 866   funcs->gl.p_glFogiv( pname, params );
 867 }
 868
 869 /***********************************************************************
 870  *              glFrontFace (OPENGL32.@)
 871  */
 872 void WINAPI wine_glFrontFace( GLenum mode ) {
 873   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 874   TRACE("(%d)\n", mode );
 875   funcs->gl.p_glFrontFace( mode );
 876 }
 877
 878 /***********************************************************************
 879  *              glFrustum (OPENGL32.@)
 880  */
 881 void WINAPI wine_glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
 882   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 883   TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
 884   funcs->gl.p_glFrustum( left, right, bottom, top, zNear, zFar );
 885 }
 886
 887 /***********************************************************************
 888  *              glGenLists (OPENGL32.@)
 889  */
 890 GLuint WINAPI wine_glGenLists( GLsizei range ) {
 891   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 892   TRACE("(%d)\n", range );
 893   return funcs->gl.p_glGenLists( range );
 894 }
 895
 896 /***********************************************************************
 897  *              glGenTextures (OPENGL32.@)
 898  */
 899 void WINAPI wine_glGenTextures( GLsizei n, GLuint* textures ) {
 900   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 901   TRACE("(%d, %p)\n", n, textures );
 902   funcs->gl.p_glGenTextures( n, textures );
 903 }
 904
 905 /***********************************************************************
 906  *              glGetBooleanv (OPENGL32.@)
 907  */
 908 void WINAPI wine_glGetBooleanv( GLenum pname, GLboolean* params ) {
 909   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 910   TRACE("(%d, %p)\n", pname, params );
 911   funcs->gl.p_glGetBooleanv( pname, params );
 912 }
 913
 914 /***********************************************************************
 915  *              glGetClipPlane (OPENGL32.@)
 916  */
 917 void WINAPI wine_glGetClipPlane( GLenum plane, GLdouble* equation ) {
 918   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 919   TRACE("(%d, %p)\n", plane, equation );
 920   funcs->gl.p_glGetClipPlane( plane, equation );
 921 }
 922
 923 /***********************************************************************
 924  *              glGetDoublev (OPENGL32.@)
 925  */
 926 void WINAPI wine_glGetDoublev( GLenum pname, GLdouble* params ) {
 927   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 928   TRACE("(%d, %p)\n", pname, params );
 929   funcs->gl.p_glGetDoublev( pname, params );
 930 }
 931
 932 /***********************************************************************
 933  *              glGetError (OPENGL32.@)
 934  */
 935 GLenum WINAPI wine_glGetError( void ) {
 936   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 937   TRACE("()\n");
 938   return funcs->gl.p_glGetError( );
 939 }
 940
 941 /***********************************************************************
 942  *              glGetFloatv (OPENGL32.@)
 943  */
 944 void WINAPI wine_glGetFloatv( GLenum pname, GLfloat* params ) {
 945   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 946   TRACE("(%d, %p)\n", pname, params );
 947   funcs->gl.p_glGetFloatv( pname, params );
 948 }
 949
 950 /***********************************************************************
 951  *              glGetIntegerv (OPENGL32.@)
 952  */
 953 void WINAPI wine_glGetIntegerv( GLenum pname, GLint* params ) {
 954   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 955   TRACE("(%d, %p)\n", pname, params );
 956   funcs->gl.p_glGetIntegerv( pname, params );
 957 }
 958
 959 /***********************************************************************
 960  *              glGetLightfv (OPENGL32.@)
 961  */
 962 void WINAPI wine_glGetLightfv( GLenum light, GLenum pname, GLfloat* params ) {
 963   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 964   TRACE("(%d, %d, %p)\n", light, pname, params );
 965   funcs->gl.p_glGetLightfv( light, pname, params );
 966 }
 967
 968 /***********************************************************************
 969  *              glGetLightiv (OPENGL32.@)
 970  */
 971 void WINAPI wine_glGetLightiv( GLenum light, GLenum pname, GLint* params ) {
 972   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 973   TRACE("(%d, %d, %p)\n", light, pname, params );
 974   funcs->gl.p_glGetLightiv( light, pname, params );
 975 }
 976
 977 /***********************************************************************
 978  *              glGetMapdv (OPENGL32.@)
 979  */
 980 void WINAPI wine_glGetMapdv( GLenum target, GLenum query, GLdouble* v ) {
 981   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 982   TRACE("(%d, %d, %p)\n", target, query, v );
 983   funcs->gl.p_glGetMapdv( target, query, v );
 984 }
 985
 986 /***********************************************************************
 987  *              glGetMapfv (OPENGL32.@)
 988  */
 989 void WINAPI wine_glGetMapfv( GLenum target, GLenum query, GLfloat* v ) {
 990   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
 991   TRACE("(%d, %d, %p)\n", target, query, v );
 992   funcs->gl.p_glGetMapfv( target, query, v );
 993 }
 994
 995 /***********************************************************************
 996  *              glGetMapiv (OPENGL32.@)
 997  */
 998 void WINAPI wine_glGetMapiv( GLenum target, GLenum query, GLint* v ) {
 999   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1000   TRACE("(%d, %d, %p)\n", target, query, v );
1001   funcs->gl.p_glGetMapiv( target, query, v );
1002 }
1003
1004 /***********************************************************************
1005  *              glGetMaterialfv (OPENGL32.@)
1006  */
1007 void WINAPI wine_glGetMaterialfv( GLenum face, GLenum pname, GLfloat* params ) {
1008   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1009   TRACE("(%d, %d, %p)\n", face, pname, params );
1010   funcs->gl.p_glGetMaterialfv( face, pname, params );
1011 }
1012
1013 /***********************************************************************
1014  *              glGetMaterialiv (OPENGL32.@)
1015  */
1016 void WINAPI wine_glGetMaterialiv( GLenum face, GLenum pname, GLint* params ) {
1017   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1018   TRACE("(%d, %d, %p)\n", face, pname, params );
1019   funcs->gl.p_glGetMaterialiv( face, pname, params );
1020 }
1021
1022 /***********************************************************************
1023  *              glGetPixelMapfv (OPENGL32.@)
1024  */
1025 void WINAPI wine_glGetPixelMapfv( GLenum map, GLfloat* values ) {
1026   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1027   TRACE("(%d, %p)\n", map, values );
1028   funcs->gl.p_glGetPixelMapfv( map, values );
1029 }
1030
1031 /***********************************************************************
1032  *              glGetPixelMapuiv (OPENGL32.@)
1033  */
1034 void WINAPI wine_glGetPixelMapuiv( GLenum map, GLuint* values ) {
1035   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1036   TRACE("(%d, %p)\n", map, values );
1037   funcs->gl.p_glGetPixelMapuiv( map, values );
1038 }
1039
1040 /***********************************************************************
1041  *              glGetPixelMapusv (OPENGL32.@)
1042  */
1043 void WINAPI wine_glGetPixelMapusv( GLenum map, GLushort* values ) {
1044   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1045   TRACE("(%d, %p)\n", map, values );
1046   funcs->gl.p_glGetPixelMapusv( map, values );
1047 }
1048
1049 /***********************************************************************
1050  *              glGetPointerv (OPENGL32.@)
1051  */
1052 void WINAPI wine_glGetPointerv( GLenum pname, GLvoid** params ) {
1053   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1054   TRACE("(%d, %p)\n", pname, params );
1055   funcs->gl.p_glGetPointerv( pname, params );
1056 }
1057
1058 /***********************************************************************
1059  *              glGetPolygonStipple (OPENGL32.@)
1060  */
1061 void WINAPI wine_glGetPolygonStipple( GLubyte* mask ) {
1062   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1063   TRACE("(%p)\n", mask );
1064   funcs->gl.p_glGetPolygonStipple( mask );
1065 }
1066
1067 /***********************************************************************
1068  *              glGetTexEnvfv (OPENGL32.@)
1069  */
1070 void WINAPI wine_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) {
1071   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1072   TRACE("(%d, %d, %p)\n", target, pname, params );
1073   funcs->gl.p_glGetTexEnvfv( target, pname, params );
1074 }
1075
1076 /***********************************************************************
1077  *              glGetTexEnviv (OPENGL32.@)
1078  */
1079 void WINAPI wine_glGetTexEnviv( GLenum target, GLenum pname, GLint* params ) {
1080   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1081   TRACE("(%d, %d, %p)\n", target, pname, params );
1082   funcs->gl.p_glGetTexEnviv( target, pname, params );
1083 }
1084
1085 /***********************************************************************
1086  *              glGetTexGendv (OPENGL32.@)
1087  */
1088 void WINAPI wine_glGetTexGendv( GLenum coord, GLenum pname, GLdouble* params ) {
1089   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1090   TRACE("(%d, %d, %p)\n", coord, pname, params );
1091   funcs->gl.p_glGetTexGendv( coord, pname, params );
1092 }
1093
1094 /***********************************************************************
1095  *              glGetTexGenfv (OPENGL32.@)
1096  */
1097 void WINAPI wine_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) {
1098   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1099   TRACE("(%d, %d, %p)\n", coord, pname, params );
1100   funcs->gl.p_glGetTexGenfv( coord, pname, params );
1101 }
1102
1103 /***********************************************************************
1104  *              glGetTexGeniv (OPENGL32.@)
1105  */
1106 void WINAPI wine_glGetTexGeniv( GLenum coord, GLenum pname, GLint* params ) {
1107   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1108   TRACE("(%d, %d, %p)\n", coord, pname, params );
1109   funcs->gl.p_glGetTexGeniv( coord, pname, params );
1110 }
1111
1112 /***********************************************************************
1113  *              glGetTexImage (OPENGL32.@)
1114  */
1115 void WINAPI wine_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels ) {
1116   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1117   TRACE("(%d, %d, %d, %d, %p)\n", target, level, format, type, pixels );
1118   funcs->gl.p_glGetTexImage( target, level, format, type, pixels );
1119 }
1120
1121 /***********************************************************************
1122  *              glGetTexLevelParameterfv (OPENGL32.@)
1123  */
1124 void WINAPI wine_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat* params ) {
1125   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1126   TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
1127   funcs->gl.p_glGetTexLevelParameterfv( target, level, pname, params );
1128 }
1129
1130 /***********************************************************************
1131  *              glGetTexLevelParameteriv (OPENGL32.@)
1132  */
1133 void WINAPI wine_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint* params ) {
1134   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1135   TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
1136   funcs->gl.p_glGetTexLevelParameteriv( target, level, pname, params );
1137 }
1138
1139 /***********************************************************************
1140  *              glGetTexParameterfv (OPENGL32.@)
1141  */
1142 void WINAPI wine_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
1143   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1144   TRACE("(%d, %d, %p)\n", target, pname, params );
1145   funcs->gl.p_glGetTexParameterfv( target, pname, params );
1146 }
1147
1148 /***********************************************************************
1149  *              glGetTexParameteriv (OPENGL32.@)
1150  */
1151 void WINAPI wine_glGetTexParameteriv( GLenum target, GLenum pname, GLint* params ) {
1152   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1153   TRACE("(%d, %d, %p)\n", target, pname, params );
1154   funcs->gl.p_glGetTexParameteriv( target, pname, params );
1155 }
1156
1157 /***********************************************************************
1158  *              glHint (OPENGL32.@)
1159  */
1160 void WINAPI wine_glHint( GLenum target, GLenum mode ) {
1161   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1162   TRACE("(%d, %d)\n", target, mode );
1163   funcs->gl.p_glHint( target, mode );
1164 }
1165
1166 /***********************************************************************
1167  *              glIndexMask (OPENGL32.@)
1168  */
1169 void WINAPI wine_glIndexMask( GLuint mask ) {
1170   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1171   TRACE("(%d)\n", mask );
1172   funcs->gl.p_glIndexMask( mask );
1173 }
1174
1175 /***********************************************************************
1176  *              glIndexPointer (OPENGL32.@)
1177  */
1178 void WINAPI wine_glIndexPointer( GLenum type, GLsizei stride, const GLvoid* pointer ) {
1179   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1180   TRACE("(%d, %d, %p)\n", type, stride, pointer );
1181   funcs->gl.p_glIndexPointer( type, stride, pointer );
1182 }
1183
1184 /***********************************************************************
1185  *              glIndexd (OPENGL32.@)
1186  */
1187 void WINAPI wine_glIndexd( GLdouble c ) {
1188   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1189   TRACE("(%f)\n", c );
1190   funcs->gl.p_glIndexd( c );
1191 }
1192
1193 /***********************************************************************
1194  *              glIndexdv (OPENGL32.@)
1195  */
1196 void WINAPI wine_glIndexdv( const GLdouble* c ) {
1197   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1198   TRACE("(%p)\n", c );
1199   funcs->gl.p_glIndexdv( c );
1200 }
1201
1202 /***********************************************************************
1203  *              glIndexf (OPENGL32.@)
1204  */
1205 void WINAPI wine_glIndexf( GLfloat c ) {
1206   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1207   TRACE("(%f)\n", c );
1208   funcs->gl.p_glIndexf( c );
1209 }
1210
1211 /***********************************************************************
1212  *              glIndexfv (OPENGL32.@)
1213  */
1214 void WINAPI wine_glIndexfv( const GLfloat* c ) {
1215   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1216   TRACE("(%p)\n", c );
1217   funcs->gl.p_glIndexfv( c );
1218 }
1219
1220 /***********************************************************************
1221  *              glIndexi (OPENGL32.@)
1222  */
1223 void WINAPI wine_glIndexi( GLint c ) {
1224   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1225   TRACE("(%d)\n", c );
1226   funcs->gl.p_glIndexi( c );
1227 }
1228
1229 /***********************************************************************
1230  *              glIndexiv (OPENGL32.@)
1231  */
1232 void WINAPI wine_glIndexiv( const GLint* c ) {
1233   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1234   TRACE("(%p)\n", c );
1235   funcs->gl.p_glIndexiv( c );
1236 }
1237
1238 /***********************************************************************
1239  *              glIndexs (OPENGL32.@)
1240  */
1241 void WINAPI wine_glIndexs( GLshort c ) {
1242   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1243   TRACE("(%d)\n", c );
1244   funcs->gl.p_glIndexs( c );
1245 }
1246
1247 /***********************************************************************
1248  *              glIndexsv (OPENGL32.@)
1249  */
1250 void WINAPI wine_glIndexsv( const GLshort* c ) {
1251   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1252   TRACE("(%p)\n", c );
1253   funcs->gl.p_glIndexsv( c );
1254 }
1255
1256 /***********************************************************************
1257  *              glIndexub (OPENGL32.@)
1258  */
1259 void WINAPI wine_glIndexub( GLubyte c ) {
1260   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1261   TRACE("(%d)\n", c );
1262   funcs->gl.p_glIndexub( c );
1263 }
1264
1265 /***********************************************************************
1266  *              glIndexubv (OPENGL32.@)
1267  */
1268 void WINAPI wine_glIndexubv( const GLubyte* c ) {
1269   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1270   TRACE("(%p)\n", c );
1271   funcs->gl.p_glIndexubv( c );
1272 }
1273
1274 /***********************************************************************
1275  *              glInitNames (OPENGL32.@)
1276  */
1277 void WINAPI wine_glInitNames( void ) {
1278   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1279   TRACE("()\n");
1280   funcs->gl.p_glInitNames( );
1281 }
1282
1283 /***********************************************************************
1284  *              glInterleavedArrays (OPENGL32.@)
1285  */
1286 void WINAPI wine_glInterleavedArrays( GLenum format, GLsizei stride, const GLvoid* pointer ) {
1287   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1288   TRACE("(%d, %d, %p)\n", format, stride, pointer );
1289   funcs->gl.p_glInterleavedArrays( format, stride, pointer );
1290 }
1291
1292 /***********************************************************************
1293  *              glIsEnabled (OPENGL32.@)
1294  */
1295 GLboolean WINAPI wine_glIsEnabled( GLenum cap ) {
1296   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1297   TRACE("(%d)\n", cap );
1298   return funcs->gl.p_glIsEnabled( cap );
1299 }
1300
1301 /***********************************************************************
1302  *              glIsList (OPENGL32.@)
1303  */
1304 GLboolean WINAPI wine_glIsList( GLuint list ) {
1305   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1306   TRACE("(%d)\n", list );
1307   return funcs->gl.p_glIsList( list );
1308 }
1309
1310 /***********************************************************************
1311  *              glIsTexture (OPENGL32.@)
1312  */
1313 GLboolean WINAPI wine_glIsTexture( GLuint texture ) {
1314   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1315   TRACE("(%d)\n", texture );
1316   return funcs->gl.p_glIsTexture( texture );
1317 }
1318
1319 /***********************************************************************
1320  *              glLightModelf (OPENGL32.@)
1321  */
1322 void WINAPI wine_glLightModelf( GLenum pname, GLfloat param ) {
1323   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1324   TRACE("(%d, %f)\n", pname, param );
1325   funcs->gl.p_glLightModelf( pname, param );
1326 }
1327
1328 /***********************************************************************
1329  *              glLightModelfv (OPENGL32.@)
1330  */
1331 void WINAPI wine_glLightModelfv( GLenum pname, const GLfloat* params ) {
1332   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1333   TRACE("(%d, %p)\n", pname, params );
1334   funcs->gl.p_glLightModelfv( pname, params );
1335 }
1336
1337 /***********************************************************************
1338  *              glLightModeli (OPENGL32.@)
1339  */
1340 void WINAPI wine_glLightModeli( GLenum pname, GLint param ) {
1341   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1342   TRACE("(%d, %d)\n", pname, param );
1343   funcs->gl.p_glLightModeli( pname, param );
1344 }
1345
1346 /***********************************************************************
1347  *              glLightModeliv (OPENGL32.@)
1348  */
1349 void WINAPI wine_glLightModeliv( GLenum pname, const GLint* params ) {
1350   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1351   TRACE("(%d, %p)\n", pname, params );
1352   funcs->gl.p_glLightModeliv( pname, params );
1353 }
1354
1355 /***********************************************************************
1356  *              glLightf (OPENGL32.@)
1357  */
1358 void WINAPI wine_glLightf( GLenum light, GLenum pname, GLfloat param ) {
1359   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1360   TRACE("(%d, %d, %f)\n", light, pname, param );
1361   funcs->gl.p_glLightf( light, pname, param );
1362 }
1363
1364 /***********************************************************************
1365  *              glLightfv (OPENGL32.@)
1366  */
1367 void WINAPI wine_glLightfv( GLenum light, GLenum pname, const GLfloat* params ) {
1368   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1369   TRACE("(%d, %d, %p)\n", light, pname, params );
1370   funcs->gl.p_glLightfv( light, pname, params );
1371 }
1372
1373 /***********************************************************************
1374  *              glLighti (OPENGL32.@)
1375  */
1376 void WINAPI wine_glLighti( GLenum light, GLenum pname, GLint param ) {
1377   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1378   TRACE("(%d, %d, %d)\n", light, pname, param );
1379   funcs->gl.p_glLighti( light, pname, param );
1380 }
1381
1382 /***********************************************************************
1383  *              glLightiv (OPENGL32.@)
1384  */
1385 void WINAPI wine_glLightiv( GLenum light, GLenum pname, const GLint* params ) {
1386   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1387   TRACE("(%d, %d, %p)\n", light, pname, params );
1388   funcs->gl.p_glLightiv( light, pname, params );
1389 }
1390
1391 /***********************************************************************
1392  *              glLineStipple (OPENGL32.@)
1393  */
1394 void WINAPI wine_glLineStipple( GLint factor, GLushort pattern ) {
1395   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1396   TRACE("(%d, %d)\n", factor, pattern );
1397   funcs->gl.p_glLineStipple( factor, pattern );
1398 }
1399
1400 /***********************************************************************
1401  *              glLineWidth (OPENGL32.@)
1402  */
1403 void WINAPI wine_glLineWidth( GLfloat width ) {
1404   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1405   TRACE("(%f)\n", width );
1406   funcs->gl.p_glLineWidth( width );
1407 }
1408
1409 /***********************************************************************
1410  *              glListBase (OPENGL32.@)
1411  */
1412 void WINAPI wine_glListBase( GLuint base ) {
1413   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1414   TRACE("(%d)\n", base );
1415   funcs->gl.p_glListBase( base );
1416 }
1417
1418 /***********************************************************************
1419  *              glLoadIdentity (OPENGL32.@)
1420  */
1421 void WINAPI wine_glLoadIdentity( void ) {
1422   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1423   TRACE("()\n");
1424   funcs->gl.p_glLoadIdentity( );
1425 }
1426
1427 /***********************************************************************
1428  *              glLoadMatrixd (OPENGL32.@)
1429  */
1430 void WINAPI wine_glLoadMatrixd( const GLdouble* m ) {
1431   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1432   TRACE("(%p)\n", m );
1433   funcs->gl.p_glLoadMatrixd( m );
1434 }
1435
1436 /***********************************************************************
1437  *              glLoadMatrixf (OPENGL32.@)
1438  */
1439 void WINAPI wine_glLoadMatrixf( const GLfloat* m ) {
1440   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1441   TRACE("(%p)\n", m );
1442   funcs->gl.p_glLoadMatrixf( m );
1443 }
1444
1445 /***********************************************************************
1446  *              glLoadName (OPENGL32.@)
1447  */
1448 void WINAPI wine_glLoadName( GLuint name ) {
1449   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1450   TRACE("(%d)\n", name );
1451   funcs->gl.p_glLoadName( name );
1452 }
1453
1454 /***********************************************************************
1455  *              glLogicOp (OPENGL32.@)
1456  */
1457 void WINAPI wine_glLogicOp( GLenum opcode ) {
1458   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1459   TRACE("(%d)\n", opcode );
1460   funcs->gl.p_glLogicOp( opcode );
1461 }
1462
1463 /***********************************************************************
1464  *              glMap1d (OPENGL32.@)
1465  */
1466 void WINAPI wine_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) {
1467   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1468   TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
1469   funcs->gl.p_glMap1d( target, u1, u2, stride, order, points );
1470 }
1471
1472 /***********************************************************************
1473  *              glMap1f (OPENGL32.@)
1474  */
1475 void WINAPI wine_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) {
1476   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1477   TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
1478   funcs->gl.p_glMap1f( target, u1, u2, stride, order, points );
1479 }
1480
1481 /***********************************************************************
1482  *              glMap2d (OPENGL32.@)
1483  */
1484 void WINAPI wine_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) {
1485   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1486   TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1487   funcs->gl.p_glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1488 }
1489
1490 /***********************************************************************
1491  *              glMap2f (OPENGL32.@)
1492  */
1493 void WINAPI wine_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) {
1494   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1495   TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1496   funcs->gl.p_glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
1497 }
1498
1499 /***********************************************************************
1500  *              glMapGrid1d (OPENGL32.@)
1501  */
1502 void WINAPI wine_glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) {
1503   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1504   TRACE("(%d, %f, %f)\n", un, u1, u2 );
1505   funcs->gl.p_glMapGrid1d( un, u1, u2 );
1506 }
1507
1508 /***********************************************************************
1509  *              glMapGrid1f (OPENGL32.@)
1510  */
1511 void WINAPI wine_glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) {
1512   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1513   TRACE("(%d, %f, %f)\n", un, u1, u2 );
1514   funcs->gl.p_glMapGrid1f( un, u1, u2 );
1515 }
1516
1517 /***********************************************************************
1518  *              glMapGrid2d (OPENGL32.@)
1519  */
1520 void WINAPI wine_glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) {
1521   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1522   TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
1523   funcs->gl.p_glMapGrid2d( un, u1, u2, vn, v1, v2 );
1524 }
1525
1526 /***********************************************************************
1527  *              glMapGrid2f (OPENGL32.@)
1528  */
1529 void WINAPI wine_glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) {
1530   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1531   TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
1532   funcs->gl.p_glMapGrid2f( un, u1, u2, vn, v1, v2 );
1533 }
1534
1535 /***********************************************************************
1536  *              glMaterialf (OPENGL32.@)
1537  */
1538 void WINAPI wine_glMaterialf( GLenum face, GLenum pname, GLfloat param ) {
1539   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1540   TRACE("(%d, %d, %f)\n", face, pname, param );
1541   funcs->gl.p_glMaterialf( face, pname, param );
1542 }
1543
1544 /***********************************************************************
1545  *              glMaterialfv (OPENGL32.@)
1546  */
1547 void WINAPI wine_glMaterialfv( GLenum face, GLenum pname, const GLfloat* params ) {
1548   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1549   TRACE("(%d, %d, %p)\n", face, pname, params );
1550   funcs->gl.p_glMaterialfv( face, pname, params );
1551 }
1552
1553 /***********************************************************************
1554  *              glMateriali (OPENGL32.@)
1555  */
1556 void WINAPI wine_glMateriali( GLenum face, GLenum pname, GLint param ) {
1557   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1558   TRACE("(%d, %d, %d)\n", face, pname, param );
1559   funcs->gl.p_glMateriali( face, pname, param );
1560 }
1561
1562 /***********************************************************************
1563  *              glMaterialiv (OPENGL32.@)
1564  */
1565 void WINAPI wine_glMaterialiv( GLenum face, GLenum pname, const GLint* params ) {
1566   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1567   TRACE("(%d, %d, %p)\n", face, pname, params );
1568   funcs->gl.p_glMaterialiv( face, pname, params );
1569 }
1570
1571 /***********************************************************************
1572  *              glMatrixMode (OPENGL32.@)
1573  */
1574 void WINAPI wine_glMatrixMode( GLenum mode ) {
1575   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1576   TRACE("(%d)\n", mode );
1577   funcs->gl.p_glMatrixMode( mode );
1578 }
1579
1580 /***********************************************************************
1581  *              glMultMatrixd (OPENGL32.@)
1582  */
1583 void WINAPI wine_glMultMatrixd( const GLdouble* m ) {
1584   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1585   TRACE("(%p)\n", m );
1586   funcs->gl.p_glMultMatrixd( m );
1587 }
1588
1589 /***********************************************************************
1590  *              glMultMatrixf (OPENGL32.@)
1591  */
1592 void WINAPI wine_glMultMatrixf( const GLfloat* m ) {
1593   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1594   TRACE("(%p)\n", m );
1595   funcs->gl.p_glMultMatrixf( m );
1596 }
1597
1598 /***********************************************************************
1599  *              glNewList (OPENGL32.@)
1600  */
1601 void WINAPI wine_glNewList( GLuint list, GLenum mode ) {
1602   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1603   TRACE("(%d, %d)\n", list, mode );
1604   funcs->gl.p_glNewList( list, mode );
1605 }
1606
1607 /***********************************************************************
1608  *              glNormal3b (OPENGL32.@)
1609  */
1610 void WINAPI wine_glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) {
1611   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1612   TRACE("(%d, %d, %d)\n", nx, ny, nz );
1613   funcs->gl.p_glNormal3b( nx, ny, nz );
1614 }
1615
1616 /***********************************************************************
1617  *              glNormal3bv (OPENGL32.@)
1618  */
1619 void WINAPI wine_glNormal3bv( const GLbyte* v ) {
1620   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1621   TRACE("(%p)\n", v );
1622   funcs->gl.p_glNormal3bv( v );
1623 }
1624
1625 /***********************************************************************
1626  *              glNormal3d (OPENGL32.@)
1627  */
1628 void WINAPI wine_glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) {
1629   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1630   TRACE("(%f, %f, %f)\n", nx, ny, nz );
1631   funcs->gl.p_glNormal3d( nx, ny, nz );
1632 }
1633
1634 /***********************************************************************
1635  *              glNormal3dv (OPENGL32.@)
1636  */
1637 void WINAPI wine_glNormal3dv( const GLdouble* v ) {
1638   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1639   TRACE("(%p)\n", v );
1640   funcs->gl.p_glNormal3dv( v );
1641 }
1642
1643 /***********************************************************************
1644  *              glNormal3f (OPENGL32.@)
1645  */
1646 void WINAPI wine_glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) {
1647   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1648   TRACE("(%f, %f, %f)\n", nx, ny, nz );
1649   funcs->gl.p_glNormal3f( nx, ny, nz );
1650 }
1651
1652 /***********************************************************************
1653  *              glNormal3fv (OPENGL32.@)
1654  */
1655 void WINAPI wine_glNormal3fv( const GLfloat* v ) {
1656   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1657   TRACE("(%p)\n", v );
1658   funcs->gl.p_glNormal3fv( v );
1659 }
1660
1661 /***********************************************************************
1662  *              glNormal3i (OPENGL32.@)
1663  */
1664 void WINAPI wine_glNormal3i( GLint nx, GLint ny, GLint nz ) {
1665   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1666   TRACE("(%d, %d, %d)\n", nx, ny, nz );
1667   funcs->gl.p_glNormal3i( nx, ny, nz );
1668 }
1669
1670 /***********************************************************************
1671  *              glNormal3iv (OPENGL32.@)
1672  */
1673 void WINAPI wine_glNormal3iv( const GLint* v ) {
1674   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1675   TRACE("(%p)\n", v );
1676   funcs->gl.p_glNormal3iv( v );
1677 }
1678
1679 /***********************************************************************
1680  *              glNormal3s (OPENGL32.@)
1681  */
1682 void WINAPI wine_glNormal3s( GLshort nx, GLshort ny, GLshort nz ) {
1683   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1684   TRACE("(%d, %d, %d)\n", nx, ny, nz );
1685   funcs->gl.p_glNormal3s( nx, ny, nz );
1686 }
1687
1688 /***********************************************************************
1689  *              glNormal3sv (OPENGL32.@)
1690  */
1691 void WINAPI wine_glNormal3sv( const GLshort* v ) {
1692   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1693   TRACE("(%p)\n", v );
1694   funcs->gl.p_glNormal3sv( v );
1695 }
1696
1697 /***********************************************************************
1698  *              glNormalPointer (OPENGL32.@)
1699  */
1700 void WINAPI wine_glNormalPointer( GLenum type, GLsizei stride, const GLvoid* pointer ) {
1701   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1702   TRACE("(%d, %d, %p)\n", type, stride, pointer );
1703   funcs->gl.p_glNormalPointer( type, stride, pointer );
1704 }
1705
1706 /***********************************************************************
1707  *              glOrtho (OPENGL32.@)
1708  */
1709 void WINAPI wine_glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
1710   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1711   TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
1712   funcs->gl.p_glOrtho( left, right, bottom, top, zNear, zFar );
1713 }
1714
1715 /***********************************************************************
1716  *              glPassThrough (OPENGL32.@)
1717  */
1718 void WINAPI wine_glPassThrough( GLfloat token ) {
1719   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1720   TRACE("(%f)\n", token );
1721   funcs->gl.p_glPassThrough( token );
1722 }
1723
1724 /***********************************************************************
1725  *              glPixelMapfv (OPENGL32.@)
1726  */
1727 void WINAPI wine_glPixelMapfv( GLenum map, GLint mapsize, const GLfloat* values ) {
1728   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1729   TRACE("(%d, %d, %p)\n", map, mapsize, values );
1730   funcs->gl.p_glPixelMapfv( map, mapsize, values );
1731 }
1732
1733 /***********************************************************************
1734  *              glPixelMapuiv (OPENGL32.@)
1735  */
1736 void WINAPI wine_glPixelMapuiv( GLenum map, GLint mapsize, const GLuint* values ) {
1737   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1738   TRACE("(%d, %d, %p)\n", map, mapsize, values );
1739   funcs->gl.p_glPixelMapuiv( map, mapsize, values );
1740 }
1741
1742 /***********************************************************************
1743  *              glPixelMapusv (OPENGL32.@)
1744  */
1745 void WINAPI wine_glPixelMapusv( GLenum map, GLint mapsize, const GLushort* values ) {
1746   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1747   TRACE("(%d, %d, %p)\n", map, mapsize, values );
1748   funcs->gl.p_glPixelMapusv( map, mapsize, values );
1749 }
1750
1751 /***********************************************************************
1752  *              glPixelStoref (OPENGL32.@)
1753  */
1754 void WINAPI wine_glPixelStoref( GLenum pname, GLfloat param ) {
1755   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1756   TRACE("(%d, %f)\n", pname, param );
1757   funcs->gl.p_glPixelStoref( pname, param );
1758 }
1759
1760 /***********************************************************************
1761  *              glPixelStorei (OPENGL32.@)
1762  */
1763 void WINAPI wine_glPixelStorei( GLenum pname, GLint param ) {
1764   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1765   TRACE("(%d, %d)\n", pname, param );
1766   funcs->gl.p_glPixelStorei( pname, param );
1767 }
1768
1769 /***********************************************************************
1770  *              glPixelTransferf (OPENGL32.@)
1771  */
1772 void WINAPI wine_glPixelTransferf( GLenum pname, GLfloat param ) {
1773   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1774   TRACE("(%d, %f)\n", pname, param );
1775   funcs->gl.p_glPixelTransferf( pname, param );
1776 }
1777
1778 /***********************************************************************
1779  *              glPixelTransferi (OPENGL32.@)
1780  */
1781 void WINAPI wine_glPixelTransferi( GLenum pname, GLint param ) {
1782   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1783   TRACE("(%d, %d)\n", pname, param );
1784   funcs->gl.p_glPixelTransferi( pname, param );
1785 }
1786
1787 /***********************************************************************
1788  *              glPixelZoom (OPENGL32.@)
1789  */
1790 void WINAPI wine_glPixelZoom( GLfloat xfactor, GLfloat yfactor ) {
1791   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1792   TRACE("(%f, %f)\n", xfactor, yfactor );
1793   funcs->gl.p_glPixelZoom( xfactor, yfactor );
1794 }
1795
1796 /***********************************************************************
1797  *              glPointSize (OPENGL32.@)
1798  */
1799 void WINAPI wine_glPointSize( GLfloat size ) {
1800   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1801   TRACE("(%f)\n", size );
1802   funcs->gl.p_glPointSize( size );
1803 }
1804
1805 /***********************************************************************
1806  *              glPolygonMode (OPENGL32.@)
1807  */
1808 void WINAPI wine_glPolygonMode( GLenum face, GLenum mode ) {
1809   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1810   TRACE("(%d, %d)\n", face, mode );
1811   funcs->gl.p_glPolygonMode( face, mode );
1812 }
1813
1814 /***********************************************************************
1815  *              glPolygonOffset (OPENGL32.@)
1816  */
1817 void WINAPI wine_glPolygonOffset( GLfloat factor, GLfloat units ) {
1818   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1819   TRACE("(%f, %f)\n", factor, units );
1820   funcs->gl.p_glPolygonOffset( factor, units );
1821 }
1822
1823 /***********************************************************************
1824  *              glPolygonStipple (OPENGL32.@)
1825  */
1826 void WINAPI wine_glPolygonStipple( const GLubyte* mask ) {
1827   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1828   TRACE("(%p)\n", mask );
1829   funcs->gl.p_glPolygonStipple( mask );
1830 }
1831
1832 /***********************************************************************
1833  *              glPopAttrib (OPENGL32.@)
1834  */
1835 void WINAPI wine_glPopAttrib( void ) {
1836   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1837   TRACE("()\n");
1838   funcs->gl.p_glPopAttrib( );
1839 }
1840
1841 /***********************************************************************
1842  *              glPopClientAttrib (OPENGL32.@)
1843  */
1844 void WINAPI wine_glPopClientAttrib( void ) {
1845   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1846   TRACE("()\n");
1847   funcs->gl.p_glPopClientAttrib( );
1848 }
1849
1850 /***********************************************************************
1851  *              glPopMatrix (OPENGL32.@)
1852  */
1853 void WINAPI wine_glPopMatrix( void ) {
1854   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1855   TRACE("()\n");
1856   funcs->gl.p_glPopMatrix( );
1857 }
1858
1859 /***********************************************************************
1860  *              glPopName (OPENGL32.@)
1861  */
1862 void WINAPI wine_glPopName( void ) {
1863   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1864   TRACE("()\n");
1865   funcs->gl.p_glPopName( );
1866 }
1867
1868 /***********************************************************************
1869  *              glPrioritizeTextures (OPENGL32.@)
1870  */
1871 void WINAPI wine_glPrioritizeTextures( GLsizei n, const GLuint* textures, const GLfloat* priorities ) {
1872   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1873   TRACE("(%d, %p, %p)\n", n, textures, priorities );
1874   funcs->gl.p_glPrioritizeTextures( n, textures, priorities );
1875 }
1876
1877 /***********************************************************************
1878  *              glPushAttrib (OPENGL32.@)
1879  */
1880 void WINAPI wine_glPushAttrib( GLbitfield mask ) {
1881   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1882   TRACE("(%d)\n", mask );
1883   funcs->gl.p_glPushAttrib( mask );
1884 }
1885
1886 /***********************************************************************
1887  *              glPushClientAttrib (OPENGL32.@)
1888  */
1889 void WINAPI wine_glPushClientAttrib( GLbitfield mask ) {
1890   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1891   TRACE("(%d)\n", mask );
1892   funcs->gl.p_glPushClientAttrib( mask );
1893 }
1894
1895 /***********************************************************************
1896  *              glPushMatrix (OPENGL32.@)
1897  */
1898 void WINAPI wine_glPushMatrix( void ) {
1899   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1900   TRACE("()\n");
1901   funcs->gl.p_glPushMatrix( );
1902 }
1903
1904 /***********************************************************************
1905  *              glPushName (OPENGL32.@)
1906  */
1907 void WINAPI wine_glPushName( GLuint name ) {
1908   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1909   TRACE("(%d)\n", name );
1910   funcs->gl.p_glPushName( name );
1911 }
1912
1913 /***********************************************************************
1914  *              glRasterPos2d (OPENGL32.@)
1915  */
1916 void WINAPI wine_glRasterPos2d( GLdouble x, GLdouble y ) {
1917   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1918   TRACE("(%f, %f)\n", x, y );
1919   funcs->gl.p_glRasterPos2d( x, y );
1920 }
1921
1922 /***********************************************************************
1923  *              glRasterPos2dv (OPENGL32.@)
1924  */
1925 void WINAPI wine_glRasterPos2dv( const GLdouble* v ) {
1926   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1927   TRACE("(%p)\n", v );
1928   funcs->gl.p_glRasterPos2dv( v );
1929 }
1930
1931 /***********************************************************************
1932  *              glRasterPos2f (OPENGL32.@)
1933  */
1934 void WINAPI wine_glRasterPos2f( GLfloat x, GLfloat y ) {
1935   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1936   TRACE("(%f, %f)\n", x, y );
1937   funcs->gl.p_glRasterPos2f( x, y );
1938 }
1939
1940 /***********************************************************************
1941  *              glRasterPos2fv (OPENGL32.@)
1942  */
1943 void WINAPI wine_glRasterPos2fv( const GLfloat* v ) {
1944   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1945   TRACE("(%p)\n", v );
1946   funcs->gl.p_glRasterPos2fv( v );
1947 }
1948
1949 /***********************************************************************
1950  *              glRasterPos2i (OPENGL32.@)
1951  */
1952 void WINAPI wine_glRasterPos2i( GLint x, GLint y ) {
1953   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1954   TRACE("(%d, %d)\n", x, y );
1955   funcs->gl.p_glRasterPos2i( x, y );
1956 }
1957
1958 /***********************************************************************
1959  *              glRasterPos2iv (OPENGL32.@)
1960  */
1961 void WINAPI wine_glRasterPos2iv( const GLint* v ) {
1962   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1963   TRACE("(%p)\n", v );
1964   funcs->gl.p_glRasterPos2iv( v );
1965 }
1966
1967 /***********************************************************************
1968  *              glRasterPos2s (OPENGL32.@)
1969  */
1970 void WINAPI wine_glRasterPos2s( GLshort x, GLshort y ) {
1971   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1972   TRACE("(%d, %d)\n", x, y );
1973   funcs->gl.p_glRasterPos2s( x, y );
1974 }
1975
1976 /***********************************************************************
1977  *              glRasterPos2sv (OPENGL32.@)
1978  */
1979 void WINAPI wine_glRasterPos2sv( const GLshort* v ) {
1980   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1981   TRACE("(%p)\n", v );
1982   funcs->gl.p_glRasterPos2sv( v );
1983 }
1984
1985 /***********************************************************************
1986  *              glRasterPos3d (OPENGL32.@)
1987  */
1988 void WINAPI wine_glRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) {
1989   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1990   TRACE("(%f, %f, %f)\n", x, y, z );
1991   funcs->gl.p_glRasterPos3d( x, y, z );
1992 }
1993
1994 /***********************************************************************
1995  *              glRasterPos3dv (OPENGL32.@)
1996  */
1997 void WINAPI wine_glRasterPos3dv( const GLdouble* v ) {
1998   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
1999   TRACE("(%p)\n", v );
2000   funcs->gl.p_glRasterPos3dv( v );
2001 }
2002
2003 /***********************************************************************
2004  *              glRasterPos3f (OPENGL32.@)
2005  */
2006 void WINAPI wine_glRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) {
2007   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2008   TRACE("(%f, %f, %f)\n", x, y, z );
2009   funcs->gl.p_glRasterPos3f( x, y, z );
2010 }
2011
2012 /***********************************************************************
2013  *              glRasterPos3fv (OPENGL32.@)
2014  */
2015 void WINAPI wine_glRasterPos3fv( const GLfloat* v ) {
2016   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2017   TRACE("(%p)\n", v );
2018   funcs->gl.p_glRasterPos3fv( v );
2019 }
2020
2021 /***********************************************************************
2022  *              glRasterPos3i (OPENGL32.@)
2023  */
2024 void WINAPI wine_glRasterPos3i( GLint x, GLint y, GLint z ) {
2025   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2026   TRACE("(%d, %d, %d)\n", x, y, z );
2027   funcs->gl.p_glRasterPos3i( x, y, z );
2028 }
2029
2030 /***********************************************************************
2031  *              glRasterPos3iv (OPENGL32.@)
2032  */
2033 void WINAPI wine_glRasterPos3iv( const GLint* v ) {
2034   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2035   TRACE("(%p)\n", v );
2036   funcs->gl.p_glRasterPos3iv( v );
2037 }
2038
2039 /***********************************************************************
2040  *              glRasterPos3s (OPENGL32.@)
2041  */
2042 void WINAPI wine_glRasterPos3s( GLshort x, GLshort y, GLshort z ) {
2043   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2044   TRACE("(%d, %d, %d)\n", x, y, z );
2045   funcs->gl.p_glRasterPos3s( x, y, z );
2046 }
2047
2048 /***********************************************************************
2049  *              glRasterPos3sv (OPENGL32.@)
2050  */
2051 void WINAPI wine_glRasterPos3sv( const GLshort* v ) {
2052   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2053   TRACE("(%p)\n", v );
2054   funcs->gl.p_glRasterPos3sv( v );
2055 }
2056
2057 /***********************************************************************
2058  *              glRasterPos4d (OPENGL32.@)
2059  */
2060 void WINAPI wine_glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
2061   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2062   TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
2063   funcs->gl.p_glRasterPos4d( x, y, z, w );
2064 }
2065
2066 /***********************************************************************
2067  *              glRasterPos4dv (OPENGL32.@)
2068  */
2069 void WINAPI wine_glRasterPos4dv( const GLdouble* v ) {
2070   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2071   TRACE("(%p)\n", v );
2072   funcs->gl.p_glRasterPos4dv( v );
2073 }
2074
2075 /***********************************************************************
2076  *              glRasterPos4f (OPENGL32.@)
2077  */
2078 void WINAPI wine_glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
2079   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2080   TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
2081   funcs->gl.p_glRasterPos4f( x, y, z, w );
2082 }
2083
2084 /***********************************************************************
2085  *              glRasterPos4fv (OPENGL32.@)
2086  */
2087 void WINAPI wine_glRasterPos4fv( const GLfloat* v ) {
2088   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2089   TRACE("(%p)\n", v );
2090   funcs->gl.p_glRasterPos4fv( v );
2091 }
2092
2093 /***********************************************************************
2094  *              glRasterPos4i (OPENGL32.@)
2095  */
2096 void WINAPI wine_glRasterPos4i( GLint x, GLint y, GLint z, GLint w ) {
2097   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2098   TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
2099   funcs->gl.p_glRasterPos4i( x, y, z, w );
2100 }
2101
2102 /***********************************************************************
2103  *              glRasterPos4iv (OPENGL32.@)
2104  */
2105 void WINAPI wine_glRasterPos4iv( const GLint* v ) {
2106   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2107   TRACE("(%p)\n", v );
2108   funcs->gl.p_glRasterPos4iv( v );
2109 }
2110
2111 /***********************************************************************
2112  *              glRasterPos4s (OPENGL32.@)
2113  */
2114 void WINAPI wine_glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
2115   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2116   TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
2117   funcs->gl.p_glRasterPos4s( x, y, z, w );
2118 }
2119
2120 /***********************************************************************
2121  *              glRasterPos4sv (OPENGL32.@)
2122  */
2123 void WINAPI wine_glRasterPos4sv( const GLshort* v ) {
2124   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2125   TRACE("(%p)\n", v );
2126   funcs->gl.p_glRasterPos4sv( v );
2127 }
2128
2129 /***********************************************************************
2130  *              glReadBuffer (OPENGL32.@)
2131  */
2132 void WINAPI wine_glReadBuffer( GLenum mode ) {
2133   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2134   TRACE("(%d)\n", mode );
2135   funcs->gl.p_glReadBuffer( mode );
2136 }
2137
2138 /***********************************************************************
2139  *              glReadPixels (OPENGL32.@)
2140  */
2141 void WINAPI wine_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) {
2142   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2143   TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, pixels );
2144   funcs->gl.p_glReadPixels( x, y, width, height, format, type, pixels );
2145 }
2146
2147 /***********************************************************************
2148  *              glRectd (OPENGL32.@)
2149  */
2150 void WINAPI wine_glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) {
2151   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2152   TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
2153   funcs->gl.p_glRectd( x1, y1, x2, y2 );
2154 }
2155
2156 /***********************************************************************
2157  *              glRectdv (OPENGL32.@)
2158  */
2159 void WINAPI wine_glRectdv( const GLdouble* v1, const GLdouble* v2 ) {
2160   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2161   TRACE("(%p, %p)\n", v1, v2 );
2162   funcs->gl.p_glRectdv( v1, v2 );
2163 }
2164
2165 /***********************************************************************
2166  *              glRectf (OPENGL32.@)
2167  */
2168 void WINAPI wine_glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) {
2169   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2170   TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
2171   funcs->gl.p_glRectf( x1, y1, x2, y2 );
2172 }
2173
2174 /***********************************************************************
2175  *              glRectfv (OPENGL32.@)
2176  */
2177 void WINAPI wine_glRectfv( const GLfloat* v1, const GLfloat* v2 ) {
2178   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2179   TRACE("(%p, %p)\n", v1, v2 );
2180   funcs->gl.p_glRectfv( v1, v2 );
2181 }
2182
2183 /***********************************************************************
2184  *              glRecti (OPENGL32.@)
2185  */
2186 void WINAPI wine_glRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) {
2187   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2188   TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
2189   funcs->gl.p_glRecti( x1, y1, x2, y2 );
2190 }
2191
2192 /***********************************************************************
2193  *              glRectiv (OPENGL32.@)
2194  */
2195 void WINAPI wine_glRectiv( const GLint* v1, const GLint* v2 ) {
2196   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2197   TRACE("(%p, %p)\n", v1, v2 );
2198   funcs->gl.p_glRectiv( v1, v2 );
2199 }
2200
2201 /***********************************************************************
2202  *              glRects (OPENGL32.@)
2203  */
2204 void WINAPI wine_glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) {
2205   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2206   TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
2207   funcs->gl.p_glRects( x1, y1, x2, y2 );
2208 }
2209
2210 /***********************************************************************
2211  *              glRectsv (OPENGL32.@)
2212  */
2213 void WINAPI wine_glRectsv( const GLshort* v1, const GLshort* v2 ) {
2214   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2215   TRACE("(%p, %p)\n", v1, v2 );
2216   funcs->gl.p_glRectsv( v1, v2 );
2217 }
2218
2219 /***********************************************************************
2220  *              glRenderMode (OPENGL32.@)
2221  */
2222 GLint WINAPI wine_glRenderMode( GLenum mode ) {
2223   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2224   TRACE("(%d)\n", mode );
2225   return funcs->gl.p_glRenderMode( mode );
2226 }
2227
2228 /***********************************************************************
2229  *              glRotated (OPENGL32.@)
2230  */
2231 void WINAPI wine_glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
2232   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2233   TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
2234   funcs->gl.p_glRotated( angle, x, y, z );
2235 }
2236
2237 /***********************************************************************
2238  *              glRotatef (OPENGL32.@)
2239  */
2240 void WINAPI wine_glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
2241   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2242   TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
2243   funcs->gl.p_glRotatef( angle, x, y, z );
2244 }
2245
2246 /***********************************************************************
2247  *              glScaled (OPENGL32.@)
2248  */
2249 void WINAPI wine_glScaled( GLdouble x, GLdouble y, GLdouble z ) {
2250   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2251   TRACE("(%f, %f, %f)\n", x, y, z );
2252   funcs->gl.p_glScaled( x, y, z );
2253 }
2254
2255 /***********************************************************************
2256  *              glScalef (OPENGL32.@)
2257  */
2258 void WINAPI wine_glScalef( GLfloat x, GLfloat y, GLfloat z ) {
2259   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2260   TRACE("(%f, %f, %f)\n", x, y, z );
2261   funcs->gl.p_glScalef( x, y, z );
2262 }
2263
2264 /***********************************************************************
2265  *              glScissor (OPENGL32.@)
2266  */
2267 void WINAPI wine_glScissor( GLint x, GLint y, GLsizei width, GLsizei height ) {
2268   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2269   TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
2270   funcs->gl.p_glScissor( x, y, width, height );
2271 }
2272
2273 /***********************************************************************
2274  *              glSelectBuffer (OPENGL32.@)
2275  */
2276 void WINAPI wine_glSelectBuffer( GLsizei size, GLuint* buffer ) {
2277   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2278   TRACE("(%d, %p)\n", size, buffer );
2279   funcs->gl.p_glSelectBuffer( size, buffer );
2280 }
2281
2282 /***********************************************************************
2283  *              glShadeModel (OPENGL32.@)
2284  */
2285 void WINAPI wine_glShadeModel( GLenum mode ) {
2286   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2287   TRACE("(%d)\n", mode );
2288   funcs->gl.p_glShadeModel( mode );
2289 }
2290
2291 /***********************************************************************
2292  *              glStencilFunc (OPENGL32.@)
2293  */
2294 void WINAPI wine_glStencilFunc( GLenum func, GLint ref, GLuint mask ) {
2295   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2296   TRACE("(%d, %d, %d)\n", func, ref, mask );
2297   funcs->gl.p_glStencilFunc( func, ref, mask );
2298 }
2299
2300 /***********************************************************************
2301  *              glStencilMask (OPENGL32.@)
2302  */
2303 void WINAPI wine_glStencilMask( GLuint mask ) {
2304   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2305   TRACE("(%d)\n", mask );
2306   funcs->gl.p_glStencilMask( mask );
2307 }
2308
2309 /***********************************************************************
2310  *              glStencilOp (OPENGL32.@)
2311  */
2312 void WINAPI wine_glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {
2313   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2314   TRACE("(%d, %d, %d)\n", fail, zfail, zpass );
2315   funcs->gl.p_glStencilOp( fail, zfail, zpass );
2316 }
2317
2318 /***********************************************************************
2319  *              glTexCoord1d (OPENGL32.@)
2320  */
2321 void WINAPI wine_glTexCoord1d( GLdouble s ) {
2322   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2323   TRACE("(%f)\n", s );
2324   funcs->gl.p_glTexCoord1d( s );
2325 }
2326
2327 /***********************************************************************
2328  *              glTexCoord1dv (OPENGL32.@)
2329  */
2330 void WINAPI wine_glTexCoord1dv( const GLdouble* v ) {
2331   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2332   TRACE("(%p)\n", v );
2333   funcs->gl.p_glTexCoord1dv( v );
2334 }
2335
2336 /***********************************************************************
2337  *              glTexCoord1f (OPENGL32.@)
2338  */
2339 void WINAPI wine_glTexCoord1f( GLfloat s ) {
2340   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2341   TRACE("(%f)\n", s );
2342   funcs->gl.p_glTexCoord1f( s );
2343 }
2344
2345 /***********************************************************************
2346  *              glTexCoord1fv (OPENGL32.@)
2347  */
2348 void WINAPI wine_glTexCoord1fv( const GLfloat* v ) {
2349   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2350   TRACE("(%p)\n", v );
2351   funcs->gl.p_glTexCoord1fv( v );
2352 }
2353
2354 /***********************************************************************
2355  *              glTexCoord1i (OPENGL32.@)
2356  */
2357 void WINAPI wine_glTexCoord1i( GLint s ) {
2358   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2359   TRACE("(%d)\n", s );
2360   funcs->gl.p_glTexCoord1i( s );
2361 }
2362
2363 /***********************************************************************
2364  *              glTexCoord1iv (OPENGL32.@)
2365  */
2366 void WINAPI wine_glTexCoord1iv( const GLint* v ) {
2367   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2368   TRACE("(%p)\n", v );
2369   funcs->gl.p_glTexCoord1iv( v );
2370 }
2371
2372 /***********************************************************************
2373  *              glTexCoord1s (OPENGL32.@)
2374  */
2375 void WINAPI wine_glTexCoord1s( GLshort s ) {
2376   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2377   TRACE("(%d)\n", s );
2378   funcs->gl.p_glTexCoord1s( s );
2379 }
2380
2381 /***********************************************************************
2382  *              glTexCoord1sv (OPENGL32.@)
2383  */
2384 void WINAPI wine_glTexCoord1sv( const GLshort* v ) {
2385   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2386   TRACE("(%p)\n", v );
2387   funcs->gl.p_glTexCoord1sv( v );
2388 }
2389
2390 /***********************************************************************
2391  *              glTexCoord2d (OPENGL32.@)
2392  */
2393 void WINAPI wine_glTexCoord2d( GLdouble s, GLdouble t ) {
2394   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2395   TRACE("(%f, %f)\n", s, t );
2396   funcs->gl.p_glTexCoord2d( s, t );
2397 }
2398
2399 /***********************************************************************
2400  *              glTexCoord2dv (OPENGL32.@)
2401  */
2402 void WINAPI wine_glTexCoord2dv( const GLdouble* v ) {
2403   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2404   TRACE("(%p)\n", v );
2405   funcs->gl.p_glTexCoord2dv( v );
2406 }
2407
2408 /***********************************************************************
2409  *              glTexCoord2f (OPENGL32.@)
2410  */
2411 void WINAPI wine_glTexCoord2f( GLfloat s, GLfloat t ) {
2412   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2413   TRACE("(%f, %f)\n", s, t );
2414   funcs->gl.p_glTexCoord2f( s, t );
2415 }
2416
2417 /***********************************************************************
2418  *              glTexCoord2fv (OPENGL32.@)
2419  */
2420 void WINAPI wine_glTexCoord2fv( const GLfloat* v ) {
2421   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2422   TRACE("(%p)\n", v );
2423   funcs->gl.p_glTexCoord2fv( v );
2424 }
2425
2426 /***********************************************************************
2427  *              glTexCoord2i (OPENGL32.@)
2428  */
2429 void WINAPI wine_glTexCoord2i( GLint s, GLint t ) {
2430   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2431   TRACE("(%d, %d)\n", s, t );
2432   funcs->gl.p_glTexCoord2i( s, t );
2433 }
2434
2435 /***********************************************************************
2436  *              glTexCoord2iv (OPENGL32.@)
2437  */
2438 void WINAPI wine_glTexCoord2iv( const GLint* v ) {
2439   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2440   TRACE("(%p)\n", v );
2441   funcs->gl.p_glTexCoord2iv( v );
2442 }
2443
2444 /***********************************************************************
2445  *              glTexCoord2s (OPENGL32.@)
2446  */
2447 void WINAPI wine_glTexCoord2s( GLshort s, GLshort t ) {
2448   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2449   TRACE("(%d, %d)\n", s, t );
2450   funcs->gl.p_glTexCoord2s( s, t );
2451 }
2452
2453 /***********************************************************************
2454  *              glTexCoord2sv (OPENGL32.@)
2455  */
2456 void WINAPI wine_glTexCoord2sv( const GLshort* v ) {
2457   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2458   TRACE("(%p)\n", v );
2459   funcs->gl.p_glTexCoord2sv( v );
2460 }
2461
2462 /***********************************************************************
2463  *              glTexCoord3d (OPENGL32.@)
2464  */
2465 void WINAPI wine_glTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) {
2466   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2467   TRACE("(%f, %f, %f)\n", s, t, r );
2468   funcs->gl.p_glTexCoord3d( s, t, r );
2469 }
2470
2471 /***********************************************************************
2472  *              glTexCoord3dv (OPENGL32.@)
2473  */
2474 void WINAPI wine_glTexCoord3dv( const GLdouble* v ) {
2475   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2476   TRACE("(%p)\n", v );
2477   funcs->gl.p_glTexCoord3dv( v );
2478 }
2479
2480 /***********************************************************************
2481  *              glTexCoord3f (OPENGL32.@)
2482  */
2483 void WINAPI wine_glTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) {
2484   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2485   TRACE("(%f, %f, %f)\n", s, t, r );
2486   funcs->gl.p_glTexCoord3f( s, t, r );
2487 }
2488
2489 /***********************************************************************
2490  *              glTexCoord3fv (OPENGL32.@)
2491  */
2492 void WINAPI wine_glTexCoord3fv( const GLfloat* v ) {
2493   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2494   TRACE("(%p)\n", v );
2495   funcs->gl.p_glTexCoord3fv( v );
2496 }
2497
2498 /***********************************************************************
2499  *              glTexCoord3i (OPENGL32.@)
2500  */
2501 void WINAPI wine_glTexCoord3i( GLint s, GLint t, GLint r ) {
2502   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2503   TRACE("(%d, %d, %d)\n", s, t, r );
2504   funcs->gl.p_glTexCoord3i( s, t, r );
2505 }
2506
2507 /***********************************************************************
2508  *              glTexCoord3iv (OPENGL32.@)
2509  */
2510 void WINAPI wine_glTexCoord3iv( const GLint* v ) {
2511   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2512   TRACE("(%p)\n", v );
2513   funcs->gl.p_glTexCoord3iv( v );
2514 }
2515
2516 /***********************************************************************
2517  *              glTexCoord3s (OPENGL32.@)
2518  */
2519 void WINAPI wine_glTexCoord3s( GLshort s, GLshort t, GLshort r ) {
2520   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2521   TRACE("(%d, %d, %d)\n", s, t, r );
2522   funcs->gl.p_glTexCoord3s( s, t, r );
2523 }
2524
2525 /***********************************************************************
2526  *              glTexCoord3sv (OPENGL32.@)
2527  */
2528 void WINAPI wine_glTexCoord3sv( const GLshort* v ) {
2529   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2530   TRACE("(%p)\n", v );
2531   funcs->gl.p_glTexCoord3sv( v );
2532 }
2533
2534 /***********************************************************************
2535  *              glTexCoord4d (OPENGL32.@)
2536  */
2537 void WINAPI wine_glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
2538   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2539   TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
2540   funcs->gl.p_glTexCoord4d( s, t, r, q );
2541 }
2542
2543 /***********************************************************************
2544  *              glTexCoord4dv (OPENGL32.@)
2545  */
2546 void WINAPI wine_glTexCoord4dv( const GLdouble* v ) {
2547   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2548   TRACE("(%p)\n", v );
2549   funcs->gl.p_glTexCoord4dv( v );
2550 }
2551
2552 /***********************************************************************
2553  *              glTexCoord4f (OPENGL32.@)
2554  */
2555 void WINAPI wine_glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
2556   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2557   TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
2558   funcs->gl.p_glTexCoord4f( s, t, r, q );
2559 }
2560
2561 /***********************************************************************
2562  *              glTexCoord4fv (OPENGL32.@)
2563  */
2564 void WINAPI wine_glTexCoord4fv( const GLfloat* v ) {
2565   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2566   TRACE("(%p)\n", v );
2567   funcs->gl.p_glTexCoord4fv( v );
2568 }
2569
2570 /***********************************************************************
2571  *              glTexCoord4i (OPENGL32.@)
2572  */
2573 void WINAPI wine_glTexCoord4i( GLint s, GLint t, GLint r, GLint q ) {
2574   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2575   TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
2576   funcs->gl.p_glTexCoord4i( s, t, r, q );
2577 }
2578
2579 /***********************************************************************
2580  *              glTexCoord4iv (OPENGL32.@)
2581  */
2582 void WINAPI wine_glTexCoord4iv( const GLint* v ) {
2583   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2584   TRACE("(%p)\n", v );
2585   funcs->gl.p_glTexCoord4iv( v );
2586 }
2587
2588 /***********************************************************************
2589  *              glTexCoord4s (OPENGL32.@)
2590  */
2591 void WINAPI wine_glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) {
2592   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2593   TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
2594   funcs->gl.p_glTexCoord4s( s, t, r, q );
2595 }
2596
2597 /***********************************************************************
2598  *              glTexCoord4sv (OPENGL32.@)
2599  */
2600 void WINAPI wine_glTexCoord4sv( const GLshort* v ) {
2601   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2602   TRACE("(%p)\n", v );
2603   funcs->gl.p_glTexCoord4sv( v );
2604 }
2605
2606 /***********************************************************************
2607  *              glTexCoordPointer (OPENGL32.@)
2608  */
2609 void WINAPI wine_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) {
2610   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2611   TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
2612   funcs->gl.p_glTexCoordPointer( size, type, stride, pointer );
2613 }
2614
2615 /***********************************************************************
2616  *              glTexEnvf (OPENGL32.@)
2617  */
2618 void WINAPI wine_glTexEnvf( GLenum target, GLenum pname, GLfloat param ) {
2619   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2620   TRACE("(%d, %d, %f)\n", target, pname, param );
2621   funcs->gl.p_glTexEnvf( target, pname, param );
2622 }
2623
2624 /***********************************************************************
2625  *              glTexEnvfv (OPENGL32.@)
2626  */
2627 void WINAPI wine_glTexEnvfv( GLenum target, GLenum pname, const GLfloat* params ) {
2628   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2629   TRACE("(%d, %d, %p)\n", target, pname, params );
2630   funcs->gl.p_glTexEnvfv( target, pname, params );
2631 }
2632
2633 /***********************************************************************
2634  *              glTexEnvi (OPENGL32.@)
2635  */
2636 void WINAPI wine_glTexEnvi( GLenum target, GLenum pname, GLint param ) {
2637   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2638   TRACE("(%d, %d, %d)\n", target, pname, param );
2639   funcs->gl.p_glTexEnvi( target, pname, param );
2640 }
2641
2642 /***********************************************************************
2643  *              glTexEnviv (OPENGL32.@)
2644  */
2645 void WINAPI wine_glTexEnviv( GLenum target, GLenum pname, const GLint* params ) {
2646   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2647   TRACE("(%d, %d, %p)\n", target, pname, params );
2648   funcs->gl.p_glTexEnviv( target, pname, params );
2649 }
2650
2651 /***********************************************************************
2652  *              glTexGend (OPENGL32.@)
2653  */
2654 void WINAPI wine_glTexGend( GLenum coord, GLenum pname, GLdouble param ) {
2655   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2656   TRACE("(%d, %d, %f)\n", coord, pname, param );
2657   funcs->gl.p_glTexGend( coord, pname, param );
2658 }
2659
2660 /***********************************************************************
2661  *              glTexGendv (OPENGL32.@)
2662  */
2663 void WINAPI wine_glTexGendv( GLenum coord, GLenum pname, const GLdouble* params ) {
2664   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2665   TRACE("(%d, %d, %p)\n", coord, pname, params );
2666   funcs->gl.p_glTexGendv( coord, pname, params );
2667 }
2668
2669 /***********************************************************************
2670  *              glTexGenf (OPENGL32.@)
2671  */
2672 void WINAPI wine_glTexGenf( GLenum coord, GLenum pname, GLfloat param ) {
2673   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2674   TRACE("(%d, %d, %f)\n", coord, pname, param );
2675   funcs->gl.p_glTexGenf( coord, pname, param );
2676 }
2677
2678 /***********************************************************************
2679  *              glTexGenfv (OPENGL32.@)
2680  */
2681 void WINAPI wine_glTexGenfv( GLenum coord, GLenum pname, const GLfloat* params ) {
2682   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2683   TRACE("(%d, %d, %p)\n", coord, pname, params );
2684   funcs->gl.p_glTexGenfv( coord, pname, params );
2685 }
2686
2687 /***********************************************************************
2688  *              glTexGeni (OPENGL32.@)
2689  */
2690 void WINAPI wine_glTexGeni( GLenum coord, GLenum pname, GLint param ) {
2691   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2692   TRACE("(%d, %d, %d)\n", coord, pname, param );
2693   funcs->gl.p_glTexGeni( coord, pname, param );
2694 }
2695
2696 /***********************************************************************
2697  *              glTexGeniv (OPENGL32.@)
2698  */
2699 void WINAPI wine_glTexGeniv( GLenum coord, GLenum pname, const GLint* params ) {
2700   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2701   TRACE("(%d, %d, %p)\n", coord, pname, params );
2702   funcs->gl.p_glTexGeniv( coord, pname, params );
2703 }
2704
2705 /***********************************************************************
2706  *              glTexImage1D (OPENGL32.@)
2707  */
2708 void WINAPI wine_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) {
2709   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2710   TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, format, type, pixels );
2711   funcs->gl.p_glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
2712 }
2713
2714 /***********************************************************************
2715  *              glTexImage2D (OPENGL32.@)
2716  */
2717 void WINAPI wine_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) {
2718   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2719   TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, format, type, pixels );
2720   funcs->gl.p_glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
2721 }
2722
2723 /***********************************************************************
2724  *              glTexParameterf (OPENGL32.@)
2725  */
2726 void WINAPI wine_glTexParameterf( GLenum target, GLenum pname, GLfloat param ) {
2727   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2728   TRACE("(%d, %d, %f)\n", target, pname, param );
2729   funcs->gl.p_glTexParameterf( target, pname, param );
2730 }
2731
2732 /***********************************************************************
2733  *              glTexParameterfv (OPENGL32.@)
2734  */
2735 void WINAPI wine_glTexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) {
2736   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2737   TRACE("(%d, %d, %p)\n", target, pname, params );
2738   funcs->gl.p_glTexParameterfv( target, pname, params );
2739 }
2740
2741 /***********************************************************************
2742  *              glTexParameteri (OPENGL32.@)
2743  */
2744 void WINAPI wine_glTexParameteri( GLenum target, GLenum pname, GLint param ) {
2745   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2746   TRACE("(%d, %d, %d)\n", target, pname, param );
2747   funcs->gl.p_glTexParameteri( target, pname, param );
2748 }
2749
2750 /***********************************************************************
2751  *              glTexParameteriv (OPENGL32.@)
2752  */
2753 void WINAPI wine_glTexParameteriv( GLenum target, GLenum pname, const GLint* params ) {
2754   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2755   TRACE("(%d, %d, %p)\n", target, pname, params );
2756   funcs->gl.p_glTexParameteriv( target, pname, params );
2757 }
2758
2759 /***********************************************************************
2760  *              glTexSubImage1D (OPENGL32.@)
2761  */
2762 void WINAPI wine_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* pixels ) {
2763   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2764   TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
2765   funcs->gl.p_glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
2766 }
2767
2768 /***********************************************************************
2769  *              glTexSubImage2D (OPENGL32.@)
2770  */
2771 void WINAPI wine_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels ) {
2772   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2773   TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
2774   funcs->gl.p_glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
2775 }
2776
2777 /***********************************************************************
2778  *              glTranslated (OPENGL32.@)
2779  */
2780 void WINAPI wine_glTranslated( GLdouble x, GLdouble y, GLdouble z ) {
2781   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2782   TRACE("(%f, %f, %f)\n", x, y, z );
2783   funcs->gl.p_glTranslated( x, y, z );
2784 }
2785
2786 /***********************************************************************
2787  *              glTranslatef (OPENGL32.@)
2788  */
2789 void WINAPI wine_glTranslatef( GLfloat x, GLfloat y, GLfloat z ) {
2790   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2791   TRACE("(%f, %f, %f)\n", x, y, z );
2792   funcs->gl.p_glTranslatef( x, y, z );
2793 }
2794
2795 /***********************************************************************
2796  *              glVertex2d (OPENGL32.@)
2797  */
2798 void WINAPI wine_glVertex2d( GLdouble x, GLdouble y ) {
2799   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2800   TRACE("(%f, %f)\n", x, y );
2801   funcs->gl.p_glVertex2d( x, y );
2802 }
2803
2804 /***********************************************************************
2805  *              glVertex2dv (OPENGL32.@)
2806  */
2807 void WINAPI wine_glVertex2dv( const GLdouble* v ) {
2808   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2809   TRACE("(%p)\n", v );
2810   funcs->gl.p_glVertex2dv( v );
2811 }
2812
2813 /***********************************************************************
2814  *              glVertex2f (OPENGL32.@)
2815  */
2816 void WINAPI wine_glVertex2f( GLfloat x, GLfloat y ) {
2817   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2818   TRACE("(%f, %f)\n", x, y );
2819   funcs->gl.p_glVertex2f( x, y );
2820 }
2821
2822 /***********************************************************************
2823  *              glVertex2fv (OPENGL32.@)
2824  */
2825 void WINAPI wine_glVertex2fv( const GLfloat* v ) {
2826   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2827   TRACE("(%p)\n", v );
2828   funcs->gl.p_glVertex2fv( v );
2829 }
2830
2831 /***********************************************************************
2832  *              glVertex2i (OPENGL32.@)
2833  */
2834 void WINAPI wine_glVertex2i( GLint x, GLint y ) {
2835   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2836   TRACE("(%d, %d)\n", x, y );
2837   funcs->gl.p_glVertex2i( x, y );
2838 }
2839
2840 /***********************************************************************
2841  *              glVertex2iv (OPENGL32.@)
2842  */
2843 void WINAPI wine_glVertex2iv( const GLint* v ) {
2844   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2845   TRACE("(%p)\n", v );
2846   funcs->gl.p_glVertex2iv( v );
2847 }
2848
2849 /***********************************************************************
2850  *              glVertex2s (OPENGL32.@)
2851  */
2852 void WINAPI wine_glVertex2s( GLshort x, GLshort y ) {
2853   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2854   TRACE("(%d, %d)\n", x, y );
2855   funcs->gl.p_glVertex2s( x, y );
2856 }
2857
2858 /***********************************************************************
2859  *              glVertex2sv (OPENGL32.@)
2860  */
2861 void WINAPI wine_glVertex2sv( const GLshort* v ) {
2862   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2863   TRACE("(%p)\n", v );
2864   funcs->gl.p_glVertex2sv( v );
2865 }
2866
2867 /***********************************************************************
2868  *              glVertex3d (OPENGL32.@)
2869  */
2870 void WINAPI wine_glVertex3d( GLdouble x, GLdouble y, GLdouble z ) {
2871   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2872   TRACE("(%f, %f, %f)\n", x, y, z );
2873   funcs->gl.p_glVertex3d( x, y, z );
2874 }
2875
2876 /***********************************************************************
2877  *              glVertex3dv (OPENGL32.@)
2878  */
2879 void WINAPI wine_glVertex3dv( const GLdouble* v ) {
2880   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2881   TRACE("(%p)\n", v );
2882   funcs->gl.p_glVertex3dv( v );
2883 }
2884
2885 /***********************************************************************
2886  *              glVertex3f (OPENGL32.@)
2887  */
2888 void WINAPI wine_glVertex3f( GLfloat x, GLfloat y, GLfloat z ) {
2889   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2890   TRACE("(%f, %f, %f)\n", x, y, z );
2891   funcs->gl.p_glVertex3f( x, y, z );
2892 }
2893
2894 /***********************************************************************
2895  *              glVertex3fv (OPENGL32.@)
2896  */
2897 void WINAPI wine_glVertex3fv( const GLfloat* v ) {
2898   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2899   TRACE("(%p)\n", v );
2900   funcs->gl.p_glVertex3fv( v );
2901 }
2902
2903 /***********************************************************************
2904  *              glVertex3i (OPENGL32.@)
2905  */
2906 void WINAPI wine_glVertex3i( GLint x, GLint y, GLint z ) {
2907   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2908   TRACE("(%d, %d, %d)\n", x, y, z );
2909   funcs->gl.p_glVertex3i( x, y, z );
2910 }
2911
2912 /***********************************************************************
2913  *              glVertex3iv (OPENGL32.@)
2914  */
2915 void WINAPI wine_glVertex3iv( const GLint* v ) {
2916   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2917   TRACE("(%p)\n", v );
2918   funcs->gl.p_glVertex3iv( v );
2919 }
2920
2921 /***********************************************************************
2922  *              glVertex3s (OPENGL32.@)
2923  */
2924 void WINAPI wine_glVertex3s( GLshort x, GLshort y, GLshort z ) {
2925   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2926   TRACE("(%d, %d, %d)\n", x, y, z );
2927   funcs->gl.p_glVertex3s( x, y, z );
2928 }
2929
2930 /***********************************************************************
2931  *              glVertex3sv (OPENGL32.@)
2932  */
2933 void WINAPI wine_glVertex3sv( const GLshort* v ) {
2934   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2935   TRACE("(%p)\n", v );
2936   funcs->gl.p_glVertex3sv( v );
2937 }
2938
2939 /***********************************************************************
2940  *              glVertex4d (OPENGL32.@)
2941  */
2942 void WINAPI wine_glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
2943   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2944   TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
2945   funcs->gl.p_glVertex4d( x, y, z, w );
2946 }
2947
2948 /***********************************************************************
2949  *              glVertex4dv (OPENGL32.@)
2950  */
2951 void WINAPI wine_glVertex4dv( const GLdouble* v ) {
2952   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2953   TRACE("(%p)\n", v );
2954   funcs->gl.p_glVertex4dv( v );
2955 }
2956
2957 /***********************************************************************
2958  *              glVertex4f (OPENGL32.@)
2959  */
2960 void WINAPI wine_glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
2961   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2962   TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
2963   funcs->gl.p_glVertex4f( x, y, z, w );
2964 }
2965
2966 /***********************************************************************
2967  *              glVertex4fv (OPENGL32.@)
2968  */
2969 void WINAPI wine_glVertex4fv( const GLfloat* v ) {
2970   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2971   TRACE("(%p)\n", v );
2972   funcs->gl.p_glVertex4fv( v );
2973 }
2974
2975 /***********************************************************************
2976  *              glVertex4i (OPENGL32.@)
2977  */
2978 void WINAPI wine_glVertex4i( GLint x, GLint y, GLint z, GLint w ) {
2979   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2980   TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
2981   funcs->gl.p_glVertex4i( x, y, z, w );
2982 }
2983
2984 /***********************************************************************
2985  *              glVertex4iv (OPENGL32.@)
2986  */
2987 void WINAPI wine_glVertex4iv( const GLint* v ) {
2988   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2989   TRACE("(%p)\n", v );
2990   funcs->gl.p_glVertex4iv( v );
2991 }
2992
2993 /***********************************************************************
2994  *              glVertex4s (OPENGL32.@)
2995  */
2996 void WINAPI wine_glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
2997   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
2998   TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
2999   funcs->gl.p_glVertex4s( x, y, z, w );
3000 }
3001
3002 /***********************************************************************
3003  *              glVertex4sv (OPENGL32.@)
3004  */
3005 void WINAPI wine_glVertex4sv( const GLshort* v ) {
3006   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
3007   TRACE("(%p)\n", v );
3008   funcs->gl.p_glVertex4sv( v );
3009 }
3010
3011 /***********************************************************************
3012  *              glVertexPointer (OPENGL32.@)
3013  */
3014 void WINAPI wine_glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) {
3015   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
3016   TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
3017   funcs->gl.p_glVertexPointer( size, type, stride, pointer );
3018 }
3019
3020 /***********************************************************************
3021  *              glViewport (OPENGL32.@)
3022  */
3023 void WINAPI wine_glViewport( GLint x, GLint y, GLsizei width, GLsizei height ) {
3024   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
3025   TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
3026   funcs->gl.p_glViewport( x, y, width, height );
3027 }
3028 static BOOL null_wglCopyContext( struct wgl_context * src, struct wgl_context * dst, UINT mask ) { return 0; }
3029 static struct wgl_context * null_wglCreateContext( HDC hdc ) { return 0; }
3030 static void null_wglDeleteContext( struct wgl_context * context ) { }
3031 static INT null_wglDescribePixelFormat( HDC hdc, INT format, UINT size, PIXELFORMATDESCRIPTOR * descr ) { return 0; }
3032 static INT null_wglGetPixelFormat( HDC hdc ) { return 0; }
3033 static PROC null_wglGetProcAddress( LPCSTR name ) { return 0; }
3034 static BOOL null_wglMakeCurrent( HDC hdc, struct wgl_context * context ) { return 0; }
3035 static BOOL null_wglSetPixelFormat( HDC hdc, INT format, const PIXELFORMATDESCRIPTOR * descr ) { return 0; }
3036 static BOOL null_wglShareLists( struct wgl_context * org, struct wgl_context * dst ) { return 0; }
3037 static void null_glAccum( GLenum op, GLfloat value ) { }
3038 static void null_glAlphaFunc( GLenum func, GLfloat ref ) { }
3039 static GLboolean null_glAreTexturesResident( GLsizei n, const GLuint* textures, GLboolean* residences ) { return 0; }
3040 static void null_glArrayElement( GLint i ) { }
3041 static void null_glBegin( GLenum mode ) { }
3042 static void null_glBindTexture( GLenum target, GLuint texture ) { }
3043 static void null_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap ) { }
3044 static void null_glBlendFunc( GLenum sfactor, GLenum dfactor ) { }
3045 static void null_glCallList( GLuint list ) { }
3046 static void null_glCallLists( GLsizei n, GLenum type, const GLvoid* lists ) { }
3047 static void null_glClear( GLbitfield mask ) { }
3048 static void null_glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
3049 static void null_glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
3050 static void null_glClearDepth( GLdouble depth ) { }
3051 static void null_glClearIndex( GLfloat c ) { }
3052 static void null_glClearStencil( GLint s ) { }
3053 static void null_glClipPlane( GLenum plane, const GLdouble* equation ) { }
3054 static void null_glColor3b( GLbyte red, GLbyte green, GLbyte blue ) { }
3055 static void null_glColor3bv( const GLbyte* v ) { }
3056 static void null_glColor3d( GLdouble red, GLdouble green, GLdouble blue ) { }
3057 static void null_glColor3dv( const GLdouble* v ) { }
3058 static void null_glColor3f( GLfloat red, GLfloat green, GLfloat blue ) { }
3059 static void null_glColor3fv( const GLfloat* v ) { }
3060 static void null_glColor3i( GLint red, GLint green, GLint blue ) { }
3061 static void null_glColor3iv( const GLint* v ) { }
3062 static void null_glColor3s( GLshort red, GLshort green, GLshort blue ) { }
3063 static void null_glColor3sv( const GLshort* v ) { }
3064 static void null_glColor3ub( GLubyte red, GLubyte green, GLubyte blue ) { }
3065 static void null_glColor3ubv( const GLubyte* v ) { }
3066 static void null_glColor3ui( GLuint red, GLuint green, GLuint blue ) { }
3067 static void null_glColor3uiv( const GLuint* v ) { }
3068 static void null_glColor3us( GLushort red, GLushort green, GLushort blue ) { }
3069 static void null_glColor3usv( const GLushort* v ) { }
3070 static void null_glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) { }
3071 static void null_glColor4bv( const GLbyte* v ) { }
3072 static void null_glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) { }
3073 static void null_glColor4dv( const GLdouble* v ) { }
3074 static void null_glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
3075 static void null_glColor4fv( const GLfloat* v ) { }
3076 static void null_glColor4i( GLint red, GLint green, GLint blue, GLint alpha ) { }
3077 static void null_glColor4iv( const GLint* v ) { }
3078 static void null_glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) { }
3079 static void null_glColor4sv( const GLshort* v ) { }
3080 static void null_glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) { }
3081 static void null_glColor4ubv( const GLubyte* v ) { }
3082 static void null_glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) { }
3083 static void null_glColor4uiv( const GLuint* v ) { }
3084 static void null_glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) { }
3085 static void null_glColor4usv( const GLushort* v ) { }
3086 static void null_glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) { }
3087 static void null_glColorMaterial( GLenum face, GLenum mode ) { }
3088 static void null_glColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) { }
3089 static void null_glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) { }
3090 static void null_glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { }
3091 static void null_glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { }
3092 static void null_glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) { }
3093 static void null_glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { }
3094 static void null_glCullFace( GLenum mode ) { }
3095 static void null_glDeleteLists( GLuint list, GLsizei range ) { }
3096 static void null_glDeleteTextures( GLsizei n, const GLuint* textures ) { }
3097 static void null_glDepthFunc( GLenum func ) { }
3098 static void null_glDepthMask( GLboolean flag ) { }
3099 static void null_glDepthRange( GLdouble nearParam, GLdouble farParam ) { }
3100 static void null_glDisable( GLenum cap ) { }
3101 static void null_glDisableClientState( GLenum array ) { }
3102 static void null_glDrawArrays( GLenum mode, GLint first, GLsizei count ) { }
3103 static void null_glDrawBuffer( GLenum mode ) { }
3104 static void null_glDrawElements( GLenum mode, GLsizei count, GLenum type, const GLvoid* indices ) { }
3105 static void null_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels ) { }
3106 static void null_glEdgeFlag( GLboolean flag ) { }
3107 static void null_glEdgeFlagPointer( GLsizei stride, const GLvoid* pointer ) { }
3108 static void null_glEdgeFlagv( const GLboolean* flag ) { }
3109 static void null_glEnable( GLenum cap ) { }
3110 static void null_glEnableClientState( GLenum array ) { }
3111 static void null_glEnd( void ) { }
3112 static void null_glEndList( void ) { }
3113 static void null_glEvalCoord1d( GLdouble u ) { }
3114 static void null_glEvalCoord1dv( const GLdouble* u ) { }
3115 static void null_glEvalCoord1f( GLfloat u ) { }
3116 static void null_glEvalCoord1fv( const GLfloat* u ) { }
3117 static void null_glEvalCoord2d( GLdouble u, GLdouble v ) { }
3118 static void null_glEvalCoord2dv( const GLdouble* u ) { }
3119 static void null_glEvalCoord2f( GLfloat u, GLfloat v ) { }
3120 static void null_glEvalCoord2fv( const GLfloat* u ) { }
3121 static void null_glEvalMesh1( GLenum mode, GLint i1, GLint i2 ) { }
3122 static void null_glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) { }
3123 static void null_glEvalPoint1( GLint i ) { }
3124 static void null_glEvalPoint2( GLint i, GLint j ) { }
3125 static void null_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat* buffer ) { }
3126 static void null_glFinish( void ) { }
3127 static void null_glFlush( void ) { }
3128 static void null_glFogf( GLenum pname, GLfloat param ) { }
3129 static void null_glFogfv( GLenum pname, const GLfloat* params ) { }
3130 static void null_glFogi( GLenum pname, GLint param ) { }
3131 static void null_glFogiv( GLenum pname, const GLint* params ) { }
3132 static void null_glFrontFace( GLenum mode ) { }
3133 static void null_glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
3134 static GLuint null_glGenLists( GLsizei range ) { return 0; }
3135 static void null_glGenTextures( GLsizei n, GLuint* textures ) { }
3136 static void null_glGetBooleanv( GLenum pname, GLboolean* params ) { }
3137 static void null_glGetClipPlane( GLenum plane, GLdouble* equation ) { }
3138 static void null_glGetDoublev( GLenum pname, GLdouble* params ) { }
3139 static GLenum null_glGetError( void ) { return GL_INVALID_OPERATION; }
3140 static void null_glGetFloatv( GLenum pname, GLfloat* params ) { }
3141 static void null_glGetIntegerv( GLenum pname, GLint* params ) { }
3142 static void null_glGetLightfv( GLenum light, GLenum pname, GLfloat* params ) { }
3143 static void null_glGetLightiv( GLenum light, GLenum pname, GLint* params ) { }
3144 static void null_glGetMapdv( GLenum target, GLenum query, GLdouble* v ) { }
3145 static void null_glGetMapfv( GLenum target, GLenum query, GLfloat* v ) { }
3146 static void null_glGetMapiv( GLenum target, GLenum query, GLint* v ) { }
3147 static void null_glGetMaterialfv( GLenum face, GLenum pname, GLfloat* params ) { }
3148 static void null_glGetMaterialiv( GLenum face, GLenum pname, GLint* params ) { }
3149 static void null_glGetPixelMapfv( GLenum map, GLfloat* values ) { }
3150 static void null_glGetPixelMapuiv( GLenum map, GLuint* values ) { }
3151 static void null_glGetPixelMapusv( GLenum map, GLushort* values ) { }
3152 static void null_glGetPointerv( GLenum pname, GLvoid** params ) { }
3153 static void null_glGetPolygonStipple( GLubyte* mask ) { }
3154 static const GLubyte * null_glGetString( GLenum name ) { return 0; }
3155 static void null_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) { }
3156 static void null_glGetTexEnviv( GLenum target, GLenum pname, GLint* params ) { }
3157 static void null_glGetTexGendv( GLenum coord, GLenum pname, GLdouble* params ) { }
3158 static void null_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) { }
3159 static void null_glGetTexGeniv( GLenum coord, GLenum pname, GLint* params ) { }
3160 static void null_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels ) { }
3161 static void null_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat* params ) { }
3162 static void null_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint* params ) { }
3163 static void null_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
3164 static void null_glGetTexParameteriv( GLenum target, GLenum pname, GLint* params ) { }
3165 static void null_glHint( GLenum target, GLenum mode ) { }
3166 static void null_glIndexMask( GLuint mask ) { }
3167 static void null_glIndexPointer( GLenum type, GLsizei stride, const GLvoid* pointer ) { }
3168 static void null_glIndexd( GLdouble c ) { }
3169 static void null_glIndexdv( const GLdouble* c ) { }
3170 static void null_glIndexf( GLfloat c ) { }
3171 static void null_glIndexfv( const GLfloat* c ) { }
3172 static void null_glIndexi( GLint c ) { }
3173 static void null_glIndexiv( const GLint* c ) { }
3174 static void null_glIndexs( GLshort c ) { }
3175 static void null_glIndexsv( const GLshort* c ) { }
3176 static void null_glIndexub( GLubyte c ) { }
3177 static void null_glIndexubv( const GLubyte* c ) { }
3178 static void null_glInitNames( void ) { }
3179 static void null_glInterleavedArrays( GLenum format, GLsizei stride, const GLvoid* pointer ) { }
3180 static GLboolean null_glIsEnabled( GLenum cap ) { return 0; }
3181 static GLboolean null_glIsList( GLuint list ) { return 0; }
3182 static GLboolean null_glIsTexture( GLuint texture ) { return 0; }
3183 static void null_glLightModelf( GLenum pname, GLfloat param ) { }
3184 static void null_glLightModelfv( GLenum pname, const GLfloat* params ) { }
3185 static void null_glLightModeli( GLenum pname, GLint param ) { }
3186 static void null_glLightModeliv( GLenum pname, const GLint* params ) { }
3187 static void null_glLightf( GLenum light, GLenum pname, GLfloat param ) { }
3188 static void null_glLightfv( GLenum light, GLenum pname, const GLfloat* params ) { }
3189 static void null_glLighti( GLenum light, GLenum pname, GLint param ) { }
3190 static void null_glLightiv( GLenum light, GLenum pname, const GLint* params ) { }
3191 static void null_glLineStipple( GLint factor, GLushort pattern ) { }
3192 static void null_glLineWidth( GLfloat width ) { }
3193 static void null_glListBase( GLuint base ) { }
3194 static void null_glLoadIdentity( void ) { }
3195 static void null_glLoadMatrixd( const GLdouble* m ) { }
3196 static void null_glLoadMatrixf( const GLfloat* m ) { }
3197 static void null_glLoadName( GLuint name ) { }
3198 static void null_glLogicOp( GLenum opcode ) { }
3199 static void null_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) { }
3200 static void null_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) { }
3201 static void null_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) { }
3202 static void null_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) { }
3203 static void null_glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) { }
3204 static void null_glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) { }
3205 static void null_glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) { }
3206 static void null_glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) { }
3207 static void null_glMaterialf( GLenum face, GLenum pname, GLfloat param ) { }
3208 static void null_glMaterialfv( GLenum face, GLenum pname, const GLfloat* params ) { }
3209 static void null_glMateriali( GLenum face, GLenum pname, GLint param ) { }
3210 static void null_glMaterialiv( GLenum face, GLenum pname, const GLint* params ) { }
3211 static void null_glMatrixMode( GLenum mode ) { }
3212 static void null_glMultMatrixd( const GLdouble* m ) { }
3213 static void null_glMultMatrixf( const GLfloat* m ) { }
3214 static void null_glNewList( GLuint list, GLenum mode ) { }
3215 static void null_glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) { }
3216 static void null_glNormal3bv( const GLbyte* v ) { }
3217 static void null_glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) { }
3218 static void null_glNormal3dv( const GLdouble* v ) { }
3219 static void null_glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) { }
3220 static void null_glNormal3fv( const GLfloat* v ) { }
3221 static void null_glNormal3i( GLint nx, GLint ny, GLint nz ) { }
3222 static void null_glNormal3iv( const GLint* v ) { }
3223 static void null_glNormal3s( GLshort nx, GLshort ny, GLshort nz ) { }
3224 static void null_glNormal3sv( const GLshort* v ) { }
3225 static void null_glNormalPointer( GLenum type, GLsizei stride, const GLvoid* pointer ) { }
3226 static void null_glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
3227 static void null_glPassThrough( GLfloat token ) { }
3228 static void null_glPixelMapfv( GLenum map, GLint mapsize, const GLfloat* values ) { }
3229 static void null_glPixelMapuiv( GLenum map, GLint mapsize, const GLuint* values ) { }
3230 static void null_glPixelMapusv( GLenum map, GLint mapsize, const GLushort* values ) { }
3231 static void null_glPixelStoref( GLenum pname, GLfloat param ) { }
3232 static void null_glPixelStorei( GLenum pname, GLint param ) { }
3233 static void null_glPixelTransferf( GLenum pname, GLfloat param ) { }
3234 static void null_glPixelTransferi( GLenum pname, GLint param ) { }
3235 static void null_glPixelZoom( GLfloat xfactor, GLfloat yfactor ) { }
3236 static void null_glPointSize( GLfloat size ) { }
3237 static void null_glPolygonMode( GLenum face, GLenum mode ) { }
3238 static void null_glPolygonOffset( GLfloat factor, GLfloat units ) { }
3239 static void null_glPolygonStipple( const GLubyte* mask ) { }
3240 static void null_glPopAttrib( void ) { }
3241 static void null_glPopClientAttrib( void ) { }
3242 static void null_glPopMatrix( void ) { }
3243 static void null_glPopName( void ) { }
3244 static void null_glPrioritizeTextures( GLsizei n, const GLuint* textures, const GLfloat* priorities ) { }
3245 static void null_glPushAttrib( GLbitfield mask ) { }
3246 static void null_glPushClientAttrib( GLbitfield mask ) { }
3247 static void null_glPushMatrix( void ) { }
3248 static void null_glPushName( GLuint name ) { }
3249 static void null_glRasterPos2d( GLdouble x, GLdouble y ) { }
3250 static void null_glRasterPos2dv( const GLdouble* v ) { }
3251 static void null_glRasterPos2f( GLfloat x, GLfloat y ) { }
3252 static void null_glRasterPos2fv( const GLfloat* v ) { }
3253 static void null_glRasterPos2i( GLint x, GLint y ) { }
3254 static void null_glRasterPos2iv( const GLint* v ) { }
3255 static void null_glRasterPos2s( GLshort x, GLshort y ) { }
3256 static void null_glRasterPos2sv( const GLshort* v ) { }
3257 static void null_glRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) { }
3258 static void null_glRasterPos3dv( const GLdouble* v ) { }
3259 static void null_glRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) { }
3260 static void null_glRasterPos3fv( const GLfloat* v ) { }
3261 static void null_glRasterPos3i( GLint x, GLint y, GLint z ) { }
3262 static void null_glRasterPos3iv( const GLint* v ) { }
3263 static void null_glRasterPos3s( GLshort x, GLshort y, GLshort z ) { }
3264 static void null_glRasterPos3sv( const GLshort* v ) { }
3265 static void null_glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
3266 static void null_glRasterPos4dv( const GLdouble* v ) { }
3267 static void null_glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
3268 static void null_glRasterPos4fv( const GLfloat* v ) { }
3269 static void null_glRasterPos4i( GLint x, GLint y, GLint z, GLint w ) { }
3270 static void null_glRasterPos4iv( const GLint* v ) { }
3271 static void null_glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) { }
3272 static void null_glRasterPos4sv( const GLshort* v ) { }
3273 static void null_glReadBuffer( GLenum mode ) { }
3274 static void null_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) { }
3275 static void null_glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) { }
3276 static void null_glRectdv( const GLdouble* v1, const GLdouble* v2 ) { }
3277 static void null_glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) { }
3278 static void null_glRectfv( const GLfloat* v1, const GLfloat* v2 ) { }
3279 static void null_glRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) { }
3280 static void null_glRectiv( const GLint* v1, const GLint* v2 ) { }
3281 static void null_glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) { }
3282 static void null_glRectsv( const GLshort* v1, const GLshort* v2 ) { }
3283 static GLint null_glRenderMode( GLenum mode ) { return 0; }
3284 static void null_glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) { }
3285 static void null_glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) { }
3286 static void null_glScaled( GLdouble x, GLdouble y, GLdouble z ) { }
3287 static void null_glScalef( GLfloat x, GLfloat y, GLfloat z ) { }
3288 static void null_glScissor( GLint x, GLint y, GLsizei width, GLsizei height ) { }
3289 static void null_glSelectBuffer( GLsizei size, GLuint* buffer ) { }
3290 static void null_glShadeModel( GLenum mode ) { }
3291 static void null_glStencilFunc( GLenum func, GLint ref, GLuint mask ) { }
3292 static void null_glStencilMask( GLuint mask ) { }
3293 static void null_glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) { }
3294 static void null_glTexCoord1d( GLdouble s ) { }
3295 static void null_glTexCoord1dv( const GLdouble* v ) { }
3296 static void null_glTexCoord1f( GLfloat s ) { }
3297 static void null_glTexCoord1fv( const GLfloat* v ) { }
3298 static void null_glTexCoord1i( GLint s ) { }
3299 static void null_glTexCoord1iv( const GLint* v ) { }
3300 static void null_glTexCoord1s( GLshort s ) { }
3301 static void null_glTexCoord1sv( const GLshort* v ) { }
3302 static void null_glTexCoord2d( GLdouble s, GLdouble t ) { }
3303 static void null_glTexCoord2dv( const GLdouble* v ) { }
3304 static void null_glTexCoord2f( GLfloat s, GLfloat t ) { }
3305 static void null_glTexCoord2fv( const GLfloat* v ) { }
3306 static void null_glTexCoord2i( GLint s, GLint t ) { }
3307 static void null_glTexCoord2iv( const GLint* v ) { }
3308 static void null_glTexCoord2s( GLshort s, GLshort t ) { }
3309 static void null_glTexCoord2sv( const GLshort* v ) { }
3310 static void null_glTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) { }
3311 static void null_glTexCoord3dv( const GLdouble* v ) { }
3312 static void null_glTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) { }
3313 static void null_glTexCoord3fv( const GLfloat* v ) { }
3314 static void null_glTexCoord3i( GLint s, GLint t, GLint r ) { }
3315 static void null_glTexCoord3iv( const GLint* v ) { }
3316 static void null_glTexCoord3s( GLshort s, GLshort t, GLshort r ) { }
3317 static void null_glTexCoord3sv( const GLshort* v ) { }
3318 static void null_glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { }
3319 static void null_glTexCoord4dv( const GLdouble* v ) { }
3320 static void null_glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { }
3321 static void null_glTexCoord4fv( const GLfloat* v ) { }
3322 static void null_glTexCoord4i( GLint s, GLint t, GLint r, GLint q ) { }
3323 static void null_glTexCoord4iv( const GLint* v ) { }
3324 static void null_glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) { }
3325 static void null_glTexCoord4sv( const GLshort* v ) { }
3326 static void null_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) { }
3327 static void null_glTexEnvf( GLenum target, GLenum pname, GLfloat param ) { }
3328 static void null_glTexEnvfv( GLenum target, GLenum pname, const GLfloat* params ) { }
3329 static void null_glTexEnvi( GLenum target, GLenum pname, GLint param ) { }
3330 static void null_glTexEnviv( GLenum target, GLenum pname, const GLint* params ) { }
3331 static void null_glTexGend( GLenum coord, GLenum pname, GLdouble param ) { }
3332 static void null_glTexGendv( GLenum coord, GLenum pname, const GLdouble* params ) { }
3333 static void null_glTexGenf( GLenum coord, GLenum pname, GLfloat param ) { }
3334 static void null_glTexGenfv( GLenum coord, GLenum pname, const GLfloat* params ) { }
3335 static void null_glTexGeni( GLenum coord, GLenum pname, GLint param ) { }
3336 static void null_glTexGeniv( GLenum coord, GLenum pname, const GLint* params ) { }
3337 static void null_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) { }
3338 static void null_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels ) { }
3339 static void null_glTexParameterf( GLenum target, GLenum pname, GLfloat param ) { }
3340 static void null_glTexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) { }
3341 static void null_glTexParameteri( GLenum target, GLenum pname, GLint param ) { }
3342 static void null_glTexParameteriv( GLenum target, GLenum pname, const GLint* params ) { }
3343 static void null_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid* pixels ) { }
3344 static void null_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels ) { }
3345 static void null_glTranslated( GLdouble x, GLdouble y, GLdouble z ) { }
3346 static void null_glTranslatef( GLfloat x, GLfloat y, GLfloat z ) { }
3347 static void null_glVertex2d( GLdouble x, GLdouble y ) { }
3348 static void null_glVertex2dv( const GLdouble* v ) { }
3349 static void null_glVertex2f( GLfloat x, GLfloat y ) { }
3350 static void null_glVertex2fv( const GLfloat* v ) { }
3351 static void null_glVertex2i( GLint x, GLint y ) { }
3352 static void null_glVertex2iv( const GLint* v ) { }
3353 static void null_glVertex2s( GLshort x, GLshort y ) { }
3354 static void null_glVertex2sv( const GLshort* v ) { }
3355 static void null_glVertex3d( GLdouble x, GLdouble y, GLdouble z ) { }
3356 static void null_glVertex3dv( const GLdouble* v ) { }
3357 static void null_glVertex3f( GLfloat x, GLfloat y, GLfloat z ) { }
3358 static void null_glVertex3fv( const GLfloat* v ) { }
3359 static void null_glVertex3i( GLint x, GLint y, GLint z ) { }
3360 static void null_glVertex3iv( const GLint* v ) { }
3361 static void null_glVertex3s( GLshort x, GLshort y, GLshort z ) { }
3362 static void null_glVertex3sv( const GLshort* v ) { }
3363 static void null_glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
3364 static void null_glVertex4dv( const GLdouble* v ) { }
3365 static void null_glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
3366 static void null_glVertex4fv( const GLfloat* v ) { }
3367 static void null_glVertex4i( GLint x, GLint y, GLint z, GLint w ) { }
3368 static void null_glVertex4iv( const GLint* v ) { }
3369 static void null_glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) { }
3370 static void null_glVertex4sv( const GLshort* v ) { }
3371 static void null_glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid* pointer ) { }
3372 static void null_glViewport( GLint x, GLint y, GLsizei width, GLsizei height ) { }
3373
3374 struct opengl_funcs null_opengl_funcs =
3375 {
3376     {
3377         null_wglCopyContext,
3378         null_wglCreateContext,
3379         null_wglDeleteContext,
3380         null_wglDescribePixelFormat,
3381         null_wglGetPixelFormat,
3382         null_wglGetProcAddress,
3383         null_wglMakeCurrent,
3384         null_wglSetPixelFormat,
3385         null_wglShareLists,
3386     },
3387 #define USE_GL_FUNC(name) null_##name,
3388     { ALL_WGL_FUNCS }
3389 #undef USE_GL_FUNC
3390 };