0025442: Visualization, TKOpenGl - prevent inclusion of system header glxext.h
[occt.git] / src / OpenGl / OpenGl_GlCore11Fwd.hxx
1 // Created on: 2014-03-17
2 // Created by: Kirill GAVRILOV
3 // Copyright (c) 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_GlCore11Fwd_Header
17 #define _OpenGl_GlCore11Fwd_Header
18
19 #include <OpenGl_GlFunctions.hxx>
20
21 //! OpenGL 1.1 core without deprecated Fixed Pipeline entry points.
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_GlCore11Fwd : protected OpenGl_GlFunctions
26 {
27
28 public: //! @name Miscellaneous
29
30   inline void glClearColor (GLclampf theRed, GLclampf theGreen, GLclampf theBlue, GLclampf theAlpha)
31   {
32     ::glClearColor  (theRed, theGreen, theBlue, theAlpha);
33   }
34
35   inline void glClear (GLbitfield theMask)
36   {
37     ::glClear (theMask);
38   }
39
40   inline void glColorMask (GLboolean theRed, GLboolean theGreen, GLboolean theBlue, GLboolean theAlpha)
41   {
42     ::glColorMask (theRed, theGreen, theBlue, theAlpha);
43   }
44
45   inline void glBlendFunc (GLenum sfactor, GLenum dfactor)
46   {
47     ::glBlendFunc(sfactor, dfactor);
48   }
49
50   inline void glCullFace (GLenum theMode)
51   {
52     ::glCullFace (theMode);
53   }
54
55   inline void glFrontFace (GLenum theMode)
56   {
57     ::glFrontFace (theMode);
58   }
59
60   inline void glLineWidth (GLfloat theWidth)
61   {
62     ::glLineWidth (theWidth);
63   }
64
65   inline void glPolygonOffset (GLfloat theFactor, GLfloat theUnits)
66   {
67     ::glPolygonOffset (theFactor, theUnits);
68   }
69
70   inline void glScissor (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
71   {
72     ::glScissor (theX, theY, theWidth, theHeight);
73   }
74
75   inline void glEnable (GLenum theCap)
76   {
77     ::glEnable (theCap);
78   }
79
80   inline void glDisable (GLenum theCap)
81   {
82     ::glDisable (theCap);
83   }
84
85   inline GLboolean glIsEnabled (GLenum theCap)
86   {
87     return ::glIsEnabled (theCap);
88   }
89
90   inline void glGetBooleanv (GLenum theParamName, GLboolean* theValues)
91   {
92     ::glGetBooleanv (theParamName, theValues);
93   }
94
95   inline void glGetFloatv (GLenum theParamName, GLfloat* theValues)
96   {
97     ::glGetFloatv (theParamName, theValues);
98   }
99
100   inline void glGetIntegerv (GLenum theParamName, GLint* theValues)
101   {
102     ::glGetIntegerv (theParamName, theValues);
103   }
104
105   inline GLenum glGetError()
106   {
107     return ::glGetError();
108   }
109
110   inline const GLubyte* glGetString (GLenum theName)
111   {
112     return ::glGetString (theName);
113   }
114
115   inline void glFinish()
116   {
117     ::glFinish();
118   }
119
120   inline void glFlush()
121   {
122     ::glFlush();
123   }
124
125   inline void glHint (GLenum theTarget, GLenum theMode)
126   {
127     ::glHint (theTarget, theMode);
128   }
129
130 public: //! @name Depth Buffer
131
132   inline void glClearDepth (GLclampd theDepth)
133   {
134   #if defined(GL_ES_VERSION_2_0)
135     ::glClearDepthf ((GLfloat )theDepth);
136   #else
137     ::glClearDepth (theDepth);
138   #endif
139   }
140
141   inline void glClearDepthf (GLfloat theDepth)
142   {
143   #if defined(GL_ES_VERSION_2_0)
144     ::glClearDepthf (theDepth);
145   #else
146     ::glClearDepth ((GLclampd )theDepth);
147   #endif
148   }
149
150   inline void glDepthFunc (GLenum theFunc)
151   {
152     ::glDepthFunc (theFunc);
153   }
154
155   inline void glDepthMask (GLboolean theFlag)
156   {
157     ::glDepthMask (theFlag);
158   }
159
160   inline void glDepthRange (GLclampd theNearValue,
161                             GLclampd theFarValue)
162   {
163   #if defined(GL_ES_VERSION_2_0)
164     ::glDepthRangef ((GLfloat )theNearValue, (GLfloat )theFarValue);
165   #else
166     ::glDepthRange (theNearValue, theFarValue);
167   #endif
168   }
169
170   inline void glDepthRangef (GLfloat theNearValue,
171                              GLfloat theFarValue)
172   {
173   #if defined(GL_ES_VERSION_2_0)
174     ::glDepthRangef (theNearValue, theFarValue);
175   #else
176     ::glDepthRange ((GLclampd )theNearValue, (GLclampd )theFarValue);
177   #endif
178   }
179
180 public: //! @name Transformation
181
182   inline void glViewport (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
183   {
184     ::glViewport (theX, theY, theWidth, theHeight);
185   }
186
187 public: //! @name Vertex Arrays
188
189   inline void glDrawArrays (GLenum theMode, GLint theFirst, GLsizei theCount)
190   {
191     ::glDrawArrays (theMode, theFirst, theCount);
192   }
193
194   inline void glDrawElements (GLenum theMode, GLsizei theCount, GLenum theType, const GLvoid* theIndices)
195   {
196     ::glDrawElements (theMode, theCount, theType, theIndices);
197   }
198
199 public: //! @name Raster functions
200
201   inline void glPixelStorei (GLenum theParamName, GLint   theParam)
202   {
203     ::glPixelStorei (theParamName, theParam);
204   }
205
206   inline void glReadPixels (GLint x, GLint y,
207                             GLsizei width, GLsizei height,
208                             GLenum format, GLenum type,
209                             GLvoid* pixels)
210   {
211     ::glReadPixels (x, y, width, height, format, type, pixels);
212   }
213
214 public: //! @name Stenciling
215
216   inline void glStencilFunc (GLenum func, GLint ref, GLuint mask)
217   {
218     ::glStencilFunc (func, ref, mask);
219   }
220
221   inline void glStencilMask (GLuint mask)
222   {
223     ::glStencilMask (mask);
224   }
225
226   inline void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
227   {
228     ::glStencilOp (fail, zfail, zpass);
229   }
230
231   inline void glClearStencil (GLint s)
232   {
233     ::glClearStencil (s);
234   }
235
236 public: //! @name Texture mapping
237
238   inline void glTexParameterf (GLenum target, GLenum pname, GLfloat param)
239   {
240     ::glTexParameterf (target, pname, param);
241   }
242
243   inline void glTexParameteri (GLenum target, GLenum pname, GLint param)
244   {
245     ::glTexParameteri (target, pname, param);
246   }
247
248   inline void glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params)
249   {
250     ::glTexParameterfv (target, pname, params);
251   }
252
253   inline void glTexParameteriv (GLenum target, GLenum pname, const GLint* params)
254   {
255     ::glTexParameteriv (target, pname, params);
256   }
257
258   inline void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params)
259   {
260     ::glGetTexParameterfv (target, pname, params);
261   }
262
263   inline void glGetTexParameteriv (GLenum target, GLenum pname, GLint* params)
264   {
265     ::glGetTexParameteriv (target, pname, params);
266   }
267
268   inline void glTexImage2D (GLenum target, GLint level,
269                             GLint internalFormat,
270                             GLsizei width, GLsizei height,
271                             GLint border, GLenum format, GLenum type,
272                             const GLvoid* pixels)
273   {
274     ::glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
275   }
276
277   inline void glGenTextures (GLsizei n, GLuint* textures)
278   {
279     ::glGenTextures(n, textures);
280   }
281
282   inline void glDeleteTextures (GLsizei n, const GLuint* textures)
283   {
284     ::glDeleteTextures(n, textures);
285   }
286
287   inline void glBindTexture (GLenum target, GLuint texture)
288   {
289     ::glBindTexture(target, texture);
290   }
291
292   inline GLboolean glIsTexture (GLuint texture)
293   {
294     return ::glIsTexture (texture);
295   }
296
297   inline void glTexSubImage2D (GLenum target, GLint level,
298                                GLint xoffset, GLint yoffset,
299                                GLsizei width, GLsizei height,
300                                GLenum format, GLenum type,
301                                const GLvoid* pixels)
302   {
303     ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
304   }
305
306   inline void glCopyTexImage2D (GLenum target, GLint level,
307                                 GLenum internalformat,
308                                 GLint x, GLint y,
309                                 GLsizei width, GLsizei height,
310                                 GLint border)
311   {
312     ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
313   }
314
315   inline void glCopyTexSubImage2D (GLenum target, GLint level,
316                                    GLint xoffset, GLint yoffset,
317                                    GLint x, GLint y,
318                                    GLsizei width, GLsizei height)
319   {
320     ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
321   }
322
323 #if !defined(GL_ES_VERSION_2_0)
324   inline void glTexImage1D (GLenum target, GLint level,
325                             GLint internalFormat,
326                             GLsizei width, GLint border,
327                             GLenum format, GLenum type,
328                             const GLvoid* pixels)
329   {
330     ::glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
331   }
332
333   inline void glTexSubImage1D (GLenum target, GLint level,
334                                GLint xoffset,
335                                GLsizei width, GLenum format,
336                                GLenum type, const GLvoid* pixels)
337   {
338     ::glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
339   }
340
341   inline void glCopyTexImage1D (GLenum target, GLint level,
342                                 GLenum internalformat,
343                                 GLint x, GLint y,
344                                 GLsizei width, GLint border)
345   {
346     ::glCopyTexImage1D(target, level, internalformat, x, y, width, border);
347   }
348
349   inline void glCopyTexSubImage1D (GLenum target, GLint level,
350                                    GLint xoffset, GLint x, GLint y,
351                                    GLsizei width)
352   {
353     ::glCopyTexSubImage1D(target, level, xoffset, x, y, width);
354   }
355 #endif
356
357 #if !defined(GL_ES_VERSION_2_0)
358
359   inline void glAlphaFunc (GLenum theFunc, GLclampf theRef)
360   {
361     ::glAlphaFunc (theFunc, theRef);
362   }
363
364   inline void glPointSize (GLfloat theSize)
365   {
366     ::glPointSize (theSize);
367   }
368
369 #endif
370
371 /*#if !defined(GL_ES_VERSION_2_0)
372
373   inline void glTexEnvf (GLenum target, GLenum pname, GLfloat param)
374   {
375     ::glTexEnvf (target, pname, param);
376   }
377
378   inline void glTexEnvi (GLenum target, GLenum pname, GLint param)
379   {
380     ::glTexEnvi (target, pname, param);
381   }
382
383   inline void glTexEnvfv (GLenum target, GLenum pname, const GLfloat* params)
384   {
385     ::glTexEnvfv (target, pname, params);
386   }
387
388   inline void glTexEnviv (GLenum target, GLenum pname, const GLint* params)
389   {
390     ::glTexEnviv (target, pname, params);
391   }
392
393   inline void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat* params)
394   {
395     ::glGetTexEnvfv (target, pname, params);
396   }
397
398   inline void glGetTexEnviv (GLenum target, GLenum pname, GLint* params)
399   {
400     ::glGetTexEnviv (target, pname, params);
401   }
402
403   inline void glGetTexImage (GLenum target, GLint level,
404                              GLenum format, GLenum type,
405                              GLvoid* pixels)
406   {
407     ::glGetTexImage(target, level, format, type, pixels);
408   }
409
410   inline void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat* params)
411   {
412     ::glGetTexLevelParameterfv (target, level, pname, params);
413   }
414
415   inline void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint* params)
416   {
417     ::glGetTexLevelParameteriv (target, level, pname, params);
418   }
419
420   inline void glClearIndex (GLfloat c)
421   {
422     ::glClearIndex(c);
423   }
424
425   inline void glIndexMask (GLuint theMask)
426   {
427     ::glIndexMask (theMask);
428   }
429
430   inline void glLogicOp (GLenum opcode)
431   {
432     ::glLogicOp(opcode);
433   }
434
435   inline void glPolygonMode (GLenum theFace, GLenum theMode)
436   {
437     ::glPolygonMode (theFace, theMode);
438   }
439
440   inline void glDrawBuffer (GLenum theMode)
441   {
442     ::glDrawBuffer (theMode);
443   }
444
445   inline void glReadBuffer (GLenum theMode)
446   {
447     ::glReadBuffer (theMode);
448   }
449
450   inline void glGetDoublev (GLenum theParamName, GLdouble* theValues)
451   {
452     ::glGetDoublev (theParamName, theValues);
453   }
454
455   inline GLint glRenderMode (GLenum theMode)
456   {
457     return ::glRenderMode (theMode);
458   }
459
460   inline void glArrayElement (GLint i)
461   {
462     ::glArrayElement (i);
463   }
464
465   inline void glPixelStoref (GLenum theParamName, GLfloat theParam)
466   {
467     ::glPixelStoref (theParamName, theParam);
468   }
469
470   inline void glPixelTransferf (GLenum theParamName, GLfloat theParam)
471   {
472     ::glPixelTransferf (theParamName, theParam);
473   }
474
475   inline void glPixelTransferi (GLenum theParamName, GLint   theParam)
476   {
477     ::glPixelTransferi (theParamName, theParam);
478   }
479
480   inline void glPixelMapfv  (GLenum map, GLsizei mapsize, const GLfloat*  values)
481   {
482     ::glPixelMapfv (map, mapsize, values);
483   }
484
485   inline void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint*   values)
486   {
487     ::glPixelMapuiv (map, mapsize, values);
488   }
489
490   inline void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort* values)
491   {
492     ::glPixelMapusv (map, mapsize, values);
493   }
494
495   inline void glGetPixelMapfv  (GLenum map, GLfloat*  values)
496   {
497     ::glGetPixelMapfv (map, values);
498   }
499
500   inline void glGetPixelMapuiv (GLenum map, GLuint*   values)
501   {
502     ::glGetPixelMapuiv (map, values);
503   }
504
505   inline void glGetPixelMapusv (GLenum map, GLushort* values)
506   {
507     ::glGetPixelMapusv (map, values);
508   }
509 #endif*/
510
511 };
512
513 #endif // _OpenGl_GlCore11Fwd_Header