path: root/ovr_sdk_win_23.0.0/LibOVRKernel/Src/GL/CAPI_GLE.h

/************************************************************************************

Filename    :   CAPI_GLE.h
Content     :   OpenGL extensions support. Implements a stripped down glew-like
                interface with some additional functionality.
Copyright   :   Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

************************************************************************************/

// This file provides functionality similar to a reduced version of GLEW, plus some
// additional functionality that's useful to us, such as function hooking.

#ifndef OVR_CAPI_GLE_h
#define OVR_CAPI_GLE_h

#include "CAPI_GLE_GL.h"
#include "Kernel/OVR_Types.h"

///////////////////////////////////////////////////////////////////////////////
// How to use this functionality
//
// - You #include this header instead of gl.h, glext.h, wglext.h (Windows), gl3.h (Apple), gl3ext.h
// (Apple), glx.h (Unix), and glxext.h (Unix).
//   Currently you still would #include <Windows.h> for the base wgl functions on Windows and
//   OpenGL.h or NSOpenGL for the base Apple cgl functions.
//
// - You call OpenGL functions just like you would if you were directly using OpenGL
//   headers and declarations. The difference is that this module automatically loads
//   extensions on init and so you should never need to use GetProcAddress, wglGetProcAddress, etc.
//
// - OpenGL 1.1 functions can be called unilaterally without checking if they are present,
//   as it's assumed they are always present.
//
// - In order to use an OpenGL 1.2 or later function you can check the GLEContext::WholeVersion
//   variable to tell what version of OpenGL is present and active. Example usage:
//       if(GLEContext::GetCurrentContext()->WholeVersion >= 302) // If OpenGL 3.2 or later...
//
// - In order to use an OpenGL extension, you can check the GLE_ helper macro that exists for each
//   extension. For example, in order to check of the KHR_debug is present you could do this:
//        if(GLE_KHR_debug) ...
//   You cannot check for the presence of extensions by testing the function pointer, because
//   when hooking is enabled then we aren't using function pointers and thus all functions will
//   look like they are present.
//
// - You can test if the OpenGL implementation is OpenGL ES by checking the GLEContext IsGLES
//   member variable. For example: if(GLEContext::GetCurrentContext()->IsGLES) ...
//
// - You can test if the OpenGL implementation is a core profile ES by checking the GLEContext
// IsCoreProfile
//   member variable. For example: if(GLEContext::GetCurrentContext()->IsCoreProfile) ...
//
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// How to add support for additional functions to this module.
//
// For an example of how to do this, search the source files for all cases of KHR_Debug and just
// copy the things that it does but for your new extension.
//
//     1) Add the appropriate extension declaration to CAPI_GLE_GL.h, preferably by
//        copying it from the standard header file it normally comes from. If it's
//        platform-specific (e.g. a Windows wgl function) then make sure it's declared
//        within the given platform section. Note that there are potentially #defines, typedefs,
//        function typedefs, and function #defines. There is always a GLE_ macro declared which
//        lets the user know at runtime whether the extension is present.
//        Note that entries are alphabetically sorted in these files.
//        e.g.  #ifndef GL_KHR_debug
//                  #define GL_KHR_debug 1
//                  #define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002 etc.
//                  typedef void (GLAPIENTRY * PFNGLPOPDEBUGGROUPPROC) ();
//                  #define glPopDebugGroup GLEGetCurrentFunction(glPopDebugGroup)
//                  #define GLE_KHR_debug GLEGetCurrentVariable(gl_KHR_debug)
//              #endif etc.
//
//     2) Add a hook function for in the hook section of the GLEContext class in this header,
//        ideally in the same order it's declared in the CAPI_GLE_GL.h so it's easily readable.
//        e.g. void glDebugMessageControl_Hook(GLenum source, GLenum type, GLenum severity, GLsizei
//        count, const GLuint* ids, GLboolean enabled); etc.
//
//     3) Add a declaration for each interface function to the GLEContext class in this header.
//        e.g. PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback_Impl; etc.
//
//     4) Add code to GLEContext::InitExtensionLoad to load the function pointer.
//        e.g. GLELoadProc(glDebugMessageCallback_Impl, glDebugMessageCallback); etc.
//
//     5) Add code to GLEContext::InitExtensionSupport to detect the extension support.
//        On Mac, core profile functions aren't identified as extensions and so in addition
//        to detecting them you need to unilaterally set them as available when using 3.2+
//        by adding them to the section at the bottom of InitExtensionSupport.
//        e.g. { gl_KHR_debug, "GL_KHR_debug" }, etc.
//
//     6) Implement the GLEContext hook function(s) you declared.
//        e.g.  void OVR::GLEContext::glDebugMessageControl_Hook(GLenum source, GLenum type, GLenum
//        severity, GLsizei count, const GLuint* ids, GLboolean enabled)
//              {
//                 if(glDebugMessageControl_Impl)
//                    glDebugMessageControl_Impl(source, type, severity, count, ids, enabled);
//                 PostHook();
//              }
//
// In order to test this, build with GLE_HOOKING_ENABLED defined and not defined.
//
// Note that if the extension is a WGL-, GLX-, or CGL-specific extension, they are handled like
// above but are in their own section below the section for regular OpenGL extensions.
//
// In some cases the given interface may already be present by currently commented out,
// in which case you can simply un-comment it to enable it.
///////////////////////////////////////////////////////////////////////////////

namespace OVR {
// Generic OpenGL GetProcAddress function interface. Maps to platform-specific functionality
// internally. On Windows this is equivalent to wglGetProcAddress as opposed to global
// GetProcAddress.
void* GLEGetProcAddress(const char* name);

// GLEContext
//
// Manages a collection of OpenGL extension interfaces.
// If the application has multiple OpenGL unrelated contexts then you will want to create a
// different instance of this class for each one you intend to use it with.
//
// Example usage:
//     GLEContext gGLEContext;
//
//     GLEContext::SetCurrentContext(&gGLEContext);
//     gGLEContext.PlatformInit(); // Initializes WGL/GLX/etc. platform-specific OpenGL
//     functionality
//
//     if(GLE_WGL_ARB_create_context) // If wglCreateContextAttribsARB is available...
//     {
//         int attribList[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 2,
//         WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB, None }; HGLRC h =
//         wglCreateContextAttribsARB(hDC, 0, attribList);
//         [...]
//     }
//
//     gGLEContext.Init(); // Must be called after an OpenGL context has been created.
//
//     if(GLE_WHOLE_VERSION() >= 302) // If OpenGL 3.2 or later
//     {
//         glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, someTexture, 0); // This is an
//         OpenGL 3.2 function.
//         [...]
//     }
//
//     if(GLE_GL_ARB_texture_multisample) // If the GL_ARB_texture_multisample extension is
//     available...
//     {
//         glEnable(GL_SAMPLE_MASK);
//         glSampleMaski(0, 0x1);
//         [...]
//     }
//
//     [...]
//
//     gGLEContext.Shutdown();
//
GLE_CLASS_EXPORT class GLEContext {
 public:
  GLEContext();
  ~GLEContext();

  // Initializes platform-specific functionality (e.g. Windows WGL, Unix GLX, Android EGL, Apple
  // CGL). You would typically call this before creating an OpenGL context and using
  // platform-specific functions.
  void PlatformInit();
  bool IsPlatformInitialized() const;

  // Loads all the extensions from the current OpenGL context. This must be called after an OpenGL
  // context has been created and made current.
  void Init();
  bool IsInitialized() const;

  // Clears all the extensions initialized by PlatformInit and Init.
  void Shutdown();

  void SetEnableHookGetError(bool enabled) {
    EnableHookGetError = enabled;
  }

  // Returns the default instance of this class.
  static GLEContext* GetCurrentContext();

  // Sets the default instance of this class. This should be called after enabling a new OpenGL
  // context. This sets the current GLEContext; it does not set the underlying OpenGL context
  // itself.
  static void SetCurrentContext(GLEContext*);

 public:
  // OpenGL version information
  int MajorVersion; // OpenGL major version
  int MinorVersion; // OpenGL minor version
  int WholeVersion; // Equals ((MajorVersion * 100) + MinorVersion). Example usage:
  // if(glv.WholeVersion >= 302) // If OpenGL v3.02+ ...
  bool IsGLES; // Open GL ES?
  bool IsCoreProfile; // Is the current OpenGL context a core profile context? Its trueness may be a
  // false positive but will never be a false negative.
  bool EnableHookGetError; // If enabled then hook functions call glGetError after making the call.

  int PlatformMajorVersion; // GLX/WGL/EGL/CGL version. Not the same as OpenGL version.
  int PlatformMinorVersion;
  int PlatformWholeVersion;

  void InitVersion(); // Initializes the version information (e.g. MajorVersion). Called by the
  // public Init function.
  void InitExtensionLoad(); // Loads the function addresses into the function pointers.
  void InitExtensionSupport(); // Loads the boolean extension support booleans.

  void InitPlatformVersion();
  void InitPlatformExtensionLoad();
  void InitPlatformExtensionSupport();

 public:
// GL_VERSION_1_1
// Not normally included because all OpenGL 1.1 functionality is always present. But if we have
// hooking enabled then we implement our own version of each function.
#if defined(GLE_HOOKING_ENABLED)
  // void PreHook(const char* functionName);             // Called at the beginning of a hook
  // function.
  void PostHook(const char* functionName); // Called at the end of a hook function.

  void glAccum_Hook(GLenum op, GLfloat value);
  void glAlphaFunc_Hook(GLenum func, GLclampf ref);
  GLboolean glAreTexturesResident_Hook(GLsizei n, const GLuint* textures, GLboolean* residences);
  void glArrayElement_Hook(GLint i);
  void glBegin_Hook(GLenum mode);
  void glBindTexture_Hook(GLenum target, GLuint texture);
  void glBitmap_Hook(
      GLsizei width,
      GLsizei height,
      GLfloat xorig,
      GLfloat yorig,
      GLfloat xmove,
      GLfloat ymove,
      const GLubyte* bitmap);
  void glBlendFunc_Hook(GLenum sfactor, GLenum dfactor);
  void glCallList_Hook(GLuint list);
  void glCallLists_Hook(GLsizei n, GLenum type, const void* lists);
  void glClear_Hook(GLbitfield mask);
  void glClearAccum_Hook(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  void glClearColor_Hook(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  void glClearDepth_Hook(GLclampd depth);
  void glClearIndex_Hook(GLfloat c);
  void glClearStencil_Hook(GLint s);
  void glClipPlane_Hook(GLenum plane, const GLdouble* equation);
  void glColor3b_Hook(GLbyte red, GLbyte green, GLbyte blue);
  void glColor3bv_Hook(const GLbyte* v);
  void glColor3d_Hook(GLdouble red, GLdouble green, GLdouble blue);
  void glColor3dv_Hook(const GLdouble* v);
  void glColor3f_Hook(GLfloat red, GLfloat green, GLfloat blue);
  void glColor3fv_Hook(const GLfloat* v);
  void glColor3i_Hook(GLint red, GLint green, GLint blue);
  void glColor3iv_Hook(const GLint* v);
  void glColor3s_Hook(GLshort red, GLshort green, GLshort blue);
  void glColor3sv_Hook(const GLshort* v);
  void glColor3ub_Hook(GLubyte red, GLubyte green, GLubyte blue);
  void glColor3ubv_Hook(const GLubyte* v);
  void glColor3ui_Hook(GLuint red, GLuint green, GLuint blue);
  void glColor3uiv_Hook(const GLuint* v);
  void glColor3us_Hook(GLushort red, GLushort green, GLushort blue);
  void glColor3usv_Hook(const GLushort* v);
  void glColor4b_Hook(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
  void glColor4bv_Hook(const GLbyte* v);
  void glColor4d_Hook(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
  void glColor4dv_Hook(const GLdouble* v);
  void glColor4f_Hook(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
  void glColor4fv_Hook(const GLfloat* v);
  void glColor4i_Hook(GLint red, GLint green, GLint blue, GLint alpha);
  void glColor4iv_Hook(const GLint* v);
  void glColor4s_Hook(GLshort red, GLshort green, GLshort blue, GLshort alpha);
  void glColor4sv_Hook(const GLshort* v);
  void glColor4ub_Hook(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
  void glColor4ubv_Hook(const GLubyte* v);
  void glColor4ui_Hook(GLuint red, GLuint green, GLuint blue, GLuint alpha);
  void glColor4uiv_Hook(const GLuint* v);
  void glColor4us_Hook(GLushort red, GLushort green, GLushort blue, GLushort alpha);
  void glColor4usv_Hook(const GLushort* v);
  void glColorMask_Hook(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
  void glColorMaterial_Hook(GLenum face, GLenum mode);
  void glColorPointer_Hook(GLint size, GLenum type, GLsizei stride, const void* pointer);
  void glCopyPixels_Hook(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
  void glCopyTexImage1D_Hook(
      GLenum target,
      GLint level,
      GLenum internalFormat,
      GLint x,
      GLint y,
      GLsizei width,
      GLint border);
  void glCopyTexImage2D_Hook(
      GLenum target,
      GLint level,
      GLenum internalFormat,
      GLint x,
      GLint y,
      GLsizei width,
      GLsizei height,
      GLint border);
  void glCopyTexSubImage1D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint x,
      GLint y,
      GLsizei width);
  void glCopyTexSubImage2D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLint x,
      GLint y,
      GLsizei width,
      GLsizei height);
  void glCullFace_Hook(GLenum mode);
  void glDeleteLists_Hook(GLuint list, GLsizei range);
  void glDeleteTextures_Hook(GLsizei n, const GLuint* textures);
  void glDepthFunc_Hook(GLenum func);
  void glDepthMask_Hook(GLboolean flag);
  void glDepthRange_Hook(GLclampd zNear, GLclampd zFar);
  void glDisable_Hook(GLenum cap);
  void glDisableClientState_Hook(GLenum array);
  void glDrawArrays_Hook(GLenum mode, GLint first, GLsizei count);
  void glDrawBuffer_Hook(GLenum mode);
  void glDrawElements_Hook(GLenum mode, GLsizei count, GLenum type, const void* indices);
  void
  glDrawPixels_Hook(GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels);
  void glEdgeFlag_Hook(GLboolean flag);
  void glEdgeFlagPointer_Hook(GLsizei stride, const void* pointer);
  void glEdgeFlagv_Hook(const GLboolean* flag);
  void glEnable_Hook(GLenum cap);
  void glEnableClientState_Hook(GLenum array);
  void glEnd_Hook(void);
  void glEndList_Hook(void);
  void glEvalCoord1d_Hook(GLdouble u);
  void glEvalCoord1dv_Hook(const GLdouble* u);
  void glEvalCoord1f_Hook(GLfloat u);
  void glEvalCoord1fv_Hook(const GLfloat* u);
  void glEvalCoord2d_Hook(GLdouble u, GLdouble v);
  void glEvalCoord2dv_Hook(const GLdouble* u);
  void glEvalCoord2f_Hook(GLfloat u, GLfloat v);
  void glEvalCoord2fv_Hook(const GLfloat* u);
  void glEvalMesh1_Hook(GLenum mode, GLint i1, GLint i2);
  void glEvalMesh2_Hook(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
  void glEvalPoint1_Hook(GLint i);
  void glEvalPoint2_Hook(GLint i, GLint j);
  void glFeedbackBuffer_Hook(GLsizei size, GLenum type, GLfloat* buffer);
  void glFinish_Hook(void);
  void glFlush_Hook(void);
  void glFogf_Hook(GLenum pname, GLfloat param);
  void glFogfv_Hook(GLenum pname, const GLfloat* params);
  void glFogi_Hook(GLenum pname, GLint param);
  void glFogiv_Hook(GLenum pname, const GLint* params);
  void glFrontFace_Hook(GLenum mode);
  void glFrustum_Hook(
      GLdouble left,
      GLdouble right,
      GLdouble bottom,
      GLdouble top,
      GLdouble zNear,
      GLdouble zFar);
  GLuint glGenLists_Hook(GLsizei range);
  void glGenTextures_Hook(GLsizei n, GLuint* textures);
  void glGetBooleanv_Hook(GLenum pname, GLboolean* params);
  void glGetClipPlane_Hook(GLenum plane, GLdouble* equation);
  void glGetDoublev_Hook(GLenum pname, GLdouble* params);
  GLenum glGetError_Hook(void);
  void glGetFloatv_Hook(GLenum pname, GLfloat* params);
  void glGetIntegerv_Hook(GLenum pname, GLint* params);
  void glGetLightfv_Hook(GLenum light, GLenum pname, GLfloat* params);
  void glGetLightiv_Hook(GLenum light, GLenum pname, GLint* params);
  void glGetMapdv_Hook(GLenum target, GLenum query, GLdouble* v);
  void glGetMapfv_Hook(GLenum target, GLenum query, GLfloat* v);
  void glGetMapiv_Hook(GLenum target, GLenum query, GLint* v);
  void glGetMaterialfv_Hook(GLenum face, GLenum pname, GLfloat* params);
  void glGetMaterialiv_Hook(GLenum face, GLenum pname, GLint* params);
  void glGetPixelMapfv_Hook(GLenum map, GLfloat* values);
  void glGetPixelMapuiv_Hook(GLenum map, GLuint* values);
  void glGetPixelMapusv_Hook(GLenum map, GLushort* values);
  void glGetPointerv_Hook(GLenum pname, void** params);
  void glGetPolygonStipple_Hook(GLubyte* mask);
  const GLubyte* glGetString_Hook(GLenum name);
  void glGetTexEnvfv_Hook(GLenum target, GLenum pname, GLfloat* params);
  void glGetTexEnviv_Hook(GLenum target, GLenum pname, GLint* params);
  void glGetTexGendv_Hook(GLenum coord, GLenum pname, GLdouble* params);
  void glGetTexGenfv_Hook(GLenum coord, GLenum pname, GLfloat* params);
  void glGetTexGeniv_Hook(GLenum coord, GLenum pname, GLint* params);
  void glGetTexImage_Hook(GLenum target, GLint level, GLenum format, GLenum type, void* pixels);
  void glGetTexLevelParameterfv_Hook(GLenum target, GLint level, GLenum pname, GLfloat* params);
  void glGetTexLevelParameteriv_Hook(GLenum target, GLint level, GLenum pname, GLint* params);
  void glGetTexParameterfv_Hook(GLenum target, GLenum pname, GLfloat* params);
  void glGetTexParameteriv_Hook(GLenum target, GLenum pname, GLint* params);
  void glHint_Hook(GLenum target, GLenum mode);
  void glIndexMask_Hook(GLuint mask);
  void glIndexPointer_Hook(GLenum type, GLsizei stride, const void* pointer);
  void glIndexd_Hook(GLdouble c);
  void glIndexdv_Hook(const GLdouble* c);
  void glIndexf_Hook(GLfloat c);
  void glIndexfv_Hook(const GLfloat* c);
  void glIndexi_Hook(GLint c);
  void glIndexiv_Hook(const GLint* c);
  void glIndexs_Hook(GLshort c);
  void glIndexsv_Hook(const GLshort* c);
  void glIndexub_Hook(GLubyte c);
  void glIndexubv_Hook(const GLubyte* c);
  void glInitNames_Hook(void);
  void glInterleavedArrays_Hook(GLenum format, GLsizei stride, const void* pointer);
  GLboolean glIsEnabled_Hook(GLenum cap);
  GLboolean glIsList_Hook(GLuint list);
  GLboolean glIsTexture_Hook(GLuint texture);
  void glLightModelf_Hook(GLenum pname, GLfloat param);
  void glLightModelfv_Hook(GLenum pname, const GLfloat* params);
  void glLightModeli_Hook(GLenum pname, GLint param);
  void glLightModeliv_Hook(GLenum pname, const GLint* params);
  void glLightf_Hook(GLenum light, GLenum pname, GLfloat param);
  void glLightfv_Hook(GLenum light, GLenum pname, const GLfloat* params);
  void glLighti_Hook(GLenum light, GLenum pname, GLint param);
  void glLightiv_Hook(GLenum light, GLenum pname, const GLint* params);
  void glLineStipple_Hook(GLint factor, GLushort pattern);
  void glLineWidth_Hook(GLfloat width);
  void glListBase_Hook(GLuint base);
  void glLoadIdentity_Hook(void);
  void glLoadMatrixd_Hook(const GLdouble* m);
  void glLoadMatrixf_Hook(const GLfloat* m);
  void glLoadName_Hook(GLuint name);
  void glLogicOp_Hook(GLenum opcode);
  void glMap1d_Hook(
      GLenum target,
      GLdouble u1,
      GLdouble u2,
      GLint stride,
      GLint order,
      const GLdouble* points);
  void glMap1f_Hook(
      GLenum target,
      GLfloat u1,
      GLfloat u2,
      GLint stride,
      GLint order,
      const GLfloat* points);
  void glMap2d_Hook(
      GLenum target,
      GLdouble u1,
      GLdouble u2,
      GLint ustride,
      GLint uorder,
      GLdouble v1,
      GLdouble v2,
      GLint vstride,
      GLint vorder,
      const GLdouble* points);
  void glMap2f_Hook(
      GLenum target,
      GLfloat u1,
      GLfloat u2,
      GLint ustride,
      GLint uorder,
      GLfloat v1,
      GLfloat v2,
      GLint vstride,
      GLint vorder,
      const GLfloat* points);
  void glMapGrid1d_Hook(GLint un, GLdouble u1, GLdouble u2);
  void glMapGrid1f_Hook(GLint un, GLfloat u1, GLfloat u2);
  void glMapGrid2d_Hook(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
  void glMapGrid2f_Hook(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
  void glMaterialf_Hook(GLenum face, GLenum pname, GLfloat param);
  void glMaterialfv_Hook(GLenum face, GLenum pname, const GLfloat* params);
  void glMateriali_Hook(GLenum face, GLenum pname, GLint param);
  void glMaterialiv_Hook(GLenum face, GLenum pname, const GLint* params);
  void glMatrixMode_Hook(GLenum mode);
  void glMultMatrixd_Hook(const GLdouble* m);
  void glMultMatrixf_Hook(const GLfloat* m);
  void glNewList_Hook(GLuint list, GLenum mode);
  void glNormal3b_Hook(GLbyte nx, GLbyte ny, GLbyte nz);
  void glNormal3bv_Hook(const GLbyte* v);
  void glNormal3d_Hook(GLdouble nx, GLdouble ny, GLdouble nz);
  void glNormal3dv_Hook(const GLdouble* v);
  void glNormal3f_Hook(GLfloat nx, GLfloat ny, GLfloat nz);
  void glNormal3fv_Hook(const GLfloat* v);
  void glNormal3i_Hook(GLint nx, GLint ny, GLint nz);
  void glNormal3iv_Hook(const GLint* v);
  void glNormal3s_Hook(GLshort nx, GLshort ny, GLshort nz);
  void glNormal3sv_Hook(const GLshort* v);
  void glNormalPointer_Hook(GLenum type, GLsizei stride, const void* pointer);
  void glOrtho_Hook(
      GLdouble left,
      GLdouble right,
      GLdouble bottom,
      GLdouble top,
      GLdouble zNear,
      GLdouble zFar);
  void glPassThrough_Hook(GLfloat token);
  void glPixelMapfv_Hook(GLenum map, GLsizei mapsize, const GLfloat* values);
  void glPixelMapuiv_Hook(GLenum map, GLsizei mapsize, const GLuint* values);
  void glPixelMapusv_Hook(GLenum map, GLsizei mapsize, const GLushort* values);
  void glPixelStoref_Hook(GLenum pname, GLfloat param);
  void glPixelStorei_Hook(GLenum pname, GLint param);
  void glPixelTransferf_Hook(GLenum pname, GLfloat param);
  void glPixelTransferi_Hook(GLenum pname, GLint param);
  void glPixelZoom_Hook(GLfloat xfactor, GLfloat yfactor);
  void glPointSize_Hook(GLfloat size);
  void glPolygonMode_Hook(GLenum face, GLenum mode);
  void glPolygonOffset_Hook(GLfloat factor, GLfloat units);
  void glPolygonStipple_Hook(const GLubyte* mask);
  void glPopAttrib_Hook(void);
  void glPopClientAttrib_Hook(void);
  void glPopMatrix_Hook(void);
  void glPopName_Hook(void);
  void glPrioritizeTextures_Hook(GLsizei n, const GLuint* textures, const GLclampf* priorities);
  void glPushAttrib_Hook(GLbitfield mask);
  void glPushClientAttrib_Hook(GLbitfield mask);
  void glPushMatrix_Hook(void);
  void glPushName_Hook(GLuint name);
  void glRasterPos2d_Hook(GLdouble x, GLdouble y);
  void glRasterPos2dv_Hook(const GLdouble* v);
  void glRasterPos2f_Hook(GLfloat x, GLfloat y);
  void glRasterPos2fv_Hook(const GLfloat* v);
  void glRasterPos2i_Hook(GLint x, GLint y);
  void glRasterPos2iv_Hook(const GLint* v);
  void glRasterPos2s_Hook(GLshort x, GLshort y);
  void glRasterPos2sv_Hook(const GLshort* v);
  void glRasterPos3d_Hook(GLdouble x, GLdouble y, GLdouble z);
  void glRasterPos3dv_Hook(const GLdouble* v);
  void glRasterPos3f_Hook(GLfloat x, GLfloat y, GLfloat z);
  void glRasterPos3fv_Hook(const GLfloat* v);
  void glRasterPos3i_Hook(GLint x, GLint y, GLint z);
  void glRasterPos3iv_Hook(const GLint* v);
  void glRasterPos3s_Hook(GLshort x, GLshort y, GLshort z);
  void glRasterPos3sv_Hook(const GLshort* v);
  void glRasterPos4d_Hook(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
  void glRasterPos4dv_Hook(const GLdouble* v);
  void glRasterPos4f_Hook(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
  void glRasterPos4fv_Hook(const GLfloat* v);
  void glRasterPos4i_Hook(GLint x, GLint y, GLint z, GLint w);
  void glRasterPos4iv_Hook(const GLint* v);
  void glRasterPos4s_Hook(GLshort x, GLshort y, GLshort z, GLshort w);
  void glRasterPos4sv_Hook(const GLshort* v);
  void glReadBuffer_Hook(GLenum mode);
  void glReadPixels_Hook(
      GLint x,
      GLint y,
      GLsizei width,
      GLsizei height,
      GLenum format,
      GLenum type,
      void* pixels);
  void glRectd_Hook(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
  void glRectdv_Hook(const GLdouble* v1, const GLdouble* v2);
  void glRectf_Hook(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
  void glRectfv_Hook(const GLfloat* v1, const GLfloat* v2);
  void glRecti_Hook(GLint x1, GLint y1, GLint x2, GLint y2);
  void glRectiv_Hook(const GLint* v1, const GLint* v2);
  void glRects_Hook(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
  void glRectsv_Hook(const GLshort* v1, const GLshort* v2);
  GLint glRenderMode_Hook(GLenum mode);
  void glRotated_Hook(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
  void glRotatef_Hook(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
  void glScaled_Hook(GLdouble x, GLdouble y, GLdouble z);
  void glScalef_Hook(GLfloat x, GLfloat y, GLfloat z);
  void glScissor_Hook(GLint x, GLint y, GLsizei width, GLsizei height);
  void glSelectBuffer_Hook(GLsizei size, GLuint* buffer);
  void glShadeModel_Hook(GLenum mode);
  void glStencilFunc_Hook(GLenum func, GLint ref, GLuint mask);
  void glStencilMask_Hook(GLuint mask);
  void glStencilOp_Hook(GLenum fail, GLenum zfail, GLenum zpass);
  void glTexCoord1d_Hook(GLdouble s);
  void glTexCoord1dv_Hook(const GLdouble* v);
  void glTexCoord1f_Hook(GLfloat s);
  void glTexCoord1fv_Hook(const GLfloat* v);
  void glTexCoord1i_Hook(GLint s);
  void glTexCoord1iv_Hook(const GLint* v);
  void glTexCoord1s_Hook(GLshort s);
  void glTexCoord1sv_Hook(const GLshort* v);
  void glTexCoord2d_Hook(GLdouble s, GLdouble t);
  void glTexCoord2dv_Hook(const GLdouble* v);
  void glTexCoord2f_Hook(GLfloat s, GLfloat t);
  void glTexCoord2fv_Hook(const GLfloat* v);
  void glTexCoord2i_Hook(GLint s, GLint t);
  void glTexCoord2iv_Hook(const GLint* v);
  void glTexCoord2s_Hook(GLshort s, GLshort t);
  void glTexCoord2sv_Hook(const GLshort* v);
  void glTexCoord3d_Hook(GLdouble s, GLdouble t, GLdouble r);
  void glTexCoord3dv_Hook(const GLdouble* v);
  void glTexCoord3f_Hook(GLfloat s, GLfloat t, GLfloat r);
  void glTexCoord3fv_Hook(const GLfloat* v);
  void glTexCoord3i_Hook(GLint s, GLint t, GLint r);
  void glTexCoord3iv_Hook(const GLint* v);
  void glTexCoord3s_Hook(GLshort s, GLshort t, GLshort r);
  void glTexCoord3sv_Hook(const GLshort* v);
  void glTexCoord4d_Hook(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
  void glTexCoord4dv_Hook(const GLdouble* v);
  void glTexCoord4f_Hook(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
  void glTexCoord4fv_Hook(const GLfloat* v);
  void glTexCoord4i_Hook(GLint s, GLint t, GLint r, GLint q);
  void glTexCoord4iv_Hook(const GLint* v);
  void glTexCoord4s_Hook(GLshort s, GLshort t, GLshort r, GLshort q);
  void glTexCoord4sv_Hook(const GLshort* v);
  void glTexCoordPointer_Hook(GLint size, GLenum type, GLsizei stride, const void* pointer);
  void glTexEnvf_Hook(GLenum target, GLenum pname, GLfloat param);
  void glTexEnvfv_Hook(GLenum target, GLenum pname, const GLfloat* params);
  void glTexEnvi_Hook(GLenum target, GLenum pname, GLint param);
  void glTexEnviv_Hook(GLenum target, GLenum pname, const GLint* params);
  void glTexGend_Hook(GLenum coord, GLenum pname, GLdouble param);
  void glTexGendv_Hook(GLenum coord, GLenum pname, const GLdouble* params);
  void glTexGenf_Hook(GLenum coord, GLenum pname, GLfloat param);
  void glTexGenfv_Hook(GLenum coord, GLenum pname, const GLfloat* params);
  void glTexGeni_Hook(GLenum coord, GLenum pname, GLint param);
  void glTexGeniv_Hook(GLenum coord, GLenum pname, const GLint* params);
  void glTexImage1D_Hook(
      GLenum target,
      GLint level,
      GLint internalformat,
      GLsizei width,
      GLint border,
      GLenum format,
      GLenum type,
      const void* pixels);
  void glTexImage2D_Hook(
      GLenum target,
      GLint level,
      GLint internalformat,
      GLsizei width,
      GLsizei height,
      GLint border,
      GLenum format,
      GLenum type,
      const void* pixels);
  void glTexParameterf_Hook(GLenum target, GLenum pname, GLfloat param);
  void glTexParameterfv_Hook(GLenum target, GLenum pname, const GLfloat* params);
  void glTexParameteri_Hook(GLenum target, GLenum pname, GLint param);
  void glTexParameteriv_Hook(GLenum target, GLenum pname, const GLint* params);
  void glTexSubImage1D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLsizei width,
      GLenum format,
      GLenum type,
      const void* pixels);
  void glTexSubImage2D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLsizei width,
      GLsizei height,
      GLenum format,
      GLenum type,
      const void* pixels);
  void glTranslated_Hook(GLdouble x, GLdouble y, GLdouble z);
  void glTranslatef_Hook(GLfloat x, GLfloat y, GLfloat z);
  void glVertex2d_Hook(GLdouble x, GLdouble y);
  void glVertex2dv_Hook(const GLdouble* v);
  void glVertex2f_Hook(GLfloat x, GLfloat y);
  void glVertex2fv_Hook(const GLfloat* v);
  void glVertex2i_Hook(GLint x, GLint y);
  void glVertex2iv_Hook(const GLint* v);
  void glVertex2s_Hook(GLshort x, GLshort y);
  void glVertex2sv_Hook(const GLshort* v);
  void glVertex3d_Hook(GLdouble x, GLdouble y, GLdouble z);
  void glVertex3dv_Hook(const GLdouble* v);
  void glVertex3f_Hook(GLfloat x, GLfloat y, GLfloat z);
  void glVertex3fv_Hook(const GLfloat* v);
  void glVertex3i_Hook(GLint x, GLint y, GLint z);
  void glVertex3iv_Hook(const GLint* v);
  void glVertex3s_Hook(GLshort x, GLshort y, GLshort z);
  void glVertex3sv_Hook(const GLshort* v);
  void glVertex4d_Hook(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
  void glVertex4dv_Hook(const GLdouble* v);
  void glVertex4f_Hook(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
  void glVertex4fv_Hook(const GLfloat* v);
  void glVertex4i_Hook(GLint x, GLint y, GLint z, GLint w);
  void glVertex4iv_Hook(const GLint* v);
  void glVertex4s_Hook(GLshort x, GLshort y, GLshort z, GLshort w);
  void glVertex4sv_Hook(const GLshort* v);
  void glVertexPointer_Hook(GLint size, GLenum type, GLsizei stride, const void* pointer);
  void glViewport_Hook(GLint x, GLint y, GLsizei width, GLsizei height);

  // GL_VERSION_1_2
  void glBlendColor_Hook(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
  void glBlendEquation_Hook(GLenum mode);
  void glDrawRangeElements_Hook(
      GLenum mode,
      GLuint start,
      GLuint end,
      GLsizei count,
      GLenum type,
      const GLvoid* indices);
  void glTexImage3D_Hook(
      GLenum target,
      GLint level,
      GLint internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLint border,
      GLenum format,
      GLenum type,
      const GLvoid* pixels);
  void glTexSubImage3D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLint zoffset,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLenum format,
      GLenum type,
      const GLvoid* pixels);
  void glCopyTexSubImage3D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLint zoffset,
      GLint x,
      GLint y,
      GLsizei width,
      GLsizei height);

  // GL_VERSION_1_2 deprecated functions
  /* Not currently supported
  void glColorTable_Hook(GLenum target, GLenum internalformat, GLsizei width,
                          GLenum format, GLenum type, const GLvoid *table);
  void glColorTableParameterfv_Hook(GLenum target, GLenum pname, const GLfloat *params);
  void glColorTableParameteriv_Hook(GLenum target, GLenum pname, const GLint *params);
  void glCopyColorTable_Hook(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
  void glGetColorTable_Hook(GLenum target, GLenum format, GLenum type, GLvoid *table);
  void glGetColorTableParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params);
  void glGetColorTableParameteriv_Hook(GLenum target, GLenum pname, GLint *params);
  void glColorSubTable_Hook(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type,
                            const GLvoid *data);
  void glCopyColorSubTable_Hook(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
  void glConvolutionFilter1D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLenum
                                  format, GLenum type, const GLvoid *image);
  void glConvolutionFilter2D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei
                                  height, GLenum format, GLenum type, const GLvoid *image);
  void glConvolutionParameterf_Hook(GLenum target, GLenum pname, GLfloat params);
  void glConvolutionParameterfv_Hook(GLenum target, GLenum pname, const GLfloat *params);
  void glConvolutionParameteri_Hook(GLenum target, GLenum pname, GLint params);
  void glConvolutionParameteriv_Hook(GLenum target, GLenum pname, const GLint *params);
  void glCopyConvolutionFilter1D_Hook(GLenum target, GLenum internalformat,
                                      GLint x, GLint y, GLsizei width);
  void glCopyConvolutionFilter2D_Hook(GLenum target, GLenum internalformat,
                                      GLint x, GLint y, GLsizei width, GLsizei height);
  void glGetConvolutionFilter_Hook(GLenum target, GLenum format, GLenum type, GLvoid *image);
  void glGetConvolutionParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params);
  void glGetConvolutionParameteriv_Hook(GLenum target, GLenum pname, GLint *params);
  void glGetSeparableFilter_Hook(GLenum target, GLenum format, GLenum type,
                                 GLvoid *row, GLvoid *column, GLvoid *span);
  void glSeparableFilter2D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei height,
                               GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
  void glGetHistogram_Hook(GLenum target, GLboolean reset, GLenum format,
                           GLenum type, GLvoid *values);
  void glGetHistogramParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params);
  void glGetHistogramParameteriv_Hook(GLenum target, GLenum pname, GLint *params);
  void glGetMinmax_Hook(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
  void glGetMinmaxParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params);
  void glGetMinmaxParameteriv_Hook(GLenum target, GLenum pname, GLint *params);
  void glHistogram_Hook(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
  void glMinmax_Hook(GLenum target, GLenum internalformat, GLboolean sink);
  void glResetHistogram_Hook(GLenum target);
  void glResetMinmax_Hook(GLenum target);
  */

  // GL_VERSION_1_3
  void glActiveTexture_Hook(GLenum texture);
  void glSampleCoverage_Hook(GLclampf value, GLboolean invert);
  void glCompressedTexImage3D_Hook(
      GLenum target,
      GLint level,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLint border,
      GLsizei imageSize,
      const GLvoid* data);
  void glCompressedTexImage2D_Hook(
      GLenum target,
      GLint level,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLint border,
      GLsizei imageSize,
      const GLvoid* data);
  void glCompressedTexImage1D_Hook(
      GLenum target,
      GLint level,
      GLenum internalformat,
      GLsizei width,
      GLint border,
      GLsizei imageSize,
      const GLvoid* data);
  void glCompressedTexSubImage3D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLint zoffset,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLenum format,
      GLsizei imageSize,
      const GLvoid* data);
  void glCompressedTexSubImage2D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLsizei width,
      GLsizei height,
      GLenum format,
      GLsizei imageSize,
      const GLvoid* data);
  void glCompressedTexSubImage1D_Hook(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLsizei width,
      GLenum format,
      GLsizei imageSize,
      const GLvoid* data);
  void glGetCompressedTexImage_Hook(GLenum target, GLint level, GLvoid* img);

  // GL_VERSION_1_3 deprecated functions
  void glClientActiveTexture_Hook(GLenum texture);
  void glMultiTexCoord1d_Hook(GLenum target, GLdouble s);
  void glMultiTexCoord1dv_Hook(GLenum target, const GLdouble* v);
  void glMultiTexCoord1f_Hook(GLenum target, GLfloat s);
  void glMultiTexCoord1fv_Hook(GLenum target, const GLfloat* v);
  void glMultiTexCoord1i_Hook(GLenum target, GLint s);
  void glMultiTexCoord1iv_Hook(GLenum target, const GLint* v);
  void glMultiTexCoord1s_Hook(GLenum target, GLshort s);
  void glMultiTexCoord1sv_Hook(GLenum target, const GLshort* v);
  void glMultiTexCoord2d_Hook(GLenum target, GLdouble s, GLdouble t);
  void glMultiTexCoord2dv_Hook(GLenum target, const GLdouble* v);
  void glMultiTexCoord2f_Hook(GLenum target, GLfloat s, GLfloat t);
  void glMultiTexCoord2fv_Hook(GLenum target, const GLfloat* v);
  void glMultiTexCoord2i_Hook(GLenum target, GLint s, GLint t);
  void glMultiTexCoord2iv_Hook(GLenum target, const GLint* v);
  void glMultiTexCoord2s_Hook(GLenum target, GLshort s, GLshort t);
  void glMultiTexCoord2sv_Hook(GLenum target, const GLshort* v);
  void glMultiTexCoord3d_Hook(GLenum target, GLdouble s, GLdouble t, GLdouble r);
  void glMultiTexCoord3dv_Hook(GLenum target, const GLdouble* v);
  void glMultiTexCoord3f_Hook(GLenum target, GLfloat s, GLfloat t, GLfloat r);
  void glMultiTexCoord3fv_Hook(GLenum target, const GLfloat* v);
  void glMultiTexCoord3i_Hook(GLenum target, GLint s, GLint t, GLint r);
  void glMultiTexCoord3iv_Hook(GLenum target, const GLint* v);
  void glMultiTexCoord3s_Hook(GLenum target, GLshort s, GLshort t, GLshort r);
  void glMultiTexCoord3sv_Hook(GLenum target, const GLshort* v);
  void glMultiTexCoord4d_Hook(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
  void glMultiTexCoord4dv_Hook(GLenum target, const GLdouble* v);
  void glMultiTexCoord4f_Hook(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
  void glMultiTexCoord4fv_Hook(GLenum target, const GLfloat* v);
  void glMultiTexCoord4i_Hook(GLenum target, GLint s, GLint t, GLint r, GLint q);
  void glMultiTexCoord4iv_Hook(GLenum target, const GLint* v);
  void glMultiTexCoord4s_Hook(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
  void glMultiTexCoord4sv_Hook(GLenum target, const GLshort* v);
  void glLoadTransposeMatrixf_Hook(const GLfloat* m);
  void glLoadTransposeMatrixd_Hook(const GLdouble* m);
  void glMultTransposeMatrixf_Hook(const GLfloat* m);
  void glMultTransposeMatrixd_Hook(const GLdouble* m);

  // GL_VERSION_1_4
  void glBlendFuncSeparate_Hook(
      GLenum sfactorRGB,
      GLenum dfactorRGB,
      GLenum sfactorAlpha,
      GLenum dfactorAlpha);
  void
  glMultiDrawArrays_Hook(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);
  void glMultiDrawElements_Hook(
      GLenum mode,
      const GLsizei* count,
      GLenum type,
      const GLvoid** indices,
      GLsizei primcount);
  void glPointParameterf_Hook(GLenum pname, GLfloat param);
  void glPointParameterfv_Hook(GLenum pname, const GLfloat* params);
  void glPointParameteri_Hook(GLenum pname, GLint param);
  void glPointParameteriv_Hook(GLenum pname, const GLint* params);

  // GL_VERSION_1_4 deprecated functions
  void glFogCoordf_Hook(GLfloat coord);
  void glFogCoordfv_Hook(const GLfloat* coord);
  void glFogCoordd_Hook(GLdouble coord);
  void glFogCoorddv_Hook(const GLdouble* coord);
  void glFogCoordPointer_Hook(GLenum type, GLsizei stride, const GLvoid* pointer);
  void glSecondaryColor3b_Hook(GLbyte red, GLbyte green, GLbyte blue);
  void glSecondaryColor3bv_Hook(const GLbyte* v);
  void glSecondaryColor3d_Hook(GLdouble red, GLdouble green, GLdouble blue);
  void glSecondaryColor3dv_Hook(const GLdouble* v);
  void glSecondaryColor3f_Hook(GLfloat red, GLfloat green, GLfloat blue);
  void glSecondaryColor3fv_Hook(const GLfloat* v);
  void glSecondaryColor3i_Hook(GLint red, GLint green, GLint blue);
  void glSecondaryColor3iv_Hook(const GLint* v);
  void glSecondaryColor3s_Hook(GLshort red, GLshort green, GLshort blue);
  void glSecondaryColor3sv_Hook(const GLshort* v);
  void glSecondaryColor3ub_Hook(GLubyte red, GLubyte green, GLubyte blue);
  void glSecondaryColor3ubv_Hook(const GLubyte* v);
  void glSecondaryColor3ui_Hook(GLuint red, GLuint green, GLuint blue);
  void glSecondaryColor3uiv_Hook(const GLuint* v);
  void glSecondaryColor3us_Hook(GLushort red, GLushort green, GLushort blue);
  void glSecondaryColor3usv_Hook(const GLushort* v);
  void glSecondaryColorPointer_Hook(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
  void glWindowPos2d_Hook(GLdouble x, GLdouble y);
  void glWindowPos2dv_Hook(const GLdouble* v);
  void glWindowPos2f_Hook(GLfloat x, GLfloat y);
  void glWindowPos2fv_Hook(const GLfloat* v);
  void glWindowPos2i_Hook(GLint x, GLint y);
  void glWindowPos2iv_Hook(const GLint* v);
  void glWindowPos2s_Hook(GLshort x, GLshort y);
  void glWindowPos2sv_Hook(const GLshort* v);
  void glWindowPos3d_Hook(GLdouble x, GLdouble y, GLdouble z);
  void glWindowPos3dv_Hook(const GLdouble* v);
  void glWindowPos3f_Hook(GLfloat x, GLfloat y, GLfloat z);
  void glWindowPos3fv_Hook(const GLfloat* v);
  void glWindowPos3i_Hook(GLint x, GLint y, GLint z);
  void glWindowPos3iv_Hook(const GLint* v);
  void glWindowPos3s_Hook(GLshort x, GLshort y, GLshort z);
  void glWindowPos3sv_Hook(const GLshort* v);

  // GL_VERSION_1_5
  void glGenQueries_Hook(GLsizei n, GLuint* ids);
  void glDeleteQueries_Hook(GLsizei n, const GLuint* ids);
  GLboolean glIsQuery_Hook(GLuint id);
  void glBeginQuery_Hook(GLenum target, GLuint id);
  void glEndQuery_Hook(GLenum target);
  void glGetQueryiv_Hook(GLenum target, GLenum pname, GLint* params);
  void glGetQueryObjectiv_Hook(GLuint id, GLenum pname, GLint* params);
  void glGetQueryObjectuiv_Hook(GLuint id, GLenum pname, GLuint* params);
  void glBindBuffer_Hook(GLenum target, GLuint buffer);
  void glDeleteBuffers_Hook(GLsizei n, const GLuint* buffers);
  void glGenBuffers_Hook(GLsizei n, GLuint* buffers);
  GLboolean glIsBuffer_Hook(GLuint buffer);
  void glBufferData_Hook(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
  void glBufferSubData_Hook(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
  void glGetBufferSubData_Hook(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data);
  GLvoid* glMapBuffer_Hook(GLenum target, GLenum access);
  GLboolean glUnmapBuffer_Hook(GLenum target);
  void glGetBufferParameteriv_Hook(GLenum target, GLenum pname, GLint* params);
  void glGetBufferPointerv_Hook(GLenum target, GLenum pname, GLvoid** params);

  // GL_VERSION_2_0
  void glBlendEquationSeparate_Hook(GLenum modeRGB, GLenum modeAlpha);
  void glDrawBuffers_Hook(GLsizei n, const GLenum* bufs);
  void glStencilOpSeparate_Hook(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
  void glStencilFuncSeparate_Hook(GLenum face, GLenum func, GLint ref, GLuint mask);
  void glStencilMaskSeparate_Hook(GLenum face, GLuint mask);
  void glAttachShader_Hook(GLuint program, GLuint shader);
  void glBindAttribLocation_Hook(GLuint program, GLuint index, const GLchar* name);
  void glCompileShader_Hook(GLuint shader);
  GLuint glCreateProgram_Hook(void);
  GLuint glCreateShader_Hook(GLenum type);
  void glDeleteProgram_Hook(GLuint program);
  void glDeleteShader_Hook(GLuint shader);
  void glDetachShader_Hook(GLuint program, GLuint shader);
  void glDisableVertexAttribArray_Hook(GLuint index);
  void glEnableVertexAttribArray_Hook(GLuint index);
  void glGetActiveAttrib_Hook(
      GLuint program,
      GLuint index,
      GLsizei bufSize,
      GLsizei* length,
      GLint* size,
      GLenum* type,
      GLchar* name);
  void glGetActiveUniform_Hook(
      GLuint program,
      GLuint index,
      GLsizei bufSize,
      GLsizei* length,
      GLint* size,
      GLenum* type,
      GLchar* name);
  void glGetAttachedShaders_Hook(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj);
  GLint glGetAttribLocation_Hook(GLuint program, const GLchar* name);
  void glGetProgramiv_Hook(GLuint program, GLenum pname, GLint* params);
  void glGetProgramInfoLog_Hook(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
  void glGetShaderiv_Hook(GLuint shader, GLenum pname, GLint* params);
  void glGetShaderInfoLog_Hook(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
  void glGetShaderSource_Hook(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source);
  GLint glGetUniformLocation_Hook(GLuint program, const GLchar* name);
  void glGetUniformfv_Hook(GLuint program, GLint location, GLfloat* params);
  void glGetUniformiv_Hook(GLuint program, GLint location, GLint* params);
  void glGetVertexAttribdv_Hook(GLuint index, GLenum pname, GLdouble* params);
  void glGetVertexAttribfv_Hook(GLuint index, GLenum pname, GLfloat* params);
  void glGetVertexAttribiv_Hook(GLuint index, GLenum pname, GLint* params);
  void glGetVertexAttribPointerv_Hook(GLuint index, GLenum pname, GLvoid** pointer);
  GLboolean glIsProgram_Hook(GLuint program);
  GLboolean glIsShader_Hook(GLuint shader);
  void glLinkProgram_Hook(GLuint program);
  void
  glShaderSource_Hook(GLuint shader, GLsizei count, const GLchar** string, const GLint* length);
  void glUseProgram_Hook(GLuint program);
  void glUniform1f_Hook(GLint location, GLfloat v0);
  void glUniform2f_Hook(GLint location, GLfloat v0, GLfloat v1);
  void glUniform3f_Hook(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
  void glUniform4f_Hook(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
  void glUniform1i_Hook(GLint location, GLint v0);
  void glUniform2i_Hook(GLint location, GLint v0, GLint v1);
  void glUniform3i_Hook(GLint location, GLint v0, GLint v1, GLint v2);
  void glUniform4i_Hook(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
  void glUniform1fv_Hook(GLint location, GLsizei count, const GLfloat* value);
  void glUniform2fv_Hook(GLint location, GLsizei count, const GLfloat* value);
  void glUniform3fv_Hook(GLint location, GLsizei count, const GLfloat* value);
  void glUniform4fv_Hook(GLint location, GLsizei count, const GLfloat* value);
  void glUniform1iv_Hook(GLint location, GLsizei count, const GLint* value);
  void glUniform2iv_Hook(GLint location, GLsizei count, const GLint* value);
  void glUniform3iv_Hook(GLint location, GLsizei count, const GLint* value);
  void glUniform4iv_Hook(GLint location, GLsizei count, const GLint* value);
  void
  glUniformMatrix2fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  void
  glUniformMatrix3fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  void
  glUniformMatrix4fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
  void glValidateProgram_Hook(GLuint program);
  void glVertexAttrib1d_Hook(GLuint index, GLdouble x);
  void glVertexAttrib1dv_Hook(GLuint index, const GLdouble* v);
  void glVertexAttrib1f_Hook(GLuint index, GLfloat x);
  void glVertexAttrib1fv_Hook(GLuint index, const GLfloat* v);
  void glVertexAttrib1s_Hook(GLuint index, GLshort x);
  void glVertexAttrib1sv_Hook(GLuint index, const GLshort* v);
  void glVertexAttrib2d_Hook(GLuint index, GLdouble x, GLdouble y);
  void glVertexAttrib2dv_Hook(GLuint index, const GLdouble* v);
  void glVertexAttrib2f_Hook(GLuint index, GLfloat x, GLfloat y);
  void glVertexAttrib2fv_Hook(GLuint index, const GLfloat* v);
  void glVertexAttrib2s_Hook(GLuint index, GLshort x, GLshort y);
  void glVertexAttrib2sv_Hook(GLuint index, const GLshort* v);
  void glVertexAttrib3d_Hook(GLuint index, GLdouble x, GLdouble y, GLdouble z);
  void glVertexAttrib3dv_Hook(GLuint index, const GLdouble* v);
  void glVertexAttrib3f_Hook(GLuint index, GLfloat x, GLfloat y, GLfloat z);
  void glVertexAttrib3fv_Hook(GLuint index, const GLfloat* v);
  void glVertexAttrib3s_Hook(GLuint index, GLshort x, GLshort y, GLshort z);
  void glVertexAttrib3sv_Hook(GLuint index, const GLshort* v);
  void glVertexAttrib4Nbv_Hook(GLuint index, const GLbyte* v);
  void glVertexAttrib4Niv_Hook(GLuint index, const GLint* v);
  void glVertexAttrib4Nsv_Hook(GLuint index, const GLshort* v);
  void glVertexAttrib4Nub_Hook(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
  void glVertexAttrib4Nubv_Hook(GLuint index, const GLubyte* v);
  void glVertexAttrib4Nuiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttrib4Nusv_Hook(GLuint index, const GLushort* v);
  void glVertexAttrib4bv_Hook(GLuint index, const GLbyte* v);
  void glVertexAttrib4d_Hook(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
  void glVertexAttrib4dv_Hook(GLuint index, const GLdouble* v);
  void glVertexAttrib4f_Hook(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
  void glVertexAttrib4fv_Hook(GLuint index, const GLfloat* v);
  void glVertexAttrib4iv_Hook(GLuint index, const GLint* v);
  void glVertexAttrib4s_Hook(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
  void glVertexAttrib4sv_Hook(GLuint index, const GLshort* v);
  void glVertexAttrib4ubv_Hook(GLuint index, const GLubyte* v);
  void glVertexAttrib4uiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttrib4usv_Hook(GLuint index, const GLushort* v);
  void glVertexAttribPointer_Hook(
      GLuint index,
      GLint size,
      GLenum type,
      GLboolean normalized,
      GLsizei stride,
      const GLvoid* pointer);

  // GL_VERSION_2_1
  void glUniformMatrix2x3fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);
  void glUniformMatrix3x2fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);
  void glUniformMatrix2x4fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);
  void glUniformMatrix4x2fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);
  void glUniformMatrix3x4fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);
  void glUniformMatrix4x3fv_Hook(
      GLint location,
      GLsizei count,
      GLboolean transpose,
      const GLfloat* value);

  // GL_VERSION_3_0
  void glColorMaski_Hook(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
  void glGetBooleani_v_Hook(GLenum target, GLuint index, GLboolean* data);
  void glGetIntegeri_v_Hook(GLenum target, GLuint index, GLint* data);
  void glEnablei_Hook(GLenum target, GLuint index);
  void glDisablei_Hook(GLenum target, GLuint index);
  GLboolean glIsEnabledi_Hook(GLenum target, GLuint index);
  void glBeginTransformFeedback_Hook(GLenum primitiveMode);
  void glEndTransformFeedback_Hook(void);
  void glBindBufferRange_Hook(
      GLenum target,
      GLuint index,
      GLuint buffer,
      GLintptr offset,
      GLsizeiptr size);
  void glBindBufferBase_Hook(GLenum target, GLuint index, GLuint buffer);
  void glTransformFeedbackVaryings_Hook(
      GLuint program,
      GLsizei count,
      const GLchar** varyings,
      GLenum bufferMode);
  void glGetTransformFeedbackVarying_Hook(
      GLuint program,
      GLuint index,
      GLsizei bufSize,
      GLsizei* length,
      GLsizei* size,
      GLenum* type,
      GLchar* name);
  void glClampColor_Hook(GLenum target, GLenum clamp);
  void glBeginConditionalRender_Hook(GLuint id, GLenum mode);
  void glEndConditionalRender_Hook(void);
  void glVertexAttribIPointer_Hook(
      GLuint index,
      GLint size,
      GLenum type,
      GLsizei stride,
      const GLvoid* pointer);
  void glGetVertexAttribIiv_Hook(GLuint index, GLenum pname, GLint* params);
  void glGetVertexAttribIuiv_Hook(GLuint index, GLenum pname, GLuint* params);
  void glVertexAttribI1i_Hook(GLuint index, GLint x);
  void glVertexAttribI2i_Hook(GLuint index, GLint x, GLint y);
  void glVertexAttribI3i_Hook(GLuint index, GLint x, GLint y, GLint z);
  void glVertexAttribI4i_Hook(GLuint index, GLint x, GLint y, GLint z, GLint w);
  void glVertexAttribI1ui_Hook(GLuint index, GLuint x);
  void glVertexAttribI2ui_Hook(GLuint index, GLuint x, GLuint y);
  void glVertexAttribI3ui_Hook(GLuint index, GLuint x, GLuint y, GLuint z);
  void glVertexAttribI4ui_Hook(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
  void glVertexAttribI1iv_Hook(GLuint index, const GLint* v);
  void glVertexAttribI2iv_Hook(GLuint index, const GLint* v);
  void glVertexAttribI3iv_Hook(GLuint index, const GLint* v);
  void glVertexAttribI4iv_Hook(GLuint index, const GLint* v);
  void glVertexAttribI1uiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttribI2uiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttribI3uiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttribI4uiv_Hook(GLuint index, const GLuint* v);
  void glVertexAttribI4bv_Hook(GLuint index, const GLbyte* v);
  void glVertexAttribI4sv_Hook(GLuint index, const GLshort* v);
  void glVertexAttribI4ubv_Hook(GLuint index, const GLubyte* v);
  void glVertexAttribI4usv_Hook(GLuint index, const GLushort* v);
  void glGetUniformuiv_Hook(GLuint program, GLint location, GLuint* params);
  void glBindFragDataLocation_Hook(GLuint program, GLuint color, const GLchar* name);
  GLint glGetFragDataLocation_Hook(GLuint program, const GLchar* name);
  void glUniform1ui_Hook(GLint location, GLuint v0);
  void glUniform2ui_Hook(GLint location, GLuint v0, GLuint v1);
  void glUniform3ui_Hook(GLint location, GLuint v0, GLuint v1, GLuint v2);
  void glUniform4ui_Hook(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
  void glUniform1uiv_Hook(GLint location, GLsizei count, const GLuint* value);
  void glUniform2uiv_Hook(GLint location, GLsizei count, const GLuint* value);
  void glUniform3uiv_Hook(GLint location, GLsizei count, const GLuint* value);
  void glUniform4uiv_Hook(GLint location, GLsizei count, const GLuint* value);
  void glTexParameterIiv_Hook(GLenum target, GLenum pname, const GLint* params);
  void glTexParameterIuiv_Hook(GLenum target, GLenum pname, const GLuint* params);
  void glGetTexParameterIiv_Hook(GLenum target, GLenum pname, GLint* params);
  void glGetTexParameterIuiv_Hook(GLenum target, GLenum pname, GLuint* params);
  void glClearBufferiv_Hook(GLenum buffer, GLint drawbuffer, const GLint* value);
  void glClearBufferuiv_Hook(GLenum buffer, GLint drawbuffer, const GLuint* value);
  void glClearBufferfv_Hook(GLenum buffer, GLint drawbuffer, const GLfloat* value);
  void glClearBufferfi_Hook(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
  const GLubyte* glGetStringi_Hook(GLenum name, GLuint index);

  // GL_VERSION_3_1
  void glDrawArraysInstanced_Hook(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
  void glDrawElementsInstanced_Hook(
      GLenum mode,
      GLsizei count,
      GLenum type,
      const GLvoid* indices,
      GLsizei primcount);
  void glTexBuffer_Hook(GLenum target, GLenum internalformat, GLuint buffer);
  void glPrimitiveRestartIndex_Hook(GLuint index);

  // GL_VERSION_3_2
  void glGetInteger64i_v_Hook(GLenum target, GLuint index, GLint64* data);
  void glGetBufferParameteri64v_Hook(GLenum target, GLenum pname, GLint64* params);
  void glFramebufferTexture_Hook(GLenum target, GLenum attachment, GLuint texture, GLint level);

  // GL_VERSION_3_3
  void glVertexAttribDivisor_Hook(GLuint index, GLuint divisor);

  // GL_VERSION_4_0
  void glMinSampleShading_Hook(GLclampf value);
  void glBlendEquationi_Hook(GLuint buf, GLenum mode);
  void glBlendEquationSeparatei_Hook(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
  void glBlendFunci_Hook(GLuint buf, GLenum src, GLenum dst);
  void glBlendFuncSeparatei_Hook(
      GLuint buf,
      GLenum srcRGB,
      GLenum dstRGB,
      GLenum srcAlpha,
      GLenum dstAlpha);

  // GL_AMD_debug_output
  void glDebugMessageEnableAMD_Hook(
      GLenum category,
      GLenum severity,
      GLsizei count,
      const GLuint* ids,
      GLboolean enabled);
  void glDebugMessageInsertAMD_Hook(
      GLenum category,
      GLenum severity,
      GLuint id,
      GLsizei length,
      const GLchar* buf);
  void glDebugMessageCallbackAMD_Hook(GLDEBUGPROCAMD callback, GLvoid* userParam);
  GLuint glGetDebugMessageLogAMD_Hook(
      GLuint count,
      GLsizei bufsize,
      GLenum* categories,
      GLuint* severities,
      GLuint* ids,
      GLsizei* lengths,
      GLchar* message);

#if defined(GLE_CGL_ENABLED)
  // GL_APPLE_element_array
  void glElementPointerAPPLE_Hook(GLenum type, const GLvoid* pointer);
  void glDrawElementArrayAPPLE_Hook(GLenum mode, GLint first, GLsizei count);
  void glDrawRangeElementArrayAPPLE_Hook(
      GLenum mode,
      GLuint start,
      GLuint end,
      GLint first,
      GLsizei count);
  void glMultiDrawElementArrayAPPLE_Hook(
      GLenum mode,
      const GLint* first,
      const GLsizei* count,
      GLsizei primcount);
  void glMultiDrawRangeElementArrayAPPLE_Hook(
      GLenum mode,
      GLuint start,
      GLuint end,
      const GLint* first,
      const GLsizei* count,
      GLsizei primcount);

  // GL_APPLE_fence
  void glGenFencesAPPLE_Hook(GLsizei n, GLuint* fences);
  void glDeleteFencesAPPLE_Hook(GLsizei n, const GLuint* fences);
  void glSetFenceAPPLE_Hook(GLuint fence);
  GLboolean glIsFenceAPPLE_Hook(GLuint fence);
  GLboolean glTestFenceAPPLE_Hook(GLuint fence);
  void glFinishFenceAPPLE_Hook(GLuint fence);
  GLboolean glTestObjectAPPLE_Hook(GLenum object, GLuint name);
  void glFinishObjectAPPLE_Hook(GLenum object, GLint name);

  // GL_APPLE_flush_buffer_range
  void glBufferParameteriAPPLE_Hook(GLenum target, GLenum pname, GLint param);
  void glFlushMappedBufferRangeAPPLE_Hook(GLenum target, GLintptr offset, GLsizeiptr size);

  // GL_APPLE_object_purgeable
  GLenum glObjectPurgeableAPPLE_Hook(GLenum objectType, GLuint name, GLenum option);
  GLenum glObjectUnpurgeableAPPLE_Hook(GLenum objectType, GLuint name, GLenum option);
  void
  glGetObjectParameterivAPPLE_Hook(GLenum objectType, GLuint name, GLenum pname, GLint* params);

  // GL_APPLE_texture_range
  void glTextureRangeAPPLE_Hook(GLenum target, GLsizei length, const GLvoid* pointer);
  void glGetTexParameterPointervAPPLE_Hook(GLenum target, GLenum pname, GLvoid** params);

  // GL_APPLE_vertex_array_object
  void glBindVertexArrayAPPLE_Hook(GLuint array);
  void glDeleteVertexArraysAPPLE_Hook(GLsizei n, const GLuint* arrays);
  void glGenVertexArraysAPPLE_Hook(GLsizei n, GLuint* arrays);
  GLboolean glIsVertexArrayAPPLE_Hook(GLuint array);

  // GL_APPLE_vertex_array_range
  void glVertexArrayRangeAPPLE_Hook(GLsizei length, GLvoid* pointer);
  void glFlushVertexArrayRangeAPPLE_Hook(GLsizei length, GLvoid* pointer);
  void glVertexArrayParameteriAPPLE_Hook(GLenum pname, GLint param);

  // GL_APPLE_vertex_program_evaluators
  void glEnableVertexAttribAPPLE_Hook(GLuint index, GLenum pname);
  void glDisableVertexAttribAPPLE_Hook(GLuint index, GLenum pname);
  GLboolean glIsVertexAttribEnabledAPPLE_Hook(GLuint index, GLenum pname);
  void glMapVertexAttrib1dAPPLE_Hook(
      GLuint index,
      GLuint size,
      GLdouble u1,
      GLdouble u2,
      GLint stride,
      GLint order,
      const GLdouble* points);
  void glMapVertexAttrib1fAPPLE_Hook(
      GLuint index,
      GLuint size,
      GLfloat u1,
      GLfloat u2,
      GLint stride,
      GLint order,
      const GLfloat* points);
  void glMapVertexAttrib2dAPPLE_Hook(
      GLuint index,
      GLuint size,
      GLdouble u1,
      GLdouble u2,
      GLint ustride,
      GLint uorder,
      GLdouble v1,
      GLdouble v2,
      GLint vstride,
      GLint vorder,
      const GLdouble* points);
  void glMapVertexAttrib2fAPPLE_Hook(
      GLuint index,
      GLuint size,
      GLfloat u1,
      GLfloat u2,
      GLint ustride,
      GLint uorder,
      GLfloat v1,
      GLfloat v2,
      GLint vstride,
      GLint vorder,
      const GLfloat* points);
#endif // GLE_CGL_ENABLED

  // GL_ARB_copy_buffer
  void glCopyBufferSubData_Hook(
      GLenum readtarget,
      GLenum writetarget,
      GLintptr readoffset,
      GLintptr writeoffset,
      GLsizeiptr size);

  // GL_ARB_debug_output
  void glDebugMessageControlARB_Hook(
      GLenum source,
      GLenum type,
      GLenum severity,
      GLsizei count,
      const GLuint* ids,
      GLboolean enabled);
  void glDebugMessageInsertARB_Hook(
      GLenum source,
      GLenum type,
      GLuint id,
      GLenum severity,
      GLsizei length,
      const GLchar* buf);
  void glDebugMessageCallbackARB_Hook(GLDEBUGPROCARB callback, const GLvoid* userParam);
  GLuint glGetDebugMessageLogARB_Hook(
      GLuint count,
      GLsizei bufsize,
      GLenum* sources,
      GLenum* types,
      GLuint* ids,
      GLenum* severities,
      GLsizei* lengths,
      GLchar* messageLog);

  // GL_ARB_ES2_compatibility
  void glReleaseShaderCompiler_Hook();
  void glShaderBinary_Hook(
      GLsizei count,
      const GLuint* shaders,
      GLenum binaryformat,
      const GLvoid* binary,
      GLsizei length);
  void glGetShaderPrecisionFormat_Hook(
      GLenum shadertype,
      GLenum precisiontype,
      GLint* range,
      GLint* precision);
  void glDepthRangef_Hook(GLclampf n, GLclampf f);
  void glClearDepthf_Hook(GLclampf d);

  // GL_ARB_framebuffer_object
  GLboolean glIsRenderbuffer_Hook(GLuint renderbuffer);
  void glBindRenderbuffer_Hook(GLenum target, GLuint renderbuffer);
  void glDeleteRenderbuffers_Hook(GLsizei n, const GLuint* renderbuffers);
  void glGenRenderbuffers_Hook(GLsizei n, GLuint* renderbuffers);
  void
  glRenderbufferStorage_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
  void glGetRenderbufferParameteriv_Hook(GLenum target, GLenum pname, GLint* params);
  GLboolean glIsFramebuffer_Hook(GLuint framebuffer);
  void glBindFramebuffer_Hook(GLenum target, GLuint framebuffer);
  void glDeleteFramebuffers_Hook(GLsizei n, const GLuint* framebuffers);
  void glGenFramebuffers_Hook(GLsizei n, GLuint* framebuffers);
  GLenum glCheckFramebufferStatus_Hook(GLenum target);
  void glFramebufferTexture1D_Hook(
      GLenum target,
      GLenum attachment,
      GLenum textarget,
      GLuint texture,
      GLint level);
  void glFramebufferTexture2D_Hook(
      GLenum target,
      GLenum attachment,
      GLenum textarget,
      GLuint texture,
      GLint level);
  void glFramebufferTexture3D_Hook(
      GLenum target,
      GLenum attachment,
      GLenum textarget,
      GLuint texture,
      GLint level,
      GLint zoffset);
  void glFramebufferRenderbuffer_Hook(
      GLenum target,
      GLenum attachment,
      GLenum renderbuffertarget,
      GLuint renderbuffer);
  void glGetFramebufferAttachmentParameteriv_Hook(
      GLenum target,
      GLenum attachment,
      GLenum pname,
      GLint* params);
  void glGenerateMipmap_Hook(GLenum target);
  void glBlitFramebuffer_Hook(
      GLint srcX0,
      GLint srcY0,
      GLint srcX1,
      GLint srcY1,
      GLint dstX0,
      GLint dstY0,
      GLint dstX1,
      GLint dstY1,
      GLbitfield mask,
      GLenum filter);
  void glRenderbufferStorageMultisample_Hook(
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height);
  void glFramebufferTextureLayer_Hook(
      GLenum target,
      GLenum attachment,
      GLuint texture,
      GLint level,
      GLint layer);

  // GL_ARB_texture_multisample
  void glTexImage2DMultisample_Hook(
      GLenum target,
      GLsizei samples,
      GLint internalformat,
      GLsizei width,
      GLsizei height,
      GLboolean fixedsamplelocations);
  void glTexImage3DMultisample_Hook(
      GLenum target,
      GLsizei samples,
      GLint internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLboolean fixedsamplelocations);
  void glGetMultisamplefv_Hook(GLenum pname, GLuint index, GLfloat* val);
  void glSampleMaski_Hook(GLuint index, GLbitfield mask);

  // GL_ARB_texture_storage
  void glTexStorage1D_Hook(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
  void glTexStorage2D_Hook(
      GLenum target,
      GLsizei levels,
      GLenum internalformat,
      GLsizei width,
      GLsizei height);
  void glTexStorage3D_Hook(
      GLenum target,
      GLsizei levels,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth);
  void glTextureStorage1DEXT_Hook(
      GLuint texture,
      GLenum target,
      GLsizei levels,
      GLenum internalformat,
      GLsizei width);
  void glTextureStorage2DEXT_Hook(
      GLuint texture,
      GLenum target,
      GLsizei levels,
      GLenum internalformat,
      GLsizei width,
      GLsizei height);
  void glTextureStorage3DEXT_Hook(
      GLuint texture,
      GLenum target,
      GLsizei levels,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth);

  // GL_ARB_texture_storage_multisample
  void glTexStorage2DMultisample_Hook(
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLboolean fixedsamplelocations);
  void glTexStorage3DMultisample_Hook(
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLboolean fixedsamplelocations);
  void glTextureStorage2DMultisampleEXT_Hook(
      GLuint texture,
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLboolean fixedsamplelocations);
  void glTextureStorage3DMultisampleEXT_Hook(
      GLuint texture,
      GLenum target,
      GLsizei samples,
      GLenum internalformat,
      GLsizei width,
      GLsizei height,
      GLsizei depth,
      GLboolean fixedsamplelocations);

  // GL_ARB_timer_query
  void glQueryCounter_Hook(GLuint id, GLenum target);
  void glGetQueryObjecti64v_Hook(GLuint id, GLenum pname, GLint64* params);
  void glGetQueryObjectui64v_Hook(GLuint id, GLenum pname, GLuint64* params);

  // GL_ARB_vertex_array_object
  void glBindVertexArray_Hook(GLuint array);
  void glDeleteVertexArrays_Hook(GLsizei n, const GLuint* arrays);
  void glGenVertexArrays_Hook(GLsizei n, GLuint* arrays);
  GLboolean glIsVertexArray_Hook(GLuint array);

  // GL_EXT_draw_buffers2
  void glColorMaskIndexedEXT_Hook(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
  void glGetBooleanIndexedvEXT_Hook(GLenum target, GLuint index, GLboolean* data);
  void glGetIntegerIndexedvEXT_Hook(GLenum target, GLuint index, GLint* data);
  void glEnableIndexedEXT_Hook(GLenum target, GLuint index);
  void glDisableIndexedEXT_Hook(GLenum target, GLuint index);
  GLboolean glIsEnabledIndexedEXT_Hook(GLenum target, GLuint index);

  // GL_KHR_debug
  void glDebugMessageControl_Hook(
      GLenum source,
      GLenum type,
      GLenum severity,
      GLsizei count,
      const GLuint* ids,
      GLboolean enabled);
  void glDebugMessageInsert_Hook(
      GLenum source,
      GLenum type,
      GLuint id,
      GLenum severity,
      GLsizei length,
      const char* buf);
  void glDebugMessageCallback_Hook(GLDEBUGPROC callback, const void* userParam);
  GLuint glGetDebugMessageLog_Hook(
      GLuint count,
      GLsizei bufSize,
      GLenum* sources,
      GLenum* types,
      GLuint* ids,
      GLenum* severities,
      GLsizei* lengths,
      char* messageLog);
  void glPushDebugGroup_Hook(GLenum source, GLuint id, GLsizei length, const char* message);
  void glPopDebugGroup_Hook(void);
  void glObjectLabel_Hook(GLenum identifier, GLuint name, GLsizei length, const char* label);
  void glGetObjectLabel_Hook(
      GLenum identifier,
      GLuint name,
      GLsizei bufSize,
      GLsizei* length,
      char* label);
  void glObjectPtrLabel_Hook(void* ptr, GLsizei length, const char* label);
  void glGetObjectPtrLabel_Hook(void* ptr, GLsizei bufSize, GLsizei* length, char* label);

  // GL_WIN_swap_hint
  void glAddSwapHintRectWIN_Hook(GLint x, GLint y, GLsizei width, GLsizei height);

#if defined(GLE_WGL_ENABLED)
  void PostWGLHook(const char* functionName);

  // WGL
  /* Hooking of these is currently disabled.
  BOOL  wglCopyContext_Hook(HGLRC, HGLRC, UINT);
  HGLRC wglCreateContext_Hook(HDC);
  HGLRC wglCreateLayerContext_Hook(HDC, int);
  BOOL  wglDeleteContext_Hook(HGLRC);
  HGLRC wglGetCurrentContext_Hook(VOID);
  HDC   wglGetCurrentDC_Hook(VOID);
  PROC  wglGetProcAddress_Hook(LPCSTR);
  BOOL  wglMakeCurrent_Hook(HDC, HGLRC);
  BOOL  wglShareLists_Hook(HGLRC, HGLRC);
  BOOL  wglUseFontBitmapsA_Hook(HDC, DWORD, DWORD, DWORD);
  BOOL  wglUseFontBitmapsW_Hook(HDC, DWORD, DWORD, DWORD);
  BOOL  wglUseFontOutlinesA_Hook(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT);
  BOOL  wglUseFontOutlinesW_Hook(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int, LPGLYPHMETRICSFLOAT);
  BOOL  wglDescribeLayerPlane_Hook(HDC, int, int, UINT, LPLAYERPLANEDESCRIPTOR);
  int   wglSetLayerPaletteEntries_Hook(HDC, int, int, int, CONST COLORREF *);
  int   wglGetLayerPaletteEntries_Hook(HDC, int, int, int, COLORREF *);
  BOOL  wglRealizeLayerPalette_Hook(HDC, int, BOOL);
  BOOL  wglSwapLayerBuffers_Hook(HDC, UINT);
  DWORD wglSwapMultipleBuffers_Hook(UINT, CONST WGLSWAP *);
  */

  // WGL_ARB_buffer_region
  HANDLE wglCreateBufferRegionARB_Hook(HDC hDC, int iLayerPlane, UINT uType);
  VOID wglDeleteBufferRegionARB_Hook(HANDLE hRegion);
  BOOL wglSaveBufferRegionARB_Hook(HANDLE hRegion, int x, int y, int width, int height);
  BOOL wglRestoreBufferRegionARB_Hook(
      HANDLE hRegion,
      int x,
      int y,
      int width,
      int height,
      int xSrc,
      int ySrc);

  // WGL_ARB_extensions_string
  const char* wglGetExtensionsStringARB_Hook(HDC hdc);

  // WGL_ARB_pixel_format
  BOOL wglGetPixelFormatAttribivARB_Hook(
      HDC hdc,
      int iPixelFormat,
      int iLayerPlane,
      UINT nAttributes,
      const int* piAttributes,
      int* piValues);
  BOOL wglGetPixelFormatAttribfvARB_Hook(
      HDC hdc,
      int iPixelFormat,
      int iLayerPlane,
      UINT nAttributes,
      const int* piAttributes,
      FLOAT* pfValues);
  BOOL wglChoosePixelFormatARB_Hook(
      HDC hdc,
      const int* piAttribIList,
      const FLOAT* pfAttribFList,
      UINT nMaxFormats,
      int* piFormats,
      UINT* nNumFormats);

  // WGL_ARB_make_current_read
  BOOL wglMakeContextCurrentARB_Hook(HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
  HDC wglGetCurrentReadDCARB_Hook(void);

  // WGL_ARB_pbuffer
  HPBUFFERARB wglCreatePbufferARB_Hook(
      HDC hDC,
      int iPixelFormat,
      int iWidth,
      int iHeight,
      const int* piAttribList);
  HDC wglGetPbufferDCARB_Hook(HPBUFFERARB hPbuffer);
  int wglReleasePbufferDCARB_Hook(HPBUFFERARB hPbuffer, HDC hDC);
  BOOL wglDestroyPbufferARB_Hook(HPBUFFERARB hPbuffer);
  BOOL wglQueryPbufferARB_Hook(HPBUFFERARB hPbuffer, int iAttribute, int* piValue);

  // WGL_ARB_render_texture
  BOOL wglBindTexImageARB_Hook(HPBUFFERARB hPbuffer, int iBuffer);
  BOOL wglReleaseTexImageARB_Hook(HPBUFFERARB hPbuffer, int iBuffer);
  BOOL wglSetPbufferAttribARB_Hook(HPBUFFERARB hPbuffer, const int* piAttribList);

  // WGL_NV_present_video
  int wglEnumerateVideoDevicesNV_Hook(HDC hDC, HVIDEOOUTPUTDEVICENV* phDeviceList);
  BOOL wglBindVideoDeviceNV_Hook(
      HDC hDC,
      unsigned int uVideoSlot,
      HVIDEOOUTPUTDEVICENV hVideoDevice,
      const int* piAttribList);
  BOOL wglQueryCurrentContextNV_Hook(int iAttribute, int* piValue);

  // WGL_ARB_create_context
  HGLRC wglCreateContextAttribsARB_Hook(HDC hDC, HGLRC hShareContext, const int* attribList);

  // WGL_EXT_extensions_string
  const char* wglGetExtensionsStringEXT_Hook();

  // WGL_EXT_swap_control
  BOOL wglSwapIntervalEXT_Hook(int interval);
  int wglGetSwapIntervalEXT_Hook();

  // WGL_OML_sync_control
  BOOL wglGetSyncValuesOML_Hook(HDC hdc, INT64* ust, INT64* msc, INT64* sbc);
  BOOL wglGetMscRateOML_Hook(HDC hdc, INT32* numerator, INT32* denominator);
  INT64 wglSwapBuffersMscOML_Hook(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
  INT64 wglSwapLayerBuffersMscOML_Hook(
      HDC hdc,
      int fuPlanes,
      INT64 target_msc,
      INT64 divisor,
      INT64 remainder);
  BOOL wglWaitForMscOML_Hook(
      HDC hdc,
      INT64 target_msc,
      INT64 divisor,
      INT64 remainder,
      INT64* ust,
      INT64* msc,
      INT64* sbc);
  BOOL wglWaitForSbcOML_Hook(HDC hdc, INT64 target_sbc, INT64* ust, INT64* msc, INT64* sbc);

  // WGL_NV_video_output
  BOOL wglGetVideoDeviceNV_Hook(HDC hDC, int numDevices, HPVIDEODEV* hVideoDevice);
  BOOL wglReleaseVideoDeviceNV_Hook(HPVIDEODEV hVideoDevice);
  BOOL wglBindVideoImageNV_Hook(HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer);
  BOOL wglReleaseVideoImageNV_Hook(HPBUFFERARB hPbuffer, int iVideoBuffer);
  BOOL wglSendPbufferToVideoNV_Hook(
      HPBUFFERARB hPbuffer,
      int iBufferType,
      unsigned long* pulCounterPbuffer,
      BOOL bBlock);
  BOOL wglGetVideoInfoNV_Hook(
      HPVIDEODEV hpVideoDevice,
      unsigned long* pulCounterOutputPbuffer,
      unsigned long* pulCounterOutputVideo);

  // WGL_NV_swap_group
  BOOL wglJoinSwapGroupNV_Hook(HDC hDC, GLuint group);
  BOOL wglBindSwapBarrierNV_Hook(GLuint group, GLuint barrier);
  BOOL wglQuerySwapGroupNV_Hook(HDC hDC, GLuint* group, GLuint* barrier);
  BOOL wglQueryMaxSwapGroupsNV_Hook(HDC hDC, GLuint* maxGroups, GLuint* maxBarriers);
  BOOL wglQueryFrameCountNV_Hook(HDC hDC, GLuint* count);
  BOOL wglResetFrameCountNV_Hook(HDC hDC);

  // WGL_NV_video_capture
  BOOL wglBindVideoCaptureDeviceNV_Hook(UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice);
  UINT wglEnumerateVideoCaptureDevicesNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV* phDeviceList);
  BOOL wglLockVideoCaptureDeviceNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV hDevice);
  BOOL wglQueryVideoCaptureDeviceNV_Hook(
      HDC hDc,
      HVIDEOINPUTDEVICENV hDevice,
      int iAttribute,
      int* piValue);
  BOOL wglReleaseVideoCaptureDeviceNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV hDevice);

  // WGL_NV_copy_image
  BOOL wglCopyImageSubDataNV_Hook(
      HGLRC hSrcRC,
      GLuint srcName,
      GLenum srcTarget,
      GLint srcLevel,
      GLint srcX,
      GLint srcY,
      GLint srcZ,
      HGLRC hDstRC,
      GLuint dstName,
      GLenum dstTarget,
      GLint dstLevel,
      GLint dstX,
      GLint dstY,
      GLint dstZ,
      GLsizei width,
      GLsizei height,
      GLsizei depth);

  // WGL_NV_DX_interop
  BOOL wglDXSetResourceShareHandleNV_Hook(void* dxObject, HANDLE shareHandle);
  HANDLE wglDXOpenDeviceNV_Hook(void* dxDevice);
  BOOL wglDXCloseDeviceNV_Hook(HANDLE hDevice);
  HANDLE wglDXRegisterObjectNV_Hook(
      HANDLE hDevice,
      void* dxObject,
      GLuint name,
      GLenum type,
      GLenum access);
  BOOL wglDXUnregisterObjectNV_Hook(HANDLE hDevice, HANDLE hObject);
  BOOL wglDXObjectAccessNV_Hook(HANDLE hObject, GLenum access);
  BOOL wglDXLockObjectsNV_Hook(HANDLE hDevice, GLint count, HANDLE* hObjects);
  BOOL wglDXUnlockObjectsNV_Hook(HANDLE hDevice, GLint count, HANDLE* hObjects);
#endif // GLE_WGL_ENABLED

#if defined(GLE_GLX_ENABLED)
  void PostGLXHook(const char* functionName);

  // GLX_VERSION_1_0
  // GLX_VERSION_1_1
  // We don't currently do hooking of these.

  // GLX_VERSION_1_2
  ::Display* glXGetCurrentDisplay_Hook(void);

  // GLX_VERSION_1_3
  GLXFBConfig*
  glXChooseFBConfig_Hook(::Display* dpy, int screen, const int* attrib_list, int* nelements);
  GLXContext glXCreateNewContext_Hook(
      ::Display* dpy,
      GLXFBConfig config,
      int render_type,
      GLXContext share_list,
      Bool direct);
  GLXPbuffer glXCreatePbuffer_Hook(::Display* dpy, GLXFBConfig config, const int* attrib_list);
  GLXPixmap
  glXCreatePixmap_Hook(::Display* dpy, GLXFBConfig config, Pixmap pixmap, const int* attrib_list);
  GLXWindow
  glXCreateWindow_Hook(::Display* dpy, GLXFBConfig config, Window win, const int* attrib_list);
  void glXDestroyPbuffer_Hook(::Display* dpy, GLXPbuffer pbuf);
  void glXDestroyPixmap_Hook(::Display* dpy, GLXPixmap pixmap);
  void glXDestroyWindow_Hook(::Display* dpy, GLXWindow win);
  GLXDrawable glXGetCurrentReadDrawable_Hook(void);
  int glXGetFBConfigAttrib_Hook(::Display* dpy, GLXFBConfig config, int attribute, int* value);
  GLXFBConfig* glXGetFBConfigs_Hook(::Display* dpy, int screen, int* nelements);
  void glXGetSelectedEvent_Hook(::Display* dpy, GLXDrawable draw, unsigned long* event_mask);
  XVisualInfo* glXGetVisualFromFBConfig_Hook(::Display* dpy, GLXFBConfig config);
  Bool glXMakeContextCurrent_Hook(
      ::Display* display,
      GLXDrawable draw,
      GLXDrawable read,
      GLXContext ctx);
  int glXQueryContext_Hook(::Display* dpy, GLXContext ctx, int attribute, int* value);
  void glXQueryDrawable_Hook(::Display* dpy, GLXDrawable draw, int attribute, unsigned int* value);
  void glXSelectEvent_Hook(::Display* dpy, GLXDrawable draw, unsigned long event_mask);

  // GLX_VERSION_1_4
  // We don't do hooking of this.

  // GLX_ARB_create_context
  GLXContext glXCreateContextAttribsARB_Hook(
      Display* dpy,
      GLXFBConfig config,
      GLXContext share_context,
      Bool direct,
      const int* attrib_list);

  // GLX_EXT_swap_control
  void glXSwapIntervalEXT_Hook(::Display* dpy, GLXDrawable drawable, int interval);

  // GLX_OML_sync_control
  Bool glXGetMscRateOML_Hook(
      ::Display* dpy,
      GLXDrawable drawable,
      int32_t* numerator,
      int32_t* denominator);
  Bool glXGetSyncValuesOML_Hook(
      ::Display* dpy,
      GLXDrawable drawable,
      int64_t* ust,
      int64_t* msc,
      int64_t* sbc);
  int64_t glXSwapBuffersMscOML_Hook(
      ::Display* dpy,
      GLXDrawable drawable,
      int64_t target_msc,
      int64_t divisor,
      int64_t remainder);
  Bool glXWaitForMscOML_Hook(
      ::Display* dpy,
      GLXDrawable drawable,
      int64_t target_msc,
      int64_t divisor,
      int64_t remainder,
      int64_t* ust,
      int64_t* msc,
      int64_t* sbc);
  Bool glXWaitForSbcOML_Hook(
      ::Display* dpy,
      GLXDrawable drawable,
      int64_t target_sbc,
      int64_t* ust,
      int64_t* msc,
      int64_t* sbc);

  // GLX_MESA_swap_control
  int glXGetSwapIntervalMESA_Hook();
  int glXSwapIntervalMESA_Hook(unsigned int interval);

#endif // GLE_GLX_ENABLED

#endif // #if defined(GLE_HOOKING_ENABLED)

  // GL_VERSION_1_1
  // These are not represented by function pointers.

  // GL_VERSION_1_2
  PFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D_Impl;
  PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements_Impl;
  PFNGLTEXIMAGE3DPROC glTexImage3D_Impl;
  PFNGLTEXSUBIMAGE3DPROC glTexSubImage3D_Impl;

  // GL_VERSION_1_2 deprecated functions
  /* Not currently supported
  PFNGLCOLORTABLEPROC glColorTable_Impl;
  PFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv_Impl;
  PFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv_Impl;
  PFNGLCOPYCOLORTABLEPROC glCopyColorTable_Impl;
  PFNGLGETCOLORTABLEPROC glGetColorTable_Impl;
  PFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv_Impl;
  PFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv_Impl;
  PFNGLCOLORSUBTABLEPROC glColorSubTable_Impl;
  PFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable_Impl;
  PFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D_Impl;
  PFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D_Impl;
  PFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf_Impl;
  PFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv_Impl;
  PFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri_Impl;
  PFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv_Impl;
  PFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D_Impl;
  PFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D_Impl;
  PFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter_Impl;
  PFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv_Impl;
  PFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv_Impl;
  PFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter_Impl;
  PFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D_Impl;
  PFNGLGETHISTOGRAMPROC glGetHistogram_Impl;
  PFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv_Impl;
  PFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv_Impl;
  PFNGLGETMINMAXPROC glGetMinmax_Impl;
  PFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv_Impl;
  PFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv_Impl;
  PFNGLHISTOGRAMPROC glHistogram_Impl;
  PFNGLMINMAXPROC glMinmax_Impl;
  PFNGLRESETHISTOGRAMPROC glResetHistogram_Impl;
  PFNGLRESETMINMAXPROC glResetMinmax_Impl;
  */

  // GL_VERSION_1_3
  PFNGLACTIVETEXTUREPROC glActiveTexture_Impl;
  PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture_Impl;
  PFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D_Impl;
  PFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D_Impl;
  PFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D_Impl;
  PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D_Impl;
  PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D_Impl;
  PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D_Impl;
  PFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage_Impl;
  PFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd_Impl;
  PFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf_Impl;
  PFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd_Impl;
  PFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf_Impl;
  PFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d_Impl;
  PFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv_Impl;
  PFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f_Impl;
  PFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv_Impl;
  PFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i_Impl;
  PFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv_Impl;
  PFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s_Impl;
  PFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv_Impl;
  PFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d_Impl;
  PFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv_Impl;
  PFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f_Impl;
  PFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv_Impl;
  PFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i_Impl;
  PFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv_Impl;
  PFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s_Impl;
  PFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv_Impl;
  PFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d_Impl;
  PFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv_Impl;
  PFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f_Impl;
  PFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv_Impl;
  PFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i_Impl;
  PFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv_Impl;
  PFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s_Impl;
  PFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv_Impl;
  PFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d_Impl;
  PFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv_Impl;
  PFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f_Impl;
  PFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv_Impl;
  PFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i_Impl;
  PFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv_Impl;
  PFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s_Impl;
  PFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv_Impl;
  PFNGLSAMPLECOVERAGEPROC glSampleCoverage_Impl;

  // GL_VERSION_1_4
  PFNGLBLENDCOLORPROC glBlendColor_Impl;
  PFNGLBLENDEQUATIONPROC glBlendEquation_Impl;
  PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate_Impl;
  PFNGLFOGCOORDPOINTERPROC glFogCoordPointer_Impl;
  PFNGLFOGCOORDDPROC glFogCoordd_Impl;
  PFNGLFOGCOORDDVPROC glFogCoorddv_Impl;
  PFNGLFOGCOORDFPROC glFogCoordf_Impl;
  PFNGLFOGCOORDFVPROC glFogCoordfv_Impl;
  PFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays_Impl;
  PFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements_Impl;
  PFNGLPOINTPARAMETERFPROC glPointParameterf_Impl;
  PFNGLPOINTPARAMETERFVPROC glPointParameterfv_Impl;
  PFNGLPOINTPARAMETERIPROC glPointParameteri_Impl;
  PFNGLPOINTPARAMETERIVPROC glPointParameteriv_Impl;
  PFNGLSECONDARYCOLOR3BPROC glSecondaryColor3b_Impl;
  PFNGLSECONDARYCOLOR3BVPROC glSecondaryColor3bv_Impl;
  PFNGLSECONDARYCOLOR3DPROC glSecondaryColor3d_Impl;
  PFNGLSECONDARYCOLOR3DVPROC glSecondaryColor3dv_Impl;
  PFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f_Impl;
  PFNGLSECONDARYCOLOR3FVPROC glSecondaryColor3fv_Impl;
  PFNGLSECONDARYCOLOR3IPROC glSecondaryColor3i_Impl;
  PFNGLSECONDARYCOLOR3IVPROC glSecondaryColor3iv_Impl;
  PFNGLSECONDARYCOLOR3SPROC glSecondaryColor3s_Impl;
  PFNGLSECONDARYCOLOR3SVPROC glSecondaryColor3sv_Impl;
  PFNGLSECONDARYCOLOR3UBPROC glSecondaryColor3ub_Impl;
  PFNGLSECONDARYCOLOR3UBVPROC glSecondaryColor3ubv_Impl;
  PFNGLSECONDARYCOLOR3UIPROC glSecondaryColor3ui_Impl;
  PFNGLSECONDARYCOLOR3UIVPROC glSecondaryColor3uiv_Impl;
  PFNGLSECONDARYCOLOR3USPROC glSecondaryColor3us_Impl;
  PFNGLSECONDARYCOLOR3USVPROC glSecondaryColor3usv_Impl;
  PFNGLSECONDARYCOLORPOINTERPROC glSecondaryColorPointer_Impl;
  PFNGLWINDOWPOS2DPROC glWindowPos2d_Impl;
  PFNGLWINDOWPOS2DVPROC glWindowPos2dv_Impl;
  PFNGLWINDOWPOS2FPROC glWindowPos2f_Impl;
  PFNGLWINDOWPOS2FVPROC glWindowPos2fv_Impl;
  PFNGLWINDOWPOS2IPROC glWindowPos2i_Impl;
  PFNGLWINDOWPOS2IVPROC glWindowPos2iv_Impl;
  PFNGLWINDOWPOS2SPROC glWindowPos2s_Impl;
  PFNGLWINDOWPOS2SVPROC glWindowPos2sv_Impl;
  PFNGLWINDOWPOS3DPROC glWindowPos3d_Impl;
  PFNGLWINDOWPOS3DVPROC glWindowPos3dv_Impl;
  PFNGLWINDOWPOS3FPROC glWindowPos3f_Impl;
  PFNGLWINDOWPOS3FVPROC glWindowPos3fv_Impl;
  PFNGLWINDOWPOS3IPROC glWindowPos3i_Impl;
  PFNGLWINDOWPOS3IVPROC glWindowPos3iv_Impl;
  PFNGLWINDOWPOS3SPROC glWindowPos3s_Impl;
  PFNGLWINDOWPOS3SVPROC glWindowPos3sv_Impl;

  // GL_VERSION_1_5
  PFNGLBEGINQUERYPROC glBeginQuery_Impl;
  PFNGLBINDBUFFERPROC glBindBuffer_Impl;
  PFNGLBUFFERDATAPROC glBufferData_Impl;
  PFNGLBUFFERSUBDATAPROC glBufferSubData_Impl;
  PFNGLDELETEBUFFERSPROC glDeleteBuffers_Impl;
  PFNGLDELETEQUERIESPROC glDeleteQueries_Impl;
  PFNGLENDQUERYPROC glEndQuery_Impl;
  PFNGLGENBUFFERSPROC glGenBuffers_Impl;
  PFNGLGENQUERIESPROC glGenQueries_Impl;
  PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv_Impl;
  PFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv_Impl;
  PFNGLGETBUFFERSUBDATAPROC glGetBufferSubData_Impl;
  PFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv_Impl;
  PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv_Impl;
  PFNGLGETQUERYIVPROC glGetQueryiv_Impl;
  PFNGLISBUFFERPROC glIsBuffer_Impl;
  PFNGLISQUERYPROC glIsQuery_Impl;
  PFNGLMAPBUFFERPROC glMapBuffer_Impl;
  PFNGLUNMAPBUFFERPROC glUnmapBuffer_Impl;

  // GL_VERSION_2_0
  PFNGLATTACHSHADERPROC glAttachShader_Impl;
  PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation_Impl;
  PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate_Impl;
  PFNGLCOMPILESHADERPROC glCompileShader_Impl;
  PFNGLCREATEPROGRAMPROC glCreateProgram_Impl;
  PFNGLCREATESHADERPROC glCreateShader_Impl;
  PFNGLDELETEPROGRAMPROC glDeleteProgram_Impl;
  PFNGLDELETESHADERPROC glDeleteShader_Impl;
  PFNGLDETACHSHADERPROC glDetachShader_Impl;
  PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray_Impl;
  PFNGLDRAWBUFFERSPROC glDrawBuffers_Impl;
  PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray_Impl;
  PFNGLGETACTIVEATTRIBPROC glGetActiveAttrib_Impl;
  PFNGLGETACTIVEUNIFORMPROC glGetActiveUniform_Impl;
  PFNGLGETATTACHEDSHADERSPROC glGetAttachedShaders_Impl;
  PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation_Impl;
  PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog_Impl;
  PFNGLGETPROGRAMIVPROC glGetProgramiv_Impl;
  PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog_Impl;
  PFNGLGETSHADERSOURCEPROC glGetShaderSource_Impl;
  PFNGLGETSHADERIVPROC glGetShaderiv_Impl;
  PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation_Impl;
  PFNGLGETUNIFORMFVPROC glGetUniformfv_Impl;
  PFNGLGETUNIFORMIVPROC glGetUniformiv_Impl;
  PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv_Impl;
  PFNGLGETVERTEXATTRIBDVPROC glGetVertexAttribdv_Impl;
  PFNGLGETVERTEXATTRIBFVPROC glGetVertexAttribfv_Impl;
  PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv_Impl;
  PFNGLISPROGRAMPROC glIsProgram_Impl;
  PFNGLISSHADERPROC glIsShader_Impl;
  PFNGLLINKPROGRAMPROC glLinkProgram_Impl;
  PFNGLSHADERSOURCEPROC glShaderSource_Impl;
  PFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate_Impl;
  PFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate_Impl;
  PFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate_Impl;
  PFNGLUNIFORM1FPROC glUniform1f_Impl;
  PFNGLUNIFORM1FVPROC glUniform1fv_Impl;
  PFNGLUNIFORM1IPROC glUniform1i_Impl;
  PFNGLUNIFORM1IVPROC glUniform1iv_Impl;
  PFNGLUNIFORM2FPROC glUniform2f_Impl;
  PFNGLUNIFORM2FVPROC glUniform2fv_Impl;
  PFNGLUNIFORM2IPROC glUniform2i_Impl;
  PFNGLUNIFORM2IVPROC glUniform2iv_Impl;
  PFNGLUNIFORM3FPROC glUniform3f_Impl;
  PFNGLUNIFORM3FVPROC glUniform3fv_Impl;
  PFNGLUNIFORM3IPROC glUniform3i_Impl;
  PFNGLUNIFORM3IVPROC glUniform3iv_Impl;
  PFNGLUNIFORM4FPROC glUniform4f_Impl;
  PFNGLUNIFORM4FVPROC glUniform4fv_Impl;
  PFNGLUNIFORM4IPROC glUniform4i_Impl;
  PFNGLUNIFORM4IVPROC glUniform4iv_Impl;
  PFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv_Impl;
  PFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv_Impl;
  PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv_Impl;
  PFNGLUSEPROGRAMPROC glUseProgram_Impl;
  PFNGLVALIDATEPROGRAMPROC glValidateProgram_Impl;
  PFNGLVERTEXATTRIB1DPROC glVertexAttrib1d_Impl;
  PFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv_Impl;
  PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f_Impl;
  PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv_Impl;
  PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s_Impl;
  PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv_Impl;
  PFNGLVERTEXATTRIB2DPROC glVertexAttrib2d_Impl;
  PFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv_Impl;
  PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_Impl;
  PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv_Impl;
  PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s_Impl;
  PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv_Impl;
  PFNGLVERTEXATTRIB3DPROC glVertexAttrib3d_Impl;
  PFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv_Impl;
  PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_Impl;
  PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv_Impl;
  PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s_Impl;
  PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv_Impl;
  PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv_Impl;
  PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv_Impl;
  PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv_Impl;
  PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub_Impl;
  PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv_Impl;
  PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv_Impl;
  PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv_Impl;
  PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv_Impl;
  PFNGLVERTEXATTRIB4DPROC glVertexAttrib4d_Impl;
  PFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv_Impl;
  PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_Impl;
  PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv_Impl;
  PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv_Impl;
  PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s_Impl;
  PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv_Impl;
  PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv_Impl;
  PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv_Impl;
  PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv_Impl;
  PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer_Impl;

  // GL_VERSION_2_1
  PFNGLUNIFORMMATRIX2X3FVPROC glUniformMatrix2x3fv_Impl;
  PFNGLUNIFORMMATRIX2X4FVPROC glUniformMatrix2x4fv_Impl;
  PFNGLUNIFORMMATRIX3X2FVPROC glUniformMatrix3x2fv_Impl;
  PFNGLUNIFORMMATRIX3X4FVPROC glUniformMatrix3x4fv_Impl;
  PFNGLUNIFORMMATRIX4X2FVPROC glUniformMatrix4x2fv_Impl;
  PFNGLUNIFORMMATRIX4X3FVPROC glUniformMatrix4x3fv_Impl;

  // GL_VERSION_3_0
  PFNGLBEGINCONDITIONALRENDERPROC glBeginConditionalRender_Impl;
  PFNGLBEGINTRANSFORMFEEDBACKPROC glBeginTransformFeedback_Impl;
  PFNGLBINDFRAGDATALOCATIONPROC glBindFragDataLocation_Impl;
  PFNGLCLAMPCOLORPROC glClampColor_Impl;
  PFNGLCLEARBUFFERFIPROC glClearBufferfi_Impl;
  PFNGLCLEARBUFFERFVPROC glClearBufferfv_Impl;
  PFNGLCLEARBUFFERIVPROC glClearBufferiv_Impl;
  PFNGLCLEARBUFFERUIVPROC glClearBufferuiv_Impl;
  PFNGLCOLORMASKIPROC glColorMaski_Impl;
  PFNGLDISABLEIPROC glDisablei_Impl;
  PFNGLENABLEIPROC glEnablei_Impl;
  PFNGLENDCONDITIONALRENDERPROC glEndConditionalRender_Impl;
  PFNGLENDTRANSFORMFEEDBACKPROC glEndTransformFeedback_Impl;
  PFNGLBINDBUFFERRANGEPROC glBindBufferRange_Impl;
  PFNGLBINDBUFFERBASEPROC glBindBufferBase_Impl;
  PFNGLGETBOOLEANI_VPROC glGetBooleani_v_Impl;
  PFNGLGETINTEGERI_VPROC glGetIntegeri_v_Impl;
  PFNGLGETFRAGDATALOCATIONPROC glGetFragDataLocation_Impl;
  PFNGLGETSTRINGIPROC glGetStringi_Impl;
  PFNGLGETTEXPARAMETERIIVPROC glGetTexParameterIiv_Impl;
  PFNGLGETTEXPARAMETERIUIVPROC glGetTexParameterIuiv_Impl;
  PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glGetTransformFeedbackVarying_Impl;
  PFNGLGETUNIFORMUIVPROC glGetUniformuiv_Impl;
  PFNGLGETVERTEXATTRIBIIVPROC glGetVertexAttribIiv_Impl;
  PFNGLGETVERTEXATTRIBIUIVPROC glGetVertexAttribIuiv_Impl;
  PFNGLISENABLEDIPROC glIsEnabledi_Impl;
  PFNGLTEXPARAMETERIIVPROC glTexParameterIiv_Impl;
  PFNGLTEXPARAMETERIUIVPROC glTexParameterIuiv_Impl;
  PFNGLTRANSFORMFEEDBACKVARYINGSPROC glTransformFeedbackVaryings_Impl;
  PFNGLUNIFORM1UIPROC glUniform1ui_Impl;
  PFNGLUNIFORM1UIVPROC glUniform1uiv_Impl;
  PFNGLUNIFORM2UIPROC glUniform2ui_Impl;
  PFNGLUNIFORM2UIVPROC glUniform2uiv_Impl;
  PFNGLUNIFORM3UIPROC glUniform3ui_Impl;
  PFNGLUNIFORM3UIVPROC glUniform3uiv_Impl;
  PFNGLUNIFORM4UIPROC glUniform4ui_Impl;
  PFNGLUNIFORM4UIVPROC glUniform4uiv_Impl;
  PFNGLVERTEXATTRIBI1IPROC glVertexAttribI1i_Impl;
  PFNGLVERTEXATTRIBI1IVPROC glVertexAttribI1iv_Impl;
  PFNGLVERTEXATTRIBI1UIPROC glVertexAttribI1ui_Impl;
  PFNGLVERTEXATTRIBI1UIVPROC glVertexAttribI1uiv_Impl;
  PFNGLVERTEXATTRIBI2IPROC glVertexAttribI2i_Impl;
  PFNGLVERTEXATTRIBI2IVPROC glVertexAttribI2iv_Impl;
  PFNGLVERTEXATTRIBI2UIPROC glVertexAttribI2ui_Impl;
  PFNGLVERTEXATTRIBI2UIVPROC glVertexAttribI2uiv_Impl;
  PFNGLVERTEXATTRIBI3IPROC glVertexAttribI3i_Impl;
  PFNGLVERTEXATTRIBI3IVPROC glVertexAttribI3iv_Impl;
  PFNGLVERTEXATTRIBI3UIPROC glVertexAttribI3ui_Impl;
  PFNGLVERTEXATTRIBI3UIVPROC glVertexAttribI3uiv_Impl;
  PFNGLVERTEXATTRIBI4BVPROC glVertexAttribI4bv_Impl;
  PFNGLVERTEXATTRIBI4IPROC glVertexAttribI4i_Impl;
  PFNGLVERTEXATTRIBI4IVPROC glVertexAttribI4iv_Impl;
  PFNGLVERTEXATTRIBI4SVPROC glVertexAttribI4sv_Impl;
  PFNGLVERTEXATTRIBI4UBVPROC glVertexAttribI4ubv_Impl;
  PFNGLVERTEXATTRIBI4UIPROC glVertexAttribI4ui_Impl;
  PFNGLVERTEXATTRIBI4UIVPROC glVertexAttribI4uiv_Impl;
  PFNGLVERTEXATTRIBI4USVPROC glVertexAttribI4usv_Impl;
  PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer_Impl;

  // GL_VERSION_3_1
  PFNGLDRAWARRAYSINSTANCEDPROC glDrawArraysInstanced_Impl;
  PFNGLDRAWELEMENTSINSTANCEDPROC glDrawElementsInstanced_Impl;
  PFNGLPRIMITIVERESTARTINDEXPROC glPrimitiveRestartIndex_Impl;
  PFNGLTEXBUFFERPROC glTexBuffer_Impl;

  // GL_VERSION_3_2
  PFNGLFRAMEBUFFERTEXTUREPROC glFramebufferTexture_Impl;
  PFNGLGETBUFFERPARAMETERI64VPROC glGetBufferParameteri64v_Impl;
  PFNGLGETINTEGER64I_VPROC glGetInteger64i_v_Impl;

  // GL_VERSION_3_3
  PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor_Impl;

  // GL_VERSION_4_0
  PFNGLBLENDEQUATIONSEPARATEIPROC glBlendEquationSeparatei_Impl;
  PFNGLBLENDEQUATIONIPROC glBlendEquationi_Impl;
  PFNGLBLENDFUNCSEPARATEIPROC glBlendFuncSeparatei_Impl;
  PFNGLBLENDFUNCIPROC glBlendFunci_Impl;
  PFNGLMINSAMPLESHADINGPROC glMinSampleShading_Impl;

  // GL_VERSION_4_2
  PFNGLMEMORYBARRIER glMemoryBarrier_Impl;

  // GL_VERSION_4_3
  PFNGLDISPATCHCOMPUTEPROC glDispatchCompute_Impl;
  PFNGLBINDIMAGETEXTUREPROC glBindImageTexture_Impl;

  // GL_AMD_debug_output
  PFNGLDEBUGMESSAGECALLBACKAMDPROC glDebugMessageCallbackAMD_Impl;
  PFNGLDEBUGMESSAGEENABLEAMDPROC glDebugMessageEnableAMD_Impl;
  PFNGLDEBUGMESSAGEINSERTAMDPROC glDebugMessageInsertAMD_Impl;
  PFNGLGETDEBUGMESSAGELOGAMDPROC glGetDebugMessageLogAMD_Impl;

#if defined(GLE_CGL_ENABLED)
  // GL_APPLE_aux_depth_stencil
  // (no functions)

  // GL_APPLE_client_storage
  // (no functions)

  // GL_APPLE_element_array
  PFNGLDRAWELEMENTARRAYAPPLEPROC glDrawElementArrayAPPLE_Impl;
  PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC glDrawRangeElementArrayAPPLE_Impl;
  PFNGLELEMENTPOINTERAPPLEPROC glElementPointerAPPLE_Impl;
  PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC glMultiDrawElementArrayAPPLE_Impl;
  PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC glMultiDrawRangeElementArrayAPPLE_Impl;

  // GL_APPLE_fence
  PFNGLDELETEFENCESAPPLEPROC glDeleteFencesAPPLE_Impl;
  PFNGLFINISHFENCEAPPLEPROC glFinishFenceAPPLE_Impl;
  PFNGLFINISHOBJECTAPPLEPROC glFinishObjectAPPLE_Impl;
  PFNGLGENFENCESAPPLEPROC glGenFencesAPPLE_Impl;
  PFNGLISFENCEAPPLEPROC glIsFenceAPPLE_Impl;
  PFNGLSETFENCEAPPLEPROC glSetFenceAPPLE_Impl;
  PFNGLTESTFENCEAPPLEPROC glTestFenceAPPLE_Impl;
  PFNGLTESTOBJECTAPPLEPROC glTestObjectAPPLE_Impl;

  // GL_APPLE_float_pixels
  // (no functions)

  // GL_APPLE_flush_buffer_range
  PFNGLBUFFERPARAMETERIAPPLEPROC glBufferParameteriAPPLE_Impl;
  PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC glFlushMappedBufferRangeAPPLE_Impl;

  // GL_APPLE_object_purgeable
  PFNGLGETOBJECTPARAMETERIVAPPLEPROC glGetObjectParameterivAPPLE_Impl;
  PFNGLOBJECTPURGEABLEAPPLEPROC glObjectPurgeableAPPLE_Impl;
  PFNGLOBJECTUNPURGEABLEAPPLEPROC glObjectUnpurgeableAPPLE_Impl;

  // GL_APPLE_pixel_buffer
  // (no functions)

  // GL_APPLE_rgb_422
  // (no functions)

  // GL_APPLE_row_bytes
  // (no functions)

  // GL_APPLE_specular_vector
  // (no functions)

  // GL_APPLE_texture_range
  PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC glGetTexParameterPointervAPPLE_Impl;
  PFNGLTEXTURERANGEAPPLEPROC glTextureRangeAPPLE_Impl;

  // GL_APPLE_transform_hint
  // (no functions)

  // GL_APPLE_vertex_array_object
  PFNGLBINDVERTEXARRAYAPPLEPROC glBindVertexArrayAPPLE_Impl;
  PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE_Impl;
  PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE_Impl;
  PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE_Impl;

  // GL_APPLE_vertex_array_range
  PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC glFlushVertexArrayRangeAPPLE_Impl;
  PFNGLVERTEXARRAYPARAMETERIAPPLEPROC glVertexArrayParameteriAPPLE_Impl;
  PFNGLVERTEXARRAYRANGEAPPLEPROC glVertexArrayRangeAPPLE_Impl;

  // GL_APPLE_vertex_program_evaluators
  PFNGLDISABLEVERTEXATTRIBAPPLEPROC glDisableVertexAttribAPPLE_Impl;
  PFNGLENABLEVERTEXATTRIBAPPLEPROC glEnableVertexAttribAPPLE_Impl;
  PFNGLISVERTEXATTRIBENABLEDAPPLEPROC glIsVertexAttribEnabledAPPLE_Impl;
  PFNGLMAPVERTEXATTRIB1DAPPLEPROC glMapVertexAttrib1dAPPLE_Impl;
  PFNGLMAPVERTEXATTRIB1FAPPLEPROC glMapVertexAttrib1fAPPLE_Impl;
  PFNGLMAPVERTEXATTRIB2DAPPLEPROC glMapVertexAttrib2dAPPLE_Impl;
  PFNGLMAPVERTEXATTRIB2FAPPLEPROC glMapVertexAttrib2fAPPLE_Impl;
#endif // GLE_CGL_ENABLED

  // GL_ARB_copy_buffer
  PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData_Impl;

  // GL_ARB_debug_output
  PFNGLDEBUGMESSAGECALLBACKARBPROC glDebugMessageCallbackARB_Impl;
  PFNGLDEBUGMESSAGECONTROLARBPROC glDebugMessageControlARB_Impl;
  PFNGLDEBUGMESSAGEINSERTARBPROC glDebugMessageInsertARB_Impl;
  PFNGLGETDEBUGMESSAGELOGARBPROC glGetDebugMessageLogARB_Impl;

  // GL_ARB_ES2_compatibility
  PFNGLCLEARDEPTHFPROC glClearDepthf_Impl;
  PFNGLDEPTHRANGEFPROC glDepthRangef_Impl;
  PFNGLGETSHADERPRECISIONFORMATPROC glGetShaderPrecisionFormat_Impl;
  PFNGLRELEASESHADERCOMPILERPROC glReleaseShaderCompiler_Impl;
  PFNGLSHADERBINARYPROC glShaderBinary_Impl;

  // GL_ARB_framebuffer_object
  PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer_Impl;
  PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer_Impl;
  PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer_Impl;
  PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus_Impl;
  PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers_Impl;
  PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers_Impl;
  PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer_Impl;
  PFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D_Impl;
  PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D_Impl;
  PFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D_Impl;
  PFNGLFRAMEBUFFERTEXTURELAYERPROC glFramebufferTextureLayer_Impl;
  PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers_Impl;
  PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers_Impl;
  PFNGLGENERATEMIPMAPPROC glGenerateMipmap_Impl;
  PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv_Impl;
  PFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv_Impl;
  PFNGLISFRAMEBUFFERPROC glIsFramebuffer_Impl;
  PFNGLISRENDERBUFFERPROC glIsRenderbuffer_Impl;
  PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage_Impl;
  PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample_Impl;

  // GL_ARB_framebuffer_sRGB
  // (no functions)

  // GL_ARB_texture_multisample
  PFNGLGETMULTISAMPLEFVPROC glGetMultisamplefv_Impl;
  PFNGLSAMPLEMASKIPROC glSampleMaski_Impl;
  PFNGLTEXIMAGE2DMULTISAMPLEPROC glTexImage2DMultisample_Impl;
  PFNGLTEXIMAGE3DMULTISAMPLEPROC glTexImage3DMultisample_Impl;

  // GL_ARB_texture_non_power_of_two
  // (no functions)

  // GL_ARB_texture_rectangle
  // (no functions)

  // GL_ARB_texture_storage
  PFNGLTEXSTORAGE1DPROC glTexStorage1D_Impl;
  PFNGLTEXSTORAGE2DPROC glTexStorage2D_Impl;
  PFNGLTEXSTORAGE3DPROC glTexStorage3D_Impl;
  PFNGLTEXTURESTORAGE1DEXTPROC glTextureStorage1DEXT_Impl;
  PFNGLTEXTURESTORAGE2DEXTPROC glTextureStorage2DEXT_Impl;
  PFNGLTEXTURESTORAGE3DEXTPROC glTextureStorage3DEXT_Impl;

  // GL_ARB_texture_storage_multisample
  PFNGLTEXSTORAGE2DMULTISAMPLEPROC glTexStorage2DMultisample_Impl;
  PFNGLTEXSTORAGE3DMULTISAMPLEPROC glTexStorage3DMultisample_Impl;
  PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC glTextureStorage2DMultisampleEXT_Impl;
  PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC glTextureStorage3DMultisampleEXT_Impl;

  // GL_ARB_timer_query
  PFNGLGETQUERYOBJECTI64VPROC glGetQueryObjecti64v_Impl;
  PFNGLGETQUERYOBJECTUI64VPROC glGetQueryObjectui64v_Impl;
  PFNGLQUERYCOUNTERPROC glQueryCounter_Impl;

  // GL_ARB_vertex_array_object
  PFNGLBINDVERTEXARRAYPROC glBindVertexArray_Impl;
  PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays_Impl;
  PFNGLGENVERTEXARRAYSPROC glGenVertexArrays_Impl;
  PFNGLISVERTEXARRAYPROC glIsVertexArray_Impl;

  // GL_EXT_draw_buffers2
  PFNGLCOLORMASKINDEXEDEXTPROC glColorMaskIndexedEXT_Impl;
  PFNGLDISABLEINDEXEDEXTPROC glDisableIndexedEXT_Impl;
  PFNGLENABLEINDEXEDEXTPROC glEnableIndexedEXT_Impl;
  PFNGLGETBOOLEANINDEXEDVEXTPROC glGetBooleanIndexedvEXT_Impl;
  PFNGLGETINTEGERINDEXEDVEXTPROC glGetIntegerIndexedvEXT_Impl;
  PFNGLISENABLEDINDEXEDEXTPROC glIsEnabledIndexedEXT_Impl;

  // GL_EXT_texture_filter_anisotropic
  // (no functions)

  // GL_KHR_debug
  PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback_Impl;
  PFNGLDEBUGMESSAGECONTROLPROC glDebugMessageControl_Impl;
  PFNGLDEBUGMESSAGEINSERTPROC glDebugMessageInsert_Impl;
  PFNGLGETDEBUGMESSAGELOGPROC glGetDebugMessageLog_Impl;
  PFNGLGETOBJECTLABELPROC glGetObjectLabel_Impl;
  PFNGLGETOBJECTPTRLABELPROC glGetObjectPtrLabel_Impl;
  PFNGLOBJECTLABELPROC glObjectLabel_Impl;
  PFNGLOBJECTPTRLABELPROC glObjectPtrLabel_Impl;
  PFNGLPOPDEBUGGROUPPROC glPopDebugGroup_Impl;
  PFNGLPUSHDEBUGGROUPPROC glPushDebugGroup_Impl;

  // GL_KHR_robust_buffer_access_behavior

  // GL_WIN_swap_hint
  PFNGLADDSWAPHINTRECTWINPROC glAddSwapHintRectWIN_Impl;

#if defined(GLE_WGL_ENABLED)
  // WGL
  // We don't declare pointers for these because we statically link to the implementations, same as
  // with the OpenGL 1.1 functions.
  // BOOL  wglCopyContext_Hook(HGLRC, HGLRC, UINT);
  // HGLRC wglCreateContext_Hook(HDC);
  // HGLRC wglCreateLayerContext_Hook(HDC, int);
  // BOOL  wglDeleteContext_Hook(HGLRC);
  // HGLRC wglGetCurrentContext_Hook(VOID);
  // HDC   wglGetCurrentDC_Hook(VOID);
  // PROC  wglGetProcAddress_Hook(LPCSTR);
  // BOOL  wglMakeCurrent_Hook(HDC, HGLRC);
  // BOOL  wglShareLists_Hook(HGLRC, HGLRC);
  // BOOL  wglUseFontBitmapsA_Hook(HDC, DWORD, DWORD, DWORD);
  // BOOL  wglUseFontBitmapsW_Hook(HDC, DWORD, DWORD, DWORD);
  // BOOL  wglUseFontOutlinesA_Hook(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT, int,
  // LPGLYPHMETRICSFLOAT); BOOL  wglUseFontOutlinesW_Hook(HDC, DWORD, DWORD, DWORD, FLOAT, FLOAT,
  // int, LPGLYPHMETRICSFLOAT); BOOL  wglDescribeLayerPlane_Hook(HDC, int, int, UINT,
  // LPLAYERPLANEDESCRIPTOR); int   wglSetLayerPaletteEntries_Hook(HDC, int, int, int, CONST
  // COLORREF *); int   wglGetLayerPaletteEntries_Hook(HDC, int, int, int, COLORREF *); BOOL
  // wglRealizeLayerPalette_Hook(HDC, int, BOOL); BOOL  wglSwapLayerBuffers_Hook(HDC, UINT); DWORD
  // wglSwapMultipleBuffers_Hook(UINT, CONST WGLSWAP *);

#if 0
        PFNWGLCOPYCONTEXTPROC            wglCopyContext_Impl;
        PFNWGLCREATECONTEXTPROC          wglCreateContext_Impl;
        PFNWGLCREATELAYERCONTEXTPROC     wglCreateLayerContext_Impl;
        PFNWGLDELETECONTEXTPROC          wglDeleteContext_Impl;
        PFNWGLGETCURRENTCONTEXTPROC      wglGetCurrentContext_Impl;
        PFNWGLGETCURRENTDCPROC           wglGetCurrentDC_Impl;
        PFNWGLGETPROCADDRESSPROC         wglGetProcAddress_Impl;
        PFNWGLMAKECURRENTPROC            wglMakeCurrent_Impl;
        PFNWGLSHARELISTSPROC             wglShareLists_Impl;
        PFNWGLUSEFONTBITMAPSAPROC        wglUseFontBitmapsA_Impl;
        PFNWGLUSEFONTBITMAPSWPROC        wglUseFontBitmapsW_Impl;
        PFNWGLUSEFONTOUTLINESAPROC       wglUseFontOutlinesA_Impl;
        PFNWGLUSEFONTOUTLINESWPROC       wglUseFontOutlinesW_Impl;
        PFNWGLDESCRIBELAYERPLANEPROC     wglDescribeLayerPlane_Impl;
        PFNWGLSETLAYERPALETTEENTRIESPROC wglSetLayerPaletteEntries_Impl;
        PFNWGLGETLAYERPALETTEENTRIESPROC wglGetLayerPaletteEntries_Impl;
        PFNWGLREALIZELAYERPALETTEPROC    wglRealizeLayerPalette_Impl;
        PFNWGLSWAPLAYERBUFFERSPROC       wglSwapLayerBuffers_Impl;
        PFNWGLSWAPMULTIPLEBUFFERSPROC    wglSwapMultipleBuffers_Impl;
#endif

  // WGL_ARB_buffer_region
  PFNWGLCREATEBUFFERREGIONARBPROC wglCreateBufferRegionARB_Impl;
  PFNWGLDELETEBUFFERREGIONARBPROC wglDeleteBufferRegionARB_Impl;
  PFNWGLSAVEBUFFERREGIONARBPROC wglSaveBufferRegionARB_Impl;
  PFNWGLRESTOREBUFFERREGIONARBPROC wglRestoreBufferRegionARB_Impl;

  // WGL_ARB_extensions_string
  PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB_Impl;

  // WGL_ARB_pixel_format
  PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB_Impl;
  PFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB_Impl;
  PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB_Impl;

  // WGL_ARB_make_current_read
  PFNWGLMAKECONTEXTCURRENTARBPROC wglMakeContextCurrentARB_Impl;
  PFNWGLGETCURRENTREADDCARBPROC wglGetCurrentReadDCARB_Impl;

  // WGL_ARB_pbuffer
  PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB_Impl;
  PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB_Impl;
  PFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB_Impl;
  PFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB_Impl;
  PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB_Impl;

  // WGL_ARB_render_texture
  PFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB_Impl;
  PFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB_Impl;
  PFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB_Impl;

  // WGL_ARB_pixel_format_float
  // (no functions)

  // WGL_ARB_framebuffer_sRGB
  // (no functions)

  // WGL_NV_present_video
  PFNWGLENUMERATEVIDEODEVICESNVPROC wglEnumerateVideoDevicesNV_Impl;
  PFNWGLBINDVIDEODEVICENVPROC wglBindVideoDeviceNV_Impl;
  PFNWGLQUERYCURRENTCONTEXTNVPROC wglQueryCurrentContextNV_Impl;

  // WGL_ARB_create_context
  PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB_Impl;

  // WGL_ARB_create_context_profile
  // (no functions)

  // WGL_ARB_create_context_robustness
  // (no functions)

  // WGL_EXT_extensions_string
  PFNWGLGETEXTENSIONSSTRINGEXTPROC wglGetExtensionsStringEXT_Impl;

  // WGL_EXT_swap_control
  PFNWGLGETSWAPINTERVALEXTPROC wglGetSwapIntervalEXT_Impl;
  PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT_Impl;

  // WGL_OML_sync_control
  PFNWGLGETSYNCVALUESOMLPROC wglGetSyncValuesOML_Impl;
  PFNWGLGETMSCRATEOMLPROC wglGetMscRateOML_Impl;
  PFNWGLSWAPBUFFERSMSCOMLPROC wglSwapBuffersMscOML_Impl;
  PFNWGLSWAPLAYERBUFFERSMSCOMLPROC wglSwapLayerBuffersMscOML_Impl;
  PFNWGLWAITFORMSCOMLPROC wglWaitForMscOML_Impl;
  PFNWGLWAITFORSBCOMLPROC wglWaitForSbcOML_Impl;

  // WGL_NV_video_output
  PFNWGLGETVIDEODEVICENVPROC wglGetVideoDeviceNV_Impl;
  PFNWGLRELEASEVIDEODEVICENVPROC wglReleaseVideoDeviceNV_Impl;
  PFNWGLBINDVIDEOIMAGENVPROC wglBindVideoImageNV_Impl;
  PFNWGLRELEASEVIDEOIMAGENVPROC wglReleaseVideoImageNV_Impl;
  PFNWGLSENDPBUFFERTOVIDEONVPROC wglSendPbufferToVideoNV_Impl;
  PFNWGLGETVIDEOINFONVPROC wglGetVideoInfoNV_Impl;

  // WGL_NV_swap_group
  PFNWGLJOINSWAPGROUPNVPROC wglJoinSwapGroupNV_Impl;
  PFNWGLBINDSWAPBARRIERNVPROC wglBindSwapBarrierNV_Impl;
  PFNWGLQUERYSWAPGROUPNVPROC wglQuerySwapGroupNV_Impl;
  PFNWGLQUERYMAXSWAPGROUPSNVPROC wglQueryMaxSwapGroupsNV_Impl;
  PFNWGLQUERYFRAMECOUNTNVPROC wglQueryFrameCountNV_Impl;
  PFNWGLRESETFRAMECOUNTNVPROC wglResetFrameCountNV_Impl;

  // WGL_NV_video_capture
  PFNWGLBINDVIDEOCAPTUREDEVICENVPROC wglBindVideoCaptureDeviceNV_Impl;
  PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC wglEnumerateVideoCaptureDevicesNV_Impl;
  PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC wglLockVideoCaptureDeviceNV_Impl;
  PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC wglQueryVideoCaptureDeviceNV_Impl;
  PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC wglReleaseVideoCaptureDeviceNV_Impl;

  // WGL_NV_copy_image
  PFNWGLCOPYIMAGESUBDATANVPROC wglCopyImageSubDataNV_Impl;

  // WGL_NV_DX_interop
  PFNWGLDXCLOSEDEVICENVPROC wglDXCloseDeviceNV_Impl;
  PFNWGLDXLOCKOBJECTSNVPROC wglDXLockObjectsNV_Impl;
  PFNWGLDXOBJECTACCESSNVPROC wglDXObjectAccessNV_Impl;
  PFNWGLDXOPENDEVICENVPROC wglDXOpenDeviceNV_Impl;
  PFNWGLDXREGISTEROBJECTNVPROC wglDXRegisterObjectNV_Impl;
  PFNWGLDXSETRESOURCESHAREHANDLENVPROC wglDXSetResourceShareHandleNV_Impl;
  PFNWGLDXUNLOCKOBJECTSNVPROC wglDXUnlockObjectsNV_Impl;
  PFNWGLDXUNREGISTEROBJECTNVPROC wglDXUnregisterObjectNV_Impl;

#endif // GLE_WGL_ENABLED

#if defined(GLE_GLX_ENABLED)
  // GLX_VERSION_1_1
  // We don't create any pointers, because we assume these functions are always present.

  // GLX_VERSION_1_2
  PFNGLXGETCURRENTDISPLAYPROC glXGetCurrentDisplay_Impl;

  // GLX_VERSION_1_3
  PFNGLXCHOOSEFBCONFIGPROC glXChooseFBConfig_Impl;
  PFNGLXCREATENEWCONTEXTPROC glXCreateNewContext_Impl;
  PFNGLXCREATEPBUFFERPROC glXCreatePbuffer_Impl;
  PFNGLXCREATEPIXMAPPROC glXCreatePixmap_Impl;
  PFNGLXCREATEWINDOWPROC glXCreateWindow_Impl;
  PFNGLXDESTROYPBUFFERPROC glXDestroyPbuffer_Impl;
  PFNGLXDESTROYPIXMAPPROC glXDestroyPixmap_Impl;
  PFNGLXDESTROYWINDOWPROC glXDestroyWindow_Impl;
  PFNGLXGETCURRENTREADDRAWABLEPROC glXGetCurrentReadDrawable_Impl;
  PFNGLXGETFBCONFIGATTRIBPROC glXGetFBConfigAttrib_Impl;
  PFNGLXGETFBCONFIGSPROC glXGetFBConfigs_Impl;
  PFNGLXGETSELECTEDEVENTPROC glXGetSelectedEvent_Impl;
  PFNGLXGETVISUALFROMFBCONFIGPROC glXGetVisualFromFBConfig_Impl;
  PFNGLXMAKECONTEXTCURRENTPROC glXMakeContextCurrent_Impl;
  PFNGLXQUERYCONTEXTPROC glXQueryContext_Impl;
  PFNGLXQUERYDRAWABLEPROC glXQueryDrawable_Impl;
  PFNGLXSELECTEVENTPROC glXSelectEvent_Impl;

  // GLX_VERSION_1_4
  // Nothing to declare

  // GLX_ARB_create_context
  PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB_Impl;

  // GLX_EXT_swap_control
  PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT_Impl;

  // GLX_OML_sync_control
  PFNGLXGETMSCRATEOMLPROC glXGetMscRateOML_Impl;
  PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML_Impl;
  PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML_Impl;
  PFNGLXWAITFORMSCOMLPROC glXWaitForMscOML_Impl;
  PFNGLXWAITFORSBCOMLPROC glXWaitForSbcOML_Impl;

  // GLX_MESA_swap_control
  PFNGLXGETSWAPINTERVALMESAPROC glXGetSwapIntervalMESA_Impl;
  PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESA_Impl;

#endif // GLE_GLX_ENABLED

  // Boolean extension support indicators. Each of these identifies the
  // presence or absence of the given extension. A better solution here
  // might be to use an STL map<const char*, bool>.
  bool gle_AMD_debug_output;
  // bool gle_AMD_performance_monitor;
  bool gle_APPLE_aux_depth_stencil;
  bool gle_APPLE_client_storage;
  bool gle_APPLE_element_array;
  bool gle_APPLE_fence;
  bool gle_APPLE_float_pixels;
  bool gle_APPLE_flush_buffer_range;
  bool gle_APPLE_object_purgeable;
  bool gle_APPLE_pixel_buffer;
  bool gle_APPLE_rgb_422;
  bool gle_APPLE_row_bytes;
  bool gle_APPLE_specular_vector;
  bool gle_APPLE_texture_range;
  bool gle_APPLE_transform_hint;
  bool gle_APPLE_vertex_array_object;
  bool gle_APPLE_vertex_array_range;
  bool gle_APPLE_vertex_program_evaluators;
  bool gle_APPLE_ycbcr_422;
  bool gle_ARB_copy_buffer;
  bool gle_ARB_debug_output;
  bool gle_ARB_depth_buffer_float;
  // bool gle_ARB_direct_state_access;
  bool gle_ARB_ES2_compatibility;
  bool gle_ARB_framebuffer_object;
  bool gle_ARB_framebuffer_sRGB;
  bool gle_ARB_texture_multisample;
  bool gle_ARB_texture_non_power_of_two;
  bool gle_ARB_texture_rectangle;
  bool gle_ARB_texture_storage;
  bool gle_ARB_texture_storage_multisample;
  bool gle_ARB_timer_query;
  bool gle_ARB_vertex_array_object;
  // bool gle_ARB_vertex_attrib_binding;
  bool gle_EXT_draw_buffers2;
  bool gle_EXT_texture_compression_s3tc;
  bool gle_EXT_texture_filter_anisotropic;
  bool gle_EXT_texture_sRGB;
  // bool gle_KHR_context_flush_control;
  bool gle_KHR_debug;
  // bool gle_KHR_robust_buffer_access_behavior;
  // bool gle_KHR_robustness;
  bool gle_WIN_swap_hint;

#if defined(GLE_WGL_ENABLED)
  bool gle_WGL_ARB_buffer_region;
  bool gle_WGL_ARB_create_context;
  bool gle_WGL_ARB_create_context_profile;
  bool gle_WGL_ARB_create_context_robustness;
  bool gle_WGL_ARB_extensions_string;
  bool gle_WGL_ARB_framebuffer_sRGB;
  bool gle_WGL_ARB_make_current_read;
  bool gle_WGL_ARB_pbuffer;
  bool gle_WGL_ARB_pixel_format;
  bool gle_WGL_ARB_pixel_format_float;
  bool gle_WGL_ARB_render_texture;
  bool gle_WGL_ATI_render_texture_rectangle;
  bool gle_WGL_EXT_extensions_string;
  bool gle_WGL_EXT_swap_control;
  bool gle_WGL_NV_copy_image;
  bool gle_WGL_NV_DX_interop;
  bool gle_WGL_NV_DX_interop2;
  bool gle_WGL_NV_present_video;
  bool gle_WGL_NV_render_texture_rectangle;
  bool gle_WGL_NV_swap_group;
  bool gle_WGL_NV_video_capture;
  bool gle_WGL_NV_video_output;
  bool gle_WGL_OML_sync_control;
#elif defined(GLE_GLX_ENABLED)
  bool gle_GLX_ARB_create_context;
  bool gle_GLX_ARB_create_context_profile;
  bool gle_GLX_ARB_create_context_robustness;
  bool gle_GLX_EXT_swap_control;
  bool gle_GLX_OML_sync_control;
  bool gle_MESA_swap_control;
#endif

}; // class GLEContext

} // namespace OVR

#endif // OVR_CAPI_GLE_h