0024732: OpenGl_Context - retrieve functions up to GL4.4
authorkgv <kgv@opencascade.com>
Thu, 20 Mar 2014 09:50:28 +0000 (13:50 +0400)
committerbugmaster <bugmaster@opencascade.com>
Thu, 20 Mar 2014 09:51:05 +0000 (13:51 +0400)
Drop unused OpenGl_ArbVBO.
Replace OpenGl_ExtFBO with OpenGl_ArbFBO.

OpenGl_Context - reorganize GL functions management.
OpenGl_GlFunctions structure now stores pointers for all GL functions,
while inheritors specify functions subset using access levels.
Drop fields core12, core13, core14; replace extFBO by arbFBO.

OpenGl_ArbIns, OpenGl_ArbTBO - use GL3.1 core functions
instead of ARB extensions when available.

OpenGl_ArbFBO - provide complete list of functions

OpenGl_GlCore11 - fix misprint

OpenGl_Context.hxx - remove redundant declarations

34 files changed:
src/OpenGl/FILES
src/OpenGl/OpenGl_ArbDbg.hxx
src/OpenGl/OpenGl_ArbFBO.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_ArbIns.hxx
src/OpenGl/OpenGl_ArbTBO.hxx
src/OpenGl/OpenGl_ArbVBO.hxx [deleted file]
src/OpenGl/OpenGl_Context.cxx
src/OpenGl/OpenGl_Context.hxx
src/OpenGl/OpenGl_ExtFBO.hxx [deleted file]
src/OpenGl/OpenGl_ExtGS.hxx
src/OpenGl/OpenGl_FrameBuffer.cxx
src/OpenGl/OpenGl_FrameBuffer.hxx
src/OpenGl/OpenGl_GlCore11.hxx
src/OpenGl/OpenGl_GlCore11Fwd.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore12.hxx
src/OpenGl/OpenGl_GlCore13.hxx
src/OpenGl/OpenGl_GlCore14.hxx
src/OpenGl/OpenGl_GlCore15.hxx
src/OpenGl/OpenGl_GlCore20.hxx
src/OpenGl/OpenGl_GlCore21.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore30.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore31.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore32.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore33.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore40.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore41.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore42.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore43.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlCore44.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_GlFunctions.hxx [new file with mode: 0644]
src/OpenGl/OpenGl_Text.cxx
src/OpenGl/OpenGl_Texture.cxx
src/OpenGl/OpenGl_TextureBufferArb.cxx
src/ViewerTest/ViewerTest_OpenGlCommands.cxx

index f94652a..8494c66 100755 (executable)
@@ -89,17 +89,28 @@ OpenGl_Context.cxx
 OpenGl_Context_1.mm
 OpenGl_ArbIns.hxx
 OpenGl_ArbTBO.hxx
-OpenGl_ArbVBO.hxx
 OpenGl_ArbDbg.hxx
-OpenGl_ExtFBO.hxx
+OpenGl_ArbFBO.hxx
 OpenGl_ExtGS.hxx
 glext.h
+OpenGl_GlFunctions.hxx
 OpenGl_GlCore11.hxx
+OpenGl_GlCore11Fwd.hxx
 OpenGl_GlCore12.hxx
 OpenGl_GlCore13.hxx
 OpenGl_GlCore14.hxx
 OpenGl_GlCore15.hxx
 OpenGl_GlCore20.hxx
+OpenGl_GlCore21.hxx
+OpenGl_GlCore30.hxx
+OpenGl_GlCore31.hxx
+OpenGl_GlCore32.hxx
+OpenGl_GlCore33.hxx
+OpenGl_GlCore40.hxx
+OpenGl_GlCore41.hxx
+OpenGl_GlCore42.hxx
+OpenGl_GlCore43.hxx
+OpenGl_GlCore44.hxx
 OpenGl_LayerList.cxx
 OpenGl_LayerList.hxx
 OpenGl_IndexBuffer.hxx
index 11e98ea..d73c7a5 100755 (executable)
 #ifndef _OpenGl_ArbDbg_H__
 #define _OpenGl_ArbDbg_H__
 
-#include <OpenGl_GlCore12.hxx>
+#include <OpenGl_GlFunctions.hxx>
 
 //! Debug context routines
-struct OpenGl_ArbDbg
+struct OpenGl_ArbDbg : protected OpenGl_GlFunctions
 {
 
-  PFNGLDEBUGMESSAGECONTROLARBPROC  glDebugMessageControlARB;
-  PFNGLDEBUGMESSAGEINSERTARBPROC   glDebugMessageInsertARB;
-  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARB;
-  PFNGLGETDEBUGMESSAGELOGARBPROC   glGetDebugMessageLogARB;
+  using OpenGl_GlFunctions::glDebugMessageControlARB;
+  using OpenGl_GlFunctions::glDebugMessageInsertARB;
+  using OpenGl_GlFunctions::glDebugMessageCallbackARB;
+  using OpenGl_GlFunctions::glGetDebugMessageLogARB;
 
 };
 
diff --git a/src/OpenGl/OpenGl_ArbFBO.hxx b/src/OpenGl/OpenGl_ArbFBO.hxx
new file mode 100644 (file)
index 0000000..638d0c2
--- /dev/null
@@ -0,0 +1,48 @@
+// Created on: 2012-01-26
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2012-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_ArbFBO_H__
+#define _OpenGl_ArbFBO_H__
+
+#include <OpenGl_GlFunctions.hxx>
+
+//! FBO is available on OpenGL 2.0+ hardware
+struct OpenGl_ArbFBO : protected OpenGl_GlFunctions
+{
+
+  using OpenGl_GlFunctions::glIsRenderbuffer;
+  using OpenGl_GlFunctions::glBindRenderbuffer;
+  using OpenGl_GlFunctions::glDeleteRenderbuffers;
+  using OpenGl_GlFunctions::glGenRenderbuffers;
+  using OpenGl_GlFunctions::glRenderbufferStorage;
+  using OpenGl_GlFunctions::glGetRenderbufferParameteriv;
+  using OpenGl_GlFunctions::glIsFramebuffer;
+  using OpenGl_GlFunctions::glBindFramebuffer;
+  using OpenGl_GlFunctions::glDeleteFramebuffers;
+  using OpenGl_GlFunctions::glGenFramebuffers;
+  using OpenGl_GlFunctions::glCheckFramebufferStatus;
+  using OpenGl_GlFunctions::glFramebufferTexture1D;
+  using OpenGl_GlFunctions::glFramebufferTexture2D;
+  using OpenGl_GlFunctions::glFramebufferTexture3D;
+  using OpenGl_GlFunctions::glFramebufferRenderbuffer;
+  using OpenGl_GlFunctions::glGetFramebufferAttachmentParameteriv;
+  using OpenGl_GlFunctions::glGenerateMipmap;
+  using OpenGl_GlFunctions::glBlitFramebuffer;
+  using OpenGl_GlFunctions::glRenderbufferStorageMultisample;
+  using OpenGl_GlFunctions::glFramebufferTextureLayer;
+
+};
+
+#endif // _OpenGl_ArbFBO_H__
index 4ab923c..39863a6 100644 (file)
 #ifndef _OpenGl_ArbIns_H__
 #define _OpenGl_ArbIns_H__
 
-#include <OpenGl_GlCore12.hxx>
+#include <OpenGl_GlFunctions.hxx>
 
-//! TBO is available on OpenGL 3.0+ hardware
-struct OpenGl_ArbIns
+//! Instancing is available on OpenGL 3.0+ hardware
+struct OpenGl_ArbIns : protected OpenGl_GlFunctions
 {
 
-  PFNGLDRAWARRAYSINSTANCEDARBPROC   glDrawArraysInstancedARB;
-  PFNGLDRAWELEMENTSINSTANCEDARBPROC glDrawElementsInstancedARB;
+  using OpenGl_GlFunctions::glDrawArraysInstanced;
+  using OpenGl_GlFunctions::glDrawElementsInstanced;
 
 };
 
index f2e91ac..34ef3c2 100644 (file)
 #ifndef _OpenGl_ArbTBO_H__
 #define _OpenGl_ArbTBO_H__
 
-#include <OpenGl_GlCore12.hxx>
+#include <OpenGl_GlFunctions.hxx>
 
 //! TBO is available on OpenGL 3.0+ hardware
-struct OpenGl_ArbTBO
+struct OpenGl_ArbTBO : protected OpenGl_GlFunctions
 {
 
-  PFNGLTEXBUFFERARBPROC glTexBufferARB;
+  using OpenGl_GlFunctions::glTexBuffer;
 
 };
 
diff --git a/src/OpenGl/OpenGl_ArbVBO.hxx b/src/OpenGl/OpenGl_ArbVBO.hxx
deleted file mode 100644 (file)
index f851471..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-// Created on: 2012-01-26
-// Created by: Kirill GAVRILOV
-// Copyright (c) 2012-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _OpenGl_ArbVBO_H__
-#define _OpenGl_ArbVBO_H__
-
-#include <OpenGl_GlCore12.hxx>
-
-//! VBO is part of OpenGL since 1.5
-struct OpenGl_ArbVBO
-{
-
-  PFNGLGENBUFFERSARBPROC    glGenBuffersARB;
-  PFNGLBINDBUFFERARBPROC    glBindBufferARB;
-  PFNGLBUFFERDATAARBPROC    glBufferDataARB;
-  PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB;
-
-};
-
-#endif // _OpenGl_ArbVBO_H__
index 514ef1b..fcbd347 100644 (file)
 
 #include <OpenGl_Context.hxx>
 
-#include <OpenGl_ArbVBO.hxx>
 #include <OpenGl_ArbTBO.hxx>
 #include <OpenGl_ArbIns.hxx>
 #include <OpenGl_ArbDbg.hxx>
-#include <OpenGl_ExtFBO.hxx>
+#include <OpenGl_ArbFBO.hxx>
 #include <OpenGl_ExtGS.hxx>
 #include <OpenGl_GlCore20.hxx>
 #include <OpenGl_ShaderManager.hxx>
 IMPLEMENT_STANDARD_HANDLE (OpenGl_Context, Standard_Transient)
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context, Standard_Transient)
 
-//! Make record shorter to retrieve function pointer using variable with same name
-#define FindProcShort(theStruct, theFunc) FindProc(#theFunc, theStruct->theFunc)
-
 namespace
 {
   static const Handle(OpenGl_Resource) NULL_GL_RESOURCE;
   static const GLdouble OpenGl_DefaultPlaneEq[] = {0.0, 0.0, 0.0, 0.0};
-};
+}
 
 // =======================================================================
 // function : OpenGl_Context
 // purpose  :
 // =======================================================================
 OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
-: core12 (NULL),
-  core13 (NULL),
-  core14 (NULL),
-  core15 (NULL),
-  core20 (NULL),
+: core11     (NULL),
+  core11fwd  (NULL),
+  core15     (NULL),
+  core15fwd  (NULL),
+  core20     (NULL),
+  core20fwd  (NULL),
+  core32     (NULL),
+  core32back (NULL),
+  core41     (NULL),
+  core41back (NULL),
+  core42     (NULL),
+  core42back (NULL),
+  core43     (NULL),
+  core43back (NULL),
+  core44     (NULL),
+  core44back (NULL),
   caps   (!theCaps.IsNull() ? theCaps : new OpenGl_Caps()),
   arbNPTW(Standard_False),
-  arbVBO (NULL),
   arbTBO (NULL),
   arbIns (NULL),
   arbDbg (NULL),
-  extFBO (NULL),
+  arbFBO (NULL),
   extGS  (NULL),
   extBgra(Standard_False),
   extAnis(Standard_False),
@@ -94,7 +100,7 @@ OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
   myReleaseQueue    (new OpenGl_ResourcesQueue()),
   myClippingState (),
   myGlLibHandle (NULL),
-  myGlCore20 (NULL),
+  myFuncs (new OpenGl_GlFunctions()),
   myAnisoMax   (1),
   myMaxTexDim  (1024),
   myMaxClipPlanes (6),
@@ -117,7 +123,7 @@ OpenGl_Context::OpenGl_Context (const Handle(OpenGl_Caps)& theCaps)
   // (depends on renderer).
   myGlLibHandle = dlopen ("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
 #endif
-
+  memset (myFuncs.operator->(), 0, sizeof(OpenGl_GlFunctions));
   myShaderManager = new OpenGl_ShaderManager (this);
 }
 
@@ -159,14 +165,6 @@ OpenGl_Context::~OpenGl_Context()
       arbDbg->glDebugMessageCallbackARB (NULL, NULL);
     }
   }
-
-  delete myGlCore20;
-  delete arbVBO;
-  delete arbTBO;
-  delete arbIns;
-  delete arbDbg;
-  delete extFBO;
-  delete extGS;
 }
 
 // =======================================================================
@@ -710,11 +708,11 @@ void OpenGl_Context::PushMessage (const unsigned int theSource,
 {
   //OpenGl_Context* aCtx = (OpenGl_Context* )theUserParam;
   Standard_CString& aSrc = (theSource >= GL_DEBUG_SOURCE_API_ARB
-                         && theSource <= GL_DEBUG_SOURCE_OTHER_ARB)
+                        && theSource <= GL_DEBUG_SOURCE_OTHER_ARB)
                          ? THE_DBGMSG_SOURCES[theSource - GL_DEBUG_SOURCE_API_ARB]
                          : THE_DBGMSG_UNKNOWN;
   Standard_CString& aType = (theType >= GL_DEBUG_TYPE_ERROR_ARB
-                          && theType <= GL_DEBUG_TYPE_OTHER_ARB)
+                         && theType <= GL_DEBUG_TYPE_OTHER_ARB)
                           ? THE_DBGMSG_TYPES[theType - GL_DEBUG_TYPE_ERROR_ARB]
                           : THE_DBGMSG_UNKNOWN;
   Standard_CString& aSev = theSeverity == GL_DEBUG_SEVERITY_HIGH_ARB
@@ -748,6 +746,28 @@ void OpenGl_Context::init()
   // read version
   readGlVersion();
 
+  core11     = (OpenGl_GlCore11*    )(&(*myFuncs));
+  core11fwd  = (OpenGl_GlCore11Fwd* )(&(*myFuncs));
+  core15     = NULL;
+  core15fwd  = NULL;
+  core20     = NULL;
+  core20fwd  = NULL;
+  core32     = NULL;
+  core32back = NULL;
+  core41     = NULL;
+  core41back = NULL;
+  core42     = NULL;
+  core42back = NULL;
+  core43     = NULL;
+  core43back = NULL;
+  core44     = NULL;
+  core44back = NULL;
+  arbTBO     = NULL;
+  arbIns     = NULL;
+  arbDbg     = NULL;
+  arbFBO     = NULL;
+  extGS      = NULL;
+
   arbNPTW = CheckExtension ("GL_ARB_texture_non_power_of_two");
   extBgra = CheckExtension ("GL_EXT_bgra");
   extAnis = CheckExtension ("GL_EXT_texture_filter_anisotropic");
@@ -770,18 +790,66 @@ void OpenGl_Context::init()
 
   myClippingState.Init (myMaxClipPlanes);
 
+  bool has12 = false;
+  bool has13 = false;
+  bool has14 = false;
+  bool has15 = false;
+  bool has20 = false;
+  bool has21 = false;
+  bool has30 = false;
+  bool has31 = false;
+  bool has32 = false;
+  bool has33 = false;
+  bool has40 = false;
+  bool has41 = false;
+  bool has42 = false;
+  bool has43 = false;
+  bool has44 = false;
+
+  //! Make record shorter to retrieve function pointer using variable with same name
+  #define FindProcShort(theFunc) FindProc(#theFunc, myFuncs->theFunc)
+
+    // retrieve platform-dependent extensions
+#ifdef _WIN32
+  if (FindProcShort (wglGetExtensionsStringARB))
+  {
+    const char* aWglExts = myFuncs->wglGetExtensionsStringARB (wglGetCurrentDC());
+    if (CheckExtension (aWglExts, "WGL_EXT_swap_control"))
+    {
+      FindProcShort (wglSwapIntervalEXT);
+    }
+    if (CheckExtension (aWglExts, "WGL_ARB_pixel_format"))
+    {
+      FindProcShort (wglChoosePixelFormatARB);
+    }
+    if (CheckExtension (aWglExts, "WGL_ARB_create_context_profile"))
+    {
+      FindProcShort (wglCreateContextAttribsARB);
+    }
+    if (CheckExtension (aWglExts, "WGL_NV_DX_interop"))
+    {
+      FindProcShort (wglDXSetResourceShareHandleNV);
+      FindProcShort (wglDXOpenDeviceNV);
+      FindProcShort (wglDXCloseDeviceNV);
+      FindProcShort (wglDXRegisterObjectNV);
+      FindProcShort (wglDXUnregisterObjectNV);
+      FindProcShort (wglDXObjectAccessNV);
+      FindProcShort (wglDXLockObjectsNV);
+      FindProcShort (wglDXUnlockObjectsNV);
+    }
+  }
+#endif
+
   // initialize debug context extension
   if (CheckExtension ("GL_ARB_debug_output"))
   {
-    arbDbg = new OpenGl_ArbDbg();
-    memset (arbDbg, 0, sizeof(OpenGl_ArbDbg)); // nullify whole structure
-    if (!FindProcShort (arbDbg, glDebugMessageControlARB)
-     || !FindProcShort (arbDbg, glDebugMessageInsertARB)
-     || !FindProcShort (arbDbg, glDebugMessageCallbackARB)
-     || !FindProcShort (arbDbg, glGetDebugMessageLogARB))
+    arbDbg = NULL;
+    if (FindProcShort (glDebugMessageControlARB)
+     && FindProcShort (glDebugMessageInsertARB)
+     && FindProcShort (glDebugMessageCallbackARB)
+     && FindProcShort (glGetDebugMessageLogARB))
     {
-      delete arbDbg;
-      arbDbg = NULL;
+      arbDbg = (OpenGl_ArbDbg* )(&(*myFuncs));
     }
     if (arbDbg != NULL
      && caps->contextDebug)
@@ -794,319 +862,880 @@ void OpenGl_Context::init()
     }
   }
 
-  // initialize VBO extension (ARB)
-  if (CheckExtension ("GL_ARB_vertex_buffer_object"))
+  // load OpenGL 1.2 new functions
+  has12 = IsGlGreaterEqual (1, 2)
+       && FindProcShort (glBlendColor)
+       && FindProcShort (glBlendEquation)
+       && FindProcShort (glDrawRangeElements)
+       && FindProcShort (glTexImage3D)
+       && FindProcShort (glTexSubImage3D)
+       && FindProcShort (glCopyTexSubImage3D);
+
+  // load OpenGL 1.3 new functions
+  has13 = IsGlGreaterEqual (1, 3)
+       && FindProcShort (glActiveTexture)
+       && FindProcShort (glSampleCoverage)
+       && FindProcShort (glCompressedTexImage3D)
+       && FindProcShort (glCompressedTexImage2D)
+       && FindProcShort (glCompressedTexImage1D)
+       && FindProcShort (glCompressedTexSubImage3D)
+       && FindProcShort (glCompressedTexSubImage2D)
+       && FindProcShort (glCompressedTexSubImage1D)
+       && FindProcShort (glGetCompressedTexImage)
+       && FindProcShort (glClientActiveTexture)
+       && FindProcShort (glMultiTexCoord1d)
+       && FindProcShort (glMultiTexCoord1dv)
+       && FindProcShort (glMultiTexCoord1f)
+       && FindProcShort (glMultiTexCoord1fv)
+       && FindProcShort (glMultiTexCoord1i)
+       && FindProcShort (glMultiTexCoord1iv)
+       && FindProcShort (glMultiTexCoord1s)
+       && FindProcShort (glMultiTexCoord1sv)
+       && FindProcShort (glMultiTexCoord2d)
+       && FindProcShort (glMultiTexCoord2dv)
+       && FindProcShort (glMultiTexCoord2f)
+       && FindProcShort (glMultiTexCoord2fv)
+       && FindProcShort (glMultiTexCoord2i)
+       && FindProcShort (glMultiTexCoord2iv)
+       && FindProcShort (glMultiTexCoord2s)
+       && FindProcShort (glMultiTexCoord2sv)
+       && FindProcShort (glMultiTexCoord3d)
+       && FindProcShort (glMultiTexCoord3dv)
+       && FindProcShort (glMultiTexCoord3f)
+       && FindProcShort (glMultiTexCoord3fv)
+       && FindProcShort (glMultiTexCoord3i)
+       && FindProcShort (glMultiTexCoord3iv)
+       && FindProcShort (glMultiTexCoord3s)
+       && FindProcShort (glMultiTexCoord3sv)
+       && FindProcShort (glMultiTexCoord4d)
+       && FindProcShort (glMultiTexCoord4dv)
+       && FindProcShort (glMultiTexCoord4f)
+       && FindProcShort (glMultiTexCoord4fv)
+       && FindProcShort (glMultiTexCoord4i)
+       && FindProcShort (glMultiTexCoord4iv)
+       && FindProcShort (glMultiTexCoord4s)
+       && FindProcShort (glMultiTexCoord4sv)
+       && FindProcShort (glLoadTransposeMatrixf)
+       && FindProcShort (glLoadTransposeMatrixd)
+       && FindProcShort (glMultTransposeMatrixf)
+       && FindProcShort (glMultTransposeMatrixd);
+
+  // load OpenGL 1.4 new functions
+  has14 = IsGlGreaterEqual (1, 4)
+       && FindProcShort (glBlendFuncSeparate)
+       && FindProcShort (glMultiDrawArrays)
+       && FindProcShort (glMultiDrawElements)
+       && FindProcShort (glPointParameterf)
+       && FindProcShort (glPointParameterfv)
+       && FindProcShort (glPointParameteri)
+       && FindProcShort (glPointParameteriv);
+
+  // load OpenGL 1.5 new functions
+  has15 = IsGlGreaterEqual (1, 5)
+       && FindProcShort (glGenQueries)
+       && FindProcShort (glDeleteQueries)
+       && FindProcShort (glIsQuery)
+       && FindProcShort (glBeginQuery)
+       && FindProcShort (glEndQuery)
+       && FindProcShort (glGetQueryiv)
+       && FindProcShort (glGetQueryObjectiv)
+       && FindProcShort (glGetQueryObjectuiv)
+       && FindProcShort (glBindBuffer)
+       && FindProcShort (glDeleteBuffers)
+       && FindProcShort (glGenBuffers)
+       && FindProcShort (glIsBuffer)
+       && FindProcShort (glBufferData)
+       && FindProcShort (glBufferSubData)
+       && FindProcShort (glGetBufferSubData)
+       && FindProcShort (glMapBuffer)
+       && FindProcShort (glUnmapBuffer)
+       && FindProcShort (glGetBufferParameteriv)
+       && FindProcShort (glGetBufferPointerv);
+
+  // load OpenGL 2.0 new functions
+  has20 = IsGlGreaterEqual (2, 0)
+       && FindProcShort (glBlendEquationSeparate)
+       && FindProcShort (glDrawBuffers)
+       && FindProcShort (glStencilOpSeparate)
+       && FindProcShort (glStencilFuncSeparate)
+       && FindProcShort (glStencilMaskSeparate)
+       && FindProcShort (glAttachShader)
+       && FindProcShort (glBindAttribLocation)
+       && FindProcShort (glCompileShader)
+       && FindProcShort (glCreateProgram)
+       && FindProcShort (glCreateShader)
+       && FindProcShort (glDeleteProgram)
+       && FindProcShort (glDeleteShader)
+       && FindProcShort (glDetachShader)
+       && FindProcShort (glDisableVertexAttribArray)
+       && FindProcShort (glEnableVertexAttribArray)
+       && FindProcShort (glGetActiveAttrib)
+       && FindProcShort (glGetActiveUniform)
+       && FindProcShort (glGetAttachedShaders)
+       && FindProcShort (glGetAttribLocation)
+       && FindProcShort (glGetProgramiv)
+       && FindProcShort (glGetProgramInfoLog)
+       && FindProcShort (glGetShaderiv)
+       && FindProcShort (glGetShaderInfoLog)
+       && FindProcShort (glGetShaderSource)
+       && FindProcShort (glGetUniformLocation)
+       && FindProcShort (glGetUniformfv)
+       && FindProcShort (glGetUniformiv)
+       && FindProcShort (glGetVertexAttribdv)
+       && FindProcShort (glGetVertexAttribfv)
+       && FindProcShort (glGetVertexAttribiv)
+       && FindProcShort (glGetVertexAttribPointerv)
+       && FindProcShort (glIsProgram)
+       && FindProcShort (glIsShader)
+       && FindProcShort (glLinkProgram)
+       && FindProcShort (glShaderSource)
+       && FindProcShort (glUseProgram)
+       && FindProcShort (glUniform1f)
+       && FindProcShort (glUniform2f)
+       && FindProcShort (glUniform3f)
+       && FindProcShort (glUniform4f)
+       && FindProcShort (glUniform1i)
+       && FindProcShort (glUniform2i)
+       && FindProcShort (glUniform3i)
+       && FindProcShort (glUniform4i)
+       && FindProcShort (glUniform1fv)
+       && FindProcShort (glUniform2fv)
+       && FindProcShort (glUniform3fv)
+       && FindProcShort (glUniform4fv)
+       && FindProcShort (glUniform1iv)
+       && FindProcShort (glUniform2iv)
+       && FindProcShort (glUniform3iv)
+       && FindProcShort (glUniform4iv)
+       && FindProcShort (glUniformMatrix2fv)
+       && FindProcShort (glUniformMatrix3fv)
+       && FindProcShort (glUniformMatrix4fv)
+       && FindProcShort (glValidateProgram)
+       && FindProcShort (glVertexAttrib1d)
+       && FindProcShort (glVertexAttrib1dv)
+       && FindProcShort (glVertexAttrib1f)
+       && FindProcShort (glVertexAttrib1fv)
+       && FindProcShort (glVertexAttrib1s)
+       && FindProcShort (glVertexAttrib1sv)
+       && FindProcShort (glVertexAttrib2d)
+       && FindProcShort (glVertexAttrib2dv)
+       && FindProcShort (glVertexAttrib2f)
+       && FindProcShort (glVertexAttrib2fv)
+       && FindProcShort (glVertexAttrib2s)
+       && FindProcShort (glVertexAttrib2sv)
+       && FindProcShort (glVertexAttrib3d)
+       && FindProcShort (glVertexAttrib3dv)
+       && FindProcShort (glVertexAttrib3f)
+       && FindProcShort (glVertexAttrib3fv)
+       && FindProcShort (glVertexAttrib3s)
+       && FindProcShort (glVertexAttrib3sv)
+       && FindProcShort (glVertexAttrib4Nbv)
+       && FindProcShort (glVertexAttrib4Niv)
+       && FindProcShort (glVertexAttrib4Nsv)
+       && FindProcShort (glVertexAttrib4Nub)
+       && FindProcShort (glVertexAttrib4Nubv)
+       && FindProcShort (glVertexAttrib4Nuiv)
+       && FindProcShort (glVertexAttrib4Nusv)
+       && FindProcShort (glVertexAttrib4bv)
+       && FindProcShort (glVertexAttrib4d)
+       && FindProcShort (glVertexAttrib4dv)
+       && FindProcShort (glVertexAttrib4f)
+       && FindProcShort (glVertexAttrib4fv)
+       && FindProcShort (glVertexAttrib4iv)
+       && FindProcShort (glVertexAttrib4s)
+       && FindProcShort (glVertexAttrib4sv)
+       && FindProcShort (glVertexAttrib4ubv)
+       && FindProcShort (glVertexAttrib4uiv)
+       && FindProcShort (glVertexAttrib4usv)
+       && FindProcShort (glVertexAttribPointer);
+
+  // load OpenGL 2.1 new functions
+  has21 = IsGlGreaterEqual (2, 1)
+       && FindProcShort (glUniformMatrix2x3fv)
+       && FindProcShort (glUniformMatrix3x2fv)
+       && FindProcShort (glUniformMatrix2x4fv)
+       && FindProcShort (glUniformMatrix4x2fv)
+       && FindProcShort (glUniformMatrix3x4fv)
+       && FindProcShort (glUniformMatrix4x3fv);
+
+  // load GL_ARB_framebuffer_object (added to OpenGL 3.0 core)
+  const bool hasFBO = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_framebuffer_object"))
+       && FindProcShort (glIsRenderbuffer)
+       && FindProcShort (glBindRenderbuffer)
+       && FindProcShort (glDeleteRenderbuffers)
+       && FindProcShort (glGenRenderbuffers)
+       && FindProcShort (glRenderbufferStorage)
+       && FindProcShort (glGetRenderbufferParameteriv)
+       && FindProcShort (glIsFramebuffer)
+       && FindProcShort (glBindFramebuffer)
+       && FindProcShort (glDeleteFramebuffers)
+       && FindProcShort (glGenFramebuffers)
+       && FindProcShort (glCheckFramebufferStatus)
+       && FindProcShort (glFramebufferTexture1D)
+       && FindProcShort (glFramebufferTexture2D)
+       && FindProcShort (glFramebufferTexture3D)
+       && FindProcShort (glFramebufferRenderbuffer)
+       && FindProcShort (glGetFramebufferAttachmentParameteriv)
+       && FindProcShort (glGenerateMipmap)
+       && FindProcShort (glBlitFramebuffer)
+       && FindProcShort (glRenderbufferStorageMultisample)
+       && FindProcShort (glFramebufferTextureLayer);
+
+  // load GL_ARB_vertex_array_object (added to OpenGL 3.0 core)
+  const bool hasVAO = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_vertex_array_object"))
+       && FindProcShort (glBindVertexArray)
+       && FindProcShort (glDeleteVertexArrays)
+       && FindProcShort (glGenVertexArrays)
+       && FindProcShort (glIsVertexArray);
+
+  // load GL_ARB_map_buffer_range (added to OpenGL 3.0 core)
+  const bool hasMapBufferRange = (IsGlGreaterEqual (3, 0) || CheckExtension ("GL_ARB_map_buffer_range"))
+       && FindProcShort (glMapBufferRange)
+       && FindProcShort (glFlushMappedBufferRange);
+
+  // load OpenGL 3.0 new functions
+  has30 = IsGlGreaterEqual (3, 0)
+       && hasFBO
+       && hasVAO
+       && hasMapBufferRange
+       && FindProcShort (glColorMaski)
+       && FindProcShort (glGetBooleani_v)
+       && FindProcShort (glGetIntegeri_v)
+       && FindProcShort (glEnablei)
+       && FindProcShort (glDisablei)
+       && FindProcShort (glIsEnabledi)
+       && FindProcShort (glBeginTransformFeedback)
+       && FindProcShort (glEndTransformFeedback)
+       && FindProcShort (glBindBufferRange)
+       && FindProcShort (glBindBufferBase)
+       && FindProcShort (glTransformFeedbackVaryings)
+       && FindProcShort (glGetTransformFeedbackVarying)
+       && FindProcShort (glClampColor)
+       && FindProcShort (glBeginConditionalRender)
+       && FindProcShort (glEndConditionalRender)
+       && FindProcShort (glVertexAttribIPointer)
+       && FindProcShort (glGetVertexAttribIiv)
+       && FindProcShort (glGetVertexAttribIuiv)
+       && FindProcShort (glVertexAttribI1i)
+       && FindProcShort (glVertexAttribI2i)
+       && FindProcShort (glVertexAttribI3i)
+       && FindProcShort (glVertexAttribI4i)
+       && FindProcShort (glVertexAttribI1ui)
+       && FindProcShort (glVertexAttribI2ui)
+       && FindProcShort (glVertexAttribI3ui)
+       && FindProcShort (glVertexAttribI4ui)
+       && FindProcShort (glVertexAttribI1iv)
+       && FindProcShort (glVertexAttribI2iv)
+       && FindProcShort (glVertexAttribI3iv)
+       && FindProcShort (glVertexAttribI4iv)
+       && FindProcShort (glVertexAttribI1uiv)
+       && FindProcShort (glVertexAttribI2uiv)
+       && FindProcShort (glVertexAttribI3uiv)
+       && FindProcShort (glVertexAttribI4uiv)
+       && FindProcShort (glVertexAttribI4bv)
+       && FindProcShort (glVertexAttribI4sv)
+       && FindProcShort (glVertexAttribI4ubv)
+       && FindProcShort (glVertexAttribI4usv)
+       && FindProcShort (glGetUniformuiv)
+       && FindProcShort (glBindFragDataLocation)
+       && FindProcShort (glGetFragDataLocation)
+       && FindProcShort (glUniform1ui)
+       && FindProcShort (glUniform2ui)
+       && FindProcShort (glUniform3ui)
+       && FindProcShort (glUniform4ui)
+       && FindProcShort (glUniform1uiv)
+       && FindProcShort (glUniform2uiv)
+       && FindProcShort (glUniform3uiv)
+       && FindProcShort (glUniform4uiv)
+       && FindProcShort (glTexParameterIiv)
+       && FindProcShort (glTexParameterIuiv)
+       && FindProcShort (glGetTexParameterIiv)
+       && FindProcShort (glGetTexParameterIuiv)
+       && FindProcShort (glClearBufferiv)
+       && FindProcShort (glClearBufferuiv)
+       && FindProcShort (glClearBufferfv)
+       && FindProcShort (glClearBufferfi)
+       && FindProcShort (glGetStringi);
+
+  // load GL_ARB_uniform_buffer_object (added to OpenGL 3.1 core)
+  const bool hasUBO = (IsGlGreaterEqual (3, 1) || CheckExtension ("GL_ARB_uniform_buffer_object"))
+       && FindProcShort (glGetUniformIndices)
+       && FindProcShort (glGetActiveUniformsiv)
+       && FindProcShort (glGetActiveUniformName)
+       && FindProcShort (glGetUniformBlockIndex)
+       && FindProcShort (glGetActiveUniformBlockiv)
+       && FindProcShort (glGetActiveUniformBlockName)
+       && FindProcShort (glUniformBlockBinding);
+
+  // load GL_ARB_copy_buffer (added to OpenGL 3.1 core)
+  const bool hasCopyBufSubData = (IsGlGreaterEqual (3, 1) || CheckExtension ("GL_ARB_copy_buffer"))
+       && FindProcShort (glCopyBufferSubData);
+
+  if (has30)
   {
-    arbVBO = new OpenGl_ArbVBO();
-    memset (arbVBO, 0, sizeof(OpenGl_ArbVBO)); // nullify whole structure
-    if (!FindProcShort (arbVBO, glGenBuffersARB)
-     || !FindProcShort (arbVBO, glBindBufferARB)
-     || !FindProcShort (arbVBO, glBufferDataARB)
-     || !FindProcShort (arbVBO, glDeleteBuffersARB))
-    {
-      delete arbVBO;
-      arbVBO = NULL;
-    }
+    // NPOT textures are required by OpenGL 2.0 specifications
+    // but doesn't hardware accelerated by some ancient OpenGL 2.1 hardware (GeForce FX, RadeOn 9700 etc.)
+    arbNPTW  = Standard_True;
+    arbTexRG = Standard_True;
   }
 
+  // load OpenGL 3.1 new functions
+  has31 = IsGlGreaterEqual (3, 1)
+       && hasUBO
+       && hasCopyBufSubData
+       && FindProcShort (glDrawArraysInstanced)
+       && FindProcShort (glDrawElementsInstanced)
+       && FindProcShort (glTexBuffer)
+       && FindProcShort (glPrimitiveRestartIndex);
+
+  // load GL_ARB_draw_elements_base_vertex (added to OpenGL 3.2 core)
+  const bool hasDrawElemsBaseVert = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_draw_elements_base_vertex"))
+       && FindProcShort (glDrawElementsBaseVertex)
+       && FindProcShort (glDrawRangeElementsBaseVertex)
+       && FindProcShort (glDrawElementsInstancedBaseVertex)
+       && FindProcShort (glMultiDrawElementsBaseVertex);
+
+  // load GL_ARB_provoking_vertex (added to OpenGL 3.2 core)
+  const bool hasProvokingVert = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_provoking_vertex"))
+       && FindProcShort (glProvokingVertex);
+
+  // load GL_ARB_sync (added to OpenGL 3.2 core)
+  const bool hasSync = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_sync"))
+       && FindProcShort (glFenceSync)
+       && FindProcShort (glIsSync)
+       && FindProcShort (glDeleteSync)
+       && FindProcShort (glClientWaitSync)
+       && FindProcShort (glWaitSync)
+       && FindProcShort (glGetInteger64v)
+       && FindProcShort (glGetSynciv);
+
+  // load GL_ARB_texture_multisample (added to OpenGL 3.2 core)
+  const bool hasTextureMultisample = (IsGlGreaterEqual (3, 2) || CheckExtension ("GL_ARB_texture_multisample"))
+       && FindProcShort (glTexImage2DMultisample)
+       && FindProcShort (glTexImage3DMultisample)
+       && FindProcShort (glGetMultisamplefv)
+       && FindProcShort (glSampleMaski);
+
+  // load OpenGL 3.2 new functions
+  has32 = IsGlGreaterEqual (3, 2)
+       && hasDrawElemsBaseVert
+       && hasProvokingVert
+       && hasSync
+       && hasTextureMultisample
+       && FindProcShort (glGetInteger64i_v)
+       && FindProcShort (glGetBufferParameteri64v)
+       && FindProcShort (glFramebufferTexture);
+
+  // load GL_ARB_blend_func_extended (added to OpenGL 3.3 core)
+  const bool hasBlendFuncExtended = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_blend_func_extended"))
+       && FindProcShort (glBindFragDataLocationIndexed)
+       && FindProcShort (glGetFragDataIndex);
+
+  // load GL_ARB_sampler_objects (added to OpenGL 3.3 core)
+  const bool hasSamplerObjects = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_sampler_objects"))
+       && FindProcShort (glGenSamplers)
+       && FindProcShort (glDeleteSamplers)
+       && FindProcShort (glIsSampler)
+       && FindProcShort (glBindSampler)
+       && FindProcShort (glSamplerParameteri)
+       && FindProcShort (glSamplerParameteriv)
+       && FindProcShort (glSamplerParameterf)
+       && FindProcShort (glSamplerParameterfv)
+       && FindProcShort (glSamplerParameterIiv)
+       && FindProcShort (glSamplerParameterIuiv)
+       && FindProcShort (glGetSamplerParameteriv)
+       && FindProcShort (glGetSamplerParameterIiv)
+       && FindProcShort (glGetSamplerParameterfv)
+       && FindProcShort (glGetSamplerParameterIuiv);
+
+  // load GL_ARB_timer_query (added to OpenGL 3.3 core)
+  const bool hasTimerQuery = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_timer_query"))
+       && FindProcShort (glQueryCounter)
+       && FindProcShort (glGetQueryObjecti64v)
+       && FindProcShort (glGetQueryObjectui64v);
+
+  // load GL_ARB_vertex_type_2_10_10_10_rev (added to OpenGL 3.3 core)
+  const bool hasVertType21010101rev = (IsGlGreaterEqual (3, 3) || CheckExtension ("GL_ARB_vertex_type_2_10_10_10_rev"))
+       && FindProcShort (glVertexP2ui)
+       && FindProcShort (glVertexP2uiv)
+       && FindProcShort (glVertexP3ui)
+       && FindProcShort (glVertexP3uiv)
+       && FindProcShort (glVertexP4ui)
+       && FindProcShort (glVertexP4uiv)
+       && FindProcShort (glTexCoordP1ui)
+       && FindProcShort (glTexCoordP1uiv)
+       && FindProcShort (glTexCoordP2ui)
+       && FindProcShort (glTexCoordP2uiv)
+       && FindProcShort (glTexCoordP3ui)
+       && FindProcShort (glTexCoordP3uiv)
+       && FindProcShort (glTexCoordP4ui)
+       && FindProcShort (glTexCoordP4uiv)
+       && FindProcShort (glMultiTexCoordP1ui)
+       && FindProcShort (glMultiTexCoordP1uiv)
+       && FindProcShort (glMultiTexCoordP2ui)
+       && FindProcShort (glMultiTexCoordP2uiv)
+       && FindProcShort (glMultiTexCoordP3ui)
+       && FindProcShort (glMultiTexCoordP3uiv)
+       && FindProcShort (glMultiTexCoordP4ui)
+       && FindProcShort (glMultiTexCoordP4uiv)
+       && FindProcShort (glNormalP3ui)
+       && FindProcShort (glNormalP3uiv)
+       && FindProcShort (glColorP3ui)
+       && FindProcShort (glColorP3uiv)
+       && FindProcShort (glColorP4ui)
+       && FindProcShort (glColorP4uiv)
+       && FindProcShort (glSecondaryColorP3ui)
+       && FindProcShort (glSecondaryColorP3uiv)
+       && FindProcShort (glVertexAttribP1ui)
+       && FindProcShort (glVertexAttribP1uiv)
+       && FindProcShort (glVertexAttribP2ui)
+       && FindProcShort (glVertexAttribP2uiv)
+       && FindProcShort (glVertexAttribP3ui)
+       && FindProcShort (glVertexAttribP3uiv)
+       && FindProcShort (glVertexAttribP4ui)
+       && FindProcShort (glVertexAttribP4uiv);
+
+  // load OpenGL 3.3 extra functions
+  has33 = IsGlGreaterEqual (3, 3)
+       && hasBlendFuncExtended
+       && hasSamplerObjects
+       && hasTimerQuery
+       && hasVertType21010101rev
+       && FindProcShort (glVertexAttribDivisor);
+
+  // load GL_ARB_draw_indirect (added to OpenGL 4.0 core)
+  const bool hasDrawIndirect = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_draw_indirect"))
+       && FindProcShort (glDrawArraysIndirect)
+       && FindProcShort (glDrawElementsIndirect);
+
+  // load GL_ARB_gpu_shader_fp64 (added to OpenGL 4.0 core)
+  const bool hasShaderFP64 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_gpu_shader_fp64"))
+       && FindProcShort (glUniform1d)
+       && FindProcShort (glUniform2d)
+       && FindProcShort (glUniform3d)
+       && FindProcShort (glUniform4d)
+       && FindProcShort (glUniform1dv)
+       && FindProcShort (glUniform2dv)
+       && FindProcShort (glUniform3dv)
+       && FindProcShort (glUniform4dv)
+       && FindProcShort (glUniformMatrix2dv)
+       && FindProcShort (glUniformMatrix3dv)
+       && FindProcShort (glUniformMatrix4dv)
+       && FindProcShort (glUniformMatrix2x3dv)
+       && FindProcShort (glUniformMatrix2x4dv)
+       && FindProcShort (glUniformMatrix3x2dv)
+       && FindProcShort (glUniformMatrix3x4dv)
+       && FindProcShort (glUniformMatrix4x2dv)
+       && FindProcShort (glUniformMatrix4x3dv)
+       && FindProcShort (glGetUniformdv);
+
+  // load GL_ARB_shader_subroutine (added to OpenGL 4.0 core)
+  const bool hasShaderSubroutine = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_shader_subroutine"))
+       && FindProcShort (glGetSubroutineUniformLocation)
+       && FindProcShort (glGetSubroutineIndex)
+       && FindProcShort (glGetActiveSubroutineUniformiv)
+       && FindProcShort (glGetActiveSubroutineUniformName)
+       && FindProcShort (glGetActiveSubroutineName)
+       && FindProcShort (glUniformSubroutinesuiv)
+       && FindProcShort (glGetUniformSubroutineuiv)
+       && FindProcShort (glGetProgramStageiv);
+
+  // load GL_ARB_tessellation_shader (added to OpenGL 4.0 core)
+  const bool hasTessellationShader = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_tessellation_shader"))
+       && FindProcShort (glPatchParameteri)
+       && FindProcShort (glPatchParameterfv);
+
+  // load GL_ARB_transform_feedback2 (added to OpenGL 4.0 core)
+  const bool hasTrsfFeedback2 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_transform_feedback2"))
+       && FindProcShort (glBindTransformFeedback)
+       && FindProcShort (glDeleteTransformFeedbacks)
+       && FindProcShort (glGenTransformFeedbacks)
+       && FindProcShort (glIsTransformFeedback)
+       && FindProcShort (glPauseTransformFeedback)
+       && FindProcShort (glResumeTransformFeedback)
+       && FindProcShort (glDrawTransformFeedback);
+
+  // load GL_ARB_transform_feedback3 (added to OpenGL 4.0 core)
+  const bool hasTrsfFeedback3 = (IsGlGreaterEqual (4, 0) || CheckExtension ("GL_ARB_transform_feedback3"))
+       && FindProcShort (glDrawTransformFeedbackStream)
+       && FindProcShort (glBeginQueryIndexed)
+       && FindProcShort (glEndQueryIndexed)
+       && FindProcShort (glGetQueryIndexediv);
+
+  // load OpenGL 4.0 new functions
+  has40 = IsGlGreaterEqual (4, 0)
+      && hasDrawIndirect
+      && hasShaderFP64
+      && hasShaderSubroutine
+      && hasTessellationShader
+      && hasTrsfFeedback2
+      && hasTrsfFeedback3
+      && FindProcShort (glMinSampleShading)
+      && FindProcShort (glBlendEquationi)
+      && FindProcShort (glBlendEquationSeparatei)
+      && FindProcShort (glBlendFunci)
+      && FindProcShort (glBlendFuncSeparatei);
+
+  // load GL_ARB_ES2_compatibility (added to OpenGL 4.1 core)
+  const bool hasES2Compatibility = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_ES2_compatibility"))
+       && FindProcShort (glReleaseShaderCompiler)
+       && FindProcShort (glShaderBinary)
+       && FindProcShort (glGetShaderPrecisionFormat)
+       && FindProcShort (glDepthRangef)
+       && FindProcShort (glClearDepthf);
+
+  // load GL_ARB_get_program_binary (added to OpenGL 4.1 core)
+  const bool hasGetProgramBinary = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_get_program_binary"))
+       && FindProcShort (glGetProgramBinary)
+       && FindProcShort (glProgramBinary)
+       && FindProcShort (glProgramParameteri);
+
+
+  // load GL_ARB_separate_shader_objects (added to OpenGL 4.1 core)
+  const bool hasSeparateShaderObjects = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_separate_shader_objects"))
+       && FindProcShort (glUseProgramStages)
+       && FindProcShort (glActiveShaderProgram)
+       && FindProcShort (glCreateShaderProgramv)
+       && FindProcShort (glBindProgramPipeline)
+       && FindProcShort (glDeleteProgramPipelines)
+       && FindProcShort (glGenProgramPipelines)
+       && FindProcShort (glIsProgramPipeline)
+       && FindProcShort (glGetProgramPipelineiv)
+       && FindProcShort (glProgramUniform1i)
+       && FindProcShort (glProgramUniform1iv)
+       && FindProcShort (glProgramUniform1f)
+       && FindProcShort (glProgramUniform1fv)
+       && FindProcShort (glProgramUniform1d)
+       && FindProcShort (glProgramUniform1dv)
+       && FindProcShort (glProgramUniform1ui)
+       && FindProcShort (glProgramUniform1uiv)
+       && FindProcShort (glProgramUniform2i)
+       && FindProcShort (glProgramUniform2iv)
+       && FindProcShort (glProgramUniform2f)
+       && FindProcShort (glProgramUniform2fv)
+       && FindProcShort (glProgramUniform2d)
+       && FindProcShort (glProgramUniform2dv)
+       && FindProcShort (glProgramUniform2ui)
+       && FindProcShort (glProgramUniform2uiv)
+       && FindProcShort (glProgramUniform3i)
+       && FindProcShort (glProgramUniform3iv)
+       && FindProcShort (glProgramUniform3f)
+       && FindProcShort (glProgramUniform3fv)
+       && FindProcShort (glProgramUniform3d)
+       && FindProcShort (glProgramUniform3dv)
+       && FindProcShort (glProgramUniform3ui)
+       && FindProcShort (glProgramUniform3uiv)
+       && FindProcShort (glProgramUniform4i)
+       && FindProcShort (glProgramUniform4iv)
+       && FindProcShort (glProgramUniform4f)
+       && FindProcShort (glProgramUniform4fv)
+       && FindProcShort (glProgramUniform4d)
+       && FindProcShort (glProgramUniform4dv)
+       && FindProcShort (glProgramUniform4ui)
+       && FindProcShort (glProgramUniform4uiv)
+       && FindProcShort (glProgramUniformMatrix2fv)
+       && FindProcShort (glProgramUniformMatrix3fv)
+       && FindProcShort (glProgramUniformMatrix4fv)
+       && FindProcShort (glProgramUniformMatrix2dv)
+       && FindProcShort (glProgramUniformMatrix3dv)
+       && FindProcShort (glProgramUniformMatrix4dv)
+       && FindProcShort (glProgramUniformMatrix2x3fv)
+       && FindProcShort (glProgramUniformMatrix3x2fv)
+       && FindProcShort (glProgramUniformMatrix2x4fv)
+       && FindProcShort (glProgramUniformMatrix4x2fv)
+       && FindProcShort (glProgramUniformMatrix3x4fv)
+       && FindProcShort (glProgramUniformMatrix4x3fv)
+       && FindProcShort (glProgramUniformMatrix2x3dv)
+       && FindProcShort (glProgramUniformMatrix3x2dv)
+       && FindProcShort (glProgramUniformMatrix2x4dv)
+       && FindProcShort (glProgramUniformMatrix4x2dv)
+       && FindProcShort (glProgramUniformMatrix3x4dv)
+       && FindProcShort (glProgramUniformMatrix4x3dv)
+       && FindProcShort (glValidateProgramPipeline)
+       && FindProcShort (glGetProgramPipelineInfoLog);
+
+  // load GL_ARB_vertex_attrib_64bit (added to OpenGL 4.1 core)
+  const bool hasVertAttrib64bit = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_vertex_attrib_64bit"))
+       && FindProcShort (glVertexAttribL1d)
+       && FindProcShort (glVertexAttribL2d)
+       && FindProcShort (glVertexAttribL3d)
+       && FindProcShort (glVertexAttribL4d)
+       && FindProcShort (glVertexAttribL1dv)
+       && FindProcShort (glVertexAttribL2dv)
+       && FindProcShort (glVertexAttribL3dv)
+       && FindProcShort (glVertexAttribL4dv)
+       && FindProcShort (glVertexAttribLPointer)
+       && FindProcShort (glGetVertexAttribLdv);
+
+  // load GL_ARB_viewport_array (added to OpenGL 4.1 core)
+  const bool hasViewportArray = (IsGlGreaterEqual (4, 1) || CheckExtension ("GL_ARB_viewport_array"))
+       && FindProcShort (glViewportArrayv)
+       && FindProcShort (glViewportIndexedf)
+       && FindProcShort (glViewportIndexedfv)
+       && FindProcShort (glScissorArrayv)
+       && FindProcShort (glScissorIndexed)
+       && FindProcShort (glScissorIndexedv)
+       && FindProcShort (glDepthRangeArrayv)
+       && FindProcShort (glDepthRangeIndexed)
+       && FindProcShort (glGetFloati_v)
+       && FindProcShort (glGetDoublei_v);
+
+  has41 = IsGlGreaterEqual (4, 1)
+       && hasES2Compatibility
+       && hasGetProgramBinary
+       && hasSeparateShaderObjects
+       && hasVertAttrib64bit
+       && hasViewportArray;
+
+  // load GL_ARB_base_instance (added to OpenGL 4.2 core)
+  const bool hasBaseInstance = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_base_instance"))
+       && FindProcShort (glDrawArraysInstancedBaseInstance)
+       && FindProcShort (glDrawElementsInstancedBaseInstance)
+       && FindProcShort (glDrawElementsInstancedBaseVertexBaseInstance);
+
+  // load GL_ARB_transform_feedback_instanced (added to OpenGL 4.2 core)
+  const bool hasTrsfFeedbackInstanced = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_transform_feedback_instanced"))
+       && FindProcShort (glDrawTransformFeedbackInstanced)
+       && FindProcShort (glDrawTransformFeedbackStreamInstanced);
+
+  // load GL_ARB_internalformat_query (added to OpenGL 4.2 core)
+  const bool hasInternalFormatQuery = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_internalformat_query"))
+       && FindProcShort (glGetInternalformativ);
+
+  // load GL_ARB_shader_atomic_counters (added to OpenGL 4.2 core)
+  const bool hasShaderAtomicCounters = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_shader_atomic_counters"))
+       && FindProcShort (glGetActiveAtomicCounterBufferiv);
+
+  // load GL_ARB_shader_image_load_store (added to OpenGL 4.2 core)
+  const bool hasShaderImgLoadStore = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_shader_image_load_store"))
+       && FindProcShort (glBindImageTexture)
+       && FindProcShort (glMemoryBarrier);
+
+  // load GL_ARB_texture_storage (added to OpenGL 4.2 core)
+  const bool hasTextureStorage = (IsGlGreaterEqual (4, 2) || CheckExtension ("GL_ARB_texture_storage"))
+       && FindProcShort (glTexStorage1D)
+       && FindProcShort (glTexStorage2D)
+       && FindProcShort (glTexStorage3D)
+       && FindProcShort (glTextureStorage1DEXT)
+       && FindProcShort (glTextureStorage2DEXT)
+       && FindProcShort (glTextureStorage3DEXT);
+
+  has42 = IsGlGreaterEqual (4, 2)
+       && hasBaseInstance
+       && hasTrsfFeedbackInstanced
+       && hasInternalFormatQuery
+       && hasShaderAtomicCounters
+       && hasShaderImgLoadStore
+       && hasTextureStorage;
+
+  has43 = IsGlGreaterEqual (4, 3)
+       && FindProcShort (glClearBufferData)
+       && FindProcShort (glClearBufferSubData)
+       && FindProcShort (glDispatchCompute)
+       && FindProcShort (glDispatchComputeIndirect)
+       && FindProcShort (glCopyImageSubData)
+       && FindProcShort (glFramebufferParameteri)
+       && FindProcShort (glGetFramebufferParameteriv)
+       && FindProcShort (glGetInternalformati64v)
+       && FindProcShort (glInvalidateTexSubImage)
+       && FindProcShort (glInvalidateTexImage)
+       && FindProcShort (glInvalidateBufferSubData)
+       && FindProcShort (glInvalidateBufferData)
+       && FindProcShort (glInvalidateFramebuffer)
+       && FindProcShort (glInvalidateSubFramebuffer)
+       && FindProcShort (glMultiDrawArraysIndirect)
+       && FindProcShort (glMultiDrawElementsIndirect)
+       && FindProcShort (glGetProgramInterfaceiv)
+       && FindProcShort (glGetProgramResourceIndex)
+       && FindProcShort (glGetProgramResourceName)
+       && FindProcShort (glGetProgramResourceiv)
+       && FindProcShort (glGetProgramResourceLocation)
+       && FindProcShort (glGetProgramResourceLocationIndex)
+       && FindProcShort (glShaderStorageBlockBinding)
+       && FindProcShort (glTexBufferRange)
+       && FindProcShort (glTexStorage2DMultisample)
+       && FindProcShort (glTexStorage3DMultisample)
+       && FindProcShort (glTextureView)
+       && FindProcShort (glBindVertexBuffer)
+       && FindProcShort (glVertexAttribFormat)
+       && FindProcShort (glVertexAttribIFormat)
+       && FindProcShort (glVertexAttribLFormat)
+       && FindProcShort (glVertexAttribBinding)
+       && FindProcShort (glVertexBindingDivisor)
+       && FindProcShort (glDebugMessageControl)
+       && FindProcShort (glDebugMessageInsert)
+       && FindProcShort (glDebugMessageCallback)
+       && FindProcShort (glGetDebugMessageLog)
+       && FindProcShort (glPushDebugGroup)
+       && FindProcShort (glPopDebugGroup)
+       && FindProcShort (glObjectLabel)
+       && FindProcShort (glGetObjectLabel)
+       && FindProcShort (glObjectPtrLabel)
+       && FindProcShort (glGetObjectPtrLabel);
+
+  // load GL_ARB_clear_texture (added to OpenGL 4.4 core)
+  bool arbTexClear = (IsGlGreaterEqual (4, 4) || CheckExtension ("GL_ARB_clear_texture"))
+       && FindProcShort (glClearTexImage)
+       && FindProcShort (glClearTexSubImage);
+
+  has44 = IsGlGreaterEqual (4, 4)
+       && arbTexClear
+       && FindProcShort (glBufferStorage)
+       && FindProcShort (glBindBuffersBase)
+       && FindProcShort (glBindBuffersRange)
+       && FindProcShort (glBindTextures)
+       && FindProcShort (glBindSamplers)
+       && FindProcShort (glBindImageTextures)
+       && FindProcShort (glBindVertexBuffers);
+
   // initialize TBO extension (ARB)
-  if (CheckExtension ("GL_ARB_texture_buffer_object"))
+  if (!has31
+   && CheckExtension ("GL_ARB_texture_buffer_object")
+   && FindProc ("glTexBufferARB", myFuncs->glTexBuffer))
   {
-    arbTBO = new OpenGl_ArbTBO();
-    memset (arbTBO, 0, sizeof(OpenGl_ArbTBO)); // nullify whole structure
-    if (!FindProcShort (arbTBO, glTexBufferARB))
-    {
-      delete arbTBO;
-      arbTBO = NULL;
-    }
+    arbTBO = (OpenGl_ArbTBO* )(&(*myFuncs));
   }
 
   // initialize hardware instancing extension (ARB)
-  if (CheckExtension ("GL_ARB_draw_instanced"))
+  if (!has31
+   && CheckExtension ("GL_ARB_draw_instanced")
+   && FindProc ("glDrawArraysInstancedARB",   myFuncs->glDrawArraysInstanced)
+   && FindProc ("glDrawElementsInstancedARB", myFuncs->glDrawElementsInstanced))
   {
-    arbIns = new OpenGl_ArbIns();
-    memset (arbIns, 0, sizeof(OpenGl_ArbIns)); // nullify whole structure
-    if (!FindProcShort (arbIns, glDrawArraysInstancedARB)
-     || !FindProcShort (arbIns, glDrawElementsInstancedARB))
-    {
-      delete arbIns;
-      arbIns = NULL;
-    }
+    arbIns = (OpenGl_ArbIns* )(&(*myFuncs));
   }
 
-  // initialize FBO extension (EXT)
-  if (CheckExtension ("GL_EXT_framebuffer_object"))
-  {
-    extFBO = new OpenGl_ExtFBO();
-    memset (extFBO, 0, sizeof(OpenGl_ExtFBO)); // nullify whole structure
-    if (!FindProcShort (extFBO, glGenFramebuffersEXT)
-     || !FindProcShort (extFBO, glDeleteFramebuffersEXT)
-     || !FindProcShort (extFBO, glBindFramebufferEXT)
-     || !FindProcShort (extFBO, glFramebufferTexture2DEXT)
-     || !FindProcShort (extFBO, glCheckFramebufferStatusEXT)
-     || !FindProcShort (extFBO, glGenRenderbuffersEXT)
-     || !FindProcShort (extFBO, glDeleteRenderbuffersEXT)
-     || !FindProcShort (extFBO, glBindRenderbufferEXT)
-     || !FindProcShort (extFBO, glRenderbufferStorageEXT)
-     || !FindProcShort (extFBO, glFramebufferRenderbufferEXT)
-     || !FindProcShort (extFBO, glGenerateMipmapEXT))
-    {
-      delete extFBO;
-      extFBO = NULL;
-    }
+  // initialize FBO extension (ARB)
+  if (hasFBO)
+  {
+    arbFBO = (OpenGl_ArbFBO* )(&(*myFuncs));
+    extPDS = Standard_True; // extension for EXT, but part of ARB
   }
 
   // initialize GS extension (EXT)
-  if (CheckExtension ("GL_EXT_geometry_shader4"))
+  if (CheckExtension ("GL_EXT_geometry_shader4")
+   && FindProcShort (glProgramParameteriEXT))
   {
-    extGS = new OpenGl_ExtGS();
-    memset (extGS, 0, sizeof(OpenGl_ExtGS)); // nullify whole structure
-    if (!FindProcShort (extGS, glProgramParameteriEXT))
-    {
-      delete extGS;
-      extGS = NULL;
-    }
+    extGS = (OpenGl_ExtGS* )(&(*myFuncs));
   }
 
-  myGlCore20 = new OpenGl_GlCore20();
-  memset (myGlCore20, 0, sizeof(OpenGl_GlCore20)); // nullify whole structure
-
-  // Check if OpenGL 1.2 core functionality is actually present
-  Standard_Boolean hasGlCore12 = IsGlGreaterEqual (1, 2)
-    && FindProcShort (myGlCore20, glBlendColor)
-    && FindProcShort (myGlCore20, glBlendEquation)
-    && FindProcShort (myGlCore20, glDrawRangeElements)
-    && FindProcShort (myGlCore20, glTexImage3D)
-    && FindProcShort (myGlCore20, glTexSubImage3D)
-    && FindProcShort (myGlCore20, glCopyTexSubImage3D);
-
-  // Check if OpenGL 1.3 core functionality is actually present
-  Standard_Boolean hasGlCore13 = IsGlGreaterEqual (1, 3)
-    && FindProcShort (myGlCore20, glActiveTexture)
-    && FindProcShort (myGlCore20, glSampleCoverage)
-    && FindProcShort (myGlCore20, glCompressedTexImage3D)
-    && FindProcShort (myGlCore20, glCompressedTexImage2D)
-    && FindProcShort (myGlCore20, glCompressedTexImage1D)
-    && FindProcShort (myGlCore20, glCompressedTexSubImage3D)
-    && FindProcShort (myGlCore20, glCompressedTexSubImage2D)
-    && FindProcShort (myGlCore20, glCompressedTexSubImage1D)
-    && FindProcShort (myGlCore20, glGetCompressedTexImage)
-     // deprecated
-    && FindProcShort (myGlCore20, glClientActiveTexture)
-    && FindProcShort (myGlCore20, glMultiTexCoord1d)
-    && FindProcShort (myGlCore20, glMultiTexCoord1dv)
-    && FindProcShort (myGlCore20, glMultiTexCoord1f)
-    && FindProcShort (myGlCore20, glMultiTexCoord1fv)
-    && FindProcShort (myGlCore20, glMultiTexCoord1i)
-    && FindProcShort (myGlCore20, glMultiTexCoord1iv)
-    && FindProcShort (myGlCore20, glMultiTexCoord1s)
-    && FindProcShort (myGlCore20, glMultiTexCoord1sv)
-    && FindProcShort (myGlCore20, glMultiTexCoord2d)
-    && FindProcShort (myGlCore20, glMultiTexCoord2dv)
-    && FindProcShort (myGlCore20, glMultiTexCoord2f)
-    && FindProcShort (myGlCore20, glMultiTexCoord2fv)
-    && FindProcShort (myGlCore20, glMultiTexCoord2i)
-    && FindProcShort (myGlCore20, glMultiTexCoord2iv)
-    && FindProcShort (myGlCore20, glMultiTexCoord2s)
-    && FindProcShort (myGlCore20, glMultiTexCoord2sv)
-    && FindProcShort (myGlCore20, glMultiTexCoord3d)
-    && FindProcShort (myGlCore20, glMultiTexCoord3dv)
-    && FindProcShort (myGlCore20, glMultiTexCoord3f)
-    && FindProcShort (myGlCore20, glMultiTexCoord3fv)
-    && FindProcShort (myGlCore20, glMultiTexCoord3i)
-    && FindProcShort (myGlCore20, glMultiTexCoord3iv)
-    && FindProcShort (myGlCore20, glMultiTexCoord3s)
-    && FindProcShort (myGlCore20, glMultiTexCoord3sv)
-    && FindProcShort (myGlCore20, glMultiTexCoord4d)
-    && FindProcShort (myGlCore20, glMultiTexCoord4dv)
-    && FindProcShort (myGlCore20, glMultiTexCoord4f)
-    && FindProcShort (myGlCore20, glMultiTexCoord4fv)
-    && FindProcShort (myGlCore20, glMultiTexCoord4i)
-    && FindProcShort (myGlCore20, glMultiTexCoord4iv)
-    && FindProcShort (myGlCore20, glMultiTexCoord4s)
-    && FindProcShort (myGlCore20, glMultiTexCoord4sv)
-    && FindProcShort (myGlCore20, glLoadTransposeMatrixf)
-    && FindProcShort (myGlCore20, glLoadTransposeMatrixd)
-    && FindProcShort (myGlCore20, glMultTransposeMatrixf)
-    && FindProcShort (myGlCore20, glMultTransposeMatrixd);
-
-  // Check if OpenGL 1.4 core functionality is actually present
-  Standard_Boolean hasGlCore14 = IsGlGreaterEqual (1, 4)
-    && FindProcShort (myGlCore20, glBlendFuncSeparate)
-    && FindProcShort (myGlCore20, glMultiDrawArrays)
-    && FindProcShort (myGlCore20, glMultiDrawElements)
-    && FindProcShort (myGlCore20, glPointParameterf)
-    && FindProcShort (myGlCore20, glPointParameterfv)
-    && FindProcShort (myGlCore20, glPointParameteri)
-    && FindProcShort (myGlCore20, glPointParameteriv);
-
-  // Check if OpenGL 1.5 core functionality is actually present
-  Standard_Boolean hasGlCore15 = IsGlGreaterEqual (1, 5)
-    && FindProcShort (myGlCore20, glGenQueries)
-    && FindProcShort (myGlCore20, glDeleteQueries)
-    && FindProcShort (myGlCore20, glIsQuery)
-    && FindProcShort (myGlCore20, glBeginQuery)
-    && FindProcShort (myGlCore20, glEndQuery)
-    && FindProcShort (myGlCore20, glGetQueryiv)
-    && FindProcShort (myGlCore20, glGetQueryObjectiv)
-    && FindProcShort (myGlCore20, glGetQueryObjectuiv)
-    && FindProcShort (myGlCore20, glBindBuffer)
-    && FindProcShort (myGlCore20, glDeleteBuffers)
-    && FindProcShort (myGlCore20, glGenBuffers)
-    && FindProcShort (myGlCore20, glIsBuffer)
-    && FindProcShort (myGlCore20, glBufferData)
-    && FindProcShort (myGlCore20, glBufferSubData)
-    && FindProcShort (myGlCore20, glGetBufferSubData)
-    && FindProcShort (myGlCore20, glMapBuffer)
-    && FindProcShort (myGlCore20, glUnmapBuffer)
-    && FindProcShort (myGlCore20, glGetBufferParameteriv)
-    && FindProcShort (myGlCore20, glGetBufferPointerv);
-
-  // Check if OpenGL 2.0 core functionality is actually present
-  Standard_Boolean hasGlCore20 = IsGlGreaterEqual (2, 0)
-    && FindProcShort (myGlCore20, glBlendEquationSeparate)
-    && FindProcShort (myGlCore20, glDrawBuffers)
-    && FindProcShort (myGlCore20, glStencilOpSeparate)
-    && FindProcShort (myGlCore20, glStencilFuncSeparate)
-    && FindProcShort (myGlCore20, glStencilMaskSeparate)
-    && FindProcShort (myGlCore20, glAttachShader)
-    && FindProcShort (myGlCore20, glBindAttribLocation)
-    && FindProcShort (myGlCore20, glCompileShader)
-    && FindProcShort (myGlCore20, glCreateProgram)
-    && FindProcShort (myGlCore20, glCreateShader)
-    && FindProcShort (myGlCore20, glDeleteProgram)
-    && FindProcShort (myGlCore20, glDeleteShader)
-    && FindProcShort (myGlCore20, glDetachShader)
-    && FindProcShort (myGlCore20, glDisableVertexAttribArray)
-    && FindProcShort (myGlCore20, glEnableVertexAttribArray)
-    && FindProcShort (myGlCore20, glGetActiveAttrib)
-    && FindProcShort (myGlCore20, glGetActiveUniform)
-    && FindProcShort (myGlCore20, glGetAttachedShaders)
-    && FindProcShort (myGlCore20, glGetAttribLocation)
-    && FindProcShort (myGlCore20, glGetProgramiv)
-    && FindProcShort (myGlCore20, glGetProgramInfoLog)
-    && FindProcShort (myGlCore20, glGetShaderiv)
-    && FindProcShort (myGlCore20, glGetShaderInfoLog)
-    && FindProcShort (myGlCore20, glGetShaderSource)
-    && FindProcShort (myGlCore20, glGetUniformLocation)
-    && FindProcShort (myGlCore20, glGetUniformfv)
-    && FindProcShort (myGlCore20, glGetUniformiv)
-    && FindProcShort (myGlCore20, glGetVertexAttribdv)
-    && FindProcShort (myGlCore20, glGetVertexAttribfv)
-    && FindProcShort (myGlCore20, glGetVertexAttribiv)
-    && FindProcShort (myGlCore20, glGetVertexAttribPointerv)
-    && FindProcShort (myGlCore20, glIsProgram)
-    && FindProcShort (myGlCore20, glIsShader)
-    && FindProcShort (myGlCore20, glLinkProgram)
-    && FindProcShort (myGlCore20, glShaderSource)
-    && FindProcShort (myGlCore20, glUseProgram)
-    && FindProcShort (myGlCore20, glUniform1f)
-    && FindProcShort (myGlCore20, glUniform2f)
-    && FindProcShort (myGlCore20, glUniform3f)
-    && FindProcShort (myGlCore20, glUniform4f)
-    && FindProcShort (myGlCore20, glUniform1i)
-    && FindProcShort (myGlCore20, glUniform2i)
-    && FindProcShort (myGlCore20, glUniform3i)
-    && FindProcShort (myGlCore20, glUniform4i)
-    && FindProcShort (myGlCore20, glUniform1fv)
-    && FindProcShort (myGlCore20, glUniform2fv)
-    && FindProcShort (myGlCore20, glUniform3fv)
-    && FindProcShort (myGlCore20, glUniform4fv)
-    && FindProcShort (myGlCore20, glUniform1iv)
-    && FindProcShort (myGlCore20, glUniform2iv)
-    && FindProcShort (myGlCore20, glUniform3iv)
-    && FindProcShort (myGlCore20, glUniform4iv)
-    && FindProcShort (myGlCore20, glUniformMatrix2fv)
-    && FindProcShort (myGlCore20, glUniformMatrix3fv)
-    && FindProcShort (myGlCore20, glUniformMatrix4fv)
-    && FindProcShort (myGlCore20, glValidateProgram)
-    && FindProcShort (myGlCore20, glVertexAttrib1d)
-    && FindProcShort (myGlCore20, glVertexAttrib1dv)
-    && FindProcShort (myGlCore20, glVertexAttrib1f)
-    && FindProcShort (myGlCore20, glVertexAttrib1fv)
-    && FindProcShort (myGlCore20, glVertexAttrib1s)
-    && FindProcShort (myGlCore20, glVertexAttrib1sv)
-    && FindProcShort (myGlCore20, glVertexAttrib2d)
-    && FindProcShort (myGlCore20, glVertexAttrib2dv)
-    && FindProcShort (myGlCore20, glVertexAttrib2f)
-    && FindProcShort (myGlCore20, glVertexAttrib2fv)
-    && FindProcShort (myGlCore20, glVertexAttrib2s)
-    && FindProcShort (myGlCore20, glVertexAttrib2sv)
-    && FindProcShort (myGlCore20, glVertexAttrib3d)
-    && FindProcShort (myGlCore20, glVertexAttrib3dv)
-    && FindProcShort (myGlCore20, glVertexAttrib3f)
-    && FindProcShort (myGlCore20, glVertexAttrib3fv)
-    && FindProcShort (myGlCore20, glVertexAttrib3s)
-    && FindProcShort (myGlCore20, glVertexAttrib3sv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nbv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Niv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nsv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nub)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nubv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nuiv)
-    && FindProcShort (myGlCore20, glVertexAttrib4Nusv)
-    && FindProcShort (myGlCore20, glVertexAttrib4bv)
-    && FindProcShort (myGlCore20, glVertexAttrib4d)
-    && FindProcShort (myGlCore20, glVertexAttrib4dv)
-    && FindProcShort (myGlCore20, glVertexAttrib4f)
-    && FindProcShort (myGlCore20, glVertexAttrib4fv)
-    && FindProcShort (myGlCore20, glVertexAttrib4iv)
-    && FindProcShort (myGlCore20, glVertexAttrib4s)
-    && FindProcShort (myGlCore20, glVertexAttrib4sv)
-    && FindProcShort (myGlCore20, glVertexAttrib4ubv)
-    && FindProcShort (myGlCore20, glVertexAttrib4uiv)
-    && FindProcShort (myGlCore20, glVertexAttrib4usv)
-    && FindProcShort (myGlCore20, glVertexAttribPointer);
-
-  if (!hasGlCore12)
+  if (!has12)
   {
     myGlVerMajor = 1;
     myGlVerMinor = 1;
     return;
   }
-  else
+  else if (!has13)
   {
-    core12 = myGlCore20;
+    myGlVerMajor = 1;
+    myGlVerMinor = 2;
+    return;
   }
-  if (!hasGlCore13)
+  else if (!has14)
   {
     myGlVerMajor = 1;
-    myGlVerMinor = 2;
+    myGlVerMinor = 3;
     return;
   }
-  else
+  else if (!has15)
   {
-    core13 = myGlCore20;
+    myGlVerMajor = 1;
+    myGlVerMinor = 4;
+    return;
   }
-  if(!hasGlCore14)
+  core15    = (OpenGl_GlCore15*    )(&(*myFuncs));
+  core15fwd = (OpenGl_GlCore15Fwd* )(&(*myFuncs));
+
+  if (!has20)
   {
     myGlVerMajor = 1;
-    myGlVerMinor = 3;
+    myGlVerMinor = 5;
     return;
   }
-  else
+
+  core20    = (OpenGl_GlCore20*    )(&(*myFuncs));
+  core20fwd = (OpenGl_GlCore20Fwd* )(&(*myFuncs));
+
+  if (!has21)
   {
-    core14 = myGlCore20;
+    myGlVerMajor = 2;
+    myGlVerMinor = 0;
+    return;
   }
-  if(!hasGlCore15)
+
+  if (!has30)
   {
-    myGlVerMajor = 1;
-    myGlVerMinor = 4;
+    myGlVerMajor = 2;
+    myGlVerMinor = 1;
     return;
   }
-  else
+
+  if (!has31)
   {
-    core15 = myGlCore20;
+    myGlVerMajor = 3;
+    myGlVerMinor = 0;
+    return;
   }
-  if(!hasGlCore20)
+  arbTBO = (OpenGl_ArbTBO* )(&(*myFuncs));
+  arbIns = (OpenGl_ArbIns* )(&(*myFuncs));
+
+  if (!has32)
   {
-    myGlVerMajor = 1;
-    myGlVerMinor = 5;
+    myGlVerMajor = 3;
+    myGlVerMinor = 1;
+    return;
   }
-  else
+  core32     = (OpenGl_GlCore32*     )(&(*myFuncs));
+  core32back = (OpenGl_GlCore32Back* )(&(*myFuncs));
+
+  if (!has33)
+  {
+    myGlVerMajor = 3;
+    myGlVerMinor = 2;
+    return;
+  }
+
+  if (!has40)
   {
-    core20 = myGlCore20;
+    myGlVerMajor = 3;
+    myGlVerMinor = 3;
+    return;
+  }
+
+  if (!has41)
+  {
+    myGlVerMajor = 4;
+    myGlVerMinor = 0;
+    return;
+  }
+  core41     = (OpenGl_GlCore41*     )(&(*myFuncs));
+  core41back = (OpenGl_GlCore41Back* )(&(*myFuncs));
+
+  if(!has42)
+  {
+    myGlVerMajor = 4;
+    myGlVerMinor = 1;
+    return;
+  }
+  core42     = (OpenGl_GlCore42*     )(&(*myFuncs));
+  core42back = (OpenGl_GlCore42Back* )(&(*myFuncs));
+
+  if(!has43)
+  {
+    myGlVerMajor = 4;
+    myGlVerMinor = 2;
+    return;
+  }
+  core43     = (OpenGl_GlCore43*     )(&(*myFuncs));
+  core43back = (OpenGl_GlCore43Back* )(&(*myFuncs));
+
+  if (!has44)
+  {
+    myGlVerMajor = 4;
+    myGlVerMinor = 3;
+    return;
   }
+  core44     = (OpenGl_GlCore44*     )(&(*myFuncs));
+  core44back = (OpenGl_GlCore44Back* )(&(*myFuncs));
 }
 
 // =======================================================================
index c1891dc..f0ce577 100644 (file)
 #include <OpenGl_GlCore11.hxx>
 
 //! Forward declarations
-struct OpenGl_GlCore12;
-struct OpenGl_GlCore13;
-struct OpenGl_GlCore14;
-struct OpenGl_GlCore15;
-struct OpenGl_GlCore20;
-struct OpenGl_ArbVBO;
+struct OpenGl_GlFunctions;
 struct OpenGl_ArbTBO;
 struct OpenGl_ArbIns;
 struct OpenGl_ArbDbg;
-struct OpenGl_ExtFBO;
+struct OpenGl_ArbFBO;
 struct OpenGl_ExtGS;
 
+template<typename theBaseClass_t> struct OpenGl_TmplCore12;
+typedef OpenGl_TmplCore12<OpenGl_GlCore11>     OpenGl_GlCore12;
+typedef OpenGl_TmplCore12<OpenGl_GlCore11Fwd>  OpenGl_GlCore12Fwd;
+
+struct OpenGl_GlCore13;
+struct OpenGl_GlCore13Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore14;
+typedef OpenGl_TmplCore14<OpenGl_GlCore13>     OpenGl_GlCore14;
+typedef OpenGl_TmplCore14<OpenGl_GlCore13Fwd>  OpenGl_GlCore14Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore15;
+typedef OpenGl_TmplCore15<OpenGl_GlCore14>     OpenGl_GlCore15;
+typedef OpenGl_TmplCore15<OpenGl_GlCore14Fwd>  OpenGl_GlCore15Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore20;
+typedef OpenGl_TmplCore20<OpenGl_GlCore15>     OpenGl_GlCore20;
+typedef OpenGl_TmplCore20<OpenGl_GlCore15Fwd>  OpenGl_GlCore20Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore21;
+typedef OpenGl_TmplCore21<OpenGl_GlCore20>     OpenGl_GlCore21;
+typedef OpenGl_TmplCore21<OpenGl_GlCore20Fwd>  OpenGl_GlCore21Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore30;
+typedef OpenGl_TmplCore30<OpenGl_GlCore21>     OpenGl_GlCore30;
+typedef OpenGl_TmplCore30<OpenGl_GlCore21Fwd>  OpenGl_GlCore30Fwd;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore31;
+typedef OpenGl_TmplCore31<OpenGl_GlCore30>     OpenGl_GlCore31Back;
+typedef OpenGl_TmplCore31<OpenGl_GlCore30Fwd>  OpenGl_GlCore31;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore32;
+typedef OpenGl_TmplCore32<OpenGl_GlCore31Back> OpenGl_GlCore32Back;
+typedef OpenGl_TmplCore32<OpenGl_GlCore31>     OpenGl_GlCore32;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore33;
+typedef OpenGl_TmplCore33<OpenGl_GlCore32Back> OpenGl_GlCore33Back;
+typedef OpenGl_TmplCore33<OpenGl_GlCore32>     OpenGl_GlCore33;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore40;
+typedef OpenGl_TmplCore40<OpenGl_GlCore33Back> OpenGl_GlCore40Back;
+typedef OpenGl_TmplCore40<OpenGl_GlCore33>     OpenGl_GlCore40;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore41;
+typedef OpenGl_TmplCore41<OpenGl_GlCore40Back> OpenGl_GlCore41Back;
+typedef OpenGl_TmplCore41<OpenGl_GlCore40>     OpenGl_GlCore41;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore42;
+typedef OpenGl_TmplCore42<OpenGl_GlCore41Back> OpenGl_GlCore42Back;
+typedef OpenGl_TmplCore42<OpenGl_GlCore41>     OpenGl_GlCore42;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore43;
+typedef OpenGl_TmplCore43<OpenGl_GlCore42Back> OpenGl_GlCore43Back;
+typedef OpenGl_TmplCore43<OpenGl_GlCore42>     OpenGl_GlCore43;
+
+template<typename theBaseClass_t> struct OpenGl_TmplCore44;
+typedef OpenGl_TmplCore44<OpenGl_GlCore43Back> OpenGl_GlCore44Back;
+typedef OpenGl_TmplCore44<OpenGl_GlCore43>     OpenGl_GlCore44;
+
 //! This class generalize access to the GL context and available extensions.
 //!
 //! Functions are grouped into structures and accessed as fields.
@@ -67,7 +121,7 @@ struct OpenGl_ExtGS;
 //!
 //! Current implementation provide access to OpenGL core functionality up to 2.0 version
 //! (core12, core13, core14, core15, fields core20).
-//! within several extensions (arbVBO, extFBO, etc.).
+//! within several extensions (arbTBO, arbFBO, etc.).
 //!
 //! Simplified extensions classification:
 //!  - prefixed with NV, AMD, ATI are vendor-specific (however may be provided by other vendors in some cases);
@@ -353,24 +407,35 @@ private:
   //! Private initialization function that should be called only once.
   Standard_EXPORT void init();
 
-public: // core profiles
-
-  OpenGl_GlCore12* core12;
-  OpenGl_GlCore13* core13;
-  OpenGl_GlCore14* core14;
-  OpenGl_GlCore15* core15;
-  OpenGl_GlCore20* core20;
+public: //! @name core profiles
+
+  OpenGl_GlCore11*     core11;     //!< OpenGL 1.1 core functionality
+  OpenGl_GlCore11Fwd*  core11fwd;  //!< OpenGL 1.1 without deprecated entry points
+  OpenGl_GlCore15*     core15;     //!< OpenGL 1.5 core functionality
+  OpenGl_GlCore15Fwd*  core15fwd;  //!< OpenGL 1.5 without deprecated entry points
+  OpenGl_GlCore20*     core20;     //!< OpenGL 2.0 core functionality (includes 1.5)
+  OpenGl_GlCore20Fwd*  core20fwd;  //!< OpenGL 2.0 without deprecated entry points
+  OpenGl_GlCore32*     core32;     //!< OpenGL 3.2 core profile
+  OpenGl_GlCore32Back* core32back; //!< OpenGL 3.2 backward compatibility profile
+  OpenGl_GlCore41*     core41;     //!< OpenGL 4.1 core profile
+  OpenGl_GlCore41Back* core41back; //!< OpenGL 4.1 backward compatibility profile
+  OpenGl_GlCore42*     core42;     //!< OpenGL 4.2 core profile
+  OpenGl_GlCore42Back* core42back; //!< OpenGL 4.2 backward compatibility profile
+  OpenGl_GlCore43*     core43;     //!< OpenGL 4.3 core profile
+  OpenGl_GlCore43Back* core43back; //!< OpenGL 4.3 backward compatibility profile
+  OpenGl_GlCore44*     core44;     //!< OpenGL 4.4 core profile
+  OpenGl_GlCore44Back* core44back; //!< OpenGL 4.4 backward compatibility profile
 
   Handle(OpenGl_Caps) caps; //!< context options
 
-public: // extensions
+public: //! @name extensions
 
   Standard_Boolean arbNPTW; //!< GL_ARB_texture_non_power_of_two
-  OpenGl_ArbVBO*   arbVBO;  //!< GL_ARB_vertex_buffer_object
+  Standard_Boolean arbTexRG;//!< GL_ARB_texture_rg
   OpenGl_ArbTBO*   arbTBO;  //!< GL_ARB_texture_buffer_object
   OpenGl_ArbIns*   arbIns;  //!< GL_ARB_draw_instanced
   OpenGl_ArbDbg*   arbDbg;  //!< GL_ARB_debug_output
-  OpenGl_ExtFBO*   extFBO;  //!< GL_EXT_framebuffer_object
+  OpenGl_ArbFBO*   arbFBO;  //!< GL_ARB_framebuffer_object
   OpenGl_ExtGS*    extGS;   //!< GL_EXT_geometry_shader4
   Standard_Boolean extBgra; //!< GL_EXT_bgra
   Standard_Boolean extAnis; //!< GL_EXT_texture_filter_anisotropic
@@ -408,7 +473,8 @@ private: // context info
   OpenGl_Clipping myClippingState; //!< state of clip planes
 
   void*            myGlLibHandle;     //!< optional handle to GL library
-  OpenGl_GlCore20* myGlCore20;        //!< common structure for GL core functions upto 2.0
+  NCollection_Handle<OpenGl_GlFunctions>
+                   myFuncs;           //!< mega structure for all GL functions
   Standard_Integer myAnisoMax;        //!< maximum level of anisotropy texture filter
   Standard_Integer myMaxTexDim;       //!< value for GL_MAX_TEXTURE_SIZE
   Standard_Integer myMaxClipPlanes;   //!< value for GL_MAX_CLIP_PLANES
diff --git a/src/OpenGl/OpenGl_ExtFBO.hxx b/src/OpenGl/OpenGl_ExtFBO.hxx
deleted file mode 100644 (file)
index 4539dac..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-// Created on: 2012-01-26
-// Created by: Kirill GAVRILOV
-// Copyright (c) 2012-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _OpenGl_ExtFBO_H__
-#define _OpenGl_ExtFBO_H__
-
-#include <OpenGl_GlCore12.hxx>
-
-//! FBO is available on OpenGL 2.0+ hardware
-struct OpenGl_ExtFBO
-{
-
-  PFNGLGENFRAMEBUFFERSEXTPROC         glGenFramebuffersEXT;
-  PFNGLDELETEFRAMEBUFFERSEXTPROC      glDeleteFramebuffersEXT;
-  PFNGLBINDFRAMEBUFFEREXTPROC         glBindFramebufferEXT;
-  PFNGLFRAMEBUFFERTEXTURE2DEXTPROC    glFramebufferTexture2DEXT;
-  PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC  glCheckFramebufferStatusEXT;
-  PFNGLGENRENDERBUFFERSEXTPROC        glGenRenderbuffersEXT;
-  PFNGLDELETERENDERBUFFERSEXTPROC     glDeleteRenderbuffersEXT;
-  PFNGLBINDRENDERBUFFEREXTPROC        glBindRenderbufferEXT;
-  PFNGLRENDERBUFFERSTORAGEEXTPROC     glRenderbufferStorageEXT;
-  PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
-  PFNGLGENERATEMIPMAPEXTPROC          glGenerateMipmapEXT;
-
-};
-
-#endif // _OpenGl_ExtFBO_H__
index 4babc4a..dd7f146 100644 (file)
 #ifndef _OpenGl_ExtGS_H__
 #define _OpenGl_ExtGS_H__
 
-#include <OpenGl_GlCore12.hxx>
+#include <OpenGl_GlFunctions.hxx>
 
 //! Geometry shader as extension is available on OpenGL 2.0+
-struct OpenGl_ExtGS
+struct OpenGl_ExtGS : protected OpenGl_GlFunctions
 {
-  PFNGLPROGRAMPARAMETERIEXTPROC glProgramParameteriEXT;
+  using OpenGl_GlFunctions::glProgramParameteriEXT;
 };
 
 #endif // _OpenGl_ExtGS_H__
index 9a435d2..b0faf4c 100644 (file)
@@ -13,6 +13,7 @@
 // commercial license or contractual agreement.
 
 #include <OpenGl_FrameBuffer.hxx>
+#include <OpenGl_ArbFBO.hxx>
 
 #include <Standard_Assert.hxx>
 
@@ -71,7 +72,7 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
                                            const GLsizei   theViewportSizeY,
                                            const GLboolean toForcePowerOfTwo)
 {
-  if (theGlContext->extFBO == NULL)
+  if (theGlContext->arbFBO == NULL)
   {
     return Standard_False;
   }
@@ -109,33 +110,33 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
   if (!theGlContext->extPDS)
   {
     // Create RenderBuffer to be used as depth buffer
-    theGlContext->extFBO->glGenRenderbuffersEXT (1, &myGlDepthRBId);
-    theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, myGlDepthRBId);
-    theGlContext->extFBO->glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, mySizeX, mySizeY);
+    theGlContext->arbFBO->glGenRenderbuffers (1, &myGlDepthRBId);
+    theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBId);
+    theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH_COMPONENT, mySizeX, mySizeY);
 
     // Create RenderBuffer to be used as stencil buffer
-    theGlContext->extFBO->glGenRenderbuffersEXT (1, &myGlStencilRBId);
-    theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, myGlStencilRBId);
-    theGlContext->extFBO->glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_STENCIL_INDEX, mySizeX, mySizeY);
+    theGlContext->arbFBO->glGenRenderbuffers (1, &myGlStencilRBId);
+    theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlStencilRBId);
+    theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, GL_STENCIL_INDEX, mySizeX, mySizeY);
   }
   else
   {
     // Create combined depth stencil buffer
-    theGlContext->extFBO->glGenRenderbuffersEXT (1, &myGlDepthRBId);
-    theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, myGlDepthRBId);
-    theGlContext->extFBO->glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, mySizeX, mySizeY);
+    theGlContext->arbFBO->glGenRenderbuffers (1, &myGlDepthRBId);
+    theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlDepthRBId);
+    theGlContext->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, mySizeX, mySizeY);
     myGlStencilRBId = myGlDepthRBId;
   }
 
   // Build FBO and setup it as texture
-  theGlContext->extFBO->glGenFramebuffersEXT (1, &myGlFBufferId);
-  theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
+  theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
+  theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
   glEnable (GL_TEXTURE_2D);
   glBindTexture (GL_TEXTURE_2D, myGlTextureId);
-  theGlContext->extFBO->glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, myGlTextureId, 0);
-  theGlContext->extFBO->glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myGlDepthRBId);
-  theGlContext->extFBO->glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myGlStencilRBId);
-  if (theGlContext->extFBO->glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
+  theGlContext->arbFBO->glFramebufferTexture2D    (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,  GL_TEXTURE_2D,   myGlTextureId, 0);
+  theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,   GL_RENDERBUFFER, myGlDepthRBId);
+  theGlContext->arbFBO->glFramebufferRenderbuffer (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, myGlStencilRBId);
+  if (theGlContext->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
   {
     if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY))
     {
@@ -147,7 +148,7 @@ Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlCo
 
   UnbindBuffer  (theGlContext);
   UnbindTexture (theGlContext);
-  theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, NO_RENDERBUFFER);
+  theGlContext->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, NO_RENDERBUFFER);
   return Standard_True;
 }
 
@@ -171,7 +172,7 @@ void OpenGl_FrameBuffer::Release (const OpenGl_Context* theGlCtx)
     if (theGlCtx->IsValid()
      && myGlStencilRBId != myGlDepthRBId)
     {
-      theGlCtx->extFBO->glDeleteRenderbuffersEXT (1, &myGlStencilRBId);
+      theGlCtx->arbFBO->glDeleteRenderbuffers (1, &myGlStencilRBId);
     }
     myGlStencilRBId = NO_RENDERBUFFER;
   }
@@ -179,7 +180,7 @@ void OpenGl_FrameBuffer::Release (const OpenGl_Context* theGlCtx)
   {
     if (theGlCtx->IsValid())
     {
-      theGlCtx->extFBO->glDeleteRenderbuffersEXT (1, &myGlDepthRBId);
+      theGlCtx->arbFBO->glDeleteRenderbuffers (1, &myGlDepthRBId);
     }
     myGlDepthRBId = NO_RENDERBUFFER;
   }
@@ -196,7 +197,7 @@ void OpenGl_FrameBuffer::Release (const OpenGl_Context* theGlCtx)
   {
     if (theGlCtx->IsValid())
     {
-      theGlCtx->extFBO->glDeleteFramebuffersEXT (1, &myGlFBufferId);
+      theGlCtx->arbFBO->glDeleteFramebuffers (1, &myGlFBufferId);
     }
     myGlFBufferId = NO_FRAMEBUFFER;
   }
@@ -286,7 +287,7 @@ void OpenGl_FrameBuffer::ChangeViewport (const GLsizei theVPSizeX,
 // =======================================================================
 void OpenGl_FrameBuffer::BindBuffer (const Handle(OpenGl_Context)& theGlCtx)
 {
-  theGlCtx->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
+  theGlCtx->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
 }
 
 // =======================================================================
@@ -295,7 +296,7 @@ void OpenGl_FrameBuffer::BindBuffer (const Handle(OpenGl_Context)& theGlCtx)
 // =======================================================================
 void OpenGl_FrameBuffer::UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx)
 {
-  theGlCtx->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, NO_FRAMEBUFFER);
+  theGlCtx->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, NO_FRAMEBUFFER);
 }
 
 // =======================================================================
index d5cf010..4bdd5c9 100644 (file)
@@ -16,7 +16,6 @@
 #define OPENGL_FRAME_BUFFER_H
 
 #include <OpenGl_Context.hxx>
-#include <OpenGl_ExtFBO.hxx>
 #include <OpenGl_Resource.hxx>
 
 #include <Standard_Boolean.hxx>
index 0757c87..cd2611d 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore11_H__
-#define _OpenGl_GlCore11_H__
-
-// required for correct APIENTRY definition
-#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-
-#ifndef APIENTRY
-  #define APIENTRY
-#endif
-#ifndef APIENTRYP
-  #define APIENTRYP APIENTRY *
-#endif
-#ifndef GLAPI
-  #define GLAPI extern
-#endif
-
-// exclude modern definitions and system-provided glext.h, should be defined before gl.h inclusion
-#define GL_GLEXT_LEGACY
-
-// include main OpenGL header provided with system
-#if defined(__APPLE__)
-  #include <OpenGL/gl.h>
-  #include <OpenGL/glu.h>
-  #define __X_GL_H // prevent chaotic gl.h inclusions to avoid compile errors
-#else
-  #include <GL/gl.h>
-  #include <GL/glu.h>
-#endif
-
-#include <InterfaceGraphic.hxx>
-#include <InterfaceGraphic_tgl_all.hxx>
-#include <InterfaceGraphic_telem.hxx>
-
-#endif // _OpenGl_GlCore11_H__
+#ifndef _OpenGl_GlCore11_Header
+#define _OpenGl_GlCore11_Header
+
+#include <OpenGl_GlCore11Fwd.hxx>
+
+//! OpenGL 1.1 core.
+//! Notice that all functions within this structure are actually exported by system GL library.
+//! The main purpose for these hint - to control visibility of functions per GL version
+//! (global functions should not be used directly to achieve this effect!).
+struct OpenGl_GlCore11 : protected OpenGl_GlFunctions
+{
+
+public: //! @name Begin/End primitive specification (removed since 3.1)
+
+  inline void glBegin (GLenum theMode)
+  {
+    ::glBegin (theMode);
+  }
+
+  inline void glEnd()
+  {
+    ::glEnd();
+  }
+
+  inline void glVertex2d (GLdouble theX, GLdouble theY)
+  {
+    ::glVertex2d (theX, theY);
+  }
+
+  inline void glVertex2f (GLfloat  theX, GLfloat  theY)
+  {
+    ::glVertex2f (theX, theY);
+  }
+
+  inline void glVertex2i (GLint    theX, GLint    theY)
+  {
+    ::glVertex2i (theX, theY);
+  }
+
+  inline void glVertex2s (GLshort  theX, GLshort  theY)
+  {
+    ::glVertex2s (theX, theY);
+  }
+
+  inline void glVertex3d (GLdouble theX, GLdouble theY, GLdouble theZ)
+  {
+    ::glVertex3d (theX, theY, theZ);
+  }
+
+  inline void glVertex3f (GLfloat  theX, GLfloat  theY, GLfloat  theZ)
+  {
+    ::glVertex3f (theX, theY, theZ);
+  }
+
+  inline void glVertex3i (GLint    theX, GLint    theY, GLint    theZ)
+  {
+    ::glVertex3i (theX, theY, theZ);
+  }
+
+  inline void glVertex3s (GLshort  theX, GLshort  theY, GLshort  theZ)
+  {
+    ::glVertex3s (theX, theY, theZ);
+  }
+
+  inline void glVertex4d (GLdouble theX, GLdouble theY, GLdouble theZ, GLdouble theW)
+  {
+    ::glVertex4d (theX, theY, theZ, theW);
+  }
+
+  inline void glVertex4f (GLfloat  theX, GLfloat  theY, GLfloat  theZ, GLfloat  theW)
+  {
+    ::glVertex4f (theX, theY, theZ, theW);
+  }
+
+  inline void glVertex4i (GLint    theX, GLint    theY, GLint    theZ, GLint    theW)
+  {
+    ::glVertex4i (theX, theY, theZ, theW);
+  }
+
+  inline void glVertex4s (GLshort  theX, GLshort  theY, GLshort  theZ, GLshort  theW)
+  {
+    ::glVertex4s (theX, theY, theZ, theW);
+  }
+
+  inline void glVertex2dv (const GLdouble* theVec2)
+  {
+    ::glVertex2dv (theVec2);
+  }
+
+  inline void glVertex2fv (const GLfloat*  theVec2)
+  {
+    ::glVertex2fv (theVec2);
+  }
+
+  inline void glVertex2iv (const GLint*    theVec2)
+  {
+    ::glVertex2iv (theVec2);
+  }
+
+  inline void glVertex2sv (const GLshort*  theVec2)
+  {
+    ::glVertex2sv (theVec2);
+  }
+
+  inline void glVertex3dv (const GLdouble* theVec3)
+  {
+    ::glVertex3dv (theVec3);
+  }
+
+  inline void glVertex3fv (const GLfloat*  theVec3)
+  {
+    ::glVertex3fv (theVec3);
+  }
+
+  inline void glVertex3iv (const GLint*    theVec3)
+  {
+    ::glVertex3iv (theVec3);
+  }
+
+  inline void glVertex3sv (const GLshort*  theVec3)
+  {
+    ::glVertex3sv (theVec3);
+  }
+
+  inline void glVertex4dv (const GLdouble* theVec4)
+  {
+    ::glVertex4dv (theVec4);
+  }
+
+  inline void glVertex4fv (const GLfloat*  theVec4)
+  {
+    ::glVertex4fv (theVec4);
+  }
+
+  inline void glVertex4iv (const GLint*    theVec4)
+  {
+    ::glVertex4iv (theVec4);
+  }
+
+  inline void glVertex4sv (const GLshort*  theVec4)
+  {
+    ::glVertex4sv (theVec4);
+  }
+
+  inline void glNormal3b (GLbyte   nx, GLbyte   ny, GLbyte   nz)
+  {
+    ::glNormal3b(nx, ny, nz);
+  }
+
+  inline void glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
+  {
+    ::glNormal3d(nx, ny, nz);
+  }
+
+  inline void glNormal3f (GLfloat  nx, GLfloat  ny, GLfloat  nz)
+  {
+    ::glNormal3f(nx, ny, nz);
+  }
+
+  inline void glNormal3i (GLint    nx, GLint    ny, GLint    nz)
+  {
+    ::glNormal3i(nx, ny, nz);
+  }
+
+  inline void glNormal3s (GLshort nx, GLshort ny, GLshort nz)
+  {
+    ::glNormal3s(nx, ny, nz);
+  }
+
+  inline void glNormal3bv (const GLbyte*   theVec)
+  {
+    ::glNormal3bv (theVec);
+  }
+
+  inline void glNormal3dv (const GLdouble* theVec)
+  {
+    ::glNormal3dv (theVec);
+  }
+
+  inline void glNormal3fv (const GLfloat*  theVec)
+  {
+    ::glNormal3fv (theVec);
+  }
+
+  inline void glNormal3iv (const GLint*    theVec)
+  {
+    ::glNormal3iv (theVec);
+  }
+
+  inline void glNormal3sv (const GLshort*  theVec)
+  {
+    ::glNormal3sv (theVec);
+  }
+
+  inline void glIndexd (GLdouble c)
+  {
+    ::glIndexd(c);
+  }
+
+  inline void glIndexf (GLfloat c)
+  {
+    ::glIndexf(c);
+  }
+
+  inline void glIndexi (GLint c)
+  {
+    ::glIndexi(c);
+  }
+
+  inline void glIndexs (GLshort c)
+  {
+    ::glIndexs(c);
+  }
+
+  inline void glIndexub (GLubyte c)
+  {
+    ::glIndexub(c);
+  }
+
+  inline void glIndexdv (const GLdouble* c)
+  {
+    ::glIndexdv(c);
+  }
+
+  inline void glIndexfv (const GLfloat* c)
+  {
+    ::glIndexfv(c);
+  }
+
+  inline void glIndexiv (const GLint* c)
+  {
+    ::glIndexiv(c);
+  }
+
+  inline void glIndexsv (const GLshort* c)
+  {
+    ::glIndexsv(c);
+  }
+
+  inline void glIndexubv (const GLubyte* c)
+  {
+    ::glIndexubv(c);
+  }
+
+  inline void glColor3b (GLbyte theRed, GLbyte theGreen, GLbyte theBlue)
+  {
+    ::glColor3b (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3d (GLdouble theRed, GLdouble theGreen, GLdouble theBlue)
+  {
+    ::glColor3d (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3f (GLfloat theRed, GLfloat theGreen, GLfloat theBlue)
+  {
+    ::glColor3f (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3i (GLint theRed, GLint theGreen, GLint theBlue)
+  {
+    ::glColor3i (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3s (GLshort theRed, GLshort theGreen, GLshort theBlue)
+  {
+    ::glColor3s (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3ub (GLubyte theRed, GLubyte theGreen, GLubyte theBlue)
+  {
+    ::glColor3ub (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3ui (GLuint theRed, GLuint theGreen, GLuint theBlue)
+  {
+    ::glColor3ui (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor3us (GLushort theRed, GLushort theGreen, GLushort theBlue)
+  {
+    ::glColor3us (theRed, theGreen, theBlue);
+  }
+
+  inline void glColor4b (GLbyte theRed, GLbyte theGreen, GLbyte theBlue, GLbyte theAlpha)
+  {
+    ::glColor4b (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4d (GLdouble theRed, GLdouble theGreen, GLdouble theBlue, GLdouble theAlpha)
+  {
+    ::glColor4d (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4f (GLfloat theRed, GLfloat theGreen, GLfloat theBlue, GLfloat theAlpha)
+  {
+    ::glColor4f (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4i (GLint theRed, GLint theGreen, GLint theBlue, GLint theAlpha)
+  {
+    ::glColor4i (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4s (GLshort theRed, GLshort theGreen, GLshort theBlue, GLshort theAlpha)
+  {
+    ::glColor4s (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4ub (GLubyte theRed, GLubyte theGreen, GLubyte theBlue, GLubyte theAlpha)
+  {
+    ::glColor4ub (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4ui (GLuint theRed, GLuint theGreen, GLuint theBlue, GLuint theAlpha)
+  {
+    ::glColor4ui (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor4us (GLushort theRed, GLushort theGreen, GLushort theBlue, GLushort theAlpha)
+  {
+    ::glColor4us (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glColor3bv (const GLbyte*    theVec)
+  {
+    ::glColor3bv (theVec);
+  }
+
+  inline void glColor3dv (const GLdouble*  theVec)
+  {
+    ::glColor3dv (theVec);
+  }
+
+  inline void glColor3fv (const GLfloat*   theVec)
+  {
+    ::glColor3fv (theVec);
+  }
+
+  inline void glColor3iv (const GLint*     theVec)
+  {
+    ::glColor3iv (theVec);
+  }
+
+  inline void glColor3sv (const GLshort*   theVec)
+  {
+    ::glColor3sv (theVec);
+  }
+
+  inline void glColor3ubv (const GLubyte*  theVec)
+  {
+    ::glColor3ubv (theVec);
+  }
+
+  inline void glColor3uiv (const GLuint*   theVec)
+  {
+    ::glColor3uiv (theVec);
+  }
+
+  inline void glColor3usv (const GLushort* theVec)
+  {
+    ::glColor3usv (theVec);
+  }
+
+  inline void glColor4bv (const GLbyte*    theVec)
+  {
+    ::glColor4bv (theVec);
+  }
+
+  inline void glColor4dv (const GLdouble*  theVec)
+  {
+    ::glColor4dv (theVec);
+  }
+
+  inline void glColor4fv (const GLfloat*   theVec)
+  {
+    ::glColor4fv (theVec);
+  }
+
+  inline void glColor4iv (const GLint*     theVec)
+  {
+    ::glColor4iv (theVec);
+  }
+
+  inline void glColor4sv (const GLshort*   theVec)
+  {
+    ::glColor4sv (theVec);
+  }
+
+  inline void glColor4ubv (const GLubyte*  theVec)
+  {
+    ::glColor4ubv (theVec);
+  }
+
+  inline void glColor4uiv (const GLuint*   theVec)
+  {
+    ::glColor4uiv (theVec);
+  }
+
+  inline void glColor4usv (const GLushort* theVec)
+  {
+    ::glColor4usv (theVec);
+  }
+
+  inline void glTexCoord1d (GLdouble s)
+  {
+    ::glTexCoord1d(s);
+  }
+
+  inline void glTexCoord1f (GLfloat s)
+  {
+    ::glTexCoord1f(s);
+  }
+
+  inline void glTexCoord1i (GLint s)
+  {
+    ::glTexCoord1i(s);
+  }
+
+  inline void glTexCoord1s (GLshort s)
+  {
+    ::glTexCoord1s(s);
+  }
+
+  inline void glTexCoord2d (GLdouble s, GLdouble t)
+  {
+    ::glTexCoord2d(s, t);
+  }
+
+  inline void glTexCoord2f (GLfloat s, GLfloat t)
+  {
+    ::glTexCoord2f(s, t);
+  }
+
+  inline void glTexCoord2i (GLint s, GLint t)
+  {
+    ::glTexCoord2i(s, t);
+  }
+
+  inline void glTexCoord2s (GLshort s, GLshort t)
+  {
+    ::glTexCoord2s(s, t);
+  }
+
+  inline void glTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
+  {
+    ::glTexCoord3d(s, t, r);
+  }
+
+  inline void glTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
+  {
+    ::glTexCoord3f(s, t, r);
+  }
+
+  inline void glTexCoord3i (GLint s, GLint t, GLint r)
+  {
+    ::glTexCoord3i(s, t, r);
+  }
+
+  inline void glTexCoord3s (GLshort s, GLshort t, GLshort r)
+  {
+    ::glTexCoord3s(s, t, r);
+  }
+
+  inline void glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+  {
+    ::glTexCoord4d(s, t, r, q);
+  }
+
+  inline void glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+  {
+    ::glTexCoord4f(s, t, r, q);
+  }
+
+  inline void glTexCoord4i (GLint s, GLint t, GLint r, GLint q)
+  {
+    ::glTexCoord4i(s, t, r, q);
+  }
+
+  inline void glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
+  {
+    ::glTexCoord4s(s, t, r, q);
+  }
+
+  inline void glTexCoord1dv (const GLdouble* theVec1)
+  {
+    ::glTexCoord1dv (theVec1);
+  }
+
+  inline void glTexCoord1fv (const GLfloat*  theVec1)
+  {
+    ::glTexCoord1fv (theVec1);
+  }
+
+  inline void glTexCoord1iv (const GLint*    theVec1)
+  {
+    ::glTexCoord1iv (theVec1);
+  }
+
+  inline void glTexCoord1sv (const GLshort*  theVec1)
+  {
+    ::glTexCoord1sv (theVec1);
+  }
+
+  inline void glTexCoord2dv (const GLdouble* theVec2)
+  {
+    ::glTexCoord2dv (theVec2);
+  }
+
+  inline void glTexCoord2fv (const GLfloat*  theVec2)
+  {
+    ::glTexCoord2fv (theVec2);
+  }
+
+  inline void glTexCoord2iv (const GLint*    theVec2)
+  {
+    ::glTexCoord2iv (theVec2);
+  }
+
+  inline void glTexCoord2sv (const GLshort*  theVec)
+  {
+    ::glTexCoord2sv (theVec);
+  }
+
+  inline void glTexCoord3dv (const GLdouble* theVec3)
+  {
+    ::glTexCoord3dv (theVec3);
+  }
+
+  inline void glTexCoord3fv (const GLfloat*  theVec3)
+  {
+    ::glTexCoord3fv (theVec3);
+  }
+
+  inline void glTexCoord3iv (const GLint*    theVec3)
+  {
+    ::glTexCoord3iv (theVec3);
+  }
+
+  inline void glTexCoord3sv (const GLshort*  theVec3)
+  {
+    ::glTexCoord3sv (theVec3);
+  }
+
+  inline void glTexCoord4dv (const GLdouble* theVec4)
+  {
+    ::glTexCoord4dv (theVec4);
+  }
+
+  inline void glTexCoord4fv (const GLfloat*  theVec4)
+  {
+    ::glTexCoord4fv (theVec4);
+  }
+
+  inline void glTexCoord4iv (const GLint*    theVec4)
+  {
+    ::glTexCoord4iv (theVec4);
+  }
+
+  inline void glTexCoord4sv (const GLshort*  theVec4)
+  {
+    ::glTexCoord4sv (theVec4);
+  }
+
+public: //! @name Matrix operations (removed since 3.1)
+
+  inline void glMatrixMode (GLenum theMode)
+  {
+    ::glMatrixMode (theMode);
+  }
+
+  inline void glOrtho (GLdouble theLeft,    GLdouble theRight,
+                       GLdouble theBottom,  GLdouble theTop,
+                       GLdouble theNearVal, GLdouble theFarVal)
+  {
+    ::glOrtho (theLeft, theRight, theBottom, theTop, theNearVal, theFarVal);
+  }
+
+  inline void glFrustum (GLdouble theLeft,    GLdouble theRight,
+                         GLdouble theBottom,  GLdouble theTop,
+                         GLdouble theNearVal, GLdouble theFarVal)
+  {
+    ::glFrustum (theLeft, theRight, theBottom, theTop, theNearVal, theFarVal);
+  }
+
+  inline void glPushMatrix()
+  {
+    ::glPushMatrix();
+  }
+
+  inline void glPopMatrix()
+  {
+    ::glPopMatrix();
+  }
+
+  inline void glLoadIdentity()
+  {
+    ::glLoadIdentity();
+  }
+
+  inline void glLoadMatrixd (const GLdouble* theMatrix)
+  {
+    ::glLoadMatrixd (theMatrix);
+  }
+
+  inline void glLoadMatrixf (const GLfloat*  theMatrix)
+  {
+    ::glLoadMatrixf (theMatrix);
+  }
+
+  inline void glMultMatrixd (const GLdouble* theMatrix)
+  {
+    ::glMultMatrixd (theMatrix);
+  }
+
+  inline void glMultMatrixf (const GLfloat*  theMatrix)
+  {
+    ::glMultMatrixf (theMatrix);
+  }
+
+  inline void glRotated (GLdouble theAngleDegrees,
+                 GLdouble theX, GLdouble theY, GLdouble theZ)
+  {
+    ::glRotated (theAngleDegrees, theX, theY, theZ);
+  }
+
+  inline void glRotatef (GLfloat theAngleDegrees,
+                 GLfloat theX, GLfloat theY, GLfloat theZ)
+  {
+    ::glRotatef (theAngleDegrees, theX, theY, theZ);
+  }
+
+  inline void glScaled (GLdouble theX, GLdouble theY, GLdouble theZ)
+  {
+    ::glScaled (theX, theY, theZ);
+  }
+
+  inline void glScalef (GLfloat theX, GLfloat theY, GLfloat theZ)
+  {
+    ::glScalef (theX, theY, theZ);
+  }
+
+  inline void glTranslated (GLdouble theX, GLdouble theY, GLdouble theZ)
+  {
+    ::glTranslated (theX, theY, theZ);
+  }
+
+  inline void glTranslatef (GLfloat theX, GLfloat theY, GLfloat theZ)
+  {
+    ::glTranslatef (theX, theY, theZ);
+  }
+
+public: //! @name Line and Polygon stripple (removed since 3.1)
+
+  //void glLineWidth (GLfloat theWidth) { ::glLineWidth (theWidth); }
+
+  inline void glLineStipple (GLint theFactor, GLushort thePattern)
+  {
+    ::glLineStipple (theFactor, thePattern);
+  }
+
+  inline void glPolygonStipple (const GLubyte* theMask)
+  {
+    ::glPolygonStipple (theMask);
+  }
+
+  inline void glGetPolygonStipple (GLubyte* theMask)
+  {
+    ::glGetPolygonStipple (theMask);
+  }
+
+public: //! @name Attribute stacks (removed since 3.1)
+
+  inline void glPushAttrib (GLbitfield theMask)
+  {
+    ::glPushAttrib (theMask);
+  }
+
+  inline void glPopAttrib()
+  {
+    ::glPopAttrib();
+  }
+
+  inline void glPushClientAttrib (GLbitfield theMask)
+  {
+    ::glPushClientAttrib (theMask);
+  }
+
+  inline void glPopClientAttrib()
+  {
+    ::glPopClientAttrib();
+  }
+
+public: //! @name Fixed pipeline lighting (removed since 3.1)
+
+  inline void glShadeModel (GLenum theMode)
+  {
+    ::glShadeModel (theMode);
+  }
+
+  inline void glLightf (GLenum theLight, GLenum pname, GLfloat param)
+  {
+    ::glLightf (theLight, pname, param);
+  }
+
+  inline void glLighti (GLenum theLight, GLenum pname, GLint param)
+  {
+    ::glLighti (theLight, pname, param);
+  }
+
+  inline void glLightfv (GLenum theLight, GLenum pname, const GLfloat* params)
+  {
+    ::glLightfv (theLight, pname, params);
+  }
+
+  inline void glLightiv (GLenum theLight, GLenum pname, const GLint* params)
+  {
+    ::glLightiv (theLight, pname, params);
+  }
+
+  inline void glGetLightfv (GLenum theLight, GLenum pname, GLfloat *params)
+  {
+    ::glGetLightfv (theLight, pname, params);
+  }
+
+  inline void glGetLightiv (GLenum theLight, GLenum pname, GLint *params)
+  {
+    ::glGetLightiv (theLight, pname, params);
+  }
+
+  inline void glLightModelf (GLenum pname, GLfloat param)
+  {
+    ::glLightModelf(pname, param);
+  }
+
+  inline void glLightModeli (GLenum pname, GLint param)
+  {
+    ::glLightModeli(pname, param);
+  }
+
+  inline void glLightModelfv (GLenum pname, const GLfloat* params)
+  {
+    ::glLightModelfv(pname, params);
+  }
+
+  inline void glLightModeliv (GLenum pname, const GLint* params)
+  {
+    ::glLightModeliv(pname, params);
+  }
+
+  inline void glMaterialf (GLenum face, GLenum pname, GLfloat param)
+  {
+    ::glMaterialf(face, pname, param);
+  }
+
+  inline void glMateriali (GLenum face, GLenum pname, GLint param)
+  {
+    ::glMateriali(face, pname, param);
+  }
+
+  inline void glMaterialfv (GLenum face, GLenum pname, const GLfloat* params)
+  {
+    ::glMaterialfv(face, pname, params);
+  }
+
+  inline void glMaterialiv (GLenum face, GLenum pname, const GLint* params)
+  {
+    ::glMaterialiv(face, pname, params);
+  }
+
+  inline void glGetMaterialfv (GLenum face, GLenum pname, GLfloat* params)
+  {
+    ::glGetMaterialfv(face, pname, params);
+  }
+
+  inline void glGetMaterialiv (GLenum face, GLenum pname, GLint* params)
+  {
+    ::glGetMaterialiv(face, pname, params);
+  }
+
+  inline void glColorMaterial (GLenum face, GLenum mode)
+  {
+    ::glColorMaterial(face, mode);
+  }
+
+public: //! @name clipping plane (removed since 3.1)
+
+  inline void glClipPlane (GLenum thePlane, const GLdouble* theEquation)
+  {
+    ::glClipPlane (thePlane, theEquation);
+  }
+
+  inline void glGetClipPlane (GLenum thePlane, GLdouble* theEquation)
+  {
+    ::glGetClipPlane (thePlane, theEquation);
+  }
+
+public: //! @name Display lists (removed since 3.1)
+
+  inline GLboolean glIsList (GLuint theList) {
+    return ::glIsList (theList);
+  }
+
+  inline void glDeleteLists (GLuint theList, GLsizei theRange)
+  {
+    ::glDeleteLists (theList, theRange);
+  }
+
+  inline GLuint glGenLists (GLsizei theRange)
+  {
+    return ::glGenLists (theRange);
+  }
+
+  inline void glNewList (GLuint theList, GLenum theMode)
+  {
+    ::glNewList (theList, theMode);
+  }
+
+  inline void glEndList()
+  {
+    ::glEndList();
+  }
+
+  inline void glCallList (GLuint theList)
+  {
+    ::glCallList (theList);
+  }
+
+  inline void glCallLists (GLsizei theNb, GLenum theType, const GLvoid* theLists)
+  {
+    ::glCallLists (theNb, theType, theLists);
+  }
+
+  inline void glListBase (GLuint theBase)
+  {
+    ::glListBase (theBase);
+  }
+
+public: //! @name Current raster position and Rectangles (removed since 3.1)
+
+  inline void glRasterPos2d (GLdouble x, GLdouble y)
+  {
+    ::glRasterPos2d (x, y);
+  }
+
+  inline void glRasterPos2f (GLfloat  x, GLfloat  y)
+  {
+    ::glRasterPos2f (x, y);
+  }
+
+  inline void glRasterPos2i (GLint    x, GLint    y)
+  {
+    ::glRasterPos2i (x, y);
+  }
+
+  inline void glRasterPos2s (GLshort  x, GLshort  y)
+  {
+    ::glRasterPos2s (x, y);
+  }
+
+  inline void glRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
+  {
+    ::glRasterPos3d (x, y, z);
+  }
+
+  inline void glRasterPos3f (GLfloat  x, GLfloat  y, GLfloat  z)
+  {
+    ::glRasterPos3f (x, y, z);
+  }
+
+  inline void glRasterPos3i (GLint    x, GLint    y, GLint    z)
+  {
+    ::glRasterPos3i (x, y, z);
+  }
+
+  inline void glRasterPos3s (GLshort  x, GLshort  y, GLshort  z)
+  {
+    ::glRasterPos3s (x, y, z);
+  }
+
+  inline void glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+  {
+    ::glRasterPos4d (x, y, z, w);
+  }
+
+  inline void glRasterPos4f (GLfloat  x, GLfloat  y, GLfloat  z, GLfloat  w)
+  {
+    ::glRasterPos4f (x, y, z, w);
+  }
+
+  inline void glRasterPos4i (GLint    x, GLint    y, GLint    z, GLint    w)
+  {
+    ::glRasterPos4i (x, y, z, w);
+  }
+
+  inline void glRasterPos4s (GLshort  x, GLshort  y, GLshort  z, GLshort  w)
+  {
+    ::glRasterPos4s (x, y, z, w);
+  }
+
+  inline void glRasterPos2dv (const GLdouble* theVec)
+  {
+    ::glRasterPos2dv (theVec);
+  }
+
+  inline void glRasterPos2fv (const GLfloat*  theVec)
+  {
+    ::glRasterPos2fv (theVec);
+  }
+
+  inline void glRasterPos2iv (const GLint*    theVec)
+  {
+    ::glRasterPos2iv (theVec);
+  }
+
+  inline void glRasterPos2sv (const GLshort*  theVec)
+  {
+    ::glRasterPos2sv (theVec);
+  }
+
+  inline void glRasterPos3dv (const GLdouble* theVec)
+  {
+    ::glRasterPos3dv (theVec);
+  }
+
+  inline void glRasterPos3fv (const GLfloat*  theVec)
+  {
+    ::glRasterPos3fv (theVec);
+  }
+
+  inline void glRasterPos3iv (const GLint*    theVec)
+  {
+    ::glRasterPos3iv (theVec);
+  }
+
+  inline void glRasterPos3sv (const GLshort*  theVec)
+  {
+    ::glRasterPos3sv (theVec);
+  }
+
+  inline void glRasterPos4dv (const GLdouble* theVec)
+  {
+    ::glRasterPos4dv (theVec);
+  }
+
+  inline void glRasterPos4fv (const GLfloat*  theVec)
+  {
+    ::glRasterPos4fv (theVec);
+  }
+
+  inline void glRasterPos4iv (const GLint*    theVec)
+  {
+    ::glRasterPos4iv (theVec);
+  }
+
+  inline void glRasterPos4sv (const GLshort*  theVec)
+  {
+    ::glRasterPos4sv (theVec);
+  }
+
+  inline void glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+  {
+    ::glRectd (x1, y1, x2, y2);
+  }
+
+  inline void glRectf (GLfloat  x1, GLfloat  y1, GLfloat  x2, GLfloat  y2)
+  {
+    ::glRectf (x1, y1, x2, y2);
+  }
+
+  inline void glRecti (GLint    x1, GLint    y1, GLint    x2, GLint    y2)
+  {
+    ::glRecti (x1, y1, x2, y2);
+  }
+
+  inline void glRects (GLshort  x1, GLshort  y1, GLshort  x2, GLshort  y2)
+  {
+    ::glRects (x1, y1, x2, y2);
+  }
+
+  inline void glRectdv (const GLdouble* v1, const GLdouble* v2)
+  {
+    ::glRectdv (v1, v2);
+  }
+
+  inline void glRectfv (const GLfloat*  v1, const GLfloat*  v2)
+  {
+    ::glRectfv (v1, v2);
+  }
+
+  inline void glRectiv (const GLint*    v1, const GLint*    v2)
+  {
+    ::glRectiv (v1, v2);
+  }
+
+  inline void glRectsv (const GLshort*  v1, const GLshort*  v2)
+  {
+    ::glRectsv (v1, v2);
+  }
+
+public: //! @name Texture mapping (removed since 3.1)
+
+  inline void glTexGend (GLenum coord, GLenum pname, GLdouble param)
+  {
+    ::glTexGend (coord, pname, param);
+  }
+
+  inline void glTexGenf (GLenum coord, GLenum pname, GLfloat param)
+  {
+    ::glTexGenf (coord, pname, param);
+  }
+
+  inline void glTexGeni (GLenum coord, GLenum pname, GLint param)
+  {
+    ::glTexGeni (coord, pname, param);
+  }
+
+  inline void glTexGendv (GLenum coord, GLenum pname, const GLdouble* params)
+  {
+    ::glTexGendv (coord, pname, params);
+  }
+
+  inline void glTexGenfv (GLenum coord, GLenum pname, const GLfloat* params)
+  {
+    ::glTexGenfv (coord, pname, params);
+  }
+
+  inline void glTexGeniv (GLenum coord, GLenum pname, const GLint* params)
+  {
+    ::glTexGeniv (coord, pname, params);
+  }
+
+  inline void glGetTexGendv (GLenum coord, GLenum pname, GLdouble* params)
+  {
+    ::glGetTexGendv (coord, pname, params);
+  }
+
+  inline void glGetTexGenfv (GLenum coord, GLenum pname, GLfloat* params)
+  {
+    ::glGetTexGenfv (coord, pname, params);
+  }
+
+  inline void glGetTexGeniv (GLenum coord, GLenum pname, GLint* params)
+  {
+    ::glGetTexGeniv (coord, pname, params);
+  }
+
+public: //! @name Resident textures and priorities (removed since 3.1)
+
+  inline void glPrioritizeTextures (GLsizei n, const GLuint* textures, const GLclampf* priorities)
+  {
+    ::glPrioritizeTextures (n, textures, priorities);
+  }
+
+  inline GLboolean glAreTexturesResident (GLsizei n, const GLuint* textures, GLboolean* residences)
+  {
+    return ::glAreTexturesResident (n, textures, residences);
+  }
+
+public: //! @name Pixel copying (removed since 3.1)
+
+  inline void glDrawPixels (GLsizei width, GLsizei height,
+                            GLenum format, GLenum type,
+                            const GLvoid* pixels)
+  {
+    ::glDrawPixels (width, height, format, type, pixels);
+  }
+
+  inline void glCopyPixels (GLint x, GLint y,
+                    GLsizei width, GLsizei height,
+                    GLenum type)
+  {
+    ::glCopyPixels (x, y, width, height, type);
+  }
+
+  inline void glBitmap (GLsizei width, GLsizei height,
+                        GLfloat xorig, GLfloat yorig,
+                        GLfloat xmove, GLfloat ymove,
+                        const GLubyte* bitmap)
+  {
+    ::glBitmap (width, height, xorig, yorig, xmove, ymove, bitmap);
+  }
+
+  inline void glPixelZoom (GLfloat xfactor, GLfloat yfactor)
+  {
+    ::glPixelZoom (xfactor, yfactor);
+  }
+
+public: //! @name Fog and all associated parameters (removed since 3.1)
+
+  inline void glFogf (GLenum pname, GLfloat param)
+  {
+    ::glFogf (pname, param);
+  }
+
+  inline void glFogi (GLenum pname, GLint param)
+  {
+    ::glFogi (pname, param);
+  }
+
+  inline void glFogfv (GLenum pname, const GLfloat* params)
+  {
+    ::glFogfv (pname, params);
+  }
+
+  inline void glFogiv (GLenum pname, const GLint* params)
+  {
+    ::glFogiv (pname, params);
+  }
+
+public: //! @name Evaluators (removed since 3.1)
+
+  inline void glMap1d (GLenum target, GLdouble u1, GLdouble u2,
+                       GLint stride,
+                       GLint order, const GLdouble* points)
+  {
+    ::glMap1d (target, u1, u2, stride, order, points);
+  }
+
+  inline void glMap1f (GLenum target, GLfloat u1, GLfloat u2,
+                       GLint stride,
+                       GLint order, const GLfloat* points)
+  {
+    ::glMap1f (target, u1, u2, stride, order, points);
+  }
+
+  inline void glMap2d (GLenum target,
+                       GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
+                       GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
+                       const GLdouble* points)
+  {
+    ::glMap2d (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  }
+
+  inline void glMap2f (GLenum target,
+                       GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
+                       GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
+                       const GLfloat* points)
+  {
+    ::glMap2f (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  }
+
+  inline void glGetMapdv (GLenum target, GLenum query, GLdouble* v)
+  {
+    ::glGetMapdv (target, query, v);
+  }
+
+  inline void glGetMapfv (GLenum target, GLenum query, GLfloat* v)
+  {
+    ::glGetMapfv (target, query, v);
+  }
+
+  inline void glGetMapiv (GLenum target, GLenum query, GLint* v)
+  {
+    ::glGetMapiv (target, query, v);
+  }
+
+  inline void glEvalCoord1d (GLdouble u)
+  {
+    ::glEvalCoord1d (u);
+  }
+
+  inline void glEvalCoord1f (GLfloat u)
+  {
+    ::glEvalCoord1f (u);
+  }
+
+  inline void glEvalCoord1dv (const GLdouble* u)
+  {
+    ::glEvalCoord1dv (u);
+  }
+
+  inline void glEvalCoord1fv (const GLfloat* u)
+  {
+    ::glEvalCoord1fv (u);
+  }
+
+  inline void glEvalCoord2d (GLdouble u, GLdouble v)
+  {
+    ::glEvalCoord2d (u, v);
+  }
+
+  inline void glEvalCoord2f (GLfloat u, GLfloat v)
+  {
+    ::glEvalCoord2f (u, v);
+  }
+
+  inline void glEvalCoord2dv (const GLdouble* u)
+  {
+    ::glEvalCoord2dv (u);
+  }
+
+  inline void glEvalCoord2fv (const GLfloat* u)
+  {
+    ::glEvalCoord2fv (u);
+  }
+
+  inline void glMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
+  {
+    ::glMapGrid1d (un, u1, u2);
+  }
+
+  inline void glMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
+  {
+    ::glMapGrid1f (un, u1, u2);
+  }
+
+  inline void glMapGrid2d (GLint un, GLdouble u1, GLdouble u2,
+                           GLint vn, GLdouble v1, GLdouble v2)
+  {
+    ::glMapGrid2d (un, u1, u2, vn, v1, v2);
+  }
+
+  inline void glMapGrid2f (GLint un, GLfloat u1, GLfloat u2,
+                           GLint vn, GLfloat v1, GLfloat v2)
+  {
+    ::glMapGrid2f (un, u1, u2, vn, v1, v2);
+  }
+
+  inline void glEvalPoint1 (GLint i)
+  {
+    ::glEvalPoint1 (i);
+  }
+
+  inline void glEvalPoint2 (GLint i, GLint j)
+  {
+    ::glEvalPoint2 (i, j);
+  }
+
+  inline void glEvalMesh1 (GLenum mode, GLint i1, GLint i2)
+  {
+    ::glEvalMesh1 (mode, i1, i2);
+  }
+
+  inline void glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+  {
+    ::glEvalMesh2 (mode, i1, i2, j1, j2);
+  }
+
+public: //! @name Selection and feedback modes (removed since 3.1)
+
+  inline void glFeedbackBuffer (GLsizei theSize, GLenum theType, GLfloat* theBuffer)
+  {
+    ::glFeedbackBuffer (theSize, theType, theBuffer);
+  }
+
+  inline void glPassThrough (GLfloat token)
+  {
+    ::glPassThrough (token);
+  }
+
+  inline void glSelectBuffer (GLsizei theSize, GLuint* theBuffer)
+  {
+    ::glSelectBuffer (theSize, theBuffer);
+  }
+
+  inline void glInitNames()
+  {
+    ::glInitNames();
+  }
+
+  inline void glLoadName (GLuint theName)
+  {
+    ::glLoadName (theName);
+  }
+
+  inline void glPushName (GLuint theName)
+  {
+    ::glPushName (theName);
+  }
+
+  inline void glPopName()
+  {
+    ::glPopName();
+  }
+
+public: //! @name Accumulation Buffer (removed since 3.1)
+
+  inline void glClearAccum (GLfloat theRed, GLfloat theGreen, GLfloat theBlue, GLfloat theAlpha)
+  {
+    ::glClearAccum (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glAccum (GLenum theOp, GLfloat theValue)
+  {
+    ::glAccum (theOp, theValue);
+  }
+
+public: //! @name Edge flags and fixed-function vertex processing (removed since 3.1)
+
+  inline void glEdgeFlag (GLboolean theFlag)
+  {
+    ::glEdgeFlag (theFlag);
+  }
+
+  inline void glEdgeFlagv (const GLboolean* theFlag)
+  {
+    ::glEdgeFlagv (theFlag);
+  }
+
+  inline void glVertexPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glVertexPointer (theSize, theType, theStride, thePtr);
+  }
+
+  inline void glNormalPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glNormalPointer (theType, theStride, thePtr);
+  }
+
+  inline void glColorPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glColorPointer (theSize, theType, theStride, thePtr);
+  }
+
+  inline void glIndexPointer (GLenum theType, GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glIndexPointer (theType, theStride, thePtr);
+  }
+
+  inline void glTexCoordPointer (GLint theSize, GLenum theType, GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glTexCoordPointer (theSize, theType, theStride, thePtr);
+  }
+
+  inline void glEdgeFlagPointer (GLsizei theStride, const GLvoid* thePtr)
+  {
+    ::glEdgeFlagPointer (theStride, thePtr);
+  }
+
+  inline void glGetPointerv (GLenum pname, GLvoid** params)
+  {
+    ::glGetPointerv(pname, params);
+  }
+
+  inline void glInterleavedArrays (GLenum theFormat, GLsizei theStride, const GLvoid* thePointer)
+  {
+    ::glInterleavedArrays (theFormat, theStride, thePointer);
+  }
+
+  inline void glEnableClientState (GLenum theCap)
+  {
+    ::glEnableClientState (theCap);
+  }
+
+  inline void glDisableClientState (GLenum theCap)
+  {
+    ::glDisableClientState (theCap);
+  }
+
+};
+
+#endif // _OpenGl_GlCore11_Header
diff --git a/src/OpenGl/OpenGl_GlCore11Fwd.hxx b/src/OpenGl/OpenGl_GlCore11Fwd.hxx
new file mode 100644 (file)
index 0000000..6cc0e21
--- /dev/null
@@ -0,0 +1,476 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore11Fwd_Header
+#define _OpenGl_GlCore11Fwd_Header
+
+#include <OpenGl_GlFunctions.hxx>
+
+//! OpenGL 1.1 core without deprecated Fixed Pipeline entry points.
+//! Notice that all functions within this structure are actually exported by system GL library.
+//! The main purpose for these hint - to control visibility of functions per GL version
+//! (global functions should not be used directly to achieve this effect!).
+struct OpenGl_GlCore11Fwd : protected OpenGl_GlFunctions
+{
+
+public: //! @name Miscellaneous
+
+  inline void glClearIndex (GLfloat c)
+  {
+    ::glClearIndex(c);
+  }
+
+  inline void glClearColor (GLclampf theRed, GLclampf theGreen, GLclampf theBlue, GLclampf theAlpha)
+  {
+    ::glClearColor  (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glClear (GLbitfield theMask)
+  {
+    ::glClear (theMask);
+  }
+
+  inline void glIndexMask (GLuint theMask)
+  {
+    ::glIndexMask (theMask);
+  }
+
+  inline void glColorMask (GLboolean theRed, GLboolean theGreen, GLboolean theBlue, GLboolean theAlpha)
+  {
+    ::glColorMask (theRed, theGreen, theBlue, theAlpha);
+  }
+
+  inline void glAlphaFunc (GLenum theFunc, GLclampf theRef)
+  {
+    ::glAlphaFunc (theFunc, theRef);
+  }
+
+  inline void glBlendFunc (GLenum sfactor, GLenum dfactor)
+  {
+    ::glBlendFunc(sfactor, dfactor);
+  }
+
+  inline void glLogicOp (GLenum opcode)
+  {
+    ::glLogicOp(opcode);
+  }
+
+  inline void glCullFace (GLenum theMode)
+  {
+    ::glCullFace (theMode);
+  }
+
+  inline void glFrontFace (GLenum theMode)
+  {
+    ::glFrontFace (theMode);
+  }
+
+  inline void glPointSize (GLfloat theSize)
+  {
+    ::glPointSize (theSize);
+  }
+
+  inline void glLineWidth (GLfloat theWidth)
+  {
+    ::glLineWidth (theWidth);
+  }
+
+  inline void glPolygonMode (GLenum theFace, GLenum theMode)
+  {
+    ::glPolygonMode (theFace, theMode);
+  }
+
+  inline void glPolygonOffset (GLfloat theFactor, GLfloat theUnits)
+  {
+    ::glPolygonOffset (theFactor, theUnits);
+  }
+
+  inline void glScissor (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
+  {
+    ::glScissor (theX, theY, theWidth, theHeight);
+  }
+
+  inline void glDrawBuffer (GLenum theMode)
+  {
+    ::glDrawBuffer (theMode);
+  }
+
+  inline void glReadBuffer (GLenum theMode)
+  {
+    ::glReadBuffer (theMode);
+  }
+
+  inline void glEnable (GLenum theCap)
+  {
+    ::glEnable (theCap);
+  }
+
+  inline void glDisable (GLenum theCap)
+  {
+    ::glDisable (theCap);
+  }
+
+  inline GLboolean glIsEnabled (GLenum theCap)
+  {
+    return ::glIsEnabled (theCap);
+  }
+
+  inline void glGetBooleanv (GLenum theParamName, GLboolean* theValues)
+  {
+    ::glGetBooleanv (theParamName, theValues);
+  }
+
+  inline void glGetDoublev (GLenum theParamName, GLdouble* theValues)
+  {
+    ::glGetDoublev (theParamName, theValues);
+  }
+
+  inline void glGetFloatv (GLenum theParamName, GLfloat* theValues)
+  {
+    ::glGetFloatv (theParamName, theValues);
+  }
+
+  inline void glGetIntegerv (GLenum theParamName, GLint* theValues)
+  {
+    ::glGetIntegerv (theParamName, theValues);
+  }
+
+  inline GLint glRenderMode (GLenum theMode)
+  {
+    return ::glRenderMode (theMode);
+  }
+
+  inline GLenum glGetError()
+  {
+    return ::glGetError();
+  }
+
+  inline const GLubyte* glGetString (GLenum theName)
+  {
+    return ::glGetString (theName);
+  }
+
+  inline void glFinish()
+  {
+    ::glFinish();
+  }
+
+  inline void glFlush()
+  {
+    ::glFlush();
+  }
+
+  inline void glHint (GLenum theTarget, GLenum theMode)
+  {
+    ::glHint (theTarget, theMode);
+  }
+
+public: //! @name Depth Buffer
+
+  inline void glClearDepth (GLclampd theDepth)
+  {
+    ::glClearDepth (theDepth);
+  }
+
+  inline void glDepthFunc (GLenum theFunc)
+  {
+    ::glDepthFunc (theFunc);
+  }
+
+  inline void glDepthMask (GLboolean theFlag)
+  {
+    ::glDepthMask (theFlag);
+  }
+
+  inline void glDepthRange (GLclampd theNearValue, GLclampd theFarValue)
+  {
+    ::glDepthRange (theNearValue, theFarValue);
+  }
+
+public: //! @name Transformation
+
+  inline void glViewport (GLint theX, GLint theY, GLsizei theWidth, GLsizei theHeight)
+  {
+    ::glViewport (theX, theY, theWidth, theHeight);
+  }
+
+public: //! @name Vertex Arrays
+
+  inline void glArrayElement (GLint i)
+  {
+    ::glArrayElement (i);
+  }
+
+  inline void glDrawArrays (GLenum theMode, GLint theFirst, GLsizei theCount)
+  {
+    ::glDrawArrays (theMode, theFirst, theCount);
+  }
+
+  inline void glDrawElements (GLenum theMode, GLsizei theCount, GLenum theType, const GLvoid* theIndices)
+  {
+    ::glDrawElements (theMode, theCount, theType, theIndices);
+  }
+
+public: //! @name Raster functions
+
+  inline void glPixelStoref (GLenum theParamName, GLfloat theParam)
+  {
+    ::glPixelStoref (theParamName, theParam);
+  }
+
+  inline void glPixelStorei (GLenum theParamName, GLint   theParam)
+  {
+    ::glPixelStorei (theParamName, theParam);
+  }
+
+  inline void glPixelTransferf (GLenum theParamName, GLfloat theParam)
+  {
+    ::glPixelTransferf (theParamName, theParam);
+  }
+
+  inline void glPixelTransferi (GLenum theParamName, GLint   theParam)
+  {
+    ::glPixelTransferi (theParamName, theParam);
+  }
+
+  inline void glPixelMapfv  (GLenum map, GLsizei mapsize, const GLfloat*  values)
+  {
+    ::glPixelMapfv (map, mapsize, values);
+  }
+
+  inline void glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint*   values)
+  {
+    ::glPixelMapuiv (map, mapsize, values);
+  }
+
+  inline void glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort* values)
+  {
+    ::glPixelMapusv (map, mapsize, values);
+  }
+
+  inline void glGetPixelMapfv  (GLenum map, GLfloat*  values)
+  {
+    ::glGetPixelMapfv (map, values);
+  }
+
+  inline void glGetPixelMapuiv (GLenum map, GLuint*   values)
+  {
+    ::glGetPixelMapuiv (map, values);
+  }
+
+  inline void glGetPixelMapusv (GLenum map, GLushort* values)
+  {
+    ::glGetPixelMapusv (map, values);
+  }
+
+  inline void glReadPixels (GLint x, GLint y,
+                            GLsizei width, GLsizei height,
+                            GLenum format, GLenum type,
+                            GLvoid* pixels)
+  {
+    ::glReadPixels (x, y, width, height, format, type, pixels);
+  }
+
+public: //! @name Stenciling
+
+  inline void glStencilFunc (GLenum func, GLint ref, GLuint mask)
+  {
+    ::glStencilFunc (func, ref, mask);
+  }
+
+  inline void glStencilMask (GLuint mask)
+  {
+    ::glStencilMask (mask);
+  }
+
+  inline void glStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
+  {
+    ::glStencilOp (fail, zfail, zpass);
+  }
+
+  inline void glClearStencil (GLint s)
+  {
+    ::glClearStencil (s);
+  }
+
+public: //! @name Texture mapping
+
+  inline void glTexEnvf (GLenum target, GLenum pname, GLfloat param)
+  {
+    ::glTexEnvf (target, pname, param);
+  }
+
+  inline void glTexEnvi (GLenum target, GLenum pname, GLint param)
+  {
+    ::glTexEnvi (target, pname, param);
+  }
+
+  inline void glTexEnvfv (GLenum target, GLenum pname, const GLfloat* params)
+  {
+    ::glTexEnvfv (target, pname, params);
+  }
+
+  inline void glTexEnviv (GLenum target, GLenum pname, const GLint* params)
+  {
+    ::glTexEnviv (target, pname, params);
+  }
+
+  inline void glGetTexEnvfv (GLenum target, GLenum pname, GLfloat* params)
+  {
+    ::glGetTexEnvfv (target, pname, params);
+  }
+
+  inline void glGetTexEnviv (GLenum target, GLenum pname, GLint* params)
+  {
+    ::glGetTexEnviv (target, pname, params);
+  }
+
+  inline void glTexParameterf (GLenum target, GLenum pname, GLfloat param)
+  {
+    ::glTexParameterf (target, pname, param);
+  }
+
+  inline void glTexParameteri (GLenum target, GLenum pname, GLint param)
+  {
+    ::glTexParameteri (target, pname, param);
+  }
+
+  inline void glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params)
+  {
+    ::glTexParameterfv (target, pname, params);
+  }
+
+  inline void glTexParameteriv (GLenum target, GLenum pname, const GLint* params)
+  {
+    ::glTexParameteriv (target, pname, params);
+  }
+
+  inline void glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params)
+  {
+    ::glGetTexParameterfv (target, pname, params);
+  }
+
+  inline void glGetTexParameteriv (GLenum target, GLenum pname, GLint* params)
+  {
+    ::glGetTexParameteriv (target, pname, params);
+  }
+
+  inline void glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat* params)
+  {
+    ::glGetTexLevelParameterfv (target, level, pname, params);
+  }
+
+  inline void glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint* params)
+  {
+    ::glGetTexLevelParameteriv (target, level, pname, params);
+  }
+
+  inline void glTexImage1D (GLenum target, GLint level,
+                            GLint internalFormat,
+                            GLsizei width, GLint border,
+                            GLenum format, GLenum type,
+                            const GLvoid* pixels)
+  {
+    ::glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
+  }
+
+  inline void glTexImage2D (GLenum target, GLint level,
+                            GLint internalFormat,
+                            GLsizei width, GLsizei height,
+                            GLint border, GLenum format, GLenum type,
+                            const GLvoid* pixels)
+  {
+    ::glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
+  }
+
+  inline void glGetTexImage (GLenum target, GLint level,
+                             GLenum format, GLenum type,
+                             GLvoid* pixels)
+  {
+    ::glGetTexImage(target, level, format, type, pixels);
+  }
+
+  inline void glGenTextures (GLsizei n, GLuint* textures)
+  {
+    ::glGenTextures(n, textures);
+  }
+
+  inline void glDeleteTextures (GLsizei n, const GLuint* textures)
+  {
+    ::glDeleteTextures(n, textures);
+  }
+
+  inline void glBindTexture (GLenum target, GLuint texture)
+  {
+    ::glBindTexture(target, texture);
+  }
+
+  inline GLboolean glIsTexture (GLuint texture)
+  {
+    return ::glIsTexture (texture);
+  }
+
+  inline void glTexSubImage1D (GLenum target, GLint level,
+                               GLint xoffset,
+                               GLsizei width, GLenum format,
+                               GLenum type, const GLvoid* pixels)
+  {
+    ::glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
+  }
+
+  inline void glTexSubImage2D (GLenum target, GLint level,
+                               GLint xoffset, GLint yoffset,
+                               GLsizei width, GLsizei height,
+                               GLenum format, GLenum type,
+                               const GLvoid* pixels)
+  {
+    ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+  }
+
+  inline void glCopyTexImage1D (GLenum target, GLint level,
+                                GLenum internalformat,
+                                GLint x, GLint y,
+                                GLsizei width, GLint border)
+  {
+    ::glCopyTexImage1D(target, level, internalformat, x, y, width, border);
+  }
+
+  inline void glCopyTexImage2D (GLenum target, GLint level,
+                                GLenum internalformat,
+                                GLint x, GLint y,
+                                GLsizei width, GLsizei height,
+                                GLint border)
+  {
+    ::glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+  }
+
+  inline void glCopyTexSubImage1D (GLenum target, GLint level,
+                                   GLint xoffset, GLint x, GLint y,
+                                   GLsizei width)
+  {
+    ::glCopyTexSubImage1D(target, level, xoffset, x, y, width);
+  }
+
+  inline void glCopyTexSubImage2D (GLenum target, GLint level,
+                                   GLint xoffset, GLint yoffset,
+                                   GLint x, GLint y,
+                                   GLsizei width, GLsizei height)
+  {
+    ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+  }
+
+};
+
+#endif // _OpenGl_GlCore11Fwd_Header
index 1d34b60..406b541 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore12_H__
-#define _OpenGl_GlCore12_H__
+#ifndef _OpenGl_GlCore12_Header
+#define _OpenGl_GlCore12_Header
 
 #include <OpenGl_GlCore11.hxx>
 
-// GL version can be defined by system gl.h header
-#undef GL_VERSION_1_2
-#undef GL_VERSION_1_3
-#undef GL_VERSION_1_4
-#undef GL_VERSION_1_5
-#undef GL_VERSION_2_0
-
-// include glext.h provided by Khronos group
-#include <glext.h>
-
-//! Function list for GL1.2 core functionality.
-struct OpenGl_GlCore12
+//! OpenGL 1.2 core based on 1.1 version.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore12 : public theBaseClass_t
 {
 
-  PFNGLBLENDCOLORPROC        glBlendColor;
-  PFNGLBLENDEQUATIONPROC     glBlendEquation;
-  PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements;
-  PFNGLTEXIMAGE3DPROC        glTexImage3D;
-  PFNGLTEXSUBIMAGE3DPROC     glTexSubImage3D;
-  PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D;
+public: //! @name OpenGL 1.2 additives to 1.1
+
+  using theBaseClass_t::glBlendColor;
+  using theBaseClass_t::glBlendEquation;
+  using theBaseClass_t::glDrawRangeElements;
+  using theBaseClass_t::glTexImage3D;
+  using theBaseClass_t::glTexSubImage3D;
+  using theBaseClass_t::glCopyTexSubImage3D;
 
 };
 
-#endif // _OpenGl_GlCore12_H__
+//! OpenGL 1.2 core based on 1.1 version.
+typedef OpenGl_TmplCore12<OpenGl_GlCore11>    OpenGl_GlCore12;
+
+//! OpenGL 1.2 without deprecated entry points.
+typedef OpenGl_TmplCore12<OpenGl_GlCore11Fwd> OpenGl_GlCore12Fwd;
+
+#endif // _OpenGl_GlCore12_Header
index cc3b6b6..0e14133 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore13_H__
-#define _OpenGl_GlCore13_H__
+#ifndef _OpenGl_GlCore13_Header
+#define _OpenGl_GlCore13_Header
 
 #include <OpenGl_GlCore12.hxx>
 
-//! Function list for GL1.3 core functionality.
+//! OpenGL 1.3 without deprecated entry points.
+struct OpenGl_GlCore13Fwd : public OpenGl_GlCore12Fwd
+{
+
+public: //! @name OpenGL 1.3 additives to 1.2
+
+  using OpenGl_GlFunctions::glActiveTexture;
+  using OpenGl_GlFunctions::glSampleCoverage;
+  using OpenGl_GlFunctions::glCompressedTexImage3D;
+  using OpenGl_GlFunctions::glCompressedTexImage2D;
+  using OpenGl_GlFunctions::glCompressedTexImage1D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage3D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage2D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage1D;
+  using OpenGl_GlFunctions::glGetCompressedTexImage;
+
+};
+
+//! OpenGL 1.3 core based on 1.2 version.
 struct OpenGl_GlCore13 : public OpenGl_GlCore12
 {
 
-  PFNGLACTIVETEXTUREPROC           glActiveTexture;
-  PFNGLSAMPLECOVERAGEPROC          glSampleCoverage;
-  PFNGLCOMPRESSEDTEXIMAGE3DPROC    glCompressedTexImage3D;
-  PFNGLCOMPRESSEDTEXIMAGE2DPROC    glCompressedTexImage2D;
-  PFNGLCOMPRESSEDTEXIMAGE1DPROC    glCompressedTexImage1D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D;
-  PFNGLGETCOMPRESSEDTEXIMAGEPROC   glGetCompressedTexImage;
-
-  // deprecated functions
-
-  PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture;
-  PFNGLMULTITEXCOORD1DPROC  glMultiTexCoord1d;
-  PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv;
-  PFNGLMULTITEXCOORD1FPROC  glMultiTexCoord1f;
-  PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv;
-  PFNGLMULTITEXCOORD1IPROC  glMultiTexCoord1i;
-  PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv;
-  PFNGLMULTITEXCOORD1SPROC  glMultiTexCoord1s;
-  PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv;
-  PFNGLMULTITEXCOORD2DPROC  glMultiTexCoord2d;
-  PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv;
-  PFNGLMULTITEXCOORD2FPROC  glMultiTexCoord2f;
-  PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv;
-  PFNGLMULTITEXCOORD2IPROC  glMultiTexCoord2i;
-  PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv;
-  PFNGLMULTITEXCOORD2SPROC  glMultiTexCoord2s;
-  PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv;
-  PFNGLMULTITEXCOORD3DPROC  glMultiTexCoord3d;
-  PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv;
-  PFNGLMULTITEXCOORD3FPROC  glMultiTexCoord3f;
-  PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv;
-  PFNGLMULTITEXCOORD3IPROC  glMultiTexCoord3i;
-  PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv;
-  PFNGLMULTITEXCOORD3SPROC  glMultiTexCoord3s;
-  PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv;
-  PFNGLMULTITEXCOORD4DPROC  glMultiTexCoord4d;
-  PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv;
-  PFNGLMULTITEXCOORD4FPROC  glMultiTexCoord4f;
-  PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv;
-  PFNGLMULTITEXCOORD4IPROC  glMultiTexCoord4i;
-  PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv;
-  PFNGLMULTITEXCOORD4SPROC  glMultiTexCoord4s;
-  PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv;
-  PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf;
-  PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd;
-  PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf;
-  PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd;
+public: //! @name OpenGL 1.3 additives to 1.2
+
+  using OpenGl_GlFunctions::glActiveTexture;
+  using OpenGl_GlFunctions::glSampleCoverage;
+  using OpenGl_GlFunctions::glCompressedTexImage3D;
+  using OpenGl_GlFunctions::glCompressedTexImage2D;
+  using OpenGl_GlFunctions::glCompressedTexImage1D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage3D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage2D;
+  using OpenGl_GlFunctions::glCompressedTexSubImage1D;
+  using OpenGl_GlFunctions::glGetCompressedTexImage;
+
+public: //! @name Begin/End primitive specification (removed since 3.1)
+
+  using OpenGl_GlFunctions::glMultiTexCoord1d;
+  using OpenGl_GlFunctions::glMultiTexCoord1dv;
+  using OpenGl_GlFunctions::glMultiTexCoord1f;
+  using OpenGl_GlFunctions::glMultiTexCoord1fv;
+  using OpenGl_GlFunctions::glMultiTexCoord1i;
+  using OpenGl_GlFunctions::glMultiTexCoord1iv;
+  using OpenGl_GlFunctions::glMultiTexCoord1s;
+  using OpenGl_GlFunctions::glMultiTexCoord1sv;
+  using OpenGl_GlFunctions::glMultiTexCoord2d;
+  using OpenGl_GlFunctions::glMultiTexCoord2dv;
+  using OpenGl_GlFunctions::glMultiTexCoord2f;
+  using OpenGl_GlFunctions::glMultiTexCoord2fv;
+  using OpenGl_GlFunctions::glMultiTexCoord2i;
+  using OpenGl_GlFunctions::glMultiTexCoord2iv;
+  using OpenGl_GlFunctions::glMultiTexCoord2s;
+  using OpenGl_GlFunctions::glMultiTexCoord2sv;
+  using OpenGl_GlFunctions::glMultiTexCoord3d;
+  using OpenGl_GlFunctions::glMultiTexCoord3dv;
+  using OpenGl_GlFunctions::glMultiTexCoord3f;
+  using OpenGl_GlFunctions::glMultiTexCoord3fv;
+  using OpenGl_GlFunctions::glMultiTexCoord3i;
+  using OpenGl_GlFunctions::glMultiTexCoord3iv;
+  using OpenGl_GlFunctions::glMultiTexCoord3s;
+  using OpenGl_GlFunctions::glMultiTexCoord3sv;
+  using OpenGl_GlFunctions::glMultiTexCoord4d;
+  using OpenGl_GlFunctions::glMultiTexCoord4dv;
+  using OpenGl_GlFunctions::glMultiTexCoord4f;
+  using OpenGl_GlFunctions::glMultiTexCoord4fv;
+  using OpenGl_GlFunctions::glMultiTexCoord4i;
+  using OpenGl_GlFunctions::glMultiTexCoord4iv;
+  using OpenGl_GlFunctions::glMultiTexCoord4s;
+  using OpenGl_GlFunctions::glMultiTexCoord4sv;
+
+  using OpenGl_GlFunctions::glClientActiveTexture;
+
+public: //! @name Matrix operations (removed since 3.1)
+
+  using OpenGl_GlFunctions::glLoadTransposeMatrixf;
+  using OpenGl_GlFunctions::glLoadTransposeMatrixd;
+  using OpenGl_GlFunctions::glMultTransposeMatrixf;
+  using OpenGl_GlFunctions::glMultTransposeMatrixd;
 
 };
 
-#endif // _OpenGl_GlCore13_H__
+#endif // _OpenGl_GlCore13_Header
index 730a81b..9725f0f 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore14_H__
-#define _OpenGl_GlCore14_H__
+#ifndef _OpenGl_GlCore14_Header
+#define _OpenGl_GlCore14_Header
 
 #include <OpenGl_GlCore13.hxx>
 
-//! Function list for GL1.4 core functionality.
-struct OpenGl_GlCore14 : public OpenGl_GlCore13
+//! OpenGL 1.4 core based on 1.3 version.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore14 : public theBaseClass_t
 {
 
-  PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
-  PFNGLMULTIDRAWARRAYSPROC   glMultiDrawArrays;
-  PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements;
-  PFNGLPOINTPARAMETERFPROC   glPointParameterf;
-  PFNGLPOINTPARAMETERFVPROC  glPointParameterfv;
-  PFNGLPOINTPARAMETERIPROC   glPointParameteri;
-  PFNGLPOINTPARAMETERIVPROC  glPointParameteriv;
+public: //! @name OpenGL 1.4 additives to 1.3
+
+  using theBaseClass_t::glBlendFuncSeparate;
+  using theBaseClass_t::glMultiDrawArrays;
+  using theBaseClass_t::glMultiDrawElements;
+  using theBaseClass_t::glPointParameterf;
+  using theBaseClass_t::glPointParameterfv;
+  using theBaseClass_t::glPointParameteri;
+  using theBaseClass_t::glPointParameteriv;
 
 };
 
-#endif // _OpenGl_GlCore14_H__
+//! OpenGL 1.4 core based on 1.3 version.
+typedef OpenGl_TmplCore14<OpenGl_GlCore13>    OpenGl_GlCore14;
+
+//! OpenGL 1.4 without deprecated entry points.
+typedef OpenGl_TmplCore14<OpenGl_GlCore13Fwd> OpenGl_GlCore14Fwd;
+
+#endif // _OpenGl_GlCore14_Header
index 5c7b8af..7e03674 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore15_H__
-#define _OpenGl_GlCore15_H__
+#ifndef _OpenGl_GlCore15_Header
+#define _OpenGl_GlCore15_Header
 
 #include <OpenGl_GlCore14.hxx>
 
-//! Function list for GL1.5 core functionality.
-struct OpenGl_GlCore15 : public OpenGl_GlCore14
+/**
+ * OpenGL 1.5 core based on 1.4 version.
+ */
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore15 : public theBaseClass_t
 {
 
-  PFNGLGENQUERIESPROC           glGenQueries;
-  PFNGLDELETEQUERIESPROC        glDeleteQueries;
-  PFNGLISQUERYPROC              glIsQuery;
-  PFNGLBEGINQUERYPROC           glBeginQuery;
-  PFNGLENDQUERYPROC             glEndQuery;
-  PFNGLGETQUERYIVPROC           glGetQueryiv;
-  PFNGLGETQUERYOBJECTIVPROC     glGetQueryObjectiv;
-  PFNGLGETQUERYOBJECTUIVPROC    glGetQueryObjectuiv;
-  PFNGLBINDBUFFERPROC           glBindBuffer;
-  PFNGLDELETEBUFFERSPROC        glDeleteBuffers;
-  PFNGLGENBUFFERSPROC           glGenBuffers;
-  PFNGLISBUFFERPROC             glIsBuffer;
-  PFNGLBUFFERDATAPROC           glBufferData;
-  PFNGLBUFFERSUBDATAPROC        glBufferSubData;
-  PFNGLGETBUFFERSUBDATAPROC     glGetBufferSubData;
-  PFNGLMAPBUFFERPROC            glMapBuffer;
-  PFNGLUNMAPBUFFERPROC          glUnmapBuffer;
-  PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv;
-  PFNGLGETBUFFERPOINTERVPROC    glGetBufferPointerv;
+public: //! @name OpenGL 1.5 additives to 1.4
+
+  using theBaseClass_t::glGenQueries;
+  using theBaseClass_t::glDeleteQueries;
+  using theBaseClass_t::glIsQuery;
+  using theBaseClass_t::glBeginQuery;
+  using theBaseClass_t::glEndQuery;
+  using theBaseClass_t::glGetQueryiv;
+  using theBaseClass_t::glGetQueryObjectiv;
+  using theBaseClass_t::glGetQueryObjectuiv;
+  using theBaseClass_t::glBindBuffer;
+  using theBaseClass_t::glDeleteBuffers;
+  using theBaseClass_t::glGenBuffers;
+  using theBaseClass_t::glIsBuffer;
+  using theBaseClass_t::glBufferData;
+  using theBaseClass_t::glBufferSubData;
+  using theBaseClass_t::glGetBufferSubData;
+  using theBaseClass_t::glMapBuffer;
+  using theBaseClass_t::glUnmapBuffer;
+  using theBaseClass_t::glGetBufferParameteriv;
+  using theBaseClass_t::glGetBufferPointerv;
 
 };
 
-#endif // _OpenGl_GlCore15_H__
+//! OpenGL 1.5 core based on 1.4 version.
+typedef OpenGl_TmplCore15<OpenGl_GlCore14>    OpenGl_GlCore15;
+
+//! OpenGL 1.5 without deprecated entry points.
+typedef OpenGl_TmplCore15<OpenGl_GlCore14Fwd> OpenGl_GlCore15Fwd;
+
+#endif // _OpenGl_GlCore15_Header
index 0996c05..b317292 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifndef _OpenGl_GlCore20_H__
-#define _OpenGl_GlCore20_H__
+#ifndef _OpenGl_GlCore20_Header
+#define _OpenGl_GlCore20_Header
 
 #include <OpenGl_GlCore15.hxx>
 
-//! Function list for GL2.0 core functionality.
-struct OpenGl_GlCore20 : public OpenGl_GlCore15
+//! OpenGL 2.0 core based on 1.5 version.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore20 : public theBaseClass_t
 {
 
-  PFNGLBLENDEQUATIONSEPARATEPROC    glBlendEquationSeparate;
-  PFNGLDRAWBUFFERSPROC              glDrawBuffers;
-  PFNGLSTENCILOPSEPARATEPROC        glStencilOpSeparate;
-  PFNGLSTENCILFUNCSEPARATEPROC      glStencilFuncSeparate;
-  PFNGLSTENCILMASKSEPARATEPROC      glStencilMaskSeparate;
-  PFNGLATTACHSHADERPROC             glAttachShader;
-  PFNGLBINDATTRIBLOCATIONPROC       glBindAttribLocation;
-  PFNGLCOMPILESHADERPROC            glCompileShader;
-  PFNGLCREATEPROGRAMPROC            glCreateProgram;
-  PFNGLCREATESHADERPROC             glCreateShader;
-  PFNGLDELETEPROGRAMPROC            glDeleteProgram;
-  PFNGLDELETESHADERPROC             glDeleteShader;
-  PFNGLDETACHSHADERPROC             glDetachShader;
-  PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
-  PFNGLENABLEVERTEXATTRIBARRAYPROC  glEnableVertexAttribArray;
-  PFNGLGETACTIVEATTRIBPROC          glGetActiveAttrib;
-  PFNGLGETACTIVEUNIFORMPROC         glGetActiveUniform;
-  PFNGLGETATTACHEDSHADERSPROC       glGetAttachedShaders;
-  PFNGLGETATTRIBLOCATIONPROC        glGetAttribLocation;
-  PFNGLGETPROGRAMIVPROC             glGetProgramiv;
-  PFNGLGETPROGRAMINFOLOGPROC        glGetProgramInfoLog;
-  PFNGLGETSHADERIVPROC              glGetShaderiv;
-  PFNGLGETSHADERINFOLOGPROC         glGetShaderInfoLog;
-  PFNGLGETSHADERSOURCEPROC          glGetShaderSource;
-  PFNGLGETUNIFORMLOCATIONPROC       glGetUniformLocation;
-  PFNGLGETUNIFORMFVPROC             glGetUniformfv;
-  PFNGLGETUNIFORMIVPROC             glGetUniformiv;
-  PFNGLGETVERTEXATTRIBDVPROC        glGetVertexAttribdv;
-  PFNGLGETVERTEXATTRIBFVPROC        glGetVertexAttribfv;
-  PFNGLGETVERTEXATTRIBIVPROC        glGetVertexAttribiv;
-  PFNGLGETVERTEXATTRIBPOINTERVPROC  glGetVertexAttribPointerv;
-  PFNGLISPROGRAMPROC                glIsProgram;
-  PFNGLISSHADERPROC                 glIsShader;
-  PFNGLLINKPROGRAMPROC              glLinkProgram;
-  PFNGLSHADERSOURCEPROC             glShaderSource;
-  PFNGLUSEPROGRAMPROC               glUseProgram;
-  PFNGLUNIFORM1FPROC                glUniform1f;
-  PFNGLUNIFORM2FPROC                glUniform2f;
-  PFNGLUNIFORM3FPROC                glUniform3f;
-  PFNGLUNIFORM4FPROC                glUniform4f;
-  PFNGLUNIFORM1IPROC                glUniform1i;
-  PFNGLUNIFORM2IPROC                glUniform2i;
-  PFNGLUNIFORM3IPROC                glUniform3i;
-  PFNGLUNIFORM4IPROC                glUniform4i;
-  PFNGLUNIFORM1FVPROC               glUniform1fv;
-  PFNGLUNIFORM2FVPROC               glUniform2fv;
-  PFNGLUNIFORM3FVPROC               glUniform3fv;
-  PFNGLUNIFORM4FVPROC               glUniform4fv;
-  PFNGLUNIFORM1IVPROC               glUniform1iv;
-  PFNGLUNIFORM2IVPROC               glUniform2iv;
-  PFNGLUNIFORM3IVPROC               glUniform3iv;
-  PFNGLUNIFORM4IVPROC               glUniform4iv;
-  PFNGLUNIFORMMATRIX2FVPROC         glUniformMatrix2fv;
-  PFNGLUNIFORMMATRIX3FVPROC         glUniformMatrix3fv;
-  PFNGLUNIFORMMATRIX4FVPROC         glUniformMatrix4fv;
-  PFNGLVALIDATEPROGRAMPROC          glValidateProgram;
-  PFNGLVERTEXATTRIB1DPROC           glVertexAttrib1d;
-  PFNGLVERTEXATTRIB1DVPROC          glVertexAttrib1dv;
-  PFNGLVERTEXATTRIB1FPROC           glVertexAttrib1f;
-  PFNGLVERTEXATTRIB1FVPROC          glVertexAttrib1fv;
-  PFNGLVERTEXATTRIB1SPROC           glVertexAttrib1s;
-  PFNGLVERTEXATTRIB1SVPROC          glVertexAttrib1sv;
-  PFNGLVERTEXATTRIB2DPROC           glVertexAttrib2d;
-  PFNGLVERTEXATTRIB2DVPROC          glVertexAttrib2dv;
-  PFNGLVERTEXATTRIB2FPROC           glVertexAttrib2f;
-  PFNGLVERTEXATTRIB2FVPROC          glVertexAttrib2fv;
-  PFNGLVERTEXATTRIB2SPROC           glVertexAttrib2s;
-  PFNGLVERTEXATTRIB2SVPROC          glVertexAttrib2sv;
-  PFNGLVERTEXATTRIB3DPROC           glVertexAttrib3d;
-  PFNGLVERTEXATTRIB3DVPROC          glVertexAttrib3dv;
-  PFNGLVERTEXATTRIB3FPROC           glVertexAttrib3f;
-  PFNGLVERTEXATTRIB3FVPROC          glVertexAttrib3fv;
-  PFNGLVERTEXATTRIB3SPROC           glVertexAttrib3s;
-  PFNGLVERTEXATTRIB3SVPROC          glVertexAttrib3sv;
-  PFNGLVERTEXATTRIB4NBVPROC         glVertexAttrib4Nbv;
-  PFNGLVERTEXATTRIB4NIVPROC         glVertexAttrib4Niv;
-  PFNGLVERTEXATTRIB4NSVPROC         glVertexAttrib4Nsv;
-  PFNGLVERTEXATTRIB4NUBPROC         glVertexAttrib4Nub;
-  PFNGLVERTEXATTRIB4NUBVPROC        glVertexAttrib4Nubv;
-  PFNGLVERTEXATTRIB4NUIVPROC        glVertexAttrib4Nuiv;
-  PFNGLVERTEXATTRIB4NUSVPROC        glVertexAttrib4Nusv;
-  PFNGLVERTEXATTRIB4BVPROC          glVertexAttrib4bv;
-  PFNGLVERTEXATTRIB4DPROC           glVertexAttrib4d;
-  PFNGLVERTEXATTRIB4DVPROC          glVertexAttrib4dv;
-  PFNGLVERTEXATTRIB4FPROC           glVertexAttrib4f;
-  PFNGLVERTEXATTRIB4FVPROC          glVertexAttrib4fv;
-  PFNGLVERTEXATTRIB4IVPROC          glVertexAttrib4iv;
-  PFNGLVERTEXATTRIB4SPROC           glVertexAttrib4s;
-  PFNGLVERTEXATTRIB4SVPROC          glVertexAttrib4sv;
-  PFNGLVERTEXATTRIB4UBVPROC         glVertexAttrib4ubv;
-  PFNGLVERTEXATTRIB4UIVPROC         glVertexAttrib4uiv;
-  PFNGLVERTEXATTRIB4USVPROC         glVertexAttrib4usv;
-  PFNGLVERTEXATTRIBPOINTERPROC      glVertexAttribPointer;
+public: //! @name OpenGL 2.0 additives to 1.5
+
+  using theBaseClass_t::glBlendEquationSeparate;
+  using theBaseClass_t::glDrawBuffers;
+  using theBaseClass_t::glStencilOpSeparate;
+  using theBaseClass_t::glStencilFuncSeparate;
+  using theBaseClass_t::glStencilMaskSeparate;
+  using theBaseClass_t::glAttachShader;
+  using theBaseClass_t::glBindAttribLocation;
+  using theBaseClass_t::glCompileShader;
+  using theBaseClass_t::glCreateProgram;
+  using theBaseClass_t::glCreateShader;
+  using theBaseClass_t::glDeleteProgram;
+  using theBaseClass_t::glDeleteShader;
+  using theBaseClass_t::glDetachShader;
+  using theBaseClass_t::glDisableVertexAttribArray;
+  using theBaseClass_t::glEnableVertexAttribArray;
+  using theBaseClass_t::glGetActiveAttrib;
+  using theBaseClass_t::glGetActiveUniform;
+  using theBaseClass_t::glGetAttachedShaders;
+  using theBaseClass_t::glGetAttribLocation;
+  using theBaseClass_t::glGetProgramiv;
+  using theBaseClass_t::glGetProgramInfoLog;
+  using theBaseClass_t::glGetShaderiv;
+  using theBaseClass_t::glGetShaderInfoLog;
+  using theBaseClass_t::glGetShaderSource;
+  using theBaseClass_t::glGetUniformLocation;
+  using theBaseClass_t::glGetUniformfv;
+  using theBaseClass_t::glGetUniformiv;
+  using theBaseClass_t::glGetVertexAttribdv;
+  using theBaseClass_t::glGetVertexAttribfv;
+  using theBaseClass_t::glGetVertexAttribiv;
+  using theBaseClass_t::glGetVertexAttribPointerv;
+  using theBaseClass_t::glIsProgram;
+  using theBaseClass_t::glIsShader;
+  using theBaseClass_t::glLinkProgram;
+  using theBaseClass_t::glShaderSource;
+  using theBaseClass_t::glUseProgram;
+  using theBaseClass_t::glUniform1f;
+  using theBaseClass_t::glUniform2f;
+  using theBaseClass_t::glUniform3f;
+  using theBaseClass_t::glUniform4f;
+  using theBaseClass_t::glUniform1i;
+  using theBaseClass_t::glUniform2i;
+  using theBaseClass_t::glUniform3i;
+  using theBaseClass_t::glUniform4i;
+  using theBaseClass_t::glUniform1fv;
+  using theBaseClass_t::glUniform2fv;
+  using theBaseClass_t::glUniform3fv;
+  using theBaseClass_t::glUniform4fv;
+  using theBaseClass_t::glUniform1iv;
+  using theBaseClass_t::glUniform2iv;
+  using theBaseClass_t::glUniform3iv;
+  using theBaseClass_t::glUniform4iv;
+  using theBaseClass_t::glUniformMatrix2fv;
+  using theBaseClass_t::glUniformMatrix3fv;
+  using theBaseClass_t::glUniformMatrix4fv;
+  using theBaseClass_t::glValidateProgram;
+  using theBaseClass_t::glVertexAttrib1d;
+  using theBaseClass_t::glVertexAttrib1dv;
+  using theBaseClass_t::glVertexAttrib1f;
+  using theBaseClass_t::glVertexAttrib1fv;
+  using theBaseClass_t::glVertexAttrib1s;
+  using theBaseClass_t::glVertexAttrib1sv;
+  using theBaseClass_t::glVertexAttrib2d;
+  using theBaseClass_t::glVertexAttrib2dv;
+  using theBaseClass_t::glVertexAttrib2f;
+  using theBaseClass_t::glVertexAttrib2fv;
+  using theBaseClass_t::glVertexAttrib2s;
+  using theBaseClass_t::glVertexAttrib2sv;
+  using theBaseClass_t::glVertexAttrib3d;
+  using theBaseClass_t::glVertexAttrib3dv;
+  using theBaseClass_t::glVertexAttrib3f;
+  using theBaseClass_t::glVertexAttrib3fv;
+  using theBaseClass_t::glVertexAttrib3s;
+  using theBaseClass_t::glVertexAttrib3sv;
+  using theBaseClass_t::glVertexAttrib4Nbv;
+  using theBaseClass_t::glVertexAttrib4Niv;
+  using theBaseClass_t::glVertexAttrib4Nsv;
+  using theBaseClass_t::glVertexAttrib4Nub;
+  using theBaseClass_t::glVertexAttrib4Nubv;
+  using theBaseClass_t::glVertexAttrib4Nuiv;
+  using theBaseClass_t::glVertexAttrib4Nusv;
+  using theBaseClass_t::glVertexAttrib4bv;
+  using theBaseClass_t::glVertexAttrib4d;
+  using theBaseClass_t::glVertexAttrib4dv;
+  using theBaseClass_t::glVertexAttrib4f;
+  using theBaseClass_t::glVertexAttrib4fv;
+  using theBaseClass_t::glVertexAttrib4iv;
+  using theBaseClass_t::glVertexAttrib4s;
+  using theBaseClass_t::glVertexAttrib4sv;
+  using theBaseClass_t::glVertexAttrib4ubv;
+  using theBaseClass_t::glVertexAttrib4uiv;
+  using theBaseClass_t::glVertexAttrib4usv;
+  using theBaseClass_t::glVertexAttribPointer;
 
 };
 
-#endif // _OpenGl_GlCore20_H__
+//! OpenGL 2.0 core based on 1.5 version.
+typedef OpenGl_TmplCore20<OpenGl_GlCore15>    OpenGl_GlCore20;
+
+//! OpenGL 2.0 without deprecated entry points.
+typedef OpenGl_TmplCore20<OpenGl_GlCore15Fwd> OpenGl_GlCore20Fwd;
+
+#endif // _OpenGl_GlCore20_Header
diff --git a/src/OpenGl/OpenGl_GlCore21.hxx b/src/OpenGl/OpenGl_GlCore21.hxx
new file mode 100644 (file)
index 0000000..baedc9a
--- /dev/null
@@ -0,0 +1,43 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore21_Header
+#define _OpenGl_GlCore21_Header
+
+#include <OpenGl_GlCore20.hxx>
+
+//! OpenGL 2.1 core based on 2.0 version.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore21 : public theBaseClass_t
+{
+
+public: //! @name OpenGL 2.1 additives to 2.0
+
+  using theBaseClass_t::glUniformMatrix2x3fv;
+  using theBaseClass_t::glUniformMatrix3x2fv;
+  using theBaseClass_t::glUniformMatrix2x4fv;
+  using theBaseClass_t::glUniformMatrix4x2fv;
+  using theBaseClass_t::glUniformMatrix3x4fv;
+  using theBaseClass_t::glUniformMatrix4x3fv;
+
+};
+
+//! OpenGL 2.1 core based on 2.0 version.
+typedef OpenGl_TmplCore21<OpenGl_GlCore20>    OpenGl_GlCore21;
+
+//! OpenGL 2.1 without deprecated entry points.
+typedef OpenGl_TmplCore21<OpenGl_GlCore20Fwd> OpenGl_GlCore21Fwd;
+
+#endif // _OpenGl_GlCore21_Header
diff --git a/src/OpenGl/OpenGl_GlCore30.hxx b/src/OpenGl/OpenGl_GlCore30.hxx
new file mode 100644 (file)
index 0000000..d45fc84
--- /dev/null
@@ -0,0 +1,134 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore30_Header
+#define _OpenGl_GlCore30_Header
+
+#include <OpenGl_GlCore21.hxx>
+
+//! OpenGL 3.0 core.
+//! This is first version with deprecation model introduced
+//! - a lot of functionality regarding to fixed pipeline were marked deprecated.
+//! Notice that nothing were actually removed in this version (unless Forward context loaded)!
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore30 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_framebuffer_object (added to OpenGL 3.0 core)
+
+  using theBaseClass_t::glIsRenderbuffer;
+  using theBaseClass_t::glBindRenderbuffer;
+  using theBaseClass_t::glDeleteRenderbuffers;
+  using theBaseClass_t::glGenRenderbuffers;
+  using theBaseClass_t::glRenderbufferStorage;
+  using theBaseClass_t::glGetRenderbufferParameteriv;
+  using theBaseClass_t::glIsFramebuffer;
+  using theBaseClass_t::glBindFramebuffer;
+  using theBaseClass_t::glDeleteFramebuffers;
+  using theBaseClass_t::glGenFramebuffers;
+  using theBaseClass_t::glCheckFramebufferStatus;
+  using theBaseClass_t::glFramebufferTexture1D;
+  using theBaseClass_t::glFramebufferTexture2D;
+  using theBaseClass_t::glFramebufferTexture3D;
+  using theBaseClass_t::glFramebufferRenderbuffer;
+  using theBaseClass_t::glGetFramebufferAttachmentParameteriv;
+  using theBaseClass_t::glGenerateMipmap;
+  using theBaseClass_t::glBlitFramebuffer;
+  using theBaseClass_t::glRenderbufferStorageMultisample;
+  using theBaseClass_t::glFramebufferTextureLayer;
+
+public: //! @name GL_ARB_vertex_array_object (added to OpenGL 3.0 core)
+
+  using theBaseClass_t::glBindVertexArray;
+  using theBaseClass_t::glDeleteVertexArrays;
+  using theBaseClass_t::glGenVertexArrays;
+  using theBaseClass_t::glIsVertexArray;
+
+public: //! @name GL_ARB_map_buffer_range (added to OpenGL 3.0 core)
+
+  using theBaseClass_t::glMapBufferRange;
+  using theBaseClass_t::glFlushMappedBufferRange;
+
+public: //! @name OpenGL 3.0 additives to 2.1
+
+  using theBaseClass_t::glColorMaski;
+  using theBaseClass_t::glGetBooleani_v;
+  using theBaseClass_t::glGetIntegeri_v;
+  using theBaseClass_t::glEnablei;
+  using theBaseClass_t::glDisablei;
+  using theBaseClass_t::glIsEnabledi;
+  using theBaseClass_t::glBeginTransformFeedback;
+  using theBaseClass_t::glEndTransformFeedback;
+  using theBaseClass_t::glBindBufferRange;
+  using theBaseClass_t::glBindBufferBase;
+  using theBaseClass_t::glTransformFeedbackVaryings;
+  using theBaseClass_t::glGetTransformFeedbackVarying;
+  using theBaseClass_t::glClampColor;
+  using theBaseClass_t::glBeginConditionalRender;
+  using theBaseClass_t::glEndConditionalRender;
+  using theBaseClass_t::glVertexAttribIPointer;
+  using theBaseClass_t::glGetVertexAttribIiv;
+  using theBaseClass_t::glGetVertexAttribIuiv;
+  using theBaseClass_t::glVertexAttribI1i;
+  using theBaseClass_t::glVertexAttribI2i;
+  using theBaseClass_t::glVertexAttribI3i;
+  using theBaseClass_t::glVertexAttribI4i;
+  using theBaseClass_t::glVertexAttribI1ui;
+  using theBaseClass_t::glVertexAttribI2ui;
+  using theBaseClass_t::glVertexAttribI3ui;
+  using theBaseClass_t::glVertexAttribI4ui;
+  using theBaseClass_t::glVertexAttribI1iv;
+  using theBaseClass_t::glVertexAttribI2iv;
+  using theBaseClass_t::glVertexAttribI3iv;
+  using theBaseClass_t::glVertexAttribI4iv;
+  using theBaseClass_t::glVertexAttribI1uiv;
+  using theBaseClass_t::glVertexAttribI2uiv;
+  using theBaseClass_t::glVertexAttribI3uiv;
+  using theBaseClass_t::glVertexAttribI4uiv;
+  using theBaseClass_t::glVertexAttribI4bv;
+  using theBaseClass_t::glVertexAttribI4sv;
+  using theBaseClass_t::glVertexAttribI4ubv;
+  using theBaseClass_t::glVertexAttribI4usv;
+  using theBaseClass_t::glGetUniformuiv;
+  using theBaseClass_t::glBindFragDataLocation;
+  using theBaseClass_t::glGetFragDataLocation;
+  using theBaseClass_t::glUniform1ui;
+  using theBaseClass_t::glUniform2ui;
+  using theBaseClass_t::glUniform3ui;
+  using theBaseClass_t::glUniform4ui;
+  using theBaseClass_t::glUniform1uiv;
+  using theBaseClass_t::glUniform2uiv;
+  using theBaseClass_t::glUniform3uiv;
+  using theBaseClass_t::glUniform4uiv;
+  using theBaseClass_t::glTexParameterIiv;
+  using theBaseClass_t::glTexParameterIuiv;
+  using theBaseClass_t::glGetTexParameterIiv;
+  using theBaseClass_t::glGetTexParameterIuiv;
+  using theBaseClass_t::glClearBufferiv;
+  using theBaseClass_t::glClearBufferuiv;
+  using theBaseClass_t::glClearBufferfv;
+  using theBaseClass_t::glClearBufferfi;
+  using theBaseClass_t::glGetStringi;
+
+};
+
+//! OpenGL 3.0 core based on 2.1 version.
+typedef OpenGl_TmplCore30<OpenGl_GlCore21>    OpenGl_GlCore30;
+
+//! OpenGL 3.0 without deprecated entry points.
+//! Notice that this doesn't actually corresponds to GL3.0 forward profile!
+typedef OpenGl_TmplCore30<OpenGl_GlCore21Fwd> OpenGl_GlCore30Fwd;
+
+#endif // _OpenGl_GlCore30_Header
diff --git a/src/OpenGl/OpenGl_GlCore31.hxx b/src/OpenGl/OpenGl_GlCore31.hxx
new file mode 100644 (file)
index 0000000..495ac82
--- /dev/null
@@ -0,0 +1,56 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore31_Header
+#define _OpenGl_GlCore31_Header
+
+#include <OpenGl_GlCore30.hxx>
+
+//! OpenGL 3.1 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore31 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_uniform_buffer_object (added to OpenGL 3.1 core)
+
+  using theBaseClass_t::glGetUniformIndices;
+  using theBaseClass_t::glGetActiveUniformsiv;
+  using theBaseClass_t::glGetActiveUniformName;
+  using theBaseClass_t::glGetUniformBlockIndex;
+  using theBaseClass_t::glGetActiveUniformBlockiv;
+  using theBaseClass_t::glGetActiveUniformBlockName;
+  using theBaseClass_t::glUniformBlockBinding;
+
+public: //! @name GL_ARB_copy_buffer (added to OpenGL 3.1 core)
+
+  using theBaseClass_t::glCopyBufferSubData;
+
+public: //! @name OpenGL 3.1 additives to 3.0
+
+  using theBaseClass_t::glDrawArraysInstanced;
+  using theBaseClass_t::glDrawElementsInstanced;
+  using theBaseClass_t::glTexBuffer;
+  using theBaseClass_t::glPrimitiveRestartIndex;
+
+};
+
+//! OpenGL 3.1 compatibility profile.
+typedef OpenGl_TmplCore31<OpenGl_GlCore30>    OpenGl_GlCore31Back;
+
+//! OpenGL 3.1 core profile (without removed entry points marked as deprecated in 3.0).
+//! Notice that GLSL versions 1.10 and 1.20 also removed in 3.1!
+typedef OpenGl_TmplCore31<OpenGl_GlCore30Fwd> OpenGl_GlCore31;
+
+#endif // _OpenGl_GlCore31_Header
diff --git a/src/OpenGl/OpenGl_GlCore32.hxx b/src/OpenGl/OpenGl_GlCore32.hxx
new file mode 100644 (file)
index 0000000..a32c062
--- /dev/null
@@ -0,0 +1,68 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore32_Header
+#define _OpenGl_GlCore32_Header
+
+#include <OpenGl_GlCore31.hxx>
+
+//! OpenGL 3.2 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore32 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_draw_elements_base_vertex (added to OpenGL 3.2 core)
+
+  using theBaseClass_t::glDrawElementsBaseVertex;
+  using theBaseClass_t::glDrawRangeElementsBaseVertex;
+  using theBaseClass_t::glDrawElementsInstancedBaseVertex;
+  using theBaseClass_t::glMultiDrawElementsBaseVertex;
+
+public: //! @name GL_ARB_provoking_vertex (added to OpenGL 3.2 core)
+
+  using theBaseClass_t::glProvokingVertex;
+
+public: //! @name GL_ARB_sync (added to OpenGL 3.2 core)
+
+  using theBaseClass_t::glFenceSync;
+  using theBaseClass_t::glIsSync;
+  using theBaseClass_t::glDeleteSync;
+  using theBaseClass_t::glClientWaitSync;
+  using theBaseClass_t::glWaitSync;
+  using theBaseClass_t::glGetInteger64v;
+  using theBaseClass_t::glGetSynciv;
+
+public: //! @name GL_ARB_texture_multisample (added to OpenGL 3.2 core)
+
+  using theBaseClass_t::glTexImage2DMultisample;
+  using theBaseClass_t::glTexImage3DMultisample;
+  using theBaseClass_t::glGetMultisamplefv;
+  using theBaseClass_t::glSampleMaski;
+
+public: //! @name OpenGL 3.2 additives to 3.1
+
+  using theBaseClass_t::glGetInteger64i_v;
+  using theBaseClass_t::glGetBufferParameteri64v;
+  using theBaseClass_t::glFramebufferTexture;
+
+};
+
+//! OpenGL 3.2 compatibility profile.
+typedef OpenGl_TmplCore32<OpenGl_GlCore31Back> OpenGl_GlCore32Back;
+
+//! OpenGL 3.2 core profile.
+typedef OpenGl_TmplCore32<OpenGl_GlCore31>     OpenGl_GlCore32;
+
+#endif // _OpenGl_GlCore32_Header
diff --git a/src/OpenGl/OpenGl_GlCore33.hxx b/src/OpenGl/OpenGl_GlCore33.hxx
new file mode 100644 (file)
index 0000000..192f52d
--- /dev/null
@@ -0,0 +1,107 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore33_Header
+#define _OpenGl_GlCore33_Header
+
+#include <OpenGl_GlCore32.hxx>
+
+//! OpenGL 3.3 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore33 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_blend_func_extended (added to OpenGL 3.3 core)
+
+  using theBaseClass_t::glBindFragDataLocationIndexed;
+  using theBaseClass_t::glGetFragDataIndex;
+
+public: //! @name GL_ARB_sampler_objects (added to OpenGL 3.3 core)
+
+  using theBaseClass_t::glGenSamplers;
+  using theBaseClass_t::glDeleteSamplers;
+  using theBaseClass_t::glIsSampler;
+  using theBaseClass_t::glBindSampler;
+  using theBaseClass_t::glSamplerParameteri;
+  using theBaseClass_t::glSamplerParameteriv;
+  using theBaseClass_t::glSamplerParameterf;
+  using theBaseClass_t::glSamplerParameterfv;
+  using theBaseClass_t::glSamplerParameterIiv;
+  using theBaseClass_t::glSamplerParameterIuiv;
+  using theBaseClass_t::glGetSamplerParameteriv;
+  using theBaseClass_t::glGetSamplerParameterIiv;
+  using theBaseClass_t::glGetSamplerParameterfv;
+  using theBaseClass_t::glGetSamplerParameterIuiv;
+
+public: //! @name GL_ARB_timer_query (added to OpenGL 3.3 core)
+
+  using theBaseClass_t::glQueryCounter;
+  using theBaseClass_t::glGetQueryObjecti64v;
+  using theBaseClass_t::glGetQueryObjectui64v;
+
+public: //! @name GL_ARB_vertex_type_2_10_10_10_rev (added to OpenGL 3.3 core)
+
+  using theBaseClass_t::glVertexP2ui;
+  using theBaseClass_t::glVertexP2uiv;
+  using theBaseClass_t::glVertexP3ui;
+  using theBaseClass_t::glVertexP3uiv;
+  using theBaseClass_t::glVertexP4ui;
+  using theBaseClass_t::glVertexP4uiv;
+  using theBaseClass_t::glTexCoordP1ui;
+  using theBaseClass_t::glTexCoordP1uiv;
+  using theBaseClass_t::glTexCoordP2ui;
+  using theBaseClass_t::glTexCoordP2uiv;
+  using theBaseClass_t::glTexCoordP3ui;
+  using theBaseClass_t::glTexCoordP3uiv;
+  using theBaseClass_t::glTexCoordP4ui;
+  using theBaseClass_t::glTexCoordP4uiv;
+  using theBaseClass_t::glMultiTexCoordP1ui;
+  using theBaseClass_t::glMultiTexCoordP1uiv;
+  using theBaseClass_t::glMultiTexCoordP2ui;
+  using theBaseClass_t::glMultiTexCoordP2uiv;
+  using theBaseClass_t::glMultiTexCoordP3ui;
+  using theBaseClass_t::glMultiTexCoordP3uiv;
+  using theBaseClass_t::glMultiTexCoordP4ui;
+  using theBaseClass_t::glMultiTexCoordP4uiv;
+  using theBaseClass_t::glNormalP3ui;
+  using theBaseClass_t::glNormalP3uiv;
+  using theBaseClass_t::glColorP3ui;
+  using theBaseClass_t::glColorP3uiv;
+  using theBaseClass_t::glColorP4ui;
+  using theBaseClass_t::glColorP4uiv;
+  using theBaseClass_t::glSecondaryColorP3ui;
+  using theBaseClass_t::glSecondaryColorP3uiv;
+  using theBaseClass_t::glVertexAttribP1ui;
+  using theBaseClass_t::glVertexAttribP1uiv;
+  using theBaseClass_t::glVertexAttribP2ui;
+  using theBaseClass_t::glVertexAttribP2uiv;
+  using theBaseClass_t::glVertexAttribP3ui;
+  using theBaseClass_t::glVertexAttribP3uiv;
+  using theBaseClass_t::glVertexAttribP4ui;
+  using theBaseClass_t::glVertexAttribP4uiv;
+
+public: //! @name OpenGL 3.3 additives to 3.2
+
+  using theBaseClass_t::glVertexAttribDivisor;
+
+};
+
+//! OpenGL 3.3 compatibility profile.
+typedef OpenGl_TmplCore33<OpenGl_GlCore32Back> OpenGl_GlCore33Back;
+
+//! OpenGL 3.3 core profile.
+typedef OpenGl_TmplCore33<OpenGl_GlCore32>     OpenGl_GlCore33;
+
+#endif // _OpenGl_GlCore33_Header
diff --git a/src/OpenGl/OpenGl_GlCore40.hxx b/src/OpenGl/OpenGl_GlCore40.hxx
new file mode 100644 (file)
index 0000000..c8a289c
--- /dev/null
@@ -0,0 +1,101 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore40_Header
+#define _OpenGl_GlCore40_Header
+
+#include <OpenGl_GlCore33.hxx>
+
+//! OpenGL 4.0 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore40 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_draw_indirect (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glDrawArraysIndirect;
+  using theBaseClass_t::glDrawElementsIndirect;
+
+public: //! @name GL_ARB_gpu_shader_fp64 (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glUniform1d;
+  using theBaseClass_t::glUniform2d;
+  using theBaseClass_t::glUniform3d;
+  using theBaseClass_t::glUniform4d;
+  using theBaseClass_t::glUniform1dv;
+  using theBaseClass_t::glUniform2dv;
+  using theBaseClass_t::glUniform3dv;
+  using theBaseClass_t::glUniform4dv;
+  using theBaseClass_t::glUniformMatrix2dv;
+  using theBaseClass_t::glUniformMatrix3dv;
+  using theBaseClass_t::glUniformMatrix4dv;
+  using theBaseClass_t::glUniformMatrix2x3dv;
+  using theBaseClass_t::glUniformMatrix2x4dv;
+  using theBaseClass_t::glUniformMatrix3x2dv;
+  using theBaseClass_t::glUniformMatrix3x4dv;
+  using theBaseClass_t::glUniformMatrix4x2dv;
+  using theBaseClass_t::glUniformMatrix4x3dv;
+  using theBaseClass_t::glGetUniformdv;
+
+public: //! @name GL_ARB_shader_subroutine (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glGetSubroutineUniformLocation;
+  using theBaseClass_t::glGetSubroutineIndex;
+  using theBaseClass_t::glGetActiveSubroutineUniformiv;
+  using theBaseClass_t::glGetActiveSubroutineUniformName;
+  using theBaseClass_t::glGetActiveSubroutineName;
+  using theBaseClass_t::glUniformSubroutinesuiv;
+  using theBaseClass_t::glGetUniformSubroutineuiv;
+  using theBaseClass_t::glGetProgramStageiv;
+
+public: //! @name GL_ARB_tessellation_shader (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glPatchParameteri;
+  using theBaseClass_t::glPatchParameterfv;
+
+public: //! @name GL_ARB_transform_feedback2 (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glBindTransformFeedback;
+  using theBaseClass_t::glDeleteTransformFeedbacks;
+  using theBaseClass_t::glGenTransformFeedbacks;
+  using theBaseClass_t::glIsTransformFeedback;
+  using theBaseClass_t::glPauseTransformFeedback;
+  using theBaseClass_t::glResumeTransformFeedback;
+  using theBaseClass_t::glDrawTransformFeedback;
+
+public: //! @name GL_ARB_transform_feedback3 (added to OpenGL 4.0 core)
+
+  using theBaseClass_t::glDrawTransformFeedbackStream;
+  using theBaseClass_t::glBeginQueryIndexed;
+  using theBaseClass_t::glEndQueryIndexed;
+  using theBaseClass_t::glGetQueryIndexediv;
+
+public: //! @name OpenGL 4.0 additives to 3.3
+
+  using theBaseClass_t::glMinSampleShading;
+  using theBaseClass_t::glBlendEquationi;
+  using theBaseClass_t::glBlendEquationSeparatei;
+  using theBaseClass_t::glBlendFunci;
+  using theBaseClass_t::glBlendFuncSeparatei;
+
+};
+
+//! OpenGL 4.0 compatibility profile.
+typedef OpenGl_TmplCore40<OpenGl_GlCore33Back> OpenGl_GlCore40Back;
+
+//! OpenGL 4.0 core profile.
+typedef OpenGl_TmplCore40<OpenGl_GlCore33>     OpenGl_GlCore40;
+
+#endif // _OpenGl_GlCore40_Header
diff --git a/src/OpenGl/OpenGl_GlCore41.hxx b/src/OpenGl/OpenGl_GlCore41.hxx
new file mode 100644 (file)
index 0000000..efa57b5
--- /dev/null
@@ -0,0 +1,139 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore41_Header
+#define _OpenGl_GlCore41_Header
+
+#include <OpenGl_GlCore40.hxx>
+
+//! OpenGL 4.1 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore41 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_ES2_compatibility (added to OpenGL 4.1 core)
+
+  using theBaseClass_t::glReleaseShaderCompiler;
+  using theBaseClass_t::glShaderBinary;
+  using theBaseClass_t::glGetShaderPrecisionFormat;
+  using theBaseClass_t::glDepthRangef;
+  using theBaseClass_t::glClearDepthf;
+
+public: //! @name GL_ARB_get_program_binary (added to OpenGL 4.1 core)
+
+  using theBaseClass_t::glGetProgramBinary;
+  using theBaseClass_t::glProgramBinary;
+  using theBaseClass_t::glProgramParameteri;
+
+public: //! @name GL_ARB_separate_shader_objects (added to OpenGL 4.1 core)
+
+  using theBaseClass_t::glUseProgramStages;
+  using theBaseClass_t::glActiveShaderProgram;
+  using theBaseClass_t::glCreateShaderProgramv;
+  using theBaseClass_t::glBindProgramPipeline;
+  using theBaseClass_t::glDeleteProgramPipelines;
+  using theBaseClass_t::glGenProgramPipelines;
+  using theBaseClass_t::glIsProgramPipeline;
+  using theBaseClass_t::glGetProgramPipelineiv;
+  using theBaseClass_t::glProgramUniform1i;
+  using theBaseClass_t::glProgramUniform1iv;
+  using theBaseClass_t::glProgramUniform1f;
+  using theBaseClass_t::glProgramUniform1fv;
+  using theBaseClass_t::glProgramUniform1d;
+  using theBaseClass_t::glProgramUniform1dv;
+  using theBaseClass_t::glProgramUniform1ui;
+  using theBaseClass_t::glProgramUniform1uiv;
+  using theBaseClass_t::glProgramUniform2i;
+  using theBaseClass_t::glProgramUniform2iv;
+  using theBaseClass_t::glProgramUniform2f;
+  using theBaseClass_t::glProgramUniform2fv;
+  using theBaseClass_t::glProgramUniform2d;
+  using theBaseClass_t::glProgramUniform2dv;
+  using theBaseClass_t::glProgramUniform2ui;
+  using theBaseClass_t::glProgramUniform2uiv;
+  using theBaseClass_t::glProgramUniform3i;
+  using theBaseClass_t::glProgramUniform3iv;
+  using theBaseClass_t::glProgramUniform3f;
+  using theBaseClass_t::glProgramUniform3fv;
+  using theBaseClass_t::glProgramUniform3d;
+  using theBaseClass_t::glProgramUniform3dv;
+  using theBaseClass_t::glProgramUniform3ui;
+  using theBaseClass_t::glProgramUniform3uiv;
+  using theBaseClass_t::glProgramUniform4i;
+  using theBaseClass_t::glProgramUniform4iv;
+  using theBaseClass_t::glProgramUniform4f;
+  using theBaseClass_t::glProgramUniform4fv;
+  using theBaseClass_t::glProgramUniform4d;
+  using theBaseClass_t::glProgramUniform4dv;
+  using theBaseClass_t::glProgramUniform4ui;
+  using theBaseClass_t::glProgramUniform4uiv;
+  using theBaseClass_t::glProgramUniformMatrix2fv;
+  using theBaseClass_t::glProgramUniformMatrix3fv;
+  using theBaseClass_t::glProgramUniformMatrix4fv;
+  using theBaseClass_t::glProgramUniformMatrix2dv;
+  using theBaseClass_t::glProgramUniformMatrix3dv;
+  using theBaseClass_t::glProgramUniformMatrix4dv;
+  using theBaseClass_t::glProgramUniformMatrix2x3fv;
+  using theBaseClass_t::glProgramUniformMatrix3x2fv;
+  using theBaseClass_t::glProgramUniformMatrix2x4fv;
+  using theBaseClass_t::glProgramUniformMatrix4x2fv;
+  using theBaseClass_t::glProgramUniformMatrix3x4fv;
+  using theBaseClass_t::glProgramUniformMatrix4x3fv;
+  using theBaseClass_t::glProgramUniformMatrix2x3dv;
+  using theBaseClass_t::glProgramUniformMatrix3x2dv;
+  using theBaseClass_t::glProgramUniformMatrix2x4dv;
+  using theBaseClass_t::glProgramUniformMatrix4x2dv;
+  using theBaseClass_t::glProgramUniformMatrix3x4dv;
+  using theBaseClass_t::glProgramUniformMatrix4x3dv;
+  using theBaseClass_t::glValidateProgramPipeline;
+  using theBaseClass_t::glGetProgramPipelineInfoLog;
+
+public: //! @name GL_ARB_vertex_attrib_64bit (added to OpenGL 4.1 core)
+
+  using theBaseClass_t::glVertexAttribL1d;
+  using theBaseClass_t::glVertexAttribL2d;
+  using theBaseClass_t::glVertexAttribL3d;
+  using theBaseClass_t::glVertexAttribL4d;
+  using theBaseClass_t::glVertexAttribL1dv;
+  using theBaseClass_t::glVertexAttribL2dv;
+  using theBaseClass_t::glVertexAttribL3dv;
+  using theBaseClass_t::glVertexAttribL4dv;
+  using theBaseClass_t::glVertexAttribLPointer;
+  using theBaseClass_t::glGetVertexAttribLdv;
+
+public: //! @name GL_ARB_viewport_array (added to OpenGL 4.1 core)
+
+  using theBaseClass_t::glViewportArrayv;
+  using theBaseClass_t::glViewportIndexedf;
+  using theBaseClass_t::glViewportIndexedfv;
+  using theBaseClass_t::glScissorArrayv;
+  using theBaseClass_t::glScissorIndexed;
+  using theBaseClass_t::glScissorIndexedv;
+  using theBaseClass_t::glDepthRangeArrayv;
+  using theBaseClass_t::glDepthRangeIndexed;
+  using theBaseClass_t::glGetFloati_v;
+  using theBaseClass_t::glGetDoublei_v;
+
+public: //! @name OpenGL 4.1 additives to 4.0
+
+};
+
+//! OpenGL 4.1 compatibility profile.
+typedef OpenGl_TmplCore41<OpenGl_GlCore40Back> OpenGl_GlCore41Back;
+
+//! OpenGL 4.1 core profile.
+typedef OpenGl_TmplCore41<OpenGl_GlCore40>     OpenGl_GlCore41;
+
+#endif // _OpenGl_GlCore41_Header
diff --git a/src/OpenGl/OpenGl_GlCore42.hxx b/src/OpenGl/OpenGl_GlCore42.hxx
new file mode 100644 (file)
index 0000000..01ba9ce
--- /dev/null
@@ -0,0 +1,68 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore42_Header
+#define _OpenGl_GlCore42_Header
+
+#include <OpenGl_GlCore41.hxx>
+
+//! OpenGL 4.2 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore42 : public theBaseClass_t
+{
+
+public: //! @name GL_ARB_base_instance (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glDrawArraysInstancedBaseInstance;
+  using theBaseClass_t::glDrawElementsInstancedBaseInstance;
+  using theBaseClass_t::glDrawElementsInstancedBaseVertexBaseInstance;
+
+public: //! @name GL_ARB_transform_feedback_instanced (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glDrawTransformFeedbackInstanced;
+  using theBaseClass_t::glDrawTransformFeedbackStreamInstanced;
+
+public: //! @name GL_ARB_internalformat_query (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glGetInternalformativ;
+
+public: //! @name GL_ARB_shader_atomic_counters (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glGetActiveAtomicCounterBufferiv;
+
+public: //! @name GL_ARB_shader_image_load_store (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glBindImageTexture;
+  using theBaseClass_t::glMemoryBarrier;
+
+public: //! @name GL_ARB_texture_storage (added to OpenGL 4.2 core)
+
+  using theBaseClass_t::glTexStorage1D;
+  using theBaseClass_t::glTexStorage2D;
+  using theBaseClass_t::glTexStorage3D;
+  using theBaseClass_t::glTextureStorage1DEXT;
+  using theBaseClass_t::glTextureStorage2DEXT;
+  using theBaseClass_t::glTextureStorage3DEXT;
+
+};
+
+//! OpenGL 4.2 compatibility profile.
+typedef OpenGl_TmplCore42<OpenGl_GlCore41Back> OpenGl_GlCore42Back;
+
+//! OpenGL 4.2 core profile.
+typedef OpenGl_TmplCore42<OpenGl_GlCore41>     OpenGl_GlCore42;
+
+
+#endif // _OpenGl_GlCore42_Header
diff --git a/src/OpenGl/OpenGl_GlCore43.hxx b/src/OpenGl/OpenGl_GlCore43.hxx
new file mode 100644 (file)
index 0000000..2a34586
--- /dev/null
@@ -0,0 +1,80 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore43_Header
+#define _OpenGl_GlCore43_Header
+
+#include <OpenGl_GlCore42.hxx>
+
+//! OpenGL 4.3 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore43 : public theBaseClass_t
+{
+
+public: //! @name OpenGL 4.3 additives to 4.2
+
+  using theBaseClass_t::glClearBufferData;
+  using theBaseClass_t::glClearBufferSubData;
+  using theBaseClass_t::glDispatchCompute;
+  using theBaseClass_t::glDispatchComputeIndirect;
+  using theBaseClass_t::glCopyImageSubData;
+  using theBaseClass_t::glFramebufferParameteri;
+  using theBaseClass_t::glGetFramebufferParameteriv;
+  using theBaseClass_t::glGetInternalformati64v;
+  using theBaseClass_t::glInvalidateTexSubImage;
+  using theBaseClass_t::glInvalidateTexImage;
+  using theBaseClass_t::glInvalidateBufferSubData;
+  using theBaseClass_t::glInvalidateBufferData;
+  using theBaseClass_t::glInvalidateFramebuffer;
+  using theBaseClass_t::glInvalidateSubFramebuffer;
+  using theBaseClass_t::glMultiDrawArraysIndirect;
+  using theBaseClass_t::glMultiDrawElementsIndirect;
+  using theBaseClass_t::glGetProgramInterfaceiv;
+  using theBaseClass_t::glGetProgramResourceIndex;
+  using theBaseClass_t::glGetProgramResourceName;
+  using theBaseClass_t::glGetProgramResourceiv;
+  using theBaseClass_t::glGetProgramResourceLocation;
+  using theBaseClass_t::glGetProgramResourceLocationIndex;
+  using theBaseClass_t::glShaderStorageBlockBinding;
+  using theBaseClass_t::glTexBufferRange;
+  using theBaseClass_t::glTexStorage2DMultisample;
+  using theBaseClass_t::glTexStorage3DMultisample;
+  using theBaseClass_t::glTextureView;
+  using theBaseClass_t::glBindVertexBuffer;
+  using theBaseClass_t::glVertexAttribFormat;
+  using theBaseClass_t::glVertexAttribIFormat;
+  using theBaseClass_t::glVertexAttribLFormat;
+  using theBaseClass_t::glVertexAttribBinding;
+  using theBaseClass_t::glVertexBindingDivisor;
+  using theBaseClass_t::glDebugMessageControl;
+  using theBaseClass_t::glDebugMessageInsert;
+  using theBaseClass_t::glDebugMessageCallback;
+  using theBaseClass_t::glGetDebugMessageLog;
+  using theBaseClass_t::glPushDebugGroup;
+  using theBaseClass_t::glPopDebugGroup;
+  using theBaseClass_t::glObjectLabel;
+  using theBaseClass_t::glGetObjectLabel;
+  using theBaseClass_t::glObjectPtrLabel;
+  using theBaseClass_t::glGetObjectPtrLabel;
+
+};
+
+//! OpenGL 4.3 compatibility profile.
+typedef OpenGl_TmplCore43<OpenGl_GlCore42Back> OpenGl_GlCore43Back;
+
+//! OpenGL 4.3 core profile.
+typedef OpenGl_TmplCore43<OpenGl_GlCore42>     OpenGl_GlCore43;
+
+#endif // _OpenGl_GlCore43_Header
diff --git a/src/OpenGl/OpenGl_GlCore44.hxx b/src/OpenGl/OpenGl_GlCore44.hxx
new file mode 100644 (file)
index 0000000..b69ec82
--- /dev/null
@@ -0,0 +1,46 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlCore44_Header
+#define _OpenGl_GlCore44_Header
+
+#include <OpenGl_GlCore43.hxx>
+
+//! OpenGL 4.4 definition.
+template<typename theBaseClass_t>
+struct OpenGl_TmplCore44 : public theBaseClass_t
+{
+
+public: //! @name OpenGL 4.4 additives to 4.3
+
+  using theBaseClass_t::glBufferStorage;
+  using theBaseClass_t::glClearTexImage;
+  using theBaseClass_t::glClearTexSubImage;
+  using theBaseClass_t::glBindBuffersBase;
+  using theBaseClass_t::glBindBuffersRange;
+  using theBaseClass_t::glBindTextures;
+  using theBaseClass_t::glBindSamplers;
+  using theBaseClass_t::glBindImageTextures;
+  using theBaseClass_t::glBindVertexBuffers;
+
+};
+
+//! OpenGL 4.4 compatibility profile.
+typedef OpenGl_TmplCore44<OpenGl_GlCore43Back> OpenGl_GlCore44Back;
+
+//! OpenGL 4.4 core profile.
+typedef OpenGl_TmplCore44<OpenGl_GlCore43>     OpenGl_GlCore44;
+
+#endif // _OpenGl_GlCore44_Header
diff --git a/src/OpenGl/OpenGl_GlFunctions.hxx b/src/OpenGl/OpenGl_GlFunctions.hxx
new file mode 100644 (file)
index 0000000..f2157c3
--- /dev/null
@@ -0,0 +1,940 @@
+// Created on: 2014-03-17
+// Created by: Kirill GAVRILOV
+// Copyright (c) 2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _OpenGl_GlFunctions_Header
+#define _OpenGl_GlFunctions_Header
+
+// required for correct APIENTRY definition
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+  #define WIN32_LEAN_AND_MEAN
+  #include <windows.h>
+#endif
+
+#ifndef APIENTRY
+  #define APIENTRY
+#endif
+#ifndef APIENTRYP
+  #define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+  #define GLAPI extern
+#endif
+
+// exclude modern definitions and system-provided glext.h, should be defined before gl.h inclusion
+#define GL_GLEXT_LEGACY
+
+// include main OpenGL header provided with system
+#if defined(__APPLE__)
+  #include <OpenGL/gl.h>
+  #include <OpenGL/glu.h>
+  #define __X_GL_H // prevent chaotic gl.h inclusions to avoid compile errors
+#else
+  #include <GL/gl.h>
+  #include <GL/glu.h>
+#endif
+
+#include <InterfaceGraphic.hxx>
+#include <InterfaceGraphic_tgl_all.hxx>
+#include <InterfaceGraphic_telem.hxx>
+
+// GL version can be defined by system gl.h header
+#undef GL_VERSION_1_2
+#undef GL_VERSION_1_3
+#undef GL_VERSION_1_4
+#undef GL_VERSION_1_5
+#undef GL_VERSION_2_0
+#undef GL_VERSION_2_1
+#undef GL_VERSION_3_0
+#undef GL_VERSION_3_1
+#undef GL_VERSION_3_2
+#undef GL_VERSION_3_3
+#undef GL_VERSION_4_0
+#undef GL_VERSION_4_1
+#undef GL_VERSION_4_2
+#undef GL_VERSION_4_3
+#undef GL_VERSION_4_4
+
+// include glext.h provided by Khronos group
+#include <glext.h>
+
+//! Mega structure defines the complete list of OpenGL functions.
+struct OpenGl_GlFunctions
+{
+
+public: //! @name OpenGL 1.2
+
+  PFNGLBLENDCOLORPROC               glBlendColor;
+  PFNGLBLENDEQUATIONPROC            glBlendEquation;
+  PFNGLDRAWRANGEELEMENTSPROC        glDrawRangeElements;
+  PFNGLTEXIMAGE3DPROC               glTexImage3D;
+  PFNGLTEXSUBIMAGE3DPROC            glTexSubImage3D;
+  PFNGLCOPYTEXSUBIMAGE3DPROC        glCopyTexSubImage3D;
+
+public: //! @name OpenGL 1.3
+
+  PFNGLACTIVETEXTUREPROC            glActiveTexture;
+  PFNGLSAMPLECOVERAGEPROC           glSampleCoverage;
+  PFNGLCOMPRESSEDTEXIMAGE3DPROC     glCompressedTexImage3D;
+  PFNGLCOMPRESSEDTEXIMAGE2DPROC     glCompressedTexImage2D;
+  PFNGLCOMPRESSEDTEXIMAGE1DPROC     glCompressedTexImage1D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC  glCompressedTexSubImage3D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC  glCompressedTexSubImage2D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC  glCompressedTexSubImage1D;
+  PFNGLGETCOMPRESSEDTEXIMAGEPROC    glGetCompressedTexImage;
+
+  PFNGLCLIENTACTIVETEXTUREPROC      glClientActiveTexture;
+  PFNGLMULTITEXCOORD1DPROC          glMultiTexCoord1d;
+  PFNGLMULTITEXCOORD1DVPROC         glMultiTexCoord1dv;
+  PFNGLMULTITEXCOORD1FPROC          glMultiTexCoord1f;
+  PFNGLMULTITEXCOORD1FVPROC         glMultiTexCoord1fv;
+  PFNGLMULTITEXCOORD1IPROC          glMultiTexCoord1i;
+  PFNGLMULTITEXCOORD1IVPROC         glMultiTexCoord1iv;
+  PFNGLMULTITEXCOORD1SPROC          glMultiTexCoord1s;
+  PFNGLMULTITEXCOORD1SVPROC         glMultiTexCoord1sv;
+  PFNGLMULTITEXCOORD2DPROC          glMultiTexCoord2d;
+  PFNGLMULTITEXCOORD2DVPROC         glMultiTexCoord2dv;
+  PFNGLMULTITEXCOORD2FPROC          glMultiTexCoord2f;
+  PFNGLMULTITEXCOORD2FVPROC         glMultiTexCoord2fv;
+  PFNGLMULTITEXCOORD2IPROC          glMultiTexCoord2i;
+  PFNGLMULTITEXCOORD2IVPROC         glMultiTexCoord2iv;
+  PFNGLMULTITEXCOORD2SPROC          glMultiTexCoord2s;
+  PFNGLMULTITEXCOORD2SVPROC         glMultiTexCoord2sv;
+  PFNGLMULTITEXCOORD3DPROC          glMultiTexCoord3d;
+  PFNGLMULTITEXCOORD3DVPROC         glMultiTexCoord3dv;
+  PFNGLMULTITEXCOORD3FPROC          glMultiTexCoord3f;
+  PFNGLMULTITEXCOORD3FVPROC         glMultiTexCoord3fv;
+  PFNGLMULTITEXCOORD3IPROC          glMultiTexCoord3i;
+  PFNGLMULTITEXCOORD3IVPROC         glMultiTexCoord3iv;
+  PFNGLMULTITEXCOORD3SPROC          glMultiTexCoord3s;
+  PFNGLMULTITEXCOORD3SVPROC         glMultiTexCoord3sv;
+  PFNGLMULTITEXCOORD4DPROC          glMultiTexCoord4d;
+  PFNGLMULTITEXCOORD4DVPROC         glMultiTexCoord4dv;
+  PFNGLMULTITEXCOORD4FPROC          glMultiTexCoord4f;
+  PFNGLMULTITEXCOORD4FVPROC         glMultiTexCoord4fv;
+  PFNGLMULTITEXCOORD4IPROC          glMultiTexCoord4i;
+  PFNGLMULTITEXCOORD4IVPROC         glMultiTexCoord4iv;
+  PFNGLMULTITEXCOORD4SPROC          glMultiTexCoord4s;
+  PFNGLMULTITEXCOORD4SVPROC         glMultiTexCoord4sv;
+  PFNGLLOADTRANSPOSEMATRIXFPROC     glLoadTransposeMatrixf;
+  PFNGLLOADTRANSPOSEMATRIXDPROC     glLoadTransposeMatrixd;
+  PFNGLMULTTRANSPOSEMATRIXFPROC     glMultTransposeMatrixf;
+  PFNGLMULTTRANSPOSEMATRIXDPROC     glMultTransposeMatrixd;
+
+public: //! @name OpenGL 1.4
+
+  PFNGLBLENDFUNCSEPARATEPROC        glBlendFuncSeparate;
+  PFNGLMULTIDRAWARRAYSPROC          glMultiDrawArrays;
+  PFNGLMULTIDRAWELEMENTSPROC        glMultiDrawElements;
+  PFNGLPOINTPARAMETERFPROC          glPointParameterf;
+  PFNGLPOINTPARAMETERFVPROC         glPointParameterfv;
+  PFNGLPOINTPARAMETERIPROC          glPointParameteri;
+  PFNGLPOINTPARAMETERIVPROC         glPointParameteriv;
+
+public: //! @name OpenGL 1.5
+
+  PFNGLGENQUERIESPROC               glGenQueries;
+  PFNGLDELETEQUERIESPROC            glDeleteQueries;
+  PFNGLISQUERYPROC                  glIsQuery;
+  PFNGLBEGINQUERYPROC               glBeginQuery;
+  PFNGLENDQUERYPROC                 glEndQuery;
+  PFNGLGETQUERYIVPROC               glGetQueryiv;
+  PFNGLGETQUERYOBJECTIVPROC         glGetQueryObjectiv;
+  PFNGLGETQUERYOBJECTUIVPROC        glGetQueryObjectuiv;
+  PFNGLBINDBUFFERPROC               glBindBuffer;
+  PFNGLDELETEBUFFERSPROC            glDeleteBuffers;
+  PFNGLGENBUFFERSPROC               glGenBuffers;
+  PFNGLISBUFFERPROC                 glIsBuffer;
+  PFNGLBUFFERDATAPROC               glBufferData;
+  PFNGLBUFFERSUBDATAPROC            glBufferSubData;
+  PFNGLGETBUFFERSUBDATAPROC         glGetBufferSubData;
+  PFNGLMAPBUFFERPROC                glMapBuffer;
+  PFNGLUNMAPBUFFERPROC              glUnmapBuffer;
+  PFNGLGETBUFFERPARAMETERIVPROC     glGetBufferParameteriv;
+  PFNGLGETBUFFERPOINTERVPROC        glGetBufferPointerv;
+
+public: //! @name OpenGL 2.0
+
+  PFNGLBLENDEQUATIONSEPARATEPROC    glBlendEquationSeparate;
+  PFNGLDRAWBUFFERSPROC              glDrawBuffers;
+  PFNGLSTENCILOPSEPARATEPROC        glStencilOpSeparate;
+  PFNGLSTENCILFUNCSEPARATEPROC      glStencilFuncSeparate;
+  PFNGLSTENCILMASKSEPARATEPROC      glStencilMaskSeparate;
+  PFNGLATTACHSHADERPROC             glAttachShader;
+  PFNGLBINDATTRIBLOCATIONPROC       glBindAttribLocation;
+  PFNGLCOMPILESHADERPROC            glCompileShader;
+  PFNGLCREATEPROGRAMPROC            glCreateProgram;
+  PFNGLCREATESHADERPROC             glCreateShader;
+  PFNGLDELETEPROGRAMPROC            glDeleteProgram;
+  PFNGLDELETESHADERPROC             glDeleteShader;
+  PFNGLDETACHSHADERPROC             glDetachShader;
+  PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
+  PFNGLENABLEVERTEXATTRIBARRAYPROC  glEnableVertexAttribArray;
+  PFNGLGETACTIVEATTRIBPROC          glGetActiveAttrib;
+  PFNGLGETACTIVEUNIFORMPROC         glGetActiveUniform;
+  PFNGLGETATTACHEDSHADERSPROC       glGetAttachedShaders;
+  PFNGLGETATTRIBLOCATIONPROC        glGetAttribLocation;
+  PFNGLGETPROGRAMIVPROC             glGetProgramiv;
+  PFNGLGETPROGRAMINFOLOGPROC        glGetProgramInfoLog;
+  PFNGLGETSHADERIVPROC              glGetShaderiv;
+  PFNGLGETSHADERINFOLOGPROC         glGetShaderInfoLog;
+  PFNGLGETSHADERSOURCEPROC          glGetShaderSource;
+  PFNGLGETUNIFORMLOCATIONPROC       glGetUniformLocation;
+  PFNGLGETUNIFORMFVPROC             glGetUniformfv;
+  PFNGLGETUNIFORMIVPROC             glGetUniformiv;
+  PFNGLGETVERTEXATTRIBDVPROC        glGetVertexAttribdv;
+  PFNGLGETVERTEXATTRIBFVPROC        glGetVertexAttribfv;
+  PFNGLGETVERTEXATTRIBIVPROC        glGetVertexAttribiv;
+  PFNGLGETVERTEXATTRIBPOINTERVPROC  glGetVertexAttribPointerv;
+  PFNGLISPROGRAMPROC                glIsProgram;
+  PFNGLISSHADERPROC                 glIsShader;
+  PFNGLLINKPROGRAMPROC              glLinkProgram;
+  PFNGLSHADERSOURCEPROC             glShaderSource;
+  PFNGLUSEPROGRAMPROC               glUseProgram;
+  PFNGLUNIFORM1FPROC                glUniform1f;
+  PFNGLUNIFORM2FPROC                glUniform2f;
+  PFNGLUNIFORM3FPROC                glUniform3f;
+  PFNGLUNIFORM4FPROC                glUniform4f;
+  PFNGLUNIFORM1IPROC                glUniform1i;
+  PFNGLUNIFORM2IPROC                glUniform2i;
+  PFNGLUNIFORM3IPROC                glUniform3i;
+  PFNGLUNIFORM4IPROC                glUniform4i;
+  PFNGLUNIFORM1FVPROC               glUniform1fv;
+  PFNGLUNIFORM2FVPROC               glUniform2fv;
+  PFNGLUNIFORM3FVPROC               glUniform3fv;
+  PFNGLUNIFORM4FVPROC               glUniform4fv;
+  PFNGLUNIFORM1IVPROC               glUniform1iv;
+  PFNGLUNIFORM2IVPROC               glUniform2iv;
+  PFNGLUNIFORM3IVPROC               glUniform3iv;
+  PFNGLUNIFORM4IVPROC               glUniform4iv;
+  PFNGLUNIFORMMATRIX2FVPROC         glUniformMatrix2fv;
+  PFNGLUNIFORMMATRIX3FVPROC         glUniformMatrix3fv;
+  PFNGLUNIFORMMATRIX4FVPROC         glUniformMatrix4fv;
+  PFNGLVALIDATEPROGRAMPROC          glValidateProgram;
+  PFNGLVERTEXATTRIB1DPROC           glVertexAttrib1d;
+  PFNGLVERTEXATTRIB1DVPROC          glVertexAttrib1dv;
+  PFNGLVERTEXATTRIB1FPROC           glVertexAttrib1f;
+  PFNGLVERTEXATTRIB1FVPROC          glVertexAttrib1fv;
+  PFNGLVERTEXATTRIB1SPROC           glVertexAttrib1s;
+  PFNGLVERTEXATTRIB1SVPROC          glVertexAttrib1sv;
+  PFNGLVERTEXATTRIB2DPROC           glVertexAttrib2d;
+  PFNGLVERTEXATTRIB2DVPROC          glVertexAttrib2dv;
+  PFNGLVERTEXATTRIB2FPROC           glVertexAttrib2f;
+  PFNGLVERTEXATTRIB2FVPROC          glVertexAttrib2fv;
+  PFNGLVERTEXATTRIB2SPROC           glVertexAttrib2s;
+  PFNGLVERTEXATTRIB2SVPROC          glVertexAttrib2sv;
+  PFNGLVERTEXATTRIB3DPROC           glVertexAttrib3d;
+  PFNGLVERTEXATTRIB3DVPROC          glVertexAttrib3dv;
+  PFNGLVERTEXATTRIB3FPROC           glVertexAttrib3f;
+  PFNGLVERTEXATTRIB3FVPROC          glVertexAttrib3fv;
+  PFNGLVERTEXATTRIB3SPROC           glVertexAttrib3s;
+  PFNGLVERTEXATTRIB3SVPROC          glVertexAttrib3sv;
+  PFNGLVERTEXATTRIB4NBVPROC         glVertexAttrib4Nbv;
+  PFNGLVERTEXATTRIB4NIVPROC         glVertexAttrib4Niv;
+  PFNGLVERTEXATTRIB4NSVPROC         glVertexAttrib4Nsv;
+  PFNGLVERTEXATTRIB4NUBPROC         glVertexAttrib4Nub;
+  PFNGLVERTEXATTRIB4NUBVPROC        glVertexAttrib4Nubv;
+  PFNGLVERTEXATTRIB4NUIVPROC        glVertexAttrib4Nuiv;
+  PFNGLVERTEXATTRIB4NUSVPROC        glVertexAttrib4Nusv;
+  PFNGLVERTEXATTRIB4BVPROC          glVertexAttrib4bv;
+  PFNGLVERTEXATTRIB4DPROC           glVertexAttrib4d;
+  PFNGLVERTEXATTRIB4DVPROC          glVertexAttrib4dv;
+  PFNGLVERTEXATTRIB4FPROC           glVertexAttrib4f;
+  PFNGLVERTEXATTRIB4FVPROC          glVertexAttrib4fv;
+  PFNGLVERTEXATTRIB4IVPROC          glVertexAttrib4iv;
+  PFNGLVERTEXATTRIB4SPROC           glVertexAttrib4s;
+  PFNGLVERTEXATTRIB4SVPROC          glVertexAttrib4sv;
+  PFNGLVERTEXATTRIB4UBVPROC         glVertexAttrib4ubv;
+  PFNGLVERTEXATTRIB4UIVPROC         glVertexAttrib4uiv;
+  PFNGLVERTEXATTRIB4USVPROC         glVertexAttrib4usv;
+  PFNGLVERTEXATTRIBPOINTERPROC      glVertexAttribPointer;
+
+public: //! @name OpenGL 2.1
+
+  PFNGLUNIFORMMATRIX2X3FVPROC       glUniformMatrix2x3fv;
+  PFNGLUNIFORMMATRIX3X2FVPROC       glUniformMatrix3x2fv;
+  PFNGLUNIFORMMATRIX2X4FVPROC       glUniformMatrix2x4fv;
+  PFNGLUNIFORMMATRIX4X2FVPROC       glUniformMatrix4x2fv;
+  PFNGLUNIFORMMATRIX3X4FVPROC       glUniformMatrix3x4fv;
+  PFNGLUNIFORMMATRIX4X3FVPROC       glUniformMatrix4x3fv;
+
+public: //! @name GL_ARB_framebuffer_object (added to OpenGL 3.0 core)
+
+  PFNGLISRENDERBUFFERPROC                      glIsRenderbuffer;
+  PFNGLBINDRENDERBUFFERPROC                    glBindRenderbuffer;
+  PFNGLDELETERENDERBUFFERSPROC                 glDeleteRenderbuffers;
+  PFNGLGENRENDERBUFFERSPROC                    glGenRenderbuffers;
+  PFNGLRENDERBUFFERSTORAGEPROC                 glRenderbufferStorage;
+  PFNGLGETRENDERBUFFERPARAMETERIVPROC          glGetRenderbufferParameteriv;
+  PFNGLISFRAMEBUFFERPROC                       glIsFramebuffer;
+  PFNGLBINDFRAMEBUFFERPROC                     glBindFramebuffer;
+  PFNGLDELETEFRAMEBUFFERSPROC                  glDeleteFramebuffers;
+  PFNGLGENFRAMEBUFFERSPROC                     glGenFramebuffers;
+  PFNGLCHECKFRAMEBUFFERSTATUSPROC              glCheckFramebufferStatus;
+  PFNGLFRAMEBUFFERTEXTURE1DPROC                glFramebufferTexture1D;
+  PFNGLFRAMEBUFFERTEXTURE2DPROC                glFramebufferTexture2D;
+  PFNGLFRAMEBUFFERTEXTURE3DPROC                glFramebufferTexture3D;
+  PFNGLFRAMEBUFFERRENDERBUFFERPROC             glFramebufferRenderbuffer;
+  PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv;
+  PFNGLGENERATEMIPMAPPROC                      glGenerateMipmap;
+  PFNGLBLITFRAMEBUFFERPROC                     glBlitFramebuffer;
+  PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC      glRenderbufferStorageMultisample;
+  PFNGLFRAMEBUFFERTEXTURELAYERPROC             glFramebufferTextureLayer;
+
+public: //! @name GL_ARB_vertex_array_object (added to OpenGL 3.0 core)
+
+  PFNGLBINDVERTEXARRAYPROC             glBindVertexArray;
+  PFNGLDELETEVERTEXARRAYSPROC          glDeleteVertexArrays;
+  PFNGLGENVERTEXARRAYSPROC             glGenVertexArrays;
+  PFNGLISVERTEXARRAYPROC               glIsVertexArray;
+
+public: //! @name GL_ARB_map_buffer_range (added to OpenGL 3.0 core)
+
+  PFNGLMAPBUFFERRANGEPROC              glMapBufferRange;
+  PFNGLFLUSHMAPPEDBUFFERRANGEPROC      glFlushMappedBufferRange;
+
+public: //! @name OpenGL 3.0
+
+  PFNGLCOLORMASKIPROC                  glColorMaski;
+  PFNGLGETBOOLEANI_VPROC               glGetBooleani_v;
+  PFNGLGETINTEGERI_VPROC               glGetIntegeri_v;
+  PFNGLENABLEIPROC                     glEnablei;
+  PFNGLDISABLEIPROC                    glDisablei;
+  PFNGLISENABLEDIPROC                  glIsEnabledi;
+  PFNGLBEGINTRANSFORMFEEDBACKPROC      glBeginTransformFeedback;
+  PFNGLENDTRANSFORMFEEDBACKPROC        glEndTransformFeedback;
+  PFNGLBINDBUFFERRANGEPROC             glBindBufferRange;
+  PFNGLBINDBUFFERBASEPROC              glBindBufferBase;
+  PFNGLTRANSFORMFEEDBACKVARYINGSPROC   glTransformFeedbackVaryings;
+  PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glGetTransformFeedbackVarying;
+  PFNGLCLAMPCOLORPROC                  glClampColor;
+  PFNGLBEGINCONDITIONALRENDERPROC      glBeginConditionalRender;
+  PFNGLENDCONDITIONALRENDERPROC        glEndConditionalRender;
+  PFNGLVERTEXATTRIBIPOINTERPROC        glVertexAttribIPointer;
+  PFNGLGETVERTEXATTRIBIIVPROC          glGetVertexAttribIiv;
+  PFNGLGETVERTEXATTRIBIUIVPROC         glGetVertexAttribIuiv;
+  PFNGLVERTEXATTRIBI1IPROC             glVertexAttribI1i;
+  PFNGLVERTEXATTRIBI2IPROC             glVertexAttribI2i;
+  PFNGLVERTEXATTRIBI3IPROC             glVertexAttribI3i;
+  PFNGLVERTEXATTRIBI4IPROC             glVertexAttribI4i;
+  PFNGLVERTEXATTRIBI1UIPROC            glVertexAttribI1ui;
+  PFNGLVERTEXATTRIBI2UIPROC            glVertexAttribI2ui;
+  PFNGLVERTEXATTRIBI3UIPROC            glVertexAttribI3ui;
+  PFNGLVERTEXATTRIBI4UIPROC            glVertexAttribI4ui;
+  PFNGLVERTEXATTRIBI1IVPROC            glVertexAttribI1iv;
+  PFNGLVERTEXATTRIBI2IVPROC            glVertexAttribI2iv;
+  PFNGLVERTEXATTRIBI3IVPROC            glVertexAttribI3iv;
+  PFNGLVERTEXATTRIBI4IVPROC            glVertexAttribI4iv;
+  PFNGLVERTEXATTRIBI1UIVPROC           glVertexAttribI1uiv;
+  PFNGLVERTEXATTRIBI2UIVPROC           glVertexAttribI2uiv;
+  PFNGLVERTEXATTRIBI3UIVPROC           glVertexAttribI3uiv;
+  PFNGLVERTEXATTRIBI4UIVPROC           glVertexAttribI4uiv;
+  PFNGLVERTEXATTRIBI4BVPROC            glVertexAttribI4bv;
+  PFNGLVERTEXATTRIBI4SVPROC            glVertexAttribI4sv;
+  PFNGLVERTEXATTRIBI4UBVPROC           glVertexAttribI4ubv;
+  PFNGLVERTEXATTRIBI4USVPROC           glVertexAttribI4usv;
+  PFNGLGETUNIFORMUIVPROC               glGetUniformuiv;
+  PFNGLBINDFRAGDATALOCATIONPROC        glBindFragDataLocation;
+  PFNGLGETFRAGDATALOCATIONPROC         glGetFragDataLocation;
+  PFNGLUNIFORM1UIPROC                  glUniform1ui;
+  PFNGLUNIFORM2UIPROC                  glUniform2ui;
+  PFNGLUNIFORM3UIPROC                  glUniform3ui;
+  PFNGLUNIFORM4UIPROC                  glUniform4ui;
+  PFNGLUNIFORM1UIVPROC                 glUniform1uiv;
+  PFNGLUNIFORM2UIVPROC                 glUniform2uiv;
+  PFNGLUNIFORM3UIVPROC                 glUniform3uiv;
+  PFNGLUNIFORM4UIVPROC                 glUniform4uiv;
+  PFNGLTEXPARAMETERIIVPROC             glTexParameterIiv;
+  PFNGLTEXPARAMETERIUIVPROC            glTexParameterIuiv;
+  PFNGLGETTEXPARAMETERIIVPROC          glGetTexParameterIiv;
+  PFNGLGETTEXPARAMETERIUIVPROC         glGetTexParameterIuiv;
+  PFNGLCLEARBUFFERIVPROC               glClearBufferiv;
+  PFNGLCLEARBUFFERUIVPROC              glClearBufferuiv;
+  PFNGLCLEARBUFFERFVPROC               glClearBufferfv;
+  PFNGLCLEARBUFFERFIPROC               glClearBufferfi;
+  PFNGLGETSTRINGIPROC                  glGetStringi;
+
+public: //! @name GL_ARB_uniform_buffer_object (added to OpenGL 3.1 core)
+
+  PFNGLGETUNIFORMINDICESPROC           glGetUniformIndices;
+  PFNGLGETACTIVEUNIFORMSIVPROC         glGetActiveUniformsiv;
+  PFNGLGETACTIVEUNIFORMNAMEPROC        glGetActiveUniformName;
+  PFNGLGETUNIFORMBLOCKINDEXPROC        glGetUniformBlockIndex;
+  PFNGLGETACTIVEUNIFORMBLOCKIVPROC     glGetActiveUniformBlockiv;
+  PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC   glGetActiveUniformBlockName;
+  PFNGLUNIFORMBLOCKBINDINGPROC         glUniformBlockBinding;
+
+public: //! @name GL_ARB_copy_buffer (added to OpenGL 3.1 core)
+
+  PFNGLCOPYBUFFERSUBDATAPROC           glCopyBufferSubData;
+
+public: //! @name OpenGL 3.1
+
+  PFNGLDRAWARRAYSINSTANCEDPROC         glDrawArraysInstanced;
+  PFNGLDRAWELEMENTSINSTANCEDPROC       glDrawElementsInstanced;
+  PFNGLTEXBUFFERPROC                   glTexBuffer;
+  PFNGLPRIMITIVERESTARTINDEXPROC       glPrimitiveRestartIndex;
+
+public: //! @name GL_ARB_draw_elements_base_vertex (added to OpenGL 3.2 core)
+
+  PFNGLDRAWELEMENTSBASEVERTEXPROC      glDrawElementsBaseVertex;
+  PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glDrawRangeElementsBaseVertex;
+  PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glDrawElementsInstancedBaseVertex;
+  PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glMultiDrawElementsBaseVertex;
+
+public: //! @name GL_ARB_provoking_vertex (added to OpenGL 3.2 core)
+
+  PFNGLPROVOKINGVERTEXPROC             glProvokingVertex;
+
+public: //! @name GL_ARB_sync (added to OpenGL 3.2 core)
+
+  PFNGLFENCESYNCPROC                   glFenceSync;
+  PFNGLISSYNCPROC                      glIsSync;
+  PFNGLDELETESYNCPROC                  glDeleteSync;
+  PFNGLCLIENTWAITSYNCPROC              glClientWaitSync;
+  PFNGLWAITSYNCPROC                    glWaitSync;
+  PFNGLGETINTEGER64VPROC               glGetInteger64v;
+  PFNGLGETSYNCIVPROC                   glGetSynciv;
+
+public: //! @name GL_ARB_texture_multisample (added to OpenGL 3.2 core)
+
+  PFNGLTEXIMAGE2DMULTISAMPLEPROC       glTexImage2DMultisample;
+  PFNGLTEXIMAGE3DMULTISAMPLEPROC       glTexImage3DMultisample;
+  PFNGLGETMULTISAMPLEFVPROC            glGetMultisamplefv;
+  PFNGLSAMPLEMASKIPROC                 glSampleMaski;
+
+public: //! @name OpenGL 3.2
+
+  PFNGLGETINTEGER64I_VPROC             glGetInteger64i_v;
+  PFNGLGETBUFFERPARAMETERI64VPROC      glGetBufferParameteri64v;
+  PFNGLFRAMEBUFFERTEXTUREPROC          glFramebufferTexture;
+
+public: //! @name GL_ARB_blend_func_extended (added to OpenGL 3.3 core)
+
+  PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glBindFragDataLocationIndexed;
+  PFNGLGETFRAGDATAINDEXPROC            glGetFragDataIndex;
+
+public: //! @name GL_ARB_sampler_objects (added to OpenGL 3.3 core)
+
+  PFNGLGENSAMPLERSPROC                 glGenSamplers;
+  PFNGLDELETESAMPLERSPROC              glDeleteSamplers;
+  PFNGLISSAMPLERPROC                   glIsSampler;
+  PFNGLBINDSAMPLERPROC                 glBindSampler;
+  PFNGLSAMPLERPARAMETERIPROC           glSamplerParameteri;
+  PFNGLSAMPLERPARAMETERIVPROC          glSamplerParameteriv;
+  PFNGLSAMPLERPARAMETERFPROC           glSamplerParameterf;
+  PFNGLSAMPLERPARAMETERFVPROC          glSamplerParameterfv;
+  PFNGLSAMPLERPARAMETERIIVPROC         glSamplerParameterIiv;
+  PFNGLSAMPLERPARAMETERIUIVPROC        glSamplerParameterIuiv;
+  PFNGLGETSAMPLERPARAMETERIVPROC       glGetSamplerParameteriv;
+  PFNGLGETSAMPLERPARAMETERIIVPROC      glGetSamplerParameterIiv;
+  PFNGLGETSAMPLERPARAMETERFVPROC       glGetSamplerParameterfv;
+  PFNGLGETSAMPLERPARAMETERIUIVPROC     glGetSamplerParameterIuiv;
+
+public: //! @name GL_ARB_timer_query (added to OpenGL 3.3 core)
+
+  PFNGLQUERYCOUNTERPROC                glQueryCounter;
+  PFNGLGETQUERYOBJECTI64VPROC          glGetQueryObjecti64v;
+  PFNGLGETQUERYOBJECTUI64VPROC         glGetQueryObjectui64v;
+
+public: //! @name GL_ARB_vertex_type_2_10_10_10_rev (added to OpenGL 3.3 core)
+
+  PFNGLVERTEXP2UIPROC                  glVertexP2ui;
+  PFNGLVERTEXP2UIVPROC                 glVertexP2uiv;
+  PFNGLVERTEXP3UIPROC                  glVertexP3ui;
+  PFNGLVERTEXP3UIVPROC                 glVertexP3uiv;
+  PFNGLVERTEXP4UIPROC                  glVertexP4ui;
+  PFNGLVERTEXP4UIVPROC                 glVertexP4uiv;
+  PFNGLTEXCOORDP1UIPROC                glTexCoordP1ui;
+  PFNGLTEXCOORDP1UIVPROC               glTexCoordP1uiv;
+  PFNGLTEXCOORDP2UIPROC                glTexCoordP2ui;
+  PFNGLTEXCOORDP2UIVPROC               glTexCoordP2uiv;
+  PFNGLTEXCOORDP3UIPROC                glTexCoordP3ui;
+  PFNGLTEXCOORDP3UIVPROC               glTexCoordP3uiv;
+  PFNGLTEXCOORDP4UIPROC                glTexCoordP4ui;
+  PFNGLTEXCOORDP4UIVPROC               glTexCoordP4uiv;
+  PFNGLMULTITEXCOORDP1UIPROC           glMultiTexCoordP1ui;
+  PFNGLMULTITEXCOORDP1UIVPROC          glMultiTexCoordP1uiv;
+  PFNGLMULTITEXCOORDP2UIPROC           glMultiTexCoordP2ui;
+  PFNGLMULTITEXCOORDP2UIVPROC          glMultiTexCoordP2uiv;
+  PFNGLMULTITEXCOORDP3UIPROC           glMultiTexCoordP3ui;
+  PFNGLMULTITEXCOORDP3UIVPROC          glMultiTexCoordP3uiv;
+  PFNGLMULTITEXCOORDP4UIPROC           glMultiTexCoordP4ui;
+  PFNGLMULTITEXCOORDP4UIVPROC          glMultiTexCoordP4uiv;
+  PFNGLNORMALP3UIPROC                  glNormalP3ui;
+  PFNGLNORMALP3UIVPROC                 glNormalP3uiv;
+  PFNGLCOLORP3UIPROC                   glColorP3ui;
+  PFNGLCOLORP3UIVPROC                  glColorP3uiv;
+  PFNGLCOLORP4UIPROC                   glColorP4ui;
+  PFNGLCOLORP4UIVPROC                  glColorP4uiv;
+  PFNGLSECONDARYCOLORP3UIPROC          glSecondaryColorP3ui;
+  PFNGLSECONDARYCOLORP3UIVPROC         glSecondaryColorP3uiv;
+  PFNGLVERTEXATTRIBP1UIPROC            glVertexAttribP1ui;
+  PFNGLVERTEXATTRIBP1UIVPROC           glVertexAttribP1uiv;
+  PFNGLVERTEXATTRIBP2UIPROC            glVertexAttribP2ui;
+  PFNGLVERTEXATTRIBP2UIVPROC           glVertexAttribP2uiv;
+  PFNGLVERTEXATTRIBP3UIPROC            glVertexAttribP3ui;
+  PFNGLVERTEXATTRIBP3UIVPROC           glVertexAttribP3uiv;
+  PFNGLVERTEXATTRIBP4UIPROC            glVertexAttribP4ui;
+  PFNGLVERTEXATTRIBP4UIVPROC           glVertexAttribP4uiv;
+
+public: //! @name OpenGL 3.3
+
+  PFNGLVERTEXATTRIBDIVISORPROC         glVertexAttribDivisor;
+
+public: //! @name GL_ARB_draw_indirect (added to OpenGL 4.0 core)
+
+  PFNGLDRAWARRAYSINDIRECTPROC          glDrawArraysIndirect;
+  PFNGLDRAWELEMENTSINDIRECTPROC        glDrawElementsIndirect;
+
+public: //! @name GL_ARB_gpu_shader_fp64 (added to OpenGL 4.0 core)
+
+  PFNGLUNIFORM1DPROC                   glUniform1d;
+  PFNGLUNIFORM2DPROC                   glUniform2d;
+  PFNGLUNIFORM3DPROC                   glUniform3d;
+  PFNGLUNIFORM4DPROC                   glUniform4d;
+  PFNGLUNIFORM1DVPROC                  glUniform1dv;
+  PFNGLUNIFORM2DVPROC                  glUniform2dv;
+  PFNGLUNIFORM3DVPROC                  glUniform3dv;
+  PFNGLUNIFORM4DVPROC                  glUniform4dv;
+  PFNGLUNIFORMMATRIX2DVPROC            glUniformMatrix2dv;
+  PFNGLUNIFORMMATRIX3DVPROC            glUniformMatrix3dv;
+  PFNGLUNIFORMMATRIX4DVPROC            glUniformMatrix4dv;
+  PFNGLUNIFORMMATRIX2X3DVPROC          glUniformMatrix2x3dv;
+  PFNGLUNIFORMMATRIX2X4DVPROC          glUniformMatrix2x4dv;
+  PFNGLUNIFORMMATRIX3X2DVPROC          glUniformMatrix3x2dv;
+  PFNGLUNIFORMMATRIX3X4DVPROC          glUniformMatrix3x4dv;
+  PFNGLUNIFORMMATRIX4X2DVPROC          glUniformMatrix4x2dv;
+  PFNGLUNIFORMMATRIX4X3DVPROC          glUniformMatrix4x3dv;
+  PFNGLGETUNIFORMDVPROC                glGetUniformdv;
+
+public: //! @name GL_ARB_shader_subroutine (added to OpenGL 4.0 core)
+
+  PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC   glGetSubroutineUniformLocation;
+  PFNGLGETSUBROUTINEINDEXPROC             glGetSubroutineIndex;
+  PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC   glGetActiveSubroutineUniformiv;
+  PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glGetActiveSubroutineUniformName;
+  PFNGLGETACTIVESUBROUTINENAMEPROC        glGetActiveSubroutineName;
+  PFNGLUNIFORMSUBROUTINESUIVPROC          glUniformSubroutinesuiv;
+  PFNGLGETUNIFORMSUBROUTINEUIVPROC        glGetUniformSubroutineuiv;
+  PFNGLGETPROGRAMSTAGEIVPROC              glGetProgramStageiv;
+
+public: //! @name GL_ARB_tessellation_shader (added to OpenGL 4.0 core)
+
+  PFNGLPATCHPARAMETERIPROC             glPatchParameteri;
+  PFNGLPATCHPARAMETERFVPROC            glPatchParameterfv;
+
+public: //! @name GL_ARB_transform_feedback2 (added to OpenGL 4.0 core)
+
+  PFNGLBINDTRANSFORMFEEDBACKPROC       glBindTransformFeedback;
+  PFNGLDELETETRANSFORMFEEDBACKSPROC    glDeleteTransformFeedbacks;
+  PFNGLGENTRANSFORMFEEDBACKSPROC       glGenTransformFeedbacks;
+  PFNGLISTRANSFORMFEEDBACKPROC         glIsTransformFeedback;
+  PFNGLPAUSETRANSFORMFEEDBACKPROC      glPauseTransformFeedback;
+  PFNGLRESUMETRANSFORMFEEDBACKPROC     glResumeTransformFeedback;
+  PFNGLDRAWTRANSFORMFEEDBACKPROC       glDrawTransformFeedback;
+
+public: //! @name GL_ARB_transform_feedback3 (added to OpenGL 4.0 core)
+
+  PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glDrawTransformFeedbackStream;
+  PFNGLBEGINQUERYINDEXEDPROC           glBeginQueryIndexed;
+  PFNGLENDQUERYINDEXEDPROC             glEndQueryIndexed;
+  PFNGLGETQUERYINDEXEDIVPROC           glGetQueryIndexediv;
+
+public: //! @name OpenGL 4.0
+
+  PFNGLMINSAMPLESHADINGPROC            glMinSampleShading;
+  PFNGLBLENDEQUATIONIPROC              glBlendEquationi;
+  PFNGLBLENDEQUATIONSEPARATEIPROC      glBlendEquationSeparatei;
+  PFNGLBLENDFUNCIPROC                  glBlendFunci;
+  PFNGLBLENDFUNCSEPARATEIPROC          glBlendFuncSeparatei;
+
+public: //! @name GL_ARB_ES2_compatibility (added to OpenGL 4.1 core)
+
+  PFNGLRELEASESHADERCOMPILERPROC       glReleaseShaderCompiler;
+  PFNGLSHADERBINARYPROC                glShaderBinary;
+  PFNGLGETSHADERPRECISIONFORMATPROC    glGetShaderPrecisionFormat;
+  PFNGLDEPTHRANGEFPROC                 glDepthRangef;
+  PFNGLCLEARDEPTHFPROC                 glClearDepthf;
+
+public: //! @name GL_ARB_get_program_binary (added to OpenGL 4.1 core)
+
+  PFNGLGETPROGRAMBINARYPROC            glGetProgramBinary;
+  PFNGLPROGRAMBINARYPROC               glProgramBinary;
+  PFNGLPROGRAMPARAMETERIPROC           glProgramParameteri;
+
+public: //! @name GL_ARB_separate_shader_objects (added to OpenGL 4.1 core)
+
+  PFNGLUSEPROGRAMSTAGESPROC            glUseProgramStages;
+  PFNGLACTIVESHADERPROGRAMPROC         glActiveShaderProgram;
+  PFNGLCREATESHADERPROGRAMVPROC        glCreateShaderProgramv;
+  PFNGLBINDPROGRAMPIPELINEPROC         glBindProgramPipeline;
+  PFNGLDELETEPROGRAMPIPELINESPROC      glDeleteProgramPipelines;
+  PFNGLGENPROGRAMPIPELINESPROC         glGenProgramPipelines;
+  PFNGLISPROGRAMPIPELINEPROC           glIsProgramPipeline;
+  PFNGLGETPROGRAMPIPELINEIVPROC        glGetProgramPipelineiv;
+  PFNGLPROGRAMUNIFORM1IPROC            glProgramUniform1i;
+  PFNGLPROGRAMUNIFORM1IVPROC           glProgramUniform1iv;
+  PFNGLPROGRAMUNIFORM1FPROC            glProgramUniform1f;
+  PFNGLPROGRAMUNIFORM1FVPROC           glProgramUniform1fv;
+  PFNGLPROGRAMUNIFORM1DPROC            glProgramUniform1d;
+  PFNGLPROGRAMUNIFORM1DVPROC           glProgramUniform1dv;
+  PFNGLPROGRAMUNIFORM1UIPROC           glProgramUniform1ui;
+  PFNGLPROGRAMUNIFORM1UIVPROC          glProgramUniform1uiv;
+  PFNGLPROGRAMUNIFORM2IPROC            glProgramUniform2i;
+  PFNGLPROGRAMUNIFORM2IVPROC           glProgramUniform2iv;
+  PFNGLPROGRAMUNIFORM2FPROC            glProgramUniform2f;
+  PFNGLPROGRAMUNIFORM2FVPROC           glProgramUniform2fv;
+  PFNGLPROGRAMUNIFORM2DPROC            glProgramUniform2d;
+  PFNGLPROGRAMUNIFORM2DVPROC           glProgramUniform2dv;
+  PFNGLPROGRAMUNIFORM2UIPROC           glProgramUniform2ui;
+  PFNGLPROGRAMUNIFORM2UIVPROC          glProgramUniform2uiv;
+  PFNGLPROGRAMUNIFORM3IPROC            glProgramUniform3i;
+  PFNGLPROGRAMUNIFORM3IVPROC           glProgramUniform3iv;
+  PFNGLPROGRAMUNIFORM3FPROC            glProgramUniform3f;
+  PFNGLPROGRAMUNIFORM3FVPROC           glProgramUniform3fv;
+  PFNGLPROGRAMUNIFORM3DPROC            glProgramUniform3d;
+  PFNGLPROGRAMUNIFORM3DVPROC           glProgramUniform3dv;
+  PFNGLPROGRAMUNIFORM3UIPROC           glProgramUniform3ui;
+  PFNGLPROGRAMUNIFORM3UIVPROC          glProgramUniform3uiv;
+  PFNGLPROGRAMUNIFORM4IPROC            glProgramUniform4i;
+  PFNGLPROGRAMUNIFORM4IVPROC           glProgramUniform4iv;
+  PFNGLPROGRAMUNIFORM4FPROC            glProgramUniform4f;
+  PFNGLPROGRAMUNIFORM4FVPROC           glProgramUniform4fv;
+  PFNGLPROGRAMUNIFORM4DPROC            glProgramUniform4d;
+  PFNGLPROGRAMUNIFORM4DVPROC           glProgramUniform4dv;
+  PFNGLPROGRAMUNIFORM4UIPROC           glProgramUniform4ui;
+  PFNGLPROGRAMUNIFORM4UIVPROC          glProgramUniform4uiv;
+  PFNGLPROGRAMUNIFORMMATRIX2FVPROC     glProgramUniformMatrix2fv;
+  PFNGLPROGRAMUNIFORMMATRIX3FVPROC     glProgramUniformMatrix3fv;
+  PFNGLPROGRAMUNIFORMMATRIX4FVPROC     glProgramUniformMatrix4fv;
+  PFNGLPROGRAMUNIFORMMATRIX2DVPROC     glProgramUniformMatrix2dv;
+  PFNGLPROGRAMUNIFORMMATRIX3DVPROC     glProgramUniformMatrix3dv;
+  PFNGLPROGRAMUNIFORMMATRIX4DVPROC     glProgramUniformMatrix4dv;
+  PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC   glProgramUniformMatrix2x3fv;
+  PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC   glProgramUniformMatrix3x2fv;
+  PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC   glProgramUniformMatrix2x4fv;
+  PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC   glProgramUniformMatrix4x2fv;
+  PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC   glProgramUniformMatrix3x4fv;
+  PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC   glProgramUniformMatrix4x3fv;
+  PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC   glProgramUniformMatrix2x3dv;
+  PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC   glProgramUniformMatrix3x2dv;
+  PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC   glProgramUniformMatrix2x4dv;
+  PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC   glProgramUniformMatrix4x2dv;
+  PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC   glProgramUniformMatrix3x4dv;
+  PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC   glProgramUniformMatrix4x3dv;
+  PFNGLVALIDATEPROGRAMPIPELINEPROC     glValidateProgramPipeline;
+  PFNGLGETPROGRAMPIPELINEINFOLOGPROC   glGetProgramPipelineInfoLog;
+
+public: //! @name GL_ARB_vertex_attrib_64bit (added to OpenGL 4.1 core)
+
+  PFNGLVERTEXATTRIBL1DPROC             glVertexAttribL1d;
+  PFNGLVERTEXATTRIBL2DPROC             glVertexAttribL2d;
+  PFNGLVERTEXATTRIBL3DPROC             glVertexAttribL3d;
+  PFNGLVERTEXATTRIBL4DPROC             glVertexAttribL4d;
+  PFNGLVERTEXATTRIBL1DVPROC            glVertexAttribL1dv;
+  PFNGLVERTEXATTRIBL2DVPROC            glVertexAttribL2dv;
+  PFNGLVERTEXATTRIBL3DVPROC            glVertexAttribL3dv;
+  PFNGLVERTEXATTRIBL4DVPROC            glVertexAttribL4dv;
+  PFNGLVERTEXATTRIBLPOINTERPROC        glVertexAttribLPointer;
+  PFNGLGETVERTEXATTRIBLDVPROC          glGetVertexAttribLdv;
+
+public: //! @name GL_ARB_viewport_array (added to OpenGL 4.1 core)
+
+  PFNGLVIEWPORTARRAYVPROC              glViewportArrayv;
+  PFNGLVIEWPORTINDEXEDFPROC            glViewportIndexedf;
+  PFNGLVIEWPORTINDEXEDFVPROC           glViewportIndexedfv;
+  PFNGLSCISSORARRAYVPROC               glScissorArrayv;
+  PFNGLSCISSORINDEXEDPROC              glScissorIndexed;
+  PFNGLSCISSORINDEXEDVPROC             glScissorIndexedv;
+  PFNGLDEPTHRANGEARRAYVPROC            glDepthRangeArrayv;
+  PFNGLDEPTHRANGEINDEXEDPROC           glDepthRangeIndexed;
+  PFNGLGETFLOATI_VPROC                 glGetFloati_v;
+  PFNGLGETDOUBLEI_VPROC                glGetDoublei_v;
+
+public: //! @name OpenGL 4.1
+
+  //
+
+public: //! @name GL_ARB_base_instance (added to OpenGL 4.2 core)
+
+  PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC             glDrawArraysInstancedBaseInstance;
+  PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC           glDrawElementsInstancedBaseInstance;
+  PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glDrawElementsInstancedBaseVertexBaseInstance;
+
+public: //! @name GL_ARB_transform_feedback_instanced (added to OpenGL 4.2 core)
+
+  PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC              glDrawTransformFeedbackInstanced;
+  PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC        glDrawTransformFeedbackStreamInstanced;
+
+public: //! @name GL_ARB_internalformat_query (added to OpenGL 4.2 core)
+
+  PFNGLGETINTERNALFORMATIVPROC                         glGetInternalformativ;
+
+public: //! @name GL_ARB_shader_atomic_counters (added to OpenGL 4.2 core)
+
+  PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC              glGetActiveAtomicCounterBufferiv;
+
+public: //! @name GL_ARB_shader_image_load_store (added to OpenGL 4.2 core)
+
+  PFNGLBINDIMAGETEXTUREPROC                            glBindImageTexture;
+  PFNGLMEMORYBARRIERPROC                               glMemoryBarrier;
+
+public: //! @name GL_ARB_texture_storage (added to OpenGL 4.2 core)
+
+  PFNGLTEXSTORAGE1DPROC                                glTexStorage1D;
+  PFNGLTEXSTORAGE2DPROC                                glTexStorage2D;
+  PFNGLTEXSTORAGE3DPROC                                glTexStorage3D;
+  PFNGLTEXTURESTORAGE1DEXTPROC                         glTextureStorage1DEXT;
+  PFNGLTEXTURESTORAGE2DEXTPROC                         glTextureStorage2DEXT;
+  PFNGLTEXTURESTORAGE3DEXTPROC                         glTextureStorage3DEXT;
+
+public: //! @name OpenGL 4.2
+
+public: //! @name OpenGL 4.3
+
+  PFNGLCLEARBUFFERDATAPROC                 glClearBufferData;
+  PFNGLCLEARBUFFERSUBDATAPROC              glClearBufferSubData;
+  PFNGLDISPATCHCOMPUTEPROC                 glDispatchCompute;
+  PFNGLDISPATCHCOMPUTEINDIRECTPROC         glDispatchComputeIndirect;
+  PFNGLCOPYIMAGESUBDATAPROC                glCopyImageSubData;
+  PFNGLFRAMEBUFFERPARAMETERIPROC           glFramebufferParameteri;
+  PFNGLGETFRAMEBUFFERPARAMETERIVPROC       glGetFramebufferParameteriv;
+  PFNGLGETINTERNALFORMATI64VPROC           glGetInternalformati64v;
+  PFNGLINVALIDATETEXSUBIMAGEPROC           glInvalidateTexSubImage;
+  PFNGLINVALIDATETEXIMAGEPROC              glInvalidateTexImage;
+  PFNGLINVALIDATEBUFFERSUBDATAPROC         glInvalidateBufferSubData;
+  PFNGLINVALIDATEBUFFERDATAPROC            glInvalidateBufferData;
+  PFNGLINVALIDATEFRAMEBUFFERPROC           glInvalidateFramebuffer;
+  PFNGLINVALIDATESUBFRAMEBUFFERPROC        glInvalidateSubFramebuffer;
+  PFNGLMULTIDRAWARRAYSINDIRECTPROC         glMultiDrawArraysIndirect;
+  PFNGLMULTIDRAWELEMENTSINDIRECTPROC       glMultiDrawElementsIndirect;
+  PFNGLGETPROGRAMINTERFACEIVPROC           glGetProgramInterfaceiv;
+  PFNGLGETPROGRAMRESOURCEINDEXPROC         glGetProgramResourceIndex;
+  PFNGLGETPROGRAMRESOURCENAMEPROC          glGetProgramResourceName;
+  PFNGLGETPROGRAMRESOURCEIVPROC            glGetProgramResourceiv;
+  PFNGLGETPROGRAMRESOURCELOCATIONPROC      glGetProgramResourceLocation;
+  PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glGetProgramResourceLocationIndex;
+  PFNGLSHADERSTORAGEBLOCKBINDINGPROC       glShaderStorageBlockBinding;
+  PFNGLTEXBUFFERRANGEPROC                  glTexBufferRange;
+  PFNGLTEXSTORAGE2DMULTISAMPLEPROC         glTexStorage2DMultisample;
+  PFNGLTEXSTORAGE3DMULTISAMPLEPROC         glTexStorage3DMultisample;
+  PFNGLTEXTUREVIEWPROC                     glTextureView;
+  PFNGLBINDVERTEXBUFFERPROC                glBindVertexBuffer;
+  PFNGLVERTEXATTRIBFORMATPROC              glVertexAttribFormat;
+  PFNGLVERTEXATTRIBIFORMATPROC             glVertexAttribIFormat;
+  PFNGLVERTEXATTRIBLFORMATPROC             glVertexAttribLFormat;
+  PFNGLVERTEXATTRIBBINDINGPROC             glVertexAttribBinding;
+  PFNGLVERTEXBINDINGDIVISORPROC            glVertexBindingDivisor;
+  PFNGLDEBUGMESSAGECONTROLPROC             glDebugMessageControl;
+  PFNGLDEBUGMESSAGEINSERTPROC              glDebugMessageInsert;
+  PFNGLDEBUGMESSAGECALLBACKPROC            glDebugMessageCallback;
+  PFNGLGETDEBUGMESSAGELOGPROC              glGetDebugMessageLog;
+  PFNGLPUSHDEBUGGROUPPROC                  glPushDebugGroup;
+  PFNGLPOPDEBUGGROUPPROC                   glPopDebugGroup;
+  PFNGLOBJECTLABELPROC                     glObjectLabel;
+  PFNGLGETOBJECTLABELPROC                  glGetObjectLabel;
+  PFNGLOBJECTPTRLABELPROC                  glObjectPtrLabel;
+  PFNGLGETOBJECTPTRLABELPROC               glGetObjectPtrLabel;
+
+public: //! @name OpenGL 4.4
+
+  PFNGLBUFFERSTORAGEPROC     glBufferStorage;
+  PFNGLCLEARTEXIMAGEPROC     glClearTexImage;
+  PFNGLCLEARTEXSUBIMAGEPROC  glClearTexSubImage;
+  PFNGLBINDBUFFERSBASEPROC   glBindBuffersBase;
+  PFNGLBINDBUFFERSRANGEPROC  glBindBuffersRange;
+  PFNGLBINDTEXTURESPROC      glBindTextures;
+  PFNGLBINDSAMPLERSPROC      glBindSamplers;
+  PFNGLBINDIMAGETEXTURESPROC glBindImageTextures;
+  PFNGLBINDVERTEXBUFFERSPROC glBindVertexBuffers;
+
+public: //! @name GL_ARB_debug_output (optional)
+
+  PFNGLDEBUGMESSAGECONTROLARBPROC  glDebugMessageControlARB;
+  PFNGLDEBUGMESSAGEINSERTARBPROC   glDebugMessageInsertARB;
+  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARB;
+  PFNGLGETDEBUGMESSAGELOGARBPROC   glGetDebugMessageLogARB;
+
+public: //! @name GL_EXT_geometry_shader4
+
+  PFNGLPROGRAMPARAMETERIEXTPROC glProgramParameteriEXT;
+
+#if defined(_WIN32)
+public: //! @name wgl extensions
+
+  typedef const char* (WINAPI *wglGetExtensionsStringARB_t)(HDC theDeviceContext);
+  wglGetExtensionsStringARB_t wglGetExtensionsStringARB;
+
+  typedef BOOL        (WINAPI *wglSwapIntervalEXT_t)(int theInterval);
+  wglSwapIntervalEXT_t wglSwapIntervalEXT;
+
+  // WGL_ARB_pixel_format
+
+#ifndef WGL_NUMBER_PIXEL_FORMATS_ARB
+  #define WGL_NUMBER_PIXEL_FORMATS_ARB            0x2000
+  #define WGL_DRAW_TO_WINDOW_ARB                  0x2001
+  #define WGL_DRAW_TO_BITMAP_ARB                  0x2002
+  #define WGL_ACCELERATION_ARB                    0x2003
+  #define WGL_NEED_PALETTE_ARB                    0x2004
+  #define WGL_NEED_SYSTEM_PALETTE_ARB             0x2005
+  #define WGL_SWAP_LAYER_BUFFERS_ARB              0x2006
+  #define WGL_SWAP_METHOD_ARB                     0x2007
+  #define WGL_NUMBER_OVERLAYS_ARB                 0x2008
+  #define WGL_NUMBER_UNDERLAYS_ARB                0x2009
+  #define WGL_TRANSPARENT_ARB                     0x200A
+  #define WGL_TRANSPARENT_RED_VALUE_ARB           0x2037
+  #define WGL_TRANSPARENT_GREEN_VALUE_ARB         0x2038
+  #define WGL_TRANSPARENT_BLUE_VALUE_ARB          0x2039
+  #define WGL_TRANSPARENT_ALPHA_VALUE_ARB         0x203A
+  #define WGL_TRANSPARENT_INDEX_VALUE_ARB         0x203B
+  #define WGL_SHARE_DEPTH_ARB                     0x200C
+  #define WGL_SHARE_STENCIL_ARB                   0x200D
+  #define WGL_SHARE_ACCUM_ARB                     0x200E
+  #define WGL_SUPPORT_GDI_ARB                     0x200F
+  #define WGL_SUPPORT_OPENGL_ARB                  0x2010
+  #define WGL_DOUBLE_BUFFER_ARB                   0x2011
+  #define WGL_STEREO_ARB                          0x2012
+  #define WGL_PIXEL_TYPE_ARB                      0x2013
+  #define WGL_COLOR_BITS_ARB                      0x2014
+  #define WGL_RED_BITS_ARB                        0x2015
+  #define WGL_RED_SHIFT_ARB                       0x2016
+  #define WGL_GREEN_BITS_ARB                      0x2017
+  #define WGL_GREEN_SHIFT_ARB                     0x2018
+  #define WGL_BLUE_BITS_ARB                       0x2019
+  #define WGL_BLUE_SHIFT_ARB                      0x201A
+  #define WGL_ALPHA_BITS_ARB                      0x201B
+  #define WGL_ALPHA_SHIFT_ARB                     0x201C
+  #define WGL_ACCUM_BITS_ARB                      0x201D
+  #define WGL_ACCUM_RED_BITS_ARB                  0x201E
+  #define WGL_ACCUM_GREEN_BITS_ARB                0x201F
+  #define WGL_ACCUM_BLUE_BITS_ARB                 0x2020
+  #define WGL_ACCUM_ALPHA_BITS_ARB                0x2021
+  #define WGL_DEPTH_BITS_ARB                      0x2022
+  #define WGL_STENCIL_BITS_ARB                    0x2023
+  #define WGL_AUX_BUFFERS_ARB                     0x2024
+
+  #define WGL_NO_ACCELERATION_ARB                 0x2025
+  #define WGL_GENERIC_ACCELERATION_ARB            0x2026
+  #define WGL_FULL_ACCELERATION_ARB               0x2027
+
+  #define WGL_SWAP_EXCHANGE_ARB                   0x2028
+  #define WGL_SWAP_COPY_ARB                       0x2029
+  #define WGL_SWAP_UNDEFINED_ARB                  0x202A
+
+  #define WGL_TYPE_RGBA_ARB                       0x202B
+  #define WGL_TYPE_COLORINDEX_ARB                 0x202C
+
+#endif // WGL_NUMBER_PIXEL_FORMATS_ARB
+
+      // WGL_ARB_multisample
+#ifndef WGL_SAMPLE_BUFFERS_ARB
+  #define WGL_SAMPLE_BUFFERS_ARB               0x2041
+  #define WGL_SAMPLES_ARB                      0x2042
+#endif
+
+      // WGL_ARB_create_context_robustness
+#ifndef WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB
+  #define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
+  #define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+  #define WGL_NO_RESET_NOTIFICATION_ARB               0x8261
+  #define WGL_LOSE_CONTEXT_ON_RESET_ARB               0x8252
+#endif
+
+  typedef BOOL (WINAPI *wglChoosePixelFormatARB_t)
+      (HDC           theDevCtx,
+       const int*    theIntAttribs,
+       const float*  theFloatAttribs,
+       unsigned int  theMaxFormats,
+       int*          theFormatsOut,
+       unsigned int* theNumFormatsOut);
+  wglChoosePixelFormatARB_t wglChoosePixelFormatARB;
+
+  // WGL_ARB_create_context_profile
+
+#ifndef WGL_CONTEXT_MAJOR_VERSION_ARB
+  #define WGL_CONTEXT_MAJOR_VERSION_ARB           0x2091
+  #define WGL_CONTEXT_MINOR_VERSION_ARB           0x2092
+  #define WGL_CONTEXT_LAYER_PLANE_ARB             0x2093
+  #define WGL_CONTEXT_FLAGS_ARB                   0x2094
+  #define WGL_CONTEXT_PROFILE_MASK_ARB            0x9126
+
+  // WGL_CONTEXT_FLAGS bits
+  #define WGL_CONTEXT_DEBUG_BIT_ARB               0x0001
+  #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002
+
+  // WGL_CONTEXT_PROFILE_MASK_ARB bits
+  #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001
+  #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+#endif // WGL_CONTEXT_MAJOR_VERSION_ARB
+
+  typedef HGLRC (WINAPI *wglCreateContextAttribsARB_t)(HDC        theDevCtx,
+                                                       HGLRC      theShareContext,
+                                                       const int* theAttribs);
+  wglCreateContextAttribsARB_t wglCreateContextAttribsARB;
+
+  // WGL_NV_DX_interop
+
+  typedef BOOL   (WINAPI *wglDXSetResourceShareHandleNV_t)(void* theObjectD3d, HANDLE theShareHandle);
+  typedef HANDLE (WINAPI *wglDXOpenDeviceNV_t      )(void*   theDeviceD3d);
+  typedef BOOL   (WINAPI *wglDXCloseDeviceNV_t     )(HANDLE  theDeviceIOP);
+  typedef HANDLE (WINAPI *wglDXRegisterObjectNV_t  )(HANDLE  theDeviceIOP,
+                                                     void*   theObjectD3d,
+                                                     GLuint  theName,
+                                                     GLenum  theType,
+                                                     GLenum  theAccess);
+  typedef BOOL   (WINAPI *wglDXUnregisterObjectNV_t)(HANDLE  theDeviceIOP,
+                                                     HANDLE  theObject);
+  typedef BOOL   (WINAPI *wglDXObjectAccessNV_t    )(HANDLE  theObject,
+                                                     GLenum  theAccess);
+  typedef BOOL   (WINAPI *wglDXLockObjectsNV_t     )(HANDLE  theDeviceIOP,
+                                                     GLint   theCount,
+                                                     HANDLE* theObjects);
+  typedef BOOL   (WINAPI *wglDXUnlockObjectsNV_t   )(HANDLE  theDeviceIOP,
+                                                     GLint   theCount,
+                                                     HANDLE* theObjects);
+
+  wglDXSetResourceShareHandleNV_t wglDXSetResourceShareHandleNV;
+  wglDXOpenDeviceNV_t       wglDXOpenDeviceNV;
+  wglDXCloseDeviceNV_t      wglDXCloseDeviceNV;
+  wglDXRegisterObjectNV_t   wglDXRegisterObjectNV;
+  wglDXUnregisterObjectNV_t wglDXUnregisterObjectNV;
+  wglDXObjectAccessNV_t     wglDXObjectAccessNV;
+  wglDXLockObjectsNV_t      wglDXLockObjectsNV;
+  wglDXUnlockObjectsNV_t    wglDXUnlockObjectsNV;
+
+#ifndef WGL_ACCESS_READ_WRITE_NV
+  #define WGL_ACCESS_READ_ONLY_NV     0x0000
+  #define WGL_ACCESS_READ_WRITE_NV    0x0001
+  #define WGL_ACCESS_WRITE_DISCARD_NV 0x0002
+#endif
+
+#elif defined(__APPLE__)
+public: //! @name CGL extensions
+
+#else
+public: //! @name glX extensions
+
+  // GLX_EXT_swap_control
+  //typedef int         (*glXSwapIntervalEXT_t)(Display* theDisplay, GLXDrawable theDrawable, int theInterval);
+  typedef int         (*glXSwapIntervalEXT_t)();
+  glXSwapIntervalEXT_t glXSwapIntervalEXT;
+
+  typedef int         (*glXSwapIntervalSGI_t)(int theInterval);
+  glXSwapIntervalSGI_t glXSwapIntervalSGI;
+#endif
+
+};
+
+#endif // _OpenGl_GlFunctions_Header
index 64e186d..7a6cc97 100755 (executable)
@@ -740,9 +740,9 @@ void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
   // activate texture unit
   glDisable (GL_TEXTURE_1D);
   glEnable  (GL_TEXTURE_2D);
-  if (theCtx->core13 != NULL)
+  if (theCtx->core15fwd != NULL)
   {
-    theCtx->core13->glActiveTexture (GL_TEXTURE0);
+    theCtx->core15fwd->glActiveTexture (GL_TEXTURE0);
   }
 
   // extra drawings
index 9fb1116..98f4675 100644 (file)
@@ -14,8 +14,9 @@
 
 #include <OpenGl_Texture.hxx>
 
-#include <OpenGl_ExtFBO.hxx>
+#include <OpenGl_ArbFBO.hxx>
 #include <OpenGl_Context.hxx>
+#include <OpenGl_GlCore15.hxx>
 #include <Graphic3d_TextureParams.hxx>
 #include <Standard_Assert.hxx>
 #include <Image_PixMap.hxx>
@@ -140,9 +141,9 @@ void OpenGl_Texture::Release (const OpenGl_Context* theGlCtx)
 void OpenGl_Texture::Bind (const Handle(OpenGl_Context)& theCtx,
                            const GLenum theTextureUnit) const
 {
-  if (theCtx->IsGlGreaterEqual (1, 3))
+  if (theCtx->IsGlGreaterEqual (1, 5))
   {
-    theCtx->core13->glActiveTexture (theTextureUnit);
+    theCtx->core15fwd->glActiveTexture (theTextureUnit);
   }
   glBindTexture (myTarget, myTextureId);
 }
@@ -154,9 +155,9 @@ void OpenGl_Texture::Bind (const Handle(OpenGl_Context)& theCtx,
 void OpenGl_Texture::Unbind (const Handle(OpenGl_Context)& theCtx,
                              const GLenum theTextureUnit) const
 {
-  if (theCtx->IsGlGreaterEqual (1, 3))
+  if (theCtx->IsGlGreaterEqual (1, 5))
   {
-    theCtx->core13->glActiveTexture (theTextureUnit);
+    theCtx->core15fwd->glActiveTexture (theTextureUnit);
   }
   glBindTexture (myTarget, NO_TEXTURE);
 }
@@ -429,7 +430,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
       glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
-      if (theCtx->extFBO != NULL
+      if (theCtx->arbFBO != NULL
        && aWidth == aWidthOut && aHeight == aHeightOut)
       {
         // use proxy to check texture could be created or not
@@ -460,7 +461,7 @@ bool OpenGl_Texture::Init (const Handle(OpenGl_Context)& theCtx,
 
         // generate mipmaps
         //glHint (GL_GENERATE_MIPMAP_HINT, GL_NICEST);
-        theCtx->extFBO->glGenerateMipmapEXT (GL_TEXTURE_2D);
+        theCtx->arbFBO->glGenerateMipmap (GL_TEXTURE_2D);
 
         Unbind (theCtx);
         return true;
index 7596655..4f06828 100644 (file)
@@ -121,7 +121,7 @@ bool OpenGl_TextureBufferArb::Init (const Handle(OpenGl_Context)& theGlCtx,
 
   Bind (theGlCtx);
   BindTexture (theGlCtx);
-  theGlCtx->arbTBO->glTexBufferARB (GetTarget(), myTexFormat, myBufferId);
+  theGlCtx->arbTBO->glTexBuffer (GetTarget(), myTexFormat, myBufferId);
   UnbindTexture (theGlCtx);
   Unbind (theGlCtx);
   return true;
index b034c73..2682f31 100644 (file)
 #include <Graphic3d_Group.hxx>
 #include <Graphic3d_ShaderObject.hxx>
 #include <Graphic3d_ShaderProgram.hxx>
-#include <OpenGl_ArbVBO.hxx>
 #include <OpenGl_AspectFace.hxx>
 #include <OpenGl_AspectLine.hxx>
 #include <OpenGl_AspectMarker.hxx>
 #include <OpenGl_AspectText.hxx>
 #include <OpenGl_Context.hxx>
 #include <OpenGl_Element.hxx>
-#include <OpenGl_ExtFBO.hxx>
 #include <OpenGl_GlCore20.hxx>
 #include <OpenGl_GraphicDriver.hxx>
 #include <OpenGl_Workspace.hxx>