Refactored wrapping layer

  - Enhance performance for no-tracing path
  - API trace is now enabled
  - Minor bug fixes

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0403664..eaa171b 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,12 +22,11 @@ SET(CMAKE_SKIP_BUILD_RPATH TRUE)
 # Build coregl Library
 # ------------------------------
 SET(COREGL "COREGL")
-SET(SRCS_common src/coregl.c src/coregl_thread_pthread.c src/coregl_trace.c
-               src/coregl_override.c src/coregl_wrappath.c
-               src/coregl_wrappath_egl.c src/coregl_wrappath_gl.c
-               src/coregl_fastpath.c src/coregl_fastpath_egl.c
-               src/coregl_fastpath_gl.c)
-#SET(HEADERS_common src/coregl_fastpath.h src/coregl_fastpath_state.h src/coregl.h src/coregl_internal.h src/coregl_thread_pthread.h src/coregl_wrappath.h)
+SET(SRCS_common src/coregl.c src/coregl_thread_pthread.c src/coregl_trace.c src/coregl_override.c
+               src/coregl_export.c src/coregl_export_egl.c src/coregl_export_gl.c
+               src/coregl_wrappath.c src/coregl_wrappath_egl.c src/coregl_wrappath_gl.c
+               src/coregl_fastpath.c src/coregl_fastpath_egl.c src/coregl_fastpath_gl.c)
+#SET(HEADERS_common src/coregl_export.h src/coregl_fastpath.h src/coregl_fastpath_state.h src/coregl.h src/coregl_internal.h src/coregl_thread_pthread.h src/coregl_wrappath.h)
 
 INCLUDE(FindPkgConfig)
 pkg_check_modules(pkg_common REQUIRED x11)

diff --git a/Makefile b/Makefile
index 96a73e0..569514e 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -10,6 +10,9 @@ SOURCES = \
                src/coregl_thread_pthread.c \
                src/coregl_trace.c \
                src/coregl_override.c \
+               src/coregl_export.c \
+               src/coregl_export_egl.c \
+               src/coregl_export_gl.c \
                src/coregl_wrappath.c \
                src/coregl_wrappath_egl.c \
                src/coregl_wrappath_gl.c \

diff --git a/include/EGL/sym_egl.h b/include/EGL/sym_egl.h
index d31a675..21bdeec 100644 (file)
--- a/include/EGL/sym_egl.h
+++ b/include/EGL/sym_egl.h
@@ -29,7 +29,7 @@ _COREGL_SYMBOL(GL_FALSE, EGLBoolean, eglReleaseThread, (void))
 _COREGL_SYMBOL(GL_FALSE, EGLSurface, eglCreatePbufferFromClientBuffer, (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list))
 
 _COREGL_SYMBOL(GL_FALSE, EGLBoolean, eglSurfaceAttrib, (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value))
-_COREGL_SYMBOL(GL_FALSE, void, eglBindTexImage, (EGLDisplay dpy, EGLSurface surface, EGLint buffer))
+_COREGL_SYMBOL(GL_FALSE, EGLBoolean, eglBindTexImage, (EGLDisplay dpy, EGLSurface surface, EGLint buffer))
 _COREGL_SYMBOL(GL_FALSE, EGLBoolean, eglReleaseTexImage, (EGLDisplay dpy, EGLSurface surface, EGLint buffer))
 _COREGL_SYMBOL(GL_FALSE, EGLBoolean, eglSwapInterval, (EGLDisplay dpy, EGLint interval))
 _COREGL_SYMBOL(GL_FALSE, EGLContext, eglCreateContext, (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list))

diff --git a/src/coregl_export.c b/src/coregl_export.c
new file mode 100644 (file)
index 0000000..eb04247
--- /dev/null
+++ b/src/coregl_export.c
@@ -0,0 +1,10 @@
+#include "coregl_export.h"
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     RET_TYPE (*ovr_##FUNC_NAME) PARAM_LIST = NULL;
+#include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     RET_TYPE (*wrp_##FUNC_NAME) PARAM_LIST = NULL;
+#include "headers/sym.h"
+#undef _COREGL_SYMBOL
+

diff --git a/src/coregl_export.h b/src/coregl_export.h
new file mode 100644 (file)
index 0000000..c0313b2
--- /dev/null
+++ b/src/coregl_export.h
@@ -0,0 +1,15 @@
+#ifndef COREGL_EXPORT_H
+#define COREGL_EXPORT_H
+
+#include "coregl_internal.h"
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     extern RET_TYPE (*ovr_##FUNC_NAME) PARAM_LIST;
+# include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     extern RET_TYPE (*wrp_##FUNC_NAME) PARAM_LIST;
+# include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
+#endif // COREGL_EXPORT_H
+

diff --git a/src/coregl_export_egl.c b/src/coregl_export_egl.c
new file mode 100644 (file)
index 0000000..a3493d6
--- /dev/null
+++ b/src/coregl_export_egl.c
@@ -0,0 +1,249 @@
+#include "coregl_export.h"
+
+EGLint
+eglGetError(void)
+{
+       return ovr_eglGetError();
+}
+
+EGLDisplay
+eglGetDisplay(EGLNativeDisplayType display_id)
+{
+       return ovr_eglGetDisplay(display_id);
+}
+
+EGLBoolean
+eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
+{
+       return ovr_eglInitialize(dpy, major, minor);
+}
+
+EGLBoolean
+eglTerminate(EGLDisplay dpy)
+{
+       return ovr_eglTerminate(dpy);
+}
+
+EGLBoolean
+eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+{
+       return ovr_eglGetConfigs(dpy, configs, config_size, num_config);
+}
+
+EGLBoolean
+eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
+{
+       return ovr_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+}
+
+EGLBoolean
+eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
+{
+       return ovr_eglGetConfigAttrib(dpy, config, attribute, value);
+}
+
+
+EGLSurface
+eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
+{
+       return ovr_eglCreateWindowSurface(dpy, config, win, attrib_list);
+}
+
+EGLSurface
+eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+{
+       return ovr_eglCreatePbufferSurface(dpy, config, attrib_list);
+}
+
+EGLSurface
+eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
+{
+       return ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+}
+
+EGLBoolean
+eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
+{
+       return ovr_eglDestroySurface(dpy, surface);
+}
+
+EGLBoolean
+eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
+{
+       return ovr_eglQuerySurface(dpy, surface, attribute, value);
+}
+
+EGLBoolean
+eglBindAPI(EGLenum api)
+{
+       return ovr_eglBindAPI(api);
+}
+
+EGLenum
+eglQueryAPI(void)
+{
+       return ovr_eglQueryAPI();
+}
+
+EGLBoolean
+eglWaitClient(void)
+{
+       return ovr_eglWaitClient();
+}
+
+EGLBoolean
+eglReleaseThread(void)
+{
+       return ovr_eglReleaseThread();
+}
+
+EGLSurface
+eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
+{
+       return ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
+}
+
+EGLBoolean
+eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
+{
+       return ovr_eglSurfaceAttrib(dpy, surface, attribute, value);
+}
+
+EGLBoolean
+eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+{
+       return ovr_eglBindTexImage(dpy, surface, buffer);
+}
+
+EGLBoolean
+eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+{
+       return ovr_eglReleaseTexImage(dpy, surface, buffer);
+}
+
+EGLBoolean
+eglSwapInterval(EGLDisplay dpy, EGLint interval)
+{
+       return ovr_eglSwapInterval(dpy, interval);
+}
+
+EGLContext
+eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
+{
+       return ovr_eglCreateContext(dpy, config, share_context, attrib_list);
+}
+
+EGLBoolean
+eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
+{
+       return ovr_eglDestroyContext(dpy, ctx);
+}
+
+EGLBoolean
+eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+{
+       return ovr_eglMakeCurrent(dpy, draw, read, ctx);
+}
+
+EGLContext
+eglGetCurrentContext(void)
+{
+       return ovr_eglGetCurrentContext();
+}
+
+EGLSurface
+eglGetCurrentSurface(EGLint readdraw)
+{
+       return ovr_eglGetCurrentSurface(readdraw);
+}
+
+EGLDisplay
+eglGetCurrentDisplay(void)
+{
+       return ovr_eglGetCurrentDisplay();
+}
+
+EGLBoolean
+eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
+{
+       return ovr_eglQueryContext(dpy, ctx, attribute, value);
+}
+
+EGLBoolean
+eglWaitGL(void)
+{
+       return ovr_eglWaitGL();
+}
+
+EGLBoolean
+eglWaitNative(EGLint engine)
+{
+       return ovr_eglWaitNative(engine);
+}
+
+EGLBoolean
+eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
+{
+       return ovr_eglSwapBuffers(dpy, surface);
+}
+
+EGLBoolean
+eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
+{
+       return ovr_eglCopyBuffers(dpy, surface, target);
+}
+
+_eng_fn
+eglGetProcAddress(const char* procname)
+{
+       return ovr_eglGetProcAddress(procname);
+}
+
+const char *
+eglQueryString(EGLDisplay dpy, EGLint name)
+{
+       return ovr_eglQueryString(dpy, name);
+}
+
+EGLImageKHR
+eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
+{
+       return ovr_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
+}
+
+EGLBoolean
+eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
+{
+       return ovr_eglDestroyImageKHR(dpy, image);
+}
+
+void *
+eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image)
+{
+       return ovr_eglMapImageSEC(dpy, image);
+}
+
+EGLBoolean
+eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image)
+{
+       return ovr_eglUnmapImageSEC(dpy, image);
+}
+
+EGLBoolean
+eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value)
+{
+       return ovr_eglGetImageAttribSEC(dpy, image, attribute, value);
+}
+
+EGLBoolean
+eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
+{
+       return ovr_eglLockSurfaceKHR(display, surface, attrib_list);
+}
+
+EGLBoolean
+eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
+{
+       return ovr_eglUnlockSurfaceKHR(display, surface);
+}
+

diff --git a/src/coregl_export_gl.c b/src/coregl_export_gl.c
new file mode 100644 (file)
index 0000000..00ba646
--- /dev/null
+++ b/src/coregl_export_gl.c
@@ -0,0 +1,906 @@
+#include "coregl_export.h"
+
+void
+glActiveTexture(GLenum texture)
+{
+       ovr_glActiveTexture(texture);
+}
+
+void
+glAttachShader(GLuint program, GLuint shader)
+{
+       ovr_glAttachShader(program, shader);
+}
+
+void
+glBindAttribLocation(GLuint program, GLuint index, const char* name)
+{
+       ovr_glBindAttribLocation(program, index, name);
+}
+
+void
+glBindBuffer(GLenum target, GLuint buffer)
+{
+       ovr_glBindBuffer(target, buffer);
+}
+
+void
+glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+       ovr_glBindFramebuffer(target, framebuffer);
+}
+
+void
+glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+{
+       ovr_glBindRenderbuffer(target, renderbuffer);
+}
+
+void
+glBindTexture(GLenum target, GLuint texture)
+{
+       ovr_glBindTexture(target, texture);
+}
+
+void
+glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+       ovr_glBlendColor(red, green, blue, alpha);
+}
+
+void
+glBlendEquation(GLenum mode)
+{
+       ovr_glBlendEquation(mode);
+}
+
+void
+glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+{
+       ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
+}
+
+void
+glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+       ovr_glBlendFunc(sfactor, dfactor);
+}
+
+void
+glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+       ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void
+glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
+{
+       ovr_glBufferData(target, size, data, usage);
+}
+
+void
+glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
+{
+       ovr_glBufferSubData(target, offset, size, data);
+}
+
+GLenum
+glCheckFramebufferStatus(GLenum target)
+{
+       return ovr_glCheckFramebufferStatus(target);
+}
+
+void
+glClear(GLbitfield mask)
+{
+       ovr_glClear(mask);
+}
+
+void
+glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+       ovr_glClearColor(red, green, blue, alpha);
+}
+
+void
+glClearDepthf(GLclampf depth)
+{
+       ovr_glClearDepthf(depth);
+}
+
+void
+glClearStencil(GLint s)
+{
+       ovr_glClearStencil(s);
+}
+
+void
+glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+       ovr_glColorMask(red, green, blue, alpha);
+}
+
+void
+glCompileShader(GLuint shader)
+{
+       ovr_glCompileShader(shader);
+}
+
+void
+glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
+{
+       ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+}
+
+void
+glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+{
+       ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+
+void
+glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+       ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+}
+
+void
+glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+       ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+}
+
+GLuint
+glCreateProgram(void)
+{
+       return ovr_glCreateProgram();
+}
+
+GLuint
+glCreateShader(GLenum type)
+{
+       return ovr_glCreateShader(type);
+}
+
+void
+glCullFace(GLenum mode)
+{
+       ovr_glCullFace(mode);
+}
+
+void
+glDeleteBuffers(GLsizei n, const GLuint* buffers)
+{
+       ovr_glDeleteBuffers(n, buffers);
+}
+
+void
+glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+{
+       ovr_glDeleteFramebuffers(n, framebuffers);
+}
+
+void
+glDeleteProgram(GLuint program)
+{
+       ovr_glDeleteProgram(program);
+}
+
+void
+glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+{
+       ovr_glDeleteRenderbuffers(n, renderbuffers);
+}
+
+void
+glDeleteShader(GLuint shader)
+{
+       ovr_glDeleteShader(shader);
+}
+
+void
+glDeleteTextures(GLsizei n, const GLuint* textures)
+{
+       ovr_glDeleteTextures(n, textures);
+}
+
+void
+glDepthFunc(GLenum func)
+{
+       ovr_glDepthFunc(func);
+}
+
+void
+glDepthMask(GLboolean flag)
+{
+       ovr_glDepthMask(flag);
+}
+
+void
+glDepthRangef(GLclampf zNear, GLclampf zFar)
+{
+       ovr_glDepthRangef(zNear, zFar);
+}
+
+void
+glDetachShader(GLuint program, GLuint shader)
+{
+       ovr_glDetachShader(program, shader);
+}
+
+void
+glDisable(GLenum cap)
+{
+       ovr_glDisable(cap);
+}
+
+void
+glDisableVertexAttribArray(GLuint index)
+{
+       ovr_glDisableVertexAttribArray(index);
+}
+
+void
+glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+       ovr_glDrawArrays(mode, first, count);
+}
+
+void
+glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
+{
+       ovr_glDrawElements(mode, count, type, indices);
+}
+
+void
+glEnable(GLenum cap)
+{
+       ovr_glEnable(cap);
+}
+
+void
+glEnableVertexAttribArray(GLuint index)
+{
+       ovr_glEnableVertexAttribArray(index);
+}
+
+void
+glFinish(void)
+{
+       ovr_glFinish();
+}
+
+void
+glFlush(void)
+{
+       ovr_glFlush();
+}
+
+void
+glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+       ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+}
+
+void
+glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+       ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
+}
+
+void
+glFrontFace(GLenum mode)
+{
+       ovr_glFrontFace(mode);
+}
+
+void
+glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+{
+       ovr_glGetVertexAttribfv(index, pname, params);
+}
+
+void
+glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+{
+       ovr_glGetVertexAttribiv(index, pname, params);
+}
+
+void
+glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
+{
+       ovr_glGetVertexAttribPointerv(index, pname, pointer);
+}
+
+void
+glHint(GLenum target, GLenum mode)
+{
+       ovr_glHint(target, mode);
+}
+
+void
+glGenBuffers(GLsizei n, GLuint* buffers)
+{
+       ovr_glGenBuffers(n, buffers);
+}
+
+void
+glGenerateMipmap(GLenum target)
+{
+       ovr_glGenerateMipmap(target);
+}
+
+void
+glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+{
+       ovr_glGenFramebuffers(n, framebuffers);
+}
+
+void
+glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+{
+       ovr_glGenRenderbuffers(n, renderbuffers);
+}
+
+void
+glGenTextures(GLsizei n, GLuint* textures)
+{
+       ovr_glGenTextures(n, textures);
+}
+
+void
+glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+{
+       ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
+}
+
+void
+glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+{
+       ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
+}
+
+void
+glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+{
+       ovr_glGetAttachedShaders(program, maxcount, count, shaders);
+}
+
+int
+glGetAttribLocation(GLuint program, const char* name)
+{
+       return ovr_glGetAttribLocation(program, name);
+}
+
+void
+glGetBooleanv(GLenum pname, GLboolean* params)
+{
+       ovr_glGetBooleanv(pname, params);
+}
+
+void
+glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+       ovr_glGetBufferParameteriv(target, pname, params);
+}
+
+GLenum
+glGetError(void)
+{
+       return ovr_glGetError();
+}
+
+void
+glGetFloatv(GLenum pname, GLfloat* params)
+{
+       ovr_glGetFloatv(pname, params);
+}
+
+void
+glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+{
+       ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+}
+
+void
+glGetIntegerv(GLenum pname, GLint* params)
+{
+       ovr_glGetIntegerv(pname, params);
+}
+
+void
+glGetProgramiv(GLuint program, GLenum pname, GLint* params)
+{
+       ovr_glGetProgramiv(program, pname, params);
+}
+
+void
+glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
+{
+       ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
+}
+
+void
+glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+       ovr_glGetRenderbufferParameteriv(target, pname, params);
+}
+
+void
+glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+{
+       ovr_glGetShaderiv(shader, pname, params);
+}
+
+void
+glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+{
+       ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
+}
+
+void
+glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+{
+       ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+}
+
+void
+glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+{
+       ovr_glGetShaderSource(shader, bufsize, length, source);
+}
+
+const GLubyte *
+glGetString(GLenum name)
+{
+       return ovr_glGetString(name);
+}
+
+void
+glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+{
+       ovr_glGetTexParameterfv(target, pname, params);
+}
+
+void
+glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+       ovr_glGetTexParameteriv(target, pname, params);
+}
+
+void
+glGetUniformfv(GLuint program, GLint location, GLfloat* params)
+{
+       ovr_glGetUniformfv(program, location, params);
+}
+
+void
+glGetUniformiv(GLuint program, GLint location, GLint* params)
+{
+       ovr_glGetUniformiv(program, location, params);
+}
+
+int
+glGetUniformLocation(GLuint program, const char* name)
+{
+       return ovr_glGetUniformLocation(program, name);
+}
+
+GLboolean
+glIsBuffer(GLuint buffer)
+{
+       return ovr_glIsBuffer(buffer);
+}
+
+GLboolean
+glIsEnabled(GLenum cap)
+{
+       return ovr_glIsEnabled(cap);
+}
+
+GLboolean
+glIsFramebuffer(GLuint framebuffer)
+{
+       return ovr_glIsFramebuffer(framebuffer);
+}
+
+GLboolean
+glIsProgram(GLuint program)
+{
+       return ovr_glIsProgram(program);
+}
+
+GLboolean
+glIsRenderbuffer(GLuint renderbuffer)
+{
+       return ovr_glIsRenderbuffer(renderbuffer);
+}
+
+GLboolean
+glIsShader(GLuint shader)
+{
+       return ovr_glIsShader(shader);
+}
+
+GLboolean
+glIsTexture(GLuint texture)
+{
+       return ovr_glIsTexture(texture);
+}
+
+void
+glLineWidth(GLfloat width)
+{
+       ovr_glLineWidth(width);
+}
+
+void
+glLinkProgram(GLuint program)
+{
+       ovr_glLinkProgram(program);
+}
+
+void
+glPixelStorei(GLenum pname, GLint param)
+{
+       ovr_glPixelStorei(pname, param);
+}
+
+void
+glPolygonOffset(GLfloat factor, GLfloat units)
+{
+       ovr_glPolygonOffset(factor, units);
+}
+
+void
+glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+{
+       ovr_glReadPixels(x, y, width, height, format, type, pixels);
+}
+
+void
+glReleaseShaderCompiler(void)
+{
+       ovr_glReleaseShaderCompiler();
+}
+
+void
+glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+{
+       ovr_glRenderbufferStorage(target, internalformat, width, height);
+}
+
+void
+glSampleCoverage(GLclampf value, GLboolean invert)
+{
+       ovr_glSampleCoverage(value, invert);
+}
+
+void
+glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+       ovr_glScissor(x, y, width, height);
+}
+
+void
+glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
+{
+       ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
+}
+
+void
+glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+{
+       ovr_glShaderSource(shader, count, string, length);
+}
+
+void
+glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+       ovr_glStencilFunc(func, ref, mask);
+}
+
+void
+glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+       ovr_glStencilFuncSeparate(face, func, ref, mask);
+}
+
+void
+glStencilMask(GLuint mask)
+{
+       ovr_glStencilMask(mask);
+}
+
+void
+glStencilMaskSeparate(GLenum face, GLuint mask)
+{
+       ovr_glStencilMaskSeparate(face, mask);
+}
+
+void
+glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+       ovr_glStencilOp(fail, zfail, zpass);
+}
+
+void
+glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+{
+       ovr_glStencilOpSeparate(face, fail, zfail, zpass);
+}
+
+void
+glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
+{
+       ovr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+}
+
+void
+glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+       ovr_glTexParameterf(target, pname, param);
+}
+
+void
+glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+{
+       ovr_glTexParameterfv(target, pname, params);
+}
+
+void
+glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+       ovr_glTexParameteri(target, pname, param);
+}
+
+void
+glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+{
+       ovr_glTexParameteriv(target, pname, params);
+}
+
+void
+glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
+{
+       ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+}
+
+void
+glUniform1f(GLint location, GLfloat x)
+{
+       ovr_glUniform1f(location, x);
+}
+
+void
+glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+{
+       ovr_glUniform1fv(location, count, v);
+}
+
+void
+glUniform1i(GLint location, GLint x)
+{
+       ovr_glUniform1i(location, x);
+}
+
+void
+glUniform1iv(GLint location, GLsizei count, const GLint* v)
+{
+       ovr_glUniform1iv(location, count, v);
+}
+
+void
+glUniform2f(GLint location, GLfloat x, GLfloat y)
+{
+       ovr_glUniform2f(location, x, y);
+}
+
+void
+glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
+{
+       ovr_glUniform2fv(location, count, v);
+}
+
+void
+glUniform2i(GLint location, GLint x, GLint y)
+{
+       ovr_glUniform2i(location, x, y);
+}
+
+void
+glUniform2iv(GLint location, GLsizei count, const GLint* v)
+{
+       ovr_glUniform2iv(location, count, v);
+}
+
+void
+glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+{
+       ovr_glUniform3f(location, x, y, z);
+}
+
+void
+glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
+{
+       ovr_glUniform3fv(location, count, v);
+}
+
+void
+glUniform3i(GLint location, GLint x, GLint y, GLint z)
+{
+       ovr_glUniform3i(location, x, y, z);
+}
+
+void
+glUniform3iv(GLint location, GLsizei count, const GLint* v)
+{
+       ovr_glUniform3iv(location, count, v);
+}
+
+void
+glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+       ovr_glUniform4f(location, x, y, z, w);
+}
+
+void
+glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
+{
+       ovr_glUniform4fv(location, count, v);
+}
+
+void
+glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+{
+       ovr_glUniform4i(location, x, y, z, w);
+}
+
+void
+glUniform4iv(GLint location, GLsizei count, const GLint* v)
+{
+       ovr_glUniform4iv(location, count, v);
+}
+
+void
+glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+       ovr_glUniformMatrix2fv(location, count, transpose, value);
+}
+
+void
+glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+       ovr_glUniformMatrix3fv(location, count, transpose, value);
+}
+
+void
+glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+{
+       ovr_glUniformMatrix4fv(location, count, transpose, value);
+}
+
+void
+glUseProgram(GLuint program)
+{
+       ovr_glUseProgram(program);
+}
+
+void
+glValidateProgram(GLuint program)
+{
+       ovr_glValidateProgram(program);
+}
+
+void
+glVertexAttrib1f(GLuint indx, GLfloat x)
+{
+       ovr_glVertexAttrib1f(indx, x);
+}
+
+void
+glVertexAttrib1fv(GLuint indx, const GLfloat* values)
+{
+       ovr_glVertexAttrib1fv(indx, values);
+}
+
+void
+glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+{
+       ovr_glVertexAttrib2f(indx, x, y);
+}
+
+void
+glVertexAttrib2fv(GLuint indx, const GLfloat* values)
+{
+       ovr_glVertexAttrib2fv(indx, values);
+}
+
+void
+glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+{
+       ovr_glVertexAttrib3f(indx, x, y, z);
+}
+
+void
+glVertexAttrib3fv(GLuint indx, const GLfloat* values)
+{
+       ovr_glVertexAttrib3fv(indx, values);
+}
+
+void
+glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+       ovr_glVertexAttrib4f(indx, x, y, z, w);
+}
+
+void
+glVertexAttrib4fv(GLuint indx, const GLfloat* values)
+{
+       ovr_glVertexAttrib4fv(indx, values);
+}
+
+void
+glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
+{
+       ovr_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+}
+
+void
+glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+       ovr_glViewport(x, y, width, height);
+}
+
+
+// GLES Extensions...
+void
+glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+{
+       ovr_glEGLImageTargetTexture2DOES(target, image);
+}
+
+void
+glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
+{
+       ovr_glEGLImageTargetRenderbufferStorageOES(target, image);
+}
+
+void
+glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
+{
+       ovr_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
+}
+
+void
+glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
+{
+       ovr_glProgramBinary(program, binaryFormat, binary, length);
+}
+
+
+void
+glProgramParameteri(GLuint program, GLuint pname, GLint value)
+{
+       ovr_glProgramParameteri(program, pname, value);
+}
+
+void
+glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+{
+       ovr_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
+}
+
+void
+glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+{
+       ovr_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
+}
+
+void
+glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
+{
+       ovr_glDiscardFramebufferEXT(target, numAttachments, attachments);
+}
+
+

diff --git a/src/coregl_export_glx.c b/src/coregl_export_glx.c
new file mode 100644 (file)
index 0000000..e69de29

diff --git a/src/coregl_fastpath.c b/src/coregl_fastpath.c
index 0dc6d27..33447e9 100644 (file)
--- a/src/coregl_fastpath.c
+++ b/src/coregl_fastpath.c
@@ -821,7 +821,7 @@ make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
 finish:
 
 #ifdef COREGL_TRACE_STATE_INFO
-       if (unlikely(trace_state_flag == 1)) return;
+       if (unlikely(trace_state_flag == 1))
                dump_context_states(newctx, 0);
 #endif // COREGL_TRACE_STATE_INFO
        return;

diff --git a/src/coregl_fastpath.h b/src/coregl_fastpath.h
index e0617fe..386e952 100644 (file)
--- a/src/coregl_fastpath.h
+++ b/src/coregl_fastpath.h
@@ -49,12 +49,12 @@ typedef struct
 
 typedef enum
 {
-       GL_OBJECT_TYPE_UNKNOWN       = 0x0,
-       GL_OBJECT_TYPE_TEXTURE       = 0x1000000,
-       GL_OBJECT_TYPE_BUFFER        = 0x2000000,
-       GL_OBJECT_TYPE_FRAMEBUFFER   = 0x3000000,
-       GL_OBJECT_TYPE_RENDERBUFFER  = 0x4000000,
-       GL_OBJECT_TYPE_PROGRAM       = 0x5000000,
+    GL_OBJECT_TYPE_UNKNOWN       = 0x0,
+    GL_OBJECT_TYPE_TEXTURE       = 0x1000000,
+    GL_OBJECT_TYPE_BUFFER        = 0x2000000,
+    GL_OBJECT_TYPE_FRAMEBUFFER   = 0x3000000,
+    GL_OBJECT_TYPE_RENDERBUFFER  = 0x4000000,
+    GL_OBJECT_TYPE_PROGRAM       = 0x5000000,
 } GL_Object_Type;
 
 typedef struct _GL_Object

diff --git a/src/coregl_fastpath_egl.c b/src/coregl_fastpath_egl.c
index ecc1e9a..3b07420 100644 (file)
--- a/src/coregl_fastpath_egl.c
+++ b/src/coregl_fastpath_egl.c
@@ -577,8 +577,10 @@ finish:
 //    The functions have prefix 'fpgl_' for (fastpath gl)         //
 //----------------------------------------------------------------//
 
-extern EGLBoolean (*_COREGL_NAME_MANGLE(eglBindAPI))(EGLenum api);
-extern EGLenum (*_COREGL_NAME_MANGLE(eglQueryAPI))(void);
+extern EGLBoolean (*wrp_eglBindAPI)(EGLenum api);
+extern EGLenum (*wrp_eglQueryAPI)(void);
+extern EGLBoolean (*ovr_eglBindAPI)(EGLenum api);
+extern EGLenum (*ovr_eglQueryAPI)(void);
 
 EGLBoolean
 fpgl_eglBindAPI(EGLenum api)
@@ -613,8 +615,16 @@ fpgl_eglBindAPI(EGLenum api)
                                // Fallback when binding other API
                                // Fastpath restores when bind OPENGL_ES_API
                                override_glue_normal_path();
-                               _COREGL_NAME_MANGLE(eglBindAPI) = fpgl_eglBindAPI;
-                               _COREGL_NAME_MANGLE(eglQueryAPI) = fpgl_eglQueryAPI;
+                               if (trace_api_flag == 1)
+                               {
+                                       wrp_eglBindAPI = fpgl_eglBindAPI;
+                                       wrp_eglQueryAPI = fpgl_eglQueryAPI;
+                               }
+                               else
+                               {
+                                       ovr_eglBindAPI = fpgl_eglBindAPI;
+                                       ovr_eglQueryAPI = fpgl_eglQueryAPI;
+                               }
                        }
                        else
                        {

diff --git a/src/coregl_internal.h b/src/coregl_internal.h
index e295554..2e93e5c 100644 (file)
--- a/src/coregl_internal.h
+++ b/src/coregl_internal.h
@@ -43,10 +43,7 @@
 typedef GLvoid *     GLvoidptr;
 typedef GLuint       GLuintmask;
 
-//#define COREGL_TRACE_ALL
-#define COREGL_TRACE_CONTEXT_INFO
-#define COREGL_TRACE_STATE_INFO
-//#define COREGL_TRACE_APICALL_INFO
+#define COREGL_TRACE_ALL
 
 #ifdef COREGL_TRACE_ALL
 #define COREGL_TRACE_CONTEXT_INFO   // Context state & thread state & Glue-context info
@@ -64,8 +61,6 @@ typedef GLuint       GLuintmask;
 # define GLERR(fn, fl, ln, op)
 #endif
 
-#define _COREGL_NAME_MANGLE(name) ovr_##name
-
 typedef struct _Trace_Data Trace_Data;
 
 #ifdef COREGL_TRACE_APICALL_INFO
@@ -91,13 +86,12 @@ typedef struct _Trace_Data Trace_Data;
 #define _COREGL_FAST_FUNC_SYMCALL_END()
 
 #define _COREGL_WRAP_FUNC_BEGIN() \
-       static void *trace_hint = NULL; \
        if (unlikely(trace_api_flag == 1)) \
-               trace_hint = _COREGL_TRACE_API_BEGIN(__func__, trace_hint, 1);
+               _COREGL_TRACE_API_BEGIN(__func__, NULL, 1);
 
 #define _COREGL_WRAP_FUNC_END() \
        if (unlikely(trace_api_flag == 1)) \
-               _COREGL_TRACE_API_END(__func__, trace_hint, 1);
+               _COREGL_TRACE_API_END(__func__, NULL, 1);
 
 typedef enum _CoreGL_Opt_Flag
 {
@@ -169,6 +163,8 @@ extern int                 trace_state_flag;
 extern int                 debug_nofp;
 extern FILE               *trace_fp;
 
+#define NEED_WRAPPING          (trace_api_flag == 1 || trace_ctx_flag == 1 || trace_state_flag == 1)
+
 // Environment functions
 extern const char         *get_env_setting(const char *name);
 

diff --git a/src/coregl_override.c b/src/coregl_override.c
index 0afdbce..9a3e509 100644 (file)
--- a/src/coregl_override.c
+++ b/src/coregl_override.c
@@ -1,17 +1,21 @@
 #include "coregl_internal.h"
+#include "coregl_export.h"
 #include "coregl_wrappath.h"
 #include "coregl_fastpath.h"
 
 #include <stdlib.h>
 
-#define COREGL_OVERRIDE_API(func, prefix) \
-   _COREGL_NAME_MANGLE(func) = prefix##func
+#define COREGL_OVERRIDE_API(mangle, func, prefix) \
+   mangle##func = prefix##func
 
 void
 override_glue_normal_path()
 {
-#define N_ORD(f) COREGL_OVERRIDE_API(f, _sym_) // GL Normal Path
+#define C_ORD(f) COREGL_OVERRIDE_API(ovr_, f, _sym_)
+#define N_ORD(f) COREGL_OVERRIDE_API(ovr_, f, wpgl_); COREGL_OVERRIDE_API(wrp_, f, _sym_)
 
+       if (NEED_WRAPPING)
+       {
 #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     N_ORD(FUNC_NAME);
 # ifndef _COREGL_DESKTOP_GL
 #  include "headers/sym_egl.h"
@@ -19,8 +23,20 @@ override_glue_normal_path()
 #  include "headers/sym_glx.h"
 # endif
 #undef _COREGL_SYMBOL
+       }
+       else
+       {
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     C_ORD(FUNC_NAME);
+# ifndef _COREGL_DESKTOP_GL
+#  include "headers/sym_egl.h"
+# else
+#  include "headers/sym_glx.h"
+# endif
+#undef _COREGL_SYMBOL
+       }
 
 #undef N_ORD
+#undef C_ORD
 }
 
 void
@@ -29,7 +45,11 @@ override_glue_fast_path()
        // Inherit from normal path
        override_glue_normal_path();
 
-#define F_ORD(f) COREGL_OVERRIDE_API(f, fpgl_) // GL Fast Path
+#define F_ORD(f) \
+       if (NEED_WRAPPING) \
+               COREGL_OVERRIDE_API(wrp_, f, fpgl_); \
+       else \
+               COREGL_OVERRIDE_API(ovr_, f, fpgl_);
 
 
 #ifndef _COREGL_DESKTOP_GL
@@ -65,13 +85,24 @@ override_glue_fast_path()
 void
 override_gl_normal_path()
 {
-#define N_ORD(f) COREGL_OVERRIDE_API(f, _sym_) // GL Normal Path
+#define C_ORD(f) COREGL_OVERRIDE_API(ovr_, f, _sym_)
+#define N_ORD(f) COREGL_OVERRIDE_API(ovr_, f, wpgl_); COREGL_OVERRIDE_API(wrp_, f, _sym_)
 
+       if (NEED_WRAPPING)
+       {
 #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     N_ORD(FUNC_NAME);
 # include "headers/sym_gl.h"
 #undef _COREGL_SYMBOL
+       }
+       else
+       {
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     C_ORD(FUNC_NAME);
+# include "headers/sym_gl.h"
+#undef _COREGL_SYMBOL
+       }
 
 #undef N_ORD
+#undef C_ORD
 }
 
 void
@@ -80,7 +111,11 @@ override_gl_fast_path()
        // Inherit from normal path
        override_gl_normal_path();
 
-#define F_ORD(f) COREGL_OVERRIDE_API(f, fpgl_) // GL Wrapped Path
+#define F_ORD(f) \
+       if (NEED_WRAPPING) \
+               COREGL_OVERRIDE_API(wrp_, f, fpgl_); \
+       else \
+               COREGL_OVERRIDE_API(ovr_, f, fpgl_);
 
        // Fast-Path Functions
        if (debug_nofp != 1)

diff --git a/src/coregl_trace.c b/src/coregl_trace.c
index 0dbdabb..7628b92 100644 (file)
--- a/src/coregl_trace.c
+++ b/src/coregl_trace.c
@@ -408,11 +408,15 @@ trace_output(int force_output)
                                {
                                        double elapsed_time_period = _get_timeval_period(current->elapsed_time, current->last_elapsed_time);
                                        double elapsed_time_per_call_period = elapsed_time_period / (current->call_count - current->last_call_count);
+                                       char *fname = current->name;
+
+                                       if (!strncmp(fname, "wpgl_", 5))
+                                               fname = &current->name[5];
 
                                        if (elapsed_time_per_call_period >= 0.01 || current->call_count - current->last_call_count > 1000)
                                        {
                                                TRACE("\E[40;37;1m %-42.42s : %10d call(s), %10.2f ms, %9.3f ms/API, %9.3f ms/API(P) \E[0m\n",
-                                                     current->name, current->call_count, elapsed_time, elapsed_time_per_call, elapsed_time_per_call_period);
+                                                     fname, current->call_count, elapsed_time, elapsed_time_per_call, elapsed_time_per_call_period);
                                                current->traced = 1;
                                        }
                                }
@@ -439,9 +443,13 @@ trace_output(int force_output)
                                                {
                                                        double elapsed_time = _get_timeval(current->elapsed_time);
                                                        double elapsed_time_per_call = elapsed_time / current->call_count;
+                                                       char *fname = current->name;
+
+                                                       if (!strncmp(fname, "wpgl_", 5))
+                                                               fname = &current->name[5];
 
                                                        TRACE(" %-42.42s : %10d call(s), %10.2f ms, %9.3f ms/API\n",
-                                                             current->name, current->call_count, elapsed_time, elapsed_time_per_call);
+                                                             fname, current->call_count, elapsed_time, elapsed_time_per_call);
                                                }
                                                current = current->next;
                                        }

diff --git a/src/coregl_wrappath.c b/src/coregl_wrappath.c
index 1900578..1107aa5 100644 (file)
--- a/src/coregl_wrappath.c
+++ b/src/coregl_wrappath.c
@@ -4,11 +4,6 @@
 #include <string.h>
 #include <sys/time.h>
 
-// Symbol definition for override
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST = NULL;
-#include "headers/sym.h"
-#undef _COREGL_SYMBOL
-
 typedef struct _GLGlueFakeContext
 {
        GLuint gl_num_tex_units[1];

diff --git a/src/coregl_wrappath.h b/src/coregl_wrappath.h
index 3aa8b69..8761216 100644 (file)
--- a/src/coregl_wrappath.h
+++ b/src/coregl_wrappath.h
@@ -1,13 +1,18 @@
+#ifndef COREGL_WRAPPATH_H\r
+#define COREGL_WRAPPATH_H\r
 \r
 #include "coregl_internal.h"\r
+#include "coregl_export.h"\r
 \r
-// Symbol definition for override\r
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;\r
-# include "headers/sym.h"
-#undef _COREGL_SYMBOL
+// Symbol definition for wrappath\r
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST)     extern RET_TYPE (wpgl_##FUNC_NAME) PARAM_LIST;\r
+# include "headers/sym.h"\r
+#undef _COREGL_SYMBOL\r
 \r
 extern void init_wrap_gl();\r
 extern void free_wrap_gl();\r
 \r
 extern void dump_wrap_context_states(int force_output);\r
 \r
+#endif // COREGL_WRAPPATH_H\r
+\r

diff --git a/src/coregl_wrappath_egl.c b/src/coregl_wrappath_egl.c
index 9d82a77..92f9e85 100644 (file)
--- a/src/coregl_wrappath_egl.c
+++ b/src/coregl_wrappath_egl.c
@@ -1,12 +1,12 @@
 #include "coregl_wrappath.h"
 
 EGLint
-eglGetError(void)
+wpgl_eglGetError(void)
 {
        EGLint ret = _COREGL_INT_INIT_VALUE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetError();
+       ret = wrp_eglGetError();
        goto finish;
 
 finish:
@@ -15,12 +15,12 @@ finish:
 }
 
 EGLDisplay
-eglGetDisplay(EGLNativeDisplayType display_id)
+wpgl_eglGetDisplay(EGLNativeDisplayType display_id)
 {
        EGLDisplay ret = EGL_NO_DISPLAY;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetDisplay(display_id);
+       ret = wrp_eglGetDisplay(display_id);
        goto finish;
 
 finish:
@@ -29,11 +29,11 @@ finish:
 }
 
 EGLBoolean
-eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
+wpgl_eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
 {
        EGLBoolean ret = EGL_FALSE;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglInitialize(dpy, major, minor);
+       ret = wrp_eglInitialize(dpy, major, minor);
        goto finish;
 
 finish:
@@ -42,12 +42,12 @@ finish:
 }
 
 EGLBoolean
-eglTerminate(EGLDisplay dpy)
+wpgl_eglTerminate(EGLDisplay dpy)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglTerminate(dpy);
+       ret = wrp_eglTerminate(dpy);
        goto finish;
 
 finish:
@@ -56,12 +56,12 @@ finish:
 }
 
 EGLBoolean
-eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
+wpgl_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetConfigs(dpy, configs, config_size, num_config);
+       ret = wrp_eglGetConfigs(dpy, configs, config_size, num_config);
        goto finish;
 
 finish:
@@ -70,12 +70,12 @@ finish:
 }
 
 EGLBoolean
-eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
+wpgl_eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+       ret = wrp_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
        goto finish;
 
 finish:
@@ -84,12 +84,12 @@ finish:
 }
 
 EGLBoolean
-eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
+wpgl_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetConfigAttrib(dpy, config, attribute, value);
+       ret = wrp_eglGetConfigAttrib(dpy, config, attribute, value);
        goto finish;
 
 finish:
@@ -99,12 +99,12 @@ finish:
 
 
 EGLSurface
-eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
+wpgl_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
 {
        EGLSurface ret = EGL_NO_SURFACE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreateWindowSurface(dpy, config, win, attrib_list);
+       ret = wrp_eglCreateWindowSurface(dpy, config, win, attrib_list);
        goto finish;
 
 finish:
@@ -113,12 +113,12 @@ finish:
 }
 
 EGLSurface
-eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
+wpgl_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
 {
        EGLSurface ret = EGL_NO_SURFACE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreatePbufferSurface(dpy, config, attrib_list);
+       ret = wrp_eglCreatePbufferSurface(dpy, config, attrib_list);
        goto finish;
 
 finish:
@@ -127,12 +127,12 @@ finish:
 }
 
 EGLSurface
-eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
+wpgl_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
 {
        EGLSurface ret = EGL_NO_SURFACE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+       ret = wrp_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
        goto finish;
 
 finish:
@@ -141,12 +141,12 @@ finish:
 }
 
 EGLBoolean
-eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
+wpgl_eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglDestroySurface(dpy, surface);
+       ret = wrp_eglDestroySurface(dpy, surface);
        goto finish;
 
 finish:
@@ -155,12 +155,12 @@ finish:
 }
 
 EGLBoolean
-eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
+wpgl_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglQuerySurface(dpy, surface, attribute, value);
+       ret = wrp_eglQuerySurface(dpy, surface, attribute, value);
        goto finish;
 
 finish:
@@ -169,12 +169,12 @@ finish:
 }
 
 EGLBoolean
-eglBindAPI(EGLenum api)
+wpgl_eglBindAPI(EGLenum api)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglBindAPI(api);
+       ret = wrp_eglBindAPI(api);
        goto finish;
 
 finish:
@@ -183,12 +183,12 @@ finish:
 }
 
 EGLenum
-eglQueryAPI(void)
+wpgl_eglQueryAPI(void)
 {
        EGLenum ret = 0;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglQueryAPI();
+       ret = wrp_eglQueryAPI();
        goto finish;
 
 finish:
@@ -197,12 +197,12 @@ finish:
 }
 
 EGLBoolean
-eglWaitClient(void)
+wpgl_eglWaitClient(void)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglWaitClient();
+       ret = wrp_eglWaitClient();
        goto finish;
 
 finish:
@@ -211,12 +211,12 @@ finish:
 }
 
 EGLBoolean
-eglReleaseThread(void)
+wpgl_eglReleaseThread(void)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglReleaseThread();
+       ret = wrp_eglReleaseThread();
        goto finish;
 
 finish:
@@ -225,12 +225,12 @@ finish:
 }
 
 EGLSurface
-eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
+wpgl_eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
 {
        EGLSurface ret = EGL_NO_SURFACE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
+       ret = wrp_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
        goto finish;
 
 finish:
@@ -239,12 +239,12 @@ finish:
 }
 
 EGLBoolean
-eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
+wpgl_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglSurfaceAttrib(dpy, surface, attribute, value);
+       ret = wrp_eglSurfaceAttrib(dpy, surface, attribute, value);
        goto finish;
 
 finish:
@@ -253,12 +253,12 @@ finish:
 }
 
 EGLBoolean
-eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+wpgl_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglBindTexImage(dpy, surface, buffer);
+       ret = wrp_eglBindTexImage(dpy, surface, buffer);
        goto finish;
 
 finish:
@@ -267,12 +267,12 @@ finish:
 }
 
 EGLBoolean
-eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+wpgl_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglReleaseTexImage(dpy, surface, buffer);
+       ret = wrp_eglReleaseTexImage(dpy, surface, buffer);
        goto finish;
 
 finish:
@@ -281,12 +281,12 @@ finish:
 }
 
 EGLBoolean
-eglSwapInterval(EGLDisplay dpy, EGLint interval)
+wpgl_eglSwapInterval(EGLDisplay dpy, EGLint interval)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglSwapInterval(dpy, interval);
+       ret = wrp_eglSwapInterval(dpy, interval);
        goto finish;
 
 finish:
@@ -295,12 +295,12 @@ finish:
 }
 
 EGLContext
-eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
+wpgl_eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
 {
        EGLContext ret = EGL_NO_CONTEXT;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreateContext(dpy, config, share_context, attrib_list);
+       ret = wrp_eglCreateContext(dpy, config, share_context, attrib_list);
        goto finish;
 
 finish:
@@ -309,12 +309,12 @@ finish:
 }
 
 EGLBoolean
-eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
+wpgl_eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglDestroyContext(dpy, ctx);
+       ret = wrp_eglDestroyContext(dpy, ctx);
        goto finish;
 
 finish:
@@ -323,12 +323,12 @@ finish:
 }
 
 EGLBoolean
-eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+wpgl_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglMakeCurrent(dpy, draw, read, ctx);
+       ret = wrp_eglMakeCurrent(dpy, draw, read, ctx);
        goto finish;
 
 finish:
@@ -336,7 +336,7 @@ finish:
 #ifdef COREGL_TRACE_STATE_INFO
        if (unlikely(trace_state_flag == 1))
        {
-               if (ovr_eglMakeCurrent == _sym_eglMakeCurrent)
+               if (wrp_eglMakeCurrent == _sym_eglMakeCurrent)
                        dump_wrap_context_states(0);
        }
 #endif // COREGL_TRACE_STATE_INFO
@@ -344,12 +344,12 @@ finish:
 }
 
 EGLContext
-eglGetCurrentContext(void)
+wpgl_eglGetCurrentContext(void)
 {
        EGLContext ret = EGL_NO_CONTEXT;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetCurrentContext();
+       ret = wrp_eglGetCurrentContext();
        goto finish;
 
 finish:
@@ -358,12 +358,12 @@ finish:
 }
 
 EGLSurface
-eglGetCurrentSurface(EGLint readdraw)
+wpgl_eglGetCurrentSurface(EGLint readdraw)
 {
        EGLSurface ret = EGL_NO_SURFACE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetCurrentSurface(readdraw);
+       ret = wrp_eglGetCurrentSurface(readdraw);
        goto finish;
 
 finish:
@@ -372,12 +372,12 @@ finish:
 }
 
 EGLDisplay
-eglGetCurrentDisplay(void)
+wpgl_eglGetCurrentDisplay(void)
 {
        EGLDisplay ret = EGL_NO_DISPLAY;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetCurrentDisplay();
+       ret = wrp_eglGetCurrentDisplay();
        goto finish;
 
 finish:
@@ -386,12 +386,12 @@ finish:
 }
 
 EGLBoolean
-eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
+wpgl_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglQueryContext(dpy, ctx, attribute, value);
+       ret = wrp_eglQueryContext(dpy, ctx, attribute, value);
        goto finish;
 
 finish:
@@ -400,12 +400,12 @@ finish:
 }
 
 EGLBoolean
-eglWaitGL(void)
+wpgl_eglWaitGL(void)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglWaitGL();
+       ret = wrp_eglWaitGL();
        goto finish;
 
 finish:
@@ -414,12 +414,12 @@ finish:
 }
 
 EGLBoolean
-eglWaitNative(EGLint engine)
+wpgl_eglWaitNative(EGLint engine)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglWaitNative(engine);
+       ret = wrp_eglWaitNative(engine);
        goto finish;
 
 finish:
@@ -428,12 +428,12 @@ finish:
 }
 
 EGLBoolean
-eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
+wpgl_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglSwapBuffers(dpy, surface);
+       ret = wrp_eglSwapBuffers(dpy, surface);
 
        goto finish;
 
@@ -444,12 +444,12 @@ finish:
 }
 
 EGLBoolean
-eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
+wpgl_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCopyBuffers(dpy, surface, target);
+       ret = wrp_eglCopyBuffers(dpy, surface, target);
        goto finish;
 
 finish:
@@ -458,12 +458,12 @@ finish:
 }
 
 _eng_fn
-eglGetProcAddress(const char* procname)
+wpgl_eglGetProcAddress(const char* procname)
 {
        _eng_fn ret = NULL;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetProcAddress(procname);
+       ret = wrp_eglGetProcAddress(procname);
        goto finish;
 
 finish:
@@ -472,12 +472,12 @@ finish:
 }
 
 const char *
-eglQueryString(EGLDisplay dpy, EGLint name)
+wpgl_eglQueryString(EGLDisplay dpy, EGLint name)
 {
        const char *ret = NULL;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglQueryString(dpy, name);
+       ret = wrp_eglQueryString(dpy, name);
        goto finish;
 
 finish:
@@ -486,12 +486,12 @@ finish:
 }
 
 EGLImageKHR
-eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
+wpgl_eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
 {
        void *ret = NULL;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
+       ret = wrp_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
        goto finish;
 
 finish:
@@ -500,12 +500,12 @@ finish:
 }
 
 EGLBoolean
-eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
+wpgl_eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglDestroyImageKHR(dpy, image);
+       ret = wrp_eglDestroyImageKHR(dpy, image);
        goto finish;
 
 finish:
@@ -514,12 +514,12 @@ finish:
 }
 
 void *
-eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image)
+wpgl_eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image)
 {
        void *ret = NULL;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglMapImageSEC(dpy, image);
+       ret = wrp_eglMapImageSEC(dpy, image);
        goto finish;
 
 finish:
@@ -528,12 +528,12 @@ finish:
 }
 
 EGLBoolean
-eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image)
+wpgl_eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglUnmapImageSEC(dpy, image);
+       ret = wrp_eglUnmapImageSEC(dpy, image);
        goto finish;
 
 finish:
@@ -542,12 +542,12 @@ finish:
 }
 
 EGLBoolean
-eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value)
+wpgl_eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglGetImageAttribSEC(dpy, image, attribute, value);
+       ret = wrp_eglGetImageAttribSEC(dpy, image, attribute, value);
        goto finish;
 
 finish:
@@ -556,12 +556,12 @@ finish:
 }
 
 EGLBoolean
-eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
+wpgl_eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglLockSurfaceKHR(display, surface, attrib_list);
+       ret = wrp_eglLockSurfaceKHR(display, surface, attrib_list);
        goto finish;
 
 finish:
@@ -570,12 +570,12 @@ finish:
 }
 
 EGLBoolean
-eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
+wpgl_eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
 {
        EGLBoolean ret = EGL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_eglUnlockSurfaceKHR(display, surface);
+       ret = wrp_eglUnlockSurfaceKHR(display, surface);
        goto finish;
 
 finish:

diff --git a/src/coregl_wrappath_gl.c b/src/coregl_wrappath_gl.c
index 3ca57c9..94b700e 100644 (file)
--- a/src/coregl_wrappath_gl.c
+++ b/src/coregl_wrappath_gl.c
@@ -1,10 +1,10 @@
 #include "coregl_wrappath.h"
 
 void
-glActiveTexture(GLenum texture)
+wpgl_glActiveTexture(GLenum texture)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glActiveTexture(texture);
+       wrp_glActiveTexture(texture);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -13,10 +13,10 @@ finish:
 }
 
 void
-glAttachShader(GLuint program, GLuint shader)
+wpgl_glAttachShader(GLuint program, GLuint shader)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glAttachShader(program, shader);
+       wrp_glAttachShader(program, shader);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -25,10 +25,10 @@ finish:
 }
 
 void
-glBindAttribLocation(GLuint program, GLuint index, const char* name)
+wpgl_glBindAttribLocation(GLuint program, GLuint index, const char* name)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBindAttribLocation(program, index, name);
+       wrp_glBindAttribLocation(program, index, name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -37,10 +37,10 @@ finish:
 }
 
 void
-glBindBuffer(GLenum target, GLuint buffer)
+wpgl_glBindBuffer(GLenum target, GLuint buffer)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBindBuffer(target, buffer);
+       wrp_glBindBuffer(target, buffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -49,10 +49,10 @@ finish:
 }
 
 void
-glBindFramebuffer(GLenum target, GLuint framebuffer)
+wpgl_glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBindFramebuffer(target, framebuffer);
+       wrp_glBindFramebuffer(target, framebuffer);
 
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
@@ -62,10 +62,10 @@ finish:
 }
 
 void
-glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+wpgl_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBindRenderbuffer(target, renderbuffer);
+       wrp_glBindRenderbuffer(target, renderbuffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -74,10 +74,10 @@ finish:
 }
 
 void
-glBindTexture(GLenum target, GLuint texture)
+wpgl_glBindTexture(GLenum target, GLuint texture)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBindTexture(target, texture);
+       wrp_glBindTexture(target, texture);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -86,10 +86,10 @@ finish:
 }
 
 void
-glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+wpgl_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBlendColor(red, green, blue, alpha);
+       wrp_glBlendColor(red, green, blue, alpha);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -98,10 +98,10 @@ finish:
 }
 
 void
-glBlendEquation(GLenum mode)
+wpgl_glBlendEquation(GLenum mode)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBlendEquation(mode);
+       wrp_glBlendEquation(mode);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -110,10 +110,10 @@ finish:
 }
 
 void
-glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+wpgl_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
+       wrp_glBlendEquationSeparate(modeRGB, modeAlpha);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -122,10 +122,10 @@ finish:
 }
 
 void
-glBlendFunc(GLenum sfactor, GLenum dfactor)
+wpgl_glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBlendFunc(sfactor, dfactor);
+       wrp_glBlendFunc(sfactor, dfactor);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -134,10 +134,10 @@ finish:
 }
 
 void
-glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+wpgl_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+       wrp_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -146,10 +146,10 @@ finish:
 }
 
 void
-glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
+wpgl_glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBufferData(target, size, data, usage);
+       wrp_glBufferData(target, size, data, usage);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -158,10 +158,10 @@ finish:
 }
 
 void
-glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
+wpgl_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glBufferSubData(target, offset, size, data);
+       wrp_glBufferSubData(target, offset, size, data);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -170,12 +170,12 @@ finish:
 }
 
 GLenum
-glCheckFramebufferStatus(GLenum target)
+wpgl_glCheckFramebufferStatus(GLenum target)
 {
        GLenum ret = GL_NONE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glCheckFramebufferStatus(target);
+       ret = wrp_glCheckFramebufferStatus(target);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -185,10 +185,10 @@ finish:
 }
 
 void
-glClear(GLbitfield mask)
+wpgl_glClear(GLbitfield mask)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glClear(mask);
+       wrp_glClear(mask);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -197,10 +197,10 @@ finish:
 }
 
 void
-glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+wpgl_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glClearColor(red, green, blue, alpha);
+       wrp_glClearColor(red, green, blue, alpha);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -209,10 +209,10 @@ finish:
 }
 
 void
-glClearDepthf(GLclampf depth)
+wpgl_glClearDepthf(GLclampf depth)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glClearDepthf(depth);
+       wrp_glClearDepthf(depth);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -221,10 +221,10 @@ finish:
 }
 
 void
-glClearStencil(GLint s)
+wpgl_glClearStencil(GLint s)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glClearStencil(s);
+       wrp_glClearStencil(s);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -233,10 +233,10 @@ finish:
 }
 
 void
-glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+wpgl_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glColorMask(red, green, blue, alpha);
+       wrp_glColorMask(red, green, blue, alpha);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -245,10 +245,10 @@ finish:
 }
 
 void
-glCompileShader(GLuint shader)
+wpgl_glCompileShader(GLuint shader)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCompileShader(shader);
+       wrp_glCompileShader(shader);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -257,10 +257,10 @@ finish:
 }
 
 void
-glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
+wpgl_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+       wrp_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -269,10 +269,10 @@ finish:
 }
 
 void
-glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+wpgl_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+       wrp_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -281,10 +281,10 @@ finish:
 }
 
 void
-glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+wpgl_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+       wrp_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -293,10 +293,10 @@ finish:
 }
 
 void
-glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+wpgl_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+       wrp_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -305,12 +305,12 @@ finish:
 }
 
 GLuint
-glCreateProgram(void)
+wpgl_glCreateProgram(void)
 {
        GLuint ret = _COREGL_INT_INIT_VALUE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glCreateProgram();
+       ret = wrp_glCreateProgram();
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -320,11 +320,11 @@ finish:
 }
 
 GLuint
-glCreateShader(GLenum type)
+wpgl_glCreateShader(GLenum type)
 {
        GLuint ret = _COREGL_INT_INIT_VALUE;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glCreateShader(type);
+       ret = wrp_glCreateShader(type);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -334,10 +334,10 @@ finish:
 }
 
 void
-glCullFace(GLenum mode)
+wpgl_glCullFace(GLenum mode)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glCullFace(mode);
+       wrp_glCullFace(mode);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -346,10 +346,10 @@ finish:
 }
 
 void
-glDeleteBuffers(GLsizei n, const GLuint* buffers)
+wpgl_glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteBuffers(n, buffers);
+       wrp_glDeleteBuffers(n, buffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -358,10 +358,10 @@ finish:
 }
 
 void
-glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+wpgl_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteFramebuffers(n, framebuffers);
+       wrp_glDeleteFramebuffers(n, framebuffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -370,10 +370,10 @@ finish:
 }
 
 void
-glDeleteProgram(GLuint program)
+wpgl_glDeleteProgram(GLuint program)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteProgram(program);
+       wrp_glDeleteProgram(program);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -382,10 +382,10 @@ finish:
 }
 
 void
-glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+wpgl_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteRenderbuffers(n, renderbuffers);
+       wrp_glDeleteRenderbuffers(n, renderbuffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -394,10 +394,10 @@ finish:
 }
 
 void
-glDeleteShader(GLuint shader)
+wpgl_glDeleteShader(GLuint shader)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteShader(shader);
+       wrp_glDeleteShader(shader);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -406,10 +406,10 @@ finish:
 }
 
 void
-glDeleteTextures(GLsizei n, const GLuint* textures)
+wpgl_glDeleteTextures(GLsizei n, const GLuint* textures)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDeleteTextures(n, textures);
+       wrp_glDeleteTextures(n, textures);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -418,10 +418,10 @@ finish:
 }
 
 void
-glDepthFunc(GLenum func)
+wpgl_glDepthFunc(GLenum func)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDepthFunc(func);
+       wrp_glDepthFunc(func);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -430,10 +430,10 @@ finish:
 }
 
 void
-glDepthMask(GLboolean flag)
+wpgl_glDepthMask(GLboolean flag)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDepthMask(flag);
+       wrp_glDepthMask(flag);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -442,10 +442,10 @@ finish:
 }
 
 void
-glDepthRangef(GLclampf zNear, GLclampf zFar)
+wpgl_glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDepthRangef(zNear, zFar);
+       wrp_glDepthRangef(zNear, zFar);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -454,10 +454,10 @@ finish:
 }
 
 void
-glDetachShader(GLuint program, GLuint shader)
+wpgl_glDetachShader(GLuint program, GLuint shader)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDetachShader(program, shader);
+       wrp_glDetachShader(program, shader);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -466,10 +466,10 @@ finish:
 }
 
 void
-glDisable(GLenum cap)
+wpgl_glDisable(GLenum cap)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDisable(cap);
+       wrp_glDisable(cap);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -478,10 +478,10 @@ finish:
 }
 
 void
-glDisableVertexAttribArray(GLuint index)
+wpgl_glDisableVertexAttribArray(GLuint index)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDisableVertexAttribArray(index);
+       wrp_glDisableVertexAttribArray(index);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -490,10 +490,10 @@ finish:
 }
 
 void
-glDrawArrays(GLenum mode, GLint first, GLsizei count)
+wpgl_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDrawArrays(mode, first, count);
+       wrp_glDrawArrays(mode, first, count);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -502,10 +502,10 @@ finish:
 }
 
 void
-glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
+wpgl_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDrawElements(mode, count, type, indices);
+       wrp_glDrawElements(mode, count, type, indices);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -514,10 +514,10 @@ finish:
 }
 
 void
-glEnable(GLenum cap)
+wpgl_glEnable(GLenum cap)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glEnable(cap);
+       wrp_glEnable(cap);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -526,10 +526,10 @@ finish:
 }
 
 void
-glEnableVertexAttribArray(GLuint index)
+wpgl_glEnableVertexAttribArray(GLuint index)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glEnableVertexAttribArray(index);
+       wrp_glEnableVertexAttribArray(index);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -538,10 +538,10 @@ finish:
 }
 
 void
-glFinish(void)
+wpgl_glFinish(void)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFinish();
+       wrp_glFinish();
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -551,10 +551,10 @@ finish:
 }
 
 void
-glFlush(void)
+wpgl_glFlush(void)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFlush();
+       wrp_glFlush();
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -564,10 +564,10 @@ finish:
 }
 
 void
-glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+wpgl_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+       wrp_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -576,10 +576,10 @@ finish:
 }
 
 void
-glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+wpgl_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
+       wrp_glFramebufferTexture2D(target, attachment, textarget, texture, level);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -588,10 +588,10 @@ finish:
 }
 
 void
-glFrontFace(GLenum mode)
+wpgl_glFrontFace(GLenum mode)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFrontFace(mode);
+       wrp_glFrontFace(mode);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -600,10 +600,10 @@ finish:
 }
 
 void
-glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+wpgl_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetVertexAttribfv(index, pname, params);
+       wrp_glGetVertexAttribfv(index, pname, params);
 
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
@@ -613,10 +613,10 @@ finish:
 }
 
 void
-glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+wpgl_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetVertexAttribiv(index, pname, params);
+       wrp_glGetVertexAttribiv(index, pname, params);
 
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
@@ -626,10 +626,10 @@ finish:
 }
 
 void
-glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
+wpgl_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetVertexAttribPointerv(index, pname, pointer);
+       wrp_glGetVertexAttribPointerv(index, pname, pointer);
 
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 
@@ -640,10 +640,10 @@ finish:
 }
 
 void
-glHint(GLenum target, GLenum mode)
+wpgl_glHint(GLenum target, GLenum mode)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glHint(target, mode);
+       wrp_glHint(target, mode);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -652,10 +652,10 @@ finish:
 }
 
 void
-glGenBuffers(GLsizei n, GLuint* buffers)
+wpgl_glGenBuffers(GLsizei n, GLuint* buffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGenBuffers(n, buffers);
+       wrp_glGenBuffers(n, buffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -664,10 +664,10 @@ finish:
 }
 
 void
-glGenerateMipmap(GLenum target)
+wpgl_glGenerateMipmap(GLenum target)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGenerateMipmap(target);
+       wrp_glGenerateMipmap(target);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -676,10 +676,10 @@ finish:
 }
 
 void
-glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+wpgl_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGenFramebuffers(n, framebuffers);
+       wrp_glGenFramebuffers(n, framebuffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -688,10 +688,10 @@ finish:
 }
 
 void
-glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+wpgl_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGenRenderbuffers(n, renderbuffers);
+       wrp_glGenRenderbuffers(n, renderbuffers);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -700,10 +700,10 @@ finish:
 }
 
 void
-glGenTextures(GLsizei n, GLuint* textures)
+wpgl_glGenTextures(GLsizei n, GLuint* textures)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGenTextures(n, textures);
+       wrp_glGenTextures(n, textures);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -712,10 +712,10 @@ finish:
 }
 
 void
-glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+wpgl_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
+       wrp_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -724,10 +724,10 @@ finish:
 }
 
 void
-glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+wpgl_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
+       wrp_glGetActiveUniform(program, index, bufsize, length, size, type, name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -736,10 +736,10 @@ finish:
 }
 
 void
-glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+wpgl_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetAttachedShaders(program, maxcount, count, shaders);
+       wrp_glGetAttachedShaders(program, maxcount, count, shaders);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -748,11 +748,11 @@ finish:
 }
 
 int
-glGetAttribLocation(GLuint program, const char* name)
+wpgl_glGetAttribLocation(GLuint program, const char* name)
 {
        int ret = _COREGL_INT_INIT_VALUE;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glGetAttribLocation(program, name);
+       ret = wrp_glGetAttribLocation(program, name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -762,10 +762,10 @@ finish:
 }
 
 void
-glGetBooleanv(GLenum pname, GLboolean* params)
+wpgl_glGetBooleanv(GLenum pname, GLboolean* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetBooleanv(pname, params);
+       wrp_glGetBooleanv(pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -774,10 +774,10 @@ finish:
 }
 
 void
-glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+wpgl_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetBufferParameteriv(target, pname, params);
+       wrp_glGetBufferParameteriv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -786,12 +786,12 @@ finish:
 }
 
 GLenum
-glGetError(void)
+wpgl_glGetError(void)
 {
        GLenum ret = GL_NONE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glGetError();
+       ret = wrp_glGetError();
        goto finish;
 
 finish:
@@ -800,10 +800,10 @@ finish:
 }
 
 void
-glGetFloatv(GLenum pname, GLfloat* params)
+wpgl_glGetFloatv(GLenum pname, GLfloat* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetFloatv(pname, params);
+       wrp_glGetFloatv(pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -812,10 +812,10 @@ finish:
 }
 
 void
-glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+wpgl_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+       wrp_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -824,10 +824,10 @@ finish:
 }
 
 void
-glGetIntegerv(GLenum pname, GLint* params)
+wpgl_glGetIntegerv(GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetIntegerv(pname, params);
+       wrp_glGetIntegerv(pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -836,10 +836,10 @@ finish:
 }
 
 void
-glGetProgramiv(GLuint program, GLenum pname, GLint* params)
+wpgl_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetProgramiv(program, pname, params);
+       wrp_glGetProgramiv(program, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -848,10 +848,10 @@ finish:
 }
 
 void
-glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
+wpgl_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
+       wrp_glGetProgramInfoLog(program, bufsize, length, infolog);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -860,10 +860,10 @@ finish:
 }
 
 void
-glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+wpgl_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetRenderbufferParameteriv(target, pname, params);
+       wrp_glGetRenderbufferParameteriv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -872,10 +872,10 @@ finish:
 }
 
 void
-glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+wpgl_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetShaderiv(shader, pname, params);
+       wrp_glGetShaderiv(shader, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -884,10 +884,10 @@ finish:
 }
 
 void
-glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+wpgl_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
+       wrp_glGetShaderInfoLog(shader, bufsize, length, infolog);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -896,11 +896,11 @@ finish:
 }
 
 void
-glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+wpgl_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
        _COREGL_WRAP_FUNC_BEGIN();
 #ifndef _COREGL_DESKTOP_GL
-       ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+       wrp_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 #else
        if (range)
@@ -923,10 +923,10 @@ finish:
 }
 
 void
-glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+wpgl_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetShaderSource(shader, bufsize, length, source);
+       wrp_glGetShaderSource(shader, bufsize, length, source);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -935,12 +935,12 @@ finish:
 }
 
 const GLubyte *
-glGetString(GLenum name)
+wpgl_glGetString(GLenum name)
 {
        const GLubyte *ret = NULL;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glGetString(name);
+       ret = wrp_glGetString(name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -950,10 +950,10 @@ finish:
 }
 
 void
-glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+wpgl_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetTexParameterfv(target, pname, params);
+       wrp_glGetTexParameterfv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -962,10 +962,10 @@ finish:
 }
 
 void
-glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+wpgl_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetTexParameteriv(target, pname, params);
+       wrp_glGetTexParameteriv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -974,10 +974,10 @@ finish:
 }
 
 void
-glGetUniformfv(GLuint program, GLint location, GLfloat* params)
+wpgl_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetUniformfv(program, location, params);
+       wrp_glGetUniformfv(program, location, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -986,10 +986,10 @@ finish:
 }
 
 void
-glGetUniformiv(GLuint program, GLint location, GLint* params)
+wpgl_glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetUniformiv(program, location, params);
+       wrp_glGetUniformiv(program, location, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -997,12 +997,12 @@ finish:
        _COREGL_WRAP_FUNC_END();
 }
 int
-glGetUniformLocation(GLuint program, const char* name)
+wpgl_glGetUniformLocation(GLuint program, const char* name)
 {
        int ret = _COREGL_INT_INIT_VALUE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glGetUniformLocation(program, name);
+       ret = wrp_glGetUniformLocation(program, name);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1012,12 +1012,12 @@ finish:
 }
 
 GLboolean
-glIsBuffer(GLuint buffer)
+wpgl_glIsBuffer(GLuint buffer)
 {
        GLboolean ret = GL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsBuffer(buffer);
+       ret = wrp_glIsBuffer(buffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1027,12 +1027,12 @@ finish:
 }
 
 GLboolean
-glIsEnabled(GLenum cap)
+wpgl_glIsEnabled(GLenum cap)
 {
        GLboolean ret = GL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsEnabled(cap);
+       ret = wrp_glIsEnabled(cap);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1042,12 +1042,12 @@ finish:
 }
 
 GLboolean
-glIsFramebuffer(GLuint framebuffer)
+wpgl_glIsFramebuffer(GLuint framebuffer)
 {
        GLboolean ret = GL_FALSE;
 
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsFramebuffer(framebuffer);
+       ret = wrp_glIsFramebuffer(framebuffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1057,11 +1057,11 @@ finish:
 }
 
 GLboolean
-glIsProgram(GLuint program)
+wpgl_glIsProgram(GLuint program)
 {
        GLboolean ret;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsProgram(program);
+       ret = wrp_glIsProgram(program);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1071,11 +1071,11 @@ finish:
 }
 
 GLboolean
-glIsRenderbuffer(GLuint renderbuffer)
+wpgl_glIsRenderbuffer(GLuint renderbuffer)
 {
        GLboolean ret;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsRenderbuffer(renderbuffer);
+       ret = wrp_glIsRenderbuffer(renderbuffer);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1085,11 +1085,11 @@ finish:
 }
 
 GLboolean
-glIsShader(GLuint shader)
+wpgl_glIsShader(GLuint shader)
 {
        GLboolean ret;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsShader(shader);
+       ret = wrp_glIsShader(shader);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1099,11 +1099,11 @@ finish:
 }
 
 GLboolean
-glIsTexture(GLuint texture)
+wpgl_glIsTexture(GLuint texture)
 {
        GLboolean ret;
        _COREGL_WRAP_FUNC_BEGIN();
-       ret = ovr_glIsTexture(texture);
+       ret = wrp_glIsTexture(texture);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1113,10 +1113,10 @@ finish:
 }
 
 void
-glLineWidth(GLfloat width)
+wpgl_glLineWidth(GLfloat width)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glLineWidth(width);
+       wrp_glLineWidth(width);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1125,10 +1125,10 @@ finish:
 }
 
 void
-glLinkProgram(GLuint program)
+wpgl_glLinkProgram(GLuint program)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glLinkProgram(program);
+       wrp_glLinkProgram(program);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1137,10 +1137,10 @@ finish:
 }
 
 void
-glPixelStorei(GLenum pname, GLint param)
+wpgl_glPixelStorei(GLenum pname, GLint param)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glPixelStorei(pname, param);
+       wrp_glPixelStorei(pname, param);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1149,10 +1149,10 @@ finish:
 }
 
 void
-glPolygonOffset(GLfloat factor, GLfloat units)
+wpgl_glPolygonOffset(GLfloat factor, GLfloat units)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glPolygonOffset(factor, units);
+       wrp_glPolygonOffset(factor, units);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1161,10 +1161,10 @@ finish:
 }
 
 void
-glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+wpgl_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glReadPixels(x, y, width, height, format, type, pixels);
+       wrp_glReadPixels(x, y, width, height, format, type, pixels);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1173,11 +1173,11 @@ finish:
 }
 
 void
-glReleaseShaderCompiler(void)
+wpgl_glReleaseShaderCompiler(void)
 {
        _COREGL_WRAP_FUNC_BEGIN();
 #ifndef _COREGL_DESKTOP_GL
-       ovr_glReleaseShaderCompiler();
+       wrp_glReleaseShaderCompiler();
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 #else
        //FIXME!!! need something here?
@@ -1190,10 +1190,10 @@ finish:
 }
 
 void
-glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+wpgl_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glRenderbufferStorage(target, internalformat, width, height);
+       wrp_glRenderbufferStorage(target, internalformat, width, height);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1202,10 +1202,10 @@ finish:
 }
 
 void
-glSampleCoverage(GLclampf value, GLboolean invert)
+wpgl_glSampleCoverage(GLclampf value, GLboolean invert)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glSampleCoverage(value, invert);
+       wrp_glSampleCoverage(value, invert);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1214,10 +1214,10 @@ finish:
 }
 
 void
-glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+wpgl_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glScissor(x, y, width, height);
+       wrp_glScissor(x, y, width, height);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1226,11 +1226,11 @@ finish:
 }
 
 void
-glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
+wpgl_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
 {
        _COREGL_WRAP_FUNC_BEGIN();
 #ifndef _COREGL_DESKTOP_GL
-       ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
+       wrp_glShaderBinary(n, shaders, binaryformat, binary, length);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
 #else
 // FIXME: need to dlsym/getprocaddress for this
@@ -1247,10 +1247,10 @@ finish:
 }
 
 void
-glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+wpgl_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glShaderSource(shader, count, string, length);
+       wrp_glShaderSource(shader, count, string, length);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1259,10 +1259,10 @@ finish:
 }
 
 void
-glStencilFunc(GLenum func, GLint ref, GLuint mask)
+wpgl_glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilFunc(func, ref, mask);
+       wrp_glStencilFunc(func, ref, mask);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1271,10 +1271,10 @@ finish:
 }
 
 void
-glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+wpgl_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilFuncSeparate(face, func, ref, mask);
+       wrp_glStencilFuncSeparate(face, func, ref, mask);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1283,10 +1283,10 @@ finish:
 }
 
 void
-glStencilMask(GLuint mask)
+wpgl_glStencilMask(GLuint mask)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilMask(mask);
+       wrp_glStencilMask(mask);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1295,10 +1295,10 @@ finish:
 }
 
 void
-glStencilMaskSeparate(GLenum face, GLuint mask)
+wpgl_glStencilMaskSeparate(GLenum face, GLuint mask)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilMaskSeparate(face, mask);
+       wrp_glStencilMaskSeparate(face, mask);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1307,10 +1307,10 @@ finish:
 }
 
 void
-glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+wpgl_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilOp(fail, zfail, zpass);
+       wrp_glStencilOp(fail, zfail, zpass);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1319,10 +1319,10 @@ finish:
 }
 
 void
-glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+wpgl_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glStencilOpSeparate(face, fail, zfail, zpass);
+       wrp_glStencilOpSeparate(face, fail, zfail, zpass);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1331,10 +1331,10 @@ finish:
 }
 
 void
-glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
+wpgl_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+       wrp_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1343,10 +1343,10 @@ finish:
 }
 
 void
-glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+wpgl_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexParameterf(target, pname, param);
+       wrp_glTexParameterf(target, pname, param);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1355,10 +1355,10 @@ finish:
 }
 
 void
-glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+wpgl_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexParameterfv(target, pname, params);
+       wrp_glTexParameterfv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1367,10 +1367,10 @@ finish:
 }
 
 void
-glTexParameteri(GLenum target, GLenum pname, GLint param)
+wpgl_glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexParameteri(target, pname, param);
+       wrp_glTexParameteri(target, pname, param);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1379,10 +1379,10 @@ finish:
 }
 
 void
-glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+wpgl_glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexParameteriv(target, pname, params);
+       wrp_glTexParameteriv(target, pname, params);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1391,10 +1391,10 @@ finish:
 }
 
 void
-glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
+wpgl_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+       wrp_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1403,10 +1403,10 @@ finish:
 }
 
 void
-glUniform1f(GLint location, GLfloat x)
+wpgl_glUniform1f(GLint location, GLfloat x)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform1f(location, x);
+       wrp_glUniform1f(location, x);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1415,10 +1415,10 @@ finish:
 }
 
 void
-glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+wpgl_glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform1fv(location, count, v);
+       wrp_glUniform1fv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1427,10 +1427,10 @@ finish:
 }
 
 void
-glUniform1i(GLint location, GLint x)
+wpgl_glUniform1i(GLint location, GLint x)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform1i(location, x);
+       wrp_glUniform1i(location, x);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1439,10 +1439,10 @@ finish:
 }
 
 void
-glUniform1iv(GLint location, GLsizei count, const GLint* v)
+wpgl_glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform1iv(location, count, v);
+       wrp_glUniform1iv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1451,10 +1451,10 @@ finish:
 }
 
 void
-glUniform2f(GLint location, GLfloat x, GLfloat y)
+wpgl_glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform2f(location, x, y);
+       wrp_glUniform2f(location, x, y);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1463,10 +1463,10 @@ finish:
 }
 
 void
-glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
+wpgl_glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform2fv(location, count, v);
+       wrp_glUniform2fv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1475,10 +1475,10 @@ finish:
 }
 
 void
-glUniform2i(GLint location, GLint x, GLint y)
+wpgl_glUniform2i(GLint location, GLint x, GLint y)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform2i(location, x, y);
+       wrp_glUniform2i(location, x, y);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1487,10 +1487,10 @@ finish:
 }
 
 void
-glUniform2iv(GLint location, GLsizei count, const GLint* v)
+wpgl_glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform2iv(location, count, v);
+       wrp_glUniform2iv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1499,10 +1499,10 @@ finish:
 }
 
 void
-glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+wpgl_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform3f(location, x, y, z);
+       wrp_glUniform3f(location, x, y, z);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1511,10 +1511,10 @@ finish:
 }
 
 void
-glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
+wpgl_glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform3fv(location, count, v);
+       wrp_glUniform3fv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1523,10 +1523,10 @@ finish:
 }
 
 void
-glUniform3i(GLint location, GLint x, GLint y, GLint z)
+wpgl_glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform3i(location, x, y, z);
+       wrp_glUniform3i(location, x, y, z);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1535,10 +1535,10 @@ finish:
 }
 
 void
-glUniform3iv(GLint location, GLsizei count, const GLint* v)
+wpgl_glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform3iv(location, count, v);
+       wrp_glUniform3iv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1547,10 +1547,10 @@ finish:
 }
 
 void
-glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+wpgl_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform4f(location, x, y, z, w);
+       wrp_glUniform4f(location, x, y, z, w);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1559,10 +1559,10 @@ finish:
 }
 
 void
-glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
+wpgl_glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform4fv(location, count, v);
+       wrp_glUniform4fv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1571,10 +1571,10 @@ finish:
 }
 
 void
-glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+wpgl_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform4i(location, x, y, z, w);
+       wrp_glUniform4i(location, x, y, z, w);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1583,10 +1583,10 @@ finish:
 }
 
 void
-glUniform4iv(GLint location, GLsizei count, const GLint* v)
+wpgl_glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniform4iv(location, count, v);
+       wrp_glUniform4iv(location, count, v);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1595,10 +1595,10 @@ finish:
 }
 
 void
-glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+wpgl_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniformMatrix2fv(location, count, transpose, value);
+       wrp_glUniformMatrix2fv(location, count, transpose, value);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1607,10 +1607,10 @@ finish:
 }
 
 void
-glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+wpgl_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniformMatrix3fv(location, count, transpose, value);
+       wrp_glUniformMatrix3fv(location, count, transpose, value);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1619,10 +1619,10 @@ finish:
 }
 
 void
-glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+wpgl_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUniformMatrix4fv(location, count, transpose, value);
+       wrp_glUniformMatrix4fv(location, count, transpose, value);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1631,10 +1631,10 @@ finish:
 }
 
 void
-glUseProgram(GLuint program)
+wpgl_glUseProgram(GLuint program)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glUseProgram(program);
+       wrp_glUseProgram(program);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1643,10 +1643,10 @@ finish:
 }
 
 void
-glValidateProgram(GLuint program)
+wpgl_glValidateProgram(GLuint program)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glValidateProgram(program);
+       wrp_glValidateProgram(program);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1655,10 +1655,10 @@ finish:
 }
 
 void
-glVertexAttrib1f(GLuint indx, GLfloat x)
+wpgl_glVertexAttrib1f(GLuint indx, GLfloat x)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib1f(indx, x);
+       wrp_glVertexAttrib1f(indx, x);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1667,10 +1667,10 @@ finish:
 }
 
 void
-glVertexAttrib1fv(GLuint indx, const GLfloat* values)
+wpgl_glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib1fv(indx, values);
+       wrp_glVertexAttrib1fv(indx, values);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1679,10 +1679,10 @@ finish:
 }
 
 void
-glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+wpgl_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib2f(indx, x, y);
+       wrp_glVertexAttrib2f(indx, x, y);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1691,10 +1691,10 @@ finish:
 }
 
 void
-glVertexAttrib2fv(GLuint indx, const GLfloat* values)
+wpgl_glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib2fv(indx, values);
+       wrp_glVertexAttrib2fv(indx, values);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1703,10 +1703,10 @@ finish:
 }
 
 void
-glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+wpgl_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib3f(indx, x, y, z);
+       wrp_glVertexAttrib3f(indx, x, y, z);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1715,10 +1715,10 @@ finish:
 }
 
 void
-glVertexAttrib3fv(GLuint indx, const GLfloat* values)
+wpgl_glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib3fv(indx, values);
+       wrp_glVertexAttrib3fv(indx, values);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1727,10 +1727,10 @@ finish:
 }
 
 void
-glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+wpgl_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib4f(indx, x, y, z, w);
+       wrp_glVertexAttrib4f(indx, x, y, z, w);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1739,10 +1739,10 @@ finish:
 }
 
 void
-glVertexAttrib4fv(GLuint indx, const GLfloat* values)
+wpgl_glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttrib4fv(indx, values);
+       wrp_glVertexAttrib4fv(indx, values);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1751,10 +1751,10 @@ finish:
 }
 
 void
-glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
+wpgl_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+       wrp_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1763,10 +1763,10 @@ finish:
 }
 
 void
-glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+wpgl_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glViewport(x, y, width, height);
+       wrp_glViewport(x, y, width, height);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1777,10 +1777,10 @@ finish:
 
 // GLES Extensions...
 void
-glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+wpgl_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glEGLImageTargetTexture2DOES(target, image);
+       wrp_glEGLImageTargetTexture2DOES(target, image);
        goto finish;
 
 finish:
@@ -1788,10 +1788,10 @@ finish:
 }
 
 void
-glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
+wpgl_glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glEGLImageTargetRenderbufferStorageOES(target, image);
+       wrp_glEGLImageTargetRenderbufferStorageOES(target, image);
        goto finish;
 
 finish:
@@ -1799,10 +1799,10 @@ finish:
 }
 
 void
-glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
+wpgl_glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
+       wrp_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1811,10 +1811,10 @@ finish:
 }
 
 void
-glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
+wpgl_glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glProgramBinary(program, binaryFormat, binary, length);
+       wrp_glProgramBinary(program, binaryFormat, binary, length);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1824,10 +1824,10 @@ finish:
 
 
 void
-glProgramParameteri(GLuint program, GLuint pname, GLint value)
+wpgl_glProgramParameteri(GLuint program, GLuint pname, GLint value)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glProgramParameteri(program, pname, value);
+       wrp_glProgramParameteri(program, pname, value);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1836,10 +1836,10 @@ finish:
 }
 
 void
-glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+wpgl_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
+       wrp_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1848,10 +1848,10 @@ finish:
 }
 
 void
-glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+wpgl_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
+       wrp_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;
 
@@ -1860,10 +1860,10 @@ finish:
 }
 
 void
-glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
+wpgl_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
        _COREGL_WRAP_FUNC_BEGIN();
-       ovr_glDiscardFramebufferEXT(target, numAttachments, attachments);
+       wrp_glDiscardFramebufferEXT(target, numAttachments, attachments);
        GLERR(__FUNCTION__, __FILE__, __LINE__, "");
        goto finish;