Merge branch 'wip/otte/kill-descriptors' into 'main'

Redo descriptors/texture binding

Closes #6564, #6574, and #6654

See merge request GNOME/gtk!7473

gdk/gdkdisplayprivate.h

@@ -45,12 +45,9 @@ typedef struct _GdkDisplayClass GdkDisplayClass;
 typedef enum {
   GDK_VULKAN_FEATURE_DMABUF                     = 1 << 0,
   GDK_VULKAN_FEATURE_YCBCR                      = 1 << 1,
-  GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING        = 1 << 2,
-  GDK_VULKAN_FEATURE_DYNAMIC_INDEXING           = 1 << 3,
-  GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING        = 1 << 4,
-  GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT           = 1 << 5,
-  GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT           = 1 << 6,
-  GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT        = 1 << 7,
+  GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT           = 1 << 2,
+  GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT           = 1 << 3,
+  GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT        = 1 << 4,
 } GdkVulkanFeatures;
 
 /* Tracks information about the device grab on this display */

gdk/gdkvulkancontext.c

@@ -38,9 +38,6 @@
 static const GdkDebugKey gsk_vulkan_feature_keys[] = {
   { "dmabuf", GDK_VULKAN_FEATURE_DMABUF, "Never import Dmabufs" },
   { "ycbcr", GDK_VULKAN_FEATURE_YCBCR, "Do not support Ycbcr textures (also disables dmabufs)" },
-  { "descriptor-indexing", GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING, "Force slow descriptor set layout codepath" },
-  { "dynamic-indexing", GDK_VULKAN_FEATURE_DYNAMIC_INDEXING, "Hardcode small number of buffer and texture arrays" },
-  { "nonuniform-indexing", GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING, "Split draw calls to ensure uniform texture accesses" },
   { "semaphore-export", GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT, "Disable sync of exported dmabufs" },
   { "semaphore-import", GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT, "Disable sync of imported dmabufs" },
   { "incremental-present", GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT, "Do not send damage regions" },
@@ -585,23 +582,6 @@ physical_device_check_features (VkPhysicalDevice device)
 
   features = 0;
 
-  if (v10_features.features.shaderUniformBufferArrayDynamicIndexing &&
-      v10_features.features.shaderSampledImageArrayDynamicIndexing)
-    features |= GDK_VULKAN_FEATURE_DYNAMIC_INDEXING;
-
-  if (v12_features.descriptorIndexing &&
-      v12_features.descriptorBindingPartiallyBound &&
-      v12_features.descriptorBindingVariableDescriptorCount &&
-      v12_features.descriptorBindingSampledImageUpdateAfterBind &&
-      v12_features.descriptorBindingStorageBufferUpdateAfterBind)
-    features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;
-  else if (physical_device_supports_extension (device, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME))
-    features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING;
-
-  if (v12_features.shaderSampledImageArrayNonUniformIndexing &&
-      v12_features.shaderStorageBufferArrayNonUniformIndexing)
-    features |= GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING;
-
   if (ycbcr_features.samplerYcbcrConversion ||
       physical_device_supports_extension (device, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME))
     features |= GDK_VULKAN_FEATURE_YCBCR;
@@ -1532,8 +1512,6 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
 
               device_extensions = g_ptr_array_new ();
               g_ptr_array_add (device_extensions, (gpointer) VK_KHR_SWAPCHAIN_EXTENSION_NAME);
-              if (features & GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING)
-                g_ptr_array_add (device_extensions, (gpointer) VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME);
               if (features & GDK_VULKAN_FEATURE_YCBCR)
                 {
                   g_ptr_array_add (device_extensions, (gpointer) VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
@@ -1576,16 +1554,6 @@ gdk_display_create_vulkan_device (GdkDisplay  *display,
                                                     .pNext = &(VkPhysicalDeviceVulkan11Features) {
                                                         .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
                                                         .samplerYcbcrConversion = ENABLE_IF (GDK_VULKAN_FEATURE_YCBCR),
-                                                        .pNext = &(VkPhysicalDeviceVulkan12Features) {
-                                                            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
-                                                            .shaderSampledImageArrayNonUniformIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING),
-                                                            .shaderStorageBufferArrayNonUniformIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING),
-                                                            .descriptorIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING),
-                                                            .descriptorBindingPartiallyBound = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING),
-                                                            .descriptorBindingVariableDescriptorCount = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING),
-                                                            .descriptorBindingSampledImageUpdateAfterBind = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING),
-                                                            .descriptorBindingStorageBufferUpdateAfterBind = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING),
-                                                        }
                                                     }
                                                 },
                                                 NULL,

gsk/gpu/gskgldescriptors.c

@@ -1,144 +0,0 @@
-#include "config.h"
-
-#include "gskgldescriptorsprivate.h"
-
-#include "gskglbufferprivate.h"
-#include "gskglimageprivate.h"
-
-struct _GskGLDescriptors
-{
-  GskGpuDescriptors parent_instance;
-
-  GskGLDevice *device;
-  guint n_external;
-};
-
-G_DEFINE_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK_TYPE_GPU_DESCRIPTORS)
-
-static void
-gsk_gl_descriptors_finalize (GObject *object)
-{
-  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (object);
-
-  g_object_unref (self->device);
-
-  G_OBJECT_CLASS (gsk_gl_descriptors_parent_class)->finalize (object);
-}
-
-static gboolean
-gsk_gl_descriptors_add_image (GskGpuDescriptors *desc,
-                              GskGpuImage       *image,
-                              GskGpuSampler      sampler,
-                              guint32           *out_descriptor)
-{
-  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (desc);
-  gsize used_texture_units;
-
-  used_texture_units = gsk_gpu_descriptors_get_n_images (desc) + 2 * self->n_external;
-
-  if (gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_EXTERNAL)
-    {
-      if (16 - used_texture_units < 3)
-        return FALSE;
-
-      *out_descriptor = (self->n_external << 1) | 1;
-      self->n_external++;
-      return TRUE;
-    }
-  else
-    {
-      if (used_texture_units >= 16)
-        return FALSE;
-
-      *out_descriptor = (gsk_gpu_descriptors_get_n_images (desc) - self->n_external) << 1;
-      return TRUE;
-    }
-}
-
-static gboolean
-gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc,
-                               GskGpuBuffer      *buffer,
-                               guint32           *out_descriptor)
-{
-  gsize used_buffers;
-
-  used_buffers = gsk_gpu_descriptors_get_n_buffers (desc);
-
-  if (used_buffers >= 11)
-    return FALSE;
-
-  *out_descriptor = used_buffers;
-
-  return TRUE;
-}
-
-static void
-gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
-{
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_gl_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_gl_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_gl_descriptors_add_buffer;
-}
-
-static void
-gsk_gl_descriptors_init (GskGLDescriptors *self)
-{
-}
-
-GskGpuDescriptors *
-gsk_gl_descriptors_new (GskGLDevice *device)
-{
-  GskGLDescriptors *self;
-
-  self = g_object_new (GSK_TYPE_GL_DESCRIPTORS, NULL);
-
-  self->device = g_object_ref (device);
-
-  return GSK_GPU_DESCRIPTORS (self);
-}
-
-guint
-gsk_gl_descriptors_get_n_external (GskGLDescriptors *self)
-{
-  return self->n_external;
-}
-
-void
-gsk_gl_descriptors_use (GskGLDescriptors *self)
-{
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
-  gsize i, ext, n_textures;
-
-  n_textures = 16 - 3 * self->n_external;
-  ext = 0;
-
-  for (i = 0; i < gsk_gpu_descriptors_get_n_images (desc); i++)
-    {
-      GskGLImage *image = GSK_GL_IMAGE (gsk_gpu_descriptors_get_image (desc, i));
-
-      if (gsk_gpu_image_get_flags (GSK_GPU_IMAGE (image)) & GSK_GPU_IMAGE_EXTERNAL)
-        {
-          glActiveTexture (GL_TEXTURE0 + n_textures + 3 * ext);
-          gsk_gl_image_bind_texture (image);
-          ext++;
-        }
-      else
-        {
-          glActiveTexture (GL_TEXTURE0 + i - ext);
-          gsk_gl_image_bind_texture (image);
-          glBindSampler (i - ext, gsk_gl_device_get_sampler_id (self->device, gsk_gpu_descriptors_get_sampler (desc, i)));
-        }
-    }
-
-  for (i = 0; i < gsk_gpu_descriptors_get_n_buffers (desc); i++)
-    {
-      GskGLBuffer *buffer = GSK_GL_BUFFER (gsk_gpu_descriptors_get_buffer (desc, i));
-
-      /* index 0 are the globals, we start at 1 */
-      gsk_gl_buffer_bind_base (buffer, i + 1);
-    }
-}

gsk/gpu/gskgldescriptorsprivate.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "gskgpudescriptorsprivate.h"
-
-#include "gskgldeviceprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_GL_DESCRIPTORS (gsk_gl_descriptors_get_type ())
-
-G_DECLARE_FINAL_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK, GL_DESCRIPTORS, GskGpuDescriptors)
-
-GskGpuDescriptors *               gsk_gl_descriptors_new                (GskGLDevice            *device);
-
-guint                             gsk_gl_descriptors_get_n_external     (GskGLDescriptors       *self);
-void                              gsk_gl_descriptors_use                (GskGLDescriptors       *self);
-
-G_END_DECLS
-

gsk/gpu/gskgldevice.c

@@ -3,6 +3,7 @@
 #include "gskgldeviceprivate.h"
 
 #include "gskdebugprivate.h"
+#include "gskgpushaderflagsprivate.h"
 #include "gskgpushaderopprivate.h"
 #include "gskglbufferprivate.h"
 #include "gskglimageprivate.h"
@@ -34,10 +35,9 @@ typedef struct _GLProgramKey GLProgramKey;
 struct _GLProgramKey
 {
   const GskGpuShaderOpClass *op_class;
+  GskGpuShaderFlags flags;
   GskGpuColorStates color_states;
   guint32 variation;
-  GskGpuShaderClip clip;
-  guint n_external_textures;
 };
 
 G_DEFINE_TYPE (GskGLDevice, gsk_gl_device, GSK_TYPE_GPU_DEVICE)
@@ -48,9 +48,8 @@ gl_program_key_hash (gconstpointer data)
   const GLProgramKey *key = data;
 
   return GPOINTER_TO_UINT (key->op_class) ^
-         key->clip ^
-         (key->variation << 2) ^
-         (key->n_external_textures << 24) ^
+         ((key->flags << 11) | (key->flags >> 21)) ^
+         ((key->variation << 21) | ( key->variation >> 11)) ^
          key->color_states;
 }
 
@@ -62,10 +61,9 @@ gl_program_key_equal (gconstpointer a,
   const GLProgramKey *keyb = b;
 
   return keya->op_class == keyb->op_class &&
+         keya->flags == keyb->flags && 
          keya->color_states == keyb->color_states && 
-         keya->variation == keyb->variation && 
-         keya->clip == keyb->clip && 
-         keya->n_external_textures == keyb->n_external_textures;
+         keya->variation == keyb->variation;
 }
 
 static GskGpuImage *
@@ -380,10 +378,9 @@ static GLuint
 gsk_gl_device_load_shader (GskGLDevice       *self,
                            const char        *program_name,
                            GLenum             shader_type,
+                           GskGpuShaderFlags  flags,
                            GskGpuColorStates  color_states,
                            guint32            variation,
-                           GskGpuShaderClip   clip,
-                           guint              n_external_textures,
                            GError           **error)
 {
   GString *preamble;
@@ -397,21 +394,23 @@ gsk_gl_device_load_shader (GskGLDevice       *self,
   g_string_append (preamble, "\n");
   if (self->api == GDK_GL_API_GLES)
     {
-      if (n_external_textures > 0)
+      if (gsk_gpu_shader_flags_has_external_textures (flags))
         {
           g_string_append (preamble, "#extension GL_OES_EGL_image_external_essl3 : require\n");
           g_string_append (preamble, "#extension GL_OES_EGL_image_external : require\n");
         }
       g_string_append (preamble, "#define GSK_GLES 1\n");
-      g_assert (3 * n_external_textures <= 16);
     }
   else
     {
-      g_assert (n_external_textures == 0);
+      g_assert (!gsk_gpu_shader_flags_has_external_textures (flags));
     }
 
-  g_string_append_printf (preamble, "#define N_TEXTURES %u\n", 16 - 3 * n_external_textures);
-  g_string_append_printf (preamble, "#define N_EXTERNAL_TEXTURES %u\n", n_external_textures);
+  /* work with AMD's compiler, too */
+  if (gsk_gpu_shader_flags_has_external_texture0 (flags))
+    g_string_append (preamble, "#define GSK_TEXTURE0_IS_EXTERNAL 1\n");
+  if (gsk_gpu_shader_flags_has_external_texture1 (flags))
+    g_string_append (preamble, "#define GSK_TEXTURE1_IS_EXTERNAL 1\n");
 
   switch (shader_type)
     {
@@ -428,25 +427,10 @@ gsk_gl_device_load_shader (GskGLDevice       *self,
         return 0;
     }
 
+  g_string_append_printf (preamble, "#define GSK_FLAGS %uu\n", flags);
   g_string_append_printf (preamble, "#define GSK_COLOR_STATES %uu\n", color_states);
   g_string_append_printf (preamble, "#define GSK_VARIATION %uu\n", variation);
 
-  switch (clip)
-  {
-    case GSK_GPU_SHADER_CLIP_NONE:
-      g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_NONE\n");
-      break;
-    case GSK_GPU_SHADER_CLIP_RECT:
-      g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_RECT\n");
-      break;
-    case GSK_GPU_SHADER_CLIP_ROUNDED:
-      g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_ROUNDED\n");
-      break;
-    default:
-      g_assert_not_reached ();
-      break;
-  }
-
   resource_name = g_strconcat ("/org/gtk/libgsk/shaders/gl/", program_name, ".glsl", NULL);
   bytes = g_resources_lookup_data (resource_name, 0, error);
   g_free (resource_name);
@@ -482,21 +466,20 @@ gsk_gl_device_load_shader (GskGLDevice       *self,
 static GLuint
 gsk_gl_device_load_program (GskGLDevice               *self,
                             const GskGpuShaderOpClass *op_class,
+                            GskGpuShaderFlags          flags,
                             GskGpuColorStates          color_states,
                             guint32                    variation,
-                            GskGpuShaderClip           clip,
-                            guint                      n_external_textures,
                             GError                   **error)
 {
   G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
   GLuint vertex_shader_id, fragment_shader_id, program_id;
   GLint link_status;
 
-  vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, color_states, variation, clip, n_external_textures, error);
+  vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, flags, color_states, variation, error);
   if (vertex_shader_id == 0)
     return 0;
 
-  fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, color_states, variation, clip, n_external_textures, error);
+  fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, flags, color_states, variation, error);
   if (fragment_shader_id == 0)
     return 0;
 
@@ -554,21 +537,18 @@ gsk_gl_device_load_program (GskGLDevice               *self,
 void
 gsk_gl_device_use_program (GskGLDevice               *self,
                            const GskGpuShaderOpClass *op_class,
+                           GskGpuShaderFlags          flags,
                            GskGpuColorStates          color_states,
-                           guint32                    variation,
-                           GskGpuShaderClip           clip,
-                           guint                      n_external_textures)
+                           guint32                    variation)
 {
   GError *error = NULL;
   GLuint program_id;
   GLProgramKey key = {
     .op_class = op_class,
+    .flags = flags,
     .color_states = color_states,
     .variation = variation,
-    .clip = clip,
-    .n_external_textures = n_external_textures
   };
-  guint i, n_textures;
 
   program_id = GPOINTER_TO_UINT (g_hash_table_lookup (self->gl_programs, &key));
   if (program_id)
@@ -577,7 +557,7 @@ gsk_gl_device_use_program (GskGLDevice               *self,
       return;
     }
 
-  program_id = gsk_gl_device_load_program (self, op_class, color_states, variation, clip, n_external_textures, &error);
+  program_id = gsk_gl_device_load_program (self, op_class, flags, color_states, variation, &error);
   if (program_id == 0)
     {
       g_critical ("Failed to load shader program: %s", error->message);
@@ -589,21 +569,9 @@ gsk_gl_device_use_program (GskGLDevice               *self,
 
   glUseProgram (program_id);
 
-  n_textures = 16 - 3 * n_external_textures;
-
-  for (i = 0; i < n_external_textures; i++)
-    {
-      char *name = g_strdup_printf ("external_textures[%u]", i);
-      glUniform1i (glGetUniformLocation (program_id, name), n_textures + 3 * i);
-      g_free (name);
-    }
-
-  for (i = 0; i < n_textures; i++)
-    {
-      char *name = g_strdup_printf ("textures[%u]", i);
-      glUniform1i (glGetUniformLocation (program_id, name), i);
-      g_free (name);
-    }
+  /* space by 3 because external textures may need 3 texture units */
+  glUniform1i (glGetUniformLocation (program_id, "GSK_TEXTURE0"), 0);
+  glUniform1i (glGetUniformLocation (program_id, "GSK_TEXTURE1"), 3);
 }
 
 GLuint

gsk/gpu/gskgldeviceprivate.h

@@ -13,10 +13,9 @@ GskGpuDevice *          gsk_gl_device_get_for_display                   (GdkDisp
 
 void                    gsk_gl_device_use_program                       (GskGLDevice            *self,
                                                                          const GskGpuShaderOpClass *op_class,
+                                                                         GskGpuShaderFlags       flags,
                                                                          GskGpuColorStates       color_states,
-                                                                         guint32                 variation,
-                                                                         GskGpuShaderClip        clip,
-                                                                         guint                   n_external_textures);
+                                                                         guint32                 variation);
 
 GLuint                  gsk_gl_device_get_sampler_id                    (GskGLDevice            *self,
                                                                          GskGpuSampler           sampler);

gsk/gpu/gskglframe.c

@@ -6,7 +6,6 @@
 #include "gskgpuopprivate.h"
 #include "gskgpushaderopprivate.h"
 #include "gskglbufferprivate.h"
-#include "gskgldescriptorsprivate.h"
 #include "gskgldeviceprivate.h"
 #include "gskglimageprivate.h"
 
@@ -125,12 +124,6 @@ gsk_gl_frame_upload_texture (GskGpuFrame  *frame,
   return GSK_GPU_FRAME_CLASS (gsk_gl_frame_parent_class)->upload_texture (frame, with_mipmap, texture);
 }
 
-static GskGpuDescriptors *
-gsk_gl_frame_create_descriptors (GskGpuFrame *frame)
-{
-  return GSK_GPU_DESCRIPTORS (gsk_gl_descriptors_new (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame))));
-}
-
 static GskGpuBuffer *
 gsk_gl_frame_create_vertex_buffer (GskGpuFrame *frame,
                                    gsize        size)
@@ -160,6 +153,15 @@ gsk_gl_frame_create_storage_buffer (GskGpuFrame *frame,
     return gsk_gl_copied_buffer_new (GL_UNIFORM_BUFFER, size);
 }
 
+static void
+gsk_gl_frame_write_texture_vertex_data (GskGpuFrame    *self,
+                                        guchar         *data,
+                                        GskGpuImage   **images,
+                                        GskGpuSampler  *samplers,
+                                        gsize           n_images)
+{
+}
+
 static void
 gsk_gl_frame_submit (GskGpuFrame       *frame,
                      GskRenderPassType  pass_type,
@@ -167,7 +169,10 @@ gsk_gl_frame_submit (GskGpuFrame       *frame,
                      GskGpuOp          *op)
 {
   GskGLFrame *self = GSK_GL_FRAME (frame);
-  GskGLCommandState state = { 0, };
+  GskGLCommandState state = {
+    /* rest is 0 */
+    .current_samplers = { GSK_GPU_SAMPLER_N_SAMPLERS, GSK_GPU_SAMPLER_N_SAMPLERS }
+  };
 
   glEnable (GL_SCISSOR_TEST);
 
@@ -215,9 +220,9 @@ gsk_gl_frame_class_init (GskGLFrameClass *klass)
   gpu_frame_class->wait = gsk_gl_frame_wait;
   gpu_frame_class->cleanup = gsk_gl_frame_cleanup;
   gpu_frame_class->upload_texture = gsk_gl_frame_upload_texture;
-  gpu_frame_class->create_descriptors = gsk_gl_frame_create_descriptors;
   gpu_frame_class->create_vertex_buffer = gsk_gl_frame_create_vertex_buffer;
   gpu_frame_class->create_storage_buffer = gsk_gl_frame_create_storage_buffer;
+  gpu_frame_class->write_texture_vertex_data = gsk_gl_frame_write_texture_vertex_data;
   gpu_frame_class->submit = gsk_gl_frame_submit;
 
   object_class->finalize = gsk_gl_frame_finalize;
@@ -238,19 +243,17 @@ gsk_gl_frame_init (GskGLFrame *self)
 void
 gsk_gl_frame_use_program (GskGLFrame                *self,
                           const GskGpuShaderOpClass *op_class,
+                          GskGpuShaderFlags          flags,
                           GskGpuColorStates          color_states,
-                          guint32                    variation,
-                          GskGpuShaderClip           clip,
-                          guint                      n_external_textures)
+                          guint32                    variation)
 {
   GLuint vao;
 
   gsk_gl_device_use_program (GSK_GL_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self))),
                              op_class,
+                             flags,
                              color_states,
-                             variation,
-                             clip,
-                             n_external_textures);
+                             variation);
 
   vao = GPOINTER_TO_UINT (g_hash_table_lookup (self->vaos, op_class));
   if (vao)

gsk/gpu/gskglframeprivate.h

@@ -10,10 +10,9 @@ G_DECLARE_FINAL_TYPE (GskGLFrame, gsk_gl_frame, GSK, GL_FRAME, GskGpuFrame)
 
 void                    gsk_gl_frame_use_program                        (GskGLFrame             *self,
                                                                          const GskGpuShaderOpClass *op_class,
+                                                                         GskGpuShaderFlags       flags,
                                                                          GskGpuColorStates       color_states,
-                                                                         guint32                 variation,
-                                                                         GskGpuShaderClip        clip,
-                                                                         guint                   n_external_textures);
+                                                                         guint32                 variation);
 
 void                    gsk_gl_frame_bind_globals                       (GskGLFrame             *self);
 

gsk/gpu/gskgpublendmodeop.c

@@ -25,9 +25,9 @@ gsk_gpu_blend_mode_op_print_instance (GskGpuShaderOp *shader,
 
   gsk_gpu_print_enum (string, GSK_TYPE_BLEND_MODE, shader->variation);
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->bottom_id);
+  gsk_gpu_print_image (string, shader->images[0]);
   gsk_gpu_print_enum (string, GSK_TYPE_BLEND_MODE, shader->variation);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->top_id);
+  gsk_gpu_print_image (string, shader->images[1]);
 }
 
 static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
@@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpublendmode",
+  gsk_gpu_blendmode_n_textures,
   sizeof (GskGpuBlendmodeInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_blendmode_info,
@@ -52,17 +53,14 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = {
 };
 
 void
-gsk_gpu_blend_mode_op (GskGpuFrame            *frame,
-                       GskGpuShaderClip        clip,
-                       GskGpuDescriptors      *desc,
-                       const graphene_rect_t  *rect,
-                       const graphene_point_t *offset,
-                       float                   opacity,
-                       GskBlendMode            blend_mode,
-                       guint32                 bottom_descriptor,
-                       const graphene_rect_t  *bottom_rect,
-                       guint32                 top_descriptor,
-                       const graphene_rect_t  *top_rect)
+gsk_gpu_blend_mode_op (GskGpuFrame             *frame,
+                       GskGpuShaderClip         clip,
+                       const graphene_rect_t   *rect,
+                       const graphene_point_t  *offset,
+                       float                    opacity,
+                       GskBlendMode             blend_mode,
+                       const GskGpuShaderImage *bottom,
+                       const GskGpuShaderImage *top)
 {
   GskGpuBlendmodeInstance *instance;
 
@@ -71,13 +69,12 @@ gsk_gpu_blend_mode_op (GskGpuFrame            *frame,
                            gsk_gpu_color_states_create_equal (TRUE, TRUE),
                            blend_mode,
                            clip,
-                           desc,
+                           (GskGpuImage *[2]) { bottom->image, top->image },
+                           (GskGpuSampler[2]) { bottom->sampler, top->sampler },
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   instance->opacity = opacity;
-  gsk_gpu_rect_to_float (bottom_rect, offset, instance->bottom_rect);
-  instance->bottom_id = bottom_descriptor;
-  gsk_gpu_rect_to_float (top_rect, offset, instance->top_rect);
-  instance->top_id = top_descriptor;
+  gsk_gpu_rect_to_float (bottom->bounds, offset, instance->bottom_rect);
+  gsk_gpu_rect_to_float (top->bounds, offset, instance->top_rect);
 }

gsk/gpu/gskgpublendmodeopprivate.h

@@ -8,15 +8,12 @@ G_BEGIN_DECLS
 
 void                    gsk_gpu_blend_mode_op                           (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
-                                                                         GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          GskBlendMode                    blend_mode,
-                                                                         guint32                         start_descriptor,
-                                                                         const graphene_rect_t          *start_rect,
-                                                                         guint32                         end_descriptor,
-                                                                         const graphene_rect_t          *end_rect);
+                                                                         const GskGpuShaderImage        *bottom,
+                                                                         const GskGpuShaderImage        *top);
 
 
 G_END_DECLS

gsk/gpu/gskgpublurop.c

@@ -28,7 +28,7 @@ gsk_gpu_blur_op_print_instance (GskGpuShaderOp *shader,
 
   g_string_append_printf (string, "%g,%g ", instance->blur_direction[0], instance->blur_direction[1]);
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_image (string, shader->images[0]);
 }
 
 static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
@@ -43,6 +43,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpublur",
+  gsk_gpu_blur_n_textures,
   sizeof (GskGpuBlurInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_blur_info,
@@ -53,17 +54,14 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = {
 };
 
 static void
-gsk_gpu_blur_op_full (GskGpuFrame            *frame,
-                      GskGpuShaderClip        clip,
-                      GskGpuColorStates       color_states,
-                      guint32                 variation,
-                      GskGpuDescriptors      *desc,
-                      guint32                 descriptor,
-                      const graphene_rect_t  *rect,
-                      const graphene_point_t *offset,
-                      const graphene_rect_t  *tex_rect,
-                      const graphene_vec2_t  *blur_direction,
-                      float                   blur_color[4])
+gsk_gpu_blur_op_full (GskGpuFrame             *frame,
+                      GskGpuShaderClip         clip,
+                      GskGpuColorStates        color_states,
+                      guint32                  variation,
+                      const graphene_point_t  *offset,
+                      const GskGpuShaderImage *image,
+                      const graphene_vec2_t   *blur_direction,
+                      float                    blur_color[4])
 {
   GskGpuBlurInstance *instance;
 
@@ -72,61 +70,49 @@ gsk_gpu_blur_op_full (GskGpuFrame            *frame,
                            color_states,
                            variation,
                            clip,
-                           desc,
+                           (GskGpuImage *[1]) { image->image },
+                           (GskGpuSampler[1]) { image->sampler },
                            &instance);
 
-  gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
+  gsk_gpu_rect_to_float (image->coverage, offset, instance->rect);
+  gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect);
   graphene_vec2_to_float (blur_direction, instance->blur_direction);
   gsk_gpu_color_to_float (blur_color, instance->blur_color);
-  instance->tex_id = descriptor;
 }
 
 void
-gsk_gpu_blur_op (GskGpuFrame            *frame,
-                 GskGpuShaderClip        clip,
-                 GskGpuColorStates       color_states,
-                 GskGpuDescriptors      *desc,
-                 guint32                 descriptor,
-                 const graphene_rect_t  *rect,
-                 const graphene_point_t *offset,
-                 const graphene_rect_t  *tex_rect,
-                 const graphene_vec2_t  *blur_direction)
+gsk_gpu_blur_op (GskGpuFrame             *frame,
+                 GskGpuShaderClip         clip,
+                 GskGpuColorStates        color_states,
+                 const graphene_point_t  *offset,
+                 const GskGpuShaderImage *image,
+                 const graphene_vec2_t   *blur_direction)
 {
   gsk_gpu_blur_op_full (frame,
                         clip,
                         color_states,
                         0,
-                        desc,
-                        descriptor,
-                        rect,
                         offset,
-                        tex_rect,
+                        image,
                         blur_direction,
                         (float[4]) { 1, 1, 1, 1 });
 }
 
 void
-gsk_gpu_blur_shadow_op (GskGpuFrame            *frame,
-                        GskGpuShaderClip        clip,
-                        GskGpuColorStates       color_states,
-                        GskGpuDescriptors      *desc,
-                        guint32                 descriptor,
-                        const graphene_rect_t  *rect,
-                        const graphene_point_t *offset,
-                        const graphene_rect_t  *tex_rect,
-                        const graphene_vec2_t  *blur_direction,
-                        float                   shadow_color[4])
+gsk_gpu_blur_shadow_op (GskGpuFrame             *frame,
+                        GskGpuShaderClip         clip,
+                        GskGpuColorStates        color_states,
+                        const graphene_point_t  *offset,
+                        const GskGpuShaderImage *image,
+                        const graphene_vec2_t   *blur_direction,
+                        float                    shadow_color[4])
 {
   gsk_gpu_blur_op_full (frame,
                         clip,
                         color_states,
                         VARIATION_COLORIZE,
-                        desc,
-                        descriptor,
-                        rect,
                         offset,
-                        tex_rect,
+                        image,
                         blur_direction,
                         shadow_color);
 }

gsk/gpu/gskgpubluropprivate.h

@@ -9,21 +9,15 @@ G_BEGIN_DECLS
 void                    gsk_gpu_blur_op                                 (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect,
+                                                                         const GskGpuShaderImage        *image,
                                                                          const graphene_vec2_t          *blur_direction);
 
 void                    gsk_gpu_blur_shadow_op                          (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect,
+                                                                         const GskGpuShaderImage        *image,
                                                                          const graphene_vec2_t          *blur_direction,
                                                                          float                           shadow_color[4]);
 

gsk/gpu/gskgpuborderop.c

@@ -84,6 +84,7 @@ static const GskGpuShaderOpClass GSK_GPU_BORDER_OP_CLASS = {
     gsk_gpu_border_op_gl_command
   },
   "gskgpuborder",
+  gsk_gpu_border_n_textures,
   sizeof (GskGpuBorderInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_border_info,
@@ -112,6 +113,7 @@ gsk_gpu_border_op (GskGpuFrame            *frame,
                            0,
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_rounded_rect_to_float (outline, offset, instance->outline);

gsk/gpu/gskgpuboxshadowop.c

@@ -63,6 +63,7 @@ static const GskGpuShaderOpClass GSK_GPU_BOX_SHADOW_OP_CLASS = {
     gsk_gpu_box_shadow_op_gl_command
   },
   "gskgpuboxshadow",
+  gsk_gpu_boxshadow_n_textures,
   sizeof (GskGpuBoxshadowInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_boxshadow_info,
@@ -96,6 +97,7 @@ gsk_gpu_box_shadow_op (GskGpuFrame            *frame,
                            inset ? VARIATION_INSET : 0,
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_gpu_rect_to_float (bounds, offset, instance->bounds);

gsk/gpu/gskgpucache.c

@@ -27,9 +27,6 @@
 G_STATIC_ASSERT (MAX_ATLAS_ITEM_SIZE < ATLAS_SIZE);
 G_STATIC_ASSERT (MIN_ALIVE_PIXELS < ATLAS_SIZE * ATLAS_SIZE);
 
-typedef struct _GskGpuCached GskGpuCached;
-typedef struct _GskGpuCachedClass GskGpuCachedClass;
-typedef struct _GskGpuCachedAtlas GskGpuCachedAtlas;
 typedef struct _GskGpuCachedGlyph GskGpuCachedGlyph;
 typedef struct _GskGpuCachedTexture GskGpuCachedTexture;
 typedef struct _GskGpuCachedTile GskGpuCachedTile;
@@ -58,32 +55,6 @@ G_DEFINE_TYPE (GskGpuCache, gsk_gpu_cache, G_TYPE_OBJECT)
 
 /* {{{ Cached base class */
 
-struct _GskGpuCachedClass
-{
-  gsize size;
-  const char *name;
-
-  void                  (* free)                        (GskGpuCache            *cache,
-                                                         GskGpuCached           *cached);
-  gboolean              (* should_collect)              (GskGpuCache            *cache,
-                                                         GskGpuCached           *cached,
-                                                         gint64                  cache_timeout,
-                                                         gint64                  timestamp);
-};
-
-struct _GskGpuCached
-{
-  const GskGpuCachedClass *class;
-
-  GskGpuCachedAtlas *atlas;
-  GskGpuCached *next;
-  GskGpuCached *prev;
-
-  gint64 timestamp;
-  gboolean stale;
-  guint pixels;   /* For glyphs and textures, pixels. For atlases, alive pixels */
-};
-
 static inline void
 mark_as_stale (GskGpuCached *cached,
                gboolean      stale)
@@ -130,9 +101,9 @@ gsk_gpu_cached_should_collect (GskGpuCache  *cache,
 }
 
 static gpointer
-gsk_gpu_cached_new (GskGpuCache             *cache,
-                    const GskGpuCachedClass *class,
-                    GskGpuCachedAtlas       *atlas)
+gsk_gpu_cached_new_from_atlas (GskGpuCache             *cache,
+                               const GskGpuCachedClass *class,
+                               GskGpuCachedAtlas       *atlas)
 {
   GskGpuCached *cached;
 
@@ -151,6 +122,13 @@ gsk_gpu_cached_new (GskGpuCache             *cache,
   return cached;
 }
 
+gpointer
+gsk_gpu_cached_new (GskGpuCache             *cache,
+                    const GskGpuCachedClass *class)
+{
+  return gsk_gpu_cached_new_from_atlas (cache, class, NULL);
+}
+
 static void
 gsk_gpu_cached_use (GskGpuCache  *self,
                     GskGpuCached *cached)
@@ -240,7 +218,7 @@ gsk_gpu_cached_atlas_new (GskGpuCache *cache)
 {
   GskGpuCachedAtlas *self;
 
-  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_ATLAS_CLASS, NULL);
+  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_ATLAS_CLASS);
   self->image = gsk_gpu_device_create_atlas_image (cache->device, ATLAS_SIZE, ATLAS_SIZE);
   self->remaining_pixels = gsk_gpu_image_get_width (self->image) * gsk_gpu_image_get_height (self->image);
 
@@ -525,7 +503,7 @@ gsk_gpu_cached_texture_new (GskGpuCache   *cache,
         }
     }
 
-  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TEXTURE_CLASS, NULL);
+  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TEXTURE_CLASS);
   self->texture = texture;
   self->image = g_object_ref (image);
   self->color_state = color_state;
@@ -665,7 +643,7 @@ gsk_gpu_cached_tile_new (GskGpuCache   *cache,
 {
   GskGpuCachedTile *self;
 
-  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TILE_CLASS, NULL);
+  self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TILE_CLASS);
   self->texture = texture;
   self->tile_id = tile_id;
   self->image = g_object_ref (image);
@@ -807,6 +785,12 @@ static const GskGpuCachedClass GSK_GPU_CACHED_GLYPH_CLASS =
 /* }}} */
 /* {{{ GskGpuCache */
 
+GskGpuDevice *
+gsk_gpu_cache_get_device (GskGpuCache *self)
+{
+  return self->device;
+}
+
 /*
  * gsk_gpu_cache_set_time:
  * @self: a `GskGpuCache`
@@ -1092,7 +1076,7 @@ gsk_gpu_cache_lookup_glyph_image (GskGpuCache            *self,
       g_object_ref (image);
       rect.origin.x = atlas_x + padding;
       rect.origin.y = atlas_y + padding;
-      cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS, self->current_atlas);
+      cache = gsk_gpu_cached_new_from_atlas (self, &GSK_GPU_CACHED_GLYPH_CLASS, self->current_atlas);
     }
   else
     {
@@ -1100,7 +1084,7 @@ gsk_gpu_cache_lookup_glyph_image (GskGpuCache            *self,
       rect.origin.x = 0;
       rect.origin.y = 0;
       padding = 0;
-      cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS, NULL);
+      cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS);
     }
 
   cache->font = g_object_ref (font);

gsk/gpu/gskgpucacheprivate.h

@@ -6,6 +6,36 @@
 
 G_BEGIN_DECLS
 
+typedef struct _GskGpuCached GskGpuCached;
+typedef struct _GskGpuCachedClass GskGpuCachedClass;
+typedef struct _GskGpuCachedAtlas GskGpuCachedAtlas;
+
+struct _GskGpuCachedClass
+{
+  gsize size;
+  const char *name;
+
+  void                  (* free)                        (GskGpuCache            *cache,
+                                                         GskGpuCached           *cached);
+  gboolean              (* should_collect)              (GskGpuCache            *cache,
+                                                         GskGpuCached           *cached,
+                                                         gint64                  cache_timeout,
+                                                         gint64                  timestamp);
+};
+
+struct _GskGpuCached
+{
+  const GskGpuCachedClass *class;
+
+  GskGpuCachedAtlas *atlas;
+  GskGpuCached *next;
+  GskGpuCached *prev;
+
+  gint64 timestamp;
+  gboolean stale;
+  guint pixels;   /* For glyphs and textures, pixels. For atlases, alive pixels */
+};
+
 #define GSK_TYPE_GPU_CACHE         (gsk_gpu_cache_get_type ())
 #define GSK_GPU_CACHE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_GPU_CACHE, GskGpuCache))
 #define GSK_GPU_CACHE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_GPU_CACHE, GskGpuCacheClass))
@@ -24,8 +54,13 @@ GType                   gsk_gpu_cache_get_type                          (void) G
 
 GskGpuCache *           gsk_gpu_cache_new                               (GskGpuDevice           *device);
 
+gpointer                gsk_gpu_cached_new                              (GskGpuCache            *cache,
+                                                                         const GskGpuCachedClass *class);
+
+GskGpuDevice *          gsk_gpu_cache_get_device                        (GskGpuCache            *self);
 void                    gsk_gpu_cache_set_time                          (GskGpuCache            *self,
                                                                          gint64                  timestamp);
+
 gboolean                gsk_gpu_cache_gc                                (GskGpuCache            *self,
                                                                          gint64                  cache_timeout,
                                                                          gint64                  timestamp);

gsk/gpu/gskgpucolorizeop.c

@@ -23,7 +23,7 @@ gsk_gpu_colorize_op_print_instance (GskGpuShaderOp *shader,
   GskGpuColorizeInstance *instance = (GskGpuColorizeInstance *) instance_;
 
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_image (string, shader->images[0]);
   gsk_gpu_print_rgba (string, instance->color);
 }
 
@@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpucolorize",
+  gsk_gpu_colorize_n_textures,
   sizeof (GskGpuColorizeInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_colorize_info,
@@ -49,15 +50,12 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = {
 };
 
 void
-gsk_gpu_colorize_op (GskGpuFrame            *frame,
-                     GskGpuShaderClip        clip,
-                     GskGpuColorStates       color_states,
-                     GskGpuDescriptors      *descriptors,
-                     guint32                 descriptor,
-                     const graphene_rect_t  *rect,
-                     const graphene_point_t *offset,
-                     const graphene_rect_t  *tex_rect,
-                     const float             color[4])
+gsk_gpu_colorize_op (GskGpuFrame             *frame,
+                     GskGpuShaderClip         clip,
+                     GskGpuColorStates        color_states,
+                     const graphene_point_t  *offset,
+                     const GskGpuShaderImage *image,
+                     const float              color[4])
 {
   GskGpuColorizeInstance *instance;
 
@@ -66,11 +64,11 @@ gsk_gpu_colorize_op (GskGpuFrame            *frame,
                            color_states,
                            0,
                            clip,
-                           descriptors,
+                           (GskGpuImage *[1]) { image->image },
+                           (GskGpuSampler[1]) { image->sampler },
                            &instance);
 
-  gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  instance->tex_id = descriptor;
+  gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect);
+  gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect);
   gsk_gpu_color_to_float (color, instance->color);
 }

gsk/gpu/gskgpucolorizeopprivate.h

@@ -9,11 +9,8 @@ G_BEGIN_DECLS
 void                    gsk_gpu_colorize_op                             (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect,
+                                                                         const GskGpuShaderImage        *image,
                                                                          const float                     color[4]);
 
 

gsk/gpu/gskgpucolormatrixop.c

@@ -23,7 +23,7 @@ gsk_gpu_color_matrix_op_print_instance (GskGpuShaderOp *shader,
   GskGpuColormatrixInstance *instance = (GskGpuColormatrixInstance *) instance_;
 
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_image (string, shader->images[0]);
 }
 
 static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = {
@@ -38,6 +38,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpucolormatrix",
+  gsk_gpu_colormatrix_n_textures,
   sizeof (GskGpuColormatrixInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_colormatrix_info,
@@ -51,11 +52,8 @@ void
 gsk_gpu_color_matrix_op (GskGpuFrame             *frame,
                          GskGpuShaderClip         clip,
                          GskGpuColorStates        color_states,
-                         GskGpuDescriptors       *desc,
-                         guint32                  descriptor,
-                         const graphene_rect_t   *rect,
                          const graphene_point_t  *offset,
-                         const graphene_rect_t   *tex_rect,
+                         const GskGpuShaderImage *image,
                          const graphene_matrix_t *color_matrix,
                          const graphene_vec4_t   *color_offset)
 {
@@ -66,12 +64,12 @@ gsk_gpu_color_matrix_op (GskGpuFrame             *frame,
                            color_states,
                            0,
                            clip,
-                           desc,
+                           (GskGpuImage *[1]) { image->image },
+                           (GskGpuSampler[1]) { image->sampler },
                            &instance);
 
-  gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  instance->tex_id = descriptor;
+  gsk_gpu_rect_to_float (image->coverage, offset, instance->rect);
+  gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect);
   graphene_matrix_to_float (color_matrix, instance->color_matrix);
   graphene_vec4_to_float (color_offset, instance->color_offset);
 }

gsk/gpu/gskgpucolormatrixopprivate.h

@@ -9,11 +9,8 @@ G_BEGIN_DECLS
 void                    gsk_gpu_color_matrix_op                         (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect,
+                                                                         const GskGpuShaderImage        *image,
                                                                          const graphene_matrix_t        *color_matrix,
                                                                          const graphene_vec4_t          *color_offset);
 

gsk/gpu/gskgpucolorop.c

@@ -40,6 +40,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpucolor",
+  gsk_gpu_color_n_textures,
   sizeof (GskGpuColorInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_color_info,
@@ -65,6 +66,7 @@ gsk_gpu_color_op (GskGpuFrame            *frame,
                            0,
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);

gsk/gpu/gskgpuconicgradientop.c

@@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_CONIC_GRADIENT_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpuconicgradient",
+  gsk_gpu_conicgradient_n_textures,
   sizeof (GskGpuConicgradientInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_conicgradient_info,
@@ -72,6 +73,7 @@ gsk_gpu_conic_gradient_op (GskGpuFrame            *frame,
                            (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0),
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);

gsk/gpu/gskgpuconvertop.c

@@ -27,7 +27,7 @@ gsk_gpu_convert_op_print_instance (GskGpuShaderOp *shader,
   GskGpuConvertInstance *instance = (GskGpuConvertInstance *) instance_;
 
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_image (string, shader->images[0]);
   if (shader->variation & VARIATION_STRAIGHT_ALPHA)
     gsk_gpu_print_string (string, "straight");
 }
@@ -44,6 +44,7 @@ static const GskGpuShaderOpClass GSK_GPU_CONVERT_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpuconvert",
+  gsk_gpu_convert_n_textures,
   sizeof (GskGpuConvertInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_convert_info,
@@ -54,16 +55,13 @@ static const GskGpuShaderOpClass GSK_GPU_CONVERT_OP_CLASS = {
 };
 
 void
-gsk_gpu_convert_op (GskGpuFrame            *frame,
-                    GskGpuShaderClip        clip,
-                    GskGpuColorStates       color_states,
-                    float                   opacity,
-                    GskGpuDescriptors      *desc,
-                    guint32                 descriptor,
-                    gboolean                straight_alpha,
-                    const graphene_rect_t  *rect,
-                    const graphene_point_t *offset,
-                    const graphene_rect_t  *tex_rect)
+gsk_gpu_convert_op (GskGpuFrame             *frame,
+                    GskGpuShaderClip         clip,
+                    GskGpuColorStates        color_states,
+                    float                    opacity,
+                    gboolean                 straight_alpha,
+                    const graphene_point_t  *offset,
+                    const GskGpuShaderImage *image)
 {
   GskGpuConvertInstance *instance;
 
@@ -73,12 +71,12 @@ gsk_gpu_convert_op (GskGpuFrame            *frame,
                            (opacity < 1.0 ? VARIATION_OPACITY : 0) |
                            (straight_alpha ? VARIATION_STRAIGHT_ALPHA : 0),
                            clip,
-                           desc,
+                           (GskGpuImage *[1]) { image->image },
+                           (GskGpuSampler[1]) { image->sampler },
                            &instance);
 
-  gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  instance->tex_id = descriptor;
+  gsk_gpu_rect_to_float (image->coverage, offset, instance->rect);
+  gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect);
   instance->opacity = opacity;
 }
 

gsk/gpu/gskgpuconvertopprivate.h

@@ -10,12 +10,9 @@ void                    gsk_gpu_convert_op                              (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
                                                                          float                           opacity,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
                                                                          gboolean                        straight_alpha,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect);
+                                                                         const GskGpuShaderImage        *image);
 
 
 G_END_DECLS

gsk/gpu/gskgpucrossfadeop.c

@@ -23,8 +23,8 @@ gsk_gpu_cross_fade_op_print_instance (GskGpuShaderOp *shader,
   GskGpuCrossfadeInstance *instance = (GskGpuCrossfadeInstance *) instance_;
 
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->start_id);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->end_id);
+  gsk_gpu_print_image (string, shader->images[0]);
+  gsk_gpu_print_image (string, shader->images[1]);
   g_string_append_printf (string, "%g%%", 100 * instance->opacity_progress[1]);
 }
 
@@ -40,6 +40,7 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpucrossfade",
+  gsk_gpu_crossfade_n_textures,
   sizeof (GskGpuCrossfadeInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_crossfade_info,
@@ -50,18 +51,15 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = {
 };
 
 void
-gsk_gpu_cross_fade_op (GskGpuFrame            *frame,
-                       GskGpuShaderClip        clip,
-                       GskGpuColorStates       color_states,
-                       GskGpuDescriptors      *desc,
-                       const graphene_rect_t  *rect,
-                       const graphene_point_t *offset,
-                       float                   opacity,
-                       float                   progress,
-                       guint32                 start_descriptor,
-                       const graphene_rect_t  *start_rect,
-                       guint32                 end_descriptor,
-                       const graphene_rect_t  *end_rect)
+gsk_gpu_cross_fade_op (GskGpuFrame             *frame,
+                       GskGpuShaderClip         clip,
+                       GskGpuColorStates        color_states,
+                       const graphene_rect_t   *rect,
+                       const graphene_point_t  *offset,
+                       float                    opacity,
+                       float                    progress,
+                       const GskGpuShaderImage *start,
+                       const GskGpuShaderImage *end)
 {
   GskGpuCrossfadeInstance *instance;
 
@@ -70,14 +68,13 @@ gsk_gpu_cross_fade_op (GskGpuFrame            *frame,
                            color_states,
                            0,
                            clip,
-                           desc,
+                           (GskGpuImage *[2]) { start->image, end->image },
+                           (GskGpuSampler[2]) { start->sampler, end->sampler },
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   instance->opacity_progress[0] = opacity;
   instance->opacity_progress[1] = progress;
-  gsk_gpu_rect_to_float (start_rect, offset, instance->start_rect);
-  instance->start_id = start_descriptor;
-  gsk_gpu_rect_to_float (end_rect, offset, instance->end_rect);
-  instance->end_id = end_descriptor;
+  gsk_gpu_rect_to_float (start->bounds, offset, instance->start_rect);
+  gsk_gpu_rect_to_float (end->bounds, offset, instance->end_rect);
 }

gsk/gpu/gskgpucrossfadeopprivate.h

@@ -9,15 +9,12 @@ G_BEGIN_DECLS
 void                    gsk_gpu_cross_fade_op                           (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuColorStates               color_states,
-                                                                         GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          float                           progress,
-                                                                         guint32                         start_descriptor,
-                                                                         const graphene_rect_t          *start_rect,
-                                                                         guint32                         end_descriptor,
-                                                                         const graphene_rect_t          *end_rect);
+                                                                         const GskGpuShaderImage        *start,
+                                                                         const GskGpuShaderImage        *end);
 
 
 G_END_DECLS

gsk/gpu/gskgpudescriptors.c

@@ -1,240 +0,0 @@
-#include "config.h"
-
-#include "gskgpudescriptorsprivate.h"
-
-typedef struct _GskGpuImageEntry GskGpuImageEntry;
-typedef struct _GskGpuBufferEntry GskGpuBufferEntry;
-
-struct _GskGpuImageEntry
-{
-  GskGpuImage *image;
-  GskGpuSampler sampler;
-  guint32 descriptor;
-};
-
-struct _GskGpuBufferEntry
-{
-  GskGpuBuffer *buffer;
-  guint32 descriptor;
-};
-
-static void
-gsk_gpu_image_entry_clear (gpointer data)
-{
-  GskGpuImageEntry *entry = data;
-
-  g_object_unref (entry->image);
-}
-
-static void
-gsk_gpu_buffer_entry_clear (gpointer data)
-{
-  GskGpuBufferEntry *entry = data;
-
-  g_object_unref (entry->buffer);
-}
-
-#define GDK_ARRAY_NAME gsk_gpu_image_entries
-#define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
-#define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
-#define GDK_ARRAY_FREE_FUNC gsk_gpu_image_entry_clear
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 16
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-#define GDK_ARRAY_NAME gsk_gpu_buffer_entries
-#define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
-#define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
-#define GDK_ARRAY_FREE_FUNC gsk_gpu_buffer_entry_clear
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 4
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate;
-
-struct _GskGpuDescriptorsPrivate
-{
-  GskGpuImageEntries images;
-  GskGpuBufferEntries buffers;
-};
-
-G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDescriptors, gsk_gpu_descriptors, G_TYPE_OBJECT)
-
-static void
-gsk_gpu_descriptors_finalize (GObject *object)
-{
-  GskGpuDescriptors *self = GSK_GPU_DESCRIPTORS (object);
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  gsk_gpu_image_entries_clear (&priv->images);
-  gsk_gpu_buffer_entries_clear (&priv->buffers);
-
-  G_OBJECT_CLASS (gsk_gpu_descriptors_parent_class)->finalize (object);
-}
-
-static void
-gsk_gpu_descriptors_class_init (GskGpuDescriptorsClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_gpu_descriptors_finalize;
-}
-
-static void
-gsk_gpu_descriptors_init (GskGpuDescriptors *self)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  gsk_gpu_image_entries_init (&priv->images);
-  gsk_gpu_buffer_entries_init (&priv->buffers);
-}
-
-gsize
-gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  return gsk_gpu_image_entries_get_size (&priv->images);
-}
-
-gsize
-gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  return gsk_gpu_buffer_entries_get_size (&priv->buffers);
-}
-void
-gsk_gpu_descriptors_set_size (GskGpuDescriptors *self,
-                              gsize              n_images,
-                              gsize              n_buffers)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-
-  g_assert (n_images <= gsk_gpu_image_entries_get_size (&priv->images));
-  gsk_gpu_image_entries_set_size (&priv->images, n_images);
-
-  g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&priv->buffers));
-  gsk_gpu_buffer_entries_set_size (&priv->buffers, n_buffers);
-}
-
-GskGpuImage *
-gsk_gpu_descriptors_get_image (GskGpuDescriptors *self,
-                               gsize              id)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
-
-  return entry->image;
-}
-
-GskGpuSampler
-gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self,
-                                 gsize              id)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
-
-  return entry->sampler;
-}
-
-gsize
-gsk_gpu_descriptors_find_image (GskGpuDescriptors *self,
-                                guint32            descriptor)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  gsize i;
-
-  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
-    {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
-
-      if (entry->descriptor == descriptor)
-        return i;
-    }
-
-  g_return_val_if_reached ((gsize) -1);
-}
-
-GskGpuBuffer *
-gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self,
-                               gsize              id)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, id);
-
-  return entry->buffer;
-}
-
-gboolean
-gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
-                               GskGpuImage       *image,
-                               GskGpuSampler      sampler,
-                               guint32           *out_descriptor)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  gsize i;
-  guint32 descriptor;
-
-  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
-    {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
-
-      if (entry->image == image && entry->sampler == sampler)
-        {
-          *out_descriptor = entry->descriptor;
-          return TRUE;
-        }
-    }
-
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_image (self, image, sampler, &descriptor))
-    return FALSE;
-
-  gsk_gpu_image_entries_append (&priv->images,
-                                &(GskGpuImageEntry) {
-                                     .image = g_object_ref (image),
-                                     .sampler = sampler,
-                                     .descriptor = descriptor
-                                });
-
-  *out_descriptor = descriptor;
-
-  return TRUE;
-}
-
-gboolean
-gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
-                                GskGpuBuffer      *buffer,
-                                guint32           *out_descriptor)
-{
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
-  gsize i;
-  guint32 descriptor;
-
-  for (i = 0; i < gsk_gpu_buffer_entries_get_size (&priv->buffers); i++)
-    {
-      const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, i);
-
-      if (entry->buffer == buffer)
-        {
-          *out_descriptor = entry->descriptor;
-          return TRUE;
-        }
-    }
-
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor))
-    return FALSE;
-
-  gsk_gpu_buffer_entries_append (&priv->buffers,
-                                 &(GskGpuBufferEntry) {
-                                      .buffer = g_object_ref (buffer),
-                                      .descriptor = descriptor
-                                 });
-
-  *out_descriptor = descriptor;
-
-  return TRUE;
-}
-

gsk/gpu/gskgpudescriptorsprivate.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "gskgputypesprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_GPU_DESCRIPTORS         (gsk_gpu_descriptors_get_type ())
-#define GSK_GPU_DESCRIPTORS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptors))
-#define GSK_GPU_DESCRIPTORS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass))
-#define GSK_IS_GPU_DESCRIPTORS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_GPU_DESCRIPTORS))
-#define GSK_IS_GPU_DESCRIPTORS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_GPU_DESCRIPTORS))
-#define GSK_GPU_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass))
-
-typedef struct _GskGpuDescriptorsClass GskGpuDescriptorsClass;
-
-struct _GskGpuDescriptors
-{
-  GObject parent_instance;
-};
-
-struct _GskGpuDescriptorsClass
-{
-  GObjectClass parent_class;
-
-  gboolean              (* add_image)                                   (GskGpuDescriptors      *self,
-                                                                         GskGpuImage            *image,
-                                                                         GskGpuSampler           sampler,
-                                                                         guint32                *out_id);
-  gboolean              (* add_buffer)                                  (GskGpuDescriptors      *self,
-                                                                         GskGpuBuffer           *buffer,
-                                                                         guint32                *out_id);
-};
-
-GType                   gsk_gpu_descriptors_get_type                    (void) G_GNUC_CONST;
-
-gsize                   gsk_gpu_descriptors_get_n_images                (GskGpuDescriptors      *self);
-gsize                   gsk_gpu_descriptors_get_n_buffers               (GskGpuDescriptors      *self);
-void                    gsk_gpu_descriptors_set_size                    (GskGpuDescriptors      *self,
-                                                                         gsize                   n_images,
-                                                                         gsize                   n_buffers);
-GskGpuImage *           gsk_gpu_descriptors_get_image                   (GskGpuDescriptors      *self,
-                                                                         gsize                   id);
-GskGpuSampler           gsk_gpu_descriptors_get_sampler                 (GskGpuDescriptors      *self,
-                                                                         gsize                   id);
-gsize                   gsk_gpu_descriptors_find_image                  (GskGpuDescriptors      *self,
-                                                                         guint32                 descriptor);
-GskGpuBuffer *          gsk_gpu_descriptors_get_buffer                  (GskGpuDescriptors      *self,
-                                                                         gsize                   id);
-
-gboolean                gsk_gpu_descriptors_add_image                   (GskGpuDescriptors      *self,
-                                                                         GskGpuImage            *image,
-                                                                         GskGpuSampler           sampler,
-                                                                         guint32                *out_descriptor);
-gboolean                gsk_gpu_descriptors_add_buffer                  (GskGpuDescriptors      *self,
-                                                                         GskGpuBuffer           *buffer,
-                                                                         guint32                *out_descriptor);
-
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref)
-
-G_END_DECLS

gsk/gpu/gskgpuframe.c

@@ -37,6 +37,7 @@ struct _GskGpuFramePrivate
   GskGpuRenderer *renderer;
   GskGpuDevice *device;
   GskGpuOptimizations optimizations;
+  gsize texture_vertex_size;
   gint64 timestamp;
 
   GskGpuOps ops;
@@ -175,6 +176,28 @@ gsk_gpu_frame_setup (GskGpuFrame         *self,
   GSK_GPU_FRAME_GET_CLASS (self)->setup (self);
 }
 
+/*
+ * gsk_gpu_frame_set_texture_vertex_size:
+ * @self: the frame
+ * @texture_vertex_size: bytes to reserve in the vertex data per
+ *   texture rendered
+ *
+ * Some renderers want to attach vertex data for textures, usually
+ * for supporting bindless textures. This is the number of bytes
+ * reserved per texture.
+ *
+ * GskGpuFrameClass::write_texture_vertex_data() is used to write that
+ * data.
+ **/
+void
+gsk_gpu_frame_set_texture_vertex_size (GskGpuFrame *self,
+                                       gsize        texture_vertex_size)
+{
+  GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self);
+
+  priv->texture_vertex_size = texture_vertex_size;
+}
+
 void
 gsk_gpu_frame_begin (GskGpuFrame          *self,
                      GdkDrawContext       *context,
@@ -450,12 +473,6 @@ gsk_gpu_frame_upload_texture (GskGpuFrame  *self,
   return image;
 }
 
-GskGpuDescriptors *
-gsk_gpu_frame_create_descriptors (GskGpuFrame *self)
-{
-  return GSK_GPU_FRAME_GET_CLASS (self)->create_descriptors (self);
-}
-
 static GskGpuBuffer *
 gsk_gpu_frame_create_vertex_buffer (GskGpuFrame *self,
                                     gsize        size)
@@ -476,6 +493,15 @@ round_up (gsize number, gsize divisor)
   return (number + divisor - 1) / divisor * divisor;
 }
 
+gsize
+gsk_gpu_frame_get_texture_vertex_size (GskGpuFrame *self,
+                                       gsize        n_textures)
+{
+  GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self);
+
+  return priv->texture_vertex_size * n_textures;
+}
+
 gsize
 gsk_gpu_frame_reserve_vertex_data (GskGpuFrame *self,
                                    gsize        size)
@@ -535,6 +561,16 @@ gsk_gpu_frame_ensure_storage_buffer (GskGpuFrame *self)
   priv->storage_buffer_data = gsk_gpu_buffer_map (priv->storage_buffer);
 }
 
+void
+gsk_gpu_frame_write_texture_vertex_data (GskGpuFrame    *self,
+                                         guchar         *data,
+                                         GskGpuImage   **images,
+                                         GskGpuSampler  *samplers,
+                                         gsize           n_images)
+{
+  GSK_GPU_FRAME_GET_CLASS (self)->write_texture_vertex_data (self, data, images, samplers, n_images);
+}
+
 GskGpuBuffer *
 gsk_gpu_frame_write_storage_buffer (GskGpuFrame  *self,
                                     const guchar *data,

gsk/gpu/gskgpuframeprivate.h

@@ -36,11 +36,15 @@ struct _GskGpuFrameClass
   GskGpuImage *         (* upload_texture)                              (GskGpuFrame            *self,
                                                                          gboolean                with_mipmap,
                                                                          GdkTexture             *texture);
-  GskGpuDescriptors *   (* create_descriptors)                          (GskGpuFrame            *self);
   GskGpuBuffer *        (* create_vertex_buffer)                        (GskGpuFrame            *self,
                                                                          gsize                   size);
   GskGpuBuffer *        (* create_storage_buffer)                       (GskGpuFrame            *self,
                                                                          gsize                   size);
+  void                  (* write_texture_vertex_data)                   (GskGpuFrame            *self,
+                                                                         guchar                 *data,
+                                                                         GskGpuImage           **images,
+                                                                         GskGpuSampler          *samplers,
+                                                                         gsize                   n_images);
   void                  (* submit)                                      (GskGpuFrame            *self,
                                                                          GskRenderPassType       pass_type,
                                                                          GskGpuBuffer           *vertex_buffer,
@@ -54,6 +58,10 @@ void                    gsk_gpu_frame_setup                             (GskGpuF
                                                                          GskGpuRenderer         *renderer,
                                                                          GskGpuDevice           *device,
                                                                          GskGpuOptimizations     optimizations);
+void                    gsk_gpu_frame_set_texture_vertex_size           (GskGpuFrame            *self,
+                                                                         gsize                   texture_vertex_size);
+gsize                   gsk_gpu_frame_get_texture_vertex_size           (GskGpuFrame            *self,
+                                                                         gsize                   n_textures);
 
 void                    gsk_gpu_frame_begin                             (GskGpuFrame            *self,
                                                                          GdkDrawContext         *context,
@@ -73,11 +81,15 @@ gpointer                gsk_gpu_frame_alloc_op                          (GskGpuF
 GskGpuImage *           gsk_gpu_frame_upload_texture                    (GskGpuFrame            *self,
                                                                          gboolean                with_mipmap,
                                                                          GdkTexture             *texture);
-GskGpuDescriptors *     gsk_gpu_frame_create_descriptors                (GskGpuFrame            *self);
 gsize                   gsk_gpu_frame_reserve_vertex_data               (GskGpuFrame            *self,
                                                                          gsize                   size);
 guchar *                gsk_gpu_frame_get_vertex_data                   (GskGpuFrame            *self,
                                                                          gsize                   offset);
+void                    gsk_gpu_frame_write_texture_vertex_data         (GskGpuFrame            *self,
+                                                                         guchar                 *data,
+                                                                         GskGpuImage           **images,
+                                                                         GskGpuSampler          *samplers,
+                                                                         gsize                   n_images);
 GskGpuBuffer *          gsk_gpu_frame_write_storage_buffer              (GskGpuFrame            *self,
                                                                          const guchar           *data,
                                                                          gsize                   size,

gsk/gpu/gskgpuglobalsop.c

@@ -9,7 +9,6 @@
 #ifdef GDK_RENDERING_VULKAN
 #include "gskvulkandeviceprivate.h"
 #include "gskvulkanframeprivate.h"
-#include "gskvulkandescriptorsprivate.h"
 #endif
 
 typedef struct _GskGpuGlobalsOp GskGpuGlobalsOp;
@@ -51,8 +50,7 @@ gsk_gpu_globals_op_vk_command (GskGpuOp              *op,
   GskGpuGlobalsOp *self = (GskGpuGlobalsOp *) op;
 
   vkCmdPushConstants (state->vk_command_buffer,
-                      gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)),
-                                                                gsk_vulkan_descriptors_get_pipeline_layout (state->desc)),
+                      gsk_vulkan_device_get_default_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame))),
                       VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
                       0,
                       sizeof (self->instance),

gsk/gpu/gskgpulineargradientop.c

@@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpulineargradient",
+  gsk_gpu_lineargradient_n_textures,
   sizeof (GskGpuLineargradientInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_lineargradient_info,
@@ -77,6 +78,7 @@ gsk_gpu_linear_gradient_op (GskGpuFrame            *frame,
                            (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0),
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);

gsk/gpu/gskgpumaskop.c

@@ -25,8 +25,8 @@ gsk_gpu_mask_op_print_instance (GskGpuShaderOp *shader,
 
   gsk_gpu_print_enum (string, GSK_TYPE_MASK_MODE, shader->variation);
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->source_id);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->mask_id);
+  gsk_gpu_print_image (string, shader->images[0]);
+  gsk_gpu_print_image (string, shader->images[1]);
 }
 
 static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
@@ -41,6 +41,7 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpumask",
+  gsk_gpu_mask_n_textures,
   sizeof (GskGpuMaskInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_mask_info,
@@ -51,17 +52,14 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = {
 };
 
 void
-gsk_gpu_mask_op (GskGpuFrame            *frame,
-                 GskGpuShaderClip        clip,
-                 GskGpuDescriptors      *desc,
-                 const graphene_rect_t  *rect,
-                 const graphene_point_t *offset,
-                 float                   opacity,
-                 GskMaskMode             mask_mode,
-                 guint32                 source_descriptor,
-                 const graphene_rect_t  *source_rect,
-                 guint32                 mask_descriptor,
-                 const graphene_rect_t  *mask_rect)
+gsk_gpu_mask_op (GskGpuFrame             *frame,
+                 GskGpuShaderClip         clip,
+                 const graphene_rect_t   *rect,
+                 const graphene_point_t  *offset,
+                 float                    opacity,
+                 GskMaskMode              mask_mode,
+                 const GskGpuShaderImage *source,
+                 const GskGpuShaderImage *mask)
 {
   GskGpuMaskInstance *instance;
 
@@ -70,13 +68,12 @@ gsk_gpu_mask_op (GskGpuFrame            *frame,
                            gsk_gpu_color_states_create_equal (TRUE, TRUE),
                            mask_mode,
                            clip,
-                           desc,
+                           (GskGpuImage *[2]) { source->image, mask->image },
+                           (GskGpuSampler[2]) { source->sampler, mask->sampler },
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (source_rect, offset, instance->source_rect);
-  instance->source_id = source_descriptor;
-  gsk_gpu_rect_to_float (mask_rect, offset, instance->mask_rect);
-  instance->mask_id = mask_descriptor;
+  gsk_gpu_rect_to_float (source->bounds, offset, instance->source_rect);
+  gsk_gpu_rect_to_float (mask->bounds, offset, instance->mask_rect);
   instance->opacity = opacity;
 }

gsk/gpu/gskgpumaskopprivate.h

@@ -8,15 +8,12 @@ G_BEGIN_DECLS
 
 void                    gsk_gpu_mask_op                                 (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
-                                                                         GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          GskMaskMode                     mask_mode,
-                                                                         guint32                         source_descriptor,
-                                                                         const graphene_rect_t          *source_rect,
-                                                                         guint32                         mask_descriptor,
-                                                                         const graphene_rect_t          *mask_rect);
+                                                                         const GskGpuShaderImage        *source,
+                                                                         const GskGpuShaderImage        *mask);
 
 
 G_END_DECLS

gsk/gpu/gskgpumipmapop.c

@@ -159,7 +159,7 @@ gsk_gpu_mipmap_op_gl_command (GskGpuOp          *op,
   glActiveTexture (GL_TEXTURE0);
   gsk_gl_image_bind_texture (GSK_GL_IMAGE (self->image));
   /* need to reset the images again */
-  state->desc = NULL;
+  state->current_images[0] = NULL;
 
   glGenerateMipmap (GL_TEXTURE_2D);
 

gsk/gpu/gskgpunodeprocessor.c

@@ -17,7 +17,6 @@
 #include "gskgpuconicgradientopprivate.h"
 #include "gskgpuconvertopprivate.h"
 #include "gskgpucrossfadeopprivate.h"
-#include "gskgpudescriptorsprivate.h"
 #include "gskgpudeviceprivate.h"
 #include "gskgpuframeprivate.h"
 #include "gskgpuglobalsopprivate.h"
@@ -112,7 +111,6 @@ struct _GskGpuNodeProcessor
 {
   GskGpuFrame                   *frame;
   GdkColorState                 *ccs;
-  GskGpuDescriptors             *desc;
   cairo_rectangle_int_t          scissor;
   GskGpuBlend                    blend;
   graphene_point_t               offset;
@@ -143,7 +141,6 @@ static void
 gsk_gpu_node_processor_finish (GskGpuNodeProcessor *self)
 {
   g_clear_pointer (&self->modelview, gsk_transform_unref);
-  g_clear_object (&self->desc);
 }
 
 static void
@@ -161,7 +158,6 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->frame = frame;
   self->ccs = ccs;
-  self->desc = NULL;
 
   self->scissor = *clip;
   self->blend = GSK_GPU_BLEND_OVER;
@@ -271,51 +267,6 @@ gsk_gpu_node_processor_color_states_for_rgba (GskGpuNodeProcessor *self)
                                       FALSE);
 }
 
-static guint32
-gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self,
-                                  GskGpuImage         *image,
-                                  GskGpuSampler        sampler)
-{
-  guint32 descriptor;
-
-  if (self->desc != NULL)
-    {
-      if (gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor))
-        return descriptor;
-
-      g_object_unref (self->desc);
-    }
-
-  self->desc = gsk_gpu_frame_create_descriptors (self->frame);
-
-  if (!gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor))
-    {
-      g_assert_not_reached ();
-      return 0;
-    }
-  
-  return descriptor;
-}
-
-static void
-gsk_gpu_node_processor_add_two_images (GskGpuNodeProcessor *self,
-                                       GskGpuImage         *image1,
-                                       GskGpuSampler        sampler1,
-                                       GskGpuImage         *image2,
-                                       GskGpuSampler        sampler2,
-                                       guint32             *out_descriptors)
-{
-  GskGpuDescriptors *desc;
-
-  do
-    {
-      out_descriptors[0] = gsk_gpu_node_processor_add_image (self, image1, sampler1);
-      desc = self->desc;
-      out_descriptors[1] = gsk_gpu_node_processor_add_image (self, image2, sampler2);
-    }
-  while (desc != self->desc);
-}
-
 static void
 rect_round_to_pixels (const graphene_rect_t  *src,
                       const graphene_vec2_t  *pixel_scale,
@@ -529,12 +480,10 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor   *self,
                                  const graphene_rect_t *rect,
                                  const graphene_rect_t *tex_rect)
 {
-  guint32 descriptor;
   gboolean straight_alpha;
 
   g_assert (self->pending_globals == 0);
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, sampler);
   straight_alpha = gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_STRAIGHT_ALPHA;
 
   if (straight_alpha ||
@@ -547,22 +496,26 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor   *self,
                                                                         image_color_state,
                                                                         TRUE),
                           self->opacity,
-                          self->desc,
-                          descriptor,
                           straight_alpha,
-                          rect,
                           &self->offset,
-                          tex_rect);
+                          &(GskGpuShaderImage) {
+                              image,
+                              sampler,
+                              rect,
+                              tex_rect
+                          });
     }
   else
     {
       gsk_gpu_texture_op (self->frame,
                           gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect),
-                          self->desc,
-                          descriptor,
-                          rect,
                           &self->offset,
-                          tex_rect);
+                          &(GskGpuShaderImage) {
+                              image,
+                              sampler,
+                              rect,
+                              tex_rect
+                          });
     }
 }
 
@@ -757,14 +710,12 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
                                 const graphene_point_t    *shadow_offset,
                                 float                      blur_radius,
                                 const GdkRGBA             *shadow_color,
-                                GskGpuDescriptors         *source_desc,
-                                guint32                    source_descriptor,
+                                GskGpuImage               *source_image,
                                 GdkMemoryDepth             source_depth,
                                 const graphene_rect_t     *source_rect)
 {
   GskGpuNodeProcessor other;
   GskGpuImage *intermediate;
-  guint32 intermediate_descriptor;
   graphene_vec2_t direction;
   graphene_rect_t clip_rect, intermediate_rect;
   graphene_point_t real_offset;
@@ -795,11 +746,13 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
   gsk_gpu_blur_op (other.frame,
                    gsk_gpu_clip_get_shader_clip (&other.clip, &other.offset, &intermediate_rect),
                    gsk_gpu_node_processor_color_states_self (&other),
-                   source_desc,
-                   source_descriptor,
-                   &intermediate_rect,
                    &other.offset,
-                   source_rect,
+                   &(GskGpuShaderImage) {
+                       source_image,
+                       GSK_GPU_SAMPLER_TRANSPARENT,
+                       &intermediate_rect,
+                       source_rect
+                   },
                    &direction);
 
   gsk_gpu_node_processor_finish_draw (&other, intermediate);
@@ -807,17 +760,18 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
   real_offset = GRAPHENE_POINT_INIT (self->offset.x + shadow_offset->x,
                                      self->offset.y + shadow_offset->y);
   graphene_vec2_init (&direction, 0.0f, blur_radius);
-  intermediate_descriptor = gsk_gpu_node_processor_add_image (self, intermediate, GSK_GPU_SAMPLER_TRANSPARENT);
   if (shadow_color)
     {
       gsk_gpu_blur_shadow_op (self->frame,
                               gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect),
                               gsk_gpu_node_processor_color_states_for_rgba (self),
-                              self->desc,
-                              intermediate_descriptor,
-                              rect,
                               &real_offset,
-                              &intermediate_rect,
+                              &(GskGpuShaderImage) {
+                                  intermediate,
+                                  GSK_GPU_SAMPLER_TRANSPARENT,
+                                  rect,
+                                  &intermediate_rect,
+                              },
                               &direction,
                               GSK_RGBA_TO_VEC4 (shadow_color));
     }
@@ -826,11 +780,13 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
       gsk_gpu_blur_op (self->frame,
                        gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect),
                        gsk_gpu_node_processor_color_states_self (self),
-                       self->desc,
-                       intermediate_descriptor,
-                       rect,
                        &real_offset,
-                       &intermediate_rect,
+                       &(GskGpuShaderImage) {
+                           intermediate,
+                           GSK_GPU_SAMPLER_TRANSPARENT,
+                           rect,
+                           &intermediate_rect,
+                       },
                        &direction);
     }
 
@@ -1034,7 +990,6 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel
   GskGpuNodeProcessor other;
   graphene_rect_t clip_bounds, child_rect;
   GskGpuImage *child_image, *mask_image;
-  guint32 descriptors[2];
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
     return;
@@ -1063,25 +1018,25 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel
                             (float[4]) { 1, 1, 1, 1 });
   gsk_gpu_node_processor_finish_draw (&other, mask_image);
 
-  gsk_gpu_node_processor_add_two_images (self,
-                                         child_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         mask_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         descriptors);
-
   gsk_gpu_node_processor_sync_globals (self, 0);
   gsk_gpu_mask_op (self->frame,
                    gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds),
-                   self->desc,
                    &clip_bounds,
                    &self->offset,
                    self->opacity,
                    GSK_MASK_MODE_ALPHA,
-                   descriptors[0],
-                   &child_rect,
-                   descriptors[1],
-                   &clip_bounds);
+                   &(GskGpuShaderImage) {
+                       child_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &child_rect,
+                   },
+                   &(GskGpuShaderImage) {
+                       mask_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &clip_bounds,
+                   });
 
   g_object_unref (child_image);
   g_object_unref (mask_image);
@@ -1999,7 +1954,6 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
   GdkTexture *texture;
   GdkColorState *image_cs;
   GskScalingFilter scaling_filter;
-  guint32 descriptor;
   gboolean need_mipmap, need_offscreen;
 
   texture = gsk_texture_scale_node_get_texture (node);
@@ -2051,14 +2005,15 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
                                                                node);
           g_object_unref (image);
         }
-      descriptor = gsk_gpu_node_processor_add_image (self, offscreen, GSK_GPU_SAMPLER_DEFAULT);
       gsk_gpu_texture_op (self->frame,
                           gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
-                          self->desc,
-                          descriptor,
-                          &node->bounds,
                           &self->offset,
-                          &clip_bounds);
+                          &(GskGpuShaderImage) {
+                              offscreen,
+                              GSK_GPU_SAMPLER_DEFAULT,
+                              &node->bounds,
+                              &clip_bounds
+                          });
       g_object_unref (offscreen);
       return;
     }
@@ -2078,15 +2033,15 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
   if (need_mipmap && !(gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_MIPMAP))
     gsk_gpu_mipmap_op (self->frame, image);
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, gsk_gpu_sampler_for_scaling_filter (scaling_filter));
-
   gsk_gpu_texture_op (self->frame,
                       gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
-                      self->desc,
-                      descriptor,
-                      &node->bounds,
                       &self->offset,
-                      &node->bounds);
+                      &(GskGpuShaderImage) {
+                          image,
+                          gsk_gpu_sampler_for_scaling_filter (scaling_filter),
+                          &node->bounds,
+                          &node->bounds,
+                      });
 
   g_object_unref (image);
 }
@@ -2239,7 +2194,6 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self,
   graphene_rect_t bounds;
   gsize i, j;
   GskGpuImage *image;
-  guint32 descriptor;
 
   if (n_stops < 8)
     {
@@ -2313,15 +2267,15 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self,
 
   gsk_gpu_node_processor_finish_draw (&other, image);
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
-
   gsk_gpu_texture_op (self->frame,
                       gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &bounds),
-                      self->desc,
-                      descriptor,
-                      &node->bounds,
                       &self->offset,
-                      &bounds);
+                      &(GskGpuShaderImage) {
+                          image,
+                          GSK_GPU_SAMPLER_DEFAULT,
+                          &node->bounds,
+                          &bounds
+                      });
 
   g_object_unref (image);
 }
@@ -2425,7 +2379,6 @@ gsk_gpu_node_processor_add_blur_node (GskGpuNodeProcessor *self,
   GskGpuImage *image;
   graphene_rect_t tex_rect, clip_rect;
   float blur_radius, clip_radius;
-  guint32 descriptor;
 
   child = gsk_blur_node_get_child (node);
   blur_radius = gsk_blur_node_get_radius (node);
@@ -2445,15 +2398,12 @@ gsk_gpu_node_processor_add_blur_node (GskGpuNodeProcessor *self,
   if (image == NULL)
     return;
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_TRANSPARENT);
-
   gsk_gpu_node_processor_blur_op (self,
                                   &node->bounds,
                                   graphene_point_zero (),
                                   blur_radius,
                                   NULL,
-                                  self->desc,
-                                  descriptor,
+                                  image,
                                   gdk_memory_format_get_depth (gsk_gpu_image_get_format (image),
                                                                gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB),
                                   &tex_rect);
@@ -2469,8 +2419,6 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self,
   graphene_rect_t clip_bounds, tex_rect;
   GskRenderNode *child;
   gsize i, n_shadows;
-  GskGpuDescriptors *desc;
-  guint32 descriptor;
 
   n_shadows = gsk_shadow_node_get_n_shadows (node);
   child = gsk_shadow_node_get_child (node);
@@ -2488,9 +2436,6 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self,
   if (image == NULL)
     return;
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_TRANSPARENT);
-  desc = self->desc;
-
   for (i = 0; i < n_shadows; i++)
     {
       const GskShadow *shadow = gsk_shadow_node_get_shadow (node, i);
@@ -2501,11 +2446,13 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self,
           gsk_gpu_colorize_op (self->frame,
                                gsk_gpu_clip_get_shader_clip (&self->clip, &shadow_offset, &child->bounds),
                                gsk_gpu_node_processor_color_states_for_rgba (self),
-                               desc,
-                               descriptor,
-                               &child->bounds,
                                &shadow_offset,
-                               &tex_rect,
+                               &(GskGpuShaderImage) {
+                                   image,
+                                   GSK_GPU_SAMPLER_TRANSPARENT,
+                                   &child->bounds,
+                                   &tex_rect,
+                               },
                                GSK_RGBA_TO_VEC4 (&shadow->color));
         }
       else
@@ -2518,22 +2465,22 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self,
                                           &GRAPHENE_POINT_INIT (shadow->dx, shadow->dy),
                                           shadow->radius,
                                           &shadow->color,
-                                          desc,
-                                          descriptor,
+                                          image,
                                           gdk_memory_format_get_depth (gsk_gpu_image_get_format (image),
                                                                        gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB),
                                           &tex_rect);
         }
     }
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
   gsk_gpu_texture_op (self->frame,
                       gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &child->bounds),
-                      self->desc,
-                      descriptor,
-                      &child->bounds,
                       &self->offset,
-                      &tex_rect);
+                      &(GskGpuShaderImage) {
+                          image,
+                          GSK_GPU_SAMPLER_DEFAULT,
+                          &child->bounds,
+                          &tex_rect,
+                      });
 
   g_object_unref (image);
 }
@@ -2559,7 +2506,6 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self,
   GskRenderNode *bottom_child, *top_child;
   graphene_rect_t bottom_rect, top_rect;
   GskGpuImage *bottom_image, *top_image;
-  guint32 descriptors[2];
 
   bottom_child = gsk_blend_node_get_bottom_child (node);
   top_child = gsk_blend_node_get_top_child (node);
@@ -2587,24 +2533,24 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self,
       top_rect = *graphene_rect_zero ();
     }
 
-  gsk_gpu_node_processor_add_two_images (self,
-                                         bottom_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         top_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         descriptors);
-
   gsk_gpu_blend_mode_op (self->frame,
                          gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
-                         self->desc,
                          &node->bounds,
                          &self->offset,
                          self->opacity,
                          gsk_blend_node_get_blend_mode (node),
-                         descriptors[0],
-                         &bottom_rect,
-                         descriptors[1],
-                         &top_rect);
+                         &(GskGpuShaderImage) {
+                             bottom_image,
+                             GSK_GPU_SAMPLER_DEFAULT,
+                             NULL,
+                             &bottom_rect
+                         },
+                         &(GskGpuShaderImage) {
+                             top_image,
+                             GSK_GPU_SAMPLER_DEFAULT,
+                             NULL,
+                             &top_rect
+                         });
 
   g_object_unref (top_image);
   g_object_unref (bottom_image);
@@ -2617,7 +2563,6 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self,
   GskRenderNode *start_child, *end_child;
   graphene_rect_t start_rect, end_rect;
   GskGpuImage *start_image, *end_image;
-  guint32 descriptors[2];
   float progress, old_opacity;
 
   start_child = gsk_cross_fade_node_get_start_child (node);
@@ -2676,25 +2621,25 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self,
       return;
     }
 
-  gsk_gpu_node_processor_add_two_images (self,
-                                         start_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         end_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         descriptors);
-
   gsk_gpu_cross_fade_op (self->frame,
                          gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
                          gsk_gpu_node_processor_color_states_for_rgba (self),
-                         self->desc,
                          &node->bounds,
                          &self->offset,
                          self->opacity,
                          progress,
-                         descriptors[0],
-                         &start_rect,
-                         descriptors[1],
-                         &end_rect);
+                         &(GskGpuShaderImage) {
+                             start_image,
+                             GSK_GPU_SAMPLER_DEFAULT,
+                             NULL,
+                             &start_rect
+                         },
+                         &(GskGpuShaderImage) {
+                             end_image,
+                             GSK_GPU_SAMPLER_DEFAULT,
+                             NULL,
+                             &end_rect
+                         });
 
   g_object_unref (end_image);
   g_object_unref (start_image);
@@ -2731,22 +2676,22 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self,
       mask_mode == GSK_MASK_MODE_ALPHA)
     {
       const GdkRGBA *rgba = gsk_color_node_get_color (source_child);
-      guint32 descriptor = gsk_gpu_node_processor_add_image (self, mask_image, GSK_GPU_SAMPLER_DEFAULT);
       gsk_gpu_colorize_op (self->frame,
                            gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
                            gsk_gpu_node_processor_color_states_for_rgba (self),
-                           self->desc,
-                           descriptor,
-                           &node->bounds,
                            &self->offset,
-                           &mask_rect,
+                           &(GskGpuShaderImage) {
+                               mask_image,
+                               GSK_GPU_SAMPLER_DEFAULT,
+                               &node->bounds,
+                               &mask_rect,
+                           },
                            GSK_RGBA_TO_VEC4_ALPHA (rgba, self->opacity));
     }
   else
     {
       GskGpuImage *source_image;
       graphene_rect_t source_rect;
-      guint32 descriptors[2];
 
       source_image = gsk_gpu_node_processor_get_node_as_image (self,
                                                                &bounds,
@@ -2757,24 +2702,25 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self,
           g_object_unref (mask_image);
           return;
         }
-      gsk_gpu_node_processor_add_two_images (self,
-                                             source_image,
-                                             GSK_GPU_SAMPLER_DEFAULT,
-                                             mask_image,
-                                             GSK_GPU_SAMPLER_DEFAULT,
-                                             descriptors);
 
       gsk_gpu_mask_op (self->frame,
                        gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
-                       self->desc,
                        &node->bounds,
                        &self->offset,
                        self->opacity,
                        mask_mode,
-                       descriptors[0],
-                       &source_rect,
-                       descriptors[1],
-                       &mask_rect);
+                       &(GskGpuShaderImage) {
+                           source_image,
+                           GSK_GPU_SAMPLER_DEFAULT,
+                           NULL,
+                           &source_rect,
+                       },
+                       &(GskGpuShaderImage) {
+                           mask_image,
+                           GSK_GPU_SAMPLER_DEFAULT,
+                           NULL,
+                           &mask_rect,
+                       });
 
       g_object_unref (source_image);
     }
@@ -2797,7 +2743,6 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
   float inv_align_scale_x, inv_align_scale_y;
   unsigned int flags_mask;
   GskGpuImage *last_image;
-  guint32 descriptor;
   const float inv_pango_scale = 1.f / PANGO_SCALE;
 
   if (self->opacity < 1.0 &&
@@ -2836,7 +2781,6 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
   inv_align_scale_y = 1 / align_scale_y;
 
   last_image = NULL;
-  descriptor = 0;
   for (i = 0; i < num_glyphs; i++)
     {
       GskGpuImage *image;
@@ -2874,28 +2818,29 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
                                           glyph_origin.y - glyph_offset.y / scale);
 
       if (image != last_image)
-        {
-          descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
-          last_image = image;
-        }
+        last_image = image;
 
       if (glyphs[i].attr.is_color)
         gsk_gpu_texture_op (self->frame,
                             gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
-                            self->desc,
-                            descriptor,
-                            &glyph_bounds,
                             &glyph_origin,
-                            &glyph_tex_rect);
+                            &(GskGpuShaderImage) {
+                                image,
+                                GSK_GPU_SAMPLER_DEFAULT,
+                                &glyph_bounds,
+                                &glyph_tex_rect
+                            });
       else
         gsk_gpu_colorize_op (self->frame,
                              gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
                              gsk_gpu_node_processor_color_states_for_rgba (self),
-                             self->desc,
-                             descriptor,
-                             &glyph_bounds,
                              &glyph_origin,
-                             &glyph_tex_rect,
+                             &(GskGpuShaderImage) {
+                                 image,
+                                 GSK_GPU_SAMPLER_DEFAULT,
+                                 &glyph_bounds,
+                                 &glyph_tex_rect
+                             },
                              GSK_RGBA_TO_VEC4 (&color));
 
       offset.x += glyphs[i].geometry.width * inv_pango_scale;
@@ -2907,7 +2852,6 @@ gsk_gpu_node_processor_add_color_matrix_node (GskGpuNodeProcessor *self,
                                               GskRenderNode       *node)
 {
   GskGpuImage *image;
-  guint32 descriptor;
   GskRenderNode *child;
   graphene_matrix_t opacity_matrix;
   const graphene_matrix_t *color_matrix;
@@ -2936,16 +2880,16 @@ gsk_gpu_node_processor_add_color_matrix_node (GskGpuNodeProcessor *self,
   if (image == NULL)
     return;
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
-  
   gsk_gpu_color_matrix_op (self->frame,
                            gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds),
                            gsk_gpu_node_processor_color_states_explicit (self, self->ccs, FALSE),
-                           self->desc,
-                           descriptor,
-                           &node->bounds,
                            &self->offset,
-                           &tex_rect,
+                           &(GskGpuShaderImage) {
+                               image,
+                               GSK_GPU_SAMPLER_DEFAULT,
+                               &node->bounds,
+                               &tex_rect,
+                           },
                            color_matrix,
                            gsk_color_matrix_node_get_color_offset (node));
 
@@ -2962,7 +2906,6 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor    *self,
 {
   GskGpuImage *image;
   graphene_rect_t clipped_child_bounds, offset_rect;
-  guint32 descriptor;
 
   gsk_rect_init_offset (&offset_rect,
                         rect,
@@ -2984,20 +2927,20 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor    *self,
 
   g_return_if_fail (image);
 
-  descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_REPEAT);
-
   gsk_gpu_texture_op (self->frame,
                       gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect),
-                      self->desc,
-                      descriptor,
-                      rect,
                       &self->offset,
-                      &GRAPHENE_RECT_INIT (
-                          clipped_child_bounds.origin.x + x * child_bounds->size.width,
-                          clipped_child_bounds.origin.y + y * child_bounds->size.height,
-                          clipped_child_bounds.size.width,
-                          clipped_child_bounds.size.height
-                      ));
+                      &(GskGpuShaderImage) {
+                          image,
+                          GSK_GPU_SAMPLER_REPEAT,
+                          rect,
+                          &GRAPHENE_RECT_INIT (
+                              clipped_child_bounds.origin.x + x * child_bounds->size.width,
+                              clipped_child_bounds.origin.y + y * child_bounds->size.height,
+                              clipped_child_bounds.size.width,
+                              clipped_child_bounds.size.height
+                          )
+                      });
 
   g_object_unref (image);
 }
@@ -3167,7 +3110,6 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self,
 {
   graphene_rect_t clip_bounds, source_rect;
   GskGpuImage *mask_image, *source_image;
-  guint32 descriptors[2];
   GskRenderNode *child;
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
@@ -3207,24 +3149,24 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self,
   if (source_image == NULL)
     return;
 
-  gsk_gpu_node_processor_add_two_images (self,
-                                         source_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         mask_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         descriptors);
-
   gsk_gpu_mask_op (self->frame,
                    gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds),
-                   self->desc,
                    &clip_bounds,
                    &self->offset,
                    self->opacity,
                    GSK_MASK_MODE_ALPHA,
-                   descriptors[0],
-                   &source_rect,
-                   descriptors[1],
-                   &clip_bounds);
+                   &(GskGpuShaderImage) {
+                       source_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &source_rect,
+                   },
+                   &(GskGpuShaderImage) {
+                       mask_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &clip_bounds,
+                   });
 
   g_object_unref (source_image);
 }
@@ -3265,7 +3207,6 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self,
 {
   graphene_rect_t clip_bounds, source_rect;
   GskGpuImage *mask_image, *source_image;
-  guint32 descriptors[2];
   GskRenderNode *child;
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
@@ -3305,24 +3246,24 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self,
   if (source_image == NULL)
     return;
 
-  gsk_gpu_node_processor_add_two_images (self,
-                                         source_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         mask_image,
-                                         GSK_GPU_SAMPLER_DEFAULT,
-                                         descriptors);
-
   gsk_gpu_mask_op (self->frame,
                    gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds),
-                   self->desc,
                    &clip_bounds,
                    &self->offset,
                    self->opacity,
                    GSK_MASK_MODE_ALPHA,
-                   descriptors[0],
-                   &source_rect,
-                   descriptors[1],
-                   &clip_bounds);
+                   &(GskGpuShaderImage) {
+                       source_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &source_rect,
+                   },
+                   &(GskGpuShaderImage) {
+                       mask_image,
+                       GSK_GPU_SAMPLER_DEFAULT,
+                       NULL,
+                       &clip_bounds,
+                   });
 
   g_object_unref (source_image);
 }
@@ -3942,7 +3883,6 @@ gsk_gpu_node_processor_process (GskGpuFrame                 *frame,
     {
       GskGpuImage *image;
       graphene_rect_t clip_bounds, tex_rect;
-      guint32 descriptor;
 
       /* Can't use gsk_gpu_node_processor_get_node_as_image () because of colorspaces */
       if (gsk_gpu_node_processor_clip_node_bounds (&self, node, &clip_bounds))
@@ -3970,17 +3910,18 @@ gsk_gpu_node_processor_process (GskGpuFrame                 *frame,
           self.pending_globals |= GSK_GPU_GLOBAL_BLEND;
           gsk_gpu_node_processor_sync_globals (&self, 0);
 
-          descriptor = gsk_gpu_node_processor_add_image (&self, image, GSK_GPU_SAMPLER_DEFAULT);
           gsk_gpu_convert_op (self.frame,
                               gsk_gpu_clip_get_shader_clip (&self.clip, &self.offset, &node->bounds),
                               gsk_gpu_node_processor_color_states_explicit (&self, ccs, TRUE),
                               self.opacity,
-                              self.desc,
-                              descriptor,
                               FALSE,
-                              &node->bounds,
                               &self.offset,
-                              &tex_rect);
+                              &(GskGpuShaderImage) {
+                                  image,
+                                  GSK_GPU_SAMPLER_DEFAULT,
+                                  &node->bounds,
+                                  &tex_rect
+                              });
 
           gsk_gpu_render_pass_end_op (frame,
                                       target,

gsk/gpu/gskgpuopprivate.h

@@ -25,12 +25,12 @@ struct _GskGLCommandState
   gsize flip_y;
   struct {
     const GskGpuOpClass *op_class;
+    GskGpuShaderFlags flags;
     GskGpuColorStates color_states;
     guint32 variation;
-    GskGpuShaderClip clip;
-    gsize n_external;
   } current_program;
-  GskGLDescriptors *desc;
+  GskGpuImage *current_images[2];
+  GskGpuSampler current_samplers[2];
 };
 
 #ifdef GDK_RENDERING_VULKAN
@@ -41,8 +41,9 @@ struct _GskVulkanCommandState
   VkCommandBuffer vk_command_buffer;
   GskGpuBlend blend;
 
-  GskVulkanDescriptors *desc;
   GskVulkanSemaphores *semaphores;
+  GskGpuImage *current_images[2];
+  GskGpuSampler current_samplers[2];
 };
 #endif
 

gsk/gpu/gskgpuprint.c

@@ -3,8 +3,8 @@
 #include "gskgpuprintprivate.h"
 
 #include "gskgpucolorstatesprivate.h"
-#include "gskgpudescriptorsprivate.h"
 #include "gskgpuimageprivate.h"
+#include "gskgpushaderflagsprivate.h"
 
 void
 gsk_gpu_print_indent (GString *string,
@@ -14,9 +14,11 @@ gsk_gpu_print_indent (GString *string,
 }
 
 void
-gsk_gpu_print_shader_clip (GString          *string,
-                           GskGpuShaderClip  clip)
+gsk_gpu_print_shader_flags (GString           *string,
+                            GskGpuShaderFlags  flags)
 {
+  GskGpuShaderClip clip = gsk_gpu_shader_flags_get_clip (flags);
+
   switch (clip)
     {
       case GSK_GPU_SHADER_CLIP_NONE:
@@ -164,12 +166,3 @@ gsk_gpu_print_image (GString     *string,
                           gdk_memory_format_get_name (gsk_gpu_image_get_format (image)));
 }
 
-void
-gsk_gpu_print_image_descriptor (GString           *string,
-                                GskGpuDescriptors *desc,
-                                guint32            descriptor)
-{
-  gsize id = gsk_gpu_descriptors_find_image (desc, descriptor);
-  gsk_gpu_print_image (string, gsk_gpu_descriptors_get_image (desc, id));
-}
-

gsk/gpu/gskgpuprintprivate.h

@@ -17,8 +17,8 @@ void                    gsk_gpu_print_newline                           (GString
 
 void                    gsk_gpu_print_string                            (GString                        *string,
                                                                          const char                     *s);
-void                    gsk_gpu_print_shader_clip                       (GString                        *string,
-                                                                         GskGpuShaderClip                clip);
+void                    gsk_gpu_print_shader_flags                      (GString                        *string,
+                                                                         GskGpuShaderFlags               flags);
 void                    gsk_gpu_print_color_states                      (GString                        *string,
                                                                          GskGpuColorStates               color_states);
 void                    gsk_gpu_print_enum                              (GString                        *string,
@@ -34,6 +34,3 @@ void                    gsk_gpu_print_rgba                              (GString
                                                                          const float                     rgba[4]);
 void                    gsk_gpu_print_image                             (GString                        *string,
                                                                          GskGpuImage                    *image);
-void                    gsk_gpu_print_image_descriptor                  (GString                        *string,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor);

gsk/gpu/gskgpuradialgradientop.c

@@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_RADIAL_GRADIENT_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpuradialgradient",
+  gsk_gpu_radialgradient_n_textures,
   sizeof (GskGpuRadialgradientInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_radialgradient_info,
@@ -79,6 +80,7 @@ gsk_gpu_radial_gradient_op (GskGpuFrame            *frame,
                            (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0),
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);

gsk/gpu/gskgpurenderpassop.c

@@ -11,7 +11,6 @@
 #include "gskrendernodeprivate.h"
 #ifdef GDK_RENDERING_VULKAN
 #include "gskvulkanimageprivate.h"
-#include "gskvulkandescriptorsprivate.h"
 #endif
 
 typedef struct _GskGpuRenderPassOp GskGpuRenderPassOp;
@@ -74,7 +73,6 @@ gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp     *self,
 {
   GskGpuShaderOp *shader;
   GskGpuOp *op;
-  GskGpuDescriptors *desc = NULL;
 
   for (op = ((GskGpuOp *) self)->next;
        op->op_class->stage != GSK_GPU_STAGE_END_PASS;
@@ -85,20 +83,21 @@ gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp     *self,
 
       shader = (GskGpuShaderOp *) op;
 
-      if (shader->desc == NULL || shader->desc == desc)
-        continue;
-
-      if (desc == NULL)
-        {
-          gsk_vulkan_descriptors_bind (GSK_VULKAN_DESCRIPTORS (shader->desc), state->desc, state->vk_command_buffer);
-          state->desc = GSK_VULKAN_DESCRIPTORS (shader->desc);
-        }
-      desc = shader->desc;
-      gsk_vulkan_descriptors_transition (GSK_VULKAN_DESCRIPTORS (desc), state->semaphores, state->vk_command_buffer);
+      if (shader->images[0])
+        gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (shader->images[0]),
+                                     state->semaphores,
+                                     state->vk_command_buffer,
+                                     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                                     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                     VK_ACCESS_SHADER_READ_BIT);
+      if (shader->images[1])
+        gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (shader->images[1]),
+                                     state->semaphores,
+                                     state->vk_command_buffer,
+                                     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                                     VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                     VK_ACCESS_SHADER_READ_BIT);
     }
-
-  if (desc == NULL)
-    gsk_vulkan_descriptors_transition (state->desc, state->semaphores, state->vk_command_buffer);
 }
 
 static GskGpuOp *

gsk/gpu/gskgpuroundedcolorop.c

@@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_ROUNDED_COLOR_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgpuroundedcolor",
+  gsk_gpu_roundedcolor_n_textures,
   sizeof (GskGpuRoundedcolorInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_roundedcolor_info,
@@ -64,6 +65,7 @@ gsk_gpu_rounded_color_op (GskGpuFrame            *frame,
                            0,
                            clip,
                            NULL,
+                           NULL,
                            &instance);
 
   gsk_rounded_rect_to_float (outline, offset, instance->outline);

gsk/gpu/gskgpushaderflagsprivate.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "gskgputypesprivate.h"
+
+static inline GskGpuShaderFlags
+gsk_gpu_shader_flags_create (GskGpuShaderClip clip,
+                             gboolean         texture0_is_external,
+                             gboolean         texture1_is_external)
+{
+  return (clip & GSK_GPU_SHADER_CLIP_MASK) |
+         (texture0_is_external ? 1 << GSK_GPU_SHADER_CLIP_SHIFT : 0) | 
+         (texture1_is_external ? 1 << (GSK_GPU_SHADER_CLIP_SHIFT + 1) : 0);
+}
+
+static inline gboolean
+gsk_gpu_shader_flags_has_external_textures (GskGpuShaderFlags flags)
+{
+  return flags & (3 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE;
+}
+
+static inline gboolean
+gsk_gpu_shader_flags_has_external_texture0 (GskGpuShaderFlags flags)
+{
+  return flags & (1 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE;
+}
+
+static inline gboolean
+gsk_gpu_shader_flags_has_external_texture1 (GskGpuShaderFlags flags)
+{
+  return flags & (2 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE;
+}
+
+static inline GskGpuShaderClip
+gsk_gpu_shader_flags_get_clip (GskGpuShaderFlags flags)
+{
+  return flags & GSK_GPU_SHADER_CLIP_MASK;
+}

gsk/gpu/gskgpushaderop.c

@@ -4,13 +4,13 @@
 
 #include "gskgpuframeprivate.h"
 #include "gskgpuprintprivate.h"
-#include "gskgldescriptorsprivate.h"
+#include "gskgpushaderflagsprivate.h"
 #include "gskgldeviceprivate.h"
 #include "gskglframeprivate.h"
 #include "gskglimageprivate.h"
 #ifdef GDK_RENDERING_VULKAN
-#include "gskvulkandescriptorsprivate.h"
 #include "gskvulkandeviceprivate.h"
+#include "gskvulkanimageprivate.h"
 #endif
 
 #include "gdkglcontextprivate.h"
@@ -26,7 +26,8 @@ gsk_gpu_shader_op_finish (GskGpuOp *op)
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
 
-  g_clear_object (&self->desc);
+  g_clear_object (&self->images[0]);
+  g_clear_object (&self->images[1]);
 }
 
 void
@@ -51,7 +52,7 @@ gsk_gpu_shader_op_print (GskGpuOp    *op,
   for (i = 0; i < self->n_ops; i++)
     {
       gsk_gpu_print_op (string, indent, shader_name);
-      gsk_gpu_print_shader_clip (string, self->clip);
+      gsk_gpu_print_shader_flags (string, self->flags);
       gsk_gpu_print_color_states (string, self->color_states);
       shader_class->print_instance (self,
                                     instance + i * shader_class->vertex_size,
@@ -69,48 +70,64 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp              *op,
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
   GskGpuShaderOpClass *shader_op_class = (GskGpuShaderOpClass *) op->op_class;
-  GskVulkanDescriptors *desc;
   GskGpuOp *next;
+  VkPipelineLayout vk_pipeline_layout;
   gsize i, n_ops, max_ops_per_draw;
 
-  if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE) &&
-      gsk_vulkan_device_has_feature (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)),
-                                     GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING))
+  if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE))
     max_ops_per_draw = MAX_MERGE_OPS;
   else
     max_ops_per_draw = 1;
 
-  desc = GSK_VULKAN_DESCRIPTORS (self->desc);
-  if (desc && state->desc != desc)
-    {
-      gsk_vulkan_descriptors_bind (desc, state->desc, state->vk_command_buffer);
-      state->desc = desc;
-    }
-
   n_ops = self->n_ops;
   for (next = op->next; next; next = next->next)
     {
       GskGpuShaderOp *next_shader = (GskGpuShaderOp *) next;
   
       if (next->op_class != op->op_class ||
-          next_shader->desc != self->desc ||
+          next_shader->flags != self->flags ||
           next_shader->color_states != self->color_states ||
           next_shader->variation != self->variation ||
-          next_shader->clip != self->clip ||
-          next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size)
+          next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size ||
+          (shader_op_class->n_textures > 0 && (next_shader->images[0] != self->images[0] || next_shader->samplers[0] != self->samplers[0])) ||
+          (shader_op_class->n_textures > 1 && (next_shader->images[1] != self->images[1] || next_shader->samplers[1] != self->samplers[1])))
         break;
 
       n_ops += next_shader->n_ops;
     }
 
+  vk_pipeline_layout = gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)),
+                                                                 shader_op_class->n_textures > 0 ? gsk_vulkan_image_get_ycbcr (GSK_VULKAN_IMAGE (self->images[0])) : NULL,
+                                                                 shader_op_class->n_textures > 1 ? gsk_vulkan_image_get_ycbcr (GSK_VULKAN_IMAGE (self->images[1])) : NULL);
+
+  for (i = 0; i < shader_op_class->n_textures; i++)
+    {
+      if (state->current_images[i] != self->images[i] ||
+          state->current_samplers[i] != self->samplers[i])
+        {
+          vkCmdBindDescriptorSets (state->vk_command_buffer,
+                                   VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                   vk_pipeline_layout,
+                                   i,
+                                   1,
+                                   (VkDescriptorSet[1]) {
+                                       gsk_vulkan_image_get_vk_descriptor_set (GSK_VULKAN_IMAGE (self->images[i]), self->samplers[i]),
+                                   },
+                                   0,
+                                   NULL);
+          state->current_images[i] = self->images[i];
+          state->current_samplers[i] = self->samplers[i];
+        }
+    }
+                               
   vkCmdBindPipeline (state->vk_command_buffer,
                      VK_PIPELINE_BIND_POINT_GRAPHICS,
                      gsk_vulkan_device_get_vk_pipeline (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)),
-                                                        gsk_vulkan_descriptors_get_pipeline_layout (state->desc),
+                                                        vk_pipeline_layout,
                                                         shader_op_class,
+                                                        self->flags,
                                                         self->color_states,
                                                         self->variation,
-                                                        self->clip,
                                                         state->blend,
                                                         state->vk_format,
                                                         state->vk_render_pass));
@@ -142,39 +159,39 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp          *op,
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
   GskGpuShaderOpClass *shader_op_class = (GskGpuShaderOpClass *) op->op_class;
-  GskGLDescriptors *desc;
   GskGpuOp *next;
-  gsize i, n_ops, n_external, max_ops_per_draw;
-
-  desc = GSK_GL_DESCRIPTORS (self->desc);
-  if (desc)
-    n_external = gsk_gl_descriptors_get_n_external (desc);
-  else
-    n_external = 0;
+  gsize i, n_ops, max_ops_per_draw;
 
   if (state->current_program.op_class != op->op_class ||
       state->current_program.color_states != self->color_states ||
       state->current_program.variation != self->variation ||
-      state->current_program.clip != self->clip ||
-      state->current_program.n_external != n_external)
+      state->current_program.flags != self->flags)
     {
       state->current_program.op_class = op->op_class;
+      state->current_program.flags = self->flags;
       state->current_program.color_states = self->color_states;
       state->current_program.variation = self->variation;
-      state->current_program.clip = self->clip;
-      state->current_program.n_external = n_external;
       gsk_gl_frame_use_program (GSK_GL_FRAME (frame),
                                 shader_op_class,
+                                self->flags,
                                 self->color_states,
-                                self->variation,
-                                self->clip,
-                                n_external);
+                                self->variation);
     }
 
-  if (desc != state->desc && desc)
+  for (i = 0; i < shader_op_class->n_textures; i++)
     {
-      gsk_gl_descriptors_use (desc);
-      state->desc = desc;
+      if (state->current_images[i] != self->images[i])
+        {
+          glActiveTexture (GL_TEXTURE0 + 3 * i);
+          gsk_gl_image_bind_texture (GSK_GL_IMAGE (self->images[i]));
+          state->current_images[i] = self->images[i];
+        }
+      if (state->current_samplers[i] != self->samplers[i])
+        {
+          glBindSampler (3 * i, gsk_gl_device_get_sampler_id (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame)),
+                                                              self->samplers[i]));
+          state->current_samplers[i] = self->samplers[i];
+        }
     }
 
   if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE))
@@ -188,11 +205,12 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp          *op,
       GskGpuShaderOp *next_shader = (GskGpuShaderOp *) next;
 
       if (next->op_class != op->op_class ||
-          next_shader->desc != self->desc ||
+          next_shader->flags != self->flags ||
           next_shader->color_states != self->color_states ||
           next_shader->variation != self->variation ||
-          next_shader->clip != self->clip ||
-          next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size)
+          next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size ||
+          (shader_op_class->n_textures > 0 && (next_shader->images[0] != self->images[0] || next_shader->samplers[0] != self->samplers[0])) ||
+          (shader_op_class->n_textures > 1 && (next_shader->images[1] != self->images[1] || next_shader->samplers[1] != self->samplers[1])))
         break;
 
       n_ops += next_shader->n_ops;
@@ -237,25 +255,41 @@ gsk_gpu_shader_op_alloc (GskGpuFrame               *frame,
                          GskGpuColorStates          color_states,
                          guint32                    variation,
                          GskGpuShaderClip           clip,
-                         GskGpuDescriptors         *desc,
+                         GskGpuImage              **images,
+                         GskGpuSampler             *samplers,
                          gpointer                   out_vertex_data)
 {
   GskGpuOp *last;
   GskGpuShaderOp *last_shader;
-  gsize vertex_offset;
+  gsize i, vertex_offset, vertex_size, texture_vertex_size;
+  guchar *vertex_data;
+  GskGpuShaderFlags flags;
 
-  vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size);
+  flags = gsk_gpu_shader_flags_create (clip,
+                                       op_class->n_textures > 0 && (gsk_gpu_image_get_flags (images[0]) & GSK_GPU_IMAGE_EXTERNAL),
+                                       op_class->n_textures > 1 && (gsk_gpu_image_get_flags (images[1]) & GSK_GPU_IMAGE_EXTERNAL));
+  texture_vertex_size = gsk_gpu_frame_get_texture_vertex_size (frame, op_class->n_textures);
+  vertex_size = texture_vertex_size + op_class->vertex_size;
+  vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, vertex_size);
+  vertex_data = gsk_gpu_frame_get_vertex_data (frame, vertex_offset);
+
+  gsk_gpu_frame_write_texture_vertex_data (frame,
+                                           vertex_data,
+                                           images,
+                                           samplers,
+                                           op_class->n_textures);
 
   last = gsk_gpu_frame_get_last_op (frame);
   /* careful: We're casting without checking, but the if() does the check */
   last_shader = (GskGpuShaderOp *) last;
   if (last &&
       last->op_class == (const GskGpuOpClass *) op_class &&
-      last_shader->desc == desc &&
       last_shader->color_states == color_states &&
       last_shader->variation == variation &&
-      last_shader->clip == clip &&
-      last_shader->vertex_offset + last_shader->n_ops * op_class->vertex_size == vertex_offset)
+      last_shader->flags == flags &&
+      last_shader->vertex_offset + last_shader->n_ops * vertex_size == vertex_offset &&
+      (op_class->n_textures < 1 || (last_shader->images[0] == images[0] && last_shader->samplers[0] == samplers[0])) &&
+      (op_class->n_textures < 2 || (last_shader->images[1] == images[1] && last_shader->samplers[1] == samplers[1])))
     {
       last_shader->n_ops++;
     }
@@ -264,17 +298,18 @@ gsk_gpu_shader_op_alloc (GskGpuFrame               *frame,
       GskGpuShaderOp *self;
       self = (GskGpuShaderOp *) gsk_gpu_op_alloc (frame, &op_class->parent_class);
 
+      self->flags = flags;
       self->color_states = color_states;
       self->variation = variation;
-      self->clip = clip;
       self->vertex_offset = vertex_offset;
-      if (desc)
-        self->desc = g_object_ref (desc);
-      else
-        self->desc = NULL;
       self->n_ops = 1;
+      for (i = 0; i < op_class->n_textures; i++)
+        {
+          self->images[i] = g_object_ref (images[i]);
+          self->samplers[i] = samplers[i];
+        }
     }
 
-  *((gpointer *) out_vertex_data) = gsk_gpu_frame_get_vertex_data (frame, vertex_offset);
+  *((gpointer *) out_vertex_data) = vertex_data + texture_vertex_size;
 }
 

gsk/gpu/gskgpushaderopprivate.h

@@ -5,16 +5,27 @@
 #include "gskgputypesprivate.h"
 #include "gskgpucolorstatesprivate.h"
 
+#include <graphene.h>
+
 G_BEGIN_DECLS
 
+struct _GskGpuShaderImage
+{
+  GskGpuImage           *image;         /* image to draw */
+  GskGpuSampler          sampler;       /* sampler to use for image */
+  const graphene_rect_t *coverage;      /* the clip area for the image or NULL for unclipped */
+  const graphene_rect_t *bounds;        /* bounds for the image */
+};
+
 struct _GskGpuShaderOp
 {
   GskGpuOp parent_op;
 
-  GskGpuDescriptors *desc;
+  GskGpuImage *images[2];
+  GskGpuSampler samplers[2];
+  GskGpuShaderFlags flags;
   GskGpuColorStates color_states;
   guint32 variation;
-  GskGpuShaderClip clip;
   gsize vertex_offset;
   gsize n_ops;
 };
@@ -24,6 +35,7 @@ struct _GskGpuShaderOpClass
   GskGpuOpClass         parent_class;
 
   const char *          shader_name;
+  gsize                 n_textures;
   gsize                 vertex_size;
 #ifdef GDK_RENDERING_VULKAN
   const VkPipelineVertexInputStateCreateInfo *vertex_input_state;
@@ -40,7 +52,8 @@ void                    gsk_gpu_shader_op_alloc                         (GskGpuF
                                                                          GskGpuColorStates       color_states,
                                                                          guint32                 variation,
                                                                          GskGpuShaderClip        clip,
-                                                                         GskGpuDescriptors      *desc,
+                                                                         GskGpuImage           **images,
+                                                                         GskGpuSampler          *samplers,
                                                                          gpointer                out_vertex_data);
 
 void                    gsk_gpu_shader_op_finish                        (GskGpuOp               *op);

gsk/gpu/gskgputextureop.c

@@ -23,7 +23,7 @@ gsk_gpu_texture_op_print_instance (GskGpuShaderOp *shader,
   GskGpuTextureInstance *instance = (GskGpuTextureInstance *) instance_;
 
   gsk_gpu_print_rect (string, instance->rect);
-  gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id);
+  gsk_gpu_print_image (string, shader->images[0]);
 }
 
 static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = {
@@ -38,6 +38,7 @@ static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = {
     gsk_gpu_shader_op_gl_command
   },
   "gskgputexture",
+  gsk_gpu_texture_n_textures,
   sizeof (GskGpuTextureInstance),
 #ifdef GDK_RENDERING_VULKAN
   &gsk_gpu_texture_info,
@@ -48,13 +49,10 @@ static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = {
 };
 
 void
-gsk_gpu_texture_op (GskGpuFrame            *frame,
-                    GskGpuShaderClip        clip,
-                    GskGpuDescriptors      *desc,
-                    guint32                 descriptor,
-                    const graphene_rect_t  *rect,
-                    const graphene_point_t *offset,
-                    const graphene_rect_t  *tex_rect)
+gsk_gpu_texture_op (GskGpuFrame             *frame,
+                    GskGpuShaderClip         clip,
+                    const graphene_point_t  *offset,
+                    const GskGpuShaderImage *image)
 {
   GskGpuTextureInstance *instance;
 
@@ -63,10 +61,10 @@ gsk_gpu_texture_op (GskGpuFrame            *frame,
                            gsk_gpu_color_states_create_equal (TRUE, TRUE),
                            0,
                            clip,
-                           desc,
+                           (GskGpuImage *[1]) { image->image },
+                           (GskGpuSampler[1]) { image->sampler },
                            &instance);
 
-  gsk_gpu_rect_to_float (rect, offset, instance->rect);
-  gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  instance->tex_id = descriptor;
+  gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect);
+  gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect);
 }

gsk/gpu/gskgputextureopprivate.h

@@ -8,11 +8,8 @@ G_BEGIN_DECLS
 
 void                    gsk_gpu_texture_op                              (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
-                                                                         GskGpuDescriptors              *desc,
-                                                                         guint32                         descriptor,
-                                                                         const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect);
+                                                                         const GskGpuShaderImage        *image);
 
 
 G_END_DECLS

gsk/gpu/gskgputypesprivate.h

@@ -5,19 +5,18 @@
 
 #include "gdk/gdkmemoryformatprivate.h"
 
-typedef struct _GskGLDescriptors        GskGLDescriptors;
 typedef struct _GskGpuBuffer            GskGpuBuffer;
 typedef struct _GskGpuCache             GskGpuCache;
 typedef guint32                         GskGpuColorStates;
-typedef struct _GskGpuDescriptors       GskGpuDescriptors;
 typedef struct _GskGpuDevice            GskGpuDevice;
 typedef struct _GskGpuFrame             GskGpuFrame;
 typedef struct _GskGpuImage             GskGpuImage;
 typedef struct _GskGpuOp                GskGpuOp;
 typedef struct _GskGpuOpClass           GskGpuOpClass;
+typedef guint32                         GskGpuShaderFlags;
+typedef struct _GskGpuShaderImage       GskGpuShaderImage;
 typedef struct _GskGpuShaderOp          GskGpuShaderOp;
 typedef struct _GskGpuShaderOpClass     GskGpuShaderOpClass;
-typedef struct _GskVulkanDescriptors    GskVulkanDescriptors;
 typedef struct _GskVulkanSemaphores     GskVulkanSemaphores;
 
 typedef enum {
@@ -47,6 +46,8 @@ typedef enum {
   GSK_GPU_SHADER_CLIP_RECT,
   GSK_GPU_SHADER_CLIP_ROUNDED
 } GskGpuShaderClip;
+#define GSK_GPU_SHADER_CLIP_SHIFT 2
+#define GSK_GPU_SHADER_CLIP_MASK ((1 << GSK_GPU_SHADER_CLIP_SHIFT) - 1)
 
 typedef enum {
   GSK_GPU_BLEND_NONE,

gsk/gpu/gskvulkandescriptors.c

@@ -1,52 +0,0 @@
-#include "config.h"
-
-#include "gskvulkandescriptorsprivate.h"
-
-#include "gskvulkanbufferprivate.h"
-#include "gskvulkanframeprivate.h"
-#include "gskvulkanimageprivate.h"
-
-G_DEFINE_TYPE (GskVulkanDescriptors, gsk_vulkan_descriptors, GSK_TYPE_GPU_DESCRIPTORS)
-
-static void
-gsk_vulkan_descriptors_class_init (GskVulkanDescriptorsClass *klass)
-{
-}
-
-static void
-gsk_vulkan_descriptors_init (GskVulkanDescriptors *self)
-{
-}
-
-GskVulkanPipelineLayout *
-gsk_vulkan_descriptors_get_pipeline_layout (GskVulkanDescriptors *self)
-{
-  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->get_pipeline_layout (self);
-}
-
-void
-gsk_vulkan_descriptors_transition (GskVulkanDescriptors *self,
-                                   GskVulkanSemaphores  *semaphores,
-                                   VkCommandBuffer       vk_command_buffer)
-{
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
-  gsize i;
-
-  for (i = 0; i < gsk_gpu_descriptors_get_n_images (desc); i++)
-    {
-      gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (gsk_gpu_descriptors_get_image (desc, i)),
-                                   semaphores,
-                                   vk_command_buffer,
-                                   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                                   VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                                   VK_ACCESS_SHADER_READ_BIT);
-    }
-}
-
-void
-gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self,
-                             GskVulkanDescriptors *previous,
-                             VkCommandBuffer       vk_command_buffer)
-{
-  GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->bind (self, previous, vk_command_buffer);
-}

gsk/gpu/gskvulkandescriptorsprivate.h

@@ -1,47 +0,0 @@
-#pragma once
-
-#include "gskgpudescriptorsprivate.h"
-
-#include "gskvulkandeviceprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_VULKAN_DESCRIPTORS         (gsk_vulkan_descriptors_get_type ())
-#define GSK_VULKAN_DESCRIPTORS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptors))
-#define GSK_VULKAN_DESCRIPTORS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass))
-#define GSK_IS_VULKAN_DESCRIPTORS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_VULKAN_DESCRIPTORS))
-#define GSK_IS_VULKAN_DESCRIPTORS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_VULKAN_DESCRIPTORS))
-#define GSK_VULKAN_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass))
-
-typedef struct _GskVulkanDescriptorsClass GskVulkanDescriptorsClass;
-
-struct _GskVulkanDescriptors
-{
-  GskGpuDescriptors parent_instance;
-};
-
-struct _GskVulkanDescriptorsClass
-{
-  GskGpuDescriptorsClass parent_class;
-
-  GskVulkanPipelineLayout *     (* get_pipeline_layout)                         (GskVulkanDescriptors   *self);
-  void                          (* bind)                                        (GskVulkanDescriptors   *self,
-                                                                                 GskVulkanDescriptors   *previous,
-                                                                                 VkCommandBuffer         vk_command_buffer);
-};
-
-GType                           gsk_vulkan_descriptors_get_type                 (void) G_GNUC_CONST;
-
-GskVulkanPipelineLayout *       gsk_vulkan_descriptors_get_pipeline_layout      (GskVulkanDescriptors   *self);
-
-void                            gsk_vulkan_descriptors_transition               (GskVulkanDescriptors   *self,
-                                                                                 GskVulkanSemaphores    *semaphores,
-                                                                                 VkCommandBuffer         vk_command_buffer);
-void                            gsk_vulkan_descriptors_bind                     (GskVulkanDescriptors   *self,
-                                                                                 GskVulkanDescriptors   *previous,
-                                                                                 VkCommandBuffer         vk_command_buffer);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskVulkanDescriptors, g_object_unref)
-
-G_END_DECLS
-

gsk/gpu/gskvulkandeviceprivate.h

@@ -11,26 +11,16 @@
 
 G_BEGIN_DECLS
 
-/* also used by gskvulkanframe.c */
-enum {
-  GSK_VULKAN_IMAGE_SET_LAYOUT,
-  GSK_VULKAN_BUFFER_SET_LAYOUT,
-
-  GSK_VULKAN_N_DESCRIPTOR_SETS
-};
+/* forward declaration */
+typedef struct _GskVulkanYcbcr GskVulkanYcbcr;
 
 #define GSK_TYPE_VULKAN_DEVICE (gsk_vulkan_device_get_type ())
 
 G_DECLARE_FINAL_TYPE(GskVulkanDevice, gsk_vulkan_device, GSK, VULKAN_DEVICE, GskGpuDevice)
 
-typedef struct _GskVulkanPipelineLayout GskVulkanPipelineLayout;
-
 GskGpuDevice *          gsk_vulkan_device_get_for_display               (GdkDisplay             *display,
                                                                          GError                **error);
 
-gsize                   gsk_vulkan_device_get_max_immutable_samplers    (GskVulkanDevice        *self);
-gsize                   gsk_vulkan_device_get_max_samplers              (GskVulkanDevice        *self);
-gsize                   gsk_vulkan_device_get_max_buffers               (GskVulkanDevice        *self);
 gboolean                gsk_vulkan_device_has_feature                   (GskVulkanDevice        *self,
                                                                          GdkVulkanFeatures       feature) G_GNUC_PURE;
 
@@ -39,45 +29,40 @@ VkPhysicalDevice        gsk_vulkan_device_get_vk_physical_device        (GskVulk
 VkQueue                 gsk_vulkan_device_get_vk_queue                  (GskVulkanDevice        *self) G_GNUC_PURE;
 uint32_t                gsk_vulkan_device_get_vk_queue_family_index     (GskVulkanDevice        *self) G_GNUC_PURE;
 VkCommandPool           gsk_vulkan_device_get_vk_command_pool           (GskVulkanDevice        *self) G_GNUC_PURE;
+VkDescriptorSet         gsk_vulkan_device_allocate_descriptor           (GskVulkanDevice        *self,
+                                                                         const VkDescriptorSetLayout layout,
+                                                                         gsize                  *out_pool_id);
+void                    gsk_vulkan_device_free_descriptor               (GskVulkanDevice        *self,
+                                                                         gsize                   pool_id,
+                                                                         VkDescriptorSet         set);
+VkDescriptorSetLayout   gsk_vulkan_device_get_vk_image_set_layout       (GskVulkanDevice        *self) G_GNUC_PURE;
+VkPipelineLayout        gsk_vulkan_device_create_vk_pipeline_layout     (GskVulkanDevice        *self,
+                                                                         VkDescriptorSetLayout   image1_layout,
+                                                                         VkDescriptorSetLayout   image2_layout);
+VkPipelineLayout        gsk_vulkan_device_get_default_vk_pipeline_layout (GskVulkanDevice       *self) G_GNUC_PURE;
+VkPipelineLayout        gsk_vulkan_device_get_vk_pipeline_layout        (GskVulkanDevice        *self,
+                                                                         GskVulkanYcbcr         *ycbcr0,
+                                                                         GskVulkanYcbcr         *ycbcr1);
 VkSampler               gsk_vulkan_device_get_vk_sampler                (GskVulkanDevice        *self,
                                                                          GskGpuSampler           sampler) G_GNUC_PURE;
 
-GskVulkanPipelineLayout *
-                        gsk_vulkan_device_acquire_pipeline_layout       (GskVulkanDevice        *self,
-                                                                         VkSampler              *immutable_samplers,
-                                                                         gsize                   n_immutable_samplers,
-                                                                         gsize                   n_samplers,
-                                                                         gsize                   n_buffers);
-void                    gsk_vulkan_device_release_pipeline_layout       (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout);
-void                    gsk_vulkan_device_get_pipeline_sizes            (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout,
-                                                                         gsize                  *n_immutable_samplers,
-                                                                         gsize                  *n_samplers,
-                                                                         gsize                  *n_buffers);
-VkDescriptorSetLayout   gsk_vulkan_device_get_vk_image_set_layout       (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout) G_GNUC_PURE;
-VkDescriptorSetLayout   gsk_vulkan_device_get_vk_buffer_set_layout      (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout) G_GNUC_PURE;
-VkPipelineLayout        gsk_vulkan_device_get_vk_pipeline_layout        (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout) G_GNUC_PURE;
+GskVulkanYcbcr *        gsk_vulkan_device_get_ycbcr                     (GskVulkanDevice        *self,
+                                                                         VkFormat                vk_format);
+void                    gsk_vulkan_device_remove_ycbcr                  (GskVulkanDevice        *self,
+                                                                         VkFormat                vk_format);
 
-VkSamplerYcbcrConversion
-                        gsk_vulkan_device_get_vk_conversion             (GskVulkanDevice        *self,
-                                                                         VkFormat                vk_format,
-                                                                         VkSampler              *out_sampler);
 VkRenderPass            gsk_vulkan_device_get_vk_render_pass            (GskVulkanDevice        *self,
                                                                          VkFormat                format,
                                                                          VkImageLayout           from_layout,
                                                                          VkImageLayout           to_layout);
 VkPipeline              gsk_vulkan_device_get_vk_pipeline               (GskVulkanDevice        *self,
-                                                                         GskVulkanPipelineLayout*layout,
+                                                                         VkPipelineLayout        layout,
                                                                          const GskGpuShaderOpClass *op_class,
+                                                                         GskGpuShaderFlags       flags,
                                                                          GskGpuColorStates       color_states,
                                                                          guint32                 variation,
-                                                                         GskGpuShaderClip        clip,
                                                                          GskGpuBlend             blend,
-                                                                         VkFormat                format,
+                                                                         VkFormat                vk_format,
                                                                          VkRenderPass            render_pass);
 
 GskVulkanAllocator *    gsk_vulkan_device_get_external_allocator        (GskVulkanDevice        *self);

gsk/gpu/gskvulkanframe.c

@@ -4,23 +4,13 @@
 
 #include "gskgpuopprivate.h"
 #include "gskvulkanbufferprivate.h"
-#include "gskvulkandescriptorsprivate.h"
 #include "gskvulkandeviceprivate.h"
 #include "gskvulkanimageprivate.h"
-#include "gskvulkanrealdescriptorsprivate.h"
-#include "gskvulkansubdescriptorsprivate.h"
 
 #include "gdk/gdkdmabuftextureprivate.h"
 #include "gdk/gdkglcontextprivate.h"
 #include "gdk/gdkgltextureprivate.h"
 
-#define GDK_ARRAY_NAME gsk_descriptors
-#define GDK_ARRAY_TYPE_NAME GskDescriptors
-#define GDK_ARRAY_ELEMENT_TYPE GskVulkanRealDescriptors *
-#define GDK_ARRAY_FREE_FUNC g_object_unref
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
 #define GDK_ARRAY_NAME gsk_semaphores
 #define GDK_ARRAY_TYPE_NAME GskSemaphores
 #define GDK_ARRAY_ELEMENT_TYPE VkSemaphore
@@ -49,9 +39,6 @@ struct _GskVulkanFrame
   VkSemaphore vk_acquire_semaphore;
   VkFence vk_fence;
   VkCommandBuffer vk_command_buffer;
-  VkDescriptorPool vk_descriptor_pool;
-
-  GskDescriptors descriptors;
 
   gsize pool_n_sets;
   gsize pool_n_images;
@@ -151,15 +138,6 @@ gsk_vulkan_frame_cleanup (GskGpuFrame *frame)
   GSK_VK_CHECK (vkResetCommandBuffer, self->vk_command_buffer,
                                       0);
 
-  if (self->vk_descriptor_pool != VK_NULL_HANDLE)
-    {
-      GSK_VK_CHECK (vkResetDescriptorPool, vk_device,
-                                           self->vk_descriptor_pool,
-                                           0);
-    }
-
-  gsk_descriptors_set_size (&self->descriptors, 0);
-
   GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->cleanup (frame);
 }
 
@@ -237,115 +215,6 @@ gsk_vulkan_frame_upload_texture (GskGpuFrame  *frame,
   return GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->upload_texture (frame, with_mipmap, texture);
 }
 
-static void
-gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self)
-{
-  GskVulkanDevice *device;
-  VkDevice vk_device;
-  gsize i, n_images, n_buffers, n_sets;
-
-  device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self)));
-  vk_device = gsk_vulkan_device_get_vk_device (device);
-
-  n_images = 0;
-  n_buffers = 0;
-  n_sets = 2 * gsk_descriptors_get_size (&self->descriptors);
-  for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++)
-    {
-      gsize n_desc_images, n_desc_buffers;
-      GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i);
-      gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images, &n_desc_buffers);
-      n_images += n_desc_images;
-      n_buffers += n_desc_buffers;
-    }
-
-  if (n_sets > self->pool_n_sets ||
-      n_images > self->pool_n_images ||
-      n_buffers > self->pool_n_buffers)
-    {
-      if (self->vk_descriptor_pool != VK_NULL_HANDLE)
-        {
-          vkDestroyDescriptorPool (vk_device,
-                                   self->vk_descriptor_pool,
-                                   NULL);
-          self->vk_descriptor_pool = VK_NULL_HANDLE;
-        }
-      if (n_sets > self->pool_n_sets)
-        self->pool_n_sets = 4 << g_bit_nth_msf (n_sets - 1, -1);
-      if (n_images > self->pool_n_images)
-        self->pool_n_images = 2 << g_bit_nth_msf (n_images - 1, -1);
-      if (n_buffers > self->pool_n_buffers)
-        self->pool_n_buffers = 4 << g_bit_nth_msf (n_buffers - 1, -1);
-    }
-
-  if (self->vk_descriptor_pool == VK_NULL_HANDLE)
-    {
-      GSK_VK_CHECK (vkCreateDescriptorPool, vk_device,
-                                            &(VkDescriptorPoolCreateInfo) {
-                                                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-                                                .flags = 0,
-                                                .maxSets = self->pool_n_sets,
-                                                .poolSizeCount = 2,
-                                                .pPoolSizes = (VkDescriptorPoolSize[2]) {
-                                                    {
-                                                        .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-                                                        .descriptorCount = self->pool_n_images,
-                                                    },
-                                                    {
-                                                        .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-                                                        .descriptorCount = self->pool_n_buffers,
-                                                    }
-                                                }
-                                            },
-                                            NULL,
-                                            &self->vk_descriptor_pool);
-    }
-
-  for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++)
-    {
-      GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i);
-
-      gsk_vulkan_real_descriptors_update_sets (desc, self->vk_descriptor_pool);
-    }
-}
-
-static GskGpuDescriptors *
-gsk_vulkan_frame_create_descriptors (GskGpuFrame *frame)
-{
-  GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
-
-  if (gsk_vulkan_device_has_feature (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING))
-    {
-      GskVulkanRealDescriptors *parent;
-
-      if (gsk_descriptors_get_size (&self->descriptors) > 0)
-        {
-          parent = gsk_descriptors_get (&self->descriptors, gsk_descriptors_get_size (&self->descriptors) - 1);
-          if (gsk_vulkan_real_descriptors_is_full (parent))
-            parent = NULL;
-        }
-      else
-        parent = NULL;
-
-      if (parent == NULL)
-        {
-          parent = gsk_vulkan_real_descriptors_new (self);
-          gsk_descriptors_append (&self->descriptors, parent);
-        }
-
-      return GSK_GPU_DESCRIPTORS (gsk_vulkan_sub_descriptors_new (GSK_VULKAN_DESCRIPTORS (parent)));
-    }
-  else
-    {
-      GskVulkanRealDescriptors *desc;
-
-      desc = gsk_vulkan_real_descriptors_new (self);
-      gsk_descriptors_append (&self->descriptors, desc);
-
-      return GSK_GPU_DESCRIPTORS (g_object_ref (desc));
-    }
-}
-
 static GskGpuBuffer *
 gsk_vulkan_frame_create_vertex_buffer (GskGpuFrame *frame,
                                        gsize        size)
@@ -360,6 +229,15 @@ gsk_vulkan_frame_create_storage_buffer (GskGpuFrame *frame,
   return gsk_vulkan_buffer_new_storage (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), size);
 }
 
+static void
+gsk_vulkan_frame_write_texture_vertex_data (GskGpuFrame    *self,
+                                            guchar         *data,
+                                            GskGpuImage   **images,
+                                            GskGpuSampler  *samplers,
+                                            gsize           n_images)
+{
+}
+
 static void
 gsk_vulkan_frame_submit (GskGpuFrame       *frame,
                          GskRenderPassType  pass_type,
@@ -368,12 +246,7 @@ gsk_vulkan_frame_submit (GskGpuFrame       *frame,
 {
   GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
   GskVulkanSemaphores semaphores;
-  GskVulkanCommandState state;
-
-  if (gsk_descriptors_get_size (&self->descriptors) == 0)
-    gsk_descriptors_append (&self->descriptors, gsk_vulkan_real_descriptors_new (self));
-
-  gsk_vulkan_frame_prepare_descriptors (self);
+  GskVulkanCommandState state = { 0, };
 
   GSK_VK_CHECK (vkBeginCommandBuffer, self->vk_command_buffer,
                                       &(VkCommandBufferBeginInfo) {
@@ -405,13 +278,8 @@ gsk_vulkan_frame_submit (GskGpuFrame       *frame,
   state.vk_render_pass = VK_NULL_HANDLE;
   state.vk_format = VK_FORMAT_UNDEFINED;
   state.blend = GSK_GPU_BLEND_OVER; /* should we have a BLEND_NONE? */
-  state.desc = GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0));
   state.semaphores = &semaphores;
 
-  gsk_vulkan_descriptors_bind (GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0)),
-                               NULL,
-                               state.vk_command_buffer);
-
   while (op)
     {
       op = gsk_gpu_op_vk_command (op, frame, &state);
@@ -450,14 +318,6 @@ gsk_vulkan_frame_finalize (GObject *object)
   vk_device = gsk_vulkan_device_get_vk_device (device);
   vk_command_pool = gsk_vulkan_device_get_vk_command_pool (device);
 
-  if (self->vk_descriptor_pool != VK_NULL_HANDLE)
-    {
-      vkDestroyDescriptorPool (vk_device,
-                               self->vk_descriptor_pool,
-                               NULL);
-    }
-  gsk_descriptors_clear (&self->descriptors);
-
   vkFreeCommandBuffers (vk_device,
                         vk_command_pool,
                         1, &self->vk_command_buffer);
@@ -483,9 +343,9 @@ gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass)
   gpu_frame_class->cleanup = gsk_vulkan_frame_cleanup;
   gpu_frame_class->begin = gsk_vulkan_frame_begin;
   gpu_frame_class->upload_texture = gsk_vulkan_frame_upload_texture;
-  gpu_frame_class->create_descriptors = gsk_vulkan_frame_create_descriptors;
   gpu_frame_class->create_vertex_buffer = gsk_vulkan_frame_create_vertex_buffer;
   gpu_frame_class->create_storage_buffer = gsk_vulkan_frame_create_storage_buffer;
+  gpu_frame_class->write_texture_vertex_data = gsk_vulkan_frame_write_texture_vertex_data;
   gpu_frame_class->submit = gsk_vulkan_frame_submit;
 
   object_class->finalize = gsk_vulkan_frame_finalize;
@@ -494,8 +354,6 @@ gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass)
 static void
 gsk_vulkan_frame_init (GskVulkanFrame *self)
 {
-  gsk_descriptors_init (&self->descriptors);
-
   self->pool_n_sets = 4;
   self->pool_n_images = 8;
   self->pool_n_buffers = 8;

gsk/gpu/gskvulkanimage.c

@@ -5,6 +5,7 @@
 #include "gskvulkanbufferprivate.h"
 #include "gskvulkanframeprivate.h"
 #include "gskvulkanmemoryprivate.h"
+#include "gskvulkanycbcrprivate.h"
 
 #include "gdk/gdkdisplayprivate.h"
 #include "gdk/gdkdmabuftextureprivate.h"
@@ -31,8 +32,12 @@ struct _GskVulkanImage
   VkImageView vk_image_view;
   VkFramebuffer vk_framebuffer;
   VkImageView vk_framebuffer_image_view;
-  VkSampler vk_sampler;
+  GskVulkanYcbcr *ycbcr;
   VkSemaphore vk_semaphore;
+  struct {
+    VkDescriptorSet vk_descriptor_set;
+    gsize pool_id;
+  } descriptor_sets[GSK_GPU_SAMPLER_N_SAMPLERS];
 
   VkPipelineStageFlags vk_pipeline_stage;
   VkImageLayout vk_image_layout;
@@ -1114,7 +1119,11 @@ gsk_vulkan_image_new_for_dmabuf (GskVulkanDevice *device,
 #endif
 
   if (is_yuv)
-    vk_conversion = gsk_vulkan_device_get_vk_conversion (device, vk_format, &self->vk_sampler);
+    {
+      self->ycbcr = gsk_vulkan_device_get_ycbcr (device, vk_format);
+      gsk_vulkan_ycbcr_ref (self->ycbcr);
+      vk_conversion = gsk_vulkan_ycbcr_get_vk_conversion (self->ycbcr);
+    }
   else
     vk_conversion = VK_NULL_HANDLE;
 
@@ -1283,9 +1292,20 @@ gsk_vulkan_image_finalize (GObject *object)
 {
   GskVulkanImage *self = GSK_VULKAN_IMAGE (object);
   VkDevice vk_device;
+  gsize i;
 
   vk_device = gsk_vulkan_device_get_vk_device (self->device);
 
+  g_clear_pointer (&self->ycbcr, gsk_vulkan_ycbcr_unref);
+
+  for (i = 0; i < GSK_GPU_SAMPLER_N_SAMPLERS; i++)
+    {
+      if (self->descriptor_sets[i].vk_descriptor_set)
+        gsk_vulkan_device_free_descriptor (self->device,
+                                           self->descriptor_sets[i].pool_id,
+                                           self->descriptor_sets[i].vk_descriptor_set);
+    }
+
   if (self->vk_framebuffer != VK_NULL_HANDLE)
     vkDestroyFramebuffer (vk_device, self->vk_framebuffer, NULL);
 
@@ -1382,10 +1402,45 @@ gsk_vulkan_image_get_vk_framebuffer (GskVulkanImage *self,
   return self->vk_framebuffer;
 }
 
-VkSampler
-gsk_vulkan_image_get_vk_sampler (GskVulkanImage *self)
+VkDescriptorSet
+gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self,
+                                        GskGpuSampler   sampler)
 {
-  return self->vk_sampler;
+  if (!self->descriptor_sets[sampler].vk_descriptor_set)
+    {
+      self->descriptor_sets[sampler].vk_descriptor_set =
+        gsk_vulkan_device_allocate_descriptor (self->device,
+                                               self->ycbcr ? gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (self->ycbcr)
+                                                           : gsk_vulkan_device_get_vk_image_set_layout (self->device),
+                                               &self->descriptor_sets[sampler].pool_id);
+
+      vkUpdateDescriptorSets (gsk_vulkan_device_get_vk_device (self->device),
+                              1,
+                              &(VkWriteDescriptorSet) {
+                                  .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                                  .dstSet = self->descriptor_sets[sampler].vk_descriptor_set,
+                                  .dstBinding = 0,
+                                  .dstArrayElement = 0,
+                                  .descriptorCount = 1,
+                                  .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                  .pImageInfo = &(VkDescriptorImageInfo) {
+                                      .sampler = self->ycbcr ? gsk_vulkan_ycbcr_get_vk_sampler (self->ycbcr)
+                                                             : gsk_vulkan_device_get_vk_sampler (self->device, sampler),
+                                      .imageView = self->vk_image_view,
+                                      .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+                                  },
+                              },
+                              0,
+                              NULL);
+    }
+
+  return self->descriptor_sets[sampler].vk_descriptor_set;
+}
+
+GskVulkanYcbcr *
+gsk_vulkan_image_get_ycbcr (GskVulkanImage *self)
+{
+  return self->ycbcr;
 }
 
 VkImage

gsk/gpu/gskvulkanimageprivate.h

@@ -50,7 +50,9 @@ GdkTexture *            gsk_vulkan_image_to_dmabuf_texture              (GskVulk
 guchar *                gsk_vulkan_image_get_data                       (GskVulkanImage         *self,
                                                                          gsize                  *out_stride);
 
-VkSampler               gsk_vulkan_image_get_vk_sampler                 (GskVulkanImage         *self);
+GskVulkanYcbcr *        gsk_vulkan_image_get_ycbcr                      (GskVulkanImage         *self);
+VkDescriptorSet         gsk_vulkan_image_get_vk_descriptor_set          (GskVulkanImage         *self,
+                                                                         GskGpuSampler           sampler);
 VkPipelineStageFlags    gsk_vulkan_image_get_vk_pipeline_stage          (GskVulkanImage         *self);
 VkImageLayout           gsk_vulkan_image_get_vk_image_layout            (GskVulkanImage         *self);
 VkAccessFlags           gsk_vulkan_image_get_vk_access                  (GskVulkanImage         *self);

gsk/gpu/gskvulkanrealdescriptors.c

@@ -1,378 +0,0 @@
-#include "config.h"
-
-#include "gskvulkanrealdescriptorsprivate.h"
-
-#include "gskgpucacheprivate.h"
-#include "gskvulkanbufferprivate.h"
-#include "gskvulkanframeprivate.h"
-#include "gskvulkanimageprivate.h"
-
-#define GDK_ARRAY_NAME gsk_descriptor_image_infos
-#define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos
-#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorImageInfo
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 128
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-#define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
-#define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
-#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 32
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-#define GDK_ARRAY_NAME gsk_samplers
-#define GDK_ARRAY_TYPE_NAME GskSamplers
-#define GDK_ARRAY_ELEMENT_TYPE VkSampler
-#define GDK_ARRAY_PREALLOC 32
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-struct _GskVulkanRealDescriptors
-{
-  GskVulkanDescriptors parent_instance;
-
-  GskVulkanFrame *frame; /* no reference, the frame owns us */
-
-  GskVulkanPipelineLayout *pipeline_layout;
-
-  GskSamplers immutable_samplers;
-  GskDescriptorImageInfos descriptor_immutable_images;
-  GskDescriptorImageInfos descriptor_images;
-  GskDescriptorBufferInfos descriptor_buffers;
-
-  VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS];
-};
-
-G_DEFINE_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS)
-
-static GskVulkanPipelineLayout *
-gsk_vulkan_real_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc)
-{
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
-
-  return self->pipeline_layout;
-}
-
-static void
-gsk_vulkan_real_descriptors_bind (GskVulkanDescriptors *desc,
-                                  GskVulkanDescriptors *previous,
-                                  VkCommandBuffer       vk_command_buffer)
-{
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
-
-  if (desc == previous)
-    return;
-
-  vkCmdBindDescriptorSets (vk_command_buffer,
-                           VK_PIPELINE_BIND_POINT_GRAPHICS,
-                           gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
-                                                                     self->pipeline_layout),
-                           0,
-                           G_N_ELEMENTS (self->descriptor_sets),
-                           self->descriptor_sets,
-                           0,
-                           NULL);
-}
-
-static gboolean
-gsk_vulkan_real_descriptors_add_image (GskGpuDescriptors *desc,
-                                       GskGpuImage       *image,
-                                       GskGpuSampler      sampler,
-                                       guint32            *out_descriptor)
-{
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
-  GskVulkanImage *vulkan_image = GSK_VULKAN_IMAGE (image);
-  GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
-  VkSampler vk_sampler;
-  guint32 result;
-
-  vk_sampler = gsk_vulkan_image_get_vk_sampler (vulkan_image);
-
-  if (vk_sampler)
-    {
-      if (gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >=
-          gsk_vulkan_device_get_max_immutable_samplers (device))
-        return FALSE;
-      if ((1 + gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) * 3 +
-          gsk_descriptor_image_infos_get_size (&self->descriptor_images) >
-          gsk_vulkan_device_get_max_samplers (device))
-        return FALSE;
-
-      result = gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) << 1 | 1;
-
-      gsk_samplers_append (&self->immutable_samplers, vk_sampler);
-      gsk_descriptor_image_infos_append (&self->descriptor_immutable_images,
-                                         &(VkDescriptorImageInfo) {
-                                           .imageView = gsk_vulkan_image_get_vk_image_view (vulkan_image),
-                                           .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
-                                         });
-    }
-  else
-    {
-      if (MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) +
-          gsk_descriptor_image_infos_get_size (&self->descriptor_images) >=
-          gsk_vulkan_device_get_max_samplers (device))
-        return FALSE;
-
-      result = gsk_descriptor_image_infos_get_size (&self->descriptor_images) << 1;
-
-      gsk_descriptor_image_infos_append (&self->descriptor_images,
-                                         &(VkDescriptorImageInfo) {
-                                           .sampler = gsk_vulkan_device_get_vk_sampler (device, sampler),
-                                           .imageView = gsk_vulkan_image_get_vk_image_view (vulkan_image),
-                                           .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
-                                         });
-    }
-
-  *out_descriptor = result;
-  return TRUE;
-}
-
-static gboolean
-gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc,
-                                        GskGpuBuffer      *buffer,
-                                        guint32           *out_descriptor)
-{
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
-  GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
-
-  if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >=
-      gsk_vulkan_device_get_max_buffers (device))
-    return FALSE;
-
-  *out_descriptor = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers);
-  gsk_descriptor_buffer_infos_append (&self->descriptor_buffers,
-                                      &(VkDescriptorBufferInfo) {
-                                        .buffer = gsk_vulkan_buffer_get_vk_buffer (GSK_VULKAN_BUFFER (buffer)),
-                                        .offset = 0,
-                                        .range = VK_WHOLE_SIZE
-                                      });
-
-  return TRUE;
-}
-
-static void
-gsk_vulkan_real_descriptors_finalize (GObject *object)
-{
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (object);
-
-  gsk_samplers_clear (&self->immutable_samplers);
-  gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images);
-  gsk_descriptor_image_infos_clear (&self->descriptor_images);
-  gsk_descriptor_buffer_infos_clear (&self->descriptor_buffers);
-
-  gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
-                                             self->pipeline_layout);
-
-  G_OBJECT_CLASS (gsk_vulkan_real_descriptors_parent_class)->finalize (object);
-}
-
-static void
-gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass)
-{
-  GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass);
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_vulkan_real_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_vulkan_real_descriptors_add_buffer;
-
-  vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout;
-  vulkan_descriptors_class->bind = gsk_vulkan_real_descriptors_bind;
-}
-
-static void
-gsk_vulkan_real_descriptors_init (GskVulkanRealDescriptors *self)
-{
-  gsk_samplers_init (&self->immutable_samplers);
-  gsk_descriptor_image_infos_init (&self->descriptor_immutable_images);
-  gsk_descriptor_image_infos_init (&self->descriptor_images);
-  gsk_descriptor_buffer_infos_init (&self->descriptor_buffers);
-}
-
-GskVulkanRealDescriptors *
-gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame)
-{
-  GskVulkanRealDescriptors *self;
-
-  self = g_object_new (GSK_TYPE_VULKAN_REAL_DESCRIPTORS, NULL);
-
-  self->frame = frame;
-
-  return self;
-}
-
-gboolean
-gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self)
-{
-  GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
-
-  return gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >= gsk_vulkan_device_get_max_immutable_samplers (device) ||
-         gsk_descriptor_image_infos_get_size (&self->descriptor_images) +
-         MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) >=
-         gsk_vulkan_device_get_max_samplers (device) ||
-         gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >= gsk_vulkan_device_get_max_buffers (device);
-}
-
-static void
-gsk_vulkan_real_descriptors_fill_sets (GskVulkanRealDescriptors *self)
-{
-  gsize n_immutable_samplers, n_samplers, n_buffers;
-  GskVulkanDevice *device;
-
-  device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
-
-  if (gsk_vulkan_device_has_feature (device, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING))
-    return;
-
-  /* If descriptor indexing isn't supported, all descriptors in the shaders
-   * must be properly setup. And that means we need to have
-   * descriptors for all of them.
-   */
-  gsk_vulkan_device_get_pipeline_sizes (device,
-                                        self->pipeline_layout,
-                                        &n_immutable_samplers,
-                                        &n_samplers,
-                                        &n_buffers);
-
-  if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) == 0)
-    {
-      /* We have no image, find any random image and attach it */
-      guint32 ignored;
-
-      if (!gsk_gpu_descriptors_add_image (GSK_GPU_DESCRIPTORS (self),
-                                          gsk_gpu_cache_get_atlas_image (gsk_gpu_device_get_cache (GSK_GPU_DEVICE (device))),
-                                          GSK_GPU_SAMPLER_DEFAULT,
-                                          &ignored))
-        {
-          g_assert_not_reached ();
-        }
-    }
-  while (MAX (1, n_immutable_samplers) > gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images))
-    {
-      gsk_descriptor_image_infos_append (&self->descriptor_immutable_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0));
-    }
-  while (n_samplers - MAX (1, 3 * n_immutable_samplers) > gsk_descriptor_image_infos_get_size (&self->descriptor_images))
-    {
-      gsk_descriptor_image_infos_append (&self->descriptor_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0));
-    }
-  if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) == 0)
-    {
-      /* If there's no storage buffer yet, just make one */
-      GskGpuBuffer *buffer;
-      gsize ignored_offset;
-      guint32 ignored;
-
-      buffer = gsk_gpu_frame_write_storage_buffer (GSK_GPU_FRAME (self->frame), NULL, 0, &ignored_offset);
-      if (!gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self),
-                                           buffer,
-                                           &ignored))
-        {
-          g_assert_not_reached ();
-        }
-    }
-  while (n_buffers > gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers))
-    {
-      gsk_descriptor_buffer_infos_append (&self->descriptor_buffers, gsk_descriptor_buffer_infos_get (&self->descriptor_buffers, 0));
-    }
-}
-
-void
-gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self,
-                                     gsize                    *n_images,
-                                     gsize                    *n_buffers)
-{
-  self->pipeline_layout = gsk_vulkan_device_acquire_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
-                                                                     gsk_samplers_get_data (&self->immutable_samplers),
-                                                                     gsk_samplers_get_size (&self->immutable_samplers),
-                                                                     gsk_descriptor_image_infos_get_size (&self->descriptor_images),
-                                                                     gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers));
-  gsk_vulkan_real_descriptors_fill_sets (self);
-
-  *n_images = MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) +
-              gsk_descriptor_image_infos_get_size (&self->descriptor_images);
-  *n_buffers = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers);
-}
-
-void
-gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self,
-                                         VkDescriptorPool          vk_descriptor_pool)
-{
-  VkWriteDescriptorSet write_descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS + 1];
-  gsize n_descriptor_sets;
-  VkDevice vk_device;
-  gboolean descriptor_indexing;
-  GskVulkanDevice *device;
-
-  device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame)));
-  descriptor_indexing = gsk_vulkan_device_has_feature (device, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING);
-  vk_device = gsk_vulkan_device_get_vk_device (device);
-
-  GSK_VK_CHECK (vkAllocateDescriptorSets, vk_device,
-                                          &(VkDescriptorSetAllocateInfo) {
-                                              .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
-                                              .descriptorPool = vk_descriptor_pool,
-                                              .descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS,
-                                              .pSetLayouts = (VkDescriptorSetLayout[GSK_VULKAN_N_DESCRIPTOR_SETS]) {
-                                                gsk_vulkan_device_get_vk_image_set_layout (device, self->pipeline_layout),
-                                                gsk_vulkan_device_get_vk_buffer_set_layout (device, self->pipeline_layout),
-                                              },
-                                              .pNext = !descriptor_indexing ? NULL : &(VkDescriptorSetVariableDescriptorCountAllocateInfo) {
-                                                .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
-                                                .descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS,
-                                                .pDescriptorCounts = (uint32_t[GSK_VULKAN_N_DESCRIPTOR_SETS]) {
-                                                  gsk_descriptor_image_infos_get_size (&self->descriptor_images),
-                                                  gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers)
-                                                }
-                                              }
-                                          },
-                                          self->descriptor_sets);
-
-  n_descriptor_sets = 0;
-  if (gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) > 0)
-    {
-      write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
-          .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[GSK_VULKAN_IMAGE_SET_LAYOUT],
-          .dstBinding = 0,
-          .dstArrayElement = 0,
-          .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images),
-          .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-          .pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_immutable_images)
-      };
-    }
-  if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) > 0)
-    {
-      write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
-          .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[GSK_VULKAN_IMAGE_SET_LAYOUT],
-          .dstBinding = 1,
-          .dstArrayElement = 0,
-          .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_images),
-          .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-          .pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_images)
-      };
-    }
-  if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) > 0)
-    {
-      write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
-          .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-          .dstSet = self->descriptor_sets[GSK_VULKAN_BUFFER_SET_LAYOUT],
-          .dstBinding = 0,
-          .dstArrayElement = 0,
-          .descriptorCount = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers),
-          .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-          .pBufferInfo = gsk_descriptor_buffer_infos_get_data (&self->descriptor_buffers)
-      };
-    }
-
-  vkUpdateDescriptorSets (vk_device,
-                          n_descriptor_sets,
-                          write_descriptor_sets,
-                          0, NULL);
-}

gsk/gpu/gskvulkanrealdescriptorsprivate.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "gskvulkandescriptorsprivate.h"
-#include "gskvulkanframeprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_VULKAN_REAL_DESCRIPTORS (gsk_vulkan_real_descriptors_get_type ())
-
-G_DECLARE_FINAL_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK, VULKAN_REAL_DESCRIPTORS, GskVulkanDescriptors)
-
-GskVulkanRealDescriptors *      gsk_vulkan_real_descriptors_new                 (GskVulkanFrame                 *frame);
-
-gboolean                        gsk_vulkan_real_descriptors_is_full             (GskVulkanRealDescriptors       *self);
-
-void                            gsk_vulkan_real_descriptors_prepare             (GskVulkanRealDescriptors       *self,
-                                                                                 gsize                          *n_images,
-                                                                                 gsize                          *n_buffers);
-void                            gsk_vulkan_real_descriptors_update_sets         (GskVulkanRealDescriptors       *self,
-                                                                                 VkDescriptorPool                vk_descriptor_pool);
-
-G_END_DECLS
-

gsk/gpu/gskvulkansubdescriptors.c

@@ -1,106 +0,0 @@
-#include "config.h"
-
-#include "gskvulkansubdescriptorsprivate.h"
-
-struct _GskVulkanSubDescriptors
-{
-  GskVulkanDescriptors parent_instance;
-
-  GskVulkanDescriptors *parent;
-};
-
-G_DEFINE_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS)
-
-static GskVulkanPipelineLayout *
-gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc)
-{
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
-
-  return gsk_vulkan_descriptors_get_pipeline_layout (self->parent);
-}
-
-static void
-gsk_vulkan_sub_descriptors_bind (GskVulkanDescriptors *desc,
-                                 GskVulkanDescriptors *previous,
-                                 VkCommandBuffer       vk_command_buffer)
-{
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
-
-  if (GSK_IS_VULKAN_SUB_DESCRIPTORS (previous))
-    previous = GSK_VULKAN_SUB_DESCRIPTORS (previous)->parent;
-
-  if (self->parent == previous)
-    return;
-
-  gsk_vulkan_descriptors_bind (self->parent, previous, vk_command_buffer);
-}
-
-static gboolean
-gsk_vulkan_sub_descriptors_add_image (GskGpuDescriptors *desc,
-                                      GskGpuImage       *image,
-                                      GskGpuSampler      sampler,
-                                      guint32           *out_descriptor)
-{
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
-
-  return gsk_gpu_descriptors_add_image (GSK_GPU_DESCRIPTORS (self->parent),
-                                        image,
-                                        sampler,
-                                        out_descriptor);
-}
-
-static gboolean
-gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
-                                       GskGpuBuffer      *buffer,
-                                       guint32           *out_descriptor)
-{
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
-
-  return gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self->parent),
-                                         buffer,
-                                         out_descriptor);
-}
-
-static void
-gsk_vulkan_sub_descriptors_finalize (GObject *object)
-{
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (object);
-
-  g_object_unref (self->parent);
-
-  G_OBJECT_CLASS (gsk_vulkan_sub_descriptors_parent_class)->finalize (object);
-}
-
-static void
-gsk_vulkan_sub_descriptors_class_init (GskVulkanSubDescriptorsClass *klass)
-{
-  GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass);
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-  object_class->finalize = gsk_vulkan_sub_descriptors_finalize;
-
-  descriptors_class->add_image = gsk_vulkan_sub_descriptors_add_image;
-  descriptors_class->add_buffer = gsk_vulkan_sub_descriptors_add_buffer;
-
-  vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout;
-  vulkan_descriptors_class->bind = gsk_vulkan_sub_descriptors_bind;
-}
-
-static void
-gsk_vulkan_sub_descriptors_init (GskVulkanSubDescriptors *self)
-{
-}
-
-GskVulkanSubDescriptors *
-gsk_vulkan_sub_descriptors_new (GskVulkanDescriptors *parent)
-{
-  GskVulkanSubDescriptors *self;
-
-  self = g_object_new (GSK_TYPE_VULKAN_SUB_DESCRIPTORS, NULL);
-
-  self->parent = g_object_ref (parent);
-
-  return self;
-}
-

gsk/gpu/gskvulkansubdescriptorsprivate.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include "gskvulkandescriptorsprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_VULKAN_SUB_DESCRIPTORS (gsk_vulkan_sub_descriptors_get_type ())
-
-G_DECLARE_FINAL_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK, VULKAN_SUB_DESCRIPTORS, GskVulkanDescriptors)
-
-GskVulkanSubDescriptors *       gsk_vulkan_sub_descriptors_new          (GskVulkanDescriptors           *parent);
-
-G_END_DECLS
-

gsk/gpu/gskvulkanycbcr.c

@@ -0,0 +1,203 @@
+#include "config.h"
+
+#include "gskvulkanycbcrprivate.h"
+
+#include "gskgpucacheprivate.h"
+
+struct _GskVulkanYcbcr
+{
+  GskGpuCached parent;
+
+  int ref_count;
+
+  VkFormat vk_format;
+  VkSamplerYcbcrConversion vk_conversion;
+  VkSampler vk_sampler;
+  VkDescriptorSetLayout vk_descriptor_set_layout;
+  VkPipelineLayout vk_pipeline_layouts[2];
+};
+
+static void
+gsk_vulkan_ycbcr_free (GskGpuCache  *cache,
+                       GskGpuCached *cached)
+{
+  GskVulkanYcbcr *self = (GskVulkanYcbcr *) cached;
+  GskVulkanDevice *device;
+  VkDevice vk_device;
+
+  device = GSK_VULKAN_DEVICE (gsk_gpu_cache_get_device (cache));
+  vk_device = gsk_vulkan_device_get_vk_device (device);
+
+  g_assert (self->ref_count == 0);
+
+  gsk_vulkan_device_remove_ycbcr (device, self->vk_format);
+
+  vkDestroySampler (vk_device, self->vk_sampler, NULL);
+  vkDestroySamplerYcbcrConversion (vk_device, self->vk_conversion, NULL);
+  vkDestroyDescriptorSetLayout (vk_device, self->vk_descriptor_set_layout, NULL);
+  vkDestroyPipelineLayout (vk_device, self->vk_pipeline_layouts[0], NULL);
+  vkDestroyPipelineLayout (vk_device, self->vk_pipeline_layouts[1], NULL);
+
+  g_free (self);
+}
+
+static inline gboolean
+gsk_gpu_cached_is_old (GskGpuCache  *self,
+                       GskGpuCached *cached,
+                       gint64        cache_timeout,
+                       gint64        timestamp)
+{
+  if (cache_timeout < 0)
+    return -1;
+  else
+    return timestamp - cached->timestamp > cache_timeout;
+}
+
+static gboolean
+gsk_vulkan_ycbcr_should_collect (GskGpuCache  *cache,
+                                 GskGpuCached *cached,
+                                 gint64        cache_timeout,
+                                 gint64        timestamp)
+{
+  GskVulkanYcbcr *self = (GskVulkanYcbcr *) cached;
+
+  if (self->ref_count > 0)
+    return FALSE;
+
+  return gsk_gpu_cached_is_old (cache, cached, cache_timeout, timestamp);
+}
+
+static const GskGpuCachedClass GSK_VULKAN_YCBCR_CLASS =
+{
+  sizeof (GskVulkanYcbcr),
+  "Vulkan Ycbcr",
+  gsk_vulkan_ycbcr_free,
+  gsk_vulkan_ycbcr_should_collect
+};
+
+GskVulkanYcbcr *
+gsk_vulkan_ycbcr_new (GskVulkanDevice *device,
+                      VkFormat         vk_format)
+{
+  GskGpuCache *cache = gsk_gpu_device_get_cache (GSK_GPU_DEVICE (device));
+  VkDevice vk_device = gsk_vulkan_device_get_vk_device (device);
+  VkDescriptorSetLayout vk_image_set_layout;
+  GskVulkanYcbcr *self;
+
+  self = gsk_gpu_cached_new (cache, &GSK_VULKAN_YCBCR_CLASS);
+
+  self->vk_format = vk_format;
+
+  GSK_VK_CHECK (vkCreateSamplerYcbcrConversion, vk_device,
+                                                &(VkSamplerYcbcrConversionCreateInfo) {
+                                                    .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+                                                    .format = vk_format,
+                                                    .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+                                                    .ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+                                                    .components = (VkComponentMapping) {
+                                                        VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                        VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                        VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                        VK_COMPONENT_SWIZZLE_IDENTITY
+                                                    },
+                                                    .xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN,
+                                                    .yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN,
+                                                    .chromaFilter = VK_FILTER_LINEAR,
+                                                    .forceExplicitReconstruction = VK_FALSE
+                                                },
+                                                NULL,
+                                                &self->vk_conversion);
+
+  GSK_VK_CHECK (vkCreateSampler, vk_device,
+                                 &(VkSamplerCreateInfo) {
+                                     .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+                                     .magFilter = VK_FILTER_LINEAR,
+                                     .minFilter = VK_FILTER_LINEAR,
+                                     .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+                                     .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+                                     .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+                                     .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
+                                     .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+                                     .unnormalizedCoordinates = VK_FALSE,
+                                     .maxAnisotropy = 1.0,
+                                     .minLod = 0.0,
+                                     .maxLod = 0.0f,
+                                     .pNext = &(VkSamplerYcbcrConversionInfo) {
+                                         .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+                                         .conversion = self->vk_conversion
+                                     }
+                                 },
+                                 NULL,
+                                 &self->vk_sampler);
+
+  GSK_VK_CHECK (vkCreateDescriptorSetLayout, vk_device,
+                                             &(VkDescriptorSetLayoutCreateInfo) {
+                                                 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+                                                 .bindingCount = 1,
+                                                 .flags = 0,
+                                                 .pBindings = (VkDescriptorSetLayoutBinding[1]) {
+                                                     {
+                                                         .binding = 0,
+                                                         .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                                                         .descriptorCount = 1,
+                                                         .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+                                                         .pImmutableSamplers = (VkSampler[1]) {
+                                                             self->vk_sampler,
+                                                         },
+                                                     }
+                                                 },
+                                             },
+                                             NULL,
+                                             &self->vk_descriptor_set_layout);
+
+  vk_image_set_layout = gsk_vulkan_device_get_vk_image_set_layout (device);
+  self->vk_pipeline_layouts[0] = gsk_vulkan_device_create_vk_pipeline_layout (device,
+                                                                              self->vk_descriptor_set_layout,
+                                                                              vk_image_set_layout);
+  self->vk_pipeline_layouts[1] = gsk_vulkan_device_create_vk_pipeline_layout (device,
+                                                                              vk_image_set_layout,
+                                                                              self->vk_descriptor_set_layout);
+
+  return self;
+}
+
+GskVulkanYcbcr *
+gsk_vulkan_ycbcr_ref (GskVulkanYcbcr *self)
+{
+  self->ref_count++;
+
+  return self;
+}
+
+void
+gsk_vulkan_ycbcr_unref (GskVulkanYcbcr *self)
+{
+  self->ref_count--;
+}
+
+VkSamplerYcbcrConversion
+gsk_vulkan_ycbcr_get_vk_conversion (GskVulkanYcbcr *self)
+{
+  return self->vk_conversion;
+}
+
+VkSampler
+gsk_vulkan_ycbcr_get_vk_sampler (GskVulkanYcbcr *self)
+{
+  return self->vk_sampler;
+}
+
+VkDescriptorSetLayout
+gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (GskVulkanYcbcr *self)
+{
+  return self->vk_descriptor_set_layout;
+}
+
+VkPipelineLayout
+gsk_vulkan_ycbcr_get_vk_pipeline_layout (GskVulkanYcbcr  *self,
+                                         gsize            id)
+{
+  g_assert (id < 2);
+
+  return self->vk_pipeline_layouts[id];
+}

gsk/gpu/gskvulkanycbcrprivate.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "gskvulkandeviceprivate.h"
+
+#include "gdk/gdkvulkancontextprivate.h"
+
+G_BEGIN_DECLS
+
+GskVulkanYcbcr *        gsk_vulkan_ycbcr_new                            (GskVulkanDevice        *self,
+                                                                         VkFormat                vk_format);
+                                                                         
+GskVulkanYcbcr *        gsk_vulkan_ycbcr_ref                            (GskVulkanYcbcr         *self);
+void                    gsk_vulkan_ycbcr_unref                          (GskVulkanYcbcr         *self);
+
+VkSamplerYcbcrConversion
+                        gsk_vulkan_ycbcr_get_vk_conversion              (GskVulkanYcbcr         *self);
+VkSampler               gsk_vulkan_ycbcr_get_vk_sampler                 (GskVulkanYcbcr         *self);
+VkDescriptorSetLayout   gsk_vulkan_ycbcr_get_vk_descriptor_set_layout   (GskVulkanYcbcr         *self);
+VkPipelineLayout        gsk_vulkan_ycbcr_get_vk_pipeline_layout         (GskVulkanYcbcr         *self,
+                                                                         gsize                   id);
+
+
+G_END_DECLS

gsk/gpu/shaders/common-gl.glsl

@@ -17,23 +17,6 @@ uniform PushConstants
 #define GSK_GLOBAL_CLIP_RECT push.clip[0]
 #define GSK_GLOBAL_SCALE push.scale
 
-#if __VERSION__ < 420 || (defined(GSK_GLES) && __VERSION__ < 310)
-layout(std140)
-#else
-layout(std140, binding = 1)
-#endif
-uniform Floats
-{
-  vec4 really_just_floats[1024];
-} floats[11];
-
-#if N_EXTERNAL_TEXTURES > 0
-uniform samplerExternalOES external_textures[N_EXTERNAL_TEXTURES];
-#endif
-#if N_TEXTURES > 0
-uniform sampler2D textures[N_TEXTURES];
-#endif
-
 #define GSK_VERTEX_INDEX gl_VertexID
 
 
@@ -48,391 +31,23 @@ uniform sampler2D textures[N_TEXTURES];
 #define PASS(_loc) in
 #define PASS_FLAT(_loc) flat in
 
-float
-gsk_get_float (int id)
-{
-  int float_id = id & 0x3FFFFF;
-  int array_id = (id >> 22) & 0xFF;
-  switch (array_id)
-    {
-      case 0:
-        return floats[0].really_just_floats[float_id >> 2][float_id & 3];
-      case 1:
-        return floats[1].really_just_floats[float_id >> 2][float_id & 3];
-      case 2:
-        return floats[2].really_just_floats[float_id >> 2][float_id & 3];
-      case 3:
-        return floats[3].really_just_floats[float_id >> 2][float_id & 3];
-      case 4:
-        return floats[4].really_just_floats[float_id >> 2][float_id & 3];
-      case 5:
-        return floats[5].really_just_floats[float_id >> 2][float_id & 3];
-      case 6:
-        return floats[6].really_just_floats[float_id >> 2][float_id & 3];
-      case 7:
-        return floats[7].really_just_floats[float_id >> 2][float_id & 3];
-      case 8:
-        return floats[8].really_just_floats[float_id >> 2][float_id & 3];
-      case 9:
-        return floats[9].really_just_floats[float_id >> 2][float_id & 3];
-      case 10:
-        return floats[10].really_just_floats[float_id >> 2][float_id & 3];
-      default:
-        return 0.0;
-    }
-}
+#if GSK_N_TEXTURES > 0
 
-float
-gsk_get_float (uint id)
-{
-  return gsk_get_float (int (id));
-}
+#ifdef GSK_TEXTURE0_IS_EXTERNAL
+uniform samplerExternalOES GSK_TEXTURE0;
+#else
+uniform sampler2D GSK_TEXTURE0;
+#endif
 
-#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id)))
-#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id)))
+#if GSK_N_TEXTURES > 1
 
-#if __VERSION__ < 400 || defined(GSK_GLES)
+#ifdef GSK_TEXTURE1_IS_EXTERNAL
+uniform samplerExternalOES GSK_TEXTURE1;
+#else
+uniform sampler2D GSK_TEXTURE1;
+#endif
 
-vec4
-gsk_texture (uint id,
-             vec2 pos)
-{
-  if ((id & 1u) != 0u)
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_EXTERNAL_TEXTURES > 0
-          return texture (external_textures[0], pos);
 #endif
-#if N_EXTERNAL_TEXTURES > 1
-        case 1u:
-          return texture (external_textures[1], pos);
-#endif
-        case 2u:
-#if N_EXTERNAL_TEXTURES > 2
-          return texture (external_textures[2], pos);
-#endif
-        case 3u:
-#if N_EXTERNAL_TEXTURES > 3
-          return texture (external_textures[3], pos);
-#endif
-        case 4u:
-#if N_EXTERNAL_TEXTURES > 4
-          return texture (external_textures[4], pos);
-#endif
-        case 5u:
-#if N_EXTERNAL_TEXTURES > 5
-          return texture (external_textures[5], pos);
-#endif
-        default:
-          break;
-        }
-    }
-  else
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_TEXTURES > 0
-          return texture (textures[0], pos);
-#endif
-        case 1u:
-#if N_TEXTURES > 1
-          return texture (textures[1], pos);
-#endif
-        case 2u:
-#if N_TEXTURES > 2
-          return texture (textures[2], pos);
-#endif
-        case 3u:
-#if N_TEXTURES > 3
-          return texture (textures[3], pos);
-#endif
-        case 4u:
-#if N_TEXTURES > 4
-          return texture (textures[4], pos);
-#endif
-        case 5u:
-#if N_TEXTURES > 5
-          return texture (textures[5], pos);
-#endif
-        case 6u:
-#if N_TEXTURES > 6
-          return texture (textures[6], pos);
-#endif
-        case 7u:
-#if N_TEXTURES > 7
-          return texture (textures[7], pos);
-#endif
-        case 8u:
-#if N_TEXTURES > 8
-          return texture (textures[8], pos);
-#endif
-        case 9u:
-#if N_TEXTURES > 9
-          return texture (textures[9], pos);
-#endif
-        case 10u:
-#if N_TEXTURES > 10
-          return texture (textures[10], pos);
-#endif
-        case 11u:
-#if N_TEXTURES > 11
-          return texture (textures[11], pos);
-#endif
-        case 12u:
-#if N_TEXTURES > 12
-          return texture (textures[12], pos);
-#endif
-        case 13u:
-#if N_TEXTURES > 13
-          return texture (textures[13], pos);
-#endif
-        case 14u:
-#if N_TEXTURES > 14
-          return texture (textures[14], pos);
-#endif
-        case 15u:
-#if N_TEXTURES > 15
-          return texture (textures[15], pos);
-#endif
-        default:
-          break;
-        }
-    }
-  return vec4 (1.0, 0.0, 0.8, 1.0);
-}
-
-ivec2
-gsk_texture_size (uint id,
-                  int  lod)
-{
-  if ((id & 1u) != 0u)
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_EXTERNAL_TEXTURES > 0
-          return textureSize (external_textures[0], lod);
-#endif
-#if N_EXTERNAL_TEXTURES > 1
-        case 1u:
-          return textureSize (external_textures[1], lod);
-#endif
-        case 2u:
-#if N_EXTERNAL_TEXTURES > 2
-          return textureSize (external_textures[2], lod);
-#endif
-        case 3u:
-#if N_EXTERNAL_TEXTURES > 3
-          return textureSize (external_textures[3], lod);
-#endif
-        case 4u:
-#if N_EXTERNAL_TEXTURES > 4
-          return textureSize (external_textures[4], lod);
-#endif
-        case 5u:
-#if N_EXTERNAL_TEXTURES > 5
-          return textureSize (external_textures[5], lod);
-#endif
-        default:
-          break;
-        }
-    }
-  else
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_TEXTURES > 0
-          return textureSize (textures[0], lod);
-#endif
-        case 1u:
-#if N_TEXTURES > 1
-          return textureSize (textures[1], lod);
-#endif
-        case 2u:
-#if N_TEXTURES > 2
-          return textureSize (textures[2], lod);
-#endif
-        case 3u:
-#if N_TEXTURES > 3
-          return textureSize (textures[3], lod);
-#endif
-        case 4u:
-#if N_TEXTURES > 4
-          return textureSize (textures[4], lod);
-#endif
-        case 5u:
-#if N_TEXTURES > 5
-          return textureSize (textures[5], lod);
-#endif
-        case 6u:
-#if N_TEXTURES > 6
-          return textureSize (textures[6], lod);
-#endif
-        case 7u:
-#if N_TEXTURES > 7
-          return textureSize (textures[7], lod);
-#endif
-        case 8u:
-#if N_TEXTURES > 8
-          return textureSize (textures[8], lod);
-#endif
-        case 9u:
-#if N_TEXTURES > 9
-          return textureSize (textures[9], lod);
-#endif
-        case 10u:
-#if N_TEXTURES > 10
-          return textureSize (textures[10], lod);
-#endif
-        case 11u:
-#if N_TEXTURES > 11
-          return textureSize (textures[11], lod);
-#endif
-        case 12u:
-#if N_TEXTURES > 12
-          return textureSize (textures[12], lod);
-#endif
-        case 13u:
-#if N_TEXTURES > 13
-          return textureSize (textures[13], lod);
-#endif
-        case 14u:
-#if N_TEXTURES > 14
-          return textureSize (textures[14], lod);
-#endif
-        case 15u:
-#if N_TEXTURES > 15
-          return textureSize (textures[15], lod);
-#endif
-        default:
-          break;
-        }
-    }
-  return ivec2 (1, 1);
-}
-
-vec4
-gsk_texel_fetch (uint  id,
-                 ivec2 pos,
-                 int   lod)
-{
-  if ((id & 1u) != 0u)
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_EXTERNAL_TEXTURES > 0
-          return texelFetch (external_textures[0], pos, lod);
-#endif
-#if N_EXTERNAL_TEXTURES > 1
-        case 1u:
-          return texelFetch (external_textures[1], pos, lod);
-#endif
-        case 2u:
-#if N_EXTERNAL_TEXTURES > 2
-          return texelFetch (external_textures[2], pos, lod);
-#endif
-        case 3u:
-#if N_EXTERNAL_TEXTURES > 3
-          return texelFetch (external_textures[3], pos, lod);
-#endif
-        case 4u:
-#if N_EXTERNAL_TEXTURES > 4
-          return texelFetch (external_textures[4], pos, lod);
-#endif
-        case 5u:
-#if N_EXTERNAL_TEXTURES > 5
-          return texelFetch (external_textures[5], pos, lod);
-#endif
-        default:
-          break;
-        }
-    }
-  else
-    {
-      switch (id >> 1u)
-        {
-        case 0u:
-#if N_TEXTURES > 0
-          return texelFetch (textures[0], pos, lod);
-#endif
-        case 1u:
-#if N_TEXTURES > 1
-          return texelFetch (textures[1], pos, lod);
-#endif
-        case 2u:
-#if N_TEXTURES > 2
-          return texelFetch (textures[2], pos, lod);
-#endif
-        case 3u:
-#if N_TEXTURES > 3
-          return texelFetch (textures[3], pos, lod);
-#endif
-        case 4u:
-#if N_TEXTURES > 4
-          return texelFetch (textures[4], pos, lod);
-#endif
-        case 5u:
-#if N_TEXTURES > 5
-          return texelFetch (textures[5], pos, lod);
-#endif
-        case 6u:
-#if N_TEXTURES > 6
-          return texelFetch (textures[6], pos, lod);
-#endif
-        case 7u:
-#if N_TEXTURES > 7
-          return texelFetch (textures[7], pos, lod);
-#endif
-        case 8u:
-#if N_TEXTURES > 8
-          return texelFetch (textures[8], pos, lod);
-#endif
-        case 9u:
-#if N_TEXTURES > 9
-          return texelFetch (textures[9], pos, lod);
-#endif
-        case 10u:
-#if N_TEXTURES > 10
-          return texelFetch (textures[10], pos, lod);
-#endif
-        case 11u:
-#if N_TEXTURES > 11
-          return texelFetch (textures[11], pos, lod);
-#endif
-        case 12u:
-#if N_TEXTURES > 12
-          return texelFetch (textures[12], pos, lod);
-#endif
-        case 13u:
-#if N_TEXTURES > 13
-          return texelFetch (textures[13], pos, lod);
-#endif
-        case 14u:
-#if N_TEXTURES > 14
-          return texelFetch (textures[14], pos, lod);
-#endif
-        case 15u:
-#if N_TEXTURES > 15
-          return texelFetch (textures[15], pos, lod);
-#endif
-        default:
-          break;
-        }
-    }
-  return vec4 (1.0, 0.0, 0.8, 1.0);
-}
-
-#else /* !GSK_GLES */
-
-#define gsk_texture(id, pos) texture (textures[id >> 1], pos)
-#define gsk_texture_size(id, lod) textureSize (textures[id >> 1], lod)
-#define gsk_texel_fetch(id, pos, lod) texelFetch (textures[id >> 1], pos, lod)
-
 #endif
 
 layout(location = 0) out vec4 out_color;

gsk/gpu/shaders/common.glsl

@@ -13,6 +13,8 @@ void            main_clip_rounded               (void);
 #include "common-gl.glsl"
 #endif
 
+#define GSK_SHADER_CLIP (GSK_FLAGS & 3u)
+
 #include "color.glsl"
 #include "rect.glsl"
 #include "roundedrect.glsl"
@@ -125,23 +127,23 @@ main (void)
 #ifdef GSK_FRAGMENT_SHADER
 
 vec4
-gsk_texture_straight_alpha (uint tex_id,
-                            vec2 pos)
+gsk_texture_straight_alpha (sampler2D tex,
+                            vec2      pos)
 {
-  vec2 size = vec2 (gsk_texture_size (tex_id, 0));
+  vec2 size = vec2 (textureSize (tex, 0));
   pos *= size;
   size -= vec2 (1.0);
   /* GL_CLAMP_TO_EDGE */
   pos = clamp (pos - 0.5, vec2 (0.0), size);
   ivec2 ipos = ivec2 (pos);
   pos = fract (pos);
-  vec4 tl = gsk_texel_fetch (tex_id, ipos, 0);
+  vec4 tl = texelFetch (tex, ipos, 0);
   tl.rgb *= tl.a;
-  vec4 tr = gsk_texel_fetch (tex_id, ipos + ivec2(1, 0), 0);
+  vec4 tr = texelFetch (tex, ipos + ivec2(1, 0), 0);
   tr.rgb *= tr.a;
-  vec4 bl = gsk_texel_fetch (tex_id, ipos + ivec2(0, 1), 0);
+  vec4 bl = texelFetch (tex, ipos + ivec2(0, 1), 0);
   bl.rgb *= bl.a;
-  vec4 br = gsk_texel_fetch (tex_id, ipos + ivec2(1, 1), 0);
+  vec4 br = texelFetch (tex, ipos + ivec2(1, 1), 0);
   br.rgb *= br.a;
   return mix (mix (tl, tr, pos.x), mix (bl, br, pos.x), pos.y);
 }

gsk/gpu/shaders/generate-header.py

@@ -7,6 +7,7 @@ import os
 name = os.path.splitext(os.path.splitext(os.path.basename(sys.argv[1]))[0])[0][6:]
 var_name = "gsk_gpu_" + name.replace('-', '_')
 struct_name = "GskGpu" + name.title().replace('-', '') + "Instance"
+n_textures = -1
 filename = sys.argv[1]
 
 with open(filename) as f:
@@ -14,6 +15,10 @@ with open(filename) as f:
     matches = []
 
     for pos, line in enumerate (lines):
+        match = re.search(r"^#define GSK_N_TEXTURES ([0-9]+)$", line)
+        if match:
+            n_textures = int(match.group(1))
+
         match = re.search(r"^IN\(([0-9]+)\) ([a-z0-9]+) ([a-zA-Z0-9_]+);$", line)
         if not match:
             if re.search(r"layout.*\sin\s.*", line):
@@ -26,9 +31,16 @@ with open(filename) as f:
                         'location': int(match.group(1)),
                         'type': match.group(2)})
 
+if n_textures < 0:
+    raise Exception(f'''{filename}: GSK_N_TEXTURES not defined''')
+if n_textures > 2:
+    raise Exception(f'''{filename}: GSK_N_TEXTURES must be <= 2''')
+
 print(f'''/* This file is auto-generated; any change will not be preserved */
 #pragma once
 
+#define {var_name}_n_textures {n_textures}
+
 typedef struct _{struct_name} {struct_name};
 
 struct _{struct_name} {{''')

gsk/gpu/shaders/gskgpublendmode.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 2
+
 #include "common.glsl"
 #include "blendmode.glsl"
 
@@ -6,19 +8,15 @@ PASS_FLAT(1) Rect _bottom_rect;
 PASS_FLAT(2) Rect _top_rect;
 PASS(3) vec2 _bottom_coord;
 PASS(4) vec2 _top_coord;
-PASS_FLAT(5) uint _bottom_id;
-PASS_FLAT(6) uint _top_id;
-PASS_FLAT(7) float _opacity;
+PASS_FLAT(5) float _opacity;
 
 
 #ifdef GSK_VERTEX_SHADER
 
 IN(0) vec4 in_rect;
 IN(1) vec4 in_bottom_rect;
-IN(2) uint in_bottom_id;
-IN(3) vec4 in_top_rect;
-IN(4) uint in_top_id;
-IN(5) float in_opacity;
+IN(2) vec4 in_top_rect;
+IN(3) float in_opacity;
 
 void
 run (out vec2 pos)
@@ -33,12 +31,10 @@ run (out vec2 pos)
   Rect bottom_rect = rect_from_gsk (in_bottom_rect);
   _bottom_rect = bottom_rect;
   _bottom_coord = rect_get_coord (bottom_rect, pos);
-  _bottom_id = in_bottom_id;
 
   Rect top_rect = rect_from_gsk (in_top_rect);
   _top_rect = top_rect;
   _top_coord = rect_get_coord (top_rect, pos);
-  _top_id = in_top_id;
 }
 
 #endif
@@ -51,10 +47,10 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  vec4 bottom_color = gsk_texture (_bottom_id, _bottom_coord);
+  vec4 bottom_color = texture (GSK_TEXTURE0, _bottom_coord);
   bottom_color = output_color_alpha (bottom_color, rect_coverage (_bottom_rect, _pos));
 
-  vec4 top_color = gsk_texture (_top_id, _top_coord);
+  vec4 top_color = texture (GSK_TEXTURE1, _top_coord);
   top_color = output_color_alpha (top_color, rect_coverage (_top_rect, _pos));
 
   color = blend_mode (bottom_color, top_color, GSK_VARIATION);

gsk/gpu/shaders/gskgpublur.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 1
+
 #include "common.glsl"
 
 /* blur radius (aka in_blur_direction) 0 is NOT supported and MUST be caught before */
@@ -10,7 +12,6 @@ PASS_FLAT(2) vec4 _blur_color;
 PASS(3) vec2 _tex_coord;
 PASS_FLAT(4) vec2 _tex_blur_step;
 PASS_FLAT(5) uint _samples_per_side;
-PASS_FLAT(6) uint _tex_id;
 PASS_FLAT(7) vec3 _initial_gaussian;
 
 
@@ -20,7 +21,6 @@ IN(0) vec4 in_rect;
 IN(1) vec4 in_blur_color;
 IN(2) vec4 in_tex_rect;
 IN(3) vec2 in_blur_direction;
-IN(4) uint in_tex_id;
 
 void
 run (out vec2 pos)
@@ -34,7 +34,6 @@ run (out vec2 pos)
   _blur_color = output_color_from_alt (in_blur_color);
   Rect tex_rect = rect_from_gsk (in_tex_rect);
   _tex_coord = rect_get_coord (tex_rect, pos);
-  _tex_id = in_tex_id;
 
   float blur_radius = length (GSK_GLOBAL_SCALE * in_blur_direction);
   _tex_blur_step = GSK_GLOBAL_SCALE * in_blur_direction / blur_radius / rect_size (tex_rect);
@@ -56,15 +55,15 @@ run (out vec4 color,
      out vec2 position)
 {
   vec3 incremental_gaussian = _initial_gaussian;
-  vec4 sum = gsk_texture (_tex_id, _tex_coord) * incremental_gaussian.x;
+  vec4 sum = texture (GSK_TEXTURE0, _tex_coord) * incremental_gaussian.x;
   float coefficient_sum = incremental_gaussian.x;
   incremental_gaussian.xy *= incremental_gaussian.yz;
   vec2 p = _tex_blur_step;
 
   for (uint i = 0u; i < _samples_per_side; i++)
     {
-      sum += gsk_texture (_tex_id, _tex_coord - p) * incremental_gaussian.x;
-      sum += gsk_texture (_tex_id, _tex_coord + p) * incremental_gaussian.x;
+      sum += texture (GSK_TEXTURE0, _tex_coord - p) * incremental_gaussian.x;
+      sum += texture (GSK_TEXTURE0, _tex_coord + p) * incremental_gaussian.x;
 
       coefficient_sum += 2.0 * incremental_gaussian.x;
       incremental_gaussian.xy *= incremental_gaussian.yz;

gsk/gpu/shaders/gskgpuborder.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;

gsk/gpu/shaders/gskgpuboxshadow.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 /* blur radius (aka in_blur_direction) 0 is NOT supported and MUST be caught before */

gsk/gpu/shaders/gskgpucolor.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;

gsk/gpu/shaders/gskgpucolorize.glsl

@@ -1,11 +1,11 @@
+#define GSK_N_TEXTURES 1
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;
 PASS_FLAT(1) Rect _rect;
 PASS_FLAT(2) vec4 _color;
 PASS(3) vec2 _tex_coord;
-PASS_FLAT(4) uint _tex_id;
-
 
 
 #ifdef GSK_VERTEX_SHADER
@@ -13,7 +13,6 @@ PASS_FLAT(4) uint _tex_id;
 IN(0) vec4 in_rect;
 IN(1) vec4 in_color;
 IN(2) vec4 in_tex_rect;
-IN(3) uint in_tex_id;
 
 void
 run (out vec2 pos)
@@ -26,7 +25,6 @@ run (out vec2 pos)
   _rect = r;
   _color = output_color_from_alt (in_color);
   _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos);
-  _tex_id = in_tex_id;
 }
 
 #endif
@@ -39,7 +37,7 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  float alpha = gsk_texture (_tex_id, _tex_coord).a * rect_coverage (_rect, _pos);
+  float alpha = texture (GSK_TEXTURE0, _tex_coord).a * rect_coverage (_rect, _pos);
   color = output_color_alpha (_color, alpha);
   position = _pos;
 }

gsk/gpu/shaders/gskgpucolormatrix.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 1
+
 #include "common.glsl"
 
 PASS_FLAT(0) mat4 _color_matrix;
@@ -5,7 +7,6 @@ PASS_FLAT(4) vec4 _color_offset;
 PASS(5) vec2 _pos;
 PASS_FLAT(6) Rect _rect;
 PASS(7) vec2 _tex_coord;
-PASS_FLAT(8) uint _tex_id;
 
 
 #ifdef GSK_VERTEX_SHADER
@@ -14,7 +15,6 @@ IN(0) mat4 in_color_matrix;
 IN(4) vec4 in_color_offset;
 IN(5) vec4 in_rect;
 IN(6) vec4 in_tex_rect;
-IN(7) uint in_tex_id;
 
 void
 run (out vec2 pos)
@@ -26,7 +26,6 @@ run (out vec2 pos)
   _pos = pos;
   _rect = r;
   _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos);
-  _tex_id = in_tex_id;
   _color_matrix = in_color_matrix;
   _color_offset = in_color_offset;
 }
@@ -41,7 +40,7 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  vec4 pixel = gsk_texture (_tex_id, _tex_coord);
+  vec4 pixel = texture (GSK_TEXTURE0, _tex_coord);
   pixel = alt_color_from_output (pixel);
 
   pixel = _color_matrix * pixel + _color_offset;

gsk/gpu/shaders/gskgpuconicgradient.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0))

gsk/gpu/shaders/gskgpuconvert.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 1
+
 #include "common.glsl"
 
 #define VARIATION_OPACITY              (1u << 0)
@@ -8,15 +10,13 @@
 PASS(0) vec2 _pos;
 PASS_FLAT(1) Rect _rect;
 PASS(2) vec2 _tex_coord;
-PASS_FLAT(3) uint _tex_id;
-PASS_FLAT(4) float _opacity;
+PASS_FLAT(3) float _opacity;
 
 #ifdef GSK_VERTEX_SHADER
 
 IN(0) vec4 in_rect;
 IN(1) vec4 in_tex_rect;
-IN(2) uint in_tex_id;
-IN(3) float in_opacity;
+IN(2) float in_opacity;
 
 void
 run (out vec2 pos)
@@ -28,7 +28,6 @@ run (out vec2 pos)
   _pos = pos;
   _rect = r;
   _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos);
-  _tex_id = in_tex_id;
   _opacity = in_opacity;
 }
 
@@ -44,9 +43,9 @@ run (out vec4 color,
 {
   vec4 pixel;
   if (HAS_VARIATION (VARIATION_STRAIGHT_ALPHA))
-    pixel = gsk_texture_straight_alpha (_tex_id, _tex_coord);
+    pixel = gsk_texture_straight_alpha (GSK_TEXTURE0, _tex_coord);
   else
-    pixel = gsk_texture (_tex_id, _tex_coord);
+    pixel = texture (GSK_TEXTURE0, _tex_coord);
 
   pixel = output_color_from_alt (pixel);
 

gsk/gpu/shaders/gskgpucrossfade.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 2
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;
@@ -5,20 +7,16 @@ PASS_FLAT(1) Rect _start_rect;
 PASS_FLAT(2) Rect _end_rect;
 PASS(3) vec2 _start_coord;
 PASS(4) vec2 _end_coord;
-PASS_FLAT(5) uint _start_id;
-PASS_FLAT(6) uint _end_id;
-PASS_FLAT(7) float _start_opacity;
-PASS_FLAT(8) float _end_opacity;
+PASS_FLAT(5) float _start_opacity;
+PASS_FLAT(6) float _end_opacity;
 
 
 #ifdef GSK_VERTEX_SHADER
 
 IN(0) vec4 in_rect;
 IN(1) vec4 in_start_rect;
-IN(2) uint in_start_id;
-IN(3) vec4 in_end_rect;
-IN(4) uint in_end_id;
-IN(5) vec2 in_opacity_progress;
+IN(2) vec4 in_end_rect;
+IN(3) vec2 in_opacity_progress;
 
 void
 run (out vec2 pos)
@@ -32,13 +30,11 @@ run (out vec2 pos)
   Rect start_rect = rect_from_gsk (in_start_rect);
   _start_rect = start_rect;
   _start_coord = rect_get_coord (start_rect, pos);
-  _start_id = in_start_id;
   _start_opacity = in_opacity_progress[0] * (1.0 - in_opacity_progress[1]);
 
   Rect end_rect = rect_from_gsk (in_end_rect);
   _end_rect = end_rect;
   _end_coord = rect_get_coord (end_rect, pos);
-  _end_id = in_end_id;
   _end_opacity = in_opacity_progress[0] * in_opacity_progress[1];
 }
 
@@ -52,10 +48,10 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  vec4 start = output_color_alpha (gsk_texture (_start_id, _start_coord),
+  vec4 start = output_color_alpha (texture (GSK_TEXTURE0, _start_coord),
                                    rect_coverage (_start_rect, _pos) *
                                    _start_opacity);
-  vec4 end = output_color_alpha (gsk_texture (_end_id, _end_coord),
+  vec4 end = output_color_alpha (texture (GSK_TEXTURE1, _end_coord),
                                  rect_coverage (_end_rect, _pos) *
                                  _end_opacity);
 

gsk/gpu/shaders/gskgpulineargradient.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0))

gsk/gpu/shaders/gskgpumask.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 2
+
 #include "common.glsl"
 
 #define VARIATION_MASK_MODE GSK_VARIATION
@@ -7,8 +9,6 @@ PASS_FLAT(1) Rect _source_rect;
 PASS_FLAT(2) Rect _mask_rect;
 PASS(3) vec2 _source_coord;
 PASS(4) vec2 _mask_coord;
-PASS_FLAT(5) uint _source_id;
-PASS_FLAT(6) uint _mask_id;
 PASS_FLAT(7) float _opacity;
 
 
@@ -16,10 +16,8 @@ PASS_FLAT(7) float _opacity;
 
 IN(0) vec4 in_rect;
 IN(1) vec4 in_source_rect;
-IN(2) uint in_source_id;
-IN(3) vec4 in_mask_rect;
-IN(4) uint in_mask_id;
-IN(5) float in_opacity;
+IN(2) vec4 in_mask_rect;
+IN(3) float in_opacity;
 
 void
 run (out vec2 pos)
@@ -32,11 +30,9 @@ run (out vec2 pos)
   Rect source_rect = rect_from_gsk (in_source_rect);
   _source_rect = source_rect;
   _source_coord = rect_get_coord (source_rect, pos);
-  _source_id = in_source_id;
   Rect mask_rect = rect_from_gsk (in_mask_rect);
   _mask_rect = mask_rect;
   _mask_coord = rect_get_coord (mask_rect, pos);
-  _mask_id = in_mask_id;
   _opacity = in_opacity;
 }
 
@@ -50,9 +46,9 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  vec4 source = gsk_texture (_source_id, _source_coord);
+  vec4 source = texture (GSK_TEXTURE0, _source_coord);
   source = output_color_alpha (source, rect_coverage (_source_rect, _pos));
-  vec4 mask = gsk_texture (_mask_id, _mask_coord);
+  vec4 mask = texture (GSK_TEXTURE1, _mask_coord);
   mask = output_color_alpha (mask, rect_coverage (_mask_rect, _pos));
 
   float alpha = _opacity;

gsk/gpu/shaders/gskgpuradialgradient.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0))

gsk/gpu/shaders/gskgpuroundedcolor.glsl

@@ -1,3 +1,5 @@
+#define GSK_N_TEXTURES 0
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;

gsk/gpu/shaders/gskgputexture.glsl

@@ -1,9 +1,10 @@
+#define GSK_N_TEXTURES 1
+
 #include "common.glsl"
 
 PASS(0) vec2 _pos;
 PASS_FLAT(1) Rect _rect;
 PASS(2) vec2 _tex_coord;
-PASS_FLAT(3) uint _tex_id;
 
 
 
@@ -11,7 +12,6 @@ PASS_FLAT(3) uint _tex_id;
 
 IN(0) vec4 in_rect;
 IN(1) vec4 in_tex_rect;
-IN(2) uint in_tex_id;
 
 void
 run (out vec2 pos)
@@ -23,7 +23,6 @@ run (out vec2 pos)
   _pos = pos;
   _rect = r;
   _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos);
-  _tex_id = in_tex_id;
 }
 
 #endif
@@ -36,7 +35,7 @@ void
 run (out vec4 color,
      out vec2 position)
 {
-  color = gsk_texture (_tex_id, _tex_coord) *
+  color = texture (GSK_TEXTURE0, _tex_coord) *
           rect_coverage (_rect, _pos);
   position = _pos;
 }

gsk/gpu/shaders/meson.build

@@ -61,27 +61,13 @@ foreach shader: gsk_private_gpu_shaders
 
   if (have_vulkan)
     glslc_options = [
-      [ fs.name (fs.replace_suffix (shader, '')) + '.1.2.vert.spv',
-        [ '--target-env=vulkan1.2',
-          '-fshader-stage=vertex',
-          '-DGSK_VERTEX_SHADER=1',
-          '-DHAVE_VULKAN_1_2=1'
-        ]
-      ],
-      [ fs.name (fs.replace_suffix (shader, '')) + '.1.2.frag.spv',
-        [ '--target-env=vulkan1.2',
-          '-fshader-stage=fragment',
-          '-DGSK_FRAGMENT_SHADER=1',
-          '-DHAVE_VULKAN_1_2=1'
-        ]
-      ],
-      [ fs.name (fs.replace_suffix (shader, '')) + '.1.0.vert.spv',
+      [ fs.name (fs.replace_suffix (shader, '')) + '.vert.spv',
         [ '--target-env=vulkan1.0',
           '-fshader-stage=vertex',
           '-DGSK_VERTEX_SHADER=1',
         ]
       ],
-      [ fs.name (fs.replace_suffix (shader, '')) + '.1.0.frag.spv',
+      [ fs.name (fs.replace_suffix (shader, '')) + '.frag.spv',
         [ '--target-env=vulkan1.0',
           '-fshader-stage=fragment',
           '-DGSK_FRAGMENT_SHADER=1',

gsk/meson.build

@@ -71,7 +71,6 @@ gsk_private_sources = files([
   'gl/fp16.c',
   'gpu/gskglbuffer.c',
   'gpu/gskgldevice.c',
-  'gpu/gskgldescriptors.c',
   'gpu/gskglframe.c',
   'gpu/gskglimage.c',
   'gpu/gskgpublendop.c',
@@ -90,7 +89,6 @@ gsk_private_sources = files([
   'gpu/gskgpuconicgradientop.c',
   'gpu/gskgpuconvertop.c',
   'gpu/gskgpucrossfadeop.c',
-  'gpu/gskgpudescriptors.c',
   'gpu/gskgpudownloadop.c',
   'gpu/gskgpudevice.c',
   'gpu/gskgpuframe.c',
@@ -161,13 +159,11 @@ gsk_private_vulkan_shader_headers = []
 if have_vulkan
   gsk_private_sources += files([
     'gpu/gskvulkanbuffer.c',
-    'gpu/gskvulkandescriptors.c',
     'gpu/gskvulkandevice.c',
     'gpu/gskvulkanframe.c',
     'gpu/gskvulkanimage.c',
     'gpu/gskvulkanmemory.c',
-    'gpu/gskvulkanrealdescriptors.c',
-    'gpu/gskvulkansubdescriptors.c',
+    'gpu/gskvulkanycbcr.c',
   ])
 endif # have_vulkan
 

testsuite/gsk/compare/lots-of-offscreens-nogl.node

@@ -0,0 +1,64 @@
+cross-fade {
+  start: cross-fade "foo15" {
+    start: cross-fade "foo14" {
+      start: cross-fade "foo13" {
+        start: cross-fade "foo12" {
+          start: cross-fade "foo11" {
+            start: cross-fade "foo10" {
+              start: cross-fade "foo9" {
+                start: cross-fade "foo8" {
+                  start: cross-fade "foo7" {
+                    start: cross-fade "foo6" {
+                      start: cross-fade "foo5" {
+                        start: cross-fade "foo4" {
+                          start: cross-fade "foo3" {
+                            start: cross-fade "foo2" {
+                              start: color "foo1" {
+                                bounds: 0 0 10 10;
+                                color: red;
+                              }
+                              end: "foo1";
+                              progress: 0.4;
+                            }
+                            end: "foo2";
+                            progress: 0.4;
+                          }
+                          end: "foo3";
+                          progress: 0.8;
+                        }
+                        end: "foo4";
+                        progress: 0.6;
+                      }
+                      end: "foo5";
+                      progress: 0.4;
+                    }
+                    end: "foo6";
+                    progress: 0.2;
+                  }
+                  end: "foo7";
+                  progress: 0.6;
+                }
+                end: "foo8";
+                progress: 0.6;
+              }
+              end: "foo9";
+              progress: 0.8;
+            }
+            end: "foo10";
+            progress: 0.6;
+          }
+          end: "foo11";
+          progress: 0.4;
+        }
+        end: "foo12";
+        progress: 0.6;
+      }
+      end: "foo13";
+      progress: 0.2;
+    }
+    end: "foo14";
+    progress: 0.4;
+  }
+  end: "foo15";
+  progress: 0.2;
+}

testsuite/gsk/meson.build

@@ -99,6 +99,7 @@ compare_render_tests = [
   'linear-gradient-3d-nocairo',
   'linear-gradient-nonorthogonal-scale-nogl',
   'linear-gradient-with-64-colorstops',
+  'lots-of-offscreens-nogl',
   'mask',
   'mask-clipped-inverted-alpha',
   'mask-empty-mask',