src/OpenGl/OpenGl_GlCore11.hxx

   1 // Created on: 2012-03-06
   2 // Created by: Kirill GAVRILOV
   3 // Copyright (c) 2012-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #ifndef _OpenGl_GlCore11_Header
  17 #define _OpenGl_GlCore11_Header
  18
  19 #include <OpenGl_GlCore11Fwd.hxx>
  20
  21 //! OpenGL 1.1 core.
  22 //! Notice that all functions within this structure are actually exported by system GL library.
  23 //! The main purpose for these hint - to control visibility of functions per GL version
  24 //! (global functions should not be used directly to achieve this effect!).
  25 struct OpenGl_GlCore11 : protected OpenGl_GlFunctions
  26 {
  27
  28 #if !defined(GL_ES_VERSION_2_0)
  29   inline void glRotated (GLdouble theAngleDegrees,
  30                          GLdouble theX, GLdouble theY, GLdouble theZ)
  31   {
  32     ::glRotated (theAngleDegrees, theX, theY, theZ);
  33   }
  34
  35   inline void glScaled (GLdouble theX, GLdouble theY, GLdouble theZ)
  36   {
  37     ::glScaled (theX, theY, theZ);
  38   }
  39
  40   inline void glTranslated (GLdouble theX, GLdouble theY, GLdouble theZ)
  41   {
  42     ::glTranslated (theX, theY, theZ);
  43   }
  44
  45 public: //! @name Begin/End primitive specification (removed since 3.1)
  46
  47   inline void glBegin (GLenum theMode)
  48   {
  49     ::glBegin (theMode);
  50   }
  51
  52   inline void glEnd()
  53   {
  54     ::glEnd();
  55   }
  56
  57   inline void glVertex2d (GLdouble theX, GLdouble theY)
  58   {
  59     ::glVertex2d (theX, theY);
  60   }
  61
  62   inline void glVertex2f (GLfloat  theX, GLfloat  theY)
  63   {
  64     ::glVertex2f (theX, theY);
  65   }
  66
  67   inline void glVertex2i (GLint    theX, GLint    theY)
  68   {
  69     ::glVertex2i (theX, theY);
  70   }
  71
  72   inline void glVertex2s (GLshort  theX, GLshort  theY)
  73   {
  74     ::glVertex2s (theX, theY);
  75   }
  76
  77   inline void glVertex3d (GLdouble theX, GLdouble theY, GLdouble theZ)
  78   {
  79     ::glVertex3d (theX, theY, theZ);
  80   }
  81
  82   inline void glVertex3f (GLfloat  theX, GLfloat  theY, GLfloat  theZ)
  83   {
  84     ::glVertex3f (theX, theY, theZ);
  85   }
  86
  87   inline void glVertex3i (GLint    theX, GLint    theY, GLint    theZ)
  88   {
  89     ::glVertex3i (theX, theY, theZ);
  90   }
  91
  92   inline void glVertex3s (GLshort  theX, GLshort  theY, GLshort  theZ)
  93   {
  94     ::glVertex3s (theX, theY, theZ);
  95   }
  96
  97   inline void glVertex4d (GLdouble theX, GLdouble theY, GLdouble theZ, GLdouble theW)
  98   {
  99     ::glVertex4d (theX, theY, theZ, theW);
 100   }
 101
 102   inline void glVertex4f (GLfloat  theX, GLfloat  theY, GLfloat  theZ, GLfloat  theW)
 103   {
 104     ::glVertex4f (theX, theY, theZ, theW);
 105   }
 106
 107   inline void glVertex4i (GLint    theX, GLint    theY, GLint    theZ, GLint    theW)
 108   {
 109     ::glVertex4i (theX, theY, theZ, theW);
 110   }
 111
 112   inline void glVertex4s (GLshort  theX, GLshort  theY, GLshort  theZ, GLshort  theW)
 113   {
 114     ::glVertex4s (theX, theY, theZ, theW);
 115   }
 116
 117   inline void glVertex2dv (const GLdouble* theVec2)
 118   {
 119     ::glVertex2dv (theVec2);
 120   }
 121
 122   inline void glVertex2fv (const GLfloat*  theVec2)
 123   {
 124     ::glVertex2fv (theVec2);
 125   }
 126
 127   inline void glVertex2iv (const GLint*    theVec2)
 128   {
 129     ::glVertex2iv (theVec2);
 130   }
 131
 132   inline void glVertex2sv (const GLshort*  theVec2)
 133   {
 134     ::glVertex2sv (theVec2);
 135   }
 136
 137   inline void glVertex3dv (const GLdouble* theVec3)
 138   {
 139     ::glVertex3dv (theVec3);
 140   }
 141
 142   inline void glVertex3fv (const GLfloat*  theVec3)
 143   {
 144     ::glVertex3fv (theVec3);
 145   }
 146
 147   inline void glVertex3iv (const GLint*    theVec3)
 148   {
 149     ::glVertex3iv (theVec3);
 150   }
 151
 152   inline void glVertex3sv (const GLshort*  theVec3)
 153   {
 154     ::glVertex3sv (theVec3);
 155   }
 156
 157   inline void glVertex4dv (const GLdouble* theVec4)
 158   {
 159     ::glVertex4dv (theVec4);
 160   }
 161
 162   inline void glVertex4fv (const GLfloat*  theVec4)
 163   {
 164     ::glVertex4fv (theVec4);
 165   }
 166
 167   inline void glVertex4iv (const GLint*    theVec4)
 168   {
 169     ::glVertex4iv (theVec4);
 170   }
 171
 172   inline void glVertex4sv (const GLshort*  theVec4)
 173   {
 174     ::glVertex4sv (theVec4);
 175   }
 176
 177   inline void glNormal3b (GLbyte   nx, GLbyte   ny, GLbyte   nz)
 178   {
 179     ::glNormal3b(nx, ny, nz);
 180   }
 181
 182   inline void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
 183   {
 184     ::glNormal3d(nx, ny, nz);
 185   }
 186
 187   inline void glNormal3f (GLfloat  nx, GLfloat  ny, GLfloat  nz)
 188   {
 189     ::glNormal3f(nx, ny, nz);
 190   }
 191
 192   inline void glNormal3i (GLint    nx, GLint    ny, GLint    nz)
 193   {
 194     ::glNormal3i(nx, ny, nz);
 195   }
 196
 197   inline void glNormal3s (GLshort nx, GLshort ny, GLshort nz)
 198   {
 199     ::glNormal3s(nx, ny, nz);
 200   }
 201
 202   inline void glNormal3bv (const GLbyte*   theVec)
 203   {
 204     ::glNormal3bv (theVec);
 205   }
 206
 207   inline void glNormal3dv (const GLdouble* theVec)
 208   {
 209     ::glNormal3dv (theVec);
 210   }
 211
 212   inline void glNormal3fv (const GLfloat*  theVec)
 213   {
 214     ::glNormal3fv (theVec);
 215   }
 216
 217   inline void glNormal3iv (const GLint*    theVec)
 218   {
 219     ::glNormal3iv (theVec);
 220   }
 221
 222   inline void glNormal3sv (const GLshort*  theVec)
 223   {
 224     ::glNormal3sv (theVec);
 225   }
 226
 227   inline void glIndexd (GLdouble c)
 228   {
 229     ::glIndexd(c);
 230   }
 231
 232   inline void glIndexf (GLfloat c)
 233   {
 234     ::glIndexf(c);
 235   }
 236
 237   inline void glIndexi (GLint c)
 238   {
 239     ::glIndexi(c);
 240   }
 241
 242   inline void glIndexs (GLshort c)
 243   {
 244     ::glIndexs(c);
 245   }
 246
 247   inline void glIndexub (GLubyte c)
 248   {
 249     ::glIndexub(c);
 250   }
 251
 252   inline void glIndexdv (const GLdouble* c)
 253   {
 254     ::glIndexdv(c);
 255   }
 256
 257   inline void glIndexfv (const GLfloat* c)
 258   {
 259     ::glIndexfv(c);
 260   }
 261
 262   inline void glIndexiv (const GLint* c)
 263   {
 264     ::glIndexiv(c);
 265   }
 266
 267   inline void glIndexsv (const GLshort* c)
 268   {
 269     ::glIndexsv(c);
 270   }
 271
 272   inline void glIndexubv (const GLubyte* c)
 273   {
 274     ::glIndexubv(c);
 275   }
 276
 277   inline void glColor3b (GLbyte theRed, GLbyte theGreen, GLbyte theBlue)
 278   {
 279     ::glColor3b (theRed, theGreen, theBlue);
 280   }
 281
 282   inline void glColor3d (GLdouble theRed, GLdouble theGreen, GLdouble theBlue)
 283   {
 284     ::glColor3d (theRed, theGreen, theBlue);
 285   }
 286
 287   inline void glColor3f (GLfloat theRed, GLfloat theGreen, GLfloat theBlue)
 288   {
 289     ::glColor3f (theRed, theGreen, theBlue);
 290   }
 291
 292   inline void glColor3i (GLint theRed, GLint theGreen, GLint theBlue)
 293   {
 294     ::glColor3i (theRed, theGreen, theBlue);
 295   }
 296
 297   inline void glColor3s (GLshort theRed, GLshort theGreen, GLshort theBlue)
 298   {
 299     ::glColor3s (theRed, theGreen, theBlue);
 300   }
 301
 302   inline void glColor3ub (GLubyte theRed, GLubyte theGreen, GLubyte theBlue)
 303   {
 304     ::glColor3ub (theRed, theGreen, theBlue);
 305   }
 306
 307   inline void glColor3ui (GLuint theRed, GLuint theGreen, GLuint theBlue)
 308   {
 309     ::glColor3ui (theRed, theGreen, theBlue);
 310   }
 311
 312   inline void glColor3us (GLushort theRed, GLushort theGreen, GLushort theBlue)
 313   {
 314     ::glColor3us (theRed, theGreen, theBlue);
 315   }
 316
 317   inline void glColor4b (GLbyte theRed, GLbyte theGreen, GLbyte theBlue, GLbyte theAlpha)
 318   {
 319     ::glColor4b (theRed, theGreen, theBlue, theAlpha);
 320   }
 321
 322   inline void glColor4d (GLdouble theRed, GLdouble theGreen, GLdouble theBlue, GLdouble theAlpha)
 323   {
 324     ::glColor4d (theRed, theGreen, theBlue, theAlpha);
 325   }
 326
 327   inline void glColor4f (GLfloat theRed, GLfloat theGreen, GLfloat theBlue, GLfloat theAlpha)
 328   {
 329     ::glColor4f (theRed, theGreen, theBlue, theAlpha);
 330   }
 331
 332   inline void glColor4i (GLint theRed, GLint theGreen, GLint theBlue, GLint theAlpha)
 333   {
 334     ::glColor4i (theRed, theGreen, theBlue, theAlpha);
 335   }
 336
 337   inline void glColor4s (GLshort theRed, GLshort theGreen, GLshort theBlue, GLshort theAlpha)
 338   {
 339     ::glColor4s (theRed, theGreen, theBlue, theAlpha);
 340   }
 341
 342   inline void glColor4ub (GLubyte theRed, GLubyte theGreen, GLubyte theBlue, GLubyte theAlpha)
 343   {
 344     ::glColor4ub (theRed, theGreen, theBlue, theAlpha);
 345   }
 346
 347   inline void glColor4ui (GLuint theRed, GLuint theGreen, GLuint theBlue, GLuint theAlpha)
 348   {
 349     ::glColor4ui (theRed, theGreen, theBlue, theAlpha);
 350   }
 351
 352   inline void glColor4us (GLushort theRed, GLushort theGreen, GLushort theBlue, GLushort theAlpha)
 353   {
 354     ::glColor4us (theRed, theGreen, theBlue, theAlpha);
 355   }
 356
 357   inline void glColor3bv (const GLbyte*    theVec)
 358   {
 359     ::glColor3bv (theVec);
 360   }
 361
 362   inline void glColor3dv (const GLdouble*  theVec)
 363   {
 364     ::glColor3dv (theVec);
 365   }
 366
 367   inline void glColor3fv (const GLfloat*   theVec)
 368   {
 369     ::glColor3fv (theVec);
 370   }
 371
 372   inline void glColor3iv (const GLint*     theVec)
 373   {
 374     ::glColor3iv (theVec);
 375   }
 376
 377   inline void glColor3sv (const GLshort*   theVec)
 378   {
 379     ::glColor3sv (theVec);
 380   }
 381
 382   inline void glColor3ubv (const GLubyte*  theVec)
 383   {
 384     ::glColor3ubv (theVec);
 385   }
 386
 387   inline void glColor3uiv (const GLuint*   theVec)
 388   {
 389     ::glColor3uiv (theVec);
 390   }
 391
 392   inline void glColor3usv (const GLushort* theVec)
 393   {
 394     ::glColor3usv (theVec);
 395   }
 396
 397   inline void glColor4bv (const GLbyte*    theVec)
 398   {
 399     ::glColor4bv (theVec);
 400   }
 401
 402   inline void glColor4dv (const GLdouble*  theVec)
 403   {
 404     ::glColor4dv (theVec);
 405   }
 406
 407   inline void glColor4fv (const GLfloat*   theVec)
 408   {
 409     ::glColor4fv (theVec);
 410   }
 411
 412   inline void glColor4iv (const GLint*     theVec)
 413   {
 414     ::glColor4iv (theVec);
 415   }
 416
 417   inline void glColor4sv (const GLshort*   theVec)
 418   {
 419     ::glColor4sv (theVec);
 420   }
 421
 422   inline void glColor4ubv (const GLubyte*  theVec)
 423   {
 424     ::glColor4ubv (theVec);
 425   }
 426
 427   inline void glColor4uiv (const GLuint*   theVec)
 428   {
 429     ::glColor4uiv (theVec);
 430   }
 431
 432   inline void glColor4usv (const GLushort* theVec)
 433   {
 434     ::glColor4usv (theVec);
 435   }
 436
 437   inline void glTexCoord1d (GLdouble s)
 438   {
 439     ::glTexCoord1d(s);
 440   }
 441
 442   inline void glTexCoord1f (GLfloat s)
 443   {
 444     ::glTexCoord1f(s);
 445   }
 446
 447   inline void glTexCoord1i (GLint s)
 448   {
 449     ::glTexCoord1i(s);
 450   }
 451
 452   inline void glTexCoord1s (GLshort s)
 453   {
 454     ::glTexCoord1s(s);
 455   }
 456
 457   inline void glTexCoord2d (GLdouble s, GLdouble t)
 458   {
 459     ::glTexCoord2d(s, t);
 460   }
 461
 462   inline void glTexCoord2f (GLfloat s, GLfloat t)
 463   {
 464     ::glTexCoord2f(s, t);
 465   }
 466
 467   inline void glTexCoord2i (GLint s, GLint t)
 468   {
 469     ::glTexCoord2i(s, t);
 470   }
 471
 472   inline void glTexCoord2s (GLshort s, GLshort t)
 473   {
 474     ::glTexCoord2s(s, t);
 475   }
 476
 477   inline void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
 478   {
 479     ::glTexCoord3d(s, t, r);
 480   }
 481
 482   inline void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
 483   {
 484     ::glTexCoord3f(s, t, r);
 485   }
 486
 487   inline void glTexCoord3i (GLint s, GLint t, GLint r)
 488   {
 489     ::glTexCoord3i(s, t, r);
 490   }
 491
 492   inline void glTexCoord3s (GLshort s, GLshort t, GLshort r)
 493   {
 494     ::glTexCoord3s(s, t, r);
 495   }
 496
 497   inline void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 498   {
 499     ::glTexCoord4d(s, t, r, q);
 500   }
 501
 502   inline void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 503   {
 504     ::glTexCoord4f(s, t, r, q);
 505   }
 506
 507   inline void glTexCoord4i (GLint s, GLint t, GLint r, GLint q)
 508   {
 509     ::glTexCoord4i(s, t, r, q);
 510   }
 511
 512   inline void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
 513   {
 514     ::glTexCoord4s(s, t, r, q);
 515   }
 516
 517   inline void glTexCoord1dv (const GLdouble* theVec1)
 518   {
 519     ::glTexCoord1dv (theVec1);
 520   }
 521
 522   inline void glTexCoord1fv (const GLfloat*  theVec1)
 523   {
 524     ::glTexCoord1fv (theVec1);
 525   }
 526
 527   inline void glTexCoord1iv (const GLint*    theVec1)
 528   {
 529     ::glTexCoord1iv (theVec1);
 530   }
 531
 532   inline void glTexCoord1sv (const GLshort*  theVec1)
 533   {
 534     ::glTexCoord1sv (theVec1);
 535   }
 536
 537   inline void glTexCoord2dv (const GLdouble* theVec2)
 538   {
 539     ::glTexCoord2dv (theVec2);
 540   }
 541
 542   inline void glTexCoord2fv (const GLfloat*  theVec2)
 543   {
 544     ::glTexCoord2fv (theVec2);
 545   }
 546
 547   inline void glTexCoord2iv (const GLint*    theVec2)
 548   {
 549     ::glTexCoord2iv (theVec2);
 550   }
 551
 552   inline void glTexCoord2sv (const GLshort*  theVec)
 553   {
 554     ::glTexCoord2sv (theVec);
 555   }
 556
 557   inline void glTexCoord3dv (const GLdouble* theVec3)
 558   {
 559     ::glTexCoord3dv (theVec3);
 560   }
 561
 562   inline void glTexCoord3fv (const GLfloat*  theVec3)
 563   {
 564     ::glTexCoord3fv (theVec3);
 565   }
 566
 567   inline void glTexCoord3iv (const GLint*    theVec3)
 568   {
 569     ::glTexCoord3iv (theVec3);
 570   }
 571
 572   inline void glTexCoord3sv (const GLshort*  theVec3)
 573   {
 574     ::glTexCoord3sv (theVec3);
 575   }
 576
 577   inline void glTexCoord4dv (const GLdouble* theVec4)
 578   {
 579     ::glTexCoord4dv (theVec4);
 580   }
 581
 582   inline void glTexCoord4fv (const GLfloat*  theVec4)
 583   {
 584     ::glTexCoord4fv (theVec4);
 585   }
 586
 587   inline void glTexCoord4iv (const GLint*    theVec4)
 588   {
 589     ::glTexCoord4iv (theVec4);
 590   }
 591
 592   inline void glTexCoord4sv (const GLshort*  theVec4)
 593   {
 594     ::glTexCoord4sv (theVec4);
 595   }
 596
 597 public: //! @name Matrix operations (removed since 3.1)
 598
 599   inline void glMatrixMode (GLenum theMode)
 600   {
 601     ::glMatrixMode (theMode);
 602   }
 603
 604   inline void glOrtho (GLdouble theLeft,    GLdouble theRight,
 605                        GLdouble theBottom,  GLdouble theTop,
 606                        GLdouble theNearVal, GLdouble theFarVal)
 607   {
 608     ::glOrtho (theLeft, theRight, theBottom, theTop, theNearVal, theFarVal);
 609   }
 610
 611   inline void glFrustum (GLdouble theLeft,    GLdouble theRight,
 612                          GLdouble theBottom,  GLdouble theTop,
 613                          GLdouble theNearVal, GLdouble theFarVal)
 614   {
 615     ::glFrustum (theLeft, theRight, theBottom, theTop, theNearVal, theFarVal);
 616   }
 617
 618   inline void glPushMatrix()
 619   {
 620     ::glPushMatrix();
 621   }
 622
 623   inline void glPopMatrix()
 624   {
 625     ::glPopMatrix();
 626   }
 627
 628   inline void glLoadIdentity()
 629   {
 630     ::glLoadIdentity();
 631   }
 632
 633   inline void glLoadMatrixd (const GLdouble* theMatrix)
 634   {
 635     ::glLoadMatrixd (theMatrix);
 636   }
 637
 638   inline void glLoadMatrixf (const GLfloat*  theMatrix)
 639   {
 640     ::glLoadMatrixf (theMatrix);
 641   }
 642
 643   inline void glMultMatrixd (const GLdouble* theMatrix)
 644   {
 645     ::glMultMatrixd (theMatrix);
 646   }
 647
 648   inline void glMultMatrixf (const GLfloat*  theMatrix)
 649   {
 650     ::glMultMatrixf (theMatrix);
 651   }
 652
 653 public: //! @name Line and Polygon stripple (removed since 3.1)
 654
 655   //void glLineWidth (GLfloat theWidth) { ::glLineWidth (theWidth); }
 656
 657   inline void glLineStipple (GLint theFactor, GLushort thePattern)
 658   {
 659     ::glLineStipple (theFactor, thePattern);
 660   }
 661
 662   inline void glPolygonStipple (const GLubyte* theMask)
 663   {
 664     ::glPolygonStipple (theMask);
 665   }
 666
 667   inline void glGetPolygonStipple (GLubyte* theMask)
 668   {
 669     ::glGetPolygonStipple (theMask);
 670   }
 671
 672 public: //! @name Attribute stacks (removed since 3.1)
 673
 674   inline void glPushAttrib (GLbitfield theMask)
 675   {
 676     ::glPushAttrib (theMask);
 677   }
 678
 679   inline void glPopAttrib()
 680   {
 681     ::glPopAttrib();
 682   }
 683
 684   inline void glPushClientAttrib (GLbitfield theMask)
 685   {
 686     ::glPushClientAttrib (theMask);
 687   }
 688
 689   inline void glPopClientAttrib()
 690   {
 691     ::glPopClientAttrib();
 692   }
 693
 694 public: //! @name Fixed pipeline lighting (removed since 3.1)
 695
 696   inline void glShadeModel (GLenum theMode)
 697   {
 698     ::glShadeModel (theMode);
 699   }
 700
 701   inline void glLightf (GLenum theLight, GLenum pname, GLfloat param)
 702   {
 703     ::glLightf (theLight, pname, param);
 704   }
 705
 706   inline void glLighti (GLenum theLight, GLenum pname, GLint param)
 707   {
 708     ::glLighti (theLight, pname, param);
 709   }
 710
 711   inline void glLightfv (GLenum theLight, GLenum pname, const GLfloat* params)
 712   {
 713     ::glLightfv (theLight, pname, params);
 714   }
 715
 716   inline void glLightiv (GLenum theLight, GLenum pname, const GLint* params)
 717   {
 718     ::glLightiv (theLight, pname, params);
 719   }
 720
 721   inline void glGetLightfv (GLenum theLight, GLenum pname, GLfloat *params)
 722   {
 723     ::glGetLightfv (theLight, pname, params);
 724   }
 725
 726   inline void glGetLightiv (GLenum theLight, GLenum pname, GLint *params)
 727   {
 728     ::glGetLightiv (theLight, pname, params);
 729   }
 730
 731   inline void glLightModelf (GLenum pname, GLfloat param)
 732   {
 733     ::glLightModelf(pname, param);
 734   }
 735
 736   inline void glLightModeli (GLenum pname, GLint param)
 737   {
 738     ::glLightModeli(pname, param);
 739   }
 740
 741   inline void glLightModelfv (GLenum pname, const GLfloat* params)
 742   {
 743     ::glLightModelfv(pname, params);
 744   }
 745
 746   inline void glLightModeliv (GLenum pname, const GLint* params)
 747   {
 748     ::glLightModeliv(pname, params);
 749   }
 750
 751   inline void glMaterialf (GLenum face, GLenum pname, GLfloat param)
 752   {
 753     ::glMaterialf(face, pname, param);
 754   }
 755
 756   inline void glMateriali (GLenum face, GLenum pname, GLint param)
 757   {
 758     ::glMateriali(face, pname, param);
 759   }
 760
 761   inline void glMaterialfv (GLenum face, GLenum pname, const GLfloat* params)
 762   {
 763     ::glMaterialfv(face, pname, params);
 764   }
 765
 766   inline void glMaterialiv (GLenum face, GLenum pname, const GLint* params)
 767   {
 768     ::glMaterialiv(face, pname, params);
 769   }
 770
 771   inline void glGetMaterialfv (GLenum face, GLenum pname, GLfloat* params)
 772   {
 773     ::glGetMaterialfv(face, pname, params);
 774   }
 775
 776   inline void glGetMaterialiv (GLenum face, GLenum pname, GLint* params)
 777   {
 778     ::glGetMaterialiv(face, pname, params);
 779   }
 780
 781   inline void glColorMaterial (GLenum face, GLenum mode)
 782   {
 783     ::glColorMaterial(face, mode);
 784   }
 785
 786 public: //! @name clipping plane (removed since 3.1)
 787
 788   inline void glClipPlane (GLenum thePlane, const GLdouble* theEquation)
 789   {
 790     ::glClipPlane (thePlane, theEquation);
 791   }
 792
 793   inline void glGetClipPlane (GLenum thePlane, GLdouble* theEquation)
 794   {
 795     ::glGetClipPlane (thePlane, theEquation);
 796   }
 797
 798 public: //! @name Display lists (removed since 3.1)
 799
 800   inline GLboolean glIsList (GLuint theList) {
 801     return ::glIsList (theList);
 802   }
 803
 804   inline void glDeleteLists (GLuint theList, GLsizei theRange)
 805   {
 806     ::glDeleteLists (theList, theRange);
 807   }
 808
 809   inline GLuint glGenLists (GLsizei theRange)
 810   {
 811     return ::glGenLists (theRange);
 812   }
 813
 814   inline void glNewList (GLuint theList, GLenum theMode)
 815   {
 816     ::glNewList (theList, theMode);
 817   }
 818
 819   inline void glEndList()
 820   {
 821     ::glEndList();
 822   }
 823
 824   inline void glCallList (GLuint theList)
 825   {
 826     ::glCallList (theList);
 827   }
 828
 829   inline void glCallLists (GLsizei theNb, GLenum theType, const GLvoid* theLists)
 830   {
 831     ::glCallLists (theNb, theType, theLists);
 832   }
 833
 834   inline void glListBase (GLuint theBase)
 835   {
 836     ::glListBase (theBase);
 837   }
 838
 839 public: //! @name Current raster position and Rectangles (removed since 3.1)
 840
 841   inline void glRasterPos2d (GLdouble x, GLdouble y)
 842   {
 843     ::glRasterPos2d (x, y);
 844   }
 845
 846   inline void glRasterPos2f (GLfloat  x, GLfloat  y)
 847   {
 848     ::glRasterPos2f (x, y);
 849   }
 850
 851   inline void glRasterPos2i (GLint    x, GLint    y)
 852   {
 853     ::glRasterPos2i (x, y);
 854   }
 855
 856   inline void glRasterPos2s (GLshort  x, GLshort  y)
 857   {
 858     ::glRasterPos2s (x, y);
 859   }
 860
 861   inline void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
 862   {
 863     ::glRasterPos3d (x, y, z);
 864   }
 865
 866   inline void glRasterPos3f (GLfloat  x, GLfloat  y, GLfloat  z)
 867   {
 868     ::glRasterPos3f (x, y, z);
 869   }
 870
 871   inline void glRasterPos3i (GLint    x, GLint    y, GLint    z)
 872   {
 873     ::glRasterPos3i (x, y, z);
 874   }
 875
 876   inline void glRasterPos3s (GLshort  x, GLshort  y, GLshort  z)
 877   {
 878     ::glRasterPos3s (x, y, z);
 879   }
 880
 881   inline void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 882   {
 883     ::glRasterPos4d (x, y, z, w);
 884   }
 885
 886   inline void glRasterPos4f (GLfloat  x, GLfloat  y, GLfloat  z, GLfloat  w)
 887   {
 888     ::glRasterPos4f (x, y, z, w);
 889   }
 890
 891   inline void glRasterPos4i (GLint    x, GLint    y, GLint    z, GLint    w)
 892   {
 893     ::glRasterPos4i (x, y, z, w);
 894   }
 895
 896   inline void glRasterPos4s (GLshort  x, GLshort  y, GLshort  z, GLshort  w)
 897   {
 898     ::glRasterPos4s (x, y, z, w);
 899   }
 900
 901   inline void glRasterPos2dv (const GLdouble* theVec)
 902   {
 903     ::glRasterPos2dv (theVec);
 904   }
 905
 906   inline void glRasterPos2fv (const GLfloat*  theVec)
 907   {
 908     ::glRasterPos2fv (theVec);
 909   }
 910
 911   inline void glRasterPos2iv (const GLint*    theVec)
 912   {
 913     ::glRasterPos2iv (theVec);
 914   }
 915
 916   inline void glRasterPos2sv (const GLshort*  theVec)
 917   {
 918     ::glRasterPos2sv (theVec);
 919   }
 920
 921   inline void glRasterPos3dv (const GLdouble* theVec)
 922   {
 923     ::glRasterPos3dv (theVec);
 924   }
 925
 926   inline void glRasterPos3fv (const GLfloat*  theVec)
 927   {
 928     ::glRasterPos3fv (theVec);
 929   }
 930
 931   inline void glRasterPos3iv (const GLint*    theVec)
 932   {
 933     ::glRasterPos3iv (theVec);
 934   }
 935
 936   inline void glRasterPos3sv (const GLshort*  theVec)
 937   {
 938     ::glRasterPos3sv (theVec);
 939   }
 940
 941   inline void glRasterPos4dv (const GLdouble* theVec)
 942   {
 943     ::glRasterPos4dv (theVec);
 944   }
 945
 946   inline void glRasterPos4fv (const GLfloat*  theVec)
 947   {
 948     ::glRasterPos4fv (theVec);
 949   }
 950
 951   inline void glRasterPos4iv (const GLint*    theVec)
 952   {
 953     ::glRasterPos4iv (theVec);
 954   }
 955
 956   inline void glRasterPos4sv (const GLshort*  theVec)
 957   {
 958     ::glRasterPos4sv (theVec);
 959   }
 960
 961   inline void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 962   {
 963     ::glRectd (x1, y1, x2, y2);
 964   }
 965
 966   inline void glRectf (GLfloat  x1, GLfloat  y1, GLfloat  x2, GLfloat  y2)
 967   {
 968     ::glRectf (x1, y1, x2, y2);
 969   }
 970
 971   inline void glRecti (GLint    x1, GLint    y1, GLint    x2, GLint    y2)
 972   {
 973     ::glRecti (x1, y1, x2, y2);
 974   }
 975
 976   inline void glRects (GLshort  x1, GLshort  y1, GLshort  x2, GLshort  y2)
 977   {
 978     ::glRects (x1, y1, x2, y2);
 979   }
 980
 981   inline void glRectdv (const GLdouble* v1, const GLdouble* v2)
 982   {
 983     ::glRectdv (v1, v2);
 984   }
 985
 986   inline void glRectfv (const GLfloat*  v1, const GLfloat*  v2)
 987   {
 988     ::glRectfv (v1, v2);
 989   }
 990
 991   inline void glRectiv (const GLint*    v1, const GLint*    v2)
 992   {
 993     ::glRectiv (v1, v2);
 994   }
 995
 996   inline void glRectsv (const GLshort*  v1, const GLshort*  v2)
 997   {
 998     ::glRectsv (v1, v2);
 999   }
1000
1001 public: //! @name Texture mapping (removed since 3.1)
1002
1003   inline void glTexGend (GLenum coord, GLenum pname, GLdouble param)
1004   {
1005     ::glTexGend (coord, pname, param);
1006   }
1007
1008   inline void glTexGenf (GLenum coord, GLenum pname, GLfloat param)
1009   {
1010     ::glTexGenf (coord, pname, param);
1011   }
1012
1013   inline void glTexGeni (GLenum coord, GLenum pname, GLint param)
1014   {
1015     ::glTexGeni (coord, pname, param);
1016   }
1017
1018   inline void glTexGendv (GLenum coord, GLenum pname, const GLdouble* params)
1019   {
1020     ::glTexGendv (coord, pname, params);
1021   }
1022
1023   inline void glTexGenfv (GLenum coord, GLenum pname, const GLfloat* params)
1024   {
1025     ::glTexGenfv (coord, pname, params);
1026   }
1027
1028   inline void glTexGeniv (GLenum coord, GLenum pname, const GLint* params)
1029   {
1030     ::glTexGeniv (coord, pname, params);
1031   }
1032
1033   inline void glGetTexGendv (GLenum coord, GLenum pname, GLdouble* params)
1034   {
1035     ::glGetTexGendv (coord, pname, params);
1036   }
1037
1038   inline void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat* params)
1039   {
1040     ::glGetTexGenfv (coord, pname, params);
1041   }
1042
1043   inline void glGetTexGeniv (GLenum coord, GLenum pname, GLint* params)
1044   {
1045     ::glGetTexGeniv (coord, pname, params);
1046   }
1047
1048 public: //! @name Resident textures and priorities (removed since 3.1)
1049
1050   inline void glPrioritizeTextures (GLsizei n, const GLuint* textures, const GLclampf* priorities)
1051   {
1052     ::glPrioritizeTextures (n, textures, priorities);
1053   }
1054
1055   inline GLboolean glAreTexturesResident (GLsizei n, const GLuint* textures, GLboolean* residences)
1056   {
1057     return ::glAreTexturesResident (n, textures, residences);
1058   }
1059
1060 public: //! @name Pixel copying (removed since 3.1)
1061
1062   inline void glDrawPixels (GLsizei width, GLsizei height,
1063                             GLenum format, GLenum type,
1064                             const GLvoid* pixels)
1065   {
1066     ::glDrawPixels (width, height, format, type, pixels);
1067   }
1068
1069   inline void glCopyPixels (GLint x, GLint y,
1070                     GLsizei width, GLsizei height,
1071                     GLenum type)
1072   {
1073     ::glCopyPixels (x, y, width, height, type);
1074   }
1075
1076   inline void glBitmap (GLsizei width, GLsizei height,
1077                         GLfloat xorig, GLfloat yorig,
1078                         GLfloat xmove, GLfloat ymove,
1079                         const GLubyte* bitmap)
1080   {
1081     ::glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap);
1082   }
1083
1084   inline void glPixelZoom (GLfloat xfactor, GLfloat yfactor)
1085   {
1086     ::glPixelZoom (xfactor, yfactor);
1087   }
1088
1089 public: //! @name Fog and all associated parameters (removed since 3.1)
1090
1091   inline void glFogf (GLenum pname, GLfloat param)
1092   {
1093     ::glFogf (pname, param);
1094   }
1095
1096   inline void glFogi (GLenum pname, GLint param)
1097   {
1098     ::glFogi (pname, param);
1099   }
1100
1101   inline void glFogfv (GLenum pname, const GLfloat* params)
1102   {
1103     ::glFogfv (pname, params);
1104   }
1105
1106   inline void glFogiv (GLenum pname, const GLint* params)
1107   {
1108     ::glFogiv (pname, params);
1109   }
1110
1111 public: //! @name Evaluators (removed since 3.1)
1112
1113   inline void glMap1d (GLenum target, GLdouble u1, GLdouble u2,
1114                        GLint stride,
1115                        GLint order, const GLdouble* points)
1116   {
1117     ::glMap1d (target, u1, u2, stride, order, points);
1118   }
1119
1120   inline void glMap1f (GLenum target, GLfloat u1, GLfloat u2,
1121                        GLint stride,
1122                        GLint order, const GLfloat* points)
1123   {
1124     ::glMap1f (target, u1, u2, stride, order, points);
1125   }
1126
1127   inline void glMap2d (GLenum target,
1128                        GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
1129                        GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
1130                        const GLdouble* points)
1131   {
1132     ::glMap2d (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1133   }
1134
1135   inline void glMap2f (GLenum target,
1136                        GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
1137                        GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
1138                        const GLfloat* points)
1139   {
1140     ::glMap2f (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
1141   }
1142
1143   inline void glGetMapdv (GLenum target, GLenum query, GLdouble* v)
1144   {
1145     ::glGetMapdv (target, query, v);
1146   }
1147
1148   inline void glGetMapfv (GLenum target, GLenum query, GLfloat* v)
1149   {
1150     ::glGetMapfv (target, query, v);
1151   }
1152
1153   inline void glGetMapiv (GLenum target, GLenum query, GLint* v)
1154   {
1155     ::glGetMapiv (target, query, v);
1156   }
1157
1158   inline void glEvalCoord1d (GLdouble u)
1159   {
1160     ::glEvalCoord1d (u);
1161   }
1162
1163   inline void glEvalCoord1f (GLfloat u)
1164   {
1165     ::glEvalCoord1f (u);
1166   }
1167
1168   inline void glEvalCoord1dv (const GLdouble* u)
1169   {
1170     ::glEvalCoord1dv (u);
1171   }
1172
1173   inline void glEvalCoord1fv (const GLfloat* u)
1174   {
1175     ::glEvalCoord1fv (u);
1176   }
1177
1178   inline void glEvalCoord2d (GLdouble u, GLdouble v)
1179   {
1180     ::glEvalCoord2d (u, v);
1181   }
1182
1183   inline void glEvalCoord2f (GLfloat u, GLfloat v)
1184   {
1185     ::glEvalCoord2f (u, v);
1186   }
1187
1188   inline void glEvalCoord2dv (const GLdouble* u)
1189   {
1190     ::glEvalCoord2dv (u);
1191   }
1192
1193   inline void glEvalCoord2fv (const GLfloat* u)
1194   {
1195     ::glEvalCoord2fv (u);
1196   }
1197
1198   inline void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
1199   {
1200     ::glMapGrid1d (un, u1, u2);
1201   }
1202
1203   inline void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
1204   {
1205     ::glMapGrid1f (un, u1, u2);
1206   }
1207
1208   inline void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2,
1209                            GLint vn, GLdouble v1, GLdouble v2)
1210   {
1211     ::glMapGrid2d (un, u1, u2, vn, v1, v2);
1212   }
1213
1214   inline void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2,
1215                            GLint vn, GLfloat v1, GLfloat v2)
1216   {
1217     ::glMapGrid2f (un, u1, u2, vn, v1, v2);
1218   }
1219
1220   inline void glEvalPoint1 (GLint i)
1221   {
1222     ::glEvalPoint1 (i);
1223   }
1224
1225   inline void glEvalPoint2 (GLint i, GLint j)
1226   {
1227     ::glEvalPoint2 (i, j);
1228   }
1229
1230   inline void glEvalMesh1 (GLenum mode, GLint i1, GLint i2)
1231   {
1232     ::glEvalMesh1 (mode, i1, i2);
1233   }
1234
1235   inline void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1236   {
1237     ::glEvalMesh2 (mode, i1, i2, j1, j2);
1238   }
1239
1240 public: //! @name Selection and feedback modes (removed since 3.1)
1241
1242   inline void glFeedbackBuffer (GLsizei theSize, GLenum theType, GLfloat* theBuffer)
1243   {
1244     ::glFeedbackBuffer (theSize, theType, theBuffer);
1245   }
1246
1247   inline void glPassThrough (GLfloat token)
1248   {
1249     ::glPassThrough (token);
1250   }
1251
1252   inline void glSelectBuffer (GLsizei theSize, GLuint* theBuffer)
1253   {
1254     ::glSelectBuffer (theSize, theBuffer);
1255   }
1256
1257   inline void glInitNames()
1258   {
1259     ::glInitNames();
1260   }
1261
1262   inline void glLoadName (GLuint theName)
1263   {
1264     ::glLoadName (theName);
1265   }
1266
1267   inline void glPushName (GLuint theName)
1268   {
1269     ::glPushName (theName);
1270   }
1271
1272   inline void glPopName()
1273   {
1274     ::glPopName();
1275   }
1276
1277 public: //! @name Accumulation Buffer (removed since 3.1)
1278
1279   inline void glClearAccum (GLfloat theRed, GLfloat theGreen, GLfloat theBlue, GLfloat theAlpha)
1280   {
1281     ::glClearAccum (theRed, theGreen, theBlue, theAlpha);
1282   }
1283
1284   inline void glAccum (GLenum theOp, GLfloat theValue)
1285   {
1286     ::glAccum (theOp, theValue);
1287   }
1288
1289 public: //! @name Edge flags and fixed-function vertex processing (removed since 3.1)
1290
1291   inline void glEdgeFlag (GLboolean theFlag)
1292   {
1293     ::glEdgeFlag (theFlag);
1294   }
1295
1296   inline void glEdgeFlagv (const GLboolean* theFlag)
1297   {
1298     ::glEdgeFlagv (theFlag);
1299   }
1300
1301   inline void glIndexPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
1302   {
1303     ::glIndexPointer (theType, theStride, thePtr);
1304   }
1305
1306   inline void glEdgeFlagPointer (GLsizei theStride, const GLvoid* thePtr)
1307   {
1308     ::glEdgeFlagPointer (theStride, thePtr);
1309   }
1310
1311   inline void glGetPointerv (GLenum pname, GLvoid** params)
1312   {
1313     ::glGetPointerv(pname, params);
1314   }
1315
1316   inline void glInterleavedArrays (GLenum theFormat, GLsizei theStride, const GLvoid* thePointer)
1317   {
1318     ::glInterleavedArrays (theFormat, theStride, thePointer);
1319   }
1320
1321   inline void glVertexPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
1322   {
1323     ::glVertexPointer (theSize, theType, theStride, thePtr);
1324   }
1325
1326   inline void glNormalPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
1327   {
1328     ::glNormalPointer (theType, theStride, thePtr);
1329   }
1330
1331   inline void glColorPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
1332   {
1333     ::glColorPointer (theSize, theType, theStride, thePtr);
1334   }
1335
1336   inline void glTexCoordPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
1337   {
1338     ::glTexCoordPointer (theSize, theType, theStride, thePtr);
1339   }
1340
1341   inline void glEnableClientState (GLenum theCap)
1342   {
1343     ::glEnableClientState (theCap);
1344   }
1345
1346   inline void glDisableClientState (GLenum theCap)
1347   {
1348     ::glDisableClientState (theCap);
1349   }
1350
1351 #endif
1352
1353 };
1354
1355 #endif // _OpenGl_GlCore11_Header