Add support for some missing processing of state which is detected by Khronos CTS

Modification including:
1. Add missing contest states and related processing like
gl_shader_storage_buffer_binding
2. Rename all context states in the from of gl_num_xxx
to gl_xxx_num, for convenient macro processing in
fastpath_glBindBuffer()
3. Clear all buffer binding related state arrays which are
set in fastpath_glBindBufferBase() if argument buffer 0 is
passed to fastpath_glBindBuffer()

Signed-off-by: Zhaowei Yuan <zhaowei.yuan@samsung.com>
Change-Id: Ie28eaac2bdff8299c4575e6415c34ae41273f39f

diff --git a/src/coregl.h b/src/coregl.h
index c94c0e3..13fa585 100644 (file)
--- a/src/coregl.h
+++ b/src/coregl.h
@@ -8,6 +8,9 @@
 # include <EGL/eglplatform.h>
 # include "headers/egl.h"
 # include "headers/gl.h"
+#include <GLES3/gl31.h>
+#include <GLES3/gl32.h>
+#include <GLES2/gl2ext.h>
 
 typedef void (*_eng_fn) (void);
 

diff --git a/src/modules/fastpath/coregl_fastpath.c b/src/modules/fastpath/coregl_fastpath.c
index 4b915e7..6c44ab9 100644 (file)
--- a/src/modules/fastpath/coregl_fastpath.c
+++ b/src/modules/fastpath/coregl_fastpath.c
@@ -41,7 +41,7 @@ _state_get_texture_states(GLenum pname, GLint *params)
 
        _orig_fastpath_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)&cur_active_tex);
        int i;
-       for (i = 0; i < initial_ctx->gl_num_tex_units[0]; i++) {
+       for (i = 0; i < initial_ctx->gl_tex_units_num[0]; i++) {
                _orig_fastpath_glActiveTexture(GL_TEXTURE0 + i);
                _orig_fastpath_glGetIntegerv(pname, (GLint *)&params[i]);
        }
@@ -54,7 +54,7 @@ _state_get_draw_buffers(GLenum *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_draw_buffers[0]; i++) {
+       for (i = 0; i < initial_ctx->gl_draw_buffers_num[0]; i++) {
                _orig_fastpath_glGetIntegerv(GL_DRAW_BUFFER0 + i, (GLint *)&params[i]);
        }
 }
@@ -65,7 +65,7 @@ _state_get_transform_feedback_buffer_bindings(GLuint *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
                                               (GLint *)&params[i]);
@@ -78,7 +78,7 @@ _state_get_transform_feedback_buffer_bindings_offset(GLintptr *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_START, i,
                                               (GLint *)&params[i]);
@@ -91,7 +91,7 @@ _state_get_transform_feedback_buffer_bindings_size(GLsizeiptr *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_fastpath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i,
                                               (GLint *)&params[i]);
@@ -104,7 +104,7 @@ _state_get_uniform_buffer_bindings(GLuint *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_ctx->gl_uniform_buffer_binding_num[0]; i++) {
 /////////////////////////////////////////////////////////////////////////////////
 // XXXX : AVOID SEGFAULT in ADRENO
                ((GLint *)params)[i] = 0;
@@ -119,7 +119,7 @@ _state_get_uniform_buffer_bindings_offset(GLintptr *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_ctx->gl_uniform_buffer_binding_num[0]; i++) {
                _orig_fastpath_glGetIntegeri_v(GL_UNIFORM_BUFFER_START, i, (GLint *)&params[i]);
        }
 }
@@ -130,11 +130,79 @@ _state_get_uniform_buffer_bindings_size(GLsizeiptr *params)
        AST(initial_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_ctx->gl_uniform_buffer_binding_num[0]; i++) {
                _orig_fastpath_glGetIntegeri_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint *)&params[i]);
        }
 }
 
+/* shader storage buffer */
+static void
+_state_get_shader_storage_buffer_bindings(GLuint *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_shader_storage_buffer_bindings_offset(GLintptr *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_shader_storage_buffer_bindings_size(GLsizeiptr *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint *)&params[i]);
+       }
+}
+
+/* atomic counter buffer */
+static void
+_state_get_atomic_counter_buffer_bindings(GLuint *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_atomic_counter_buffer_bindings_offset(GLintptr *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_atomic_counter_buffer_bindings_size(GLsizeiptr *params)
+{
+       AST(initial_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_fastpath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i, (GLint *)&params[i]);
+       }
+}
+
 void
 fastpath_state_get_draw_buffers(GLenum *params)
 {
@@ -1539,24 +1607,34 @@ fastpath_init_context_states(GLGlueContext *ctx)
 # undef _COREGL_END_API
 # undef _COREGL_START_API
 
-               if (initial_ctx->gl_num_vertex_attribs[0] > MAX_VERTEX_ATTRIBS) {
+               if (initial_ctx->gl_vertex_attribs_num[0] > MAX_VERTEX_ATTRIBS) {
                        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]);
+                                  MAX_VERTEX_ATTRIBS, initial_ctx->gl_vertex_attribs_num[0]);
                }
-               if (initial_ctx->gl_num_tex_units[0] > MAX_TEXTURE_UNITS) {
+               if (initial_ctx->gl_tex_units_num[0] > MAX_TEXTURE_UNITS) {
                        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]);
+                                  MAX_TEXTURE_UNITS, initial_ctx->gl_tex_units_num[0]);
                }
-               if (initial_ctx->gl_num_transform_feedback_separate_attribs[0] >
+               if (initial_ctx->gl_transform_feedback_buffer_binding_num[0] >
                    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS) {
                        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]);
+                                  initial_ctx->gl_transform_feedback_buffer_binding_num[0]);
                }
-               if (initial_ctx->gl_num_uniform_buffer_bindings[0] >
+               if (initial_ctx->gl_uniform_buffer_binding_num[0] >
                    MAX_UNIFORM_BUFFER_BINDINGS) {
                        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]);
+                                  MAX_UNIFORM_BUFFER_BINDINGS, initial_ctx->gl_uniform_buffer_binding_num[0]);
+               }
+               if (initial_ctx->gl_shader_storage_buffer_binding_num[0] >
+                   MAX_SHADER_STORAGE_BUFFER_BINDINGS) {
+                       COREGL_WRN("\E[40;31;1mNumber of shader storage buffer binding is too big! (%d-%d)\E[0m\n",
+                                  MAX_SHADER_STORAGE_BUFFER_BINDINGS, initial_ctx->gl_shader_storage_buffer_binding_num[0]);
+               }
+               if (initial_ctx->gl_atomic_counter_buffer_binding_num[0] >
+                   MAX_ATOMIC_COUNTER_BUFFER_BINDING) {
+                       COREGL_WRN("\E[40;31;1mNumber of uniform buffer binding is too big! (%d-%d)\E[0m\n",
+                                  MAX_ATOMIC_COUNTER_BUFFER_BINDING, initial_ctx->gl_atomic_counter_buffer_binding_num[0]);
                }
        }
 
@@ -1668,7 +1746,7 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
 
        flag = oldctx->_vattrib_flag | newctx->_vattrib_flag;
        if (flag) {
-               for (i = 0; i < oldctx->gl_num_vertex_attribs[0]; i++) {
+               for (i = 0; i < oldctx->gl_vertex_attribs_num[0]; i++) {
                        if (newctx->gl_vertex_array_buf_id[i] != oldctx->gl_vertex_array_buf_id[i]) {
                                CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ARRAY_BUFFER,
                                                newctx->gl_vertex_array_buf_id[i]))
@@ -1804,6 +1882,30 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
                                        newctx->gl_uniform_buffer_binding[0]))
                }
        }
+
+       flag = oldctx->_bind_flag3 | newctx->_bind_flag3;
+       if (flag) {
+               STATE_COMPARE(gl_shader_storage_buffer_binding[0]) {
+                       CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_SHADER_STORAGE_BUFFER,
+                                       newctx->gl_shader_storage_buffer_binding[0]))
+               }
+               STATE_COMPARE(gl_atomic_counter_buffer_binding[0]) {
+                       CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_ATOMIC_COUNTER_BUFFER,
+                                       newctx->gl_atomic_counter_buffer_binding[0]))
+               }
+               STATE_COMPARE(gl_draw_indirect_buffer_binding[0]) {
+                       CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_DRAW_INDIRECT_BUFFER,
+                                       newctx->gl_draw_indirect_buffer_binding[0]))
+               }
+               STATE_COMPARE(gl_dispatch_indirect_buffer_binding[0]) {
+                       CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER,
+                                       newctx->gl_dispatch_indirect_buffer_binding[0]))
+               }
+               STATE_COMPARE(gl_texture_buffer_binding[0]) {
+                       CHECK_GL_ERROR(_orig_fastpath_glBindBuffer(GL_TEXTURE_BUFFER,
+                                       newctx->gl_texture_buffer_binding[0]))
+               }
+       }
 #ifdef COREGL_USE_MODULE_TRACEPATH
        tracepath_api_trace_end("eglMakeCurrent(FP bind buffers)",
                                trace_hint_bindbuffers, 0);
@@ -1827,25 +1929,25 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND))
-                       }
+               }
                STATE_COMPARE(gl_cull_face[0]) {
                        if (newctx->gl_cull_face[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_CULL_FACE))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_CULL_FACE))
-                       }
+               }
                STATE_COMPARE(gl_depth_test[0]) {
                        if (newctx->gl_depth_test[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DEPTH_TEST))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DEPTH_TEST))
-                       }
+               }
                STATE_COMPARE(gl_dither[0]) {
                        if (newctx->gl_dither[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_DITHER))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_DITHER))
-                       }
+               }
        }
 
        // _enable_flag2
@@ -1856,31 +1958,43 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_POLYGON_OFFSET_FILL))
                        } else
                                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]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE))
-                       }
+               }
                STATE_COMPARE(gl_sample_coverage[0]) {
                        if (newctx->gl_sample_coverage[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_COVERAGE))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_COVERAGE))
-                       }
+               }
                STATE_COMPARE(gl_scissor_test[0]) {
                        if (newctx->gl_scissor_test[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SCISSOR_TEST))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SCISSOR_TEST))
-                       }
+               }
                STATE_COMPARE(gl_stencil_test[0]) {
                        if (newctx->gl_stencil_test[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_STENCIL_TEST))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_STENCIL_TEST))
-                       }
+               }
+               STATE_COMPARE(gl_sample_shading_oes[0]) {
+                       if (newctx->gl_sample_shading_oes[0]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_SHADING_OES))
+                       } else
+                               CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_SHADING_OES))
+               }
+               STATE_COMPARE(gl_sample_mask[0]) {
+                       if (newctx->gl_sample_mask[0]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_SAMPLE_MASK))
+                       } else
+                               CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_SAMPLE_MASK))
+               }
        }
 
        // _enable_flag3
@@ -1891,13 +2005,19 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX))
-                       }
+               }
                STATE_COMPARE(gl_rasterizer_discard[0]) {
                        if (newctx->gl_rasterizer_discard[0]) {
                                CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_RASTERIZER_DISCARD))
                        } else
                                CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_RASTERIZER_DISCARD))
-                       }
+               }
+               STATE_COMPARE(gl_blend_advanced_coherent_khr[0]) {
+                       if (newctx->gl_blend_advanced_coherent_khr[0]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glEnable(GL_BLEND_ADVANCED_COHERENT_KHR))
+                       } else
+                               CHECK_GL_ERROR(_orig_fastpath_glDisable(GL_BLEND_ADVANCED_COHERENT_KHR))
+               }
        }
 
 #ifdef COREGL_USE_MODULE_TRACEPATH
@@ -1981,7 +2101,7 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
        flag = oldctx->_tex_flag1 | newctx->_tex_flag1;
        if (flag) {
 
-               for (i = 0; i < oldctx->gl_num_tex_units[0]; i++) {
+               for (i = 0; i < oldctx->gl_tex_units_num[0]; i++) {
                        STATE_COMPARE(gl_tex_2d_state[i]) {
                                CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
                                CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D,
@@ -2017,6 +2137,27 @@ fastpath_make_context_current(GLGlueContext *oldctx, GLGlueContext *newctx)
                                                             newctx->gl_generate_mipmap_hint[0]))
                }
        }
+
+       flag = oldctx->_tex_flag2 | newctx->_tex_flag2;
+       if (flag) {
+               for (i = 0; i < oldctx->gl_tex_units_num[0]; i++) {
+                       STATE_COMPARE(gl_tex_buffer_ext_state[i]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
+                               CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_BUFFER_EXT,
+                                               newctx->gl_tex_buffer_ext_state[i]))
+                       }
+                       STATE_COMPARE(gl_tex_2d_multisample_state[i]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
+                               CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE,
+                                               newctx->gl_tex_2d_multisample_state[i]))
+                       }
+                       STATE_COMPARE(gl_tex_2d_multisample_array_oes_state[i]) {
+                               CHECK_GL_ERROR(_orig_fastpath_glActiveTexture(GL_TEXTURE0 + i))
+                               CHECK_GL_ERROR(_orig_fastpath_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES,
+                                               newctx->gl_tex_2d_multisample_array_oes_state[i]))
+                       }
+               }
+       }
 #ifdef COREGL_USE_MODULE_TRACEPATH
        tracepath_api_trace_end("eglMakeCurrent(FP bind textures)",
                                trace_hint_bind_textures, 0);

diff --git a/src/modules/fastpath/coregl_fastpath.h b/src/modules/fastpath/coregl_fastpath.h
index bc32eee..9f9a4a5 100644 (file)
--- a/src/modules/fastpath/coregl_fastpath.h
+++ b/src/modules/fastpath/coregl_fastpath.h
@@ -54,6 +54,8 @@
 #define MAX_VERTEX_ATTRIBS 64
 #define MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 64
 #define MAX_UNIFORM_BUFFER_BINDINGS 72
+#define MAX_SHADER_STORAGE_BUFFER_BINDINGS 70
+#define MAX_ATOMIC_COUNTER_BUFFER_BINDING 8
 
 typedef enum _Fastpath_Opt_Flag {
        FP_UNKNOWN_PATH,
@@ -229,6 +231,13 @@ typedef struct _GLGlueContext {
 #define _BIND_FLAG2_BIT_gl_transform_feedback_buffer_binding  FLAG_BIT_4
 #define _BIND_FLAG2_BIT_gl_uniform_buffer_binding             FLAG_BIT_5
 
+       unsigned char           _bind_flag3;
+#define _BIND_FLAG3_BIT_gl_shader_storage_buffer_binding      FLAG_BIT_0
+#define _BIND_FLAG3_BIT_gl_atomic_counter_buffer_binding      FLAG_BIT_1
+#define _BIND_FLAG3_BIT_gl_draw_indirect_buffer_binding       FLAG_BIT_2
+#define _BIND_FLAG3_BIT_gl_dispatch_indirect_buffer_binding   FLAG_BIT_3
+#define _BIND_FLAG3_BIT_gl_texture_buffer_binding             FLAG_BIT_4
+
        unsigned char           _enable_flag1;
 #define _ENABLE_FLAG1_BIT_gl_blend        FLAG_BIT_0
 #define _ENABLE_FLAG1_BIT_gl_cull_face    FLAG_BIT_1
@@ -241,10 +250,13 @@ typedef struct _GLGlueContext {
 #define _ENABLE_FLAG2_BIT_gl_sample_coverage           FLAG_BIT_2
 #define _ENABLE_FLAG2_BIT_gl_scissor_test              FLAG_BIT_3
 #define _ENABLE_FLAG2_BIT_gl_stencil_test              FLAG_BIT_4
+#define _ENABLE_FLAG2_BIT_gl_sample_shading_oes        FLAG_BIT_5
+#define _ENABLE_FLAG2_BIT_gl_sample_mask               FLAG_BIT_6
 
        unsigned char           _enable_flag3;
 #define _ENABLE_FLAG3_BIT_gl_primitive_restart_fixed_index  FLAG_BIT_0
 #define _ENABLE_FLAG3_BIT_gl_rasterizer_discard             FLAG_BIT_1
+#define _ENABLE_FLAG3_BIT_gl_blend_advanced_coherent_khr    FLAG_BIT_2
 
        unsigned char           _clear_flag1;
 #define _CLEAR_FLAG1_BIT_gl_viewport            FLAG_BIT_0
@@ -267,8 +279,12 @@ typedef struct _GLGlueContext {
 #define _TEX_FLAG1_BIT_gl_tex_2d_array_state     FLAG_BIT_4
 #define _TEX_FLAG1_BIT_gl_tex_cube_state         FLAG_BIT_5
 #define _TEX_FLAG1_BIT_gl_tex_external_oes_state FLAG_BIT_6
-#define        _TEX_FLAG1_BIT_gl_client_active_texture  FLAG_BIT_7
+#define _TEX_FLAG1_BIT_gl_client_active_texture  FLAG_BIT_7
 
+       unsigned char           _tex_flag2;
+#define _TEX_FLAG2_BIT_gl_tex_buffer_ext_state               FLAG_BIT_0
+#define _TEX_FLAG2_BIT_gl_tex_2d_multisample_state           FLAG_BIT_1
+#define _TEX_FLAG2_BIT_gl_tex_2d_multisample_array_oes_state FLAG_BIT_2
 
        unsigned char           _blend_flag;
 #define _BLEND_FLAG_BIT_gl_blend_color           FLAG_BIT_0

diff --git a/src/modules/fastpath/coregl_fastpath_gl.c b/src/modules/fastpath/coregl_fastpath_gl.c
index b418cb4..313bfea 100644 (file)
--- a/src/modules/fastpath/coregl_fastpath_gl.c
+++ b/src/modules/fastpath/coregl_fastpath_gl.c
@@ -583,6 +583,15 @@ fastpath_glBindTexture(GLenum target, GLuint texture)
        case GL_TEXTURE_EXTERNAL_OES:
                STATE_PROC(gl_tex_external_oes_state, _tex_flag1, _TEX_FLAG1_BIT);
                break;
+       case GL_TEXTURE_BUFFER_EXT:
+               STATE_PROC(gl_tex_buffer_ext_state, _tex_flag2, _TEX_FLAG2_BIT);
+               break;
+       case GL_TEXTURE_2D_MULTISAMPLE:
+               STATE_PROC(gl_tex_2d_multisample_state, _tex_flag2, _TEX_FLAG2_BIT);
+               break;
+       case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
+               STATE_PROC(gl_tex_2d_multisample_array_oes_state, _tex_flag2, _TEX_FLAG2_BIT);
+               break;
        default:
                _set_gl_error(GL_INVALID_ENUM);
                break;
@@ -789,7 +798,7 @@ fastpath_glDeleteTextures(GLsizei n, const GLuint *textures)
                                        GLGlueContext *cur_gctx = (GLGlueContext *)current->value;
 
                                        if (cur_gctx->initialized == 1) {
-                                               for (j = 0; j < cur_gctx->gl_num_tex_units[0]; j++) {
+                                               for (j = 0; j < cur_gctx->gl_tex_units_num[0]; j++) {
                                                        if (cur_gctx->gl_tex_2d_state[j] == objid_array[i]) {
                                                                CURR_STATE_CLEAR(gl_tex_2d_state, j)
                                                        }
@@ -869,6 +878,7 @@ void
 fastpath_glBindBuffer(GLenum target, GLuint buffer)
 {
        GLuint real_obj;
+       int index;
 
        DEFINE_FASTPAH_GL_FUNC();
        _COREGL_FASTPATH_FUNC_BEGIN();
@@ -879,12 +889,23 @@ fastpath_glBindBuffer(GLenum target, GLuint buffer)
                goto finish;
        }
 
+/* clear states set in fastpath_glBindBufferBase() */
+#define BIND_STATE_ARRAY_CLEAR(gl_state)                                               \
+       if (buffer == 0) {                                                                                      \
+               for(index = 0; index < current_ctx->gl_state##_num[0]; index++) {       \
+                       CURR_STATE_CLEAR(gl_state##_array, index)                               \
+               }                                                                                                                       \
+       }
 
 #define STATE_PROC(gl_state, flagid, flagbit) \
-       if CURR_STATE_COMPARE(gl_state, 0, real_obj) \
-       { \
-               IF_GL_SUCCESS(_orig_fastpath_glBindBuffer(target, real_obj)) \
-               { \
+       if(buffer == 0) {       \
+               IF_GL_SUCCESS(_orig_fastpath_glBindBuffer(target, real_obj)) { \
+                       current_ctx->flagid &= (~flagbit##_##gl_state); \
+                       CURR_STATE_CLEAR(gl_state, 0);                                  \
+               }                                                                                                       \
+       }\
+       else if CURR_STATE_COMPARE(gl_state, 0, real_obj) { \
+               IF_GL_SUCCESS(_orig_fastpath_glBindBuffer(target, real_obj)) { \
                        if (real_obj == 0) \
                                current_ctx->flagid &= (~flagbit##_##gl_state); \
                        else \
@@ -894,7 +915,6 @@ fastpath_glBindBuffer(GLenum target, GLuint buffer)
                }       \
        }
 
-
        switch (target) {
        case GL_ARRAY_BUFFER:
                STATE_PROC(gl_array_buffer_binding, _bind_flag1, _BIND_FLAG1_BIT);
@@ -921,9 +941,28 @@ fastpath_glBindBuffer(GLenum target, GLuint buffer)
        case GL_TRANSFORM_FEEDBACK_BUFFER:
                STATE_PROC_WITH_CHECK(gl_transform_feedback_buffer_binding, _bind_flag2,
                                      _BIND_FLAG2_BIT);
+               BIND_STATE_ARRAY_CLEAR(gl_transform_feedback_buffer_binding);
                break;
        case GL_UNIFORM_BUFFER:
                STATE_PROC_WITH_CHECK(gl_uniform_buffer_binding, _bind_flag2, _BIND_FLAG2_BIT);
+               BIND_STATE_ARRAY_CLEAR(gl_uniform_buffer_binding);
+               break;
+       case GL_SHADER_STORAGE_BUFFER:
+               STATE_PROC_WITH_CHECK(gl_shader_storage_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               BIND_STATE_ARRAY_CLEAR(gl_shader_storage_buffer_binding);
+               break;
+       case GL_ATOMIC_COUNTER_BUFFER:
+               STATE_PROC_WITH_CHECK(gl_atomic_counter_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               BIND_STATE_ARRAY_CLEAR(gl_atomic_counter_buffer_binding);
+               break;
+       case GL_DRAW_INDIRECT_BUFFER:
+               STATE_PROC_WITH_CHECK(gl_draw_indirect_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               break;
+       case GL_DISPATCH_INDIRECT_BUFFER:
+               STATE_PROC_WITH_CHECK(gl_dispatch_indirect_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               break;
+       case GL_TEXTURE_BUFFER:
+               STATE_PROC_WITH_CHECK(gl_texture_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
                break;
        default:
                _set_gl_error(GL_INVALID_ENUM);
@@ -3071,6 +3110,12 @@ fastpath_glDisable(GLenum cap)
        case GL_STENCIL_TEST:
                STATE_PROC(gl_stencil_test, _enable_flag2, _ENABLE_FLAG2_BIT);
                break;
+       case GL_SAMPLE_SHADING_OES:
+               STATE_PROC(gl_sample_shading_oes, _enable_flag2, _ENABLE_FLAG2_BIT);
+               break;
+       case GL_SAMPLE_MASK:
+               STATE_PROC(gl_sample_mask, _enable_flag2, _ENABLE_FLAG2_BIT);
+               break;
        default:
                _set_gl_error(GL_INVALID_ENUM);
                break;
@@ -3160,6 +3205,9 @@ fastpath_glEnable(GLenum cap)
        case GL_STENCIL_TEST:
                STATE_PROC(gl_stencil_test, _enable_flag2, _ENABLE_FLAG2_BIT);
                break;
+       case GL_BLEND_ADVANCED_COHERENT_KHR:
+               STATE_PROC(gl_blend_advanced_coherent_khr, _enable_flag3, _ENABLE_FLAG3_BIT);
+               break;
        default:
                _set_gl_error(GL_INVALID_ENUM);
                break;
@@ -3307,6 +3355,9 @@ fastpath_glPixelStorei(GLenum pname, GLint param)
        case GL_UNPACK_ROW_LENGTH:
                STATE_PROC_WITH_CHECK(gl_unpack_row_length, _pixel_flag2, _PIXEL_FLAG2_BIT);
                break;
+       case GL_UNPACK_SKIP_ROWS:
+               STATE_PROC_WITH_CHECK(gl_unpack_skip_rows, _pixel_flag2, _PIXEL_FLAG2_BIT);
+               break;
        case GL_UNPACK_IMAGE_HEIGHT:
                STATE_PROC_WITH_CHECK(gl_unpack_image_height, _pixel_flag2, _PIXEL_FLAG2_BIT);
                break;
@@ -4851,12 +4902,12 @@ fastpath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
        }
 
 #define STATE_PROC(gl_state, flagid, flagbit) \
-       if CURR_STATE_COMPARE(gl_state##_array, index, real_obj) { \
+       if CURR_STATE_COMPARE(gl_state##_array, index, real_obj) {              \
                IF_GL_SUCCESS(_orig_fastpath_glBindBufferBase(target, index, real_obj)) { \
-                       current_ctx->flagid |= flagbit##_##gl_state; \
+                       current_ctx->flagid |= flagbit##_##gl_state;                    \
                        CURR_STATE_UPDATE(gl_state##_array, index, real_obj)    \
-                       current_ctx->gl_state##_array_offset[index] = 0; \
-                       current_ctx->gl_state##_array_size[index] = 0; \
+                       current_ctx->gl_state##_array_offset[index] = 0;                \
+                       current_ctx->gl_state##_array_size[index] = 0;                  \
                } \
        }
 
@@ -4867,6 +4918,12 @@ fastpath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
        case GL_UNIFORM_BUFFER:
                STATE_PROC(gl_uniform_buffer_binding, _bind_flag2, _BIND_FLAG2_BIT);
                break;
+       case GL_SHADER_STORAGE_BUFFER:
+               STATE_PROC(gl_shader_storage_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               break;
+       case GL_ATOMIC_COUNTER_BUFFER:
+               STATE_PROC(gl_atomic_counter_buffer_binding, _bind_flag3, _BIND_FLAG3_BIT);
+               break;
        default:
                _set_gl_error(GL_INVALID_ENUM);
                break;

diff --git a/src/modules/fastpath/coregl_fastpath_state.h b/src/modules/fastpath/coregl_fastpath_state.h
index 275e62f..a06007c 100644 (file)
--- a/src/modules/fastpath/coregl_fastpath_state.h
+++ b/src/modules/fastpath/coregl_fastpath_state.h
@@ -27,31 +27,41 @@
       } \
    }
 
-GLUE_STATE(GLuint, gl_num_draw_buffers, 1, 1,
+GLUE_STATE(GLuint, gl_draw_buffers_num, 1, 1,
           _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS,
                              (GLint *)value); /* DEFAULT NOT EFFECT */,
           _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS, (GLint *)value);)
 
-GLUE_STATE(GLuint, gl_num_tex_units, 1, 1,
+GLUE_STATE(GLuint, gl_tex_units_num, 1, 1,
           _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
                              (GLint *)value); /* DEFAULT NOT EFFECT */,
           _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, (GLint *)value);)
 
-GLUE_STATE(GLuint, gl_num_vertex_attribs, 1, 1,
+GLUE_STATE(GLuint, gl_vertex_attribs_num, 1, 1,
           _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,
                              (GLint *)value); /* DEFAULT NOT EFFECT */,
           _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)value);)
 
-GLUE_STATE(GLuint, gl_num_transform_feedback_separate_attribs, 1, 1,
+GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding_num, 1, 1,
           _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
                              (GLint *)value); /* DEFAULT NOT EFFECT */,
           _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, (GLint *)value);)
 
-GLUE_STATE(GLuint, gl_num_uniform_buffer_bindings, 1, 1,
+GLUE_STATE(GLuint, gl_uniform_buffer_binding_num, 1, 1,
           _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
                              (GLint *)value); /* DEFAULT NOT EFFECT */,
           _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, (GLint *)value);)
 
+GLUE_STATE(GLuint, gl_shader_storage_buffer_binding_num, 1, 1,
+          _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+                             (GLint *)value); /* DEFAULT NOT EFFECT */,
+          _sym_glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, (GLint *)value);)
+
+GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding_num, 1, 1,
+          _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,
+                             (GLint *)value); /* DEFAULT NOT EFFECT */,
+          _sym_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, (GLint *)value);)
+
 GLUE_STATE(GLuint, gl_array_buffer_binding, 1, 1, SET_1(0),
           _sym_glGetIntegerv(GL_ARRAY_BUFFER_BINDING, (GLint *)value);)
 GLUE_STATE(GLuint, gl_copy_read_buffer_binding, 1, 1, SET_1(0),
@@ -68,42 +78,82 @@ GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding, 1, 1, SET_1(0),
           _sym_glGetIntegerv(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, (GLint *)value);)
 GLUE_STATE(GLuint, gl_uniform_buffer_binding, 1, 1, SET_1(0),
           _sym_glGetIntegerv(GL_UNIFORM_BUFFER_BINDING, (GLint *)value);)
+GLUE_STATE(GLuint, gl_texture_buffer_binding, 1, 1, SET_1(0),
+          _sym_glGetIntegerv(GL_TEXTURE_BUFFER_BINDING, (GLint *)value);)
+GLUE_STATE(GLuint, gl_shader_storage_buffer_binding, 1, 1, SET_1(0),
+          _sym_glGetIntegerv(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint *)value);)
+GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding, 1, 1, SET_1(0),
+          _sym_glGetIntegerv(GL_ATOMIC_COUNTER_BUFFER_BINDING, (GLint *)value);)
+GLUE_STATE(GLuint, gl_draw_indirect_buffer_binding, 1, 1, SET_1(0),
+          _sym_glGetIntegerv(GL_DRAW_INDIRECT_BUFFER_BINDING, (GLint *)value);)
+GLUE_STATE(GLuint, gl_dispatch_indirect_buffer_binding, 1, 1, SET_1(0),
+          _sym_glGetIntegerv(GL_DISPATCH_INDIRECT_BUFFER_BINDING, (GLint *)value);)
 
 _COREGL_START_API(COREGL_GLAPI_3)
 GLUE_STATE(GLuint, gl_transform_feedback_buffer_binding_array,
-          INITIAL_CTX->gl_num_transform_feedback_separate_attribs[0],
+          INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
           MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
           _state_get_transform_feedback_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
           _state_get_transform_feedback_buffer_bindings(value);)
 
 GLUE_STATE(GLintptr, gl_transform_feedback_buffer_binding_array_offset,
-          INITIAL_CTX->gl_num_transform_feedback_separate_attribs[0],
+          INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
           MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
           _state_get_transform_feedback_buffer_bindings_offset(
                   value); /* DEFAULT NOT EFFECT */,
           _state_get_transform_feedback_buffer_bindings_offset(value);)
 
 GLUE_STATE(GLsizeiptr, gl_transform_feedback_buffer_binding_array_size,
-          INITIAL_CTX->gl_num_transform_feedback_separate_attribs[0],
+          INITIAL_CTX->gl_transform_feedback_buffer_binding_num[0],
           MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
           _state_get_transform_feedback_buffer_bindings_size(
                   value); /* DEFAULT NOT EFFECT */,
           _state_get_transform_feedback_buffer_bindings_size(value);)
 
 GLUE_STATE(GLuint, gl_uniform_buffer_binding_array,
-          INITIAL_CTX->gl_num_uniform_buffer_bindings[0], MAX_UNIFORM_BUFFER_BINDINGS,
+          INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
           _state_get_uniform_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
           _state_get_uniform_buffer_bindings(value);)
 
 GLUE_STATE(GLintptr, gl_uniform_buffer_binding_array_offset,
-          INITIAL_CTX->gl_num_uniform_buffer_bindings[0], MAX_UNIFORM_BUFFER_BINDINGS,
+          INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
           _state_get_uniform_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
           _state_get_uniform_buffer_bindings_offset(value);)
 
 GLUE_STATE(GLsizeiptr, gl_uniform_buffer_binding_array_size,
-          INITIAL_CTX->gl_num_uniform_buffer_bindings[0], MAX_UNIFORM_BUFFER_BINDINGS,
+          INITIAL_CTX->gl_uniform_buffer_binding_num[0], MAX_UNIFORM_BUFFER_BINDINGS,
           _state_get_uniform_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
           _state_get_uniform_buffer_bindings_size(value);)
+
+GLUE_STATE(GLuint, gl_shader_storage_buffer_binding_array,
+          INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+          _state_get_shader_storage_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+          _state_get_shader_storage_buffer_bindings(value);)
+
+GLUE_STATE(GLintptr, gl_shader_storage_buffer_binding_array_offset,
+          INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+          _state_get_shader_storage_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
+          _state_get_shader_storage_buffer_bindings_offset(value);)
+
+GLUE_STATE(GLsizeiptr, gl_shader_storage_buffer_binding_array_size,
+          INITIAL_CTX->gl_shader_storage_buffer_binding_num[0], MAX_SHADER_STORAGE_BUFFER_BINDINGS,
+          _state_get_shader_storage_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+          _state_get_shader_storage_buffer_bindings_size(value);)
+
+GLUE_STATE(GLuint, gl_atomic_counter_buffer_binding_array,
+          INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+          _state_get_atomic_counter_buffer_bindings(value); /* DEFAULT NOT EFFECT */,
+          _state_get_atomic_counter_buffer_bindings(value);)
+
+GLUE_STATE(GLintptr, gl_atomic_counter_buffer_binding_array_offset,
+          INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+          _state_get_atomic_counter_buffer_bindings_offset(value); /* DEFAULT NOT EFFECT */,
+          _state_get_atomic_counter_buffer_bindings_offset(value);)
+
+GLUE_STATE(GLsizeiptr, gl_atomic_counter_buffer_binding_array_size,
+          INITIAL_CTX->gl_atomic_counter_buffer_binding_num[0], MAX_ATOMIC_COUNTER_BUFFER_BINDING,
+          _state_get_atomic_counter_buffer_bindings_size(value); /* DEFAULT NOT EFFECT */,
+          _state_get_atomic_counter_buffer_bindings_size(value);)
 _COREGL_END_API(COREGL_GLAPI_3)
 
 GLUE_STATE(GLuint, gl_framebuffer_binding, 1, 1, SET_1(0),
@@ -134,11 +184,17 @@ GLUE_STATE(GLboolean, gl_scissor_test, 1, 1, SET_1(GL_FALSE),
           _sym_glGetBooleanv(GL_SCISSOR_TEST, (GLboolean *)value);)
 GLUE_STATE(GLboolean, gl_stencil_test, 1, 1, SET_1(GL_FALSE),
           _sym_glGetBooleanv(GL_STENCIL_TEST, (GLboolean *)value);)
+GLUE_STATE(GLboolean, gl_sample_shading_oes, 1, 1, SET_1(GL_FALSE),
+          _sym_glGetBooleanv(GL_SAMPLE_SHADING_OES, (GLboolean *)value);)
+GLUE_STATE(GLboolean, gl_sample_mask, 1, 1, SET_1(GL_FALSE),
+          _sym_glGetBooleanv(GL_SAMPLE_MASK, (GLboolean *)value);)
 
 GLUE_STATE(GLboolean, gl_primitive_restart_fixed_index, 1, 1, SET_1(GL_FALSE),
           _sym_glGetBooleanv(GL_PRIMITIVE_RESTART_FIXED_INDEX, (GLboolean *)value);)
 GLUE_STATE(GLboolean, gl_rasterizer_discard, 1, 1, SET_1(GL_FALSE),
           _sym_glGetBooleanv(GL_RASTERIZER_DISCARD, (GLboolean *)value);)
+GLUE_STATE(GLboolean, gl_blend_advanced_coherent_khr, 1, 1, SET_1(GL_TRUE),
+          _sym_glGetBooleanv(GL_BLEND_ADVANCED_COHERENT_KHR, (GLboolean *)value);)
 
 GLUE_STATE(GLint, gl_viewport, 4, 4,
           _sym_glGetIntegerv(GL_VIEWPORT, (GLint *)value); /* DEFAULT NOT EFFECT */,
@@ -162,26 +218,38 @@ GLUE_STATE(GLboolean, gl_depth_writemask, 1, 1, SET_1(GL_TRUE),
 GLUE_STATE(GLenum, gl_cull_face_mode, 1, 1, SET_1(GL_BACK),
           _sym_glGetIntegerv(GL_CULL_FACE_MODE, (GLint *)value);)
 
-GLUE_STATE(GLuint, gl_tex_2d_state, INITIAL_CTX->gl_num_tex_units[0],
+GLUE_STATE(GLuint, gl_tex_2d_state, INITIAL_CTX->gl_tex_units_num[0],
           MAX_TEXTURE_UNITS,
-          SET_N(INITIAL_CTX->gl_num_tex_units[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
           _state_get_texture_states(GL_TEXTURE_BINDING_2D, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_3d_state, INITIAL_CTX->gl_num_tex_units[0],
+GLUE_STATE(GLuint, gl_tex_3d_state, INITIAL_CTX->gl_tex_units_num[0],
           MAX_TEXTURE_UNITS,
-          SET_N(INITIAL_CTX->gl_num_tex_units[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
           _state_get_texture_states(GL_TEXTURE_BINDING_3D, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_2d_array_state, INITIAL_CTX->gl_num_tex_units[0],
+GLUE_STATE(GLuint, gl_tex_2d_array_state, INITIAL_CTX->gl_tex_units_num[0],
           MAX_TEXTURE_UNITS,
-          SET_N(INITIAL_CTX->gl_num_tex_units[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
           _state_get_texture_states(GL_TEXTURE_BINDING_2D_ARRAY, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_cube_state, INITIAL_CTX->gl_num_tex_units[0],
+GLUE_STATE(GLuint, gl_tex_cube_state, INITIAL_CTX->gl_tex_units_num[0],
           MAX_TEXTURE_UNITS,
-          SET_N(INITIAL_CTX->gl_num_tex_units[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
           _state_get_texture_states(GL_TEXTURE_BINDING_CUBE_MAP, (GLint *)value);)
-GLUE_STATE(GLuint, gl_tex_external_oes_state, INITIAL_CTX->gl_num_tex_units[0],
+GLUE_STATE(GLuint, gl_tex_external_oes_state, INITIAL_CTX->gl_tex_units_num[0],
           MAX_TEXTURE_UNITS,
-          SET_N(INITIAL_CTX->gl_num_tex_units[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
           _state_get_texture_states(GL_TEXTURE_EXTERNAL_OES, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_buffer_ext_state, INITIAL_CTX->gl_tex_units_num[0],
+          MAX_TEXTURE_UNITS,
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+          _state_get_texture_states(GL_TEXTURE_BUFFER_EXT, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_2d_multisample_state, INITIAL_CTX->gl_tex_units_num[0],
+          MAX_TEXTURE_UNITS,
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+          _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE, (GLint *)value);)
+GLUE_STATE(GLuint, gl_tex_2d_multisample_array_oes_state, INITIAL_CTX->gl_tex_units_num[0],
+          MAX_TEXTURE_UNITS,
+          SET_N(INITIAL_CTX->gl_tex_units_num[0], 1, SET_1(0)),
+          _state_get_texture_states(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, (GLint *)value);)
 
 GLUE_STATE(GLenum, gl_active_texture, 1, 1, SET_1(GL_TEXTURE0),
           _sym_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)value))
@@ -294,77 +362,77 @@ GLUE_STATE(GLint, gl_scissor_box, 4, 4,
           _sym_glGetIntegerv(GL_SCISSOR_BOX, (GLint *)value);)
 
 GLUE_STATE(GLuint, gl_vertex_array_buf_id,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(0)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(0)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, (GLint *)value);))
 GLUE_STATE(GLint, gl_vertex_array_enabled,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FALSE)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_ENABLED, (GLint *)value);))
-GLUE_STATE(GLint, gl_vertex_array_size, INITIAL_CTX->gl_num_vertex_attribs[0],
+GLUE_STATE(GLint, gl_vertex_array_size, INITIAL_CTX->gl_vertex_attribs_num[0],
           MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(4)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(4)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_SIZE, (GLint *)value);))
 GLUE_STATE(GLsizei, gl_vertex_array_stride,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FALSE)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_STRIDE, (GLint *)value);))
-GLUE_STATE(GLenum, gl_vertex_array_type, INITIAL_CTX->gl_num_vertex_attribs[0],
+GLUE_STATE(GLenum, gl_vertex_array_type, INITIAL_CTX->gl_vertex_attribs_num[0],
           MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FLOAT)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FLOAT)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_TYPE, (GLint *)value);))
 GLUE_STATE(GLint, gl_vertex_array_normalized,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FALSE)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, (GLint *)value);))
 GLUE_STATE(GLint, gl_vertex_array_integer,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FALSE)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_INTEGER, (GLint *)value);))
 GLUE_STATE(GLuint, gl_vertex_array_divisor,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(GL_FALSE)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, _sym_glGetVertexAttribiv(i,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(GL_FALSE)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, _sym_glGetVertexAttribiv(i,
                           GL_VERTEX_ATTRIB_ARRAY_DIVISOR, (GLint *)value);))
 GLUE_STATE(GLvoidptr, gl_vertex_array_pointer,
-          INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1, SET_1(NULL)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 1,
+          INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1, SET_1(NULL)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 1,
                 _sym_glGetVertexAttribPointerv(i, GL_VERTEX_ATTRIB_ARRAY_POINTER,
                                 (GLvoidptr *)value);))
 GLUE_STATE(GLfloat, gl_vertex_attrib_value,
-          4 * INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, SET_4(0, 0, 0, 1)),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, _sym_glGetVertexAttribfv(i,
+          4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0, 1)),
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, _sym_glGetVertexAttribfv(i,
                           GL_CURRENT_VERTEX_ATTRIB, (GLfloat *)value);))
 
 _COREGL_START_API(COREGL_GLAPI_3)
 GLUE_STATE(GLint, gl_vertex_attrib_value_integer,
-          4 * INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, SET_4(0, 0, 0,
+          4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
                           GET_INT_FROM_FLOAT(1.0f))),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, SET_4(0, 0, 0,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
                           GET_INT_FROM_FLOAT(1.0f))))
 GLUE_STATE(GLuint, gl_vertex_attrib_value_unsigned_integer,
-          4 * INITIAL_CTX->gl_num_vertex_attribs[0], MAX_VERTEX_ATTRIBS,
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, SET_4(0, 0, 0,
+          4 * INITIAL_CTX->gl_vertex_attribs_num[0], MAX_VERTEX_ATTRIBS,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
                           GET_UINT_FROM_FLOAT(1.0f))),
-          SET_N(INITIAL_CTX->gl_num_vertex_attribs[0], 4, SET_4(0, 0, 0,
+          SET_N(INITIAL_CTX->gl_vertex_attribs_num[0], 4, SET_4(0, 0, 0,
                           GET_INT_FROM_FLOAT(1.0f))))
 
 // MISC FLAG 3
 GLUE_STATE(GLenum, gl_read_buffer, 1, 1, SET_1(GL_BACK),
           _sym_glGetIntegerv(GL_READ_BUFFER, (GLint *)value);)
-GLUE_STATE(GLenum, gl_draw_buffers, INITIAL_CTX->gl_num_draw_buffers[0], 16,
+GLUE_STATE(GLenum, gl_draw_buffers, INITIAL_CTX->gl_draw_buffers_num[0], 16,
           SET_1(GL_BACK); value++;
-          SET_N(INITIAL_CTX->gl_num_draw_buffers[0] - 1, 1, SET_1(GL_NONE)),
+          SET_N(INITIAL_CTX->gl_draw_buffers_num[0] - 1, 1, SET_1(GL_NONE)),
           _state_get_draw_buffers(value);)
 GLUE_STATE(GLuint, gl_vertex_array_binding, 1, 1, SET_1(0),
           _sym_glGetIntegerv(GL_VERTEX_ARRAY_BINDING, (GLint *)value);)

diff --git a/src/modules/tracepath/coregl_tracepath.c b/src/modules/tracepath/coregl_tracepath.c
index 120217a..56781ce 100644 (file)
--- a/src/modules/tracepath/coregl_tracepath.c
+++ b/src/modules/tracepath/coregl_tracepath.c
@@ -65,11 +65,13 @@ struct _Surface_Data {
 };
 
 typedef struct _GLGlueFakeContext {
-       GLuint gl_num_draw_buffers[1];
-       GLuint gl_num_tex_units[1];
-       GLuint gl_num_vertex_attribs[1];
-       GLuint gl_num_transform_feedback_separate_attribs[1];
-       GLuint gl_num_uniform_buffer_bindings[1];
+       GLuint gl_draw_buffers_num[1];
+       GLuint gl_tex_units_num[1];
+       GLuint gl_vertex_attribs_num[1];
+       GLuint gl_transform_feedback_buffer_binding_num[1];
+       GLuint gl_uniform_buffer_binding_num[1];
+       GLuint gl_shader_storage_buffer_binding_num[1];
+       GLuint gl_atomic_counter_buffer_binding_num[1];
 } GLGlueFakeContext;
 
 GLGlueFakeContext initial_fake_ctx_real;
@@ -97,7 +99,7 @@ _state_get_texture_states(GLenum pname, GLint *params)
 
        _orig_tracepath_glGetIntegerv(GL_ACTIVE_TEXTURE, (GLint *)&cur_active_tex);
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_tex_units[0]; i++) {
+       for (i = 0; i < initial_fake_ctx->gl_tex_units_num[0]; i++) {
                _orig_tracepath_glActiveTexture(GL_TEXTURE0 + i);
                _orig_tracepath_glGetIntegerv(pname, (GLint *)&params[i]);
        }
@@ -110,7 +112,7 @@ _state_get_draw_buffers(GLenum *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_draw_buffers[0]; i++) {
+       for (i = 0; i < initial_fake_ctx->gl_draw_buffers_num[0]; i++) {
                _orig_tracepath_glGetIntegerv(GL_DRAW_BUFFER0 + i, (GLint *)&params[i]);
        }
 }
@@ -121,7 +123,7 @@ _state_get_transform_feedback_buffer_bindings(GLuint *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
                                                (GLint *)&params[i]);
@@ -134,7 +136,7 @@ _state_get_transform_feedback_buffer_bindings_offset(GLintptr *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_START, i,
                                                (GLint *)&params[i]);
@@ -147,7 +149,7 @@ _state_get_transform_feedback_buffer_bindings_size(GLsizeiptr *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_transform_feedback_separate_attribs[0];
+       for (i = 0; i < initial_fake_ctx->gl_transform_feedback_buffer_binding_num[0];
             i++) {
                _orig_tracepath_glGetIntegeri_v(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i,
                                                (GLint *)&params[i]);
@@ -160,7 +162,7 @@ _state_get_uniform_buffer_bindings(GLuint *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_fake_ctx->gl_uniform_buffer_binding_num[0]; i++) {
 /////////////////////////////////////////////////////////////////////////////////
 // XXXX : AVOID SEGFAULT in ADRENO
                ((GLint *)params)[i] = 0;
@@ -175,7 +177,7 @@ _state_get_uniform_buffer_bindings_offset(GLintptr *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_fake_ctx->gl_uniform_buffer_binding_num[0]; i++) {
                _orig_tracepath_glGetIntegeri_v(GL_UNIFORM_BUFFER_START, i,
                                                (GLint *)&params[i]);
        }
@@ -187,11 +189,79 @@ _state_get_uniform_buffer_bindings_size(GLsizeiptr *params)
        AST(initial_fake_ctx != NULL);
 
        int i;
-       for (i = 0; i < initial_fake_ctx->gl_num_uniform_buffer_bindings[0]; i++) {
+       for (i = 0; i < initial_fake_ctx->gl_uniform_buffer_binding_num[0]; i++) {
                _orig_tracepath_glGetIntegeri_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint *)&params[i]);
        }
 }
 
+/* shader storage buffer */
+static void
+_state_get_shader_storage_buffer_bindings(GLuint *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_shader_storage_buffer_bindings_offset(GLintptr *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_shader_storage_buffer_bindings_size(GLsizeiptr *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_shader_storage_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint *)&params[i]);
+       }
+}
+
+/* atomic counter buffer */
+static void
+_state_get_atomic_counter_buffer_bindings(GLuint *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_BINDING, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_atomic_counter_buffer_bindings_offset(GLintptr *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_START, i, (GLint *)&params[i]);
+       }
+}
+
+static void
+_state_get_atomic_counter_buffer_bindings_size(GLsizeiptr *params)
+{
+       AST(initial_fake_ctx != NULL);
+
+       int i;
+       for (i = 0; i < initial_fake_ctx->gl_atomic_counter_buffer_binding_num[0]; i++) {
+               _orig_tracepath_glGetIntegeri_v(GL_ATOMIC_COUNTER_BUFFER_SIZE, i, (GLint *)&params[i]);
+       }
+}
+
 void
 init_modules_tracepath()
 {
@@ -454,15 +524,15 @@ tracepath_dump_context_states(int force_output)
        if (unlikely(trace_state_flag != 1)) return;
 
        _sym_glGetIntegerv(GL_MAX_DRAW_BUFFERS,
-                          (GLint *)initial_fake_ctx->gl_num_draw_buffers);
+                          (GLint *)initial_fake_ctx->gl_draw_buffers_num);
        _sym_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
-                          (GLint *)initial_fake_ctx->gl_num_tex_units);
+                          (GLint *)initial_fake_ctx->gl_tex_units_num);
        _sym_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS,
-                          (GLint *)initial_fake_ctx->gl_num_vertex_attribs);
+                          (GLint *)initial_fake_ctx->gl_vertex_attribs_num);
        _sym_glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
-                          (GLint *)initial_fake_ctx->gl_num_transform_feedback_separate_attribs);
+                          (GLint *)initial_fake_ctx->gl_transform_feedback_buffer_binding_num);
        _sym_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS,
-                          (GLint *)initial_fake_ctx->gl_num_uniform_buffer_bindings);
+                          (GLint *)initial_fake_ctx->gl_uniform_buffer_binding_num);
 
        if (!force_output) {
                struct timeval tv_now = { 0, 0 };