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