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, 0 insertions, 7884 deletions
diff --git a/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp b/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp deleted file mode 100644 index c41d745..0000000 --- a/LibOVR/Src/CAPI/GL/CAPI_GLE.cpp +++ /dev/null @@ -1,7884 +0,0 @@ -/************************************************************************************ - -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 - - - |