diff options
Diffstat (limited to 'LibOVR/Src/CAPI/GL/CAPI_GLE.cpp')
| -rw-r--r-- | LibOVR/Src/CAPI/GL/CAPI_GLE.cpp | 7884 |
1 files changed, 7884 insertions, 0 deletions
diff --git a/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp b/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp new file mode 100644 index 0000000..c41d745 --- /dev/null +++ b/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp @@ -0,0 +1,7884 @@ +/************************************************************************************ + +Filename : Render_GLE.cpp +Content : OpenGL Extensions support. Implements a stripped down glew-like + interface with some additional functionality. +Copyright : Copyright 2014 Oculus VR, LLC 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. + +************************************************************************************/ + +#include "CAPI_GLE.h" +#include "../../Kernel/OVR_Log.h" +#include <string.h> + + +#if defined(_WIN32) + #if !defined(WINAPI) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN 1 + #endif + #include <windows.h> + #endif + + #pragma comment(lib, "opengl32.lib") +#elif defined(__APPLE__) + #include <stdlib.h> + #include <string.h> + #include <AvailabilityMacros.h> + #include <dlfcn.h> +#endif + + + +//namespace OVR +//{ + // OVRTypeof + // Acts the same as the C++11 decltype expression, though with reduced requirements. + #if !defined(OVRTypeof) + #if defined(_MSC_VER) + #define OVRTypeof(x) decltype(x) // VS2010+ unilaterally supports decltype + #else + #define OVRTypeof(x) __typeof__(x) // Other compilers support decltype, but usually not unless C++11 support is present and explicitly enabled. + #endif + #endif + + + // GLELoadProc + // Macro which implements dynamically looking up and assigning an OpenGL function. + // + // Example usage: + // GLELoadProc(glCopyTexSubImage3D, glCopyTexSubImage3D); + // Expands to: + // gleCopyTexSubImage3D = (OVRTypeof(gleCopyTexSubImage3D)) GLEGetProcAddress("glCopyTexSubImage3D"); + + #define GLELoadProc(var, name) var = (OVRTypeof(var))GLEGetProcAddress(#name) + + + // Disable some #defines, as we need to call these functions directly. + #if defined(GLE_HOOKING_ENABLED) + #if defined(_WIN32) + #undef wglGetProcAddress + extern "C" { GLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc); } + #endif + + #undef glGetString + extern "C" { GLAPI const GLubyte * GLAPIENTRY glGetString(GLenum name); } + #endif + + + // Generic OpenGL GetProcAddress function interface. Maps to platform-specific functionality + // internally. On Windows this is equivalent to wglGetProcAddress as opposed to global GetProcAddress. + void* OVR::GLEGetProcAddress(const char* name) + { + #if defined(_WIN32) + return wglGetProcAddress(name); + + #elif defined(__APPLE__) + // Requires the OS 10.3 SDK or later. + static void* dlImage = NULL; + void* addr = nullptr; + + if(!dlImage) + dlImage = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY); + + if(dlImage) + addr = dlsym(dlImage, name); + + return addr; + + #elif defined(__ANDROID__) + return eglGetProcAddress(name); + + #else + // This was glXGetProcAddressARB in GLX versions prior to v1.4, but that was ten years ago. + return (void*)glXGetProcAddress((const GLubyte*)name); + #endif + } + + + + // Current context functionality + static OVR::GLEContext* GLECurrentContext = NULL; + + OVR::GLEContext* OVR::GLEContext::GetCurrentContext() + { + return GLECurrentContext; + } + + void OVR::GLEContext::SetCurrentContext(OVR::GLEContext* p) + { + GLECurrentContext = p; + } + + + + OVR::GLEContext::GLEContext() + : MajorVersion(0) + , MinorVersion(0) + , WholeVersion(0) + , IsGLES(false) + , IsCoreProfile(false) + , EnableHookGetError(true) + , PlatformMajorVersion(0) + , PlatformMinorVersion(0) + , PlatformWholeVersion(0) + { + // The following sequence is not thread-safe. Two threads could set the context to this at the same time. + if(GetCurrentContext() == NULL) + SetCurrentContext(this); + } + + + OVR::GLEContext::~GLEContext() + { + // Currently empty + } + + + void OVR::GLEContext::Init() + { + PlatformInit(); + + if(!IsInitialized()) + { + InitVersion(); + InitExtensionLoad(); + InitExtensionSupport(); + } + } + + + bool OVR::GLEContext::IsInitialized() const + { + return (MajorVersion != 0); + } + + + void OVR::GLEContext::Shutdown() + { + // This memset is valid only if this class has no virtual functions (similar to concept of POD). + // We cannot assert this because restrictions prevent us from using C++11 type traits here. + memset(this, 0, sizeof(GLEContext)); + } + + + void OVR::GLEContext::PlatformInit() + { + if(!IsPlatformInitialized()) + { + InitPlatformExtensionLoad(); + InitPlatformExtensionSupport(); + InitPlatformVersion(); + } + } + + + bool OVR::GLEContext::IsPlatformInitialized() const + { + return (PlatformMajorVersion != 0); + } + + + void OVR::GLEContext::InitVersion() + { + const char* version = (const char*)glGetString(GL_VERSION); + int fields = 0, major = 0, minor = 0; + bool isGLES = false; + + OVR_ASSERT(version); + if (version) + { + OVR_DEBUG_LOG(("GL_VERSION: %s", (const char*)version)); + + // Skip all leading non-digits before reading %d. + // Example GL_VERSION strings: + // "1.5 ATI-1.4.18" + // "OpenGL ES-CM 3.2" + OVR_DISABLE_MSVC_WARNING(4996) // "scanf may be unsafe" + fields = sscanf(version, isdigit(*version) ? "%d.%d" : "%*[^0-9]%d.%d", &major, &minor); + isGLES = (strstr(version, "OpenGL ES") != NULL); + OVR_RESTORE_MSVC_WARNING() + } + else + { + LogText("Warning: GL_VERSION was NULL\n"); + } + + // If two fields were not found, + if (fields != 2) + { + static_assert(sizeof(major) == sizeof(GLint), "type mis-match"); + + glGetIntegerv(GL_MAJOR_VERSION, &major); + glGetIntegerv(GL_MINOR_VERSION, &minor); + } + + // Write version data + MajorVersion = major; + MinorVersion = minor; + WholeVersion = (major * 100) + minor; + + GLint profileMask = 0; + if(WholeVersion >= 302) + { + // Older NVidia drivers have a bug with this on at least Windows. + // https://www.opengl.org/discussion_boards/showthread.php/171380-NVIDIA-drivers-not-returning-the-right-profile-mas + // A workaround could be to check for the GL_ARB_compatibility extension, which indicates if OpenGL is in compatibility mode, + // and if not then we are in core profile mode. On Apple another solution would be to use NSOpeNGLPixelFormat + // NSOpenGLView::pixelFormat to get the core profile attribute. + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &profileMask); + } + IsCoreProfile = (profileMask == GL_CONTEXT_CORE_PROFILE_BIT); // There's also GL_CONTEXT_COMPATIBILITY_PROFILE_BIT + IsGLES = isGLES; + } + + + void OVR::GLEContext::InitExtensionLoad() + { + // GL_VERSION_1_1 + // We don't load these but rather link to them directly. + + // GL_VERSION_1_2 + GLELoadProc(glCopyTexSubImage3D_Impl, glCopyTexSubImage3D); // This expands to a get proc address call (e.g. wglGetProcAddress on Windows). + GLELoadProc(glDrawRangeElements_Impl, glDrawRangeElements); + GLELoadProc(glTexImage3D_Impl, glTexImage3D); + GLELoadProc(glTexSubImage3D_Impl, glTexSubImage3D); + + // GL_VERSION_1_3 + GLELoadProc(glActiveTexture_Impl, glActiveTexture); + GLELoadProc(glClientActiveTexture_Impl, glClientActiveTexture); + GLELoadProc(glCompressedTexImage1D_Impl, glCompressedTexImage1D); + GLELoadProc(glCompressedTexImage2D_Impl, glCompressedTexImage2D); + GLELoadProc(glCompressedTexImage3D_Impl, glCompressedTexImage3D); + GLELoadProc(glCompressedTexSubImage1D_Impl, glCompressedTexSubImage1D); + GLELoadProc(glCompressedTexSubImage2D_Impl, glCompressedTexSubImage2D); + GLELoadProc(glCompressedTexSubImage3D_Impl, glCompressedTexSubImage3D); + GLELoadProc(glGetCompressedTexImage_Impl, glGetCompressedTexImage); + GLELoadProc(glLoadTransposeMatrixd_Impl, glLoadTransposeMatrixd); + GLELoadProc(glLoadTransposeMatrixf_Impl, glLoadTransposeMatrixf); + GLELoadProc(glMultTransposeMatrixd_Impl, glMultTransposeMatrixd); + GLELoadProc(glMultTransposeMatrixf_Impl, glMultTransposeMatrixf); + GLELoadProc(glMultiTexCoord1d_Impl, glMultiTexCoord1d); + GLELoadProc(glMultiTexCoord1dv_Impl, glMultiTexCoord1dv); + GLELoadProc(glMultiTexCoord1f_Impl, glMultiTexCoord1f); + GLELoadProc(glMultiTexCoord1fv_Impl, glMultiTexCoord1fv); + GLELoadProc(glMultiTexCoord1i_Impl, glMultiTexCoord1i); + GLELoadProc(glMultiTexCoord1iv_Impl, glMultiTexCoord1iv); + GLELoadProc(glMultiTexCoord1s_Impl, glMultiTexCoord1s); + GLELoadProc(glMultiTexCoord1sv_Impl, glMultiTexCoord1sv); + GLELoadProc(glMultiTexCoord2d_Impl, glMultiTexCoord2d); + GLELoadProc(glMultiTexCoord2dv_Impl, glMultiTexCoord2dv); + GLELoadProc(glMultiTexCoord2f_Impl, glMultiTexCoord2f); + GLELoadProc(glMultiTexCoord2fv_Impl, glMultiTexCoord2fv); + GLELoadProc(glMultiTexCoord2i_Impl, glMultiTexCoord2i); + GLELoadProc(glMultiTexCoord2iv_Impl, glMultiTexCoord2iv); + GLELoadProc(glMultiTexCoord2s_Impl, glMultiTexCoord2s); + GLELoadProc(glMultiTexCoord2sv_Impl, glMultiTexCoord2sv); + GLELoadProc(glMultiTexCoord3d_Impl, glMultiTexCoord3d); + GLELoadProc(glMultiTexCoord3dv_Impl, glMultiTexCoord3dv); + GLELoadProc(glMultiTexCoord3f_Impl, glMultiTexCoord3f); + GLELoadProc(glMultiTexCoord3fv_Impl, glMultiTexCoord3fv); + GLELoadProc(glMultiTexCoord3i_Impl, glMultiTexCoord3i); + GLELoadProc(glMultiTexCoord3iv_Impl, glMultiTexCoord3iv); + GLELoadProc(glMultiTexCoord3s_Impl, glMultiTexCoord3s); + GLELoadProc(glMultiTexCoord3sv_Impl, glMultiTexCoord3sv); + GLELoadProc(glMultiTexCoord4d_Impl, glMultiTexCoord4d); + GLELoadProc(glMultiTexCoord4dv_Impl, glMultiTexCoord4dv); + GLELoadProc(glMultiTexCoord4f_Impl, glMultiTexCoord4f); + GLELoadProc(glMultiTexCoord4fv_Impl, glMultiTexCoord4fv); + GLELoadProc(glMultiTexCoord4i_Impl, glMultiTexCoord4i); + GLELoadProc(glMultiTexCoord4iv_Impl, glMultiTexCoord4iv); + GLELoadProc(glMultiTexCoord4s_Impl, glMultiTexCoord4s); + GLELoadProc(glMultiTexCoord4sv_Impl, glMultiTexCoord4sv); + GLELoadProc(glSampleCoverage_Impl, glSampleCoverage); + + // GL_VERSION_1_4 + GLELoadProc(glBlendColor_Impl, glBlendColor); + GLELoadProc(glBlendEquation_Impl, glBlendEquation); + GLELoadProc(glBlendFuncSeparate_Impl, glBlendFuncSeparate); + GLELoadProc(glFogCoordPointer_Impl, glFogCoordPointer); + GLELoadProc(glFogCoordd_Impl, glFogCoordd); + GLELoadProc(glFogCoorddv_Impl, glFogCoorddv); + GLELoadProc(glFogCoordf_Impl, glFogCoordf); + GLELoadProc(glFogCoordfv_Impl, glFogCoordfv); + GLELoadProc(glMultiDrawArrays_Impl, glMultiDrawArrays); + GLELoadProc(glMultiDrawElements_Impl, glMultiDrawElements); + GLELoadProc(glPointParameterf_Impl, glPointParameterf); + GLELoadProc(glPointParameterfv_Impl, glPointParameterfv); + GLELoadProc(glPointParameteri_Impl, glPointParameteri); + GLELoadProc(glPointParameteriv_Impl, glPointParameteriv); + GLELoadProc(glSecondaryColor3b_Impl, glSecondaryColor3b); + GLELoadProc(glSecondaryColor3bv_Impl, glSecondaryColor3bv); + GLELoadProc(glSecondaryColor3d_Impl, glSecondaryColor3d); + GLELoadProc(glSecondaryColor3dv_Impl, glSecondaryColor3dv); + GLELoadProc(glSecondaryColor3f_Impl, glSecondaryColor3f); + GLELoadProc(glSecondaryColor3fv_Impl, glSecondaryColor3fv); + GLELoadProc(glSecondaryColor3i_Impl, glSecondaryColor3i); + GLELoadProc(glSecondaryColor3iv_Impl, glSecondaryColor3iv); + GLELoadProc(glSecondaryColor3s_Impl, glSecondaryColor3s); + GLELoadProc(glSecondaryColor3sv_Impl, glSecondaryColor3sv); + GLELoadProc(glSecondaryColor3ub_Impl, glSecondaryColor3ub); + GLELoadProc(glSecondaryColor3ubv_Impl, glSecondaryColor3ubv); + GLELoadProc(glSecondaryColor3ui_Impl, glSecondaryColor3ui); + GLELoadProc(glSecondaryColor3uiv_Impl, glSecondaryColor3uiv); + GLELoadProc(glSecondaryColor3us_Impl, glSecondaryColor3us); + GLELoadProc(glSecondaryColor3usv_Impl, glSecondaryColor3usv); + GLELoadProc(glSecondaryColorPointer_Impl, glSecondaryColorPointer); + GLELoadProc(glWindowPos2d_Impl, glWindowPos2d); + GLELoadProc(glWindowPos2dv_Impl, glWindowPos2dv); + GLELoadProc(glWindowPos2f_Impl, glWindowPos2f); + GLELoadProc(glWindowPos2fv_Impl, glWindowPos2fv); + GLELoadProc(glWindowPos2i_Impl, glWindowPos2i); + GLELoadProc(glWindowPos2iv_Impl, glWindowPos2iv); + GLELoadProc(glWindowPos2s_Impl, glWindowPos2s); + GLELoadProc(glWindowPos2sv_Impl, glWindowPos2sv); + GLELoadProc(glWindowPos3d_Impl, glWindowPos3d); + GLELoadProc(glWindowPos3dv_Impl, glWindowPos3dv); + GLELoadProc(glWindowPos3f_Impl, glWindowPos3f); + GLELoadProc(glWindowPos3fv_Impl, glWindowPos3fv); + GLELoadProc(glWindowPos3i_Impl, glWindowPos3i); + GLELoadProc(glWindowPos3iv_Impl, glWindowPos3iv); + GLELoadProc(glWindowPos3s_Impl, glWindowPos3s); + GLELoadProc(glWindowPos3sv_Impl, glWindowPos3sv); + + // GL_VERSION_1_5 + GLELoadProc(glBeginQuery_Impl, glBeginQuery); + GLELoadProc(glBindBuffer_Impl, glBindBuffer); + GLELoadProc(glBufferData_Impl, glBufferData); + GLELoadProc(glBufferSubData_Impl, glBufferSubData); + GLELoadProc(glDeleteBuffers_Impl, glDeleteBuffers); + GLELoadProc(glDeleteQueries_Impl, glDeleteQueries); + GLELoadProc(glEndQuery_Impl, glEndQuery); + GLELoadProc(glGenBuffers_Impl, glGenBuffers); + GLELoadProc(glGenQueries_Impl, glGenQueries); + GLELoadProc(glGetBufferParameteriv_Impl, glGetBufferParameteriv); + GLELoadProc(glGetBufferPointerv_Impl, glGetBufferPointerv); + GLELoadProc(glGetBufferSubData_Impl, glGetBufferSubData); + GLELoadProc(glGetQueryObjectiv_Impl, glGetQueryObjectiv); + GLELoadProc(glGetQueryObjectuiv_Impl, glGetQueryObjectuiv); + GLELoadProc(glGetQueryiv_Impl, glGetQueryiv); + GLELoadProc(glIsBuffer_Impl, glIsBuffer); + GLELoadProc(glIsQuery_Impl, glIsQuery); + GLELoadProc(glMapBuffer_Impl, glMapBuffer); + GLELoadProc(glUnmapBuffer_Impl, glUnmapBuffer); + + // GL_VERSION_2_0 + GLELoadProc(glAttachShader_Impl, glAttachShader); + GLELoadProc(glBindAttribLocation_Impl, glBindAttribLocation); + GLELoadProc(glBlendEquationSeparate_Impl, glBlendEquationSeparate); + GLELoadProc(glCompileShader_Impl, glCompileShader); + GLELoadProc(glCreateProgram_Impl, glCreateProgram); + GLELoadProc(glCreateShader_Impl, glCreateShader); + GLELoadProc(glDeleteProgram_Impl, glDeleteProgram); + GLELoadProc(glDeleteShader_Impl, glDeleteShader); + GLELoadProc(glDetachShader_Impl, glDetachShader); + GLELoadProc(glDisableVertexAttribArray_Impl, glDisableVertexAttribArray); + GLELoadProc(glDrawBuffers_Impl, glDrawBuffers); + GLELoadProc(glEnableVertexAttribArray_Impl, glEnableVertexAttribArray); + GLELoadProc(glGetActiveAttrib_Impl, glGetActiveAttrib); + GLELoadProc(glGetActiveUniform_Impl, glGetActiveUniform); + GLELoadProc(glGetAttachedShaders_Impl, glGetAttachedShaders); + GLELoadProc(glGetAttribLocation_Impl, glGetAttribLocation); + GLELoadProc(glGetProgramInfoLog_Impl, glGetProgramInfoLog); + GLELoadProc(glGetProgramiv_Impl, glGetProgramiv); + GLELoadProc(glGetShaderInfoLog_Impl, glGetShaderInfoLog); + GLELoadProc(glGetShaderSource_Impl, glGetShaderSource); + GLELoadProc(glGetShaderiv_Impl, glGetShaderiv); + GLELoadProc(glGetUniformLocation_Impl, glGetUniformLocation); + GLELoadProc(glGetUniformfv_Impl, glGetUniformfv); + GLELoadProc(glGetUniformiv_Impl, glGetUniformiv); + GLELoadProc(glGetVertexAttribPointerv_Impl, glGetVertexAttribPointerv); + GLELoadProc(glGetVertexAttribdv_Impl, glGetVertexAttribdv); + GLELoadProc(glGetVertexAttribfv_Impl, glGetVertexAttribfv); + GLELoadProc(glGetVertexAttribiv_Impl, glGetVertexAttribiv); + GLELoadProc(glIsProgram_Impl, glIsProgram); + GLELoadProc(glIsShader_Impl, glIsShader); + GLELoadProc(glLinkProgram_Impl, glLinkProgram); + GLELoadProc(glShaderSource_Impl, glShaderSource); + GLELoadProc(glStencilFuncSeparate_Impl, glStencilFuncSeparate); + GLELoadProc(glStencilMaskSeparate_Impl, glStencilMaskSeparate); + GLELoadProc(glStencilOpSeparate_Impl, glStencilOpSeparate); + GLELoadProc(glUniform1f_Impl, glUniform1f); + GLELoadProc(glUniform1fv_Impl, glUniform1fv); + GLELoadProc(glUniform1i_Impl, glUniform1i); + GLELoadProc(glUniform1iv_Impl, glUniform1iv); + GLELoadProc(glUniform2f_Impl, glUniform2f); + GLELoadProc(glUniform2fv_Impl, glUniform2fv); + GLELoadProc(glUniform2i_Impl, glUniform2i); + GLELoadProc(glUniform2iv_Impl, glUniform2iv); + GLELoadProc(glUniform3f_Impl, glUniform3f); + GLELoadProc(glUniform3fv_Impl, glUniform3fv); + GLELoadProc(glUniform3i_Impl, glUniform3i); + GLELoadProc(glUniform3iv_Impl, glUniform3iv); + GLELoadProc(glUniform4f_Impl, glUniform4f); + GLELoadProc(glUniform4fv_Impl, glUniform4fv); + GLELoadProc(glUniform4i_Impl, glUniform4i); + GLELoadProc(glUniform4iv_Impl, glUniform4iv); + GLELoadProc(glUniformMatrix2fv_Impl, glUniformMatrix2fv); + GLELoadProc(glUniformMatrix3fv_Impl, glUniformMatrix3fv); + GLELoadProc(glUniformMatrix4fv_Impl, glUniformMatrix4fv); + GLELoadProc(glUseProgram_Impl, glUseProgram); + GLELoadProc(glValidateProgram_Impl, glValidateProgram); + GLELoadProc(glVertexAttrib1d_Impl, glVertexAttrib1d); + GLELoadProc(glVertexAttrib1dv_Impl, glVertexAttrib1dv); + GLELoadProc(glVertexAttrib1f_Impl, glVertexAttrib1f); + GLELoadProc(glVertexAttrib1fv_Impl, glVertexAttrib1fv); + GLELoadProc(glVertexAttrib1s_Impl, glVertexAttrib1s); + GLELoadProc(glVertexAttrib1sv_Impl, glVertexAttrib1sv); + GLELoadProc(glVertexAttrib2d_Impl, glVertexAttrib2d); + GLELoadProc(glVertexAttrib2dv_Impl, glVertexAttrib2dv); + GLELoadProc(glVertexAttrib2f_Impl, glVertexAttrib2f); + GLELoadProc(glVertexAttrib2fv_Impl, glVertexAttrib2fv); + GLELoadProc(glVertexAttrib2s_Impl, glVertexAttrib2s); + GLELoadProc(glVertexAttrib2sv_Impl, glVertexAttrib2sv); + GLELoadProc(glVertexAttrib3d_Impl, glVertexAttrib3d); + GLELoadProc(glVertexAttrib3dv_Impl, glVertexAttrib3dv); + GLELoadProc(glVertexAttrib3f_Impl, glVertexAttrib3f); + GLELoadProc(glVertexAttrib3fv_Impl, glVertexAttrib3fv); + GLELoadProc(glVertexAttrib3s_Impl, glVertexAttrib3s); + GLELoadProc(glVertexAttrib3sv_Impl, glVertexAttrib3sv); + GLELoadProc(glVertexAttrib4Nbv_Impl, glVertexAttrib4Nbv); + GLELoadProc(glVertexAttrib4Niv_Impl, glVertexAttrib4Niv); + GLELoadProc(glVertexAttrib4Nsv_Impl, glVertexAttrib4Nsv); + GLELoadProc(glVertexAttrib4Nub_Impl, glVertexAttrib4Nub); + GLELoadProc(glVertexAttrib4Nubv_Impl, glVertexAttrib4Nubv); + GLELoadProc(glVertexAttrib4Nuiv_Impl, glVertexAttrib4Nuiv); + GLELoadProc(glVertexAttrib4Nusv_Impl, glVertexAttrib4Nusv); + GLELoadProc(glVertexAttrib4bv_Impl, glVertexAttrib4bv); + GLELoadProc(glVertexAttrib4d_Impl, glVertexAttrib4d); + GLELoadProc(glVertexAttrib4dv_Impl, glVertexAttrib4dv); + GLELoadProc(glVertexAttrib4f_Impl, glVertexAttrib4f); + GLELoadProc(glVertexAttrib4fv_Impl, glVertexAttrib4fv); + GLELoadProc(glVertexAttrib4iv_Impl, glVertexAttrib4iv); + GLELoadProc(glVertexAttrib4s_Impl, glVertexAttrib4s); + GLELoadProc(glVertexAttrib4sv_Impl, glVertexAttrib4sv); + GLELoadProc(glVertexAttrib4ubv_Impl, glVertexAttrib4ubv); + GLELoadProc(glVertexAttrib4uiv_Impl, glVertexAttrib4uiv); + GLELoadProc(glVertexAttrib4usv_Impl, glVertexAttrib4usv); + GLELoadProc(glVertexAttribPointer_Impl, glVertexAttribPointer); + + // GL_VERSION_2_1 + GLELoadProc(glUniformMatrix2x3fv_Impl, glUniformMatrix2x3fv); + GLELoadProc(glUniformMatrix2x4fv_Impl, glUniformMatrix2x4fv); + GLELoadProc(glUniformMatrix3x2fv_Impl, glUniformMatrix3x2fv); + GLELoadProc(glUniformMatrix3x4fv_Impl, glUniformMatrix3x4fv); + GLELoadProc(glUniformMatrix4x2fv_Impl, glUniformMatrix4x2fv); + GLELoadProc(glUniformMatrix4x3fv_Impl, glUniformMatrix4x3fv); + + // GL_VERSION_3_0 + GLELoadProc(glBeginConditionalRender_Impl, glBeginConditionalRender); + GLELoadProc(glBeginTransformFeedback_Impl, glBeginTransformFeedback); + GLELoadProc(glBindFragDataLocation_Impl, glBindFragDataLocation); + GLELoadProc(glClampColor_Impl, glClampColor); + GLELoadProc(glClearBufferfi_Impl, glClearBufferfi); + GLELoadProc(glClearBufferfv_Impl, glClearBufferfv); + GLELoadProc(glClearBufferiv_Impl, glClearBufferiv); + GLELoadProc(glClearBufferuiv_Impl, glClearBufferuiv); + GLELoadProc(glColorMaski_Impl, glColorMaski); + GLELoadProc(glDisablei_Impl, glDisablei); + GLELoadProc(glEnablei_Impl, glEnablei); + GLELoadProc(glEndConditionalRender_Impl, glEndConditionalRender); + GLELoadProc(glEndTransformFeedback_Impl, glEndTransformFeedback); + GLELoadProc(glBindBufferRange_Impl, glBindBufferRange); + GLELoadProc(glBindBufferBase_Impl, glBindBufferBase); + GLELoadProc(glGetBooleani_v_Impl, glGetBooleani_v); + GLELoadProc(glGetIntegeri_v_Impl, glGetIntegeri_v); + GLELoadProc(glGetFragDataLocation_Impl, glGetFragDataLocation); + GLELoadProc(glGetStringi_Impl, glGetStringi); + GLELoadProc(glGetTexParameterIiv_Impl, glGetTexParameterIiv); + GLELoadProc(glGetTexParameterIuiv_Impl, glGetTexParameterIuiv); + GLELoadProc(glGetTransformFeedbackVarying_Impl, glGetTransformFeedbackVarying); + GLELoadProc(glGetUniformuiv_Impl, glGetUniformuiv); + GLELoadProc(glGetVertexAttribIiv_Impl, glGetVertexAttribIiv); + GLELoadProc(glGetVertexAttribIuiv_Impl, glGetVertexAttribIuiv); + GLELoadProc(glIsEnabledi_Impl, glIsEnabledi); + GLELoadProc(glTexParameterIiv_Impl, glTexParameterIiv); + GLELoadProc(glTexParameterIuiv_Impl, glTexParameterIuiv); + GLELoadProc(glTransformFeedbackVaryings_Impl, glTransformFeedbackVaryings); + GLELoadProc(glUniform1ui_Impl, glUniform1ui); + GLELoadProc(glUniform1uiv_Impl, glUniform1uiv); + GLELoadProc(glUniform2ui_Impl, glUniform2ui); + GLELoadProc(glUniform2uiv_Impl, glUniform2uiv); + GLELoadProc(glUniform3ui_Impl, glUniform3ui); + GLELoadProc(glUniform3uiv_Impl, glUniform3uiv); + GLELoadProc(glUniform4ui_Impl, glUniform4ui); + GLELoadProc(glUniform4uiv_Impl, glUniform4uiv); + GLELoadProc(glVertexAttribI1i_Impl, glVertexAttribI1i); + GLELoadProc(glVertexAttribI1iv_Impl, glVertexAttribI1iv); + GLELoadProc(glVertexAttribI1ui_Impl, glVertexAttribI1ui); + GLELoadProc(glVertexAttribI1uiv_Impl, glVertexAttribI1uiv); + GLELoadProc(glVertexAttribI2i_Impl, glVertexAttribI2i); + GLELoadProc(glVertexAttribI2iv_Impl, glVertexAttribI2iv); + GLELoadProc(glVertexAttribI2ui_Impl, glVertexAttribI2ui); + GLELoadProc(glVertexAttribI2uiv_Impl, glVertexAttribI2uiv); + GLELoadProc(glVertexAttribI3i_Impl, glVertexAttribI3i); + GLELoadProc(glVertexAttribI3iv_Impl, glVertexAttribI3iv); + GLELoadProc(glVertexAttribI3ui_Impl, glVertexAttribI3ui); + GLELoadProc(glVertexAttribI3uiv_Impl, glVertexAttribI3uiv); + GLELoadProc(glVertexAttribI4bv_Impl, glVertexAttribI4bv); + GLELoadProc(glVertexAttribI4i_Impl, glVertexAttribI4i); + GLELoadProc(glVertexAttribI4iv_Impl, glVertexAttribI4iv); + GLELoadProc(glVertexAttribI4sv_Impl, glVertexAttribI4sv); + GLELoadProc(glVertexAttribI4ubv_Impl, glVertexAttribI4ubv); + GLELoadProc(glVertexAttribI4ui_Impl, glVertexAttribI4ui); + GLELoadProc(glVertexAttribI4uiv_Impl, glVertexAttribI4uiv); + GLELoadProc(glVertexAttribI4usv_Impl, glVertexAttribI4usv); + GLELoadProc(glVertexAttribIPointer_Impl, glVertexAttribIPointer); + + // GL_VERSION_3_1 + GLELoadProc(glDrawArraysInstanced_Impl, glDrawArraysInstanced); + GLELoadProc(glDrawElementsInstanced_Impl, glDrawElementsInstanced); + GLELoadProc(glPrimitiveRestartIndex_Impl, glPrimitiveRestartIndex); + GLELoadProc(glTexBuffer_Impl, glTexBuffer); + + // GL_VERSION_3_2 + GLELoadProc(glFramebufferTexture_Impl, glFramebufferTexture); + GLELoadProc(glGetBufferParameteri64v_Impl, glGetBufferParameteri64v); + GLELoadProc(glGetInteger64i_v_Impl, glGetInteger64i_v); + + // GL_VERSION_3_3 + GLELoadProc(glVertexAttribDivisor_Impl, glVertexAttribDivisor); + + // GL_VERSION_4_0 + GLELoadProc(glBlendEquationSeparatei_Impl, glBlendEquationSeparatei); + GLELoadProc(glBlendEquationi_Impl, glBlendEquationi); + GLELoadProc(glBlendFuncSeparatei_Impl, glBlendFuncSeparatei); + GLELoadProc(glBlendFunci_Impl, glBlendFunci); + GLELoadProc(glMinSampleShading_Impl, glMinSampleShading); + + // GL_AMD_debug_output + GLELoadProc(glDebugMessageCallbackAMD_Impl, glDebugMessageCallbackAMD); + GLELoadProc(glDebugMessageEnableAMD_Impl, glDebugMessageEnableAMD); + GLELoadProc(glDebugMessageInsertAMD_Impl, glDebugMessageInsertAMD); + GLELoadProc(glGetDebugMessageLogAMD_Impl, glGetDebugMessageLogAMD); + + #if defined(GLE_CGL_ENABLED) + // GL_APPLE_element_array + GLELoadProc(glDrawElementArrayAPPLE_Impl, glDrawElementArrayAPPLE); + GLELoadProc(glDrawRangeElementArrayAPPLE_Impl, glDrawRangeElementArrayAPPLE); + GLELoadProc(glElementPointerAPPLE_Impl, glElementPointerAPPLE); + GLELoadProc(glMultiDrawElementArrayAPPLE_Impl, glMultiDrawElementArrayAPPLE); + GLELoadProc(glMultiDrawRangeElementArrayAPPLE_Impl, glMultiDrawRangeElementArrayAPPLE); + + // GL_APPLE_fence + GLELoadProc(glDeleteFencesAPPLE_Impl, glDeleteFencesAPPLE); + GLELoadProc(glFinishFenceAPPLE_Impl, glFinishFenceAPPLE); + GLELoadProc(glFinishObjectAPPLE_Impl, glFinishObjectAPPLE); + GLELoadProc(glGenFencesAPPLE_Impl, glGenFencesAPPLE); + GLELoadProc(glIsFenceAPPLE_Impl, glIsFenceAPPLE); + GLELoadProc(glSetFenceAPPLE_Impl, glSetFenceAPPLE); + GLELoadProc(glTestFenceAPPLE_Impl, glTestFenceAPPLE); + GLELoadProc(glTestObjectAPPLE_Impl, glTestObjectAPPLE); + + // GL_APPLE_flush_buffer_range + GLELoadProc(glBufferParameteriAPPLE_Impl, glMultiDrawRangeElementArrayAPPLE); + GLELoadProc(glFlushMappedBufferRangeAPPLE_Impl, glFlushMappedBufferRangeAPPLE); + + // GL_APPLE_object_purgeable + GLELoadProc(glGetObjectParameterivAPPLE_Impl, glGetObjectParameterivAPPLE); + GLELoadProc(glObjectPurgeableAPPLE_Impl, glObjectPurgeableAPPLE); + GLELoadProc(glObjectUnpurgeableAPPLE_Impl, glObjectUnpurgeableAPPLE); + + // GL_APPLE_texture_range + GLELoadProc(glGetTexParameterPointervAPPLE_Impl, glGetTexParameterPointervAPPLE); + GLELoadProc(glTextureRangeAPPLE_Impl, glTextureRangeAPPLE); + + // GL_APPLE_vertex_array_object + GLELoadProc(glBindVertexArrayAPPLE_Impl, glBindVertexArrayAPPLE); + GLELoadProc(glDeleteVertexArraysAPPLE_Impl, glDeleteVertexArraysAPPLE); + GLELoadProc(glGenVertexArraysAPPLE_Impl, glGenVertexArraysAPPLE); + GLELoadProc(glIsVertexArrayAPPLE_Impl, glIsVertexArrayAPPLE); + + // GL_APPLE_vertex_array_range + GLELoadProc(glFlushVertexArrayRangeAPPLE_Impl, glFlushVertexArrayRangeAPPLE); + GLELoadProc(glVertexArrayParameteriAPPLE_Impl, glVertexArrayParameteriAPPLE); + GLELoadProc(glVertexArrayRangeAPPLE_Impl, glVertexArrayRangeAPPLE); + + // GL_APPLE_vertex_program_evaluators + GLELoadProc(glDisableVertexAttribAPPLE_Impl, glDisableVertexAttribAPPLE); + GLELoadProc(glEnableVertexAttribAPPLE_Impl, glEnableVertexAttribAPPLE); + GLELoadProc(glIsVertexAttribEnabledAPPLE_Impl, glIsVertexAttribEnabledAPPLE); + GLELoadProc(glMapVertexAttrib1dAPPLE_Impl, glMapVertexAttrib1dAPPLE); + GLELoadProc(glMapVertexAttrib1fAPPLE_Impl, glMapVertexAttrib1fAPPLE); + GLELoadProc(glMapVertexAttrib2dAPPLE_Impl, glMapVertexAttrib2dAPPLE); + GLELoadProc(glMapVertexAttrib2fAPPLE_Impl, glMapVertexAttrib2fAPPLE); + + #endif // GLE_CGL_ENABLED + + // GL_ARB_debug_output + GLELoadProc(glDebugMessageCallbackARB_Impl, glDebugMessageCallbackARB); + GLELoadProc(glDebugMessageControlARB_Impl, glDebugMessageControlARB); + GLELoadProc(glDebugMessageInsertARB_Impl, glDebugMessageInsertARB); + GLELoadProc(glGetDebugMessageLogARB_Impl, glGetDebugMessageLogARB); + + // GL_ARB_ES2_compatibility + GLELoadProc(glClearDepthf_Impl, glClearDepthf); + GLELoadProc(glDepthRangef_Impl, glDepthRangef); + GLELoadProc(glGetShaderPrecisionFormat_Impl, glGetShaderPrecisionFormat); + GLELoadProc(glReleaseShaderCompiler_Impl, glReleaseShaderCompiler); + GLELoadProc(glShaderBinary_Impl, glShaderBinary); + + // GL_ARB_framebuffer_object + GLELoadProc(glBindFramebuffer_Impl, glBindFramebuffer); + GLELoadProc(glBindRenderbuffer_Impl, glBindRenderbuffer); + GLELoadProc(glBlitFramebuffer_Impl, glBlitFramebuffer); + GLELoadProc(glCheckFramebufferStatus_Impl, glCheckFramebufferStatus); + GLELoadProc(glDeleteFramebuffers_Impl, glDeleteFramebuffers); + GLELoadProc(glDeleteRenderbuffers_Impl, glDeleteRenderbuffers); + GLELoadProc(glFramebufferRenderbuffer_Impl, glFramebufferRenderbuffer); + GLELoadProc(glFramebufferTexture1D_Impl, glFramebufferTexture1D); + GLELoadProc(glFramebufferTexture2D_Impl, glFramebufferTexture2D); + GLELoadProc(glFramebufferTexture3D_Impl, glFramebufferTexture3D); + GLELoadProc(glFramebufferTextureLayer_Impl, glFramebufferTextureLayer); + GLELoadProc(glGenFramebuffers_Impl, glGenFramebuffers); + GLELoadProc(glGenRenderbuffers_Impl, glGenRenderbuffers); + GLELoadProc(glGenerateMipmap_Impl, glGenerateMipmap); + GLELoadProc(glGetFramebufferAttachmentParameteriv_Impl, glGetFramebufferAttachmentParameteriv); + GLELoadProc(glGetRenderbufferParameteriv_Impl, glGetRenderbufferParameteriv); + GLELoadProc(glIsFramebuffer_Impl, glIsFramebuffer); + GLELoadProc(glIsRenderbuffer_Impl, glIsRenderbuffer); + GLELoadProc(glRenderbufferStorage_Impl, glRenderbufferStorage); + GLELoadProc(glRenderbufferStorageMultisample_Impl, glRenderbufferStorageMultisample); + + if(!glBindFramebuffer_Impl) // This will rarely if ever be the case in practice with modern computers and drivers. + { + // See if we can map GL_EXT_framebuffer_object to GL_ARB_framebuffer_object. The former is basically a subset of the latter, but we use only that subset. + GLELoadProc(glBindFramebuffer_Impl, glBindFramebufferEXT); + GLELoadProc(glBindRenderbuffer_Impl, glBindRenderbufferEXT); + //GLELoadProc(glBlitFramebuffer_Impl, glBlitFramebufferEXT (nonexistent)); + GLELoadProc(glCheckFramebufferStatus_Impl, glCheckFramebufferStatusEXT); + GLELoadProc(glDeleteFramebuffers_Impl, glDeleteFramebuffersEXT); + GLELoadProc(glDeleteRenderbuffers_Impl, glDeleteRenderbuffersEXT); + GLELoadProc(glFramebufferRenderbuffer_Impl, glFramebufferRenderbufferEXT); + GLELoadProc(glFramebufferTexture1D_Impl, glFramebufferTexture1DEXT); + GLELoadProc(glFramebufferTexture2D_Impl, glFramebufferTexture2DEXT); + GLELoadProc(glFramebufferTexture3D_Impl, glFramebufferTexture3DEXT); + //GLELoadProc(glFramebufferTextureLayer_Impl, glFramebufferTextureLayerEXT (nonexistent)); + GLELoadProc(glGenFramebuffers_Impl, glGenFramebuffersEXT); + GLELoadProc(glGenRenderbuffers_Impl, glGenRenderbuffersEXT); + GLELoadProc(glGenerateMipmap_Impl, glGenerateMipmapEXT); + GLELoadProc(glGetFramebufferAttachmentParameteriv_Impl, glGetFramebufferAttachmentParameterivEXT); + GLELoadProc(glGetRenderbufferParameteriv_Impl, glGetRenderbufferParameterivEXT); + GLELoadProc(glIsFramebuffer_Impl, glIsFramebufferEXT); + GLELoadProc(glIsRenderbuffer_Impl, glIsRenderbufferEXT); + GLELoadProc(glRenderbufferStorage_Impl, glRenderbufferStorageEXT); + //GLELoadProc(glRenderbufferStorageMultisample_Impl, glRenderbufferStorageMultisampleEXT (nonexistent)); + } + + // GL_ARB_texture_multisample + GLELoadProc(glGetMultisamplefv_Impl, glGetMultisamplefv); + GLELoadProc(glSampleMaski_Impl, glSampleMaski); + GLELoadProc(glTexImage2DMultisample_Impl, glTexImage2DMultisample); + GLELoadProc(glTexImage3DMultisample_Impl, glTexImage3DMultisample); + + // GL_ARB_timer_query + GLELoadProc(glGetQueryObjecti64v_Impl, glGetQueryObjecti64v); + GLELoadProc(glGetQueryObjectui64v_Impl, glGetQueryObjectui64v); + GLELoadProc(glQueryCounter_Impl, glQueryCounter); + + // GL_ARB_vertex_array_object + GLELoadProc(glBindVertexArray_Impl, glBindVertexArray); + GLELoadProc(glDeleteVertexArrays_Impl, glDeleteVertexArrays); + GLELoadProc(glGenVertexArrays_Impl, glGenVertexArrays); + GLELoadProc(glIsVertexArray_Impl, glIsVertexArray); + + #if defined(GLE_CGL_ENABLED) // Apple OpenGL... + if(WholeVersion < 302) // It turns out that Apple OpenGL versions prior to 3.2 have glBindVertexArray, etc. but they silently fail by default. So always use the APPLE version. + { + glBindVertexArray_Impl = glBindVertexArrayAPPLE_Impl; + glDeleteVertexArrays_Impl = glDeleteVertexArraysAPPLE_Impl; + glGenVertexArrays_Impl = (OVRTypeof(glGenVertexArrays_Impl)) glGenVertexArraysAPPLE_Impl; // There is a const cast of the arrays argument here due to a slight difference in the Apple behavior. For our purposes it should be OK. + glIsVertexArray_Impl = glIsVertexArrayAPPLE_Impl; + + if(glBindVertexArray_Impl) + gle_ARB_vertex_array_object = true; // We are routing the APPLE version through our version, with the assumption that we use the ARB version the same as we would use the APPLE version. + } + #endif + + // GL_EXT_draw_buffers2 + GLELoadProc(glColorMaskIndexedEXT_Impl, glColorMaskIndexedEXT); + GLELoadProc(glDisableIndexedEXT_Impl, glDisableIndexedEXT); + GLELoadProc(glEnableIndexedEXT_Impl, glEnableIndexedEXT); + GLELoadProc(glGetBooleanIndexedvEXT_Impl, glGetBooleanIndexedvEXT); + GLELoadProc(glGetIntegerIndexedvEXT_Impl, glGetIntegerIndexedvEXT); + GLELoadProc(glIsEnabledIndexedEXT_Impl, glIsEnabledIndexedEXT); + + // GL_KHR_debug + GLELoadProc(glDebugMessageCallback_Impl, glDebugMessageCallback); + GLELoadProc(glDebugMessageControl_Impl, glDebugMessageControl); + GLELoadProc(glDebugMessageInsert_Impl, glDebugMessageInsert); + GLELoadProc(glGetDebugMessageLog_Impl, glGetDebugMessageLog); + GLELoadProc(glGetObjectLabel_Impl, glGetObjectLabel); + GLELoadProc(glGetObjectPtrLabel_Impl, glGetObjectPtrLabel); + GLELoadProc(glObjectLabel_Impl, glObjectLabel); + GLELoadProc(glObjectPtrLabel_Impl, glObjectPtrLabel); + GLELoadProc(glPopDebugGroup_Impl, glPopDebugGroup); + GLELoadProc(glPushDebugGroup_Impl, glPushDebugGroup); + + // GL_WIN_swap_hint + GLELoadProc(glAddSwapHintRectWIN_Impl, glAddSwapHintRectWIN); + } + + + + OVR_DISABLE_MSVC_WARNING(4510 4512 4610) // default constructor could not be generated, + struct ValueStringPair + { + bool& IsPresent; + const char* ExtensionName; + }; + + + // Helper function for InitExtensionSupport. + static void CheckExtensions(ValueStringPair* pValueStringPairArray, size_t arrayCount, const char* extensions) + { + // We search the extesion list string for each of the individual extensions we are interested in. + // We do this by walking over the string and comparing each entry in turn to our array of entries of interest. + // Example string (with patholigical extra spaces): " ext1 ext2 ext3 " + + char extension[64]; + const char* p = extensions; // p points to the beginning of the current word + const char* pEnd; // pEnd points to one-past the last character of the current word. It is where the trailing '\0' of the string would be. + + while(*p) + { + while(*p == ' ') // Find the next word begin. + ++p; + + pEnd = p; + + while((*pEnd != '\0') && (*pEnd != ' ')) // Find the next word end. + ++pEnd; + + if(((pEnd - p) > 0) && ((size_t)(pEnd - p) < OVR_ARRAY_COUNT(extension))) + { + memcpy(extension, p, pEnd - p); // To consider: Revise this code to directly read from p/pEnd instead of doing a memcpy. + extension[pEnd - p] = '\0'; + + for(size_t i = 0; i < arrayCount; i++) // For each extension we are interested in... + { + ValueStringPair& vsp = pValueStringPairArray[i]; + + if(strcmp(extension, vsp.ExtensionName) == 0) // case-sensitive compare + pValueStringPairArray[i].IsPresent = true; + } + } + + p = pEnd; + } + } + + + void OVR::GLEContext::InitExtensionSupport() + { + // It may be better in the long run to use a member STL map<const char*, bool>. + // It would make this loading code cleaner, though it would make lookups slower. + + ValueStringPair vspArray[] = + { + { gle_AMD_debug_output, "GL_AMD_debug_output" }, + #if defined(GLE_CGL_ENABLED) + { gle_APPLE_aux_depth_stencil, "GL_APPLE_aux_depth_stencil" }, + { gle_APPLE_client_storage, "GL_APPLE_client_storage" }, + { gle_APPLE_element_array, "GL_APPLE_element_array" }, + { gle_APPLE_fence, "GL_APPLE_fence" }, + { gle_APPLE_float_pixels, "GL_APPLE_float_pixels" }, + { gle_APPLE_flush_buffer_range, "GL_APPLE_flush_buffer_range" }, + { gle_APPLE_object_purgeable, "GL_APPLE_object_purgeable" }, + { gle_APPLE_pixel_buffer, "GL_APPLE_pixel_buffer" }, + { gle_APPLE_rgb_422, "GL_APPLE_rgb_422" }, + { gle_APPLE_row_bytes, "GL_APPLE_row_bytes" }, + { gle_APPLE_specular_vector, "GL_APPLE_specular_vector" }, + { gle_APPLE_texture_range, "GL_APPLE_texture_range" }, + { gle_APPLE_transform_hint, "GL_APPLE_transform_hint" }, + { gle_APPLE_vertex_array_object, "GL_APPLE_vertex_array_object" }, + { gle_APPLE_vertex_array_range, "GL_APPLE_vertex_array_range" }, + { gle_APPLE_vertex_program_evaluators, "GL_APPLE_vertex_program_evaluators" }, + { gle_APPLE_ycbcr_422, "GL_APPLE_ycbcr_422" }, + #endif + { gle_ARB_debug_output, "GL_ARB_debug_output" }, + { gle_ARB_depth_buffer_float, "GL_ARB_depth_buffer_float" }, + { gle_ARB_ES2_compatibility, "GL_ARB_ES2_compatibility" }, + { gle_ARB_framebuffer_object, "GL_ARB_framebuffer_object" }, + { gle_ARB_framebuffer_object, "GL_EXT_framebuffer_object" }, // We map glBindFramebuffer, etc. to glBindFramebufferEXT, etc. if necessary + { gle_ARB_framebuffer_sRGB, "GL_ARB_framebuffer_sRGB" }, + { gle_ARB_texture_multisample, "GL_ARB_texture_multisample" }, + { gle_ARB_texture_non_power_of_two, "GL_ARB_texture_non_power_of_two" }, + { gle_ARB_texture_rectangle, "GL_ARB_texture_rectangle" }, + { gle_ARB_texture_rectangle, "GL_EXT_texture_rectangle" }, // We also check for GL_EXT_texture_rectangle and GL_NV_texture_rectangle. + { gle_ARB_texture_rectangle, "GL_NV_texture_rectangle" }, + { gle_ARB_timer_query, "GL_ARB_timer_query" }, + { gle_ARB_vertex_array_object, "GL_ARB_vertex_array_object" }, + { gle_EXT_draw_buffers2, "GL_EXT_draw_buffers2" }, + { gle_EXT_texture_compression_s3tc, "GL_EXT_texture_compression_s3tc" }, + { gle_EXT_texture_filter_anisotropic, "GL_EXT_texture_filter_anisotropic" }, + { gle_KHR_debug, "GL_KHR_debug" }, + { gle_WIN_swap_hint, "GL_WIN_swap_hint" } + // Windows WGL, Unix GLX, and Apple CGL extensions are handled below, as they require different calls from glGetString(GL_EXTENSIONS). + }; + + // We cannot use glGetString(GL_EXTENSIONS) when an OpenGL core profile is active, + // as it's deprecated in favor of using OpenGL 3+ glGetStringi. + const char* extensions = (MajorVersion < 3) ? (const char*)glGetString(GL_EXTENSIONS) : ""; + + if (extensions && *extensions) // If we have a space-delimited extension string to search for individual extensions... + { + OVR_DEBUG_LOG(("GL_EXTENSIONS: %s", (const char*)extensions)); + CheckExtensions(vspArray, OVR_ARRAY_COUNT(vspArray), extensions); // Call our shared helper function for this. + } + else + { + if(MajorVersion >= 3) // If glGetIntegerv(GL_NUM_EXTENSIONS, ...) is supported... + { + // In this case we need to match an array of individual extensions against an array of + // externsions provided by glGetStringi. This is an O(n^2) operation, but at least we + // are doing this only once on startup. There are a few tricks we can employ to speed + // up the logic below, but they may not be worth much. + + GLint extensionCount = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount); + GLenum err = glGetError(); + + if(err == 0) + { + #ifdef OVR_BUILD_DEBUG + OVR::StringBuffer extensionsStr; + #endif + + for(GLint e = 0; e != extensionCount; ++e) // For each extension supported... + { + const char* extension = (const char*)glGetStringi(GL_EXTENSIONS, (GLuint)e); + + if(extension) // glGetStringi returns NULL upon error. + { + #ifdef OVR_BUILD_DEBUG + extensionsStr.AppendFormat(" %s", extension); + #endif + + for(size_t i = 0; i < OVR_ARRAY_COUNT(vspArray); i++) // For each extension we are interested in... + { + ValueStringPair& vsp = vspArray[i]; + + if(strcmp(extension, vsp.ExtensionName) == 0) // case-sensitive compare + vspArray[i].IsPresent = true; + } + } + else + break; + } + + OVR_DEBUG_LOG(("GL_EXTENSIONS: %s", extensionsStr.ToCStr())); + } + } + // Else we have a problem: no means to read the extensions was successful. + } + + #if defined(GLE_CGL_ENABLED) + // The following are built into Apple OpenGL 3.2+ (declared in <OpenGL/gl3.h>) and not identified as extensions. + // On other platforms (e.g. Windows) these are identified as extensions and are detected above. + if(WholeVersion >= 302) + { + gle_ARB_depth_buffer_float = true; + gle_ARB_framebuffer_object = true; + gle_ARB_framebuffer_sRGB = true; + gle_ARB_texture_multisample = true; + gle_ARB_texture_non_power_of_two = true; + gle_ARB_texture_rectangle = true; + gle_ARB_vertex_array_object = true; + } + #endif + + } // GLEContext::InitExtensionSupport() + + + void OVR::GLEContext::InitPlatformVersion() + { + #if defined(GLE_GLX_ENABLED) + const char* pGLXVersion = glXGetClientString(glXGetCurrentDisplay(), GLX_VERSION); // To do: Use a better mechanism to get the desired display. + sscanf(pGLXVersion, "%d.%d", &PlatformMajorVersion, &PlatformMinorVersion); + + #elif defined(GLE_EGL_ENABLED) + const char* pEGLVersion = eglQueryString(eglGetDisplay(EGL_DEFAULT_DISPLAY), EGL_VERSION); + sscanf(pEGLVersion, "%d.%d", &PlatformMajorVersion, &PlatformMinorVersion); + + #else + PlatformMajorVersion = 1; + PlatformMinorVersion = 0; + PlatformWholeVersion = 100; + #endif + } + + + void OVR::GLEContext::InitPlatformExtensionLoad() + { + #if defined(GLE_WGL_ENABLED) + // WGL + // We don't load these as function pointers but rather statically link to them. + // These need to be loaded via LoadLibrary instead of wglLoadLibrary. + + #if 0 + HINSTANCE hOpenGL = LoadLibraryW(L"Opengl32.dll"); + if(hOpenGL) + { + wglCopyContext_Impl = (OVRTypeof(wglCopyContext_Impl)) GetProcAddress(hOpenGL, "wglCopyContext"); + wglCreateContext_Impl = (OVRTypeof(wglCreateContext_Impl)) GetProcAddress(hOpenGL, "wglCreateContext"); + wglCreateLayerContext_Impl = (OVRTypeof(wglCreateLayerContext_Impl)) GetProcAddress(hOpenGL, "wglCreateLayerContext"); + wglDeleteContext_Impl = (OVRTypeof(wglDeleteContext_Impl)) GetProcAddress(hOpenGL, "wglDeleteContext"); + wglGetCurrentContext_Impl = (OVRTypeof(wglGetCurrentContext_Impl)) GetProcAddress(hOpenGL, "wglGetCurrentContext"); + wglGetCurrentDC_Impl = (OVRTypeof(wglGetCurrentDC_Impl)) GetProcAddress(hOpenGL, "wglGetCurrentDC"); + wglGetProcAddress_Impl = (OVRTypeof(wglGetProcAddress_Impl)) GetProcAddress(hOpenGL, "wglGetProcAddress"); + wglMakeCurrent_Impl = (OVRTypeof(wglMakeCurrent_Impl)) GetProcAddress(hOpenGL, "wglMakeCurrent"); + wglShareLists_Impl = (OVRTypeof(wglShareLists_Impl)) GetProcAddress(hOpenGL, "wglShareLists"); + wglUseFontBitmapsA_Impl = (OVRTypeof(wglUseFontBitmapsA_Impl)) GetProcAddress(hOpenGL, "wglUseFontBitmapsA"); + wglUseFontBitmapsW_Impl = (OVRTypeof(wglUseFontBitmapsW_Impl)) GetProcAddress(hOpenGL, "wglUseFontBitmapsW"); + wglUseFontOutlinesA_Impl = (OVRTypeof(wglUseFontOutlinesA_Impl)) GetProcAddress(hOpenGL, "wglUseFontOutlinesA"); + wglUseFontOutlinesW_Impl = (OVRTypeof(wglUseFontOutlinesW_Impl)) GetProcAddress(hOpenGL, "wglUseFontOutlinesW"); + wglDescribeLayerPlane_Impl = (OVRTypeof(wglDescribeLayerPlane_Impl)) GetProcAddress(hOpenGL, "wglDescribeLayerPlane"); + wglSetLayerPaletteEntries_Impl = (OVRTypeof(wglSetLayerPaletteEntries_Impl)) GetProcAddress(hOpenGL, "wglSetLayerPaletteEntries"); + wglGetLayerPaletteEntries_Impl = (OVRTypeof(wglGetLayerPaletteEntries_Impl)) GetProcAddress(hOpenGL, "wglGetLayerPaletteEntries"); + wglRealizeLayerPalette_Impl = (OVRTypeof(wglRealizeLayerPalette_Impl)) GetProcAddress(hOpenGL, "wglRealizeLayerPalette"); + wglSwapLayerBuffers_Impl = (OVRTypeof(wglSwapLayerBuffers_Impl)) GetProcAddress(hOpenGL, "wglSwapLayerBuffers"); + wglSwapMultipleBuffers_Impl = (OVRTypeof(wglSwapMultipleBuffers_Impl)) GetProcAddress(hOpenGL, "wglSwapMultipleBuffers"); + FreeLibrary(hOpenGL); + } + #endif + + // WGL_ARB_buffer_region + GLELoadProc(wglCreateBufferRegionARB_Impl, wglCreateBufferRegionARB); + GLELoadProc(wglDeleteBufferRegionARB_Impl, wglDeleteBufferRegionARB); + GLELoadProc(wglSaveBufferRegionARB_Impl, wglSaveBufferRegionARB); + GLELoadProc(wglRestoreBufferRegionARB_Impl, wglRestoreBufferRegionARB); + + // WGL_ARB_extensions_string + GLELoadProc(wglGetExtensionsStringARB_Impl, wglGetExtensionsStringARB); + + // WGL_ARB_pixel_format + GLELoadProc(wglGetPixelFormatAttribivARB_Impl, wglGetPixelFormatAttribivARB); + GLELoadProc(wglGetPixelFormatAttribfvARB_Impl, wglGetPixelFormatAttribfvARB); + GLELoadProc(wglChoosePixelFormatARB_Impl, wglChoosePixelFormatARB); + + // WGL_ARB_make_current_read + GLELoadProc(wglMakeContextCurrentARB_Impl, wglMakeContextCurrentARB); + GLELoadProc(wglGetCurrentReadDCARB_Impl, wglGetCurrentReadDCARB); + + // WGL_ARB_pbuffer + GLELoadProc(wglCreatePbufferARB_Impl, wglCreatePbufferARB); + GLELoadProc(wglGetPbufferDCARB_Impl, wglGetPbufferDCARB); + GLELoadProc(wglReleasePbufferDCARB_Impl, wglReleasePbufferDCARB); + GLELoadProc(wglDestroyPbufferARB_Impl, wglDestroyPbufferARB); + GLELoadProc(wglQueryPbufferARB_Impl, wglQueryPbufferARB); + + // WGL_ARB_render_texture + GLELoadProc(wglBindTexImageARB_Impl, wglBindTexImageARB); + GLELoadProc(wglReleaseTexImageARB_Impl, wglReleaseTexImageARB); + GLELoadProc(wglSetPbufferAttribARB_Impl, wglSetPbufferAttribARB); + + // WGL_NV_present_video + GLELoadProc(wglEnumerateVideoDevicesNV_Impl, wglEnumerateVideoDevicesNV); + GLELoadProc(wglBindVideoDeviceNV_Impl, wglBindVideoDeviceNV); + GLELoadProc(wglQueryCurrentContextNV_Impl, wglQueryCurrentContextNV); + + // WGL_ARB_create_context + GLELoadProc(wglCreateContextAttribsARB_Impl, wglCreateContextAttribsARB); + + // WGL_EXT_extensions_string + GLELoadProc(wglGetExtensionsStringEXT_Impl, wglGetExtensionsStringEXT); + + // WGL_EXT_swap_control + GLELoadProc(wglGetSwapIntervalEXT_Impl, wglGetSwapIntervalEXT); + GLELoadProc(wglSwapIntervalEXT_Impl, wglSwapIntervalEXT); + + // WGL_OML_sync_control + GLELoadProc(wglGetSyncValuesOML_Impl, wglGetSyncValuesOML); + GLELoadProc(wglGetMscRateOML_Impl, wglGetMscRateOML); + GLELoadProc(wglSwapBuffersMscOML_Impl, wglSwapBuffersMscOML); + GLELoadProc(wglSwapLayerBuffersMscOML_Impl, wglSwapLayerBuffersMscOML); + GLELoadProc(wglWaitForMscOML_Impl, wglWaitForMscOML); + GLELoadProc(wglWaitForSbcOML_Impl, wglWaitForSbcOML); + + // WGL_NV_video_output + GLELoadProc(wglGetVideoDeviceNV_Impl, wglGetVideoDeviceNV); + GLELoadProc(wglReleaseVideoDeviceNV_Impl, wglReleaseVideoDeviceNV); + GLELoadProc(wglBindVideoImageNV_Impl, wglBindVideoImageNV); + GLELoadProc(wglReleaseVideoImageNV_Impl, wglReleaseVideoImageNV); + GLELoadProc(wglSendPbufferToVideoNV_Impl, wglSendPbufferToVideoNV); + GLELoadProc(wglGetVideoInfoNV_Impl, wglGetVideoInfoNV); + + // WGL_NV_swap_group + GLELoadProc(wglJoinSwapGroupNV_Impl, wglJoinSwapGroupNV); + GLELoadProc(wglBindSwapBarrierNV_Impl, wglBindSwapBarrierNV); + GLELoadProc(wglQuerySwapGroupNV_Impl, wglQuerySwapGroupNV); + GLELoadProc(wglQueryMaxSwapGroupsNV_Impl, wglQueryMaxSwapGroupsNV); + GLELoadProc(wglQueryFrameCountNV_Impl, wglQueryFrameCountNV); + GLELoadProc(wglResetFrameCountNV_Impl, wglResetFrameCountNV); + + // WGL_NV_video_capture + GLELoadProc(wglBindVideoCaptureDeviceNV_Impl, wglBindVideoCaptureDeviceNV); + GLELoadProc(wglEnumerateVideoCaptureDevicesNV_Impl, wglEnumerateVideoCaptureDevicesNV); + GLELoadProc(wglLockVideoCaptureDeviceNV_Impl, wglLockVideoCaptureDeviceNV); + GLELoadProc(wglQueryVideoCaptureDeviceNV_Impl, wglQueryVideoCaptureDeviceNV); + GLELoadProc(wglReleaseVideoCaptureDeviceNV_Impl, wglReleaseVideoCaptureDeviceNV); + + // WGL_NV_copy_image + GLELoadProc(wglCopyImageSubDataNV_Impl, wglCopyImageSubDataNV); + + // WGL_NV_DX_interop + GLELoadProc(wglDXCloseDeviceNV_Impl, wglDXCloseDeviceNV); + GLELoadProc(wglDXLockObjectsNV_Impl, wglDXLockObjectsNV); + GLELoadProc(wglDXObjectAccessNV_Impl, wglDXObjectAccessNV); + GLELoadProc(wglDXOpenDeviceNV_Impl, wglDXOpenDeviceNV); + GLELoadProc(wglDXRegisterObjectNV_Impl, wglDXRegisterObjectNV); + GLELoadProc(wglDXSetResourceShareHandleNV_Impl, wglDXSetResourceShareHandleNV); + GLELoadProc(wglDXUnlockObjectsNV_Impl, wglDXUnlockObjectsNV); + GLELoadProc(wglDXUnregisterObjectNV_Impl, wglDXUnregisterObjectNV); + + #elif defined(GLE_GLX_ENABLED) + // GLX_VERSION_1_1 + // We don't create any pointers_Impl, because we assume these functions are always present. + + // GLX_VERSION_1_2 + GLELoadProc(glXGetCurrentDisplay_Impl, glXGetCurrentDisplay); + + // GLX_VERSION_1_3 + GLELoadProc(glXChooseFBConfig_Impl, glXChooseFBConfig); + GLELoadProc(glXCreateNewContext_Impl, glXCreateNewContext); + GLELoadProc(glXCreatePbuffer_Impl, glXCreatePbuffer); + GLELoadProc(glXCreatePixmap_Impl, glXCreatePixmap); + GLELoadProc(glXCreateWindow_Impl, glXCreateWindow); + GLELoadProc(glXDestroyPbuffer_Impl, glXDestroyPbuffer); + GLELoadProc(glXDestroyPixmap_Impl, glXDestroyPixmap); + GLELoadProc(glXDestroyWindow_Impl, glXDestroyWindow); + GLELoadProc(glXGetCurrentReadDrawable_Impl, glXGetCurrentReadDrawable); + GLELoadProc(glXGetFBConfigAttrib_Impl, glXGetFBConfigAttrib); + GLELoadProc(glXGetFBConfigs_Impl, glXGetFBConfigs); + GLELoadProc(glXGetSelectedEvent_Impl, glXGetSelectedEvent); + GLELoadProc(glXGetVisualFromFBConfig_Impl, glXGetVisualFromFBConfig); + GLELoadProc(glXMakeContextCurrent_Impl, glXMakeContextCurrent); + GLELoadProc(glXQueryContext_Impl, glXQueryContext); + GLELoadProc(glXQueryDrawable_Impl, glXQueryDrawable); + GLELoadProc(glXSelectEvent_Impl, glXSelectEvent); + + // GLX_VERSION_1_4 + // Nothing to declare + + // GLX_ARB_create_context + GLELoadProc(glXCreateContextAttribsARB_Impl, glXCreateContextAttribsARB); + + // GLX_EXT_swap_control + GLELoadProc(glXSwapIntervalEXT_Impl, glXSwapIntervalEXT); + + // GLX_OML_sync_control + GLELoadProc(glXGetMscRateOML_Impl, glXGetMscRateOML); + GLELoadProc(glXGetSyncValuesOML_Impl, glXGetSyncValuesOML); + GLELoadProc(glXGetSyncValuesOML_Impl, glXSwapBuffersMscOML); + GLELoadProc(glXSwapBuffersMscOML_Impl, glXSwapBuffersMscOML); + GLELoadProc(glXWaitForSbcOML_Impl, glXWaitForSbcOML); + + // GLX_MESA_swap_control + GLELoadProc(glXGetSwapIntervalMESA_Impl, glXGetSwapIntervalMESA); + GLELoadProc(glXSwapIntervalMESA_Impl, glXSwapIntervalMESA); + #endif + } + + + void OVR::GLEContext::InitPlatformExtensionSupport() + { + #if defined(GLE_WGL_ENABLED) + // We need to use wglGetExtensionsStringARB or wglGetExtensionsStringEXT as opposed to above with glGetString(GL_EXTENSIONS). + ValueStringPair vspWGLArray[] = + { + { gle_WGL_ARB_buffer_region, "WGL_ARB_buffer_region" } + ,{ gle_WGL_ARB_create_context, "WGL_ARB_create_context" } + ,{ gle_WGL_ARB_create_context_profile, "WGL_ARB_create_context_profile" } + ,{ gle_WGL_ARB_create_context_robustness, "WGL_ARB_create_context_robustness" } + ,{ gle_WGL_ARB_extensions_string, "WGL_ARB_extensions_string" } + ,{ gle_WGL_ARB_framebuffer_sRGB, "WGL_ARB_framebuffer_sRGB" } + ,{ gle_WGL_ARB_framebuffer_sRGB, "WGL_EXT_framebuffer_sRGB" } // We map the EXT to the ARB. + ,{ gle_WGL_ARB_make_current_read, "WGL_ARB_make_current_read" } + ,{ gle_WGL_ARB_pbuffer, "WGL_ARB_pbuffer" } + ,{ gle_WGL_ARB_pixel_format, "WGL_ARB_pixel_format" } + ,{ gle_WGL_ARB_pixel_format_float, "WGL_ARB_pixel_format_float" } + ,{ gle_WGL_ARB_render_texture, "WGL_ARB_render_texture" } + ,{ gle_WGL_ATI_render_texture_rectangle, "WGL_ATI_render_texture_rectangle" } + ,{ gle_WGL_EXT_extensions_string, "WGL_EXT_extensions_string" } + ,{ gle_WGL_EXT_swap_control, "WGL_EXT_swap_control" } + ,{ gle_WGL_NV_copy_image, "WGL_NV_copy_image" } + ,{ gle_WGL_NV_DX_interop, "WGL_NV_DX_interop" } + ,{ gle_WGL_NV_DX_interop2, "WGL_NV_DX_interop2" } + ,{ gle_WGL_NV_present_video, "WGL_NV_present_video" } + ,{ gle_WGL_NV_render_texture_rectangle, "WGL_NV_render_texture_rectangle" } + ,{ gle_WGL_NV_swap_group, "WGL_NV_swap_group" } + ,{ gle_WGL_NV_video_capture, "WGL_NV_video_capture" } + ,{ gle_WGL_NV_video_output, "WGL_NV_video_output" } + ,{ gle_WGL_OML_sync_control, "WGL_OML_sync_control" } + }; + + const char* extensions = NULL; + + if(wglGetExtensionsStringARB_Impl) + extensions = wglGetExtensionsStringARB_Impl(wglGetCurrentDC()); // To do: Use a better mechanism to get the desired HDC. + else if(wglGetExtensionsStringEXT_Impl) + extensions = wglGetExtensionsStringEXT_Impl(); + + if (extensions && *extensions) + { + OVR_DEBUG_LOG(("WGL_EXTENSIONS: %s", (const char*)extensions)); + CheckExtensions(vspWGLArray, OVR_ARRAY_COUNT(vspWGLArray), extensions); + } + + #elif defined(GLE_GLX_ENABLED) + ValueStringPair vspGLXArray[] = + { + { gle_GLX_ARB_create_context, "GLX_ARB_create_context" } + ,{ gle_GLX_ARB_create_context_profile, "GLX_ARB_create_context_profile" } + ,{ gle_GLX_ARB_create_context_robustness, "GLX_ARB_create_context_robustness" } + ,{ gle_GLX_EXT_swap_control, "GLX_EXT_swap_control" } + ,{ gle_GLX_OML_sync_control, "GLX_OML_sync_control" } + ,{ gle_MESA_swap_control, "GLX_MESA_swap_control" } + }; + + const char* extensions = glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); // To do: Use a better mechanism to get the desired display. + + if (extensions && *extensions) + { + OVR_DEBUG_LOG(("GLX_EXTENSIONS: %s", (const char*)extensions)); + CheckExtensions(vspGLXArray, OVR_ARRAY_COUNT(vspGLXArray), extensions); + } + #endif + } + + + #if defined(GLE_HOOKING_ENABLED) + + #undef glGetError + extern "C" { GLAPI GLenum GLAPIENTRY glGetError(); } + + // Disabled until such time as it might be useful to enable for debug purposes. + //void OVR::GLEContext::PreHook(const char* functionName) + //{ + // if(EnableHookGetError) + // { + // int err = glGetError(); + // + // for(int i = 0; (i < 6) && (err != GL_NO_ERROR); i++) // 6 is an arbitrary cap to prevent infinite looping which would occur if the current GL context is invalid. + // { + // OVR_DEBUG_LOG(("GL Error prior to hook: %d (%#x) from %s", err, err, functionName ? functionName : "OpenGL")); OVR_UNUSED(functionName); + // err = glGetError(); + // } + // } + //} + + void OVR::GLEContext::PostHook(const char* functionName) + { + if(EnableHookGetError) + { + // OpenGL Standard regarding error state: To allow for distributed implementations, there may be several error flags. If any single error flag has recorded an error, the value of that flag + // is returned and that flag is reset to GL_NO_ERROR when glGetError is called. If more than one flag has recorded an error, glGetError returns and + // clears an arbitrary error flag value. Thus, glGetError should always be called in a loop, until it returns GL_NO_ERROR, if all error flags are to be reset. + int err = glGetError(); + + for(int i = 0; (i < 6) && (err != GL_NO_ERROR); i++) // 6 is an arbitrary cap to prevent infinite looping which would occur if the current GL context is invalid. + { + OVR_DEBUG_LOG(("GL Error: %d (%#x) from %s", err, err, functionName ? functionName : "OpenGL")); OVR_UNUSED(functionName); + err = glGetError(); + } + } + } + + + // OpenGL 1.1 link-based functions + #undef glAccum // Undefine the macro from our header so that we can directly call the real version of this function. + extern "C" { GLAPI void GLAPIENTRY glAccum(GLenum op, GLfloat value); } + void OVR::GLEContext::glAccum_Hook(GLenum op, GLfloat value) + { + glAccum(op, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glAlphaFunc + extern "C" { GLAPI void GLAPIENTRY glAlphaFunc(GLenum func, GLclampf ref); } + void OVR::GLEContext::glAlphaFunc_Hook(GLenum func, GLclampf ref) + { + glAlphaFunc(func, ref); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glAreTexturesResident + extern "C" { GLAPI GLboolean GLAPIENTRY glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences); } + GLboolean OVR::GLEContext::glAreTexturesResident_Hook(GLsizei n, const GLuint *textures, GLboolean *residences) + { + GLboolean b = glAreTexturesResident(n, textures, residences); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef glArrayElement + extern "C" { GLAPI void GLAPIENTRY glArrayElement(GLint i); } + void OVR::GLEContext::glArrayElement_Hook(GLint i) + { + glArrayElement(i); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glBegin + extern "C" { GLAPI void GLAPIENTRY glBegin(GLenum mode); } + void OVR::GLEContext::glBegin_Hook(GLenum mode) + { + glBegin(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glBindTexture + extern "C" { GLAPI void GLAPIENTRY glBindTexture(GLenum target, GLuint texture); } + void OVR::GLEContext::glBindTexture_Hook(GLenum target, GLuint texture) + { + glBindTexture(target, texture); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glBitmap + extern "C" { GLAPI void GLAPIENTRY glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); } + void OVR::GLEContext::glBitmap_Hook(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) + { + glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glBlendFunc + extern "C" { GLAPI void GLAPIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor); } + void OVR::GLEContext::glBlendFunc_Hook(GLenum sfactor, GLenum dfactor) + { + glBlendFunc(sfactor, dfactor); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCallList + extern "C" { GLAPI void GLAPIENTRY glCallList(GLuint list); } + void OVR::GLEContext::glCallList_Hook(GLuint list) + { + glCallList(list); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCallLists + extern "C" { GLAPI void GLAPIENTRY glCallLists(GLsizei n, GLenum type, const void *lists); } + void OVR::GLEContext::glCallLists_Hook(GLsizei n, GLenum type, const void *lists) + { + glCallLists(n, type, lists); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClear + extern "C" { GLAPI void GLAPIENTRY glClear(GLbitfield mask); } + void OVR::GLEContext::glClear_Hook(GLbitfield mask) + { + glClear(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClearAccum + extern "C" { GLAPI void GLAPIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); } + void OVR::GLEContext::glClearAccum_Hook(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + glClearAccum(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClearColor + extern "C" { GLAPI void GLAPIENTRY glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); } + void OVR::GLEContext::glClearColor_Hook(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) + { + glClearColor(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClearDepth + extern "C" { GLAPI void GLAPIENTRY glClearDepth(GLclampd depth); } + void OVR::GLEContext::glClearDepth_Hook(GLclampd depth) + { + glClearDepth(depth); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClearIndex + extern "C" { GLAPI void GLAPIENTRY glClearIndex(GLfloat c); } + void OVR::GLEContext::glClearIndex_Hook(GLfloat c) + { + glClearIndex(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClearStencil + extern "C" { GLAPI void GLAPIENTRY glClearStencil(GLint s); } + void OVR::GLEContext::glClearStencil_Hook(GLint s) + { + glClearStencil(s); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glClipPlane + extern "C" { GLAPI void GLAPIENTRY glClipPlane(GLenum plane, const GLdouble *equation); } + void OVR::GLEContext::glClipPlane_Hook(GLenum plane, const GLdouble *equation) + { + glClipPlane(plane, equation); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3b + extern "C" { GLAPI void GLAPIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue); } + void OVR::GLEContext::glColor3b_Hook(GLbyte red, GLbyte green, GLbyte blue) + { + glColor3b(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3bv + extern "C" { GLAPI void GLAPIENTRY glColor3bv(const GLbyte *v); } + void OVR::GLEContext::glColor3bv_Hook(const GLbyte *v) + { + glColor3bv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3d + extern "C" { GLAPI void GLAPIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue); } + void OVR::GLEContext::glColor3d_Hook(GLdouble red, GLdouble green, GLdouble blue) + { + glColor3d(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3dv + extern "C" { GLAPI void GLAPIENTRY glColor3dv(const GLdouble *v); } + void OVR::GLEContext::glColor3dv_Hook(const GLdouble *v) + { + glColor3dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3f + extern "C" { GLAPI void GLAPIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue); } + void OVR::GLEContext::glColor3f_Hook(GLfloat red, GLfloat green, GLfloat blue) + { + glColor3f(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3fv + extern "C" { GLAPI void GLAPIENTRY glColor3fv(const GLfloat *v); } + void OVR::GLEContext::glColor3fv_Hook(const GLfloat *v) + { + glColor3fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3i + extern "C" { GLAPI void GLAPIENTRY glColor3i(GLint red, GLint green, GLint blue); } + void OVR::GLEContext::glColor3i_Hook(GLint red, GLint green, GLint blue) + { + glColor3i(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3iv + extern "C" { GLAPI void GLAPIENTRY glColor3iv(const GLint *v); } + void OVR::GLEContext::glColor3iv_Hook(const GLint *v) + { + glColor3iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3s + extern "C" { GLAPI void GLAPIENTRY glColor3s(GLshort red, GLshort green, GLshort blue); } + void OVR::GLEContext::glColor3s_Hook(GLshort red, GLshort green, GLshort blue) + { + glColor3s(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3sv + extern "C" { GLAPI void GLAPIENTRY glColor3sv(const GLshort *v); } + void OVR::GLEContext::glColor3sv_Hook(const GLshort *v) + { + glColor3sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3ub + extern "C" { GLAPI void GLAPIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue); } + void OVR::GLEContext::glColor3ub_Hook(GLubyte red, GLubyte green, GLubyte blue) + { + glColor3ub(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3ubv + extern "C" { GLAPI void GLAPIENTRY glColor3ubv(const GLubyte *v); } + void OVR::GLEContext::glColor3ubv_Hook(const GLubyte *v) + { + glColor3ubv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3ui + extern "C" { GLAPI void GLAPIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue); } + void OVR::GLEContext::glColor3ui_Hook(GLuint red, GLuint green, GLuint blue) + { + glColor3ui(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3uiv + extern "C" { GLAPI void GLAPIENTRY glColor3uiv(const GLuint *v); } + void OVR::GLEContext::glColor3uiv_Hook(const GLuint *v) + { + glColor3uiv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3us + extern "C" { GLAPI void GLAPIENTRY glColor3us(GLushort red, GLushort green, GLushort blue); } + void OVR::GLEContext::glColor3us_Hook(GLushort red, GLushort green, GLushort blue) + { + glColor3us(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor3usv + extern "C" { GLAPI void GLAPIENTRY glColor3usv(const GLushort *v); } + void OVR::GLEContext::glColor3usv_Hook(const GLushort *v) + { + glColor3usv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4b + extern "C" { GLAPI void GLAPIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); } + void OVR::GLEContext::glColor4b_Hook(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) + { + glColor4b(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4bv + extern "C" { GLAPI void GLAPIENTRY glColor4bv(const GLbyte *v); } + void OVR::GLEContext::glColor4bv_Hook(const GLbyte *v) + { + glColor4bv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4d + extern "C" { GLAPI void GLAPIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); } + void OVR::GLEContext::glColor4d_Hook(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) + { + glColor4d(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4dv + extern "C" { GLAPI void GLAPIENTRY glColor4dv(const GLdouble *v); } + void OVR::GLEContext::glColor4dv_Hook(const GLdouble *v) + { + glColor4dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4f + extern "C" { GLAPI void GLAPIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); } + void OVR::GLEContext::glColor4f_Hook(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + glColor4f(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4fv + extern "C" { GLAPI void GLAPIENTRY glColor4fv(const GLfloat *v); } + void OVR::GLEContext::glColor4fv_Hook(const GLfloat *v) + { + glColor4fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4i + extern "C" { GLAPI void GLAPIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha); } + void OVR::GLEContext::glColor4i_Hook(GLint red, GLint green, GLint blue, GLint alpha) + { + glColor4i(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4iv + extern "C" { GLAPI void GLAPIENTRY glColor4iv(const GLint *v); } + void OVR::GLEContext::glColor4iv_Hook(const GLint *v) + { + glColor4iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4s + extern "C" { GLAPI void GLAPIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha); } + void OVR::GLEContext::glColor4s_Hook(GLshort red, GLshort green, GLshort blue, GLshort alpha) + { + glColor4s(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4sv + extern "C" { GLAPI void GLAPIENTRY glColor4sv(const GLshort *v); } + void OVR::GLEContext::glColor4sv_Hook(const GLshort *v) + { + glColor4sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4ub + extern "C" { GLAPI void GLAPIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); } + void OVR::GLEContext::glColor4ub_Hook(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) + { + glColor4ub(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4ubv + extern "C" { GLAPI void GLAPIENTRY glColor4ubv(const GLubyte *v); } + void OVR::GLEContext::glColor4ubv_Hook(const GLubyte *v) + { + glColor4ubv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4ui + extern "C" { GLAPI void GLAPIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha); } + void OVR::GLEContext::glColor4ui_Hook(GLuint red, GLuint green, GLuint blue, GLuint alpha) + { + glColor4ui(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4uiv + extern "C" { GLAPI void GLAPIENTRY glColor4uiv(const GLuint *v); } + void OVR::GLEContext::glColor4uiv_Hook(const GLuint *v) + { + glColor4uiv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4us + extern "C" { GLAPI void GLAPIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha); } + void OVR::GLEContext::glColor4us_Hook(GLushort red, GLushort green, GLushort blue, GLushort alpha) + { + glColor4us(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColor4usv + extern "C" { GLAPI void GLAPIENTRY glColor4usv(const GLushort *v); } + void OVR::GLEContext::glColor4usv_Hook(const GLushort *v) + { + glColor4usv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColorMask + extern "C" { GLAPI void GLAPIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); } + void OVR::GLEContext::glColorMask_Hook(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) + { + glColorMask(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColorMaterial + extern "C" { GLAPI void GLAPIENTRY glColorMaterial(GLenum face, GLenum mode); } + void OVR::GLEContext::glColorMaterial_Hook(GLenum face, GLenum mode) + { + glColorMaterial(face, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glColorPointer + extern "C" { GLAPI void GLAPIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glColorPointer_Hook(GLint size, GLenum type, GLsizei stride, const void *pointer) + { + glColorPointer(size, type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCopyPixels + extern "C" { GLAPI void GLAPIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); } + void OVR::GLEContext::glCopyPixels_Hook(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) + { + glCopyPixels(x, y, width, height, type); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCopyTexImage1D + extern "C" { GLAPI void GLAPIENTRY glCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); } + void OVR::GLEContext::glCopyTexImage1D_Hook(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) + { + glCopyTexImage1D(target, level, internalFormat, x, y, width, border); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCopyTexImage2D + extern "C" { GLAPI void GLAPIENTRY glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); } + void OVR::GLEContext::glCopyTexImage2D_Hook(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) + { + glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCopyTexSubImage1D + extern "C" { GLAPI void GLAPIENTRY glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); } + void OVR::GLEContext::glCopyTexSubImage1D_Hook(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) + { + glCopyTexSubImage1D(target, level, xoffset, x, y, width); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCopyTexSubImage2D + extern "C" { GLAPI void GLAPIENTRY glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); } + void OVR::GLEContext::glCopyTexSubImage2D_Hook(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glCullFace + extern "C" { GLAPI void GLAPIENTRY glCullFace(GLenum mode); } + void OVR::GLEContext::glCullFace_Hook(GLenum mode) + { + glCullFace(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDeleteLists + extern "C" { GLAPI void GLAPIENTRY glDeleteLists(GLuint list, GLsizei range); } + void OVR::GLEContext::glDeleteLists_Hook(GLuint list, GLsizei range) + { + glDeleteLists(list, range); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDeleteTextures + extern "C" { GLAPI void GLAPIENTRY glDeleteTextures(GLsizei n, const GLuint *textures); } + void OVR::GLEContext::glDeleteTextures_Hook(GLsizei n, const GLuint *textures) + { + glDeleteTextures(n, textures); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDepthFunc + extern "C" { GLAPI void GLAPIENTRY glDepthFunc(GLenum func); } + void OVR::GLEContext::glDepthFunc_Hook(GLenum func) + { + glDepthFunc(func); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDepthMask + extern "C" { GLAPI void GLAPIENTRY glDepthMask(GLboolean flag); } + void OVR::GLEContext::glDepthMask_Hook(GLboolean flag) + { + glDepthMask(flag); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDepthRange + extern "C" { GLAPI void GLAPIENTRY glDepthRange(GLclampd zNear, GLclampd zFar); } + void OVR::GLEContext::glDepthRange_Hook(GLclampd zNear, GLclampd zFar) + { + glDepthRange(zNear, zFar); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDisable + extern "C" { GLAPI void GLAPIENTRY glDisable(GLenum cap); } + void OVR::GLEContext::glDisable_Hook(GLenum cap) + { + glDisable(cap); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDisableClientState + extern "C" { GLAPI void GLAPIENTRY glDisableClientState(GLenum array); } + void OVR::GLEContext::glDisableClientState_Hook(GLenum array) + { + glDisableClientState(array); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDrawArrays + extern "C" { GLAPI void GLAPIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count); } + void OVR::GLEContext::glDrawArrays_Hook(GLenum mode, GLint first, GLsizei count) + { + glDrawArrays(mode, first, count); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDrawBuffer + extern "C" { GLAPI void GLAPIENTRY glDrawBuffer(GLenum mode); } + void OVR::GLEContext::glDrawBuffer_Hook(GLenum mode) + { + glDrawBuffer(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDrawElements + extern "C" { GLAPI void GLAPIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices); } + void OVR::GLEContext::glDrawElements_Hook(GLenum mode, GLsizei count, GLenum type, const void *indices) + { + glDrawElements(mode, count, type, indices); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glDrawPixels + extern "C" { GLAPI void GLAPIENTRY glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); } + void OVR::GLEContext::glDrawPixels_Hook(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) + { + glDrawPixels(width, height, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEdgeFlag + extern "C" { GLAPI void GLAPIENTRY glEdgeFlag(GLboolean flag); } + void OVR::GLEContext::glEdgeFlag_Hook(GLboolean flag) + { + glEdgeFlag(flag); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEdgeFlagPointer + extern "C" { GLAPI void GLAPIENTRY glEdgeFlagPointer(GLsizei stride, const void *pointer); } + void OVR::GLEContext::glEdgeFlagPointer_Hook(GLsizei stride, const void *pointer) + { + glEdgeFlagPointer(stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEdgeFlagv + extern "C" { GLAPI void GLAPIENTRY glEdgeFlagv(const GLboolean *flag); } + void OVR::GLEContext::glEdgeFlagv_Hook(const GLboolean *flag) + { + glEdgeFlagv(flag); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEnable + extern "C" { GLAPI void GLAPIENTRY glEnable(GLenum cap); } + namespace OVR { + void GLEContext::glEnable_Hook(GLenum cap) + { + glEnable(cap); + PostHook(GLE_CURRENT_FUNCTION); + } + } + + #undef glEnableClientState + extern "C" { GLAPI void GLAPIENTRY glEnableClientState(GLenum array); } + void OVR::GLEContext::glEnableClientState_Hook(GLenum array) + { + glEnableClientState(array); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEnd + extern "C" { GLAPI void GLAPIENTRY glEnd(); } + void OVR::GLEContext::glEnd_Hook() + { + glEnd(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEndList + extern "C" { GLAPI void GLAPIENTRY glEndList(); } + void OVR::GLEContext::glEndList_Hook() + { + glEndList(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord1d + extern "C" { GLAPI void GLAPIENTRY glEvalCoord1d(GLdouble u); } + void OVR::GLEContext::glEvalCoord1d_Hook(GLdouble u) + { + glEvalCoord1d(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord1dv + extern "C" { GLAPI void GLAPIENTRY glEvalCoord1dv(const GLdouble *u); } + void OVR::GLEContext::glEvalCoord1dv_Hook(const GLdouble *u) + { + glEvalCoord1dv(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord1f + extern "C" { GLAPI void GLAPIENTRY glEvalCoord1f(GLfloat u); } + void OVR::GLEContext::glEvalCoord1f_Hook(GLfloat u) + { + glEvalCoord1f(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord1fv + extern "C" { GLAPI void GLAPIENTRY glEvalCoord1fv(const GLfloat *u); } + void OVR::GLEContext::glEvalCoord1fv_Hook(const GLfloat *u) + { + glEvalCoord1fv(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord2d + extern "C" { GLAPI void GLAPIENTRY glEvalCoord2d(GLdouble u, GLdouble v); } + void OVR::GLEContext::glEvalCoord2d_Hook(GLdouble u, GLdouble v) + { + glEvalCoord2d(u, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord2dv + extern "C" { GLAPI void GLAPIENTRY glEvalCoord2dv(const GLdouble *u); } + void OVR::GLEContext::glEvalCoord2dv_Hook(const GLdouble *u) + { + glEvalCoord2dv(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord2f + extern "C" { GLAPI void GLAPIENTRY glEvalCoord2f(GLfloat u, GLfloat v); } + void OVR::GLEContext::glEvalCoord2f_Hook(GLfloat u, GLfloat v) + { + glEvalCoord2f(u, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalCoord2fv + extern "C" { GLAPI void GLAPIENTRY glEvalCoord2fv(const GLfloat *u); } + void OVR::GLEContext::glEvalCoord2fv_Hook(const GLfloat *u) + { + glEvalCoord2fv(u); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalMesh1 + extern "C" { GLAPI void GLAPIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2); } + void OVR::GLEContext::glEvalMesh1_Hook(GLenum mode, GLint i1, GLint i2) + { + glEvalMesh1(mode, i1, i2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalMesh2 + extern "C" { GLAPI void GLAPIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); } + void OVR::GLEContext::glEvalMesh2_Hook(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) + { + glEvalMesh2(mode, i1, i2, j1, j2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalPoint1 + extern "C" { GLAPI void GLAPIENTRY glEvalPoint1(GLint i); } + void OVR::GLEContext::glEvalPoint1_Hook(GLint i) + { + glEvalPoint1(i); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glEvalPoint2 + extern "C" { GLAPI void GLAPIENTRY glEvalPoint2(GLint i, GLint j); } + void OVR::GLEContext::glEvalPoint2_Hook(GLint i, GLint j) + { + glEvalPoint2(i, j); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFeedbackBuffer + extern "C" { GLAPI void GLAPIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer); } + void OVR::GLEContext::glFeedbackBuffer_Hook(GLsizei size, GLenum type, GLfloat *buffer) + { + glFeedbackBuffer(size, type, buffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFinish + extern "C" { GLAPI void GLAPIENTRY glFinish(); } + void OVR::GLEContext::glFinish_Hook() + { + glFinish(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFlush + extern "C" { GLAPI void GLAPIENTRY glFlush(); } + void OVR::GLEContext::glFlush_Hook() + { + glFlush(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFogf + extern "C" { GLAPI void GLAPIENTRY glFogf(GLenum pname, GLfloat param); } + void OVR::GLEContext::glFogf_Hook(GLenum pname, GLfloat param) + { + glFogf(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFogfv + extern "C" { GLAPI void GLAPIENTRY glFogfv(GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glFogfv_Hook(GLenum pname, const GLfloat *params) + { + glFogfv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFogi + extern "C" { GLAPI void GLAPIENTRY glFogi(GLenum pname, GLint param); } + void OVR::GLEContext::glFogi_Hook(GLenum pname, GLint param) + { + glFogi(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFogiv + extern "C" { GLAPI void GLAPIENTRY glFogiv(GLenum pname, const GLint *params); } + void OVR::GLEContext::glFogiv_Hook(GLenum pname, const GLint *params) + { + glFogiv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFrontFace + extern "C" { GLAPI void GLAPIENTRY glFrontFace(GLenum mode); } + void OVR::GLEContext::glFrontFace_Hook(GLenum mode) + { + glFrontFace(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glFrustum + extern "C" { GLAPI void GLAPIENTRY glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); } + void OVR::GLEContext::glFrustum_Hook(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) + { + glFrustum(left, right, bottom, top, zNear, zFar); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGenLists + extern "C" { GLAPI GLuint GLAPIENTRY glGenLists(GLsizei range); } + GLuint OVR::GLEContext::glGenLists_Hook(GLsizei range) + { + GLuint u = glGenLists(range); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + #undef glGenTextures + extern "C" { GLAPI void GLAPIENTRY glGenTextures(GLsizei n, GLuint *textures); } + void OVR::GLEContext::glGenTextures_Hook(GLsizei n, GLuint *textures) + { + glGenTextures(n, textures); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetBooleanv + extern "C" { GLAPI void GLAPIENTRY glGetBooleanv(GLenum pname, GLboolean *params); } + void OVR::GLEContext::glGetBooleanv_Hook(GLenum pname, GLboolean *params) + { + glGetBooleanv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetClipPlane + extern "C" { GLAPI void GLAPIENTRY glGetClipPlane(GLenum plane, GLdouble *equation); } + void OVR::GLEContext::glGetClipPlane_Hook(GLenum plane, GLdouble *equation) + { + glGetClipPlane(plane, equation); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetDoublev + extern "C" { GLAPI void GLAPIENTRY glGetDoublev(GLenum pname, GLdouble *params); } + void OVR::GLEContext::glGetDoublev_Hook(GLenum pname, GLdouble *params) + { + glGetDoublev(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + //#undef glGetError Not needed because we happen to do this above already. + //extern "C" { GLAPI GLenum GLAPIENTRY glGetError(); } + GLenum OVR::GLEContext::glGetError_Hook() + { + GLenum e = glGetError(); + PostHook(GLE_CURRENT_FUNCTION); + return e; + } + + #undef glGetFloatv + extern "C" { GLAPI void GLAPIENTRY glGetFloatv(GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetFloatv_Hook(GLenum pname, GLfloat *params) + { + glGetFloatv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetIntegerv + extern "C" { GLAPI void GLAPIENTRY glGetIntegerv(GLenum pname, GLint *params); } + void OVR::GLEContext::glGetIntegerv_Hook(GLenum pname, GLint *params) + { + glGetIntegerv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetLightfv + extern "C" { GLAPI void GLAPIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetLightfv_Hook(GLenum light, GLenum pname, GLfloat *params) + { + glGetLightfv(light, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetLightiv + extern "C" { GLAPI void GLAPIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetLightiv_Hook(GLenum light, GLenum pname, GLint *params) + { + glGetLightiv(light, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetMapdv + extern "C" { GLAPI void GLAPIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v); } + void OVR::GLEContext::glGetMapdv_Hook(GLenum target, GLenum query, GLdouble *v) + { + glGetMapdv(target, query, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetMapfv + extern "C" { GLAPI void GLAPIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v); } + void OVR::GLEContext::glGetMapfv_Hook(GLenum target, GLenum query, GLfloat *v) + { + glGetMapfv(target, query, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetMapiv + extern "C" { GLAPI void GLAPIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v); } + void OVR::GLEContext::glGetMapiv_Hook(GLenum target, GLenum query, GLint *v) + { + glGetMapiv(target, query, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetMaterialfv + extern "C" { GLAPI void GLAPIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetMaterialfv_Hook(GLenum face, GLenum pname, GLfloat *params) + { + glGetMaterialfv(face, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetMaterialiv + extern "C" { GLAPI void GLAPIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetMaterialiv_Hook(GLenum face, GLenum pname, GLint *params) + { + glGetMaterialiv(face, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetPixelMapfv + extern "C" { GLAPI void GLAPIENTRY glGetPixelMapfv(GLenum map, GLfloat *values); } + void OVR::GLEContext::glGetPixelMapfv_Hook(GLenum map, GLfloat *values) + { + glGetPixelMapfv(map, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetPixelMapuiv + extern "C" { GLAPI void GLAPIENTRY glGetPixelMapuiv(GLenum map, GLuint *values); } + void OVR::GLEContext::glGetPixelMapuiv_Hook(GLenum map, GLuint *values) + { + glGetPixelMapuiv(map, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetPixelMapusv + extern "C" { GLAPI void GLAPIENTRY glGetPixelMapusv(GLenum map, GLushort *values); } + void OVR::GLEContext::glGetPixelMapusv_Hook(GLenum map, GLushort *values) + { + glGetPixelMapusv(map, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetPointerv + extern "C" { GLAPI void GLAPIENTRY glGetPointerv(GLenum pname, void* *params); } + void OVR::GLEContext::glGetPointerv_Hook(GLenum pname, void* *params) + { + glGetPointerv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetPolygonStipple + extern "C" { GLAPI void GLAPIENTRY glGetPolygonStipple(GLubyte *mask); } + void OVR::GLEContext::glGetPolygonStipple_Hook(GLubyte *mask) + { + glGetPolygonStipple(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + // #undef glGetString // This was already disabled above. + // extern "C" { GLAPI const GLubyte * GLAPIENTRY glGetString(GLenum name); } + const GLubyte * OVR::GLEContext::glGetString_Hook(GLenum name) + { + const GLubyte * p = glGetString(name); + PostHook(GLE_CURRENT_FUNCTION); + return p; + } + + #undef glGetTexEnvfv + extern "C" { GLAPI void GLAPIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetTexEnvfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + glGetTexEnvfv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexEnviv + extern "C" { GLAPI void GLAPIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetTexEnviv_Hook(GLenum target, GLenum pname, GLint *params) + { + glGetTexEnviv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexGendv + extern "C" { GLAPI void GLAPIENTRY glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params); } + void OVR::GLEContext::glGetTexGendv_Hook(GLenum coord, GLenum pname, GLdouble *params) + { + glGetTexGendv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexGenfv + extern "C" { GLAPI void GLAPIENTRY glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetTexGenfv_Hook(GLenum coord, GLenum pname, GLfloat *params) + { + glGetTexGenfv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexGeniv + extern "C" { GLAPI void GLAPIENTRY glGetTexGeniv(GLenum coord, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetTexGeniv_Hook(GLenum coord, GLenum pname, GLint *params) + { + glGetTexGeniv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexImage + extern "C" { GLAPI void GLAPIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); } + void OVR::GLEContext::glGetTexImage_Hook(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) + { + glGetTexImage(target, level, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexLevelParameterfv + extern "C" { GLAPI void GLAPIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetTexLevelParameterfv_Hook(GLenum target, GLint level, GLenum pname, GLfloat *params) + { + glGetTexLevelParameterfv(target, level, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexLevelParameteriv + extern "C" { GLAPI void GLAPIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetTexLevelParameteriv_Hook(GLenum target, GLint level, GLenum pname, GLint *params) + { + glGetTexLevelParameteriv(target, level, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexParameterfv + extern "C" { GLAPI void GLAPIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); } + void OVR::GLEContext::glGetTexParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + glGetTexParameterfv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glGetTexParameteriv + extern "C" { GLAPI void GLAPIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params); } + void OVR::GLEContext::glGetTexParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + glGetTexParameteriv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glHint + extern "C" { GLAPI void GLAPIENTRY glHint(GLenum target, GLenum mode); } + void OVR::GLEContext::glHint_Hook(GLenum target, GLenum mode) + { + glHint(target, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexMask + extern "C" { GLAPI void GLAPIENTRY glIndexMask(GLuint mask); } + void OVR::GLEContext::glIndexMask_Hook(GLuint mask) + { + glIndexMask(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexPointer + extern "C" { GLAPI void GLAPIENTRY glIndexPointer(GLenum type, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glIndexPointer_Hook(GLenum type, GLsizei stride, const void *pointer) + { + glIndexPointer(type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexd + extern "C" { GLAPI void GLAPIENTRY glIndexd(GLdouble c); } + void OVR::GLEContext::glIndexd_Hook(GLdouble c) + { + glIndexd(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexdv + extern "C" { GLAPI void GLAPIENTRY glIndexdv(const GLdouble *c); } + void OVR::GLEContext::glIndexdv_Hook(const GLdouble *c) + { + glIndexdv(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexf + extern "C" { GLAPI void GLAPIENTRY glIndexf(GLfloat c); } + void OVR::GLEContext::glIndexf_Hook(GLfloat c) + { + glIndexf(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexfv + extern "C" { GLAPI void GLAPIENTRY glIndexfv(const GLfloat *c); } + void OVR::GLEContext::glIndexfv_Hook(const GLfloat *c) + { + glIndexfv(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexi + extern "C" { GLAPI void GLAPIENTRY glIndexi(GLint c); } + void OVR::GLEContext::glIndexi_Hook(GLint c) + { + glIndexi(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexiv + extern "C" { GLAPI void GLAPIENTRY glIndexiv(const GLint *c); } + void OVR::GLEContext::glIndexiv_Hook(const GLint *c) + { + glIndexiv(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexs + extern "C" { GLAPI void GLAPIENTRY glIndexs(GLshort c); } + void OVR::GLEContext::glIndexs_Hook(GLshort c) + { + glIndexs(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexsv + extern "C" { GLAPI void GLAPIENTRY glIndexsv(const GLshort *c); } + void OVR::GLEContext::glIndexsv_Hook(const GLshort *c) + { + glIndexsv(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexub + extern "C" { GLAPI void GLAPIENTRY glIndexub(GLubyte c); } + void OVR::GLEContext::glIndexub_Hook(GLubyte c) + { + glIndexub(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIndexubv + extern "C" { GLAPI void GLAPIENTRY glIndexubv(const GLubyte *c); } + void OVR::GLEContext::glIndexubv_Hook(const GLubyte *c) + { + glIndexubv(c); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glInitNames + extern "C" { GLAPI void GLAPIENTRY glInitNames(); } + void OVR::GLEContext::glInitNames_Hook() + { + glInitNames(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glInterleavedArrays + extern "C" { GLAPI void GLAPIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glInterleavedArrays_Hook(GLenum format, GLsizei stride, const void *pointer) + { + glInterleavedArrays(format, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glIsEnabled + extern "C" { GLAPI GLboolean GLAPIENTRY glIsEnabled(GLenum cap); } + GLboolean OVR::GLEContext::glIsEnabled_Hook(GLenum cap) + { + GLboolean b = glIsEnabled(cap); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef glIsList + extern "C" { GLAPI GLboolean GLAPIENTRY glIsList(GLuint list); } + GLboolean OVR::GLEContext::glIsList_Hook(GLuint list) + { + GLboolean b = glIsList(list); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef glIsTexture + extern "C" { GLAPI GLboolean GLAPIENTRY glIsTexture(GLuint texture); } + GLboolean OVR::GLEContext::glIsTexture_Hook(GLuint texture) + { + GLboolean b = glIsTexture(texture); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef glLightModelf + extern "C" { GLAPI void GLAPIENTRY glLightModelf(GLenum pname, GLfloat param); } + void OVR::GLEContext::glLightModelf_Hook(GLenum pname, GLfloat param) + { + glLightModelf(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightModelfv + extern "C" { GLAPI void GLAPIENTRY glLightModelfv(GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glLightModelfv_Hook(GLenum pname, const GLfloat *params) + { + glLightModelfv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightModeli + extern "C" { GLAPI void GLAPIENTRY glLightModeli(GLenum pname, GLint param); } + void OVR::GLEContext::glLightModeli_Hook(GLenum pname, GLint param) + { + glLightModeli(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightModeliv + extern "C" { GLAPI void GLAPIENTRY glLightModeliv(GLenum pname, const GLint *params); } + void OVR::GLEContext::glLightModeliv_Hook(GLenum pname, const GLint *params) + { + glLightModeliv(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightf + extern "C" { GLAPI void GLAPIENTRY glLightf(GLenum light, GLenum pname, GLfloat param); } + void OVR::GLEContext::glLightf_Hook(GLenum light, GLenum pname, GLfloat param) + { + glLightf(light, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightfv + extern "C" { GLAPI void GLAPIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glLightfv_Hook(GLenum light, GLenum pname, const GLfloat *params) + { + glLightfv(light, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLighti + extern "C" { GLAPI void GLAPIENTRY glLighti(GLenum light, GLenum pname, GLint param); } + void OVR::GLEContext::glLighti_Hook(GLenum light, GLenum pname, GLint param) + { + glLighti(light, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLightiv + extern "C" { GLAPI void GLAPIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params); } + void OVR::GLEContext::glLightiv_Hook(GLenum light, GLenum pname, const GLint *params) + { + glLightiv(light, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLineStipple + extern "C" { GLAPI void GLAPIENTRY glLineStipple(GLint factor, GLushort pattern); } + void OVR::GLEContext::glLineStipple_Hook(GLint factor, GLushort pattern) + { + glLineStipple(factor, pattern); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLineWidth + extern "C" { GLAPI void GLAPIENTRY glLineWidth(GLfloat width); } + void OVR::GLEContext::glLineWidth_Hook(GLfloat width) + { + glLineWidth(width); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glListBase + extern "C" { GLAPI void GLAPIENTRY glListBase(GLuint base); } + void OVR::GLEContext::glListBase_Hook(GLuint base) + { + glListBase(base); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLoadIdentity + extern "C" { GLAPI void GLAPIENTRY glLoadIdentity(); } + void OVR::GLEContext::glLoadIdentity_Hook() + { + glLoadIdentity(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLoadMatrixd + extern "C" { GLAPI void GLAPIENTRY glLoadMatrixd(const GLdouble *m); } + void OVR::GLEContext::glLoadMatrixd_Hook(const GLdouble *m) + { + glLoadMatrixd(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLoadMatrixf + extern "C" { GLAPI void GLAPIENTRY glLoadMatrixf(const GLfloat *m); } + void OVR::GLEContext::glLoadMatrixf_Hook(const GLfloat *m) + { + glLoadMatrixf(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLoadName + extern "C" { GLAPI void GLAPIENTRY glLoadName(GLuint name); } + void OVR::GLEContext::glLoadName_Hook(GLuint name) + { + glLoadName(name); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glLogicOp + extern "C" { GLAPI void GLAPIENTRY glLogicOp(GLenum opcode); } + void OVR::GLEContext::glLogicOp_Hook(GLenum opcode) + { + glLogicOp(opcode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMap1d + extern "C" { GLAPI void GLAPIENTRY glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); } + void OVR::GLEContext::glMap1d_Hook(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) + { + glMap1d(target, u1, u2, stride, order, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMap1f + extern "C" { GLAPI void GLAPIENTRY glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); } + void OVR::GLEContext::glMap1f_Hook(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) + { + glMap1f(target, u1, u2, stride, order, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMap2d + extern "C" { GLAPI void GLAPIENTRY glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); } + void OVR::GLEContext::glMap2d_Hook(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) + { + glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMap2f + extern "C" { GLAPI void GLAPIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); } + void OVR::GLEContext::glMap2f_Hook(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) + { + glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMapGrid1d + extern "C" { GLAPI void GLAPIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2); } + void OVR::GLEContext::glMapGrid1d_Hook(GLint un, GLdouble u1, GLdouble u2) + { + glMapGrid1d(un, u1, u2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMapGrid1f + extern "C" { GLAPI void GLAPIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2); } + void OVR::GLEContext::glMapGrid1f_Hook(GLint un, GLfloat u1, GLfloat u2) + { + glMapGrid1f(un, u1, u2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMapGrid2d + extern "C" { GLAPI void GLAPIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); } + void OVR::GLEContext::glMapGrid2d_Hook(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) + { + glMapGrid2d(un, u1, u2, vn, v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMapGrid2f + extern "C" { GLAPI void GLAPIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); } + void OVR::GLEContext::glMapGrid2f_Hook(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) + { + glMapGrid2f(un, u1, u2, vn, v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMaterialf + extern "C" { GLAPI void GLAPIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param); } + void OVR::GLEContext::glMaterialf_Hook(GLenum face, GLenum pname, GLfloat param) + { + glMaterialf(face, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMaterialfv + extern "C" { GLAPI void GLAPIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glMaterialfv_Hook(GLenum face, GLenum pname, const GLfloat *params) + { + glMaterialfv(face, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMateriali + extern "C" { GLAPI void GLAPIENTRY glMateriali(GLenum face, GLenum pname, GLint param); } + void OVR::GLEContext::glMateriali_Hook(GLenum face, GLenum pname, GLint param) + { + glMateriali(face, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMaterialiv + extern "C" { GLAPI void GLAPIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params); } + void OVR::GLEContext::glMaterialiv_Hook(GLenum face, GLenum pname, const GLint *params) + { + glMaterialiv(face, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMatrixMode + extern "C" { GLAPI void GLAPIENTRY glMatrixMode(GLenum mode); } + void OVR::GLEContext::glMatrixMode_Hook(GLenum mode) + { + glMatrixMode(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMultMatrixd + extern "C" { GLAPI void GLAPIENTRY glMultMatrixd(const GLdouble *m); } + void OVR::GLEContext::glMultMatrixd_Hook(const GLdouble *m) + { + glMultMatrixd(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glMultMatrixf + extern "C" { GLAPI void GLAPIENTRY glMultMatrixf(const GLfloat *m); } + void OVR::GLEContext::glMultMatrixf_Hook(const GLfloat *m) + { + glMultMatrixf(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNewList + extern "C" { GLAPI void GLAPIENTRY glNewList(GLuint list, GLenum mode); } + void OVR::GLEContext::glNewList_Hook(GLuint list, GLenum mode) + { + glNewList(list, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3b + extern "C" { GLAPI void GLAPIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz); } + void OVR::GLEContext::glNormal3b_Hook(GLbyte nx, GLbyte ny, GLbyte nz) + { + glNormal3b(nx, ny, nz); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3bv + extern "C" { GLAPI void GLAPIENTRY glNormal3bv(const GLbyte *v); } + void OVR::GLEContext::glNormal3bv_Hook(const GLbyte *v) + { + glNormal3bv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3d + extern "C" { GLAPI void GLAPIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz); } + void OVR::GLEContext::glNormal3d_Hook(GLdouble nx, GLdouble ny, GLdouble nz) + { + glNormal3d(nx, ny, nz); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3dv + extern "C" { GLAPI void GLAPIENTRY glNormal3dv(const GLdouble *v); } + void OVR::GLEContext::glNormal3dv_Hook(const GLdouble *v) + { + glNormal3dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3f + extern "C" { GLAPI void GLAPIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); } + void OVR::GLEContext::glNormal3f_Hook(GLfloat nx, GLfloat ny, GLfloat nz) + { + glNormal3f(nx, ny, nz); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3fv + extern "C" { GLAPI void GLAPIENTRY glNormal3fv(const GLfloat *v); } + void OVR::GLEContext::glNormal3fv_Hook(const GLfloat *v) + { + glNormal3fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3i + extern "C" { GLAPI void GLAPIENTRY glNormal3i(GLint nx, GLint ny, GLint nz); } + void OVR::GLEContext::glNormal3i_Hook(GLint nx, GLint ny, GLint nz) + { + glNormal3i(nx, ny, nz); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3iv + extern "C" { GLAPI void GLAPIENTRY glNormal3iv(const GLint *v); } + void OVR::GLEContext::glNormal3iv_Hook(const GLint *v) + { + glNormal3iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3s + extern "C" { GLAPI void GLAPIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz); } + void OVR::GLEContext::glNormal3s_Hook(GLshort nx, GLshort ny, GLshort nz) + { + glNormal3s(nx, ny, nz); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormal3sv + extern "C" { GLAPI void GLAPIENTRY glNormal3sv(const GLshort *v); } + void OVR::GLEContext::glNormal3sv_Hook(const GLshort *v) + { + glNormal3sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glNormalPointer + extern "C" { GLAPI void GLAPIENTRY glNormalPointer(GLenum type, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glNormalPointer_Hook(GLenum type, GLsizei stride, const void *pointer) + { + glNormalPointer(type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glOrtho + extern "C" { GLAPI void GLAPIENTRY glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); } + void OVR::GLEContext::glOrtho_Hook(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) + { + glOrtho(left, right, bottom, top, zNear, zFar); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPassThrough + extern "C" { GLAPI void GLAPIENTRY glPassThrough(GLfloat token); } + void OVR::GLEContext::glPassThrough_Hook(GLfloat token) + { + glPassThrough(token); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelMapfv + extern "C" { GLAPI void GLAPIENTRY glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values); } + void OVR::GLEContext::glPixelMapfv_Hook(GLenum map, GLsizei mapsize, const GLfloat *values) + { + glPixelMapfv(map, mapsize, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelMapuiv + extern "C" { GLAPI void GLAPIENTRY glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values); } + void OVR::GLEContext::glPixelMapuiv_Hook(GLenum map, GLsizei mapsize, const GLuint *values) + { + glPixelMapuiv(map, mapsize, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelMapusv + extern "C" { GLAPI void GLAPIENTRY glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values); } + void OVR::GLEContext::glPixelMapusv_Hook(GLenum map, GLsizei mapsize, const GLushort *values) + { + glPixelMapusv(map, mapsize, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelStoref + extern "C" { GLAPI void GLAPIENTRY glPixelStoref(GLenum pname, GLfloat param); } + void OVR::GLEContext::glPixelStoref_Hook(GLenum pname, GLfloat param) + { + glPixelStoref(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelStorei + extern "C" { GLAPI void GLAPIENTRY glPixelStorei(GLenum pname, GLint param); } + void OVR::GLEContext::glPixelStorei_Hook(GLenum pname, GLint param) + { + glPixelStorei(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelTransferf + extern "C" { GLAPI void GLAPIENTRY glPixelTransferf(GLenum pname, GLfloat param); } + void OVR::GLEContext::glPixelTransferf_Hook(GLenum pname, GLfloat param) + { + glPixelTransferf(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelTransferi + extern "C" { GLAPI void GLAPIENTRY glPixelTransferi(GLenum pname, GLint param); } + void OVR::GLEContext::glPixelTransferi_Hook(GLenum pname, GLint param) + { + glPixelTransferi(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPixelZoom + extern "C" { GLAPI void GLAPIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor); } + void OVR::GLEContext::glPixelZoom_Hook(GLfloat xfactor, GLfloat yfactor) + { + glPixelZoom(xfactor, yfactor); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPointSize + extern "C" { GLAPI void GLAPIENTRY glPointSize(GLfloat size); } + void OVR::GLEContext::glPointSize_Hook(GLfloat size) + { + glPointSize(size); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPolygonMode + extern "C" { GLAPI void GLAPIENTRY glPolygonMode(GLenum face, GLenum mode); } + void OVR::GLEContext::glPolygonMode_Hook(GLenum face, GLenum mode) + { + glPolygonMode(face, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPolygonOffset + extern "C" { GLAPI void GLAPIENTRY glPolygonOffset(GLfloat factor, GLfloat units); } + void OVR::GLEContext::glPolygonOffset_Hook(GLfloat factor, GLfloat units) + { + glPolygonOffset(factor, units); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPolygonStipple + extern "C" { GLAPI void GLAPIENTRY glPolygonStipple(const GLubyte *mask); } + void OVR::GLEContext::glPolygonStipple_Hook(const GLubyte *mask) + { + glPolygonStipple(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPopAttrib + extern "C" { GLAPI void GLAPIENTRY glPopAttrib(); } + void OVR::GLEContext::glPopAttrib_Hook() + { + glPopAttrib(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPopClientAttrib + extern "C" { GLAPI void GLAPIENTRY glPopClientAttrib(); } + void OVR::GLEContext::glPopClientAttrib_Hook() + { + glPopClientAttrib(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPopMatrix + extern "C" { GLAPI void GLAPIENTRY glPopMatrix(); } + void OVR::GLEContext::glPopMatrix_Hook() + { + glPopMatrix(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPopName + extern "C" { GLAPI void GLAPIENTRY glPopName(); } + void OVR::GLEContext::glPopName_Hook() + { + glPopName(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPrioritizeTextures + extern "C" { GLAPI void GLAPIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities); } + void OVR::GLEContext::glPrioritizeTextures_Hook(GLsizei n, const GLuint *textures, const GLclampf *priorities) + { + glPrioritizeTextures(n, textures, priorities); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPushAttrib + extern "C" { GLAPI void GLAPIENTRY glPushAttrib(GLbitfield mask); } + void OVR::GLEContext::glPushAttrib_Hook(GLbitfield mask) + { + glPushAttrib(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPushClientAttrib + extern "C" { GLAPI void GLAPIENTRY glPushClientAttrib(GLbitfield mask); } + void OVR::GLEContext::glPushClientAttrib_Hook(GLbitfield mask) + { + glPushClientAttrib(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPushMatrix + extern "C" { GLAPI void GLAPIENTRY glPushMatrix(); } + void OVR::GLEContext::glPushMatrix_Hook() + { + glPushMatrix(); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glPushName + extern "C" { GLAPI void GLAPIENTRY glPushName(GLuint name); } + void OVR::GLEContext::glPushName_Hook(GLuint name) + { + glPushName(name); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2d + extern "C" { GLAPI void GLAPIENTRY glRasterPos2d(GLdouble x, GLdouble y); } + void OVR::GLEContext::glRasterPos2d_Hook(GLdouble x, GLdouble y) + { + glRasterPos2d(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2dv + extern "C" { GLAPI void GLAPIENTRY glRasterPos2dv(const GLdouble *v); } + void OVR::GLEContext::glRasterPos2dv_Hook(const GLdouble *v) + { + glRasterPos2dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2f + extern "C" { GLAPI void GLAPIENTRY glRasterPos2f(GLfloat x, GLfloat y); } + void OVR::GLEContext::glRasterPos2f_Hook(GLfloat x, GLfloat y) + { + glRasterPos2f(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2fv + extern "C" { GLAPI void GLAPIENTRY glRasterPos2fv(const GLfloat *v); } + void OVR::GLEContext::glRasterPos2fv_Hook(const GLfloat *v) + { + glRasterPos2fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2i + extern "C" { GLAPI void GLAPIENTRY glRasterPos2i(GLint x, GLint y); } + void OVR::GLEContext::glRasterPos2i_Hook(GLint x, GLint y) + { + glRasterPos2i(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2iv + extern "C" { GLAPI void GLAPIENTRY glRasterPos2iv(const GLint *v); } + void OVR::GLEContext::glRasterPos2iv_Hook(const GLint *v) + { + glRasterPos2iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2s + extern "C" { GLAPI void GLAPIENTRY glRasterPos2s(GLshort x, GLshort y); } + void OVR::GLEContext::glRasterPos2s_Hook(GLshort x, GLshort y) + { + glRasterPos2s(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos2sv + extern "C" { GLAPI void GLAPIENTRY glRasterPos2sv(const GLshort *v); } + void OVR::GLEContext::glRasterPos2sv_Hook(const GLshort *v) + { + glRasterPos2sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3d + extern "C" { GLAPI void GLAPIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z); } + void OVR::GLEContext::glRasterPos3d_Hook(GLdouble x, GLdouble y, GLdouble z) + { + glRasterPos3d(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3dv + extern "C" { GLAPI void GLAPIENTRY glRasterPos3dv(const GLdouble *v); } + void OVR::GLEContext::glRasterPos3dv_Hook(const GLdouble *v) + { + glRasterPos3dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3f + extern "C" { GLAPI void GLAPIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z); } + void OVR::GLEContext::glRasterPos3f_Hook(GLfloat x, GLfloat y, GLfloat z) + { + glRasterPos3f(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3fv + extern "C" { GLAPI void GLAPIENTRY glRasterPos3fv(const GLfloat *v); } + void OVR::GLEContext::glRasterPos3fv_Hook(const GLfloat *v) + { + glRasterPos3fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3i + extern "C" { GLAPI void GLAPIENTRY glRasterPos3i(GLint x, GLint y, GLint z); } + void OVR::GLEContext::glRasterPos3i_Hook(GLint x, GLint y, GLint z) + { + glRasterPos3i(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3iv + extern "C" { GLAPI void GLAPIENTRY glRasterPos3iv(const GLint *v); } + void OVR::GLEContext::glRasterPos3iv_Hook(const GLint *v) + { + glRasterPos3iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3s + extern "C" { GLAPI void GLAPIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z); } + void OVR::GLEContext::glRasterPos3s_Hook(GLshort x, GLshort y, GLshort z) + { + glRasterPos3s(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos3sv + extern "C" { GLAPI void GLAPIENTRY glRasterPos3sv(const GLshort *v); } + void OVR::GLEContext::glRasterPos3sv_Hook(const GLshort *v) + { + glRasterPos3sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4d + extern "C" { GLAPI void GLAPIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); } + void OVR::GLEContext::glRasterPos4d_Hook(GLdouble x, GLdouble y, GLdouble z, GLdouble w) + { + glRasterPos4d(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4dv + extern "C" { GLAPI void GLAPIENTRY glRasterPos4dv(const GLdouble *v); } + void OVR::GLEContext::glRasterPos4dv_Hook(const GLdouble *v) + { + glRasterPos4dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4f + extern "C" { GLAPI void GLAPIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); } + void OVR::GLEContext::glRasterPos4f_Hook(GLfloat x, GLfloat y, GLfloat z, GLfloat w) + { + glRasterPos4f(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4fv + extern "C" { GLAPI void GLAPIENTRY glRasterPos4fv(const GLfloat *v); } + void OVR::GLEContext::glRasterPos4fv_Hook(const GLfloat *v) + { + glRasterPos4fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4i + extern "C" { GLAPI void GLAPIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w); } + void OVR::GLEContext::glRasterPos4i_Hook(GLint x, GLint y, GLint z, GLint w) + { + glRasterPos4i(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4iv + extern "C" { GLAPI void GLAPIENTRY glRasterPos4iv(const GLint *v); } + void OVR::GLEContext::glRasterPos4iv_Hook(const GLint *v) + { + glRasterPos4iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4s + extern "C" { GLAPI void GLAPIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w); } + void OVR::GLEContext::glRasterPos4s_Hook(GLshort x, GLshort y, GLshort z, GLshort w) + { + glRasterPos4s(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRasterPos4sv + extern "C" { GLAPI void GLAPIENTRY glRasterPos4sv(const GLshort *v); } + void OVR::GLEContext::glRasterPos4sv_Hook(const GLshort *v) + { + glRasterPos4sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glReadBuffer + extern "C" { GLAPI void GLAPIENTRY glReadBuffer(GLenum mode); } + void OVR::GLEContext::glReadBuffer_Hook(GLenum mode) + { + glReadBuffer(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glReadPixels + extern "C" { GLAPI void GLAPIENTRY glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); } + void OVR::GLEContext::glReadPixels_Hook(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) + { + glReadPixels(x, y, width, height, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectd + extern "C" { GLAPI void GLAPIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); } + void OVR::GLEContext::glRectd_Hook(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) + { + glRectd(x1, y1, x2, y2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectdv + extern "C" { GLAPI void GLAPIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2); } + void OVR::GLEContext::glRectdv_Hook(const GLdouble *v1, const GLdouble *v2) + { + glRectdv(v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectf + extern "C" { GLAPI void GLAPIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); } + void OVR::GLEContext::glRectf_Hook(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) + { + glRectf(x1, y1, x2, y2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectfv + extern "C" { GLAPI void GLAPIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2); } + void OVR::GLEContext::glRectfv_Hook(const GLfloat *v1, const GLfloat *v2) + { + glRectfv(v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRecti + extern "C" { GLAPI void GLAPIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2); } + void OVR::GLEContext::glRecti_Hook(GLint x1, GLint y1, GLint x2, GLint y2) + { + glRecti(x1, y1, x2, y2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectiv + extern "C" { GLAPI void GLAPIENTRY glRectiv(const GLint *v1, const GLint *v2); } + void OVR::GLEContext::glRectiv_Hook(const GLint *v1, const GLint *v2) + { + glRectiv(v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRects + extern "C" { GLAPI void GLAPIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2); } + void OVR::GLEContext::glRects_Hook(GLshort x1, GLshort y1, GLshort x2, GLshort y2) + { + glRects(x1, y1, x2, y2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRectsv + extern "C" { GLAPI void GLAPIENTRY glRectsv(const GLshort *v1, const GLshort *v2); } + void OVR::GLEContext::glRectsv_Hook(const GLshort *v1, const GLshort *v2) + { + glRectsv(v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRenderMode + extern "C" { GLAPI GLint GLAPIENTRY glRenderMode(GLenum mode); } + GLint OVR::GLEContext::glRenderMode_Hook(GLenum mode) + { + GLint i = glRenderMode(mode); + PostHook(GLE_CURRENT_FUNCTION); + return i; + } + + #undef glRotated + extern "C" { GLAPI void GLAPIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); } + void OVR::GLEContext::glRotated_Hook(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) + { + glRotated(angle, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glRotatef + extern "C" { GLAPI void GLAPIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); } + void OVR::GLEContext::glRotatef_Hook(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) + { + glRotatef(angle, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glScaled + extern "C" { GLAPI void GLAPIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z); } + void OVR::GLEContext::glScaled_Hook(GLdouble x, GLdouble y, GLdouble z) + { + glScaled(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glScalef + extern "C" { GLAPI void GLAPIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z); } + void OVR::GLEContext::glScalef_Hook(GLfloat x, GLfloat y, GLfloat z) + { + glScalef(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glScissor + extern "C" { GLAPI void GLAPIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height); } + void OVR::GLEContext::glScissor_Hook(GLint x, GLint y, GLsizei width, GLsizei height) + { + glScissor(x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glSelectBuffer + extern "C" { GLAPI void GLAPIENTRY glSelectBuffer(GLsizei size, GLuint *buffer); } + void OVR::GLEContext::glSelectBuffer_Hook(GLsizei size, GLuint *buffer) + { + glSelectBuffer(size, buffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glShadeModel + extern "C" { GLAPI void GLAPIENTRY glShadeModel(GLenum mode); } + void OVR::GLEContext::glShadeModel_Hook(GLenum mode) + { + glShadeModel(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glStencilFunc + extern "C" { GLAPI void GLAPIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask); } + void OVR::GLEContext::glStencilFunc_Hook(GLenum func, GLint ref, GLuint mask) + { + glStencilFunc(func, ref, mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glStencilMask + extern "C" { GLAPI void GLAPIENTRY glStencilMask(GLuint mask); } + void OVR::GLEContext::glStencilMask_Hook(GLuint mask) + { + glStencilMask(mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glStencilOp + extern "C" { GLAPI void GLAPIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass); } + void OVR::GLEContext::glStencilOp_Hook(GLenum fail, GLenum zfail, GLenum zpass) + { + glStencilOp(fail, zfail, zpass); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1d + extern "C" { GLAPI void GLAPIENTRY glTexCoord1d(GLdouble s); } + void OVR::GLEContext::glTexCoord1d_Hook(GLdouble s) + { + glTexCoord1d(s); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1dv + extern "C" { GLAPI void GLAPIENTRY glTexCoord1dv(const GLdouble *v); } + void OVR::GLEContext::glTexCoord1dv_Hook(const GLdouble *v) + { + glTexCoord1dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1f + extern "C" { GLAPI void GLAPIENTRY glTexCoord1f(GLfloat s); } + void OVR::GLEContext::glTexCoord1f_Hook(GLfloat s) + { + glTexCoord1f(s); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1fv + extern "C" { GLAPI void GLAPIENTRY glTexCoord1fv(const GLfloat *v); } + void OVR::GLEContext::glTexCoord1fv_Hook(const GLfloat *v) + { + glTexCoord1fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1i + extern "C" { GLAPI void GLAPIENTRY glTexCoord1i(GLint s); } + void OVR::GLEContext::glTexCoord1i_Hook(GLint s) + { + glTexCoord1i(s); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1iv + extern "C" { GLAPI void GLAPIENTRY glTexCoord1iv(const GLint *v); } + void OVR::GLEContext::glTexCoord1iv_Hook(const GLint *v) + { + glTexCoord1iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1s + extern "C" { GLAPI void GLAPIENTRY glTexCoord1s(GLshort s); } + void OVR::GLEContext::glTexCoord1s_Hook(GLshort s) + { + glTexCoord1s(s); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord1sv + extern "C" { GLAPI void GLAPIENTRY glTexCoord1sv(const GLshort *v); } + void OVR::GLEContext::glTexCoord1sv_Hook(const GLshort *v) + { + glTexCoord1sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2d + extern "C" { GLAPI void GLAPIENTRY glTexCoord2d(GLdouble s, GLdouble t); } + void OVR::GLEContext::glTexCoord2d_Hook(GLdouble s, GLdouble t) + { + glTexCoord2d(s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2dv + extern "C" { GLAPI void GLAPIENTRY glTexCoord2dv(const GLdouble *v); } + void OVR::GLEContext::glTexCoord2dv_Hook(const GLdouble *v) + { + glTexCoord2dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2f + extern "C" { GLAPI void GLAPIENTRY glTexCoord2f(GLfloat s, GLfloat t); } + void OVR::GLEContext::glTexCoord2f_Hook(GLfloat s, GLfloat t) + { + glTexCoord2f(s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2fv + extern "C" { GLAPI void GLAPIENTRY glTexCoord2fv(const GLfloat *v); } + void OVR::GLEContext::glTexCoord2fv_Hook(const GLfloat *v) + { + glTexCoord2fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2i + extern "C" { GLAPI void GLAPIENTRY glTexCoord2i(GLint s, GLint t); } + void OVR::GLEContext::glTexCoord2i_Hook(GLint s, GLint t) + { + glTexCoord2i(s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2iv + extern "C" { GLAPI void GLAPIENTRY glTexCoord2iv(const GLint *v); } + void OVR::GLEContext::glTexCoord2iv_Hook(const GLint *v) + { + glTexCoord2iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2s + extern "C" { GLAPI void GLAPIENTRY glTexCoord2s(GLshort s, GLshort t); } + void OVR::GLEContext::glTexCoord2s_Hook(GLshort s, GLshort t) + { + glTexCoord2s(s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord2sv + extern "C" { GLAPI void GLAPIENTRY glTexCoord2sv(const GLshort *v); } + void OVR::GLEContext::glTexCoord2sv_Hook(const GLshort *v) + { + glTexCoord2sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3d + extern "C" { GLAPI void GLAPIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r); } + void OVR::GLEContext::glTexCoord3d_Hook(GLdouble s, GLdouble t, GLdouble r) + { + glTexCoord3d(s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3dv + extern "C" { GLAPI void GLAPIENTRY glTexCoord3dv(const GLdouble *v); } + void OVR::GLEContext::glTexCoord3dv_Hook(const GLdouble *v) + { + glTexCoord3dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3f + extern "C" { GLAPI void GLAPIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r); } + void OVR::GLEContext::glTexCoord3f_Hook(GLfloat s, GLfloat t, GLfloat r) + { + glTexCoord3f(s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3fv + extern "C" { GLAPI void GLAPIENTRY glTexCoord3fv(const GLfloat *v); } + void OVR::GLEContext::glTexCoord3fv_Hook(const GLfloat *v) + { + glTexCoord3fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3i + extern "C" { GLAPI void GLAPIENTRY glTexCoord3i(GLint s, GLint t, GLint r); } + void OVR::GLEContext::glTexCoord3i_Hook(GLint s, GLint t, GLint r) + { + glTexCoord3i(s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3iv + extern "C" { GLAPI void GLAPIENTRY glTexCoord3iv(const GLint *v); } + void OVR::GLEContext::glTexCoord3iv_Hook(const GLint *v) + { + glTexCoord3iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3s + extern "C" { GLAPI void GLAPIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r); } + void OVR::GLEContext::glTexCoord3s_Hook(GLshort s, GLshort t, GLshort r) + { + glTexCoord3s(s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord3sv + extern "C" { GLAPI void GLAPIENTRY glTexCoord3sv(const GLshort *v); } + void OVR::GLEContext::glTexCoord3sv_Hook(const GLshort *v) + { + glTexCoord3sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4d + extern "C" { GLAPI void GLAPIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q); } + void OVR::GLEContext::glTexCoord4d_Hook(GLdouble s, GLdouble t, GLdouble r, GLdouble q) + { + glTexCoord4d(s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4dv + extern "C" { GLAPI void GLAPIENTRY glTexCoord4dv(const GLdouble *v); } + void OVR::GLEContext::glTexCoord4dv_Hook(const GLdouble *v) + { + glTexCoord4dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4f + extern "C" { GLAPI void GLAPIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q); } + void OVR::GLEContext::glTexCoord4f_Hook(GLfloat s, GLfloat t, GLfloat r, GLfloat q) + { + glTexCoord4f(s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4fv + extern "C" { GLAPI void GLAPIENTRY glTexCoord4fv(const GLfloat *v); } + void OVR::GLEContext::glTexCoord4fv_Hook(const GLfloat *v) + { + glTexCoord4fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4i + extern "C" { GLAPI void GLAPIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q); } + void OVR::GLEContext::glTexCoord4i_Hook(GLint s, GLint t, GLint r, GLint q) + { + glTexCoord4i(s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4iv + extern "C" { GLAPI void GLAPIENTRY glTexCoord4iv(const GLint *v); } + void OVR::GLEContext::glTexCoord4iv_Hook(const GLint *v) + { + glTexCoord4iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4s + extern "C" { GLAPI void GLAPIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q); } + void OVR::GLEContext::glTexCoord4s_Hook(GLshort s, GLshort t, GLshort r, GLshort q) + { + glTexCoord4s(s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoord4sv + extern "C" { GLAPI void GLAPIENTRY glTexCoord4sv(const GLshort *v); } + void OVR::GLEContext::glTexCoord4sv_Hook(const GLshort *v) + { + glTexCoord4sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexCoordPointer + extern "C" { GLAPI void GLAPIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glTexCoordPointer_Hook(GLint size, GLenum type, GLsizei stride, const void *pointer) + { + glTexCoordPointer(size, type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexEnvf + extern "C" { GLAPI void GLAPIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param); } + void OVR::GLEContext::glTexEnvf_Hook(GLenum target, GLenum pname, GLfloat param) + { + glTexEnvf(target, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexEnvfv + extern "C" { GLAPI void GLAPIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glTexEnvfv_Hook(GLenum target, GLenum pname, const GLfloat *params) + { + glTexEnvfv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexEnvi + extern "C" { GLAPI void GLAPIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param); } + void OVR::GLEContext::glTexEnvi_Hook(GLenum target, GLenum pname, GLint param) + { + glTexEnvi(target, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexEnviv + extern "C" { GLAPI void GLAPIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params); } + void OVR::GLEContext::glTexEnviv_Hook(GLenum target, GLenum pname, const GLint *params) + { + glTexEnviv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGend + extern "C" { GLAPI void GLAPIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param); } + void OVR::GLEContext::glTexGend_Hook(GLenum coord, GLenum pname, GLdouble param) + { + glTexGend(coord, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGendv + extern "C" { GLAPI void GLAPIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params); } + void OVR::GLEContext::glTexGendv_Hook(GLenum coord, GLenum pname, const GLdouble *params) + { + glTexGendv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGenf + extern "C" { GLAPI void GLAPIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param); } + void OVR::GLEContext::glTexGenf_Hook(GLenum coord, GLenum pname, GLfloat param) + { + glTexGenf(coord, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGenfv + extern "C" { GLAPI void GLAPIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glTexGenfv_Hook(GLenum coord, GLenum pname, const GLfloat *params) + { + glTexGenfv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGeni + extern "C" { GLAPI void GLAPIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param); } + void OVR::GLEContext::glTexGeni_Hook(GLenum coord, GLenum pname, GLint param) + { + glTexGeni(coord, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexGeniv + extern "C" { GLAPI void GLAPIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params); } + void OVR::GLEContext::glTexGeniv_Hook(GLenum coord, GLenum pname, const GLint *params) + { + glTexGeniv(coord, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexImage1D + extern "C" { GLAPI void GLAPIENTRY glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); } + void OVR::GLEContext::glTexImage1D_Hook(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) + { + glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexImage2D + extern "C" { GLAPI void GLAPIENTRY glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); } + void OVR::GLEContext::glTexImage2D_Hook(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) + { + glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexParameterf + extern "C" { GLAPI void GLAPIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param); } + void OVR::GLEContext::glTexParameterf_Hook(GLenum target, GLenum pname, GLfloat param) + { + glTexParameterf(target, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexParameterfv + extern "C" { GLAPI void GLAPIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params); } + void OVR::GLEContext::glTexParameterfv_Hook(GLenum target, GLenum pname, const GLfloat *params) + { + glTexParameterfv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexParameteri + extern "C" { GLAPI void GLAPIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param); } + void OVR::GLEContext::glTexParameteri_Hook(GLenum target, GLenum pname, GLint param) + { + glTexParameteri(target, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexParameteriv + extern "C" { GLAPI void GLAPIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params); } + void OVR::GLEContext::glTexParameteriv_Hook(GLenum target, GLenum pname, const GLint *params) + { + glTexParameteriv(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexSubImage1D + extern "C" { GLAPI void GLAPIENTRY glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); } + void OVR::GLEContext::glTexSubImage1D_Hook(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) + { + glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTexSubImage2D + extern "C" { GLAPI void GLAPIENTRY glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); } + void OVR::GLEContext::glTexSubImage2D_Hook(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) + { + glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTranslated + extern "C" { GLAPI void GLAPIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z); } + void OVR::GLEContext::glTranslated_Hook(GLdouble x, GLdouble y, GLdouble z) + { + glTranslated(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glTranslatef + extern "C" { GLAPI void GLAPIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z); } + void OVR::GLEContext::glTranslatef_Hook(GLfloat x, GLfloat y, GLfloat z) + { + glTranslatef(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2d + extern "C" { GLAPI void GLAPIENTRY glVertex2d(GLdouble x, GLdouble y); } + void OVR::GLEContext::glVertex2d_Hook(GLdouble x, GLdouble y) + { + glVertex2d(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2dv + extern "C" { GLAPI void GLAPIENTRY glVertex2dv(const GLdouble *v); } + void OVR::GLEContext::glVertex2dv_Hook(const GLdouble *v) + { + glVertex2dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2f + extern "C" { GLAPI void GLAPIENTRY glVertex2f(GLfloat x, GLfloat y); } + void OVR::GLEContext::glVertex2f_Hook(GLfloat x, GLfloat y) + { + glVertex2f(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2fv + extern "C" { GLAPI void GLAPIENTRY glVertex2fv(const GLfloat *v); } + void OVR::GLEContext::glVertex2fv_Hook(const GLfloat *v) + { + glVertex2fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2i + extern "C" { GLAPI void GLAPIENTRY glVertex2i(GLint x, GLint y); } + void OVR::GLEContext::glVertex2i_Hook(GLint x, GLint y) + { + glVertex2i(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2iv + extern "C" { GLAPI void GLAPIENTRY glVertex2iv(const GLint *v); } + void OVR::GLEContext::glVertex2iv_Hook(const GLint *v) + { + glVertex2iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2s + extern "C" { GLAPI void GLAPIENTRY glVertex2s(GLshort x, GLshort y); } + void OVR::GLEContext::glVertex2s_Hook(GLshort x, GLshort y) + { + glVertex2s(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex2sv + extern "C" { GLAPI void GLAPIENTRY glVertex2sv(const GLshort *v); } + void OVR::GLEContext::glVertex2sv_Hook(const GLshort *v) + { + glVertex2sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3d + extern "C" { GLAPI void GLAPIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z); } + void OVR::GLEContext::glVertex3d_Hook(GLdouble x, GLdouble y, GLdouble z) + { + glVertex3d(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3dv + extern "C" { GLAPI void GLAPIENTRY glVertex3dv(const GLdouble *v); } + void OVR::GLEContext::glVertex3dv_Hook(const GLdouble *v) + { + glVertex3dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3f + extern "C" { GLAPI void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z); } + void OVR::GLEContext::glVertex3f_Hook(GLfloat x, GLfloat y, GLfloat z) + { + glVertex3f(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3fv + extern "C" { GLAPI void GLAPIENTRY glVertex3fv(const GLfloat *v); } + void OVR::GLEContext::glVertex3fv_Hook(const GLfloat *v) + { + glVertex3fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3i + extern "C" { GLAPI void GLAPIENTRY glVertex3i(GLint x, GLint y, GLint z); } + void OVR::GLEContext::glVertex3i_Hook(GLint x, GLint y, GLint z) + { + glVertex3i(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3iv + extern "C" { GLAPI void GLAPIENTRY glVertex3iv(const GLint *v); } + void OVR::GLEContext::glVertex3iv_Hook(const GLint *v) + { + glVertex3iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3s + extern "C" { GLAPI void GLAPIENTRY glVertex3s(GLshort x, GLshort y, GLshort z); } + void OVR::GLEContext::glVertex3s_Hook(GLshort x, GLshort y, GLshort z) + { + glVertex3s(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex3sv + extern "C" { GLAPI void GLAPIENTRY glVertex3sv(const GLshort *v); } + void OVR::GLEContext::glVertex3sv_Hook(const GLshort *v) + { + glVertex3sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4d + extern "C" { GLAPI void GLAPIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); } + void OVR::GLEContext::glVertex4d_Hook(GLdouble x, GLdouble y, GLdouble z, GLdouble w) + { + glVertex4d(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4dv + extern "C" { GLAPI void GLAPIENTRY glVertex4dv(const GLdouble *v); } + void OVR::GLEContext::glVertex4dv_Hook(const GLdouble *v) + { + glVertex4dv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4f + extern "C" { GLAPI void GLAPIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); } + void OVR::GLEContext::glVertex4f_Hook(GLfloat x, GLfloat y, GLfloat z, GLfloat w) + { + glVertex4f(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4fv + extern "C" { GLAPI void GLAPIENTRY glVertex4fv(const GLfloat *v); } + void OVR::GLEContext::glVertex4fv_Hook(const GLfloat *v) + { + glVertex4fv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4i + extern "C" { GLAPI void GLAPIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w); } + void OVR::GLEContext::glVertex4i_Hook(GLint x, GLint y, GLint z, GLint w) + { + glVertex4i(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4iv + extern "C" { GLAPI void GLAPIENTRY glVertex4iv(const GLint *v); } + void OVR::GLEContext::glVertex4iv_Hook(const GLint *v) + { + glVertex4iv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4s + extern "C" { GLAPI void GLAPIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w); } + void OVR::GLEContext::glVertex4s_Hook(GLshort x, GLshort y, GLshort z, GLshort w) + { + glVertex4s(x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertex4sv + extern "C" { GLAPI void GLAPIENTRY glVertex4sv(const GLshort *v); } + void OVR::GLEContext::glVertex4sv_Hook(const GLshort *v) + { + glVertex4sv(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glVertexPointer + extern "C" { GLAPI void GLAPIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); } + void OVR::GLEContext::glVertexPointer_Hook(GLint size, GLenum type, GLsizei stride, const void *pointer) + { + glVertexPointer(size, type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + #undef glViewport + extern "C" { GLAPI void GLAPIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height); } + void OVR::GLEContext::glViewport_Hook(GLint x, GLint y, GLsizei width, GLsizei height) + { + glViewport(x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + + + // Pointer-based functions + void OVR::GLEContext::glBlendColor_Hook(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) + { + if(glBlendColor_Impl) + glBlendColor_Impl(red, green, blue, alpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlendEquation_Hook(GLenum mode) + { + if(glBlendEquation_Impl) + glBlendEquation_Impl(mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDrawRangeElements_Hook(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) + { + if(glDrawRangeElements_Impl) + glDrawRangeElements_Impl(mode, start, end, count, type, indices); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTexImage3D_Hook(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + if(glTexImage3D_Impl) + glTexImage3D_Impl(target, level, internalformat, width, height, depth, border, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::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) + { + if(glTexSubImage3D_Impl) + glTexSubImage3D_Impl(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + PostHook(GLE_CURRENT_FUNCTION); + } + + + void OVR::GLEContext::glCopyTexSubImage3D_Hook(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + if(glCopyTexSubImage3D_Impl) + glCopyTexSubImage3D_Impl(target, level, xoffset, yoffset, zoffset, x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + // GL_VERSION_1_2 deprecated functions + /* Not currently supported + void OVR::GLEContext::glColorTable_Hook(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) + { + if(glColorTable_Impl) + glColorTable_Impl(target, internalformat, width, format, type, table); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glColorTableParameterfv_Hook(GLenum target, GLenum pname, const GLfloat *params) + { + if(glColorTableParameterfv_Impl) + glColorTableParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glColorTableParameteriv_Hook(GLenum target, GLenum pname, const GLint *params) + { + if(glColorTableParameteriv_Impl) + glColorTableParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCopyColorTable_Hook(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) + { + if(glCopyColorTable_Impl) + glCopyColorTable_Impl(target, internalformat, x, y, width); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetColorTable_Hook(GLenum target, GLenum format, GLenum type, GLvoid *table) + { + if(glGetColorTable_Impl) + glGetColorTable_Impl(target, format, type, table); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetColorTableParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + if(glGetColorTableParameterfv_Impl) + glGetColorTableParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetColorTableParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetColorTableParameteriv_Impl) + glGetColorTableParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glColorSubTable_Hook(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) + { + if(glColorSubTable_Impl) + glColorSubTable_Impl(target, start, count, format, type, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCopyColorSubTable_Hook(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) + { + if(glCopyColorSubTable_Impl) + glCopyColorSubTable_Impl(target, start, x, y, width); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionFilter1D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image) + { + if(glConvolutionFilter1D_Impl) + glConvolutionFilter1D_Impl(target, internalformat, width, format, type, image); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionFilter2D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image) + { + if(glConvolutionFilter2D_Impl) + glConvolutionFilter2D_Impl(target, internalformat, width, height, format, type, image); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionParameterf_Hook(GLenum target, GLenum pname, GLfloat params) + { + if(glConvolutionParameterf_Impl) + glConvolutionParameterf_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionParameterfv_Hook(GLenum target, GLenum pname, const GLfloat *params) + { + if(glConvolutionParameterfv_Impl) + glConvolutionParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionParameteri_Hook(GLenum target, GLenum pname, GLint params) + { + if(glConvolutionParameteri_Impl) + glConvolutionParameteri_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glConvolutionParameteriv_Hook(GLenum target, GLenum pname, const GLint *params) + { + if(glConvolutionParameteriv_Impl) + glConvolutionParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCopyConvolutionFilter1D_Hook(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) + { + if(glCopyConvolutionFilter1D_Impl) + glCopyConvolutionFilter1D_Impl(target, internalformat, x, y, width); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCopyConvolutionFilter2D_Hook(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) + { + if(glCopyConvolutionFilter2D_Impl) + glCopyConvolutionFilter2D_Impl(target, internalformat, x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetConvolutionFilter_Hook(GLenum target, GLenum format, GLenum type, GLvoid *image) + { + if(glGetConvolutionFilter_Impl) + glGetConvolutionFilter_Impl(target, format, type, image); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetConvolutionParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + if(glGetConvolutionParameterfv_Impl) + glGetConvolutionParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetConvolutionParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetConvolutionParameteriv_Impl) + glGetConvolutionParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetSeparableFilter_Hook(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span) + { + if(glGetSeparableFilter_Impl) + glGetSeparableFilter_Impl(target, format, type, row, column, span); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSeparableFilter2D_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column) + { + if(glSeparableFilter2D_Impl) + glSeparableFilter2D_Impl(target, internalformat, width, height, format, type, row, column); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetHistogram_Hook(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) + { + if(glGetHistogram_Impl) + glGetHistogram_Impl(target, reset, format, type, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetHistogramParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + if(glGetHistogramParameterfv_Impl) + glGetHistogramParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetHistogramParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetHistogramParameteriv_Impl) + glGetHistogramParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetMinmax_Hook(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) + { + if(glGetMinmax_Impl) + glGetMinmax_Impl(target, reset, format, type, values); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetMinmaxParameterfv_Hook(GLenum target, GLenum pname, GLfloat *params) + { + if(glGetMinmaxParameterfv_Impl) + glGetMinmaxParameterfv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetMinmaxParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetMinmaxParameteriv_Impl) + glGetMinmaxParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glHistogram_Hook(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) + { + if(glHistogram_Impl) + glHistogram_Impl(target, width, internalformat, sink); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMinmax_Hook(GLenum target, GLenum internalformat, GLboolean sink) + { + if(glMinmax_Impl) + glMinmax_Impl(target, internalformat, sink); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glResetHistogram_Hook(GLenum target) + { + if(glResetHistogram_Impl) + glResetHistogram_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glResetMinmax_Hook(GLenum target) + { + if(glResetMinmax_Impl) + glResetMinmax_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + } + */ + + // GL_VERSION_1_3 + void OVR::GLEContext::glActiveTexture_Hook(GLenum texture) + { + if(glActiveTexture_Impl) + glActiveTexture_Impl(texture); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSampleCoverage_Hook(GLclampf value, GLboolean invert) + { + if(glSampleCoverage_Impl) + glSampleCoverage_Impl(value, invert); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompressedTexImage3D_Hook(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) + { + if(glCompressedTexImage3D_Impl) + glCompressedTexImage3D_Impl(target, level, internalformat, width, height, depth, border, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompressedTexImage2D_Hook(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) + { + if(glCompressedTexImage2D_Impl) + glCompressedTexImage2D_Impl(target, level, internalformat, width, height, border, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompressedTexImage1D_Hook(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) + { + if(glCompressedTexImage1D_Impl) + glCompressedTexImage1D_Impl(target, level, internalformat, width, border, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::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) + { + if(glCompressedTexSubImage3D_Impl) + glCompressedTexSubImage3D_Impl(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompressedTexSubImage2D_Hook(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) + { + if(glCompressedTexSubImage2D_Impl) + glCompressedTexSubImage2D_Impl(target, level, xoffset, yoffset, width, height, format, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompressedTexSubImage1D_Hook(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) + { + if(glCompressedTexSubImage1D_Impl) + glCompressedTexSubImage1D_Impl(target, level, xoffset, width, format, imageSize, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetCompressedTexImage_Hook(GLenum target, GLint level, GLvoid *img) + { + if(glGetCompressedTexImage_Impl) + glGetCompressedTexImage_Impl(target, level, img); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_1_3 deprecated functions + void OVR::GLEContext::glClientActiveTexture_Hook(GLenum texture) + { + if(glClientActiveTexture_Impl) + glClientActiveTexture_Impl(texture); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1d_Hook(GLenum target, GLdouble s) + { + if(glMultiTexCoord1d_Impl) + glMultiTexCoord1d_Impl(target, s); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1dv_Hook(GLenum target, const GLdouble *v) + { + if(glMultiTexCoord1dv_Impl) + glMultiTexCoord1dv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1f_Hook(GLenum target, GLfloat s) + { + if(glMultiTexCoord1f_Impl) + glMultiTexCoord1f_Impl(target, s); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1fv_Hook(GLenum target, const GLfloat *v) + { + if(glMultiTexCoord1fv_Impl) + glMultiTexCoord1fv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1i_Hook(GLenum target, GLint s) + { + if(glMultiTexCoord1i_Impl) + glMultiTexCoord1i_Impl(target, s); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1iv_Hook(GLenum target, const GLint *v) + { + if(glMultiTexCoord1iv_Impl) + glMultiTexCoord1iv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1s_Hook(GLenum target, GLshort s) + { + if(glMultiTexCoord1s_Impl) + glMultiTexCoord1s_Impl(target, s); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord1sv_Hook(GLenum target, const GLshort *v) + { + if(glMultiTexCoord1sv_Impl) + glMultiTexCoord1sv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2d_Hook(GLenum target, GLdouble s, GLdouble t) + { + if(glMultiTexCoord2d_Impl) + glMultiTexCoord2d_Impl(target, s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2dv_Hook(GLenum target, const GLdouble *v) + { + if(glMultiTexCoord2dv_Impl) + glMultiTexCoord2dv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2f_Hook(GLenum target, GLfloat s, GLfloat t) + { + if(glMultiTexCoord2f_Impl) + glMultiTexCoord2f_Impl(target, s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2fv_Hook(GLenum target, const GLfloat *v) + { + if(glMultiTexCoord2fv_Impl) + glMultiTexCoord2fv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2i_Hook(GLenum target, GLint s, GLint t) + { + if(glMultiTexCoord2i_Impl) + glMultiTexCoord2i_Impl(target, s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2iv_Hook(GLenum target, const GLint *v) + { + if(glMultiTexCoord2iv_Impl) + glMultiTexCoord2iv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2s_Hook(GLenum target, GLshort s, GLshort t) + { + if(glMultiTexCoord2s_Impl) + glMultiTexCoord2s_Impl(target, s, t); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord2sv_Hook(GLenum target, const GLshort *v) + { + if(glMultiTexCoord2sv_Impl) + glMultiTexCoord2sv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3d_Hook(GLenum target, GLdouble s, GLdouble t, GLdouble r) + { + if(glMultiTexCoord3d_Impl) + glMultiTexCoord3d_Impl(target, s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3dv_Hook(GLenum target, const GLdouble *v) + { + if(glMultiTexCoord3dv_Impl) + glMultiTexCoord3dv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3f_Hook(GLenum target, GLfloat s, GLfloat t, GLfloat r) + { + if(glMultiTexCoord3f_Impl) + glMultiTexCoord3f_Impl(target, s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3fv_Hook(GLenum target, const GLfloat *v) + { + if(glMultiTexCoord3fv_Impl) + glMultiTexCoord3fv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3i_Hook(GLenum target, GLint s, GLint t, GLint r) + { + if(glMultiTexCoord3i_Impl) + glMultiTexCoord3i_Impl(target, s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3iv_Hook(GLenum target, const GLint *v) + { + if(glMultiTexCoord3iv_Impl) + glMultiTexCoord3iv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3s_Hook(GLenum target, GLshort s, GLshort t, GLshort r) + { + if(glMultiTexCoord3s_Impl) + glMultiTexCoord3s_Impl(target, s, t, r); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord3sv_Hook(GLenum target, const GLshort *v) + { + if(glMultiTexCoord3sv_Impl) + glMultiTexCoord3sv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4d_Hook(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) + { + if(glMultiTexCoord4d_Impl) + glMultiTexCoord4d_Impl(target, s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4dv_Hook(GLenum target, const GLdouble *v) + { + if(glMultiTexCoord4dv_Impl) + glMultiTexCoord4dv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4f_Hook(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) + { + if(glMultiTexCoord4f_Impl) + glMultiTexCoord4f_Impl(target, s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4fv_Hook(GLenum target, const GLfloat *v) + { + if(glMultiTexCoord4fv_Impl) + glMultiTexCoord4fv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4i_Hook(GLenum target, GLint s, GLint t, GLint r, GLint q) + { + if(glMultiTexCoord4i_Impl) + glMultiTexCoord4i_Impl(target, s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4iv_Hook(GLenum target, const GLint *v) + { + if(glMultiTexCoord4iv_Impl) + glMultiTexCoord4iv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4s_Hook(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) + { + if(glMultiTexCoord4s_Impl) + glMultiTexCoord4s_Impl(target, s, t, r, q); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiTexCoord4sv_Hook(GLenum target, const GLshort *v) + { + if(glMultiTexCoord4sv_Impl) + glMultiTexCoord4sv_Impl(target, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glLoadTransposeMatrixf_Hook(const GLfloat *m) + { + if(glLoadTransposeMatrixf_Impl) + glLoadTransposeMatrixf_Impl(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glLoadTransposeMatrixd_Hook(const GLdouble *m) + { + if(glLoadTransposeMatrixd_Impl) + glLoadTransposeMatrixd_Impl(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultTransposeMatrixf_Hook(const GLfloat *m) + { + if(glMultTransposeMatrixf_Impl) + glMultTransposeMatrixf_Impl(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultTransposeMatrixd_Hook(const GLdouble *m) + { + if(glMultTransposeMatrixd_Impl) + glMultTransposeMatrixd_Impl(m); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_1_4 + void OVR::GLEContext::glBlendFuncSeparate_Hook(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) + { + if(glBlendFuncSeparate_Impl) + glBlendFuncSeparate_Impl(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiDrawArrays_Hook(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) + { + if(glMultiDrawArrays_Impl) + glMultiDrawArrays_Impl(mode, first, count, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiDrawElements_Hook(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) + { + if(glMultiDrawElements_Impl) + glMultiDrawElements_Impl(mode, count, type, indices, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPointParameterf_Hook(GLenum pname, GLfloat param) + { + if(glPointParameterf_Impl) + glPointParameterf_Impl(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPointParameterfv_Hook(GLenum pname, const GLfloat *params) + { + if(glPointParameterfv_Impl) + glPointParameterfv_Impl(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPointParameteri_Hook(GLenum pname, GLint param) + { + if(glPointParameteri_Impl) + glPointParameteri_Impl(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPointParameteriv_Hook(GLenum pname, const GLint *params) + { + if(glPointParameteriv_Impl) + glPointParameteriv_Impl(pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_1_4 deprecated functions + void OVR::GLEContext::glFogCoordf_Hook(GLfloat coord) + { + if(glFogCoordf_Impl) + glFogCoordf_Impl(coord); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFogCoordfv_Hook(const GLfloat *coord) + { + if(glFogCoordfv_Impl) + glFogCoordfv_Impl(coord); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFogCoordd_Hook(GLdouble coord) + { + if(glFogCoordd_Impl) + glFogCoordd_Impl(coord); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFogCoorddv_Hook(const GLdouble *coord) + { + if(glFogCoorddv_Impl) + glFogCoorddv_Impl(coord); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFogCoordPointer_Hook(GLenum type, GLsizei stride, const GLvoid *pointer) + { + if(glFogCoordPointer_Impl) + glFogCoordPointer_Impl(type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3b_Hook(GLbyte red, GLbyte green, GLbyte blue) + { + if(glSecondaryColor3b_Impl) + glSecondaryColor3b_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3bv_Hook(const GLbyte *v) + { + if(glSecondaryColor3bv_Impl) + glSecondaryColor3bv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3d_Hook(GLdouble red, GLdouble green, GLdouble blue) + { + if(glSecondaryColor3d_Impl) + glSecondaryColor3d_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3dv_Hook(const GLdouble *v) + { + if(glSecondaryColor3dv_Impl) + glSecondaryColor3dv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3f_Hook(GLfloat red, GLfloat green, GLfloat blue) + { + if(glSecondaryColor3f_Impl) + glSecondaryColor3f_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3fv_Hook(const GLfloat *v) + { + if(glSecondaryColor3fv_Impl) + glSecondaryColor3fv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3i_Hook(GLint red, GLint green, GLint blue) + { + if(glSecondaryColor3i_Impl) + glSecondaryColor3i_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3iv_Hook(const GLint *v) + { + if(glSecondaryColor3iv_Impl) + glSecondaryColor3iv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3s_Hook(GLshort red, GLshort green, GLshort blue) + { + if(glSecondaryColor3s_Impl) + glSecondaryColor3s_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3sv_Hook(const GLshort *v) + { + if(glSecondaryColor3sv_Impl) + glSecondaryColor3sv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3ub_Hook(GLubyte red, GLubyte green, GLubyte blue) + { + if(glSecondaryColor3ub_Impl) + glSecondaryColor3ub_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3ubv_Hook(const GLubyte *v) + { + if(glSecondaryColor3ubv_Impl) + glSecondaryColor3ubv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3ui_Hook(GLuint red, GLuint green, GLuint blue) + { + if(glSecondaryColor3ui_Impl) + glSecondaryColor3ui_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3uiv_Hook(const GLuint *v) + { + if(glSecondaryColor3uiv_Impl) + glSecondaryColor3uiv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3us_Hook(GLushort red, GLushort green, GLushort blue) + { + if(glSecondaryColor3us_Impl) + glSecondaryColor3us_Impl(red, green, blue); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColor3usv_Hook(const GLushort *v) + { + if(glSecondaryColor3usv_Impl) + glSecondaryColor3usv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSecondaryColorPointer_Hook(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + if(glSecondaryColorPointer_Impl) + glSecondaryColorPointer_Impl(size, type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2d_Hook(GLdouble x, GLdouble y) + { + if(glWindowPos2d_Impl) + glWindowPos2d_Impl(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2dv_Hook(const GLdouble *v) + { + if(glWindowPos2dv_Impl) + glWindowPos2dv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2f_Hook(GLfloat x, GLfloat y) + { + if(glWindowPos2f_Impl) + glWindowPos2f_Impl(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2fv_Hook(const GLfloat *v) + { + if(glWindowPos2fv_Impl) + glWindowPos2fv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2i_Hook(GLint x, GLint y) + { + if(glWindowPos2i_Impl) + glWindowPos2i_Impl(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2iv_Hook(const GLint *v) + { + if(glWindowPos2iv_Impl) + glWindowPos2iv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2s_Hook(GLshort x, GLshort y) + { + if(glWindowPos2s_Impl) + glWindowPos2s_Impl(x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos2sv_Hook(const GLshort *v) + { + if(glWindowPos2sv_Impl) + glWindowPos2sv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3d_Hook(GLdouble x, GLdouble y, GLdouble z) + { + if(glWindowPos3d_Impl) + glWindowPos3d_Impl(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3dv_Hook(const GLdouble *v) + { + if(glWindowPos3dv_Impl) + glWindowPos3dv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3f_Hook(GLfloat x, GLfloat y, GLfloat z) + { + if(glWindowPos3f_Impl) + glWindowPos3f_Impl(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3fv_Hook(const GLfloat *v) + { + if(glWindowPos3fv_Impl) + glWindowPos3fv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3i_Hook(GLint x, GLint y, GLint z) + { + if(glWindowPos3i_Impl) + glWindowPos3i_Impl(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3iv_Hook(const GLint *v) + { + if(glWindowPos3iv_Impl) + glWindowPos3iv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3s_Hook(GLshort x, GLshort y, GLshort z) + { + if(glWindowPos3s_Impl) + glWindowPos3s_Impl(x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glWindowPos3sv_Hook(const GLshort *v) + { + if(glWindowPos3sv_Impl) + glWindowPos3sv_Impl(v); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_1_5 + void OVR::GLEContext::glGenQueries_Hook(GLsizei n, GLuint *ids) + { + if(glGenQueries_Impl) + glGenQueries_Impl(n, ids); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteQueries_Hook(GLsizei n, const GLuint *ids) + { + if(glDeleteQueries_Impl) + glDeleteQueries_Impl(n, ids); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsQuery_Hook(GLuint id) + { + GLboolean b = GL_FALSE; + if(glIsQuery_Impl) + b = glIsQuery_Impl(id); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glBeginQuery_Hook(GLenum target, GLuint id) + { + if(glBeginQuery_Impl) + glBeginQuery_Impl(target, id); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEndQuery_Hook(GLenum target) + { + if(glEndQuery_Impl) + glEndQuery_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetQueryiv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetQueryiv_Impl) + glGetQueryiv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetQueryObjectiv_Hook(GLuint id, GLenum pname, GLint *params) + { + if(glGetQueryObjectiv_Impl) + glGetQueryObjectiv_Impl(id, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetQueryObjectuiv_Hook(GLuint id, GLenum pname, GLuint *params) + { + if(glGetQueryObjectuiv_Impl) + glGetQueryObjectuiv_Impl(id, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBindBuffer_Hook(GLenum target, GLuint buffer) + { + if(glBindBuffer_Impl) + glBindBuffer_Impl(target, buffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteBuffers_Hook(GLsizei n, const GLuint *buffers) + { + if(glDeleteBuffers_Impl) + glDeleteBuffers_Impl(n, buffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenBuffers_Hook(GLsizei n, GLuint *buffers) + { + if(glGenBuffers_Impl) + glGenBuffers_Impl(n, buffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsBuffer_Hook(GLuint buffer) + { + GLboolean b = GL_FALSE; + if(glIsBuffer_Impl) + b = glIsBuffer_Impl(buffer); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glBufferData_Hook(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) + { + if(glBufferData_Impl) + glBufferData_Impl(target, size, data, usage); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBufferSubData_Hook(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) + { + if(glBufferSubData_Impl) + glBufferSubData_Impl(target, offset, size, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetBufferSubData_Hook(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) + { + if(glGetBufferSubData_Impl) + glGetBufferSubData_Impl(target, offset, size, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLvoid* OVR::GLEContext::glMapBuffer_Hook(GLenum target, GLenum access) + { + GLvoid* p = NULL; + if(glMapBuffer_Impl) + p = glMapBuffer_Impl(target, access); + PostHook(GLE_CURRENT_FUNCTION); + return p; + } + + GLboolean OVR::GLEContext::glUnmapBuffer_Hook(GLenum target) + { + GLboolean b = GL_FALSE; + if(glUnmapBuffer_Impl) + b = glUnmapBuffer_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glGetBufferParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetBufferParameteriv_Impl) + glGetBufferParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetBufferPointerv_Hook(GLenum target, GLenum pname, GLvoid* *params) + { + if(glGetBufferPointerv_Impl) + glGetBufferPointerv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_2_0 + void OVR::GLEContext::glBlendEquationSeparate_Hook(GLenum modeRGB, GLenum modeAlpha) + { + if(glBlendEquationSeparate_Impl) + glBlendEquationSeparate_Impl(modeRGB, modeAlpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDrawBuffers_Hook(GLsizei n, const GLenum *bufs) + { + if(glDrawBuffers_Impl) + glDrawBuffers_Impl(n, bufs); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glStencilOpSeparate_Hook(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) + { + if(glStencilOpSeparate_Impl) + glStencilOpSeparate_Impl(face, sfail, dpfail, dppass); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glStencilFuncSeparate_Hook(GLenum face, GLenum func, GLint ref, GLuint mask) + { + if(glStencilFuncSeparate_Impl) + glStencilFuncSeparate_Impl(face, func, ref, mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glStencilMaskSeparate_Hook(GLenum face, GLuint mask) + { + if(glStencilMaskSeparate_Impl) + glStencilMaskSeparate_Impl(face, mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glAttachShader_Hook(GLuint program, GLuint shader) + { + if(glAttachShader_Impl) + glAttachShader_Impl(program, shader); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBindAttribLocation_Hook(GLuint program, GLuint index, const GLchar *name) + { + if(glBindAttribLocation_Impl) + glBindAttribLocation_Impl(program, index, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glCompileShader_Hook(GLuint shader) + { + if(glCompileShader_Impl) + glCompileShader_Impl(shader); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLuint OVR::GLEContext::glCreateProgram_Hook() + { + GLuint u = 0; + if(glCreateProgram_Impl) + u = glCreateProgram_Impl(); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + GLuint OVR::GLEContext::glCreateShader_Hook(GLenum type) + { + GLuint u = 0; + if(glCreateShader_Impl) + u = glCreateShader_Impl(type); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + void OVR::GLEContext::glDeleteProgram_Hook(GLuint program) + { + if(glDeleteProgram_Impl) + glDeleteProgram_Impl(program); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteShader_Hook(GLuint shader) + { + if(glDeleteShader_Impl) + glDeleteShader_Impl(shader); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDetachShader_Hook(GLuint program, GLuint shader) + { + if(glDetachShader_Impl) + glDetachShader_Impl(program, shader); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDisableVertexAttribArray_Hook(GLuint index) + { + if(glDisableVertexAttribArray_Impl) + glDisableVertexAttribArray_Impl(index); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEnableVertexAttribArray_Hook(GLuint index) + { + if(glEnableVertexAttribArray_Impl) + glEnableVertexAttribArray_Impl(index); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetActiveAttrib_Hook(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + if(glGetActiveAttrib_Impl) + glGetActiveAttrib_Impl(program, index, bufSize, length, size, type, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetActiveUniform_Hook(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + if(glGetActiveUniform_Impl) + glGetActiveUniform_Impl(program, index, bufSize, length, size, type, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetAttachedShaders_Hook(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj) + { + if(glGetAttachedShaders_Impl) + glGetAttachedShaders_Impl(program, maxCount, count, obj); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLint OVR::GLEContext::glGetAttribLocation_Hook(GLuint program, const GLchar *name) + { + GLint i = 0; + if(glGetAttribLocation_Impl) + i = glGetAttribLocation_Impl(program, name); + PostHook(GLE_CURRENT_FUNCTION); + return i; + } + + void OVR::GLEContext::glGetProgramiv_Hook(GLuint program, GLenum pname, GLint *params) + { + if(glGetProgramiv_Impl) + glGetProgramiv_Impl(program, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetProgramInfoLog_Hook(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + if(glGetProgramInfoLog_Impl) + glGetProgramInfoLog_Impl(program, bufSize, length, infoLog); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetShaderiv_Hook(GLuint shader, GLenum pname, GLint *params) + { + if(glGetShaderiv_Impl) + glGetShaderiv_Impl(shader, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetShaderInfoLog_Hook(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + if(glGetShaderInfoLog_Impl) + glGetShaderInfoLog_Impl(shader, bufSize, length, infoLog); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetShaderSource_Hook(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) + { + if(glGetShaderSource_Impl) + glGetShaderSource_Impl(shader, bufSize, length, source); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLint OVR::GLEContext::glGetUniformLocation_Hook(GLuint program, const GLchar *name) + { + GLint i = 0; + if(glGetUniformLocation_Impl) + i = glGetUniformLocation_Impl(program, name); + PostHook(GLE_CURRENT_FUNCTION); + return i; + } + + void OVR::GLEContext::glGetUniformfv_Hook(GLuint program, GLint location, GLfloat *params) + { + if(glGetUniformfv_Impl) + glGetUniformfv_Impl(program, location, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetUniformiv_Hook(GLuint program, GLint location, GLint *params) + { + if(glGetUniformiv_Impl) + glGetUniformiv_Impl(program, location, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribdv_Hook(GLuint index, GLenum pname, GLdouble *params) + { + if(glGetVertexAttribdv_Impl) + glGetVertexAttribdv_Impl(index, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribfv_Hook(GLuint index, GLenum pname, GLfloat *params) + { + if(glGetVertexAttribfv_Impl) + glGetVertexAttribfv_Impl(index, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribiv_Hook(GLuint index, GLenum pname, GLint *params) + { + if(glGetVertexAttribiv_Impl) + glGetVertexAttribiv_Impl(index, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribPointerv_Hook(GLuint index, GLenum pname, GLvoid* *pointer) + { + if(glGetVertexAttribPointerv_Impl) + glGetVertexAttribPointerv_Impl(index, pname, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsProgram_Hook(GLuint program) + { + GLboolean b = GL_FALSE; + if(glIsProgram_Impl) + b = glIsProgram_Impl(program); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + GLboolean OVR::GLEContext::glIsShader_Hook(GLuint shader) + { + GLboolean b = GL_FALSE; + if(glIsShader_Impl) + b = glIsShader_Impl(shader); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glLinkProgram_Hook(GLuint program) + { + if(glLinkProgram_Impl) + glLinkProgram_Impl(program); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glShaderSource_Hook(GLuint shader, GLsizei count, const GLchar* *string, const GLint *length) + { + if(glShaderSource_Impl) + glShaderSource_Impl(shader, count, string, length); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUseProgram_Hook(GLuint program) + { + if(glUseProgram_Impl) + glUseProgram_Impl(program); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform1f_Hook(GLint location, GLfloat v0) + { + if(glUniform1f_Impl) + glUniform1f_Impl(location, v0); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2f_Hook(GLint location, GLfloat v0, GLfloat v1) + { + if(glUniform2f_Impl) + glUniform2f_Impl(location, v0, v1); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3f_Hook(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) + { + if(glUniform3f_Impl) + glUniform3f_Impl(location, v0, v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4f_Hook(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) + { + if(glUniform4f_Impl) + glUniform4f_Impl(location, v0, v1, v2, v3); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform1i_Hook(GLint location, GLint v0) + { + if(glUniform1i_Impl) + glUniform1i_Impl(location, v0); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2i_Hook(GLint location, GLint v0, GLint v1) + { + if(glUniform2i_Impl) + glUniform2i_Impl(location, v0, v1); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3i_Hook(GLint location, GLint v0, GLint v1, GLint v2) + { + if(glUniform3i_Impl) + glUniform3i_Impl(location, v0, v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4i_Hook(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) + { + if(glUniform4i_Impl) + glUniform4i_Impl(location, v0, v1, v2, v3); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform1fv_Hook(GLint location, GLsizei count, const GLfloat *value) + { + if(glUniform1fv_Impl) + glUniform1fv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2fv_Hook(GLint location, GLsizei count, const GLfloat *value) + { + if(glUniform2fv_Impl) + glUniform2fv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3fv_Hook(GLint location, GLsizei count, const GLfloat *value) + { + if(glUniform3fv_Impl) + glUniform3fv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4fv_Hook(GLint location, GLsizei count, const GLfloat *value) + { + if(glUniform4fv_Impl) + glUniform4fv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform1iv_Hook(GLint location, GLsizei count, const GLint *value) + { + if(glUniform1iv_Impl) + glUniform1iv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2iv_Hook(GLint location, GLsizei count, const GLint *value) + { + if(glUniform2iv_Impl) + glUniform2iv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3iv_Hook(GLint location, GLsizei count, const GLint *value) + { + if(glUniform3iv_Impl) + glUniform3iv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4iv_Hook(GLint location, GLsizei count, const GLint *value) + { + if(glUniform4iv_Impl) + glUniform4iv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix2fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix2fv_Impl) + glUniformMatrix2fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix3fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix3fv_Impl) + glUniformMatrix3fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix4fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix4fv_Impl) + glUniformMatrix4fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glValidateProgram_Hook(GLuint program) + { + if(glValidateProgram_Impl) + glValidateProgram_Impl(program); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1d_Hook(GLuint index, GLdouble x) + { + if(glVertexAttrib1d_Impl) + glVertexAttrib1d_Impl(index, x); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1dv_Hook(GLuint index, const GLdouble *v) + { + if(glVertexAttrib1dv_Impl) + glVertexAttrib1dv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1f_Hook(GLuint index, GLfloat x) + { + if(glVertexAttrib1f_Impl) + glVertexAttrib1f_Impl(index, x); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1fv_Hook(GLuint index, const GLfloat *v) + { + if(glVertexAttrib1fv_Impl) + glVertexAttrib1fv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1s_Hook(GLuint index, GLshort x) + { + if(glVertexAttrib1s_Impl) + glVertexAttrib1s_Impl(index, x); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib1sv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttrib1sv_Impl) + glVertexAttrib1sv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2d_Hook(GLuint index, GLdouble x, GLdouble y) + { + if(glVertexAttrib2d_Impl) + glVertexAttrib2d_Impl(index, x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2dv_Hook(GLuint index, const GLdouble *v) + { + if(glVertexAttrib2dv_Impl) + glVertexAttrib2dv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2f_Hook(GLuint index, GLfloat x, GLfloat y) + { + if(glVertexAttrib2f_Impl) + glVertexAttrib2f_Impl(index, x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2fv_Hook(GLuint index, const GLfloat *v) + { + if(glVertexAttrib2fv_Impl) + glVertexAttrib2fv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2s_Hook(GLuint index, GLshort x, GLshort y) + { + if(glVertexAttrib2s_Impl) + glVertexAttrib2s_Impl(index, x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib2sv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttrib2sv_Impl) + glVertexAttrib2sv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3d_Hook(GLuint index, GLdouble x, GLdouble y, GLdouble z) + { + if(glVertexAttrib3d_Impl) + glVertexAttrib3d_Impl(index, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3dv_Hook(GLuint index, const GLdouble *v) + { + if(glVertexAttrib3dv_Impl) + glVertexAttrib3dv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3f_Hook(GLuint index, GLfloat x, GLfloat y, GLfloat z) + { + if(glVertexAttrib3f_Impl) + glVertexAttrib3f_Impl(index, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3fv_Hook(GLuint index, const GLfloat *v) + { + if(glVertexAttrib3fv_Impl) + glVertexAttrib3fv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3s_Hook(GLuint index, GLshort x, GLshort y, GLshort z) + { + if(glVertexAttrib3s_Impl) + glVertexAttrib3s_Impl(index, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib3sv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttrib3sv_Impl) + glVertexAttrib3sv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nbv_Hook(GLuint index, const GLbyte *v) + { + if(glVertexAttrib4Nbv_Impl) + glVertexAttrib4Nbv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Niv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttrib4Niv_Impl) + glVertexAttrib4Niv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nsv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttrib4Nsv_Impl) + glVertexAttrib4Nsv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nub_Hook(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) + { + if(glVertexAttrib4Nub_Impl) + glVertexAttrib4Nub_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nubv_Hook(GLuint index, const GLubyte *v) + { + if(glVertexAttrib4Nubv_Impl) + glVertexAttrib4Nubv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nuiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttrib4Nuiv_Impl) + glVertexAttrib4Nuiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4Nusv_Hook(GLuint index, const GLushort *v) + { + if(glVertexAttrib4Nusv_Impl) + glVertexAttrib4Nusv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4bv_Hook(GLuint index, const GLbyte *v) + { + if(glVertexAttrib4bv_Impl) + glVertexAttrib4bv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4d_Hook(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) + { + if(glVertexAttrib4d_Impl) + glVertexAttrib4d_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4dv_Hook(GLuint index, const GLdouble *v) + { + if(glVertexAttrib4dv_Impl) + glVertexAttrib4dv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4f_Hook(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) + { + if(glVertexAttrib4f_Impl) + glVertexAttrib4f_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4fv_Hook(GLuint index, const GLfloat *v) + { + if(glVertexAttrib4fv_Impl) + glVertexAttrib4fv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4iv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttrib4iv_Impl) + glVertexAttrib4iv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4s_Hook(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) + { + if(glVertexAttrib4s_Impl) + glVertexAttrib4s_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4sv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttrib4sv_Impl) + glVertexAttrib4sv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4ubv_Hook(GLuint index, const GLubyte *v) + { + if(glVertexAttrib4ubv_Impl) + glVertexAttrib4ubv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4uiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttrib4uiv_Impl) + glVertexAttrib4uiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttrib4usv_Hook(GLuint index, const GLushort *v) + { + if(glVertexAttrib4usv_Impl) + glVertexAttrib4usv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribPointer_Hook(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) + { + if(glVertexAttribPointer_Impl) + glVertexAttribPointer_Impl(index, size, type, normalized, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_2_1 + void OVR::GLEContext::glUniformMatrix2x3fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix2x3fv_Impl) + glUniformMatrix2x3fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix3x2fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix3x2fv_Impl) + glUniformMatrix3x2fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix2x4fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix2x4fv_Impl) + glUniformMatrix2x4fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix4x2fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix4x2fv_Impl) + glUniformMatrix4x2fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix3x4fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix3x4fv_Impl) + glUniformMatrix3x4fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniformMatrix4x3fv_Hook(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + if(glUniformMatrix4x3fv_Impl) + glUniformMatrix4x3fv_Impl(location, count, transpose, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_3_0 + void OVR::GLEContext::glColorMaski_Hook(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) + { + if(glColorMaski_Impl) + glColorMaski_Impl(index, r, g, b, a); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetBooleani_v_Hook(GLenum target, GLuint index, GLboolean *data) + { + if(glGetBooleani_v_Impl) + glGetBooleani_v_Impl(target, index, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetIntegeri_v_Hook(GLenum target, GLuint index, GLint *data) + { + if(glGetIntegeri_v_Impl) + glGetIntegeri_v_Impl(target, index, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEnablei_Hook(GLenum target, GLuint index) + { + if(glEnablei_Impl) + glEnablei_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDisablei_Hook(GLenum target, GLuint index) + { + if(glDisablei_Impl) + glDisablei_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsEnabledi_Hook(GLenum target, GLuint index) + { + GLboolean b = GL_FALSE; + if(glIsEnabledi_Impl) + b = glIsEnabledi_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glBeginTransformFeedback_Hook(GLenum primitiveMode) + { + if(glBeginTransformFeedback_Impl) + glBeginTransformFeedback_Impl(primitiveMode); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEndTransformFeedback_Hook() + { + if(glEndTransformFeedback_Impl) + glEndTransformFeedback_Impl(); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBindBufferRange_Hook(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) + { + if(glBindBufferRange_Impl) + glBindBufferRange_Impl(target, index, buffer, offset, size); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBindBufferBase_Hook(GLenum target, GLuint index, GLuint buffer) + { + if(glBindBufferBase_Impl) + glBindBufferBase_Impl(target, index, buffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTransformFeedbackVaryings_Hook(GLuint program, GLsizei count, const GLchar* *varyings, GLenum bufferMode) + { + if(glTransformFeedbackVaryings_Impl) + glTransformFeedbackVaryings_Impl(program, count, varyings, bufferMode); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetTransformFeedbackVarying_Hook(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) + { + if(glGetTransformFeedbackVarying_Impl) + glGetTransformFeedbackVarying_Impl(program, index, bufSize, length, size, type, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClampColor_Hook(GLenum target, GLenum clamp) + { + if(glClampColor_Impl) + glClampColor_Impl(target, clamp); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBeginConditionalRender_Hook(GLuint id, GLenum mode) + { + if(glBeginConditionalRender_Impl) + glBeginConditionalRender_Impl(id, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEndConditionalRender_Hook() + { + if(glEndConditionalRender_Impl) + glEndConditionalRender_Impl(); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribIPointer_Hook(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + if(glVertexAttribIPointer_Impl) + glVertexAttribIPointer_Impl(index, size, type, stride, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribIiv_Hook(GLuint index, GLenum pname, GLint *params) + { + if(glGetVertexAttribIiv_Impl) + glGetVertexAttribIiv_Impl(index, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetVertexAttribIuiv_Hook(GLuint index, GLenum pname, GLuint *params) + { + if(glGetVertexAttribIuiv_Impl) + glGetVertexAttribIuiv_Impl(index, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI1i_Hook(GLuint index, GLint x) + { + if(glVertexAttribI1i_Impl) + glVertexAttribI1i_Impl(index, x); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI2i_Hook(GLuint index, GLint x, GLint y) + { + if(glVertexAttribI2i_Impl) + glVertexAttribI2i_Impl(index, x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI3i_Hook(GLuint index, GLint x, GLint y, GLint z) + { + if(glVertexAttribI3i_Impl) + glVertexAttribI3i_Impl(index, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4i_Hook(GLuint index, GLint x, GLint y, GLint z, GLint w) + { + if(glVertexAttribI4i_Impl) + glVertexAttribI4i_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI1ui_Hook(GLuint index, GLuint x) + { + if(glVertexAttribI1ui_Impl) + glVertexAttribI1ui_Impl(index, x); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI2ui_Hook(GLuint index, GLuint x, GLuint y) + { + if(glVertexAttribI2ui_Impl) + glVertexAttribI2ui_Impl(index, x, y); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI3ui_Hook(GLuint index, GLuint x, GLuint y, GLuint z) + { + if(glVertexAttribI3ui_Impl) + glVertexAttribI3ui_Impl(index, x, y, z); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4ui_Hook(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) + { + if(glVertexAttribI4ui_Impl) + glVertexAttribI4ui_Impl(index, x, y, z, w); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI1iv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttribI1iv_Impl) + glVertexAttribI1iv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI2iv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttribI2iv_Impl) + glVertexAttribI2iv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI3iv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttribI3iv_Impl) + glVertexAttribI3iv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4iv_Hook(GLuint index, const GLint *v) + { + if(glVertexAttribI4iv_Impl) + glVertexAttribI4iv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI1uiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttribI1uiv_Impl) + glVertexAttribI1uiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI2uiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttribI2uiv_Impl) + glVertexAttribI2uiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI3uiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttribI3uiv_Impl) + glVertexAttribI3uiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4uiv_Hook(GLuint index, const GLuint *v) + { + if(glVertexAttribI4uiv_Impl) + glVertexAttribI4uiv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4bv_Hook(GLuint index, const GLbyte *v) + { + if(glVertexAttribI4bv_Impl) + glVertexAttribI4bv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4sv_Hook(GLuint index, const GLshort *v) + { + if(glVertexAttribI4sv_Impl) + glVertexAttribI4sv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4ubv_Hook(GLuint index, const GLubyte *v) + { + if(glVertexAttribI4ubv_Impl) + glVertexAttribI4ubv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexAttribI4usv_Hook(GLuint index, const GLushort *v) + { + if(glVertexAttribI4usv_Impl) + glVertexAttribI4usv_Impl(index, v); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetUniformuiv_Hook(GLuint program, GLint location, GLuint *params) + { + if(glGetUniformuiv_Impl) + glGetUniformuiv_Impl(program, location, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBindFragDataLocation_Hook(GLuint program, GLuint color, const GLchar *name) + { + if(glBindFragDataLocation_Impl) + glBindFragDataLocation_Impl(program, color, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLint OVR::GLEContext::glGetFragDataLocation_Hook(GLuint program, const GLchar *name) + { + GLint i = 0; + if(glGetFragDataLocation_Impl) + i = glGetFragDataLocation_Impl(program, name); + PostHook(GLE_CURRENT_FUNCTION); + return i; + } + + void OVR::GLEContext::glUniform1ui_Hook(GLint location, GLuint v0) + { + if(glUniform1ui_Impl) + glUniform1ui_Impl(location, v0); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2ui_Hook(GLint location, GLuint v0, GLuint v1) + { + if(glUniform2ui_Impl) + glUniform2ui_Impl(location, v0, v1); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3ui_Hook(GLint location, GLuint v0, GLuint v1, GLuint v2) + { + if(glUniform3ui_Impl) + glUniform3ui_Impl(location, v0, v1, v2); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4ui_Hook(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) + { + if(glUniform4ui_Impl) + glUniform4ui_Impl(location, v0, v1, v2, v3); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform1uiv_Hook(GLint location, GLsizei count, const GLuint *value) + { + if(glUniform1uiv_Impl) + glUniform1uiv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform2uiv_Hook(GLint location, GLsizei count, const GLuint *value) + { + if(glUniform2uiv_Impl) + glUniform2uiv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform3uiv_Hook(GLint location, GLsizei count, const GLuint *value) + { + if(glUniform3uiv_Impl) + glUniform3uiv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glUniform4uiv_Hook(GLint location, GLsizei count, const GLuint *value) + { + if(glUniform4uiv_Impl) + glUniform4uiv_Impl(location, count, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTexParameterIiv_Hook(GLenum target, GLenum pname, const GLint *params) + { + if(glTexParameterIiv_Impl) + glTexParameterIiv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTexParameterIuiv_Hook(GLenum target, GLenum pname, const GLuint *params) + { + if(glTexParameterIuiv_Impl) + glTexParameterIuiv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetTexParameterIiv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetTexParameterIiv_Impl) + glGetTexParameterIiv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetTexParameterIuiv_Hook(GLenum target, GLenum pname, GLuint *params) + { + if(glGetTexParameterIuiv_Impl) + glGetTexParameterIuiv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClearBufferiv_Hook(GLenum buffer, GLint drawbuffer, const GLint *value) + { + if(glClearBufferiv_Impl) + glClearBufferiv_Impl(buffer, drawbuffer, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClearBufferuiv_Hook(GLenum buffer, GLint drawbuffer, const GLuint *value) + { + if(glClearBufferuiv_Impl) + glClearBufferuiv_Impl(buffer, drawbuffer, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClearBufferfv_Hook(GLenum buffer, GLint drawbuffer, const GLfloat *value) + { + if(glClearBufferfv_Impl) + glClearBufferfv_Impl(buffer, drawbuffer, value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClearBufferfi_Hook(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) + { + if(glClearBufferfi_Impl) + glClearBufferfi_Impl(buffer, drawbuffer, depth, stencil); + PostHook(GLE_CURRENT_FUNCTION); + } + + const GLubyte* OVR::GLEContext::glGetStringi_Hook(GLenum name, GLuint index) + { + const GLubyte* p = NULL; + if(glGetStringi_Impl) + p = glGetStringi_Impl(name, index); + PostHook(GLE_CURRENT_FUNCTION); + return p; + } + + + // GL_VERSION_3_1 + void OVR::GLEContext::glDrawArraysInstanced_Hook(GLenum mode, GLint first, GLsizei count, GLsizei primcount) + { + if(glDrawArraysInstanced_Impl) + glDrawArraysInstanced_Impl(mode, first, count, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDrawElementsInstanced_Hook(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount) + { + if(glDrawElementsInstanced_Impl) + glDrawElementsInstanced_Impl(mode, count, type, indices, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTexBuffer_Hook(GLenum target, GLenum internalformat, GLuint buffer) + { + if(glTexBuffer_Impl) + glTexBuffer_Impl(target, internalformat, buffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPrimitiveRestartIndex_Hook(GLuint index) + { + if(glPrimitiveRestartIndex_Impl) + glPrimitiveRestartIndex_Impl(index); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_3_2 + void OVR::GLEContext::glGetInteger64i_v_Hook(GLenum target, GLuint index, GLint64 *data) + { + if(glGetInteger64i_v_Impl) + glGetInteger64i_v_Impl(target, index, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetBufferParameteri64v_Hook(GLenum target, GLenum pname, GLint64 *params) + { + if(glGetBufferParameteri64v_Impl) + glGetBufferParameteri64v_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFramebufferTexture_Hook(GLenum target, GLenum attachment, GLuint texture, GLint level) + { + if(glFramebufferTexture_Impl) + glFramebufferTexture_Impl(target, attachment, texture, level); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_3_3 + void OVR::GLEContext::glVertexAttribDivisor_Hook(GLuint index, GLuint divisor) + { + if(glVertexAttribDivisor_Impl) + glVertexAttribDivisor_Impl(index, divisor); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_VERSION_4_0 + void OVR::GLEContext::glMinSampleShading_Hook(GLclampf value) + { + if(glMinSampleShading_Impl) + glMinSampleShading_Impl(value); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlendEquationi_Hook(GLuint buf, GLenum mode) + { + if(glBlendEquationi_Impl) + glBlendEquationi_Impl(buf, mode); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlendEquationSeparatei_Hook(GLuint buf, GLenum modeRGB, GLenum modeAlpha) + { + if(glBlendEquationSeparatei_Impl) + glBlendEquationSeparatei_Impl(buf, modeRGB, modeAlpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlendFunci_Hook(GLuint buf, GLenum src, GLenum dst) + { + if(glBlendFunci_Impl) + glBlendFunci_Impl(buf, src, dst); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlendFuncSeparatei_Hook(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) + { + if(glBlendFuncSeparatei_Impl) + glBlendFuncSeparatei_Impl(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_AMD_debug_output + void OVR::GLEContext::glDebugMessageEnableAMD_Hook(GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) + { + if(glDebugMessageEnableAMD_Impl) + glDebugMessageEnableAMD_Impl(category, severity, count, ids, enabled); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageInsertAMD_Hook(GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf) + { + if(glDebugMessageInsertAMD_Impl) + glDebugMessageInsertAMD_Impl(category, severity, id, length, buf); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageCallbackAMD_Hook(GLDEBUGPROCAMD callback, GLvoid *userParam) + { + if(glDebugMessageCallbackAMD_Impl) + glDebugMessageCallbackAMD_Impl(callback, userParam); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLuint OVR::GLEContext::glGetDebugMessageLogAMD_Hook(GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message) + { + GLuint u = 0; + if(glGetDebugMessageLogAMD_Impl) + u = glGetDebugMessageLogAMD_Impl(count, bufsize, categories, severities, ids, lengths, message); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + + #if defined(GLE_CGL_ENABLED) + // GL_APPLE_element_array + void OVR::GLEContext::glElementPointerAPPLE_Hook(GLenum type, const GLvoid *pointer) + { + if(glElementPointerAPPLE_Impl) + glElementPointerAPPLE_Impl(type, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDrawElementArrayAPPLE_Hook(GLenum mode, GLint first, GLsizei count) + { + if(glDrawElementArrayAPPLE_Impl) + glDrawElementArrayAPPLE_Impl(mode, first, count); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDrawRangeElementArrayAPPLE_Hook(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count) + { + if(glDrawRangeElementArrayAPPLE_Impl) + glDrawRangeElementArrayAPPLE_Impl(mode, start, end, first, count); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiDrawElementArrayAPPLE_Hook(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) + { + if(glMultiDrawElementArrayAPPLE_Impl) + glMultiDrawElementArrayAPPLE_Impl(mode, first, count, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMultiDrawRangeElementArrayAPPLE_Hook(GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount) + { + if(glMultiDrawRangeElementArrayAPPLE_Impl) + glMultiDrawRangeElementArrayAPPLE_Impl(mode, start, end, first, count, primcount); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_fence + void OVR::GLEContext::glGenFencesAPPLE_Hook(GLsizei n, GLuint *fences) + { + if(glGenFencesAPPLE_Impl) + glGenFencesAPPLE_Impl(n, fences); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteFencesAPPLE_Hook(GLsizei n, const GLuint *fences) + { + if(glDeleteFencesAPPLE_Impl) + glDeleteFencesAPPLE_Impl(n, fences); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSetFenceAPPLE_Hook(GLuint fence) + { + if(glSetFenceAPPLE_Impl) + glSetFenceAPPLE_Impl(fence); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsFenceAPPLE_Hook(GLuint fence) + { + GLboolean b = GL_FALSE; + if(glIsFenceAPPLE_Impl) + b = glIsFenceAPPLE_Impl(fence); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + GLboolean OVR::GLEContext::glTestFenceAPPLE_Hook(GLuint fence) + { + GLboolean b = GL_FALSE; + if(glTestFenceAPPLE_Impl) + b = glTestFenceAPPLE_Impl(fence); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glFinishFenceAPPLE_Hook(GLuint fence) + { + if(glFinishFenceAPPLE_Impl) + glFinishFenceAPPLE_Impl(fence); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glTestObjectAPPLE_Hook(GLenum object, GLuint name) + { + GLboolean b = GL_FALSE; + if(glTestObjectAPPLE_Impl) + b = glTestObjectAPPLE_Impl(object, name); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glFinishObjectAPPLE_Hook(GLenum object, GLint name) + { + if(glFinishObjectAPPLE_Impl) + glFinishObjectAPPLE_Impl(object, name); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_flush_buffer_range + void OVR::GLEContext::glBufferParameteriAPPLE_Hook(GLenum target, GLenum pname, GLint param) + { + if(glBufferParameteriAPPLE_Impl) + glBufferParameteriAPPLE_Impl(target, pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFlushMappedBufferRangeAPPLE_Hook(GLenum target, GLintptr offset, GLsizeiptr size) + { + if(glFlushMappedBufferRangeAPPLE_Impl) + glFlushMappedBufferRangeAPPLE_Impl(target, offset, size); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_object_purgeable + GLenum OVR::GLEContext::glObjectPurgeableAPPLE_Hook(GLenum objectType, GLuint name, GLenum option) + { + GLenum e = 0; + if(glObjectPurgeableAPPLE_Impl) + e = glObjectPurgeableAPPLE_Impl(objectType, name, option); + PostHook(GLE_CURRENT_FUNCTION); + return e; + } + + GLenum OVR::GLEContext::glObjectUnpurgeableAPPLE_Hook(GLenum objectType, GLuint name, GLenum option) + { + GLenum e = 0; + if(glObjectUnpurgeableAPPLE_Impl) + e =glObjectUnpurgeableAPPLE_Impl(objectType, name, option); + PostHook(GLE_CURRENT_FUNCTION); + return e; + } + + void OVR::GLEContext::glGetObjectParameterivAPPLE_Hook(GLenum objectType, GLuint name, GLenum pname, GLint *params) + { + if(glGetObjectParameterivAPPLE_Impl) + glGetObjectParameterivAPPLE_Impl(objectType, name, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_texture_range + void OVR::GLEContext::glTextureRangeAPPLE_Hook(GLenum target, GLsizei length, const GLvoid *pointer) + { + if(glTextureRangeAPPLE_Impl) + glTextureRangeAPPLE_Impl(target, length, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetTexParameterPointervAPPLE_Hook(GLenum target, GLenum pname, GLvoid **params) + { + if(glGetTexParameterPointervAPPLE_Impl) + glGetTexParameterPointervAPPLE_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_vertex_array_object + void OVR::GLEContext::glBindVertexArrayAPPLE_Hook(GLuint array) + { + if(glBindVertexArrayAPPLE_Impl) + glBindVertexArrayAPPLE_Impl(array); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteVertexArraysAPPLE_Hook(GLsizei n, const GLuint *arrays) + { + if(glDeleteVertexArraysAPPLE_Impl) + glDeleteVertexArraysAPPLE_Impl(n, arrays); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenVertexArraysAPPLE_Hook(GLsizei n, GLuint *arrays) + { + if(glGenVertexArraysAPPLE_Impl) + glGenVertexArraysAPPLE_Impl(n, arrays); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsVertexArrayAPPLE_Hook(GLuint array) + { + GLboolean b = GL_FALSE; + if(glIsVertexArrayAPPLE_Impl) + b = glIsVertexArrayAPPLE_Impl(array); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + + // GL_APPLE_vertex_array_range + void OVR::GLEContext::glVertexArrayRangeAPPLE_Hook(GLsizei length, GLvoid *pointer) + { + if(glVertexArrayRangeAPPLE_Impl) + glVertexArrayRangeAPPLE_Impl(length, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFlushVertexArrayRangeAPPLE_Hook(GLsizei length, GLvoid *pointer) + { + if(glFlushVertexArrayRangeAPPLE_Impl) + glFlushVertexArrayRangeAPPLE_Impl(length, pointer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glVertexArrayParameteriAPPLE_Hook(GLenum pname, GLint param) + { + if(glVertexArrayParameteriAPPLE_Impl) + glVertexArrayParameteriAPPLE_Impl(pname, param); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_APPLE_vertex_program_evaluators + void OVR::GLEContext::glEnableVertexAttribAPPLE_Hook(GLuint index, GLenum pname) + { + if(glEnableVertexAttribAPPLE_Impl) + glEnableVertexAttribAPPLE_Impl(index, pname); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDisableVertexAttribAPPLE_Hook(GLuint index, GLenum pname) + { + if(glDisableVertexAttribAPPLE_Impl) + glDisableVertexAttribAPPLE_Impl(index, pname); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsVertexAttribEnabledAPPLE_Hook(GLuint index, GLenum pname) + { + GLboolean b = GL_FALSE; + if(glIsVertexAttribEnabledAPPLE_Impl) + b = glIsVertexAttribEnabledAPPLE_Impl(index, pname); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glMapVertexAttrib1dAPPLE_Hook(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) + { + if(glMapVertexAttrib1dAPPLE_Impl) + glMapVertexAttrib1dAPPLE_Impl(index, size, u1, u2, stride, order, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glMapVertexAttrib1fAPPLE_Hook(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) + { + if(glMapVertexAttrib1fAPPLE_Impl) + glMapVertexAttrib1fAPPLE_Impl(index, size, u1, u2, stride, order, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::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) + { + if(glMapVertexAttrib2dAPPLE_Impl) + glMapVertexAttrib2dAPPLE_Impl(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::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) + { + if(glMapVertexAttrib2fAPPLE_Impl) + glMapVertexAttrib2fAPPLE_Impl(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); + PostHook(GLE_CURRENT_FUNCTION); + } + #endif // GLE_CGL_ENABLED + + + // GL_ARB_debug_output + void OVR::GLEContext::glDebugMessageControlARB_Hook(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) + { + if(glDebugMessageControlARB_Impl) + glDebugMessageControlARB_Impl(source, type, severity, count, ids, enabled); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageInsertARB_Hook(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) + { + if(glDebugMessageInsertARB_Impl) + glDebugMessageInsertARB_Impl(source, type, id, severity, length, buf); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageCallbackARB_Hook(GLDEBUGPROCARB callback, const GLvoid *userParam) + { + if(glDebugMessageCallbackARB_Impl) + glDebugMessageCallbackARB_Impl(callback, userParam); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLuint OVR::GLEContext::glGetDebugMessageLogARB_Hook(GLuint count, GLsizei bufsize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog) + { + GLuint u = 0; + if(glGetDebugMessageLogARB_Impl) + u = glGetDebugMessageLogARB_Impl(count, bufsize, sources, types, ids, severities, lengths, messageLog); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + + // GL_ARB_ES2_compatibility + void OVR::GLEContext::glReleaseShaderCompiler_Hook() + { + if(glReleaseShaderCompiler_Impl) + glReleaseShaderCompiler_Impl(); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glShaderBinary_Hook(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length) + { + if(glShaderBinary_Impl) + glShaderBinary_Impl(count, shaders, binaryformat, binary, length); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetShaderPrecisionFormat_Hook(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) + { + if(glGetShaderPrecisionFormat_Impl) + glGetShaderPrecisionFormat_Impl(shadertype, precisiontype, range, precision); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDepthRangef_Hook(GLclampf n, GLclampf f) + { + if(glDepthRangef_Impl) + glDepthRangef_Impl(n, f); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glClearDepthf_Hook(GLclampf d) + { + if(glClearDepthf_Impl) + glClearDepthf_Impl(d); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_ARB_framebuffer_object + GLboolean OVR::GLEContext::glIsRenderbuffer_Hook(GLuint renderbuffer) + { + GLboolean b = GL_FALSE; + if(glIsRenderbuffer_Impl) + b = glIsRenderbuffer_Impl(renderbuffer); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glBindRenderbuffer_Hook(GLenum target, GLuint renderbuffer) + { + if(glBindRenderbuffer_Impl) + glBindRenderbuffer_Impl(target, renderbuffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteRenderbuffers_Hook(GLsizei n, const GLuint *renderbuffers) + { + if(glDeleteRenderbuffers_Impl) + glDeleteRenderbuffers_Impl(n, renderbuffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenRenderbuffers_Hook(GLsizei n, GLuint *renderbuffers) + { + if(glGenRenderbuffers_Impl) + glGenRenderbuffers_Impl(n, renderbuffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glRenderbufferStorage_Hook(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) + { + if(glRenderbufferStorage_Impl) + glRenderbufferStorage_Impl(target, internalformat, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetRenderbufferParameteriv_Hook(GLenum target, GLenum pname, GLint *params) + { + if(glGetRenderbufferParameteriv_Impl) + glGetRenderbufferParameteriv_Impl(target, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsFramebuffer_Hook(GLuint framebuffer) + { + GLboolean b = GL_FALSE; + if(glIsFramebuffer_Impl) + b = glIsFramebuffer_Impl(framebuffer); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + void OVR::GLEContext::glBindFramebuffer_Hook(GLenum target, GLuint framebuffer) + { + if(glBindFramebuffer_Impl) + glBindFramebuffer_Impl(target, framebuffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteFramebuffers_Hook(GLsizei n, const GLuint *framebuffers) + { + if(glDeleteFramebuffers_Impl) + glDeleteFramebuffers_Impl(n, framebuffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenFramebuffers_Hook(GLsizei n, GLuint *framebuffers) + { + if(glGenFramebuffers_Impl) + glGenFramebuffers_Impl(n, framebuffers); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLenum OVR::GLEContext::glCheckFramebufferStatus_Hook(GLenum target) + { + GLenum e = 0; + if(glCheckFramebufferStatus_Impl) + e = glCheckFramebufferStatus_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + return e; + } + + void OVR::GLEContext::glFramebufferTexture1D_Hook(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + if(glFramebufferTexture1D_Impl) + glFramebufferTexture1D_Impl(target, attachment, textarget, texture, level); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFramebufferTexture2D_Hook(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + if(glFramebufferTexture2D_Impl) + glFramebufferTexture2D_Impl(target, attachment, textarget, texture, level); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFramebufferTexture3D_Hook(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) + { + if(glFramebufferTexture3D_Impl) + glFramebufferTexture3D_Impl(target, attachment, textarget, texture, level, zoffset); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFramebufferRenderbuffer_Hook(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) + { + if(glFramebufferRenderbuffer_Impl) + glFramebufferRenderbuffer_Impl(target, attachment, renderbuffertarget, renderbuffer); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetFramebufferAttachmentParameteriv_Hook(GLenum target, GLenum attachment, GLenum pname, GLint *params) + { + if(glGetFramebufferAttachmentParameteriv_Impl) + glGetFramebufferAttachmentParameteriv_Impl(target, attachment, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenerateMipmap_Hook(GLenum target) + { + if(glGenerateMipmap_Impl) + glGenerateMipmap_Impl(target); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glBlitFramebuffer_Hook(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) + { + if(glBlitFramebuffer_Impl) + glBlitFramebuffer_Impl(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glRenderbufferStorageMultisample_Hook(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) + { + if(glRenderbufferStorageMultisample_Impl) + glRenderbufferStorageMultisample_Impl(target, samples, internalformat, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glFramebufferTextureLayer_Hook(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) + { + if(glFramebufferTextureLayer_Impl) + glFramebufferTextureLayer_Impl(target, attachment, texture, level, layer); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_ARB_texture_multisample + void OVR::GLEContext::glTexImage2DMultisample_Hook(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) + { + if(glTexImage2DMultisample_Impl) + glTexImage2DMultisample_Impl(target, samples, internalformat, width, height, fixedsamplelocations); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glTexImage3DMultisample_Hook(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) + { + if(glTexImage3DMultisample_Impl) + glTexImage3DMultisample_Impl(target, samples, internalformat, width, height, depth, fixedsamplelocations); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetMultisamplefv_Hook(GLenum pname, GLuint index, GLfloat *val) + { + if(glGetMultisamplefv_Impl) + glGetMultisamplefv_Impl(pname, index, val); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glSampleMaski_Hook(GLuint index, GLbitfield mask) + { + if(glSampleMaski_Impl) + glSampleMaski_Impl(index, mask); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_ARB_timer_query + void OVR::GLEContext::glQueryCounter_Hook(GLuint id, GLenum target) + { + if(glQueryCounter_Impl) + glQueryCounter_Impl(id, target); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetQueryObjecti64v_Hook(GLuint id, GLenum pname, GLint64 *params) + { + if(glGetQueryObjecti64v_Impl) + glGetQueryObjecti64v_Impl(id, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetQueryObjectui64v_Hook(GLuint id, GLenum pname, GLuint64 *params) + { + if(glGetQueryObjectui64v_Impl) + glGetQueryObjectui64v_Impl(id, pname, params); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_ARB_vertex_array_object + void OVR::GLEContext::glBindVertexArray_Hook(GLuint array) + { + if(glBindVertexArray_Impl) + glBindVertexArray_Impl(array); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDeleteVertexArrays_Hook(GLsizei n, const GLuint *arrays) + { + if(glDeleteVertexArrays_Impl) + glDeleteVertexArrays_Impl(n, arrays); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGenVertexArrays_Hook(GLsizei n, GLuint *arrays) + { + if(glGenVertexArrays_Impl) + glGenVertexArrays_Impl(n, arrays); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsVertexArray_Hook(GLuint array) + { + GLboolean b = GL_FALSE; + if(glIsVertexArray_Impl) + b = glIsVertexArray_Impl(array); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + + // GL_EXT_draw_buffers2 + void OVR::GLEContext::glColorMaskIndexedEXT_Hook(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) + { + if(glColorMaskIndexedEXT_Impl) + glColorMaskIndexedEXT_Impl(index, r, g, b, a); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetBooleanIndexedvEXT_Hook(GLenum target, GLuint index, GLboolean *data) + { + if(glGetBooleanIndexedvEXT_Impl) + glGetBooleanIndexedvEXT_Impl(target, index, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetIntegerIndexedvEXT_Hook(GLenum target, GLuint index, GLint *data) + { + if(glGetIntegerIndexedvEXT_Impl) + glGetIntegerIndexedvEXT_Impl(target, index, data); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glEnableIndexedEXT_Hook(GLenum target, GLuint index) + { + if(glEnableIndexedEXT_Impl) + glEnableIndexedEXT_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDisableIndexedEXT_Hook(GLenum target, GLuint index) + { + if(glDisableIndexedEXT_Impl) + glDisableIndexedEXT_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLboolean OVR::GLEContext::glIsEnabledIndexedEXT_Hook(GLenum target, GLuint index) + { + GLboolean b = GL_FALSE; + if(glIsEnabledIndexedEXT_Impl) + b = glIsEnabledIndexedEXT_Impl(target, index); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + + // GL_KHR_debug + 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(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageInsert_Hook(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char* buf) + { + if(glDebugMessageInsert_Impl) + glDebugMessageInsert_Impl(source, type, id, severity, length, buf); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glDebugMessageCallback_Hook(GLDEBUGPROC callback, const void* userParam) + { + if(glDebugMessageCallback_Impl) + glDebugMessageCallback_Impl(callback, userParam); + PostHook(GLE_CURRENT_FUNCTION); + } + + GLuint OVR::GLEContext::glGetDebugMessageLog_Hook(GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, char* messageLog) + { + GLuint u = 0; + if(glGetDebugMessageLog_Impl) + u = glGetDebugMessageLog_Impl(count, bufSize, sources, types, ids, severities, lengths, messageLog); + PostHook(GLE_CURRENT_FUNCTION); + return u; + } + + void OVR::GLEContext::glPushDebugGroup_Hook(GLenum source, GLuint id, GLsizei length, const char * message) + { + if(glPushDebugGroup_Impl) + glPushDebugGroup_Impl(source, id, length, message); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glPopDebugGroup_Hook() + { + if(glPopDebugGroup_Impl) + glPopDebugGroup_Impl(); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glObjectLabel_Hook(GLenum identifier, GLuint name, GLsizei length, const char *label) + { + if(glObjectLabel_Impl) + glObjectLabel_Impl(identifier, name, length, label); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetObjectLabel_Hook(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, char *label) + { + if(glGetObjectLabel_Impl) + glGetObjectLabel_Impl(identifier, name, bufSize, length, label); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glObjectPtrLabel_Hook(void* ptr, GLsizei length, const char *label) + { + if(glObjectPtrLabel_Impl) + glObjectPtrLabel_Impl(ptr, length, label); + PostHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glGetObjectPtrLabel_Hook(void* ptr, GLsizei bufSize, GLsizei *length, char *label) + { + if(glGetObjectPtrLabel_Impl) + glGetObjectPtrLabel_Impl(ptr, bufSize, length, label); + PostHook(GLE_CURRENT_FUNCTION); + } + + + // GL_WIN_swap_hint + void OVR::GLEContext::glAddSwapHintRectWIN_Hook(GLint x, GLint y, GLsizei width, GLsizei height) + { + if(glAddSwapHintRectWIN_Impl) + glAddSwapHintRectWIN_Impl(x, y, width, height); + PostHook(GLE_CURRENT_FUNCTION); + } + + + #if defined(GLE_WGL_ENABLED) + // WGL + void OVR::GLEContext::PostWGLHook(const char* /*function*/) + { + // Empty for now. WGL functions don't have a function like glGetError(). + } + + /* We currently don't hook these + #undef wglCopyContext + extern "C" { GLAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask); } + BOOL OVR::GLEContext::wglCopyContext_Hook(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) + { + BOOL b = wglCopyContext(hglrcSrc, hglrcDst, mask); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglCreateContext + extern "C" { GLAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc); } + HGLRC OVR::GLEContext::wglCreateContext_Hook(HDC hdc) + { + HGLRC h = wglCreateContext(hdc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + #undef wglCreateLayerContext + extern "C" { GLAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc, int iLayerPlane); } + HGLRC OVR::GLEContext::wglCreateLayerContext_Hook(HDC hdc, int iLayerPlane) + { + HGLRC h = wglCreateLayerContext(hdc, iLayerPlane); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + #undef wglDeleteContext + extern "C" { GLAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc); } + BOOL OVR::GLEContext::wglDeleteContext_Hook(HGLRC hglrc) + { + BOOL b = wglDeleteContext(hglrc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglGetCurrentContext + extern "C" { GLAPI HGLRC GLAPIENTRY wglGetCurrentContext(); } + HGLRC OVR::GLEContext::wglGetCurrentContext_Hook() + { + HGLRC h = wglGetCurrentContext(); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + #undef wglGetCurrentDC + extern "C" { GLAPI HDC GLAPIENTRY wglGetCurrentDC(); } + HDC OVR::GLEContext::wglGetCurrentDC_Hook() + { + HDC h = wglGetCurrentDC(); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + //#undef wglGetProcAddress Not needed because we happen to do it above already. + //extern "C" { GLAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc); } + PROC OVR::GLEContext::wglGetProcAddress_Hook(LPCSTR lpszProc) + { + PROC p = wglGetProcAddress(lpszProc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return p; + } + + #undef wglMakeCurrent + extern "C" { GLAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc, HGLRC hglrc); } + BOOL OVR::GLEContext::wglMakeCurrent_Hook(HDC hdc, HGLRC hglrc) + { + BOOL b = wglMakeCurrent(hdc, hglrc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglShareLists + extern "C" { GLAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1, HGLRC hglrc2); } + BOOL OVR::GLEContext::wglShareLists_Hook(HGLRC hglrc1, HGLRC hglrc2) + { + BOOL b = wglShareLists(hglrc1, hglrc2); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglUseFontBitmapsA + extern "C" { GLAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase); } + BOOL OVR::GLEContext::wglUseFontBitmapsA_Hook(HDC hdc, DWORD first, DWORD count, DWORD listBase) + { + BOOL b = wglUseFontBitmapsA(hdc, first, count, listBase); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglUseFontBitmapsW + extern "C" { GLAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase); } + BOOL OVR::GLEContext::wglUseFontBitmapsW_Hook(HDC hdc, DWORD first, DWORD count, DWORD listBase) + { + BOOL b = wglUseFontBitmapsW(hdc, first, count, listBase); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglUseFontOutlinesA + extern "C" { GLAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf); } + BOOL OVR::GLEContext::wglUseFontOutlinesA_Hook(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf) + { + BOOL b = wglUseFontOutlinesA(hdc, first, count, listBase, deviation, extrusion, format, lpgmf); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglUseFontOutlinesW + extern "C" { GLAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf); } + BOOL OVR::GLEContext::wglUseFontOutlinesW_Hook(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf) + { + BOOL b = wglUseFontOutlinesW(hdc, first, count, listBase, deviation, extrusion, format, lpgmf); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglDescribeLayerPlane + extern "C" { GLAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd); } + BOOL OVR::GLEContext::wglDescribeLayerPlane_Hook(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd) + { + BOOL b = wglDescribeLayerPlane(hdc, iPixelFormat, iLayerPlane, nBytes, plpd); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglSetLayerPaletteEntries + extern "C" { GLAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF *pcr); } + int OVR::GLEContext::wglSetLayerPaletteEntries_Hook(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF *pcr) + { + int i = wglSetLayerPaletteEntries(hdc, iLayerPlane, iStart, cEntries, pcr); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + #undef wglGetLayerPaletteEntries + extern "C" { GLAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr); } + int OVR::GLEContext::wglGetLayerPaletteEntries_Hook(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr) + { + int i = wglGetLayerPaletteEntries(hdc, iLayerPlane, iStart, cEntries, pcr); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + #undef wglRealizeLayerPalette + extern "C" { GLAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize); } + BOOL OVR::GLEContext::wglRealizeLayerPalette_Hook(HDC hdc, int iLayerPlane, BOOL bRealize) + { + BOOL b = wglRealizeLayerPalette(hdc, iLayerPlane, bRealize); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglSwapLayerBuffers + extern "C" { GLAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc, UINT fuPlanes); } + BOOL OVR::GLEContext::wglSwapLayerBuffers_Hook(HDC hdc, UINT fuPlanes) + { + BOOL b = wglSwapLayerBuffers(hdc, fuPlanes); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #undef wglSwapMultipleBuffers + extern "C" { GLAPI DWORD GLAPIENTRY wglSwapMultipleBuffers(UINT i, CONST WGLSWAP* p); } + DWORD OVR::GLEContext::wglSwapMultipleBuffers_Hook(UINT i, CONST WGLSWAP* p) + { + DWORD dw = wglSwapMultipleBuffers(i, p); + PostWGLHook(GLE_CURRENT_FUNCTION); + return dw; + } + */ + + // The rest of the functions are pointer-based. + + // WGL_ARB_buffer_region + HANDLE OVR::GLEContext::wglCreateBufferRegionARB_Hook(HDC hDC, int iLayerPlane, UINT uType) + { + HANDLE h = NULL; + if(wglCreateBufferRegionARB_Impl) + h = wglCreateBufferRegionARB_Impl(hDC, iLayerPlane, uType); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + VOID OVR::GLEContext::wglDeleteBufferRegionARB_Hook(HANDLE hRegion) + { + if(wglDeleteBufferRegionARB_Impl) + wglDeleteBufferRegionARB_Impl(hRegion); + PostWGLHook(GLE_CURRENT_FUNCTION); + } + + BOOL OVR::GLEContext::wglSaveBufferRegionARB_Hook(HANDLE hRegion, int x, int y, int width, int height) + { + BOOL b = FALSE; + if(wglSaveBufferRegionARB_Impl) + b = wglSaveBufferRegionARB_Impl(hRegion, x, y, width, height); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglRestoreBufferRegionARB_Hook(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc) + { + BOOL b = FALSE; + if(wglRestoreBufferRegionARB_Impl) + b = wglRestoreBufferRegionARB_Impl(hRegion, x, y, width, height, xSrc, ySrc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_ARB_extensions_string + const char * OVR::GLEContext::wglGetExtensionsStringARB_Hook(HDC hdc) + { + const char * p = NULL; + if(wglGetExtensionsStringARB_Impl) + p = wglGetExtensionsStringARB_Impl(hdc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return p; + } + + // WGL_ARB_pixel_format + BOOL OVR::GLEContext::wglGetPixelFormatAttribivARB_Hook(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues) + { + BOOL b = FALSE; + if(wglGetPixelFormatAttribivARB_Impl) + b = wglGetPixelFormatAttribivARB_Impl(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglGetPixelFormatAttribfvARB_Hook(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues) + { + BOOL b = FALSE; + if(wglGetPixelFormatAttribfvARB_Impl) + b = wglGetPixelFormatAttribfvARB_Impl(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglChoosePixelFormatARB_Hook(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats) + { + BOOL b = FALSE; + if(wglChoosePixelFormatARB_Impl) + b = wglChoosePixelFormatARB_Impl(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_ARB_make_current_read + BOOL OVR::GLEContext::wglMakeContextCurrentARB_Hook(HDC hDrawDC, HDC hReadDC, HGLRC hglrc) + { + BOOL b = FALSE; + if(wglMakeContextCurrentARB_Impl) + b = wglMakeContextCurrentARB_Impl(hDrawDC, hReadDC, hglrc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + HDC OVR::GLEContext::wglGetCurrentReadDCARB_Hook() + { + HDC h = NULL; + if(wglGetCurrentReadDCARB_Impl) + h = wglGetCurrentReadDCARB_Impl(); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + // WGL_ARB_pbuffer + HPBUFFERARB OVR::GLEContext::wglCreatePbufferARB_Hook(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList) + { + HPBUFFERARB h = NULL; + if(wglCreatePbufferARB_Impl) + h = wglCreatePbufferARB_Impl(hDC, iPixelFormat, iWidth, iHeight, piAttribList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + HDC OVR::GLEContext::wglGetPbufferDCARB_Hook(HPBUFFERARB hPbuffer) + { + HDC h = NULL; + if(wglGetPbufferDCARB_Impl) + h = wglGetPbufferDCARB_Impl(hPbuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + int OVR::GLEContext::wglReleasePbufferDCARB_Hook(HPBUFFERARB hPbuffer, HDC hDC) + { + int i = 0; + if(wglReleasePbufferDCARB_Impl) + i = wglReleasePbufferDCARB_Impl(hPbuffer, hDC); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + BOOL OVR::GLEContext::wglDestroyPbufferARB_Hook(HPBUFFERARB hPbuffer) + { + BOOL b = FALSE; + if(wglDestroyPbufferARB_Impl) + b = wglDestroyPbufferARB_Impl(hPbuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQueryPbufferARB_Hook(HPBUFFERARB hPbuffer, int iAttribute, int *piValue) + { + BOOL b = FALSE; + if(wglQueryPbufferARB_Impl) + b = wglQueryPbufferARB_Impl(hPbuffer, iAttribute, piValue); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_ARB_render_texture + BOOL OVR::GLEContext::wglBindTexImageARB_Hook(HPBUFFERARB hPbuffer, int iBuffer) + { + BOOL b = FALSE; + if(wglBindTexImageARB_Impl) + b = wglBindTexImageARB_Impl(hPbuffer, iBuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglReleaseTexImageARB_Hook(HPBUFFERARB hPbuffer, int iBuffer) + { + BOOL b = FALSE; + if(wglReleaseTexImageARB_Impl) + b = wglReleaseTexImageARB_Impl(hPbuffer, iBuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglSetPbufferAttribARB_Hook(HPBUFFERARB hPbuffer, const int *piAttribList) + { + BOOL b = FALSE; + if(wglSetPbufferAttribARB_Impl) + b = wglSetPbufferAttribARB_Impl(hPbuffer, piAttribList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_present_video + int OVR::GLEContext::wglEnumerateVideoDevicesNV_Hook(HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList) + { + int i = 0; + if(wglEnumerateVideoDevicesNV_Impl) + i = wglEnumerateVideoDevicesNV_Impl(hDC, phDeviceList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + BOOL OVR::GLEContext::wglBindVideoDeviceNV_Hook(HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList) + { + BOOL b = FALSE; + if(wglBindVideoDeviceNV_Impl) + b = wglBindVideoDeviceNV_Impl(hDC, uVideoSlot, hVideoDevice, piAttribList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQueryCurrentContextNV_Hook(int iAttribute, int *piValue) + { + BOOL b = FALSE; + if(wglQueryCurrentContextNV_Impl) + b = wglQueryCurrentContextNV_Impl(iAttribute, piValue); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_ARB_create_context + HGLRC OVR::GLEContext::wglCreateContextAttribsARB_Hook(HDC hDC, HGLRC hShareContext, const int *attribList) + { + HGLRC h = NULL; + if(wglCreateContextAttribsARB_Impl) + h = wglCreateContextAttribsARB_Impl(hDC, hShareContext, attribList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + // WGL_EXT_extensions_string + const char * OVR::GLEContext::wglGetExtensionsStringEXT_Hook() + { + const char * p = NULL; + if(wglGetExtensionsStringEXT_Impl) + p = wglGetExtensionsStringEXT_Impl(); + PostWGLHook(GLE_CURRENT_FUNCTION); + return p; + } + + // WGL_EXT_swap_control + BOOL OVR::GLEContext::wglSwapIntervalEXT_Hook(int interval) + { + BOOL b = FALSE; + if(wglSwapIntervalEXT_Impl) + b = wglSwapIntervalEXT_Impl(interval); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + int OVR::GLEContext::wglGetSwapIntervalEXT_Hook() + { + int i = 0; + if(wglGetSwapIntervalEXT_Impl) + i = wglGetSwapIntervalEXT_Impl(); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + // WGL_OML_sync_control + BOOL OVR::GLEContext::wglGetSyncValuesOML_Hook(HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc) + { + BOOL b = FALSE; + if(wglGetSyncValuesOML_Impl) + b = wglGetSyncValuesOML_Impl(hdc, ust, msc, sbc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglGetMscRateOML_Hook(HDC hdc, INT32 *numerator, INT32 *denominator) + { + BOOL b = FALSE; + if(wglGetMscRateOML_Impl) + b = wglGetMscRateOML_Impl(hdc, numerator, denominator); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + INT64 OVR::GLEContext::wglSwapBuffersMscOML_Hook(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder) + { + INT64 i = 0; + if(wglSwapBuffersMscOML_Impl) + i = wglSwapBuffersMscOML_Impl(hdc, target_msc, divisor, remainder); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + INT64 OVR::GLEContext::wglSwapLayerBuffersMscOML_Hook(HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder) + { + INT64 i = 0; + if(wglSwapLayerBuffersMscOML_Impl) + i = wglSwapLayerBuffersMscOML_Impl(hdc, fuPlanes, target_msc, divisor, remainder); + PostWGLHook(GLE_CURRENT_FUNCTION); + return i; + } + + BOOL OVR::GLEContext::wglWaitForMscOML_Hook(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc) + { + BOOL b = FALSE; + if(wglWaitForMscOML_Impl) + b = wglWaitForMscOML_Impl(hdc, target_msc, divisor, remainder, ust, msc, sbc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglWaitForSbcOML_Hook(HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc) + { + BOOL b = FALSE; + if(wglWaitForSbcOML_Impl) + b = wglWaitForSbcOML_Impl(hdc, target_sbc, ust, msc, sbc); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_video_output + BOOL OVR::GLEContext::wglGetVideoDeviceNV_Hook(HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice) + { + BOOL b = FALSE; + if(wglGetVideoDeviceNV_Impl) + b = wglGetVideoDeviceNV_Impl(hDC, numDevices, hVideoDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglReleaseVideoDeviceNV_Hook(HPVIDEODEV hVideoDevice) + { + BOOL b = FALSE; + if(wglReleaseVideoDeviceNV_Impl) + b = wglReleaseVideoDeviceNV_Impl(hVideoDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglBindVideoImageNV_Hook(HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer) + { + BOOL b = FALSE; + if(wglBindVideoImageNV_Impl) + b = wglBindVideoImageNV_Impl(hVideoDevice, hPbuffer, iVideoBuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglReleaseVideoImageNV_Hook(HPBUFFERARB hPbuffer, int iVideoBuffer) + { + BOOL b = FALSE; + if(wglReleaseVideoImageNV_Impl) + b = wglReleaseVideoImageNV_Impl(hPbuffer, iVideoBuffer); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglSendPbufferToVideoNV_Hook(HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock) + { + BOOL b = FALSE; + if(wglSendPbufferToVideoNV_Impl) + b = wglSendPbufferToVideoNV_Impl(hPbuffer, iBufferType, pulCounterPbuffer, bBlock); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglGetVideoInfoNV_Hook(HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo) + { + BOOL b = FALSE; + if(wglGetVideoInfoNV_Impl) + b = wglGetVideoInfoNV_Impl(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_swap_group + BOOL OVR::GLEContext::wglJoinSwapGroupNV_Hook(HDC hDC, GLuint group) + { + BOOL b = FALSE; + if(wglJoinSwapGroupNV_Impl) + b = wglJoinSwapGroupNV_Impl(hDC, group); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglBindSwapBarrierNV_Hook(GLuint group, GLuint barrier) + { + BOOL b = FALSE; + if(wglBindSwapBarrierNV_Impl) + b = wglBindSwapBarrierNV_Impl(group, barrier); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQuerySwapGroupNV_Hook(HDC hDC, GLuint *group, GLuint *barrier) + { + BOOL b = FALSE; + if(wglQuerySwapGroupNV_Impl) + b = wglQuerySwapGroupNV_Impl(hDC, group, barrier); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQueryMaxSwapGroupsNV_Hook(HDC hDC, GLuint *maxGroups, GLuint *maxBarriers) + { + BOOL b = FALSE; + if(wglQueryMaxSwapGroupsNV_Impl) + b = wglQueryMaxSwapGroupsNV_Impl(hDC, maxGroups, maxBarriers); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQueryFrameCountNV_Hook(HDC hDC, GLuint *count) + { + BOOL b = FALSE; + if(wglQueryFrameCountNV_Impl) + b = wglQueryFrameCountNV_Impl(hDC, count); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglResetFrameCountNV_Hook(HDC hDC) + { + BOOL b = FALSE; + if(wglResetFrameCountNV_Impl) + b = wglResetFrameCountNV_Impl(hDC); + PostHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_video_capture + BOOL OVR::GLEContext::wglBindVideoCaptureDeviceNV_Hook(UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice) + { + BOOL b = FALSE; + if(wglBindVideoCaptureDeviceNV_Impl) + b = wglBindVideoCaptureDeviceNV_Impl(uVideoSlot, hDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + UINT OVR::GLEContext::wglEnumerateVideoCaptureDevicesNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList) + { + UINT u = 0; + if(wglEnumerateVideoCaptureDevicesNV_Impl) + u = wglEnumerateVideoCaptureDevicesNV_Impl(hDc, phDeviceList); + PostWGLHook(GLE_CURRENT_FUNCTION); + return u; + } + + BOOL OVR::GLEContext::wglLockVideoCaptureDeviceNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV hDevice) + { + BOOL b = FALSE; + if(wglLockVideoCaptureDeviceNV_Impl) + b = wglLockVideoCaptureDeviceNV_Impl(hDc, hDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglQueryVideoCaptureDeviceNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue) + { + BOOL b = FALSE; + if(wglQueryVideoCaptureDeviceNV_Impl) + b = wglQueryVideoCaptureDeviceNV_Impl(hDc, hDevice, iAttribute, piValue); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglReleaseVideoCaptureDeviceNV_Hook(HDC hDc, HVIDEOINPUTDEVICENV hDevice) + { + BOOL b = FALSE; + if(wglReleaseVideoCaptureDeviceNV_Impl) + b = wglReleaseVideoCaptureDeviceNV_Impl(hDc, hDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_copy_image + BOOL OVR::GLEContext::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) + { + BOOL b = FALSE; + if(wglCopyImageSubDataNV_Impl) + b = wglCopyImageSubDataNV_Impl(hSrcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, hDstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + // WGL_NV_DX_interop + BOOL OVR::GLEContext::wglDXSetResourceShareHandleNV_Hook(void *dxObject, HANDLE shareHandle) + { + BOOL b = FALSE; + if(wglDXSetResourceShareHandleNV_Impl) + b = wglDXSetResourceShareHandleNV_Impl(dxObject, shareHandle); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + HANDLE OVR::GLEContext::wglDXOpenDeviceNV_Hook(void *dxDevice) + { + HANDLE h = NULL; + if(wglDXOpenDeviceNV_Impl) + h = wglDXOpenDeviceNV_Impl(dxDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + BOOL OVR::GLEContext::wglDXCloseDeviceNV_Hook(HANDLE hDevice) + { + BOOL b = FALSE; + if(wglDXCloseDeviceNV_Impl) + b = wglDXCloseDeviceNV_Impl(hDevice); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + HANDLE OVR::GLEContext::wglDXRegisterObjectNV_Hook(HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access) + { + HANDLE h = NULL; + if(wglDXRegisterObjectNV_Impl) + h = wglDXRegisterObjectNV_Impl(hDevice, dxObject, name, type, access); + PostWGLHook(GLE_CURRENT_FUNCTION); + return h; + } + + BOOL OVR::GLEContext::wglDXUnregisterObjectNV_Hook(HANDLE hDevice, HANDLE hObject) + { + BOOL b = FALSE; + if(wglDXUnregisterObjectNV_Impl) + b = wglDXUnregisterObjectNV_Impl(hDevice, hObject); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglDXObjectAccessNV_Hook(HANDLE hObject, GLenum access) + { + BOOL b = FALSE; + if(wglDXObjectAccessNV_Impl) + b = wglDXObjectAccessNV_Impl(hObject, access); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglDXLockObjectsNV_Hook(HANDLE hDevice, GLint count, HANDLE *hObjects) + { + BOOL b = FALSE; + if(wglDXLockObjectsNV_Impl) + b = wglDXLockObjectsNV_Impl(hDevice, count, hObjects); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + BOOL OVR::GLEContext::wglDXUnlockObjectsNV_Hook(HANDLE hDevice, GLint count, HANDLE *hObjects) + { + BOOL b = FALSE; + if(wglDXUnlockObjectsNV_Impl) + b = wglDXUnlockObjectsNV_Impl(hDevice, count, hObjects); + PostWGLHook(GLE_CURRENT_FUNCTION); + return b; + } + + #endif // defined(GLE_WGL_ENABLED) + + #if defined(GLE_GLX_ENABLED) + void OVR::GLEContext::PostGLXHook(const char* /*function*/) + { + // Empty for now. GLX functions don't have a function like glGetError(). + } + + // GLX_VERSION_1_0 + // GLX_VERSION_1_1 + // We don't currently implement hooking of these. + + // GLX_VERSION_1_2 + ::Display* OVR::GLEContext::glXGetCurrentDisplay_Hook(void) + { + ::Display* p = NULL; + if(glXGetCurrentDisplay_Impl) + p = glXGetCurrentDisplay_Impl(); + PostGLXHook(GLE_CURRENT_FUNCTION); + return p; + } + + // GLX_VERSION_1_3 + GLXFBConfig* OVR::GLEContext::glXChooseFBConfig_Hook(Display *dpy, int screen, const int *attrib_list, int *nelements) + { + GLXFBConfig* p = NULL; + if(glXChooseFBConfig_Impl) + p = glXChooseFBConfig_Impl(dpy, screen, attrib_list, nelements); + PostGLXHook(GLE_CURRENT_FUNCTION); + return p; + } + + GLXContext OVR::GLEContext::glXCreateNewContext_Hook(Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct) + { + GLXContext c = 0; + if(glXCreateNewContext_Impl) + c = glXCreateNewContext_Impl(dpy, config, render_type, share_list, direct); + PostGLXHook(GLE_CURRENT_FUNCTION); + return c; + } + + GLXPbuffer OVR::GLEContext::glXCreatePbuffer_Hook(Display *dpy, GLXFBConfig config, const int *attrib_list) + { + GLXPbuffer b = 0; + if(glXCreatePbuffer_Impl) + b = glXCreatePbuffer_Impl(dpy, config, attrib_list); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + GLXPixmap OVR::GLEContext::glXCreatePixmap_Hook(Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list) + { + GLXPixmap m = 0; + if(glXCreatePixmap_Impl) + m = glXCreatePixmap_Impl(dpy, config, pixmap, attrib_list); + PostGLXHook(GLE_CURRENT_FUNCTION); + return m; + } + + GLXWindow OVR::GLEContext::glXCreateWindow_Hook(Display *dpy, GLXFBConfig config, Window win, const int *attrib_list) + { + GLXWindow w = 0; + if(glXCreateWindow_Impl) + w = glXCreateWindow_Impl(dpy, config, win, attrib_list); + PostGLXHook(GLE_CURRENT_FUNCTION); + return w; + } + + void OVR::GLEContext::glXDestroyPbuffer_Hook(Display *dpy, GLXPbuffer pbuf) + { + if(glXDestroyPbuffer_Impl) + glXDestroyPbuffer_Impl(dpy, pbuf); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glXDestroyPixmap_Hook(Display *dpy, GLXPixmap pixmap) + { + if(glXDestroyPixmap_Impl) + glXDestroyPixmap_Impl(dpy, pixmap); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glXDestroyWindow_Hook(Display *dpy, GLXWindow win) + { + if(glXDestroyWindow_Impl) + glXDestroyWindow_Impl(dpy, win); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + GLXDrawable OVR::GLEContext::glXGetCurrentReadDrawable_Hook(void) + { + GLXDrawable d; + if(glXGetCurrentReadDrawable_Impl) + d = glXGetCurrentReadDrawable_Impl(); + PostGLXHook(GLE_CURRENT_FUNCTION); + return d; + } + + int OVR::GLEContext::glXGetFBConfigAttrib_Hook(Display *dpy, GLXFBConfig config, int attribute, int *value) + { + int i = -1; + if(glXGetFBConfigAttrib_Impl) + i = glXGetFBConfigAttrib_Impl(dpy, config, attribute, value); + PostGLXHook(GLE_CURRENT_FUNCTION); + return i; + } + + GLXFBConfig* OVR::GLEContext::glXGetFBConfigs_Hook(Display *dpy, int screen, int *nelements) + { + GLXFBConfig* p = NULL; + if(glXGetFBConfigs_Impl) + p = glXGetFBConfigs_Impl(dpy, screen, nelements); + PostGLXHook(GLE_CURRENT_FUNCTION); + return p; + } + + void OVR::GLEContext::glXGetSelectedEvent_Hook(Display *dpy, GLXDrawable draw, unsigned long *event_mask) + { + if(glXGetSelectedEvent_Impl) + glXGetSelectedEvent_Impl(dpy, draw, event_mask); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + XVisualInfo* OVR::GLEContext::glXGetVisualFromFBConfig_Hook(Display *dpy, GLXFBConfig config) + { + XVisualInfo* p = NULL; + if(glXGetVisualFromFBConfig_Impl) + p = glXGetVisualFromFBConfig_Impl(dpy, config); + PostGLXHook(GLE_CURRENT_FUNCTION); + return p; + } + + Bool OVR::GLEContext::glXMakeContextCurrent_Hook(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) + { + Bool b = False; + if(glXMakeContextCurrent_Impl) + b = glXMakeContextCurrent_Impl(dpy, draw, read, ctx); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + int OVR::GLEContext::glXQueryContext_Hook(Display *dpy, GLXContext ctx, int attribute, int *value) + { + int i = GLX_BAD_ATTRIBUTE; + if(glXQueryContext_Impl) + i = glXQueryContext_Impl(dpy, ctx, attribute, value); + PostGLXHook(GLE_CURRENT_FUNCTION); + return i; + } + + void OVR::GLEContext::glXQueryDrawable_Hook(Display *dpy, GLXDrawable draw, int attribute, unsigned int *value) + { + if(glXQueryDrawable_Impl) + glXQueryDrawable_Impl(dpy, draw, attribute, value); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + void OVR::GLEContext::glXSelectEvent_Hook(Display *dpy, GLXDrawable draw, unsigned long event_mask) + { + if(glXSelectEvent_Impl) + glXSelectEvent_Impl(dpy, draw, event_mask); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + // GLX_VERSION_1_4 + // We don't do hooking of this. + + // GLX_ARB_create_context + GLXContext OVR::GLEContext::glXCreateContextAttribsARB_Hook(Display* dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list) + { + GLXContext c = 0; + if(glXCreateContextAttribsARB_Impl) + c = glXCreateContextAttribsARB_Impl(dpy, config, share_context, direct, attrib_list); + PostGLXHook(GLE_CURRENT_FUNCTION); + return c; + } + + // GLX_EXT_swap_control + void OVR::GLEContext::glXSwapIntervalEXT_Hook(Display* dpy, GLXDrawable drawable, int interval) + { + if(glXSwapIntervalEXT_Impl) + glXSwapIntervalEXT_Impl(dpy, drawable, interval); + PostGLXHook(GLE_CURRENT_FUNCTION); + } + + // GLX_OML_sync_control + Bool OVR::GLEContext::glXGetMscRateOML_Hook(Display* dpy, GLXDrawable drawable, int32_t* numerator, int32_t* denominator) + { + Bool b = False; + if(glXGetMscRateOML_Impl) + b = glXGetMscRateOML_Impl(dpy, drawable, numerator, denominator); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + Bool OVR::GLEContext::glXGetSyncValuesOML_Hook(Display* dpy, GLXDrawable drawable, int64_t* ust, int64_t* msc, int64_t* sbc) + { + Bool b = False; + if(glXGetSyncValuesOML_Impl) + b = glXGetSyncValuesOML_Impl(dpy, drawable, ust, msc, sbc); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + int64_t OVR::GLEContext::glXSwapBuffersMscOML_Hook(Display* dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder) + { + int64_t i = 0; + if(glXSwapBuffersMscOML_Impl) + i = glXSwapBuffersMscOML_Impl(dpy, drawable, target_msc, divisor, remainder); + PostGLXHook(GLE_CURRENT_FUNCTION); + return i; + } + + Bool OVR::GLEContext::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 b = False; + if(glXWaitForMscOML_Impl) + b = glXWaitForMscOML_Impl(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + Bool OVR::GLEContext::glXWaitForSbcOML_Hook(Display* dpy, GLXDrawable drawable, int64_t target_sbc, int64_t* ust, int64_t* msc, int64_t* sbc) + { + Bool b = False; + if(glXWaitForSbcOML_Impl) + b = glXWaitForSbcOML_Impl(dpy, drawable, target_sbc, ust, msc, sbc); + PostGLXHook(GLE_CURRENT_FUNCTION); + return b; + } + + // GLX_MESA_swap_control + int OVR::GLEContext::glXGetSwapIntervalMESA_Hook() + { + int i = 0; + if(glXGetSwapIntervalMESA_Impl) + i = glXGetSwapIntervalMESA_Impl(); + PostGLXHook(GLE_CURRENT_FUNCTION); + return i; + } + + + int OVR::GLEContext::glXSwapIntervalMESA_Hook(unsigned int interval) + { + int i = 0; + if(glXSwapIntervalMESA_Impl) + i = glXSwapIntervalMESA_Impl(interval); + PostGLXHook(GLE_CURRENT_FUNCTION); + return i; + } + + #endif // defined(GLE_GLX_ENABLED) + + #endif // GLE_HOOKING_ENABLED + +//} // namespace OVR + + + |