#include <stdlib.h>
-#define COREGL_OVERRIDE_API(mangle, func, prefix) \
- mangle##func = prefix##func
-
int export_initialized = 0;
static void
_clean_overrides();
}
-void
-deinit_export()
-{
-}
-
#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_OVERRIDE_API(mangle, func, prefix) \
mangle##func = prefix##func
// Module interfaces
extern void init_modules();
extern void deinit_modules();
+extern void reset_modules_override();
extern void init_modules_tstate(GLThreadState *tstate);
extern void deinit_modules_tstate(GLThreadState *tstate);
#include <stdlib.h>
-#define COREGL_OVERRIDE_API(mangle, func, prefix) \
- mangle##func = prefix##func
-
void
init_overrides()
{
//appopt_apply_overrides_gl(1);
}
-#define OVERRIDE(f) \
- if (enable == 1) \
- { \
- COREGL_OVERRIDE_API(_orig_appopt_, f, ovr_); \
- COREGL_OVERRIDE_API(ovr_, f, appopt_); \
- } \
- else \
- { \
- AST(ovr_##f != NULL); \
- COREGL_OVERRIDE_API(ovr_, f, _orig_appopt_); \
- _orig_appopt_##f = NULL; \
- }
-
void
appopt_apply_overrides_egl(int enable)
{
- // Fast-Path Core Functions
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_appopt_, FUNC_NAME);
+# include "../../headers/sym_egl.h"
+#undef _COREGL_SYMBOL
}
void
appopt_apply_overrides_gl(int enable)
{
- // Fast-Path Functions
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_appopt_, FUNC_NAME);
+# include "../../headers/sym_gl.h"
+#undef _COREGL_SYMBOL
}
#undef A_ORD
void
init_modules()
{
- // Step 1 : Initialization
- init_export();
-
- // Step 2 : User Define Modules : Sequence is important! (Last module's API is called first)
init_modules_fastpath();
init_modules_appopt();
-
- // Step 3 : Common Wrapping Modules
init_modules_tracepath();
+
+ reset_modules_override();
}
void
deinit_modules()
{
- // Step 1(rollback init 3) : Common Wrapping Modules
deinit_modules_tracepath();
-
- // Step 2(rollback init 2) : User Define Modules : Sequence is important!
deinit_modules_appopt();
deinit_modules_fastpath();
+}
- // Step 3(rollback init 1) : De-Initialization
- deinit_export();
+void
+reset_modules_override()
+{
+ // Step 1 : Initialization
+ init_export();
+
+ // Step 2 : User Define Modules : Sequence is important! (Last module's API is called first)
+ fastpath_apply_overrides();
+ appopt_apply_overrides();
+
+ // Step 3 : Common Wrapping Modules
+ tracepath_apply_overrides();
}
void
else \
val = NULL
+#define COREGL_OVERRIDE_API(mangle, func, prefix) \
+ mangle##func = prefix##func
+
+#define COREGL_INIT_ORIGINAL(orig_prefix, f) \
+{ \
+ if (enable == 1) \
+ { \
+ AST(orig_prefix##f == NULL); \
+ COREGL_OVERRIDE_API(orig_prefix, f, ovr_); \
+ } \
+ else \
+ { \
+ AST(ovr_##f != NULL); \
+ COREGL_OVERRIDE_API(ovr_, f, orig_prefix); \
+ orig_prefix##f = NULL; \
+ } \
+}
+
+#define COREGL_OVERRIDE(prefix, f) \
+ if (enable == 1) \
+ { \
+ COREGL_OVERRIDE_API(ovr_, f, prefix); \
+ }
+
#endif // COREGL_MODULE_H
AST(initial_ctx != NULL);
- _sym_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)&cur_active_tex);
+ _orig_fastpath_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)&cur_active_tex);
int i;
for (i = 0; i < initial_ctx->gl_num_tex_units[0]; i++)
{
- _sym_glActiveTexture(GL_TEXTURE0 + i);
- _sym_glGetIntegerv(pname, &(((GLint *)params)[i]));
+ _orig_fastpath_glActiveTexture(GL_TEXTURE0 + i);
+ _orig_fastpath_glGetIntegerv(pname, &(((GLint *)params)[i]));
}
- _sym_glActiveTexture(cur_active_tex);
+ _orig_fastpath_glActiveTexture(cur_active_tex);
}
static GLuint
{
GLuint stencil_bit = 0;
- _sym_glGetIntegerv(GL_STENCIL_BITS, (GLint *)&stencil_bit);
+ _orig_fastpath_glGetIntegerv(GL_STENCIL_BITS, (GLint *)&stencil_bit);
return (1 << stencil_bit) - 1;
}
debug_nofp = atoi(get_env_setting("COREGL_DEBUG_NOFP"));
- fastpath_apply_overrides();
-
}
void
{
ERR("\E[0;31;1mWARNING : Context attached to [dpy=%p|rctx=%p] has not been completely destroyed.(leak)\E[0m\n", current->cstate->rdpy, current->cstate->rctx);
- _sym_eglMakeCurrent(current->cstate->rdpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- _sym_eglDestroyContext(current->cstate->rdpy, current->cstate->rctx);
+ _orig_fastpath_eglMakeCurrent(current->cstate->rdpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ _orig_fastpath_eglDestroyContext(current->cstate->rdpy, current->cstate->rctx);
fastpath_remove_context_states_from_list(current->cstate, NULL);
retry_destroy = 1;
}
}
-#define OVERRIDE(f) \
- if (enable == 1) \
- { \
- COREGL_OVERRIDE_API(_orig_fastpath_, f, ovr_); \
- COREGL_OVERRIDE_API(ovr_, f, fastpath_); \
- } \
- else \
- { \
- AST(ovr_##f != NULL); \
- COREGL_OVERRIDE_API(ovr_, f, _orig_fastpath_); \
- _orig_fastpath_##f = NULL; \
- }
void
fastpath_apply_overrides_egl(int enable)
{
- // Fast-Path Core Functions
- OVERRIDE(eglGetProcAddress);
-
- OVERRIDE(eglBindAPI);
- OVERRIDE(eglQueryAPI);
-
- OVERRIDE(eglCreateContext);
- OVERRIDE(eglCreateImageKHR);
- OVERRIDE(eglMakeCurrent);
- OVERRIDE(eglDestroyContext);
- OVERRIDE(eglQueryContext);
- OVERRIDE(eglGetCurrentContext);
- OVERRIDE(eglReleaseThread);
- OVERRIDE(eglGetCurrentSurface);
- OVERRIDE(eglTerminate);
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_fastpath_, FUNC_NAME);
+# include "../../headers/sym_egl.h"
+#undef _COREGL_SYMBOL
+
+ COREGL_OVERRIDE(fastpath_, eglGetProcAddress);
+
+ COREGL_OVERRIDE(fastpath_, eglBindAPI);
+ COREGL_OVERRIDE(fastpath_, eglQueryAPI);
+
+ COREGL_OVERRIDE(fastpath_, eglCreateContext);
+ COREGL_OVERRIDE(fastpath_, eglCreateImageKHR);
+ COREGL_OVERRIDE(fastpath_, eglMakeCurrent);
+ COREGL_OVERRIDE(fastpath_, eglDestroyContext);
+ COREGL_OVERRIDE(fastpath_, eglQueryContext);
+ COREGL_OVERRIDE(fastpath_, eglGetCurrentContext);
+ COREGL_OVERRIDE(fastpath_, eglReleaseThread);
+ COREGL_OVERRIDE(fastpath_, eglGetCurrentSurface);
+ COREGL_OVERRIDE(fastpath_, eglTerminate);
}
void
fastpath_apply_overrides_gl(int enable)
{
- // Fast-Path Functions
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_fastpath_, FUNC_NAME);
+# include "../../headers/sym_gl.h"
+#undef _COREGL_SYMBOL
+
if (debug_nofp != 1)
{
- OVERRIDE(glGetError);
-
- OVERRIDE(glGetIntegerv);
- OVERRIDE(glGetFloatv);
- OVERRIDE(glGetBooleanv);
-
- OVERRIDE(glActiveTexture);
- OVERRIDE(glGenTextures);
- OVERRIDE(glBindTexture);
- OVERRIDE(glIsTexture);
- OVERRIDE(glDeleteTextures);
- OVERRIDE(glFramebufferTexture2D);
- OVERRIDE(glFramebufferTexture2DMultisampleEXT);
-
- OVERRIDE(glGenBuffers);
- OVERRIDE(glBindBuffer);
- OVERRIDE(glIsBuffer);
- OVERRIDE(glDeleteBuffers);
-
- OVERRIDE(glGenFramebuffers);
- OVERRIDE(glBindFramebuffer);
- OVERRIDE(glIsFramebuffer);
- OVERRIDE(glDeleteFramebuffers);
-
- OVERRIDE(glGenRenderbuffers);
- OVERRIDE(glBindRenderbuffer);
- OVERRIDE(glFramebufferRenderbuffer);
- OVERRIDE(glIsRenderbuffer);
- OVERRIDE(glDeleteRenderbuffers);
-
- OVERRIDE(glCreateShader);
- OVERRIDE(glCreateProgram);
- OVERRIDE(glAttachShader);
- OVERRIDE(glCompileShader);
- OVERRIDE(glShaderBinary);
- OVERRIDE(glDeleteShader);
- OVERRIDE(glDetachShader);
- OVERRIDE(glGetShaderiv);
- OVERRIDE(glGetShaderInfoLog);
- OVERRIDE(glGetShaderSource);
- OVERRIDE(glIsShader);
- OVERRIDE(glShaderSource);
- OVERRIDE(glBindAttribLocation);
- OVERRIDE(glDeleteProgram);
- OVERRIDE(glGetActiveAttrib);
- OVERRIDE(glGetActiveUniform);
- OVERRIDE(glGetAttachedShaders);
- OVERRIDE(glGetAttribLocation);
- OVERRIDE(glGetProgramiv);
- OVERRIDE(glGetProgramInfoLog);
- OVERRIDE(glGetUniformfv);
- OVERRIDE(glGetUniformiv);
- OVERRIDE(glGetUniformLocation);
- OVERRIDE(glIsProgram);
- OVERRIDE(glLinkProgram);
- OVERRIDE(glUseProgram);
- OVERRIDE(glValidateProgram);
- OVERRIDE(glGetProgramBinary);
- OVERRIDE(glProgramBinary);
-
- OVERRIDE(glBlendColor);
- OVERRIDE(glBlendEquation);
- OVERRIDE(glBlendEquationSeparate);
- OVERRIDE(glBlendFunc);
- OVERRIDE(glBlendFuncSeparate);
- OVERRIDE(glClearColor);
- OVERRIDE(glClearDepthf);
- OVERRIDE(glClearStencil);
- OVERRIDE(glColorMask);
- OVERRIDE(glCullFace);
- OVERRIDE(glDepthFunc);
- OVERRIDE(glDepthMask);
- OVERRIDE(glDepthRangef);
- OVERRIDE(glDisable);
- OVERRIDE(glDisableVertexAttribArray);
- OVERRIDE(glDrawArrays);
- OVERRIDE(glDrawElements);
- OVERRIDE(glEnable);
- OVERRIDE(glEnableVertexAttribArray);
- OVERRIDE(glFrontFace);
- OVERRIDE(glGetVertexAttribfv);
- OVERRIDE(glGetVertexAttribiv);
- OVERRIDE(glGetVertexAttribPointerv);
- OVERRIDE(glHint);
- OVERRIDE(glLineWidth);
- OVERRIDE(glPixelStorei);
- OVERRIDE(glPolygonOffset);
- OVERRIDE(glSampleCoverage);
- OVERRIDE(glScissor);
- OVERRIDE(glStencilFunc);
- OVERRIDE(glStencilFuncSeparate);
- OVERRIDE(glStencilMask);
- OVERRIDE(glStencilMaskSeparate);
- OVERRIDE(glStencilOp);
- OVERRIDE(glStencilOpSeparate);
- OVERRIDE(glVertexAttrib1f);
- OVERRIDE(glVertexAttrib1fv);
- OVERRIDE(glVertexAttrib2f);
- OVERRIDE(glVertexAttrib2fv);
- OVERRIDE(glVertexAttrib3f);
- OVERRIDE(glVertexAttrib3fv);
- OVERRIDE(glVertexAttrib4f);
- OVERRIDE(glVertexAttrib4fv);
- OVERRIDE(glVertexAttribPointer);
- OVERRIDE(glViewport);
-
- OVERRIDE(glEGLImageTargetTexture2DOES);
+ COREGL_OVERRIDE(fastpath_, glGetError);
+
+ COREGL_OVERRIDE(fastpath_, glGetIntegerv);
+ COREGL_OVERRIDE(fastpath_, glGetFloatv);
+ COREGL_OVERRIDE(fastpath_, glGetBooleanv);
+
+ COREGL_OVERRIDE(fastpath_, glActiveTexture);
+ COREGL_OVERRIDE(fastpath_, glGenTextures);
+ COREGL_OVERRIDE(fastpath_, glBindTexture);
+ COREGL_OVERRIDE(fastpath_, glIsTexture);
+ COREGL_OVERRIDE(fastpath_, glDeleteTextures);
+ COREGL_OVERRIDE(fastpath_, glFramebufferTexture2D);
+ COREGL_OVERRIDE(fastpath_, glFramebufferTexture2DMultisampleEXT);
+
+ COREGL_OVERRIDE(fastpath_, glGenBuffers);
+ COREGL_OVERRIDE(fastpath_, glBindBuffer);
+ COREGL_OVERRIDE(fastpath_, glIsBuffer);
+ COREGL_OVERRIDE(fastpath_, glDeleteBuffers);
+
+ COREGL_OVERRIDE(fastpath_, glGenFramebuffers);
+ COREGL_OVERRIDE(fastpath_, glBindFramebuffer);
+ COREGL_OVERRIDE(fastpath_, glIsFramebuffer);
+ COREGL_OVERRIDE(fastpath_, glDeleteFramebuffers);
+
+ COREGL_OVERRIDE(fastpath_, glGenRenderbuffers);
+ COREGL_OVERRIDE(fastpath_, glBindRenderbuffer);
+ COREGL_OVERRIDE(fastpath_, glFramebufferRenderbuffer);
+ COREGL_OVERRIDE(fastpath_, glIsRenderbuffer);
+ COREGL_OVERRIDE(fastpath_, glDeleteRenderbuffers);
+
+ COREGL_OVERRIDE(fastpath_, glCreateShader);
+ COREGL_OVERRIDE(fastpath_, glCreateProgram);
+ COREGL_OVERRIDE(fastpath_, glAttachShader);
+ COREGL_OVERRIDE(fastpath_, glCompileShader);
+ COREGL_OVERRIDE(fastpath_, glShaderBinary);
+ COREGL_OVERRIDE(fastpath_, glDeleteShader);
+ COREGL_OVERRIDE(fastpath_, glDetachShader);
+ COREGL_OVERRIDE(fastpath_, glGetShaderiv);
+ COREGL_OVERRIDE(fastpath_, glGetShaderInfoLog);
+ COREGL_OVERRIDE(fastpath_, glGetShaderSource);
+ COREGL_OVERRIDE(fastpath_, glIsShader);
+ COREGL_OVERRIDE(fastpath_, glShaderSource);
+ COREGL_OVERRIDE(fastpath_, glBindAttribLocation);
+ COREGL_OVERRIDE(fastpath_, glDeleteProgram);
+ COREGL_OVERRIDE(fastpath_, glGetActiveAttrib);
+ COREGL_OVERRIDE(fastpath_, glGetActiveUniform);
+ COREGL_OVERRIDE(fastpath_, glGetAttachedShaders);
+ COREGL_OVERRIDE(fastpath_, glGetAttribLocation);
+ COREGL_OVERRIDE(fastpath_, glGetProgramiv);
+ COREGL_OVERRIDE(fastpath_, glGetProgramInfoLog);
+ COREGL_OVERRIDE(fastpath_, glGetUniformfv);
+ COREGL_OVERRIDE(fastpath_, glGetUniformiv);
+ COREGL_OVERRIDE(fastpath_, glGetUniformLocation);
+ COREGL_OVERRIDE(fastpath_, glIsProgram);
+ COREGL_OVERRIDE(fastpath_, glLinkProgram);
+ COREGL_OVERRIDE(fastpath_, glUseProgram);
+ COREGL_OVERRIDE(fastpath_, glValidateProgram);
+ COREGL_OVERRIDE(fastpath_, glGetProgramBinary);
+ COREGL_OVERRIDE(fastpath_, glProgramBinary);
+
+ COREGL_OVERRIDE(fastpath_, glBlendColor);
+ COREGL_OVERRIDE(fastpath_, glBlendEquation);
+ COREGL_OVERRIDE(fastpath_, glBlendEquationSeparate);
+ COREGL_OVERRIDE(fastpath_, glBlendFunc);
+ COREGL_OVERRIDE(fastpath_, glBlendFuncSeparate);
+ COREGL_OVERRIDE(fastpath_, glClearColor);
+ COREGL_OVERRIDE(fastpath_, glClearDepthf);
+ COREGL_OVERRIDE(fastpath_, glClearStencil);
+ COREGL_OVERRIDE(fastpath_, glColorMask);
+ COREGL_OVERRIDE(fastpath_, glCullFace);
+ COREGL_OVERRIDE(fastpath_, glDepthFunc);
+ COREGL_OVERRIDE(fastpath_, glDepthMask);
+ COREGL_OVERRIDE(fastpath_, glDepthRangef);
+ COREGL_OVERRIDE(fastpath_, glDisable);
+ COREGL_OVERRIDE(fastpath_, glDisableVertexAttribArray);
+ COREGL_OVERRIDE(fastpath_, glEnable);
+ COREGL_OVERRIDE(fastpath_, glEnableVertexAttribArray);
+ COREGL_OVERRIDE(fastpath_, glFrontFace);
+ COREGL_OVERRIDE(fastpath_, glHint);
+ COREGL_OVERRIDE(fastpath_, glLineWidth);
+ COREGL_OVERRIDE(fastpath_, glPixelStorei);
+ COREGL_OVERRIDE(fastpath_, glPolygonOffset);
+ COREGL_OVERRIDE(fastpath_, glSampleCoverage);
+ COREGL_OVERRIDE(fastpath_, glScissor);
+ COREGL_OVERRIDE(fastpath_, glStencilFunc);
+ COREGL_OVERRIDE(fastpath_, glStencilFuncSeparate);
+ COREGL_OVERRIDE(fastpath_, glStencilMask);
+ COREGL_OVERRIDE(fastpath_, glStencilMaskSeparate);
+ COREGL_OVERRIDE(fastpath_, glStencilOp);
+ COREGL_OVERRIDE(fastpath_, glStencilOpSeparate);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib1f);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib1fv);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib2f);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib2fv);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib3f);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib3fv);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib4f);
+ COREGL_OVERRIDE(fastpath_, glVertexAttrib4fv);
+ COREGL_OVERRIDE(fastpath_, glVertexAttribPointer);
+ COREGL_OVERRIDE(fastpath_, glViewport);
+
+ COREGL_OVERRIDE(fastpath_, glEGLImageTargetTexture2DOES);
}
else
GL_Object *newobj = (GL_Object *)calloc(1, sizeof(GL_Object));
newobj->id = (int)type + i;
newobj->real_id = real_name;
+ newobj->ref_count = 1;
object[i] = newobj;
ret = newobj->id;
goto finish;
goto finish;
}
- free(object[hash]);
- object[hash] = NULL;
+ object[hash]->ref_count--;
+
+ if (object[hash]->ref_count <= 0)
+ {
+ free(object[hash]);
+ object[hash] = NULL;
+ }
+
ret = 1;
goto finish;
return ret;
}
+GLint
+fastpath_sostate_set_object_tag(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name, GLvoid *tag)
+{
+ GL_Object **object = NULL;
+ GLint ret = _COREGL_INT_INIT_VALUE;
+ int hash = _COREGL_INT_INIT_VALUE;
+
+ object = _get_shared_object(sostate, type);
+
+ hash = glue_name - (int)type;
+ if (hash < 0 ||
+ hash > MAX_GL_OBJECT_SIZE ||
+ object[hash] == NULL ||
+ object[hash]->id != glue_name)
+ {
+ ret = 0;
+ goto finish;
+ }
+ object[hash]->tag = tag;
+ ret = 1;
+ goto finish;
+
+finish:
+ return ret;
+}
+
+GLvoid *
+fastpath_sostate_get_object_tag(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name)
+{
+ GL_Object **object = NULL;
+ GLvoid *ret = NULL;
+ int hash = _COREGL_INT_INIT_VALUE;
+
+ object = _get_shared_object(sostate, type);
+
+ hash = glue_name - (int)type;
+ if (hash < 0 ||
+ hash > MAX_GL_OBJECT_SIZE ||
+ object[hash] == NULL ||
+ object[hash]->id != glue_name)
+ {
+ ret = NULL;
+ goto finish;
+ }
+ ret = object[hash]->tag;
+ goto finish;
+
+finish:
+ return ret;
+}
+
GLuint
fastpath_sostate_find_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint real_name)
{
return ret;
}
+GLint
+fastpath_sostate_use_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name)
+{
+ GL_Object **object = NULL;
+ GLint ret = 0;
+ int hash = _COREGL_INT_INIT_VALUE;
+
+ object = _get_shared_object(sostate, type);
+
+ hash = glue_name - (int)type;
+ if (hash < 0 ||
+ hash > MAX_GL_OBJECT_SIZE ||
+ object[hash] == NULL ||
+ object[hash]->id != glue_name)
+ {
+ ret = 0;
+ goto finish;
+ }
+ object[hash]->ref_count++;
+ ret = 1;
+ goto finish;
+
+finish:
+ return ret;
+}
+
void
fastpath_dump_context_states(GLGlueContext *ctx, int force_output)
{
extern void *tracepath_api_trace_end(const char *name, void *hint, int trace_total_time);
#endif
-void
+#define CHECK_GL_ERROR(func) \
+ { \
+ func; \
+ int err = _orig_fastpath_glGetError(); \
+ if (err != GL_NO_ERROR) \
+ { \
+ printf("\E[0;31;1mERROR(GL %p) : %s returns GL error 0x%X\E[0m\n", oldctx->cstate, #func, err); \
+ goto finish; \
+ } \
+ }
+
+int
fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
{
+ int ret = 0;
unsigned char flag = 0;
int i = 0;
- if (debug_nofp == 1) goto finish;
+ if (debug_nofp == 1)
+ {
+ ret = 1;
+ goto finish;
+ }
// Return if they're the same
- if (oldctx == newctx) goto finish;
+ if (oldctx == newctx)
+ {
+ ret = 1;
+ goto finish;
+ }
#define STATE_COMPARE(state) \
if ((oldctx->state) != (newctx->state))
trace_hint_glfinish = tracepath_api_trace_begin("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
- _sym_glFlush();
+ {
+ int err = _orig_fastpath_glGetError();
+ if (err != GL_NO_ERROR && oldctx->gl_error == GL_NO_ERROR)
+ oldctx->gl_error = err;
+ }
+
+ CHECK_GL_ERROR(_orig_fastpath_glFlush())
#ifdef COREGL_USE_MODULE_TRACEPATH
tracepath_api_trace_end("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
trace_hint_bindbuffers = tracepath_api_trace_begin("eglMakeCurrent(FP bind buffers)", trace_hint_bindbuffers, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
+
//------------------//
// _bind_flag
flag = oldctx->_bind_flag | newctx->_bind_flag;
{
STATE_COMPARE(gl_array_buffer_binding[0])
{
- _sym_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_array_buffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_array_buffer_binding[0]))
}
STATE_COMPARE(gl_element_array_buffer_binding[0])
{
- _sym_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, newctx->gl_element_array_buffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, newctx->gl_element_array_buffer_binding[0]))
}
STATE_COMPARE(gl_framebuffer_binding[0])
{
- _sym_glBindFramebuffer(GL_FRAMEBUFFER, newctx->gl_framebuffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_FRAMEBUFFER, newctx->gl_framebuffer_binding[0]))
}
STATE_COMPARE(gl_renderbuffer_binding[0])
{
- _sym_glBindRenderbuffer(GL_RENDERBUFFER, newctx->gl_renderbuffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindRenderbuffer(GL_RENDERBUFFER, newctx->gl_renderbuffer_binding[0]))
}
}
STATE_COMPARE(gl_blend[0])
{
if (newctx->gl_blend[0])
- _sym_glEnable(GL_BLEND);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND))
+ }
else
- _sym_glDisable(GL_BLEND);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND))
+ }
STATE_COMPARE(gl_cull_face[0])
{
if (newctx->gl_cull_face[0])
- _sym_glEnable(GL_CULL_FACE);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_CULL_FACE))
+ }
else
- _sym_glDisable(GL_CULL_FACE);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_CULL_FACE))
+ }
STATE_COMPARE(gl_depth_test[0])
{
if (newctx->gl_depth_test[0])
- _sym_glEnable(GL_DEPTH_TEST);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DEPTH_TEST))
+ }
else
- _sym_glDisable(GL_DEPTH_TEST);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DEPTH_TEST))
+ }
STATE_COMPARE(gl_dither[0])
{
if (newctx->gl_dither[0])
- _sym_glEnable(GL_DITHER);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DITHER))
+ }
else
- _sym_glDisable(GL_DITHER);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DITHER))
+ }
}
// _enable_flag2
STATE_COMPARE(gl_polygon_offset_fill[0])
{
if (newctx->gl_polygon_offset_fill[0])
- _sym_glEnable(GL_POLYGON_OFFSET_FILL);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_POLYGON_OFFSET_FILL))
+ }
else
- _sym_glDisable(GL_POLYGON_OFFSET_FILL);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_POLYGON_OFFSET_FILL))
+ }
STATE_COMPARE(gl_sample_alpha_to_coverage[0])
{
if (newctx->gl_sample_alpha_to_coverage[0])
- _sym_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE))
+ }
else
- _sym_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE))
+ }
STATE_COMPARE(gl_sample_coverage[0])
{
if (newctx->gl_sample_coverage[0])
- _sym_glEnable(GL_SAMPLE_COVERAGE);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_COVERAGE))
+ }
else
- _sym_glDisable(GL_SAMPLE_COVERAGE);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_COVERAGE))
+ }
STATE_COMPARE(gl_scissor_test[0])
{
if (newctx->gl_scissor_test[0])
- _sym_glEnable(GL_SCISSOR_TEST);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SCISSOR_TEST))
+ }
else
- _sym_glDisable(GL_SCISSOR_TEST);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SCISSOR_TEST))
+ }
STATE_COMPARE(gl_stencil_test[0])
{
if (newctx->gl_stencil_test[0])
- _sym_glEnable(GL_STENCIL_TEST);
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_STENCIL_TEST))
+ }
else
- _sym_glDisable(GL_STENCIL_TEST);
- }
+ CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_STENCIL_TEST))
+ }
}
#ifdef COREGL_USE_MODULE_TRACEPATH
// Viewport.
STATES_COMPARE(gl_viewport, 4 * sizeof(GLint))
{
- _sym_glViewport(newctx->gl_viewport[0],
- newctx->gl_viewport[1],
- newctx->gl_viewport[2],
- newctx->gl_viewport[3]);
+ CHECK_GL_ERROR(_orig_fastpath_glViewport(newctx->gl_viewport[0],
+ newctx->gl_viewport[1],
+ newctx->gl_viewport[2],
+ newctx->gl_viewport[3]))
}
STATE_COMPARE(gl_current_program[0])
{
- _sym_glUseProgram(newctx->gl_current_program[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glUseProgram(newctx->gl_current_program[0]))
}
STATES_COMPARE(gl_color_clear_value, 4 * sizeof(GLclampf))
{
- _sym_glClearColor(newctx->gl_color_clear_value[0],
- newctx->gl_color_clear_value[1],
- newctx->gl_color_clear_value[2],
- newctx->gl_color_clear_value[3]);
+ CHECK_GL_ERROR(_orig_fastpath_glClearColor(newctx->gl_color_clear_value[0],
+ newctx->gl_color_clear_value[1],
+ newctx->gl_color_clear_value[2],
+ newctx->gl_color_clear_value[3]))
}
}
{
STATES_COMPARE(gl_color_writemask, 4 * sizeof(GLboolean))
{
- _sym_glColorMask(newctx->gl_color_writemask[0],
- newctx->gl_color_writemask[1],
- newctx->gl_color_writemask[2],
- newctx->gl_color_writemask[3]);
+ CHECK_GL_ERROR(_orig_fastpath_glColorMask(newctx->gl_color_writemask[0],
+ newctx->gl_color_writemask[1],
+ newctx->gl_color_writemask[2],
+ newctx->gl_color_writemask[3]))
}
STATES_COMPARE(gl_depth_range, 2 * sizeof(GLclampf))
{
- _sym_glDepthRangef(newctx->gl_depth_range[0],
- newctx->gl_depth_range[1]);
+ CHECK_GL_ERROR(_orig_fastpath_glDepthRangef(newctx->gl_depth_range[0],
+ newctx->gl_depth_range[1]))
}
STATE_COMPARE(gl_depth_clear_value[0])
{
- _sym_glClearDepthf(newctx->gl_depth_clear_value[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glClearDepthf(newctx->gl_depth_clear_value[0]))
}
STATE_COMPARE(gl_depth_func[0])
{
- _sym_glDepthFunc(newctx->gl_depth_func[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glDepthFunc(newctx->gl_depth_func[0]))
}
STATE_COMPARE(gl_depth_writemask[0])
{
- _sym_glDepthMask(newctx->gl_depth_writemask[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glDepthMask(newctx->gl_depth_writemask[0]))
}
STATE_COMPARE(gl_cull_face_mode[0])
{
- _sym_glCullFace(newctx->gl_cull_face_mode[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glCullFace(newctx->gl_cull_face_mode[0]))
}
}
{
STATE_COMPARE(gl_tex_2d_state[i])
{
- _sym_glActiveTexture(GL_TEXTURE0 + i);
- _sym_glBindTexture(GL_TEXTURE_2D, newctx->gl_tex_2d_state[i]);
+ CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
+ CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D, newctx->gl_tex_2d_state[i]))
}
STATE_COMPARE(gl_tex_cube_state[i])
{
- _sym_glActiveTexture(GL_TEXTURE0 + i);
- _sym_glBindTexture(GL_TEXTURE_CUBE_MAP, newctx->gl_tex_cube_state[i]);
+ CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
+ CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_CUBE_MAP, newctx->gl_tex_cube_state[i]))
}
}
// Restore active texture
- _sym_glActiveTexture(newctx->gl_active_texture[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(newctx->gl_active_texture[0]))
STATE_COMPARE(gl_generate_mipmap_hint[0])
{
- _sym_glHint(GL_GENERATE_MIPMAP_HINT, newctx->gl_generate_mipmap_hint[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glHint(GL_GENERATE_MIPMAP_HINT, newctx->gl_generate_mipmap_hint[0]))
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
{
STATES_COMPARE(gl_blend_color, 4 * sizeof(GLclampf))
{
- _sym_glBlendColor(newctx->gl_blend_color[0],
- newctx->gl_blend_color[1],
- newctx->gl_blend_color[2],
- newctx->gl_blend_color[3]);
+ CHECK_GL_ERROR(_orig_fastpath_glBlendColor(newctx->gl_blend_color[0],
+ newctx->gl_blend_color[1],
+ newctx->gl_blend_color[2],
+ newctx->gl_blend_color[3]))
}
if ((oldctx->gl_blend_src_rgb[0] != newctx->gl_blend_src_rgb[0]) ||
(oldctx->gl_blend_dst_rgb[0] != newctx->gl_blend_dst_rgb[0]) ||
(oldctx->gl_blend_src_alpha[0] != newctx->gl_blend_src_alpha[0]) ||
(oldctx->gl_blend_dst_alpha[0] != newctx->gl_blend_dst_alpha[0]))
{
- _sym_glBlendFuncSeparate(newctx->gl_blend_src_rgb[0],
- newctx->gl_blend_dst_rgb[0],
- newctx->gl_blend_src_alpha[0],
- newctx->gl_blend_dst_alpha[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBlendFuncSeparate(newctx->gl_blend_src_rgb[0],
+ newctx->gl_blend_dst_rgb[0],
+ newctx->gl_blend_src_alpha[0],
+ newctx->gl_blend_dst_alpha[0]))
}
if ((oldctx->gl_blend_equation_rgb[0] != newctx->gl_blend_equation_rgb[0]) ||
(oldctx->gl_blend_equation_alpha[0] != newctx->gl_blend_equation_alpha[0]))
{
- _sym_glBlendEquationSeparate(newctx->gl_blend_equation_rgb[0], newctx->gl_blend_equation_alpha[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBlendEquationSeparate(newctx->gl_blend_equation_rgb[0], newctx->gl_blend_equation_alpha[0]))
}
}
(oldctx->gl_stencil_ref[0] != newctx->gl_stencil_ref[0]) ||
(oldctx->gl_stencil_value_mask[0] != newctx->gl_stencil_value_mask[0]))
{
- _sym_glStencilFuncSeparate(GL_FRONT,
- newctx->gl_stencil_func[0],
- newctx->gl_stencil_ref[0],
- newctx->gl_stencil_value_mask[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_FRONT,
+ newctx->gl_stencil_func[0],
+ newctx->gl_stencil_ref[0],
+ newctx->gl_stencil_value_mask[0]))
}
if ((oldctx->gl_stencil_fail[0] != newctx->gl_stencil_fail[0]) ||
(oldctx->gl_stencil_pass_depth_fail[0] != newctx->gl_stencil_pass_depth_fail[0]) ||
(oldctx->gl_stencil_pass_depth_pass[0] != newctx->gl_stencil_pass_depth_pass[0]))
{
- _sym_glStencilOpSeparate(GL_FRONT,
- newctx->gl_stencil_fail[0],
- newctx->gl_stencil_pass_depth_fail[0],
- newctx->gl_stencil_pass_depth_pass[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_FRONT,
+ newctx->gl_stencil_fail[0],
+ newctx->gl_stencil_pass_depth_fail[0],
+ newctx->gl_stencil_pass_depth_pass[0]))
}
STATE_COMPARE(gl_stencil_writemask[0])
{
- _sym_glStencilMaskSeparate(GL_FRONT, newctx->gl_stencil_writemask[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_FRONT, newctx->gl_stencil_writemask[0]))
}
}
(oldctx->gl_stencil_back_ref[0] != newctx->gl_stencil_back_ref[0]) ||
(oldctx->gl_stencil_back_value_mask[0] != newctx->gl_stencil_back_value_mask[0]))
{
- _sym_glStencilFuncSeparate(GL_BACK,
- newctx->gl_stencil_back_func[0],
- newctx->gl_stencil_back_ref[0],
- newctx->gl_stencil_back_value_mask[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_BACK,
+ newctx->gl_stencil_back_func[0],
+ newctx->gl_stencil_back_ref[0],
+ newctx->gl_stencil_back_value_mask[0]))
}
if ((oldctx->gl_stencil_back_fail[0] != newctx->gl_stencil_back_fail[0]) ||
(oldctx->gl_stencil_back_pass_depth_fail[0] != newctx->gl_stencil_back_pass_depth_fail[0]) ||
(oldctx->gl_stencil_back_pass_depth_pass[0] != newctx->gl_stencil_back_pass_depth_pass[0]))
{
- _sym_glStencilOpSeparate(GL_BACK,
- newctx->gl_stencil_back_fail[0],
- newctx->gl_stencil_back_pass_depth_fail[0],
- newctx->gl_stencil_back_pass_depth_pass[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_BACK,
+ newctx->gl_stencil_back_fail[0],
+ newctx->gl_stencil_back_pass_depth_fail[0],
+ newctx->gl_stencil_back_pass_depth_pass[0]))
}
STATE_COMPARE(gl_stencil_back_writemask[0])
{
- _sym_glStencilMaskSeparate(GL_BACK, newctx->gl_stencil_back_writemask[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_BACK, newctx->gl_stencil_back_writemask[0]))
}
STATE_COMPARE(gl_stencil_clear_value[0])
{
- _sym_glClearStencil(newctx->gl_stencil_clear_value[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glClearStencil(newctx->gl_stencil_clear_value[0]))
}
}
{
STATE_COMPARE(gl_front_face[0])
{
- _sym_glFrontFace(newctx->gl_front_face[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glFrontFace(newctx->gl_front_face[0]))
}
STATE_COMPARE(gl_line_width[0])
{
- _sym_glLineWidth(newctx->gl_line_width[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glLineWidth(newctx->gl_line_width[0]))
}
if ((oldctx->gl_polygon_offset_factor[0] != newctx->gl_polygon_offset_factor[0]) ||
(oldctx->gl_polygon_offset_units[0] != newctx->gl_polygon_offset_units[0]))
{
- _sym_glPolygonOffset(newctx->gl_polygon_offset_factor[0],
- newctx->gl_polygon_offset_units[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glPolygonOffset(newctx->gl_polygon_offset_factor[0],
+ newctx->gl_polygon_offset_units[0]))
}
if ((oldctx->gl_sample_coverage_value[0] != newctx->gl_sample_coverage_value[0]) ||
(oldctx->gl_sample_coverage_invert[0] != newctx->gl_sample_coverage_invert[0]))
{
- _sym_glSampleCoverage(newctx->gl_sample_coverage_value[0],
- newctx->gl_sample_coverage_invert[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glSampleCoverage(newctx->gl_sample_coverage_value[0],
+ newctx->gl_sample_coverage_invert[0]))
}
}
{
STATES_COMPARE(gl_scissor_box, 4 * sizeof(GLint))
{
- _sym_glScissor(newctx->gl_scissor_box[0],
- newctx->gl_scissor_box[1],
- newctx->gl_scissor_box[2],
- newctx->gl_scissor_box[3]);
+ CHECK_GL_ERROR(_orig_fastpath_glScissor(newctx->gl_scissor_box[0],
+ newctx->gl_scissor_box[1],
+ newctx->gl_scissor_box[2],
+ newctx->gl_scissor_box[3]))
}
STATE_COMPARE(gl_pack_alignment[0])
{
- _sym_glPixelStorei(GL_PACK_ALIGNMENT, newctx->gl_pack_alignment[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_ALIGNMENT, newctx->gl_pack_alignment[0]))
}
STATE_COMPARE(gl_unpack_alignment[0])
{
- _sym_glPixelStorei(GL_UNPACK_ALIGNMENT, newctx->gl_unpack_alignment[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_ALIGNMENT, newctx->gl_unpack_alignment[0]))
}
}
#ifdef COREGL_USE_MODULE_TRACEPATH
{
if (newctx->gl_vertex_array_buf_id[i] != oldctx->gl_vertex_array_buf_id[i])
{
- _sym_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_vertex_array_buf_id[i]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_vertex_array_buf_id[i]))
+ }
+ else
+ {
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, 0))
}
- else _sym_glBindBuffer(GL_ARRAY_BUFFER, 0);
- _sym_glVertexAttribPointer(i,
- newctx->gl_vertex_array_size[i],
- newctx->gl_vertex_array_type[i],
- newctx->gl_vertex_array_normalized[i],
- newctx->gl_vertex_array_stride[i],
- newctx->gl_vertex_array_pointer[i]);
+ CHECK_GL_ERROR(_orig_fastpath_glVertexAttribPointer(i,
+ newctx->gl_vertex_array_size[i],
+ newctx->gl_vertex_array_type[i],
+ newctx->gl_vertex_array_normalized[i],
+ newctx->gl_vertex_array_stride[i],
+ newctx->gl_vertex_array_pointer[i]))
STATES_COMPARE(gl_vertex_attrib_value + 4 * i, 4 * sizeof(GLfloat))
{
- _sym_glVertexAttrib4fv(i, &newctx->gl_vertex_attrib_value[4 * i]);
+ CHECK_GL_ERROR(_orig_fastpath_glVertexAttrib4fv(i, &newctx->gl_vertex_attrib_value[4 * i]))
}
if (newctx->gl_vertex_array_enabled[i] == GL_TRUE)
{
- _sym_glEnableVertexAttribArray(i);
+ CHECK_GL_ERROR(_orig_fastpath_glEnableVertexAttribArray(i))
}
else
{
- _sym_glDisableVertexAttribArray(i);
+ CHECK_GL_ERROR(_orig_fastpath_glDisableVertexAttribArray(i))
}
}
STATE_COMPARE(gl_array_buffer_binding[0])
{
- _sym_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_array_buffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_array_buffer_binding[0]))
}
STATE_COMPARE(gl_element_array_buffer_binding[0])
{
- _sym_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, newctx->gl_element_array_buffer_binding[0]);
+ CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, newctx->gl_element_array_buffer_binding[0]))
}
}
tracepath_api_trace_end("eglMakeCurrent(FP vertex attrib)", trace_hint_vertex_attrib, 0);
#endif // COREGL_USE_MODULE_TRACEPATH
+ ret = 1;
goto finish;
finish:
if (unlikely(trace_state_flag == 1))
fastpath_dump_context_states(newctx, 0);
#endif // COREGL_FASTPATH_TRACE_STATE_INFO
- return;
+ return ret;
#undef STATE_COMPARE
#undef STATES_COMPARE
}
{
GLuint id;
GLuint real_id;
+ GLint ref_count;
+ GLvoid *tag;
struct _GL_Shared_Object_State *parent;
} GL_Object;
typedef struct _GL_Shared_Object_State
{
- int ref_count;
+ int ref_count;
+ General_Trace_List *using_gctxs;
GL_Object *texture[MAX_GL_OBJECT_SIZE];
GL_Object *buffer[MAX_GL_OBJECT_SIZE];
extern void fastpath_apply_overrides_gl(int enable);
extern int fastpath_init_context_states(GLGlueContext *ctx);
-extern void fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx);
+extern int fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx);
#ifdef COREGL_FASTPATH_TRACE_STATE_INFO
extern void fastpath_dump_context_states(GLGlueContext *ctx, int force_output);
extern GLuint fastpath_sostate_remove_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name);
extern GLuint fastpath_sostate_get_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint name);
extern GLuint fastpath_sostate_find_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint real_name);
+extern GLint fastpath_sostate_use_object(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name);
+extern GLint fastpath_sostate_set_object_tag(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name, GLvoid *tag);
+extern GLvoid *fastpath_sostate_get_object_tag(GL_Shared_Object_State *sostate, GL_Object_Type type, GLuint glue_name);
+// GL context management functions
+extern void fastpath_release_gl_context(GLGlueContext *gctx);
#endif // COREGL_FASTPATH_H
}
static void
-_add_shared_obj_state_ref(GL_Shared_Object_State *sostate)
+_add_shared_obj_state_ref(GLGlueContext *gctx, GL_Shared_Object_State *sostate)
{
AST(sostate->ref_count >= 0);
sostate->ref_count++;
+ add_to_general_trace_list(&sostate->using_gctxs, gctx);
}
static void
-_remove_shared_obj_state_ref(GL_Shared_Object_State *sostate)
+_remove_shared_obj_state_ref(GLGlueContext *gctx, GL_Shared_Object_State *sostate)
{
+ remove_from_general_trace_list(&sostate->using_gctxs, gctx);
+
+ // Restore attached states
+ fastpath_release_gl_context(gctx);
+
AST(sostate->ref_count > 0);
sostate->ref_count--;
if (sostate->ref_count == 0)
_unlink_context_state(gctx, ctx_list_mtx);
AST(gctx->sostate != NULL);
- _remove_shared_obj_state_ref(gctx->sostate);
+ _remove_shared_obj_state_ref(gctx, gctx->sostate);
gctx->sostate = NULL;
if (gctx->real_ctx_option != NULL)
}
}
-static void
+static int
_bind_context_state(GLGlueContext *gctx, GLContextState *cstate, Mutex *ctx_list_mtx)
{
if (gctx != NULL)
AST(newctx != NULL);
AST(curctx != NULL);
- fastpath_make_context_current(curctx, newctx);
+ if (!fastpath_make_context_current(curctx, newctx))
+ return 0;
+
cstate->data = (void *)newctx;
_remove_context_ref(curctx, ctx_list_mtx);
_add_context_ref(newctx);
}
+ return 1;
+
}
GLContextState *
{
EGLenum newapi = _orig_fastpath_eglQueryAPI();
- if (tstate->binded_api != newapi)
+ if (tstate->binded_api != EGL_OPENGL_ES_API)
{
- if (newapi != EGL_OPENGL_ES_API)
- {
- // Fallback when binding other API
- // Fastpath restores when bind OPENGL_ES_API
- fastpath_apply_overrides_egl(0);
- ovr_eglBindAPI = fastpath_eglBindAPI;
- ovr_eglQueryAPI = fastpath_eglQueryAPI;
- }
- else
- {
- fastpath_apply_overrides_egl(1);
- }
tstate->binded_api = newapi;
}
}
ERR("\E[40;31;1mERROR : Error creating a new GLGlueContext(Memory full 4)\E[0m\n");
goto finish;
}
+ sostate_new->using_gctxs = NULL;
gctx->sostate = sostate_new;
}
- _add_shared_obj_state_ref(gctx->sostate);
+ _add_shared_obj_state_ref(gctx, gctx->sostate);
gctx->real_ctx_option = real_ctx_option;
gctx->real_ctx_option_len = sizeof(EGL_packed_option);
gctx->real_ctx_sharable_option = real_ctx_sharable_option;
if (tstate->cstate != NULL)
{
- _bind_context_state(NULL, tstate->cstate, &ctx_list_access_mutex);
+ if (_bind_context_state(NULL, tstate->cstate, &ctx_list_access_mutex) != 1)
+ {
+ ERR("\E[40;31;1mWARNING : Error soft-makecurrent for context deletion\E[0m\n");
+ }
tstate->cstate = NULL;
}
if (_orig_fastpath_eglMakeCurrent(dpy, draw, read, ctx) != EGL_TRUE)
AST(cstate_new != NULL);
- _bind_context_state(gctx, cstate_new, &ctx_list_access_mutex);
+ if (_bind_context_state(gctx, cstate_new, &ctx_list_access_mutex) != 1)
+ {
+ ERR("\E[40;31;1mWARNING : Error soft-makecurrent in Cross-thread usage!\E[0m\n");
+ free(cstate_new);
+ _orig_fastpath_eglDestroyContext(dpy, new_real_ctx);
+ ret = EGL_FALSE;
+ goto finish;
+ }
// TODO : Setup context state for new real ctx
ERR("\E[40;31;1mWARNING : Cross-thread usage(makecurrent) can cause a state-broken situation!\E[0m\n");
gctx->surface_attached = 1;
}
- _bind_context_state(gctx, tstate->cstate, &ctx_list_access_mutex);
+ if (_bind_context_state(gctx, tstate->cstate, &ctx_list_access_mutex) != 1)
+ {
+ ret = EGL_FALSE;
+ goto finish;
+ }
gctx->used_count++;
ret = EGL_TRUE;
#define CURR_STATE_COMPARE(curr_state, state ) \
if ((current_ctx->curr_state[0]) != (state))
+#define IF_GL_SUCCESS(orig_gl_func) \
+ _get_gl_error(); \
+ orig_gl_func; \
+ if (_get_gl_error() == GL_NO_ERROR)
+
#define DEFINE_FASTPAH_GL_FUNC() \
MY_MODULE_TSTATE *tstate = NULL; \
GLGlueContext *current_ctx = NULL;
return 1;
}
-static void
-_set_gl_error(GLenum error)
+static inline GLenum
+_get_gl_error()
{
GLenum glerror = GL_NONE;
DEFINE_FASTPAH_GL_FUNC();
glerror = _orig_fastpath_glGetError();
- if (current_ctx->gl_error == GL_NO_ERROR &&
- glerror == GL_NO_ERROR &&
- error != GL_NO_ERROR)
+ if (current_ctx->gl_error == GL_NO_ERROR && glerror != GL_NO_ERROR)
+ {
+ current_ctx->gl_error = glerror;
+ }
+ goto finish;
+
+finish:
+ return glerror;
+}
+
+static inline void
+_set_gl_error(GLenum error)
+{
+ DEFINE_FASTPAH_GL_FUNC();
+ INIT_FASTPATH_GL_FUNC();
+
+ _get_gl_error();
+
+ if (current_ctx->gl_error == GL_NO_ERROR && error != GL_NO_ERROR)
{
current_ctx->gl_error = error;
}
return;
}
+typedef struct
+{
+ GLsizei shader_count;
+ GLuint shaders[10];
+ GLuint is_deleting;
+} Program_object_attached_tag;
+
+GLuint
+_create_program_object(GL_Shared_Object_State *sostate, int is_program, GLenum shader_type)
+{
+ GLuint ret = 0;
+ GLuint real_obj = 0;
+
+ if (is_program == 1)
+ real_obj = _orig_fastpath_glCreateProgram();
+ else
+ real_obj = _orig_fastpath_glCreateShader(shader_type);
+
+ if (real_obj != 0)
+ {
+ ret = fastpath_sostate_create_object(sostate, GL_OBJECT_TYPE_PROGRAM, real_obj);
+
+ Program_object_attached_tag *poat = NULL;
+ poat = (Program_object_attached_tag *)calloc(1, sizeof(Program_object_attached_tag));
+ AST(poat != NULL);
+
+ poat->is_deleting = 0;
+ poat->shader_count = 0;
+
+ fastpath_sostate_set_object_tag(sostate, GL_OBJECT_TYPE_PROGRAM, ret, poat);
+ }
+
+ return ret;
+}
+
+static void
+_update_program_attach_info(GL_Shared_Object_State *sostate, GLuint program)
+{
+ Program_object_attached_tag *poat = NULL;
+ GLuint real_program = _COREGL_INT_INIT_VALUE;
+
+ poat = (Program_object_attached_tag *)fastpath_sostate_get_object_tag(sostate, GL_OBJECT_TYPE_PROGRAM, program);
+ AST(poat != NULL);
+
+ real_program = fastpath_sostate_get_object(sostate, GL_OBJECT_TYPE_PROGRAM, program);
+ AST(real_program > 0);
+
+ _orig_fastpath_glGetAttachedShaders(real_program, 10, &poat->shader_count, poat->shaders);
+}
+
+static void
+_attach_program_object(GL_Shared_Object_State *sostate, GLuint object)
+{
+ if (object != 0)
+ {
+ fastpath_sostate_use_object(sostate, GL_OBJECT_TYPE_PROGRAM, object);
+ }
+}
+
+static int
+_is_deleted_program_object(GL_Shared_Object_State *sostate, GLuint glue_object)
+{
+ Program_object_attached_tag *poat = NULL;
+ poat = (Program_object_attached_tag *)fastpath_sostate_get_object_tag(sostate, GL_OBJECT_TYPE_PROGRAM, glue_object);
+ AST(poat != NULL);
+ return poat->is_deleting;
+}
+
+static void
+_detach_program_object(GL_Shared_Object_State *sostate, GLuint real_object, int is_program, int is_deleting)
+{
+ if (real_object != 0)
+ {
+ GLuint object = _COREGL_INT_INIT_VALUE;
+ Program_object_attached_tag *poat = NULL;
+
+ object = fastpath_sostate_find_object(sostate, GL_OBJECT_TYPE_PROGRAM, real_object);
+ AST(object != 0);
+
+ poat = (Program_object_attached_tag *)fastpath_sostate_get_object_tag(sostate, GL_OBJECT_TYPE_PROGRAM, object);
+ AST(poat != NULL);
+
+ if (is_deleting == 1)
+ {
+ if (poat->is_deleting == 0)
+ {
+ poat->is_deleting = 1;
+ fastpath_sostate_remove_object(sostate, GL_OBJECT_TYPE_PROGRAM, object);
+ }
+ }
+ else
+ {
+ fastpath_sostate_remove_object(sostate, GL_OBJECT_TYPE_PROGRAM, object);
+ }
+
+ if (fastpath_sostate_get_object(sostate, GL_OBJECT_TYPE_PROGRAM, object) == 0)
+ {
+ // Is completely removed. De-referencing attached shader objects
+ int i;
+ for (i = 0; i < poat->shader_count; i++)
+ {
+ GLuint glue_shader = fastpath_sostate_find_object(sostate, GL_OBJECT_TYPE_PROGRAM, poat->shaders[i]);
+ fastpath_sostate_remove_object(sostate, GL_OBJECT_TYPE_PROGRAM, glue_shader);
+ }
+
+ poat = NULL;
+ free(poat);
+
+ if (is_program == 1)
+ _orig_fastpath_glDeleteProgram(real_object);
+ else
+ _orig_fastpath_glDeleteShader(real_object);
+ }
+ }
+}
+
+
+void
+fastpath_release_gl_context(GLGlueContext *gctx)
+{
+ // Release program
+ if (gctx->gl_current_program[0] != 0)
+ {
+ _detach_program_object(gctx->sostate, gctx->gl_current_program[0], 1, 0);
+ gctx->gl_current_program[0] = 0;
+ }
+}
+
GLenum
fastpath_glGetError(void)
{
{
ret = current_ctx->gl_error;
current_ctx->gl_error = GL_NO_ERROR;
+ _orig_fastpath_glGetError();
}
else
{
CURR_STATE_COMPARE(gl_active_texture, texture)
{
- _orig_fastpath_glActiveTexture(texture);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_tex_flag1 |= FLAG_BIT_1;
- current_ctx->gl_active_texture[0] = texture;
+ IF_GL_SUCCESS(_orig_fastpath_glActiveTexture(texture))
+ {
+ current_ctx->_tex_flag1 |= FLAG_BIT_1;
+ current_ctx->gl_active_texture[0] = texture;
+ }
}
goto finish;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (textures == NULL) goto finish;
AST(current_ctx->sostate != NULL);
{
if (current_ctx->gl_tex_2d_state[active_idx] != real_obj)
{
- _orig_fastpath_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;
+ IF_GL_SUCCESS(_orig_fastpath_glBindTexture(target, real_obj))
+ {
+ 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)
{
- _orig_fastpath_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;
+ IF_GL_SUCCESS(_orig_fastpath_glBindTexture(target, real_obj))
+ {
+ current_ctx->_tex_flag1 |= FLAG_BIT_4;
+ current_ctx->gl_tex_cube_state[active_idx] = real_obj;
+ }
}
}
+ else
+ {
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
+ }
goto finish;
finish:
_orig_fastpath_glFramebufferTexture2D(target, attachment, textarget, real_obj, level);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
_orig_fastpath_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, real_obj, level, samples);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
ret = _orig_fastpath_glIsTexture(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (textures == NULL) goto finish;
AST(current_ctx->sostate != NULL);
real_objid = fastpath_sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
if (real_objid == 0) continue;
- fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]);
+ AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_TEXTURE, textures[i]) == 1);
objid_array[real_n++] = real_objid;
}
- _orig_fastpath_glDeleteTextures(real_n, objid_array);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- for (i = 0; i < real_n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glDeleteTextures(real_n, objid_array))
{
- for (j = 0; j < current_ctx->gl_num_tex_units[0]; j++)
+ for (i = 0; i < real_n; i++)
{
- 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;
+ General_Trace_List *current = NULL;
+ current = current_ctx->sostate->using_gctxs;
+
+ while (current != NULL)
+ {
+ GLGlueContext *cur_gctx = (GLGlueContext *)current->value;
+
+ for (j = 0; j < cur_gctx->gl_num_tex_units[0]; j++)
+ {
+ if (cur_gctx->gl_tex_2d_state[j] == objid_array[i])
+ cur_gctx->gl_tex_2d_state[j] = 0;
+ if (cur_gctx->gl_tex_cube_state[j] == objid_array[i])
+ cur_gctx->gl_tex_cube_state[j] = 0;
+ }
+
+ current = current->next;
+ }
}
}
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (buffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
- _orig_fastpath_glGenBuffers(n, objid_array);
-
- for (i = 0; i < n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glGenBuffers(n, objid_array))
{
- buffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, objid_array[i]);
+ for (i = 0; i < n; i++)
+ {
+ buffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, objid_array[i]);
+ }
}
goto finish;
{
CURR_STATE_COMPARE(gl_array_buffer_binding, real_obj)
{
- _orig_fastpath_glBindBuffer(target, real_obj);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ IF_GL_SUCCESS(_orig_fastpath_glBindBuffer(target, real_obj))
+ {
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_0);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_0;
- 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;
+ 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)
{
- _orig_fastpath_glBindBuffer(target, real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ IF_GL_SUCCESS(_orig_fastpath_glBindBuffer(target, real_obj))
+ {
+ if (real_obj == 0)
+ current_ctx->_bind_flag &= (~FLAG_BIT_1);
+ else
+ current_ctx->_bind_flag |= FLAG_BIT_1;
- 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;
+ current_ctx->gl_element_array_buffer_binding[0] = real_obj;
+ }
}
}
else
{
- // For error recording
- _orig_fastpath_glBindBuffer(target, real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
+
goto finish;
finish:
ret = _orig_fastpath_glIsBuffer(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (buffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
real_objid = fastpath_sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, buffers[i]);
if (real_objid == 0) continue;
- fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, buffers[i]);
+ AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_BUFFER, buffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
- _orig_fastpath_glDeleteBuffers(real_n, objid_array);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- for (i = 0; i < real_n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glDeleteBuffers(real_n, objid_array))
{
- 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])
+ for (i = 0; i < real_n; i++)
{
- current_ctx->_bind_flag &= (~FLAG_BIT_1);
- current_ctx->gl_element_array_buffer_binding[0] = 0;
+ General_Trace_List *current = NULL;
+ current = current_ctx->sostate->using_gctxs;
+
+ while (current != NULL)
+ {
+ GLGlueContext *cur_gctx = (GLGlueContext *)current->value;
+
+ if (cur_gctx->gl_array_buffer_binding[0] == objid_array[i])
+ {
+ cur_gctx->_bind_flag &= (~FLAG_BIT_0);
+ cur_gctx->gl_array_buffer_binding[0] = 0;
+ }
+ if (cur_gctx->gl_element_array_buffer_binding[0] == objid_array[i])
+ {
+ cur_gctx->_bind_flag &= (~FLAG_BIT_1);
+ cur_gctx->gl_element_array_buffer_binding[0] = 0;
+ }
+
+ current = current->next;
+ }
}
}
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (framebuffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
- _orig_fastpath_glGenFramebuffers(n, objid_array);
-
- for (i = 0; i < n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glGenFramebuffers(n, objid_array))
{
- framebuffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
+ for (i = 0; i < n; i++)
+ {
+ framebuffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, objid_array[i]);
+ }
}
goto finish;
{
CURR_STATE_COMPARE(gl_framebuffer_binding, real_obj)
{
- _orig_fastpath_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;
+ IF_GL_SUCCESS(_orig_fastpath_glBindFramebuffer(target, real_obj))
+ {
+ 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
- _orig_fastpath_glBindFramebuffer(target, real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
ret = _orig_fastpath_glIsFramebuffer(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (framebuffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
real_objid = fastpath_sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
if (real_objid == 0) continue;
- fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]);
+ AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_FRAMEBUFFER, framebuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
- _orig_fastpath_glDeleteFramebuffers(real_n, objid_array);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- for (i = 0; i < real_n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glDeleteFramebuffers(real_n, objid_array))
{
- if (current_ctx->gl_framebuffer_binding[0] == framebuffers[i])
+ for (i = 0; i < real_n; i++)
{
- current_ctx->_bind_flag &= (~FLAG_BIT_2);
- current_ctx->gl_framebuffer_binding[0] = 0;
+ General_Trace_List *current = NULL;
+ current = current_ctx->sostate->using_gctxs;
+
+ while (current != NULL)
+ {
+ GLGlueContext *cur_gctx = (GLGlueContext *)current->value;
+
+ if (cur_gctx->gl_framebuffer_binding[0] == framebuffers[i])
+ {
+ cur_gctx->_bind_flag &= (~FLAG_BIT_2);
+ cur_gctx->gl_framebuffer_binding[0] = 0;
+ }
+
+ current = current->next;
+ }
}
}
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (renderbuffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
objid_array = (GLuint *)calloc(1, sizeof(GLuint) * n);
- _orig_fastpath_glGenRenderbuffers(n, objid_array);
-
- for (i = 0; i < n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glGenRenderbuffers(n, objid_array))
{
- renderbuffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
+ for (i = 0; i < n; i++)
+ {
+ renderbuffers[i] = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, objid_array[i]);
+ }
}
goto finish;
{
CURR_STATE_COMPARE(gl_renderbuffer_binding, real_obj)
{
- _orig_fastpath_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;
+ IF_GL_SUCCESS(_orig_fastpath_glBindRenderbuffer(target, real_obj))
+ {
+ 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
- _orig_fastpath_glBindRenderbuffer(target, real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
+
goto finish;
finish:
_orig_fastpath_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
ret = _orig_fastpath_glIsRenderbuffer(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (renderbuffers == NULL) goto finish;
AST(current_ctx->sostate != NULL);
real_objid = fastpath_sostate_get_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
if (real_objid == 0) continue;
- fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]);
+ AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_RENDERBUFFER, renderbuffers[i]) == 1);
objid_array[real_n++] = real_objid;
}
- _orig_fastpath_glDeleteRenderbuffers(real_n, objid_array);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- for (i = 0; i < real_n; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glDeleteRenderbuffers(real_n, objid_array))
{
- if (current_ctx->gl_renderbuffer_binding[0] == renderbuffers[i])
+ for (i = 0; i < real_n; i++)
{
- current_ctx->_bind_flag &= (~FLAG_BIT_3);
- current_ctx->gl_renderbuffer_binding[0] = 0;
+ General_Trace_List *current = NULL;
+ current = current_ctx->sostate->using_gctxs;
+
+ while (current != NULL)
+ {
+ GLGlueContext *cur_gctx = (GLGlueContext *)current->value;
+
+ if (cur_gctx->gl_renderbuffer_binding[0] == renderbuffers[i])
+ {
+ cur_gctx->_bind_flag &= (~FLAG_BIT_3);
+ cur_gctx->gl_renderbuffer_binding[0] = 0;
+ }
+
+ current = current->next;
+ }
}
}
}
GLuint
fastpath_glCreateProgram(void)
{
- GLuint ret = _COREGL_INT_INIT_VALUE;
- GLuint real_obj = _COREGL_INT_INIT_VALUE;
+ GLuint ret = 0;
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
AST(current_ctx->sostate != NULL);
- real_obj = _orig_fastpath_glCreateProgram();
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ ret = _create_program_object(current_ctx->sostate, 1, GL_NONE);
- ret = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, real_obj);
+ _attach_program_object(current_ctx->sostate, ret);
goto finish;
GLuint
fastpath_glCreateShader(GLenum type)
{
- GLuint ret = _COREGL_INT_INIT_VALUE;
- GLuint real_obj = _COREGL_INT_INIT_VALUE;
+ GLuint ret = 0;
DEFINE_FASTPAH_GL_FUNC();
_COREGL_FASTPATH_FUNC_BEGIN();
AST(current_ctx->sostate != NULL);
- real_obj = _orig_fastpath_glCreateShader(type);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ ret = _create_program_object(current_ctx->sostate, 0, type);
- ret = fastpath_sostate_create_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, real_obj);
+ _attach_program_object(current_ctx->sostate, ret);
goto finish;
goto finish;
}
_orig_fastpath_glShaderSource(real_obj, count, string, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
+ if (n < 0)
+ {
+ _set_gl_error(GL_INVALID_VALUE);
+ goto finish;
+ }
+ if (n == 0) goto finish;
if (shaders == NULL) goto finish;
AST(current_ctx->sostate != NULL);
}
_orig_fastpath_glShaderBinary(n, objid_array, binaryformat, binary, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glCompileShader(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glBindAttribLocation(real_obj, index, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glAttachShader(real_obj_program, real_obj_shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ IF_GL_SUCCESS(_orig_fastpath_glAttachShader(real_obj_program, real_obj_shader))
+ {
+ _update_program_attach_info(current_ctx->sostate, program);
+ _attach_program_object(current_ctx->sostate, shader);
+ }
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glDetachShader(real_obj_program, real_obj_shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ IF_GL_SUCCESS(_orig_fastpath_glDetachShader(real_obj_program, real_obj_shader))
+ {
+ _update_program_attach_info(current_ctx->sostate, program);
+ _detach_program_object(current_ctx->sostate, real_obj_shader, 0, 0);
+ }
+
goto finish;
finish:
}
ret = _orig_fastpath_glIsShader(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
ret = _orig_fastpath_glIsProgram(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glLinkProgram(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glValidateProgram(real_obj);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
CURR_STATE_COMPARE(gl_current_program, real_obj)
{
- _orig_fastpath_glUseProgram(real_obj);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ IF_GL_SUCCESS(_orig_fastpath_glUseProgram(real_obj))
+ {
+ _attach_program_object(current_ctx->sostate, program);
+ _detach_program_object(current_ctx->sostate, current_ctx->gl_current_program[0], 1, 0);
- current_ctx->_clear_flag1 |= FLAG_BIT_1;
- current_ctx->gl_current_program[0] = real_obj;
+ current_ctx->_clear_flag1 |= FLAG_BIT_1;
+ current_ctx->gl_current_program[0] = real_obj;
+ }
}
goto finish;
}
_orig_fastpath_glGetActiveAttrib(real_obj, index, bufsize, length, size, type, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glGetActiveUniform(real_obj, index, bufsize, length, size, type, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glGetAttachedShaders(real_obj, maxcount, &real_count, shaders);
-
- for (i = 0; i < real_count; i++)
+ IF_GL_SUCCESS(_orig_fastpath_glGetAttachedShaders(real_obj, maxcount, &real_count, shaders))
{
- if (shaders[i] != 0)
- shaders[i] = fastpath_sostate_find_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shaders[i]);
+ for (i = 0; i < real_count; i++)
+ {
+ if (shaders[i] != 0)
+ shaders[i] = fastpath_sostate_find_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shaders[i]);
+ }
+ if (count != NULL) *count = real_count;
}
- if (count != NULL) *count = real_count;
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
}
ret = _orig_fastpath_glGetAttribLocation(real_obj, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glGetShaderiv(real_obj, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ switch (pname)
+ {
+ case GL_DELETE_STATUS:
+ *params = GL_FALSE;
+ if (_is_deleted_program_object(current_ctx->sostate, shader) == 1)
+ *params = GL_TRUE;
+ break;
+ default:
+ _orig_fastpath_glGetShaderiv(real_obj, pname, params);
+ break;
+ }
+
goto finish;
finish:
}
_orig_fastpath_glGetShaderInfoLog(real_obj, bufsize, length, infolog);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glGetProgramiv(real_obj, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ switch (pname)
+ {
+ case GL_DELETE_STATUS:
+ *params = GL_FALSE;
+ if (_is_deleted_program_object(current_ctx->sostate, program) == 1)
+ *params = GL_TRUE;
+ break;
+ default:
+ _orig_fastpath_glGetProgramiv(real_obj, pname, params);
+ break;
+ }
+
goto finish;
finish:
}
_orig_fastpath_glGetProgramInfoLog(real_obj, bufsize, length, infolog);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glGetShaderSource(real_obj, bufsize, length, source);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glGetUniformfv(real_obj, location, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glGetUniformiv(real_obj, location, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glGetProgramBinary(real_obj, bufsize, length, binaryFormat, binary);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glProgramBinary(real_obj, binaryFormat, binary, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
_orig_fastpath_glProgramParameteri(real_obj, pname, value);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
}
ret = _orig_fastpath_glGetUniformLocation(real_obj, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glDeleteShader(real_obj);
- if (real_obj != 0)
- {
- AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, shader) == 1);
- }
+ _detach_program_object(current_ctx->sostate, real_obj, 0, 1);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
goto finish;
}
- _orig_fastpath_glDeleteProgram(real_obj);
- if (real_obj != 0)
- {
- AST(fastpath_sostate_remove_object(current_ctx->sostate, GL_OBJECT_TYPE_PROGRAM, program) == 1);
- }
+ _detach_program_object(current_ctx->sostate, real_obj, 1, 1);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
goto finish;
finish:
(current_ctx->gl_blend_color[2] != blue) ||
(current_ctx->gl_blend_color[3] != alpha))
{
- _orig_fastpath_glBlendColor(red, green, blue, alpha);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_blend_flag |= FLAG_BIT_0;
- current_ctx->gl_blend_color[0] = red;
- current_ctx->gl_blend_color[1] = green;
- current_ctx->gl_blend_color[2] = blue;
- current_ctx->gl_blend_color[3] = alpha;
+ IF_GL_SUCCESS(_orig_fastpath_glBlendColor(red, green, blue, alpha))
+ {
+ current_ctx->_blend_flag |= FLAG_BIT_0;
+ current_ctx->gl_blend_color[0] = red;
+ current_ctx->gl_blend_color[1] = green;
+ current_ctx->gl_blend_color[2] = blue;
+ current_ctx->gl_blend_color[3] = alpha;
+ }
}
goto finish;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glBlendEquation(mode);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_blend_flag |= (FLAG_BIT_5 | FLAG_BIT_6);
- _orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*) & (current_ctx->gl_blend_equation_rgb));
- _orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*) & (current_ctx->gl_blend_equation_alpha));
+ IF_GL_SUCCESS(_orig_fastpath_glBlendEquation(mode))
+ {
+ current_ctx->_blend_flag |= (FLAG_BIT_5 | FLAG_BIT_6);
+ _orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_RGB, (GLint*) & (current_ctx->gl_blend_equation_rgb));
+ _orig_fastpath_glGetIntegerv(GL_BLEND_EQUATION_ALPHA, (GLint*) & (current_ctx->gl_blend_equation_alpha));
+ }
goto finish;
finish:
if ((current_ctx->gl_blend_equation_rgb[0] != modeRGB) ||
(current_ctx->gl_blend_equation_alpha[0] != modeAlpha))
{
- _orig_fastpath_glBlendEquationSeparate(modeRGB, modeAlpha);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_blend_flag |= (FLAG_BIT_5 | FLAG_BIT_6);
- current_ctx->gl_blend_equation_rgb[0] = modeRGB;
- current_ctx->gl_blend_equation_alpha[0] = modeAlpha;
+ IF_GL_SUCCESS(_orig_fastpath_glBlendEquationSeparate(modeRGB, modeAlpha))
+ {
+ current_ctx->_blend_flag |= (FLAG_BIT_5 | FLAG_BIT_6);
+ current_ctx->gl_blend_equation_rgb[0] = modeRGB;
+ current_ctx->gl_blend_equation_alpha[0] = modeAlpha;
+ }
}
goto finish;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glBlendFunc(sfactor, dfactor);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_blend_flag |= (FLAG_BIT_1 | FLAG_BIT_2 | FLAG_BIT_3 | FLAG_BIT_4);
- _orig_fastpath_glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*) & (current_ctx->gl_blend_src_rgb));
- _orig_fastpath_glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*) & (current_ctx->gl_blend_src_alpha));
- _orig_fastpath_glGetIntegerv(GL_BLEND_DST_RGB, (GLint*) & (current_ctx->gl_blend_dst_rgb));
- _orig_fastpath_glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*) & (current_ctx->gl_blend_dst_alpha));
+ IF_GL_SUCCESS(_orig_fastpath_glBlendFunc(sfactor, dfactor))
+ {
+ current_ctx->_blend_flag |= (FLAG_BIT_1 | FLAG_BIT_2 | FLAG_BIT_3 | FLAG_BIT_4);
+ _orig_fastpath_glGetIntegerv(GL_BLEND_SRC_RGB, (GLint*) & (current_ctx->gl_blend_src_rgb));
+ _orig_fastpath_glGetIntegerv(GL_BLEND_SRC_ALPHA, (GLint*) & (current_ctx->gl_blend_src_alpha));
+ _orig_fastpath_glGetIntegerv(GL_BLEND_DST_RGB, (GLint*) & (current_ctx->gl_blend_dst_rgb));
+ _orig_fastpath_glGetIntegerv(GL_BLEND_DST_ALPHA, (GLint*) & (current_ctx->gl_blend_dst_alpha));
+ }
goto finish;
finish:
(current_ctx->gl_blend_src_alpha[0] != srcAlpha) ||
(current_ctx->gl_blend_dst_alpha[0] != dstAlpha))
{
- _orig_fastpath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_blend_flag |= (FLAG_BIT_1 | FLAG_BIT_2 | FLAG_BIT_3 | FLAG_BIT_4);
- current_ctx->gl_blend_src_rgb[0] = srcRGB;
- current_ctx->gl_blend_dst_rgb[0] = dstRGB;
- current_ctx->gl_blend_src_alpha[0] = srcAlpha;
- current_ctx->gl_blend_dst_alpha[0] = dstAlpha;
+ IF_GL_SUCCESS(_orig_fastpath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha))
+ {
+ current_ctx->_blend_flag |= (FLAG_BIT_1 | FLAG_BIT_2 | FLAG_BIT_3 | FLAG_BIT_4);
+ current_ctx->gl_blend_src_rgb[0] = srcRGB;
+ current_ctx->gl_blend_dst_rgb[0] = dstRGB;
+ current_ctx->gl_blend_src_alpha[0] = srcAlpha;
+ current_ctx->gl_blend_dst_alpha[0] = dstAlpha;
+ }
}
goto finish;
(current_ctx->gl_color_clear_value[2] != blue) ||
(current_ctx->gl_color_clear_value[3] != alpha))
{
- _orig_fastpath_glClearColor(red, green, blue, alpha);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag1 |= (FLAG_BIT_2);
- current_ctx->gl_color_clear_value[0] = red;
- current_ctx->gl_color_clear_value[1] = green;
- current_ctx->gl_color_clear_value[2] = blue;
- current_ctx->gl_color_clear_value[3] = alpha;
+ IF_GL_SUCCESS(_orig_fastpath_glClearColor(red, green, blue, alpha))
+ {
+ current_ctx->_clear_flag1 |= (FLAG_BIT_2);
+ current_ctx->gl_color_clear_value[0] = red;
+ current_ctx->gl_color_clear_value[1] = green;
+ current_ctx->gl_color_clear_value[2] = blue;
+ current_ctx->gl_color_clear_value[3] = alpha;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_depth_clear_value, depth)
{
- _orig_fastpath_glClearDepthf(depth);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_2;
- current_ctx->gl_depth_clear_value[0] = depth;
+ IF_GL_SUCCESS(_orig_fastpath_glClearDepthf(depth))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_2;
+ current_ctx->gl_depth_clear_value[0] = depth;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_stencil_clear_value, s)
{
- _orig_fastpath_glClearStencil(s);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag2 |= FLAG_BIT_7;
- current_ctx->gl_stencil_clear_value[0] = s;
+ IF_GL_SUCCESS(_orig_fastpath_glClearStencil(s))
+ {
+ current_ctx->_stencil_flag2 |= FLAG_BIT_7;
+ current_ctx->gl_stencil_clear_value[0] = s;
+ }
}
goto finish;
(current_ctx->gl_color_writemask[2] != blue) ||
(current_ctx->gl_color_writemask[3] != alpha))
{
- _orig_fastpath_glColorMask(red, green, blue, alpha);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_0;
- current_ctx->gl_color_writemask[0] = red;
- current_ctx->gl_color_writemask[1] = green;
- current_ctx->gl_color_writemask[2] = blue;
- current_ctx->gl_color_writemask[3] = alpha;
+ IF_GL_SUCCESS(_orig_fastpath_glColorMask(red, green, blue, alpha))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_0;
+ current_ctx->gl_color_writemask[0] = red;
+ current_ctx->gl_color_writemask[1] = green;
+ current_ctx->gl_color_writemask[2] = blue;
+ current_ctx->gl_color_writemask[3] = alpha;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_cull_face_mode, mode)
{
- _orig_fastpath_glCullFace(mode);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_5;
- current_ctx->gl_cull_face_mode[0] = mode;
+ IF_GL_SUCCESS(_orig_fastpath_glCullFace(mode))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_5;
+ current_ctx->gl_cull_face_mode[0] = mode;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_depth_func, func)
{
- _orig_fastpath_glDepthFunc(func);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_3;
- current_ctx->gl_depth_func[0] = func;
+ IF_GL_SUCCESS(_orig_fastpath_glDepthFunc(func))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_3;
+ current_ctx->gl_depth_func[0] = func;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_depth_writemask, flag)
{
- _orig_fastpath_glDepthMask(flag);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_4;
- current_ctx->gl_depth_writemask[0] = flag;
+ IF_GL_SUCCESS(_orig_fastpath_glDepthMask(flag))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_4;
+ current_ctx->gl_depth_writemask[0] = flag;
+ }
}
goto finish;
if ((current_ctx->gl_depth_range[0] != zNear) ||
(current_ctx->gl_depth_range[1] != zFar))
{
- _orig_fastpath_glDepthRangef(zNear, zFar);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag2 |= FLAG_BIT_1;
- current_ctx->gl_depth_range[0] = zNear;
- current_ctx->gl_depth_range[1] = zFar;
+ IF_GL_SUCCESS(_orig_fastpath_glDepthRangef(zNear, zFar))
+ {
+ current_ctx->_clear_flag2 |= FLAG_BIT_1;
+ current_ctx->gl_depth_range[0] = zNear;
+ current_ctx->gl_depth_range[1] = zFar;
+ }
}
goto finish;
CURR_STATE_COMPARE(gl_blend, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag1 &= (~FLAG_BIT_0);
current_ctx->gl_blend[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_cull_face, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag1 &= (~FLAG_BIT_1);
current_ctx->gl_cull_face[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_depth_test, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag1 &= (~FLAG_BIT_2);
current_ctx->gl_depth_test[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_dither, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag1 &= (~FLAG_BIT_3);
current_ctx->gl_dither[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_polygon_offset_fill, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag2 &= (~FLAG_BIT_0);
current_ctx->gl_polygon_offset_fill[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_sample_alpha_to_coverage, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag2 &= (~FLAG_BIT_1);
current_ctx->gl_sample_alpha_to_coverage[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_sample_coverage, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag2 &= (~FLAG_BIT_2);
current_ctx->gl_sample_coverage[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_scissor_test, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag2 &= (~FLAG_BIT_3);
current_ctx->gl_scissor_test[0] = GL_FALSE;
}
CURR_STATE_COMPARE(gl_stencil_test, GL_FALSE)
{
_orig_fastpath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
current_ctx->_enable_flag2 &= (~FLAG_BIT_4);
current_ctx->gl_stencil_test[0] = GL_FALSE;
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glDisableVertexAttribArray(index);
-
- current_ctx->_vattrib_flag |= FLAG_BIT_1;
- current_ctx->gl_vertex_array_enabled[index] = GL_FALSE;
-
- goto finish;
-
-finish:
- _COREGL_FASTPATH_FUNC_END();
-}
-
-
-void
-fastpath_glDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
- DEFINE_FASTPAH_GL_FUNC();
- _COREGL_FASTPATH_FUNC_BEGIN();
- INIT_FASTPATH_GL_FUNC();
-
- _orig_fastpath_glDrawArrays(mode, first, count);
- goto finish;
-
-finish:
- _COREGL_FASTPATH_FUNC_END();
-}
-
-
-void
-fastpath_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
-{
- DEFINE_FASTPAH_GL_FUNC();
- _COREGL_FASTPATH_FUNC_BEGIN();
- INIT_FASTPATH_GL_FUNC();
+ IF_GL_SUCCESS(_orig_fastpath_glDisableVertexAttribArray(index))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_1;
+ current_ctx->gl_vertex_array_enabled[index] = GL_FALSE;
+ }
- _orig_fastpath_glDrawElements(mode, count, type, indices);
goto finish;
finish:
_COREGL_FASTPATH_FUNC_END();
}
-
void
fastpath_glEnable(GLenum cap)
{
CURR_STATE_COMPARE(gl_blend, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
current_ctx->_enable_flag1 |= FLAG_BIT_0;
current_ctx->gl_blend[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_cull_face, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag1 |= FLAG_BIT_1;
current_ctx->gl_cull_face[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_depth_test, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag1 |= FLAG_BIT_2;
current_ctx->gl_depth_test[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_dither, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag1 |= FLAG_BIT_3;
current_ctx->gl_dither[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_polygon_offset_fill, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag2 |= FLAG_BIT_0;
current_ctx->gl_polygon_offset_fill[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_sample_alpha_to_coverage, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag2 |= FLAG_BIT_1;
current_ctx->gl_sample_alpha_to_coverage[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_sample_coverage, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag2 |= FLAG_BIT_2;
current_ctx->gl_sample_coverage[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_scissor_test, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag2 |= FLAG_BIT_3;
current_ctx->gl_scissor_test[0] = GL_TRUE;
}
CURR_STATE_COMPARE(gl_stencil_test, GL_TRUE)
{
_orig_fastpath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
-
current_ctx->_enable_flag2 |= FLAG_BIT_4;
current_ctx->gl_stencil_test[0] = GL_TRUE;
}
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glEnableVertexAttribArray(index);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_1;
- current_ctx->gl_vertex_array_enabled[index] = GL_TRUE;
+ IF_GL_SUCCESS(_orig_fastpath_glEnableVertexAttribArray(index))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_1;
+ current_ctx->gl_vertex_array_enabled[index] = GL_TRUE;
+ }
goto finish;
CURR_STATE_COMPARE(gl_front_face, mode)
{
- _orig_fastpath_glFrontFace(mode);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag1 |= FLAG_BIT_0;
- current_ctx->gl_front_face[0] = mode;
+ IF_GL_SUCCESS(_orig_fastpath_glFrontFace(mode))
+ {
+ current_ctx->_misc_flag1 |= FLAG_BIT_0;
+ current_ctx->gl_front_face[0] = mode;
+ }
}
goto finish;
_COREGL_FASTPATH_FUNC_END();
}
-
-void
-fastpath_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
-{
- DEFINE_FASTPAH_GL_FUNC();
- _COREGL_FASTPATH_FUNC_BEGIN();
- INIT_FASTPATH_GL_FUNC();
-
- _orig_fastpath_glGetVertexAttribfv(index, pname, params);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
- goto finish;
-
-finish:
- _COREGL_FASTPATH_FUNC_END();
-}
-
-
-void
-fastpath_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
-{
- DEFINE_FASTPAH_GL_FUNC();
- _COREGL_FASTPATH_FUNC_BEGIN();
- INIT_FASTPATH_GL_FUNC();
-
- _orig_fastpath_glGetVertexAttribiv(index, pname, params);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
- goto finish;
-
-finish:
- _COREGL_FASTPATH_FUNC_END();
-}
-
-
-void
-fastpath_glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
-{
- DEFINE_FASTPAH_GL_FUNC();
- _COREGL_FASTPATH_FUNC_BEGIN();
- INIT_FASTPATH_GL_FUNC();
-
- _orig_fastpath_glGetVertexAttribPointerv(index, pname, pointer);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- goto finish;
-
-finish:
- _COREGL_FASTPATH_FUNC_END();
-}
-
// Fix Maybe?
void
fastpath_glHint(GLenum target, GLenum mode)
{
CURR_STATE_COMPARE(gl_generate_mipmap_hint, mode)
{
- _orig_fastpath_glHint(target, mode);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_tex_flag1 |= FLAG_BIT_2;
- current_ctx->gl_generate_mipmap_hint[0] = mode;
+ IF_GL_SUCCESS(_orig_fastpath_glHint(target, mode))
+ {
+ current_ctx->_tex_flag1 |= FLAG_BIT_2;
+ current_ctx->gl_generate_mipmap_hint[0] = mode;
+ }
}
}
else
{
- // For GL Error to be picked up
- _orig_fastpath_glHint(target, mode);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
CURR_STATE_COMPARE(gl_line_width, width)
{
- _orig_fastpath_glLineWidth(width);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag1 |= FLAG_BIT_1;
- current_ctx->gl_line_width[0] = width;
+ IF_GL_SUCCESS(_orig_fastpath_glLineWidth(width))
+ {
+ current_ctx->_misc_flag1 |= FLAG_BIT_1;
+ current_ctx->gl_line_width[0] = width;
+ }
}
goto finish;
{
CURR_STATE_COMPARE(gl_pack_alignment, param)
{
- _orig_fastpath_glPixelStorei(pname, param);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag2 |= FLAG_BIT_1;
- current_ctx->gl_pack_alignment[0] = param;
+ IF_GL_SUCCESS(_orig_fastpath_glPixelStorei(pname, param))
+ {
+ current_ctx->_misc_flag2 |= FLAG_BIT_1;
+ current_ctx->gl_pack_alignment[0] = param;
+ }
}
}
else if (pname == GL_UNPACK_ALIGNMENT)
{
CURR_STATE_COMPARE(gl_unpack_alignment, param)
{
- _orig_fastpath_glPixelStorei(pname, param);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag2 |= FLAG_BIT_2;
- current_ctx->gl_unpack_alignment[0] = param;
+ IF_GL_SUCCESS(_orig_fastpath_glPixelStorei(pname, param))
+ {
+ current_ctx->_misc_flag2 |= FLAG_BIT_2;
+ current_ctx->gl_unpack_alignment[0] = param;
+ }
}
}
else
{
- // For GL Error to be picked up
- _orig_fastpath_glPixelStorei(pname, param);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
if ((current_ctx->gl_polygon_offset_factor[0] != factor) ||
(current_ctx->gl_polygon_offset_units[0] != units))
{
- _orig_fastpath_glPolygonOffset(factor, units);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag1 |= (FLAG_BIT_2 | FLAG_BIT_3);
- current_ctx->gl_polygon_offset_factor[0] = factor;
- current_ctx->gl_polygon_offset_units[0] = units;
+ IF_GL_SUCCESS(_orig_fastpath_glPolygonOffset(factor, units))
+ {
+ current_ctx->_misc_flag1 |= (FLAG_BIT_2 | FLAG_BIT_3);
+ current_ctx->gl_polygon_offset_factor[0] = factor;
+ current_ctx->gl_polygon_offset_units[0] = units;
+ }
}
goto finish;
if ((current_ctx->gl_sample_coverage_value[0] != value) ||
(current_ctx->gl_sample_coverage_invert[0] != invert))
{
- _orig_fastpath_glSampleCoverage(value, invert);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag1 |= (FLAG_BIT_4 | FLAG_BIT_5);
- current_ctx->gl_sample_coverage_value[0] = value;
- current_ctx->gl_sample_coverage_invert[0] = invert;
+ IF_GL_SUCCESS(_orig_fastpath_glSampleCoverage(value, invert))
+ {
+ current_ctx->_misc_flag1 |= (FLAG_BIT_4 | FLAG_BIT_5);
+ current_ctx->gl_sample_coverage_value[0] = value;
+ current_ctx->gl_sample_coverage_invert[0] = invert;
+ }
}
goto finish;
(current_ctx->gl_scissor_box[2] != width) ||
(current_ctx->gl_scissor_box[3] != height))
{
- _orig_fastpath_glScissor(x, y, width, height);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_misc_flag2 |= FLAG_BIT_0;
- current_ctx->gl_scissor_box[0] = x;
- current_ctx->gl_scissor_box[1] = y;
- current_ctx->gl_scissor_box[2] = width;
- current_ctx->gl_scissor_box[3] = height;
+ IF_GL_SUCCESS(_orig_fastpath_glScissor(x, y, width, height))
+ {
+ current_ctx->_misc_flag2 |= FLAG_BIT_0;
+ current_ctx->gl_scissor_box[0] = x;
+ current_ctx->gl_scissor_box[1] = y;
+ current_ctx->gl_scissor_box[2] = width;
+ current_ctx->gl_scissor_box[3] = height;
+ }
}
goto finish;
(current_ctx->gl_stencil_back_ref[0] != ref) ||
(current_ctx->gl_stencil_back_value_mask[0] != mask))
{
- _orig_fastpath_glStencilFunc(func, ref, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
- current_ctx->gl_stencil_func[0] = func;
- current_ctx->gl_stencil_ref[0] = ref;
- current_ctx->gl_stencil_value_mask[0] = mask;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilFunc(func, ref, mask))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
+ current_ctx->gl_stencil_func[0] = func;
+ current_ctx->gl_stencil_ref[0] = ref;
+ current_ctx->gl_stencil_value_mask[0] = mask;
- current_ctx->_stencil_flag2 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
- current_ctx->gl_stencil_back_func[0] = func;
- current_ctx->gl_stencil_back_ref[0] = ref;
- current_ctx->gl_stencil_back_value_mask[0] = mask;
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
+ current_ctx->gl_stencil_back_func[0] = func;
+ current_ctx->gl_stencil_back_ref[0] = ref;
+ current_ctx->gl_stencil_back_value_mask[0] = mask;
+ }
}
goto finish;
(current_ctx->gl_stencil_ref[0] != ref) ||
(current_ctx->gl_stencil_value_mask[0] != mask))
{
- _orig_fastpath_glStencilFuncSeparate(face, func, ref, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
+ IF_GL_SUCCESS(_orig_fastpath_glStencilFuncSeparate(face, func, ref, mask))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
- current_ctx->gl_stencil_func[0] = func;
- current_ctx->gl_stencil_ref[0] = ref;
- current_ctx->gl_stencil_value_mask[0] = mask;
+ current_ctx->gl_stencil_func[0] = func;
+ current_ctx->gl_stencil_ref[0] = ref;
+ current_ctx->gl_stencil_value_mask[0] = mask;
+ }
}
}
else if ((face == GL_BACK) || (face == GL_FRONT_AND_BACK))
(current_ctx->gl_stencil_back_ref[0] != ref) ||
(current_ctx->gl_stencil_back_value_mask[0] != mask))
{
- _orig_fastpath_glStencilFuncSeparate(face, func, ref, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag2 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
+ IF_GL_SUCCESS(_orig_fastpath_glStencilFuncSeparate(face, func, ref, mask))
+ {
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_0 | FLAG_BIT_1 | FLAG_BIT_2);
- current_ctx->gl_stencil_back_func[0] = func;
- current_ctx->gl_stencil_back_ref[0] = ref;
- current_ctx->gl_stencil_back_value_mask[0] = mask;
+ current_ctx->gl_stencil_back_func[0] = func;
+ current_ctx->gl_stencil_back_ref[0] = ref;
+ current_ctx->gl_stencil_back_value_mask[0] = mask;
+ }
}
}
else
{
- // Have GL pick up the error
- _orig_fastpath_glStencilFuncSeparate(face, func, ref, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
if ((current_ctx->gl_stencil_writemask[0] != mask) ||
(current_ctx->gl_stencil_back_writemask[0] != mask))
{
- _orig_fastpath_glStencilMask(mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_6);
- current_ctx->_stencil_flag2 |= (FLAG_BIT_6);
+ IF_GL_SUCCESS(_orig_fastpath_glStencilMask(mask))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_6);
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_6);
- current_ctx->gl_stencil_writemask[0] = mask;
- current_ctx->gl_stencil_back_writemask[0] = mask;
+ current_ctx->gl_stencil_writemask[0] = mask;
+ current_ctx->gl_stencil_back_writemask[0] = mask;
+ }
}
goto finish;
{
if (current_ctx->gl_stencil_writemask[0] != mask)
{
- _orig_fastpath_glStencilMaskSeparate(face, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_6);
- current_ctx->gl_stencil_writemask[0] = mask;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilMaskSeparate(face, mask))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_6);
+ current_ctx->gl_stencil_writemask[0] = mask;
+ }
}
}
else if ((face == GL_BACK) || (face == GL_FRONT_AND_BACK))
{
if (current_ctx->gl_stencil_back_writemask[0] != mask)
{
- _orig_fastpath_glStencilMaskSeparate(face, mask);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag2 |= (FLAG_BIT_6);
- current_ctx->gl_stencil_back_writemask[0] = mask;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilMaskSeparate(face, mask))
+ {
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_6);
+ current_ctx->gl_stencil_back_writemask[0] = mask;
+ }
}
}
else
{
- // Have GL pick up the error
- _orig_fastpath_glStencilMaskSeparate(face, mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
(current_ctx->gl_stencil_back_pass_depth_fail[0] != zfail) ||
(current_ctx->gl_stencil_back_pass_depth_pass[0] != zpass))
{
- _orig_fastpath_glStencilOp(fail, zfail, zpass);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
- current_ctx->gl_stencil_fail[0] = fail;
- current_ctx->gl_stencil_pass_depth_fail[0] = zfail;
- current_ctx->gl_stencil_pass_depth_pass[0] = zpass;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilOp(fail, zfail, zpass))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
+ current_ctx->gl_stencil_fail[0] = fail;
+ current_ctx->gl_stencil_pass_depth_fail[0] = zfail;
+ current_ctx->gl_stencil_pass_depth_pass[0] = zpass;
- current_ctx->_stencil_flag2 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
- current_ctx->gl_stencil_back_fail[0] = fail;
- current_ctx->gl_stencil_back_pass_depth_fail[0] = zfail;
- current_ctx->gl_stencil_back_pass_depth_pass[0] = zpass;
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
+ current_ctx->gl_stencil_back_fail[0] = fail;
+ current_ctx->gl_stencil_back_pass_depth_fail[0] = zfail;
+ current_ctx->gl_stencil_back_pass_depth_pass[0] = zpass;
+ }
}
goto finish;
(current_ctx->gl_stencil_pass_depth_fail[0] != zfail) ||
(current_ctx->gl_stencil_pass_depth_pass[0] != zpass))
{
- _orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag1 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
- current_ctx->gl_stencil_fail[0] = fail;
- current_ctx->gl_stencil_pass_depth_fail[0] = zfail;
- current_ctx->gl_stencil_pass_depth_pass[0] = zpass;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass))
+ {
+ current_ctx->_stencil_flag1 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
+ current_ctx->gl_stencil_fail[0] = fail;
+ current_ctx->gl_stencil_pass_depth_fail[0] = zfail;
+ current_ctx->gl_stencil_pass_depth_pass[0] = zpass;
+ }
}
}
else if ((face == GL_BACK) || (face == GL_FRONT_AND_BACK))
(current_ctx->gl_stencil_back_pass_depth_fail[0] != zfail) ||
(current_ctx->gl_stencil_back_pass_depth_pass[0] != zpass))
{
- _orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_stencil_flag2 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
- current_ctx->gl_stencil_back_fail[0] = fail;
- current_ctx->gl_stencil_back_pass_depth_fail[0] = zfail;
- current_ctx->gl_stencil_back_pass_depth_pass[0] = zpass;
+ IF_GL_SUCCESS(_orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass))
+ {
+ current_ctx->_stencil_flag2 |= (FLAG_BIT_3 | FLAG_BIT_4 | FLAG_BIT_5);
+ current_ctx->gl_stencil_back_fail[0] = fail;
+ current_ctx->gl_stencil_back_pass_depth_fail[0] = zfail;
+ current_ctx->gl_stencil_back_pass_depth_pass[0] = zpass;
+ }
}
}
else
{
- // For picking up error purpose
- _orig_fastpath_glStencilOpSeparate(face, fail, zfail, zpass);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _set_gl_error(GL_INVALID_ENUM);
+ goto finish;
}
goto finish;
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib1f(indx, x);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib1f(indx, x))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib1fv(indx, values);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib1fv(indx, values))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib2f(indx, x, y);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib2f(indx, x, y))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib2fv(indx, values);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib2fv(indx, values))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = 0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib3f(indx, x, y, z);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = z;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib3f(indx, x, y, z))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = z;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib3fv(indx, values);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = values[2];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib3fv(indx, values))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = values[2];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = 1;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib4f(indx, x, y, z, w);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = z;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = w;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib4f(indx, x, y, z, w))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = x;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = y;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = z;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = w;
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttrib4fv(indx, values);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_0;
- current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = values[2];
- current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = values[3];
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttrib4fv(indx, values))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_0;
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 0] = values[0];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 1] = values[1];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 2] = values[2];
+ current_ctx->gl_vertex_attrib_value[indx * 4 + 3] = values[3];
+ }
goto finish;
finish:
_COREGL_FASTPATH_FUNC_BEGIN();
INIT_FASTPATH_GL_FUNC();
- _orig_fastpath_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_vattrib_flag |= FLAG_BIT_1;
+ IF_GL_SUCCESS(_orig_fastpath_glVertexAttribPointer(indx, size, type, normalized, stride, ptr))
+ {
+ current_ctx->_vattrib_flag |= FLAG_BIT_1;
- current_ctx->gl_vertex_array_buf_id[indx] = current_ctx->gl_array_buffer_binding[0];
- current_ctx->gl_vertex_array_size[indx] = size;
- current_ctx->gl_vertex_array_type[indx] = type;
- current_ctx->gl_vertex_array_normalized[indx] = normalized;
- current_ctx->gl_vertex_array_stride[indx] = stride;
- current_ctx->gl_vertex_array_pointer[indx] = (GLvoid *)ptr;
+ current_ctx->gl_vertex_array_buf_id[indx] = current_ctx->gl_array_buffer_binding[0];
+ current_ctx->gl_vertex_array_size[indx] = size;
+ current_ctx->gl_vertex_array_type[indx] = type;
+ current_ctx->gl_vertex_array_normalized[indx] = normalized;
+ current_ctx->gl_vertex_array_stride[indx] = stride;
+ current_ctx->gl_vertex_array_pointer[indx] = (GLvoid *)ptr;
+ }
goto finish;
finish:
(current_ctx->gl_viewport[2] != width) ||
(current_ctx->gl_viewport[3] != height))
{
- _orig_fastpath_glViewport(x, y, width, height);
-
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
- current_ctx->_clear_flag1 |= FLAG_BIT_0;
- current_ctx->gl_viewport[0] = x;
- current_ctx->gl_viewport[1] = y;
- current_ctx->gl_viewport[2] = width;
- current_ctx->gl_viewport[3] = height;
+ IF_GL_SUCCESS(_orig_fastpath_glViewport(x, y, width, height))
+ {
+ current_ctx->_clear_flag1 |= FLAG_BIT_0;
+ current_ctx->gl_viewport[0] = x;
+ current_ctx->gl_viewport[1] = y;
+ current_ctx->gl_viewport[2] = width;
+ current_ctx->gl_viewport[3] = height;
+ }
}
goto finish;
_orig_fastpath_glEGLImageTargetTexture2DOES(target, image);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
-
goto finish;
finish:
GLint real_obj_id = _COREGL_INT_INIT_VALUE;
GLuint glue_obj_id = _COREGL_INT_INIT_VALUE;
GL_Object_Type obj_type = GL_OBJECT_TYPE_UNKNOWN;
- _orig_fastpath_glGetIntegerv(pname, (GLint *)&real_obj_id);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ _orig_fastpath_glGetIntegerv(pname, (GLint *)&real_obj_id);
switch(pname)
{
if (_process_getfunc(pname, params, GL_BOOL) != GL_TRUE)
{
_orig_fastpath_glGetBooleanv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
}
goto finish;
if (_process_getfunc(pname, params, GL_FLOAT) != GL_TRUE)
{
_orig_fastpath_glGetFloatv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
}
goto finish;
if (_process_getfunc(pname, params, GL_INT) != GL_TRUE)
{
_orig_fastpath_glGetIntegerv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
}
goto finish;
}
}
-#define OVERRIDE(f) \
- if (enable == 1) \
- { \
- COREGL_OVERRIDE_API(_orig_tracepath_, f, ovr_); \
- COREGL_OVERRIDE_API(ovr_, f, tracepath_); \
- } \
- else \
- { \
- AST(ovr_##f != NULL); \
- COREGL_OVERRIDE_API(ovr_, f, _orig_tracepath_); \
- _orig_tracepath_##f = NULL; \
- }
-
void
tracepath_apply_overrides_egl(int enable)
{
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) OVERRIDE(FUNC_NAME);
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_tracepath_, FUNC_NAME);
+# include "../../headers/sym_egl.h"
+#undef _COREGL_SYMBOL
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_OVERRIDE(tracepath_, FUNC_NAME);
# include "../../headers/sym_egl.h"
#undef _COREGL_SYMBOL
}
void
tracepath_apply_overrides_gl(int enable)
{
-#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) OVERRIDE(FUNC_NAME);
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_tracepath_, FUNC_NAME);
+# include "../../headers/sym_gl.h"
+#undef _COREGL_SYMBOL
+
+#define _COREGL_SYMBOL(IS_EXTENSION, RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_OVERRIDE(tracepath_, FUNC_NAME);
# include "../../headers/sym_gl.h"
#undef _COREGL_SYMBOL
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glActiveTexture(texture);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glAttachShader(program, shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindAttribLocation(program, index, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindBuffer(target, buffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindFramebuffer(target, framebuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindRenderbuffer(target, renderbuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBindTexture(target, texture);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendColor(red, green, blue, alpha);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendEquation(mode);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendEquationSeparate(modeRGB, modeAlpha);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendFunc(sfactor, dfactor);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBufferData(target, size, data, usage);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glBufferSubData(target, offset, size, data);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glCheckFramebufferStatus(target);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClear(mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearColor(red, green, blue, alpha);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearDepthf(depth);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glClearStencil(s);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glColorMask(red, green, blue, alpha);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompileShader(shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glCreateProgram();
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
GLuint ret = _COREGL_INT_INIT_VALUE;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glCreateShader(type);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glCullFace(mode);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteBuffers(n, buffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteFramebuffers(n, framebuffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteProgram(program);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteRenderbuffers(n, renderbuffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteShader(shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDeleteTextures(n, textures);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDepthFunc(func);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDepthMask(flag);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDepthRangef(zNear, zFar);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDetachShader(program, shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDisable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDisableVertexAttribArray(index);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawArrays(mode, first, count);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDrawElements(mode, count, type, indices);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glEnable(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glEnableVertexAttribArray(index);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFinish();
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFlush();
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture, level);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFrontFace(mode);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetVertexAttribfv(index, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetVertexAttribiv(index, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetVertexAttribPointerv(index, pname, pointer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glHint(target, mode);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGenBuffers(n, buffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGenerateMipmap(target);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGenFramebuffers(n, framebuffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGenRenderbuffers(n, renderbuffers);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGenTextures(n, textures);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
int ret = _COREGL_INT_INIT_VALUE;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glGetAttribLocation(program, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetBooleanv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetBufferParameteriv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetFloatv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetIntegerv(pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramiv(program, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderiv(shader, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glGetString(name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTexParameterfv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetTexParameteriv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetUniformfv(program, location, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetUniformiv(program, location, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glGetUniformLocation(program, name);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsBuffer(buffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsEnabled(cap);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsFramebuffer(framebuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
GLboolean ret;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsProgram(program);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
GLboolean ret;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsRenderbuffer(renderbuffer);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
GLboolean ret;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsShader(shader);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
GLboolean ret;
_COREGL_TRACEPATH_FUNC_BEGIN();
ret = _orig_tracepath_glIsTexture(texture);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glLineWidth(width);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glLinkProgram(program);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glPixelStorei(pname, param);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glPolygonOffset(factor, units);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glReleaseShaderCompiler();
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glRenderbufferStorage(target, internalformat, width, height);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glSampleCoverage(value, invert);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glScissor(x, y, width, height);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glShaderSource(shader, count, string, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilFunc(func, ref, mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilMask(mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilMaskSeparate(face, mask);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilOp(fail, zfail, zpass);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameterf(target, pname, param);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameterfv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameteri(target, pname, param);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexParameteriv(target, pname, params);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform1f(location, x);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform1fv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform1i(location, x);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform1iv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform2f(location, x, y);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform2fv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform2i(location, x, y);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform2iv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform3f(location, x, y, z);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform3fv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform3i(location, x, y, z);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform3iv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4f(location, x, y, z, w);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4fv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4i(location, x, y, z, w);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniform4iv(location, count, v);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glUseProgram(program);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glValidateProgram(program);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib1f(indx, x);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib1fv(indx, values);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib2f(indx, x, y);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib2fv(indx, values);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib3f(indx, x, y, z);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib3fv(indx, values);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib4f(indx, x, y, z, w);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttrib4fv(indx, values);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glViewport(x, y, width, height);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glGetProgramBinary(program, bufsize, length, binaryFormat, binary);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glProgramParameteri(program, pname, value);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
{
_COREGL_TRACEPATH_FUNC_BEGIN();
_orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
- GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+
goto finish;
finish:
projects / platform / core / uifw / coregl.git / commitdiff