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