From 245ccb66475eb29b9cff14f4102fd76cc936e254 Mon Sep 17 00:00:00 2001 From: Haegeun Park Date: Thu, 24 Jan 2013 22:52:12 -0800 Subject: [PATCH] [Title] Removed EGL/GL symbols in libCOREGL [Issue#] [Problem] [Cause] [Solution] - Now, all EGL/GL symbols are exported only in libEGL/libGLESv2 - After the patch, applications can't use libCOREGL directly. --- src/coregl.h | 2 + src/coregl_export_egl.c | 117 ++++++-------------- src/coregl_export_gl.c | 284 ++++++++++++++++++++++++------------------------ src/wraps/coregl_egl.c | 2 +- src/wraps/coregl_gl.c | 2 +- 5 files changed, 180 insertions(+), 227 deletions(-) diff --git a/src/coregl.h b/src/coregl.h index 58b5942..1554433 100644 --- a/src/coregl.h +++ b/src/coregl.h @@ -11,9 +11,11 @@ typedef void (*_eng_fn) (void); +#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_API extern RET_TYPE coregl_api_##FUNC_NAME PARAM_LIST; #define _COREGL_EXT_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) #include "headers/sym.h" #undef _COREGL_EXT_SYMBOL +#undef _COREGL_SYMBOL extern int coregl_initialize(); extern void coregl_terminate(); diff --git a/src/coregl_export_egl.c b/src/coregl_export_egl.c index 0bdb529..da04740 100644 --- a/src/coregl_export_egl.c +++ b/src/coregl_export_egl.c @@ -15,49 +15,49 @@ Mutex init_export_mutex = MUTEX_INITIALIZER; } EGLint -eglGetError(void) +coregl_api_eglGetError(void) { INIT_EXPORT(); return ovr_eglGetError(); } EGLDisplay -eglGetDisplay(EGLNativeDisplayType display_id) +coregl_api_eglGetDisplay(EGLNativeDisplayType display_id) { INIT_EXPORT(); return ovr_eglGetDisplay(display_id); } EGLBoolean -eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) +coregl_api_eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) { INIT_EXPORT(); return ovr_eglInitialize(dpy, major, minor); } EGLBoolean -eglTerminate(EGLDisplay dpy) +coregl_api_eglTerminate(EGLDisplay dpy) { INIT_EXPORT(); return ovr_eglTerminate(dpy); } EGLBoolean -eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) +coregl_api_eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) { INIT_EXPORT(); 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) +coregl_api_eglChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config) { INIT_EXPORT(); return ovr_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config); } EGLBoolean -eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) +coregl_api_eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) { INIT_EXPORT(); return ovr_eglGetConfigAttrib(dpy, config, attribute, value); @@ -65,240 +65,191 @@ eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *v EGLSurface -eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list) +coregl_api_eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list) { INIT_EXPORT(); return ovr_eglCreateWindowSurface(dpy, config, win, attrib_list); } EGLSurface -eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) +coregl_api_eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) { INIT_EXPORT(); return ovr_eglCreatePbufferSurface(dpy, config, attrib_list); } EGLSurface -eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list) +coregl_api_eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list) { INIT_EXPORT(); return ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list); } EGLBoolean -eglDestroySurface(EGLDisplay dpy, EGLSurface surface) +coregl_api_eglDestroySurface(EGLDisplay dpy, EGLSurface surface) { INIT_EXPORT(); return ovr_eglDestroySurface(dpy, surface); } EGLBoolean -eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) +coregl_api_eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) { INIT_EXPORT(); return ovr_eglQuerySurface(dpy, surface, attribute, value); } EGLBoolean -eglBindAPI(EGLenum api) +coregl_api_eglBindAPI(EGLenum api) { INIT_EXPORT(); return ovr_eglBindAPI(api); } EGLenum -eglQueryAPI(void) +coregl_api_eglQueryAPI(void) { INIT_EXPORT(); return ovr_eglQueryAPI(); } EGLBoolean -eglWaitClient(void) +coregl_api_eglWaitClient(void) { INIT_EXPORT(); return ovr_eglWaitClient(); } EGLBoolean -eglReleaseThread(void) +coregl_api_eglReleaseThread(void) { INIT_EXPORT(); return ovr_eglReleaseThread(); } EGLSurface -eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) +coregl_api_eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) { INIT_EXPORT(); return ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list); } EGLBoolean -eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) +coregl_api_eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) { INIT_EXPORT(); return ovr_eglSurfaceAttrib(dpy, surface, attribute, value); } EGLBoolean -eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +coregl_api_eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { INIT_EXPORT(); return ovr_eglBindTexImage(dpy, surface, buffer); } EGLBoolean -eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +coregl_api_eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { INIT_EXPORT(); return ovr_eglReleaseTexImage(dpy, surface, buffer); } EGLBoolean -eglSwapInterval(EGLDisplay dpy, EGLint interval) +coregl_api_eglSwapInterval(EGLDisplay dpy, EGLint interval) { INIT_EXPORT(); return ovr_eglSwapInterval(dpy, interval); } EGLContext -eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list) +coregl_api_eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list) { INIT_EXPORT(); return ovr_eglCreateContext(dpy, config, share_context, attrib_list); } EGLBoolean -eglDestroyContext(EGLDisplay dpy, EGLContext ctx) +coregl_api_eglDestroyContext(EGLDisplay dpy, EGLContext ctx) { INIT_EXPORT(); return ovr_eglDestroyContext(dpy, ctx); } EGLBoolean -eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) +coregl_api_eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) { INIT_EXPORT(); return ovr_eglMakeCurrent(dpy, draw, read, ctx); } EGLContext -eglGetCurrentContext(void) +coregl_api_eglGetCurrentContext(void) { INIT_EXPORT(); return ovr_eglGetCurrentContext(); } EGLSurface -eglGetCurrentSurface(EGLint readdraw) +coregl_api_eglGetCurrentSurface(EGLint readdraw) { INIT_EXPORT(); return ovr_eglGetCurrentSurface(readdraw); } EGLDisplay -eglGetCurrentDisplay(void) +coregl_api_eglGetCurrentDisplay(void) { INIT_EXPORT(); return ovr_eglGetCurrentDisplay(); } EGLBoolean -eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) +coregl_api_eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) { INIT_EXPORT(); return ovr_eglQueryContext(dpy, ctx, attribute, value); } EGLBoolean -eglWaitGL(void) +coregl_api_eglWaitGL(void) { INIT_EXPORT(); return ovr_eglWaitGL(); } EGLBoolean -eglWaitNative(EGLint engine) +coregl_api_eglWaitNative(EGLint engine) { INIT_EXPORT(); return ovr_eglWaitNative(engine); } EGLBoolean -eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) +coregl_api_eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) { INIT_EXPORT(); return ovr_eglSwapBuffers(dpy, surface); } EGLBoolean -eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) +coregl_api_eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) { INIT_EXPORT(); return ovr_eglCopyBuffers(dpy, surface, target); } _eng_fn -eglGetProcAddress(const char* procname) +coregl_api_eglGetProcAddress(const char* procname) { INIT_EXPORT(); return ovr_eglGetProcAddress(procname); } const char * -eglQueryString(EGLDisplay dpy, EGLint name) +coregl_api_eglQueryString(EGLDisplay dpy, EGLint name) { INIT_EXPORT(); return ovr_eglQueryString(dpy, name); } -EGLImageKHR -eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) -{ - INIT_EXPORT(); - return ovr_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list); -} - -EGLBoolean -eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) -{ - INIT_EXPORT(); - return ovr_eglDestroyImageKHR(dpy, image); -} - -void * -eglMapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type, EGLint access_option) -{ - INIT_EXPORT(); - return ovr_eglMapImageSEC(dpy, image, device_type, access_option); -} - -EGLBoolean -eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image, EGLint device_type) -{ - INIT_EXPORT(); - return ovr_eglUnmapImageSEC(dpy, image, device_type); -} - -EGLBoolean -eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value) -{ - INIT_EXPORT(); - return ovr_eglGetImageAttribSEC(dpy, image, attribute, value); -} - -EGLBoolean -eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list) -{ - INIT_EXPORT(); - return ovr_eglLockSurfaceKHR(display, surface, attrib_list); -} - -EGLBoolean -eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface) -{ - INIT_EXPORT(); - return ovr_eglUnlockSurfaceKHR(display, surface); -} - diff --git a/src/coregl_export_gl.c b/src/coregl_export_gl.c index 9b16d4b..dd0112c 100644 --- a/src/coregl_export_gl.c +++ b/src/coregl_export_gl.c @@ -1,853 +1,853 @@ #include "coregl_export.h" void -glActiveTexture(GLenum texture) +coregl_api_glActiveTexture(GLenum texture) { ovr_glActiveTexture(texture); } void -glAttachShader(GLuint program, GLuint shader) +coregl_api_glAttachShader(GLuint program, GLuint shader) { ovr_glAttachShader(program, shader); } void -glBindAttribLocation(GLuint program, GLuint index, const char* name) +coregl_api_glBindAttribLocation(GLuint program, GLuint index, const char* name) { ovr_glBindAttribLocation(program, index, name); } void -glBindBuffer(GLenum target, GLuint buffer) +coregl_api_glBindBuffer(GLenum target, GLuint buffer) { ovr_glBindBuffer(target, buffer); } void -glBindFramebuffer(GLenum target, GLuint framebuffer) +coregl_api_glBindFramebuffer(GLenum target, GLuint framebuffer) { ovr_glBindFramebuffer(target, framebuffer); } void -glBindRenderbuffer(GLenum target, GLuint renderbuffer) +coregl_api_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { ovr_glBindRenderbuffer(target, renderbuffer); } void -glBindTexture(GLenum target, GLuint texture) +coregl_api_glBindTexture(GLenum target, GLuint texture) { ovr_glBindTexture(target, texture); } void -glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +coregl_api_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { ovr_glBlendColor(red, green, blue, alpha); } void -glBlendEquation(GLenum mode) +coregl_api_glBlendEquation(GLenum mode) { ovr_glBlendEquation(mode); } void -glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +coregl_api_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { ovr_glBlendEquationSeparate(modeRGB, modeAlpha); } void -glBlendFunc(GLenum sfactor, GLenum dfactor) +coregl_api_glBlendFunc(GLenum sfactor, GLenum dfactor) { ovr_glBlendFunc(sfactor, dfactor); } void -glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +coregl_api_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) +coregl_api_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) +coregl_api_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) { ovr_glBufferSubData(target, offset, size, data); } GLenum -glCheckFramebufferStatus(GLenum target) +coregl_api_glCheckFramebufferStatus(GLenum target) { return ovr_glCheckFramebufferStatus(target); } void -glClear(GLbitfield mask) +coregl_api_glClear(GLbitfield mask) { ovr_glClear(mask); } void -glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +coregl_api_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { ovr_glClearColor(red, green, blue, alpha); } void -glClearDepthf(GLclampf depth) +coregl_api_glClearDepthf(GLclampf depth) { ovr_glClearDepthf(depth); } void -glClearStencil(GLint s) +coregl_api_glClearStencil(GLint s) { ovr_glClearStencil(s); } void -glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +coregl_api_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { ovr_glColorMask(red, green, blue, alpha); } void -glCompileShader(GLuint shader) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_glCreateProgram(void) { return ovr_glCreateProgram(); } GLuint -glCreateShader(GLenum type) +coregl_api_glCreateShader(GLenum type) { return ovr_glCreateShader(type); } void -glCullFace(GLenum mode) +coregl_api_glCullFace(GLenum mode) { ovr_glCullFace(mode); } void -glDeleteBuffers(GLsizei n, const GLuint* buffers) +coregl_api_glDeleteBuffers(GLsizei n, const GLuint* buffers) { ovr_glDeleteBuffers(n, buffers); } void -glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) +coregl_api_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { ovr_glDeleteFramebuffers(n, framebuffers); } void -glDeleteProgram(GLuint program) +coregl_api_glDeleteProgram(GLuint program) { ovr_glDeleteProgram(program); } void -glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) +coregl_api_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { ovr_glDeleteRenderbuffers(n, renderbuffers); } void -glDeleteShader(GLuint shader) +coregl_api_glDeleteShader(GLuint shader) { ovr_glDeleteShader(shader); } void -glDeleteTextures(GLsizei n, const GLuint* textures) +coregl_api_glDeleteTextures(GLsizei n, const GLuint* textures) { ovr_glDeleteTextures(n, textures); } void -glDepthFunc(GLenum func) +coregl_api_glDepthFunc(GLenum func) { ovr_glDepthFunc(func); } void -glDepthMask(GLboolean flag) +coregl_api_glDepthMask(GLboolean flag) { ovr_glDepthMask(flag); } void -glDepthRangef(GLclampf zNear, GLclampf zFar) +coregl_api_glDepthRangef(GLclampf zNear, GLclampf zFar) { ovr_glDepthRangef(zNear, zFar); } void -glDetachShader(GLuint program, GLuint shader) +coregl_api_glDetachShader(GLuint program, GLuint shader) { ovr_glDetachShader(program, shader); } void -glDisable(GLenum cap) +coregl_api_glDisable(GLenum cap) { ovr_glDisable(cap); } void -glDisableVertexAttribArray(GLuint index) +coregl_api_glDisableVertexAttribArray(GLuint index) { ovr_glDisableVertexAttribArray(index); } void -glDrawArrays(GLenum mode, GLint first, GLsizei count) +coregl_api_glDrawArrays(GLenum mode, GLint first, GLsizei count) { ovr_glDrawArrays(mode, first, count); } void -glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) +coregl_api_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) { ovr_glDrawElements(mode, count, type, indices); } void -glEnable(GLenum cap) +coregl_api_glEnable(GLenum cap) { ovr_glEnable(cap); } void -glEnableVertexAttribArray(GLuint index) +coregl_api_glEnableVertexAttribArray(GLuint index) { ovr_glEnableVertexAttribArray(index); } void -glFinish(void) +coregl_api_glFinish(void) { ovr_glFinish(); } void -glFlush(void) +coregl_api_glFlush(void) { ovr_glFlush(); } void -glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +coregl_api_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) +coregl_api_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level); } void -glFrontFace(GLenum mode) +coregl_api_glFrontFace(GLenum mode) { ovr_glFrontFace(mode); } void -glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) +coregl_api_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { ovr_glGetVertexAttribfv(index, pname, params); } void -glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) +coregl_api_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { ovr_glGetVertexAttribiv(index, pname, params); } void -glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) +coregl_api_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) { ovr_glGetVertexAttribPointerv(index, pname, pointer); } void -glHint(GLenum target, GLenum mode) +coregl_api_glHint(GLenum target, GLenum mode) { ovr_glHint(target, mode); } void -glGenBuffers(GLsizei n, GLuint* buffers) +coregl_api_glGenBuffers(GLsizei n, GLuint* buffers) { ovr_glGenBuffers(n, buffers); } void -glGenerateMipmap(GLenum target) +coregl_api_glGenerateMipmap(GLenum target) { ovr_glGenerateMipmap(target); } void -glGenFramebuffers(GLsizei n, GLuint* framebuffers) +coregl_api_glGenFramebuffers(GLsizei n, GLuint* framebuffers) { ovr_glGenFramebuffers(n, framebuffers); } void -glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) +coregl_api_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { ovr_glGenRenderbuffers(n, renderbuffers); } void -glGenTextures(GLsizei n, GLuint* textures) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { ovr_glGetAttachedShaders(program, maxcount, count, shaders); } int -glGetAttribLocation(GLuint program, const char* name) +coregl_api_glGetAttribLocation(GLuint program, const char* name) { return ovr_glGetAttribLocation(program, name); } void -glGetBooleanv(GLenum pname, GLboolean* params) +coregl_api_glGetBooleanv(GLenum pname, GLboolean* params) { ovr_glGetBooleanv(pname, params); } void -glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) +coregl_api_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { ovr_glGetBufferParameteriv(target, pname, params); } GLenum -glGetError(void) +coregl_api_glGetError(void) { return ovr_glGetError(); } void -glGetFloatv(GLenum pname, GLfloat* params) +coregl_api_glGetFloatv(GLenum pname, GLfloat* params) { ovr_glGetFloatv(pname, params); } void -glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) +coregl_api_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) { ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); } void -glGetIntegerv(GLenum pname, GLint* params) +coregl_api_glGetIntegerv(GLenum pname, GLint* params) { ovr_glGetIntegerv(pname, params); } void -glGetProgramiv(GLuint program, GLenum pname, GLint* params) +coregl_api_glGetProgramiv(GLuint program, GLenum pname, GLint* params) { ovr_glGetProgramiv(program, pname, params); } void -glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) +coregl_api_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) { ovr_glGetProgramInfoLog(program, bufsize, length, infolog); } void -glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) +coregl_api_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) { ovr_glGetRenderbufferParameteriv(target, pname, params); } void -glGetShaderiv(GLuint shader, GLenum pname, GLint* params) +coregl_api_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { ovr_glGetShaderiv(shader, pname, params); } void -glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) +coregl_api_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) +coregl_api_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) +coregl_api_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) { ovr_glGetShaderSource(shader, bufsize, length, source); } const GLubyte * -glGetString(GLenum name) +coregl_api_glGetString(GLenum name) { return ovr_glGetString(name); } void -glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) +coregl_api_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { ovr_glGetTexParameterfv(target, pname, params); } void -glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) +coregl_api_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { ovr_glGetTexParameteriv(target, pname, params); } void -glGetUniformfv(GLuint program, GLint location, GLfloat* params) +coregl_api_glGetUniformfv(GLuint program, GLint location, GLfloat* params) { ovr_glGetUniformfv(program, location, params); } void -glGetUniformiv(GLuint program, GLint location, GLint* params) +coregl_api_glGetUniformiv(GLuint program, GLint location, GLint* params) { ovr_glGetUniformiv(program, location, params); } int -glGetUniformLocation(GLuint program, const char* name) +coregl_api_glGetUniformLocation(GLuint program, const char* name) { return ovr_glGetUniformLocation(program, name); } GLboolean -glIsBuffer(GLuint buffer) +coregl_api_glIsBuffer(GLuint buffer) { return ovr_glIsBuffer(buffer); } GLboolean -glIsEnabled(GLenum cap) +coregl_api_glIsEnabled(GLenum cap) { return ovr_glIsEnabled(cap); } GLboolean -glIsFramebuffer(GLuint framebuffer) +coregl_api_glIsFramebuffer(GLuint framebuffer) { return ovr_glIsFramebuffer(framebuffer); } GLboolean -glIsProgram(GLuint program) +coregl_api_glIsProgram(GLuint program) { return ovr_glIsProgram(program); } GLboolean -glIsRenderbuffer(GLuint renderbuffer) +coregl_api_glIsRenderbuffer(GLuint renderbuffer) { return ovr_glIsRenderbuffer(renderbuffer); } GLboolean -glIsShader(GLuint shader) +coregl_api_glIsShader(GLuint shader) { return ovr_glIsShader(shader); } GLboolean -glIsTexture(GLuint texture) +coregl_api_glIsTexture(GLuint texture) { return ovr_glIsTexture(texture); } void -glLineWidth(GLfloat width) +coregl_api_glLineWidth(GLfloat width) { ovr_glLineWidth(width); } void -glLinkProgram(GLuint program) +coregl_api_glLinkProgram(GLuint program) { ovr_glLinkProgram(program); } void -glPixelStorei(GLenum pname, GLint param) +coregl_api_glPixelStorei(GLenum pname, GLint param) { ovr_glPixelStorei(pname, param); } void -glPolygonOffset(GLfloat factor, GLfloat units) +coregl_api_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) +coregl_api_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) +coregl_api_glReleaseShaderCompiler(void) { ovr_glReleaseShaderCompiler(); } void -glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +coregl_api_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { ovr_glRenderbufferStorage(target, internalformat, width, height); } void -glSampleCoverage(GLclampf value, GLboolean invert) +coregl_api_glSampleCoverage(GLclampf value, GLboolean invert) { ovr_glSampleCoverage(value, invert); } void -glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_glStencilFunc(GLenum func, GLint ref, GLuint mask) { ovr_glStencilFunc(func, ref, mask); } void -glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +coregl_api_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { ovr_glStencilFuncSeparate(face, func, ref, mask); } void -glStencilMask(GLuint mask) +coregl_api_glStencilMask(GLuint mask) { ovr_glStencilMask(mask); } void -glStencilMaskSeparate(GLenum face, GLuint mask) +coregl_api_glStencilMaskSeparate(GLenum face, GLuint mask) { ovr_glStencilMaskSeparate(face, mask); } void -glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +coregl_api_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { ovr_glStencilOp(fail, zfail, zpass); } void -glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +coregl_api_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) +coregl_api_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) +coregl_api_glTexParameterf(GLenum target, GLenum pname, GLfloat param) { ovr_glTexParameterf(target, pname, param); } void -glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) +coregl_api_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { ovr_glTexParameterfv(target, pname, params); } void -glTexParameteri(GLenum target, GLenum pname, GLint param) +coregl_api_glTexParameteri(GLenum target, GLenum pname, GLint param) { ovr_glTexParameteri(target, pname, param); } void -glTexParameteriv(GLenum target, GLenum pname, const GLint* params) +coregl_api_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) +coregl_api_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) +coregl_api_glUniform1f(GLint location, GLfloat x) { ovr_glUniform1f(location, x); } void -glUniform1fv(GLint location, GLsizei count, const GLfloat* v) +coregl_api_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) { ovr_glUniform1fv(location, count, v); } void -glUniform1i(GLint location, GLint x) +coregl_api_glUniform1i(GLint location, GLint x) { ovr_glUniform1i(location, x); } void -glUniform1iv(GLint location, GLsizei count, const GLint* v) +coregl_api_glUniform1iv(GLint location, GLsizei count, const GLint* v) { ovr_glUniform1iv(location, count, v); } void -glUniform2f(GLint location, GLfloat x, GLfloat y) +coregl_api_glUniform2f(GLint location, GLfloat x, GLfloat y) { ovr_glUniform2f(location, x, y); } void -glUniform2fv(GLint location, GLsizei count, const GLfloat* v) +coregl_api_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) { ovr_glUniform2fv(location, count, v); } void -glUniform2i(GLint location, GLint x, GLint y) +coregl_api_glUniform2i(GLint location, GLint x, GLint y) { ovr_glUniform2i(location, x, y); } void -glUniform2iv(GLint location, GLsizei count, const GLint* v) +coregl_api_glUniform2iv(GLint location, GLsizei count, const GLint* v) { ovr_glUniform2iv(location, count, v); } void -glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) +coregl_api_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { ovr_glUniform3f(location, x, y, z); } void -glUniform3fv(GLint location, GLsizei count, const GLfloat* v) +coregl_api_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) { ovr_glUniform3fv(location, count, v); } void -glUniform3i(GLint location, GLint x, GLint y, GLint z) +coregl_api_glUniform3i(GLint location, GLint x, GLint y, GLint z) { ovr_glUniform3i(location, x, y, z); } void -glUniform3iv(GLint location, GLsizei count, const GLint* v) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_glUniform4iv(GLint location, GLsizei count, const GLint* v) { ovr_glUniform4iv(location, count, v); } void -glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +coregl_api_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) +coregl_api_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) +coregl_api_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ovr_glUniformMatrix4fv(location, count, transpose, value); } void -glUseProgram(GLuint program) +coregl_api_glUseProgram(GLuint program) { ovr_glUseProgram(program); } void -glValidateProgram(GLuint program) +coregl_api_glValidateProgram(GLuint program) { ovr_glValidateProgram(program); } void -glVertexAttrib1f(GLuint indx, GLfloat x) +coregl_api_glVertexAttrib1f(GLuint indx, GLfloat x) { ovr_glVertexAttrib1f(indx, x); } void -glVertexAttrib1fv(GLuint indx, const GLfloat* values) +coregl_api_glVertexAttrib1fv(GLuint indx, const GLfloat* values) { ovr_glVertexAttrib1fv(indx, values); } void -glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) +coregl_api_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { ovr_glVertexAttrib2f(indx, x, y); } void -glVertexAttrib2fv(GLuint indx, const GLfloat* values) +coregl_api_glVertexAttrib2fv(GLuint indx, const GLfloat* values) { ovr_glVertexAttrib2fv(indx, values); } void -glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) +coregl_api_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { ovr_glVertexAttrib3f(indx, x, y, z); } void -glVertexAttrib3fv(GLuint indx, const GLfloat* values) +coregl_api_glVertexAttrib3fv(GLuint indx, const GLfloat* values) { ovr_glVertexAttrib3fv(indx, values); } void -glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +coregl_api_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) +coregl_api_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) +coregl_api_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) +coregl_api_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { ovr_glViewport(x, y, width, height); } diff --git a/src/wraps/coregl_egl.c b/src/wraps/coregl_egl.c index 54f1284..9a2456a 100644 --- a/src/wraps/coregl_egl.c +++ b/src/wraps/coregl_egl.c @@ -36,7 +36,7 @@ coregl_glwrap_init() } #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) \ - ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, #FUNC_NAME); + ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, "coregl_api_"#FUNC_NAME); #define _COREGL_EXT_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) #include "../headers/sym_egl.h" #undef _COREGL_EXT_SYMBOL diff --git a/src/wraps/coregl_gl.c b/src/wraps/coregl_gl.c index 187356d..92426a3 100644 --- a/src/wraps/coregl_gl.c +++ b/src/wraps/coregl_gl.c @@ -33,7 +33,7 @@ coregl_glwrap_init() } #define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) \ - ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, #FUNC_NAME); + ovr_##FUNC_NAME = (__typeof__(ovr_##FUNC_NAME))dlsym(lib_handle, "coregl_api_"#FUNC_NAME); #include "../headers/sym_gl.h" #undef _COREGL_SYMBOL -- 2.7.4