gpu: Make GskGpuDescriptors non-objects

This is a bit involved, since we have to deal with subclassing
here, but in the end it works out ok. And it make g_object_ref
and g_object_unref disappear from the profiles.

gsk/gpu/gskgldescriptors.c

@@ -5,6 +5,7 @@
 #include "gskglbufferprivate.h"
 #include "gskglimageprivate.h"
 
+
 struct _GskGLDescriptors
 {
   GskGpuDescriptors parent_instance;
@@ -13,16 +14,12 @@ struct _GskGLDescriptors
   guint n_external;
 };
 
-G_DEFINE_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK_TYPE_GPU_DESCRIPTORS)
-
 static void
-gsk_gl_descriptors_finalize (GObject *object)
+gsk_gl_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (object);
+  GskGLDescriptors *self = GSK_GL_DESCRIPTORS (desc);
 
   g_object_unref (self->device);
-
-  G_OBJECT_CLASS (gsk_gl_descriptors_parent_class)->finalize (object);
 }
 
 static gboolean
@@ -72,33 +69,24 @@ gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc,
   return TRUE;
 }
 
-static void
+static GskGpuDescriptorsClass GSK_GL_DESCRIPTORS_CLASS =
-gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass)
 {
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
+  .finalize = gsk_gl_descriptors_finalize,
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  .add_image = gsk_gl_descriptors_add_image,
-
+  .add_buffer = gsk_gl_descriptors_add_buffer,
-  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_object_new (GSK_TYPE_GL_DESCRIPTORS, NULL);
+  desc = gsk_gpu_descriptors_new ((GskGpuDescriptorsClass *) &GSK_GL_DESCRIPTORS_CLASS,
+                                  sizeof (GskGLDescriptors));
 
-  self->device = g_object_ref (device);
+  GSK_GL_DESCRIPTORS (desc)->device = g_object_ref (device);
 
-  return GSK_GPU_DESCRIPTORS (self);
+  return desc;
 }
 
 guint
@@ -110,7 +98,7 @@ gsk_gl_descriptors_get_n_external (GskGLDescriptors *self)
 void
 gsk_gl_descriptors_use (GskGLDescriptors *self)
 {
-  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
+  GskGpuDescriptors *desc = &self->parent_instance;
   gsize i, ext, n_textures;
 
   n_textures = 16 - 3 * self->n_external;

gsk/gpu/gskgldescriptorsprivate.h

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

gsk/gpu/gskgpudescriptors.c

@@ -52,43 +52,39 @@ gsk_gpu_buffer_entry_clear (gpointer data)
 #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 inline GskGpuDescriptorsPrivate *
-
+gsk_gpu_descriptors_get_instance_private (GskGpuDescriptors *self)
-static void
-gsk_gpu_descriptors_finalize (GObject *object)
 {
-  GskGpuDescriptors *self = GSK_GPU_DESCRIPTORS (object);
+  return (GskGpuDescriptorsPrivate *) (((guchar *)self) - sizeof (GskGpuDescriptorsPrivate));
-  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
+/* Just for subclasses */
-gsk_gpu_descriptors_class_init (GskGpuDescriptorsClass *klass)
+GskGpuDescriptors *
+gsk_gpu_descriptors_new (GskGpuDescriptorsClass *desc_class,
+                         gsize                   child_size)
 {
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GskGpuDescriptors *self;
+  GskGpuDescriptorsPrivate *priv;
+  guchar *data;
 
-  object_class->finalize = gsk_gpu_descriptors_finalize;
+  data = g_new0 (guchar, child_size + sizeof (GskGpuDescriptorsPrivate));
-}
 
-static void
+  priv = (GskGpuDescriptorsPrivate *) data;
-gsk_gpu_descriptors_init (GskGpuDescriptors *self)
+  self = (GskGpuDescriptors *) (data + sizeof (GskGpuDescriptorsPrivate));
-{
+
-  GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+  self->ref_count = 1;
+  self->desc_class = desc_class;
 
   gsk_gpu_image_entries_init (&priv->images);
   gsk_gpu_buffer_entries_init (&priv->buffers);
+
+  return self;
 }
 
 gsize
@@ -189,7 +185,7 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self,
         }
     }
 
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_image (self, image, sampler, &descriptor))
+  if (!self->desc_class->add_image (self, image, sampler, &descriptor))
     return FALSE;
 
   gsk_gpu_image_entries_append (&priv->images,
@@ -224,7 +220,7 @@ gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self,
         }
     }
 
-  if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor))
+  if (!self->desc_class->add_buffer (self, buffer, &descriptor))
     return FALSE;
 
   gsk_gpu_buffer_entries_append (&priv->buffers,
@@ -238,3 +234,28 @@ 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)
+    {
+      GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self);
+
+      self->desc_class->finalize (self);
+
+      gsk_gpu_image_entries_clear (&priv->images);
+      gsk_gpu_buffer_entries_clear (&priv->buffers);
+
+      g_free (priv);
+    }
+}

gsk/gpu/gskgpudescriptorsprivate.h

@@ -4,24 +4,23 @@
 
 G_BEGIN_DECLS
 
-#define GSK_TYPE_GPU_DESCRIPTORS         (gsk_gpu_descriptors_get_type ())
+typedef struct _GskGpuDescriptors GskGpuDescriptors;
-#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;
+typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate;
+
+#define GSK_GPU_DESCRIPTORS(d) ((GskGpuDescriptors *) (d))
 
 struct _GskGpuDescriptors
 {
-  GObject parent_instance;
+  GskGpuDescriptorsClass *desc_class;
+  int ref_count;
+
+  GskGpuDescriptorsPrivate *priv;
 };
 
 struct _GskGpuDescriptorsClass
 {
-  GObjectClass parent_class;
+  void                  (* finalize)                                    (GskGpuDescriptors      *self);
-
   gboolean              (* add_image)                                   (GskGpuDescriptors      *self,
                                                                          GskGpuImage            *image,
                                                                          GskGpuSampler           sampler,
@@ -31,7 +30,8 @@ struct _GskGpuDescriptorsClass
                                                                          guint32                *out_id);
 };
 
-GType                   gsk_gpu_descriptors_get_type                    (void) G_GNUC_CONST;
+GskGpuDescriptors *     gsk_gpu_descriptors_ref                         (GskGpuDescriptors      *self);
+void                    gsk_gpu_descriptors_unref                       (GskGpuDescriptors      *self);
 
 gsize                   gsk_gpu_descriptors_get_n_images                (GskGpuDescriptors      *self);
 gsize                   gsk_gpu_descriptors_get_n_buffers               (GskGpuDescriptors      *self);
@@ -55,7 +55,8 @@ gboolean                gsk_gpu_descriptors_add_buffer                  (GskGpuD
                                                                          GskGpuBuffer           *buffer,
                                                                          guint32                *out_descriptor);
 
+GskGpuDescriptors      *gsk_gpu_descriptors_new                         (GskGpuDescriptorsClass *desc_class,
+                                                                         gsize                   child_size);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref)
 
 G_END_DECLS

gsk/gpu/gskgpunodeprocessor.c

@@ -152,7 +152,7 @@ static void
 gsk_gpu_node_processor_finish (GskGpuNodeProcessor *self)
 {
   g_clear_pointer (&self->modelview, gsk_transform_unref);
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 static void
@@ -170,7 +170,7 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->frame = frame;
   if (desc)
-    self->desc = g_object_ref (desc);
+    self->desc = gsk_gpu_descriptors_ref (desc);
   else
     self->desc = NULL;
 
@@ -268,7 +268,7 @@ gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self,
       if (gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor))
         return descriptor;
 
-      g_object_unref (self->desc);
+      gsk_gpu_descriptors_unref (self->desc);
     }
 
   self->desc = gsk_gpu_frame_create_descriptors (self->frame);
@@ -545,7 +545,7 @@ gsk_gpu_pattern_writer_finish (GskGpuPatternWriter *self)
 {
   pattern_buffer_clear (&self->buffer);
   g_assert (self->stack == 0);
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 static gboolean

gsk/gpu/gskgpushaderop.c

@@ -23,7 +23,7 @@ gsk_gpu_shader_op_finish (GskGpuOp *op)
 {
   GskGpuShaderOp *self = (GskGpuShaderOp *) op;
 
-  g_clear_object (&self->desc);
+  g_clear_pointer (&self->desc, gsk_gpu_descriptors_unref);
 }
 
 #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 = g_object_ref (desc);
+    self->desc = gsk_gpu_descriptors_ref (desc);
   else
     self->desc = NULL;
   self->vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size);

gsk/gpu/gskvulkandescriptors.c

@@ -6,22 +6,13 @@
 #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);
+  GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self);
+  GskVulkanDescriptorsClass *class = GSK_VULKAN_DESCRIPTORS_CLASS (desc->desc_class);
+
+  return class->get_pipeline_layout (self);
 }
 
 void
@@ -48,5 +39,19 @@ gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self,
                              GskVulkanDescriptors *previous,
                              VkCommandBuffer       vk_command_buffer)
 {
-  return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->bind (self, previous, 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);
+}
+
+GskVulkanDescriptors *
+gsk_vulkan_descriptors_new (GskVulkanDescriptorsClass *desc_class,
+                            gsize                      child_size)
+{
+  GskGpuDescriptors *desc;
+
+  desc = gsk_gpu_descriptors_new ((GskGpuDescriptorsClass *)desc_class, child_size);
+
+  return GSK_VULKAN_DESCRIPTORS (desc);
 }

gsk/gpu/gskvulkandescriptorsprivate.h

@@ -6,15 +6,12 @@
 
 G_BEGIN_DECLS
 
-#define GSK_TYPE_VULKAN_DESCRIPTORS         (gsk_vulkan_descriptors_get_type ())
+typedef struct _GskVulkanDescriptors GskVulkanDescriptors;
-#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;
 
+#define GSK_VULKAN_DESCRIPTORS(d) ((GskVulkanDescriptors *) (d))
+#define GSK_VULKAN_DESCRIPTORS_CLASS(d) ((GskVulkanDescriptorsClass *) (d))
+
 struct _GskVulkanDescriptors
 {
   GskGpuDescriptors parent_instance;
@@ -30,8 +27,6 @@ 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,
@@ -41,7 +36,9 @@ void                            gsk_vulkan_descriptors_bind
                                                                                  GskVulkanDescriptors   *previous,
                                                                                  VkCommandBuffer         vk_command_buffer);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskVulkanDescriptors, g_object_unref)
+GskVulkanDescriptors *         gsk_vulkan_descriptors_new                       (GskVulkanDescriptorsClass *desc_class,
+                                                                                 gsize                      child_size);
+
 
 G_END_DECLS
 

gsk/gpu/gskvulkanframe.c

@@ -13,10 +13,16 @@
 #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 g_object_unref
+#define GDK_ARRAY_FREE_FUNC gsk_vulkan_real_descriptors_unref
 #define GDK_ARRAY_NO_MEMSET 1
 #include "gdk/gdkarrayimpl.c"
 
@@ -262,7 +268,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 (g_object_ref (desc));
+      return gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (desc));
     }
 }
 

gsk/gpu/gskvulkanrealdescriptors.c

@@ -2,10 +2,6 @@
 
 #include "gskvulkanrealdescriptorsprivate.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
@@ -45,8 +41,6 @@ struct _GskVulkanRealDescriptors
   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)
 {
@@ -154,9 +148,9 @@ gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_real_descriptors_finalize (GObject *object)
+gsk_vulkan_real_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (object);
+  GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
 
   gsk_samplers_clear (&self->immutable_samplers);
   gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images);
@@ -165,25 +159,18 @@ gsk_vulkan_real_descriptors_finalize (GObject *object)
 
   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
+static GskVulkanDescriptorsClass GSK_VULKAN_REAL_DESCRIPTORS_CLASS =
-gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass)
 {
-  GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass);
+  .parent_class = (GskGpuDescriptorsClass) {
-  GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass);
+    .finalize = gsk_vulkan_real_descriptors_finalize,
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+    .add_image = gsk_vulkan_real_descriptors_add_image,
-
+    .add_buffer = gsk_vulkan_real_descriptors_add_buffer,
-  object_class->finalize = gsk_vulkan_real_descriptors_finalize;
+   },
-
+  .get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout,
-  descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image;
+  .bind = gsk_vulkan_real_descriptors_bind
-  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)
@@ -198,9 +185,14 @@ GskVulkanRealDescriptors *
 gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame)
 {
   GskVulkanRealDescriptors *self;
+  GskVulkanDescriptors *desc;
 
-  self = g_object_new (GSK_TYPE_VULKAN_REAL_DESCRIPTORS, NULL);
+  desc = gsk_vulkan_descriptors_new (&GSK_VULKAN_REAL_DESCRIPTORS_CLASS,
+                                     sizeof (GskVulkanRealDescriptors));
 
+  self = GSK_VULKAN_REAL_DESCRIPTORS (desc);
+
+  gsk_vulkan_real_descriptors_init (self);
   self->frame = frame;
 
   return self;

gsk/gpu/gskvulkanrealdescriptorsprivate.h

@@ -3,11 +3,17 @@
 #include "gskvulkandescriptorsprivate.h"
 #include "gskvulkanframeprivate.h"
 
+#include "gskvulkanbufferprivate.h"
+#include "gskvulkanframeprivate.h"
+#include "gskvulkanimageprivate.h"
+
+
 G_BEGIN_DECLS
 
-#define GSK_TYPE_VULKAN_REAL_DESCRIPTORS (gsk_vulkan_real_descriptors_get_type ())
+typedef struct _GskVulkanRealDescriptors GskVulkanRealDescriptors;
+
+#define GSK_VULKAN_REAL_DESCRIPTORS(d) ((GskVulkanRealDescriptors *) (d))
 
-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,6 +2,7 @@
 
 #include "gskvulkansubdescriptorsprivate.h"
 
+
 struct _GskVulkanSubDescriptors
 {
   GskVulkanDescriptors parent_instance;
@@ -9,7 +10,31 @@ struct _GskVulkanSubDescriptors
   GskVulkanDescriptors *parent;
 };
 
-G_DEFINE_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS)
+
+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 =
+{
+  .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,
+};
 
 static GskVulkanPipelineLayout *
 gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc)
@@ -26,7 +51,7 @@ gsk_vulkan_sub_descriptors_bind (GskVulkanDescriptors *desc,
 {
   GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
 
-  if (GSK_IS_VULKAN_SUB_DESCRIPTORS (previous))
+  if (GSK_GPU_DESCRIPTORS (previous)->desc_class == (GskGpuDescriptorsClass *) &GSK_VULKAN_SUB_DESCRIPTORS_CLASS)
     previous = GSK_VULKAN_SUB_DESCRIPTORS (previous)->parent;
 
   if (self->parent == previous)
@@ -62,45 +87,24 @@ gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc,
 }
 
 static void
-gsk_vulkan_sub_descriptors_finalize (GObject *object)
+gsk_vulkan_sub_descriptors_finalize (GskGpuDescriptors *desc)
 {
-  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (object);
+  GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
 
-  g_object_unref (self->parent);
+  gsk_gpu_descriptors_unref (GSK_GPU_DESCRIPTORS (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;
+  GskVulkanDescriptors *desc;
 
-  self = g_object_new (GSK_TYPE_VULKAN_SUB_DESCRIPTORS, NULL);
+  desc = gsk_vulkan_descriptors_new (&GSK_VULKAN_SUB_DESCRIPTORS_CLASS,
+                                     sizeof (GskVulkanSubDescriptors));
 
-  self->parent = g_object_ref (parent);
+  self = GSK_VULKAN_SUB_DESCRIPTORS (desc);
+  self->parent = GSK_VULKAN_DESCRIPTORS (gsk_gpu_descriptors_ref (GSK_GPU_DESCRIPTORS (parent)));
 
   return self;
 }
-

gsk/gpu/gskvulkansubdescriptorsprivate.h

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