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 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
 180 public: //! @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
 202 public: //! @name Transformation
 203
 204   inline void glViewport (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
 205   {
 206     ::glViewport (theX, theY, theWidth, theHeight);
 207   }
 208
 209 public: //! @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
 226 public: //! @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
 286 public: //! @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
 308 public: //! @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