[gtk/wip/chergert/glproto: 453/493] add plumbing for per-uniform stamps




commit b24ea7f9a81e97a0cb3de23ab05081787ea0534f
Author: Christian Hergert <chergert redhat com>
Date:   Thu Feb 11 17:59:36 2021 -0800

    add plumbing for per-uniform stamps

 gsk/next/gskgldriver.c              |   4 +-
 gsk/next/gskglprogram.c             |   6 ++
 gsk/next/gskglprogramprivate.h      |  57 ++++++------
 gsk/next/gskglrenderjob.c           | 172 ++++++++++++++++++------------------
 gsk/next/gskgluniformstateprivate.h |  64 ++++++++++----
 5 files changed, 169 insertions(+), 134 deletions(-)
---
diff --git a/gsk/next/gskgldriver.c b/gsk/next/gskgldriver.c
index 2e1dfba79b..5f089d2cb9 100644
--- a/gsk/next/gskgldriver.c
+++ b/gsk/next/gskgldriver.c
@@ -382,7 +382,7 @@ gsk_next_driver_load_programs (GskNextDriver  *self,
     gsk_gl_program_uniforms_added (program);                                                    \
                                                                                                 \
     if (have_alpha)                                                                             \
-      gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 1.0f);                       \
+      gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f);                    \
                                                                                                 \
     *(GskGLProgram **)(((guint8 *)self) + G_STRUCT_OFFSET (GskNextDriver, name)) =              \
         g_steal_pointer (&program);                                                             \
@@ -1132,7 +1132,7 @@ gsk_next_driver_lookup_shader (GskNextDriver  *self,
           gsk_gl_program_uniforms_added (program);
 
           if (have_alpha)
-            gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 1.0f);
+            gsk_gl_program_set_uniform1f (program, UNIFORM_SHARED_ALPHA, 0, 1.0f);
 
           g_hash_table_insert (self->shader_cache, shader, program);
           g_object_weak_ref (G_OBJECT (shader),
diff --git a/gsk/next/gskglprogram.c b/gsk/next/gskglprogram.c
index 23dad322c3..eb7c7af128 100644
--- a/gsk/next/gskglprogram.c
+++ b/gsk/next/gskglprogram.c
@@ -171,6 +171,7 @@ gsk_gl_program_begin_draw (GskGLProgram            *self,
     gsk_gl_uniform_state_set4fv (self->uniforms,
                                  self->program_info,
                                  self->uniform_locations[UNIFORM_SHARED_VIEWPORT],
+                                 0,
                                  1,
                                  (const float *)viewport);
 
@@ -178,12 +179,14 @@ gsk_gl_program_begin_draw (GskGLProgram            *self,
     gsk_gl_uniform_state_set_matrix (self->uniforms,
                                      self->program_info,
                                      self->uniform_locations[UNIFORM_SHARED_MODELVIEW],
+                                     0,
                                      modelview);
 
   if (self->uniform_locations[UNIFORM_SHARED_PROJECTION] > -1)
     gsk_gl_uniform_state_set_matrix (self->uniforms,
                                      self->program_info,
                                      self->uniform_locations[UNIFORM_SHARED_PROJECTION],
+                                     0,
                                      projection);
 
   if (self->uniform_locations[UNIFORM_SHARED_CLIP_RECT] > -1)
@@ -192,11 +195,13 @@ gsk_gl_program_begin_draw (GskGLProgram            *self,
         gsk_gl_uniform_state_set_rounded_rect (self->uniforms,
                                                self->program_info,
                                                self->uniform_locations[UNIFORM_SHARED_CLIP_RECT],
+                                               0,
                                                clip);
       else
         gsk_gl_uniform_state_set_rounded_rect (self->uniforms,
                                                self->program_info,
                                                self->uniform_locations[UNIFORM_SHARED_CLIP_RECT],
+                                               0,
                                                &GSK_ROUNDED_RECT_INIT (0,
                                                                        0,
                                                                        viewport->size.width,
@@ -207,6 +212,7 @@ gsk_gl_program_begin_draw (GskGLProgram            *self,
     gsk_gl_uniform_state_set1f (self->uniforms,
                                 self->program_info,
                                 self->uniform_locations[UNIFORM_SHARED_ALPHA],
+                                0,
                                 alpha);
 }
 
diff --git a/gsk/next/gskglprogramprivate.h b/gsk/next/gskglprogramprivate.h
index 7c3b9b7a51..f5e04395f6 100644
--- a/gsk/next/gskglprogramprivate.h
+++ b/gsk/next/gskglprogramprivate.h
@@ -82,73 +82,79 @@ void          gsk_gl_program_begin_draw     (GskGLProgram            *self,
 static inline void
 gsk_gl_program_set_uniform1fv (GskGLProgram *self,
                                guint         key,
+                               guint         stamp,
                                guint         count,
                                const float  *values)
 {
   gsk_gl_uniform_state_set1fv (self->uniforms, self->program_info,
                                gsk_gl_program_get_uniform_location (self, key),
-                               count, values);
+                               stamp, count, values);
 }
 
 static inline void
 gsk_gl_program_set_uniform2fv (GskGLProgram *self,
                                guint         key,
+                               guint         stamp,
                                guint         count,
                                const float  *values)
 {
   gsk_gl_uniform_state_set2fv (self->uniforms, self->program_info,
                                gsk_gl_program_get_uniform_location (self, key),
-                               count, values);
+                               stamp, count, values);
 }
 
 static inline void
 gsk_gl_program_set_uniform4fv (GskGLProgram *self,
                                guint         key,
+                               guint         stamp,
                                guint         count,
                                const float  *values)
 {
   gsk_gl_uniform_state_set4fv (self->uniforms, self->program_info,
                                gsk_gl_program_get_uniform_location (self, key),
-                               count, values);
+                               stamp, count, values);
 }
 
 static inline void
 gsk_gl_program_set_uniform_rounded_rect (GskGLProgram         *self,
                                          guint                 key,
+                                         guint                 stamp,
                                          const GskRoundedRect *rounded_rect)
 {
   gsk_gl_uniform_state_set_rounded_rect (self->uniforms, self->program_info,
                                          gsk_gl_program_get_uniform_location (self, key),
-                                         rounded_rect);
+                                         stamp, rounded_rect);
 }
 
 static inline void
 gsk_gl_program_set_uniform1i (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               int           value0)
 {
   gsk_gl_uniform_state_set1i (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0);
+                              stamp, value0);
 }
 
 static inline void
 gsk_gl_program_set_uniform2i (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               int           value0,
                               int           value1)
 {
   gsk_gl_uniform_state_set2i (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1);
+                              stamp, value0, value1);
 }
 
 static inline void
 gsk_gl_program_set_uniform3i (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               int           value0,
                               int           value1,
                               int           value2)
@@ -156,14 +162,13 @@ gsk_gl_program_set_uniform3i (GskGLProgram *self,
   gsk_gl_uniform_state_set3i (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1,
-                              value2);
+                              stamp, value0, value1, value2);
 }
 
 static inline void
 gsk_gl_program_set_uniform4i (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               int           value0,
                               int           value1,
                               int           value2,
@@ -172,39 +177,38 @@ gsk_gl_program_set_uniform4i (GskGLProgram *self,
   gsk_gl_uniform_state_set4i (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1,
-                              value2,
-                              value3);
+                              stamp, value0, value1, value2, value3);
 }
 
 static inline void
 gsk_gl_program_set_uniform1f (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               float         value0)
 {
   gsk_gl_uniform_state_set1f (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0);
+                              stamp, value0);
 }
 
 static inline void
 gsk_gl_program_set_uniform2f (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               float         value0,
                               float         value1)
 {
   gsk_gl_uniform_state_set2f (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1);
+                              stamp, value0, value1);
 }
 
 static inline void
 gsk_gl_program_set_uniform3f (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               float         value0,
                               float         value1,
                               float         value2)
@@ -212,14 +216,13 @@ gsk_gl_program_set_uniform3f (GskGLProgram *self,
   gsk_gl_uniform_state_set3f (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1,
-                              value2);
+                              stamp, value0, value1, value2);
 }
 
 static inline void
 gsk_gl_program_set_uniform4f (GskGLProgram *self,
                               guint         key,
+                              guint         stamp,
                               float         value0,
                               float         value1,
                               float         value2,
@@ -228,26 +231,25 @@ gsk_gl_program_set_uniform4f (GskGLProgram *self,
   gsk_gl_uniform_state_set4f (self->uniforms,
                               self->program_info,
                               gsk_gl_program_get_uniform_location (self, key),
-                              value0,
-                              value1,
-                              value2,
-                              value3);
+                              stamp, value0, value1, value2, value3);
 }
 
 static inline void
 gsk_gl_program_set_uniform_color (GskGLProgram  *self,
                                   guint          key,
+                                  guint          stamp,
                                   const GdkRGBA *color)
 {
   gsk_gl_uniform_state_set_color (self->uniforms,
                                   self->program_info,
                                   gsk_gl_program_get_uniform_location (self, key),
-                                  color);
+                                  stamp, color);
 }
 
 static inline void
 gsk_gl_program_set_uniform_texture (GskGLProgram *self,
                                     guint         key,
+                                    guint         stamp,
                                     GLenum        texture_target,
                                     GLenum        texture_slot,
                                     guint         texture_id)
@@ -259,18 +261,19 @@ gsk_gl_program_set_uniform_texture (GskGLProgram *self,
   gsk_gl_uniform_state_set_texture (self->uniforms,
                                     self->program_info,
                                     gsk_gl_program_get_uniform_location (self, key),
-                                    texture_slot);
+                                    stamp, texture_slot);
 }
 
 static inline void
 gsk_gl_program_set_uniform_matrix (GskGLProgram            *self,
                                    guint                    key,
+                                   guint                    stamp,
                                    const graphene_matrix_t *matrix)
 {
   gsk_gl_uniform_state_set_matrix (self->uniforms,
                                    self->program_info,
                                    gsk_gl_program_get_uniform_location (self, key),
-                                   matrix);
+                                   stamp, matrix);
 }
 
 G_END_DECLS
diff --git a/gsk/next/gskglrenderjob.c b/gsk/next/gskglrenderjob.c
index d5e07dec08..7823417351 100644
--- a/gsk/next/gskglrenderjob.c
+++ b/gsk/next/gskglrenderjob.c
@@ -998,7 +998,7 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
     {
       gsk_gl_render_job_begin_draw (job, job->driver->blit);
       gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D, GL_TEXTURE0, cached_id);
       gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
       gsk_gl_render_job_end_draw (job);
@@ -1077,7 +1077,7 @@ gsk_gl_render_job_visit_as_fallback (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->blit);
   gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       texture_id);
@@ -1137,19 +1137,19 @@ blur_offscreen (GskGLRenderJob       *job,
    */
   gsk_gl_render_job_begin_draw (job, job->driver->blur);
   gsk_gl_program_set_uniform_texture (job->driver->blur,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       offscreen->texture_id);
   gsk_gl_program_set_uniform1f (job->driver->blur,
-                                UNIFORM_BLUR_RADIUS,
+                                UNIFORM_BLUR_RADIUS, 0,
                                 blur_radius_x);
   gsk_gl_program_set_uniform2f (job->driver->blur,
-                                UNIFORM_BLUR_SIZE,
+                                UNIFORM_BLUR_SIZE, 0,
                                 texture_to_blur_width,
                                 texture_to_blur_height);
   gsk_gl_program_set_uniform2f (job->driver->blur,
-                                UNIFORM_BLUR_DIR,
+                                UNIFORM_BLUR_DIR, 0,
                                 1, 0);
   gsk_gl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
   gsk_gl_render_job_end_draw (job);
@@ -1161,19 +1161,19 @@ blur_offscreen (GskGLRenderJob       *job,
   /* Draw using blur program with first pass as source texture */
   gsk_gl_render_job_begin_draw (job, job->driver->blur);
   gsk_gl_program_set_uniform_texture (job->driver->blur,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       pass1->texture_id);
   gsk_gl_program_set_uniform1f (job->driver->blur,
-                                UNIFORM_BLUR_RADIUS,
+                                UNIFORM_BLUR_RADIUS, 0,
                                 blur_radius_y);
   gsk_gl_program_set_uniform2f (job->driver->blur,
-                                UNIFORM_BLUR_SIZE,
+                                UNIFORM_BLUR_SIZE, 0,
                                 texture_to_blur_width,
                                 texture_to_blur_height);
   gsk_gl_program_set_uniform2f (job->driver->blur,
-                                UNIFORM_BLUR_DIR,
+                                UNIFORM_BLUR_DIR, 0,
                                 0, 1);
   gsk_gl_render_job_draw_coords (job, 0, 0, texture_to_blur_width, texture_to_blur_height);
   gsk_gl_render_job_end_draw (job);
@@ -1250,7 +1250,7 @@ gsk_gl_render_job_visit_color_node (GskGLRenderJob      *job,
 {
   gsk_gl_render_job_begin_draw (job, job->driver->color);
   gsk_gl_program_set_uniform_color (job->driver->color,
-                                    UNIFORM_COLOR_COLOR,
+                                    UNIFORM_COLOR_COLOR, 0,
                                     gsk_color_node_get_color (node));
   gsk_gl_render_job_draw_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -1274,17 +1274,17 @@ gsk_gl_render_job_visit_linear_gradient_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->linear_gradient);
   gsk_gl_program_set_uniform1i (job->driver->linear_gradient,
-                                UNIFORM_LINEAR_GRADIENT_NUM_COLOR_STOPS,
+                                UNIFORM_LINEAR_GRADIENT_NUM_COLOR_STOPS, 0,
                                 n_color_stops);
   gsk_gl_program_set_uniform1fv (job->driver->linear_gradient,
-                                 UNIFORM_LINEAR_GRADIENT_COLOR_STOPS,
+                                 UNIFORM_LINEAR_GRADIENT_COLOR_STOPS, 0,
                                  n_color_stops * 5,
                                  (const float *)stops);
   gsk_gl_program_set_uniform4f (job->driver->linear_gradient,
-                                UNIFORM_LINEAR_GRADIENT_POINTS,
+                                UNIFORM_LINEAR_GRADIENT_POINTS, 0,
                                 x1, y1, x2 - x1, y2 - y1);
   gsk_gl_program_set_uniform1i (job->driver->linear_gradient,
-                                UNIFORM_LINEAR_GRADIENT_REPEAT,
+                                UNIFORM_LINEAR_GRADIENT_REPEAT, 0,
                                 repeat);
   gsk_gl_render_job_draw_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -1306,14 +1306,14 @@ gsk_gl_render_job_visit_conic_gradient_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->conic_gradient);
   gsk_gl_program_set_uniform1i (job->driver->conic_gradient,
-                                UNIFORM_CONIC_GRADIENT_NUM_COLOR_STOPS,
+                                UNIFORM_CONIC_GRADIENT_NUM_COLOR_STOPS, 0,
                                 n_color_stops);
   gsk_gl_program_set_uniform1fv (job->driver->conic_gradient,
-                                 UNIFORM_CONIC_GRADIENT_COLOR_STOPS,
+                                 UNIFORM_CONIC_GRADIENT_COLOR_STOPS, 0,
                                  n_color_stops * 5,
                                  (const float *)stops);
   gsk_gl_program_set_uniform4f (job->driver->conic_gradient,
-                                UNIFORM_CONIC_GRADIENT_GEOMETRY,
+                                UNIFORM_CONIC_GRADIENT_GEOMETRY, 0,
                                 job->offset_x + center->x,
                                 job->offset_y + center->y,
                                 scale,
@@ -1341,20 +1341,20 @@ gsk_gl_render_job_visit_radial_gradient_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->radial_gradient);
   gsk_gl_program_set_uniform1i (job->driver->radial_gradient,
-                                UNIFORM_RADIAL_GRADIENT_NUM_COLOR_STOPS,
+                                UNIFORM_RADIAL_GRADIENT_NUM_COLOR_STOPS, 0,
                                 n_color_stops);
   gsk_gl_program_set_uniform1fv (job->driver->radial_gradient,
-                                 UNIFORM_RADIAL_GRADIENT_COLOR_STOPS,
+                                 UNIFORM_RADIAL_GRADIENT_COLOR_STOPS, 0,
                                  n_color_stops * 5,
                                  (const float *)stops);
   gsk_gl_program_set_uniform1i (job->driver->radial_gradient,
-                                UNIFORM_RADIAL_GRADIENT_REPEAT,
+                                UNIFORM_RADIAL_GRADIENT_REPEAT, 0,
                                 repeat);
   gsk_gl_program_set_uniform2f (job->driver->radial_gradient,
-                                UNIFORM_RADIAL_GRADIENT_RANGE,
+                                UNIFORM_RADIAL_GRADIENT_RANGE, 0,
                                 scale, bias);
   gsk_gl_program_set_uniform4f (job->driver->radial_gradient,
-                                UNIFORM_RADIAL_GRADIENT_GEOMETRY,
+                                UNIFORM_RADIAL_GRADIENT_GEOMETRY, 0,
                                 job->offset_x + center->x,
                                 job->offset_y + center->y,
                                 1.0f / (hradius * job->scale_x),
@@ -1413,7 +1413,7 @@ gsk_gl_render_job_visit_clipped_child (GskGLRenderJob        *job,
 
       gsk_gl_render_job_begin_draw (job, job->driver->blit);
       gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
@@ -1524,7 +1524,7 @@ gsk_gl_render_job_visit_rounded_clip_node (GskGLRenderJob      *job,
 
       gsk_gl_render_job_begin_draw (job, job->driver->blit);
       gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
@@ -1577,16 +1577,16 @@ gsk_gl_render_job_visit_uniform_border_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
   gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
-                                           UNIFORM_INSET_SHADOW_OUTLINE_RECT,
+                                           UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
                                            &outline);
   gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
-                                    UNIFORM_INSET_SHADOW_COLOR,
+                                    UNIFORM_INSET_SHADOW_COLOR, 0,
                                     &colors[0]);
   gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
-                                UNIFORM_INSET_SHADOW_SPREAD,
+                                UNIFORM_INSET_SHADOW_SPREAD, 0,
                                 widths[0]);
   gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
-                                UNIFORM_INSET_SHADOW_OFFSET,
+                                UNIFORM_INSET_SHADOW_OFFSET, 0,
                                 0, 0);
   gsk_gl_render_job_draw_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -1706,11 +1706,11 @@ gsk_gl_render_job_visit_border_node (GskGLRenderJob      *job,
     gsk_gl_render_job_transform_rounded_rect (job, rounded_outline, &outline);
 
     gsk_gl_program_set_uniform4fv (job->driver->border,
-                                   UNIFORM_BORDER_WIDTHS,
+                                   UNIFORM_BORDER_WIDTHS, 0,
                                    1,
                                    widths);
     gsk_gl_program_set_uniform_rounded_rect (job->driver->border,
-                                             UNIFORM_BORDER_OUTLINE_RECT,
+                                             UNIFORM_BORDER_OUTLINE_RECT, 0,
                                              &outline);
 
     for (guint i = 0; i < 4; i++)
@@ -1722,7 +1722,7 @@ gsk_gl_render_job_visit_border_node (GskGLRenderJob      *job,
 
         gsk_gl_render_job_begin_draw (job, job->driver->border);
         gsk_gl_program_set_uniform4fv (job->driver->border,
-                                       UNIFORM_BORDER_COLOR,
+                                       UNIFORM_BORDER_COLOR, 0,
                                        1,
                                        (const float *)&colors[indices[i]]);
         vertices = gsk_gl_command_queue_add_vertices (job->command_queue);
@@ -1828,7 +1828,7 @@ gsk_gl_render_job_visit_transform_node (GskGLRenderJob      *job,
 
               gsk_gl_render_job_begin_draw (job, job->driver->blit);
               gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                                  UNIFORM_SHARED_SOURCE,
+                                                  UNIFORM_SHARED_SOURCE, 0,
                                                   GL_TEXTURE_2D,
                                                   GL_TEXTURE0,
                                                   offscreen.texture_id);
@@ -1856,16 +1856,16 @@ gsk_gl_render_job_visit_unblurred_inset_shadow_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
   gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
-                                           UNIFORM_INSET_SHADOW_OUTLINE_RECT,
+                                           UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
                                            &transformed_outline);
   gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
-                                    UNIFORM_INSET_SHADOW_COLOR,
+                                    UNIFORM_INSET_SHADOW_COLOR, 0,
                                     gsk_inset_shadow_node_get_color (node));
   gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
-                                UNIFORM_INSET_SHADOW_SPREAD,
+                                UNIFORM_INSET_SHADOW_SPREAD, 0,
                                 gsk_inset_shadow_node_get_spread (node));
   gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
-                                UNIFORM_INSET_SHADOW_OFFSET,
+                                UNIFORM_INSET_SHADOW_OFFSET, 0,
                                 gsk_inset_shadow_node_get_dx (node),
                                 gsk_inset_shadow_node_get_dy (node));
   gsk_gl_render_job_draw_rect (job, &node->bounds);
@@ -1959,16 +1959,16 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob      *job,
       /* Actual inset shadow outline drawing */
       gsk_gl_render_job_begin_draw (job, job->driver->inset_shadow);
       gsk_gl_program_set_uniform_rounded_rect (job->driver->inset_shadow,
-                                               UNIFORM_INSET_SHADOW_OUTLINE_RECT,
+                                               UNIFORM_INSET_SHADOW_OUTLINE_RECT, 0,
                                                &transformed_outline);
       gsk_gl_program_set_uniform_color (job->driver->inset_shadow,
-                                        UNIFORM_INSET_SHADOW_COLOR,
+                                        UNIFORM_INSET_SHADOW_COLOR, 0,
                                         gsk_inset_shadow_node_get_color (node));
       gsk_gl_program_set_uniform1f (job->driver->inset_shadow,
-                                    UNIFORM_INSET_SHADOW_SPREAD,
+                                    UNIFORM_INSET_SHADOW_SPREAD, 0,
                                     spread * MAX (scale_x, scale_y));
       gsk_gl_program_set_uniform2f (job->driver->inset_shadow,
-                                    UNIFORM_INSET_SHADOW_OFFSET,
+                                    UNIFORM_INSET_SHADOW_OFFSET, 0,
                                     offset_x * scale_x,
                                     offset_y * scale_y);
       gsk_gl_render_job_draw (job, 0, 0, texture_width, texture_height);
@@ -2029,7 +2029,7 @@ gsk_gl_render_job_visit_blurred_inset_shadow_node (GskGLRenderJob      *job,
 
     gsk_gl_render_job_begin_draw (job, job->driver->blit);
     gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                        UNIFORM_SHARED_SOURCE,
+                                        UNIFORM_SHARED_SOURCE, 0,
                                         GL_TEXTURE_2D,
                                         GL_TEXTURE0,
                                         blurred_texture_id);
@@ -2068,16 +2068,16 @@ gsk_gl_render_job_visit_unblurred_outset_shadow_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->unblurred_outset_shadow);
   gsk_gl_program_set_uniform_rounded_rect (job->driver->unblurred_outset_shadow,
-                                           UNIFORM_UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT,
+                                           UNIFORM_UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, 0,
                                            &transformed_outline);
   gsk_gl_program_set_uniform_color (job->driver->unblurred_outset_shadow,
-                                    UNIFORM_UNBLURRED_OUTSET_SHADOW_COLOR,
+                                    UNIFORM_UNBLURRED_OUTSET_SHADOW_COLOR, 0,
                                     gsk_outset_shadow_node_get_color (node));
   gsk_gl_program_set_uniform1f (job->driver->unblurred_outset_shadow,
-                                UNIFORM_UNBLURRED_OUTSET_SHADOW_SPREAD,
+                                UNIFORM_UNBLURRED_OUTSET_SHADOW_SPREAD, 0,
                                 spread);
   gsk_gl_program_set_uniform2f (job->driver->unblurred_outset_shadow,
-                                UNIFORM_UNBLURRED_OUTSET_SHADOW_OFFSET,
+                                UNIFORM_UNBLURRED_OUTSET_SHADOW_OFFSET, 0,
                                 dx, dy);
 
   /* Corners... */
@@ -2224,7 +2224,7 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
       /* Draw the outline using color program */
       gsk_gl_render_job_begin_draw (job, job->driver->color);
       gsk_gl_program_set_uniform_color (job->driver->color,
-                                        UNIFORM_COLOR_COLOR,
+                                        UNIFORM_COLOR_COLOR, 0,
                                         &white);
       gsk_gl_render_job_draw (job, 0, 0, texture_width, texture_height);
       gsk_gl_render_job_end_draw (job);
@@ -2270,15 +2270,15 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
 
       gsk_gl_render_job_begin_draw (job, job->driver->outset_shadow);
       gsk_gl_program_set_uniform_color (job->driver->outset_shadow,
-                                        UNIFORM_OUTSET_SHADOW_COLOR,
+                                        UNIFORM_OUTSET_SHADOW_COLOR, 0,
                                         color);
       gsk_gl_program_set_uniform_texture (job->driver->outset_shadow,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           blurred_texture_id);
       gsk_gl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
-                                               UNIFORM_OUTSET_SHADOW_OUTLINE_RECT,
+                                               UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
                                                &transformed_outline);
       gsk_gl_render_job_load_vertices_from_offscreen (job,
                                                       &GRAPHENE_RECT_INIT (min_x,
@@ -2293,15 +2293,15 @@ gsk_gl_render_job_visit_blurred_outset_shadow_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->outset_shadow);
   gsk_gl_program_set_uniform_color (job->driver->outset_shadow,
-                                    UNIFORM_OUTSET_SHADOW_COLOR,
+                                    UNIFORM_OUTSET_SHADOW_COLOR, 0,
                                     color);
   gsk_gl_program_set_uniform_texture (job->driver->outset_shadow,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       blurred_texture_id);
   gsk_gl_program_set_uniform_rounded_rect (job->driver->outset_shadow,
-                                           UNIFORM_OUTSET_SHADOW_OUTLINE_RECT,
+                                           UNIFORM_OUTSET_SHADOW_OUTLINE_RECT, 0,
                                            &transformed_outline);
 
   {
@@ -2500,17 +2500,17 @@ gsk_gl_render_job_visit_cross_fade_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->cross_fade);
   gsk_gl_program_set_uniform_texture (job->driver->cross_fade,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       offscreen_start.texture_id);
   gsk_gl_program_set_uniform_texture (job->driver->cross_fade,
-                                      UNIFORM_CROSS_FADE_SOURCE2,
+                                      UNIFORM_CROSS_FADE_SOURCE2, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE1,
                                       offscreen_end.texture_id);
   gsk_gl_program_set_uniform1f (job->driver->cross_fade,
-                                UNIFORM_CROSS_FADE_PROGRESS,
+                                UNIFORM_CROSS_FADE_PROGRESS, 0,
                                 progress);
   gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -2546,7 +2546,7 @@ gsk_gl_render_job_visit_opacity_node (GskGLRenderJob      *job,
 
           gsk_gl_render_job_begin_draw (job, job->driver->blit);
           gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                              UNIFORM_SHARED_SOURCE,
+                                              UNIFORM_SHARED_SOURCE, 0,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               offscreen.texture_id);
@@ -2594,7 +2594,7 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
   else
     {
       program = job->driver->coloring;
-      gsk_gl_program_set_uniform_color (program, UNIFORM_COLORING_COLOR, color);
+      gsk_gl_program_set_uniform_color (program, UNIFORM_COLORING_COLOR, 0, color);
     }
 
   lookup.font = (PangoFont *)font;
@@ -2638,7 +2638,7 @@ gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
           if G_LIKELY (last_texture != 0)
             gsk_gl_render_job_split_draw (job);
           gsk_gl_program_set_uniform_texture (program,
-                                              UNIFORM_SHARED_SOURCE,
+                                              UNIFORM_SHARED_SOURCE, 0,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               texture_id);
@@ -2777,12 +2777,12 @@ gsk_gl_render_job_visit_shadow_node (GskGLRenderJob      *job,
       gsk_gl_render_job_offset (job, dx, dy);
       gsk_gl_render_job_begin_draw (job, job->driver->coloring);
       gsk_gl_program_set_uniform_texture (job->driver->coloring,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
       gsk_gl_program_set_uniform_color (job->driver->coloring,
-                                        UNIFORM_COLORING_COLOR,
+                                        UNIFORM_COLORING_COLOR, 0,
                                         &shadow->color);
       gsk_gl_render_job_load_vertices_from_offscreen (job, &bounds, &offscreen);
       gsk_gl_render_job_end_draw (job);
@@ -2834,7 +2834,7 @@ gsk_gl_render_job_visit_blur_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->blit);
   gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       offscreen.texture_id);
@@ -2873,7 +2873,7 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob      *job,
     {
       gsk_gl_render_job_begin_draw (job, job->driver->blit);
       gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           bottom_offscreen.texture_id);
@@ -2886,17 +2886,17 @@ gsk_gl_render_job_visit_blend_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->blend);
   gsk_gl_program_set_uniform_texture (job->driver->blend,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       bottom_offscreen.texture_id);
   gsk_gl_program_set_uniform_texture (job->driver->blend,
-                                      UNIFORM_BLEND_SOURCE2,
+                                      UNIFORM_BLEND_SOURCE2, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE1,
                                       top_offscreen.texture_id);
   gsk_gl_program_set_uniform1i (job->driver->blend,
-                                UNIFORM_BLEND_MODE,
+                                UNIFORM_BLEND_MODE, 0,
                                 gsk_blend_node_get_blend_mode (node));
   gsk_gl_render_job_draw_offscreen_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -2925,15 +2925,15 @@ gsk_gl_render_job_visit_color_matrix_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->color_matrix);
   gsk_gl_program_set_uniform_texture (job->driver->color_matrix,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       offscreen.texture_id);
   gsk_gl_program_set_uniform_matrix (job->driver->color_matrix,
-                                     UNIFORM_COLOR_MATRIX_COLOR_MATRIX,
+                                     UNIFORM_COLOR_MATRIX_COLOR_MATRIX, 0,
                                      gsk_color_matrix_node_get_color_matrix (node));
   gsk_gl_program_set_uniform4fv (job->driver->color_matrix,
-                                 UNIFORM_COLOR_MATRIX_COLOR_OFFSET,
+                                 UNIFORM_COLOR_MATRIX_COLOR_OFFSET, 0,
                                  1,
                                  offset);
   gsk_gl_render_job_load_vertices_from_offscreen (job, &node->bounds, &offscreen);
@@ -2948,7 +2948,7 @@ gsk_gl_render_job_visit_gl_shader_node_fallback (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->color);
   gsk_gl_program_set_uniform_color (job->driver->color,
-                                    UNIFORM_COLOR_COLOR,
+                                    UNIFORM_COLOR_COLOR, 0,
                                     &pink);
   gsk_gl_render_job_draw_rect (job, &node->bounds);
   gsk_gl_render_job_end_draw (job);
@@ -3006,12 +3006,12 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob      *job,
       gsk_gl_render_job_begin_draw (job, program);
       for (guint i = 0; i < n_children; i++)
         gsk_gl_program_set_uniform_texture (program,
-                                            UNIFORM_CUSTOM_TEXTURE1 + i,
+                                            UNIFORM_CUSTOM_TEXTURE1 + i, 0,
                                             GL_TEXTURE_2D,
                                             GL_TEXTURE0 + i,
                                             offscreens[i].texture_id);
       gsk_gl_program_set_uniform2f (program,
-                                    UNIFORM_CUSTOM_SIZE,
+                                    UNIFORM_CUSTOM_SIZE, 0,
                                     node->bounds.size.width,
                                     node->bounds.size.height);
       for (guint i = 0; i < n_uniforms; i++)
@@ -3028,42 +3028,38 @@ gsk_gl_render_job_visit_gl_shader_node (GskGLRenderJob      *job,
               gsk_gl_uniform_state_set1fv (job->command_queue->uniforms,
                                            program->program_info,
                                            program->args_locations[i],
-                                           1,
-                                           (const float *)data);
+                                           0, 1, (const float *)data);
               break;
             case GSK_GL_UNIFORM_TYPE_INT:
               gsk_gl_uniform_state_set1i (job->command_queue->uniforms,
                                           program->program_info,
                                           program->args_locations[i],
-                                          *(const gint32 *)data);
+                                          0, *(const gint32 *)data);
               break;
             case GSK_GL_UNIFORM_TYPE_UINT:
             case GSK_GL_UNIFORM_TYPE_BOOL:
               gsk_gl_uniform_state_set1ui (job->command_queue->uniforms,
                                            program->program_info,
                                            program->args_locations[i],
-                                           *(const guint32 *)data);
+                                           0, *(const guint32 *)data);
               break;
             case GSK_GL_UNIFORM_TYPE_VEC2:
               gsk_gl_uniform_state_set2fv (job->command_queue->uniforms,
                                            program->program_info,
                                            program->args_locations[i],
-                                           1,
-                                           (const float *)data);
+                                           0, 1, (const float *)data);
               break;
             case GSK_GL_UNIFORM_TYPE_VEC3:
               gsk_gl_uniform_state_set3fv (job->command_queue->uniforms,
                                            program->program_info,
                                            program->args_locations[i],
-                                           1,
-                                           (const float *)data);
+                                           0, 1, (const float *)data);
               break;
             case GSK_GL_UNIFORM_TYPE_VEC4:
               gsk_gl_uniform_state_set4fv (job->command_queue->uniforms,
                                            program->program_info,
                                            program->args_locations[i],
-                                           1,
-                                           (const float *)data);
+                                           0, 1, (const float *)data);
               break;
             }
         }
@@ -3114,7 +3110,7 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob      *job,
 
       gsk_gl_render_job_begin_draw (job, job->driver->blit);
       gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                          UNIFORM_SHARED_SOURCE,
+                                          UNIFORM_SHARED_SOURCE, 0,
                                           GL_TEXTURE_2D,
                                           GL_TEXTURE0,
                                           offscreen.texture_id);
@@ -3153,7 +3149,7 @@ gsk_gl_render_job_visit_texture_node (GskGLRenderJob      *job,
           if (i > 0)
             gsk_gl_render_job_split_draw (job);
           gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                              UNIFORM_SHARED_SOURCE,
+                                              UNIFORM_SHARED_SOURCE, 0,
                                               GL_TEXTURE_2D,
                                               GL_TEXTURE0,
                                               slice->texture_id);
@@ -3229,18 +3225,18 @@ gsk_gl_render_job_visit_repeat_node (GskGLRenderJob      *job,
 
   gsk_gl_render_job_begin_draw (job, job->driver->repeat);
   gsk_gl_program_set_uniform_texture (job->driver->repeat,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       offscreen.texture_id);
   gsk_gl_program_set_uniform4f (job->driver->repeat,
-                                UNIFORM_REPEAT_CHILD_BOUNDS,
+                                UNIFORM_REPEAT_CHILD_BOUNDS, 0,
                                 (node->bounds.origin.x - child_bounds->origin.x) / child_bounds->size.width,
                                 (node->bounds.origin.y - child_bounds->origin.y) / child_bounds->size.height,
                                 node->bounds.size.width / child_bounds->size.width,
                                 node->bounds.size.height / child_bounds->size.height);
   gsk_gl_program_set_uniform4f (job->driver->repeat,
-                                UNIFORM_REPEAT_TEXTURE_RECT,
+                                UNIFORM_REPEAT_TEXTURE_RECT, 0,
                                 offscreen.area.x,
                                 offscreen.was_offscreen ? offscreen.area.y2 : offscreen.area.y,
                                 offscreen.area.x2,
@@ -3616,7 +3612,7 @@ gsk_gl_render_job_render_flipped (GskGLRenderJob *job,
   gsk_gl_command_queue_clear (job->command_queue, 0, &job->viewport);
   gsk_gl_render_job_begin_draw (job, job->driver->blit);
   gsk_gl_program_set_uniform_texture (job->driver->blit,
-                                      UNIFORM_SHARED_SOURCE,
+                                      UNIFORM_SHARED_SOURCE, 0,
                                       GL_TEXTURE_2D,
                                       GL_TEXTURE0,
                                       texture_id);
diff --git a/gsk/next/gskgluniformstateprivate.h b/gsk/next/gskgluniformstateprivate.h
index a0dc1b0933..0f574ad945 100644
--- a/gsk/next/gskgluniformstateprivate.h
+++ b/gsk/next/gskgluniformstateprivate.h
@@ -175,12 +175,25 @@ gsk_gl_uniform_state_get_value (GskGLUniformState        *state,
                                 GskGLUniformFormat        format,
                                 guint                     array_count,
                                 guint                     location,
+                                guint                     stamp,
                                 GskGLUniformInfoElement **infoptr)
 {
   GskGLUniformInfoElement *info = &program->uniforms[location];
 
   if G_LIKELY (format == info->info.format && array_count <= info->info.array_count)
     {
+      /* If the stamp is the same, then we can ignore the request
+       * and short-circuit as early as possible. This requires the
+       * peer to also increment their private stamp when they change
+       * internal state.
+       *
+       * This is generally used for the shared uniforms like projection,
+       * modelview, clip, etc to avoid so many comparisons which cost
+       * considerable CPU.
+       */
+      if (stamp == info->stamp)
+        return NULL;
+
       *infoptr = info;
       return state->values_buf + info->info.offset;
     }
@@ -257,6 +270,7 @@ static inline void
 gsk_gl_uniform_state_set1f (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             float                value0)
 {
   Uniform1f *u;
@@ -265,7 +279,7 @@ gsk_gl_uniform_state_set1f (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != 0);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1F, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1F, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0)
         {
@@ -280,6 +294,7 @@ static inline void
 gsk_gl_uniform_state_set2f (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             float                value0,
                             float                value1)
 {
@@ -289,7 +304,7 @@ gsk_gl_uniform_state_set2f (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2F, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2F, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1)
         {
@@ -305,6 +320,7 @@ static inline void
 gsk_gl_uniform_state_set3f (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             float                value0,
                             float                value1,
                             float                value2)
@@ -315,7 +331,7 @@ gsk_gl_uniform_state_set3f (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3F, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3F, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1 || u->v2 != value2)
         {
@@ -332,6 +348,7 @@ static inline void
 gsk_gl_uniform_state_set4f (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             float                value0,
                             float                value1,
                             float                value2,
@@ -343,7 +360,7 @@ gsk_gl_uniform_state_set4f (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4F, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4F, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1 || u->v2 != value2 || u->v3 != value3)
         {
@@ -361,6 +378,7 @@ static inline void
 gsk_gl_uniform_state_set1ui (GskGLUniformState   *state,
                              GskGLUniformProgram *program,
                              guint                location,
+                             guint                stamp,
                              guint                value0)
 {
   Uniform1ui *u;
@@ -369,7 +387,7 @@ gsk_gl_uniform_state_set1ui (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1UI, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1UI, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0)
         {
@@ -384,6 +402,7 @@ static inline void
 gsk_gl_uniform_state_set1i (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             int                  value0)
 {
   Uniform1i *u;
@@ -392,7 +411,7 @@ gsk_gl_uniform_state_set1i (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1I, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1I, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0)
         {
@@ -407,6 +426,7 @@ static inline void
 gsk_gl_uniform_state_set2i (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             int                  value0,
                             int                  value1)
 {
@@ -416,7 +436,7 @@ gsk_gl_uniform_state_set2i (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2I, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2I, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1)
         {
@@ -432,6 +452,7 @@ static inline void
 gsk_gl_uniform_state_set3i (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             int                  value0,
                             int                  value1,
                             int                  value2)
@@ -442,7 +463,7 @@ gsk_gl_uniform_state_set3i (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3I, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3I, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1 || u->v2 != value2)
         {
@@ -459,6 +480,7 @@ static inline void
 gsk_gl_uniform_state_set4i (GskGLUniformState   *state,
                             GskGLUniformProgram *program,
                             guint                location,
+                            guint                stamp,
                             int                  value0,
                             int                  value1,
                             int                  value2,
@@ -470,7 +492,7 @@ gsk_gl_uniform_state_set4i (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4I, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4I, 1, location, stamp, 
&info)))
     {
       if (info->info.initial || u->v0 != value0 || u->v1 != value1 || u->v2 != value2 || u->v3 != value3)
         {
@@ -506,6 +528,7 @@ static inline void
 gsk_gl_uniform_state_set_rounded_rect (GskGLUniformState    *state,
                                        GskGLUniformProgram  *program,
                                        guint                 location,
+                                       guint                 stamp,
                                        const GskRoundedRect *rounded_rect)
 {
   GskRoundedRect *u;
@@ -515,7 +538,7 @@ gsk_gl_uniform_state_set_rounded_rect (GskGLUniformState    *state,
   g_assert (program != NULL);
   g_assert (rounded_rect != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_ROUNDED_RECT, 1, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_ROUNDED_RECT, 1, location, 
stamp, &info)))
     {
       if (info->info.initial || !rounded_rect_equal (rounded_rect, u))
         {
@@ -540,6 +563,7 @@ static inline void
 gsk_gl_uniform_state_set_matrix (GskGLUniformState       *state,
                                  GskGLUniformProgram     *program,
                                  guint                    location,
+                                 guint                    stamp,
                                  const graphene_matrix_t *matrix)
 {
   graphene_matrix_t *u;
@@ -549,7 +573,7 @@ gsk_gl_uniform_state_set_matrix (GskGLUniformState       *state,
   g_assert (program != NULL);
   g_assert (matrix != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_MATRIX, 1, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_MATRIX, 1, location, stamp, 
&info)))
     {
       if (!info->info.initial && memcmp (u, matrix, sizeof *u) == 0)
         return;
@@ -578,6 +602,7 @@ static inline void
 gsk_gl_uniform_state_set_texture (GskGLUniformState   *state,
                                   GskGLUniformProgram *program,
                                   guint                location,
+                                  guint                stamp,
                                   guint                texture_slot)
 {
   GskGLUniformInfoElement *info;
@@ -588,7 +613,7 @@ gsk_gl_uniform_state_set_texture (GskGLUniformState   *state,
 
   texture_slot -= GL_TEXTURE0;
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_TEXTURE, 1, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_TEXTURE, 1, location, 
stamp, &info)))
     {
       if (info->info.initial || *u != texture_slot)
         {
@@ -614,6 +639,7 @@ static inline void
 gsk_gl_uniform_state_set_color (GskGLUniformState   *state,
                                 GskGLUniformProgram *program,
                                 guint                location,
+                                guint                stamp,
                                 const GdkRGBA       *color)
 {
   static const GdkRGBA transparent = {0};
@@ -623,7 +649,7 @@ gsk_gl_uniform_state_set_color (GskGLUniformState   *state,
   g_assert (state != NULL);
   g_assert (program != NULL);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_COLOR, 1, location, &info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_COLOR, 1, location, stamp, 
&info)))
     {
       if (color == NULL)
         color = &transparent;
@@ -641,6 +667,7 @@ static inline void
 gsk_gl_uniform_state_set1fv (GskGLUniformState   *state,
                              GskGLUniformProgram *program,
                              guint                location,
+                             guint                stamp,
                              guint                count,
                              const float         *value)
 {
@@ -651,7 +678,7 @@ gsk_gl_uniform_state_set1fv (GskGLUniformState   *state,
   g_assert (program != NULL);
   g_assert (count > 0);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1FV, count, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_1FV, count, location, 
stamp, &info)))
     {
       gboolean changed = info->info.initial || memcmp (u, value, sizeof *u * count) != 0;
 
@@ -668,6 +695,7 @@ static inline void
 gsk_gl_uniform_state_set2fv (GskGLUniformState   *state,
                              GskGLUniformProgram *program,
                              guint                location,
+                             guint                stamp,
                              guint                count,
                              const float         *value)
 {
@@ -678,7 +706,7 @@ gsk_gl_uniform_state_set2fv (GskGLUniformState   *state,
   g_assert (program != NULL);
   g_assert (count > 0);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2FV, count, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_2FV, count, location, 
stamp, &info)))
     {
       gboolean changed = info->info.initial || memcmp (u, value, sizeof *u * count) != 0;
 
@@ -695,6 +723,7 @@ static inline void
 gsk_gl_uniform_state_set3fv (GskGLUniformState   *state,
                              GskGLUniformProgram *program,
                              guint                location,
+                             guint                stamp,
                              guint                count,
                              const float         *value)
 {
@@ -705,7 +734,7 @@ gsk_gl_uniform_state_set3fv (GskGLUniformState   *state,
   g_assert (program != NULL);
   g_assert (count > 0);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3FV, count, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_3FV, count, location, 
stamp, &info)))
     {
       gboolean changed = info->info.initial || memcmp (u, value, sizeof *u * count) != 0;
 
@@ -722,6 +751,7 @@ static inline void
 gsk_gl_uniform_state_set4fv (GskGLUniformState   *state,
                              GskGLUniformProgram *program,
                              guint                location,
+                             guint                stamp,
                              guint                count,
                              const float         *value)
 {
@@ -732,7 +762,7 @@ gsk_gl_uniform_state_set4fv (GskGLUniformState   *state,
   g_assert (program != NULL);
   g_assert (count > 0);
 
-  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4FV, count, location, 
&info)))
+  if ((u = gsk_gl_uniform_state_get_value (state, program, GSK_GL_UNIFORM_FORMAT_4FV, count, location, 
stamp, &info)))
     {
       gboolean changed = info->info.initial || memcmp (u, value, sizeof *u * count) != 0;
 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]