From f479b0e2dda2d687060b93e06eeada4dfebda652 Mon Sep 17 00:00:00 2001 From: Haegeun Park Date: Wed, 30 May 2012 00:16:09 -0700 Subject: [PATCH] Refactored wrapping layer - Enhance performance for no-tracing path - API trace is now enabled - Minor bug fixes --- CMakeLists.txt | 11 +- Makefile | 3 + include/EGL/sym_egl.h | 2 +- src/coregl_export.c | 10 + src/coregl_export.h | 15 + src/coregl_export_egl.c | 249 +++++++++++++ src/coregl_export_gl.c | 906 ++++++++++++++++++++++++++++++++++++++++++++++ src/coregl_export_glx.c | 0 src/coregl_fastpath.c | 2 +- src/coregl_fastpath.h | 12 +- src/coregl_fastpath_egl.c | 18 +- src/coregl_internal.h | 14 +- src/coregl_override.c | 47 ++- src/coregl_trace.c | 12 +- src/coregl_wrappath.c | 5 - src/coregl_wrappath.h | 13 +- src/coregl_wrappath_egl.c | 166 ++++----- src/coregl_wrappath_gl.c | 600 +++++++++++++++--------------- 18 files changed, 1658 insertions(+), 427 deletions(-) create mode 100644 src/coregl_export.c create mode 100644 src/coregl_export.h create mode 100644 src/coregl_export_egl.c create mode 100644 src/coregl_export_gl.c create mode 100644 src/coregl_export_glx.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 0403664..eaa171b 100644 --- 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 --- 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 --- 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 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 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 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 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 index 0000000..e69de29 diff --git a/src/coregl_fastpath.c b/src/coregl_fastpath.c index 0dc6d27..33447e9 100644 --- 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 --- 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 --- 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 --- 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 --- 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 -#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 --- 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 = ¤t->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 = ¤t->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 --- a/src/coregl_wrappath.c +++ b/src/coregl_wrappath.c @@ -4,11 +4,6 @@ #include #include -// 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 --- a/src/coregl_wrappath.h +++ b/src/coregl_wrappath.h @@ -1,13 +1,18 @@ +#ifndef COREGL_WRAPPATH_H +#define COREGL_WRAPPATH_H #include "coregl_internal.h" +#include "coregl_export.h" -// Symbol definition for override -#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST; -# include "headers/sym.h" -#undef _COREGL_SYMBOL +// Symbol definition for wrappath +#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (wpgl_##FUNC_NAME) PARAM_LIST; +# include "headers/sym.h" +#undef _COREGL_SYMBOL extern void init_wrap_gl(); extern void free_wrap_gl(); extern void dump_wrap_context_states(int force_output); +#endif // COREGL_WRAPPATH_H + diff --git a/src/coregl_wrappath_egl.c b/src/coregl_wrappath_egl.c index 9d82a77..92f9e85 100644 --- 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 --- 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; -- 2.7.4