/************************************************************************************ 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" #if defined(OVR_OS_WIN32) #include "Kernel/OVR_Win32_IncludeWindows.h" #endif // OVR_OS_WIN32 #include #if defined(_WIN32) #pragma comment(lib, "opengl32.lib") #elif defined(__APPLE__) #include #include #include #include #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_copy_buffer GLELoadProc(glCopyBufferSubData_Impl, glCopyBufferSubData); // 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. // 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_copy_buffer, "GL_ARB_copy_buffer" }, { 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 ) 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_copy_buffer = true; 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_copy_buffer void OVR::GLEContext::glCopyBufferSubData_Hook(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size) { if(glCopyBufferSubData_Impl) glCopyBufferSubData_Impl(readtarget, writetarget, readoffset, writeoffset, size); PostHook(GLE_CURRENT_FUNCTION); } // 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