1 #include "coregl_fastpath.h"
10 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) RET_TYPE (*_orig_fastpath_##FUNC_NAME) PARAM_LIST = NULL;
11 #include "../../headers/sym.h"
14 Fastpath_Opt_Flag fp_opt = FP_UNKNOWN_PATH;
17 FILE *trace_fp = NULL;
19 GLenum FPGL_Error = GL_NO_ERROR;
21 GLGlueContext_List *gctx_list = NULL;
23 Mutex init_context_mutex = MUTEX_INITIALIZER;
24 GLGlueContext *initial_ctx = NULL;
26 Mutex ctx_list_access_mutex = MUTEX_INITIALIZER;
28 GLContext_List *glctx_list = NULL;
29 static int api_gl_version=COREGL_GLAPI_2;
32 _state_get_texture_states(GLenum pname, GLint *params)
34 GLuint cur_active_tex = 0;
36 AST(initial_ctx != NULL);
38 _orig_fastpath_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)&cur_active_tex);
40 for (i = 0; i < initial_ctx->gl_num_tex_units[0]; i++)
42 _orig_fastpath_glActiveTexture(GL_TEXTURE0 + i);
43 _orig_fastpath_glGetIntegerv(pname, (GLint *)¶ms[i]);
45 _orig_fastpath_glActiveTexture(cur_active_tex);
49 _state_get_draw_buffers(GLenum *params)
51 AST(initial_ctx != NULL);
54 for (i = 0; i < initial_ctx->gl_num_draw_buffers[0]; i++)
56 _orig_fastpath_glGetIntegerv(GL_DRAW_BUFFER0 + i, (GLint *)¶ms[i]);
61 _state_get_transform_feedback_buffer_bindings(GLuint *params)
63 AST(initial_ctx != NULL);
66 for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0]; i++)
68 _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i, (GLint *)¶ms[i]);
73 _state_get_transform_feedback_buffer_bindings_offset(GLintptr *params)
75 AST(initial_ctx != NULL);
78 for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0]; i++)
80 _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_START, i, (GLint *)¶ms[i]);
85 _state_get_transform_feedback_buffer_bindings_size(GLsizeiptr *params)
87 AST(initial_ctx != NULL);
90 for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0]; i++)
92 _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i, (GLint *)¶ms[i]);
97 _state_get_uniform_buffer_bindings(GLuint *params)
99 AST(initial_ctx != NULL);
102 for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++)
104 /////////////////////////////////////////////////////////////////////////////////
105 // XXXX : AVOID SEGFAULT in ADRENO
106 ((GLint *)params)[i] = 0;
107 // _orig_fastpath_glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, i, (GLint *)¶ms[i]);
108 /////////////////////////////////////////////////////////////////////////////////
113 _state_get_uniform_buffer_bindings_offset(GLintptr *params)
115 AST(initial_ctx != NULL);
118 for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++)
120 _orig_fastpath_glGetIntegeri_v(GL_UNIFORM_BUFFER_START, i, (GLint *)¶ms[i]);
125 _state_get_uniform_buffer_bindings_size(GLsizeiptr *params)
127 AST(initial_ctx != NULL);
130 for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++)
132 _orig_fastpath_glGetIntegeri_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint *)¶ms[i]);
137 fastpath_state_get_draw_buffers(GLenum *params)
139 _state_get_draw_buffers(params);
143 init_modules_fastpath()
145 int fastpath_opt = 0;
146 int fastpath_force_off_opt = 0;
148 COREGL_LOG("[CoreGL] <Fastpath> : ");
150 fastpath_opt = atoi(get_env_setting("COREGL_FASTPATH"));
151 fastpath_force_off_opt = atoi(get_env_setting("COREGL_FASTPATH_FORCE_OFF"));
153 if (fastpath_force_off_opt == 1)
155 COREGL_LOG("\E[40;31;1m(DISABLED by force option)\E[0m ");
159 switch (fastpath_opt)
162 COREGL_LOG("(%d) Fastpath enabled...\n", fastpath_opt);
163 fp_opt = FP_FAST_PATH;
166 COREGL_LOG("(%d) Default API path enabled...\n", fastpath_opt);
167 fp_opt = FP_NORMAL_PATH;
171 debug_nofp = atoi(get_env_setting("COREGL_DEBUG_NOFP"));
176 deinit_modules_fastpath()
178 GLContext_List *current = NULL;
180 AST(mutex_lock(&ctx_list_access_mutex) == 1);
182 // Destroy remained context & Detect leaks
183 int retry_destroy = 0;
188 current = glctx_list;
191 if (current->cstate != NULL)
193 COREGL_WRN("\E[40;31;1mContext attached to [dpy=%p|rctx=%p] has not been completely destroyed.(leak)\E[0m\n", current->cstate->rdpy, current->cstate->rctx);
195 _orig_fastpath_eglMakeCurrent(current->cstate->rdpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
196 _orig_fastpath_eglDestroyContext(current->cstate->rdpy, current->cstate->rctx);
198 fastpath_remove_context_states_from_list(current->cstate, NULL);
203 glctx_list = current->next;
205 current = glctx_list;
207 if (retry_destroy == 0) break;
212 AST(mutex_unlock(&ctx_list_access_mutex) == 1);
216 init_modules_tstate_fastpath(GLThreadState *tstate)
218 MY_MODULE_TSTATE *tstate_mt = NULL;
220 tstate_mt = (MY_MODULE_TSTATE *)calloc(1, sizeof(MY_MODULE_TSTATE));
222 tstate_mt->binded_api = EGL_OPENGL_ES_API;
224 tstate->module_data[MY_MODULE_ID] = tstate_mt;
228 deinit_modules_tstate_fastpath(GLThreadState *tstate)
230 if (tstate->module_data[MY_MODULE_ID] != NULL)
232 free(tstate->module_data[MY_MODULE_ID]);
233 tstate->module_data[MY_MODULE_ID] = NULL;
238 fastpath_apply_overrides()
243 fastpath_apply_overrides_egl(1);
244 fastpath_apply_overrides_gl(1);
249 COREGL_ERR("Invalide GL Override Option!!!\n");
256 fastpath_apply_overrides_egl(int enable)
258 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) COREGL_INIT_ORIGINAL(_orig_fastpath_, FUNC_NAME);
259 # include "../../headers/sym_egl.h"
260 #undef _COREGL_SYMBOL
262 COREGL_OVERRIDE(fastpath_, eglGetProcAddress);
264 COREGL_OVERRIDE(fastpath_, eglBindAPI);
265 COREGL_OVERRIDE(fastpath_, eglQueryAPI);
267 COREGL_OVERRIDE(fastpath_, eglCreateContext);
268 COREGL_OVERRIDE(fastpath_, eglCreateImageKHR);
269 COREGL_OVERRIDE(fastpath_, eglMakeCurrent);
270 COREGL_OVERRIDE(fastpath_, eglDestroyContext);
271 COREGL_OVERRIDE(fastpath_, eglQueryContext);
272 COREGL_OVERRIDE(fastpath_, eglGetCurrentContext);
273 COREGL_OVERRIDE(fastpath_, eglReleaseThread);
274 COREGL_OVERRIDE(fastpath_, eglGetCurrentSurface);
275 COREGL_OVERRIDE(fastpath_, eglTerminate);
276 COREGL_OVERRIDE(fastpath_, eglGetCurrentDisplay);
281 fastpath_apply_overrides_gl(int enable)
283 #define _COREGL_START_API(version) api_gl_version = version;
284 #define _COREGL_END_API(version) api_gl_version = COREGL_GLAPI_2;
285 #define _COREGL_SYMBOL(RET_TYPE, FUNC_NAME, PARAM_LIST) \
286 if(api_gl_version <= driver_gl_version) COREGL_INIT_ORIGINAL(_orig_fastpath_, FUNC_NAME);
288 # include "../../headers/sym_gl.h"
289 #undef _COREGL_SYMBOL
290 #undef _COREGL_START_API
291 #undef _COREGL_END_API
295 COREGL_OVERRIDE(fastpath_, glGetError);
296 COREGL_OVERRIDE(fastpath_, glGetString);
298 COREGL_OVERRIDE(fastpath_, glGetIntegerv);
299 COREGL_OVERRIDE(fastpath_, glGetFloatv);
300 COREGL_OVERRIDE(fastpath_, glGetBooleanv);
302 COREGL_OVERRIDE(fastpath_, glActiveTexture);
303 COREGL_OVERRIDE(fastpath_, glGenTextures);
304 COREGL_OVERRIDE(fastpath_, glBindTexture);
305 COREGL_OVERRIDE(fastpath_, glIsTexture);
306 COREGL_OVERRIDE(fastpath_, glDeleteTextures);
307 COREGL_OVERRIDE(fastpath_, glFramebufferTexture2D);
309 COREGL_OVERRIDE(fastpath_, glGenBuffers);
310 COREGL_OVERRIDE(fastpath_, glBindBuffer);
311 COREGL_OVERRIDE(fastpath_, glIsBuffer);
312 COREGL_OVERRIDE(fastpath_, glDeleteBuffers);
314 COREGL_OVERRIDE(fastpath_, glGenFramebuffers);
315 COREGL_OVERRIDE(fastpath_, glBindFramebuffer);
316 COREGL_OVERRIDE(fastpath_, glIsFramebuffer);
317 COREGL_OVERRIDE(fastpath_, glDeleteFramebuffers);
318 COREGL_OVERRIDE(fastpath_, glGetFramebufferAttachmentParameteriv);
320 COREGL_OVERRIDE(fastpath_, glGenRenderbuffers);
321 COREGL_OVERRIDE(fastpath_, glBindRenderbuffer);
322 COREGL_OVERRIDE(fastpath_, glFramebufferRenderbuffer);
323 COREGL_OVERRIDE(fastpath_, glIsRenderbuffer);
324 COREGL_OVERRIDE(fastpath_, glDeleteRenderbuffers);
326 COREGL_OVERRIDE(fastpath_, glCreateShader);
327 COREGL_OVERRIDE(fastpath_, glCreateProgram);
328 COREGL_OVERRIDE(fastpath_, glAttachShader);
329 COREGL_OVERRIDE(fastpath_, glCompileShader);
330 COREGL_OVERRIDE(fastpath_, glShaderBinary);
331 COREGL_OVERRIDE(fastpath_, glDeleteShader);
332 COREGL_OVERRIDE(fastpath_, glDetachShader);
333 COREGL_OVERRIDE(fastpath_, glGetShaderiv);
334 COREGL_OVERRIDE(fastpath_, glGetShaderInfoLog);
335 COREGL_OVERRIDE(fastpath_, glGetShaderSource);
336 COREGL_OVERRIDE(fastpath_, glIsShader);
337 COREGL_OVERRIDE(fastpath_, glShaderSource);
338 COREGL_OVERRIDE(fastpath_, glBindAttribLocation);
339 COREGL_OVERRIDE(fastpath_, glDeleteProgram);
340 COREGL_OVERRIDE(fastpath_, glGetActiveAttrib);
341 COREGL_OVERRIDE(fastpath_, glGetActiveUniform);
342 COREGL_OVERRIDE(fastpath_, glGetAttachedShaders);
343 COREGL_OVERRIDE(fastpath_, glGetAttribLocation);
344 COREGL_OVERRIDE(fastpath_, glGetProgramiv);
345 COREGL_OVERRIDE(fastpath_, glGetProgramInfoLog);
346 COREGL_OVERRIDE(fastpath_, glGetUniformfv);
347 COREGL_OVERRIDE(fastpath_, glGetUniformiv);
348 COREGL_OVERRIDE(fastpath_, glGetUniformLocation);
349 COREGL_OVERRIDE(fastpath_, glIsProgram);
350 COREGL_OVERRIDE(fastpath_, glLinkProgram);
351 COREGL_OVERRIDE(fastpath_, glUseProgram);
352 COREGL_OVERRIDE(fastpath_, glValidateProgram);
354 COREGL_OVERRIDE(fastpath_, glBlendColor);
355 COREGL_OVERRIDE(fastpath_, glBlendEquation);
356 COREGL_OVERRIDE(fastpath_, glBlendEquationSeparate);
357 COREGL_OVERRIDE(fastpath_, glBlendFunc);
358 COREGL_OVERRIDE(fastpath_, glBlendFuncSeparate);
359 COREGL_OVERRIDE(fastpath_, glClearColor);
360 COREGL_OVERRIDE(fastpath_, glClearDepthf);
361 COREGL_OVERRIDE(fastpath_, glClearStencil);
362 COREGL_OVERRIDE(fastpath_, glColorMask);
363 COREGL_OVERRIDE(fastpath_, glCullFace);
364 COREGL_OVERRIDE(fastpath_, glDepthFunc);
365 COREGL_OVERRIDE(fastpath_, glDepthMask);
366 COREGL_OVERRIDE(fastpath_, glDepthRangef);
367 COREGL_OVERRIDE(fastpath_, glDisable);
368 COREGL_OVERRIDE(fastpath_, glDisableVertexAttribArray);
369 COREGL_OVERRIDE(fastpath_, glEnable);
370 COREGL_OVERRIDE(fastpath_, glEnableVertexAttribArray);
371 COREGL_OVERRIDE(fastpath_, glFrontFace);
372 COREGL_OVERRIDE(fastpath_, glHint);
373 COREGL_OVERRIDE(fastpath_, glLineWidth);
374 COREGL_OVERRIDE(fastpath_, glPixelStorei);
375 COREGL_OVERRIDE(fastpath_, glPolygonOffset);
376 COREGL_OVERRIDE(fastpath_, glSampleCoverage);
377 COREGL_OVERRIDE(fastpath_, glScissor);
378 COREGL_OVERRIDE(fastpath_, glStencilFunc);
379 COREGL_OVERRIDE(fastpath_, glStencilFuncSeparate);
380 COREGL_OVERRIDE(fastpath_, glStencilMask);
381 COREGL_OVERRIDE(fastpath_, glStencilMaskSeparate);
382 COREGL_OVERRIDE(fastpath_, glStencilOp);
383 COREGL_OVERRIDE(fastpath_, glStencilOpSeparate);
384 COREGL_OVERRIDE(fastpath_, glVertexAttrib1f);
385 COREGL_OVERRIDE(fastpath_, glVertexAttrib1fv);
386 COREGL_OVERRIDE(fastpath_, glVertexAttrib2f);
387 COREGL_OVERRIDE(fastpath_, glVertexAttrib2fv);
388 COREGL_OVERRIDE(fastpath_, glVertexAttrib3f);
389 COREGL_OVERRIDE(fastpath_, glVertexAttrib3fv);
390 COREGL_OVERRIDE(fastpath_, glVertexAttrib4f);
391 COREGL_OVERRIDE(fastpath_, glVertexAttrib4fv);
392 COREGL_OVERRIDE(fastpath_, glVertexAttribPointer);
393 COREGL_OVERRIDE(fastpath_, glViewport);
395 COREGL_OVERRIDE(fastpath_, glGetProgramBinaryOES);
396 COREGL_OVERRIDE(fastpath_, glProgramBinaryOES);
398 COREGL_OVERRIDE(fastpath_, glUseProgramStagesEXT);
399 COREGL_OVERRIDE(fastpath_, glActiveShaderProgramEXT);
400 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
401 COREGL_OVERRIDE(fastpath_, glProgramUniform1iEXT);
402 COREGL_OVERRIDE(fastpath_, glProgramUniform2iEXT);
403 COREGL_OVERRIDE(fastpath_, glProgramUniform3iEXT);
404 COREGL_OVERRIDE(fastpath_, glProgramUniform4iEXT);
405 COREGL_OVERRIDE(fastpath_, glProgramUniform1fEXT);
406 COREGL_OVERRIDE(fastpath_, glProgramUniform2fEXT);
407 COREGL_OVERRIDE(fastpath_, glProgramUniform3fEXT);
408 COREGL_OVERRIDE(fastpath_, glProgramUniform4fEXT);
409 COREGL_OVERRIDE(fastpath_, glProgramUniform1ivEXT);
410 COREGL_OVERRIDE(fastpath_, glProgramUniform2ivEXT);
411 COREGL_OVERRIDE(fastpath_, glProgramUniform3ivEXT);
412 COREGL_OVERRIDE(fastpath_, glProgramUniform4ivEXT);
413 COREGL_OVERRIDE(fastpath_, glProgramUniform1fvEXT);
414 COREGL_OVERRIDE(fastpath_, glProgramUniform2fvEXT);
415 COREGL_OVERRIDE(fastpath_, glProgramUniform3fvEXT);
416 COREGL_OVERRIDE(fastpath_, glProgramUniform4fvEXT);
417 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix2fvEXT);
418 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix3fvEXT);
419 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix4fvEXT);
420 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
421 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
422 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
423 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
424 COREGL_OVERRIDE(fastpath_, glProgramParameteriEXT);
426 COREGL_OVERRIDE(fastpath_, glFramebufferTexture2DMultisampleEXT);
427 COREGL_OVERRIDE(fastpath_, glFramebufferTexture3DOES);
429 /* Start overriding GLES 3.0 */
430 if(driver_gl_version >= COREGL_GLAPI_3) {
431 COREGL_OVERRIDE(fastpath_, glReadBuffer);
433 COREGL_OVERRIDE(fastpath_, glGenQueries);
434 COREGL_OVERRIDE(fastpath_, glDeleteQueries);
435 COREGL_OVERRIDE(fastpath_, glIsQuery);
436 COREGL_OVERRIDE(fastpath_, glBeginQuery);
437 COREGL_OVERRIDE(fastpath_, glGetQueryiv);
438 COREGL_OVERRIDE(fastpath_, glGetQueryObjectuiv);
439 COREGL_OVERRIDE(fastpath_, glDrawBuffers);
440 COREGL_OVERRIDE(fastpath_, glFramebufferTextureLayer);
442 COREGL_OVERRIDE(fastpath_, glBindVertexArray);
443 COREGL_OVERRIDE(fastpath_, glDeleteVertexArrays);
444 COREGL_OVERRIDE(fastpath_, glGenVertexArrays);
445 COREGL_OVERRIDE(fastpath_, glIsVertexArray);
447 COREGL_OVERRIDE(fastpath_, glGetIntegeri_v);
449 COREGL_OVERRIDE(fastpath_, glBindTransformFeedback);
450 COREGL_OVERRIDE(fastpath_, glDeleteTransformFeedbacks);
451 COREGL_OVERRIDE(fastpath_, glGenTransformFeedbacks);
452 COREGL_OVERRIDE(fastpath_, glIsTransformFeedback);
454 COREGL_OVERRIDE(fastpath_, glBindBufferRange);
455 COREGL_OVERRIDE(fastpath_, glBindBufferBase);
456 COREGL_OVERRIDE(fastpath_, glTransformFeedbackVaryings);
457 COREGL_OVERRIDE(fastpath_, glGetTransformFeedbackVarying);
458 COREGL_OVERRIDE(fastpath_, glVertexAttribIPointer);
459 COREGL_OVERRIDE(fastpath_, glVertexAttribI4i);
460 COREGL_OVERRIDE(fastpath_, glVertexAttribI4ui);
461 COREGL_OVERRIDE(fastpath_, glVertexAttribI4iv);
462 COREGL_OVERRIDE(fastpath_, glVertexAttribI4uiv);
463 COREGL_OVERRIDE(fastpath_, glGetUniformuiv);
464 COREGL_OVERRIDE(fastpath_, glGetFragDataLocation);
465 COREGL_OVERRIDE(fastpath_, glGetStringi);
466 COREGL_OVERRIDE(fastpath_, glGetUniformIndices);
467 COREGL_OVERRIDE(fastpath_, glGetActiveUniformsiv);
468 COREGL_OVERRIDE(fastpath_, glGetUniformBlockIndex);
469 COREGL_OVERRIDE(fastpath_, glGetActiveUniformBlockiv);
470 COREGL_OVERRIDE(fastpath_, glGetActiveUniformBlockName);
471 COREGL_OVERRIDE(fastpath_, glUniformBlockBinding);
472 COREGL_OVERRIDE(fastpath_, glGetInteger64v);
473 COREGL_OVERRIDE(fastpath_, glGetInteger64i_v);
474 COREGL_OVERRIDE(fastpath_, glGenSamplers);
475 COREGL_OVERRIDE(fastpath_, glDeleteSamplers);
476 COREGL_OVERRIDE(fastpath_, glIsSampler);
477 COREGL_OVERRIDE(fastpath_, glBindSampler);
478 COREGL_OVERRIDE(fastpath_, glSamplerParameteri);
479 COREGL_OVERRIDE(fastpath_, glSamplerParameteriv);
480 COREGL_OVERRIDE(fastpath_, glSamplerParameterf);
481 COREGL_OVERRIDE(fastpath_, glSamplerParameterfv);
482 COREGL_OVERRIDE(fastpath_, glGetSamplerParameteriv);
483 COREGL_OVERRIDE(fastpath_, glGetSamplerParameterfv);
484 COREGL_OVERRIDE(fastpath_, glVertexAttribDivisor);
485 COREGL_OVERRIDE(fastpath_, glGetProgramBinary);
486 COREGL_OVERRIDE(fastpath_, glProgramBinary);
487 COREGL_OVERRIDE(fastpath_, glProgramParameteri);
490 if(driver_gl_version >= COREGL_GLAPI_31)
492 COREGL_OVERRIDE(fastpath_, glCreateShaderProgramv);
493 COREGL_OVERRIDE(fastpath_, glGenProgramPipelines);
494 COREGL_OVERRIDE(fastpath_, glGetProgramPipelineiv);
495 COREGL_OVERRIDE(fastpath_, glBindProgramPipeline);
496 COREGL_OVERRIDE(fastpath_, glDeleteProgramPipelines);
497 COREGL_OVERRIDE(fastpath_, glIsProgramPipeline);
498 COREGL_OVERRIDE(fastpath_, glValidateProgramPipeline);
499 COREGL_OVERRIDE(fastpath_, glGetProgramPipelineInfoLog);
500 COREGL_OVERRIDE(fastpath_, glDispatchCompute);
501 COREGL_OVERRIDE(fastpath_, glDispatchComputeIndirect);
502 COREGL_OVERRIDE(fastpath_, glGetProgramInterfaceiv);
503 COREGL_OVERRIDE(fastpath_, glGetProgramResourceIndex);
504 COREGL_OVERRIDE(fastpath_, glGetProgramResourceName);
505 COREGL_OVERRIDE(fastpath_, glGetProgramResourceiv);
506 COREGL_OVERRIDE(fastpath_, glGetProgramResourceLocation);
507 COREGL_OVERRIDE(fastpath_, glUseProgramStages);
508 COREGL_OVERRIDE(fastpath_, glActiveShaderProgram);
509 COREGL_OVERRIDE(fastpath_, glProgramUniform1iv);
510 COREGL_OVERRIDE(fastpath_, glProgramUniform2iv);
511 COREGL_OVERRIDE(fastpath_, glProgramUniform3iv);
512 COREGL_OVERRIDE(fastpath_, glProgramUniform4iv);
513 COREGL_OVERRIDE(fastpath_, glProgramUniform1fv);
514 COREGL_OVERRIDE(fastpath_, glProgramUniform2fv);
515 COREGL_OVERRIDE(fastpath_, glProgramUniform3fv);
516 COREGL_OVERRIDE(fastpath_, glProgramUniform4fv);
517 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix2fv);
518 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix3fv);
519 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix4fv);
520 COREGL_OVERRIDE(fastpath_, glProgramUniform1i);
521 COREGL_OVERRIDE(fastpath_, glProgramUniform2i);
522 COREGL_OVERRIDE(fastpath_, glProgramUniform3i);
523 COREGL_OVERRIDE(fastpath_, glProgramUniform4i);
524 COREGL_OVERRIDE(fastpath_, glProgramUniform1f);
525 COREGL_OVERRIDE(fastpath_, glProgramUniform2f);
526 COREGL_OVERRIDE(fastpath_, glProgramUniform3f);
527 COREGL_OVERRIDE(fastpath_, glProgramUniform4f);
528 COREGL_OVERRIDE(fastpath_, glProgramUniform1uiv);
529 COREGL_OVERRIDE(fastpath_, glProgramUniform2uiv);
530 COREGL_OVERRIDE(fastpath_, glProgramUniform3uiv);
531 COREGL_OVERRIDE(fastpath_, glProgramUniform4uiv);
532 COREGL_OVERRIDE(fastpath_, glProgramUniform1ui);
533 COREGL_OVERRIDE(fastpath_, glProgramUniform2ui);
534 COREGL_OVERRIDE(fastpath_, glProgramUniform3ui);
535 COREGL_OVERRIDE(fastpath_, glProgramUniform4ui);
536 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix2x3fv);
537 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix3x2fv);
538 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix4x2fv);
539 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix2x4fv);
540 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix3x4fv);
541 COREGL_OVERRIDE(fastpath_, glProgramUniformMatrix4x3fv);
542 COREGL_OVERRIDE(fastpath_, glBindImageTexture);
543 COREGL_OVERRIDE(fastpath_, glGetBooleani_v);
544 COREGL_OVERRIDE(fastpath_, glMemoryBarrier);
545 COREGL_OVERRIDE(fastpath_, glMemoryBarrierByRegion);
546 COREGL_OVERRIDE(fastpath_, glTexStorage2DMultisample);
547 COREGL_OVERRIDE(fastpath_, glGetMultisamplefv);
548 COREGL_OVERRIDE(fastpath_, glSampleMaski);
549 COREGL_OVERRIDE(fastpath_, glGetTexLevelParameteriv);
550 COREGL_OVERRIDE(fastpath_, glGetTexLevelParameterfv);
551 COREGL_OVERRIDE(fastpath_, glBindVertexBuffer);
552 COREGL_OVERRIDE(fastpath_, glVertexAttribFormat);
553 COREGL_OVERRIDE(fastpath_, glVertexAttribIFormat);
554 COREGL_OVERRIDE(fastpath_, glVertexAttribBinding);
555 COREGL_OVERRIDE(fastpath_, glVertexBindingDivisor);
560 COREGL_LOG("\E[40;35;1m[CoreGL] SKIP GL FASTPATH...\E[0m\n");
566 static inline GL_Object_Hash_Base *
567 _lock_gl_object_hash(GL_Object_State *ostate, GL_Object_Type type)
571 case GL_OBJECT_TYPE_QUERY:
572 return &ostate->query;
573 case GL_OBJECT_TYPE_TEXTURE:
574 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
575 return &ostate->shared->texture;
576 case GL_OBJECT_TYPE_BUFFER:
577 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
578 return &ostate->shared->buffer;
579 case GL_OBJECT_TYPE_FRAMEBUFFER:
580 return &ostate->framebuffer;
581 case GL_OBJECT_TYPE_RENDERBUFFER:
582 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
583 return &ostate->shared->renderbuffer;
584 case GL_OBJECT_TYPE_PROGRAM:
585 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
586 return &ostate->shared->program;
587 case GL_OBJECT_TYPE_VERTEXARRAY:
588 return &ostate->vertexarray;
589 case GL_OBJECT_TYPE_SAMPLER:
590 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
591 return &ostate->shared->sampler;
592 case GL_OBJECT_TYPE_TRANSFORMFEEDBACK:
593 return &ostate->transformfeedback;
594 case GL_OBJECT_TYPE_PROGRAMPIPELINE:
595 AST(mutex_lock(&ostate->shared->access_mutex) == 1);
596 return &ostate->shared->programpipeline;
603 _unlock_gl_object_hash(GL_Object_State *ostate, GL_Object_Type type)
607 case GL_OBJECT_TYPE_TEXTURE:
608 case GL_OBJECT_TYPE_BUFFER:
609 case GL_OBJECT_TYPE_RENDERBUFFER:
610 case GL_OBJECT_TYPE_PROGRAM:
611 case GL_OBJECT_TYPE_SAMPLER:
612 case GL_OBJECT_TYPE_PROGRAMPIPELINE:
613 AST(mutex_unlock(&ostate->shared->access_mutex) == 1);
619 static inline GL_Object_Hash_Base *
620 _lock_gl_object_hash_real(GL_Object_State *ostate, GL_Object_Type type)
624 case GL_OBJECT_TYPE_QUERY:
625 return &ostate->query_real;
626 case GL_OBJECT_TYPE_TEXTURE:
627 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
628 return &ostate->shared->texture_real;
629 case GL_OBJECT_TYPE_BUFFER:
630 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
631 return &ostate->shared->buffer_real;
632 case GL_OBJECT_TYPE_FRAMEBUFFER:
633 return &ostate->framebuffer_real;
634 case GL_OBJECT_TYPE_RENDERBUFFER:
635 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
636 return &ostate->shared->renderbuffer_real;
637 case GL_OBJECT_TYPE_PROGRAM:
638 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
639 return &ostate->shared->program_real;
640 case GL_OBJECT_TYPE_VERTEXARRAY:
641 return &ostate->vertexarray_real;
642 case GL_OBJECT_TYPE_SAMPLER:
643 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
644 return &ostate->shared->sampler_real;
645 case GL_OBJECT_TYPE_TRANSFORMFEEDBACK:
646 return &ostate->transformfeedback_real;
647 case GL_OBJECT_TYPE_PROGRAMPIPELINE:
648 AST(mutex_lock(&ostate->shared->real_access_mutex) == 1);
649 return &ostate->shared->programpipeline_real;
656 _unlock_gl_object_hash_real(GL_Object_State *ostate, GL_Object_Type type)
660 case GL_OBJECT_TYPE_TEXTURE:
661 case GL_OBJECT_TYPE_BUFFER:
662 case GL_OBJECT_TYPE_RENDERBUFFER:
663 case GL_OBJECT_TYPE_PROGRAM:
664 case GL_OBJECT_TYPE_SAMPLER:
665 case GL_OBJECT_TYPE_PROGRAMPIPELINE:
666 AST(mutex_unlock(&ostate->shared->real_access_mutex) == 1);
674 fastpath_add_context_state_to_list(const void *option, const int option_len, GLContextState *cstate, Mutex *mtx)
678 GLContext_List *current = NULL;
679 GLContext_List *newitm = NULL;
681 if (mtx != NULL) AST(mutex_lock(mtx) == 1);
685 tid = get_current_thread();
687 current = glctx_list;
688 while (current != NULL)
690 if (current->option_len == option_len &&
691 memcmp(current->option, option, option_len) == 0 &&
692 current->thread_id == tid)
694 AST(current->cstate == cstate);
697 current = current->next;
700 newitm = (GLContext_List *)calloc(1, sizeof(GLContext_List));
703 COREGL_ERR("Failed to create context list.\n");
707 newitm->cstate = cstate;
708 newitm->thread_id = tid;
709 newitm->option_len = option_len;
710 newitm->option = (void *)malloc(option_len);
711 memcpy(newitm->option, option, option_len);
713 if (glctx_list != NULL)
714 newitm->next = glctx_list;
735 if (mtx != NULL) AST(mutex_unlock(mtx) == 1);
741 fastpath_get_context_state_from_list(const void *option, const int option_len, Mutex *mtx)
743 GLContextState *ret = NULL;
744 GLContext_List *current = NULL;
747 if (mtx != NULL) AST(mutex_lock(mtx) == 1);
749 tid = get_current_thread();
751 current = glctx_list;
752 while (current != NULL)
754 if (current->option_len == option_len &&
755 memcmp(current->option, option, option_len) == 0 &&
756 current->thread_id == tid)
758 ret = current->cstate;
761 current = current->next;
766 if (mtx != NULL) AST(mutex_unlock(mtx) == 1);
771 fastpath_remove_context_states_from_list(GLContextState *cstate, Mutex *mtx)
774 GLContext_List *olditm = NULL;
775 GLContext_List *current = NULL;
777 if (mtx != NULL) AST(mutex_lock(mtx) == 1);
781 current = glctx_list;
783 while (current != NULL)
785 if (current->cstate == cstate)
787 GLContext_List *nextitm = NULL;
790 olditm->next = current->next;
791 nextitm = olditm->next;
795 glctx_list = current->next;
796 nextitm = glctx_list;
798 if (current->option != NULL)
800 AST(current->option_len > 0);
801 free(current->option);
802 current->option = NULL;
803 current->option_len = 0;
811 current = current->next;
816 if (mtx != NULL) AST(mutex_unlock(mtx) == 1);
822 #define HASH_INIT(hash_base) \
823 hash_base.hash_field = (GL_Object_Hash **)calloc(1, sizeof(GL_Object_Hash *) * GL_OBJECT_HASH_BASE); \
824 hash_base.hash_size = GL_OBJECT_HASH_BASE;
827 fastpath_ostate_init(GL_Object_State *ostate)
829 HASH_INIT(ostate->query);
830 HASH_INIT(ostate->framebuffer);
831 HASH_INIT(ostate->vertexarray);
832 HASH_INIT(ostate->transformfeedback);
834 HASH_INIT(ostate->query_real);
835 HASH_INIT(ostate->framebuffer_real);
836 HASH_INIT(ostate->vertexarray_real);
837 HASH_INIT(ostate->transformfeedback_real);
841 fastpath_sostate_init(GL_Shared_Object_State *sostate)
843 mutex_init(&sostate->access_mutex);
845 HASH_INIT(sostate->texture);
846 HASH_INIT(sostate->buffer);
847 HASH_INIT(sostate->renderbuffer);
848 HASH_INIT(sostate->program);
849 HASH_INIT(sostate->sampler);
850 HASH_INIT(sostate->programpipeline);
852 HASH_INIT(sostate->texture_real);
853 HASH_INIT(sostate->buffer_real);
854 HASH_INIT(sostate->renderbuffer_real);
855 HASH_INIT(sostate->program_real);
856 HASH_INIT(sostate->sampler_real);
857 HASH_INIT(sostate->programpipeline_real);
864 _add_hash(GL_Object_Hash_Base *hash_base, GL_Object_Hash *data)
866 int array_idx = data->hash_key & (hash_base->hash_size - 1);
867 if (hash_base->hash_field[array_idx] == NULL)
869 hash_base->hash_field[array_idx] = data;
873 GL_Object_Hash *current = hash_base->hash_field[array_idx];
876 AST(current->hash_key != data->hash_key);
877 current = current->next;
879 current->next = data;
882 hash_base->item_size++;
886 _remove_hash(GL_Object_Hash_Base *hash_base, GLuint hash)
889 int array_idx = hash & (hash_base->hash_size - 1);
891 GL_Object_Hash *current = hash_base->hash_field[array_idx];
892 GL_Object_Hash *prev = NULL;
896 if (current->hash_key == hash)
899 prev->next = current->next;
901 hash_base->hash_field[array_idx] = current->next;
902 hash_base->item_size--;
907 current = current->next;
914 _free_hash_list(GL_Object_Hash_Base *hash_base, int free_data)
916 if (hash_base->item_size == 0) return;
918 for (int i = 0; i < hash_base->hash_size; i++)
920 if (hash_base->hash_field[i] != NULL)
922 GL_Object_Hash *current = hash_base->hash_field[i];
924 while (current != NULL)
926 GL_Object_Hash *current_next = current->next;
928 if (free_data == 1 && current->item != NULL)
934 hash_base->item_size--;
935 current = current_next;
943 #define HASH_DEINIT(hash_base, free_data) \
944 _free_hash_list(&hash_base, free_data); \
945 free(hash_base.hash_field); \
946 hash_base.hash_size = 0;
949 fastpath_ostate_deinit(GL_Object_State *ostate)
951 HASH_DEINIT(ostate->query, 1);
952 HASH_DEINIT(ostate->framebuffer, 1);
953 HASH_DEINIT(ostate->vertexarray, 1);
954 HASH_DEINIT(ostate->transformfeedback, 1);
956 HASH_DEINIT(ostate->query_real, 0);
957 HASH_DEINIT(ostate->framebuffer_real, 0);
958 HASH_DEINIT(ostate->vertexarray_real, 0);
959 HASH_DEINIT(ostate->transformfeedback_real, 0);
963 fastpath_sostate_deinit(GL_Shared_Object_State *sostate)
965 HASH_DEINIT(sostate->texture, 1);
966 HASH_DEINIT(sostate->buffer, 1);
967 HASH_DEINIT(sostate->renderbuffer, 1);
968 HASH_DEINIT(sostate->program, 1);
969 HASH_DEINIT(sostate->sampler, 1);
970 HASH_DEINIT(sostate->programpipeline, 1);
972 HASH_DEINIT(sostate->texture_real, 0);
973 HASH_DEINIT(sostate->buffer_real, 0);
974 HASH_DEINIT(sostate->renderbuffer_real, 0);
975 HASH_DEINIT(sostate->program_real, 0);
976 HASH_DEINIT(sostate->sampler_real, 0);
978 HASH_DEINIT(sostate->programpipeline_real, 0);
985 #define FIND_HASH(hash_base, key, ret) \
987 GL_Object_Hash *fh_current = hash_base->hash_field[(key) & (hash_base->hash_size - 1)]; \
990 if (fh_current->hash_key == (key)) \
995 fh_current = fh_current->next; \
1000 _ostate_hash_check(GL_Object_Hash_Base *hash_base)
1002 if (hash_base->item_size + 1 < hash_base->hash_size)
1005 int oldsize = hash_base->hash_size;
1006 GL_Object_Hash **oldfield = hash_base->hash_field;
1008 hash_base->hash_size = oldsize << 1;
1009 hash_base->hash_field = (GL_Object_Hash **)calloc(1, sizeof(GL_Object_Hash *) * hash_base->hash_size);
1010 AST(hash_base->hash_field != NULL);
1012 for (int i = 0; i < oldsize; i++)
1014 if (oldfield[i] != NULL)
1016 GL_Object_Hash *current = oldfield[i];
1018 while (current != NULL)
1020 GL_Object_Hash *current_next = current->next;
1021 _add_hash(hash_base, current);
1022 hash_base->item_size--;
1023 current = current_next;
1032 fastpath_ostate_create_object(GL_Object_State *ostate, GL_Object_Type type, GLuint real_name)
1034 GLuint ret = _COREGL_INT_INIT_VALUE;
1036 GL_Object_Hash_Base *hash_base = NULL;
1037 GL_Object_Hash_Base *hash_base_real = NULL;
1038 int newid = _COREGL_INT_INIT_VALUE;
1040 hash_base = _lock_gl_object_hash(ostate, type);
1041 hash_base_real = _lock_gl_object_hash_real(ostate, type);
1043 newid = hash_base->last_id + 1;
1044 if (newid >= hash_base->hash_size)
1046 hash_base->is_looped = 1;
1048 hash_base->last_id = 1;
1051 if (hash_base->is_looped != 0)
1054 int findingid = newid;
1056 for (i = 0; i < hash_base->hash_size; i++)
1058 GL_Object_Hash *exist_hash = NULL;
1059 FIND_HASH(hash_base, findingid, exist_hash);
1060 if (exist_hash == NULL)
1066 if (findingid >= hash_base->hash_size) findingid = 1;
1070 hash_base->last_id = newid;
1073 GL_Object *newobj = (GL_Object *)calloc(1, sizeof(GL_Object));
1074 AST(newobj != NULL);
1075 newobj->id = (int)type + newid;
1076 newobj->real_id = real_name;
1077 newobj->ref_count = 1;
1080 GL_Object_Hash *newobj_hash = (GL_Object_Hash *)calloc(1, sizeof(GL_Object_Hash));
1081 AST(newobj_hash != NULL);
1082 newobj_hash->item = newobj;
1083 newobj_hash->hash_key = newid;
1084 _add_hash(hash_base, newobj_hash);
1086 GL_Object_Hash *newobj_hash_real = (GL_Object_Hash *)calloc(1, sizeof(GL_Object_Hash));
1087 AST(newobj_hash_real != NULL);
1088 newobj_hash_real->item = newobj;
1089 newobj_hash_real->hash_key = real_name;
1090 _add_hash(hash_base_real, newobj_hash_real);
1093 _ostate_hash_check(hash_base);
1094 _ostate_hash_check(hash_base_real);
1099 _unlock_gl_object_hash(ostate, type);
1100 _unlock_gl_object_hash_real(ostate, type);
1104 #define FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, hash, object) \
1105 if (((int)(hash)) < 0) { ret = 0; goto finish; } \
1107 GL_Object_Hash *object_hash = NULL; \
1108 FIND_HASH((hash_base), (int)(hash), object_hash); \
1109 if (object_hash == NULL) { ret = 0; goto finish; } \
1110 (object) = object_hash->item; \
1111 if ((object) == NULL) { ret = 0; goto finish; } \
1115 fastpath_ostate_remove_object(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_name)
1117 GLuint ret = _COREGL_INT_INIT_VALUE;
1119 GL_Object_Hash_Base *hash_base = NULL;
1120 GL_Object_Hash_Base *hash_base_real = NULL;
1121 GL_Object *object = NULL;
1123 hash_base = _lock_gl_object_hash(ostate, type);
1124 hash_base_real = _lock_gl_object_hash_real(ostate, type);
1126 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, glue_name - (int)type, object);
1128 object->ref_count--;
1130 if (object->ref_count <= 0)
1132 GL_Object_Hash *object_hash = NULL;
1134 FIND_HASH(hash_base, object->id - (int)type, object_hash);
1135 AST(object_hash != NULL);
1136 _remove_hash(hash_base, object->id - (int)type);
1140 FIND_HASH(hash_base_real, object->real_id, object_hash);
1141 AST(object_hash != NULL);
1142 _remove_hash(hash_base_real, object->real_id);
1154 _unlock_gl_object_hash(ostate, type);
1155 _unlock_gl_object_hash_real(ostate, type);
1160 fastpath_ostate_get_object(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_name)
1162 GLuint ret = _COREGL_INT_INIT_VALUE;
1164 GL_Object_Hash_Base *hash_base = NULL;
1165 GL_Object *object = NULL;
1167 hash_base = _lock_gl_object_hash(ostate, type);
1169 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, glue_name - (int)type, object);
1171 ret = object->real_id;
1175 _unlock_gl_object_hash(ostate, type);
1180 /* Check if the context's state contains object of a given type */
1182 fastpath_ostate_has_object_type(GL_Object_State *ostate, GL_Object_Type type)
1184 GLuint ret = _COREGL_INT_INIT_VALUE;
1186 GL_Object_Hash_Base *hash_base = NULL;
1187 GL_Object *object = NULL;
1188 hash_base = _lock_gl_object_hash(ostate, type);
1190 if(hash_base->hash_field == 0)
1196 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, 1, object);
1198 ret = object->real_id;
1202 _unlock_gl_object_hash(ostate, type);
1208 fastpath_ostate_set_object_tag(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_name, GLvoid *tag)
1210 GLint ret = _COREGL_INT_INIT_VALUE;
1212 GL_Object_Hash_Base *hash_base = NULL;
1213 GL_Object *object = NULL;
1214 int hash = _COREGL_INT_INIT_VALUE;
1216 hash_base = _lock_gl_object_hash(ostate, type);
1218 hash = glue_name - (int)type;
1220 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, hash, object);
1222 AST(object->tag == NULL);
1228 _unlock_gl_object_hash(ostate, type);
1233 fastpath_ostate_get_object_tag(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_name)
1237 GL_Object_Hash_Base *hash_base = NULL;
1238 GL_Object *object = NULL;
1240 hash_base = _lock_gl_object_hash(ostate, type);
1242 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, glue_name - (int)type, object);
1248 _unlock_gl_object_hash(ostate, type);
1253 fastpath_ostate_find_object(GL_Object_State *ostate, GL_Object_Type type, GLuint real_name)
1255 GLuint ret = _COREGL_INT_INIT_VALUE;
1257 GL_Object_Hash_Base *hash_base_real = NULL;
1258 GL_Object *object = NULL;
1260 hash_base_real = _lock_gl_object_hash_real(ostate, type);
1262 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base_real, real_name, object);
1268 _unlock_gl_object_hash_real(ostate, type);
1273 fastpath_ostate_use_object(GL_Object_State *ostate, GL_Object_Type type, GLuint glue_name)
1275 GLint ret = _COREGL_INT_INIT_VALUE;
1277 GL_Object_Hash_Base *hash_base = NULL;
1278 GL_Object *object = NULL;
1280 hash_base = _lock_gl_object_hash(ostate, type);
1282 FIND_OBJ_FROM_HASH_WITH_VERIFY(hash_base, glue_name - (int)type, object);
1284 object->ref_count++;
1289 _unlock_gl_object_hash(ostate, type);
1294 fastpath_dump_context_states(GLGlueContext *ctx, int force_output)
1296 static struct timeval tv_last = { 0, 0 };
1298 if (unlikely(trace_state_flag != 1)) return;
1302 struct timeval tv_now = { 0, 0 };
1303 AST(gettimeofday(&tv_now, NULL) == 0);
1304 if (tv_now.tv_sec - tv_last.tv_sec < _COREGL_TRACE_OUTPUT_INTERVAL_SEC)
1312 TRACE("\E[0;40;34m========================================================================================================================\E[0m\n");
1313 TRACE("\E[40;32;1m State info \E[1;37;1m: <PID = %d> GlueCTX = %p\E[0m\n", getpid(), ctx);
1314 TRACE("\E[0;40;34m========================================================================================================================\E[0m\n");
1316 #define PRINTF_CHAR_GLenum "0x%8X"
1317 #define PRINTF_CHAR_GLboolean "%10d"
1318 #define PRINTF_CHAR_GLint "%10d"
1319 #define PRINTF_CHAR_GLsizei "%10u"
1320 #define PRINTF_CHAR_GLuint "%10u"
1321 #define PRINTF_CHAR_GLuintmask "0x%8X"
1322 #define PRINTF_CHAR_GLintptr "%10ld"
1323 #define PRINTF_CHAR_GLsizeiptr "%10ld"
1325 #define PRINTF_CHAR_GLclampf "%10.6f"
1326 #define PRINTF_CHAR_GLfloat "%10.6f"
1328 #define PRINTF_CHAR_GLvoidptr "%10p"
1330 #define PRINTF_CHAR(type) PRINTF_CHAR_##type
1332 #define _COREGL_START_API(version) api_gl_version = version;
1333 #define _COREGL_END_API(version) api_gl_version = COREGL_GLAPI_2;
1334 #define INITIAL_CTX initial_ctx
1335 #define GLUE_STATE(TYPE, NAME, SIZE, ARRAY_SIZE, DEFAULT_STMT, GET_STMT) \
1337 TYPE valuedata[SIZE]; \
1338 TYPE *value = NULL; \
1339 if(api_gl_version <= driver_gl_version) { \
1340 value = valuedata; GET_STMT; value = valuedata; \
1341 TRACE("\E[40;37;1m %-30.30s : (\E[0m ", #NAME); \
1342 for (int i = 0; i < SIZE; i++) \
1346 TRACE("\n %-30.30s ", "");\
1350 if (ctx->NAME[i] != value[i]) { TRACE("\E[40;31;1m"); } \
1351 TRACE(PRINTF_CHAR(TYPE), ctx->NAME[i]); \
1352 TRACE("["PRINTF_CHAR(TYPE)"]", value[i]); \
1353 if (ctx->NAME[i] != value[i]) { TRACE("\E[0m"); } \
1355 TRACE(" \E[40;37;1m)\E[0m\n"); \
1358 # include "coregl_fastpath_state.h"
1361 #undef _COREGL_START_API
1362 #undef _COREGL_END_API
1364 TRACE("\E[0;40;34m========================================================================================================================\E[0m\n");
1374 fastpath_init_context_states(GLGlueContext *ctx)
1378 AST(mutex_lock(&init_context_mutex) == 1);
1382 COREGL_ERR("Context NULL\n");
1387 AST(ctx->initialized == 0);
1388 AST(ctx->ostate.shared != NULL);
1390 if (initial_ctx == NULL)
1392 initial_ctx = (GLGlueContext *)calloc(1, sizeof(GLGlueContext));
1393 AST(initial_ctx != NULL);
1395 //#define FORCE_DEFAULT_VALUE
1396 #define _COREGL_START_API(version) api_gl_version = version;
1397 #define _COREGL_END_API(version) api_gl_version = COREGL_GLAPI_2;
1398 #ifdef FORCE_DEFAULT_VALUE
1399 # define INITIAL_CTX initial_ctx
1400 # define GLUE_STATE(TYPE, NAME, SIZE, ARRAY_SIZE, DEFAULT_STMT, GET_STMT) \
1403 TYPE valuedata[SIZE]; \
1404 TYPE *value = NULL; \
1405 memset(valuedata, 0xcc, sizeof(TYPE) * SIZE); \
1406 if(api_gl_version <= driver_gl_version) { \
1407 value = valuedata; DEFAULT_STMT; value = valuedata; \
1408 for (i = 0; i < SIZE; i++) \
1410 if (*((char *)(&value[i])) == 0xcc) \
1412 memset(&value[i], 0xaa, sizeof(TYPE)); \
1413 value = valuedata; DEFAULT_STMT; value = valuedata; \
1414 if (*((char *)(&value[i])) == 0xaa) \
1416 COREGL_WRN("\E[40;31;1mGL-state '"#NAME"' cannot be retrieved\E[0m\n"); \
1420 initial_ctx->NAME[i] = value[i]; \
1424 # include "coregl_fastpath_state.h"
1428 # define INITIAL_CTX initial_ctx
1429 # define SET_GLUE_VALUE(DEFAULT_STMT, FALLBACK_STMT) \
1430 if (try_step == 1) \
1432 value = valuedata; DEFAULT_STMT; value = valuedata; \
1436 value = valuedata; FALLBACK_STMT; value = valuedata; \
1439 # define GLUE_STATE(TYPE, NAME, SIZE, ARRAY_SIZE, DEFAULT_STMT, GET_STMT) \
1443 TYPE valuedata[SIZE]; \
1444 TYPE *value = NULL; \
1445 _sym_glGetError(); \
1446 memset(valuedata, 0xcc, sizeof(TYPE) * SIZE); \
1447 if(api_gl_version <= driver_gl_version) { \
1450 SET_GLUE_VALUE(GET_STMT, DEFAULT_STMT); \
1451 if (_sym_glGetError() == GL_INVALID_ENUM) \
1453 initial_ctx->NAME##_used = 0; \
1454 value = valuedata; DEFAULT_STMT; value = valuedata; \
1457 initial_ctx->NAME##_used = 1; \
1458 for (i = 0; i < SIZE; i++) \
1460 if (*((char *)(&value[i])) == 0xcc) \
1462 memset(&value[i], 0xaa, sizeof(TYPE)); \
1463 SET_GLUE_VALUE(GET_STMT, DEFAULT_STMT); \
1464 if (*((char *)(&value[i])) == 0xaa) \
1467 if (try_step == 2) \
1469 COREGL_WRN("\E[40;31;1mGL-state '"#NAME"' cannot be retrieved\E[0m\n"); \
1474 initial_ctx->NAME[i] = value[i]; \
1476 if (try_step != 2) \
1478 value = valuedata; DEFAULT_STMT; value = valuedata; \
1479 for (i = 0; i < SIZE; i++) \
1481 if (initial_ctx->NAME[i] != value[i]) \
1483 COREGL_WRN("GL-state '"#NAME"'[%d] value ["PRINTF_CHAR(TYPE)"] is different from SPEC-DEFAULT ["PRINTF_CHAR(TYPE)"]\n", i, initial_ctx->NAME[i], value[i]); \
1488 while (try_step == 2); \
1491 # include "coregl_fastpath_state.h"
1492 # undef SET_GLUE_VALUE
1496 # undef _COREGL_END_API
1497 # undef _COREGL_START_API
1499 if (initial_ctx->gl_num_vertex_attribs[0] > MAX_VERTEX_ATTRIBS)
1501 COREGL_WRN("\E[40;31;1mNumber of vertex attrib is too big! (%d-%d)\E[0m\n", MAX_VERTEX_ATTRIBS, initial_ctx->gl_num_vertex_attribs[0]);
1503 if (initial_ctx->gl_num_tex_units[0] > MAX_TEXTURE_UNITS)
1505 COREGL_WRN("\E[40;31;1mNumber of texture unit is too big! (%d-%d)\E[0m\n", MAX_TEXTURE_UNITS, initial_ctx->gl_num_tex_units[0]);
1507 if (initial_ctx->gl_num_transform_feedback_separate_attribs[0] > MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS)
1509 COREGL_WRN("\E[40;31;1mNumber of transform feedback separate attrib is too big! (%d-%d)\E[0m\n", MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, initial_ctx->gl_num_transform_feedback_separate_attribs[0]);
1511 if (initial_ctx->gl_num_uniform_buffer_bindings[0] > MAX_UNIFORM_BUFFER_BINDINGS)
1513 COREGL_WRN("\E[40;31;1mNumber of uniform buffer binding is too big! (%d-%d)\E[0m\n", MAX_UNIFORM_BUFFER_BINDINGS, initial_ctx->gl_num_uniform_buffer_bindings[0]);
1519 #define _COREGL_START_API(version) api_gl_version = version;
1520 #define _COREGL_END_API(version) api_gl_version = COREGL_GLAPI_2;
1521 #define INITIAL_CTX initial_ctx
1522 #define GLUE_STATE(TYPE, NAME, SIZE, ARRAY_SIZE, DEFAULT_STMT, GET_STMT) \
1523 if(api_gl_version <= driver_gl_version) { \
1524 for (i = 0; i < SIZE; i++) \
1526 ctx->NAME[i] = initial_ctx->NAME[i]; \
1527 ctx->NAME##_used = initial_ctx->NAME##_used; \
1530 # include "coregl_fastpath_state.h"
1533 #undef _COREGL_START_API
1534 #undef _COREGL_END_API
1537 ctx->initialized = 1;
1542 AST(mutex_unlock(&init_context_mutex) == 1);
1547 #ifdef COREGL_USE_MODULE_TRACEPATH
1548 extern void *tracepath_api_trace_begin(const char *name, void *hint, int trace_total_time);
1549 extern void *tracepath_api_trace_end(const char *name, void *hint, int trace_total_time);
1552 #define CHECK_GL_ERROR(func) \
1555 int err = _orig_fastpath_glGetError(); \
1556 if (err != GL_NO_ERROR) \
1558 COREGL_ERR("\E[40;31;1m(GL %p) : %s returns GL error 0x%X\E[0m\n", oldctx->cstate, #func, err); \
1564 fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
1567 unsigned char flag = 0;
1570 if (debug_nofp == 1)
1576 // Return if they're the same
1577 if (oldctx == newctx)
1583 #define STATE_COMPARE(state) \
1584 if ((oldctx->state) != (newctx->state))
1586 #define STATES_COMPARE(state_ptr, bytes) \
1587 if ((memcmp((oldctx->state_ptr), (newctx->state_ptr), (bytes))) != 0)
1590 #ifdef COREGL_USE_MODULE_TRACEPATH
1591 static void *trace_hint_glfinish = NULL;
1592 trace_hint_glfinish = tracepath_api_trace_begin("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
1593 #endif // COREGL_USE_MODULE_TRACEPATH
1596 int err = _orig_fastpath_glGetError();
1597 if (err != GL_NO_ERROR && oldctx->gl_error == GL_NO_ERROR)
1598 oldctx->gl_error = err;
1601 CHECK_GL_ERROR(_orig_fastpath_glFlush())
1603 #ifdef COREGL_USE_MODULE_TRACEPATH
1604 tracepath_api_trace_end("eglMakeCurrent(FP glFinish)", trace_hint_glfinish, 0);
1605 #endif // COREGL_USE_MODULE_TRACEPATH
1608 #ifdef COREGL_USE_MODULE_TRACEPATH
1609 static void *trace_hint_vertex_attrib = NULL;
1610 trace_hint_vertex_attrib = tracepath_api_trace_begin("eglMakeCurrent(FP vertex attrib)", trace_hint_vertex_attrib, 0);
1611 #endif // COREGL_USE_MODULE_TRACEPATH
1613 flag = oldctx->_vattrib_flag | newctx->_vattrib_flag;
1616 for (i = 0; i < oldctx->gl_num_vertex_attribs[0]; i++)
1618 if (newctx->gl_vertex_array_buf_id[i] != oldctx->gl_vertex_array_buf_id[i])
1620 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_vertex_array_buf_id[i]))
1624 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, 0))
1627 STATE_COMPARE(gl_vertex_array_divisor[i])
1629 CHECK_GL_ERROR(_orig_fastpath_glVertexAttribDivisor(i, newctx->gl_vertex_array_divisor[i]))
1632 if (newctx->gl_vertex_array_size[i] != 0)
1634 CHECK_GL_ERROR(_orig_fastpath_glVertexAttribPointer(i,
1635 newctx->gl_vertex_array_size[i],
1636 newctx->gl_vertex_array_type[i],
1637 newctx->gl_vertex_array_normalized[i],
1638 newctx->gl_vertex_array_stride[i],
1639 newctx->gl_vertex_array_pointer[i]))
1643 if (newctx->gl_vertex_array_integer[0] == GL_TRUE)
1645 if (newctx->gl_vertex_array_type[0] == GL_UNSIGNED_INT)
1647 CHECK_GL_ERROR(_orig_fastpath_glVertexAttribI4uiv(i, &newctx->gl_vertex_attrib_value_unsigned_integer[4 * i]))
1651 CHECK_GL_ERROR(_orig_fastpath_glVertexAttribI4iv(i, &newctx->gl_vertex_attrib_value_integer[4 * i]))
1656 CHECK_GL_ERROR(_orig_fastpath_glVertexAttrib4fv(i, &newctx->gl_vertex_attrib_value[4 * i]))
1660 if (newctx->gl_vertex_array_enabled[i] == GL_TRUE)
1662 CHECK_GL_ERROR(_orig_fastpath_glEnableVertexAttribArray(i))
1666 CHECK_GL_ERROR(_orig_fastpath_glDisableVertexAttribArray(i))
1672 #ifdef COREGL_USE_MODULE_TRACEPATH
1673 tracepath_api_trace_end("eglMakeCurrent(FP vertex attrib)", trace_hint_vertex_attrib, 0);
1674 #endif // COREGL_USE_MODULE_TRACEPATH
1677 #ifdef COREGL_USE_MODULE_TRACEPATH
1678 static void *trace_hint_bindbuffers = NULL;
1679 trace_hint_bindbuffers = tracepath_api_trace_begin("eglMakeCurrent(FP bind buffers)", trace_hint_bindbuffers, 0);
1680 #endif // COREGL_USE_MODULE_TRACEPATH
1682 //------------------//
1684 flag = oldctx->_bind_flag1 | newctx->_bind_flag1;
1687 STATE_COMPARE(gl_array_buffer_binding[0])
1689 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER, newctx->gl_array_buffer_binding[0]))
1691 STATE_COMPARE(gl_element_array_buffer_binding[0])
1693 STATE_COMPARE(gl_vertex_array_binding[0])
1695 CHECK_GL_ERROR(_orig_fastpath_glBindVertexArray(newctx->gl_vertex_array_binding[0]))
1697 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, newctx->gl_element_array_buffer_binding[0]))
1700 if (newctx->gl_framebuffer_binding_read_used == 1)
1702 STATE_COMPARE(gl_framebuffer_binding_read[0])
1704 CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_READ_FRAMEBUFFER, newctx->gl_framebuffer_binding_read[0]))
1706 STATE_COMPARE(gl_framebuffer_binding_draw[0])
1708 CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_DRAW_FRAMEBUFFER, newctx->gl_framebuffer_binding_draw[0]))
1713 STATE_COMPARE(gl_framebuffer_binding[0])
1715 CHECK_GL_ERROR(_orig_fastpath_glBindFramebuffer(GL_FRAMEBUFFER, newctx->gl_framebuffer_binding[0]))
1718 STATE_COMPARE(gl_renderbuffer_binding[0])
1720 CHECK_GL_ERROR(_orig_fastpath_glBindRenderbuffer(GL_RENDERBUFFER, newctx->gl_renderbuffer_binding[0]))
1724 //------------------//
1726 flag = oldctx->_bind_flag2 | newctx->_bind_flag2;
1729 STATE_COMPARE(gl_copy_read_buffer_binding[0])
1731 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_COPY_READ_BUFFER, newctx->gl_copy_read_buffer_binding[0]))
1733 STATE_COMPARE(gl_copy_write_buffer_binding[0])
1735 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_COPY_WRITE_BUFFER, newctx->gl_copy_write_buffer_binding[0]))
1737 STATE_COMPARE(gl_pixel_pack_buffer_binding[0])
1739 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_PIXEL_PACK_BUFFER, newctx->gl_pixel_pack_buffer_binding[0]))
1741 STATE_COMPARE(gl_pixel_unpack_buffer_binding[0])
1743 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_PIXEL_UNPACK_BUFFER, newctx->gl_pixel_unpack_buffer_binding[0]))
1745 STATE_COMPARE(gl_transform_feedback_buffer_binding[0])
1747 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, newctx->gl_transform_feedback_buffer_binding[0]))
1749 STATE_COMPARE(gl_uniform_buffer_binding[0])
1751 CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_UNIFORM_BUFFER, newctx->gl_uniform_buffer_binding[0]))
1754 #ifdef COREGL_USE_MODULE_TRACEPATH
1755 tracepath_api_trace_end("eglMakeCurrent(FP bind buffers)", trace_hint_bindbuffers, 0);
1756 #endif // COREGL_USE_MODULE_TRACEPATH
1759 //------------------//
1762 #ifdef COREGL_USE_MODULE_TRACEPATH
1763 static void *trace_hint_enable_states = NULL;
1764 trace_hint_enable_states = tracepath_api_trace_begin("eglMakeCurrent(FP enable states)", trace_hint_enable_states, 0);
1765 #endif // COREGL_USE_MODULE_TRACEPATH
1767 flag = oldctx->_enable_flag1 | newctx->_enable_flag1;
1770 STATE_COMPARE(gl_blend[0])
1772 if (newctx->gl_blend[0])
1774 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND))
1777 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND))
1779 STATE_COMPARE(gl_cull_face[0])
1781 if (newctx->gl_cull_face[0])
1783 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_CULL_FACE))
1786 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_CULL_FACE))
1788 STATE_COMPARE(gl_depth_test[0])
1790 if (newctx->gl_depth_test[0])
1792 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DEPTH_TEST))
1795 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DEPTH_TEST))
1797 STATE_COMPARE(gl_dither[0])
1799 if (newctx->gl_dither[0])
1801 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DITHER))
1804 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DITHER))
1809 flag = oldctx->_enable_flag2 | newctx->_enable_flag2;
1812 STATE_COMPARE(gl_polygon_offset_fill[0])
1814 if (newctx->gl_polygon_offset_fill[0])
1816 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_POLYGON_OFFSET_FILL))
1819 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_POLYGON_OFFSET_FILL))
1821 STATE_COMPARE(gl_sample_alpha_to_coverage[0])
1823 if (newctx->gl_sample_alpha_to_coverage[0])
1825 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE))
1828 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE))
1830 STATE_COMPARE(gl_sample_coverage[0])
1832 if (newctx->gl_sample_coverage[0])
1834 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_COVERAGE))
1837 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_COVERAGE))
1839 STATE_COMPARE(gl_scissor_test[0])
1841 if (newctx->gl_scissor_test[0])
1843 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SCISSOR_TEST))
1846 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SCISSOR_TEST))
1848 STATE_COMPARE(gl_stencil_test[0])
1850 if (newctx->gl_stencil_test[0])
1852 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_STENCIL_TEST))
1855 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_STENCIL_TEST))
1860 flag = oldctx->_enable_flag3 | newctx->_enable_flag3;
1863 STATE_COMPARE(gl_primitive_restart_fixed_index[0])
1865 if (newctx->gl_primitive_restart_fixed_index[0])
1867 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
1870 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
1872 STATE_COMPARE(gl_rasterizer_discard[0])
1874 if (newctx->gl_rasterizer_discard[0])
1876 CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_RASTERIZER_DISCARD))
1879 CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_RASTERIZER_DISCARD))
1883 #ifdef COREGL_USE_MODULE_TRACEPATH
1884 tracepath_api_trace_end("eglMakeCurrent(FP enable states)", trace_hint_enable_states, 0);
1885 #endif // COREGL_USE_MODULE_TRACEPATH
1887 //------------------//
1889 #ifdef COREGL_USE_MODULE_TRACEPATH
1890 static void *trace_hint_clear_viewport = NULL;
1891 trace_hint_clear_viewport = tracepath_api_trace_begin("eglMakeCurrent(FP clear/viewport)", trace_hint_clear_viewport, 0);
1892 #endif // COREGL_USE_MODULE_TRACEPATH
1894 flag = oldctx->_clear_flag1 | newctx->_clear_flag1;
1898 STATES_COMPARE(gl_viewport, 4 * sizeof(GLint))
1900 CHECK_GL_ERROR(_orig_fastpath_glViewport(newctx->gl_viewport[0],
1901 newctx->gl_viewport[1],
1902 newctx->gl_viewport[2],
1903 newctx->gl_viewport[3]))
1906 STATE_COMPARE(gl_current_program[0])
1908 CHECK_GL_ERROR(_orig_fastpath_glUseProgram(newctx->gl_current_program[0]))
1910 STATES_COMPARE(gl_color_clear_value, 4 * sizeof(GLclampf))
1912 CHECK_GL_ERROR(_orig_fastpath_glClearColor(newctx->gl_color_clear_value[0],
1913 newctx->gl_color_clear_value[1],
1914 newctx->gl_color_clear_value[2],
1915 newctx->gl_color_clear_value[3]))
1921 flag = oldctx->_clear_flag2 | newctx->_clear_flag2;
1924 STATES_COMPARE(gl_color_writemask, 4 * sizeof(GLboolean))
1926 CHECK_GL_ERROR(_orig_fastpath_glColorMask(newctx->gl_color_writemask[0],
1927 newctx->gl_color_writemask[1],
1928 newctx->gl_color_writemask[2],
1929 newctx->gl_color_writemask[3]))
1931 STATES_COMPARE(gl_depth_range, 2 * sizeof(GLclampf))
1933 CHECK_GL_ERROR(_orig_fastpath_glDepthRangef(newctx->gl_depth_range[0],
1934 newctx->gl_depth_range[1]))
1936 STATE_COMPARE(gl_depth_clear_value[0])
1938 CHECK_GL_ERROR(_orig_fastpath_glClearDepthf(newctx->gl_depth_clear_value[0]))
1940 STATE_COMPARE(gl_depth_func[0])
1942 CHECK_GL_ERROR(_orig_fastpath_glDepthFunc(newctx->gl_depth_func[0]))
1944 STATE_COMPARE(gl_depth_writemask[0])
1946 CHECK_GL_ERROR(_orig_fastpath_glDepthMask(newctx->gl_depth_writemask[0]))
1948 STATE_COMPARE(gl_cull_face_mode[0])
1950 CHECK_GL_ERROR(_orig_fastpath_glCullFace(newctx->gl_cull_face_mode[0]))
1955 #ifdef COREGL_USE_MODULE_TRACEPATH
1956 tracepath_api_trace_end("eglMakeCurrent(FP clear/viewport)", trace_hint_clear_viewport, 0);
1957 #endif // COREGL_USE_MODULE_TRACEPATH
1959 //------------------//
1961 #ifdef COREGL_USE_MODULE_TRACEPATH
1962 static void *trace_hint_bind_textures = NULL;
1963 trace_hint_bind_textures = tracepath_api_trace_begin("eglMakeCurrent(FP bind textures)", trace_hint_bind_textures, 0);
1964 #endif // COREGL_USE_MODULE_TRACEPATH
1966 flag = oldctx->_tex_flag1 | newctx->_tex_flag1;
1970 for (i = 0; i < oldctx->gl_num_tex_units[0]; i++)
1972 STATE_COMPARE(gl_tex_2d_state[i])
1974 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
1975 CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D, newctx->gl_tex_2d_state[i]))
1977 STATE_COMPARE(gl_tex_3d_state[i])
1979 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
1980 CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_3D, newctx->gl_tex_3d_state[i]))
1982 STATE_COMPARE(gl_tex_2d_array_state[i])
1984 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
1985 CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_ARRAY, newctx->gl_tex_2d_array_state[i]))
1987 STATE_COMPARE(gl_tex_cube_state[i])
1989 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
1990 CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_CUBE_MAP, newctx->gl_tex_cube_state[i]))
1992 STATE_COMPARE(gl_tex_external_oes_state[i])
1994 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
1995 CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_EXTERNAL_OES, newctx->gl_tex_external_oes_state[i]))
1999 // Restore active texture
2000 CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(newctx->gl_active_texture[0]))
2002 STATE_COMPARE(gl_generate_mipmap_hint[0])
2004 CHECK_GL_ERROR(_orig_fastpath_glHint(GL_GENERATE_MIPMAP_HINT, newctx->gl_generate_mipmap_hint[0]))
2007 #ifdef COREGL_USE_MODULE_TRACEPATH
2008 tracepath_api_trace_end("eglMakeCurrent(FP bind textures)", trace_hint_bind_textures, 0);
2009 #endif // COREGL_USE_MODULE_TRACEPATH
2011 //------------------//
2012 #ifdef COREGL_USE_MODULE_TRACEPATH
2013 static void *trace_hint_etc = NULL;
2014 trace_hint_etc = tracepath_api_trace_begin("eglMakeCurrent(FP etc.)", trace_hint_etc, 0);
2015 #endif // COREGL_USE_MODULE_TRACEPATH
2017 flag = oldctx->_blend_flag | newctx->_blend_flag;
2020 STATES_COMPARE(gl_blend_color, 4 * sizeof(GLclampf))
2022 CHECK_GL_ERROR(_orig_fastpath_glBlendColor(newctx->gl_blend_color[0],
2023 newctx->gl_blend_color[1],
2024 newctx->gl_blend_color[2],
2025 newctx->gl_blend_color[3]))
2027 if ((oldctx->gl_blend_src_rgb[0] != newctx->gl_blend_src_rgb[0]) ||
2028 (oldctx->gl_blend_dst_rgb[0] != newctx->gl_blend_dst_rgb[0]) ||
2029 (oldctx->gl_blend_src_alpha[0] != newctx->gl_blend_src_alpha[0]) ||
2030 (oldctx->gl_blend_dst_alpha[0] != newctx->gl_blend_dst_alpha[0]))
2032 CHECK_GL_ERROR(_orig_fastpath_glBlendFuncSeparate(newctx->gl_blend_src_rgb[0],
2033 newctx->gl_blend_dst_rgb[0],
2034 newctx->gl_blend_src_alpha[0],
2035 newctx->gl_blend_dst_alpha[0]))
2037 if ((oldctx->gl_blend_equation_rgb[0] != newctx->gl_blend_equation_rgb[0]) ||
2038 (oldctx->gl_blend_equation_alpha[0] != newctx->gl_blend_equation_alpha[0]))
2040 CHECK_GL_ERROR(_orig_fastpath_glBlendEquationSeparate(newctx->gl_blend_equation_rgb[0], newctx->gl_blend_equation_alpha[0]))
2045 //------------------//
2047 flag = oldctx->_stencil_flag1 | newctx->_stencil_flag1;
2050 if ((oldctx->gl_stencil_func[0] != newctx->gl_stencil_func[0]) ||
2051 (oldctx->gl_stencil_ref[0] != newctx->gl_stencil_ref[0]) ||
2052 (oldctx->gl_stencil_value_mask[0] != newctx->gl_stencil_value_mask[0]))
2054 CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_FRONT,
2055 newctx->gl_stencil_func[0],
2056 newctx->gl_stencil_ref[0],
2057 newctx->gl_stencil_value_mask[0]))
2059 if ((oldctx->gl_stencil_fail[0] != newctx->gl_stencil_fail[0]) ||
2060 (oldctx->gl_stencil_pass_depth_fail[0] != newctx->gl_stencil_pass_depth_fail[0]) ||
2061 (oldctx->gl_stencil_pass_depth_pass[0] != newctx->gl_stencil_pass_depth_pass[0]))
2063 CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_FRONT,
2064 newctx->gl_stencil_fail[0],
2065 newctx->gl_stencil_pass_depth_fail[0],
2066 newctx->gl_stencil_pass_depth_pass[0]))
2069 STATE_COMPARE(gl_stencil_writemask[0])
2071 CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_FRONT, newctx->gl_stencil_writemask[0]))
2077 flag = oldctx->_stencil_flag2 | newctx->_stencil_flag2;
2080 if ((oldctx->gl_stencil_back_func[0] != newctx->gl_stencil_back_func[0]) ||
2081 (oldctx->gl_stencil_back_ref[0] != newctx->gl_stencil_back_ref[0]) ||
2082 (oldctx->gl_stencil_back_value_mask[0] != newctx->gl_stencil_back_value_mask[0]))
2084 CHECK_GL_ERROR(_orig_fastpath_glStencilFuncSeparate(GL_BACK,
2085 newctx->gl_stencil_back_func[0],
2086 newctx->gl_stencil_back_ref[0],
2087 newctx->gl_stencil_back_value_mask[0]))
2089 if ((oldctx->gl_stencil_back_fail[0] != newctx->gl_stencil_back_fail[0]) ||
2090 (oldctx->gl_stencil_back_pass_depth_fail[0] != newctx->gl_stencil_back_pass_depth_fail[0]) ||
2091 (oldctx->gl_stencil_back_pass_depth_pass[0] != newctx->gl_stencil_back_pass_depth_pass[0]))
2093 CHECK_GL_ERROR(_orig_fastpath_glStencilOpSeparate(GL_BACK,
2094 newctx->gl_stencil_back_fail[0],
2095 newctx->gl_stencil_back_pass_depth_fail[0],
2096 newctx->gl_stencil_back_pass_depth_pass[0]))
2099 STATE_COMPARE(gl_stencil_back_writemask[0])
2101 CHECK_GL_ERROR(_orig_fastpath_glStencilMaskSeparate(GL_BACK, newctx->gl_stencil_back_writemask[0]))
2103 STATE_COMPARE(gl_stencil_clear_value[0])
2105 CHECK_GL_ERROR(_orig_fastpath_glClearStencil(newctx->gl_stencil_clear_value[0]))
2109 //------------------//
2111 flag = oldctx->_pixel_flag1 | newctx->_pixel_flag1;
2114 STATE_COMPARE(gl_pack_row_length[0])
2116 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_ROW_LENGTH, newctx->gl_pack_row_length[0]))
2118 STATE_COMPARE(gl_pack_skip_rows[0])
2120 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_SKIP_ROWS, newctx->gl_pack_skip_rows[0]))
2122 STATE_COMPARE(gl_pack_skip_pixels[0])
2124 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_SKIP_PIXELS, newctx->gl_pack_skip_pixels[0]))
2126 STATE_COMPARE(gl_pack_alignment[0])
2128 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_PACK_ALIGNMENT, newctx->gl_pack_alignment[0]))
2133 flag = oldctx->_pixel_flag2 | newctx->_pixel_flag2;
2136 STATE_COMPARE(gl_unpack_row_length[0])
2138 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_ROW_LENGTH, newctx->gl_unpack_row_length[0]))
2140 STATE_COMPARE(gl_unpack_skip_rows[0])
2142 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_ROWS, newctx->gl_unpack_skip_rows[0]))
2144 STATE_COMPARE(gl_unpack_skip_pixels[0])
2146 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_PIXELS, newctx->gl_unpack_skip_pixels[0]))
2148 STATE_COMPARE(gl_unpack_alignment[0])
2150 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_ALIGNMENT, newctx->gl_unpack_alignment[0]))
2152 STATE_COMPARE(gl_unpack_image_height[0])
2154 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, newctx->gl_unpack_image_height[0]))
2156 STATE_COMPARE(gl_unpack_skip_images[0])
2158 CHECK_GL_ERROR(_orig_fastpath_glPixelStorei(GL_UNPACK_SKIP_IMAGES, newctx->gl_unpack_skip_images[0]))
2162 //------------------//
2164 flag = oldctx->_misc_flag1 | newctx->_misc_flag1;
2167 STATE_COMPARE(gl_front_face[0])
2169 CHECK_GL_ERROR(_orig_fastpath_glFrontFace(newctx->gl_front_face[0]))
2171 STATE_COMPARE(gl_line_width[0])
2173 CHECK_GL_ERROR(_orig_fastpath_glLineWidth(newctx->gl_line_width[0]))
2175 if ((oldctx->gl_polygon_offset_factor[0] != newctx->gl_polygon_offset_factor[0]) ||
2176 (oldctx->gl_polygon_offset_units[0] != newctx->gl_polygon_offset_units[0]))
2178 CHECK_GL_ERROR(_orig_fastpath_glPolygonOffset(newctx->gl_polygon_offset_factor[0],
2179 newctx->gl_polygon_offset_units[0]))
2181 if ((oldctx->gl_sample_coverage_value[0] != newctx->gl_sample_coverage_value[0]) ||
2182 (oldctx->gl_sample_coverage_invert[0] != newctx->gl_sample_coverage_invert[0]))
2184 CHECK_GL_ERROR(_orig_fastpath_glSampleCoverage(newctx->gl_sample_coverage_value[0],
2185 newctx->gl_sample_coverage_invert[0]))
2187 STATE_COMPARE(gl_fragment_shader_derivative_hint[0])
2189 CHECK_GL_ERROR(_orig_fastpath_glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES, newctx->gl_fragment_shader_derivative_hint[0]))
2194 flag = oldctx->_misc_flag2 | newctx->_misc_flag2;
2197 STATES_COMPARE(gl_scissor_box, 4 * sizeof(GLint))
2199 CHECK_GL_ERROR(_orig_fastpath_glScissor(newctx->gl_scissor_box[0],
2200 newctx->gl_scissor_box[1],
2201 newctx->gl_scissor_box[2],
2202 newctx->gl_scissor_box[3]))
2207 flag = oldctx->_misc_flag3 | newctx->_misc_flag3;
2210 STATE_COMPARE(gl_read_buffer[0])
2212 CHECK_GL_ERROR(_orig_fastpath_glReadBuffer(newctx->gl_read_buffer[0]))
2214 STATES_COMPARE(gl_draw_buffers, 16 * sizeof(GLenum))
2216 int drawBuffSize = 16;
2217 /* If the context has only default framebuffer, then size of glDrawBuffers can only be 1 */
2218 if(fastpath_ostate_has_object_type(&newctx->ostate, GL_OBJECT_TYPE_FRAMEBUFFER) == 0) {
2222 CHECK_GL_ERROR(_orig_fastpath_glDrawBuffers(drawBuffSize, newctx->gl_draw_buffers))
2225 if (oldctx->gl_transform_feedback_active[0] == GL_TRUE && oldctx->gl_transform_feedback_paused[0] == GL_FALSE)
2227 CHECK_GL_ERROR(_orig_fastpath_glPauseTransformFeedback())
2229 STATE_COMPARE(gl_transform_feedback_binding[0])
2231 CHECK_GL_ERROR(_orig_fastpath_glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, newctx->gl_transform_feedback_binding[0]))
2233 if (newctx->gl_transform_feedback_active[0] == GL_TRUE && newctx->gl_transform_feedback_paused[0] == GL_FALSE)
2235 CHECK_GL_ERROR(_orig_fastpath_glResumeTransformFeedback())
2239 #ifdef COREGL_USE_MODULE_TRACEPATH
2240 tracepath_api_trace_end("eglMakeCurrent(FP etc.)", trace_hint_etc, 0);
2241 #endif // COREGL_USE_MODULE_TRACEPATH
2248 #ifdef COREGL_FASTPATH_TRACE_STATE_INFO
2249 if (unlikely(trace_state_flag == 1))
2250 fastpath_dump_context_states(newctx, 0);
2251 #endif // COREGL_FASTPATH_TRACE_STATE_INFO
2253 #undef STATE_COMPARE
2254 #undef STATES_COMPARE