gsk: Add some inline vec2 apis

The gpu renderers are using a vec2 for their scale, and frequently
need to access the components. Avoid PLT overhead for this.

gdk/gdkarrayimpl.c

@@ -52,13 +52,6 @@ G_BEGIN_DECLS
 #define gdk_array_paste(GDK_ARRAY_NAME, func_name) gdk_array_paste_more (GDK_ARRAY_NAME, func_name)
 #define gdk_array(func_name) gdk_array_paste (GDK_ARRAY_NAME, func_name)
 
-#if !defined(INCLUDE_DECL) && !defined(INCLUDE_IMPL)
-#define INCLUDE_DECL 1
-#define INCLUDE_IMPL 1
-#endif
-
-#ifdef INCLUDE_DECL
-
 typedef struct GdkArray GdkArray;
 
 struct GdkArray
@@ -89,9 +82,6 @@ gdk_array(init) (GdkArray *self)
 #endif
 }
 
-#endif /* INCLUDE_DECL */
-#ifdef INCLUDE_IMPL
-
 G_GNUC_UNUSED static inline gsize
 gdk_array(get_capacity) (const GdkArray *self)
 {
@@ -314,8 +304,6 @@ gdk_array(get) (const GdkArray *self,
  }
 #endif
 
-#endif  /* INCLUDE_IMPL */
-
 #ifndef GDK_ARRAY_NO_UNDEF
 
 #undef _T_
@@ -333,9 +321,6 @@ gdk_array(get) (const GdkArray *self,
 #undef GDK_ARRAY_PREALLOC
 #undef GDK_ARRAY_TYPE_NAME
 #undef GDK_ARRAY_NO_MEMSET
-
-#undef INCLUDE_DECL
-#undef INCLUDE_IMPL
 #endif
 
 G_END_DECLS

gsk/gpu/gskglbuffer.c

@@ -1,5 +1,7 @@
 #include "config.h"
 
+#include <gdk/gdkprofilerprivate.h>
+
 #include "gskglbufferprivate.h"
 
 struct _GskGLBuffer
@@ -14,6 +16,9 @@ struct _GskGLBuffer
 
 G_DEFINE_TYPE (GskGLBuffer, gsk_gl_buffer, GSK_TYPE_GPU_BUFFER)
 
+static guint profiler_buffer_uploads_id;
+static gint64 profiler_buffer_uploads;
+
 static void
 gsk_gl_buffer_finalize (GObject *object)
 {
@@ -44,7 +49,9 @@ gsk_gl_buffer_unmap (GskGpuBuffer *buffer,
 
   gsk_gl_buffer_bind (self);
 
+  profiler_buffer_uploads += used;
   glBufferSubData (self->target, 0, used, self->data);
+  gdk_profiler_set_int_counter (profiler_buffer_uploads_id, profiler_buffer_uploads);
 }
 
 static void
@@ -57,6 +64,8 @@ gsk_gl_buffer_class_init (GskGLBufferClass *klass)
   buffer_class->unmap = gsk_gl_buffer_unmap;
 
   gobject_class->finalize = gsk_gl_buffer_finalize;
+
+  profiler_buffer_uploads_id = gdk_profiler_define_int_counter ("ngl-buffer-uploads", "Number of bytes uploaded to GPU");
 }
 
 static void

gsk/gpu/gskgldescriptors.c

@@ -5,14 +5,24 @@
 #include "gskglbufferprivate.h"
 #include "gskglimageprivate.h"
 
-static void
-gsk_gl_descriptors_finalize (GskGpuDescriptors *desc)
+struct _GskGLDescriptors
 {
-  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (desc);
+  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);
 
-  gsk_gpu_descriptors_finalize (&self->parent_instance);
+  G_OBJECT_CLASS (gsk_gl_descriptors_parent_class)->finalize (object);
 }
 
 static gboolean
@@ -62,25 +72,29 @@ gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc,
   return TRUE;
 }
 
-static GskGpuDescriptorsClass GSK_GL_DESCRIPTORS_CLASS =
+static void
+gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
 {
-  .finalize = gsk_gl_descriptors_finalize,
-  .add_image = gsk_gl_descriptors_add_image,
-  .add_buffer = gsk_gl_descriptors_add_buffer,
-};
+  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;
-  GskGpuDescriptors *desc;
 
-  self = g_new0 (GskGLDescriptors, 1);
-  desc = GSK_GPU_DESCRIPTORS (self);
-
-  desc->ref_count = 1;
-  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_GL_DESCRIPTORS_CLASS;
-  gsk_gpu_descriptors_init (&self->parent_instance);
+  self = g_object_new (GSK_TYPE_GL_DESCRIPTORS, NULL);
 
   self->device = g_object_ref (device);
 
@@ -96,7 +110,7 @@ gsk_gl_descriptors_get_n_external (GskGLDescriptors *self)
 void
 gsk_gl_descriptors_use (GskGLDescriptors *self)
 {
-  GskGpuDescriptors *desc = &self->parent_instance;
+  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
   gsize i, ext, n_textures;
 
   n_textures = 16 - 3 * self->n_external;

gsk/gpu/gskgldescriptorsprivate.h

@@ -6,17 +6,9 @@
 
 G_BEGIN_DECLS
 
-typedef struct _GskGLDescriptors GskGLDescriptors;
+#define GSK_TYPE_GL_DESCRIPTORS (gsk_gl_descriptors_get_type ())
 
-#define GSK_GL_DESCRIPTORS(d) ((GskGLDescriptors *) (d))
-
-struct _GskGLDescriptors
-{
-  GskGpuDescriptors parent_instance;
-
-  GskGLDevice *device;
-  guint n_external;
-};
+G_DECLARE_FINAL_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK, GL_DESCRIPTORS, GskGpuDescriptors)
 
 GskGpuDescriptors *               gsk_gl_descriptors_new                (GskGLDevice            *device);
 

gsk/gpu/gskglframe.c

@@ -6,7 +6,6 @@
 #include "gskgpuopprivate.h"
 #include "gskgpushaderopprivate.h"
 #include "gskglbufferprivate.h"
-#include "gskglmapbufferprivate.h"
 #include "gskgldescriptorsprivate.h"
 #include "gskgldeviceprivate.h"
 #include "gskglimageprivate.h"
@@ -125,20 +124,14 @@ gsk_gl_frame_create_vertex_buffer (GskGpuFrame *frame,
    */
   g_hash_table_remove_all (self->vaos);
 
-  if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MAP_BUFFER))
-    return gsk_gl_map_buffer_new (GL_ARRAY_BUFFER, size, GL_WRITE_ONLY);
-  else
-    return gsk_gl_buffer_new (GL_ARRAY_BUFFER, size, GL_WRITE_ONLY);
+  return gsk_gl_buffer_new (GL_ARRAY_BUFFER, size, GL_WRITE_ONLY);
 }
 
 static GskGpuBuffer *
 gsk_gl_frame_create_storage_buffer (GskGpuFrame *frame,
                                     gsize        size)
 {
-  if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MAP_BUFFER))
-    return gsk_gl_map_buffer_new (GL_UNIFORM_BUFFER, size, GL_WRITE_ONLY);
-  else
-    return gsk_gl_buffer_new (GL_UNIFORM_BUFFER, size, GL_WRITE_ONLY);
+  return gsk_gl_buffer_new (GL_UNIFORM_BUFFER, size, GL_WRITE_ONLY);
 }
 
 static void

gsk/gpu/gskglmapbuffer.c

@@ -1,95 +0,0 @@
-#include "config.h"
-
-#include "gskglmapbufferprivate.h"
-
-struct _GskGLMapBuffer
-{
-  GskGpuBuffer parent_instance;
-
-  GLenum target;
-  GLuint buffer_id;
-  GLenum access;
-};
-
-G_DEFINE_TYPE (GskGLMapBuffer, gsk_gl_map_buffer, GSK_TYPE_GPU_BUFFER)
-
-static void
-gsk_gl_map_buffer_finalize (GObject *object)
-{
-  GskGLMapBuffer *self = GSK_GL_MAP_BUFFER (object);
-
-  glDeleteBuffers (1, &self->buffer_id);
-
-  G_OBJECT_CLASS (gsk_gl_map_buffer_parent_class)->finalize (object);
-}
-
-static guchar *
-gsk_gl_map_buffer_map (GskGpuBuffer *buffer)
-{
-  GskGLMapBuffer *self = GSK_GL_MAP_BUFFER (buffer);
-
-  gsk_gl_map_buffer_bind (self);
-
-  return glMapBuffer (self->target, self->access);
-}
-
-static void
-gsk_gl_map_buffer_unmap (GskGpuBuffer *buffer,
-                         gsize         used)
-{
-  GskGLMapBuffer *self = GSK_GL_MAP_BUFFER (buffer);
-
-  if (!glUnmapBuffer (self->target))
-    g_warning ("glUnmapBuffer failed");
-}
-
-static void
-gsk_gl_map_buffer_class_init (GskGLMapBufferClass *klass)
-{
-  GskGpuBufferClass *buffer_class = GSK_GPU_BUFFER_CLASS (klass);
-  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-
-  buffer_class->map = gsk_gl_map_buffer_map;
-  buffer_class->unmap = gsk_gl_map_buffer_unmap;
-
-  gobject_class->finalize = gsk_gl_map_buffer_finalize;
-}
-
-static void
-gsk_gl_map_buffer_init (GskGLMapBuffer *self)
-{
-}
-
-GskGpuBuffer *
-gsk_gl_map_buffer_new (GLenum target,
-                       gsize  size,
-                       GLenum access)
-{
-  GskGLMapBuffer *self;
-
-  self = g_object_new (GSK_TYPE_GL_MAP_BUFFER, NULL);
-
-  gsk_gpu_buffer_setup (GSK_GPU_BUFFER (self), size);
-
-  self->target = target;
-  self->access = access;
-
-  glGenBuffers (1, &self->buffer_id);
-  glBindBuffer (target, self->buffer_id);
-  glBufferData (target, size, NULL, GL_STATIC_DRAW);
-
-  return GSK_GPU_BUFFER (self);
-}
-
-void
-gsk_gl_map_buffer_bind (GskGLMapBuffer *self)
-{
-  glBindBuffer (self->target, self->buffer_id);
-}
-
-void
-gsk_gl_map_buffer_bind_base (GskGLMapBuffer *self,
-                             GLuint          index)
-{
-  glBindBufferBase (self->target, index, self->buffer_id);
-}

gsk/gpu/gskglmapbufferprivate.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "gskgpubufferprivate.h"
-
-#include "gskgldeviceprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_GL_MAP_BUFFER (gsk_gl_map_buffer_get_type ())
-
-G_DECLARE_FINAL_TYPE (GskGLMapBuffer, gsk_gl_map_buffer, GSK, GL_MAP_BUFFER, GskGpuBuffer)
-
-GskGpuBuffer *          gsk_gl_map_buffer_new                           (GLenum                  target,
-                                                                         gsize                   size,
-                                                                         GLenum                  access);
-
-void                    gsk_gl_map_buffer_bind                          (GskGLMapBuffer         *self);
-void                    gsk_gl_map_buffer_bind_base                     (GskGLMapBuffer         *self,
-                                                                         GLuint                  index);
-
-G_END_DECLS
-

gsk/gpu/gskgpubuffer.c

@@ -2,8 +2,6 @@
 
 #include "gskgpubufferprivate.h"
 
-#include <gdk/gdkprofilerprivate.h>
-
 typedef struct _GskGpuBufferPrivate GskGpuBufferPrivate;
 
 struct _GskGpuBufferPrivate
@@ -13,13 +11,9 @@ struct _GskGpuBufferPrivate
 
 G_DEFINE_TYPE_WITH_PRIVATE (GskGpuBuffer, gsk_gpu_buffer, G_TYPE_OBJECT)
 
-static guint profiler_buffer_uploads_id;
-static gint64 profiler_buffer_uploads;
-
 static void
 gsk_gpu_buffer_class_init (GskGpuBufferClass *klass)
 {
-  profiler_buffer_uploads_id = gdk_profiler_define_int_counter ("ngl-buffer-uploads", "Number of bytes uploaded to GPU");
 }
 
 static void
@@ -35,7 +29,7 @@ gsk_gpu_buffer_setup (GskGpuBuffer *self,
 
   priv->size = size;
 }
-
+                     
 gsize
 gsk_gpu_buffer_get_size (GskGpuBuffer *self)
 {
@@ -55,8 +49,5 @@ gsk_gpu_buffer_unmap (GskGpuBuffer *self,
                       gsize         size)
 {
   GSK_GPU_BUFFER_GET_CLASS (self)->unmap (self, size);
-
-  profiler_buffer_uploads += size;
-  gdk_profiler_set_int_counter (profiler_buffer_uploads_id, profiler_buffer_uploads);
 }
 

gsk/gpu/gskgpudescriptors.c

@@ -2,6 +2,22 @@
 
 #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)
 {
@@ -18,8 +34,6 @@ gsk_gpu_buffer_entry_clear (gpointer data)
   g_object_unref (entry->buffer);
 }
 
-#define INCLUDE_IMPL 1
-
 #define GDK_ARRAY_NAME gsk_gpu_image_entries
 #define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
 #define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
@@ -29,8 +43,6 @@ gsk_gpu_buffer_entry_clear (gpointer data)
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-#define INCLUDE_IMPL 1
-
 #define GDK_ARRAY_NAME gsk_gpu_buffer_entries
 #define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
 #define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
@@ -40,48 +52,80 @@ gsk_gpu_buffer_entry_clear (gpointer data)
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-void
-gsk_gpu_descriptors_finalize (GskGpuDescriptors *self)
+typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate;
+
+struct _GskGpuDescriptorsPrivate
 {
-  gsk_gpu_image_entries_clear (&self->images);
-  gsk_gpu_buffer_entries_clear (&self->buffers);
+  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);
 }
 
-void
+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)
 {
-  gsk_gpu_image_entries_init (&self->images);
-  gsk_gpu_buffer_entries_init (&self->buffers);
+  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)
 {
-  return gsk_gpu_image_entries_get_size (&self->images);
+  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)
 {
-  return gsk_gpu_buffer_entries_get_size (&self->buffers);
+  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)
 {
-  g_assert (n_images <= gsk_gpu_image_entries_get_size (&self->images));
-  gsk_gpu_image_entries_set_size (&self->images, n_images);
+  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
 
-  g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&self->buffers));
-  gsk_gpu_buffer_entries_set_size (&self->buffers, n_buffers);
+  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)
 {
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, id);
+  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
 
   return entry->image;
 }
@@ -90,7 +134,8 @@ GskGpuSampler
 gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self,
                                  gsize              id)
 {
-  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, id);
+  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+  const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id);
 
   return entry->sampler;
 }
@@ -99,11 +144,12 @@ 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 (&self->images); i++)
+  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
     {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, i);
+      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
 
       if (entry->descriptor == descriptor)
         return i;
@@ -116,7 +162,8 @@ GskGpuBuffer *
 gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self,
                                gsize              id)
 {
-  const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&self->buffers, id);
+  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+  const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, id);
 
   return entry->buffer;
 }
@@ -127,12 +174,13 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
                                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 (&self->images); i++)
+  for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++)
     {
-      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&self->images, i);
+      const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i);
 
       if (entry->image == image && entry->sampler == sampler)
         {
@@ -141,10 +189,10 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
         }
     }
 
-  if (!self->desc_class->add_image (self, image, sampler, &descriptor))
+  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_image (self, image, sampler, &descriptor))
     return FALSE;
 
-  gsk_gpu_image_entries_append (&self->images,
+  gsk_gpu_image_entries_append (&priv->images,
                                 &(GskGpuImageEntry) {
                                      .image = g_object_ref (image),
                                      .sampler = sampler,
@@ -161,12 +209,13 @@ 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 (&self->buffers); i++)
+  for (i = 0; i < gsk_gpu_buffer_entries_get_size (&priv->buffers); i++)
     {
-      const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&self->buffers, i);
+      const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, i);
 
       if (entry->buffer == buffer)
         {
@@ -175,10 +224,10 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
         }
     }
 
-  if (!self->desc_class->add_buffer (self, buffer, &descriptor))
+  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor))
     return FALSE;
 
-  gsk_gpu_buffer_entries_append (&self->buffers,
+  gsk_gpu_buffer_entries_append (&priv->buffers,
                                  &(GskGpuBufferEntry) {
                                       .buffer = g_object_ref (buffer),
                                       .descriptor = descriptor
@@ -189,22 +238,3 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
   return TRUE;
 }
 
-GskGpuDescriptors *
-gsk_gpu_descriptors_ref (GskGpuDescriptors *self)
-{
-  self->ref_count++;
-
-  return self;
-}
-
-void
-gsk_gpu_descriptors_unref (GskGpuDescriptors *self)
-{
-  self->ref_count--;
-
-  if (self->ref_count == 0)
-    {
-      self->desc_class->finalize (self);
-      g_free (self);
-    }
-}

gsk/gpu/gskgpudescriptorsprivate.h

@@ -2,62 +2,26 @@
 
 #include "gskgputypesprivate.h"
 
-typedef struct _GskGpuImageEntry GskGpuImageEntry;
-typedef struct _GskGpuBufferEntry GskGpuBufferEntry;
-
-struct _GskGpuImageEntry
-{
-  GskGpuImage *image;
-  GskGpuSampler sampler;
-  guint32 descriptor;
-};
-
-struct _GskGpuBufferEntry
-{
-  GskGpuBuffer *buffer;
-  guint32 descriptor;
-};
-
-#define INCLUDE_DECL 1
-
-#define GDK_ARRAY_NAME gsk_gpu_image_entries
-#define GDK_ARRAY_TYPE_NAME GskGpuImageEntries
-#define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 16
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
-#define INCLUDE_DECL 1
-
-#define GDK_ARRAY_NAME gsk_gpu_buffer_entries
-#define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries
-#define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry
-#define GDK_ARRAY_BY_VALUE 1
-#define GDK_ARRAY_PREALLOC 4
-#define GDK_ARRAY_NO_MEMSET 1
-#include "gdk/gdkarrayimpl.c"
-
 G_BEGIN_DECLS
 
-typedef struct _GskGpuDescriptors GskGpuDescriptors;
-typedef struct _GskGpuDescriptorsClass GskGpuDescriptorsClass;
+#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))
 
-#define GSK_GPU_DESCRIPTORS(d) ((GskGpuDescriptors *) (d))
+typedef struct _GskGpuDescriptorsClass GskGpuDescriptorsClass;
 
 struct _GskGpuDescriptors
 {
-  GskGpuDescriptorsClass *desc_class;
-
-  int ref_count;
-
-  GskGpuImageEntries images;
-  GskGpuBufferEntries buffers;
+  GObject parent_instance;
 };
 
 struct _GskGpuDescriptorsClass
 {
-  void                  (* finalize)                                    (GskGpuDescriptors      *self);
+  GObjectClass parent_class;
+
   gboolean              (* add_image)                                   (GskGpuDescriptors      *self,
                                                                          GskGpuImage            *image,
                                                                          GskGpuSampler           sampler,
@@ -67,9 +31,7 @@ struct _GskGpuDescriptorsClass
                                                                          guint32                *out_id);
 };
 
-GskGpuDescriptors *     gsk_gpu_descriptors_ref                         (GskGpuDescriptors      *self);
-void                    gsk_gpu_descriptors_unref                       (GskGpuDescriptors      *self);
-
+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);
@@ -93,7 +55,7 @@ gboolean                gsk_gpu_descriptors_add_buffer                  (GskGpuD
                                                                          GskGpuBuffer           *buffer,
                                                                          guint32                *out_descriptor);
 
-void gsk_gpu_descriptors_finalize (GskGpuDescriptors *self);
-void gsk_gpu_descriptors_init     (GskGpuDescriptors *self);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref)
 
 G_END_DECLS

gsk/gpu/gskgpunodeprocessor.c

@@ -36,6 +36,7 @@
 #include "gskdebugprivate.h"
 #include "gskpath.h"
 #include "gskrectprivate.h"
+#include "gskvec2private.h"
 #include "gskrendernodeprivate.h"
 #include "gskroundedrectprivate.h"
 #include "gskstrokeprivate.h"
@@ -152,7 +153,7 @@ static void
 gsk_gpu_node_processor_finish (GskGpuNodeProcessor *self)
 {
   g_clear_pointer (&self->modelview, gsk_transform_unref);
-  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
+  g_clear_object (&self->desc);
 }
 
 static void
@@ -170,7 +171,7 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->frame = frame;
   if (desc)
-    self->desc = gsk_gpu_descriptors_ref (desc);
+    self->desc = g_object_ref (desc);
   else
     self->desc = NULL;
 
@@ -195,9 +196,9 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->modelview = NULL;
   gsk_gpu_image_get_projection_matrix (target, &self->projection);
-  graphene_vec2_init (&self->scale,
-                      width / viewport->size.width,
-                      height / viewport->size.height);
+  gsk_vec2_init (&self->scale,
+                 width / viewport->size.width,
+                 height / viewport->size.height);
   self->offset = GRAPHENE_POINT_INIT (-viewport->origin.x,
                                       -viewport->origin.y);
   self->opacity = 1.0;
@@ -268,7 +269,7 @@ gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self,
       if (gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor))
         return descriptor;
 
-      gsk_gpu_descriptors_unref (self->desc);
+      g_object_unref (self->desc);
     }
 
   self->desc = gsk_gpu_frame_create_descriptors (self->frame);
@@ -319,8 +320,8 @@ rect_round_to_pixels (const graphene_rect_t  *src,
 {
   float x, y, xscale, yscale, inv_xscale, inv_yscale;
 
-  xscale = graphene_vec2_get_x (pixel_scale);
-  yscale = graphene_vec2_get_y (pixel_scale);
+  xscale = gsk_vec2_get_x (pixel_scale);
+  yscale = gsk_vec2_get_y (pixel_scale);
   inv_xscale = 1.0f / xscale;
   inv_yscale = 1.0f / yscale;
 
@@ -345,8 +346,8 @@ gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor   *self,
 
   area.x = 0;
   area.y = 0;
-  area.width = ceilf (graphene_vec2_get_x (scale) * viewport->size.width - EPSILON);
-  area.height = ceilf (graphene_vec2_get_y (scale) * viewport->size.height - EPSILON);
+  area.width = ceilf (gsk_vec2_get_x (scale) * viewport->size.width - EPSILON);
+  area.height = ceilf (gsk_vec2_get_y (scale) * viewport->size.height - EPSILON);
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,
@@ -545,7 +546,7 @@ gsk_gpu_pattern_writer_finish (GskGpuPatternWriter *self)
 {
   pattern_buffer_clear (&self->buffer);
   g_assert (self->stack == 0);
-  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
+  g_clear_object (&self->desc);
 }
 
 static gboolean
@@ -629,8 +630,8 @@ gsk_gpu_node_processor_rect_is_integer (GskGpuNodeProcessor   *self,
                                         cairo_rectangle_int_t *int_rect)
 {
   graphene_rect_t transformed_rect;
-  float scale_x = graphene_vec2_get_x (&self->scale);
-  float scale_y = graphene_vec2_get_y (&self->scale);
+  float scale_x = gsk_vec2_get_x (&self->scale);
+  float scale_y = gsk_vec2_get_y (&self->scale);
 
   switch (gsk_transform_get_category (self->modelview))
     {
@@ -1030,7 +1031,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
 
   gsk_gpu_node_processor_sync_globals (&other, 0);
 
-  graphene_vec2_init (&direction, blur_radius, 0.0f);
+  gsk_vec2_init (&direction, blur_radius, 0.0f);
   gsk_gpu_blur_op (other.frame,
                    gsk_gpu_clip_get_shader_clip (&other.clip, &other.offset, &intermediate_rect),
                    source_desc,
@@ -1044,7 +1045,7 @@ 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);
+  gsk_vec2_init (&direction, 0.0f, blur_radius);
   intermediate_descriptor = gsk_gpu_node_processor_add_image (self, intermediate, GSK_GPU_SAMPLER_TRANSPARENT);
   if (shadow_color)
     {
@@ -1581,8 +1582,8 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         gsk_gpu_clip_scale (&self->clip, &old_clip, scale_x, scale_y);
         self->offset.x = (self->offset.x + dx) / scale_x;
         self->offset.y = (self->offset.y + dy) / scale_y;
-        graphene_vec2_init (&self->scale, fabs (scale_x), fabs (scale_y));
-        graphene_vec2_multiply (&self->scale, &old_scale, &self->scale);
+        gsk_vec2_init (&self->scale, fabs (scale_x), fabs (scale_y));
+        gsk_vec2_multiply (&self->scale, &old_scale, &self->scale);
         self->modelview = gsk_transform_scale (self->modelview,
                                                scale_x / fabs (scale_x),
                                                scale_y / fabs (scale_y));
@@ -1642,15 +1643,15 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         old_modelview = gsk_transform_ref (self->modelview);
 
         self->modelview = gsk_transform_scale (self->modelview,
-                                               graphene_vec2_get_x (&self->scale),
-                                               graphene_vec2_get_y (&self->scale));
+                                               gsk_vec2_get_x (&self->scale),
+                                               gsk_vec2_get_y (&self->scale));
         self->modelview = gsk_transform_transform (self->modelview, clip_transform);
         gsk_transform_unref (clip_transform);
 
         extract_scale_from_transform (self->modelview, &scale_x, &scale_y);
 
-        old_pixels = MAX (graphene_vec2_get_x (&old_scale) * old_clip.rect.bounds.size.width,
-                          graphene_vec2_get_y (&old_scale) * old_clip.rect.bounds.size.height);
+        old_pixels = MAX (gsk_vec2_get_x (&old_scale) * old_clip.rect.bounds.size.width,
+                          gsk_vec2_get_y (&old_scale) * old_clip.rect.bounds.size.height);
         new_pixels = MAX (scale_x * self->clip.rect.bounds.size.width,
                           scale_y * self->clip.rect.bounds.size.height);
 
@@ -1663,7 +1664,7 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
           }
 
         self->modelview = gsk_transform_scale (self->modelview, 1 / scale_x, 1 / scale_y);
-        graphene_vec2_init (&self->scale, scale_x, scale_y);
+        gsk_vec2_init (&self->scale, scale_x, scale_y);
         self->offset = *graphene_point_zero ();
       }
       break;
@@ -1735,8 +1736,8 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
         self->bounds.size.width *= inv_sx;
         self->bounds.size.height *= inv_sy;
         self->offset = GRAPHENE_POINT_INIT (0, 0);
-        graphene_vec2_init (&self->scale, fabs (sx), fabs (sy));
-        graphene_vec2_multiply (&self->scale, &old_scale, &self->scale);
+        gsk_vec2_init (&self->scale, fabs (sx), fabs (sy));
+        gsk_vec2_multiply (&self->scale, &old_scale, &self->scale);
       }
       break;
 
@@ -1820,8 +1821,8 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
               return;
             }
 
-          scale_x = graphene_vec2_get_x (&self->scale);
-          scale_y = graphene_vec2_get_y (&self->scale);
+          scale_x = gsk_vec2_get_x (&self->scale);
+          scale_y = gsk_vec2_get_y (&self->scale);
           clipped = GRAPHENE_RECT_INIT (int_clipped.x / scale_x, int_clipped.y / scale_y,
                                         int_clipped.width / scale_x, int_clipped.height / scale_y);
           shader_clip = gsk_gpu_clip_get_shader_clip (&self->clip, graphene_point_zero(), &clipped);
@@ -1948,8 +1949,8 @@ gsk_gpu_node_processor_add_texture_node (GskGpuNodeProcessor *self,
     }
 
   if (gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_MIPMAP) &&
-      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * graphene_vec2_get_x (&self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * graphene_vec2_get_y (&self->scale)))
+      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * gsk_vec2_get_x (&self->scale) ||
+       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_vec2_get_y (&self->scale)))
     {
       guint32 descriptor;
 
@@ -2015,8 +2016,8 @@ gsk_gpu_node_processor_create_texture_pattern (GskGpuPatternWriter *self,
     }
 
   if (gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_MIPMAP) &&
-      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * graphene_vec2_get_x (&self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * graphene_vec2_get_y (&self->scale)))
+      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * gsk_vec2_get_x (&self->scale) ||
+       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_vec2_get_y (&self->scale)))
     {
       image = gsk_gpu_node_processor_ensure_image (self->frame,
                                                    image,
@@ -2060,7 +2061,7 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
   gboolean need_mipmap, need_offscreen;
 
   need_offscreen = self->modelview != NULL ||
-            !graphene_vec2_equal (&self->scale, graphene_vec2_one ());
+                   gsk_vec2_equal (&self->scale, graphene_vec2_one ());
   if (need_offscreen)
     {
       GskGpuImage *offscreen;
@@ -3021,7 +3022,7 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
   offset.x += self->offset.x;
   offset.y += self->offset.y;
 
-  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
+  scale = MAX (gsk_vec2_get_x (&self->scale), gsk_vec2_get_y (&self->scale));
   inv_scale = 1.f / scale;
 
   glyph_align = gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_GLYPH_ALIGN);
@@ -3135,7 +3136,7 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   offset.x += self->offset.x;
   offset.y += self->offset.y;
 
-  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
+  scale = MAX (gsk_vec2_get_x (&self->scale), gsk_vec2_get_y (&self->scale));
   inv_scale = 1.f / scale;
 
   gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_GLYPHS);

gsk/gpu/gskgpurenderer.c

@@ -31,7 +31,6 @@ static const GdkDebugKey gsk_gpu_optimization_keys[] = {
   { "gradients", GSK_GPU_OPTIMIZE_GRADIENTS, "Don't supersample gradients" },
   { "mipmap", GSK_GPU_OPTIMIZE_MIPMAP, "Avoid creating mipmaps" },
   { "glyph-align", GSK_GPU_OPTIMIZE_GLYPH_ALIGN, "Never align glyphs to the subpixel grid" },
-  { "map-buffer", GSK_GPU_OPTIMIZE_MAP_BUFFER, "Don't use glMapBuffer" },
 
   { "gl-baseinstance", GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE, "Assume no ARB/EXT_base_instance support" },
 };

gsk/gpu/gskgpushaderop.c

@@ -23,7 +23,7 @@ gsk_gpu_shader_op_finish (GskGpuOp *op)
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
 
-  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
+  g_clear_object (&self->desc);
 }
 
 #ifdef GDK_RENDERING_VULKAN
@@ -197,7 +197,7 @@ gsk_gpu_shader_op_alloc (GskGpuFrame               *frame,
   self->variation = variation;
   self->clip = clip;
   if (desc)
-    self->desc = gsk_gpu_descriptors_ref (desc);
+    self->desc = g_object_ref (desc);
   else
     self->desc = NULL;
   self->vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size);

gsk/gpu/gskgputypesprivate.h

@@ -119,8 +119,6 @@ typedef enum {
   GSK_GPU_OPTIMIZE_GRADIENTS            = 1 <<  4,
   GSK_GPU_OPTIMIZE_MIPMAP               = 1 <<  5,
   GSK_GPU_OPTIMIZE_GLYPH_ALIGN          = 1 <<  6,
-  GSK_GPU_OPTIMIZE_MAP_BUFFER           = 1 <<  7,
-
   /* These require hardware support */
   GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE     = 1 <<  7,
 } GskGpuOptimizations;

gsk/gpu/gskgpuuploadop.c

@@ -14,6 +14,7 @@
 
 #include "gdk/gdkglcontextprivate.h"
 #include "gsk/gskdebugprivate.h"
+#include "gskvec2private.h"
 
 static GskGpuOp *
 gsk_gpu_upload_op_gl_command_with_area (GskGpuOp                    *op,
@@ -465,8 +466,8 @@ gsk_gpu_upload_cairo_op (GskGpuFrame           *frame,
   self->image = gsk_gpu_device_create_upload_image (gsk_gpu_frame_get_device (frame),
                                                     FALSE,
                                                     GDK_MEMORY_DEFAULT,
-                                                    ceil (graphene_vec2_get_x (scale) * viewport->size.width),
-                                                    ceil (graphene_vec2_get_y (scale) * viewport->size.height));
+                                                    ceil (gsk_vec2_get_x (scale) * viewport->size.width),
+                                                    ceil (gsk_vec2_get_y (scale) * viewport->size.height));
   self->viewport = *viewport;
   self->func = func;
   self->user_data = user_data;

gsk/gpu/gskvulkandescriptors.c

@@ -6,13 +6,22 @@
 #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)
 {
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
-  GskVulkanDescriptorsClass *class = GSK_VULKAN_DESCRIPTORS_CLASS (desc->desc_class);
-
-  return class->get_pipeline_layout (self);
+  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->get_pipeline_layout (self);
 }
 
 void
@@ -39,20 +48,5 @@ gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self,
                              GskVulkanDescriptors *previous,
                              VkCommandBuffer       vk_command_buffer)
 {
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
-  GskVulkanDescriptorsClass *class = GSK_VULKAN_DESCRIPTORS_CLASS (desc->desc_class);
-
-  return class->bind (self, previous, vk_command_buffer);
-}
-
-void
-gsk_vulkan_descriptors_init (GskVulkanDescriptors *self)
-{
-  gsk_gpu_descriptors_init ((GskGpuDescriptors *) self);
-}
-
-void
-gsk_vulkan_descriptors_finalize (GskVulkanDescriptors *self)
-{
-  gsk_gpu_descriptors_finalize ((GskGpuDescriptors *) self);
+  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->bind (self, previous, vk_command_buffer);
 }

gsk/gpu/gskvulkandescriptorsprivate.h

@@ -6,11 +6,14 @@
 
 G_BEGIN_DECLS
 
-typedef struct _GskVulkanDescriptors GskVulkanDescriptors;
-typedef struct _GskVulkanDescriptorsClass GskVulkanDescriptorsClass;
+#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))
 
-#define GSK_VULKAN_DESCRIPTORS(d) ((GskVulkanDescriptors *) (d))
-#define GSK_VULKAN_DESCRIPTORS_CLASS(d) ((GskVulkanDescriptorsClass *) (d))
+typedef struct _GskVulkanDescriptorsClass GskVulkanDescriptorsClass;
 
 struct _GskVulkanDescriptors
 {
@@ -27,6 +30,8 @@ struct _GskVulkanDescriptorsClass
                                                                                  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,
@@ -36,8 +41,7 @@ void                            gsk_vulkan_descriptors_bind
                                                                                  GskVulkanDescriptors   *previous,
                                                                                  VkCommandBuffer         vk_command_buffer);
 
-void                            gsk_vulkan_descriptors_init     (GskVulkanDescriptors *self);
-void                            gsk_vulkan_descriptors_finalize (GskVulkanDescriptors *self);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskVulkanDescriptors, g_object_unref)
 
 G_END_DECLS
 

gsk/gpu/gskvulkanframe.c

@@ -13,16 +13,10 @@
 #include "gdk/gdkdisplayprivate.h"
 #include "gdk/gdkdmabuftextureprivate.h"
 
-static inline void
-gsk_vulkan_real_descriptors_unref (GskVulkanRealDescriptors *desc)
-{
-  gsk_gpu_descriptors_unref (GSK_GPU_DESCRIPTORS (desc));
-}
-
 #define GDK_ARRAY_NAME gsk_descriptors
 #define GDK_ARRAY_TYPE_NAME GskDescriptors
 #define GDK_ARRAY_ELEMENT_TYPE GskVulkanRealDescriptors *
-#define GDK_ARRAY_FREE_FUNC gsk_vulkan_real_descriptors_unref
+#define GDK_ARRAY_FREE_FUNC g_object_unref
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
@@ -268,7 +262,7 @@ gsk_vulkan_frame_create_descriptors (GskGpuFrame *frame)
       desc = gsk_vulkan_real_descriptors_new (self);
       gsk_descriptors_append (&self->descriptors, desc);
 
-      return gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (desc));
+      return GSK_GPU_DESCRIPTORS (g_object_ref (desc));
     }
 }
 

gsk/gpu/gskvulkanrealdescriptors.c

@@ -2,7 +2,9 @@
 
 #include "gskvulkanrealdescriptorsprivate.h"
 
-#define INCLUDE_IMPL 1
+#include "gskvulkanbufferprivate.h"
+#include "gskvulkanframeprivate.h"
+#include "gskvulkanimageprivate.h"
 
 #define GDK_ARRAY_NAME gsk_descriptor_image_infos
 #define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos
@@ -12,8 +14,6 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-#define INCLUDE_IMPL 1
-
 #define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
 #define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
 #define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
@@ -22,8 +22,6 @@
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
-#define INCLUDE_IMPL 1
-
 #define GDK_ARRAY_NAME gsk_samplers
 #define GDK_ARRAY_TYPE_NAME GskSamplers
 #define GDK_ARRAY_ELEMENT_TYPE VkSampler
@@ -31,6 +29,24 @@
 #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)
 {
@@ -138,9 +154,9 @@ gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_real_descriptors_finalize (GskGpuDescriptors *desc)
+gsk_vulkan_real_descriptors_finalize (GObject *object)
 {
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
+  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (object);
 
   gsk_samplers_clear (&self->immutable_samplers);
   gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images);
@@ -150,25 +166,28 @@ gsk_vulkan_real_descriptors_finalize (GskGpuDescriptors *desc)
   gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))),
                                              self->pipeline_layout);
 
-  gsk_vulkan_descriptors_finalize ((GskVulkanDescriptors *) desc);
+  G_OBJECT_CLASS (gsk_vulkan_real_descriptors_parent_class)->finalize (object);
 }
 
-static GskVulkanDescriptorsClass GSK_VULKAN_REAL_DESCRIPTORS_CLASS =
+static void
+gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass)
 {
-  .parent_class = (GskGpuDescriptorsClass) {
-    .finalize = gsk_vulkan_real_descriptors_finalize,
-    .add_image = gsk_vulkan_real_descriptors_add_image,
-    .add_buffer = gsk_vulkan_real_descriptors_add_buffer,
-   },
-  .get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout,
-  .bind = gsk_vulkan_real_descriptors_bind
-};
+  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_vulkan_descriptors_init (GSK_VULKAN_DESCRIPTORS (self));
-
   gsk_samplers_init (&self->immutable_samplers);
   gsk_descriptor_image_infos_init (&self->descriptor_immutable_images);
   gsk_descriptor_image_infos_init (&self->descriptor_images);
@@ -179,15 +198,8 @@ GskVulkanRealDescriptors *
 gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame)
 {
   GskVulkanRealDescriptors *self;
-  GskGpuDescriptors *desc;
 
-  self = g_new0 (GskVulkanRealDescriptors, 1);
-
-  desc = GSK_GPU_DESCRIPTORS (self);
-  desc->ref_count = 1;
-  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_VULKAN_REAL_DESCRIPTORS_CLASS;
-
-  gsk_vulkan_real_descriptors_init (self);
+  self = g_object_new (GSK_TYPE_VULKAN_REAL_DESCRIPTORS, NULL);
 
   self->frame = frame;
 

gsk/gpu/gskvulkanrealdescriptorsprivate.h

@@ -3,61 +3,11 @@
 #include "gskvulkandescriptorsprivate.h"
 #include "gskvulkanframeprivate.h"
 
-#include "gskvulkanbufferprivate.h"
-#include "gskvulkanframeprivate.h"
-#include "gskvulkanimageprivate.h"
-
-#define INCLUDE_DECL 1
-
-#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 INCLUDE_DECL 1
-
-#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 INCLUDE_DECL 1
-
-#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"
-
-
 G_BEGIN_DECLS
 
-typedef struct _GskVulkanRealDescriptors GskVulkanRealDescriptors;
+#define GSK_TYPE_VULKAN_REAL_DESCRIPTORS (gsk_vulkan_real_descriptors_get_type ())
 
-#define GSK_VULKAN_REAL_DESCRIPTORS(d) ((GskVulkanRealDescriptors *) (d))
-
-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_DECLARE_FINAL_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK, VULKAN_REAL_DESCRIPTORS, GskVulkanDescriptors)
 
 GskVulkanRealDescriptors *      gsk_vulkan_real_descriptors_new                 (GskVulkanFrame                 *frame);
 

gsk/gpu/gskvulkansubdescriptors.c

@@ -2,32 +2,15 @@
 
 #include "gskvulkansubdescriptorsprivate.h"
 
-
-static void     gsk_vulkan_sub_descriptors_finalize   (GskGpuDescriptors *desc);
-static gboolean gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
-                                                       GskGpuBuffer      *buffer,
-                                                       guint32           *out_descriptor);
-static gboolean gsk_vulkan_sub_descriptors_add_image  (GskGpuDescriptors *desc,
-                                                       GskGpuImage       *image,
-                                                       GskGpuSampler      sampler,
-                                                       guint32           *out_descriptor);
-static GskVulkanPipelineLayout *
-                gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc);
-static void     gsk_vulkan_sub_descriptors_bind       (GskVulkanDescriptors *desc,
-                                                       GskVulkanDescriptors *previous,
-                                                       VkCommandBuffer       vk_command_buffer);
-
-static GskVulkanDescriptorsClass GSK_VULKAN_SUB_DESCRIPTORS_CLASS =
+struct _GskVulkanSubDescriptors
 {
-  .parent_class = (GskGpuDescriptorsClass) {
-    .finalize = gsk_vulkan_sub_descriptors_finalize,
-    .add_image = gsk_vulkan_sub_descriptors_add_image,
-    .add_buffer = gsk_vulkan_sub_descriptors_add_buffer,
-  },
-  .get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout,
-  .bind = gsk_vulkan_sub_descriptors_bind,
+  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)
 {
@@ -43,7 +26,7 @@ gsk_vulkan_sub_descriptors_bind (GskVulkanDescriptors *desc,
 {
   GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
 
-  if (GSK_GPU_DESCRIPTORS (previous)->desc_class == (GskGpuDescriptorsClass *) &GSK_VULKAN_SUB_DESCRIPTORS_CLASS)
+  if (GSK_IS_VULKAN_SUB_DESCRIPTORS (previous))
     previous = GSK_VULKAN_SUB_DESCRIPTORS (previous)->parent;
 
   if (self->parent == previous)
@@ -79,35 +62,45 @@ gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_sub_descriptors_finalize (GskGpuDescriptors *desc)
+gsk_vulkan_sub_descriptors_finalize (GObject *object)
 {
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
+  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (object);
 
-  gsk_gpu_descriptors_unref (GSK_GPU_DESCRIPTORS (self->parent));
+  g_object_unref (self->parent);
 
-  gsk_vulkan_descriptors_finalize (GSK_VULKAN_DESCRIPTORS (self));
+  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)
 {
-  gsk_vulkan_descriptors_init (GSK_VULKAN_DESCRIPTORS (self));
 }
 
 GskVulkanSubDescriptors *
 gsk_vulkan_sub_descriptors_new (GskVulkanDescriptors *parent)
 {
   GskVulkanSubDescriptors *self;
-  GskGpuDescriptors *desc;
 
-  self = g_new0 (GskVulkanSubDescriptors, 1);
-  desc = GSK_GPU_DESCRIPTORS (self);
+  self = g_object_new (GSK_TYPE_VULKAN_SUB_DESCRIPTORS, NULL);
 
-  desc->ref_count = 1;
-  desc->desc_class = (GskGpuDescriptorsClass *) &GSK_VULKAN_SUB_DESCRIPTORS_CLASS;
-  gsk_vulkan_sub_descriptors_init (self);
-
-  self->parent = GSK_VULKAN_DESCRIPTORS (gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (parent)));
+  self->parent = g_object_ref (parent);
 
   return self;
 }
+

gsk/gpu/gskvulkansubdescriptorsprivate.h

@@ -4,16 +4,9 @@
 
 G_BEGIN_DECLS
 
-typedef struct _GskVulkanSubDescriptors GskVulkanSubDescriptors;
+#define GSK_TYPE_VULKAN_SUB_DESCRIPTORS (gsk_vulkan_sub_descriptors_get_type ())
 
-#define GSK_VULKAN_SUB_DESCRIPTORS(d) ((GskVulkanSubDescriptors *) (d))
-
-struct _GskVulkanSubDescriptors
-{
-  GskVulkanDescriptors parent_instance;
-
-  GskVulkanDescriptors *parent;
-};
+G_DECLARE_FINAL_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK, VULKAN_SUB_DESCRIPTORS, GskVulkanDescriptors)
 
 GskVulkanSubDescriptors *       gsk_vulkan_sub_descriptors_new          (GskVulkanDescriptors           *parent);
 

gsk/gskvec2private.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <graphene.h>
+#include <math.h>
+
+static inline float
+gsk_vec2_get_x (const graphene_vec2_t *v)
+{
+  return graphene_simd4f_get_x (v->__graphene_private_value);
+}
+
+static inline float
+gsk_vec2_get_y (const graphene_vec2_t *v)
+{
+  return graphene_simd4f_get_y (v->__graphene_private_value);
+}
+
+static inline graphene_vec2_t *
+gsk_vec2_init (graphene_vec2_t *v,
+               float            x,
+               float            y)
+{
+  v->__graphene_private_value = graphene_simd4f_init (x, y, 0.f, 0.f);
+
+  return v;
+}
+
+static inline void
+gsk_vec2_multiply (const graphene_vec2_t *a,
+                   const graphene_vec2_t *b,
+                   graphene_vec2_t       *res)
+{
+  res->__graphene_private_value = graphene_simd4f_mul (a->__graphene_private_value,
+                                                       b->__graphene_private_value);
+}
+
+static inline bool
+gsk_vec2_equal (const graphene_vec2_t *v1,
+                const graphene_vec2_t *v2)
+{
+  return graphene_simd4f_cmp_eq (v1->__graphene_private_value, v2->__graphene_private_value);
+}
+

gsk/meson.build

@@ -68,7 +68,6 @@ gsk_private_sources = files([
   'gl/stb_rect_pack.c',
   'gl/fp16.c',
   'gpu/gskglbuffer.c',
-  'gpu/gskglmapbuffer.c',
   'gpu/gskgldevice.c',
   'gpu/gskgldescriptors.c',
   'gpu/gskglframe.c',