0027961: Visualization - remove unused and no more working OpenGl_AVIWriter
[occt.git] / 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