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 "wine_gl.h"
   6
   7
   8 /***********************************************************************
   9  *              glClearIndex
  10  */
  11 void WINAPI wine_glClearIndex(GLfloat c ) {
  12   ENTER_GL();
  13   glClearIndex(c);
  14   LEAVE_GL();
  15 }
  16
  17 /***********************************************************************
  18  *              glClearColor
  19  */
  20 void WINAPI wine_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
  21   ENTER_GL();
  22   glClearColor(red, green, blue, alpha);
  23   LEAVE_GL();
  24 }
  25
  26 /***********************************************************************
  27  *              glClear
  28  */
  29 void WINAPI wine_glClear(GLbitfield mask ) {
  30   ENTER_GL();
  31   glClear(mask);
  32   LEAVE_GL();
  33 }
  34
  35 /***********************************************************************
  36  *              glIndexMask
  37  */
  38 void WINAPI wine_glIndexMask(GLuint mask ) {
  39   ENTER_GL();
  40   glIndexMask(mask);
  41   LEAVE_GL();
  42 }
  43
  44 /***********************************************************************
  45  *              glColorMask
  46  */
  47 void WINAPI wine_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
  48   ENTER_GL();
  49   glColorMask(red, green, blue, alpha);
  50   LEAVE_GL();
  51 }
  52
  53 /***********************************************************************
  54  *              glAlphaFunc
  55  */
  56 void WINAPI wine_glAlphaFunc(GLenum func, GLclampf ref ) {
  57   ENTER_GL();
  58   glAlphaFunc(func, ref);
  59   LEAVE_GL();
  60 }
  61
  62 /***********************************************************************
  63  *              glBlendFunc
  64  */
  65 void WINAPI wine_glBlendFunc(GLenum sfactor, GLenum dfactor ) {
  66   ENTER_GL();
  67   glBlendFunc(sfactor, dfactor);
  68   LEAVE_GL();
  69 }
  70
  71 /***********************************************************************
  72  *              glLogicOp
  73  */
  74 void WINAPI wine_glLogicOp(GLenum opcode ) {
  75   ENTER_GL();
  76   glLogicOp(opcode);
  77   LEAVE_GL();
  78 }
  79
  80 /***********************************************************************
  81  *              glCullFace
  82  */
  83 void WINAPI wine_glCullFace(GLenum mode ) {
  84   ENTER_GL();
  85   glCullFace(mode);
  86   LEAVE_GL();
  87 }
  88
  89 /***********************************************************************
  90  *              glFrontFace
  91  */
  92 void WINAPI wine_glFrontFace(GLenum mode ) {
  93   ENTER_GL();
  94   glFrontFace(mode);
  95   LEAVE_GL();
  96 }
  97
  98 /***********************************************************************
  99  *              glPointSize
 100  */
 101 void WINAPI wine_glPointSize(GLfloat size ) {
 102   ENTER_GL();
 103   glPointSize(size);
 104   LEAVE_GL();
 105 }
 106
 107 /***********************************************************************
 108  *              glLineWidth
 109  */
 110 void WINAPI wine_glLineWidth(GLfloat width ) {
 111   ENTER_GL();
 112   glLineWidth(width);
 113   LEAVE_GL();
 114 }
 115
 116 /***********************************************************************
 117  *              glLineStipple
 118  */
 119 void WINAPI wine_glLineStipple(GLint factor, GLushort pattern ) {
 120   ENTER_GL();
 121   glLineStipple(factor, pattern);
 122   LEAVE_GL();
 123 }
 124
 125 /***********************************************************************
 126  *              glPolygonMode
 127  */
 128 void WINAPI wine_glPolygonMode(GLenum face, GLenum mode ) {
 129   ENTER_GL();
 130   glPolygonMode(face, mode);
 131   LEAVE_GL();
 132 }
 133
 134 /***********************************************************************
 135  *              glPolygonOffset
 136  */
 137 void WINAPI wine_glPolygonOffset(GLfloat factor, GLfloat units ) {
 138   ENTER_GL();
 139   glPolygonOffset(factor, units);
 140   LEAVE_GL();
 141 }
 142
 143 /***********************************************************************
 144  *              glPolygonStipple
 145  */
 146 void WINAPI wine_glPolygonStipple(const GLubyte *mask ) {
 147   ENTER_GL();
 148   glPolygonStipple(mask);
 149   LEAVE_GL();
 150 }
 151
 152 /***********************************************************************
 153  *              glGetPolygonStipple
 154  */
 155 void WINAPI wine_glGetPolygonStipple(GLubyte *mask ) {
 156   ENTER_GL();
 157   glGetPolygonStipple(mask);
 158   LEAVE_GL();
 159 }
 160
 161 /***********************************************************************
 162  *              glEdgeFlag
 163  */
 164 void WINAPI wine_glEdgeFlag(GLboolean flag ) {
 165   ENTER_GL();
 166   glEdgeFlag(flag);
 167   LEAVE_GL();
 168 }
 169
 170 /***********************************************************************
 171  *              glEdgeFlagv
 172  */
 173 void WINAPI wine_glEdgeFlagv(const GLboolean *flag ) {
 174   ENTER_GL();
 175   glEdgeFlagv(flag);
 176   LEAVE_GL();
 177 }
 178
 179 /***********************************************************************
 180  *              glScissor
 181  */
 182 void WINAPI wine_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 183   ENTER_GL();
 184   glScissor(x, y, width, height);
 185   LEAVE_GL();
 186 }
 187
 188 /***********************************************************************
 189  *              glClipPlane
 190  */
 191 void WINAPI wine_glClipPlane(GLenum plane, const GLdouble *equation ) {
 192   ENTER_GL();
 193   glClipPlane(plane, equation);
 194   LEAVE_GL();
 195 }
 196
 197 /***********************************************************************
 198  *              glGetClipPlane
 199  */
 200 void WINAPI wine_glGetClipPlane(GLenum plane, GLdouble *equation ) {
 201   ENTER_GL();
 202   glGetClipPlane(plane, equation);
 203   LEAVE_GL();
 204 }
 205
 206 /***********************************************************************
 207  *              glDrawBuffer
 208  */
 209 void WINAPI wine_glDrawBuffer(GLenum mode ) {
 210   ENTER_GL();
 211   glDrawBuffer(mode);
 212   LEAVE_GL();
 213 }
 214
 215 /***********************************************************************
 216  *              glReadBuffer
 217  */
 218 void WINAPI wine_glReadBuffer(GLenum mode ) {
 219   ENTER_GL();
 220   glReadBuffer(mode);
 221   LEAVE_GL();
 222 }
 223
 224 /***********************************************************************
 225  *              glEnable
 226  */
 227 void WINAPI wine_glEnable(GLenum cap ) {
 228   ENTER_GL();
 229   glEnable(cap);
 230   LEAVE_GL();
 231 }
 232
 233 /***********************************************************************
 234  *              glDisable
 235  */
 236 void WINAPI wine_glDisable(GLenum cap ) {
 237   ENTER_GL();
 238   glDisable(cap);
 239   LEAVE_GL();
 240 }
 241
 242 /***********************************************************************
 243  *              glIsEnabled
 244  */
 245 GLboolean WINAPI wine_glIsEnabled(GLenum cap ) {
 246   GLboolean ret;
 247   ENTER_GL();
 248   ret = glIsEnabled(cap);
 249   LEAVE_GL();
 250   return ret;
 251 }
 252
 253 /***********************************************************************
 254  *              glEnableClientState
 255  */
 256 void WINAPI wine_glEnableClientState(GLenum cap ) {
 257   ENTER_GL();
 258   glEnableClientState(cap);
 259   LEAVE_GL();
 260 }
 261
 262 /***********************************************************************
 263  *              glDisableClientState
 264  */
 265 void WINAPI wine_glDisableClientState(GLenum cap ) {
 266   ENTER_GL();
 267   glDisableClientState(cap);
 268   LEAVE_GL();
 269 }
 270
 271 /***********************************************************************
 272  *              glGetBooleanv
 273  */
 274 void WINAPI wine_glGetBooleanv(GLenum pname, GLboolean *params ) {
 275   ENTER_GL();
 276   glGetBooleanv(pname, params);
 277   LEAVE_GL();
 278 }
 279
 280 /***********************************************************************
 281  *              glGetDoublev
 282  */
 283 void WINAPI wine_glGetDoublev(GLenum pname, GLdouble *params ) {
 284   ENTER_GL();
 285   glGetDoublev(pname, params);
 286   LEAVE_GL();
 287 }
 288
 289 /***********************************************************************
 290  *              glGetFloatv
 291  */
 292 void WINAPI wine_glGetFloatv(GLenum pname, GLfloat *params ) {
 293   ENTER_GL();
 294   glGetFloatv(pname, params);
 295   LEAVE_GL();
 296 }
 297
 298 /***********************************************************************
 299  *              glGetIntegerv
 300  */
 301 void WINAPI wine_glGetIntegerv(GLenum pname, GLint *params ) {
 302   ENTER_GL();
 303   glGetIntegerv(pname, params);
 304   LEAVE_GL();
 305 }
 306
 307 /***********************************************************************
 308  *              glPushAttrib
 309  */
 310 void WINAPI wine_glPushAttrib(GLbitfield mask ) {
 311   ENTER_GL();
 312   glPushAttrib(mask);
 313   LEAVE_GL();
 314 }
 315
 316 /***********************************************************************
 317  *              glPopAttrib
 318  */
 319 void WINAPI wine_glPopAttrib(void ) {
 320   ENTER_GL();
 321   glPopAttrib();
 322   LEAVE_GL();
 323 }
 324
 325 /***********************************************************************
 326  *              glPushClientAttrib
 327  */
 328 void WINAPI wine_glPushClientAttrib(GLbitfield mask ) {
 329   ENTER_GL();
 330   glPushClientAttrib(mask);
 331   LEAVE_GL();
 332 }
 333
 334 /***********************************************************************
 335  *              glPopClientAttrib
 336  */
 337 void WINAPI wine_glPopClientAttrib(void ) {
 338   ENTER_GL();
 339   glPopClientAttrib();
 340   LEAVE_GL();
 341 }
 342
 343 /***********************************************************************
 344  *              glRenderMode
 345  */
 346 GLint WINAPI wine_glRenderMode(GLenum mode ) {
 347   GLint ret;
 348   ENTER_GL();
 349   ret = glRenderMode(mode);
 350   LEAVE_GL();
 351   return ret;
 352 }
 353
 354 /***********************************************************************
 355  *              glGetError
 356  */
 357 GLenum WINAPI wine_glGetError(void ) {
 358   GLenum ret;
 359   ENTER_GL();
 360   ret = glGetError();
 361   LEAVE_GL();
 362   return ret;
 363 }
 364
 365 /***********************************************************************
 366  *              glGetString
 367  */
 368 const GLubyte* WINAPI wine_glGetString(GLenum name ) {
 369   const GLubyte* ret;
 370   ENTER_GL();
 371   ret = glGetString(name);
 372   LEAVE_GL();
 373   return ret;
 374 }
 375
 376 /***********************************************************************
 377  *              glFinish
 378  */
 379 void WINAPI wine_glFinish(void ) {
 380   ENTER_GL();
 381   glFinish();
 382   LEAVE_GL();
 383 }
 384
 385 /***********************************************************************
 386  *              glFlush
 387  */
 388 void WINAPI wine_glFlush(void ) {
 389   ENTER_GL();
 390   glFlush();
 391   LEAVE_GL();
 392 }
 393
 394 /***********************************************************************
 395  *              glHint
 396  */
 397 void WINAPI wine_glHint(GLenum target, GLenum mode ) {
 398   ENTER_GL();
 399   glHint(target, mode);
 400   LEAVE_GL();
 401 }
 402
 403 /***********************************************************************
 404  *              glClearDepth
 405  */
 406 void WINAPI wine_glClearDepth(GLclampd depth ) {
 407   ENTER_GL();
 408   glClearDepth(depth);
 409   LEAVE_GL();
 410 }
 411
 412 /***********************************************************************
 413  *              glDepthFunc
 414  */
 415 void WINAPI wine_glDepthFunc(GLenum func ) {
 416   ENTER_GL();
 417   glDepthFunc(func);
 418   LEAVE_GL();
 419 }
 420
 421 /***********************************************************************
 422  *              glDepthMask
 423  */
 424 void WINAPI wine_glDepthMask(GLboolean flag ) {
 425   ENTER_GL();
 426   glDepthMask(flag);
 427   LEAVE_GL();
 428 }
 429
 430 /***********************************************************************
 431  *              glDepthRange
 432  */
 433 void WINAPI wine_glDepthRange(GLclampd near_val, GLclampd far_val ) {
 434   ENTER_GL();
 435   glDepthRange(near_val, far_val);
 436   LEAVE_GL();
 437 }
 438
 439 /***********************************************************************
 440  *              glClearAccum
 441  */
 442 void WINAPI wine_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
 443   ENTER_GL();
 444   glClearAccum(red, green, blue, alpha);
 445   LEAVE_GL();
 446 }
 447
 448 /***********************************************************************
 449  *              glAccum
 450  */
 451 void WINAPI wine_glAccum(GLenum op, GLfloat value ) {
 452   ENTER_GL();
 453   glAccum(op, value);
 454   LEAVE_GL();
 455 }
 456
 457 /***********************************************************************
 458  *              glMatrixMode
 459  */
 460 void WINAPI wine_glMatrixMode(GLenum mode ) {
 461   ENTER_GL();
 462   glMatrixMode(mode);
 463   LEAVE_GL();
 464 }
 465
 466 /***********************************************************************
 467  *              glOrtho
 468  */
 469 void WINAPI wine_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) {
 470   ENTER_GL();
 471   glOrtho(left, right, bottom, top, near_val, far_val);
 472   LEAVE_GL();
 473 }
 474
 475 /***********************************************************************
 476  *              glFrustum
 477  */
 478 void WINAPI wine_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val ) {
 479   ENTER_GL();
 480   glFrustum(left, right, bottom, top, near_val, far_val);
 481   LEAVE_GL();
 482 }
 483
 484 /***********************************************************************
 485  *              glViewport
 486  */
 487 void WINAPI wine_glViewport(GLint x, GLint y, GLsizei width, GLsizei height ) {
 488   ENTER_GL();
 489   glViewport(x, y, width, height);
 490   LEAVE_GL();
 491 }
 492
 493 /***********************************************************************
 494  *              glPushMatrix
 495  */
 496 void WINAPI wine_glPushMatrix(void ) {
 497   ENTER_GL();
 498   glPushMatrix();
 499   LEAVE_GL();
 500 }
 501
 502 /***********************************************************************
 503  *              glPopMatrix
 504  */
 505 void WINAPI wine_glPopMatrix(void ) {
 506   ENTER_GL();
 507   glPopMatrix();
 508   LEAVE_GL();
 509 }
 510
 511 /***********************************************************************
 512  *              glLoadIdentity
 513  */
 514 void WINAPI wine_glLoadIdentity(void ) {
 515   ENTER_GL();
 516   glLoadIdentity();
 517   LEAVE_GL();
 518 }
 519
 520 /***********************************************************************
 521  *              glLoadMatrixd
 522  */
 523 void WINAPI wine_glLoadMatrixd(const GLdouble *m ) {
 524   ENTER_GL();
 525   glLoadMatrixd(m);
 526   LEAVE_GL();
 527 }
 528
 529 /***********************************************************************
 530  *              glLoadMatrixf
 531  */
 532 void WINAPI wine_glLoadMatrixf(const GLfloat *m ) {
 533   ENTER_GL();
 534   glLoadMatrixf(m);
 535   LEAVE_GL();
 536 }
 537
 538 /***********************************************************************
 539  *              glMultMatrixd
 540  */
 541 void WINAPI wine_glMultMatrixd(const GLdouble *m ) {
 542   ENTER_GL();
 543   glMultMatrixd(m);
 544   LEAVE_GL();
 545 }
 546
 547 /***********************************************************************
 548  *              glMultMatrixf
 549  */
 550 void WINAPI wine_glMultMatrixf(const GLfloat *m ) {
 551   ENTER_GL();
 552   glMultMatrixf(m);
 553   LEAVE_GL();
 554 }
 555
 556 /***********************************************************************
 557  *              glRotated
 558  */
 559 void WINAPI wine_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
 560   ENTER_GL();
 561   glRotated(angle, x, y, z);
 562   LEAVE_GL();
 563 }
 564
 565 /***********************************************************************
 566  *              glRotatef
 567  */
 568 void WINAPI wine_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
 569   ENTER_GL();
 570   glRotatef(angle, x, y, z);
 571   LEAVE_GL();
 572 }
 573
 574 /***********************************************************************
 575  *              glScaled
 576  */
 577 void WINAPI wine_glScaled(GLdouble x, GLdouble y, GLdouble z ) {
 578   ENTER_GL();
 579   glScaled(x, y, z);
 580   LEAVE_GL();
 581 }
 582
 583 /***********************************************************************
 584  *              glScalef
 585  */
 586 void WINAPI wine_glScalef(GLfloat x, GLfloat y, GLfloat z ) {
 587   ENTER_GL();
 588   glScalef(x, y, z);
 589   LEAVE_GL();
 590 }
 591
 592 /***********************************************************************
 593  *              glTranslated
 594  */
 595 void WINAPI wine_glTranslated(GLdouble x, GLdouble y, GLdouble z ) {
 596   ENTER_GL();
 597   glTranslated(x, y, z);
 598   LEAVE_GL();
 599 }
 600
 601 /***********************************************************************
 602  *              glTranslatef
 603  */
 604 void WINAPI wine_glTranslatef(GLfloat x, GLfloat y, GLfloat z ) {
 605   ENTER_GL();
 606   glTranslatef(x, y, z);
 607   LEAVE_GL();
 608 }
 609
 610 /***********************************************************************
 611  *              glIsList
 612  */
 613 GLboolean WINAPI wine_glIsList(GLuint list ) {
 614   GLboolean ret;
 615   ENTER_GL();
 616   ret = glIsList(list);
 617   LEAVE_GL();
 618   return ret;
 619 }
 620
 621 /***********************************************************************
 622  *              glDeleteLists
 623  */
 624 void WINAPI wine_glDeleteLists(GLuint list, GLsizei range ) {
 625   ENTER_GL();
 626   glDeleteLists(list, range);
 627   LEAVE_GL();
 628 }
 629
 630 /***********************************************************************
 631  *              glGenLists
 632  */
 633 GLuint WINAPI wine_glGenLists(GLsizei range ) {
 634   GLuint ret;
 635   ENTER_GL();
 636   ret = glGenLists(range);
 637   LEAVE_GL();
 638   return ret;
 639 }
 640
 641 /***********************************************************************
 642  *              glNewList
 643  */
 644 void WINAPI wine_glNewList(GLuint list, GLenum mode ) {
 645   ENTER_GL();
 646   glNewList(list, mode);
 647   LEAVE_GL();
 648 }
 649
 650 /***********************************************************************
 651  *              glEndList
 652  */
 653 void WINAPI wine_glEndList(void ) {
 654   ENTER_GL();
 655   glEndList();
 656   LEAVE_GL();
 657 }
 658
 659 /***********************************************************************
 660  *              glCallList
 661  */
 662 void WINAPI wine_glCallList(GLuint list ) {
 663   ENTER_GL();
 664   glCallList(list);
 665   LEAVE_GL();
 666 }
 667
 668 /***********************************************************************
 669  *              glCallLists
 670  */
 671 void WINAPI wine_glCallLists(GLsizei n, GLenum type, const GLvoid *lists ) {
 672   ENTER_GL();
 673   glCallLists(n, type, lists);
 674   LEAVE_GL();
 675 }
 676
 677 /***********************************************************************
 678  *              glListBase
 679  */
 680 void WINAPI wine_glListBase(GLuint base ) {
 681   ENTER_GL();
 682   glListBase(base);
 683   LEAVE_GL();
 684 }
 685
 686 /***********************************************************************
 687  *              glBegin
 688  */
 689 void WINAPI wine_glBegin(GLenum mode ) {
 690   ENTER_GL();
 691   glBegin(mode);
 692   LEAVE_GL();
 693 }
 694
 695 /***********************************************************************
 696  *              glEnd
 697  */
 698 void WINAPI wine_glEnd(void ) {
 699   ENTER_GL();
 700   glEnd();
 701   LEAVE_GL();
 702 }
 703
 704 /***********************************************************************
 705  *              glVertex2d
 706  */
 707 void WINAPI wine_glVertex2d(GLdouble x, GLdouble y ) {
 708   ENTER_GL();
 709   glVertex2d(x, y);
 710   LEAVE_GL();
 711 }
 712
 713 /***********************************************************************
 714  *              glVertex2f
 715  */
 716 void WINAPI wine_glVertex2f(GLfloat x, GLfloat y ) {
 717   ENTER_GL();
 718   glVertex2f(x, y);
 719   LEAVE_GL();
 720 }
 721
 722 /***********************************************************************
 723  *              glVertex2i
 724  */
 725 void WINAPI wine_glVertex2i(GLint x, GLint y ) {
 726   ENTER_GL();
 727   glVertex2i(x, y);
 728   LEAVE_GL();
 729 }
 730
 731 /***********************************************************************
 732  *              glVertex2s
 733  */
 734 void WINAPI wine_glVertex2s(GLshort x, GLshort y ) {
 735   ENTER_GL();
 736   glVertex2s(x, y);
 737   LEAVE_GL();
 738 }
 739
 740 /***********************************************************************
 741  *              glVertex3d
 742  */
 743 void WINAPI wine_glVertex3d(GLdouble x, GLdouble y, GLdouble z ) {
 744   ENTER_GL();
 745   glVertex3d(x, y, z);
 746   LEAVE_GL();
 747 }
 748
 749 /***********************************************************************
 750  *              glVertex3f
 751  */
 752 void WINAPI wine_glVertex3f(GLfloat x, GLfloat y, GLfloat z ) {
 753   ENTER_GL();
 754   glVertex3f(x, y, z);
 755   LEAVE_GL();
 756 }
 757
 758 /***********************************************************************
 759  *              glVertex3i
 760  */
 761 void WINAPI wine_glVertex3i(GLint x, GLint y, GLint z ) {
 762   ENTER_GL();
 763   glVertex3i(x, y, z);
 764   LEAVE_GL();
 765 }
 766
 767 /***********************************************************************
 768  *              glVertex3s
 769  */
 770 void WINAPI wine_glVertex3s(GLshort x, GLshort y, GLshort z ) {
 771   ENTER_GL();
 772   glVertex3s(x, y, z);
 773   LEAVE_GL();
 774 }
 775
 776 /***********************************************************************
 777  *              glVertex4d
 778  */
 779 void WINAPI wine_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
 780   ENTER_GL();
 781   glVertex4d(x, y, z, w);
 782   LEAVE_GL();
 783 }
 784
 785 /***********************************************************************
 786  *              glVertex4f
 787  */
 788 void WINAPI wine_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
 789   ENTER_GL();
 790   glVertex4f(x, y, z, w);
 791   LEAVE_GL();
 792 }
 793
 794 /***********************************************************************
 795  *              glVertex4i
 796  */
 797 void WINAPI wine_glVertex4i(GLint x, GLint y, GLint z, GLint w ) {
 798   ENTER_GL();
 799   glVertex4i(x, y, z, w);
 800   LEAVE_GL();
 801 }
 802
 803 /***********************************************************************
 804  *              glVertex4s
 805  */
 806 void WINAPI wine_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w ) {
 807   ENTER_GL();
 808   glVertex4s(x, y, z, w);
 809   LEAVE_GL();
 810 }
 811
 812 /***********************************************************************
 813  *              glVertex2dv
 814  */
 815 void WINAPI wine_glVertex2dv(const GLdouble *v ) {
 816   ENTER_GL();
 817   glVertex2dv(v);
 818   LEAVE_GL();
 819 }
 820
 821 /***********************************************************************
 822  *              glVertex2fv
 823  */
 824 void WINAPI wine_glVertex2fv(const GLfloat *v ) {
 825   ENTER_GL();
 826   glVertex2fv(v);
 827   LEAVE_GL();
 828 }
 829
 830 /***********************************************************************
 831  *              glVertex2iv
 832  */
 833 void WINAPI wine_glVertex2iv(const GLint *v ) {
 834   ENTER_GL();
 835   glVertex2iv(v);
 836   LEAVE_GL();
 837 }
 838
 839 /***********************************************************************
 840  *              glVertex2sv
 841  */
 842 void WINAPI wine_glVertex2sv(const GLshort *v ) {
 843   ENTER_GL();
 844   glVertex2sv(v);
 845   LEAVE_GL();
 846 }
 847
 848 /***********************************************************************
 849  *              glVertex3dv
 850  */
 851 void WINAPI wine_glVertex3dv(const GLdouble *v ) {
 852   ENTER_GL();
 853   glVertex3dv(v);
 854   LEAVE_GL();
 855 }
 856
 857 /***********************************************************************
 858  *              glVertex3fv
 859  */
 860 void WINAPI wine_glVertex3fv(const GLfloat *v ) {
 861   ENTER_GL();
 862   glVertex3fv(v);
 863   LEAVE_GL();
 864 }
 865
 866 /***********************************************************************
 867  *              glVertex3iv
 868  */
 869 void WINAPI wine_glVertex3iv(const GLint *v ) {
 870   ENTER_GL();
 871   glVertex3iv(v);
 872   LEAVE_GL();
 873 }
 874
 875 /***********************************************************************
 876  *              glVertex3sv
 877  */
 878 void WINAPI wine_glVertex3sv(const GLshort *v ) {
 879   ENTER_GL();
 880   glVertex3sv(v);
 881   LEAVE_GL();
 882 }
 883
 884 /***********************************************************************
 885  *              glVertex4dv
 886  */
 887 void WINAPI wine_glVertex4dv(const GLdouble *v ) {
 888   ENTER_GL();
 889   glVertex4dv(v);
 890   LEAVE_GL();
 891 }
 892
 893 /***********************************************************************
 894  *              glVertex4fv
 895  */
 896 void WINAPI wine_glVertex4fv(const GLfloat *v ) {
 897   ENTER_GL();
 898   glVertex4fv(v);
 899   LEAVE_GL();
 900 }
 901
 902 /***********************************************************************
 903  *              glVertex4iv
 904  */
 905 void WINAPI wine_glVertex4iv(const GLint *v ) {
 906   ENTER_GL();
 907   glVertex4iv(v);
 908   LEAVE_GL();
 909 }
 910
 911 /***********************************************************************
 912  *              glVertex4sv
 913  */
 914 void WINAPI wine_glVertex4sv(const GLshort *v ) {
 915   ENTER_GL();
 916   glVertex4sv(v);
 917   LEAVE_GL();
 918 }
 919
 920 /***********************************************************************
 921  *              glNormal3b
 922  */
 923 void WINAPI wine_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz ) {
 924   ENTER_GL();
 925   glNormal3b(nx, ny, nz);
 926   LEAVE_GL();
 927 }
 928
 929 /***********************************************************************
 930  *              glNormal3d
 931  */
 932 void WINAPI wine_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz ) {
 933   ENTER_GL();
 934   glNormal3d(nx, ny, nz);
 935   LEAVE_GL();
 936 }
 937
 938 /***********************************************************************
 939  *              glNormal3f
 940  */
 941 void WINAPI wine_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz ) {
 942   ENTER_GL();
 943   glNormal3f(nx, ny, nz);
 944   LEAVE_GL();
 945 }
 946
 947 /***********************************************************************
 948  *              glNormal3i
 949  */
 950 void WINAPI wine_glNormal3i(GLint nx, GLint ny, GLint nz ) {
 951   ENTER_GL();
 952   glNormal3i(nx, ny, nz);
 953   LEAVE_GL();
 954 }
 955
 956 /***********************************************************************
 957  *              glNormal3s
 958  */
 959 void WINAPI wine_glNormal3s(GLshort nx, GLshort ny, GLshort nz ) {
 960   ENTER_GL();
 961   glNormal3s(nx, ny, nz);
 962   LEAVE_GL();
 963 }
 964
 965 /***********************************************************************
 966  *              glNormal3bv
 967  */
 968 void WINAPI wine_glNormal3bv(const GLbyte *v ) {
 969   ENTER_GL();
 970   glNormal3bv(v);
 971   LEAVE_GL();
 972 }
 973
 974 /***********************************************************************
 975  *              glNormal3dv
 976  */
 977 void WINAPI wine_glNormal3dv(const GLdouble *v ) {
 978   ENTER_GL();
 979   glNormal3dv(v);
 980   LEAVE_GL();
 981 }
 982
 983 /***********************************************************************
 984  *              glNormal3fv
 985  */
 986 void WINAPI wine_glNormal3fv(const GLfloat *v ) {
 987   ENTER_GL();
 988   glNormal3fv(v);
 989   LEAVE_GL();
 990 }
 991
 992 /***********************************************************************
 993  *              glNormal3iv
 994  */
 995 void WINAPI wine_glNormal3iv(const GLint *v ) {
 996   ENTER_GL();
 997   glNormal3iv(v);
 998   LEAVE_GL();
 999 }
1000
1001 /***********************************************************************
1002  *              glNormal3sv
1003  */
1004 void WINAPI wine_glNormal3sv(const GLshort *v ) {
1005   ENTER_GL();
1006   glNormal3sv(v);
1007   LEAVE_GL();
1008 }
1009
1010 /***********************************************************************
1011  *              glIndexd
1012  */
1013 void WINAPI wine_glIndexd(GLdouble c ) {
1014   ENTER_GL();
1015   glIndexd(c);
1016   LEAVE_GL();
1017 }
1018
1019 /***********************************************************************
1020  *              glIndexf
1021  */
1022 void WINAPI wine_glIndexf(GLfloat c ) {
1023   ENTER_GL();
1024   glIndexf(c);
1025   LEAVE_GL();
1026 }
1027
1028 /***********************************************************************
1029  *              glIndexi
1030  */
1031 void WINAPI wine_glIndexi(GLint c ) {
1032   ENTER_GL();
1033   glIndexi(c);
1034   LEAVE_GL();
1035 }
1036
1037 /***********************************************************************
1038  *              glIndexs
1039  */
1040 void WINAPI wine_glIndexs(GLshort c ) {
1041   ENTER_GL();
1042   glIndexs(c);
1043   LEAVE_GL();
1044 }
1045
1046 /***********************************************************************
1047  *              glIndexub
1048  */
1049 void WINAPI wine_glIndexub(GLubyte c ) {
1050   ENTER_GL();
1051   glIndexub(c);
1052   LEAVE_GL();
1053 }
1054
1055 /***********************************************************************
1056  *              glIndexdv
1057  */
1058 void WINAPI wine_glIndexdv(const GLdouble *c ) {
1059   ENTER_GL();
1060   glIndexdv(c);
1061   LEAVE_GL();
1062 }
1063
1064 /***********************************************************************
1065  *              glIndexfv
1066  */
1067 void WINAPI wine_glIndexfv(const GLfloat *c ) {
1068   ENTER_GL();
1069   glIndexfv(c);
1070   LEAVE_GL();
1071 }
1072
1073 /***********************************************************************
1074  *              glIndexiv
1075  */
1076 void WINAPI wine_glIndexiv(const GLint *c ) {
1077   ENTER_GL();
1078   glIndexiv(c);
1079   LEAVE_GL();
1080 }
1081
1082 /***********************************************************************
1083  *              glIndexsv
1084  */
1085 void WINAPI wine_glIndexsv(const GLshort *c ) {
1086   ENTER_GL();
1087   glIndexsv(c);
1088   LEAVE_GL();
1089 }
1090
1091 /***********************************************************************
1092  *              glIndexubv
1093  */
1094 void WINAPI wine_glIndexubv(const GLubyte *c ) {
1095   ENTER_GL();
1096   glIndexubv(c);
1097   LEAVE_GL();
1098 }
1099
1100 /***********************************************************************
1101  *              glColor3b
1102  */
1103 void WINAPI wine_glColor3b(GLbyte red, GLbyte green, GLbyte blue ) {
1104   ENTER_GL();
1105   glColor3b(red, green, blue);
1106   LEAVE_GL();
1107 }
1108
1109 /***********************************************************************
1110  *              glColor3d
1111  */
1112 void WINAPI wine_glColor3d(GLdouble red, GLdouble green, GLdouble blue ) {
1113   ENTER_GL();
1114   glColor3d(red, green, blue);
1115   LEAVE_GL();
1116 }
1117
1118 /***********************************************************************
1119  *              glColor3f
1120  */
1121 void WINAPI wine_glColor3f(GLfloat red, GLfloat green, GLfloat blue ) {
1122   ENTER_GL();
1123   glColor3f(red, green, blue);
1124   LEAVE_GL();
1125 }
1126
1127 /***********************************************************************
1128  *              glColor3i
1129  */
1130 void WINAPI wine_glColor3i(GLint red, GLint green, GLint blue ) {
1131   ENTER_GL();
1132   glColor3i(red, green, blue);
1133   LEAVE_GL();
1134 }
1135
1136 /***********************************************************************
1137  *              glColor3s
1138  */
1139 void WINAPI wine_glColor3s(GLshort red, GLshort green, GLshort blue ) {
1140   ENTER_GL();
1141   glColor3s(red, green, blue);
1142   LEAVE_GL();
1143 }
1144
1145 /***********************************************************************
1146  *              glColor3ub
1147  */
1148 void WINAPI wine_glColor3ub(GLubyte red, GLubyte green, GLubyte blue ) {
1149   ENTER_GL();
1150   glColor3ub(red, green, blue);
1151   LEAVE_GL();
1152 }
1153
1154 /***********************************************************************
1155  *              glColor3ui
1156  */
1157 void WINAPI wine_glColor3ui(GLuint red, GLuint green, GLuint blue ) {
1158   ENTER_GL();
1159   glColor3ui(red, green, blue);
1160   LEAVE_GL();
1161 }
1162
1163 /***********************************************************************
1164  *              glColor3us
1165  */
1166 void WINAPI wine_glColor3us(GLushort red, GLushort green, GLushort blue ) {
1167   ENTER_GL();
1168   glColor3us(red, green, blue);
1169   LEAVE_GL();
1170 }
1171
1172 /***********************************************************************
1173  *              glColor4b
1174  */
1175 void WINAPI wine_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) {
1176   ENTER_GL();
1177   glColor4b(red, green, blue, alpha);
1178   LEAVE_GL();
1179 }
1180
1181 /***********************************************************************
1182  *              glColor4d
1183  */
1184 void WINAPI wine_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) {
1185   ENTER_GL();
1186   glColor4d(red, green, blue, alpha);
1187   LEAVE_GL();
1188 }
1189
1190 /***********************************************************************
1191  *              glColor4f
1192  */
1193 void WINAPI wine_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
1194   ENTER_GL();
1195   glColor4f(red, green, blue, alpha);
1196   LEAVE_GL();
1197 }
1198
1199 /***********************************************************************
1200  *              glColor4i
1201  */
1202 void WINAPI wine_glColor4i(GLint red, GLint green, GLint blue, GLint alpha ) {
1203   ENTER_GL();
1204   glColor4i(red, green, blue, alpha);
1205   LEAVE_GL();
1206 }
1207
1208 /***********************************************************************
1209  *              glColor4s
1210  */
1211 void WINAPI wine_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha ) {
1212   ENTER_GL();
1213   glColor4s(red, green, blue, alpha);
1214   LEAVE_GL();
1215 }
1216
1217 /***********************************************************************
1218  *              glColor4ub
1219  */
1220 void WINAPI wine_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) {
1221   ENTER_GL();
1222   glColor4ub(red, green, blue, alpha);
1223   LEAVE_GL();
1224 }
1225
1226 /***********************************************************************
1227  *              glColor4ui
1228  */
1229 void WINAPI wine_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
1230   ENTER_GL();
1231   glColor4ui(red, green, blue, alpha);
1232   LEAVE_GL();
1233 }
1234
1235 /***********************************************************************
1236  *              glColor4us
1237  */
1238 void WINAPI wine_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha ) {
1239   ENTER_GL();
1240   glColor4us(red, green, blue, alpha);
1241   LEAVE_GL();
1242 }
1243
1244 /***********************************************************************
1245  *              glColor3bv
1246  */
1247 void WINAPI wine_glColor3bv(const GLbyte *v ) {
1248   ENTER_GL();
1249   glColor3bv(v);
1250   LEAVE_GL();
1251 }
1252
1253 /***********************************************************************
1254  *              glColor3dv
1255  */
1256 void WINAPI wine_glColor3dv(const GLdouble *v ) {
1257   ENTER_GL();
1258   glColor3dv(v);
1259   LEAVE_GL();
1260 }
1261
1262 /***********************************************************************
1263  *              glColor3fv
1264  */
1265 void WINAPI wine_glColor3fv(const GLfloat *v ) {
1266   ENTER_GL();
1267   glColor3fv(v);
1268   LEAVE_GL();
1269 }
1270
1271 /***********************************************************************
1272  *              glColor3iv
1273  */
1274 void WINAPI wine_glColor3iv(const GLint *v ) {
1275   ENTER_GL();
1276   glColor3iv(v);
1277   LEAVE_GL();
1278 }
1279
1280 /***********************************************************************
1281  *              glColor3sv
1282  */
1283 void WINAPI wine_glColor3sv(const GLshort *v ) {
1284   ENTER_GL();
1285   glColor3sv(v);
1286   LEAVE_GL();
1287 }
1288
1289 /***********************************************************************
1290  *              glColor3ubv
1291  */
1292 void WINAPI wine_glColor3ubv(const GLubyte *v ) {
1293   ENTER_GL();
1294   glColor3ubv(v);
1295   LEAVE_GL();
1296 }
1297
1298 /***********************************************************************
1299  *              glColor3uiv
1300  */
1301 void WINAPI wine_glColor3uiv(const GLuint *v ) {
1302   ENTER_GL();
1303   glColor3uiv(v);
1304   LEAVE_GL();
1305 }
1306
1307 /***********************************************************************
1308  *              glColor3usv
1309  */
1310 void WINAPI wine_glColor3usv(const GLushort *v ) {
1311   ENTER_GL();
1312   glColor3usv(v);
1313   LEAVE_GL();
1314 }
1315
1316 /***********************************************************************
1317  *              glColor4bv
1318  */
1319 void WINAPI wine_glColor4bv(const GLbyte *v ) {
1320   ENTER_GL();
1321   glColor4bv(v);
1322   LEAVE_GL();
1323 }
1324
1325 /***********************************************************************
1326  *              glColor4dv
1327  */
1328 void WINAPI wine_glColor4dv(const GLdouble *v ) {
1329   ENTER_GL();
1330   glColor4dv(v);
1331   LEAVE_GL();
1332 }
1333
1334 /***********************************************************************
1335  *              glColor4fv
1336  */
1337 void WINAPI wine_glColor4fv(const GLfloat *v ) {
1338   ENTER_GL();
1339   glColor4fv(v);
1340   LEAVE_GL();
1341 }
1342
1343 /***********************************************************************
1344  *              glColor4iv
1345  */
1346 void WINAPI wine_glColor4iv(const GLint *v ) {
1347   ENTER_GL();
1348   glColor4iv(v);
1349   LEAVE_GL();
1350 }
1351
1352 /***********************************************************************
1353  *              glColor4sv
1354  */
1355 void WINAPI wine_glColor4sv(const GLshort *v ) {
1356   ENTER_GL();
1357   glColor4sv(v);
1358   LEAVE_GL();
1359 }
1360
1361 /***********************************************************************
1362  *              glColor4ubv
1363  */
1364 void WINAPI wine_glColor4ubv(const GLubyte *v ) {
1365   ENTER_GL();
1366   glColor4ubv(v);
1367   LEAVE_GL();
1368 }
1369
1370 /***********************************************************************
1371  *              glColor4uiv
1372  */
1373 void WINAPI wine_glColor4uiv(const GLuint *v ) {
1374   ENTER_GL();
1375   glColor4uiv(v);
1376   LEAVE_GL();
1377 }
1378
1379 /***********************************************************************
1380  *              glColor4usv
1381  */
1382 void WINAPI wine_glColor4usv(const GLushort *v ) {
1383   ENTER_GL();
1384   glColor4usv(v);
1385   LEAVE_GL();
1386 }
1387
1388 /***********************************************************************
1389  *              glTexCoord1d
1390  */
1391 void WINAPI wine_glTexCoord1d(GLdouble s ) {
1392   ENTER_GL();
1393   glTexCoord1d(s);
1394   LEAVE_GL();
1395 }
1396
1397 /***********************************************************************
1398  *              glTexCoord1f
1399  */
1400 void WINAPI wine_glTexCoord1f(GLfloat s ) {
1401   ENTER_GL();
1402   glTexCoord1f(s);
1403   LEAVE_GL();
1404 }
1405
1406 /***********************************************************************
1407  *              glTexCoord1i
1408  */
1409 void WINAPI wine_glTexCoord1i(GLint s ) {
1410   ENTER_GL();
1411   glTexCoord1i(s);
1412   LEAVE_GL();
1413 }
1414
1415 /***********************************************************************
1416  *              glTexCoord1s
1417  */
1418 void WINAPI wine_glTexCoord1s(GLshort s ) {
1419   ENTER_GL();
1420   glTexCoord1s(s);
1421   LEAVE_GL();
1422 }
1423
1424 /***********************************************************************
1425  *              glTexCoord2d
1426  */
1427 void WINAPI wine_glTexCoord2d(GLdouble s, GLdouble t ) {
1428   ENTER_GL();
1429   glTexCoord2d(s, t);
1430   LEAVE_GL();
1431 }
1432
1433 /***********************************************************************
1434  *              glTexCoord2f
1435  */
1436 void WINAPI wine_glTexCoord2f(GLfloat s, GLfloat t ) {
1437   ENTER_GL();
1438   glTexCoord2f(s, t);
1439   LEAVE_GL();
1440 }
1441
1442 /***********************************************************************
1443  *              glTexCoord2i
1444  */
1445 void WINAPI wine_glTexCoord2i(GLint s, GLint t ) {
1446   ENTER_GL();
1447   glTexCoord2i(s, t);
1448   LEAVE_GL();
1449 }
1450
1451 /***********************************************************************
1452  *              glTexCoord2s
1453  */
1454 void WINAPI wine_glTexCoord2s(GLshort s, GLshort t ) {
1455   ENTER_GL();
1456   glTexCoord2s(s, t);
1457   LEAVE_GL();
1458 }
1459
1460 /***********************************************************************
1461  *              glTexCoord3d
1462  */
1463 void WINAPI wine_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r ) {
1464   ENTER_GL();
1465   glTexCoord3d(s, t, r);
1466   LEAVE_GL();
1467 }
1468
1469 /***********************************************************************
1470  *              glTexCoord3f
1471  */
1472 void WINAPI wine_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r ) {
1473   ENTER_GL();
1474   glTexCoord3f(s, t, r);
1475   LEAVE_GL();
1476 }
1477
1478 /***********************************************************************
1479  *              glTexCoord3i
1480  */
1481 void WINAPI wine_glTexCoord3i(GLint s, GLint t, GLint r ) {
1482   ENTER_GL();
1483   glTexCoord3i(s, t, r);
1484   LEAVE_GL();
1485 }
1486
1487 /***********************************************************************
1488  *              glTexCoord3s
1489  */
1490 void WINAPI wine_glTexCoord3s(GLshort s, GLshort t, GLshort r ) {
1491   ENTER_GL();
1492   glTexCoord3s(s, t, r);
1493   LEAVE_GL();
1494 }
1495
1496 /***********************************************************************
1497  *              glTexCoord4d
1498  */
1499 void WINAPI wine_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
1500   ENTER_GL();
1501   glTexCoord4d(s, t, r, q);
1502   LEAVE_GL();
1503 }
1504
1505 /***********************************************************************
1506  *              glTexCoord4f
1507  */
1508 void WINAPI wine_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
1509   ENTER_GL();
1510   glTexCoord4f(s, t, r, q);
1511   LEAVE_GL();
1512 }
1513
1514 /***********************************************************************
1515  *              glTexCoord4i
1516  */
1517 void WINAPI wine_glTexCoord4i(GLint s, GLint t, GLint r, GLint q ) {
1518   ENTER_GL();
1519   glTexCoord4i(s, t, r, q);
1520   LEAVE_GL();
1521 }
1522
1523 /***********************************************************************
1524  *              glTexCoord4s
1525  */
1526 void WINAPI wine_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q ) {
1527   ENTER_GL();
1528   glTexCoord4s(s, t, r, q);
1529   LEAVE_GL();
1530 }
1531
1532 /***********************************************************************
1533  *              glTexCoord1dv
1534  */
1535 void WINAPI wine_glTexCoord1dv(const GLdouble *v ) {
1536   ENTER_GL();
1537   glTexCoord1dv(v);
1538   LEAVE_GL();
1539 }
1540
1541 /***********************************************************************
1542  *              glTexCoord1fv
1543  */
1544 void WINAPI wine_glTexCoord1fv(const GLfloat *v ) {
1545   ENTER_GL();
1546   glTexCoord1fv(v);
1547   LEAVE_GL();
1548 }
1549
1550 /***********************************************************************
1551  *              glTexCoord1iv
1552  */
1553 void WINAPI wine_glTexCoord1iv(const GLint *v ) {
1554   ENTER_GL();
1555   glTexCoord1iv(v);
1556   LEAVE_GL();
1557 }
1558
1559 /***********************************************************************
1560  *              glTexCoord1sv
1561  */
1562 void WINAPI wine_glTexCoord1sv(const GLshort *v ) {
1563   ENTER_GL();
1564   glTexCoord1sv(v);
1565   LEAVE_GL();
1566 }
1567
1568 /***********************************************************************
1569  *              glTexCoord2dv
1570  */
1571 void WINAPI wine_glTexCoord2dv(const GLdouble *v ) {
1572   ENTER_GL();
1573   glTexCoord2dv(v);
1574   LEAVE_GL();
1575 }
1576
1577 /***********************************************************************
1578  *              glTexCoord2fv
1579  */
1580 void WINAPI wine_glTexCoord2fv(const GLfloat *v ) {
1581   ENTER_GL();
1582   glTexCoord2fv(v);
1583   LEAVE_GL();
1584 }
1585
1586 /***********************************************************************
1587  *              glTexCoord2iv
1588  */
1589 void WINAPI wine_glTexCoord2iv(const GLint *v ) {
1590   ENTER_GL();
1591   glTexCoord2iv(v);
1592   LEAVE_GL();
1593 }
1594
1595 /***********************************************************************
1596  *              glTexCoord2sv
1597  */
1598 void WINAPI wine_glTexCoord2sv(const GLshort *v ) {
1599   ENTER_GL();
1600   glTexCoord2sv(v);
1601   LEAVE_GL();
1602 }
1603
1604 /***********************************************************************
1605  *              glTexCoord3dv
1606  */
1607 void WINAPI wine_glTexCoord3dv(const GLdouble *v ) {
1608   ENTER_GL();
1609   glTexCoord3dv(v);
1610   LEAVE_GL();
1611 }
1612
1613 /***********************************************************************
1614  *              glTexCoord3fv
1615  */
1616 void WINAPI wine_glTexCoord3fv(const GLfloat *v ) {
1617   ENTER_GL();
1618   glTexCoord3fv(v);
1619   LEAVE_GL();
1620 }
1621
1622 /***********************************************************************
1623  *              glTexCoord3iv
1624  */
1625 void WINAPI wine_glTexCoord3iv(const GLint *v ) {
1626   ENTER_GL();
1627   glTexCoord3iv(v);
1628   LEAVE_GL();
1629 }
1630
1631 /***********************************************************************
1632  *              glTexCoord3sv
1633  */
1634 void WINAPI wine_glTexCoord3sv(const GLshort *v ) {
1635   ENTER_GL();
1636   glTexCoord3sv(v);
1637   LEAVE_GL();
1638 }
1639
1640 /***********************************************************************
1641  *              glTexCoord4dv
1642  */
1643 void WINAPI wine_glTexCoord4dv(const GLdouble *v ) {
1644   ENTER_GL();
1645   glTexCoord4dv(v);
1646   LEAVE_GL();
1647 }
1648
1649 /***********************************************************************
1650  *              glTexCoord4fv
1651  */
1652 void WINAPI wine_glTexCoord4fv(const GLfloat *v ) {
1653   ENTER_GL();
1654   glTexCoord4fv(v);
1655   LEAVE_GL();
1656 }
1657
1658 /***********************************************************************
1659  *              glTexCoord4iv
1660  */
1661 void WINAPI wine_glTexCoord4iv(const GLint *v ) {
1662   ENTER_GL();
1663   glTexCoord4iv(v);
1664   LEAVE_GL();
1665 }
1666
1667 /***********************************************************************
1668  *              glTexCoord4sv
1669  */
1670 void WINAPI wine_glTexCoord4sv(const GLshort *v ) {
1671   ENTER_GL();
1672   glTexCoord4sv(v);
1673   LEAVE_GL();
1674 }
1675
1676 /***********************************************************************
1677  *              glRasterPos2d
1678  */
1679 void WINAPI wine_glRasterPos2d(GLdouble x, GLdouble y ) {
1680   ENTER_GL();
1681   glRasterPos2d(x, y);
1682   LEAVE_GL();
1683 }
1684
1685 /***********************************************************************
1686  *              glRasterPos2f
1687  */
1688 void WINAPI wine_glRasterPos2f(GLfloat x, GLfloat y ) {
1689   ENTER_GL();
1690   glRasterPos2f(x, y);
1691   LEAVE_GL();
1692 }
1693
1694 /***********************************************************************
1695  *              glRasterPos2i
1696  */
1697 void WINAPI wine_glRasterPos2i(GLint x, GLint y ) {
1698   ENTER_GL();
1699   glRasterPos2i(x, y);
1700   LEAVE_GL();
1701 }
1702
1703 /***********************************************************************
1704  *              glRasterPos2s
1705  */
1706 void WINAPI wine_glRasterPos2s(GLshort x, GLshort y ) {
1707   ENTER_GL();
1708   glRasterPos2s(x, y);
1709   LEAVE_GL();
1710 }
1711
1712 /***********************************************************************
1713  *              glRasterPos3d
1714  */
1715 void WINAPI wine_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z ) {
1716   ENTER_GL();
1717   glRasterPos3d(x, y, z);
1718   LEAVE_GL();
1719 }
1720
1721 /***********************************************************************
1722  *              glRasterPos3f
1723  */
1724 void WINAPI wine_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z ) {
1725   ENTER_GL();
1726   glRasterPos3f(x, y, z);
1727   LEAVE_GL();
1728 }
1729
1730 /***********************************************************************
1731  *              glRasterPos3i
1732  */
1733 void WINAPI wine_glRasterPos3i(GLint x, GLint y, GLint z ) {
1734   ENTER_GL();
1735   glRasterPos3i(x, y, z);
1736   LEAVE_GL();
1737 }
1738
1739 /***********************************************************************
1740  *              glRasterPos3s
1741  */
1742 void WINAPI wine_glRasterPos3s(GLshort x, GLshort y, GLshort z ) {
1743   ENTER_GL();
1744   glRasterPos3s(x, y, z);
1745   LEAVE_GL();
1746 }
1747
1748 /***********************************************************************
1749  *              glRasterPos4d
1750  */
1751 void WINAPI wine_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
1752   ENTER_GL();
1753   glRasterPos4d(x, y, z, w);
1754   LEAVE_GL();
1755 }
1756
1757 /***********************************************************************
1758  *              glRasterPos4f
1759  */
1760 void WINAPI wine_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
1761   ENTER_GL();
1762   glRasterPos4f(x, y, z, w);
1763   LEAVE_GL();
1764 }
1765
1766 /***********************************************************************
1767  *              glRasterPos4i
1768  */
1769 void WINAPI wine_glRasterPos4i(GLint x, GLint y, GLint z, GLint w ) {
1770   ENTER_GL();
1771   glRasterPos4i(x, y, z, w);
1772   LEAVE_GL();
1773 }
1774
1775 /***********************************************************************
1776  *              glRasterPos4s
1777  */
1778 void WINAPI wine_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w ) {
1779   ENTER_GL();
1780   glRasterPos4s(x, y, z, w);
1781   LEAVE_GL();
1782 }
1783
1784 /***********************************************************************
1785  *              glRasterPos2dv
1786  */
1787 void WINAPI wine_glRasterPos2dv(const GLdouble *v ) {
1788   ENTER_GL();
1789   glRasterPos2dv(v);
1790   LEAVE_GL();
1791 }
1792
1793 /***********************************************************************
1794  *              glRasterPos2fv
1795  */
1796 void WINAPI wine_glRasterPos2fv(const GLfloat *v ) {
1797   ENTER_GL();
1798   glRasterPos2fv(v);
1799   LEAVE_GL();
1800 }
1801
1802 /***********************************************************************
1803  *              glRasterPos2iv
1804  */
1805 void WINAPI wine_glRasterPos2iv(const GLint *v ) {
1806   ENTER_GL();
1807   glRasterPos2iv(v);
1808   LEAVE_GL();
1809 }
1810
1811 /***********************************************************************
1812  *              glRasterPos2sv
1813  */
1814 void WINAPI wine_glRasterPos2sv(const GLshort *v ) {
1815   ENTER_GL();
1816   glRasterPos2sv(v);
1817   LEAVE_GL();
1818 }
1819
1820 /***********************************************************************
1821  *              glRasterPos3dv
1822  */
1823 void WINAPI wine_glRasterPos3dv(const GLdouble *v ) {
1824   ENTER_GL();
1825   glRasterPos3dv(v);
1826   LEAVE_GL();
1827 }
1828
1829 /***********************************************************************
1830  *              glRasterPos3fv
1831  */
1832 void WINAPI wine_glRasterPos3fv(const GLfloat *v ) {
1833   ENTER_GL();
1834   glRasterPos3fv(v);
1835   LEAVE_GL();
1836 }
1837
1838 /***********************************************************************
1839  *              glRasterPos3iv
1840  */
1841 void WINAPI wine_glRasterPos3iv(const GLint *v ) {
1842   ENTER_GL();
1843   glRasterPos3iv(v);
1844   LEAVE_GL();
1845 }
1846
1847 /***********************************************************************
1848  *              glRasterPos3sv
1849  */
1850 void WINAPI wine_glRasterPos3sv(const GLshort *v ) {
1851   ENTER_GL();
1852   glRasterPos3sv(v);
1853   LEAVE_GL();
1854 }
1855
1856 /***********************************************************************
1857  *              glRasterPos4dv
1858  */
1859 void WINAPI wine_glRasterPos4dv(const GLdouble *v ) {
1860   ENTER_GL();
1861   glRasterPos4dv(v);
1862   LEAVE_GL();
1863 }
1864
1865 /***********************************************************************
1866  *              glRasterPos4fv
1867  */
1868 void WINAPI wine_glRasterPos4fv(const GLfloat *v ) {
1869   ENTER_GL();
1870   glRasterPos4fv(v);
1871   LEAVE_GL();
1872 }
1873
1874 /***********************************************************************
1875  *              glRasterPos4iv
1876  */
1877 void WINAPI wine_glRasterPos4iv(const GLint *v ) {
1878   ENTER_GL();
1879   glRasterPos4iv(v);
1880   LEAVE_GL();
1881 }
1882
1883 /***********************************************************************
1884  *              glRasterPos4sv
1885  */
1886 void WINAPI wine_glRasterPos4sv(const GLshort *v ) {
1887   ENTER_GL();
1888   glRasterPos4sv(v);
1889   LEAVE_GL();
1890 }
1891
1892 /***********************************************************************
1893  *              glRectd
1894  */
1895 void WINAPI wine_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) {
1896   ENTER_GL();
1897   glRectd(x1, y1, x2, y2);
1898   LEAVE_GL();
1899 }
1900
1901 /***********************************************************************
1902  *              glRectf
1903  */
1904 void WINAPI wine_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) {
1905   ENTER_GL();
1906   glRectf(x1, y1, x2, y2);
1907   LEAVE_GL();
1908 }
1909
1910 /***********************************************************************
1911  *              glRecti
1912  */
1913 void WINAPI wine_glRecti(GLint x1, GLint y1, GLint x2, GLint y2 ) {
1914   ENTER_GL();
1915   glRecti(x1, y1, x2, y2);
1916   LEAVE_GL();
1917 }
1918
1919 /***********************************************************************
1920  *              glRects
1921  */
1922 void WINAPI wine_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) {
1923   ENTER_GL();
1924   glRects(x1, y1, x2, y2);
1925   LEAVE_GL();
1926 }
1927
1928 /***********************************************************************
1929  *              glRectdv
1930  */
1931 void WINAPI wine_glRectdv(const GLdouble *v1, const GLdouble *v2 ) {
1932   ENTER_GL();
1933   glRectdv(v1, v2);
1934   LEAVE_GL();
1935 }
1936
1937 /***********************************************************************
1938  *              glRectfv
1939  */
1940 void WINAPI wine_glRectfv(const GLfloat *v1, const GLfloat *v2 ) {
1941   ENTER_GL();
1942   glRectfv(v1, v2);
1943   LEAVE_GL();
1944 }
1945
1946 /***********************************************************************
1947  *              glRectiv
1948  */
1949 void WINAPI wine_glRectiv(const GLint *v1, const GLint *v2 ) {
1950   ENTER_GL();
1951   glRectiv(v1, v2);
1952   LEAVE_GL();
1953 }
1954
1955 /***********************************************************************
1956  *              glRectsv
1957  */
1958 void WINAPI wine_glRectsv(const GLshort *v1, const GLshort *v2 ) {
1959   ENTER_GL();
1960   glRectsv(v1, v2);
1961   LEAVE_GL();
1962 }
1963
1964 /***********************************************************************
1965  *              glVertexPointer
1966  */
1967 void WINAPI wine_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) {
1968   ENTER_GL();
1969   glVertexPointer(size, type, stride, ptr);
1970   LEAVE_GL();
1971 }
1972
1973 /***********************************************************************
1974  *              glNormalPointer
1975  */
1976 void WINAPI wine_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) {
1977   ENTER_GL();
1978   glNormalPointer(type, stride, ptr);
1979   LEAVE_GL();
1980 }
1981
1982 /***********************************************************************
1983  *              glColorPointer
1984  */
1985 void WINAPI wine_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) {
1986   ENTER_GL();
1987   glColorPointer(size, type, stride, ptr);
1988   LEAVE_GL();
1989 }
1990
1991 /***********************************************************************
1992  *              glIndexPointer
1993  */
1994 void WINAPI wine_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr ) {
1995   ENTER_GL();
1996   glIndexPointer(type, stride, ptr);
1997   LEAVE_GL();
1998 }
1999
2000 /***********************************************************************
2001  *              glTexCoordPointer
2002  */
2003 void WINAPI wine_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr ) {
2004   ENTER_GL();
2005   glTexCoordPointer(size, type, stride, ptr);
2006   LEAVE_GL();
2007 }
2008
2009 /***********************************************************************
2010  *              glEdgeFlagPointer
2011  */
2012 void WINAPI wine_glEdgeFlagPointer(GLsizei stride, const GLvoid *ptr ) {
2013   ENTER_GL();
2014   glEdgeFlagPointer(stride, ptr);
2015   LEAVE_GL();
2016 }
2017
2018 /***********************************************************************
2019  *              glGetPointerv
2020  */
2021 void WINAPI wine_glGetPointerv(GLenum pname, void **params ) {
2022   ENTER_GL();
2023   glGetPointerv(pname, params);
2024   LEAVE_GL();
2025 }
2026
2027 /***********************************************************************
2028  *              glArrayElement
2029  */
2030 void WINAPI wine_glArrayElement(GLint i ) {
2031   ENTER_GL();
2032   glArrayElement(i);
2033   LEAVE_GL();
2034 }
2035
2036 /***********************************************************************
2037  *              glDrawArrays
2038  */
2039 void WINAPI wine_glDrawArrays(GLenum mode, GLint first, GLsizei count ) {
2040   ENTER_GL();
2041   glDrawArrays(mode, first, count);
2042   LEAVE_GL();
2043 }
2044
2045 /***********************************************************************
2046  *              glDrawElements
2047  */
2048 void WINAPI wine_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) {
2049   ENTER_GL();
2050   glDrawElements(mode, count, type, indices);
2051   LEAVE_GL();
2052 }
2053
2054 /***********************************************************************
2055  *              glInterleavedArrays
2056  */
2057 void WINAPI wine_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer ) {
2058   ENTER_GL();
2059   glInterleavedArrays(format, stride, pointer);
2060   LEAVE_GL();
2061 }
2062
2063 /***********************************************************************
2064  *              glShadeModel
2065  */
2066 void WINAPI wine_glShadeModel(GLenum mode ) {
2067   ENTER_GL();
2068   glShadeModel(mode);
2069   LEAVE_GL();
2070 }
2071
2072 /***********************************************************************
2073  *              glLightf
2074  */
2075 void WINAPI wine_glLightf(GLenum light, GLenum pname, GLfloat param ) {
2076   ENTER_GL();
2077   glLightf(light, pname, param);
2078   LEAVE_GL();
2079 }
2080
2081 /***********************************************************************
2082  *              glLighti
2083  */
2084 void WINAPI wine_glLighti(GLenum light, GLenum pname, GLint param ) {
2085   ENTER_GL();
2086   glLighti(light, pname, param);
2087   LEAVE_GL();
2088 }
2089
2090 /***********************************************************************
2091  *              glLightfv
2092  */
2093 void WINAPI wine_glLightfv(GLenum light, GLenum pname, const GLfloat *params ) {
2094   ENTER_GL();
2095   glLightfv(light, pname, params);
2096   LEAVE_GL();
2097 }
2098
2099 /***********************************************************************
2100  *              glLightiv
2101  */
2102 void WINAPI wine_glLightiv(GLenum light, GLenum pname, const GLint *params ) {
2103   ENTER_GL();
2104   glLightiv(light, pname, params);
2105   LEAVE_GL();
2106 }
2107
2108 /***********************************************************************
2109  *              glGetLightfv
2110  */
2111 void WINAPI wine_glGetLightfv(GLenum light, GLenum pname, GLfloat *params ) {
2112   ENTER_GL();
2113   glGetLightfv(light, pname, params);
2114   LEAVE_GL();
2115 }
2116
2117 /***********************************************************************
2118  *              glGetLightiv
2119  */
2120 void WINAPI wine_glGetLightiv(GLenum light, GLenum pname, GLint *params ) {
2121   ENTER_GL();
2122   glGetLightiv(light, pname, params);
2123   LEAVE_GL();
2124 }
2125
2126 /***********************************************************************
2127  *              glLightModelf
2128  */
2129 void WINAPI wine_glLightModelf(GLenum pname, GLfloat param ) {
2130   ENTER_GL();
2131   glLightModelf(pname, param);
2132   LEAVE_GL();
2133 }
2134
2135 /***********************************************************************
2136  *              glLightModeli
2137  */
2138 void WINAPI wine_glLightModeli(GLenum pname, GLint param ) {
2139   ENTER_GL();
2140   glLightModeli(pname, param);
2141   LEAVE_GL();
2142 }
2143
2144 /***********************************************************************
2145  *              glLightModelfv
2146  */
2147 void WINAPI wine_glLightModelfv(GLenum pname, const GLfloat *params ) {
2148   ENTER_GL();
2149   glLightModelfv(pname, params);
2150   LEAVE_GL();
2151 }
2152
2153 /***********************************************************************
2154  *              glLightModeliv
2155  */
2156 void WINAPI wine_glLightModeliv(GLenum pname, const GLint *params ) {
2157   ENTER_GL();
2158   glLightModeliv(pname, params);
2159   LEAVE_GL();
2160 }
2161
2162 /***********************************************************************
2163  *              glMaterialf
2164  */
2165 void WINAPI wine_glMaterialf(GLenum face, GLenum pname, GLfloat param ) {
2166   ENTER_GL();
2167   glMaterialf(face, pname, param);
2168   LEAVE_GL();
2169 }
2170
2171 /***********************************************************************
2172  *              glMateriali
2173  */
2174 void WINAPI wine_glMateriali(GLenum face, GLenum pname, GLint param ) {
2175   ENTER_GL();
2176   glMateriali(face, pname, param);
2177   LEAVE_GL();
2178 }
2179
2180 /***********************************************************************
2181  *              glMaterialfv
2182  */
2183 void WINAPI wine_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params ) {
2184   ENTER_GL();
2185   glMaterialfv(face, pname, params);
2186   LEAVE_GL();
2187 }
2188
2189 /***********************************************************************
2190  *              glMaterialiv
2191  */
2192 void WINAPI wine_glMaterialiv(GLenum face, GLenum pname, const GLint *params ) {
2193   ENTER_GL();
2194   glMaterialiv(face, pname, params);
2195   LEAVE_GL();
2196 }
2197
2198 /***********************************************************************
2199  *              glGetMaterialfv
2200  */
2201 void WINAPI wine_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params ) {
2202   ENTER_GL();
2203   glGetMaterialfv(face, pname, params);
2204   LEAVE_GL();
2205 }
2206
2207 /***********************************************************************
2208  *              glGetMaterialiv
2209  */
2210 void WINAPI wine_glGetMaterialiv(GLenum face, GLenum pname, GLint *params ) {
2211   ENTER_GL();
2212   glGetMaterialiv(face, pname, params);
2213   LEAVE_GL();
2214 }
2215
2216 /***********************************************************************
2217  *              glColorMaterial
2218  */
2219 void WINAPI wine_glColorMaterial(GLenum face, GLenum mode ) {
2220   ENTER_GL();
2221   glColorMaterial(face, mode);
2222   LEAVE_GL();
2223 }
2224
2225 /***********************************************************************
2226  *              glPixelZoom
2227  */
2228 void WINAPI wine_glPixelZoom(GLfloat xfactor, GLfloat yfactor ) {
2229   ENTER_GL();
2230   glPixelZoom(xfactor, yfactor);
2231   LEAVE_GL();
2232 }
2233
2234 /***********************************************************************
2235  *              glPixelStoref
2236  */
2237 void WINAPI wine_glPixelStoref(GLenum pname, GLfloat param ) {
2238   ENTER_GL();
2239   glPixelStoref(pname, param);
2240   LEAVE_GL();
2241 }
2242
2243 /***********************************************************************
2244  *              glPixelStorei
2245  */
2246 void WINAPI wine_glPixelStorei(GLenum pname, GLint param ) {
2247   ENTER_GL();
2248   glPixelStorei(pname, param);
2249   LEAVE_GL();
2250 }
2251
2252 /***********************************************************************
2253  *              glPixelTransferf
2254  */
2255 void WINAPI wine_glPixelTransferf(GLenum pname, GLfloat param ) {
2256   ENTER_GL();
2257   glPixelTransferf(pname, param);
2258   LEAVE_GL();
2259 }
2260
2261 /***********************************************************************
2262  *              glPixelTransferi
2263  */
2264 void WINAPI wine_glPixelTransferi(GLenum pname, GLint param ) {
2265   ENTER_GL();
2266   glPixelTransferi(pname, param);
2267   LEAVE_GL();
2268 }
2269
2270 /***********************************************************************
2271  *              glPixelMapfv
2272  */
2273 void WINAPI wine_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values ) {
2274   ENTER_GL();
2275   glPixelMapfv(map, mapsize, values);
2276   LEAVE_GL();
2277 }
2278
2279 /***********************************************************************
2280  *              glPixelMapuiv
2281  */
2282 void WINAPI wine_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values ) {
2283   ENTER_GL();
2284   glPixelMapuiv(map, mapsize, values);
2285   LEAVE_GL();
2286 }
2287
2288 /***********************************************************************
2289  *              glPixelMapusv
2290  */
2291 void WINAPI wine_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values ) {
2292   ENTER_GL();
2293   glPixelMapusv(map, mapsize, values);
2294   LEAVE_GL();
2295 }
2296
2297 /***********************************************************************
2298  *              glGetPixelMapfv
2299  */
2300 void WINAPI wine_glGetPixelMapfv(GLenum map, GLfloat *values ) {
2301   ENTER_GL();
2302   glGetPixelMapfv(map, values);
2303   LEAVE_GL();
2304 }
2305
2306 /***********************************************************************
2307  *              glGetPixelMapuiv
2308  */
2309 void WINAPI wine_glGetPixelMapuiv(GLenum map, GLuint *values ) {
2310   ENTER_GL();
2311   glGetPixelMapuiv(map, values);
2312   LEAVE_GL();
2313 }
2314
2315 /***********************************************************************
2316  *              glGetPixelMapusv
2317  */
2318 void WINAPI wine_glGetPixelMapusv(GLenum map, GLushort *values ) {
2319   ENTER_GL();
2320   glGetPixelMapusv(map, values);
2321   LEAVE_GL();
2322 }
2323
2324 /***********************************************************************
2325  *              glBitmap
2326  */
2327 void WINAPI wine_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap ) {
2328   ENTER_GL();
2329   glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
2330   LEAVE_GL();
2331 }
2332
2333 /***********************************************************************
2334  *              glReadPixels
2335  */
2336 void WINAPI wine_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) {
2337   ENTER_GL();
2338   glReadPixels(x, y, width, height, format, type, pixels);
2339   LEAVE_GL();
2340 }
2341
2342 /***********************************************************************
2343  *              glDrawPixels
2344  */
2345 void WINAPI wine_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) {
2346   ENTER_GL();
2347   glDrawPixels(width, height, format, type, pixels);
2348   LEAVE_GL();
2349 }
2350
2351 /***********************************************************************
2352  *              glCopyPixels
2353  */
2354 void WINAPI wine_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) {
2355   ENTER_GL();
2356   glCopyPixels(x, y, width, height, type);
2357   LEAVE_GL();
2358 }
2359
2360 /***********************************************************************
2361  *              glStencilFunc
2362  */
2363 void WINAPI wine_glStencilFunc(GLenum func, GLint ref, GLuint mask ) {
2364   ENTER_GL();
2365   glStencilFunc(func, ref, mask);
2366   LEAVE_GL();
2367 }
2368
2369 /***********************************************************************
2370  *              glStencilMask
2371  */
2372 void WINAPI wine_glStencilMask(GLuint mask ) {
2373   ENTER_GL();
2374   glStencilMask(mask);
2375   LEAVE_GL();
2376 }
2377
2378 /***********************************************************************
2379  *              glStencilOp
2380  */
2381 void WINAPI wine_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass ) {
2382   ENTER_GL();
2383   glStencilOp(fail, zfail, zpass);
2384   LEAVE_GL();
2385 }
2386
2387 /***********************************************************************
2388  *              glClearStencil
2389  */
2390 void WINAPI wine_glClearStencil(GLint s ) {
2391   ENTER_GL();
2392   glClearStencil(s);
2393   LEAVE_GL();
2394 }
2395
2396 /***********************************************************************
2397  *              glTexGend
2398  */
2399 void WINAPI wine_glTexGend(GLenum coord, GLenum pname, GLdouble param ) {
2400   ENTER_GL();
2401   glTexGend(coord, pname, param);
2402   LEAVE_GL();
2403 }
2404
2405 /***********************************************************************
2406  *              glTexGenf
2407  */
2408 void WINAPI wine_glTexGenf(GLenum coord, GLenum pname, GLfloat param ) {
2409   ENTER_GL();
2410   glTexGenf(coord, pname, param);
2411   LEAVE_GL();
2412 }
2413
2414 /***********************************************************************
2415  *              glTexGeni
2416  */
2417 void WINAPI wine_glTexGeni(GLenum coord, GLenum pname, GLint param ) {
2418   ENTER_GL();
2419   glTexGeni(coord, pname, param);
2420   LEAVE_GL();
2421 }
2422
2423 /***********************************************************************
2424  *              glTexGendv
2425  */
2426 void WINAPI wine_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params ) {
2427   ENTER_GL();
2428   glTexGendv(coord, pname, params);
2429   LEAVE_GL();
2430 }
2431
2432 /***********************************************************************
2433  *              glTexGenfv
2434  */
2435 void WINAPI wine_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params ) {
2436   ENTER_GL();
2437   glTexGenfv(coord, pname, params);
2438   LEAVE_GL();
2439 }
2440
2441 /***********************************************************************
2442  *              glTexGeniv
2443  */
2444 void WINAPI wine_glTexGeniv(GLenum coord, GLenum pname, const GLint *params ) {
2445   ENTER_GL();
2446   glTexGeniv(coord, pname, params);
2447   LEAVE_GL();
2448 }
2449
2450 /***********************************************************************
2451  *              glGetTexGendv
2452  */
2453 void WINAPI wine_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params ) {
2454   ENTER_GL();
2455   glGetTexGendv(coord, pname, params);
2456   LEAVE_GL();
2457 }
2458
2459 /***********************************************************************
2460  *              glGetTexGenfv
2461  */
2462 void WINAPI wine_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params ) {
2463   ENTER_GL();
2464   glGetTexGenfv(coord, pname, params);
2465   LEAVE_GL();
2466 }
2467
2468 /***********************************************************************
2469  *              glGetTexGeniv
2470  */
2471 void WINAPI wine_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params ) {
2472   ENTER_GL();
2473   glGetTexGeniv(coord, pname, params);
2474   LEAVE_GL();
2475 }
2476
2477 /***********************************************************************
2478  *              glTexEnvf
2479  */
2480 void WINAPI wine_glTexEnvf(GLenum target, GLenum pname, GLfloat param ) {
2481   ENTER_GL();
2482   glTexEnvf(target, pname, param);
2483   LEAVE_GL();
2484 }
2485
2486 /***********************************************************************
2487  *              glTexEnvi
2488  */
2489 void WINAPI wine_glTexEnvi(GLenum target, GLenum pname, GLint param ) {
2490   ENTER_GL();
2491   glTexEnvi(target, pname, param);
2492   LEAVE_GL();
2493 }
2494
2495 /***********************************************************************
2496  *              glTexEnvfv
2497  */
2498 void WINAPI wine_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params ) {
2499   ENTER_GL();
2500   glTexEnvfv(target, pname, params);
2501   LEAVE_GL();
2502 }
2503
2504 /***********************************************************************
2505  *              glTexEnviv
2506  */
2507 void WINAPI wine_glTexEnviv(GLenum target, GLenum pname, const GLint *params ) {
2508   ENTER_GL();
2509   glTexEnviv(target, pname, params);
2510   LEAVE_GL();
2511 }
2512
2513 /***********************************************************************
2514  *              glGetTexEnvfv
2515  */
2516 void WINAPI wine_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params ) {
2517   ENTER_GL();
2518   glGetTexEnvfv(target, pname, params);
2519   LEAVE_GL();
2520 }
2521
2522 /***********************************************************************
2523  *              glGetTexEnviv
2524  */
2525 void WINAPI wine_glGetTexEnviv(GLenum target, GLenum pname, GLint *params ) {
2526   ENTER_GL();
2527   glGetTexEnviv(target, pname, params);
2528   LEAVE_GL();
2529 }
2530
2531 /***********************************************************************
2532  *              glTexParameterf
2533  */
2534 void WINAPI wine_glTexParameterf(GLenum target, GLenum pname, GLfloat param ) {
2535   ENTER_GL();
2536   glTexParameterf(target, pname, param);
2537   LEAVE_GL();
2538 }
2539
2540 /***********************************************************************
2541  *              glTexParameteri
2542  */
2543 void WINAPI wine_glTexParameteri(GLenum target, GLenum pname, GLint param ) {
2544   ENTER_GL();
2545   glTexParameteri(target, pname, param);
2546   LEAVE_GL();
2547 }
2548
2549 /***********************************************************************
2550  *              glTexParameterfv
2551  */
2552 void WINAPI wine_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params ) {
2553   ENTER_GL();
2554   glTexParameterfv(target, pname, params);
2555   LEAVE_GL();
2556 }
2557
2558 /***********************************************************************
2559  *              glTexParameteriv
2560  */
2561 void WINAPI wine_glTexParameteriv(GLenum target, GLenum pname, const GLint *params ) {
2562   ENTER_GL();
2563   glTexParameteriv(target, pname, params);
2564   LEAVE_GL();
2565 }
2566
2567 /***********************************************************************
2568  *              glGetTexParameterfv
2569  */
2570 void WINAPI wine_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
2571   ENTER_GL();
2572   glGetTexParameterfv(target, pname, params);
2573   LEAVE_GL();
2574 }
2575
2576 /***********************************************************************
2577  *              glGetTexParameteriv
2578  */
2579 void WINAPI wine_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params ) {
2580   ENTER_GL();
2581   glGetTexParameteriv(target, pname, params);
2582   LEAVE_GL();
2583 }
2584
2585 /***********************************************************************
2586  *              glGetTexLevelParameterfv
2587  */
2588 void WINAPI wine_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params ) {
2589   ENTER_GL();
2590   glGetTexLevelParameterfv(target, level, pname, params);
2591   LEAVE_GL();
2592 }
2593
2594 /***********************************************************************
2595  *              glGetTexLevelParameteriv
2596  */
2597 void WINAPI wine_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params ) {
2598   ENTER_GL();
2599   glGetTexLevelParameteriv(target, level, pname, params);
2600   LEAVE_GL();
2601 }
2602
2603 /***********************************************************************
2604  *              glTexImage1D
2605  */
2606 void WINAPI wine_glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) {
2607   ENTER_GL();
2608   glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
2609   LEAVE_GL();
2610 }
2611
2612 /***********************************************************************
2613  *              glTexImage2D
2614  */
2615 void WINAPI wine_glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) {
2616   ENTER_GL();
2617   glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
2618   LEAVE_GL();
2619 }
2620
2621 /***********************************************************************
2622  *              glGetTexImage
2623  */
2624 void WINAPI wine_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels ) {
2625   ENTER_GL();
2626   glGetTexImage(target, level, format, type, pixels);
2627   LEAVE_GL();
2628 }
2629
2630 /***********************************************************************
2631  *              glGenTextures
2632  */
2633 void WINAPI wine_glGenTextures(GLsizei n, GLuint *textures ) {
2634   ENTER_GL();
2635   glGenTextures(n, textures);
2636   LEAVE_GL();
2637 }
2638
2639 /***********************************************************************
2640  *              glDeleteTextures
2641  */
2642 void WINAPI wine_glDeleteTextures(GLsizei n, const GLuint *textures) {
2643   ENTER_GL();
2644   glDeleteTextures(n, textures);
2645   LEAVE_GL();
2646 }
2647
2648 /***********************************************************************
2649  *              glBindTexture
2650  */
2651 void WINAPI wine_glBindTexture(GLenum target, GLuint texture ) {
2652   ENTER_GL();
2653   glBindTexture(target, texture);
2654   LEAVE_GL();
2655 }
2656
2657 /***********************************************************************
2658  *              glPrioritizeTextures
2659  */
2660 void WINAPI wine_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities ) {
2661   ENTER_GL();
2662   glPrioritizeTextures(n, textures, priorities);
2663   LEAVE_GL();
2664 }
2665
2666 /***********************************************************************
2667  *              glAreTexturesResident
2668  */
2669 GLboolean WINAPI wine_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences ) {
2670   GLboolean ret;
2671   ENTER_GL();
2672   ret = glAreTexturesResident(n, textures, residences);
2673   LEAVE_GL();
2674   return ret;
2675 }
2676
2677 /***********************************************************************
2678  *              glIsTexture
2679  */
2680 GLboolean WINAPI wine_glIsTexture(GLuint texture ) {
2681   GLboolean ret;
2682   ENTER_GL();
2683   ret = glIsTexture(texture);
2684   LEAVE_GL();
2685   return ret;
2686 }
2687
2688 /***********************************************************************
2689  *              glTexSubImage1D
2690  */
2691 void WINAPI wine_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels ) {
2692   ENTER_GL();
2693   glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
2694   LEAVE_GL();
2695 }
2696
2697 /***********************************************************************
2698  *              glTexSubImage2D
2699  */
2700 void WINAPI wine_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) {
2701   ENTER_GL();
2702   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
2703   LEAVE_GL();
2704 }
2705
2706 /***********************************************************************
2707  *              glCopyTexImage1D
2708  */
2709 void WINAPI wine_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
2710   ENTER_GL();
2711   glCopyTexImage1D(target, level, internalformat, x, y, width, border);
2712   LEAVE_GL();
2713 }
2714
2715 /***********************************************************************
2716  *              glCopyTexImage2D
2717  */
2718 void WINAPI wine_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
2719   ENTER_GL();
2720   glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
2721   LEAVE_GL();
2722 }
2723
2724 /***********************************************************************
2725  *              glCopyTexSubImage1D
2726  */
2727 void WINAPI wine_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
2728   ENTER_GL();
2729   glCopyTexSubImage1D(target, level, xoffset, x, y, width);
2730   LEAVE_GL();
2731 }
2732
2733 /***********************************************************************
2734  *              glCopyTexSubImage2D
2735  */
2736 void WINAPI wine_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
2737   ENTER_GL();
2738   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
2739   LEAVE_GL();
2740 }
2741
2742 /***********************************************************************
2743  *              glMap1d
2744  */
2745 void WINAPI wine_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ) {
2746   ENTER_GL();
2747   glMap1d(target, u1, u2, stride, order, points);
2748   LEAVE_GL();
2749 }
2750
2751 /***********************************************************************
2752  *              glMap1f
2753  */
2754 void WINAPI wine_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ) {
2755   ENTER_GL();
2756   glMap1f(target, u1, u2, stride, order, points);
2757   LEAVE_GL();
2758 }
2759
2760 /***********************************************************************
2761  *              glMap2d
2762  */
2763 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 ) {
2764   ENTER_GL();
2765   glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2766   LEAVE_GL();
2767 }
2768
2769 /***********************************************************************
2770  *              glMap2f
2771  */
2772 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 ) {
2773   ENTER_GL();
2774   glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
2775   LEAVE_GL();
2776 }
2777
2778 /***********************************************************************
2779  *              glGetMapdv
2780  */
2781 void WINAPI wine_glGetMapdv(GLenum target, GLenum query, GLdouble *v ) {
2782   ENTER_GL();
2783   glGetMapdv(target, query, v);
2784   LEAVE_GL();
2785 }
2786
2787 /***********************************************************************
2788  *              glGetMapfv
2789  */
2790 void WINAPI wine_glGetMapfv(GLenum target, GLenum query, GLfloat *v ) {
2791   ENTER_GL();
2792   glGetMapfv(target, query, v);
2793   LEAVE_GL();
2794 }
2795
2796 /***********************************************************************
2797  *              glGetMapiv
2798  */
2799 void WINAPI wine_glGetMapiv(GLenum target, GLenum query, GLint *v ) {
2800   ENTER_GL();
2801   glGetMapiv(target, query, v);
2802   LEAVE_GL();
2803 }
2804
2805 /***********************************************************************
2806  *              glEvalCoord1d
2807  */
2808 void WINAPI wine_glEvalCoord1d(GLdouble u ) {
2809   ENTER_GL();
2810   glEvalCoord1d(u);
2811   LEAVE_GL();
2812 }
2813
2814 /***********************************************************************
2815  *              glEvalCoord1f
2816  */
2817 void WINAPI wine_glEvalCoord1f(GLfloat u ) {
2818   ENTER_GL();
2819   glEvalCoord1f(u);
2820   LEAVE_GL();
2821 }
2822
2823 /***********************************************************************
2824  *              glEvalCoord1dv
2825  */
2826 void WINAPI wine_glEvalCoord1dv(const GLdouble *u ) {
2827   ENTER_GL();
2828   glEvalCoord1dv(u);
2829   LEAVE_GL();
2830 }
2831
2832 /***********************************************************************
2833  *              glEvalCoord1fv
2834  */
2835 void WINAPI wine_glEvalCoord1fv(const GLfloat *u ) {
2836   ENTER_GL();
2837   glEvalCoord1fv(u);
2838   LEAVE_GL();
2839 }
2840
2841 /***********************************************************************
2842  *              glEvalCoord2d
2843  */
2844 void WINAPI wine_glEvalCoord2d(GLdouble u, GLdouble v ) {
2845   ENTER_GL();
2846   glEvalCoord2d(u, v);
2847   LEAVE_GL();
2848 }
2849
2850 /***********************************************************************
2851  *              glEvalCoord2f
2852  */
2853 void WINAPI wine_glEvalCoord2f(GLfloat u, GLfloat v ) {
2854   ENTER_GL();
2855   glEvalCoord2f(u, v);
2856   LEAVE_GL();
2857 }
2858
2859 /***********************************************************************
2860  *              glEvalCoord2dv
2861  */
2862 void WINAPI wine_glEvalCoord2dv(const GLdouble *u ) {
2863   ENTER_GL();
2864   glEvalCoord2dv(u);
2865   LEAVE_GL();
2866 }
2867
2868 /***********************************************************************
2869  *              glEvalCoord2fv
2870  */
2871 void WINAPI wine_glEvalCoord2fv(const GLfloat *u ) {
2872   ENTER_GL();
2873   glEvalCoord2fv(u);
2874   LEAVE_GL();
2875 }
2876
2877 /***********************************************************************
2878  *              glMapGrid1d
2879  */
2880 void WINAPI wine_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2 ) {
2881   ENTER_GL();
2882   glMapGrid1d(un, u1, u2);
2883   LEAVE_GL();
2884 }
2885
2886 /***********************************************************************
2887  *              glMapGrid1f
2888  */
2889 void WINAPI wine_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2 ) {
2890   ENTER_GL();
2891   glMapGrid1f(un, u1, u2);
2892   LEAVE_GL();
2893 }
2894
2895 /***********************************************************************
2896  *              glMapGrid2d
2897  */
2898 void WINAPI wine_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) {
2899   ENTER_GL();
2900   glMapGrid2d(un, u1, u2, vn, v1, v2);
2901   LEAVE_GL();
2902 }
2903
2904 /***********************************************************************
2905  *              glMapGrid2f
2906  */
2907 void WINAPI wine_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) {
2908   ENTER_GL();
2909   glMapGrid2f(un, u1, u2, vn, v1, v2);
2910   LEAVE_GL();
2911 }
2912
2913 /***********************************************************************
2914  *              glEvalPoint1
2915  */
2916 void WINAPI wine_glEvalPoint1(GLint i ) {
2917   ENTER_GL();
2918   glEvalPoint1(i);
2919   LEAVE_GL();
2920 }
2921
2922 /***********************************************************************
2923  *              glEvalPoint2
2924  */
2925 void WINAPI wine_glEvalPoint2(GLint i, GLint j ) {
2926   ENTER_GL();
2927   glEvalPoint2(i, j);
2928   LEAVE_GL();
2929 }
2930
2931 /***********************************************************************
2932  *              glEvalMesh1
2933  */
2934 void WINAPI wine_glEvalMesh1(GLenum mode, GLint i1, GLint i2 ) {
2935   ENTER_GL();
2936   glEvalMesh1(mode, i1, i2);
2937   LEAVE_GL();
2938 }
2939
2940 /***********************************************************************
2941  *              glEvalMesh2
2942  */
2943 void WINAPI wine_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) {
2944   ENTER_GL();
2945   glEvalMesh2(mode, i1, i2, j1, j2);
2946   LEAVE_GL();
2947 }
2948
2949 /***********************************************************************
2950  *              glFogf
2951  */
2952 void WINAPI wine_glFogf(GLenum pname, GLfloat param ) {
2953   ENTER_GL();
2954   glFogf(pname, param);
2955   LEAVE_GL();
2956 }
2957
2958 /***********************************************************************
2959  *              glFogi
2960  */
2961 void WINAPI wine_glFogi(GLenum pname, GLint param ) {
2962   ENTER_GL();
2963   glFogi(pname, param);
2964   LEAVE_GL();
2965 }
2966
2967 /***********************************************************************
2968  *              glFogfv
2969  */
2970 void WINAPI wine_glFogfv(GLenum pname, const GLfloat *params ) {
2971   ENTER_GL();
2972   glFogfv(pname, params);
2973   LEAVE_GL();
2974 }
2975
2976 /***********************************************************************
2977  *              glFogiv
2978  */
2979 void WINAPI wine_glFogiv(GLenum pname, const GLint *params ) {
2980   ENTER_GL();
2981   glFogiv(pname, params);
2982   LEAVE_GL();
2983 }
2984
2985 /***********************************************************************
2986  *              glFeedbackBuffer
2987  */
2988 void WINAPI wine_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer ) {
2989   ENTER_GL();
2990   glFeedbackBuffer(size, type, buffer);
2991   LEAVE_GL();
2992 }
2993
2994 /***********************************************************************
2995  *              glPassThrough
2996  */
2997 void WINAPI wine_glPassThrough(GLfloat token ) {
2998   ENTER_GL();
2999   glPassThrough(token);
3000   LEAVE_GL();
3001 }
3002
3003 /***********************************************************************
3004  *              glSelectBuffer
3005  */
3006 void WINAPI wine_glSelectBuffer(GLsizei size, GLuint *buffer ) {
3007   ENTER_GL();
3008   glSelectBuffer(size, buffer);
3009   LEAVE_GL();
3010 }
3011
3012 /***********************************************************************
3013  *              glInitNames
3014  */
3015 void WINAPI wine_glInitNames(void ) {
3016   ENTER_GL();
3017   glInitNames();
3018   LEAVE_GL();
3019 }
3020
3021 /***********************************************************************
3022  *              glLoadName
3023  */
3024 void WINAPI wine_glLoadName(GLuint name ) {
3025   ENTER_GL();
3026   glLoadName(name);
3027   LEAVE_GL();
3028 }
3029
3030 /***********************************************************************
3031  *              glPushName
3032  */
3033 void WINAPI wine_glPushName(GLuint name ) {
3034   ENTER_GL();
3035   glPushName(name);
3036   LEAVE_GL();
3037 }
3038
3039 /***********************************************************************
3040  *              glPopName
3041  */
3042 void WINAPI wine_glPopName(void ) {
3043   ENTER_GL();
3044   glPopName();
3045   LEAVE_GL();
3046 }
3047
3048 /***********************************************************************
3049  *              glDrawRangeElements
3050  */
3051 void WINAPI wine_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices ) {
3052   ENTER_GL();
3053   glDrawRangeElements(mode, start, end, count, type, indices);
3054   LEAVE_GL();
3055 }
3056
3057 /***********************************************************************
3058  *              glTexImage3D
3059  */
3060 void WINAPI wine_glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) {
3061   ENTER_GL();
3062   glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
3063   LEAVE_GL();
3064 }
3065
3066 /***********************************************************************
3067  *              glTexSubImage3D
3068  */
3069 void WINAPI wine_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) {
3070   ENTER_GL();
3071   glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3072   LEAVE_GL();
3073 }
3074
3075 /***********************************************************************
3076  *              glCopyTexSubImage3D
3077  */
3078 void WINAPI wine_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
3079   ENTER_GL();
3080   glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
3081   LEAVE_GL();
3082 }
3083
3084 /***********************************************************************
3085  *              glColorTable
3086  */
3087 void WINAPI wine_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table ) {
3088   ENTER_GL();
3089   glColorTable(target, internalformat, width, format, type, table);
3090   LEAVE_GL();
3091 }
3092
3093 /***********************************************************************
3094  *              glColorSubTable
3095  */
3096 void WINAPI wine_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data ) {
3097   ENTER_GL();
3098   glColorSubTable(target, start, count, format, type, data);
3099   LEAVE_GL();
3100 }
3101
3102 /***********************************************************************
3103  *              glColorTableParameteriv
3104  */
3105 void WINAPI wine_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) {
3106   ENTER_GL();
3107   glColorTableParameteriv(target, pname, params);
3108   LEAVE_GL();
3109 }
3110
3111 /***********************************************************************
3112  *              glColorTableParameterfv
3113  */
3114 void WINAPI wine_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
3115   ENTER_GL();
3116   glColorTableParameterfv(target, pname, params);
3117   LEAVE_GL();
3118 }
3119
3120 /***********************************************************************
3121  *              glCopyColorSubTable
3122  */
3123 void WINAPI wine_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
3124   ENTER_GL();
3125   glCopyColorSubTable(target, start, x, y, width);
3126   LEAVE_GL();
3127 }
3128
3129 /***********************************************************************
3130  *              glCopyColorTable
3131  */
3132 void WINAPI wine_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
3133   ENTER_GL();
3134   glCopyColorTable(target, internalformat, x, y, width);
3135   LEAVE_GL();
3136 }
3137
3138 /***********************************************************************
3139  *              glGetColorTable
3140  */
3141 void WINAPI wine_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table ) {
3142   ENTER_GL();
3143   glGetColorTable(target, format, type, table);
3144   LEAVE_GL();
3145 }
3146
3147 /***********************************************************************
3148  *              glGetColorTableParameterfv
3149  */
3150 void WINAPI wine_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params ) {
3151   ENTER_GL();
3152   glGetColorTableParameterfv(target, pname, params);
3153   LEAVE_GL();
3154 }
3155
3156 /***********************************************************************
3157  *              glGetColorTableParameteriv
3158  */
3159 void WINAPI wine_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params ) {
3160   ENTER_GL();
3161   glGetColorTableParameteriv(target, pname, params);
3162   LEAVE_GL();
3163 }
3164
3165 /***********************************************************************
3166  *              glBlendEquation
3167  */
3168 void WINAPI wine_glBlendEquation(GLenum mode ) {
3169   ENTER_GL();
3170   glBlendEquation(mode);
3171   LEAVE_GL();
3172 }
3173
3174 /***********************************************************************
3175  *              glBlendColor
3176  */
3177 void WINAPI wine_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) {
3178   ENTER_GL();
3179   glBlendColor(red, green, blue, alpha);
3180   LEAVE_GL();
3181 }
3182
3183 /***********************************************************************
3184  *              glHistogram
3185  */
3186 void WINAPI wine_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
3187   ENTER_GL();
3188   glHistogram(target, width, internalformat, sink);
3189   LEAVE_GL();
3190 }
3191
3192 /***********************************************************************
3193  *              glResetHistogram
3194  */
3195 void WINAPI wine_glResetHistogram(GLenum target ) {
3196   ENTER_GL();
3197   glResetHistogram(target);
3198   LEAVE_GL();
3199 }
3200
3201 /***********************************************************************
3202  *              glGetHistogram
3203  */
3204 void WINAPI wine_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values ) {
3205   ENTER_GL();
3206   glGetHistogram(target, reset, format, type, values);
3207   LEAVE_GL();
3208 }
3209
3210 /***********************************************************************
3211  *              glGetHistogramParameterfv
3212  */
3213 void WINAPI wine_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params ) {
3214   ENTER_GL();
3215   glGetHistogramParameterfv(target, pname, params);
3216   LEAVE_GL();
3217 }
3218
3219 /***********************************************************************
3220  *              glGetHistogramParameteriv
3221  */
3222 void WINAPI wine_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params ) {
3223   ENTER_GL();
3224   glGetHistogramParameteriv(target, pname, params);
3225   LEAVE_GL();
3226 }
3227
3228 /***********************************************************************
3229  *              glMinmax
3230  */
3231 void WINAPI wine_glMinmax(GLenum target, GLenum internalformat, GLboolean sink ) {
3232   ENTER_GL();
3233   glMinmax(target, internalformat, sink);
3234   LEAVE_GL();
3235 }
3236
3237 /***********************************************************************
3238  *              glResetMinmax
3239  */
3240 void WINAPI wine_glResetMinmax(GLenum target ) {
3241   ENTER_GL();
3242   glResetMinmax(target);
3243   LEAVE_GL();
3244 }
3245
3246 /***********************************************************************
3247  *              glGetMinmax
3248  */
3249 void WINAPI wine_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values ) {
3250   ENTER_GL();
3251   glGetMinmax(target, reset, format, types, values);
3252   LEAVE_GL();
3253 }
3254
3255 /***********************************************************************
3256  *              glGetMinmaxParameterfv
3257  */
3258 void WINAPI wine_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params ) {
3259   ENTER_GL();
3260   glGetMinmaxParameterfv(target, pname, params);
3261   LEAVE_GL();
3262 }
3263
3264 /***********************************************************************
3265  *              glGetMinmaxParameteriv
3266  */
3267 void WINAPI wine_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params ) {
3268   ENTER_GL();
3269   glGetMinmaxParameteriv(target, pname, params);
3270   LEAVE_GL();
3271 }
3272
3273 /***********************************************************************
3274  *              glConvolutionFilter1D
3275  */
3276 void WINAPI wine_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image ) {
3277   ENTER_GL();
3278   glConvolutionFilter1D(target, internalformat, width, format, type, image);
3279   LEAVE_GL();
3280 }
3281
3282 /***********************************************************************
3283  *              glConvolutionFilter2D
3284  */
3285 void WINAPI wine_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image ) {
3286   ENTER_GL();
3287   glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
3288   LEAVE_GL();
3289 }
3290
3291 /***********************************************************************
3292  *              glConvolutionParameterf
3293  */
3294 void WINAPI wine_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params ) {
3295   ENTER_GL();
3296   glConvolutionParameterf(target, pname, params);
3297   LEAVE_GL();
3298 }
3299
3300 /***********************************************************************
3301  *              glConvolutionParameterfv
3302  */
3303 void WINAPI wine_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params ) {
3304   ENTER_GL();
3305   glConvolutionParameterfv(target, pname, params);
3306   LEAVE_GL();
3307 }
3308
3309 /***********************************************************************
3310  *              glConvolutionParameteri
3311  */
3312 void WINAPI wine_glConvolutionParameteri(GLenum target, GLenum pname, GLint params ) {
3313   ENTER_GL();
3314   glConvolutionParameteri(target, pname, params);
3315   LEAVE_GL();
3316 }
3317
3318 /***********************************************************************
3319  *              glConvolutionParameteriv
3320  */
3321 void WINAPI wine_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params ) {
3322   ENTER_GL();
3323   glConvolutionParameteriv(target, pname, params);
3324   LEAVE_GL();
3325 }
3326
3327 /***********************************************************************
3328  *              glCopyConvolutionFilter1D
3329  */
3330 void WINAPI wine_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
3331   ENTER_GL();
3332   glCopyConvolutionFilter1D(target, internalformat, x, y, width);
3333   LEAVE_GL();
3334 }
3335
3336 /***********************************************************************
3337  *              glCopyConvolutionFilter2D
3338  */
3339 void WINAPI wine_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {
3340   ENTER_GL();
3341   glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
3342   LEAVE_GL();
3343 }
3344
3345 /***********************************************************************
3346  *              glGetConvolutionFilter
3347  */
3348 void WINAPI wine_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image ) {
3349   ENTER_GL();
3350   glGetConvolutionFilter(target, format, type, image);
3351   LEAVE_GL();
3352 }
3353
3354 /***********************************************************************
3355  *              glGetConvolutionParameterfv
3356  */
3357 void WINAPI wine_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params ) {
3358   ENTER_GL();
3359   glGetConvolutionParameterfv(target, pname, params);
3360   LEAVE_GL();
3361 }
3362
3363 /***********************************************************************
3364  *              glGetConvolutionParameteriv
3365  */
3366 void WINAPI wine_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params ) {
3367   ENTER_GL();
3368   glGetConvolutionParameteriv(target, pname, params);
3369   LEAVE_GL();
3370 }
3371
3372 /***********************************************************************
3373  *              glSeparableFilter2D
3374  */
3375 void WINAPI wine_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column ) {
3376   ENTER_GL();
3377   glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
3378   LEAVE_GL();
3379 }
3380
3381 /***********************************************************************
3382  *              glGetSeparableFilter
3383  */
3384 void WINAPI wine_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span ) {
3385   ENTER_GL();
3386   glGetSeparableFilter(target, format, type, row, column, span);
3387   LEAVE_GL();
3388 }
3389
3390 /***********************************************************************
3391  *              glActiveTextureARB
3392  */
3393 void WINAPI wine_glActiveTextureARB(GLenum texture) {
3394   ENTER_GL();
3395   glActiveTextureARB(texture);
3396   LEAVE_GL();
3397 }
3398
3399 /***********************************************************************
3400  *              glClientActiveTextureARB
3401  */
3402 void WINAPI wine_glClientActiveTextureARB(GLenum texture) {
3403   ENTER_GL();
3404   glClientActiveTextureARB(texture);
3405   LEAVE_GL();
3406 }
3407
3408 /***********************************************************************
3409  *              glMultiTexCoord1dARB
3410  */
3411 void WINAPI wine_glMultiTexCoord1dARB(GLenum target, GLdouble s) {
3412   ENTER_GL();
3413   glMultiTexCoord1dARB(target, s);
3414   LEAVE_GL();
3415 }
3416
3417 /***********************************************************************
3418  *              glMultiTexCoord1dvARB
3419  */
3420 void WINAPI wine_glMultiTexCoord1dvARB(GLenum target, const GLdouble *v) {
3421   ENTER_GL();
3422   glMultiTexCoord1dvARB(target, v);
3423   LEAVE_GL();
3424 }
3425
3426 /***********************************************************************
3427  *              glMultiTexCoord1fARB
3428  */
3429 void WINAPI wine_glMultiTexCoord1fARB(GLenum target, GLfloat s) {
3430   ENTER_GL();
3431   glMultiTexCoord1fARB(target, s);
3432   LEAVE_GL();
3433 }
3434
3435 /***********************************************************************
3436  *              glMultiTexCoord1fvARB
3437  */
3438 void WINAPI wine_glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) {
3439   ENTER_GL();
3440   glMultiTexCoord1fvARB(target, v);
3441   LEAVE_GL();
3442 }
3443
3444 /***********************************************************************
3445  *              glMultiTexCoord1iARB
3446  */
3447 void WINAPI wine_glMultiTexCoord1iARB(GLenum target, GLint s) {
3448   ENTER_GL();
3449   glMultiTexCoord1iARB(target, s);
3450   LEAVE_GL();
3451 }
3452
3453 /***********************************************************************
3454  *              glMultiTexCoord1ivARB
3455  */
3456 void WINAPI wine_glMultiTexCoord1ivARB(GLenum target, const GLint *v) {
3457   ENTER_GL();
3458   glMultiTexCoord1ivARB(target, v);
3459   LEAVE_GL();
3460 }
3461
3462 /***********************************************************************
3463  *              glMultiTexCoord1sARB
3464  */
3465 void WINAPI wine_glMultiTexCoord1sARB(GLenum target, GLshort s) {
3466   ENTER_GL();
3467   glMultiTexCoord1sARB(target, s);
3468   LEAVE_GL();
3469 }
3470
3471 /***********************************************************************
3472  *              glMultiTexCoord1svARB
3473  */
3474 void WINAPI wine_glMultiTexCoord1svARB(GLenum target, const GLshort *v) {
3475   ENTER_GL();
3476   glMultiTexCoord1svARB(target, v);
3477   LEAVE_GL();
3478 }
3479
3480 /***********************************************************************
3481  *              glMultiTexCoord2dARB
3482  */
3483 void WINAPI wine_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) {
3484   ENTER_GL();
3485   glMultiTexCoord2dARB(target, s, t);
3486   LEAVE_GL();
3487 }
3488
3489 /***********************************************************************
3490  *              glMultiTexCoord2dvARB
3491  */
3492 void WINAPI wine_glMultiTexCoord2dvARB(GLenum target, const GLdouble *v) {
3493   ENTER_GL();
3494   glMultiTexCoord2dvARB(target, v);
3495   LEAVE_GL();
3496 }
3497
3498 /***********************************************************************
3499  *              glMultiTexCoord2fARB
3500  */
3501 void WINAPI wine_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) {
3502   ENTER_GL();
3503   glMultiTexCoord2fARB(target, s, t);
3504   LEAVE_GL();
3505 }
3506
3507 /***********************************************************************
3508  *              glMultiTexCoord2fvARB
3509  */
3510 void WINAPI wine_glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) {
3511   ENTER_GL();
3512   glMultiTexCoord2fvARB(target, v);
3513   LEAVE_GL();
3514 }
3515
3516 /***********************************************************************
3517  *              glMultiTexCoord2iARB
3518  */
3519 void WINAPI wine_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) {
3520   ENTER_GL();
3521   glMultiTexCoord2iARB(target, s, t);
3522   LEAVE_GL();
3523 }
3524
3525 /***********************************************************************
3526  *              glMultiTexCoord2ivARB
3527  */
3528 void WINAPI wine_glMultiTexCoord2ivARB(GLenum target, const GLint *v) {
3529   ENTER_GL();
3530   glMultiTexCoord2ivARB(target, v);
3531   LEAVE_GL();
3532 }
3533
3534 /***********************************************************************
3535  *              glMultiTexCoord2sARB
3536  */
3537 void WINAPI wine_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) {
3538   ENTER_GL();
3539   glMultiTexCoord2sARB(target, s, t);
3540   LEAVE_GL();
3541 }
3542
3543 /***********************************************************************
3544  *              glMultiTexCoord2svARB
3545  */
3546 void WINAPI wine_glMultiTexCoord2svARB(GLenum target, const GLshort *v) {
3547   ENTER_GL();
3548   glMultiTexCoord2svARB(target, v);
3549   LEAVE_GL();
3550 }
3551
3552 /***********************************************************************
3553  *              glMultiTexCoord3dARB
3554  */
3555 void WINAPI wine_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r) {
3556   ENTER_GL();
3557   glMultiTexCoord3dARB(target, s, t, r);
3558   LEAVE_GL();
3559 }
3560
3561 /***********************************************************************
3562  *              glMultiTexCoord3dvARB
3563  */
3564 void WINAPI wine_glMultiTexCoord3dvARB(GLenum target, const GLdouble *v) {
3565   ENTER_GL();
3566   glMultiTexCoord3dvARB(target, v);
3567   LEAVE_GL();
3568 }
3569
3570 /***********************************************************************
3571  *              glMultiTexCoord3fARB
3572  */
3573 void WINAPI wine_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) {
3574   ENTER_GL();
3575   glMultiTexCoord3fARB(target, s, t, r);
3576   LEAVE_GL();
3577 }
3578
3579 /***********************************************************************
3580  *              glMultiTexCoord3fvARB
3581  */
3582 void WINAPI wine_glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) {
3583   ENTER_GL();
3584   glMultiTexCoord3fvARB(target, v);
3585   LEAVE_GL();
3586 }
3587
3588 /***********************************************************************
3589  *              glMultiTexCoord3iARB
3590  */
3591 void WINAPI wine_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) {
3592   ENTER_GL();
3593   glMultiTexCoord3iARB(target, s, t, r);
3594   LEAVE_GL();
3595 }
3596
3597 /***********************************************************************
3598  *              glMultiTexCoord3ivARB
3599  */
3600 void WINAPI wine_glMultiTexCoord3ivARB(GLenum target, const GLint *v) {
3601   ENTER_GL();
3602   glMultiTexCoord3ivARB(target, v);
3603   LEAVE_GL();
3604 }
3605
3606 /***********************************************************************
3607  *              glMultiTexCoord3sARB
3608  */
3609 void WINAPI wine_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r) {
3610   ENTER_GL();
3611   glMultiTexCoord3sARB(target, s, t, r);
3612   LEAVE_GL();
3613 }
3614
3615 /***********************************************************************
3616  *              glMultiTexCoord3svARB
3617  */
3618 void WINAPI wine_glMultiTexCoord3svARB(GLenum target, const GLshort *v) {
3619   ENTER_GL();
3620   glMultiTexCoord3svARB(target, v);
3621   LEAVE_GL();
3622 }
3623
3624 /***********************************************************************
3625  *              glMultiTexCoord4dARB
3626  */
3627 void WINAPI wine_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
3628   ENTER_GL();
3629   glMultiTexCoord4dARB(target, s, t, r, q);
3630   LEAVE_GL();
3631 }
3632
3633 /***********************************************************************
3634  *              glMultiTexCoord4dvARB
3635  */
3636 void WINAPI wine_glMultiTexCoord4dvARB(GLenum target, const GLdouble *v) {
3637   ENTER_GL();
3638   glMultiTexCoord4dvARB(target, v);
3639   LEAVE_GL();
3640 }
3641
3642 /***********************************************************************
3643  *              glMultiTexCoord4fARB
3644  */
3645 void WINAPI wine_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
3646   ENTER_GL();
3647   glMultiTexCoord4fARB(target, s, t, r, q);
3648   LEAVE_GL();
3649 }
3650
3651 /***********************************************************************
3652  *              glMultiTexCoord4fvARB
3653  */
3654 void WINAPI wine_glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) {
3655   ENTER_GL();
3656   glMultiTexCoord4fvARB(target, v);
3657   LEAVE_GL();
3658 }
3659
3660 /***********************************************************************
3661  *              glMultiTexCoord4iARB
3662  */
3663 void WINAPI wine_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q) {
3664   ENTER_GL();
3665   glMultiTexCoord4iARB(target, s, t, r, q);
3666   LEAVE_GL();
3667 }
3668
3669 /***********************************************************************
3670  *              glMultiTexCoord4ivARB
3671  */
3672 void WINAPI wine_glMultiTexCoord4ivARB(GLenum target, const GLint *v) {
3673   ENTER_GL();
3674   glMultiTexCoord4ivARB(target, v);
3675   LEAVE_GL();
3676 }
3677
3678 /***********************************************************************
3679  *              glMultiTexCoord4sARB
3680  */
3681 void WINAPI wine_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {
3682   ENTER_GL();
3683   glMultiTexCoord4sARB(target, s, t, r, q);
3684   LEAVE_GL();
3685 }
3686
3687 /***********************************************************************
3688  *              glMultiTexCoord4svARB
3689  */
3690 void WINAPI wine_glMultiTexCoord4svARB(GLenum target, const GLshort *v) {
3691   ENTER_GL();
3692   glMultiTexCoord4svARB(target, v);
3693   LEAVE_GL();
3694 }
3695