CC = gcc
-CFLAGS = -g -O2 -fPIC -Wall -std=c99 \
+CFLAGS = -g -O2 -fvisibility=hidden -fPIC -Wall -std=c99 \
-D_COREGL_EMBEDDED_GL \
-LDFLAGS = -g -O2 -Wall -std=c99 -lpthread
+LDFLAGS = -g -O2 -fvisibility=hidden -Wall -std=c99 -lpthread
SOURCES = \
src/coregl.c \
// Defult use-case for exporting symbols
#ifndef _COREGL_SYMBOL
#define _COREGL_SYMBOL_NOT_DEFINED
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
#endif
// Standard EGL APIs
_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglUnmapImageSEC, (EGLDisplay dpy, EGLImageKHR image))
_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglGetImageAttribSEC, (EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value))
-//_COREGL_SYMBOL(GL_FALSE, unsigned int, eglLockSurface, (EGLDisplay a, EGLSurface b, const int *attrib_list))
-//_COREGL_SYMBOL(GL_FALSE, unsigned int, eglUnlockSurface, (EGLDisplay a, EGLSurface b))
+_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglLockSurfaceKHR, (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list))
+_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglUnlockSurfaceKHR, (EGLDisplay display, EGLSurface surface))
#ifdef _COREGL_SYMBOL_NOT_DEFINED
#undef _COREGL_SYMBOL_NOT_DEFINED
// Defult use-case for exporting symbols
#ifndef _COREGL_SYMBOL
#define _COREGL_SYMBOL_NOT_DEFINED
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
#endif
/* version 1: */
_COREGL_SYMBOL(GL_TRUE, void, glProgramParameteri, (GLuint a, GLuint b, GLint d))
_COREGL_SYMBOL(GL_TRUE, void, glRenderbufferStorageMultisampleEXT, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_SYMBOL(GL_TRUE, void, glFramebufferTexture2DMultisampleEXT, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples))
+_COREGL_SYMBOL(GL_TRUE, void, glDiscardFramebufferEXT, (GLenum target, GLsizei numAttachments, const GLenum *attachments))
#ifdef _COREGL_SYMBOL_NOT_DEFINED
#undef _COREGL_SYMBOL_NOT_DEFINED
#include <string.h>
#include "coregl_internal.h"
+CoreGL_Opt_Flag api_opt = COREGL_UNKNOWN_PATH;
+
Mutex ctx_list_access_mutex = MUTEX_INITIALIZER;
void *egl_lib_handle;
GLContext_List *glctx_list = NULL;
-// Symbol definition for local
-#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
+int trace_api_flag = 0;
+int trace_ctx_flag = 0;
+int trace_state_flag = 0;
+int debug_nofp = 0;
-// Symbol definition for static
+// Symbol definition for real
#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) RET_TYPE (*_sym_##FUNC_NAME) PARAM_LIST;
#include "headers/sym.h"
#undef _COREGL_SYMBOL
tstate = (GLThreadState *)calloc(1, sizeof(GLThreadState));
tstate->thread_id = get_current_thread();
+ tstate->binded_api = EGL_NONE;
set_current_thread_state(&ctx_list_access_mutex, tstate);
return 1;
}
+COREGL_API void coregl_symbol_exported()
+{
+ LOG("\E[0;31;1mERROR : Invalid library link! (Check linkage of libCOREGL)\E[0m\n");
+}
+
static int
_gl_lib_init(void)
{
//------------------------------------------------//
// Open EGL Library as EGL is separate
#ifndef _COREGL_EMBED_EVAS
- egl_lib_handle = dlopen("libEGL_drv.so", RTLD_NOW | RTLD_GLOBAL);
+ egl_lib_handle = dlopen("libEGL_drv.so", RTLD_NOW);
#else
- egl_lib_handle = dlopen("libEGL.so.1", RTLD_NOW | RTLD_GLOBAL);
+ egl_lib_handle = dlopen("libEGL.so.1", RTLD_NOW);
if (!egl_lib_handle)
- egl_lib_handle = dlopen("libEGL.so", RTLD_NOW | RTLD_GLOBAL);
+ egl_lib_handle = dlopen("libEGL.so", RTLD_NOW);
#endif
if (!egl_lib_handle)
{
- ERR("%s\n", dlerror());
+ ERR("\E[0;31;1mERROR : %s\E[0m\n\n", dlerror());
+ ERR("\E[0;31;1mERROR : Invalid library link! (Check linkage of libCOREGL -> libEGL_drv)\E[0m\n");
+ return 0;
+ }
+
+ // test for invalid linking egl
+ if (dlsym(egl_lib_handle, "coregl_symbol_exported"))
+ {
+ ERR("\E[0;31;1mERROR : Invalid library link! (Check linkage of libCOREGL -> libEGL_drv)\E[0m\n");
return 0;
}
#endif
if (!gl_lib_handle)
{
- ERR("%s\n", dlerror());
+ ERR("\E[0;31;1mERROR : %s\E[0m\n\n", dlerror());
+ ERR("\E[0;31;1mERROR : Invalid library link! (Check linkage of libCOREGL -> libGLESv2_drv)\E[0m\n");
+ return 0;
+ }
+
+ // test for invalid linking gl
+ if (dlsym(gl_lib_handle, "coregl_symbol_exported"))
+ {
+ ERR("\E[0;31;1mERROR : Invalid library link! (Check linkage of libCOREGL -> libGLESv2_drv)\E[0m\n");
return 0;
}
//------------------------------------------------//
return 1;
}
+extern void init_fast_gl();
+extern void init_wrap_gl();
+
#ifndef _COREGL_EMBED_EVAS
__attribute__((constructor))
#endif
init_gl()
{
int fastpath_opt = 0;
- CoreGL_Opt_Flag api_opt = COREGL_NORMAL_PATH;
LOG("[CoreGL] ");
case 1:
api_opt = COREGL_FAST_PATH;
LOG(": (%d) Fastpath enabled...\n", fastpath_opt);
+ init_fast_gl();
break;
default:
LOG(": (%d) Default API path enabled...\n", fastpath_opt);
api_opt = COREGL_NORMAL_PATH;
+ init_wrap_gl();
break;
- }
+ }
+
+#ifdef COREGL_TRACE_APICALL_INFO
+ trace_api_flag = atoi(get_env_setting("COREGL_TRACE_API"));
+#endif
+#ifdef COREGL_TRACE_CONTEXT_INFO
+ trace_ctx_flag = atoi(get_env_setting("COREGL_TRACE_CTX"));
+#endif
+#ifdef COREGL_TRACE_STATE_INFO
+ trace_state_flag = atoi(get_env_setting("COREGL_TRACE_STATE"));
+#endif
+
+ debug_nofp = atoi(get_env_setting("COREGL_DEBUG_NOFP"));
+
override_glue_apis(api_opt);
override_gl_apis(api_opt);
return 1;
}
+extern void free_fast_gl();
+extern void free_wrap_gl();
+
#ifndef _COREGL_EMBED_EVAS
__attribute__((destructor))
#endif
{
GLContext_List *current = NULL;
+ switch (api_opt)
+ {
+ case COREGL_FAST_PATH:
+ free_fast_gl();
+ break;
+ default:
+ free_wrap_gl();
+ break;
+ }
+
AST(mutex_lock(&ctx_list_access_mutex) == 1);
{
#undef _COREGL_DESKTOP_GL
#endif
-#define _COREGL_NAME_MANGLE(name) glsym_##name
+#define COREGL_API __attribute__((visibility("default")))
// Include GL/EGL/GLX types
#ifndef _COREGL_DESKTOP_GL
#include <string.h>
#include <sys/time.h>
+GLenum FPGL_Error = GL_NO_ERROR;
+
Mutex init_context_mutex = MUTEX_INITIALIZER;
GLGlueContext *initial_ctx = NULL;
return (1 << stencil_bit) - 1;
}
+void
+init_fast_gl()
+{
+}
+
+void
+free_fast_gl()
+{
+}
+
+static GL_Object **
+_get_shared_object(GL_Shared_Object_State *sostate, GL_Object_Type type)
+{
+ switch (type)
+ {
+ case GL_OBJECT_TYPE_TEXTURE:
+ return sostate->texture;
+ case GL_OBJECT_TYPE_BUFFER:
+ return sostate->buffer;
+ case GL_OBJECT_TYPE_FRAMEBUFFER:
+ return sostate->framebuffer;
+ case GL_OBJECT_TYPE_RENDERBUFFER:
+ return sostate->renderbuffer;
+ case GL_OBJECT_TYPE_PROGRAM:
+ return sostate->program;
+ default:
+ return NULL;
+ }
+}
+
+
GLuint
sostate_create_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint real_name)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
int i;
- switch (type)
- {
- case GL_OBJECT_TYPE_TEXTURE: object = sostate->texture; break;
- }
+ object = _get_shared_object(sostate, type);
for (i = 1; i < MAX_GL_OBJECT_SIZE; i++)
{
GLuint ret = _COREGL_INT_INIT_VALUE;
int hash = _COREGL_INT_INIT_VALUE;
- switch (type)
- {
- case GL_OBJECT_TYPE_TEXTURE: object = sostate->texture; break;
- }
+ object = _get_shared_object(sostate, type);
hash = glue_name - (int)type;
if (hash < 0 ||
free(object[hash]);
object[hash] = NULL;
+ ret = 1;
goto finish;
finish:
GLuint ret = _COREGL_INT_INIT_VALUE;
int hash = _COREGL_INT_INIT_VALUE;
- switch (type)
- {
- case GL_OBJECT_TYPE_TEXTURE: object = sostate->texture; break;
- }
+ object = _get_shared_object(sostate, type);
hash = glue_name - (int)type;
if (hash < 0 ||
GLuint ret = _COREGL_INT_INIT_VALUE;
int i;
- switch (type)
- {
- case GL_OBJECT_TYPE_TEXTURE: object = sostate->texture; break;
- }
+ object = _get_shared_object(sostate, type);
for (i = 1; i < MAX_GL_OBJECT_SIZE; i++)
{
{
static struct timeval tv_last = { 0, 0 };
- {
- char *fp_env = NULL;
- int fp_envi = 0;
- fp_env = getenv("COREGL_TRACE_STATE");
- if (fp_env) fp_envi = atoi(fp_env);
- else fp_envi = 0;
- if (fp_envi == 0) return;
- }
+ if (trace_state_flag != 1) return;
if (!force_output)
{
unsigned char flag = 0;
int i = 0;
- if (atoi(get_env_setting("COREGL_DEBUG_NOFP")) == 1) goto finish;
+ if (debug_nofp == 1) goto finish;
// Return if they're the same
if (oldctx == newctx) goto finish;
if ((memcmp((oldctx->state_ptr), (newctx->state_ptr), (bytes))) != 0)
#endif
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP glFinish)");
+ static void *trace_hint_glfinish = NULL;
+ trace_hint_glfinish = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
_sym_glFlush();
- _COREGL_TRACE_API_END("eglMakeCurrent(FP glFinish)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP bind buffers)");
+ static void *trace_hint_bindbuffers = NULL;
+ trace_hint_bindbuffers = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP bind buffers)", trace_hint_bindbuffers, 0);
//------------------//
// _bind_flag
}
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP bind buffers)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP bind buffers)", trace_hint_bindbuffers, 0);
//------------------//
// Enable States
// _enable_flag1
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP enable states)");
+ static void *trace_hint_enable_states = NULL;
+ trace_hint_enable_states = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP enable states)", trace_hint_enable_states, 0);
flag = oldctx->_enable_flag1 | newctx->_enable_flag1;
if (flag)
}
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP enable states)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP enable states)", trace_hint_enable_states, 0);
//------------------//
// _clear_flag1
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP clear/viewport)");
+ static void *trace_hint_clear_viewport = NULL;
+ trace_hint_clear_viewport = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP clear/viewport)", trace_hint_clear_viewport, 0);
flag = oldctx->_clear_flag1 | newctx->_clear_flag1;
if (flag)
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP clear/viewport)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP clear/viewport)", trace_hint_clear_viewport, 0);
//------------------//
// Texture here...
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP bind textures)");
+ static void *trace_hint_bind_textures = NULL;
+ trace_hint_bind_textures = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP bind textures)", trace_hint_bind_textures, 0);
flag = oldctx->_tex_flag1 | newctx->_tex_flag1;
if (flag)
_sym_glHint(GL_GENERATE_MIPMAP_HINT, newctx->gl_generate_mipmap_hint[0]);
}
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP bind textures)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP bind textures)", trace_hint_bind_textures, 0);
//------------------//
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP etc.)");
+ static void *trace_hint_etc = NULL;
+ trace_hint_etc = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP etc.)", trace_hint_etc, 0);
flag = oldctx->_blend_flag | newctx->_blend_flag;
if (flag)
_sym_glPixelStorei(GL_UNPACK_ALIGNMENT, newctx->gl_unpack_alignment[0]);
}
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP etc.)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP etc.)", trace_hint_etc, 0);
// _varray_flag
- _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP vertex attrib)");
+ static void *trace_hint_vertex_attrib = NULL;
+ trace_hint_vertex_attrib = _COREGL_TRACE_API_BEGIN("eglMakeCurrent(FP vertex attrib)", trace_hint_vertex_attrib, 0);
flag = oldctx->_vattrib_flag | newctx->_vattrib_flag;
if (flag)
{
}
- _COREGL_TRACE_API_END("eglMakeCurrent(FP vertex attrib)");
+ _COREGL_TRACE_API_END("eglMakeCurrent(FP vertex attrib)", trace_hint_vertex_attrib, 0);
goto finish;
finish:
#include "coregl_internal.h"
+// Symbol definition for fastpath
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (fpgl_##FUNC_NAME) PARAM_LIST;
+# include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
#define FLAG_BIT_0 0x01
#define FLAG_BIT_1 0x02
#define FLAG_BIT_2 0x04
typedef enum
{
- GL_OBJECT_TYPE_TEXTURE = 0x1000000,
+ 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
{
int ref_count;
- GL_Object *texture[MAX_GL_OBJECT_SIZE]; // Texture object : 0x10000X
+ GL_Object *texture[MAX_GL_OBJECT_SIZE];
+ GL_Object *buffer[MAX_GL_OBJECT_SIZE];
+ GL_Object *framebuffer[MAX_GL_OBJECT_SIZE];
+ GL_Object *renderbuffer[MAX_GL_OBJECT_SIZE];
+ GL_Object *program[MAX_GL_OBJECT_SIZE];
} GL_Shared_Object_State;
typedef struct _GLGlueContext
GL_Shared_Object_State *sostate;
+ GLenum gl_error;
+
// General state
#define GLUE_STATE(TYPE, NAME, SIZE, ARRAY_SIZE, DEFAULT_STMT, GET_STMT) TYPE NAME[ARRAY_SIZE];
# include "coregl_fastpath_state.h"
extern GLGlueContext *initial_ctx;
+extern int debug_nofp;
+
+extern void init_fast_gl();
+extern void free_fast_gl();
+
extern int init_context_states(GLGlueContext *ctx);
extern void make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx);
General_Trace_List *glue_ctx_trace_list = NULL;
General_Trace_List *context_state_trace_list = NULL;
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) \
- extern RET_TYPE FUNC_NAME PARAM_LIST;
-#include "headers/sym_egl.h"
-#include "headers/sym_gl.h"
-#undef _COREGL_SYMBOL
-
-
static void
_dump_context_info(const char *ment, int force_output)
{
GLThreadState *tstate = NULL;
static struct timeval tv_last = { 0, 0 };
- {
- char *fp_env = NULL;
- int fp_envi = 0;
- fp_env = getenv("COREGL_TRACE_CTX");
- if (fp_env) fp_envi = atoi(fp_env);
- else fp_envi = 0;
- if (fp_envi == 0) return;
- }
+ if (trace_ctx_flag != 1) return;
AST(mutex_lock(&ctx_list_access_mutex) == 1);
AST(mutex_lock(&general_trace_lists_access_mutex) == 1);
tstate = get_current_thread_state();
LOG("\n");
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
- LOG("\E[0;32;1m Context info \E[1;37;1m: %s\E[0m\n", ment);
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
+ LOG("\E[40;32;1m Context info \E[1;37;1m: %s\E[0m\n", ment);
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
// Thread State List
}
}
- LOG("\E[0;40;33m........................................................................................................................\E[0m\n");
+ LOG("\E[40;33m........................................................................................................................\E[0m\n");
// Not-binded Context State List
{
}
- LOG("\E[0;40;33m........................................................................................................................\E[0m\n");
+ LOG("\E[40;33m........................................................................................................................\E[0m\n");
// Not-binded Glue Context List
{
}
}
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
LOG("\n");
goto finish;
default:
ERR("Invalid context attribute.\n");
goto finish;
- }
+ }
attrib += 2;
}
ret = 1;
// Pack context option
AST(_pack_egl_context_option(real_ctx_option, dpy, config, 0, attrib_list) == 1);
- if (atoi(get_env_setting("COREGL_DEBUG_NOFP")) == 1)
+ if (debug_nofp == 1)
{
static int debug_force_real = 100001;
AST(_pack_egl_context_option(real_ctx_option, dpy, config, debug_force_real, attrib_list) == 1);
// Fastpath EGL Functions //
// The functions have prefix 'fpgl_' for (fastpath gl) //
//----------------------------------------------------------------//
+
+extern EGLBoolean (*_COREGL_NAME_MANGLE(eglBindAPI))(EGLenum api);
+extern EGLenum (*_COREGL_NAME_MANGLE(eglQueryAPI))(void);
+
+EGLBoolean
+fpgl_eglBindAPI(EGLenum api)
+{
+ EGLBoolean ret = EGL_FALSE;
+ GLThreadState *tstate = NULL;
+
+ _COREGL_FAST_FUNC_BEGIN();
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+
+ ret = _sym_eglBindAPI(api);
+
+ tstate = get_current_thread_state();
+ if (tstate == NULL)
+ {
+ AST(init_new_thread_state() == 1);
+
+ tstate = get_current_thread_state();
+ AST(tstate != NULL);
+ }
+
+ {
+ EGLenum newapi = _sym_eglQueryAPI();
+ if (tstate->binded_api != newapi)
+ {
+ if (newapi != EGL_OPENGL_ES_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;
+ }
+ else
+ {
+ override_glue_fast_path();
+ }
+ tstate->binded_api = newapi;
+ }
+ }
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+EGLenum
+fpgl_eglQueryAPI(void)
+{
+ EGLenum ret = 0;
+ GLThreadState *tstate = NULL;
+
+ _COREGL_FAST_FUNC_BEGIN();
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+
+ ret = _sym_eglQueryAPI();
+
+ tstate = get_current_thread_state();
+ if (tstate != NULL)
+ {
+ AST(tstate->binded_api == ret);
+ }
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
EGLContext
fpgl_eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
{
if (gctx->is_destroyed == 1)
{
- ERR("\E[0;31;1mWARNING : Context [%p] is already destroyed!!!\E[0m\n", ctx);
+ ERR("\E[40;31;1mWARNING : Context [%p] is already destroyed!!!\E[0m\n", ctx);
}
else
{
real_ctx = gctx->cstate->rctx;
}
+ _COREGL_FAST_FUNC_SYMCALL_BEGIN();
ret = _sym_eglQueryContext(dpy, real_ctx, attribute, value);
+ _COREGL_FAST_FUNC_SYMCALL_END();
goto finish;
finish:
}
+
EGLBoolean
-fpgl_eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
+fpgl_eglReleaseThread(void)
{
EGLBoolean ret = EGL_FALSE;
+ EGLDisplay dpy = EGL_NO_DISPLAY;
_COREGL_FAST_FUNC_BEGIN();
- // BB : NO OP
- ret = _sym_eglDestroySurface(dpy, surface);
+ dpy = _sym_eglGetCurrentDisplay();
+ AST(dpy != EGL_NO_DISPLAY);
+ fpgl_eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ ret = _sym_eglReleaseThread();
goto finish;
finish:
_bind_context_state(NULL, tstate->cstate, &ctx_list_access_mutex);
tstate->cstate = NULL;
}
- if (!_sym_eglMakeCurrent(dpy, draw, read, EGL_NO_CONTEXT))
+ if (_sym_eglMakeCurrent(dpy, draw, read, ctx) != EGL_TRUE)
{
- ERR("WARNING : Error making EGL_NO_CONTEXT current. (invalid EGL display [%p] or EGL surface [D:%p/R:%p])\n", dpy, draw, read);
+ ERR("WARNING : Error making context [%p] current. (invalid EGL display [%p] or EGL surface [D:%p/R:%p])\n", ctx, dpy, draw, read);
ret = EGL_FALSE;
goto finish;
}
_bind_context_state(gctx, cstate_new, &ctx_list_access_mutex);
// TODO : Setup context state for new real ctx
- ERR("\E[0;31;1mWARNING : Cross-thread usage(makecurrent) can cause a state-broken situation!\E[0m\n");
+ ERR("\E[40;31;1mWARNING : Cross-thread usage(makecurrent) can cause a state-broken situation!\E[0m\n");
_unlink_context_state(gctx, &ctx_list_access_mutex);
_link_context_state(gctx, cstate_new);
if (need_mc == EGL_TRUE)
{
// BB : full makecurrent
- if (!_sym_eglMakeCurrent(dpy, draw, read, gctx->cstate->rctx))
+ if (_sym_eglMakeCurrent(dpy, draw, read, gctx->cstate->rctx) != EGL_TRUE)
{
ERR("Error making context current with the drawable.\n");
ret = EGL_FALSE;
case EGL_READ :
ret = (GLGlueContext *)tstate->rsurf_read;
break;
- }
+ }
}
goto finish;
fpgl_eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
{
void *ret = NULL;
- GLThreadState *tstate = NULL;
EGLContext real_ctx = EGL_NO_CONTEXT;
_COREGL_FAST_FUNC_BEGIN();
- tstate = get_current_thread_state();
-
if (ctx != NULL && ctx != EGL_NO_CONTEXT)
{
GLGlueContext *gctx = (GLGlueContext *)ctx;
- AST(gctx->cstate != NULL);
- real_ctx = gctx->cstate->rctx;
+ if (gctx->magic != MAGIC_GLFAST)
+ {
+ real_ctx = ctx;
+ }
+ else
+ {
+ AST(gctx->cstate != NULL);
+ real_ctx = gctx->cstate->rctx;
+ }
}
ret = _sym_eglCreateImageKHR(dpy, real_ctx, target, buffer, attrib_list);
ret = _sym_eglGetProcAddress(procname);
if (ret != NULL)
{
- LOG("\E[0;31;1mWARNING : COREGL can't support '%s' (unmanaged situation may occur)\E[0m\n", procname);
+ LOG("\E[40;31;1mWARNING : COREGL can't support '%s' (unmanaged situation may occur)\E[0m\n", procname);
}
goto finish;
current_ctx = (GLGlueContext *)tstate->cstate->data; \
AST(current_ctx != NULL);
+#define GET_REAL_OBJ(type, glue_handle, real_handle) \
+ _get_real_obj(current_ctx->sostate, type, glue_handle, real_handle)
+
+static inline int
+_get_real_obj(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_handle, GLuint *real_handle)
+{
+ if (glue_handle == 0)
+ {
+ *real_handle = 0;
+ }
+ else
+ {
+ AST(sostate != NULL);
+ *real_handle = sostate_get_object(sostate, type, glue_handle);
+ if (*real_handle == 0)
+ return 0;
+ }
+ return 1;
+}
+
+static void
+_set_gl_error(GLenum error)
+{
+ GLenum glerror = GL_NONE;
+ DEFINE_FAST_GL_FUNC();
+ INIT_FAST_GL_FUNC();
+
+ glerror = _sym_glGetError();
+
+ if (current_ctx->gl_error == GL_NO_ERROR &&
+ glerror == GL_NO_ERROR &&
+ error != GL_NO_ERROR)
+ {
+ current_ctx->gl_error = error;
+ }
+}
+
+GLenum
+fpgl_glGetError(void)
+{
+ GLenum ret = GL_NONE;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (current_ctx->gl_error != GL_NO_ERROR)
+ {
+ ret = current_ctx->gl_error;
+ }
+ else
+ {
+ ret = _sym_glGetError();
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+////////////////////////////////////////////////////////////////////////
+
+void
+fpgl_glActiveTexture(GLenum texture)
+{
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ CURR_STATE_COMPARE(gl_active_texture, texture)
+ {
+ _sym_glActiveTexture(texture);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ current_ctx->_tex_flag1 |= FLAG_BIT_1;
+ current_ctx->gl_active_texture[0] = texture;
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glGenTextures(GLsizei n, GLuint* textures)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (textures == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+
+ _sym_glGenTextures(n, objid_array);
+
+ for (i = 0; i < n; i++)
+ {
+ textures[i] = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, objid_array[i]);
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glBindTexture(GLenum target, GLuint texture)
+{
+ int active_idx;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ active_idx = current_ctx->gl_active_texture[0] - GL_TEXTURE0;
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_TEXTURE, texture, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ if (target == GL_TEXTURE_2D)
+ {
+ if (current_ctx->gl_tex_2d_state[active_idx] != real_obj)
+ {
+ _sym_glBindTexture(target, real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ current_ctx->_tex_flag1 |= FLAG_BIT_3;
+
+ current_ctx->gl_tex_2d_state[active_idx] = real_obj;
+ }
+ }
+ else if (target == GL_TEXTURE_CUBE_MAP)
+ {
+ if (current_ctx->gl_tex_cube_state[active_idx] != real_obj)
+ {
+ _sym_glBindTexture(target, real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ current_ctx->_tex_flag1 |= FLAG_BIT_4;
+
+ current_ctx->gl_tex_cube_state[active_idx] = real_obj;
+ }
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_TEXTURE, texture, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ _sym_glFramebufferTexture2D(target, attachment, textarget, real_obj, level);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_TEXTURE, texture, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ _sym_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, real_obj, level, samples);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+GLboolean
+fpgl_glIsTexture(GLuint texture)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_TEXTURE, texture, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsTexture(real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+
+void
+fpgl_glDeleteTextures(GLsizei n, const GLuint* textures)
+{
+ int i, j;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (textures == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+ {
+ int real_n = 0;
+
+ for (i = 0; i < n; i++)
+ {
+ int real_objid = _COREGL_INT_INIT_VALUE;
+ if (textures[i] == 0) continue;
+
+ real_objid = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
+ if (real_objid == 0) continue;
+
+ sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
+ objid_array[real_n++] = real_objid;
+ }
+
+ _sym_glDeleteTextures(real_n, objid_array);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ for (i = 0; i < real_n; i++)
+ {
+ for (j = 0; j < current_ctx->gl_num_tex_units[0]; j++)
+ {
+ if (current_ctx->gl_tex_2d_state[j] == objid_array[i])
+ current_ctx->gl_tex_2d_state[j] = 0;
+ if (current_ctx->gl_tex_cube_state[j] == objid_array[i])
+ current_ctx->gl_tex_cube_state[j] = 0;
+ }
+ }
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+void
+fpgl_glGenBuffers(GLsizei n, GLuint* buffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (buffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+
+ _sym_glGenBuffers(n, objid_array);
+
+ for (i = 0; i < n; i++)
+ {
+ buffers[i] = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, objid_array[i]);
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glBindBuffer(GLenum target, GLuint buffer)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_BUFFER, buffer, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ if (target == GL_ARRAY_BUFFER)
+ {
+ CURR_STATE_COMPARE(gl_array_buffer_binding, real_obj)
+ {
+ _sym_glBindBuffer(target, real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_0);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_0;
+ current_ctx->gl_array_buffer_binding[0] = real_obj;
+ }
+ }
+ else if (target == GL_ELEMENT_ARRAY_BUFFER)
+ {
+ CURR_STATE_COMPARE(gl_element_array_buffer_binding, real_obj)
+ {
+ _sym_glBindBuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_1);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_1;
+ current_ctx->gl_element_array_buffer_binding[0] = real_obj;
+ }
+ }
+ else
+ {
+ // For error recording
+ _sym_glBindBuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+GLboolean
+fpgl_glIsBuffer(GLuint buffer)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_BUFFER, buffer, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsBuffer(real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+
+void
+fpgl_glDeleteBuffers(GLsizei n, const GLuint* buffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (buffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+ {
+ int real_n = 0;
+
+ for (i = 0; i < n; i++)
+ {
+ int real_objid = _COREGL_INT_INIT_VALUE;
+ if (buffers[i] == 0) continue;
+
+ real_objid = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, buffers[i]);
+ if (real_objid == 0) continue;
+
+ sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, buffers[i]);
+ objid_array[real_n++] = real_objid;
+ }
+
+ _sym_glDeleteBuffers(real_n, objid_array);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ for (i = 0; i < real_n; i++)
+ {
+ if (current_ctx->gl_array_buffer_binding[0] == objid_array[i])
+ {
+ current_ctx->_bind_flag &= (~FLAG_BIT_0);
+ current_ctx->gl_array_buffer_binding[0] = 0;
+ }
+ if (current_ctx->gl_element_array_buffer_binding[0] == objid_array[i])
+ {
+ current_ctx->_bind_flag &= (~FLAG_BIT_1);
+ current_ctx->gl_element_array_buffer_binding[0] = 0;
+ }
+ }
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+
+void
+fpgl_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (framebuffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+
+ _sym_glGenFramebuffers(n, objid_array);
+
+ for (i = 0; i < n; i++)
+ {
+ framebuffers[i] = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_FRAMEBUFFER, framebuffer, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ if (target == GL_FRAMEBUFFER)
+ {
+ CURR_STATE_COMPARE(gl_framebuffer_binding, real_obj)
+ {
+ _sym_glBindFramebuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_2);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_2;
+ current_ctx->gl_framebuffer_binding[0] = real_obj;
+ }
+ }
+ else
+ {
+ // For error recording
+ _sym_glBindFramebuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+GLboolean
+fpgl_glIsFramebuffer(GLuint framebuffer)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_FRAMEBUFFER, framebuffer, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsFramebuffer(real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+
+void
+fpgl_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (framebuffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+ {
+ int real_n = 0;
+
+ for (i = 0; i < n; i++)
+ {
+ int real_objid = _COREGL_INT_INIT_VALUE;
+ if (framebuffers[i] == 0) continue;
+
+ real_objid = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
+ if (real_objid == 0) continue;
+
+ sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
+ objid_array[real_n++] = real_objid;
+ }
+
+ _sym_glDeleteFramebuffers(real_n, objid_array);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ for (i = 0; i < real_n; i++)
+ {
+ if (current_ctx->gl_framebuffer_binding[0] == framebuffers[i])
+ {
+ current_ctx->_bind_flag &= (~FLAG_BIT_2);
+ current_ctx->gl_framebuffer_binding[0] = 0;
+ }
+ }
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+
+void
+fpgl_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (renderbuffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+
+ _sym_glGenRenderbuffers(n, objid_array);
+
+ for (i = 0; i < n; i++)
+ {
+ renderbuffers[i] = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+
+void
+fpgl_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_RENDERBUFFER, renderbuffer, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ if (target == GL_RENDERBUFFER)
+ {
+ CURR_STATE_COMPARE(gl_renderbuffer_binding, real_obj)
+ {
+ _sym_glBindRenderbuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_3);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_3;
+ current_ctx->gl_renderbuffer_binding[0] = real_obj;
+ }
+ }
+ else
+ {
+ // For error recording
+ _sym_glBindRenderbuffer(target, real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_RENDERBUFFER, renderbuffer, &real_obj) != 1)
+ {
+ _set_gl_error(GL_OUT_OF_MEMORY);
+ goto finish;
+ }
+
+ _sym_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+GLboolean
+fpgl_glIsRenderbuffer(GLuint renderbuffer)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_RENDERBUFFER, renderbuffer, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsRenderbuffer(real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+
+void
+fpgl_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (renderbuffers == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+ {
+ int real_n = 0;
+
+ for (i = 0; i < n; i++)
+ {
+ int real_objid = _COREGL_INT_INIT_VALUE;
+ if (renderbuffers[i] == 0) continue;
+
+ real_objid = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
+ if (real_objid == 0) continue;
+
+ sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
+ objid_array[real_n++] = real_objid;
+ }
+
+ _sym_glDeleteRenderbuffers(real_n, objid_array);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ for (i = 0; i < real_n; i++)
+ {
+ if (current_ctx->gl_renderbuffer_binding[0] == renderbuffers[i])
+ {
+ current_ctx->_bind_flag &= (~FLAG_BIT_3);
+ current_ctx->gl_renderbuffer_binding[0] = 0;
+ }
+ }
+ }
+
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+ _COREGL_FAST_FUNC_END();
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+
+GLuint
+fpgl_glCreateProgram(void)
+{
+ GLuint ret = _COREGL_INT_INIT_VALUE;
+ GLuint real_obj = _COREGL_INT_INIT_VALUE;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ AST(current_ctx->sostate != NULL);
+
+ real_obj = _sym_glCreateProgram();
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ ret = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, real_obj);
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+GLuint
+fpgl_glCreateShader(GLenum type)
+{
+ GLuint ret = _COREGL_INT_INIT_VALUE;
+ GLuint real_obj = _COREGL_INT_INIT_VALUE;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ AST(current_ctx->sostate != NULL);
+
+ real_obj = _sym_glCreateShader(type);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ ret = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, real_obj);
+
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+void
+fpgl_glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ _sym_glShaderSource(real_obj, count, string, length);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
+{
+ int i;
+ GLuint *objid_array = NULL;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (shaders == NULL) goto finish;
+
+ AST(current_ctx->sostate != NULL);
+
+ objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+
+ for (i = 0; i < n; i++)
+ {
+ if (shaders[i] == 0) continue;
+ objid_array[i] = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shaders[i]);
+ }
+
+#ifndef _COREGL_DESKTOP_GL
+ _sym_glShaderBinary(n, objid_array, binaryformat, binary, length);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+#else
+// FIXME: need to dlsym/getprocaddress for this
+ /*
+ n = binaryformat = length = 0;
+ shaders = binary = 0;
+ */
+#endif
+ goto finish;
+
+finish:
+ if (objid_array != NULL)
+ {
+ free(objid_array);
+ objid_array = NULL;
+ }
+
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glCompileShader(GLuint shader)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glCompileShader(real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glBindAttribLocation(GLuint program, GLuint index, const char* name)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glBindAttribLocation(real_obj, index, name);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glAttachShader(GLuint program, GLuint shader)
+{
+ GLuint real_obj_program;
+ GLuint real_obj_shader;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj_program) != 1 ||
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glAttachShader(real_obj_program, real_obj_shader);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glDetachShader(GLuint program, GLuint shader)
+{
+ GLuint real_obj_program;
+ GLuint real_obj_shader;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj_program) != 1 ||
+ GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj_shader) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glDetachShader(real_obj_program, real_obj_shader);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+GLboolean
+fpgl_glIsShader(GLuint shader)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsShader(real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+GLboolean
+fpgl_glIsProgram(GLuint program)
+{
+ GLboolean ret;
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ ret = GL_FALSE;
+ goto finish;
+ }
+
+ ret = _sym_glIsProgram(real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+ return ret;
+}
+
+void
+fpgl_glLinkProgram(GLuint program)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glLinkProgram(real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glValidateProgram(GLuint program)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glValidateProgram(real_obj);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glUseProgram(GLuint program)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ CURR_STATE_COMPARE(gl_current_program, real_obj)
+ {
+ _sym_glUseProgram(real_obj);
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
+ current_ctx->_clear_flag1 |= FLAG_BIT_1;
+ current_ctx->gl_current_program[0] = real_obj;
+ }
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glGetActiveAttrib(real_obj, index, bufsize, length, size, type, name);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
+
+void
+fpgl_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+{
+ GLuint real_obj;
+
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
+
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+
+ _sym_glGetActiveUniform(real_obj, index, bufsize, length, size, type, name);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_FAST_FUNC_END();
+}
void
-fpgl_glActiveTexture(GLenum texture)
+fpgl_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
+ int i;
+ GLsizei real_count = _COREGL_INT_INIT_VALUE;
+ GLuint real_obj;
+
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- CURR_STATE_COMPARE(gl_active_texture, texture)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- _sym_glActiveTexture(texture);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ _sym_glGetAttachedShaders(real_obj, maxcount, &real_count, shaders);
- current_ctx->_tex_flag1 |= FLAG_BIT_1;
- current_ctx->gl_active_texture[0] = texture;
+ for (i = 0; i < real_count; i++)
+ {
+ if (shaders[i] != 0)
+ shaders[i] = sostate_find_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shaders[i]);
}
+ if (count != NULL) *count = real_count;
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
-void
-fpgl_glBindBuffer(GLenum target, GLuint buffer)
+int
+fpgl_glGetAttribLocation(GLuint program, const char* name)
{
+ int ret = _COREGL_INT_INIT_VALUE;
+ GLuint real_obj;
+
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
-
- if (target == GL_ARRAY_BUFFER)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- CURR_STATE_COMPARE(gl_array_buffer_binding, buffer)
- {
- _sym_glBindBuffer(target, buffer);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- if (buffer == 0)
- current_ctx->_bind_flag &= (~FLAG_BIT_0);
- else
- current_ctx->_bind_flag |= FLAG_BIT_0;
- current_ctx->gl_array_buffer_binding[0] = buffer;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- else if (target == GL_ELEMENT_ARRAY_BUFFER)
- {
- CURR_STATE_COMPARE(gl_element_array_buffer_binding, buffer)
- {
- _sym_glBindBuffer(target, buffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
- if (buffer == 0)
- current_ctx->_bind_flag &= (~FLAG_BIT_1);
- else
- current_ctx->_bind_flag |= FLAG_BIT_1;
- current_ctx->gl_element_array_buffer_binding[0] = buffer;
- }
- }
- else
- {
- // For error recording
- _sym_glBindBuffer(target, buffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
- }
+ ret = _sym_glGetAttribLocation(real_obj, name);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
+ return ret;
}
-
void
-fpgl_glBindFramebuffer(GLenum target, GLuint framebuffer)
+fpgl_glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
+ GLuint real_obj;
+
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (target == GL_FRAMEBUFFER)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
{
- CURR_STATE_COMPARE(gl_framebuffer_binding, framebuffer)
- {
- _sym_glBindFramebuffer(target, framebuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- if (framebuffer == 0)
- current_ctx->_bind_flag &= (~FLAG_BIT_2);
- else
- current_ctx->_bind_flag |= FLAG_BIT_2;
- current_ctx->gl_framebuffer_binding[0] = framebuffer;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- else
- {
- // For error recording
- _sym_glBindFramebuffer(target, framebuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
- }
+ _sym_glGetShaderiv(real_obj, pname, params);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
void
-fpgl_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+fpgl_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
{
+ GLuint real_obj;
+
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (target == GL_RENDERBUFFER)
- {
- CURR_STATE_COMPARE(gl_renderbuffer_binding, renderbuffer)
- {
- _sym_glBindRenderbuffer(target, renderbuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- if (renderbuffer == 0)
- current_ctx->_bind_flag &= (~FLAG_BIT_3);
- else
- current_ctx->_bind_flag |= FLAG_BIT_3;
- current_ctx->gl_renderbuffer_binding[0] = renderbuffer;
- }
- }
- else
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
{
- // For error recording
- _sym_glBindRenderbuffer(target, renderbuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
+
+ _sym_glGetShaderInfoLog(real_obj, bufsize, length, infolog);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
}
void
-fpgl_glGenTextures(GLsizei n, GLuint* textures)
+fpgl_glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
- int i;
- GLuint *texid_array = NULL;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (textures == NULL) goto finish;
-
- AST(current_ctx->sostate != NULL);
-
- texid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
-
- _sym_glGenTextures(n, texid_array);
-
- for (i = 0; i < n; i++)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- textures[i] = sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, texid_array[i]);
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- free(texid_array);
-
+ _sym_glGetProgramiv(real_obj, pname, params);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
void
-fpgl_glBindTexture(GLenum target, GLuint texture)
+fpgl_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
{
- int active_idx;
- GLuint real_texobj;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- active_idx = current_ctx->gl_active_texture[0] - GL_TEXTURE0;
-
- if (texture == 0)
- {
- real_texobj = 0;
- }
- else
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- AST(current_ctx->sostate != NULL);
- real_texobj = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, texture);
- if (real_texobj == 0)
- {
- // GLERROR : OUT_OF_MEMORY
- LOG("\E[0;31;1mWARNING : Try binding invalid texture object\E[0m\n");
- goto finish;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- if (target == GL_TEXTURE_2D)
- {
- if (current_ctx->gl_tex_2d_state[active_idx] != real_texobj)
- {
- _sym_glBindTexture(target, real_texobj);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_tex_flag1 |= FLAG_BIT_3;
+ _sym_glGetProgramInfoLog(real_obj, bufsize, length, infolog);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
- current_ctx->gl_tex_2d_state[active_idx] = real_texobj;
- }
- }
- else if (target == GL_TEXTURE_CUBE_MAP)
- {
- if (current_ctx->gl_tex_cube_state[active_idx] != real_texobj)
- {
- _sym_glBindTexture(target, real_texobj);
+finish:
+ _COREGL_FAST_FUNC_END();
+}
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+void
+fpgl_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+{
+ GLuint real_obj;
- current_ctx->_tex_flag1 |= FLAG_BIT_4;
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
- current_ctx->gl_tex_cube_state[active_idx] = real_texobj;
- }
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
+
+ _sym_glGetShaderSource(real_obj, bufsize, length, source);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
void
-fpgl_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+fpgl_glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
- GLuint real_texobj;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (texture == 0)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- real_texobj = 0;
- }
- else
- {
- AST(current_ctx->sostate != NULL);
- real_texobj = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, texture);
- if (real_texobj == 0)
- {
- // GLERROR : OUT_OF_MEMORY
- LOG("\E[0;31;1mWARNING : Try using invalid texture object\E[0m\n");
- goto finish;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- _sym_glFramebufferTexture2D(target, attachment, textarget, real_texobj, level);
-
+ _sym_glGetUniformfv(real_obj, location, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
}
void
-fpgl_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
+fpgl_glGetUniformiv(GLuint program, GLint location, GLint* params)
{
- GLuint real_texobj;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (texture == 0)
- {
- real_texobj = 0;
- }
- else
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- AST(current_ctx->sostate != NULL);
- real_texobj = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, texture);
- if (real_texobj == 0)
- {
- // GLERROR : OUT_OF_MEMORY
- LOG("\E[0;31;1mWARNING : Try using invalid texture object\E[0m\n");
- goto finish;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- _sym_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, real_texobj, level, samples);
-
+ _sym_glGetUniformiv(real_obj, location, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
_COREGL_FAST_FUNC_END();
}
-GLboolean
-fpgl_glIsTexture(GLuint texture)
+void
+fpgl_glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
{
- GLboolean ret;
- GLuint real_texobj;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (texture == 0)
- {
- real_texobj = 0;
- }
- else
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- AST(current_ctx->sostate != NULL);
- real_texobj = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, texture);
- if (real_texobj == 0)
- {
- ret = GL_FALSE;
- goto finish;
- }
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
}
- ret = _sym_glIsTexture(real_texobj);
-
+ _sym_glGetProgramBinary(real_obj, bufsize, length, binaryFormat, binary);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
_COREGL_FAST_FUNC_END();
- return ret;
}
-
void
-fpgl_glDeleteTextures(GLsizei n, const GLuint* textures)
+fpgl_glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
{
- int i, j;
- GLuint *texid_array = NULL;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- if (textures == NULL) goto finish;
-
- AST(current_ctx->sostate != NULL);
-
- texid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- int real_n = 0;
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
- for (i = 0; i < n; i++)
- {
- int real_texid = _COREGL_INT_INIT_VALUE;
- if (textures[i] == 0) continue;
+ _sym_glProgramBinary(real_obj, binaryFormat, binary, length);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
- real_texid = sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
- if (real_texid == 0) continue;
+finish:
+ _COREGL_FAST_FUNC_END();
+}
- sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
- texid_array[real_n++] = real_texid;
- }
- _sym_glDeleteTextures(real_n, texid_array);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+void
+fpgl_glProgramParameteri(GLuint program, GLuint pname, GLint value)
+{
+ GLuint real_obj;
- for (i = 0; i < real_n; i++)
- {
- for (j = 0; j < current_ctx->gl_num_tex_units[0]; j++)
- {
- if (current_ctx->gl_tex_2d_state[j] == texid_array[i])
- current_ctx->gl_tex_2d_state[j] = 0;
- if (current_ctx->gl_tex_cube_state[j] == texid_array[i])
- current_ctx->gl_tex_cube_state[j] = 0;
- }
- }
- }
+ DEFINE_FAST_GL_FUNC();
+ _COREGL_FAST_FUNC_BEGIN();
+ INIT_FAST_GL_FUNC();
- free(texid_array);
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ _sym_glProgramParameteri(real_obj, pname, value);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-void
-fpgl_glDeleteBuffers(GLsizei n, const GLuint* buffers)
+int
+fpgl_glGetUniformLocation(GLuint program, const char* name)
{
- int i;
+ int ret = _COREGL_INT_INIT_VALUE;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- _sym_glDeleteBuffers(n, buffers);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- for (i = 0; i < n; i++)
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
{
- if (current_ctx->gl_array_buffer_binding[0] == buffers[i])
- current_ctx->gl_array_buffer_binding[0] = 0;
- if (current_ctx->gl_element_array_buffer_binding[0] == buffers[i])
- current_ctx->gl_element_array_buffer_binding[0] = 0;
+ _set_gl_error(GL_INVALID_VALUE);
+ ret = -1;
+ goto finish;
}
+
+ ret = _sym_glGetUniformLocation(real_obj, name);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
+ return ret;
}
-
void
-fpgl_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+fpgl_glDeleteShader(GLuint shader)
{
- int i;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- _sym_glDeleteFramebuffers(n, framebuffers);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, shader, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
- for (i = 0; i < n; i++)
+ _sym_glDeleteShader(real_obj);
+ if (real_obj != 0)
{
- if (current_ctx->gl_framebuffer_binding[0] == framebuffers[i])
- current_ctx->gl_framebuffer_binding[0] = 0;
+ AST(sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shader) == 1);
}
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
void
-fpgl_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+fpgl_glDeleteProgram(GLuint program)
{
- int i;
+ GLuint real_obj;
DEFINE_FAST_GL_FUNC();
_COREGL_FAST_FUNC_BEGIN();
INIT_FAST_GL_FUNC();
- _sym_glDeleteRenderbuffers(n, renderbuffers);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ if (GET_REAL_OBJ(GL_OBJECT_TYPE_PROGRAM, program, &real_obj) != 1)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
- for (i = 0; i < n; i++)
+ _sym_glDeleteProgram(real_obj);
+ if (real_obj != 0)
{
- if (current_ctx->gl_renderbuffer_binding[0] == renderbuffers[i])
- current_ctx->gl_renderbuffer_binding[0] = 0;
+ AST(sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, program) == 1);
}
+
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
}
+
+//////////////////////////////////////////////////////////////////////////////////
+
void
fpgl_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
current_ctx->gl_stencil_test[0] = GL_FALSE;
}
break;
- }
+ }
goto finish;
finish:
current_ctx->gl_stencil_test[0] = GL_TRUE;
}
break;
- }
+ }
goto finish;
finish:
_COREGL_FAST_FUNC_END();
}
-
-void
-fpgl_glUseProgram(GLuint program)
-{
- DEFINE_FAST_GL_FUNC();
- _COREGL_FAST_FUNC_BEGIN();
- INIT_FAST_GL_FUNC();
-
- CURR_STATE_COMPARE(gl_current_program, program)
- {
- _sym_glUseProgram(program);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag1 |= FLAG_BIT_1;
- current_ctx->gl_current_program[0] = program;
- }
- goto finish;
-
-finish:
- _COREGL_FAST_FUNC_END();
-}
-
-
// Optmize?
void
fpgl_glVertexAttrib1f(GLuint indx, GLfloat x)
case GL_TEXTURE_CUBE_MAP:
current_ctx->gl_tex_cube_state[tex_idx] = -1;
break;
- }
+ }
_sym_glEGLImageTargetTexture2DOES(target, image);
switch (get_type)
{
- case GL_INT: ((GLint *)ptr)[0] = glue_tex_id; break;
- case GL_FLOAT: ((GLfloat *)ptr)[0] = (GLfloat)glue_tex_id; break;
- case GL_BOOL: ((GLboolean *)ptr)[0] = (glue_tex_id == 0) ? GL_FALSE : GL_TRUE; break;
+ case GL_INT:
+ ((GLint *)ptr)[0] = glue_tex_id;
+ break;
+ case GL_FLOAT:
+ ((GLfloat *)ptr)[0] = (GLfloat)glue_tex_id;
+ break;
+ case GL_BOOL:
+ ((GLboolean *)ptr)[0] = (glue_tex_id == 0) ? GL_FALSE : GL_TRUE;
+ break;
}
ret = GL_TRUE;
break;
goto finish;
finish:
- _COREGL_WRAP_FUNC_END();
+ _COREGL_FAST_FUNC_END();
}
void
goto finish;
finish:
- _COREGL_WRAP_FUNC_END();
+ _COREGL_FAST_FUNC_END();
}
void
goto finish;
finish:
- _COREGL_WRAP_FUNC_END();
+ _COREGL_FAST_FUNC_END();
}
#include "coregl.h"
+// Symbol definition for real
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_sym_##FUNC_NAME) PARAM_LIST;
+# include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
#define COREGL_DEBUG
# define ERR(...) \
#define _COREGL_TRACE_OUTPUT_INTERVAL_SEC 5
-// Symbol definition for static
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_sym_##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 (evgl_##FUNC_NAME) PARAM_LIST;
-# include "headers/sym.h"
-#undef _COREGL_SYMBOL
-
-// Symbol definition for fastpath
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (fpgl_##FUNC_NAME) PARAM_LIST;
-# include "headers/sym.h"
-#undef _COREGL_SYMBOL
-
#define _COREGL_INT_INIT_VALUE -3
-
#ifdef COREGL_ERRORS
# define GLERR(fn, fl, ln, op)
#else
# 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
-# define _COREGL_TRACE_API_BEGIN(api) \
- trace_begin(api);
-# define _COREGL_TRACE_API_END(api) \
- trace_end(api);
+# define _COREGL_TRACE_API_BEGIN(api, hint, trace_total_time) \
+ trace_begin(api, hint, trace_total_time);
+# define _COREGL_TRACE_API_END(api, hint, trace_total_time) \
+ trace_end(api, hint, trace_total_time);
# define _COREGL_TRACE_API_OUTPUT(force_output) \
trace_output(force_output);
#else
-# define _COREGL_TRACE_API_BEGIN(api)
-# define _COREGL_TRACE_API_END(api)
+# define _COREGL_TRACE_API_BEGIN(api, trace_total_time)
+# define _COREGL_TRACE_API_END(api, trace_total_time)
# define _COREGL_TRACE_API_OUTPUT(force_output)
#endif
#define _COREGL_FAST_FUNC_END()
+#define _COREGL_FAST_FUNC_SYMCALL_BEGIN()
+
+#define _COREGL_FAST_FUNC_SYMCALL_END()
+
#define _COREGL_WRAP_FUNC_BEGIN() \
- _COREGL_TRACE_API_BEGIN(__func__);
+ static void *trace_hint = NULL; \
+ trace_hint = _COREGL_TRACE_API_BEGIN(__func__, trace_hint, 1);
#define _COREGL_WRAP_FUNC_END() \
- _COREGL_TRACE_API_END(__func__);
+ _COREGL_TRACE_API_END(__func__, trace_hint, 1);
typedef enum _CoreGL_Opt_Flag
{
+ COREGL_UNKNOWN_PATH,
COREGL_NORMAL_PATH,
- GL_WRAPPED_PATH,
COREGL_FAST_PATH
} CoreGL_Opt_Flag;
+extern CoreGL_Opt_Flag api_opt;
#ifndef _COREGL_DESKTOP_GL
typedef EGLSurface GLSurface;
typedef struct _GLThreadState
{
int thread_id;
+ EGLenum binded_api;
GLContextState *cstate;
GLSurface *rsurf_draw;
GLSurface *rsurf_read;
extern General_Trace_List *thread_trace_list;
extern Mutex general_trace_lists_access_mutex;
-extern int trace_api_flag;
+extern int trace_api_flag;
+extern int trace_ctx_flag;
+extern int trace_state_flag;
+extern int debug_nofp;
// Environment functions
-extern const char *get_env_setting(const char *name);
+extern const char *get_env_setting(const char *name);
// Main utility functions
extern int init_new_thread_state();
// Debug & Trace functions
extern int add_to_general_trace_list(General_Trace_List **gtl, void *value);
extern int remove_from_general_trace_list(General_Trace_List **gtl, void *value);
-extern void trace_begin(const char *name);
-extern void trace_end(const char *name);
+extern void *trace_begin(const char *name, void *hint, int trace_total_time);
+extern void *trace_end(const char *name, void *hint, int trace_total_time);
extern void trace_output(int force_output);
#endif // COREGL_INTERNAL_H
#include "coregl_internal.h"
+#include "coregl_wrappath.h"
+#include "coregl_fastpath.h"
#include <stdlib.h>
-#define COREGL_API_OVERRIDE(func, prefix) \
+#define COREGL_OVERRIDE_API(func, prefix) \
_COREGL_NAME_MANGLE(func) = prefix##func
void
override_glue_normal_path()
{
-#define N_ORD(f) COREGL_API_OVERRIDE(f, _sym_) // GL Normal Path
+#define N_ORD(f) COREGL_OVERRIDE_API(f, _sym_) // GL Normal Path
#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) N_ORD(FUNC_NAME);
# ifndef _COREGL_DESKTOP_GL
// Inherit from normal path
override_glue_normal_path();
-#define F_ORD(f) COREGL_API_OVERRIDE(f, fpgl_) // GL Fast Path
+#define F_ORD(f) COREGL_OVERRIDE_API(f, fpgl_) // GL Fast Path
#ifndef _COREGL_DESKTOP_GL
// Fast-Path Core Functions
F_ORD(eglGetProcAddress);
+ F_ORD(eglBindAPI);
+ F_ORD(eglQueryAPI);
+
F_ORD(eglCreateContext);
F_ORD(eglCreateImageKHR);
F_ORD(eglMakeCurrent);
F_ORD(eglDestroyContext);
F_ORD(eglQueryContext);
F_ORD(eglGetCurrentContext);
-
- if (atoi(get_env_setting("COREGL_DEBUG_NOFP")) != 1)
- {
- F_ORD(eglGetCurrentSurface);
- F_ORD(eglDestroySurface);
- }
- else
- {
- LOG("\E[0;35;1m[CoreGL] SKIP GLUE FASTPATH...\E[0m\n");
- }
+ F_ORD(eglReleaseThread);
+ F_ORD(eglGetCurrentSurface);
#else
- // Fastpath-ed Functions
- F_ORD(glXCreateContext);
- F_ORD(glXDestroyContext);
- F_ORD(glXMakeCurrent);
- F_ORD(glXGetCurrentContext);
- F_ORD(glXGetCurrentDrawable);
-
- F_ORD(glXMakeContextCurrent);
+ // Fastpath-ed Functions
+ F_ORD(glXCreateContext);
+ F_ORD(glXDestroyContext);
+ F_ORD(glXMakeCurrent);
+ F_ORD(glXGetCurrentContext);
+ F_ORD(glXGetCurrentDrawable);
+
+ F_ORD(glXMakeContextCurrent);
#endif
#undef F_ORD
void
override_gl_normal_path()
{
-#define N_ORD(f) COREGL_API_OVERRIDE(f, _sym_) // GL Normal Path
+#define N_ORD(f) COREGL_OVERRIDE_API(f, _sym_) // GL Normal Path
#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) N_ORD(FUNC_NAME);
# include "headers/sym_gl.h"
// Inherit from normal path
override_gl_normal_path();
-#define F_ORD(f) COREGL_API_OVERRIDE(f, fpgl_) // GL Wrapped Path
+#define F_ORD(f) COREGL_OVERRIDE_API(f, fpgl_) // GL Wrapped Path
// Fast-Path Functions
- if (atoi(get_env_setting("COREGL_DEBUG_NOFP")) != 1)
+ if (debug_nofp != 1)
{
- F_ORD(glActiveTexture);
- F_ORD(glBindBuffer);
- F_ORD(glDeleteBuffers);
+ F_ORD(glGetError);
+ F_ORD(glActiveTexture);
F_ORD(glGenTextures);
F_ORD(glBindTexture);
F_ORD(glIsTexture);
F_ORD(glFramebufferTexture2D);
F_ORD(glDeleteTextures);
+ F_ORD(glGenBuffers);
+ F_ORD(glBindBuffer);
+ F_ORD(glIsBuffer);
+ F_ORD(glDeleteBuffers);
+
+ F_ORD(glGenFramebuffers);
F_ORD(glBindFramebuffer);
+ F_ORD(glIsFramebuffer);
F_ORD(glDeleteFramebuffers);
+
+ F_ORD(glGenRenderbuffers);
F_ORD(glBindRenderbuffer);
+ F_ORD(glFramebufferRenderbuffer);
+ F_ORD(glIsRenderbuffer);
F_ORD(glDeleteRenderbuffers);
+
+ F_ORD(glCreateShader);
+ F_ORD(glCreateProgram);
+ F_ORD(glAttachShader);
+ F_ORD(glCompileShader);
+ F_ORD(glShaderBinary);
+ F_ORD(glDeleteShader);
+ F_ORD(glDetachShader);
+ F_ORD(glGetShaderiv);
+ F_ORD(glGetShaderInfoLog);
+ F_ORD(glGetShaderSource);
+ F_ORD(glIsShader);
+ F_ORD(glShaderSource);
+ F_ORD(glBindAttribLocation);
+ F_ORD(glDeleteProgram);
+ F_ORD(glDetachShader);
+ F_ORD(glGetActiveAttrib);
+ F_ORD(glGetActiveUniform);
+ F_ORD(glGetAttachedShaders);
+ F_ORD(glGetAttribLocation);
+ F_ORD(glGetProgramiv);
+ F_ORD(glGetProgramInfoLog);
+ F_ORD(glGetUniformfv);
+ F_ORD(glGetUniformiv);
+ F_ORD(glGetUniformLocation);
+ F_ORD(glIsProgram);
+ F_ORD(glLinkProgram);
+ F_ORD(glUseProgram);
+ F_ORD(glValidateProgram);
+ F_ORD(glGetProgramBinary);
+ F_ORD(glProgramBinary);
+
F_ORD(glBlendColor);
F_ORD(glBlendEquation);
F_ORD(glBlendEquationSeparate);
F_ORD(glStencilMaskSeparate);
F_ORD(glStencilOp);
F_ORD(glStencilOpSeparate);
- F_ORD(glUseProgram);
F_ORD(glVertexAttrib1f);
F_ORD(glVertexAttrib1fv);
F_ORD(glVertexAttrib2f);
break;
default:
ERR("Invalide GL Override Option!!!\n");
- }
+ }
}
void
break;
default:
ERR("Invalide GL Override Option!!!\n");
- }
+ }
}
#include <string.h>
#include <sys/time.h>
-#define MAX_TRACE_NAME_LENGTH 256
-#define MAX_TRACE_TABLE_SIZE 65536
+#define MAX_TRACE_NAME_LENGTH 256
+#define MAX_TRACE_TABLE_SIZE 65536
+
+#define TIMEVAL_INIT { 0, 0 }
struct _Trace_Data
{
char name[MAX_TRACE_NAME_LENGTH];
int call_count;
int last_call_count;
- long elapsed_time;
- long last_elapsed_time;
+ struct timeval elapsed_time;
+ struct timeval last_elapsed_time;
+ struct timeval total_elapsed_time;
+ struct timeval last_total_elapsed_time;
struct timeval last_time;
int traced;
General_Trace_List *thread_trace_list = NULL;
Mutex general_trace_lists_access_mutex = MUTEX_INITIALIZER;
-int trace_api_flag = 1;
+struct timeval initial_time = TIMEVAL_INIT;
+struct timeval last_initial_time = TIMEVAL_INIT;
+
+struct timeval last_trace_time = TIMEVAL_INIT;
+struct timeval other_elapsed_time = TIMEVAL_INIT;
+struct timeval traced_other_elapsed_time = TIMEVAL_INIT;
+static inline void
+_add_timeval_period(struct timeval *tv_dst, struct timeval tv_now, struct timeval tv_old)
+{
+ tv_dst->tv_sec += tv_now.tv_sec - tv_old.tv_sec;
+ tv_dst->tv_usec += 1000000 + (tv_now.tv_usec - tv_old.tv_usec);
+ tv_dst->tv_sec += (tv_dst->tv_usec / 1000000) - 1;
+ tv_dst->tv_usec = tv_dst->tv_usec % 1000000;
+}
+
+static inline void
+_add_timeval(struct timeval *tv_dst, struct timeval tv_src)
+{
+ tv_dst->tv_sec += tv_src.tv_sec;
+ tv_dst->tv_usec += tv_src.tv_usec;
+ if (tv_dst->tv_usec > 1000000)
+ {
+ tv_dst->tv_usec -= 1000000;
+ tv_dst->tv_sec++;
+ }
+ else if (tv_dst->tv_usec < 0)
+ {
+ tv_dst->tv_usec += 1000000;
+ tv_dst->tv_sec--;
+ }
+}
+
+static inline double
+_get_timeval_period(struct timeval time_now, struct timeval time_old)
+{
+ return ((time_now.tv_sec - time_old.tv_sec) * 1000) + ((time_now.tv_usec - time_old.tv_usec) / 1000.0);
+}
+
+static inline double
+_get_timeval(struct timeval time)
+{
+ return (time.tv_sec * 1000) + (time.tv_usec / 1000.0);
+}
+
static unsigned short
_generate_hash_short(const char *string)
{
unsigned short hash = 0;
int i;
+
for (i = 0; i < strlen(string); i++)
{
hash = 253 * hash + string[i];
}
- return hash ^ (hash >> 8);
+ return (hash ^ (hash >> 8)) % MAX_TRACE_TABLE_SIZE;
}
static Trace_Data *
current = ftd_table[hash];
- while (current != NULL)
+ while (current != NULL && current->next != NULL)
{
if (strcmp(current->name, name) == 0)
break;
}
ret = newitm;
}
+
goto finish;
finish:
return ret;
}
-void
-trace_begin(const char *funcname)
+void *
+trace_begin(const char *funcname, void *hint, int trace_total_time)
{
- GLThreadState *tstate = NULL;
-
- tstate = get_current_thread_state();
+ Trace_Data *ftd = NULL;
+ struct timeval t = TIMEVAL_INIT;
- if (tstate == NULL)
+ if (trace_api_flag == 1)
{
- init_new_thread_state();
+ AST(gettimeofday(&t, NULL) == 0);
- tstate = get_current_thread_state();
- AST(tstate != NULL);
- }
+ ftd = (Trace_Data *)hint;
- if (tstate->ftd_table == NULL)
- {
- tstate->ftd_table = (Trace_Data **)calloc(1, sizeof(Trace_Data *) * MAX_TRACE_TABLE_SIZE);
- }
+ if (ftd == NULL)
+ {
+ GLThreadState *tstate = NULL;
+ tstate = get_current_thread_state();
+
+ if (tstate == NULL)
+ {
+ init_new_thread_state();
+
+ tstate = get_current_thread_state();
+ AST(tstate != NULL);
+ }
+
+ if (tstate->ftd_table == NULL)
+ {
+ tstate->ftd_table = (Trace_Data **)calloc(1, sizeof(Trace_Data *) * MAX_TRACE_TABLE_SIZE);
+ }
+
+ ftd = _get_trace_data(tstate->ftd_table, funcname);
+ }
- if (trace_api_flag == 1)
- {
- Trace_Data *ftd = _get_trace_data(tstate->ftd_table, funcname);
AST(ftd != NULL);
ftd->call_count++;
AST(ftd->last_time.tv_sec == 0);
AST(gettimeofday(&ftd->last_time, NULL) == 0);
+
+ if (initial_time.tv_sec == 0)
+ {
+ initial_time = ftd->last_time;
+ last_initial_time = ftd->last_time;
+ }
+
+ if (trace_total_time == 1)
+ {
+ if (last_trace_time.tv_sec != 0)
+ {
+ _add_timeval_period(&other_elapsed_time, t, last_trace_time);
+ last_trace_time.tv_sec = 0;
+ }
+ }
+
}
+
+ return ftd;
}
-void
-trace_end(const char *funcname)
+void *
+trace_end(const char *funcname, void *hint, int trace_total_time)
{
- GLThreadState *tstate = NULL;
- struct timeval t = {0};
+ Trace_Data *ftd = NULL;
+ struct timeval t = TIMEVAL_INIT;
- AST(gettimeofday(&t, NULL) == 0);
+ ftd = (Trace_Data *)hint;
- tstate = get_current_thread_state();
+ AST(gettimeofday(&t, NULL) == 0);
- if (tstate == NULL)
+ if (trace_api_flag == 1)
{
- init_new_thread_state();
+ GLThreadState *tstate = NULL;
+ struct timeval elapsed_time = TIMEVAL_INIT;
- tstate = get_current_thread_state();
- AST(tstate != NULL);
- }
+ if (ftd == NULL)
+ {
+ tstate = get_current_thread_state();
- AST(tstate->ftd_table != NULL);
+ if (tstate == NULL)
+ {
+ init_new_thread_state();
+
+ tstate = get_current_thread_state();
+ AST(tstate != NULL);
+ }
+ AST(tstate->ftd_table != NULL);
+
+ ftd = _get_trace_data(tstate->ftd_table, funcname);
+ }
- if (trace_api_flag == 1)
- {
- Trace_Data *ftd = _get_trace_data(tstate->ftd_table, funcname);
AST(ftd != NULL);
- ftd->elapsed_time +=
- (t.tv_sec - ftd->last_time.tv_sec) * 100000 +
- (t.tv_usec - ftd->last_time.tv_usec) / 10;
+ _add_timeval_period(&elapsed_time, t, ftd->last_time);
+
+ _add_timeval(&ftd->elapsed_time, elapsed_time);
+
+
ftd->last_time.tv_sec = 0;
+
+ if (trace_total_time == 1)
+ {
+ _add_timeval(&ftd->total_elapsed_time, elapsed_time);
+
+ AST(gettimeofday(&last_trace_time, NULL) == 0);
+
+ if (initial_time.tv_sec == 0)
+ {
+ initial_time = t;
+ last_initial_time = t;
+ }
+ }
+
}
+
+
+ return ftd;
}
void
trace_output(int force_output)
{
- static struct timeval tv_last = { 0, 0 };
+ static struct timeval tv_last = TIMEVAL_INIT;
+ struct timeval total_now = TIMEVAL_INIT;
GLThreadState *tstate = NULL;
Trace_Data **ftd_table = NULL;
+
+ double total_elapsed_time = 0.0;
+ double total_elapsed_time_period = 0.0;
+ double total_opengl_elapsed_time = 0.0;
+ double total_opengl_elapsed_time_period = 0.0;
+ double total_other_elapsed_time = 0.0;
+ double total_other_elapsed_time_period = 0.0;
+
+ double swaps_per_sec = 0.0;
+
int i;
+ if (trace_api_flag != 1)
{
- char *fp_env = NULL;
- int fp_envi = 0;
- fp_env = getenv("COREGL_TRACE_API");
- if (fp_env) fp_envi = atoi(fp_env);
- else fp_envi = 0;
- if (fp_envi == 0) return;
+ goto finish;
}
if (!force_output)
{
- struct timeval tv_now = { 0, 0 };
+ struct timeval tv_now = TIMEVAL_INIT;
AST(gettimeofday(&tv_now, NULL) == 0);
if (tv_now.tv_sec - tv_last.tv_sec < _COREGL_TRACE_OUTPUT_INTERVAL_SEC)
{
tv_last = tv_now;
}
+ AST(gettimeofday(&total_now, NULL) == 0);
+
+ total_elapsed_time = _get_timeval_period(total_now, initial_time);
+ total_elapsed_time_period = _get_timeval_period(total_now, last_initial_time);
+ last_initial_time = total_now;
+
+ total_other_elapsed_time = _get_timeval(other_elapsed_time);
+ total_other_elapsed_time_period = _get_timeval_period(other_elapsed_time, traced_other_elapsed_time);
+ traced_other_elapsed_time = other_elapsed_time;
+
tstate = get_current_thread_state();
if (tstate == NULL)
ftd_table = tstate->ftd_table;
if (ftd_table == NULL) return;
+ {
+ static Trace_Data *trace_hint_swap = NULL;
+ if (trace_hint_swap == NULL)
+ trace_hint_swap = _get_trace_data(ftd_table, "eglSwapBuffers");
+
+ if (trace_hint_swap != NULL && total_elapsed_time_period > 0)
+ {
+ swaps_per_sec = (trace_hint_swap->call_count - trace_hint_swap->last_call_count) / (total_elapsed_time_period / 1000);
+ }
+ }
+
+
LOG("\n");
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
- LOG("\E[0;32;1m API call info \E[1;37;1m: Thread ID = %d\E[0m\n", tstate->thread_id);
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
+ LOG("\E[40;32;1m API call info \E[1;37;1m: Thread ID = %d [Swaps per Second(P) = %7.2f]\E[0m\n", tstate->thread_id, swaps_per_sec);
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
// highlighted
for (i = 0; i < MAX_TRACE_TABLE_SIZE; i++)
while (current != NULL)
{
- double elapsed_time = current->elapsed_time / 100.0;
+ double elapsed_time = _get_timeval(current->elapsed_time);
double elapsed_time_per_call = elapsed_time / current->call_count;
+ total_opengl_elapsed_time += _get_timeval(current->total_elapsed_time);
+ total_opengl_elapsed_time_period += _get_timeval(current->total_elapsed_time) - _get_timeval(current->last_total_elapsed_time);
+
current->traced = 0;
if (current->call_count > current->last_call_count)
{
- double elapsed_time_period = (current->elapsed_time - current->last_elapsed_time) / 100.0;
+ 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);
- if (elapsed_time_per_call_period >= 0.01)
+ if (elapsed_time_per_call_period >= 0.01 || current->call_count - current->last_call_count > 1000)
{
- LOG("\E[0;37;1m %-42.42s : %10d call(s), %10.2f ms, %9.2f ms/API, %9.2f ms/API(P) \E[0m\n",
+ LOG("\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);
current->traced = 1;
}
}
{
- char *fp_env = NULL;
- int fp_envi = 0;
- fp_env = getenv("COREGL_TRACE_API_ALL");
- if (fp_env) fp_envi = atoi(fp_env);
- else fp_envi = 0;
- if (fp_envi != 0)
+ int fp_env = 0;
+ fp_env = atoi(get_env_setting("COREGL_TRACE_API_ALL"));
+ if (fp_env == 0)
{
// other
for (i = 0; i < MAX_TRACE_TABLE_SIZE; i++)
{
if (current->traced == 0)
{
- double elapsed_time = current->elapsed_time / 100.0;
+ double elapsed_time = _get_timeval(current->elapsed_time);
double elapsed_time_per_call = elapsed_time / current->call_count;
- LOG(" %-42.42s : %10d call(s), %10.2f ms, %9.2f ms/API\n",
+ LOG(" %-42.42s : %10d call(s), %10.2f ms, %9.3f ms/API\n",
current->name, current->call_count, elapsed_time, elapsed_time_per_call);
}
current = current->next;
}
}
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
+
+ LOG("\E[40;36;1m %-42.42s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
+ "TOTAL elapsed Time",
+ total_elapsed_time,
+ 100.0,
+ total_elapsed_time_period,
+ 100.0);
+
+
+ LOG("\E[40;36;1m %-42.42s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
+ "OpenGL elapsed Time",
+ total_opengl_elapsed_time,
+ total_opengl_elapsed_time * 100.0 / total_elapsed_time,
+ total_opengl_elapsed_time_period,
+ total_opengl_elapsed_time_period * 100.0 / total_elapsed_time_period);
+
+ LOG("\E[40;36;1m %-42.42s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
+ "Out of OpenGL elapsed time",
+ total_other_elapsed_time,
+ total_other_elapsed_time * 100.0 / total_elapsed_time,
+ total_other_elapsed_time_period,
+ total_other_elapsed_time_period * 100.0 / total_elapsed_time_period);
+
+ LOG("\E[40;36;1m %-42.42s : %13.2f ms[%6.2f%%], %13.2f ms(P)[%6.2f%%]\E[0m\n",
+ "CoreGL API tracing overhead",
+ total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time,
+ (total_elapsed_time - total_opengl_elapsed_time - total_other_elapsed_time) * 100.0 / total_elapsed_time,
+ total_elapsed_time_period - total_opengl_elapsed_time_period - total_other_elapsed_time_period,
+ (total_elapsed_time_period - total_opengl_elapsed_time_period - total_other_elapsed_time_period) * 100.0 / total_elapsed_time_period);
+
+ LOG("\E[40;34m========================================================================================================================\E[0m\n");
+ LOG("\n");
+
for (i = 0; i < MAX_TRACE_TABLE_SIZE; i++)
{
if (ftd_table[i] != NULL)
{
current->last_call_count = current->call_count;
current->last_elapsed_time = current->elapsed_time;
+ current->last_total_elapsed_time = current->total_elapsed_time;
current = current->next;
}
}
}
- LOG("\E[0;40;34m========================================================================================================================\E[0m\n");
- LOG("\n");
-
goto finish;
finish:
#include <string.h>
#include <sys/time.h>
+// Symbol definition for override
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST = NULL;
+#include "headers/sym.h"
+#undef _COREGL_SYMBOL
+
typedef struct _GLGlueFakeContext
{
GLuint gl_num_tex_units[1];
}
void
+init_wrap_gl()
+{
+}
+
+void
+free_wrap_gl()
+{
+}
+
+void
dump_wrap_context_states(int force_output)
{
static struct timeval tv_last = { 0, 0 };
+ if (trace_ctx_flag != 1) return;
_sym_glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, (GLint *)initial_fake_ctx->gl_num_tex_units);
_sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)initial_fake_ctx->gl_num_vertex_attribs);
- {
- char *fp_env = NULL;
- int fp_envi = 0;
- fp_env = getenv("COREGL_TRACE_STATE");
- if (fp_env) fp_envi = atoi(fp_env);
- else fp_envi = 0;
- if (fp_envi == 0) return;
- }
-
if (!force_output)
{
struct timeval tv_now = { 0, 0 };
\r
#include "coregl_internal.h"\r
\r
+// Symbol definition for override\r
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;\r
+# include "headers/sym.h"
+#undef _COREGL_SYMBOL
+\r
+extern void init_wrap_gl();\r
+extern void free_wrap_gl();\r
+\r
extern void dump_wrap_context_states(int force_output);\r
\r
EGLint ret = _COREGL_INT_INIT_VALUE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetError();
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglGetError();
goto finish;
finish:
EGLDisplay ret = EGL_NO_DISPLAY;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetDisplay(display_id);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglGetDisplay(display_id);
goto finish;
finish:
eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
{
EGLBoolean ret = EGL_FALSE;
-
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglInitialize(dpy, major, minor);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglInitialize(dpy, major, minor);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglTerminate(dpy);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglTerminate(dpy);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetConfigs(dpy, configs, config_size, num_config);
+ ret = ovr_eglGetConfigs(dpy, configs, config_size, num_config);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+ ret = ovr_eglChooseConfig(dpy, attrib_list, configs, config_size, num_config);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetConfigAttrib(dpy, config, attribute, value);
+ ret = ovr_eglGetConfigAttrib(dpy, config, attribute, value);
goto finish;
finish:
EGLSurface ret = EGL_NO_SURFACE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreateWindowSurface(dpy, config, win, attrib_list);
+ ret = ovr_eglCreateWindowSurface(dpy, config, win, attrib_list);
goto finish;
finish:
EGLSurface ret = EGL_NO_SURFACE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreatePbufferSurface(dpy, config, attrib_list);
+ ret = ovr_eglCreatePbufferSurface(dpy, config, attrib_list);
goto finish;
finish:
EGLSurface ret = EGL_NO_SURFACE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+ ret = ovr_eglCreatePixmapSurface(dpy, config, pixmap, attrib_list);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglDestroySurface(dpy, surface);
+ ret = ovr_eglDestroySurface(dpy, surface);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglQuerySurface(dpy, surface, attribute, value);
+ ret = ovr_eglQuerySurface(dpy, surface, attribute, value);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglBindAPI(api);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglBindAPI(api);
goto finish;
finish:
EGLenum ret = 0;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglQueryAPI();
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglQueryAPI();
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglWaitClient();
+ ret = ovr_eglWaitClient();
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglReleaseThread();
+ ret = ovr_eglReleaseThread();
goto finish;
finish:
EGLSurface ret = EGL_NO_SURFACE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
+ ret = ovr_eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglSurfaceAttrib(dpy, surface, attribute, value);
+ ret = ovr_eglSurfaceAttrib(dpy, surface, attribute, value);
goto finish;
finish:
eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_eglBindTexImage(dpy, surface, buffer);
+ ovr_eglBindTexImage(dpy, surface, buffer);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglReleaseTexImage(dpy, surface, buffer);
+ ret = ovr_eglReleaseTexImage(dpy, surface, buffer);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglSwapInterval(dpy, interval);
+ ret = ovr_eglSwapInterval(dpy, interval);
goto finish;
finish:
EGLContext ret = EGL_NO_CONTEXT;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreateContext(dpy, config, share_context, attrib_list);
+ ret = ovr_eglCreateContext(dpy, config, share_context, attrib_list);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglDestroyContext(dpy, ctx);
+ ret = ovr_eglDestroyContext(dpy, ctx);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglMakeCurrent(dpy, draw, read, ctx);
+ ret = ovr_eglMakeCurrent(dpy, draw, read, ctx);
goto finish;
finish:
_COREGL_WRAP_FUNC_END();
#ifdef COREGL_TRACE_STATE_INFO
- if (glsym_eglMakeCurrent != fpgl_eglMakeCurrent)
+ if (ovr_eglMakeCurrent == _sym_eglMakeCurrent)
dump_wrap_context_states(0);
#endif // COREGL_TRACE_STATE_INFO
return ret;
EGLContext ret = EGL_NO_CONTEXT;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetCurrentContext();
+ ret = ovr_eglGetCurrentContext();
goto finish;
finish:
EGLSurface ret = EGL_NO_SURFACE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetCurrentSurface(readdraw);
+ ret = ovr_eglGetCurrentSurface(readdraw);
goto finish;
finish:
EGLDisplay ret = EGL_NO_DISPLAY;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetCurrentDisplay();
+ ret = ovr_eglGetCurrentDisplay();
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglQueryContext(dpy, ctx, attribute, value);
+ ret = ovr_eglQueryContext(dpy, ctx, attribute, value);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglWaitGL();
+ ret = ovr_eglWaitGL();
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglWaitNative(engine);
+ ret = ovr_eglWaitNative(engine);
goto finish;
finish:
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglSwapBuffers(dpy, surface);
+ ret = ovr_eglSwapBuffers(dpy, surface);
goto finish;
EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCopyBuffers(dpy, surface, target);
+ ret = ovr_eglCopyBuffers(dpy, surface, target);
goto finish;
finish:
_eng_fn ret = NULL;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetProcAddress(procname);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglGetProcAddress(procname);
goto finish;
finish:
const char *ret = NULL;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglQueryString(dpy, name);
+ if (api_opt == COREGL_UNKNOWN_PATH) goto finish;
+ ret = ovr_eglQueryString(dpy, name);
goto finish;
finish:
void *ret = NULL;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
+ ret = ovr_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
goto finish;
finish:
EGLBoolean
eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
{
- unsigned int ret = _COREGL_INT_INIT_VALUE;
+ EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglDestroyImageKHR(dpy, image);
+ ret = ovr_eglDestroyImageKHR(dpy, image);
goto finish;
finish:
void *ret = NULL;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglMapImageSEC(dpy, image);
+ ret = ovr_eglMapImageSEC(dpy, image);
goto finish;
finish:
EGLBoolean
eglUnmapImageSEC(EGLDisplay dpy, EGLImageKHR image)
{
- unsigned int ret = _COREGL_INT_INIT_VALUE;
+ EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglUnmapImageSEC(dpy, image);
+ ret = ovr_eglUnmapImageSEC(dpy, image);
goto finish;
finish:
EGLBoolean
eglGetImageAttribSEC(EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value)
{
- unsigned int ret = _COREGL_INT_INIT_VALUE;
+ EGLBoolean ret = EGL_FALSE;
+
+ _COREGL_WRAP_FUNC_BEGIN();
+ ret = ovr_eglGetImageAttribSEC(dpy, image, attribute, value);
+ goto finish;
+
+finish:
+ _COREGL_WRAP_FUNC_END();
+ return ret;
+}
+
+EGLBoolean
+eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
+{
+ EGLBoolean ret = EGL_FALSE;
+
+ _COREGL_WRAP_FUNC_BEGIN();
+ ret = ovr_eglLockSurfaceKHR(display, surface, attrib_list);
+ goto finish;
+
+finish:
+ _COREGL_WRAP_FUNC_END();
+ return ret;
+}
+
+EGLBoolean
+eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
+{
+ EGLBoolean ret = EGL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_eglGetImageAttribSEC(dpy, image, attribute, value);
+ ret = ovr_eglUnlockSurfaceKHR(display, surface);
goto finish;
finish:
glActiveTexture(GLenum texture)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glActiveTexture(texture);
+ ovr_glActiveTexture(texture);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glAttachShader(GLuint program, GLuint shader)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glAttachShader(program, shader);
+ ovr_glAttachShader(program, shader);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBindAttribLocation(GLuint program, GLuint index, const char* name)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBindAttribLocation(program, index, name);
+ ovr_glBindAttribLocation(program, index, name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBindBuffer(GLenum target, GLuint buffer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBindBuffer(target, buffer);
+ ovr_glBindBuffer(target, buffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBindFramebuffer(GLenum target, GLuint framebuffer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBindFramebuffer(target, framebuffer);
+ ovr_glBindFramebuffer(target, framebuffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBindRenderbuffer(target, renderbuffer);
+ ovr_glBindRenderbuffer(target, renderbuffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBindTexture(GLenum target, GLuint texture)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBindTexture(target, texture);
+ ovr_glBindTexture(target, texture);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBlendColor(red, green, blue, alpha);
+ ovr_glBlendColor(red, green, blue, alpha);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBlendEquation(GLenum mode)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBlendEquation(mode);
+ ovr_glBlendEquation(mode);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBlendEquationSeparate(modeRGB, modeAlpha);
+ ovr_glBlendEquationSeparate(modeRGB, modeAlpha);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBlendFunc(GLenum sfactor, GLenum dfactor)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBlendFunc(sfactor, dfactor);
+ ovr_glBlendFunc(sfactor, dfactor);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+ ovr_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBufferData(target, size, data, usage);
+ ovr_glBufferData(target, size, data, usage);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glBufferSubData(target, offset, size, data);
+ ovr_glBufferSubData(target, offset, size, data);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLenum ret = GL_NONE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glCheckFramebufferStatus(target);
+ ret = ovr_glCheckFramebufferStatus(target);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glClear(GLbitfield mask)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glClear(mask);
+ ovr_glClear(mask);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glClearColor(red, green, blue, alpha);
+ ovr_glClearColor(red, green, blue, alpha);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glClearDepthf(GLclampf depth)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glClearDepthf(depth);
+ ovr_glClearDepthf(depth);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glClearStencil(GLint s)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glClearStencil(s);
+ ovr_glClearStencil(s);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glColorMask(red, green, blue, alpha);
+ ovr_glColorMask(red, green, blue, alpha);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCompileShader(GLuint shader)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCompileShader(shader);
+ ovr_glCompileShader(shader);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+ ovr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ ovr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+ ovr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+ ovr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLuint ret = _COREGL_INT_INIT_VALUE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glCreateProgram();
+ ret = ovr_glCreateProgram();
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
GLuint ret = _COREGL_INT_INIT_VALUE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glCreateShader(type);
+ ret = ovr_glCreateShader(type);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glCullFace(GLenum mode)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glCullFace(mode);
+ ovr_glCullFace(mode);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteBuffers(GLsizei n, const GLuint* buffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteBuffers(n, buffers);
+ ovr_glDeleteBuffers(n, buffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteFramebuffers(n, framebuffers);
+ ovr_glDeleteFramebuffers(n, framebuffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteProgram(GLuint program)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteProgram(program);
+ ovr_glDeleteProgram(program);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteRenderbuffers(n, renderbuffers);
+ ovr_glDeleteRenderbuffers(n, renderbuffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteShader(GLuint shader)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteShader(shader);
+ ovr_glDeleteShader(shader);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDeleteTextures(GLsizei n, const GLuint* textures)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDeleteTextures(n, textures);
+ ovr_glDeleteTextures(n, textures);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDepthFunc(GLenum func)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDepthFunc(func);
+ ovr_glDepthFunc(func);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDepthMask(GLboolean flag)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDepthMask(flag);
+ ovr_glDepthMask(flag);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDepthRangef(GLclampf zNear, GLclampf zFar)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDepthRangef(zNear, zFar);
+ ovr_glDepthRangef(zNear, zFar);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDetachShader(GLuint program, GLuint shader)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDetachShader(program, shader);
+ ovr_glDetachShader(program, shader);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDisable(GLenum cap)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDisable(cap);
+ ovr_glDisable(cap);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDisableVertexAttribArray(GLuint index)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDisableVertexAttribArray(index);
+ ovr_glDisableVertexAttribArray(index);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDrawArrays(mode, first, count);
+ ovr_glDrawArrays(mode, first, count);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glDrawElements(mode, count, type, indices);
+ ovr_glDrawElements(mode, count, type, indices);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glEnable(GLenum cap)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glEnable(cap);
+ ovr_glEnable(cap);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glEnableVertexAttribArray(GLuint index)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glEnableVertexAttribArray(index);
+ ovr_glEnableVertexAttribArray(index);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFinish(void)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFinish();
+ ovr_glFinish();
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFlush(void)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFlush();
+ ovr_glFlush();
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+ ovr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFramebufferTexture2D(target, attachment, textarget, texture, level);
+ ovr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFrontFace(GLenum mode)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFrontFace(mode);
+ ovr_glFrontFace(mode);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetVertexAttribfv(index, pname, params);
+ ovr_glGetVertexAttribfv(index, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetVertexAttribiv(index, pname, params);
+ ovr_glGetVertexAttribiv(index, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetVertexAttribPointerv(index, pname, pointer);
+ ovr_glGetVertexAttribPointerv(index, pname, pointer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
glHint(GLenum target, GLenum mode)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glHint(target, mode);
+ ovr_glHint(target, mode);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGenBuffers(GLsizei n, GLuint* buffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGenBuffers(n, buffers);
+ ovr_glGenBuffers(n, buffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGenerateMipmap(GLenum target)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGenerateMipmap(target);
+ ovr_glGenerateMipmap(target);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGenFramebuffers(GLsizei n, GLuint* framebuffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGenFramebuffers(n, framebuffers);
+ ovr_glGenFramebuffers(n, framebuffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGenRenderbuffers(n, renderbuffers);
+ ovr_glGenRenderbuffers(n, renderbuffers);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGenTextures(GLsizei n, GLuint* textures)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGenTextures(n, textures);
+ ovr_glGenTextures(n, textures);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
+ ovr_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetActiveUniform(program, index, bufsize, length, size, type, name);
+ ovr_glGetActiveUniform(program, index, bufsize, length, size, type, name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetAttachedShaders(program, maxcount, count, shaders);
+ ovr_glGetAttachedShaders(program, maxcount, count, shaders);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
int ret = _COREGL_INT_INIT_VALUE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glGetAttribLocation(program, name);
+ ret = ovr_glGetAttribLocation(program, name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetBooleanv(GLenum pname, GLboolean* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetBooleanv(pname, params);
+ ovr_glGetBooleanv(pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetBufferParameteriv(target, pname, params);
+ ovr_glGetBufferParameteriv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLenum ret = GL_NONE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glGetError();
+ ret = ovr_glGetError();
goto finish;
finish:
glGetFloatv(GLenum pname, GLfloat* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetFloatv(pname, params);
+ ovr_glGetFloatv(pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+ ovr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetIntegerv(GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetIntegerv(pname, params);
+ ovr_glGetIntegerv(pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetProgramiv(program, pname, params);
+ ovr_glGetProgramiv(program, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetProgramInfoLog(program, bufsize, length, infolog);
+ ovr_glGetProgramInfoLog(program, bufsize, length, infolog);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetRenderbufferParameteriv(target, pname, params);
+ ovr_glGetRenderbufferParameteriv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetShaderiv(shader, pname, params);
+ ovr_glGetShaderiv(shader, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetShaderInfoLog(shader, bufsize, length, infolog);
+ ovr_glGetShaderInfoLog(shader, bufsize, length, infolog);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
_COREGL_WRAP_FUNC_BEGIN();
#ifndef _COREGL_DESKTOP_GL
- glsym_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+ ovr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
#else
if (range)
glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetShaderSource(shader, bufsize, length, source);
+ ovr_glGetShaderSource(shader, bufsize, length, source);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
const GLubyte *ret = NULL;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glGetString(name);
+ ret = ovr_glGetString(name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetTexParameterfv(target, pname, params);
+ ovr_glGetTexParameterfv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetTexParameteriv(target, pname, params);
+ ovr_glGetTexParameteriv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetUniformfv(program, location, params);
+ ovr_glGetUniformfv(program, location, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glGetUniformiv(GLuint program, GLint location, GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetUniformiv(program, location, params);
+ ovr_glGetUniformiv(program, location, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
int ret = _COREGL_INT_INIT_VALUE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glGetUniformLocation(program, name);
+ ret = ovr_glGetUniformLocation(program, name);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLboolean ret = GL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsBuffer(buffer);
+ ret = ovr_glIsBuffer(buffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLboolean ret = GL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsEnabled(cap);
+ ret = ovr_glIsEnabled(cap);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
GLboolean ret = GL_FALSE;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsFramebuffer(framebuffer);
+ ret = ovr_glIsFramebuffer(framebuffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
GLboolean ret;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsProgram(program);
+ ret = ovr_glIsProgram(program);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
GLboolean ret;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsRenderbuffer(renderbuffer);
+ ret = ovr_glIsRenderbuffer(renderbuffer);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
GLboolean ret;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsShader(shader);
+ ret = ovr_glIsShader(shader);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
GLboolean ret;
_COREGL_WRAP_FUNC_BEGIN();
- ret = glsym_glIsTexture(texture);
+ ret = ovr_glIsTexture(texture);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glLineWidth(GLfloat width)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glLineWidth(width);
+ ovr_glLineWidth(width);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glLinkProgram(GLuint program)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glLinkProgram(program);
+ ovr_glLinkProgram(program);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glPixelStorei(GLenum pname, GLint param)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glPixelStorei(pname, param);
+ ovr_glPixelStorei(pname, param);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glPolygonOffset(GLfloat factor, GLfloat units)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glPolygonOffset(factor, units);
+ ovr_glPolygonOffset(factor, units);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glReadPixels(x, y, width, height, format, type, pixels);
+ ovr_glReadPixels(x, y, width, height, format, type, pixels);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
_COREGL_WRAP_FUNC_BEGIN();
#ifndef _COREGL_DESKTOP_GL
- glsym_glReleaseShaderCompiler();
+ ovr_glReleaseShaderCompiler();
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
#else
//FIXME!!! need something here?
glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glRenderbufferStorage(target, internalformat, width, height);
+ ovr_glRenderbufferStorage(target, internalformat, width, height);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glSampleCoverage(GLclampf value, GLboolean invert)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glSampleCoverage(value, invert);
+ ovr_glSampleCoverage(value, invert);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glScissor(x, y, width, height);
+ ovr_glScissor(x, y, width, height);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
{
_COREGL_WRAP_FUNC_BEGIN();
#ifndef _COREGL_DESKTOP_GL
- glsym_glShaderBinary(n, shaders, binaryformat, binary, length);
+ ovr_glShaderBinary(n, shaders, binaryformat, binary, length);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
#else
// FIXME: need to dlsym/getprocaddress for this
glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glShaderSource(shader, count, string, length);
+ ovr_glShaderSource(shader, count, string, length);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilFunc(func, ref, mask);
+ ovr_glStencilFunc(func, ref, mask);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilFuncSeparate(face, func, ref, mask);
+ ovr_glStencilFuncSeparate(face, func, ref, mask);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilMask(GLuint mask)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilMask(mask);
+ ovr_glStencilMask(mask);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilMaskSeparate(GLenum face, GLuint mask)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilMaskSeparate(face, mask);
+ ovr_glStencilMaskSeparate(face, mask);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilOp(fail, zfail, zpass);
+ ovr_glStencilOp(fail, zfail, zpass);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glStencilOpSeparate(face, fail, zfail, zpass);
+ ovr_glStencilOpSeparate(face, fail, zfail, zpass);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+ ovr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexParameterf(target, pname, param);
+ ovr_glTexParameterf(target, pname, param);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexParameterfv(target, pname, params);
+ ovr_glTexParameterfv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexParameteri(GLenum target, GLenum pname, GLint param)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexParameteri(target, pname, param);
+ ovr_glTexParameteri(target, pname, param);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexParameteriv(target, pname, params);
+ ovr_glTexParameteriv(target, pname, params);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+ ovr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform1f(GLint location, GLfloat x)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform1f(location, x);
+ ovr_glUniform1f(location, x);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform1fv(location, count, v);
+ ovr_glUniform1fv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform1i(GLint location, GLint x)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform1i(location, x);
+ ovr_glUniform1i(location, x);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform1iv(GLint location, GLsizei count, const GLint* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform1iv(location, count, v);
+ ovr_glUniform1iv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform2f(GLint location, GLfloat x, GLfloat y)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform2f(location, x, y);
+ ovr_glUniform2f(location, x, y);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform2fv(location, count, v);
+ ovr_glUniform2fv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform2i(GLint location, GLint x, GLint y)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform2i(location, x, y);
+ ovr_glUniform2i(location, x, y);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform2iv(GLint location, GLsizei count, const GLint* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform2iv(location, count, v);
+ ovr_glUniform2iv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform3f(location, x, y, z);
+ ovr_glUniform3f(location, x, y, z);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform3fv(location, count, v);
+ ovr_glUniform3fv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform3i(GLint location, GLint x, GLint y, GLint z)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform3i(location, x, y, z);
+ ovr_glUniform3i(location, x, y, z);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform3iv(GLint location, GLsizei count, const GLint* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform3iv(location, count, v);
+ ovr_glUniform3iv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform4f(location, x, y, z, w);
+ ovr_glUniform4f(location, x, y, z, w);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform4fv(location, count, v);
+ ovr_glUniform4fv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform4i(location, x, y, z, w);
+ ovr_glUniform4i(location, x, y, z, w);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniform4iv(GLint location, GLsizei count, const GLint* v)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniform4iv(location, count, v);
+ ovr_glUniform4iv(location, count, v);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniformMatrix2fv(location, count, transpose, value);
+ ovr_glUniformMatrix2fv(location, count, transpose, value);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniformMatrix3fv(location, count, transpose, value);
+ ovr_glUniformMatrix3fv(location, count, transpose, value);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUniformMatrix4fv(location, count, transpose, value);
+ ovr_glUniformMatrix4fv(location, count, transpose, value);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glUseProgram(GLuint program)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glUseProgram(program);
+ ovr_glUseProgram(program);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glValidateProgram(GLuint program)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glValidateProgram(program);
+ ovr_glValidateProgram(program);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib1f(GLuint indx, GLfloat x)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib1f(indx, x);
+ ovr_glVertexAttrib1f(indx, x);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib1fv(GLuint indx, const GLfloat* values)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib1fv(indx, values);
+ ovr_glVertexAttrib1fv(indx, values);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib2f(indx, x, y);
+ ovr_glVertexAttrib2f(indx, x, y);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib2fv(GLuint indx, const GLfloat* values)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib2fv(indx, values);
+ ovr_glVertexAttrib2fv(indx, values);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib3f(indx, x, y, z);
+ ovr_glVertexAttrib3f(indx, x, y, z);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib3fv(GLuint indx, const GLfloat* values)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib3fv(indx, values);
+ ovr_glVertexAttrib3fv(indx, values);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib4f(indx, x, y, z, w);
+ ovr_glVertexAttrib4f(indx, x, y, z, w);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttrib4fv(GLuint indx, const GLfloat* values)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttrib4fv(indx, values);
+ ovr_glVertexAttrib4fv(indx, values);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+ ovr_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glViewport(x, y, width, height);
+ ovr_glViewport(x, y, width, height);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glEGLImageTargetTexture2DOES(target, image);
+ ovr_glEGLImageTargetTexture2DOES(target, image);
goto finish;
finish:
glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glEGLImageTargetRenderbufferStorageOES(target, image);
+ ovr_glEGLImageTargetRenderbufferStorageOES(target, image);
goto finish;
finish:
glGetProgramBinary(GLuint program, GLsizei bufsize, GLsizei* length, GLenum* binaryFormat, void* binary)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
+ ovr_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLint length)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glProgramBinary(program, binaryFormat, binary, length);
+ ovr_glProgramBinary(program, binaryFormat, binary, length);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glProgramParameteri(GLuint program, GLuint pname, GLint value)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glProgramParameteri(program, pname, value);
+ ovr_glProgramParameteri(program, pname, value);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
+ ovr_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
{
_COREGL_WRAP_FUNC_BEGIN();
- glsym_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
+ ovr_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ goto finish;
+
+finish:
+ _COREGL_WRAP_FUNC_END();
+}
+
+void
+glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments)
+{
+ _COREGL_WRAP_FUNC_BEGIN();
+ ovr_glDiscardFramebufferEXT(target, numAttachments, attachments);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
// Defult use-case for exporting symbols
#ifndef _COREGL_SYMBOL
#define _COREGL_SYMBOL_NOT_DEFINED
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
#endif
// Standard EGL APIs
_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglUnmapImageSEC, (EGLDisplay dpy, EGLImageKHR image))
_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglGetImageAttribSEC, (EGLDisplay dpy, EGLImageKHR image, EGLint attribute, EGLint *value))
-//_COREGL_SYMBOL(GL_FALSE, unsigned int, eglLockSurface, (EGLDisplay a, EGLSurface b, const int *attrib_list))
-//_COREGL_SYMBOL(GL_FALSE, unsigned int, eglUnlockSurface, (EGLDisplay a, EGLSurface b))
+_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglLockSurfaceKHR, (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list))
+_COREGL_SYMBOL(GL_TRUE, EGLBoolean, eglUnlockSurfaceKHR, (EGLDisplay display, EGLSurface surface))
#ifdef _COREGL_SYMBOL_NOT_DEFINED
#undef _COREGL_SYMBOL_NOT_DEFINED
// Defult use-case for exporting symbols
#ifndef _COREGL_SYMBOL
#define _COREGL_SYMBOL_NOT_DEFINED
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) extern RET_TYPE (*_COREGL_NAME_MANGLE(FUNC_NAME)) PARAM_LIST;
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_API extern RET_TYPE FUNC_NAME PARAM_LIST;
#endif
/* version 1: */
_COREGL_SYMBOL(GL_TRUE, void, glProgramParameteri, (GLuint a, GLuint b, GLint d))
_COREGL_SYMBOL(GL_TRUE, void, glRenderbufferStorageMultisampleEXT, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height))
_COREGL_SYMBOL(GL_TRUE, void, glFramebufferTexture2DMultisampleEXT, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples))
+_COREGL_SYMBOL(GL_TRUE, void, glDiscardFramebufferEXT, (GLenum target, GLsizei numAttachments, const GLenum *attachments))
#ifdef _COREGL_SYMBOL_NOT_DEFINED
#undef _COREGL_SYMBOL_NOT_DEFINED
projects / platform / core / uifw / coregl.git / commitdiff