0030748: Visualization - Marker displayed in immediate layer ruins QT Quick view...
[occt.git] / src / OpenGl / OpenGl_GlCore11.hxx
CommitLineData
6aca4d39 1// Created on: 2012-03-06
b311480e 2// Created by: Kirill GAVRILOV
6aca4d39 3// Copyright (c) 2012-2014 OPEN CASCADE SAS
b311480e 4//
973c2be1 5// This file is part of Open CASCADE Technology software library.
b311480e 6//
d5f74e42 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
973c2be1 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.
b311480e 12//
973c2be1 13// Alternatively, this file may be used under the terms of Open CASCADE
14// commercial license or contractual agreement.
5f8b738e 15
01ca42b2 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!).
25struct OpenGl_GlCore11 : protected OpenGl_GlFunctions
26{
27
ca3c13d1 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
01ca42b2 45public: //! @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
597public: //! @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
01ca42b2 653public: //! @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
672public: //! @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
694public: //! @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
786public: //! @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
798public: //! @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
839public: //! @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
1001public: //! @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
1048public: //! @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
1060public: //! @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
1089public: //! @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
1111public: //! @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
1240public: //! @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
1277public: //! @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
1289public: //! @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
ca3c13d1 1301 inline void glIndexPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1302 {
ca3c13d1 1303 ::glIndexPointer (theType, theStride, thePtr);
01ca42b2 1304 }
1305
ca3c13d1 1306 inline void glEdgeFlagPointer (GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1307 {
ca3c13d1 1308 ::glEdgeFlagPointer (theStride, thePtr);
01ca42b2 1309 }
1310
ca3c13d1 1311 inline void glGetPointerv (GLenum pname, GLvoid** params)
01ca42b2 1312 {
ca3c13d1 1313 ::glGetPointerv(pname, params);
01ca42b2 1314 }
1315
ca3c13d1 1316 inline void glInterleavedArrays (GLenum theFormat, GLsizei theStride, const GLvoid* thePointer)
01ca42b2 1317 {
ca3c13d1 1318 ::glInterleavedArrays (theFormat, theStride, thePointer);
01ca42b2 1319 }
1320
ca3c13d1 1321 inline void glVertexPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1322 {
ca3c13d1 1323 ::glVertexPointer (theSize, theType, theStride, thePtr);
01ca42b2 1324 }
1325
ca3c13d1 1326 inline void glNormalPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1327 {
ca3c13d1 1328 ::glNormalPointer (theType, theStride, thePtr);
01ca42b2 1329 }
1330
ca3c13d1 1331 inline void glColorPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1332 {
ca3c13d1 1333 ::glColorPointer (theSize, theType, theStride, thePtr);
01ca42b2 1334 }
1335
ca3c13d1 1336 inline void glTexCoordPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
01ca42b2 1337 {
ca3c13d1 1338 ::glTexCoordPointer (theSize, theType, theStride, thePtr);
01ca42b2 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
ca3c13d1 1351#endif
1352
01ca42b2 1353};
1354
1355#endif // _OpenGl_GlCore11_Header