stroke: Add support for dashes

... and hook it up in the node parser and for Cairo rendering.

.flake8

@@ -1,2 +0,0 @@
-[flake8]
-ignore = E501

NEWS

@@ -1,7 +1,4 @@
-Overview of Changes in 4.11.5, xx-xx-xxxx
-=========================================
-
-Overview of Changes in 4.11.4, 03-07-2023
+Overview of Changes in 4.11.4, xx-xx-xxxx
 =========================================
 
 * GtkFileChooser:
@@ -29,9 +26,6 @@ Overview of Changes in 4.11.4, 03-07-2023
 * GtkDropDown:
  - Update on expression changes
 
-* GtkMapListModel:
- - Implement GtkSectionModel
-
 * Accessibility:
  - Improvements all over the place: GtkButton, GtkPasswordEntry,
    GtkFontChooserDialog, GtkColorChooserDialog, GtkShortcutsWindow,
@@ -78,7 +72,6 @@ Overview of Changes in 4.11.4, 03-07-2023
 * Build:
  - Require GLib 2.76
  - Make asan builds work again
- - Fix the build if ld is not ld.bdf
 
 * Translation updates:
  Brazilian Portuguese

demos/gtk-demo/demo.gresource.xml

@@ -335,6 +335,9 @@
     <file>paintable_symbolic.c</file>
     <file>panes.c</file>
     <file>password_entry.c</file>
+    <file>path_fill.c</file>
+    <file>path_maze.c</file>
+    <file>path_text.c</file>
     <file>peg_solitaire.c</file>
     <file>pickers.c</file>
     <file>printing.c</file>
@@ -420,6 +423,9 @@
   <gresource prefix="/fontrendering">
     <file>fontrendering.ui</file>
   </gresource>
+  <gresource prefix="/path_text">
+    <file>path_text.ui</file>
+  </gresource>
   <gresource prefix="/org/gtk/Demo4">
     <file>icons/16x16/actions/application-exit.png</file>
     <file>icons/16x16/actions/document-new.png</file>

demos/gtk-demo/meson.build

@@ -72,6 +72,9 @@ demos = files([
   'paintable_symbolic.c',
   'panes.c',
   'password_entry.c',
+  'path_fill.c',
+  'path_maze.c',
+  'path_text.c',
   'peg_solitaire.c',
   'pickers.c',
   'printing.c',

demos/gtk-demo/path_fill.c

@@ -0,0 +1,321 @@
+/* Path/Fill
+ *
+ * This demo shows how to use PangoCairo to draw text with more than
+ * just a single color.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#define GTK_TYPE_PATH_PAINTABLE (gtk_path_paintable_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathPaintable, gtk_path_paintable, GTK, PATH_PAINTABLE, GObject)
+
+struct _GtkPathPaintable
+{
+  GObject parent_instance;
+
+  int width;
+  int height;
+  GskPath *path;
+  GdkPaintable *background;
+};
+
+struct _GtkPathPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+static int
+gtk_path_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return MAX (gdk_paintable_get_intrinsic_width (self->background), self->width);
+  else
+    return self->width;
+}
+
+static int
+gtk_path_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return MAX (gdk_paintable_get_intrinsic_height (self->background), self->height);
+  else
+    return self->height;
+}
+
+static void
+gtk_path_paintable_snapshot (GdkPaintable *paintable,
+                             GdkSnapshot  *snapshot,
+                             double        width,
+                             double        height)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+#if 0
+  gtk_snapshot_push_fill (snapshot, self->path, GSK_FILL_RULE_WINDING);
+#else
+  GskStroke *stroke = gsk_stroke_new (4.0);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gsk_stroke_free (stroke);
+#endif
+
+  if (self->background)
+    {
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+    }
+  else
+    {
+      gtk_snapshot_append_linear_gradient (snapshot,
+                                           &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                           &GRAPHENE_POINT_INIT (0, 0),
+                                           &GRAPHENE_POINT_INIT (width, height),
+                                           (GskColorStop[8]) {
+                                             { 0.0, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.2, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.3, { 1.0, 1.0, 0.0, 1.0 } },
+                                             { 0.4, { 0.0, 1.0, 0.0, 1.0 } },
+                                             { 0.6, { 0.0, 1.0, 1.0, 1.0 } },
+                                             { 0.7, { 0.0, 0.0, 1.0, 1.0 } },
+                                             { 0.8, { 1.0, 0.0, 1.0, 1.0 } },
+                                             { 1.0, { 1.0, 0.0, 1.0, 1.0 } }
+                                           },
+                                           8);
+    }
+
+  gtk_snapshot_pop (snapshot);
+
+}
+
+static GdkPaintableFlags
+gtk_path_paintable_get_flags (GdkPaintable *paintable)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (paintable);
+
+  if (self->background)
+    return gdk_paintable_get_flags (self->background);
+  else
+    return GDK_PAINTABLE_STATIC_CONTENTS | GDK_PAINTABLE_STATIC_SIZE;
+}
+
+static void
+gtk_path_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->get_intrinsic_width = gtk_path_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_path_paintable_get_intrinsic_height;
+  iface->snapshot = gtk_path_paintable_snapshot;
+  iface->get_flags = gtk_path_paintable_get_flags;
+}
+
+/* When defining the GType, we need to implement the GdkPaintable interface */
+G_DEFINE_TYPE_WITH_CODE (GtkPathPaintable, gtk_path_paintable, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                                gtk_path_paintable_paintable_init))
+
+/* Here's the boilerplate for the GObject declaration.
+ * We need to disconnect the signals here that we set up elsewhere
+ */
+static void 
+gtk_path_paintable_dispose (GObject *object)
+{
+  GtkPathPaintable *self = GTK_PATH_PAINTABLE (object);
+
+  if (self->background)
+    {
+      g_signal_handlers_disconnect_by_func (self->background, gdk_paintable_invalidate_contents, self);
+      g_signal_handlers_disconnect_by_func (self->background, gdk_paintable_invalidate_size, self);
+      g_clear_object (&self->background);
+    }
+
+  G_OBJECT_CLASS (gtk_path_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_paintable_class_init (GtkPathPaintableClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_paintable_dispose;
+}
+
+static void
+gtk_path_paintable_init (GtkPathPaintable *self)
+{
+}
+
+/* And finally, we add a simple constructor.
+ * It is declared in the header so that the other examples
+ * can use it.
+ */
+GdkPaintable *
+gtk_path_paintable_new (GskPath      *path,
+                        GdkPaintable *background,
+                        int           width,
+                        int           height)
+{
+  GtkPathPaintable *self;
+
+  self = g_object_new (GTK_TYPE_PATH_PAINTABLE, NULL);
+  self->path = path;
+  self->background = background;
+  if (self->background)
+    {
+      g_object_ref (self->background);
+      g_signal_connect_swapped (self->background, "invalidate-contents", G_CALLBACK (gdk_paintable_invalidate_contents), self);
+      g_signal_connect_swapped (self->background, "invalidate-size", G_CALLBACK (gdk_paintable_invalidate_size), self);
+    }
+  self->width = width;
+  self->height = height;
+
+  return GDK_PAINTABLE (self);
+}
+
+void
+gtk_path_paintable_set_path (GtkPathPaintable *self,
+                             GskPath          *path)
+{
+  g_clear_pointer (&self->path, gsk_path_unref);
+  self->path = gsk_path_ref (path);
+
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+static GskPath *
+create_hexagon (GtkWidget *widget)
+{
+  GskPathBuilder *builder;
+
+  builder = gsk_path_builder_new ();
+
+  gsk_path_builder_move_to (builder, 120, 0);
+  gsk_path_builder_line_to (builder, 360, 0);
+  gsk_path_builder_line_to (builder, 480, 208);
+  gsk_path_builder_line_to (builder, 360, 416);
+  gsk_path_builder_line_to (builder, 120, 416);
+  gsk_path_builder_line_to (builder, 0, 208);
+  gsk_path_builder_close (builder);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+static GskPath *
+create_path_from_text (GtkWidget *widget)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+  cairo_path_t *path;
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+  GskPath *result;
+
+  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
+  cr = cairo_create (surface);
+
+  layout = gtk_widget_create_pango_layout (widget, "Pango power!\nPango power!\nPango power!");
+  desc = pango_font_description_from_string ("sans bold 36");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  pango_cairo_layout_path (cr, layout);
+  path = cairo_copy_path_flat (cr);
+  result = gsk_path_new_from_cairo (path);
+
+  cairo_path_destroy (path);
+  g_object_unref (layout);
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+
+  return result;
+}
+
+static gboolean
+update_path (GtkWidget     *widget,
+             GdkFrameClock *frame_clock,
+             gpointer       measure)
+{
+  float progress = gdk_frame_clock_get_frame_time (frame_clock) % (60 * G_USEC_PER_SEC) / (float) (30 * G_USEC_PER_SEC);
+  GskPathBuilder *builder;
+  GskPath *path;
+  graphene_point_t pos;
+  graphene_vec2_t tangent;
+
+  builder = gsk_path_builder_new ();
+  gsk_path_measure_add_segment (measure,
+                                builder,
+                                progress > 1 ? (progress - 1) * gsk_path_measure_get_length (measure) : 0.0,
+                                (progress < 1 ? progress : 1.0) * gsk_path_measure_get_length (measure));
+
+  gsk_path_measure_get_point (measure,
+                              (progress > 1 ? (progress - 1) : progress) * gsk_path_measure_get_length (measure),
+                              &pos,
+                              &tangent);
+  gsk_path_builder_move_to (builder, pos.x + 5 * graphene_vec2_get_x (&tangent), pos.y + 5 * graphene_vec2_get_y (&tangent));
+  gsk_path_builder_line_to (builder, pos.x + 3 * graphene_vec2_get_y (&tangent), pos.y + 3 * graphene_vec2_get_x (&tangent));
+  gsk_path_builder_line_to (builder, pos.x - 3 * graphene_vec2_get_y (&tangent), pos.y - 3 * graphene_vec2_get_x (&tangent));
+  gsk_path_builder_close (builder);
+  path = gsk_path_builder_free_to_path (builder);
+
+  gtk_path_paintable_set_path (GTK_PATH_PAINTABLE (gtk_picture_get_paintable (GTK_PICTURE (widget))),
+                               path);
+  gsk_path_unref (path);
+
+  return G_SOURCE_CONTINUE;
+}
+
+GtkWidget *
+do_path_fill (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *picture;
+      GdkPaintable *paintable;
+      GtkMediaStream *stream;
+      GskPath *path;
+      graphene_rect_t bounds;
+      GskPathMeasure *measure;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Path Fill");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+#if 0
+      stream = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
+#else
+      stream = gtk_nuclear_media_stream_new ();
+#endif
+      gtk_media_stream_play (stream);
+      gtk_media_stream_set_loop (stream, TRUE);
+
+      path = create_hexagon (window);
+      path = create_path_from_text (window);
+      gsk_path_get_bounds (path, &bounds);
+
+      paintable = gtk_path_paintable_new (path,
+                                          GDK_PAINTABLE (stream),
+                                          bounds.origin.x + bounds.size.width,
+                                          bounds.origin.y + bounds.size.height);
+      picture = gtk_picture_new_for_paintable (paintable);
+      measure = gsk_path_measure_new (path);
+      gtk_widget_add_tick_callback (picture, update_path, measure, (GDestroyNotify) gsk_path_measure_unref);
+      gtk_picture_set_content_fit (GTK_PICTURE (picture), GTK_CONTENT_FIT_CONTAIN);
+      gtk_picture_set_can_shrink (GTK_PICTURE (picture), FALSE);
+      g_object_unref (paintable);
+
+      gtk_window_set_child (GTK_WINDOW (window), picture);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/path_maze.c

@@ -0,0 +1,338 @@
+/* Path/Maze
+ *
+ * This demo shows how to use a GskPath to create a maze and use
+ * gsk_path_measure_get_closest_point() to check the mouse stays
+ * on the path.
+ *
+ * It also shows off the performance of GskPath (or not) as this
+ * is a rather complex path.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "paintable.h"
+
+#define MAZE_GRID_SIZE 20
+#define MAZE_STROKE_SIZE_ACTIVE (MAZE_GRID_SIZE - 4)
+#define MAZE_STROKE_SIZE_INACTIVE (MAZE_GRID_SIZE - 12)
+#define MAZE_WIDTH 31
+#define MAZE_HEIGHT 21
+
+#define GTK_TYPE_MAZE (gtk_maze_get_type ())
+G_DECLARE_FINAL_TYPE (GtkMaze, gtk_maze, GTK, MAZE, GtkWidget)
+
+struct _GtkMaze
+{
+  GtkWidget parent_instance;
+
+  int width;
+  int height;
+  GskPath *path;
+  GskPathMeasure *measure;
+  GdkPaintable *background;
+
+  gboolean active;
+};
+
+struct _GtkMazeClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GtkMaze, gtk_maze, GTK_TYPE_WIDGET)
+
+static void
+gtk_maze_measure (GtkWidget      *widget,
+                  GtkOrientation  orientation,
+                  int             for_size,
+                  int            *minimum,
+                  int            *natural,
+                  int            *minimum_baseline,
+                  int            *natural_baseline)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = self->width;
+  else
+    *minimum = *natural = self->height;
+}
+
+static void
+gtk_maze_snapshot (GtkWidget   *widget,
+                   GdkSnapshot *snapshot)
+{
+  GtkMaze *self = GTK_MAZE (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskStroke *stroke;
+
+  stroke = gsk_stroke_new (MAZE_STROKE_SIZE_INACTIVE);
+  if (self->active)
+    gsk_stroke_set_line_width (stroke, MAZE_STROKE_SIZE_ACTIVE);
+  gsk_stroke_set_line_join (stroke, GSK_LINE_JOIN_ROUND);
+  gsk_stroke_set_line_cap (stroke, GSK_LINE_CAP_ROUND);
+  gtk_snapshot_push_stroke (snapshot, self->path, stroke);
+  gsk_stroke_free (stroke);
+
+  if (self->background)
+    {
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+    }
+  else
+    {
+      gtk_snapshot_append_linear_gradient (snapshot,
+                                           &GRAPHENE_RECT_INIT (0, 0, width, height),
+                                           &GRAPHENE_POINT_INIT (0, 0),
+                                           &GRAPHENE_POINT_INIT (width, height),
+                                           (GskColorStop[8]) {
+                                             { 0.0, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.2, { 1.0, 0.0, 0.0, 1.0 } },
+                                             { 0.3, { 1.0, 1.0, 0.0, 1.0 } },
+                                             { 0.4, { 0.0, 1.0, 0.0, 1.0 } },
+                                             { 0.6, { 0.0, 1.0, 1.0, 1.0 } },
+                                             { 0.7, { 0.0, 0.0, 1.0, 1.0 } },
+                                             { 0.8, { 1.0, 0.0, 1.0, 1.0 } },
+                                             { 1.0, { 1.0, 0.0, 1.0, 1.0 } }
+                                           },
+                                           8);
+    }
+
+  gtk_snapshot_pop (snapshot);
+
+}
+
+static void
+gtk_maze_dispose (GObject *object)
+{
+  GtkMaze *self = GTK_MAZE (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  if (self->background)
+    {
+      g_signal_handlers_disconnect_matched (self->background, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, self);
+      g_clear_object (&self->background);
+    }
+
+  G_OBJECT_CLASS (gtk_maze_parent_class)->dispose (object);
+}
+
+static void
+gtk_maze_class_init (GtkMazeClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_maze_dispose;
+
+  widget_class->measure = gtk_maze_measure;
+  widget_class->snapshot = gtk_maze_snapshot;
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkMaze                  *self)
+{
+  if (!self->active)
+    return;
+
+  if (gsk_path_measure_get_closest_point (self->measure, &GRAPHENE_POINT_INIT (x, y), NULL) <= MAZE_STROKE_SIZE_ACTIVE / 2.0f)
+    return;
+
+  self->active = FALSE;
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkMaze                  *self)
+{
+  if (!self->active)
+    {
+      self->active = TRUE;
+      gtk_widget_queue_draw (GTK_WIDGET (self));
+    }
+}
+
+static void
+gtk_maze_init (GtkMaze *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->active = TRUE;
+}
+
+static void
+gtk_maze_set_path (GtkMaze *self,
+                   GskPath *path)
+{
+  g_clear_pointer (&self->path, gsk_path_unref);
+  g_clear_pointer (&self->measure, gsk_path_measure_unref);
+  self->path = gsk_path_ref (path);
+  self->measure = gsk_path_measure_new (path);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+GtkWidget *
+gtk_maze_new (GskPath      *path,
+              GdkPaintable *background,
+              int           width,
+              int           height)
+{
+  GtkMaze *self;
+
+  self = g_object_new (GTK_TYPE_MAZE, NULL);
+
+  gtk_maze_set_path (self, path);
+  gsk_path_unref (path);
+  self->background = background;
+  if (self->background)
+    {
+      g_signal_connect_swapped (self->background, "invalidate-contents", G_CALLBACK (gtk_widget_queue_draw), self);
+      g_signal_connect_swapped (self->background, "invalidate-size", G_CALLBACK (gtk_widget_queue_resize), self);
+    }
+  self->width = width;
+  self->height = height;
+
+  return GTK_WIDGET (self);
+}
+
+static void
+add_point_to_maze (GtkBitset      *maze,
+                   GskPathBuilder *builder,
+                   guint           x,
+                   guint           y)
+{
+  gboolean set[4] = { FALSE, FALSE, FALSE, FALSE };
+  guint dir;
+
+  gtk_bitset_add (maze, y * MAZE_WIDTH + x);
+
+  while (TRUE)
+    {
+      set[0] = set[0] || x == 0 || gtk_bitset_contains (maze, y * MAZE_WIDTH + x - 1);
+      set[1] = set[1] || y == 0 || gtk_bitset_contains (maze, (y - 1) * MAZE_WIDTH + x);
+      set[2] = set[2] || x + 1 == MAZE_WIDTH || gtk_bitset_contains (maze, y * MAZE_WIDTH + x + 1);
+      set[3] = set[3] || y + 1 == MAZE_HEIGHT || gtk_bitset_contains (maze, (y + 1) * MAZE_WIDTH + x);
+
+      if (set[0] && set[1] && set[2] && set[3])
+        return;
+      
+      do
+        {
+          dir = g_random_int_range (0, 4);
+        }
+      while (set[dir]);
+
+      switch (dir)
+        {
+          case 0:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x - 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x - 1, y);
+            break;
+
+          case 1:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y - 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y - 1);
+            break;
+
+          case 2:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 1.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x + 1, y);
+            break;
+
+          case 3:
+            gsk_path_builder_move_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 0.5) * MAZE_GRID_SIZE);
+            gsk_path_builder_line_to (builder, (x + 0.5) * MAZE_GRID_SIZE, (y + 1.5) * MAZE_GRID_SIZE);
+            add_point_to_maze (maze, builder, x, y + 1);
+            break;
+
+          default:
+            g_assert_not_reached ();
+            break;
+        }
+    }
+}
+
+static GskPath *
+create_path_for_maze (GtkWidget *widget)
+{
+  GskPathBuilder *builder;
+  GtkBitset *maze;
+
+  builder = gsk_path_builder_new ();
+  maze = gtk_bitset_new_empty ();
+  /* make sure the outer lines are unreachable:
+   * Set the full range, then remove the center again. */
+  gtk_bitset_add_range (maze, 0, MAZE_WIDTH * MAZE_HEIGHT);
+  gtk_bitset_remove_rectangle (maze, MAZE_WIDTH + 1, MAZE_WIDTH - 2, MAZE_HEIGHT - 2, MAZE_WIDTH);
+
+  /* Fill the maze */
+  add_point_to_maze (maze, builder, MAZE_WIDTH / 2, MAZE_HEIGHT / 2);
+
+  /* Add start and stop lines */
+  gsk_path_builder_move_to (builder, 1.5 * MAZE_GRID_SIZE, -0.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, 1.5 * MAZE_GRID_SIZE, 1.5 * MAZE_GRID_SIZE);
+  gsk_path_builder_move_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT - 1.5) * MAZE_GRID_SIZE);
+  gsk_path_builder_line_to (builder, (MAZE_WIDTH - 1.5) * MAZE_GRID_SIZE, (MAZE_HEIGHT + 0.5) * MAZE_GRID_SIZE);
+
+
+  gtk_bitset_unref (maze);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
+GtkWidget *
+do_path_maze (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *maze;
+      GtkMediaStream *stream;
+      GskPath *path;
+
+      window = gtk_window_new ();
+      gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
+      gtk_window_set_title (GTK_WINDOW (window), "Follow the maze with the mouse");
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *)&window);
+
+#if 0
+      stream = gtk_media_file_new_for_resource ("/images/gtk-logo.webm");
+#else
+      stream = gtk_nuclear_media_stream_new ();
+#endif
+      gtk_media_stream_play (stream);
+      gtk_media_stream_set_loop (stream, TRUE);
+
+      path = create_path_for_maze (window);
+
+      maze = gtk_maze_new (path,
+                           GDK_PAINTABLE (stream),
+                           MAZE_WIDTH * MAZE_GRID_SIZE,
+                           MAZE_HEIGHT * MAZE_GRID_SIZE);
+
+      gtk_window_set_child (GTK_WINDOW (window), maze);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/path_text.c

@@ -0,0 +1,580 @@
+/* Path/Text
+ *
+ * This demo shows how to use GskPath to animate a path along another path.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#define GTK_TYPE_PATH_WIDGET (gtk_path_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GtkPathWidget, gtk_path_widget, GTK, PATH_WIDGET, GtkWidget)
+
+#define POINT_SIZE 8
+
+enum {
+  PROP_0,
+  PROP_TEXT,
+  PROP_EDITABLE,
+  N_PROPS
+};
+
+struct _GtkPathWidget
+{
+  GtkWidget parent_instance;
+
+  char *text;
+  gboolean editable;
+
+  graphene_point_t points[4];
+
+  guint active_point;
+  float line_closest;
+
+  GskPath *line_path;
+  GskPathMeasure *line_measure;
+  GskPath *text_path;
+
+  GdkPaintable *background;
+};
+
+struct _GtkPathWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+G_DEFINE_TYPE (GtkPathWidget, gtk_path_widget, GTK_TYPE_WIDGET)
+
+static GskPath *
+create_path_from_text (GtkWidget  *widget,
+                       const char *text)
+{
+  cairo_surface_t *surface;
+  cairo_t *cr;
+  cairo_path_t *path;
+  PangoLayout *layout;
+  PangoFontDescription *desc;
+  GskPath *result;
+
+  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
+  cr = cairo_create (surface);
+
+  layout = gtk_widget_create_pango_layout (widget, text);
+  desc = pango_font_description_from_string ("sans bold 36");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  cairo_move_to (cr, 0, - pango_layout_get_baseline (layout) / (double) PANGO_SCALE);
+  pango_cairo_layout_path (cr, layout);
+  path = cairo_copy_path_flat (cr);
+  result = gsk_path_new_from_cairo (path);
+
+  cairo_path_destroy (path);
+  g_object_unref (layout);
+  cairo_destroy (cr);
+  cairo_surface_destroy (surface);
+
+  return result;
+}
+
+typedef struct
+{
+  GskPathMeasure *measure;
+  GskPathBuilder *builder;
+  double scale;
+} GtkPathTransform;
+
+static void
+gtk_path_transform_point (GskPathMeasure         *measure,
+                          const graphene_point_t *pt,
+                          float                   scale,
+                          graphene_point_t       *res)
+{
+  graphene_vec2_t tangent;
+
+  gsk_path_measure_get_point (measure, pt->x * scale, res, &tangent);
+
+  res->x -= pt->y * scale * graphene_vec2_get_y (&tangent);
+  res->y += pt->y * scale * graphene_vec2_get_x (&tangent);
+}
+
+static gboolean
+gtk_path_transform_op (GskPathOperation        op,
+                       const graphene_point_t *pts,
+                       gsize                   n_pts,
+                       gpointer                data)
+{
+  GtkPathTransform *transform = data;
+
+  switch (op)
+  {
+    case GSK_PATH_MOVE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[0], transform->scale, &res);
+        gsk_path_builder_move_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_LINE:
+      {
+        graphene_point_t res;
+        gtk_path_transform_point (transform->measure, &pts[1], transform->scale, &res);
+        gsk_path_builder_line_to (transform->builder, res.x, res.y);
+      }
+      break;
+
+    case GSK_PATH_CURVE:
+      {
+        graphene_point_t res[3];
+        gtk_path_transform_point (transform->measure, &pts[1], transform->scale, &res[0]);
+        gtk_path_transform_point (transform->measure, &pts[2], transform->scale, &res[1]);
+        gtk_path_transform_point (transform->measure, &pts[3], transform->scale, &res[2]);
+        gsk_path_builder_curve_to (transform->builder, res[0].x, res[0].y, res[1].x, res[1].y, res[2].x, res[2].y);
+      }
+      break;
+
+    case GSK_PATH_CLOSE:
+      gsk_path_builder_close (transform->builder);
+      break;
+
+    default:
+      g_assert_not_reached();
+      return FALSE;
+  }
+
+  return TRUE;
+}
+
+static GskPath *
+gtk_path_transform (GskPathMeasure *measure,
+                    GskPath        *path)
+{
+  GtkPathTransform transform = { measure, gsk_path_builder_new () };
+  graphene_rect_t bounds;
+
+  gsk_path_get_bounds (path, &bounds);
+  if (bounds.origin.x + bounds.size.width > 0)
+    transform.scale = gsk_path_measure_get_length (measure) / (bounds.origin.x + bounds.size.width);
+  else
+    transform.scale = 1.0f;
+
+  gsk_path_foreach (path, GSK_PATH_FOREACH_ALLOW_CURVES, gtk_path_transform_op, &transform);
+
+  return gsk_path_builder_free_to_path (transform.builder);
+}
+
+static void
+gtk_path_widget_clear_text_path (GtkPathWidget *self)
+{
+  g_clear_pointer (&self->text_path, gsk_path_unref);
+}
+
+static void
+gtk_path_widget_clear_paths (GtkPathWidget *self)
+{
+  gtk_path_widget_clear_text_path (self);
+
+  g_clear_pointer (&self->line_path, gsk_path_unref);
+  g_clear_pointer (&self->line_measure, gsk_path_measure_unref);
+}
+
+static void
+gtk_path_widget_create_text_path (GtkPathWidget *self)
+{
+  GskPath *path;
+
+  gtk_path_widget_clear_text_path (self);
+
+  if (self->line_measure == NULL)
+    return;
+
+  path = create_path_from_text (GTK_WIDGET (self), self->text);
+  self->text_path = gtk_path_transform (self->line_measure, path);
+
+  gsk_path_unref (path);
+}
+
+static void
+gtk_path_widget_create_paths (GtkPathWidget *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  GskPathBuilder *builder;
+
+  gtk_path_widget_clear_paths (self);
+
+  if (width <= 0 || height <= 0)
+    return;
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder,
+                            self->points[0].x * width, self->points[0].y * height);
+  gsk_path_builder_curve_to (builder,
+                             self->points[1].x * width, self->points[1].y * height,
+                             self->points[2].x * width, self->points[2].y * height,
+                             self->points[3].x * width, self->points[3].y * height);
+  self->line_path = gsk_path_builder_free_to_path (builder);
+
+  self->line_measure = gsk_path_measure_new (self->line_path);
+
+  gtk_path_widget_create_text_path (self);
+}
+
+static void
+gtk_path_widget_allocate (GtkWidget *widget,
+                          int        width,
+                          int        height,
+                          int        baseline)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+
+  GTK_WIDGET_CLASS (gtk_path_widget_parent_class)->size_allocate (widget, width, height, baseline);
+
+  gtk_path_widget_create_paths (self);
+}
+
+static void
+gtk_path_widget_snapshot (GtkWidget   *widget,
+                          GtkSnapshot *snapshot)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (widget);
+  double width = gtk_widget_get_width (widget);
+  double height = gtk_widget_get_height (widget);
+  GskPath *path;
+  GskStroke *stroke;
+  gsize i;
+
+  /* frosted glass the background */
+  gtk_snapshot_push_blur (snapshot, 100);
+  gdk_paintable_snapshot (self->background, snapshot, width, height);
+  gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 0.6 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+  gtk_snapshot_pop (snapshot);
+
+  /* draw the text */
+  if (self->text_path)
+    {
+      gtk_snapshot_push_fill (snapshot, self->text_path, GSK_FILL_RULE_WINDING);
+      gdk_paintable_snapshot (self->background, snapshot, width, height);
+
+      /* ... with an emboss effect */
+      stroke = gsk_stroke_new (2.0);
+      gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT(1, 1));
+      gtk_snapshot_push_stroke (snapshot, self->text_path, stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 0.2 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gsk_stroke_free (stroke);
+      gtk_snapshot_pop (snapshot);
+
+      gtk_snapshot_pop (snapshot);
+    }
+
+  if (self->editable && self->line_path)
+    {
+      GskPathBuilder *builder;
+
+      /* draw the control line */
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, self->line_path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      /* draw the points */
+      builder = gsk_path_builder_new ();
+      for (i = 0; i < 4; i++)
+        {
+          gsk_path_builder_add_circle (builder, &GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), POINT_SIZE);
+        }
+      path = gsk_path_builder_free_to_path (builder);
+
+      gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 1, 1, 1, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      stroke = gsk_stroke_new (1.0);
+      gtk_snapshot_push_stroke (snapshot, path, stroke);
+      gsk_stroke_free (stroke);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 0, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      gsk_path_unref (path);
+    }
+
+  if (self->line_closest >= 0)
+    {
+      GskPathBuilder *builder;
+      graphene_point_t closest;
+
+      builder = gsk_path_builder_new ();
+      gsk_path_measure_get_point (self->line_measure, self->line_closest, &closest, NULL);
+      gsk_path_builder_add_circle (builder, &closest, POINT_SIZE);
+      path = gsk_path_builder_free_to_path (builder);
+
+      gtk_snapshot_push_fill (snapshot, path, GSK_FILL_RULE_WINDING);
+      gtk_snapshot_append_color (snapshot, &(GdkRGBA) { 0, 0, 1, 1 }, &GRAPHENE_RECT_INIT (0, 0, width, height));
+      gtk_snapshot_pop (snapshot);
+
+      gsk_path_unref (path);
+    }
+}
+
+static void
+gtk_path_widget_set_text (GtkPathWidget *self,
+                          const char    *text)
+{
+  if (g_strcmp0 (self->text, text) == 0)
+    return;
+
+  g_free (self->text);
+  self->text = g_strdup (text);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TEXT]);
+}
+
+static void
+gtk_path_widget_set_editable (GtkPathWidget *self,
+                              gboolean       editable)
+{
+  if (self->editable == editable)
+    return;
+
+  self->editable = editable;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EDITABLE]);
+}
+
+static void
+gtk_path_widget_set_property (GObject      *object,
+                              guint         prop_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      gtk_path_widget_set_text (self, g_value_get_string (value));
+      break;
+
+    case PROP_EDITABLE:
+      gtk_path_widget_set_editable (self, g_value_get_boolean (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_get_property (GObject    *object,
+                              guint       prop_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  switch (prop_id)
+    {
+    case PROP_TEXT:
+      g_value_set_string (value, self->text);
+      break;
+
+    case PROP_EDITABLE:
+      g_value_set_boolean (value, self->editable);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_path_widget_dispose (GObject *object)
+{
+  GtkPathWidget *self = GTK_PATH_WIDGET (object);
+
+  gtk_path_widget_clear_paths (self);
+
+  G_OBJECT_CLASS (gtk_path_widget_parent_class)->dispose (object);
+}
+
+static void
+gtk_path_widget_class_init (GtkPathWidgetClass *klass)
+{
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->dispose = gtk_path_widget_dispose;
+  object_class->set_property = gtk_path_widget_set_property;
+  object_class->get_property = gtk_path_widget_get_property;
+
+  widget_class->size_allocate = gtk_path_widget_allocate;
+  widget_class->snapshot = gtk_path_widget_snapshot;
+
+  properties[PROP_TEXT] =
+    g_param_spec_string ("text",
+                         "text",
+                         "Text transformed along a path",
+                         NULL,
+                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  properties[PROP_EDITABLE] =
+    g_param_spec_boolean ("editable",
+                          "editable",
+                          "If the path can be edited by the user",
+                          FALSE,
+                          G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, N_PROPS, properties);
+}
+
+static void
+drag_begin (GtkGestureDrag *gesture,
+            double          x,
+            double          y,
+            GtkPathWidget  *self)
+{
+  graphene_point_t mouse = GRAPHENE_POINT_INIT (x, y);
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  gsize i;
+
+  for (i = 0; i < 4; i++)
+    {
+      if (graphene_point_distance (&GRAPHENE_POINT_INIT (self->points[i].x * width, self->points[i].y * height), &mouse, NULL, NULL) <= POINT_SIZE)
+        {
+          self->active_point = i;
+          break;
+        }
+    }
+  if (i == 4)
+    {
+      gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
+      return;
+    }
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+drag_update (GtkGestureDrag *drag,
+             double          offset_x,
+             double          offset_y,
+             GtkPathWidget  *self)
+{
+  double width = gtk_widget_get_width (GTK_WIDGET (self));
+  double height = gtk_widget_get_height (GTK_WIDGET (self));
+  double start_x, start_y;
+
+  gtk_gesture_drag_get_start_point (drag, &start_x, &start_y);
+
+  self->points[self->active_point] = GRAPHENE_POINT_INIT ((start_x + offset_x) / width,
+                                                          (start_y + offset_y) / height);
+  self->points[self->active_point].x = CLAMP (self->points[self->active_point].x, 0, 1);
+  self->points[self->active_point].y = CLAMP (self->points[self->active_point].y, 0, 1);
+
+  gtk_path_widget_create_paths (self);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_motion (GtkEventControllerMotion *controller,
+                double                    x,
+                double                    y,
+                GtkPathWidget            *self)
+{
+  gsk_path_measure_get_closest_point_full (self->line_measure,
+                                           &GRAPHENE_POINT_INIT (x, y),
+                                           INFINITY,
+                                           &self->line_closest,
+                                           NULL, NULL, NULL);
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+pointer_leave (GtkEventControllerMotion *controller,
+               GtkPathWidget            *self)
+{
+  self->line_closest = -1;
+
+  gtk_widget_queue_draw (GTK_WIDGET (self));
+}
+
+static void
+gtk_path_widget_init (GtkPathWidget *self)
+{
+  GtkEventController *controller;
+
+  controller = GTK_EVENT_CONTROLLER (gtk_gesture_drag_new ());
+  g_signal_connect (controller, "drag-begin", G_CALLBACK (drag_begin), self);
+  g_signal_connect (controller, "drag-update", G_CALLBACK (drag_update), self);
+  g_signal_connect (controller, "drag-end", G_CALLBACK (drag_update), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  controller = GTK_EVENT_CONTROLLER (gtk_event_controller_motion_new ());
+  g_signal_connect (controller, "enter", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "motion", G_CALLBACK (pointer_motion), self);
+  g_signal_connect (controller, "leave", G_CALLBACK (pointer_leave), self);
+  gtk_widget_add_controller (GTK_WIDGET (self), controller);
+
+  self->line_closest = -1;
+
+  self->points[0] = GRAPHENE_POINT_INIT (0.1, 0.9);
+  self->points[1] = GRAPHENE_POINT_INIT (0.3, 0.1);
+  self->points[2] = GRAPHENE_POINT_INIT (0.7, 0.1);
+  self->points[3] = GRAPHENE_POINT_INIT (0.9, 0.9);
+
+  self->background = GDK_PAINTABLE (gdk_texture_new_from_resource ("/sliding_puzzle/portland-rose.jpg"));
+
+  gtk_path_widget_set_text (self, "It's almost working");
+}
+
+GtkWidget *
+gtk_path_widget_new (void)
+{
+  GtkPathWidget *self;
+
+  self = g_object_new (GTK_TYPE_PATH_WIDGET, NULL);
+
+  return GTK_WIDGET (self);
+}
+
+GtkWidget *
+do_path_text (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkBuilder *builder;
+
+      g_type_ensure (GTK_TYPE_PATH_WIDGET);
+
+      builder = gtk_builder_new_from_resource ("/path_text/path_text.ui");
+      window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
+      gtk_window_set_display (GTK_WINDOW (window),
+                              gtk_widget_get_display (do_widget));
+      g_object_add_weak_pointer (G_OBJECT (window), (gpointer *) &window);
+      g_object_unref (builder);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_window_present (GTK_WINDOW (window));
+  else
+    gtk_window_destroy (GTK_WINDOW (window));
+
+  return window;
+}

demos/gtk-demo/path_text.ui

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <object class="GtkWindow" id="window">
+    <property name="title" translatable="yes">Text along a Path</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar">
+        <child type="end">
+          <object class="GtkToggleButton" id="edit-toggle">
+            <property name="icon-name">document-edit-symbolic</property>
+          </object>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkRevealer">
+            <property name="reveal-child" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <child>
+              <object class="GtkEntry" id="text">
+                <property name="text">Through the looking glass</property>
+              </object>
+            </child>
+          </object>
+        </child>
+        <child>
+          <object class="GtkPathWidget" id="view">
+            <property name="editable" bind-source="edit-toggle" bind-property="active" bind-flags="sync-create"></property>
+            <property name="text" bind-source="text" bind-property="text" bind-flags="sync-create"></property>
+            <property name="hexpand">true</property>
+            <property name="vexpand">true</property>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

docs/reference/gtk/section-list-widget.md

@@ -30,12 +30,12 @@ Views display data from a **_model_**. Models implement the [`iface@Gio.ListMode
 interface and can be provided in a variety of ways:
 
  * List model implementations for many specific types of data already exist, for
-   example [`class@Gtk.DirectoryList`] or [`class@Gtk.StringList`].
+   example `GtkDirectoryList` or `GtkStringList`.
 
- * There are generic list model implementations like [`class@Gio.ListStore`] that allow building
+ * There are generic list model implementations like`GListStore` that allow building
    lists of arbitrary objects.
 
- * Wrapping list models like [`class@Gtk.FilterListModel`] or [`class@Gtk.SortListModel`]
+ * Wrapping list models like `GtkFilterListModel` or `GtkSortListModel`
    modify, adapt or combine other models.
 
  * Last but not least, developers are encouraged to create their own `GListModel`
@@ -133,8 +133,8 @@ tradeoffs of those and experiment with them.
 
 GTK offers a wide variety of wrapping models which change or supplement an
 existing model (or models) in some way. But when it comes to storing your
-actual data, there are only a few ready-made choices available:
-[`class@Gio.ListStore`], [`class@Gtk.StringList`], and [`class@Gtk.DirectoryList`].
+actual data, there are only a few ready-made choices available: [`class@Gio.ListStore`]
+and [`class@Gtk.StringList`].
 
 `GListStore` is backed by a balanced tree and has performance characteristics
 that are expected for that data structure. It works reasonably well for dataset
@@ -147,10 +147,6 @@ that are expected for that data structure. `GtkStringList` is a good fit for any
 place where you would otherwise use `char*[]` and works best if the dataset
 is not very dynamic.
 
-`GtkDirectoryList` is a list model that wraps [`method@Gio.File.enumerate_children_async`].
-It presents a `GListModel` and fills it asynchronously with the [`iface@Gio.File`]s
-returned from that function.
-
 If these models don't fit your use case or scalability requirements, you
 should make a custom `GListModel` implementation. It is a small interface and
 not very hard to implement.
@@ -203,7 +199,7 @@ the `.data-table` style class.
 ## Sections
 
 List models can optionally group their items into **_sections_**, by implementing
-the `GtkSectionModel` interface. `GtkListView` can
+the `GtkSectionModel` interface. Both `GtkListView` and `GtkGridView` can
 display headers for sections, by installing a separate **_header factory_**.
 
 Many GTK list models support section inherently, or they pass through the

gdk/gdkdisplayprivate.h

@@ -104,7 +104,6 @@ struct _GdkDisplay
   gsize vk_pipeline_cache_size;
   char *vk_pipeline_cache_etag;
   guint vk_save_pipeline_cache_source;
-  GHashTable *vk_shader_modules;
 
   guint vulkan_refcount;
 #endif /* GDK_RENDERING_VULKAN */

gdk/gdkglcontext.c

@@ -1552,7 +1552,7 @@ gdk_gl_context_check_extensions (GdkGLContext *context)
 
   priv->has_sync = gdk_gl_context_check_version (context, "3.2", "3.0") ||
                    epoxy_has_gl_extension ("GL_ARB_sync") ||
-                   epoxy_has_gl_extension ("GL_APPLE_sync");
+                   epoxy_has_gl_extension ("GK_APPLE_sync");
 
 #ifdef G_ENABLE_DEBUG
   {

gdk/gdktexture.c

@@ -25,8 +25,7 @@
  * multiple frames, and will be used for a long time.
  *
  * There are various ways to create `GdkTexture` objects from a
- * [class@GdkPixbuf.Pixbuf], or from bytes stored in memory, a file, or a
- * [struct@Gio.Resource].
+ * [class@GdkPixbuf.Pixbuf], or a Cairo surface, or other pixel data.
  *
  * The ownership of the pixel data is transferred to the `GdkTexture`
  * instance; you can only make a copy of it, via [method@Gdk.Texture.download].

gdk/gdkvulkancontext.c

@@ -383,13 +383,6 @@ gdk_vulkan_context_check_swapchain (GdkVulkanContext  *context,
 
   device = gdk_vulkan_context_get_device (context);
 
-  /*
-   * Wait for device to be idle because this function is also called in window resizes.
-   * And if we destroy old swapchain it also destroy the old VkImages, those images could
-   * be in use by a vulkan render.
-   */
-  vkDeviceWaitIdle (device);
-
   res = GDK_VK_CHECK (vkGetPhysicalDeviceSurfaceCapabilitiesKHR, gdk_vulkan_context_get_physical_device (context),
                                                                  priv->surface,
                                                                  &capabilities);
@@ -1600,8 +1593,6 @@ gdk_display_create_vulkan_instance (GdkDisplay  *display,
 
   gdk_display_create_pipeline_cache (display);
 
-  display->vk_shader_modules = g_hash_table_new (g_str_hash, g_str_equal);
-
   return TRUE;
 }
 
@@ -1623,9 +1614,6 @@ gdk_display_ref_vulkan (GdkDisplay *display,
 void
 gdk_display_unref_vulkan (GdkDisplay *display)
 {
-  GHashTableIter iter;
-  gpointer key, value;
-
   g_return_if_fail (GDK_IS_DISPLAY (display));
   g_return_if_fail (display->vulkan_refcount > 0);
 
@@ -1633,16 +1621,6 @@ gdk_display_unref_vulkan (GdkDisplay *display)
   if (display->vulkan_refcount > 0)
     return;
 
-  display->vk_shader_modules = g_hash_table_new (g_str_hash, g_str_equal);
-  g_hash_table_iter_init (&iter, display->vk_shader_modules);
-  while (g_hash_table_iter_next (&iter, &key, &value))
-    {
-      g_free (key);
-      vkDestroyShaderModule (display->vk_device,
-                             value,
-                             NULL);
-    }
-
   if (display->vk_save_pipeline_cache_source)
     {
       gdk_vulkan_save_pipeline_cache_cb (display);
@@ -1669,47 +1647,6 @@ gdk_display_unref_vulkan (GdkDisplay *display)
   display->vk_instance = VK_NULL_HANDLE;
 }
 
-VkShaderModule
-gdk_display_get_vk_shader_module (GdkDisplay *self,
-                                  const char *resource_name)
-{
-  VkShaderModule shader;
-  GError *error = NULL;
-  GBytes *bytes;
-
-  shader = g_hash_table_lookup (self->vk_shader_modules, resource_name);
-  if (shader)
-    return shader;
-
-  bytes = g_resources_lookup_data (resource_name, 0, &error);
-  if (bytes == NULL)
-    {
-      GDK_DEBUG (VULKAN, "Error loading shader data: %s", error->message);
-      g_clear_error (&error);
-      return VK_NULL_HANDLE;
-    }
-
-  if (GDK_VK_CHECK (vkCreateShaderModule, self->vk_device,
-                                          &(VkShaderModuleCreateInfo) {
-                                              .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-                                              .codeSize = g_bytes_get_size (bytes),
-                                              .pCode = (uint32_t *) g_bytes_get_data (bytes, NULL),
-                                          },
-                                          NULL,
-                                          &shader) == VK_SUCCESS)
-    {
-      g_hash_table_insert (self->vk_shader_modules, g_strdup (resource_name), shader);
-    }
-  else
-    {
-      shader = VK_NULL_HANDLE;
-    }
-
-  g_bytes_unref (bytes);
-
-  return shader;
-}
-
 #else /* GDK_RENDERING_VULKAN */
 
 static void

gdk/gdkvulkancontextprivate.h

@@ -73,9 +73,6 @@ gboolean                gdk_display_ref_vulkan                          (GdkDisp
                                                                          GError               **error);
 void                    gdk_display_unref_vulkan                        (GdkDisplay            *display);
 
-VkShaderModule          gdk_display_get_vk_shader_module                (GdkDisplay            *display,
-                                                                         const char            *resource_name);
-
 VkPipelineCache         gdk_vulkan_context_get_pipeline_cache           (GdkVulkanContext      *self);
 void                    gdk_vulkan_context_pipeline_cache_updated       (GdkVulkanContext      *self);
 

gdk/wayland/gdkseat-wayland.c

@@ -3064,9 +3064,9 @@ tablet_tool_handle_button (void                      *data,
   tablet->pointer_info.press_serial = serial;
 
   if (button == BTN_STYLUS)
-    n_button = GDK_BUTTON_MIDDLE;
-  else if (button == BTN_STYLUS2)
     n_button = GDK_BUTTON_SECONDARY;
+  else if (button == BTN_STYLUS2)
+    n_button = GDK_BUTTON_MIDDLE;
   else if (button == BTN_STYLUS3)
     n_button = 8; /* Back */
   else

gdk/win32/gdkevents-win32.c

@@ -139,6 +139,7 @@ static GSourceFuncs event_funcs = {
 
 static GdkSurface *mouse_window = NULL;
 static GdkSurface *mouse_window_ignored_leave = NULL;
+static int current_x, current_y;
 static int current_root_x, current_root_y;
 
 static UINT got_gdk_events_message;
@@ -1521,15 +1522,14 @@ generate_button_event (GdkEventType      type,
   GdkEvent *event;
   GdkDeviceManagerWin32 *device_manager;
   GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
-  double x, y;
 
   if (_gdk_input_ignore_core > 0)
     return;
 
   device_manager = GDK_DEVICE_MANAGER_WIN32 (_gdk_device_manager);
 
-  x = (double) GET_X_LPARAM (msg->lParam) / impl->surface_scale;
-  y = (double) GET_Y_LPARAM (msg->lParam) / impl->surface_scale;
+  current_x = (gint16) GET_X_LPARAM (msg->lParam) / impl->surface_scale;
+  current_y = (gint16) GET_Y_LPARAM (msg->lParam) / impl->surface_scale;
 
   _gdk_device_virtual_set_active (_gdk_device_manager->core_pointer,
                                   _gdk_device_manager->system_pointer);
@@ -1541,10 +1541,10 @@ generate_button_event (GdkEventType      type,
                                 _gdk_win32_get_next_tick (msg->time),
                                 build_pointer_event_state (msg),
                                 button,
-                                x,
-                                y,
+                                current_x,
+                                current_y,
                                 NULL);
-
+                                
   _gdk_win32_append_event (event);
 }
 
@@ -2350,19 +2350,19 @@ gdk_event_translate (MSG *msg,
        * sends WM_MOUSEMOVE messages after a new window is shown under
        * the mouse, even if the mouse hasn't moved. This disturbs gtk.
        */
-      if (msg->pt.x == current_root_x &&
-          msg->pt.y == current_root_y)
+      if (msg->pt.x / impl->surface_scale == current_root_x &&
+          msg->pt.y / impl->surface_scale == current_root_y)
         break;
 
-      current_root_x = msg->pt.x;
-      current_root_y = msg->pt.y;
+      current_root_x = msg->pt.x / impl->surface_scale;
+      current_root_y = msg->pt.y / impl->surface_scale;
 
       if (impl->drag_move_resize_context.op != GDK_WIN32_DRAGOP_NONE)
-        gdk_win32_surface_do_move_resize_drag (window, msg->pt.x, msg->pt.y);
+        gdk_win32_surface_do_move_resize_drag (window, current_root_x, current_root_y);
       else if (_gdk_input_ignore_core == 0)
 	{
-          double x = (double) GET_X_LPARAM (msg->lParam) / impl->surface_scale;
-          double y = (double) GET_Y_LPARAM (msg->lParam) / impl->surface_scale;
+	  current_x = (gint16) GET_X_LPARAM (msg->lParam) / impl->surface_scale;
+	  current_y = (gint16) GET_Y_LPARAM (msg->lParam) / impl->surface_scale;
 
           _gdk_device_virtual_set_active (_gdk_device_manager->core_pointer,
                                           _gdk_device_manager->system_pointer);
@@ -2372,8 +2372,8 @@ gdk_event_translate (MSG *msg,
                                         NULL,
                                         _gdk_win32_get_next_tick (msg->time),
 	                                build_pointer_event_state (msg),
-                                        x,
-                                        y,
+                                        current_x,
+                                        current_y,
                                         NULL);
 
 	  _gdk_win32_append_event (event);

gdk/win32/gdkinput-winpointer.c

@@ -271,10 +271,9 @@ winpointer_make_event (GdkDeviceWinpointer *device,
   y /= impl->surface_scale;
 
   state = 0;
-  /* Note that info->dwKeyStates is not reliable, use GetKeyState() */
-  if (GetKeyState (VK_CONTROL) < 0)
+  if (info->dwKeyStates & POINTER_MOD_CTRL)
     state |= GDK_CONTROL_MASK;
-  if (GetKeyState (VK_SHIFT) < 0)
+  if (info->dwKeyStates & POINTER_MOD_SHIFT)
     state |= GDK_SHIFT_MASK;
   if (GetKeyState (VK_MENU) < 0)
     state |= GDK_ALT_MASK;

gdk/win32/gdksurface-win32.c

@@ -3535,8 +3535,6 @@ setup_drag_move_resize_context (GdkSurface                  *surface,
   context->button = button;
   context->start_root_x = root_x;
   context->start_root_y = root_y;
-  context->current_root_x = root_x;
-  context->current_root_y = root_y;
   context->timestamp = timestamp;
   context->start_rect = rect;
 
@@ -3652,16 +3650,6 @@ gdk_win32_surface_do_move_resize_drag (GdkSurface *window,
   if (!_gdk_win32_get_window_rect (window, &rect))
     return;
 
-  x /= impl->surface_scale;
-  y /= impl->surface_scale;
-
-  if (context->current_root_x == x &&
-      context->current_root_y == y)
-    return;
-
-  context->current_root_x = x;
-  context->current_root_y = y;
-
   new_rect = context->start_rect;
   diffx = (x - context->start_root_x) * impl->surface_scale;
   diffy = (y - context->start_root_y) * impl->surface_scale;

gdk/win32/gdksurface-win32.h

@@ -137,12 +137,6 @@ struct _GdkW32DragMoveResizeContext
   int                start_root_x;
   int                start_root_y;
 
-  /* Last processed cursor position. Values are divided by the window
-   * scale.
-   */
-  int                current_root_x;
-  int                current_root_y;
-
   /* Initial window rectangle (position and size).
    * The window is resized/moved relative to this (see start_root_*).
    */

gsk/broadway/gskbroadwayrenderer.c

@@ -271,6 +271,8 @@ collect_reused_child_nodes (GskRenderer *renderer,
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
 
     default:
 
@@ -859,6 +861,8 @@ gsk_broadway_renderer_add_node (GskRenderer *renderer,
     case GSK_CROSS_FADE_NODE:
     case GSK_BLUR_NODE:
     case GSK_GL_SHADER_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
     default:
       break; /* Fallback */
     }

gsk/gl/gskgldriver.c

@@ -32,7 +32,6 @@
 #include "gskglcommandqueueprivate.h"
 #include "gskglcompilerprivate.h"
 #include "gskglglyphlibraryprivate.h"
-#include "gskglglyphylibraryprivate.h"
 #include "gskgliconlibraryprivate.h"
 #include "gskglprogramprivate.h"
 #include "gskglshadowlibraryprivate.h"
@@ -274,7 +273,6 @@ gsk_gl_driver_dispose (GObject *object)
     }
 
   g_clear_object (&self->glyphs_library);
-  g_clear_object (&self->glyphy_library);
   g_clear_object (&self->icons_library);
   g_clear_object (&self->shadows_library);
 
@@ -465,7 +463,6 @@ gsk_gl_driver_new (GskGLCommandQueue  *command_queue,
     }
 
   self->glyphs_library = gsk_gl_glyph_library_new (self);
-  self->glyphy_library = gsk_gl_glyphy_library_new (self);
   self->icons_library = gsk_gl_icon_library_new (self);
   self->shadows_library = gsk_gl_shadow_library_new (self);
 
@@ -576,8 +573,6 @@ gsk_gl_driver_begin_frame (GskGLDriver       *self,
                                       self->current_frame_id);
   gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphs_library),
                                       self->current_frame_id);
-  gsk_gl_texture_library_begin_frame (GSK_GL_TEXTURE_LIBRARY (self->glyphy_library),
-                                      self->current_frame_id);
 
   /* Cleanup old shadows */
   gsk_gl_shadow_library_begin_frame (self->shadows_library);

gsk/gl/gskgldriverprivate.h

@@ -97,7 +97,6 @@ struct _GskGLDriver
   GskGLCommandQueue *command_queue;
 
   GskGLGlyphLibrary *glyphs_library;
-  GskGLGlyphyLibrary *glyphy_library;
   GskGLIconLibrary *icons_library;
   GskGLShadowLibrary *shadows_library;
 

gsk/gl/gskglglyphylibrary.c

@@ -1,544 +0,0 @@
-/* gskglglyphylibrary.c
- *
- * Copyright 2020 Christian Hergert <chergert@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-/* Some of the glyphy cache is based upon the original glyphy code.
- * It's license is provided below.
- */
-/*
- * Copyright 2012 Google, Inc. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Google Author(s): Behdad Esfahbod
- */
-
-#include "config.h"
-
-#include <gdk/gdkglcontextprivate.h>
-#include <gdk/gdkmemoryformatprivate.h>
-#include <gdk/gdkprofilerprivate.h>
-
-#include "gskglcommandqueueprivate.h"
-#include "gskgldriverprivate.h"
-#include "gskglglyphylibraryprivate.h"
-#include "gskdebugprivate.h"
-
-#include "gskpathprivate.h"
-
-#include <glyphy.h>
-
-#define TOLERANCE (1/2048.)
-#define MIN_FONT_SIZE 14
-#define GRID_SIZE 20 /* Per EM */
-#define ENLIGHTEN_MAX .01 /* Per EM */
-#define EMBOLDEN_MAX .024 /* Per EM */
-
-/* We split the atlas into cells of size 64x8, so the minimum number of
- * bytes we store per glyph is 2048, and an atlas of size 2048x1024 can
- * hold at most 4096 glyphs. We need 5 and 7 bits to store the position
- * of a glyph in the atlas.
- *
- * We allocate each glyph a column of as many vertically adjacent cells
- * as it needs.
- */
-#define ITEM_W 64
-#define ITEM_H_QUANTUM 8
-
-G_DEFINE_TYPE (GskGLGlyphyLibrary, gsk_gl_glyphy_library, GSK_TYPE_GL_TEXTURE_LIBRARY)
-
-GskGLGlyphyLibrary *
-gsk_gl_glyphy_library_new (GskGLDriver *driver)
-{
-  g_return_val_if_fail (GSK_IS_GL_DRIVER (driver), NULL);
-
-  return g_object_new (GSK_TYPE_GL_GLYPHY_LIBRARY,
-                       "driver", driver,
-                       NULL);
-}
-
-static guint
-gsk_gl_glyphy_key_hash (gconstpointer data)
-{
-  const GskGLGlyphyKey *key = data;
-
-  /* malloc()'d pointers already guarantee 3 bits from the LSB on 64-bit and
-   * 2 bits from the LSB on 32-bit. Shift by enough to give us 256 entries
-   * in our front cache for the glyph since languages will naturally cluster
-   * for us.
-   */
-
-  return (key->font << 8) ^ key->glyph;
-}
-
-static gboolean
-gsk_gl_glyphy_key_equal (gconstpointer v1,
-                         gconstpointer v2)
-{
-  return memcmp (v1, v2, sizeof (GskGLGlyphyKey)) == 0;
-}
-
-static void
-gsk_gl_glyphy_key_free (gpointer data)
-{
-  GskGLGlyphyKey *key = data;
-
-  g_slice_free (GskGLGlyphyKey, key);
-}
-
-static void
-gsk_gl_glyphy_value_free (gpointer data)
-{
-  g_slice_free (GskGLGlyphyValue, data);
-}
-
-static void
-gsk_gl_glyphy_library_clear_cache (GskGLTextureLibrary *library)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)library;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-
-  memset (self->front, 0, sizeof self->front);
-}
-
-static void
-gsk_gl_glyphy_library_init_atlas (GskGLTextureLibrary *library,
-                                  GskGLTextureAtlas   *atlas)
-{
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (library));
-  g_assert (atlas != NULL);
-
-  atlas->cursor_x = 0;
-  atlas->cursor_y = 0;
-}
-
-static gboolean
-gsk_gl_glyphy_library_allocate (GskGLTextureLibrary *library,
-                                GskGLTextureAtlas   *atlas,
-                                int                  width,
-                                int                  height,
-                                int                 *out_x,
-                                int                 *out_y)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)library;
-  int cursor_save_x;
-  int cursor_save_y;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-  g_assert (atlas != NULL);
-
-  cursor_save_x = atlas->cursor_x;
-  cursor_save_y = atlas->cursor_y;
-
-  if ((height & (self->item_h_q-1)) != 0)
-    height = (height + self->item_h_q - 1) & ~(self->item_h_q - 1);
-
-  /* Require allocations in columns of 64 and rows of 8 */
-  g_assert (width == self->item_w);
-  g_assert ((height % self->item_h_q) == 0);
-
-  if (atlas->cursor_y + height > atlas->height)
-    {
-      /* Go to next column */
-      atlas->cursor_x += self->item_w;
-      atlas->cursor_y = 0;
-    }
-
-  if (atlas->cursor_x + width <= atlas->width &&
-      atlas->cursor_y + height <= atlas->height)
-    {
-      *out_x = atlas->cursor_x;
-      *out_y = atlas->cursor_y;
-      atlas->cursor_y += height;
-      return TRUE;
-    }
-
-  atlas->cursor_x = cursor_save_x;
-  atlas->cursor_y = cursor_save_y;
-
-  return FALSE;
-}
-
-static void
-gsk_gl_glyphy_library_finalize (GObject *object)
-{
-  GskGLGlyphyLibrary *self = (GskGLGlyphyLibrary *)object;
-
-  g_clear_pointer (&self->acc, glyphy_arc_accumulator_destroy);
-  g_clear_pointer (&self->acc_endpoints, g_array_unref);
-
-  G_OBJECT_CLASS (gsk_gl_glyphy_library_parent_class)->finalize (object);
-}
-
-GQuark quark_glyphy_font_key;
-
-static void
-gsk_gl_glyphy_library_class_init (GskGLGlyphyLibraryClass *klass)
-{
-  GObjectClass *object_class = G_OBJECT_CLASS (klass);
-  GskGLTextureLibraryClass *library_class = GSK_GL_TEXTURE_LIBRARY_CLASS (klass);
-
-  quark_glyphy_font_key = g_quark_from_static_string ("glyphy-font-key");
-
-  object_class->finalize = gsk_gl_glyphy_library_finalize;
-
-  library_class->allocate = gsk_gl_glyphy_library_allocate;
-  library_class->clear_cache = gsk_gl_glyphy_library_clear_cache;
-  library_class->init_atlas = gsk_gl_glyphy_library_init_atlas;
-}
-
-static void
-gsk_gl_glyphy_library_init (GskGLGlyphyLibrary *self)
-{
-  GskGLTextureLibrary *tl = (GskGLTextureLibrary *)self;
-
-  tl->max_entry_size = 0;
-  tl->max_frame_age = 512;
-  tl->atlas_width = 2048;
-  tl->atlas_height = 1024;
-  gsk_gl_texture_library_set_funcs (tl,
-                                    gsk_gl_glyphy_key_hash,
-                                    gsk_gl_glyphy_key_equal,
-                                    gsk_gl_glyphy_key_free,
-                                    gsk_gl_glyphy_value_free);
-
-  self->acc = glyphy_arc_accumulator_create ();
-  self->acc_endpoints = g_array_new (FALSE, FALSE, sizeof (glyphy_arc_endpoint_t));
-  self->item_w = ITEM_W;
-  self->item_h_q = ITEM_H_QUANTUM;
-}
-
-static glyphy_bool_t
-accumulate_endpoint (glyphy_arc_endpoint_t *endpoint,
-                     GArray                *endpoints)
-{
-  g_array_append_vals (endpoints, endpoint, 1);
-  return TRUE;
-}
-
-static void
-move_to (hb_draw_funcs_t *dfuncs,
-         GskPathBuilder  *builder,
-         hb_draw_state_t *st,
-         float            x,
-         float            y,
-         void            *data)
-{
-  gsk_path_builder_move_to (builder, x, y);
-}
-
-static void
-line_to (hb_draw_funcs_t *dfuncs,
-         GskPathBuilder  *builder,
-         hb_draw_state_t *st,
-         float            x,
-         float            y,
-         void            *data)
-{
-  gsk_path_builder_line_to (builder, x, y);
-}
-
-static void
-cubic_to (hb_draw_funcs_t *dfuncs,
-          GskPathBuilder  *builder,
-          hb_draw_state_t *st,
-          float            x1,
-          float            y1,
-          float            x2,
-          float            y2,
-          float            x3,
-          float            y3,
-          void            *data)
-{
-  gsk_path_builder_cubic_to (builder, x1, y1, x2, y2, x3, y3);
-}
-
-static void
-close_path (hb_draw_funcs_t *dfuncs,
-            GskPathBuilder  *builder,
-            hb_draw_state_t *st,
-            void            *data)
-{
-  gsk_path_builder_close (builder);
-}
-
-static hb_draw_funcs_t *
-gsk_path_get_draw_funcs (void)
-{
-  static hb_draw_funcs_t *funcs = NULL;
-
-  if (!funcs)
-    {
-      funcs = hb_draw_funcs_create ();
-
-      hb_draw_funcs_set_move_to_func (funcs, (hb_draw_move_to_func_t) move_to, NULL, NULL);
-      hb_draw_funcs_set_line_to_func (funcs, (hb_draw_line_to_func_t) line_to, NULL, NULL);
-      hb_draw_funcs_set_cubic_to_func (funcs, (hb_draw_cubic_to_func_t) cubic_to, NULL, NULL);
-      hb_draw_funcs_set_close_path_func (funcs, (hb_draw_close_path_func_t) close_path, NULL, NULL);
-
-      hb_draw_funcs_make_immutable (funcs);
-    }
-
-  return funcs;
-}
-
-static gboolean
-acc_callback (GskPathOperation        op,
-              const graphene_point_t *pts,
-              gsize                   n_pts,
-              float                   weight,
-              gpointer                user_data)
-{
-  glyphy_arc_accumulator_t *acc = user_data;
-  glyphy_point_t p0, p1, p2, p3;
-
-  switch (op)
-    {
-    case GSK_PATH_MOVE:
-      p0.x = pts[0].x; p0.y = pts[0].y;
-      glyphy_arc_accumulator_move_to (acc, &p0);
-      break;
-    case GSK_PATH_CLOSE:
-      glyphy_arc_accumulator_close_path (acc);
-      break;
-    case GSK_PATH_LINE:
-      p1.x = pts[1].x; p1.y = pts[1].y;
-      glyphy_arc_accumulator_line_to (acc, &p1);
-      break;
-    case GSK_PATH_QUAD:
-      p1.x = pts[1].x; p1.y = pts[1].y;
-      p2.x = pts[2].x; p2.y = pts[2].y;
-      /* This glyphy api is mis-named */
-      glyphy_arc_accumulator_conic_to (acc, &p1, &p2);
-      break;
-    case GSK_PATH_CUBIC:
-      p1.x = pts[1].x; p1.y = pts[1].y;
-      p2.x = pts[2].x; p2.y = pts[2].y;
-      p3.x = pts[3].x; p3.y = pts[3].y;
-      glyphy_arc_accumulator_cubic_to (acc, &p1, &p2, &p3);
-      break;
-    case GSK_PATH_CONIC:
-    default:
-      g_assert_not_reached ();
-    }
-
-  return TRUE;
-}
-
-static inline gboolean
-encode_glyph (GskGLGlyphyLibrary *self,
-              hb_font_t          *font,
-              unsigned int        glyph_index,
-              double              tolerance_per_em,
-              glyphy_rgba_t      *buffer,
-              guint               buffer_len,
-              guint              *output_len,
-              guint              *nominal_width,
-              guint              *nominal_height,
-              glyphy_extents_t   *extents)
-{
-  hb_face_t *face = hb_font_get_face (font);
-  guint upem = hb_face_get_upem (face);
-  double tolerance = upem * tolerance_per_em;
-  double faraway = (double)upem / (MIN_FONT_SIZE * M_SQRT2);
-  double unit_size = (double) upem / GRID_SIZE;
-  double enlighten_max = (double) upem * ENLIGHTEN_MAX;
-  double embolden_max = (double) upem * EMBOLDEN_MAX;
-  double avg_fetch_achieved;
-  GskPathBuilder *builder;
-  GskPath *path, *simplified;
-
-  self->acc_endpoints->len = 0;
-
-  glyphy_arc_accumulator_reset (self->acc);
-  glyphy_arc_accumulator_set_tolerance (self->acc, tolerance);
-  glyphy_arc_accumulator_set_callback (self->acc,
-                                       (glyphy_arc_endpoint_accumulator_callback_t)accumulate_endpoint,
-                                       self->acc_endpoints);
-
-  builder = gsk_path_builder_new ();
-#if HB_VERSION_ATLEAST (7, 0, 0)
-  hb_font_draw_glyph (font, glyph_index, gsk_path_get_draw_funcs (), builder);
-#else
-  hb_font_get_glyph_shape (font, glyph_index, gsk_path_get_draw_funcs (), builder);
-#endif
-  path = gsk_path_builder_free_to_path (builder);
-  simplified = gsk_path_op (GSK_PATH_OP_SIMPLIFY, GSK_FILL_RULE_WINDING, path, NULL);
-  gsk_path_foreach (simplified, -1, acc_callback, self->acc);
-  gsk_path_unref (simplified);
-  gsk_path_unref (path);
-
-  if (!glyphy_arc_accumulator_successful (self->acc))
-    return FALSE;
-
-  g_assert (glyphy_arc_accumulator_get_error (self->acc) <= tolerance);
-
-  if (self->acc_endpoints->len > 0)
-    glyphy_outline_winding_from_even_odd ((gpointer)self->acc_endpoints->data,
-                                          self->acc_endpoints->len,
-                                          FALSE);
-
-  if (!glyphy_arc_list_encode_blob2 ((gpointer)self->acc_endpoints->data,
-                                     self->acc_endpoints->len,
-                                     buffer,
-                                     buffer_len,
-                                     faraway,
-                                     unit_size,
-                                     enlighten_max,
-                                     embolden_max,
-                                     &avg_fetch_achieved,
-                                     output_len,
-                                     nominal_width,
-                                     nominal_height,
-                                     extents))
-    return FALSE;
-
-  glyphy_extents_scale (extents, 1./upem, 1./upem);
-
-  return TRUE;
-}
-
-static inline hb_font_t *
-get_nominal_size_hb_font (PangoFont *font)
-{
-  hb_font_t *hbfont;
-  const float *coords;
-  unsigned int length;
-
-  hbfont = (hb_font_t *) g_object_get_data ((GObject *)font, "glyph-nominal-size-font");
-  if (hbfont == NULL)
-    {
-      hbfont = hb_font_create (hb_font_get_face (pango_font_get_hb_font (font)));
-      coords = hb_font_get_var_coords_design (pango_font_get_hb_font (font), &length);
-      if (length > 0)
-        hb_font_set_var_coords_design (hbfont, coords, length);
-
-      g_object_set_data_full ((GObject *)font, "glyphy-nominal-size-font",
-                              hbfont, (GDestroyNotify)hb_font_destroy);
-    }
-
-  return hbfont;
-}
-
-gboolean
-gsk_gl_glyphy_library_add (GskGLGlyphyLibrary      *self,
-                           GskGLGlyphyKey          *key,
-                           PangoFont               *font,
-                           const GskGLGlyphyValue **out_value)
-{
-  static glyphy_rgba_t buffer[4096 * 16];
-  GskGLTextureLibrary *tl = (GskGLTextureLibrary *)self;
-  GskGLGlyphyValue *value;
-  glyphy_extents_t extents;
-  hb_font_t *hbfont;
-  guint packed_x;
-  guint packed_y;
-  guint nominal_w, nominal_h;
-  guint output_len = 0;
-  guint texture_id;
-  guint width, height;
-
-  g_assert (GSK_IS_GL_GLYPHY_LIBRARY (self));
-  g_assert (key != NULL);
-  g_assert (font != NULL);
-  g_assert (out_value != NULL);
-
-  hbfont = get_nominal_size_hb_font (font);
-
-  /* Convert the glyph to a list of arcs */
-  if (!encode_glyph (self, hbfont, key->glyph, TOLERANCE,
-                     buffer, sizeof buffer, &output_len,
-                     &nominal_w, &nominal_h, &extents))
-    return FALSE;
-
-  /* Allocate space for list within atlas */
-  width = self->item_w;
-  height = (output_len + width - 1) / width;
-  GSK_DEBUG (GLYPH_CACHE, "font %u glyph %u: %u bytes (%u x %u)", key->font, key->glyph, output_len * 4, width, height);
-
-  value = gsk_gl_texture_library_pack (tl, key, sizeof *value,
-                                       width, height, 0,
-                                       &packed_x, &packed_y);
-
-  g_assert (packed_x % ITEM_W == 0);
-  g_assert (packed_y % ITEM_H_QUANTUM == 0);
-
-  /* Make sure we found space to pack */
-  texture_id = GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (value);
-  if (texture_id == 0)
-    return FALSE;
-
-  if (!glyphy_extents_is_empty (&extents))
-    {
-      /* Connect the texture for data upload */
-      glActiveTexture (GL_TEXTURE0);
-      glBindTexture (GL_TEXTURE_2D, texture_id);
-
-      g_assert (width > 0);
-      g_assert (height > 0);
-
-      /* Upload the arc list */
-      if (width * height == output_len)
-        {
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y,
-                           width, height,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer);
-        }
-      else
-        {
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y,
-                           width, height - 1,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer);
-          /* Upload the last row separately */
-          glTexSubImage2D (GL_TEXTURE_2D, 0,
-                           packed_x, packed_y + height - 1,
-                           output_len - (width * (height - 1)), 1,
-                           GL_RGBA, GL_UNSIGNED_BYTE,
-                           buffer + (width * (height - 1)));
-        }
-    }
-
-  value->extents.min_x = extents.min_x;
-  value->extents.min_y = extents.min_y;
-  value->extents.max_x = extents.max_x;
-  value->extents.max_y = extents.max_y;
-  value->nominal_w = nominal_w;
-  value->nominal_h = nominal_h;
-  value->atlas_x = packed_x / self->item_w;
-  value->atlas_y = packed_y / self->item_h_q;
-
-  *out_value = value;
-
-  return TRUE;
-}

gsk/gl/gskglglyphylibraryprivate.h

@@ -1,142 +0,0 @@
-/* gskglglyphylibraryprivate.h
- *
- * Copyright 2020-2022 Christian Hergert <chergert@redhat.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__
-#define __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__
-
-#include <glyphy.h>
-#include <pango/pango.h>
-
-#include "gskgltexturelibraryprivate.h"
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_GL_GLYPHY_LIBRARY (gsk_gl_glyphy_library_get_type())
-
-typedef guint FontKey;
-
-extern GQuark quark_glyphy_font_key;
-
-static inline FontKey
-gsk_gl_glyphy_library_get_font_key (PangoFont *font)
-{
-  FontKey key;
-
-  key = (FontKey) GPOINTER_TO_UINT (g_object_get_qdata ((GObject *)font, quark_glyphy_font_key));
-  if (key == 0)
-    {
-      PangoFontDescription *desc = pango_font_describe (font);
-      pango_font_description_set_size (desc, 10 * PANGO_SCALE);
-      key = (FontKey) pango_font_description_hash (desc);
-      pango_font_description_free (desc);
-      g_object_set_qdata ((GObject *)font, quark_glyphy_font_key, GUINT_TO_POINTER (key));
-    }
-
-  return key;
-}
-
-static inline float
-gsk_gl_glyphy_library_get_font_scale (PangoFont *font)
-{
-  hb_font_t *hbfont;
-  int x_scale, y_scale;
-
-  hbfont = pango_font_get_hb_font (font);
-  hb_font_get_scale (hbfont, &x_scale, &y_scale);
-
-  return MAX (x_scale, y_scale) / 1000.0;
-}
-
-
-typedef struct _GskGLGlyphyKey
-{
-  FontKey font;
-  PangoGlyph glyph;
-} GskGLGlyphyKey;
-
-typedef struct _GskGLGlyphyValue
-{
-  GskGLTextureAtlasEntry entry;
-  struct {
-    float min_x;
-    float min_y;
-    float max_x;
-    float max_y;
-  } extents;
-  guint nominal_w;
-  guint nominal_h;
-  guint atlas_x;
-  guint atlas_y;
-} GskGLGlyphyValue;
-
-G_DECLARE_FINAL_TYPE (GskGLGlyphyLibrary, gsk_gl_glyphy_library, GSK, GL_GLYPHY_LIBRARY, GskGLTextureLibrary)
-
-struct _GskGLGlyphyLibrary
-{
-  GskGLTextureLibrary parent_instance;
-  glyphy_arc_accumulator_t *acc;
-  GArray *acc_endpoints;
-  guint item_w;
-  guint item_h_q;
-  struct {
-    GskGLGlyphyKey key;
-    const GskGLGlyphyValue *value;
-  } front[256];
-};
-
-GskGLGlyphyLibrary *gsk_gl_glyphy_library_new (GskGLDriver             *driver);
-gboolean            gsk_gl_glyphy_library_add (GskGLGlyphyLibrary      *self,
-                                               GskGLGlyphyKey          *key,
-                                               PangoFont               *font,
-                                               const GskGLGlyphyValue **out_value);
-
-static inline guint
-gsk_gl_glyphy_library_lookup_or_add (GskGLGlyphyLibrary      *self,
-                                     const GskGLGlyphyKey    *key,
-                                     PangoFont               *font,
-                                     const GskGLGlyphyValue **out_value)
-{
-  GskGLTextureAtlasEntry *entry;
-  guint front_index = key->glyph & 0xFF;
-
-  if (memcmp (key, &self->front[front_index], sizeof *key) == 0)
-    {
-      *out_value = self->front[front_index].value;
-    }
-  else if (gsk_gl_texture_library_lookup ((GskGLTextureLibrary *)self, key, &entry))
-    {
-      *out_value = (GskGLGlyphyValue *)entry;
-      self->front[front_index].key = *key;
-      self->front[front_index].value = *out_value;
-    }
-  else
-    {
-      GskGLGlyphyKey *k = g_slice_copy (sizeof *key, key);
-      gsk_gl_glyphy_library_add (self, k, font, out_value);
-      self->front[front_index].key = *key;
-      self->front[front_index].value = *out_value;
-    }
-
-  return GSK_GL_TEXTURE_ATLAS_ENTRY_TEXTURE (*out_value);
-}
-
-G_END_DECLS
-
-#endif /* __GSK_GL_GLYPHY_LIBRARY_PRIVATE_H__ */

gsk/gl/gskglprograms.defs

@@ -87,21 +87,3 @@ GSK_GL_DEFINE_PROGRAM (unblurred_outset_shadow,
                        GSK_GL_ADD_UNIFORM (1, UNBLURRED_OUTSET_SHADOW_SPREAD, u_spread)
                        GSK_GL_ADD_UNIFORM (2, UNBLURRED_OUTSET_SHADOW_OFFSET, u_offset)
                        GSK_GL_ADD_UNIFORM (3, UNBLURRED_OUTSET_SHADOW_OUTLINE_RECT, u_outline_rect))
-
-GSK_GL_DEFINE_PROGRAM (glyphy,
-                       GSK_GL_SHADER_JOINED (VERTEX,
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.vs.glsl"),
-                                             NULL)
-                       GSK_GL_SHADER_JOINED (FRAGMENT,
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.atlas.glsl"),
-                                             GSK_GL_SHADER_STRING (glyphy_common_shader_source ()),
-                                             GSK_GL_SHADER_STRING ("#define GLYPHY_SDF_PSEUDO_DISTANCE 1\n"),
-                                             GSK_GL_SHADER_STRING (glyphy_sdf_shader_source ()),
-                                             GSK_GL_SHADER_RESOURCE ("glyphy.fs.glsl"),
-                                             NULL),
-                       GSK_GL_ADD_UNIFORM (0, GLYPHY_CONTRAST, u_contrast)
-                       GSK_GL_ADD_UNIFORM (1, GLYPHY_GAMMA_ADJUST, u_gamma_adjust)
-                       GSK_GL_ADD_UNIFORM (2, GLYPHY_OUTLINE_THICKNESS, u_outline_thickness)
-                       GSK_GL_ADD_UNIFORM (3, GLYPHY_OUTLINE, u_outline)
-                       GSK_GL_ADD_UNIFORM (4, GLYPHY_BOLDNESS, u_boldness)
-                       GSK_GL_ADD_UNIFORM (6, GLYPHY_ATLAS_INFO, u_atlas_info))

gsk/gl/gskglrenderer.c

@@ -150,13 +150,6 @@ gsk_gl_renderer_realize (GskRenderer  *renderer,
   gsk_gl_command_queue_set_profiler (self->command_queue,
                                      gsk_renderer_get_profiler (renderer));
 
-#ifdef G_ENABLE_DEBUG
-  if (gsk_renderer_get_debug_flags (renderer) & GSK_DEBUG_NO_GLYPHY)
-    GSK_RENDERER_DEBUG (renderer, RENDERER, "GL Renderer will use cairo for glyph rendering");
-  else
-    GSK_RENDERER_DEBUG (renderer, RENDERER, "GL Renderer will use glyphy for glyph rendering");
-#endif
-
   ret = TRUE;
 
 failure:
@@ -314,15 +307,10 @@ gsk_gl_renderer_render (GskRenderer          *renderer,
 
   gsk_gl_driver_begin_frame (self->driver, self->command_queue);
   job = gsk_gl_render_job_new (self->driver, &viewport, scale, render_region, 0, clear_framebuffer);
-
-  if ((gsk_renderer_get_debug_flags (renderer) & GSK_DEBUG_NO_GLYPHY) == 0)
-    gsk_gl_render_job_set_use_glyphy (job, TRUE);
-
 #ifdef G_ENABLE_DEBUG
   if (GSK_RENDERER_DEBUG_CHECK (GSK_RENDERER (self), FALLBACK))
     gsk_gl_render_job_set_debug_fallback (job, TRUE);
 #endif
-
   gsk_gl_render_job_render (job, root);
   gsk_gl_driver_end_frame (self->driver);
   gsk_gl_render_job_free (job);

gsk/gl/gskglrenderjob.c

@@ -34,14 +34,10 @@
 #include <gsk/gskroundedrectprivate.h>
 #include <math.h>
 #include <string.h>
-#ifdef HAVE_PANGOFT
-#include <pango/pangofc-font.h>
-#endif
 
 #include "gskglcommandqueueprivate.h"
 #include "gskgldriverprivate.h"
 #include "gskglglyphlibraryprivate.h"
-#include "gskglglyphylibraryprivate.h"
 #include "gskgliconlibraryprivate.h"
 #include "gskglprogramprivate.h"
 #include "gskglrenderjobprivate.h"
@@ -153,9 +149,6 @@ struct _GskGLRenderJob
    */
   guint clear_framebuffer : 1;
 
-  /* Allow experimental glyph rendering with glyphy */
-  guint use_glyphy : 1;
-
   /* Format we want to use for intermediate textures, determined by
    * looking at the format of the framebuffer we are rendering on.
    */
@@ -261,6 +254,8 @@ node_supports_2d_transform (const GskRenderNode *node)
     case GSK_BLEND_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
       return TRUE;
 
     case GSK_SHADOW_NODE:
@@ -315,6 +310,8 @@ node_supports_transform (const GskRenderNode *node)
     case GSK_BLEND_NODE:
     case GSK_BLUR_NODE:
     case GSK_MASK_NODE:
+    case GSK_FILL_NODE:
+    case GSK_STROKE_NODE:
       return TRUE;
 
     case GSK_SHADOW_NODE:
@@ -2966,10 +2963,10 @@ compute_phase_and_pos (float value, float *pos)
 }
 
 static inline void
-gsk_gl_render_job_visit_text_node_legacy (GskGLRenderJob      *job,
-                                          const GskRenderNode *node,
-                                          const GdkRGBA       *color,
-                                          gboolean             force_color)
+gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
+                                   const GskRenderNode *node,
+                                   const GdkRGBA       *color,
+                                   gboolean             force_color)
 {
   const PangoFont *font = gsk_text_node_get_font (node);
   const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
@@ -3105,263 +3102,6 @@ gsk_gl_render_job_visit_text_node_legacy (GskGLRenderJob      *job,
     }
 }
 
-/* Keep this in sync with glyph_vertex_transcode in glyphy.vs.glsl */
-typedef struct
-{
-  float x;
-  float y;
-  float g16hi;
-  float g16lo;
-} EncodedGlyph;
-
-static inline unsigned int
-glyph_encode (guint atlas_x ,  /* 7 bits */
-              guint atlas_y,   /* 7 bits */
-              guint corner_x,  /* 1 bit */
-              guint corner_y,  /* 1 bit */
-              guint nominal_w, /* 6 bits */
-              guint nominal_h) /* 6 bits */
-{
-  guint x, y;
-
-  g_assert (0 == (atlas_x & ~0x7F));
-  g_assert (0 == (atlas_y & ~0x7F));
-  g_assert (0 == (corner_x & ~1));
-  g_assert (0 == (corner_y & ~1));
-  g_assert (0 == (nominal_w & ~0x3F));
-  g_assert (0 == (nominal_h & ~0x3F));
-
-  x = (((atlas_x << 6) | nominal_w) << 1) | corner_x;
-  y = (((atlas_y << 6) | nominal_h) << 1) | corner_y;
-
-  return (x << 16) | y;
-}
-
-static inline void
-encoded_glyph_init (EncodedGlyph           *eg,
-                    float                   x,
-                    float                   y,
-                    guint                   corner_x,
-                    guint                   corner_y,
-                    const GskGLGlyphyValue *gi)
-{
-  guint encoded = glyph_encode (gi->atlas_x, gi->atlas_y, corner_x, corner_y, gi->nominal_w, gi->nominal_h);
-
-  eg->x = x;
-  eg->y = y;
-  eg->g16hi = encoded >> 16;
-  eg->g16lo = encoded & 0xFFFF;
-}
-
-static inline void
-add_encoded_glyph (GskGLDrawVertex    *vertices,
-                   const EncodedGlyph *eg,
-                   const guint16       c[4])
-{
-  *vertices = (GskGLDrawVertex) { .position = { eg->x, eg->y}, .uv = { eg->g16hi, eg->g16lo}, .color = { c[0], c[1], c[2], c[3] } };
-}
-
-static void
-get_synthetic_font_params (PangoFont   *font,
-                           gboolean    *embolden,
-                           PangoMatrix *matrix)
-{
-  *embolden = FALSE;
-  *matrix = (PangoMatrix) PANGO_MATRIX_INIT;
-
-#ifdef HAVE_PANGOFT
-  if (PANGO_IS_FC_FONT (font))
-    {
-      FcPattern *pattern = pango_fc_font_get_pattern (PANGO_FC_FONT (font));
-      FcBool b;
-      FcMatrix mat;
-      FcMatrix *m;
-
-      if (FcPatternGetBool (pattern, FC_EMBOLDEN, 0, &b) == FcResultMatch)
-        *embolden = b;
-
-      FcMatrixInit (&mat);
-      for (int i = 0; FcPatternGetMatrix (pattern, FC_MATRIX, i, &m) == FcResultMatch; i++)
-        FcMatrixMultiply (&mat, &mat, m);
-
-      matrix->xx = mat.xx;
-      matrix->xy = mat.xy;
-      matrix->yx = mat.yx;
-      matrix->yy = mat.yy;
-    }
-#endif
-}
-
-static inline void
-gsk_gl_render_job_visit_text_node_glyphy (GskGLRenderJob      *job,
-                                          const GskRenderNode *node,
-                                          const GdkRGBA       *color)
-{
-  const graphene_point_t *offset;
-  const PangoGlyphInfo *glyphs;
-  const PangoGlyphInfo *gi;
-  GskGLGlyphyLibrary *library;
-  GskGLCommandBatch *batch;
-  PangoFont *font;
-  GskGLDrawVertex *vertices;
-  const guint16 *c;
-  GskGLGlyphyKey lookup;
-  guint16 cc[4];
-  float x;
-  float y;
-  guint last_texture = 0;
-  guint num_glyphs;
-  guint used = 0;
-  guint i;
-  int x_position = 0;
-  float font_scale;
-  gboolean embolden;
-  PangoMatrix matrix = PANGO_MATRIX_INIT;
-
-#define GRID_SIZE 20
-
-  g_assert (!gsk_text_node_has_color_glyphs (node));
-
-  if (!(num_glyphs = gsk_text_node_get_num_glyphs (node)))
-    return;
-
-  if (RGBA_IS_CLEAR (color))
-    return;
-
-  font = (PangoFont *)gsk_text_node_get_font (node);
-  get_synthetic_font_params (font, &embolden, &matrix);
-
-  glyphs = gsk_text_node_get_glyphs (node, NULL);
-  library = job->driver->glyphy_library;
-  offset = gsk_text_node_get_offset (node);
-  x = offset->x + job->offset_x;
-  y = offset->y + job->offset_y;
-
-  rgba_to_half (color, cc);
-  c = cc;
-
-  gsk_gl_render_job_begin_draw (job, CHOOSE_PROGRAM (job, glyphy));
-
-  batch = gsk_gl_command_queue_get_batch (job->command_queue);
-  vertices = gsk_gl_command_queue_add_n_vertices (job->command_queue, num_glyphs);
-
-  lookup.font = gsk_gl_glyphy_library_get_font_key (font);
-  font_scale = gsk_gl_glyphy_library_get_font_scale (font);
-
-  for (i = 0, gi = glyphs; i < num_glyphs; i++, gi++)
-    {
-      const GskGLGlyphyValue *glyph;
-      float cx = 0, cy = 0;
-      guint texture_id;
-
-      lookup.glyph = gi->glyph;
-      texture_id = gsk_gl_glyphy_library_lookup_or_add (library, &lookup, font, &glyph);
-
-      if G_UNLIKELY (texture_id == 0)
-        continue;
-
-      if G_UNLIKELY (last_texture != texture_id || batch->draw.vbo_count + GSK_GL_N_VERTICES > 0xffff)
-        {
-          if G_LIKELY (last_texture != 0)
-            {
-              guint vbo_offset = batch->draw.vbo_offset + batch->draw.vbo_count;
-
-              /* Since we have batched added our VBO vertices to avoid repeated
-               * calls to the buffer, we need to manually tweak the vbo offset
-               * of the new batch as otherwise it will point at the end of our
-               * vbo array.
-               */
-              gsk_gl_render_job_split_draw (job);
-              batch = gsk_gl_command_queue_get_batch (job->command_queue);
-              batch->draw.vbo_offset = vbo_offset;
-            }
-
-          gsk_gl_program_set_uniform4i (job->current_program,
-                                        UNIFORM_GLYPHY_ATLAS_INFO, 0,
-                                        GSK_GL_TEXTURE_LIBRARY (library)->atlas_width,
-                                        GSK_GL_TEXTURE_LIBRARY (library)->atlas_height,
-                                        library->item_w,
-                                        library->item_h_q);
-          gsk_gl_program_set_uniform_texture (job->current_program,
-                                              UNIFORM_SHARED_SOURCE, 0,
-                                              GL_TEXTURE_2D,
-                                              GL_TEXTURE0,
-                                              texture_id);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_GAMMA_ADJUST, 0,
-                                        1.0);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_CONTRAST, 0,
-                                        1.0);
-
-          /* 0.0208 is the value used by freetype for synthetic emboldening */
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_BOLDNESS, 0,
-                                        embolden ? 0.0208 * GRID_SIZE : 0.0);
-
-#if 0
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_OUTLINE_THICKNESS, 0,
-                                        1.0);
-          gsk_gl_program_set_uniform1f (job->current_program,
-                                        UNIFORM_GLYPHY_OUTLINE, 0,
-                                        1.0);
-#endif
-
-          last_texture = texture_id;
-        }
-
-      cx = (float)(x_position + gi->geometry.x_offset) / PANGO_SCALE;
-      if G_UNLIKELY (gi->geometry.y_offset != 0)
-        cy = (float)(gi->geometry.y_offset) / PANGO_SCALE;
-
-      x_position += gi->geometry.width;
-
-      EncodedGlyph encoded[4];
-#define ENCODE_CORNER(_cx, _cy) \
-  G_STMT_START { \
-    float _dx = _cx * (glyph->extents.max_x - glyph->extents.min_x); \
-    float _dy = _cy * (glyph->extents.max_y - glyph->extents.min_y); \
-    float _vx = x + cx + font_scale * (glyph->extents.min_x + matrix.xx * _dx + matrix.xy * _dy); \
-    float _vy = y + cy - font_scale * (glyph->extents.min_y + matrix.yx * _dx + matrix.yy * _dy); \
-    encoded_glyph_init (&encoded[_cx * 2 + _cy], _vx, _vy, _cx, _cy, glyph); \
-  } G_STMT_END
-      ENCODE_CORNER (0, 0);
-      ENCODE_CORNER (0, 1);
-      ENCODE_CORNER (1, 0);
-      ENCODE_CORNER (1, 1);
-#undef ENCODE_CORNER
-
-      add_encoded_glyph (vertices++, &encoded[0], c);
-      add_encoded_glyph (vertices++, &encoded[1], c);
-      add_encoded_glyph (vertices++, &encoded[2], c);
-
-      add_encoded_glyph (vertices++, &encoded[1], c);
-      add_encoded_glyph (vertices++, &encoded[2], c);
-      add_encoded_glyph (vertices++, &encoded[3], c);
-
-      batch->draw.vbo_count += GSK_GL_N_VERTICES;
-      used++;
-    }
-
-  if (used != num_glyphs)
-    gsk_gl_command_queue_retract_n_vertices (job->command_queue, num_glyphs - used);
-
-  gsk_gl_render_job_end_draw (job);
-}
-
-static inline void
-gsk_gl_render_job_visit_text_node (GskGLRenderJob      *job,
-                                   const GskRenderNode *node,
-                                   const GdkRGBA       *color,
-                                   gboolean             force_color)
-{
-  if (job->use_glyphy && !gsk_text_node_has_color_glyphs (node))
-    gsk_gl_render_job_visit_text_node_glyphy (job, node, color);
-  else
-    gsk_gl_render_job_visit_text_node_legacy (job, node, color, force_color);
-}
-
 static inline void
 gsk_gl_render_job_visit_shadow_node (GskGLRenderJob      *job,
                                      const GskRenderNode *node)
@@ -4377,6 +4117,14 @@ gsk_gl_render_job_visit_node (GskGLRenderJob      *job,
       gsk_gl_render_job_visit_as_fallback (job, node);
     break;
 
+    case GSK_FILL_NODE:
+      gsk_gl_render_job_visit_as_fallback (job, node);
+    break;
+
+    case GSK_STROKE_NODE:
+      gsk_gl_render_job_visit_as_fallback (job, node);
+    break;
+
     case GSK_NOT_A_RENDER_NODE:
     default:
       g_assert_not_reached ();
@@ -4727,15 +4475,6 @@ gsk_gl_render_job_set_debug_fallback (GskGLRenderJob *job,
   job->debug_fallback = !!debug_fallback;
 }
 
-void
-gsk_gl_render_job_set_use_glyphy (GskGLRenderJob *job,
-                                  gboolean        use_glyphy)
-{
-  g_return_if_fail (job != NULL);
-
-  job->use_glyphy = !!use_glyphy;
-}
-
 static int
 get_framebuffer_format (GdkGLContext *context,
                         guint         framebuffer)

gsk/gl/gskglrenderjobprivate.h

@@ -35,5 +35,4 @@ void            gsk_gl_render_job_render_flipped     (GskGLRenderJob        *job
                                                       GskRenderNode         *root);
 void            gsk_gl_render_job_set_debug_fallback (GskGLRenderJob        *job,
                                                       gboolean               debug_fallback);
-void            gsk_gl_render_job_set_use_glyphy     (GskGLRenderJob        *job,
-                                                      gboolean               use_glyphy);
+

gsk/gl/gskgltexturelibraryprivate.h

@@ -36,14 +36,9 @@ G_BEGIN_DECLS
 
 typedef struct _GskGLTextureAtlas
 {
-  /* Used by Glyph/Icons */
   struct stbrp_context context;
   struct stbrp_node *nodes;
 
-  /* Used by Glyphy */
-  int cursor_x;
-  int cursor_y;
-
   int width;
   int height;
 
@@ -53,6 +48,7 @@ typedef struct _GskGLTextureAtlas
    * But are now unused.
    */
   int unused_pixels;
+
 } GskGLTextureAtlas;
 
 typedef struct _GskGLTextureAtlasEntry

gsk/gl/gskgltypesprivate.h

@@ -36,7 +36,6 @@ typedef struct _GskGLCompiler GskGLCompiler;
 typedef struct _GskGLDrawVertex GskGLDrawVertex;
 typedef struct _GskGLRenderTarget GskGLRenderTarget;
 typedef struct _GskGLGlyphLibrary GskGLGlyphLibrary;
-typedef struct _GskGLGlyphyLibrary GskGLGlyphyLibrary;
 typedef struct _GskGLIconLibrary GskGLIconLibrary;
 typedef struct _GskGLProgram GskGLProgram;
 typedef struct _GskGLRenderJob GskGLRenderJob;

gsk/gl/resources/glyphy.atlas.glsl

@@ -1,15 +0,0 @@
-uniform ivec4 u_atlas_info;
-
-#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos
-#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos
-#define GLYPHY_DEMO_EXTRA_ARGS , u_source, u_atlas_info, gi.atlas_pos
-
-vec4
-glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)
-{
-  ivec2 item_geom = _atlas_info.zw;
-  vec2 pos = (vec2 (_atlas_pos.xy * item_geom +
-		   ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +
-	      + vec2 (.5, .5)) / vec2(_atlas_info.xy);
-  return GskTexture (_tex, pos);
-}

gsk/gl/resources/glyphy.fs.glsl

@@ -1,62 +0,0 @@
-// FRAGMENT_SHADER:
-// glyphy.fs.glsl
-
-uniform float u_contrast;
-uniform float u_gamma_adjust;
-uniform float u_outline_thickness;
-uniform bool  u_outline;
-uniform float u_boldness;
-
-_IN_ vec4 v_glyph;
-_IN_ vec4 final_color;
-
-#define SQRT2     1.4142135623730951
-#define SQRT2_INV 0.70710678118654757 /* 1 / sqrt(2.) */
-
-struct glyph_info_t {
-  ivec2 nominal_size;
-  ivec2 atlas_pos;
-};
-
-glyph_info_t
-glyph_info_decode (vec4 v)
-{
-  glyph_info_t gi;
-  gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4;
-  gi.atlas_pos = ivec2 (v_glyph.zw) / 256;
-  return gi;
-}
-
-float
-antialias (float d)
-{
-  return smoothstep (-.75, +.75, d);
-}
-
-void
-main()
-{
-  vec2 p = v_glyph.xy;
-  glyph_info_t gi = glyph_info_decode (v_glyph);
-
-  /* isotropic antialiasing */
-  vec2 dpdx = dFdx (p);
-  vec2 dpdy = dFdy (p);
-  float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_INV;
-
-  float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS);
-  gsdist -= u_boldness;
-  float sdist = gsdist / m * u_contrast;
-
-  if (u_outline)
-    sdist = abs (sdist) - u_outline_thickness * .5;
-
-  if (sdist > 1.)
-    discard;
-
-  float alpha = antialias (-sdist);
-  if (u_gamma_adjust != 1.)
-    alpha = pow (alpha, 1./u_gamma_adjust);
-
-  gskSetOutputColor(final_color * alpha);
-}

gsk/gl/resources/glyphy.vs.glsl

@@ -1,25 +0,0 @@
-// VERTEX_SHADER:
-// glyphy.vs.glsl
-
-_OUT_ vec4 v_glyph;
-_OUT_ vec4 final_color;
-
-// Keep this in sync with glyph_encode in gskglrenderjob.c
-vec4
-glyph_vertex_transcode (vec2 v)
-{
-  ivec2 g = ivec2 (v);
-  ivec2 corner = ivec2 (mod (v, 2.));
-  g /= 2;
-  ivec2 nominal_size = ivec2 (mod (vec2(g), 64.));
-  return vec4 (corner * nominal_size, g * 4);
-}
-
-void
-main()
-{
-  v_glyph = glyph_vertex_transcode(aUv);
-  vUv = v_glyph.zw;
-  gl_Position = u_projection * u_modelview * vec4(aPosition, 0.0, 1.0);
-  final_color = gsk_scaled_premultiply(aColor, u_alpha);
-}

gsk/gl/resources/mask.glsl

@@ -13,12 +13,6 @@ void main() {
 uniform int u_mode;
 uniform sampler2D u_mask;
 
-float
-luminance (vec3 color)
-{
-  return dot (vec3 (0.2126, 0.7152, 0.0722), color);
-}
-
 void main() {
   vec4 source = GskTexture(u_source, vUv);
   vec4 mask = GskTexture(u_mask, vUv);
@@ -29,9 +23,9 @@ void main() {
   else if (u_mode == 1)
     mask_value = 1.0 - mask.a;
   else if (u_mode == 2)
-    mask_value = luminance (mask.rgb);
+    mask_value = (0.2126 * mask.r + 0.7152 * mask.g + 0.0722 * mask.b) * mask.a;
   else if (u_mode == 3)
-    mask_value = mask.a - luminance (mask.rgb);
+    mask_value = 1.0 - (0.2126 * mask.r + 0.7152 * mask.g + 0.0722 * mask.b) * mask.a;
   else
     mask_value = 0.0;
 

gsk/gl/resources/preamble.glsl

@@ -1,5 +1,3 @@
-#extension GL_OES_standard_derivatives : enable
-
 #ifndef GSK_LEGACY
 precision highp float;
 #endif

gsk/gsk.h

@@ -20,11 +20,15 @@
 #define __GSK_H_INSIDE__
 
 #include <gsk/gskenums.h>
+#include <gsk/gskglshader.h>
+#include <gsk/gskpath.h>
+#include <gsk/gskpathbuilder.h>
+#include <gsk/gskpathmeasure.h>
 #include <gsk/gskrenderer.h>
 #include <gsk/gskrendernode.h>
 #include <gsk/gskroundedrect.h>
+#include <gsk/gskstroke.h>
 #include <gsk/gsktransform.h>
-#include <gsk/gskglshader.h>
 
 #include <gsk/gskcairorenderer.h>
 

gsk/gskboundingboxprivate.h

@@ -1,100 +0,0 @@
-#pragma once
-
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-typedef struct _GskBoundingBox GskBoundingBox;
-
-struct _GskBoundingBox {
-  graphene_point_t min;
-  graphene_point_t max;
-};
-
-static inline GskBoundingBox *
-gsk_bounding_box_init (GskBoundingBox         *self,
-                       const graphene_point_t *a,
-                       const graphene_point_t *b)
-{
-  self->min.x = MIN (a->x, b->x);
-  self->min.y = MIN (a->y, b->y);
-  self->max.x = MAX (a->x, b->x);
-  self->max.y = MAX (a->y, b->y);
-  return self;
-}
-
-static inline GskBoundingBox *
-gsk_bounding_box_init_copy (GskBoundingBox       *self,
-                            const GskBoundingBox *src)
-{
-  self->min = src->min;
-  self->max = src->max;
-  return self;
-}
-
-static inline GskBoundingBox *
-gsk_bounding_box_init_from_rect (GskBoundingBox        *self,
-                                 const graphene_rect_t *bounds)
-{
-  self->min = bounds->origin;
-  self->max.x = bounds->origin.x + bounds->size.width;
-  self->max.y = bounds->origin.y + bounds->size.height;
-  return self;
-}
-
-static inline void
-gsk_bounding_box_expand (GskBoundingBox         *self,
-                         const graphene_point_t *p)
-{
-  self->min.x = MIN (self->min.x, p->x);
-  self->min.y = MIN (self->min.y, p->y);
-  self->max.x = MAX (self->max.x, p->x);
-  self->max.y = MAX (self->max.y, p->y);
-}
-
-static inline graphene_rect_t *
-gsk_bounding_box_to_rect (const GskBoundingBox  *self,
-                          graphene_rect_t       *rect)
-{
-  rect->origin = self->min;
-  rect->size.width = self->max.x - self->min.x;
-  rect->size.height = self->max.y - self->min.y;
-  return rect;
-}
-
-static inline gboolean
-gsk_bounding_box_contains_point (const GskBoundingBox   *self,
-                                 const graphene_point_t *p)
-{
-  return self->min.x <= p->x && p->x <= self->max.x &&
-         self->min.y <= p->y && p->y <= self->max.y;
-}
-
-static inline gboolean
-gsk_bounding_box_contains_point_with_epsilon (const GskBoundingBox   *self,
-                                              const graphene_point_t *p,
-                                              float                   epsilon)
-{
-  return self->min.x - epsilon <= p->x && p->x <= self->max.x + epsilon &&
-         self->min.y - epsilon <= p->y && p->y <= self->max.y + epsilon;
-}
-
-static inline gboolean
-gsk_bounding_box_intersection (const GskBoundingBox *a,
-                               const GskBoundingBox *b,
-                               GskBoundingBox       *res)
-{
-  graphene_point_t min, max;
-
-  min.x = MAX (a->min.x, b->min.x);
-  min.y = MAX (a->min.y, b->min.y);
-  max.x = MIN (a->max.x, b->max.x);
-  max.y = MIN (a->max.y, b->max.y);
-
-  if (res)
-    gsk_bounding_box_init (res, &min, &max);
-
-  return min.x <= max.x && min.y <= max.y;
-}
-
-G_END_DECLS

gsk/gskcontourprivate.h

@@ -1,103 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#pragma once
-
-#include "gskpath.h"
-
-#include "gskpathopprivate.h"
-
-G_BEGIN_DECLS
-
-typedef enum
-{
-  GSK_PATH_FLAT,
-  GSK_PATH_CLOSED
-} GskPathFlags;
-
-typedef struct _GskContour GskContour;
-
-GskContour *            gsk_rect_contour_new                    (const graphene_rect_t  *rect);
-GskContour *            gsk_rounded_rect_contour_new            (const GskRoundedRect   *rounded_rect);
-GskContour *            gsk_circle_contour_new                  (const graphene_point_t *center,
-                                                                 float                   radius,
-                                                                 float                   start_angle,
-                                                                 float                   end_angle);
-GskContour *            gsk_standard_contour_new                (GskPathFlags            flags,
-                                                                 const graphene_point_t *points,
-                                                                 gsize                   n_points,
-                                                                 const gskpathop        *ops,
-                                                                 gsize                   n_ops,
-                                                                 gssize                  offset);
-
-void                    gsk_contour_copy                        (GskContour *            dest,
-                                                                 const GskContour       *src);
-GskContour *            gsk_contour_dup                         (const GskContour       *src);
-GskContour *            gsk_contour_reverse                     (const GskContour       *src);
-
-gsize                   gsk_contour_get_size                    (const GskContour       *self);
-GskPathFlags            gsk_contour_get_flags                   (const GskContour       *self);
-void                    gsk_contour_print                       (const GskContour       *self,
-                                                                 GString                *string);
-gboolean                gsk_contour_get_bounds                  (const GskContour       *self,
-                                                                 graphene_rect_t        *bounds);
-gpointer                gsk_contour_init_measure                (const GskContour       *self,
-                                                                 float                   tolerance,
-                                                                 float                  *out_length);
-void                    gsk_contour_free_measure                (const GskContour       *self,
-                                                                 gpointer                data);
-gboolean                gsk_contour_foreach                     (const GskContour       *self,
-                                                                 float                   tolerance,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-void                    gsk_contour_get_start_end               (const GskContour       *self,
-                                                                 graphene_point_t       *start,
-                                                                 graphene_point_t       *end);
-void                    gsk_contour_get_point                   (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 float                   distance,
-                                                                 GskPathDirection        direction,
-                                                                 graphene_point_t       *pos,
-                                                                 graphene_vec2_t        *tangent);
-gboolean                gsk_contour_get_closest_point           (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 float                   tolerance,
-                                                                 const graphene_point_t *point,
-                                                                 float                   threshold,
-                                                                 float                  *out_distance,
-                                                                 graphene_point_t       *out_pos,
-                                                                 float                  *out_offset,
-                                                                 graphene_vec2_t        *out_tangent);
-int                     gsk_contour_get_winding                 (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 const graphene_point_t *point);
-void                    gsk_contour_add_segment                 (const GskContour       *self,
-                                                                 GskPathBuilder         *builder,
-                                                                 gpointer                measure_data,
-                                                                 gboolean                emit_move_to,
-                                                                 float                   start,
-                                                                 float                   end);
-float                   gsk_contour_get_curvature               (const GskContour       *self,
-                                                                 gpointer                measure_data,
-                                                                 float                   distance,
-                                                                 graphene_point_t       *center);
-
-
-G_END_DECLS

gsk/gskcurveintersect.c

@@ -1,879 +0,0 @@
-/*
- * Copyright © 2020 Red Hat, Inc
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Matthias Clasen <mclasen@redhat.com>
- */
-
-#include "config.h"
-
-#include <math.h>
-
-#include "gskcurveprivate.h"
-
-/* {{{ Utilities */
-
-static void
-get_tangent (const graphene_point_t *p0,
-             const graphene_point_t *p1,
-             graphene_vec2_t        *t)
-{
-  graphene_vec2_init (t, p1->x - p0->x, p1->y - p0->y);
-  graphene_vec2_normalize (t, t);
-}
-
-static inline gboolean
-acceptable (float t)
-{
-  return 0 - FLT_EPSILON <= t && t <= 1 + FLT_EPSILON;
-}
-
-static inline void
-_sincosf (float  angle,
-          float *out_s,
-          float *out_c)
-{
-#ifdef HAVE_SINCOSF
-      sincosf (angle, out_s, out_c);
-#else
-      *out_s = sinf (angle);
-      *out_c = cosf (angle);
-#endif
-}
-
-static void
-align_points (const graphene_point_t *p,
-              const graphene_point_t *a,
-              const graphene_point_t *b,
-              graphene_point_t       *q,
-              int                     n)
-{
-  graphene_vec2_t n1;
-  float angle;
-  float s, c;
-
-  get_tangent (a, b, &n1);
-  angle = - atan2 (graphene_vec2_get_y (&n1), graphene_vec2_get_x (&n1));
-  _sincosf (angle, &s, &c);
-
-  for (int i = 0; i < n; i++)
-    {
-      q[i].x = (p[i].x - a->x) * c - (p[i].y - a->y) * s;
-      q[i].y = (p[i].x - a->x) * s + (p[i].y - a->y) * c;
-    }
-}
-
-static void
-find_point_on_line (const graphene_point_t *p1,
-                    const graphene_point_t *p2,
-                    const graphene_point_t *q,
-                    float                  *t)
-{
-  if (p2->x != p1->x)
-    *t = (q->x - p1->x) / (p2->x - p1->x);
-  else
-    *t = (q->y - p1->y) / (p2->y - p1->y);
-}
-
-/* find solutions for at^2 + bt + c = 0 */
-static int
-solve_quadratic (float a, float b, float c, float t[2])
-{
-  float d;
-  int n = 0;
-
-  if (fabs (a) > 0.0001)
-    {
-      if (b*b > 4*a*c)
-        {
-          d = sqrt (b*b - 4*a*c);
-          t[n++] = (-b + d)/(2*a);
-          t[n++] = (-b - d)/(2*a);
-        }
-      else
-        {
-          t[n++] = -b / (2*a);
-        }
-    }
-  else if (fabs (b) > 0.0001)
-    {
-      t[n++] = -c / b;
-    }
-
-  return n;
-}
-
-static int
-filter_allowable (float t[3],
-                  int   n)
-{
-  float g[3];
-  int j = 0;
-
-  for (int i = 0; i < n; i++)
-    if (0 < t[i] && t[i] < 1)
-      g[j++] = t[i];
-  for (int i = 0; i < j; i++)
-    t[i] = g[i];
-  return j;
-}
-
-/* Solve P = 0 where P is
- * P = (1-t)^2*pa + 2*t*(1-t)*pb + t^2*pc
- */
-static int
-get_quadratic_roots (float pa, float pb, float pc, float roots[2])
-{
-  float a, b, c, d;
-  int n_roots = 0;
-
-  a = pa - 2 * pb + pc;
-  b = 2 * (pb - pa);
-  c = pa;
-
-  d = b*b - 4*a*c;
-
-  if (d > 0.0001)
-    {
-      float q = sqrt (d);
-      roots[n_roots] = (-b + q) / (2 * a);
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-      roots[n_roots] = (-b - q) / (2 * a);
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-    }
-  else if (fabs (d) < 0.0001)
-    {
-      roots[n_roots] = -b / (2 * a);
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-    }
-
-  return n_roots;
-}
-
-static float
-cuberoot (float v)
-{
-  if (v < 0)
-    return -pow (-v, 1.f / 3);
-  return pow (v, 1.f / 3);
-}
-
-/* Solve P = 0 where P is
- * P = (1-t)^3*pa + 3*t*(1-t)^2*pb + 3*t^2*(1-t)*pc + t^3*pd
- */
-static int
-get_cubic_roots (float pa, float pb, float pc, float pd, float roots[3])
-{
-  float a, b, c, d;
-  float q, q2;
-  float p, p3;
-  float discriminant;
-  float u1, v1, sd;
-  int n_roots = 0;
-
-  d = -pa + 3*pb - 3*pc + pd;
-  a = 3*pa - 6*pb + 3*pc;
-  b = -3*pa + 3*pb;
-  c = pa;
-
-  if (fabs (d) < 0.0001)
-    {
-      if (fabs (a) < 0.0001)
-        {
-          if (fabs (b) < 0.0001)
-            return 0;
-
-          if (acceptable (-c / b))
-            {
-              roots[0] = -c / b;
-
-              return 1;
-            }
-
-          return 0;
-        }
-      q = sqrt (b*b - 4*a*c);
-      roots[n_roots] = (-b + q) / (2 * a);
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-
-      roots[n_roots] = (-b - q) / (2 * a);
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-
-      return n_roots;
-    }
-
-  a /= d;
-  b /= d;
-  c /= d;
-
-  p = (3*b - a*a)/3;
-  p3 = p/3;
-  q = (2*a*a*a - 9*a*b + 27*c)/27;
-  q2 = q/2;
-  discriminant = q2*q2 + p3*p3*p3;
-
-  if (discriminant < 0)
-    {
-      float mp3 = -p/3;
-      float mp33 = mp3*mp3*mp3;
-      float r = sqrt (mp33);
-      float t = -q / (2*r);
-      float cosphi = t < -1 ? -1 : (t > 1 ? 1 : t);
-      float phi = acos (cosphi);
-      float crtr = cuberoot (r);
-      float t1 = 2*crtr;
-
-      roots[n_roots] = t1 * cos (phi/3) - a/3;
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-      roots[n_roots] = t1 * cos ((phi + 2*M_PI) / 3) - a/3;
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-      roots[n_roots] = t1 * cos ((phi + 4*M_PI) / 3) - a/3;
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-
-    return n_roots;
-  }
-
-  if (discriminant == 0)
-    {
-      u1 = q2 < 0 ? cuberoot (-q2) : -cuberoot (q2);
-      roots[n_roots] = 2*u1 - a/3;
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-      roots[n_roots] = -u1 - a/3;
-      if (acceptable (roots[n_roots]))
-        n_roots++;
-
-      return n_roots;
-    }
-
-  sd = sqrt (discriminant);
-  u1 = cuberoot (sd - q2);
-  v1 = cuberoot (sd + q2);
-  roots[n_roots] = u1 - v1 - a/3;
-  if (acceptable (roots[n_roots]))
-    n_roots++;
-
-  return n_roots;
-}
-
-/* }}} */
-/* {{{ Cusps and inflections */
-
-/* Get the points where the curvature of curve is
- * zero, or a maximum or minimum, inside the open
- * interval from 0 to 1.
- */
-int
-gsk_curve_get_curvature_points (const GskCurve *curve,
-                                float           t[3])
-{
-  const graphene_point_t *pts = curve->cubic.points;
-  graphene_point_t p[4];
-  float a, b, c, d;
-  float x, y, z;
-  int n;
-
-  if (curve->op != GSK_PATH_CUBIC)
-    return 0;
-
-  align_points (pts, &pts[0], &pts[3], p, 4);
-
-  a = p[2].x * p[1].y;
-  b = p[3].x * p[1].y;
-  c = p[1].x * p[2].y;
-  d = p[3].x * p[2].y;
-
-  x = - 3*a + 2*b + 3*c - d;
-  y = 3*a - b - 3*c;
-  z = c - a;
-
-  n = solve_quadratic (x, y, z, t);
-  return filter_allowable (t, n);
-}
-
-/* Find cusps inside the open interval from 0 to 1.
- *
- * According to Stone & deRose, A Geometric Characterization
- * of Parametric Cubic curves, a necessary and sufficient
- * condition is that the first derivative vanishes.
- */
-int
-gsk_curve_get_cusps (const GskCurve *curve,
-                     float           t[2])
-{
-  const graphene_point_t *pts = curve->cubic.points;
-  graphene_point_t p[3];
-  float ax, bx, cx;
-  float ay, by, cy;
-  float tx[3];
-  int nx;
-  int n = 0;
-
-  if (curve->op != GSK_PATH_CUBIC)
-    return 0;
-
-  p[0].x = 3 * (pts[1].x - pts[0].x);
-  p[0].y = 3 * (pts[1].y - pts[0].y);
-  p[1].x = 3 * (pts[2].x - pts[1].x);
-  p[1].y = 3 * (pts[2].y - pts[1].y);
-  p[2].x = 3 * (pts[3].x - pts[2].x);
-  p[2].y = 3 * (pts[3].y - pts[2].y);
-
-  ax = p[0].x - 2 * p[1].x + p[2].x;
-  bx = - 2 * p[0].x + 2 * p[1].x;
-  cx = p[0].x;
-
-  nx = solve_quadratic (ax, bx, cx, tx);
-  nx = filter_allowable (tx, nx);
-
-  ay = p[0].y - 2 * p[1].y + p[2].y;
-  by = - 2 * p[0].y + 2 * p[1].y;
-  cy = p[0].y;
-
-  for (int i = 0; i < nx; i++)
-    {
-      float ti = tx[i];
-
-      if (0 < ti && ti < 1 &&
-          fabs (ay * ti * ti + by * ti + cy) < 0.001)
-        t[n++] = ti;
-    }
-
-  return n;
-}
-
-/* }}} */
-/* {{{ Intersection */
-
-static int
-line_intersect (const GskCurve   *curve1,
-                const GskCurve   *curve2,
-                float            *t1,
-                float            *t2,
-                graphene_point_t *p,
-                int               n)
-{
-  const graphene_point_t *pts1 = curve1->line.points;
-  const graphene_point_t *pts2 = curve2->line.points;
-  float a1 = pts1[0].x - pts1[1].x;
-  float b1 = pts1[0].y - pts1[1].y;
-  float a2 = pts2[0].x - pts2[1].x;
-  float b2 = pts2[0].y - pts2[1].y;
-  float det = a1 * b2 - b1 * a2;
-
-  if (fabs(det) > 0.01)
-    {
-      float tt =   ((pts1[0].x - pts2[0].x) * b2 - (pts1[0].y - pts2[0].y) * a2) / det;
-      float ss = - ((pts1[0].y - pts2[0].y) * a1 - (pts1[0].x - pts2[0].x) * b1) / det;
-
-      if (acceptable (tt) && acceptable (ss))
-        {
-          p[0].x = pts1[0].x + tt * (pts1[1].x - pts1[0].x);
-          p[0].y = pts1[0].y + tt * (pts1[1].y - pts1[0].y);
-
-          t1[0] = tt;
-          t2[0] = ss;
-
-          return 1;
-        }
-    }
-  else /* parallel lines */
-    {
-      float r = a1 * (pts1[1].y - pts2[0].y) - (pts1[1].x - pts2[0].x) * b1;
-      float dist = (r * r) / (a1 * a1 + b1 * b1);
-      float t, s, tt, ss;
-
-      if (dist > 0.01)
-        return 0;
-
-      if (pts1[1].x != pts1[0].x)
-        {
-          t = (pts2[0].x - pts1[0].x) / (pts1[1].x - pts1[0].x);
-          s = (pts2[1].x - pts1[0].x) / (pts1[1].x - pts1[0].x);
-        }
-      else
-        {
-          t = (pts2[0].y - pts1[0].y) / (pts1[1].y - pts1[0].y);
-          s = (pts2[1].y - pts1[0].y) / (pts1[1].y - pts1[0].y);
-        }
-
-      if ((t < 0 && s < 0) || (t > 1 && s > 1))
-        return 0;
-
-      if (acceptable (t))
-        {
-          t1[0] = t;
-          t2[0] = 0;
-          p[0] = pts2[0];
-        }
-      else if (t < 0)
-        {
-          if (pts2[1].x != pts2[0].x)
-            tt = (pts1[0].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
-          else
-            tt = (pts1[0].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
-
-          t1[0] = 0;
-          t2[0] = tt;
-          p[0] = pts1[0];
-        }
-      else
-        {
-          if (pts2[1].x != pts2[0].x)
-            tt = (pts1[1].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
-          else
-            tt = (pts1[1].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
-
-          t1[0] = 1;
-          t2[0] = tt;
-          p[0] = pts1[1];
-        }
-
-      if (acceptable (s))
-        {
-          if (t2[0] == 1)
-            return 1;
-
-          t1[1] = s;
-          t2[1] = 1;
-          p[1] = pts2[1];
-        }
-      else if (s < 0)
-        {
-          if (t1[0] == 0)
-            return 1;
-
-          if (pts2[1].x != pts2[0].x)
-            ss = (pts1[0].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
-          else
-            ss = (pts1[0].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
-
-          t1[1] = 0;
-          t2[1] = ss;
-          p[1] = pts1[0];
-        }
-      else
-        {
-          if (t1[0] == 1)
-            return 1;
-
-          if (pts2[1].x != pts2[0].x)
-            ss = (pts1[1].x - pts2[0].x) / (pts2[1].x - pts2[0].x);
-          else
-            ss = (pts1[1].y - pts2[0].y) / (pts2[1].y - pts2[0].y);
-
-          t1[1] = 1;
-          t2[1] = ss;
-          p[1] = pts1[1];
-        }
-
-      return 2;
-    }
-
-  return 0;
-}
-
-static int
-line_quad_intersect (const GskCurve   *curve1,
-                     const GskCurve   *curve2,
-                     float            *t1,
-                     float            *t2,
-                     graphene_point_t *p,
-                     int               n)
-{
-  const graphene_point_t *a = &curve1->line.points[0];
-  const graphene_point_t *b = &curve1->line.points[1];
-  graphene_point_t pts[4];
-  float t[2];
-  int m, i, j;
-
-  /* Rotate things to place curve1 on the x axis,
-   * then solve curve2 for y == 0.
-   */
-  align_points (curve2->quad.points, a, b, pts, 3);
-
-  m = get_quadratic_roots (pts[0].y, pts[1].y, pts[2].y, t);
-
-  j = 0;
-  for (i = 0; i < m; i++)
-    {
-      t2[j] = t[i];
-      gsk_curve_get_point (curve2, t2[j], &p[j]);
-      find_point_on_line (a, b, &p[j], &t1[j]);
-      if (acceptable (t1[j]))
-        j++;
-      if (j == n)
-        break;
-    }
-
-  return j;
-}
-
-static int
-line_cubic_intersect (const GskCurve   *curve1,
-                      const GskCurve   *curve2,
-                      float            *t1,
-                      float            *t2,
-                      graphene_point_t *p,
-                      int               n)
-{
-  const graphene_point_t *a = &curve1->line.points[0];
-  const graphene_point_t *b = &curve1->line.points[1];
-  graphene_point_t pts[4];
-  float t[3];
-  int m, i, j;
-
-  /* Rotate things to place curve1 on the x axis,
-   * then solve curve2 for y == 0.
-   */
-  align_points (curve2->cubic.points, a, b, pts, 4);
-
-  m = get_cubic_roots (pts[0].y, pts[1].y, pts[2].y, pts[3].y, t);
-
-  j = 0;
-  for (i = 0; i < m; i++)
-    {
-      t2[j] = t[i];
-      gsk_curve_get_point (curve2, t2[j], &p[j]);
-      find_point_on_line (a, b, &p[j], &t1[j]);
-      if (acceptable (t1[j]))
-        j++;
-      if (j == n)
-        break;
-    }
-
-  return j;
-}
-
-#define MAX_LEVEL 25
-#define TOLERANCE 0.001
-
-static void
-cubic_intersect_recurse (const GskCurve   *curve1,
-                         const GskCurve   *curve2,
-                         float             t1l,
-                         float             t1r,
-                         float             t2l,
-                         float             t2r,
-                         float            *t1,
-                         float            *t2,
-                         graphene_point_t *p,
-                         int               n,
-                         int              *pos,
-                         int               level)
-{
-  GskCurve p11, p12, p21, p22;
-  GskBoundingBox b1, b2;
-  float d1, d2;
-
-  if (*pos == n)
-    return;
-
-  if (level == MAX_LEVEL)
-    return;
-
-  gsk_curve_get_bounds (curve1, &b1);
-  gsk_curve_get_bounds (curve2, &b2);
-  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
-    return;
-
-  gsk_curve_get_tight_bounds (curve1, &b1);
-  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
-    return;
-
-  gsk_curve_get_tight_bounds (curve2, &b2);
-  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
-    return;
-
-  d1 = (t1r - t1l) / 2;
-  d2 = (t2r - t2l) / 2;
-
-  if (b1.max.x - b1.min.x < TOLERANCE && b1.max.y - b1.min.y < TOLERANCE &&
-      b2.max.x - b2.min.x < TOLERANCE && b2.max.y - b2.min.y < TOLERANCE)
-    {
-      graphene_point_t c;
-      t1[*pos] = t1l + d1;
-      t2[*pos] = t2l + d2;
-      gsk_curve_get_point (curve1, 0.5, &c);
-
-      for (int i = 0; i < *pos; i++)
-        {
-          if (graphene_point_near (&c, &p[i], 0.1))
-            return;
-        }
-
-      p[*pos] = c;
-      (*pos)++;
-
-      return;
-    }
-
-  gsk_curve_split (curve1, 0.5, &p11, &p12);
-  gsk_curve_split (curve2, 0.5, &p21, &p22);
-
-  cubic_intersect_recurse (&p11, &p21, t1l,      t1l + d1, t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
-  cubic_intersect_recurse (&p11, &p22, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
-  cubic_intersect_recurse (&p12, &p21, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
-  cubic_intersect_recurse (&p12, &p22, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
-}
-
-static int
-cubic_intersect (const GskCurve   *curve1,
-                 const GskCurve   *curve2,
-                 float            *t1,
-                 float            *t2,
-                 graphene_point_t *p,
-                 int               n)
-{
-  int pos = 0;
-
-  cubic_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, 0);
-
-  return pos;
-}
-
-static void
-get_bounds (const GskCurve  *curve,
-            float            tl,
-            float            tr,
-            GskBoundingBox  *bounds)
-{
-  GskCurve c;
-
-  gsk_curve_segment (curve, tl, tr, &c);
-  gsk_curve_get_tight_bounds (&c, bounds);
-}
-
-static void
-general_intersect_recurse (const GskCurve   *curve1,
-                           const GskCurve   *curve2,
-                           float             t1l,
-                           float             t1r,
-                           float             t2l,
-                           float             t2r,
-                           float            *t1,
-                           float            *t2,
-                           graphene_point_t *p,
-                           int               n,
-                           int              *pos,
-                           int               level)
-{
-  GskBoundingBox b1, b2;
-  float d1, d2;
-
-  if (*pos == n)
-    return;
-
-  if (level == MAX_LEVEL)
-    return;
-
-  get_bounds (curve1, t1l, t1r, &b1);
-  get_bounds (curve2, t2l, t2r, &b2);
-
-  if (!gsk_bounding_box_intersection (&b1, &b2, NULL))
-    return;
-
-  d1 = (t1r - t1l) / 2;
-  d2 = (t2r - t2l) / 2;
-
-  if (b1.max.x - b1.min.x < TOLERANCE && b1.max.y - b1.min.y < TOLERANCE &&
-      b2.max.x - b2.min.x < TOLERANCE && b2.max.y - b2.min.y < TOLERANCE)
-    {
-      graphene_point_t c;
-      t1[*pos] = t1l + d1;
-      t2[*pos] = t2l + d2;
-      gsk_curve_get_point (curve1, t1[*pos], &c);
-
-      for (int i = 0; i < *pos; i++)
-        {
-          if (graphene_point_near (&c, &p[i], 0.1))
-            return;
-        }
-
-      p[*pos] = c;
-      (*pos)++;
-
-      return;
-    }
-
-  /* Note that in the conic case, we cannot just split the curves and
-   * pass the two halves down, since splitting changes the parametrization,
-   * and we need the t's to be valid parameters wrt to the original curve.
-   *
-   * So, instead, we determine the bounding boxes above by always starting
-   * from the original curve. That is a bit less efficient, but also works
-   * for conics.
-   */
-  general_intersect_recurse (curve1, curve2, t1l,      t1l + d1, t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
-  general_intersect_recurse (curve1, curve2, t1l,      t1l + d1, t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
-  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l,      t2l + d2, t1, t2, p, n, pos, level + 1);
-  general_intersect_recurse (curve1, curve2, t1l + d1, t1r,      t2l + d2, t2r,      t1, t2, p, n, pos, level + 1);
-}
-
-static int
-general_intersect (const GskCurve   *curve1,
-                   const GskCurve   *curve2,
-                   float            *t1,
-                   float            *t2,
-                   graphene_point_t *p,
-                   int               n)
-{
-  int pos = 0;
-
-  general_intersect_recurse (curve1, curve2, 0, 1, 0, 1, t1, t2, p, n, &pos, 0);
-
-  return pos;
-}
-
-static int
-curve_self_intersect (const GskCurve   *curve,
-                      float            *t1,
-                      float            *t2,
-                      graphene_point_t *p,
-                      int               n)
-{
-  float tt[3], ss[3], s;
-  graphene_point_t pp[3];
-  int m;
-  GskCurve cs, ce;
-
-  if (curve->op != GSK_PATH_CUBIC)
-    return 0;
-
-  s = 0.5;
-  m = gsk_curve_get_curvature_points (curve, tt);
-  for (int i = 0; i < m; i++)
-    {
-      if (gsk_curve_get_curvature (curve, tt[i], NULL) == 0)
-        {
-          s = tt[i];
-          break;
-        }
-    }
-
-  gsk_curve_split (curve, s, &cs, &ce);
-
-  m = cubic_intersect (&cs, &ce, tt, ss, pp, 3);
-
-  if (m > 1)
-    {
-      /* One of the (at most 2) intersections we found
-       * must be the common point where we split the curve.
-       * It will have a t value of 1 and an s value of 0.
-       */
-      if (fabs (tt[0] - 1) > 1e-3)
-        {
-          t1[0] = t2[0] = tt[0] * s;
-          p[0] = pp[0];
-        }
-      else if (fabs (tt[1] - 1) > 1e-3)
-        {
-          t1[0] = t2[0] = tt[1] * s;
-          p[0] = pp[1];
-        }
-
-      if (n == 1)
-        return 1;
-
-      if (fabs (ss[0]) > 1e-3)
-        {
-          t1[1] = t2[1] = s + ss[0] * (1 - s);
-          p[1] = pp[0];
-        }
-      else if (fabs (ss[1]) > 1e-3)
-        {
-          t1[1] = t2[1] = s + ss[1] * (1 - s);
-          p[1] = pp[1];
-        }
-
-      return 2;
-    }
-
-  return 0;
-}
-
-static inline gboolean
-curve_equal (const GskCurve *c1,
-             const GskCurve *c2)
-{
-  gsize curve_size[] = {
-    sizeof (GskLineCurve),
-    sizeof (GskLineCurve),
-    sizeof (GskLineCurve),
-    sizeof (GskQuadCurve),
-    sizeof (GskCubicCurve),
-    sizeof (GskConicCurve)
-  };
-
-  return c1->op == c2->op && memcmp (c1, c2, curve_size[c1->op]) == 0;
-}
-
-/* Place intersections between the curves in p, and their Bezier positions
- * in t1 and t2, up to n. Return the number of intersections found.
- *
- * Note that two cubic Beziers can have up to 9 intersections.
- */
-int
-gsk_curve_intersect (const GskCurve   *curve1,
-                     const GskCurve   *curve2,
-                     float            *t1,
-                     float            *t2,
-                     graphene_point_t *p,
-                     int               n)
-{
-  GskPathOperation op1 = curve1->op;
-  GskPathOperation op2 = curve2->op;
-
-  if (op1 == GSK_PATH_CLOSE)
-    op1 = GSK_PATH_LINE;
-
-  if (op2 == GSK_PATH_CLOSE)
-    op2 = GSK_PATH_LINE;
-
-  if (curve_equal (curve1, curve2))
-    return curve_self_intersect (curve1, t1, t2, p, n);
-
-  /* We special-case line-line and line-cubic intersections,
-   * since we can solve them directly.
-   * Everything else is done via bisection.
-   */
-  if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_LINE)
-    return line_intersect (curve1, curve2, t1, t2, p, n);
-  else if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_QUAD)
-    return line_quad_intersect (curve1, curve2, t1, t2, p, n);
-  else if (op1 == GSK_PATH_QUAD && op2 == GSK_PATH_LINE)
-    return line_quad_intersect (curve2, curve1, t2, t1, p, n);
-  else if (op1 == GSK_PATH_LINE && op2 == GSK_PATH_CUBIC)
-    return line_cubic_intersect (curve1, curve2, t1, t2, p, n);
-  else if (op1 == GSK_PATH_CUBIC && op2 == GSK_PATH_LINE)
-    return line_cubic_intersect (curve2, curve1, t2, t1, p, n);
-  else if ((op1 == GSK_PATH_QUAD || op1 == GSK_PATH_CUBIC) &&
-           (op2 == GSK_PATH_QUAD || op2 == GSK_PATH_CUBIC))
-    return cubic_intersect (curve1, curve2, t1, t2, p, n);
-  else
-    return general_intersect (curve1, curve2, t1, t2, p, n);
-}
-
-/* }}} */
-
-/* vim:set foldmethod=marker expandtab: */

gsk/gskcurveprivate.h

@@ -1,181 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#pragma once
-
-#include "gskpathopprivate.h"
-#include "gskpath.h"
-#include "gskboundingboxprivate.h"
-
-G_BEGIN_DECLS
-
-typedef gpointer gskpathop;
-
-typedef union _GskCurve GskCurve;
-
-typedef struct _GskLineCurve GskLineCurve;
-typedef struct _GskQuadCurve GskQuadCurve;
-typedef struct _GskCubicCurve GskCubicCurve;
-typedef struct _GskConicCurve GskConicCurve;
-
-struct _GskLineCurve
-{
-  GskPathOperation op;
-
-  gboolean padding;
-
-  graphene_point_t points[2];
-};
-
-struct _GskQuadCurve
-{
-  GskPathOperation op;
-
-  gboolean has_coefficients;
-
-  graphene_point_t points[3];
-
-  graphene_point_t coeffs[3];
-};
-
-struct _GskCubicCurve
-{
-  GskPathOperation op;
-
-  gboolean has_coefficients;
-
-  graphene_point_t points[4];
-
-  graphene_point_t coeffs[4];
-};
-
-struct _GskConicCurve
-{
-  GskPathOperation op;
-
-  gboolean has_coefficients;
-
-  /* points[0], points[1], points[3] are the control points,
-   * points[2].x is the weight
-   */
-  graphene_point_t points[4];
-
-  graphene_point_t num[3];
-  graphene_point_t denom[3];
-};
-
-union _GskCurve
-{
-  GskPathOperation op;
-  GskLineCurve line;
-  GskQuadCurve quad;
-  GskCubicCurve cubic;
-  GskConicCurve conic;
-};
-
-typedef enum {
-  GSK_CURVE_LINE_REASON_STRAIGHT,
-  GSK_CURVE_LINE_REASON_SHORT
-} GskCurveLineReason;
-
-typedef gboolean (* GskCurveAddLineFunc) (const graphene_point_t *from,
-                                          const graphene_point_t *to,
-                                          float                   from_progress,
-                                          float                   to_progress,
-                                          GskCurveLineReason      reason,
-                                          gpointer                user_data);
-
-typedef gboolean (* GskCurveAddCurveFunc) (GskPathOperation        op,
-                                           const graphene_point_t *pts,
-                                           gsize                   n_pts,
-                                           float                   weight,
-                                           gpointer                user_data);
-
-void                    gsk_curve_init                          (GskCurve               *curve,
-                                                                 gskpathop               op);
-void                    gsk_curve_init_foreach                  (GskCurve               *curve,
-                                                                 GskPathOperation        op,
-                                                                 const graphene_point_t *pts,
-                                                                 gsize                   n_pts,
-                                                                 float                   weight);
-
-void                    gsk_curve_print                         (const GskCurve         *curve,
-                                                                 GString                *string);
-
-char *                  gsk_curve_to_string                     (const GskCurve         *curve);
-
-gskpathop               gsk_curve_pathop                        (const GskCurve         *curve);
-const graphene_point_t *gsk_curve_get_start_point               (const GskCurve         *curve);
-const graphene_point_t *gsk_curve_get_end_point                 (const GskCurve         *curve);
-void                    gsk_curve_get_start_tangent             (const GskCurve         *curve,
-                                                                 graphene_vec2_t        *tangent);
-void                    gsk_curve_get_end_tangent               (const GskCurve         *curve,
-                                                                 graphene_vec2_t        *tangent);
-void                    gsk_curve_get_point                     (const GskCurve         *curve,
-                                                                 float                   progress,
-                                                                 graphene_point_t       *pos);
-void                    gsk_curve_get_tangent                   (const GskCurve         *curve,
-                                                                 float                   progress,
-                                                                 graphene_vec2_t        *tangent);
-void                    gsk_curve_reverse                       (const GskCurve         *curve,
-                                                                 GskCurve               *reverse);
-void                    gsk_curve_split                         (const GskCurve         *curve,
-                                                                 float                   progress,
-                                                                 GskCurve               *start,
-                                                                 GskCurve               *end);
-void                    gsk_curve_segment                       (const GskCurve         *curve,
-                                                                 float                   start,
-                                                                 float                   end,
-                                                                 GskCurve               *segment);
-gboolean                gsk_curve_decompose                     (const GskCurve         *curve,
-                                                                 float                   tolerance,
-                                                                 GskCurveAddLineFunc     add_line_func,
-                                                                 gpointer                user_data);
-gboolean                gsk_curve_decompose_curve               (const GskCurve         *curve,
-                                                                 GskPathForeachFlags     flags,
-                                                                 float                   tolerance,
-                                                                 GskCurveAddCurveFunc    add_curve_func,
-                                                                 gpointer                user_data);
-
-#define gsk_curve_builder_to(curve, builder) gsk_path_builder_pathop_to ((builder), gsk_curve_pathop (curve))
-
-float                   gsk_curve_get_curvature                 (const GskCurve         *curve,
-                                                                 float                   t,
-                                                                 graphene_point_t       *center);
-void                    gsk_curve_get_bounds                    (const GskCurve         *curve,
-                                                                 GskBoundingBox         *bounds);
-void                    gsk_curve_get_tight_bounds              (const GskCurve         *curve,
-                                                                 GskBoundingBox         *bounds);
-
-int                     gsk_curve_get_curvature_points          (const GskCurve         *curve,
-                                                                 float                   t[3]);
-
-int                     gsk_curve_get_cusps                     (const GskCurve         *curve,
-                                                                 float                   t[2]);
-
-int                     gsk_curve_intersect                     (const GskCurve         *curve1,
-                                                                 const GskCurve         *curve2,
-                                                                 float                  *t1,
-                                                                 float                  *t2,
-                                                                 graphene_point_t       *p,
-                                                                 int                     n);
-
-G_END_DECLS
-

gsk/gskdebug.c

@@ -12,12 +12,10 @@ static const GdkDebugKey gsk_debug_keys[] = {
   { "surface", GSK_DEBUG_SURFACE, "Information about surfaces" },
   { "fallback", GSK_DEBUG_FALLBACK, "Information about fallbacks" },
   { "glyphcache", GSK_DEBUG_GLYPH_CACHE, "Information about glyph caching" },
-  { "verbose", GSK_DEBUG_VERBOSE, "Print verbose output while rendering" },
   { "geometry", GSK_DEBUG_GEOMETRY, "Show borders (when using cairo)" },
   { "full-redraw", GSK_DEBUG_FULL_REDRAW, "Force full redraws" },
   { "sync", GSK_DEBUG_SYNC, "Sync after each frame" },
   { "staging", GSK_DEBUG_STAGING, "Use a staging image for texture upload (Vulkan only)" },
-  { "no-glyphy", GSK_DEBUG_NO_GLYPHY, "Don't use GPU for glyph rendering (OpenGL only)", TRUE },
 };
 
 static guint gsk_debug_flags;

gsk/gskdebugprivate.h

@@ -14,13 +14,11 @@ typedef enum {
   GSK_DEBUG_VULKAN                = 1 <<  5,
   GSK_DEBUG_FALLBACK              = 1 <<  6,
   GSK_DEBUG_GLYPH_CACHE           = 1 <<  7,
-  GSK_DEBUG_VERBOSE               = 1 <<  8,
   /* flags below may affect behavior */
   GSK_DEBUG_GEOMETRY              = 1 <<  9,
   GSK_DEBUG_FULL_REDRAW           = 1 << 10,
   GSK_DEBUG_SYNC                  = 1 << 11,
-  GSK_DEBUG_STAGING               = 1 << 12,
-  GSK_DEBUG_NO_GLYPHY             = 1 << 13
+  GSK_DEBUG_STAGING               = 1 << 12
 } GskDebugFlags;
 
 #define GSK_DEBUG_ANY ((1 << 13) - 1)

gsk/gskenums.h

@@ -42,6 +42,8 @@
  * @GSK_REPEAT_NODE: A node that repeats the child's contents
  * @GSK_CLIP_NODE: A node that clips its child to a rectangular area
  * @GSK_ROUNDED_CLIP_NODE: A node that clips its child to a rounded rectangle
+ * @GSK_FILL_NODE: A node that fills a path
+ * @GSK_STROKE_NODE: A node that strokes a path
  * @GSK_SHADOW_NODE: A node that draws a shadow below its child
  * @GSK_BLEND_NODE: A node that blends two children together
  * @GSK_CROSS_FADE_NODE: A node that cross-fades between two children
@@ -74,6 +76,8 @@ typedef enum {
   GSK_REPEAT_NODE,
   GSK_CLIP_NODE,
   GSK_ROUNDED_CLIP_NODE,
+  GSK_FILL_NODE,
+  GSK_STROKE_NODE,
   GSK_SHADOW_NODE,
   GSK_BLEND_NODE,
   GSK_CROSS_FADE_NODE,
@@ -171,23 +175,90 @@ typedef enum {
 } GskCorner;
 
 /**
- * GskPathOperation:
- * @GSK_PATH_MOVE: A move-to operation, with 1 point describing the target point.
- * @GSK_PATH_CLOSE: A close operation ending the current contour with a line back
- *   to the starting point. Two points describe the start and end of the line.
- * @GSK_PATH_LINE: A line-to operation, with 2 points describing the start and
- *   end point of a straight line.
- * @GSK_PATH_QUAD: A curve-to operation describing a quadratic Bézier curve
- *   with 3 points describing the start point, the control point and the end
- *   point of the curve.
- * @GSK_PATH_CUBIC: A curve-to operation describing a cubic Bézier curve with 4
- *   points describing the start point, the two control points and the end point
- *   of the curve.
- * @GSK_PATH_CONIC: A weighted quadratic Bézier curve with 3 points describing
- *   the start point, control point and end point of the curve. A weight for the
- *   curve will be passed, too.
+ * GskFillRule:
+ * @GSK_FILL_RULE_WINDING: If the path crosses the ray from
+ *   left-to-right, counts +1. If the path crosses the ray
+ *   from right to left, counts -1. (Left and right are determined
+ *   from the perspective of looking along the ray from the starting
+ *   point.) If the total count is non-zero, the point will be filled.
+ * @GSK_FILL_RULE_EVEN_ODD: Counts the total number of
+ *   intersections, without regard to the orientation of the contour. If
+ *   the total number of intersections is odd, the point will be
+ *   filled.
  *
- * Path operations can be used to approximate a `GskPath`.
+ * #GskFillRule is used to select how paths are filled, for example in
+ * gsk_fill_node_new(). Whether or not a point is included in the fill is
+ * determined by taking a ray from that point to infinity and looking
+ * at intersections with the path. The ray can be in any direction,
+ * as long as it doesn't pass through the end point of a segment
+ * or have a tricky intersection such as intersecting tangent to the path.
+ * (Note that filling is not actually implemented in this way. This
+ * is just a description of the rule that is applied.)
+ *
+ * New entries may be added in future versions.
+ **/
+typedef enum {
+  GSK_FILL_RULE_WINDING,
+  GSK_FILL_RULE_EVEN_ODD
+} GskFillRule;
+
+/**
+ * GskLineCap:
+ * @GSK_LINE_CAP_BUTT: Start and stop the line exactly at the start
+ *     and end point
+ * @GSK_LINE_CAP_ROUND: Use a round ending, the center of the circle
+ *     is the start or end point.
+ * @GSK_LINE_CAP_SQUARE: use squared ending, the center of the square
+ *     is the start or end point.
+ *
+ * Specifies how to render the start and end points of contours or
+ * dashes when stroking.
+ *
+ * The default line cap style is %GSK_LINE_CAP_BUTT.
+ */
+typedef enum {
+  GSK_LINE_CAP_BUTT,
+  GSK_LINE_CAP_ROUND,
+  GSK_LINE_CAP_SQUARE
+} GskLineCap;
+
+/**
+ * GskLineJoin:
+ * @GSK_LINE_JOIN_MITER: Use a sharp, angled corner
+ * @GSK_LINE_JOIN_MITER_CLIP: Use a sharp, angled corner, at a distance
+ * @GSK_LINE_JOIN_ROUND: Use a round join, the center of the circle is
+ *     the joint point
+ * @GSK_LINE_JOIN_BEVEL: Use a cut-off join, the join is cut off at half
+ *     the line width from the joint point
+ *
+ * Specifies how to render the junction of two lines when stroking.
+ *
+ * See gsk_stroke_set_miter_limit() for details on the difference between
+ * @GSK_LINE_JOIN_MITER and @GSK_LINE_JOIN_MITER_CLIP.
+ *
+ * The default line join style is %GSK_LINE_JOIN_MITER.
+ **/
+typedef enum {
+  GSK_LINE_JOIN_MITER,
+  GSK_LINE_JOIN_MITER_CLIP,
+  GSK_LINE_JOIN_ROUND,
+  GSK_LINE_JOIN_BEVEL
+} GskLineJoin;
+
+/**
+ * GskPathOperation:
+ * @GSK_PATH_MOVE: A move-to operation, with 1 point describing the
+ *     target point.
+ * @GSK_PATH_LINE: A line-to operation, with 2 points describing the
+ *     start and end point of a straight line.
+ * @GSK_PATH_CLOSE: A close operation ending the current contour with
+ *     a line back to the starting point. Two points describe the start
+ *     and end of the line.
+ * @GSK_PATH_CURVE: A curve-to operation describing a cubic Bézier curve
+ *     with 4 points describing the start point, the two control points
+ *     and the end point of the curve.
+ *
+ * Path operations can be used to approximate a #GskPath.
  *
  * More values may be added in the future.
  **/
@@ -195,24 +266,9 @@ typedef enum {
   GSK_PATH_MOVE,
   GSK_PATH_CLOSE,
   GSK_PATH_LINE,
-  GSK_PATH_QUAD,
-  GSK_PATH_CUBIC,
-  GSK_PATH_CONIC,
+  GSK_PATH_CURVE,
 } GskPathOperation;
 
-/**
- * GskPathDirection:
- * @GSK_PATH_START: The side that leads to the start of the path
- * @GSK_PATH_END: The side that leads to the end of the path
- *
- * The values of the `GskPathDirection` enum are used to pick one
- * of the two sides of the path that at a given point on the path.
- */
-typedef enum {
-  GSK_PATH_START,
-  GSK_PATH_END
-} GskPathDirection;
-
 /**
  * GskSerializationError:
  * @GSK_SERIALIZATION_UNSUPPORTED_FORMAT: The format can not be identified
@@ -317,3 +373,4 @@ typedef enum
   GSK_MASK_MODE_LUMINANCE,
   GSK_MASK_MODE_INVERTED_LUMINANCE
 } GskMaskMode;
+

gsk/gskpath.h

@@ -17,7 +17,8 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#pragma once
+#ifndef __GSK_PATH_H__
+#define __GSK_PATH_H__
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
@@ -28,29 +29,21 @@
 
 G_BEGIN_DECLS
 
-typedef enum {
-  GSK_FILL_RULE_WINDING,
-  GSK_FILL_RULE_EVEN_ODD
-} GskFillRule;
-
 /**
  * GskPathForeachFlags:
- * @GSK_PATH_FOREACH_ALLOW_QUAD: Allow emission of `GSK_PATH_QUAD` operations
- * @GSK_PATH_FOREACH_ALLOW_CUBIC: Allow emission of `GSK_PATH_CUBIC` operations.
- * @GSK_PATH_FOREACH_ALLOW_CONIC: Allow emission of `GSK_PATH_CONIC` operations.
+ * @GSK_PATH_FOREACH_ALLOW_CURVES: Allow emission of %GSK_PATH_CURVE
+ *     operations.
  *
  * Flags that can be passed to gsk_path_foreach() to enable additional
  * features.
  *
- * By default, [method@Gsk.Path.foreach] will only emit a path with all operations
+ * By default, gsk_path_foreach() will only emit a path with all operations
  * flattened to straight lines to allow for maximum compatibility. The only
- * operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and `GSK_PATH_CLOSE`.
+ * operations emitted will be %GSK_PATH_MOVE, %GSK_PATH_LINE and %GSK_PATH_CLOSE.
  */
 typedef enum
 {
-  GSK_PATH_FOREACH_ALLOW_QUAD  = (1 << 0),
-  GSK_PATH_FOREACH_ALLOW_CUBIC = (1 << 1),
-  GSK_PATH_FOREACH_ALLOW_CONIC = (1 << 2),
+  GSK_PATH_FOREACH_ALLOW_CURVES = (1 << 0)
 } GskPathForeachFlags;
 
 /**
@@ -58,7 +51,6 @@ typedef enum
  * @op: The operation to perform
  * @pts: The points of the operation
  * @n_pts: The number of points
- * @weight: The weight for conic curves, or unused if not a conic curve.
  * @user_data: The user data provided with the function
  *
  * Prototype of the callback to iterate throught the operations of
@@ -70,24 +62,40 @@ typedef enum
 typedef gboolean (* GskPathForeachFunc) (GskPathOperation        op,
                                          const graphene_point_t *pts,
                                          gsize                   n_pts,
-                                         float                   weight,
                                          gpointer                user_data);
 
 #define GSK_TYPE_PATH (gsk_path_get_type ())
 
+GDK_AVAILABLE_IN_ALL
 GType                   gsk_path_get_type                       (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_path_new_from_cairo                 (const cairo_path_t     *path);
 
+GDK_AVAILABLE_IN_ALL
 GskPath *               gsk_path_ref                            (GskPath                *self);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_unref                          (GskPath                *self);
+
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_print                          (GskPath                *self,
                                                                  GString                *string);
+GDK_AVAILABLE_IN_ALL
 char *                  gsk_path_to_string                      (GskPath                *self);
+
+GDK_AVAILABLE_IN_ALL
 GskPath *               gsk_path_parse                          (const char             *string);
+
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_to_cairo                       (GskPath                *self,
                                                                  cairo_t                *cr);
+
+GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_is_empty                       (GskPath                *self);
+GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_get_bounds                     (GskPath                *self,
                                                                  graphene_rect_t        *bounds);
+
+GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_foreach                        (GskPath                *self,
                                                                  GskPathForeachFlags     flags,
                                                                  GskPathForeachFunc      func,
@@ -96,3 +104,5 @@ gboolean                gsk_path_foreach                        (GskPath
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPath, gsk_path_unref)
 
 G_END_DECLS
+
+#endif /* __GSK_PATH_H__ */

gsk/gskpathbuilder.c

@@ -19,18 +19,17 @@
 
 #include "config.h"
 
-#include <math.h>
-
 #include "gskpathbuilder.h"
 
 #include "gskpathprivate.h"
 
-/*< private >
- * GskPathBuilder:
+/**
+ * SECTION:gskpathbuilder
+ * @Title: Building paths
+ * @Short_description: Building paths of lines and curves
+ * @See_also: #GskPath, #GskPathMeasure
  *
- * A `GskPathBuilder` struct is an opaque struct. It is meant to
- * not be kept around and only be used to create new `GskPath`
- * objects.
+ * This section describes how to construct #GskPath structures.
  *
  * A path is constructed like this:
  *
@@ -47,23 +46,30 @@
  *   return gsk_path_builder_free_to_path (builder);
  * ]|
  *
- * Adding contours to the path can be done in two ways.
+ * Adding contours to the path can be done in two ways.  
  * The easiest option is to use the `gsk_path_builder_add_*` group
  * of functions that add predefined contours to the current path,
- * either common shapes like [method@Gsk.PathBuilder.add_circle]
- * or by adding from other paths like [method@Gsk.PathBuilder.add_path].
+ * either common shapes like gsk_path_builder_add_circle()
+ * or by adding from other paths like gsk_path_builder_add_path().
  *
  * The other option is to define each line and curve manually with
  * the `gsk_path_builder_*_to` group of functions. You start with
- * a call to [method@Gsk.PathBuilder.move_to] to set the starting point
+ * a call to gsk_path_builder_move_to() to set the starting point
  * and then use multiple calls to any of the drawing functions to
  * move the pen along the plane. Once you are done, you can call
- * [method@Gsk.PathBuilder.close] to close the path by connecting it
+ * gsk_path_builder_close() to close the path by connecting it
  * back with a line to the starting point.
- *
  * This is similar for how paths are drawn in Cairo.
  */
 
+/**
+ * GskPathBuilder:
+ *
+ * A #GskPathBuilder struct is an opaque struct. It is meant to
+ * not be kept around and only be used to create new #GskPath
+ * objects.
+ */
+
 struct _GskPathBuilder
 {
   int ref_count;
@@ -82,16 +88,15 @@ G_DEFINE_BOXED_TYPE (GskPathBuilder,
                      gsk_path_builder_unref)
 
 
-/*< private >
+/**
  * gsk_path_builder_new:
  *
- * Create a new `GskPathBuilder` object.
+ * Create a new #GskPathBuilder object. The resulting builder
+ * would create an empty #GskPath. Use addition functions to add
+ * types to it.
  *
- * The resulting builder would create an empty `GskPath`.
- * Use addition functions to add types to it.
- *
- * Returns: a new `GskPathBuilder`
- */
+ * Returns: a new #GskPathBuilder
+ **/
 GskPathBuilder *
 gsk_path_builder_new (void)
 {
@@ -100,7 +105,7 @@ gsk_path_builder_new (void)
   self = g_slice_new0 (GskPathBuilder);
   self->ref_count = 1;
 
-  self->ops = g_array_new (FALSE, FALSE, sizeof (gskpathop));
+  self->ops = g_array_new (FALSE, FALSE, sizeof (GskStandardOperation));
   self->points = g_array_new (FALSE, FALSE, sizeof (graphene_point_t));
 
   /* Be explicit here */
@@ -109,16 +114,16 @@ gsk_path_builder_new (void)
   return self;
 }
 
-/*< private >
+/**
  * gsk_path_builder_ref:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
  * Acquires a reference on the given builder.
  *
- * This function is intended primarily for bindings.
- * `GskPathBuilder` objects should not be kept around.
+ * This function is intended primarily for bindings. #GskPathBuilder objects
+ * should not be kept around.
  *
- * Returns: (transfer none): the given `GskPathBuilder` with
+ * Returns: (transfer none): the given #GskPathBuilder with
  *   its reference count increased
  */
 GskPathBuilder *
@@ -132,19 +137,6 @@ gsk_path_builder_ref (GskPathBuilder *self)
   return self;
 }
 
-/* We're cheating here. Out pathops are relative to the NULL pointer,
- * so that we can not care about the points GArray reallocating itself
- * until we create the contour.
- * This does however mean that we need to not use gsk_pathop_get_points()
- * without offsetting the returned pointer.
- */
-static inline gskpathop
-gsk_pathop_encode_index (GskPathOperation op,
-                         gsize            index)
-{
-  return gsk_pathop_encode (op, ((graphene_point_t *) NULL) + index);
-}
-
 static void
 gsk_path_builder_ensure_current (GskPathBuilder *self)
 {
@@ -152,7 +144,7 @@ gsk_path_builder_ensure_current (GskPathBuilder *self)
     return;
 
   self->flags = GSK_PATH_FLAT;
-  g_array_append_vals (self->ops, (gskpathop[1]) { gsk_pathop_encode_index (GSK_PATH_MOVE, 0) }, 1);
+  g_array_append_vals (self->ops, &(GskStandardOperation) { GSK_PATH_MOVE, 0 }, 1);
   g_array_append_val (self->points, self->current_point);
 }
 
@@ -164,7 +156,7 @@ gsk_path_builder_append_current (GskPathBuilder         *self,
 {
   gsk_path_builder_ensure_current (self);
 
-  g_array_append_vals (self->ops, (gskpathop[1]) { gsk_pathop_encode_index (op, self->points->len - 1) }, 1);
+  g_array_append_vals (self->ops, &(GskStandardOperation) { op, self->points->len - 1 }, 1);
   g_array_append_vals (self->points, points, n_points);
 
   self->current_point = points[n_points - 1];
@@ -179,11 +171,10 @@ gsk_path_builder_end_current (GskPathBuilder *self)
    return;
 
   contour = gsk_standard_contour_new (self->flags,
-                                      (graphene_point_t *) self->points->data,
-                                      self->points->len,
-                                      (gskpathop *) self->ops->data,
+                                      (GskStandardOperation *) self->ops->data,
                                       self->ops->len,
-                                      (graphene_point_t *) self->points->data - (graphene_point_t *) NULL);
+                                      (graphene_point_t *) self->points->data,
+                                      self->points->len);
 
   g_array_set_size (self->ops, 0);
   g_array_set_size (self->points, 0);
@@ -201,9 +192,9 @@ gsk_path_builder_clear (GskPathBuilder *self)
   self->contours = NULL;
 }
 
-/*< private >
+/**
  * gsk_path_builder_unref:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
  * Releases a reference on the given builder.
  */
@@ -224,14 +215,14 @@ gsk_path_builder_unref (GskPathBuilder *self)
   g_slice_free (GskPathBuilder, self);
 }
 
-/*< private >
+/**
  * gsk_path_builder_free_to_path: (skip)
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
- * Creates a new `GskPath` from the current state of the
+ * Creates a new #GskPath from the current state of the
  * given builder, and frees the @builder instance.
  *
- * Returns: (transfer full): the newly created `GskPath`
+ * Returns: (transfer full): the newly created #GskPath
  *   with all the contours added to the builder
  */
 GskPath *
@@ -248,20 +239,19 @@ gsk_path_builder_free_to_path (GskPathBuilder *self)
   return res;
 }
 
-/*< private >
+/**
  * gsk_path_builder_to_path:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
- * Creates a new `GskPath` from the given builder.
+ * Creates a new #GskPath from the given builder.
  *
- * The given `GskPathBuilder` is reset once this function returns;
- * you cannot call this function multiple times on the same builder
- * instance.
+ * The given #GskPathBuilder is reset once this function returns;
+ * you cannot call this function multiple times on the same builder instance.
  *
- * This function is intended primarily for bindings.
- * C code should use [method@Gsk.PathBuilder.free_to_path].
+ * This function is intended primarily for bindings. C code should use
+ * gsk_path_builder_free_to_path().
  *
- * Returns: (transfer full): the newly created `GskPath`
+ * Returns: (transfer full): the newly created #GskPath
  *   with all the contours added to the builder
  */
 GskPath *
@@ -291,9 +281,9 @@ gsk_path_builder_add_contour (GskPathBuilder *self,
   self->contours = g_slist_prepend (self->contours, contour);
 }
 
-/*< private >
+/**
  * gsk_path_builder_get_current_point:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
  * Gets the current point. The current point is used for relative
  * drawing commands and updated after every operation.
@@ -301,7 +291,7 @@ gsk_path_builder_add_contour (GskPathBuilder *self,
  * When the builder is created, the default current point is set to (0, 0).
  *
  * Returns: (transfer none): The current point
- */
+ **/
 const graphene_point_t *
 gsk_path_builder_get_current_point (GskPathBuilder *self)
 {
@@ -310,21 +300,23 @@ gsk_path_builder_get_current_point (GskPathBuilder *self)
   return &self->current_point;
 }
 
-/*< private >
+/**
  * gsk_path_builder_add_path:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @path: (transfer none): the path to append
  *
  * Appends all of @path to the builder.
- */
+ **/
 void
 gsk_path_builder_add_path (GskPathBuilder *self,
                            GskPath        *path)
 {
+  gsize i;
+
   g_return_if_fail (self != NULL);
   g_return_if_fail (path != NULL);
 
-  for (gsize i = 0; i < gsk_path_get_n_contours (path); i++)
+  for (i = 0; i < gsk_path_get_n_contours (path); i++)
     {
       const GskContour *contour = gsk_path_get_contour (path, i);
 
@@ -332,80 +324,9 @@ gsk_path_builder_add_path (GskPathBuilder *self,
     }
 }
 
-/*< private >
- * gsk_path_builder_add_reverse_path:
- * @self: a `GskPathBuilder`
- * @path: (transfer none): the path to append
- *
- * Appends all of @path to the builder, in reverse
- * order.
- */
-void
-gsk_path_builder_add_reverse_path (GskPathBuilder *self,
-                                   GskPath        *path)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (path != NULL);
-
-  for (gsize i = gsk_path_get_n_contours (path); i > 0; i--)
-    {
-      const GskContour *contour = gsk_path_get_contour (path, i - 1);
-
-      gsk_path_builder_add_contour (self, gsk_contour_reverse (contour));
-    }
-}
-
-/*< private >
- * gsk_path_builder_add_cairo_path:
- * @self: a `GskPathBuilder`
- *
- * Adds a Cairo path to the builder.
- *
- * You can use cairo_copy_path() to access the path
- * from a Cairo context.
- */
-void
-gsk_path_builder_add_cairo_path (GskPathBuilder     *self,
-                                 const cairo_path_t *path)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (path != NULL);
-
-  for (gsize i = 0; i < path->num_data; i += path->data[i].header.length)
-    {
-      const cairo_path_data_t *data = &path->data[i];
-
-      switch (data->header.type)
-        {
-        case CAIRO_PATH_MOVE_TO:
-          gsk_path_builder_move_to (self, data[1].point.x, data[1].point.y);
-          break;
-
-        case CAIRO_PATH_LINE_TO:
-          gsk_path_builder_line_to (self, data[1].point.x, data[1].point.y);
-          break;
-
-        case CAIRO_PATH_CURVE_TO:
-          gsk_path_builder_cubic_to (self,
-                                     data[1].point.x, data[1].point.y,
-                                     data[2].point.x, data[2].point.y,
-                                     data[3].point.x, data[3].point.y);
-          break;
-
-        case CAIRO_PATH_CLOSE_PATH:
-          gsk_path_builder_close (self);
-          break;
-
-        default:
-          g_assert_not_reached ();
-          break;
-        }
-    }
-}
-
-/*< private >
+/**
  * gsk_path_builder_add_rect:
- * @self: A `GskPathBuilder`
+ * @self: A #GskPathBuilder
  * @rect: The rectangle to create a path for
  *
  * Adds @rect as a new contour to the path built by the builder.
@@ -415,7 +336,7 @@ gsk_path_builder_add_cairo_path (GskPathBuilder     *self,
  *
  * If the the width or height are 0, the path will be a closed
  * horizontal or vertical line. If both are 0, it'll be a closed dot.
- */
+ **/
 void
 gsk_path_builder_add_rect (GskPathBuilder        *self,
                            const graphene_rect_t *rect)
@@ -430,34 +351,14 @@ gsk_path_builder_add_rect (GskPathBuilder        *self,
   gsk_contour_get_start_end (contour, NULL, &self->current_point);
 }
 
-/*< private >
- * gsk_path_builder_add_rounded_rect:
- * @self: a #GskPathBuilder
- * @rect: the rounded rect
- *
- * Adds @rect as a new contour to the path built in @self.
- */
-void
-gsk_path_builder_add_rounded_rect (GskPathBuilder       *self,
-                                   const GskRoundedRect *rect)
-{
-  GskContour *contour;
-
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (rect != NULL);
-
-  contour = gsk_rounded_rect_contour_new (rect);
-  gsk_path_builder_add_contour (self, contour);
-}
-
-/*< private >
+/**
  * gsk_path_builder_add_circle:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @center: the center of the circle
  * @radius: the radius of the circle
  *
  * Adds a circle with the @center and @radius.
- */
+ **/
 void
 gsk_path_builder_add_circle (GskPathBuilder         *self,
                              const graphene_point_t *center,
@@ -473,64 +374,18 @@ gsk_path_builder_add_circle (GskPathBuilder         *self,
   gsk_path_builder_add_contour (self, contour);
 }
 
-/*< private >
- * gsk_path_builder_add_ellipse:
- * @self: a #GskPathBuilder
- * @center: the center point of the ellipse
- * @radius: the radius of the ellipse in x/y direction
- *
- * Adds an ellipse with the given @center and the @radius in
- * x/y direction.
- */
-void
-gsk_path_builder_add_ellipse (GskPathBuilder         *self,
-                              const graphene_point_t *center,
-                              const graphene_size_t  *radius)
-{
-  const float weight = sqrt(0.5f);
-  graphene_point_t pts[8];
-
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (center != NULL);
-  g_return_if_fail (radius != NULL);
-
-  pts[0] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
-                                center->y);
-  pts[1] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
-                                center->y + radius->height / 2);
-  pts[2] = GRAPHENE_POINT_INIT (center->x,
-                                center->y + radius->height / 2);
-  pts[3] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
-                                center->y + radius->height / 2);
-  pts[4] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
-                                center->y);
-  pts[5] = GRAPHENE_POINT_INIT (center->x - radius->width / 2,
-                                center->y - radius->height / 2);
-  pts[6] = GRAPHENE_POINT_INIT (center->x,
-                                center->y - radius->height / 2);
-  pts[7] = GRAPHENE_POINT_INIT (center->x + radius->width / 2,
-                                center->y - radius->height / 2);
-
-  gsk_path_builder_move_to (self, pts[0].x, pts[0].y);
-  gsk_path_builder_conic_to (self, pts[1].x, pts[1].y, pts[2].x, pts[2].y, weight);
-  gsk_path_builder_conic_to (self, pts[3].x, pts[3].y, pts[4].x, pts[4].y, weight);
-  gsk_path_builder_conic_to (self, pts[5].x, pts[5].y, pts[6].x, pts[6].y, weight);
-  gsk_path_builder_conic_to (self, pts[7].x, pts[7].y, pts[0].x, pts[0].y, weight);
-  gsk_path_builder_close (self);
-}
-
-/*< private >
+/**
  * gsk_path_builder_move_to:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @x: x coordinate
  * @y: y coordinate
  *
  * Starts a new contour by placing the pen at @x, @y.
  *
- * If this function is called twice in succession, the first
- * call will result in a contour made up of a single point.
- * The second call will start a new contour.
- */
+ * If gsk_path_builder_move_to() is called twice in succession, the first
+ * call will result in a contour made up of a single point. The second call
+ * will start a new contour.
+ **/
 void
 gsk_path_builder_move_to (GskPathBuilder *self,
                           float           x,
@@ -545,17 +400,17 @@ gsk_path_builder_move_to (GskPathBuilder *self,
   gsk_path_builder_ensure_current (self);
 }
 
-/*< private >
+/**
  * gsk_path_builder_rel_move_to:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @x: x offset
  * @y: y offset
  *
  * Starts a new contour by placing the pen at @x, @y relative to the current
  * point.
  *
- * This is the relative version of [method@Gsk.PathBuilder.move_to].
- */
+ * This is the relative version of gsk_path_builder_move_to().
+ **/
 void
 gsk_path_builder_rel_move_to (GskPathBuilder *self,
                               float           x,
@@ -568,15 +423,15 @@ gsk_path_builder_rel_move_to (GskPathBuilder *self,
                             self->current_point.y + y);
 }
 
-/*< private >
+/**
  * gsk_path_builder_line_to:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @x: x coordinate
  * @y: y coordinate
  *
- * Draws a line from the current point to @x, @y and makes it
- * the new current point.
- */
+ * Draws a line from the current point to @x, @y and makes it the new current
+ * point.
+ **/
 void
 gsk_path_builder_line_to (GskPathBuilder *self,
                           float           x,
@@ -596,17 +451,17 @@ gsk_path_builder_line_to (GskPathBuilder *self,
                                    });
 }
 
-/*< private >
+/**
  * gsk_path_builder_rel_line_to:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  * @x: x offset
  * @y: y offset
  *
  * Draws a line from the current point to a point offset to it by @x, @y
  * and makes it the new current point.
  *
- * This is the relative version of [method@Gsk.PathBuilder.line_to].
- */
+ * This is the relative version of gsk_path_builder_line_to().
+ **/
 void
 gsk_path_builder_rel_line_to (GskPathBuilder *self,
                               float           x,
@@ -619,71 +474,9 @@ gsk_path_builder_rel_line_to (GskPathBuilder *self,
                             self->current_point.y + y);
 }
 
-/*< private >
- * gsk_path_builder_quad_to:
+/**
+ * gsk_path_builder_curve_to:
  * @self: a #GskPathBuilder
- * @x1: x coordinate of control point
- * @y1: y coordinate of control point
- * @x2: x coordinate of the end of the curve
- * @y2: y coordinate of the end of the curve
- *
- * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
- * from the current point to @x2, @y2 with @x1, @y1 as the control point.
- *
- * After this, @x2, @y2 will be the new current point.
- */
-void
-gsk_path_builder_quad_to (GskPathBuilder *self,
-                          float           x1,
-                          float           y1,
-                          float           x2,
-                          float           y2)
-{
-  g_return_if_fail (self != NULL);
-
-  self->flags &= ~GSK_PATH_FLAT;
-  gsk_path_builder_append_current (self,
-                                   GSK_PATH_QUAD,
-                                   2, (graphene_point_t[2]) {
-                                     GRAPHENE_POINT_INIT (x1, y1),
-                                     GRAPHENE_POINT_INIT (x2, y2)
-                                   });
-}
-
-/*< private >
- * gsk_path_builder_rel_quad_to:
- * @self: a `GskPathBuilder`
- * @x1: x offset of control point
- * @y1: y offset of control point
- * @x2: x offset of the end of the curve
- * @y2: y offset of the end of the curve
- *
- * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
- * from the current point to @x2, @y2 with @x1, @y1 the control point.
- *
- * All coordinates are given relative to the current point.
- *
- * This is the relative version of [method@Gsk.PathBuilder.quad_to].
- */
-void
-gsk_path_builder_rel_quad_to (GskPathBuilder *self,
-                              float           x1,
-                              float           y1,
-                              float           x2,
-                              float           y2)
-{
-  g_return_if_fail (self != NULL);
-
-  gsk_path_builder_quad_to (self,
-                            self->current_point.x + x1,
-                            self->current_point.y + y1,
-                            self->current_point.x + x2,
-                            self->current_point.y + y2);
-}
-
-/*< private >
- * gsk_path_builder_cubic_to:
- * @self: a `GskPathBuilder`
  * @x1: x coordinate of first control point
  * @y1: y coordinate of first control point
  * @x2: x coordinate of second control point
@@ -696,9 +489,9 @@ gsk_path_builder_rel_quad_to (GskPathBuilder *self,
  * points.
  *
  * After this, @x3, @y3 will be the new current point.
- */
+ **/
 void
-gsk_path_builder_cubic_to (GskPathBuilder *self,
+gsk_path_builder_curve_to (GskPathBuilder *self,
                            float           x1,
                            float           y1,
                            float           x2,
@@ -710,7 +503,7 @@ gsk_path_builder_cubic_to (GskPathBuilder *self,
 
   self->flags &= ~GSK_PATH_FLAT;
   gsk_path_builder_append_current (self,
-                                   GSK_PATH_CUBIC,
+                                   GSK_PATH_CURVE,
                                    3, (graphene_point_t[3]) {
                                      GRAPHENE_POINT_INIT (x1, y1),
                                      GRAPHENE_POINT_INIT (x2, y2),
@@ -718,9 +511,9 @@ gsk_path_builder_cubic_to (GskPathBuilder *self,
                                    });
 }
 
-/*< private >
- * gsk_path_builder_rel_cubic_to:
- * @self: a `GskPathBuilder`
+/**
+ * gsk_path_builder_rel_curve_to:
+ * @self: a #GskPathBuilder
  * @x1: x offset of first control point
  * @y1: y offset of first control point
  * @x2: x offset of second control point
@@ -732,10 +525,10 @@ gsk_path_builder_cubic_to (GskPathBuilder *self,
  * from the current point to @x3, @y3 with @x1, @y1 and @x2, @y2 as the control
  * points. All coordinates are given relative to the current point.
  *
- * This is the relative version of [method@Gsk.PathBuilder.cubic_to].
- */
+ * This is the relative version of gsk_path_builder_curve_to().
+ **/
 void
-gsk_path_builder_rel_cubic_to (GskPathBuilder *self,
+gsk_path_builder_rel_curve_to (GskPathBuilder *self,
                                float           x1,
                                float           y1,
                                float           x2,
@@ -745,7 +538,7 @@ gsk_path_builder_rel_cubic_to (GskPathBuilder *self,
 {
   g_return_if_fail (self != NULL);
 
-  gsk_path_builder_cubic_to (self,
+  gsk_path_builder_curve_to (self,
                              self->current_point.x + x1,
                              self->current_point.y + y1,
                              self->current_point.x + x2,
@@ -754,90 +547,18 @@ gsk_path_builder_rel_cubic_to (GskPathBuilder *self,
                              self->current_point.y + y3);
 }
 
-/*< private >
- * gsk_path_builder_conic_to:
- * @self: a `GskPathBuilder`
- * @x1: x coordinate of control point
- * @y1: y coordinate of control point
- * @x2: x coordinate of the end of the curve
- * @y2: y coordinate of the end of the curve
- * @weight: weight of the curve
- *
- * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
- * from the current point to @x2, @y2 with the given
- * @weight and @x1, @y1 as the single control point.
- *
- * Conic curves can be used to draw ellipses and circles.
- *
- * After this, @x2, @y2 will be the new current point.
- */
-void
-gsk_path_builder_conic_to (GskPathBuilder *self,
-                           float           x1,
-                           float           y1,
-                           float           x2,
-                           float           y2,
-                           float           weight)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (weight >= 0);
-
-  self->flags &= ~GSK_PATH_FLAT;
-  gsk_path_builder_append_current (self,
-                                   GSK_PATH_CONIC,
-                                   3, (graphene_point_t[3]) {
-                                     GRAPHENE_POINT_INIT (x1, y1),
-                                     GRAPHENE_POINT_INIT (weight, 0),
-                                     GRAPHENE_POINT_INIT (x2, y2)
-                                   });
-}
-
-/*< private >
- * gsk_path_builder_rel_conic_to:
- * @self: a `GskPathBuilder`
- * @x1: x offset of control point
- * @y1: y offset of control point
- * @x2: x offset of the end of the curve
- * @y2: y offset of the end of the curve
- * @weight: weight of the curve
- *
- * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
- * from the current point to @x2, @y2 with the given
- * @weight and @x1, @y1 as the single control point.
- *
- * This is the relative version of [method@Gsk.PathBuilder.conic_to].
- */
-void
-gsk_path_builder_rel_conic_to (GskPathBuilder *self,
-                               float           x1,
-                               float           y1,
-                               float           x2,
-                               float           y2,
-                               float           weight)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (weight >= 0);
-
-  gsk_path_builder_conic_to (self,
-                             self->current_point.x + x1,
-                             self->current_point.y + y1,
-                             self->current_point.x + x2,
-                             self->current_point.y + y2,
-                             weight);
-}
-
-/*< private >
+/**
  * gsk_path_builder_close:
- * @self: a `GskPathBuilder`
+ * @self: a #GskPathBuilder
  *
  * Ends the current contour with a line back to the start point.
  *
- * Note that this is different from calling [method@Gsk.PathBuilder.line_to]
+ * Note that this is different from calling gsk_path_builder_line_to()
  * with the start point in that the contour will be closed. A closed
  * contour behaves different from an open one when stroking its start
  * and end point are considered connected, so they will be joined
  * via the line join, and not ended with line caps.
- */
+ **/
 void
 gsk_path_builder_close (GskPathBuilder *self)
 {
@@ -856,8 +577,9 @@ gsk_path_builder_close (GskPathBuilder *self)
   gsk_path_builder_end_current (self);
 }
 
+
 static void
-arc_segment (GskPathBuilder *self,
+arc_segment (GskPathBuilder *builder,
              double          cx,
              double          cy,
              double          rx,
@@ -879,7 +601,7 @@ arc_segment (GskPathBuilder *self,
   x2 = x3 + rx * (t * sin_th1);
   y2 = y3 + ry * (-t * cos_th1);
 
-  gsk_path_builder_cubic_to (self,
+  gsk_path_builder_curve_to (builder,
                              cx + cos_phi * x1 - sin_phi * y1,
                              cy + sin_phi * x1 + cos_phi * y1,
                              cx + cos_phi * x2 - sin_phi * y2,
@@ -888,21 +610,19 @@ arc_segment (GskPathBuilder *self,
                              cy + sin_phi * x3 + cos_phi * y3);
 }
 
+#ifndef HAVE_SINCOS
 static inline void
-_sincos (double angle,
-         double *y,
-         double *x)
+sincos (double angle,
+        double *y,
+        double *x)
 {
-#ifdef HAVE_SINCOS
-  sincos (angle, y, x);
-#else
   *x = cos (angle);
   *y = sin (angle);
-#endif
 }
+#endif
 
 void
-gsk_path_builder_svg_arc_to (GskPathBuilder *self,
+gsk_path_builder_svg_arc_to (GskPathBuilder *builder,
                              float           rx,
                              float           ry,
                              float           x_axis_rotation,
@@ -933,9 +653,9 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *self,
   double th_half;
   double t;
 
-  if (self->points->len > 0)
+  if (builder->points->len > 0)
     {
-      current = &g_array_index (self->points, graphene_point_t, self->points->len - 1);
+      current = &g_array_index (builder->points, graphene_point_t, builder->points->len - 1);
       x1 = current->x;
       y1 = current->y;
     }
@@ -948,7 +668,7 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *self,
   y2 = y;
 
   phi = x_axis_rotation * M_PI / 180.0;
-  _sincos (phi, &sin_phi, &cos_phi);
+  sincos (phi, &sin_phi, &cos_phi);
 
   rx = fabs (rx);
   ry = fabs (ry);
@@ -1011,7 +731,7 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *self,
   n_segs = ceil (fabs (delta_theta / (M_PI_2 + 0.001)));
   d_theta = delta_theta / n_segs;
   theta = theta1;
-  _sincos (theta1, &sin_th1, &cos_th1);
+  sincos (theta1, &sin_th1, &cos_th1);
 
   th_half = d_theta / 2;
   t = (8.0 / 3.0) * sin (th_half / 2) * sin (th_half / 2) / sin (th_half);
@@ -1022,8 +742,8 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *self,
       theta1 = theta + d_theta;
       sin_th0 = sin_th1;
       cos_th0 = cos_th1;
-      _sincos (theta1, &sin_th1, &cos_th1);
-      arc_segment (self,
+      sincos (theta1, &sin_th1, &cos_th1);
+      arc_segment (builder,
                    cx, cy, rx, ry,
                    sin_phi, cos_phi,
                    sin_th0, cos_th0,
@@ -1031,32 +751,3 @@ gsk_path_builder_svg_arc_to (GskPathBuilder *self,
                    t);
     }
 }
-
-/*< private >
- * gsk_path_builder_add_layout:
- * @self: a #GskPathBuilder
- * @layout: the pango layout to add
- *
- * Adds the outlines for the glyphs in @layout to
- * the builder.
- */
-void
-gsk_path_builder_add_layout (GskPathBuilder *self,
-                             PangoLayout    *layout)
-{
-  cairo_surface_t *surface;
-  cairo_t *cr;
-  cairo_path_t *cairo_path;
-
-  surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
-  cr = cairo_create (surface);
-
-  pango_cairo_layout_path (cr, layout);
-  cairo_path = cairo_copy_path (cr);
-
-  gsk_path_builder_add_cairo_path (self, cairo_path);
-
-  cairo_path_destroy (cairo_path);
-  cairo_destroy (cr);
-  cairo_surface_destroy (surface);
-}

gsk/gskpathbuilder.h

@@ -17,102 +17,85 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#pragma once
+#ifndef __GSK_PATH_BUILDER_H__
+#define __GSK_PATH_BUILDER_H__
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
 #endif
 
 
-#include <gsk/gskroundedrect.h>
 #include <gsk/gsktypes.h>
 
 G_BEGIN_DECLS
 
 #define GSK_TYPE_PATH_BUILDER (gsk_path_builder_get_type ())
 
+GDK_AVAILABLE_IN_ALL
 GType                   gsk_path_builder_get_type               (void) G_GNUC_CONST;
 
+GDK_AVAILABLE_IN_ALL
 GskPathBuilder *        gsk_path_builder_new                    (void);
+GDK_AVAILABLE_IN_ALL
 GskPathBuilder *        gsk_path_builder_ref                    (GskPathBuilder         *self);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_unref                  (GskPathBuilder         *self);
+GDK_AVAILABLE_IN_ALL
 GskPath *               gsk_path_builder_free_to_path           (GskPathBuilder         *self) G_GNUC_WARN_UNUSED_RESULT;
+GDK_AVAILABLE_IN_ALL
 GskPath *               gsk_path_builder_to_path                (GskPathBuilder         *self) G_GNUC_WARN_UNUSED_RESULT;
 
+GDK_AVAILABLE_IN_ALL
 const graphene_point_t *gsk_path_builder_get_current_point      (GskPathBuilder         *self);
 
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_path               (GskPathBuilder         *self,
                                                                  GskPath                *path);
-void                    gsk_path_builder_add_reverse_path       (GskPathBuilder         *self,
-                                                                 GskPath                *path);
-void                    gsk_path_builder_add_cairo_path         (GskPathBuilder         *self,
-                                                                 const cairo_path_t     *path);
-void                    gsk_path_builder_add_layout             (GskPathBuilder         *self,
-                                                                 PangoLayout            *layout);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_rect               (GskPathBuilder         *self,
                                                                  const graphene_rect_t  *rect);
-void                    gsk_path_builder_add_rounded_rect       (GskPathBuilder         *self,
-                                                                 const GskRoundedRect   *rect);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_add_circle             (GskPathBuilder         *self,
                                                                  const graphene_point_t *center,
                                                                  float                   radius);
-void                    gsk_path_builder_add_ellipse            (GskPathBuilder         *self,
-                                                                 const graphene_point_t *center,
-                                                                 const graphene_size_t  *radius);
-void                    gsk_path_builder_add_segment            (GskPathBuilder         *self,
-                                                                 GskPathMeasure         *measure,
-                                                                 float                   start,
-                                                                 float                   end);
+
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_move_to                (GskPathBuilder         *self,
                                                                  float                   x,
                                                                  float                   y);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_rel_move_to            (GskPathBuilder         *self,
                                                                  float                   x,
                                                                  float                   y);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_line_to                (GskPathBuilder         *self,
                                                                  float                   x,
                                                                  float                   y);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_rel_line_to            (GskPathBuilder         *self,
                                                                  float                   x,
                                                                  float                   y);
-void                    gsk_path_builder_quad_to                (GskPathBuilder         *self,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2);
-void                    gsk_path_builder_rel_quad_to            (GskPathBuilder         *self,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2);
-void                    gsk_path_builder_cubic_to               (GskPathBuilder         *self,
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_curve_to               (GskPathBuilder         *self,
                                                                  float                   x1,
                                                                  float                   y1,
                                                                  float                   x2,
                                                                  float                   y2,
                                                                  float                   x3,
                                                                  float                   y3);
-void                    gsk_path_builder_rel_cubic_to           (GskPathBuilder         *self,
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_builder_rel_curve_to           (GskPathBuilder         *self,
                                                                  float                   x1,
                                                                  float                   y1,
                                                                  float                   x2,
                                                                  float                   y2,
                                                                  float                   x3,
                                                                  float                   y3);
-void                    gsk_path_builder_conic_to               (GskPathBuilder         *self,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   weight);
-void                    gsk_path_builder_rel_conic_to           (GskPathBuilder         *self,
-                                                                 float                   x1,
-                                                                 float                   y1,
-                                                                 float                   x2,
-                                                                 float                   y2,
-                                                                 float                   weight);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_builder_close                  (GskPathBuilder         *self);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathBuilder, gsk_path_builder_unref)
 
 G_END_DECLS
+
+#endif /* __GSK_PATH_BUILDER_H__ */

gsk/gskpathmeasure.c

@@ -21,21 +21,16 @@
 
 #include "gskpathmeasure.h"
 
-#include "gskpathbuilder.h"
-#include "gskpathpointprivate.h"
 #include "gskpathprivate.h"
 
-/*< private >
- * `GskPathMeasure` is an object that allows measurements
- * on `GskPath`s such as determining the length of the path.
+/**
+ * SECTION:gskpathmeasure
+ * @Title: PathMeasure
+ * @Short_description: Measuring operations on paths
+ * @See_also: #GskPath
  *
- * Many measuring operations require approximating the path
- * with simpler shapes. Therefore, a `GskPathMeasure` has
- * a tolerance that determines what amount is required
- * for such approximations.
- *
- * A `GskPathMeasure` struct is a reference counted struct
- * and should be treated as opaque.
+ * #GskPathMeasure is an object that allows measuring operations on #GskPaths.
+ * These operations are useful when implementing animations.
  */
 
 typedef struct _GskContourMeasure GskContourMeasure;
@@ -59,33 +54,40 @@ struct _GskPathMeasure
   GskContourMeasure measures[];
 };
 
+/**
+ * GskPathMeasure:
+ *
+ * A #GskPathMeasure struct is a reference counted struct
+ * and should be treated as opaque.
+ */
+
 G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
                      gsk_path_measure_ref,
                      gsk_path_measure_unref)
 
-/*< private >
+/**
  * gsk_path_measure_new:
  * @path: the path to measure
  *
  * Creates a measure object for the given @path.
  *
- * Returns: a new `GskPathMeasure` representing @path
- */
+ * Returns: a new #GskPathMeasure representing @path
+ **/
 GskPathMeasure *
 gsk_path_measure_new (GskPath *path)
 {
   return gsk_path_measure_new_with_tolerance (path, GSK_PATH_TOLERANCE_DEFAULT);
 }
 
-/*< private >
+/**
  * gsk_path_measure_new_with_tolerance:
  * @path: the path to measure
  * @tolerance: the tolerance for measuring operations
  *
  * Creates a measure object for the given @path and @tolerance.
  *
- * Returns: a new `GskPathMeasure` representing @path
- */
+ * Returns: a new #GskPathMeasure representing @path
+ **/
 GskPathMeasure *
 gsk_path_measure_new_with_tolerance (GskPath *path,
                                      float    tolerance)
@@ -107,7 +109,7 @@ gsk_path_measure_new_with_tolerance (GskPath *path,
 
   for (i = 0; i < n_contours; i++)
     {
-      self->measures[i].contour_data = gsk_contour_init_measure (gsk_path_get_contour (path, i),
+      self->measures[i].contour_data = gsk_contour_init_measure (path, i,
                                                                  self->tolerance,
                                                                  &self->measures[i].length);
       self->length += self->measures[i].length;
@@ -116,14 +118,14 @@ gsk_path_measure_new_with_tolerance (GskPath *path,
   return self;
 }
 
-/*< private >
+/**
  * gsk_path_measure_ref:
- * @self: a `GskPathMeasure`
+ * @self: a #GskPathMeasure
  *
- * Increases the reference count of a `GskPathMeasure` by one.
+ * Increases the reference count of a #GskPathMeasure by one.
  *
- * Returns: the passed in `GskPathMeasure`.
- */
+ * Returns: the passed in #GskPathMeasure.
+ **/
 GskPathMeasure *
 gsk_path_measure_ref (GskPathMeasure *self)
 {
@@ -134,14 +136,13 @@ gsk_path_measure_ref (GskPathMeasure *self)
   return self;
 }
 
-/*< private >
+/**
  * gsk_path_measure_unref:
- * @self: a `GskPathMeasure`
+ * @self: a #GskPathMeasure
  *
- * Decreases the reference count of a `GskPathMeasure` by one.
- *
- * If the resulting reference count is zero, frees the object.
- */
+ * Decreases the reference count of a #GskPathMeasure by one.
+ * If the resulting reference count is zero, frees the path_measure.
+ **/
 void
 gsk_path_measure_unref (GskPathMeasure *self)
 {
@@ -156,52 +157,23 @@ gsk_path_measure_unref (GskPathMeasure *self)
 
   for (i = 0; i < self->n_contours; i++)
     {
-      gsk_contour_free_measure (gsk_path_get_contour (self->path, i),
-                                self->measures[i].contour_data);
+      gsk_contour_free_measure (self->path, i, self->measures[i].contour_data);
     }
 
   gsk_path_unref (self->path);
   g_free (self);
 }
 
-/*< private >
- * gsk_path_measure_get_path:
- * @self: a `GskPathMeasure`
- *
- * Returns the path that the measure was created for.
- *
- * Returns: (transfer none): the path of @self
- */
-GskPath *
-gsk_path_measure_get_path (GskPathMeasure *self)
-{
-  return self->path;
-}
-
-/*< private >
- * gsk_path_measure_get_tolerance:
- * @self: a `GskPathMeasure`
- *
- * Returns the tolerance that the measure was created with.
- *
- * Returns: the tolerance of @self
- */
-float
-gsk_path_measure_get_tolerance (GskPathMeasure *self)
-{
-  return self->tolerance;
-}
-
-/*< private >
+/**
  * gsk_path_measure_get_length:
- * @self: a `GskPathMeasure`
+ * @self: a #GskPathMeasure
  *
  * Gets the length of the path being measured.
  *
  * The length is cached, so this function does not do any work.
  *
  * Returns: The length of the path measured by @self
- */
+ **/
 float
 gsk_path_measure_get_length (GskPathMeasure *self)
 {
@@ -210,30 +182,6 @@ gsk_path_measure_get_length (GskPathMeasure *self)
   return self->length;
 }
 
-/*< private >
- * gsk_path_measure_is_closed:
- * @self: a `GskPathMeasure`
- *
- * Returns if the path being measured represents a single closed
- * contour.
- *
- * Returns: `TRUE` if the current path is closed
- */
-gboolean
-gsk_path_measure_is_closed (GskPathMeasure *self)
-{
-  const GskContour *contour;
-
-  g_return_val_if_fail (self != NULL, FALSE);
-
-  /* XXX: is the empty path closed? Currently it's not */
-  if (self->n_contours != 1)
-    return FALSE;
-
-  contour = gsk_path_get_contour (self->path, 0);
-  return gsk_contour_get_flags (contour) & GSK_PATH_CLOSED ? TRUE : FALSE;
-}
-
 static float
 gsk_path_measure_clamp_distance (GskPathMeasure *self,
                                  float           distance)
@@ -244,17 +192,198 @@ gsk_path_measure_clamp_distance (GskPathMeasure *self,
   return CLAMP (distance, 0, self->length);
 }
 
-/*< private >
+/**
+ * gsk_path_measure_get_point:
+ * @self: a #GskPathMeasure
+ * @distance: distance into the path
+ * @pos: (out caller-allocates) (optional): The coordinates
+ *    of the position at @distance
+ * @tangent: (out caller-allocates) (optional): The tangent
+ *    to the position at @distance
+ *
+ * Calculates the coordinates and tangent of the point @distance
+ * units into the path. The value will be clamped to the length
+ * of the path.
+ *
+ * If the point is a discontinuous edge in the path, the returned
+ * point and tangent will describe the line starting at that point
+ * going forward.
+ *
+ * If @self describes an empty path, the returned point will be 
+ * set to `(0, 0)` and the tangent will be the x axis or `(1, 0)`.
+ **/
+void
+gsk_path_measure_get_point (GskPathMeasure   *self,
+                            float             distance,
+                            graphene_point_t *pos,
+                            graphene_vec2_t  *tangent)
+{
+  gsize i;
+
+  g_return_if_fail (self != NULL);
+
+  if (pos == NULL && tangent == NULL)
+    return;
+
+  distance = gsk_path_measure_clamp_distance (self, distance);
+
+  for (i = 0; i < self->n_contours; i++)
+    {
+      if (distance < self->measures[i].length)
+        break;
+
+      distance -= self->measures[i].length;
+    }
+
+  /* weird corner cases */
+  if (i == self->n_contours)
+    {
+      /* the empty path goes here */
+      if (self->n_contours == 0)
+        {
+          if (pos)
+            graphene_point_init (pos, 0.f, 0.f);
+          if (tangent)
+            graphene_vec2_init (tangent, 1.f, 0.f);
+          return;
+        }
+      /* rounding errors can make this happen */
+      i = self->n_contours - 1;
+      distance = self->measures[i].length;
+    }
+
+  gsk_contour_get_point (self->path,
+                         i,
+                         self->measures[i].contour_data,
+                         distance,
+                         pos,
+                         tangent);
+}
+
+/**
+ * gsk_path_measure_get_closest_point:
+ * @self: a #GskPathMeasure
+ * @point: the point to fond the closest point to
+ * @out_pos: (out caller-allocates) (optional): return location
+ *    for the closest point
+ *
+ * Gets the point on the path that is closest to @point.
+ *
+ * If the path being measured is empty, return 0 and set
+ * @out_pos to (0, 0).
+ *
+ * This is a simpler and slower version of
+ * gsk_path_measure_get_closest_point_full(). Use that one if you
+ * need more control.
+ *
+ * Returns: The offset into the path of the closest point
+ **/
+float
+gsk_path_measure_get_closest_point (GskPathMeasure         *self,
+                                    const graphene_point_t *point,
+                                    graphene_point_t       *out_pos)
+{
+  float result;
+
+  g_return_val_if_fail (self != NULL, 0.0f);
+
+  if (gsk_path_measure_get_closest_point_full (self, 
+                                               point,
+                                               INFINITY,
+                                               &result,
+                                               out_pos,
+                                               NULL,
+                                               NULL))
+    return result;
+
+  if (out_pos)
+    *out_pos = GRAPHENE_POINT_INIT (0, 0);
+
+  return 0;
+
+}
+
+/**
+ * gsk_path_measure_get_closest_point_full:
+ * @self: a #GskPathMeasure
+ * @point: the point to fond the closest point to
+ * @threshold: The maximum allowed distance between the path and @point.
+ *     Use INFINITY to look for any point.
+ * @out_distance: (out caller-allocates) (optional): The 
+ *     distance between the found closest point on the path and the given
+ *     @point.
+ * @out_pos: (out caller-allocates) (optional): return location
+ *     for the closest point
+ * @out_offset: (out caller-allocates) (optional): The offset into
+ *     the path of the found point
+ * @out_tangent: (out caller-allocates) (optional): return location for
+ *     the tangent at the closest point
+ *
+ * Gets the point on the path that is closest to @point. If no point on
+ * path is closer to @point than @threshold, return %FALSE.
+ *
+ * Returns: %TRUE if a point was found, %FALSE otherwise.
+ **/
+gboolean
+gsk_path_measure_get_closest_point_full (GskPathMeasure         *self,
+                                         const graphene_point_t *point,
+                                         float                   threshold,
+                                         float                  *out_distance,
+                                         graphene_point_t       *out_pos,
+                                         float                  *out_offset,
+                                         graphene_vec2_t        *out_tangent)
+{
+  gboolean result;
+  gsize i;
+  float distance, length;
+
+  g_return_val_if_fail (self != NULL, FALSE);
+  g_return_val_if_fail (point != NULL, FALSE);
+
+  result = FALSE;
+  length = 0;
+
+  for (i = 0; i < self->n_contours; i++)
+    {
+      if (gsk_contour_get_closest_point (self->path,
+                                         i,
+                                         self->measures[i].contour_data,
+                                         self->tolerance,
+                                         point,
+                                         threshold,
+                                         &distance,
+                                         out_pos,
+                                         out_offset,
+                                         out_tangent))
+        {
+          result = TRUE;
+          if (out_offset)
+            *out_offset += length;
+
+          if (distance < self->tolerance)
+            break;
+          threshold = distance - self->tolerance;
+        }
+
+      length += self->measures[i].length;
+    }
+
+  if (result && out_distance)
+    *out_distance = distance;
+
+  return result;
+}
+
+/**
  * gsk_path_measure_in_fill:
- * @self: a `GskPathMeasure`
+ * @self: a #GskPathMeasure
  * @point: the point to test
  * @fill_rule: the fill rule to follow
  *
- * Returns whether the given point is inside the area
- * that would be affected if the path was filled according
- * to @fill_rule.
+ * Returns whether the given point is inside the area that would be
+ * affected if the path of @self was filled according to @fill_rule.
  *
- * Returns: `TRUE` if @point is inside
+ * Returns: %TRUE if @point is inside
  */
 gboolean
 gsk_path_measure_in_fill (GskPathMeasure         *self,
@@ -262,12 +391,18 @@ gsk_path_measure_in_fill (GskPathMeasure         *self,
                           GskFillRule             fill_rule)
 {
   int winding = 0;
+  gboolean on_edge = FALSE;
   int i;
 
   for (i = 0; i < self->n_contours; i++)
-    winding += gsk_contour_get_winding (gsk_path_get_contour (self->path, i),
-                                        self->measures[i].contour_data,
-                                        point);
+    {
+      winding += gsk_contour_get_winding (gsk_path_get_contour (self->path, i),
+                                          self->measures[i].contour_data,
+                                          point,
+                                          &on_edge);
+      if (on_edge)
+        return TRUE;
+    }
 
   switch (fill_rule)
     {
@@ -280,29 +415,52 @@ gsk_path_measure_in_fill (GskPathMeasure         *self,
     }
 }
 
-static void
-gsk_path_builder_add_segment_chunk (GskPathBuilder *self,
-                                    GskPathMeasure *measure,
-                                    gboolean        emit_move_to,
-                                    float           start,
-                                    float           end)
-{
-  g_assert (start < end);
 
-  for (gsize i = 0; i < measure->n_contours; i++)
+/**
+ * gsk_path_measure_add_segment:
+ * @self: a #GskPathMeasure
+ * @builder: the builder to add the segment to
+ * @start: start distance into the path
+ * @end: end distance into the path
+ *
+ * Adds to @builder the segment of @path inbetween @start and @end.
+ *
+ * The distances are given relative to the length of @self's path,
+ * from 0 for the beginning of the path to
+ * gsk_path_measure_get_length() for the end of the path. The values
+ * will be clamped to that range.
+ *
+ * If @start >= @end after clamping, no path will be added.
+ **/
+void
+gsk_path_measure_add_segment (GskPathMeasure *self,
+                              GskPathBuilder *builder,
+                              float           start,
+                              float           end)
+{
+  gsize i;
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (builder != NULL);
+
+  start = gsk_path_measure_clamp_distance (self, start);
+  end = gsk_path_measure_clamp_distance (self, end);
+  if (start >= end)
+    return;
+
+  for (i = 0; i < self->n_contours; i++)
     {
-      if (measure->measures[i].length < start)
+      if (self->measures[i].length < start)
         {
-          start -= measure->measures[i].length;
-          end -= measure->measures[i].length;
+          start -= self->measures[i].length;
+          end -= self->measures[i].length;
         }
-      else if (start > 0 || end < measure->measures[i].length)
+      else if (start > 0 || end < self->measures[i].length)
         {
-          float len = MIN (end, measure->measures[i].length);
-          gsk_contour_add_segment (gsk_path_get_contour (measure->path, i),
-                                   self,
-                                   measure->measures[i].contour_data,
-                                   emit_move_to,
+          float len = MIN (end, self->measures[i].length);
+          gsk_contour_add_segment (gsk_path_get_contour (self->path, i),
+                                   builder,
+                                   self->measures[i].contour_data,
                                    start,
                                    len);
           end -= len;
@@ -312,178 +470,8 @@ gsk_path_builder_add_segment_chunk (GskPathBuilder *self,
         }
       else
         {
-          end -= measure->measures[i].length;
-          gsk_path_builder_add_contour (self, gsk_contour_dup (gsk_path_get_contour (measure->path, i)));
+          end -= self->measures[i].length;
+          gsk_path_builder_add_contour (builder, gsk_contour_dup (gsk_path_get_contour (self->path, i)));
         }
-      emit_move_to = TRUE;
     }
 }
-
-/*< private >
- * gsk_path_builder_add_segment:
- * @self: a `GskPathBuilder`
- * @measure: the `GskPathMeasure` to take the segment to
- * @start: start distance into the path
- * @end: end distance into the path
- *
- * Adds to @self the segment of @measure from @start to @end.
- *
- * The distances are given relative to the length of @measure's path,
- * from 0 for the beginning of the path to its length for the end
- * of the path. The values will be clamped to that range. The length
- * can be obtained with [method@Gsk.PathMeasure.get_length].
- *
- * If @start >= @end after clamping, the path will first add the segment
- * from @start to the end of the path, and then add the segment from
- * the beginning to @end. If the path is closed, these segments will
- * be connected.
- */
-void
-gsk_path_builder_add_segment (GskPathBuilder *self,
-                              GskPathMeasure *measure,
-                              float           start,
-                              float           end)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (measure != NULL);
-
-  start = gsk_path_measure_clamp_distance (measure, start);
-  end = gsk_path_measure_clamp_distance (measure, end);
-
-  if (start < end)
-    {
-      gsk_path_builder_add_segment_chunk (self, measure, TRUE, start, end);
-    }
-  else
-    {
-      /* If the path is closed, we can connect the 2 subpaths. */
-      gboolean closed = gsk_path_measure_is_closed (measure);
-      gboolean need_move_to = !closed;
-
-      if (start < measure->length)
-        gsk_path_builder_add_segment_chunk (self, measure,
-                                            TRUE,
-                                            start, measure->length);
-      else
-        need_move_to = TRUE;
-
-      if (end > 0)
-        gsk_path_builder_add_segment_chunk (self, measure,
-                                            need_move_to,
-                                            0, end);
-      if (start == end && closed)
-        gsk_path_builder_close (self);
-    }
-}
-
-/*< private >
- * gsk_path_measure_get_point:
- * @self: a `GskPathMeasure`
- * @distance: the distance
- *
- * Returns a `GskPathPoint` representing the point at the given
- * distance into the path.
- *
- * An empty path has no points, so `NULL` is returned in that case.
- *
- * Returns: (transfer full) (nullable): a newly allocated `GskPathPoint`
- */
-GskPathPoint *
-gsk_path_measure_get_point (GskPathMeasure *self,
-                            float           distance)
-{
-  gsize i;
-  float contour_offset;
-  float offset;
-  const GskContour *contour;
-
-  g_return_val_if_fail (self != NULL, NULL);
-
-  if (self->n_contours == 0)
-    return NULL;
-
-  contour_offset = 0;
-  offset = gsk_path_measure_clamp_distance (self, distance);
-
-  for (i = 0; i < self->n_contours - 1; i++)
-    {
-      if (offset < self->measures[i].length)
-        break;
-
-      contour_offset += self->measures[i].length;
-      offset -= self->measures[i].length;
-    }
-
-  g_assert (0 <= i && i < self->n_contours);
-
-  offset = CLAMP (offset, 0, self->measures[i].length);
-
-  contour = gsk_path_get_contour (self->path, i);
-
-  return gsk_path_point_new (self,
-                             contour, self->measures[i].contour_data,
-                             contour_offset, offset);
-}
-
-/*< private >
- * gsk_path_measure_get_closest_point:
- * @self: a `GskPathMeasure`
- * @point: the point to fond the closest point to
- * @threshold: The maximum allowed distance between the path and @point.
- *   Use `INFINITY` to look for any point.
- *
- * Returns a `GskPathPoint` representing the point on the path
- * that is closest to the given point.
- *
- * If no point on the path is closer than @threshold, `NULL` is returned.
- *
- * Returns: (transfer full) (nullable): a newly allocated `GskPathPoint`
- */
-GskPathPoint *
-gsk_path_measure_get_closest_point (GskPathMeasure         *self,
-                                    const graphene_point_t *point,
-                                    float                   threshold)
-{
-  gssize best_idx;
-  float best_offset;
-  float best_contour_offset;
-  float contour_offset;
-
-  contour_offset = 0;
-  best_idx = -1;
-
-  for (gsize i = 0; i < self->n_contours; i++)
-    {
-      float distance, offset;
-
-      if (gsk_contour_get_closest_point (gsk_path_get_contour (self->path, i),
-                                         self->measures[i].contour_data,
-                                         self->tolerance,
-                                         point,
-                                         threshold,
-                                         &distance,
-                                         NULL,
-                                         &offset,
-                                         NULL))
-        {
-          best_idx = i;
-          best_offset = offset;
-          best_contour_offset = contour_offset;
-
-          if (distance < self->tolerance)
-            break;
-
-          threshold = distance - self->tolerance;
-        }
-
-      contour_offset += self->measures[i].length;
-    }
-
-  if (best_idx != -1)
-    return gsk_path_point_new (self,
-                               gsk_path_get_contour (self->path, best_idx),
-                               self->measures[best_idx].contour_data,
-                               best_contour_offset, best_offset);
-
-  return NULL;
-}

gsk/gskpathmeasure.h

@@ -17,7 +17,8 @@
  * Authors: Benjamin Otte <otte@gnome.org>
  */
 
-#pragma once
+#ifndef __GSK_PATH_MEASURE_H__
+#define __GSK_PATH_MEASURE_H__
 
 #if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
 #error "Only <gsk/gsk.h> can be included directly."
@@ -25,31 +26,56 @@
 
 
 #include <gsk/gskpath.h>
-#include <gsk/gskpathpoint.h>
 
 G_BEGIN_DECLS
 
 #define GSK_TYPE_PATH_MEASURE (gsk_path_measure_get_type ())
 
+GDK_AVAILABLE_IN_ALL
 GType                   gsk_path_measure_get_type               (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
 GskPathMeasure *        gsk_path_measure_new                    (GskPath                *path);
+GDK_AVAILABLE_IN_ALL
 GskPathMeasure *        gsk_path_measure_new_with_tolerance     (GskPath                *path,
                                                                  float                   tolerance);
+
+GDK_AVAILABLE_IN_ALL
 GskPathMeasure *        gsk_path_measure_ref                    (GskPathMeasure         *self);
+GDK_AVAILABLE_IN_ALL
 void                    gsk_path_measure_unref                  (GskPathMeasure         *self);
-GskPath *               gsk_path_measure_get_path               (GskPathMeasure         *self) G_GNUC_PURE;
-float                   gsk_path_measure_get_tolerance          (GskPathMeasure         *self) G_GNUC_PURE;
+
+GDK_AVAILABLE_IN_ALL
 float                   gsk_path_measure_get_length             (GskPathMeasure         *self);
-gboolean                gsk_path_measure_is_closed              (GskPathMeasure         *self);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_measure_get_point              (GskPathMeasure         *self,
+                                                                 float                   distance,
+                                                                 graphene_point_t       *pos,
+                                                                 graphene_vec2_t        *tangent);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_path_measure_get_closest_point      (GskPathMeasure         *self,
+                                                                 const graphene_point_t *point,
+                                                                 graphene_point_t       *out_pos);
+GDK_AVAILABLE_IN_ALL
+gboolean                gsk_path_measure_get_closest_point_full (GskPathMeasure         *self,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 float                  *out_distance,
+                                                                 graphene_point_t       *out_pos,
+                                                                 float                  *out_offset,
+                                                                 graphene_vec2_t        *out_tangent);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_path_measure_add_segment            (GskPathMeasure         *self,
+                                                                 GskPathBuilder         *builder,
+                                                                 float                   start,
+                                                                 float                   end);
+
+GDK_AVAILABLE_IN_ALL
 gboolean                gsk_path_measure_in_fill                (GskPathMeasure         *self,
                                                                  const graphene_point_t *point,
                                                                  GskFillRule             fill_rule);
-GskPathPoint *          gsk_path_measure_get_point              (GskPathMeasure         *self,
-                                                                 float                   distance);
-GskPathPoint *          gsk_path_measure_get_closest_point      (GskPathMeasure         *self,
-                                                                 const graphene_point_t *point,
-                                                                 float                   threshold);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathMeasure, gsk_path_measure_unref)
-
 G_END_DECLS
+
+#endif /* __GSK_PATH_MEASURE_H__ */

gsk/gskpathopprivate.h

@@ -1,186 +0,0 @@
-/*
- * Copyright © 2020 Benjamin Otte
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Authors: Benjamin Otte <otte@gnome.org>
- */
-
-
-#pragma once
-
-#include "gskpath.h"
-#include "gskpathbuilder.h"
-
-G_BEGIN_DECLS
-
-typedef gpointer gskpathop;
-
-static inline
-gskpathop               gsk_pathop_encode                       (GskPathOperation        op,
-                                                                 const graphene_point_t *pts);
-static inline
-const graphene_point_t *gsk_pathop_points                       (gskpathop               pop);
-static inline
-GskPathOperation        gsk_pathop_op                           (gskpathop               pop);
-
-static inline
-gboolean                gsk_pathop_foreach                      (gskpathop               pop,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
-
-/* included inline so tests can use them */
-static inline
-void                    gsk_path_builder_pathop_to              (GskPathBuilder         *builder,
-                                                                 gskpathop               op);
-static inline
-void                    gsk_path_builder_pathop_reverse_to      (GskPathBuilder         *builder,
-                                                                 gskpathop               op);
-
-/* IMPLEMENTATION */
-
-#define GSK_PATHOP_OPERATION_MASK (0x7)
-
-static inline gskpathop
-gsk_pathop_encode (GskPathOperation        op,
-                   const graphene_point_t *pts)
-{
-  /* g_assert (op & GSK_PATHOP_OPERATION_MASK == op); */
-  g_assert ((GPOINTER_TO_SIZE (pts) & GSK_PATHOP_OPERATION_MASK) == 0);
-
-  return GSIZE_TO_POINTER (GPOINTER_TO_SIZE (pts) | op);
-}
-
-static inline const graphene_point_t *
-gsk_pathop_points (gskpathop pop)
-{
-  return GSIZE_TO_POINTER (GPOINTER_TO_SIZE (pop) & ~GSK_PATHOP_OPERATION_MASK);
-}
-
-static inline
-GskPathOperation gsk_pathop_op (gskpathop pop)
-{
-  return GPOINTER_TO_SIZE (pop) & GSK_PATHOP_OPERATION_MASK;
-}
-
-static inline gboolean
-gsk_pathop_foreach (gskpathop          pop,
-                    GskPathForeachFunc func,
-                    gpointer           user_data)
-{
-  switch (gsk_pathop_op (pop))
-  {
-    case GSK_PATH_MOVE:
-      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 1, 0, user_data);
-
-    case GSK_PATH_CLOSE:
-    case GSK_PATH_LINE:
-      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 2, 0, user_data);
-
-    case GSK_PATH_QUAD:
-      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 3, 0, user_data);
-
-    case GSK_PATH_CUBIC:
-      return func (gsk_pathop_op (pop), gsk_pathop_points (pop), 4, 0, user_data);
-
-    case GSK_PATH_CONIC:
-      {
-        const graphene_point_t *pts = gsk_pathop_points (pop);
-        return func (gsk_pathop_op (pop), (graphene_point_t[3]) { pts[0], pts[1], pts[3] }, 3, pts[2].x, user_data);
-      }
-
-    default:
-      g_assert_not_reached ();
-      return TRUE;
-    }
-}
-
-static inline void
-gsk_path_builder_pathop_to (GskPathBuilder *builder,
-                            gskpathop       op)
-{
-  const graphene_point_t *pts = gsk_pathop_points (op);
-
-  switch (gsk_pathop_op (op))
-  {
-    case GSK_PATH_MOVE:
-      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
-      break;
-
-    case GSK_PATH_CLOSE:
-      gsk_path_builder_close (builder);
-      break;
-
-    case GSK_PATH_LINE:
-      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
-      break;
-
-    case GSK_PATH_QUAD:
-      gsk_path_builder_quad_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y);
-      break;
-
-    case GSK_PATH_CUBIC:
-      gsk_path_builder_cubic_to (builder, pts[1].x, pts[1].y, pts[2].x, pts[2].y, pts[3].x, pts[3].y);
-      break;
-
-    case GSK_PATH_CONIC:
-      gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[3].x, pts[3].y, pts[2].x);
-      break;
-
-    default:
-      g_assert_not_reached ();
-      break;
-  }
-}
-
-static inline void
-gsk_path_builder_pathop_reverse_to (GskPathBuilder *builder,
-                                    gskpathop       op)
-{
-  const graphene_point_t *pts = gsk_pathop_points (op);
-
-  switch (gsk_pathop_op (op))
-  {
-    case GSK_PATH_MOVE:
-      gsk_path_builder_move_to (builder, pts[0].x, pts[0].y);
-      break;
-
-    case GSK_PATH_CLOSE:
-      gsk_path_builder_line_to (builder, pts[0].x, pts[0].y);
-      break;
-
-    case GSK_PATH_LINE:
-      gsk_path_builder_line_to (builder, pts[1].x, pts[1].y);
-      break;
-
-    case GSK_PATH_QUAD:
-      gsk_path_builder_quad_to (builder, pts[1].x, pts[1].y, pts[0].x, pts[0].y);
-      break;
-
-    case GSK_PATH_CUBIC:
-      gsk_path_builder_cubic_to (builder, pts[2].x, pts[2].y, pts[1].x, pts[1].y, pts[0].x, pts[0].y);
-      break;
-
-    case GSK_PATH_CONIC:
-      gsk_path_builder_conic_to (builder, pts[1].x, pts[1].y, pts[0].x, pts[0].y, pts[2].x);
-      break;
-
-    default:
-      g_assert_not_reached ();
-      break;
-  }
-}
-
-
-G_END_DECLS

gsk/gskpathpoint.c

@@ -1,195 +0,0 @@
-#include "config.h"
-
-#include "gskpathpointprivate.h"
-
-#include "gskcontourprivate.h"
-#include "gskpathmeasure.h"
-
-#include "gdk/gdkprivate.h"
-
-
-/**
- * GskPathPoint:
- *
- * `GskPathPoint` is an opaque, immutable type representing a point on a path.
- *
- * It can be queried for properties of the path at that point, such as its
- * tangent or its curvature.
- *
- * To obtain a `GskPathPoint`, use [method@Gsk.PathMeasure.get_path_point]
- * or [method@Gsk.PathMeasure.get_closest_point].
- */
-
-struct _GskPathPoint
-{
-  guint ref_count;
-
-  GskPathMeasure *measure;
-  const GskContour *contour;
-  gpointer measure_data;
-  float contour_offset;  /* distance from beginning of path to contour */
-  float offset;          /* offset of point inside contour */
-};
-
-G_DEFINE_BOXED_TYPE (GskPathPoint, gsk_path_point,
-                     gsk_path_point_ref,
-                     gsk_path_point_unref)
-
-GskPathPoint *
-gsk_path_point_new (GskPathMeasure   *measure,
-                    const GskContour *contour,
-                    gpointer          measure_data,
-                    float             contour_offset,
-                    float             offset)
-{
-  GskPathPoint *self;
-
-  self = g_new0 (GskPathPoint, 1);
-
-  self->ref_count = 1;
-
-  self->measure = gsk_path_measure_ref (measure);
-  self->contour = contour;
-  self->measure_data = measure_data;
-  self->contour_offset = contour_offset;
-  self->offset = offset;
-
-  return self;
-}
-
-/**
- * gsk_path_point_ref:
- * @self: a `GskPathPoint`
- *
- * Increases the reference count of a `GskPathPoint` by one.
- *
- * Returns: the passed in `GskPathPoint`
- */
-GskPathPoint *
-gsk_path_point_ref (GskPathPoint *self)
-{
-  g_return_val_if_fail (self != NULL, NULL);
-
-  self->ref_count++;
-
-  return self;
-}
-
-/**
- * gsk_path_point_unref:
- * @self: a `GskPathPoint`
- *
- * Decreases the reference count of a `GskPathPoint` by one.
- *
- * If the resulting reference count is zero, frees the path_measure.
- */
-void
-gsk_path_point_unref (GskPathPoint *self)
-{
-  g_return_if_fail (self != NULL);
-  g_return_if_fail (self->ref_count > 0);
-
-  self->ref_count--;
-  if (self->ref_count > 0)
-    return;
-
-  gsk_path_measure_unref (self->measure);
-
-  g_free (self);
-}
-
-GskPathMeasure *
-gsk_path_point_get_measure (GskPathPoint *self)
-{
-  return self->measure;
-}
-
-/**
- * gsk_path_point_get_distance:
- * @self: a `GskPathPoint`
- *
- * Returns the distance of the given point from the start of the path.
- *
- * This is the length of the contour from the beginning of the path
- * to the point.
- *
- * Returns: The offset of point in path
- */
-float
-gsk_path_point_get_distance (GskPathPoint *self)
-{
-  return self->contour_offset + self->offset;
-}
-
-/**
- * gsk_path_point_get_position:
- * @self: a `GskPathPoint`
- * @position: (out caller-allocates): Return location for
- *   the coordinates of the point
- *
- * Gets the position of the point.
- */
-void
-gsk_path_point_get_position (GskPathPoint     *self,
-                             graphene_point_t *position)
-{
-  gsk_contour_get_point (self->contour,
-                         self->measure_data,
-                         self->offset,
-                         GSK_PATH_END,
-                         position, NULL);
-}
-
-/**
- * gsk_path_point_get_tangent:
- * @self: a `GskPathPoint`
- * @direction: the direction for which to return the tangent
- * @tangent: (out caller-allocates): Return location for
- *   the tangent at the point
- *
- * Gets the tangent of the path at the point.
- *
- * Note that certain points on a path may not have a single
- * tangent, such as sharp turns. At such points, there are
- * two tangents -- the direction of the path going into the
- * point, and the direction coming out of it.
- *
- * The @direction argument lets you choose which one to get.
- */
-void
-gsk_path_point_get_tangent (GskPathPoint     *self,
-                            GskPathDirection  direction,
-                            graphene_vec2_t  *tangent)
-{
-  gsk_contour_get_point (self->contour,
-                         self->measure_data,
-                         self->offset,
-                         direction,
-                         NULL, tangent);
-}
-
-/**
- * gsk_path_point_get_curvature:
- * @self: a `GskPathPoint`
- * @center: (out caller-allocates): Return location for
- *   the center of the osculating circle
- *
- * Calculates the curvature at the point @distance units into
- * the path.
- *
- * Optionally, returns the center of the osculating circle as well.
- *
- * If the curvature is infinite (at line segments), zero is returned,
- * and @center is not modified.
- *
- * Returns: The curvature of the path at the given point
- */
-float
-gsk_path_point_get_curvature (GskPathPoint     *self,
-                              graphene_point_t *center)
-{
-  return gsk_contour_get_curvature (self->contour,
-                                    self->measure_data,
-                                    self->offset,
-                                    center);
-}

gsk/gskpathpoint.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
-#error "Only <gsk/gsk.h> can be included directly."
-#endif
-
-
-#include <gsk/gsktypes.h>
-
-G_BEGIN_DECLS
-
-#define GSK_TYPE_PATH_POINT (gsk_path_point_get_type ())
-
-GType                   gsk_path_point_get_type        (void) G_GNUC_CONST;
-GskPathPoint *          gsk_path_point_ref             (GskPathPoint *self);
-void                    gsk_path_point_unref           (GskPathPoint *self);
-GskPathMeasure *        gsk_path_point_get_measure     (GskPathPoint     *self);
-float                   gsk_path_point_get_distance    (GskPathPoint     *self);
-void                    gsk_path_point_get_position    (GskPathPoint     *self,
-                                                        graphene_point_t *position);
-void                    gsk_path_point_get_tangent     (GskPathPoint     *self,
-                                                        GskPathDirection  direction,
-                                                        graphene_vec2_t  *tangent);
-float                   gsk_path_point_get_curvature   (GskPathPoint     *self,
-                                                        graphene_point_t *center);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathPoint, gsk_path_point_unref)
-
-G_END_DECLS

gsk/gskpathpointprivate.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include "gskpathpoint.h"
-#include "gskcontourprivate.h"
-#include "gskpathmeasure.h"
-
-G_BEGIN_DECLS
-
-GskPathPoint * gsk_path_point_new (GskPathMeasure *measure,
-                                   const GskContour *contour,
-                                   gpointer          measure_data,
-                                   float             contour_offset,
-                                   float             offset);
-
-G_END_DECLS
-

gsk/gskpathprivate.h

@@ -18,32 +18,90 @@
  */
 
 
-#pragma once
+#ifndef __GSK_PATH_PRIVATE_H__
+#define __GSK_PATH_PRIVATE_H__
 
 #include "gskpath.h"
 
-#include "gskcontourprivate.h"
-#include "gskpathopprivate.h"
-
 G_BEGIN_DECLS
 
 /* Same as Skia, so looks like a good value. ¯\_(ツ)_/¯ */
 #define GSK_PATH_TOLERANCE_DEFAULT (0.5)
 
+typedef enum 
+{
+  GSK_PATH_FLAT,
+  GSK_PATH_CLOSED
+} GskPathFlags;
+
+typedef struct _GskContour GskContour;
+typedef struct _GskContourClass GskContourClass;
+
+typedef struct _GskStandardOperation GskStandardOperation;
+
+struct _GskStandardOperation {
+  GskPathOperation op;
+  gsize point; /* index into points array of the start point (last point of previous op) */
+};
+
+GskContour *            gsk_rect_contour_new                    (const graphene_rect_t  *rect);
+GskContour *            gsk_circle_contour_new                  (const graphene_point_t *center,
+                                                                 float                   radius,
+                                                                 float                   start_angle,
+                                                                 float                   end_angle);
+GskContour *            gsk_standard_contour_new                (GskPathFlags            flags,
+                                                                 const                   GskStandardOperation *ops,
+                                                                 gsize                   n_ops,
+                                                                 const                   graphene_point_t *points,
+                                                                 gsize                   n_points);
+
 GskPath *               gsk_path_new_from_contours              (const GSList           *contours);
 
-gsize                   gsk_path_get_n_contours                 (GskPath                *path);
-const GskContour *      gsk_path_get_contour                    (GskPath                *path,
-                                                                 gsize                   i);
-
-GskPathFlags            gsk_path_get_flags                      (GskPath                *self);
-
-gboolean                gsk_path_foreach_with_tolerance         (GskPath                *self,
-                                                                 GskPathForeachFlags     flags,
-                                                                 double                  tolerance,
-                                                                 GskPathForeachFunc      func,
-                                                                 gpointer                user_data);
+gsize                   gsk_path_get_n_contours                 (GskPath              *path);
+const GskContour *      gsk_path_get_contour                    (GskPath              *path,
+                                                                 gsize                 i);
+gboolean                gsk_path_foreach_with_tolerance         (GskPath              *self,
+                                                                 GskPathForeachFlags   flags,
+                                                                 double                tolerance,
+                                                                 GskPathForeachFunc    func,
+                                                                 gpointer              user_data);
 
+GskContour *            gsk_contour_dup                         (const GskContour     *src);
+gpointer                gsk_contour_init_measure                (GskPath              *path,
+                                                                 gsize                 i,
+                                                                 float                 tolerance,
+                                                                 float                *out_length);
+void                    gsk_contour_free_measure                (GskPath              *path,
+                                                                 gsize                 i,
+                                                                 gpointer              data);
+void                    gsk_contour_get_start_end               (const GskContour       *self,
+                                                                 graphene_point_t       *start,
+                                                                 graphene_point_t       *end);
+void                    gsk_contour_get_point                   (GskPath              *path,
+                                                                 gsize                 i,
+                                                                 gpointer              measure_data,
+                                                                 float                 distance,
+                                                                 graphene_point_t     *pos,
+                                                                 graphene_vec2_t      *tangent);
+gboolean                gsk_contour_get_closest_point           (GskPath                *path,
+                                                                 gsize                   i,
+                                                                 gpointer                measure_data,
+                                                                 float                   tolerance,
+                                                                 const graphene_point_t *point,
+                                                                 float                   threshold,
+                                                                 float                  *out_distance,
+                                                                 graphene_point_t       *out_pos,
+                                                                 float                  *out_offset,
+                                                                 graphene_vec2_t        *out_tangent);
+int                     gsk_contour_get_winding                 (const GskContour       *self,
+                                                                 gpointer                measure_data,
+                                                                 const graphene_point_t *point,
+                                                                 gboolean               *on_edge);
+void                    gsk_contour_add_segment                 (const GskContour       *self,
+                                                                 GskPathBuilder         *builder,
+                                                                 gpointer                measure_data,
+                                                                 float                   start,
+                                                                 float                   end);
 
 void                    gsk_path_builder_add_contour            (GskPathBuilder         *builder,
                                                                  GskContour             *contour);
@@ -57,21 +115,7 @@ void                    gsk_path_builder_svg_arc_to             (GskPathBuilder
                                                                  float                   x,
                                                                  float                   y);
 
-
-typedef enum
-{
-  GSK_PATH_OP_SIMPLIFY,
-  GSK_PATH_OP_UNION,
-  GSK_PATH_OP_INTERSECTION,
-  GSK_PATH_OP_DIFFERENCE,
-  GSK_PATH_OP_XOR
-} GskPathOp;
-
-GskPath *               gsk_path_op                             (GskPathOp               operation,
-                                                                 GskFillRule             fill_rule,
-                                                                 GskPath                *first,
-                                                                 GskPath                *second);
-
-
 G_END_DECLS
 
+#endif /* __GSK_PATH_PRIVATE_H__ */
+

gsk/gskprivate.h

@@ -7,5 +7,8 @@ G_BEGIN_DECLS
 
 void gsk_ensure_resources (void);
 
+typedef struct _GskVulkanRender GskVulkanRender;
+typedef struct _GskVulkanRenderPass GskVulkanRenderPass;
+
 G_END_DECLS
 

gsk/gskrendernode.h

@@ -31,7 +31,7 @@ G_BEGIN_DECLS
 
 #define GSK_TYPE_RENDER_NODE (gsk_render_node_get_type ())
 
-#define GSK_IS_RENDER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_RENDER_NODE))
+#define GSK_IS_RENDER_NODE(obj) ((obj) != NULL)
 
 #define GSK_SERIALIZATION_ERROR       (gsk_serialization_error_quark ())
 
@@ -158,6 +158,8 @@ GskRenderNode *         gsk_render_node_deserialize             (GBytes
 #define GSK_TYPE_REPEAT_NODE                    (gsk_repeat_node_get_type())
 #define GSK_TYPE_CLIP_NODE                      (gsk_clip_node_get_type())
 #define GSK_TYPE_ROUNDED_CLIP_NODE              (gsk_rounded_clip_node_get_type())
+#define GSK_TYPE_FILL_NODE                      (gsk_fill_node_get_type())
+#define GSK_TYPE_STROKE_NODE                    (gsk_stroke_node_get_type())
 #define GSK_TYPE_SHADOW_NODE                    (gsk_shadow_node_get_type())
 #define GSK_TYPE_BLEND_NODE                     (gsk_blend_node_get_type())
 #define GSK_TYPE_CROSS_FADE_NODE                (gsk_cross_fade_node_get_type())
@@ -186,6 +188,8 @@ typedef struct _GskColorMatrixNode              GskColorMatrixNode;
 typedef struct _GskRepeatNode                   GskRepeatNode;
 typedef struct _GskClipNode                     GskClipNode;
 typedef struct _GskRoundedClipNode              GskRoundedClipNode;
+typedef struct _GskFillNode                     GskFillNode;
+typedef struct _GskStrokeNode                   GskStrokeNode;
 typedef struct _GskShadowNode                   GskShadowNode;
 typedef struct _GskBlendNode                    GskBlendNode;
 typedef struct _GskCrossFadeNode                GskCrossFadeNode;
@@ -459,6 +463,32 @@ GskRenderNode *         gsk_rounded_clip_node_get_child         (const GskRender
 GDK_AVAILABLE_IN_ALL
 const GskRoundedRect *  gsk_rounded_clip_node_get_clip          (const GskRenderNode      *node) G_GNUC_PURE;
 
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_fill_node_get_type                  (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_fill_node_new                       (GskRenderNode            *child,
+                                                                 GskPath                  *path,
+                                                                 GskFillRule               fill_rule);
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_fill_node_get_child                 (GskRenderNode            *node);
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_fill_node_get_path                  (GskRenderNode            *node);
+GDK_AVAILABLE_IN_ALL
+GskFillRule             gsk_fill_node_get_fill_rule             (GskRenderNode            *node);
+
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_stroke_node_get_type                (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_stroke_node_new                     (GskRenderNode            *child,
+                                                                 GskPath                  *path,
+                                                                 const GskStroke          *stroke);
+GDK_AVAILABLE_IN_ALL
+GskRenderNode *         gsk_stroke_node_get_child               (GskRenderNode            *node);
+GDK_AVAILABLE_IN_ALL
+GskPath *               gsk_stroke_node_get_path                (GskRenderNode            *node);
+GDK_AVAILABLE_IN_ALL
+const GskStroke *       gsk_stroke_node_get_stroke              (GskRenderNode            *node);
+
 GDK_AVAILABLE_IN_ALL
 GType                   gsk_shadow_node_get_type                (void) G_GNUC_CONST;
 GDK_AVAILABLE_IN_ALL

gsk/gskrendernodeimpl.c

@@ -25,8 +25,10 @@
 #include "gskdebugprivate.h"
 #include "gskdiffprivate.h"
 #include "gl/gskglrenderer.h"
+#include "gskpath.h"
 #include "gskrendererprivate.h"
 #include "gskroundedrectprivate.h"
+#include "gskstrokeprivate.h"
 #include "gsktransformprivate.h"
 
 #include "gdk/gdktextureprivate.h"
@@ -2421,7 +2423,6 @@ gsk_inset_shadow_node_new (const GskRoundedRect *outline,
 
   g_return_val_if_fail (outline != NULL, NULL);
   g_return_val_if_fail (color != NULL, NULL);
-  g_return_val_if_fail (blur_radius >= 0, NULL);
 
   self = gsk_render_node_alloc (GSK_INSET_SHADOW_NODE);
   node = (GskRenderNode *) self;
@@ -2697,7 +2698,7 @@ gsk_outset_shadow_node_diff (GskRenderNode  *node1,
 
 static void
 gsk_outset_shadow_node_class_init (gpointer g_class,
-                                   gpointer class_data)
+                          gpointer class_data)
 {
   GskRenderNodeClass *node_class = g_class;
 
@@ -2735,7 +2736,6 @@ gsk_outset_shadow_node_new (const GskRoundedRect *outline,
 
   g_return_val_if_fail (outline != NULL, NULL);
   g_return_val_if_fail (color != NULL, NULL);
-  g_return_val_if_fail (blur_radius >= 0, NULL);
 
   self = gsk_render_node_alloc (GSK_OUTSET_SHADOW_NODE);
   node = (GskRenderNode *) self;
@@ -3702,7 +3702,8 @@ gsk_color_matrix_node_finalize (GskRenderNode *node)
 static void
 apply_color_matrix_to_pattern (cairo_pattern_t         *pattern,
                                const graphene_matrix_t *color_matrix,
-                               const graphene_vec4_t   *color_offset)
+                               const graphene_vec4_t   *color_offset,
+                               gboolean                 multiply_alpha)
 {
   cairo_surface_t *surface, *image_surface;
   guchar *data;
@@ -3740,6 +3741,13 @@ apply_color_matrix_to_pattern (cairo_pattern_t         *pattern,
               graphene_matrix_transform_vec4 (color_matrix, &pixel, &pixel);
             }
 
+          if (multiply_alpha)
+            graphene_vec4_init (&pixel,
+                                graphene_vec4_get_x (&pixel),
+                                graphene_vec4_get_y (&pixel),
+                                graphene_vec4_get_z (&pixel),
+                                alpha * graphene_vec4_get_w (&pixel));
+
           graphene_vec4_add (&pixel, color_offset, &pixel);
 
           alpha = graphene_vec4_get_w (&pixel);
@@ -3762,8 +3770,6 @@ apply_color_matrix_to_pattern (cairo_pattern_t         *pattern,
 
   cairo_surface_mark_dirty (image_surface);
   cairo_surface_unmap_image (surface, image_surface);
-  /* https://gitlab.freedesktop.org/cairo/cairo/-/merge_requests/487 */
-  cairo_surface_mark_dirty (surface);
 }
 
 static void
@@ -3785,7 +3791,7 @@ gsk_color_matrix_node_draw (GskRenderNode *node,
 
   pattern = cairo_pop_group (cr);
 
-  apply_color_matrix_to_pattern (pattern, &self->color_matrix, &self->color_offset);
+  apply_color_matrix_to_pattern (pattern, &self->color_matrix, &self->color_offset, FALSE);
 
   cairo_set_source (cr, pattern);
   cairo_paint (cr);
@@ -4366,6 +4372,368 @@ gsk_rounded_clip_node_get_clip (const GskRenderNode *node)
   return &self->clip;
 }
 
+/* }}} */
+/* {{{ GSK_FILL_NODE */
+
+struct _GskFillNode
+{
+  GskRenderNode render_node;
+
+  GskRenderNode *child;
+  GskPath *path;
+  GskFillRule fill_rule;
+};
+
+static void
+gsk_fill_node_finalize (GskRenderNode *node)
+{
+  GskFillNode *self = (GskFillNode *) node;
+  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_FILL_NODE));
+
+  gsk_render_node_unref (self->child);
+  gsk_path_unref (self->path);
+
+  parent_class->finalize (node);
+}
+
+static void
+gsk_fill_node_draw (GskRenderNode *node,
+                    cairo_t       *cr)
+{
+  GskFillNode *self = (GskFillNode *) node;
+
+  cairo_save (cr);
+
+  switch (self->fill_rule)
+  {
+    case GSK_FILL_RULE_WINDING:
+      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);
+      break;
+    case GSK_FILL_RULE_EVEN_ODD:
+      cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+  }
+  gsk_path_to_cairo (self->path, cr);
+  cairo_clip (cr);
+
+  gsk_render_node_draw (self->child, cr);
+
+  cairo_restore (cr);
+}
+
+static void
+gsk_fill_node_diff (GskRenderNode  *node1,
+                    GskRenderNode  *node2,
+                    cairo_region_t *region)
+{
+  GskFillNode *self1 = (GskFillNode *) node1;
+  GskFillNode *self2 = (GskFillNode *) node2;
+
+  if (self1->path == self2->path)
+    {
+      cairo_region_t *sub;
+      cairo_rectangle_int_t clip_rect;
+      graphene_rect_t rect;
+
+      sub = cairo_region_create();
+      gsk_render_node_diff (self1->child, self2->child, sub);
+      graphene_rect_union (&node1->bounds, &node2->bounds, &rect);
+      rectangle_init_from_graphene (&clip_rect, &rect);
+      cairo_region_intersect_rectangle (sub, &clip_rect);
+      cairo_region_union (region, sub);
+      cairo_region_destroy (sub);
+    }
+  else
+    {
+      gsk_render_node_diff_impossible (node1, node2, region);
+    }
+}
+
+static void
+gsk_fill_node_class_init (gpointer g_class,
+                          gpointer class_data)
+{
+  GskRenderNodeClass *node_class = g_class;
+
+  node_class->node_type = GSK_FILL_NODE;
+
+  node_class->finalize = gsk_fill_node_finalize;
+  node_class->draw = gsk_fill_node_draw;
+  node_class->diff = gsk_fill_node_diff;
+}
+
+/**
+ * gsk_fill_node_new:
+ * @child: The node to fill the area with
+ * @path: The path describing the area to fill
+ * @fill_rule: The fill rule to use
+ *
+ * Creates a #GskRenderNode that will fill the @child in the area
+ * given by @path and @fill_rule.
+ *
+ * Returns: (transfer none) (type GskFillNode): A new #GskRenderNode
+ */
+GskRenderNode *
+gsk_fill_node_new (GskRenderNode *child,
+                   GskPath       *path,
+                   GskFillRule    fill_rule)
+{
+  GskFillNode *self;
+  GskRenderNode *node;
+  graphene_rect_t path_bounds;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
+  g_return_val_if_fail (path != NULL, NULL);
+
+  self = gsk_render_node_alloc (GSK_FILL_NODE);
+  node = (GskRenderNode *) self;
+
+  self->child = gsk_render_node_ref (child);
+  self->path = gsk_path_ref (path);
+  self->fill_rule = fill_rule;
+
+  if (gsk_path_get_bounds (path, &path_bounds))
+    graphene_rect_intersection (&path_bounds, &child->bounds, &node->bounds);
+  else
+    graphene_rect_init_from_rect (&node->bounds, graphene_rect_zero ());
+
+  return node;
+}
+
+/**
+ * gsk_fill_node_get_child:
+ * @node: (type GskFillNode): a fill #GskRenderNode
+ *
+ * Gets the child node that is getting drawn by the given @node.
+ *
+ * Returns: (transfer none): The child that is getting drawn
+ **/
+GskRenderNode *
+gsk_fill_node_get_child (GskRenderNode *node)
+{
+  GskFillNode *self = (GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
+
+  return self->child;
+}
+
+/**
+ * gsk_fill_node_get_path:
+ * @node: (type GskFillNode): a fill #GskRenderNode
+ *
+ * Retrievs the path used to describe the area filled with the contents of
+ * the @node.
+ *
+ * Returns: (transfer none): a #GskPath
+ */
+GskPath *
+gsk_fill_node_get_path (GskRenderNode *node)
+{
+  GskFillNode *self = (GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), NULL);
+
+  return self->path;
+}
+
+/**
+ * gsk_fill_node_get_fill_rule:
+ * @node: (type GskFillNode): a fill #GskRenderNode
+ *
+ * Retrievs the fill rule used to determine how the path is filled.
+ *
+ * Returns: a #GskFillRule
+ */
+GskFillRule
+gsk_fill_node_get_fill_rule (GskRenderNode *node)
+{
+  GskFillNode *self = (GskFillNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_FILL_NODE), GSK_FILL_RULE_WINDING);
+
+  return self->fill_rule;
+}
+
+/* }}} */
+/* {{{ GSK_STROKE_NODE */
+
+struct _GskStrokeNode
+{
+  GskRenderNode render_node;
+
+  GskRenderNode *child;
+  GskPath *path;
+  GskStroke stroke;
+};
+
+static void
+gsk_stroke_node_finalize (GskRenderNode *node)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+  GskRenderNodeClass *parent_class = g_type_class_peek (g_type_parent (GSK_TYPE_STROKE_NODE));
+
+  gsk_render_node_unref (self->child);
+  gsk_path_unref (self->path);
+  gsk_stroke_clear (&self->stroke);
+
+  parent_class->finalize (node);
+}
+
+static void
+gsk_stroke_node_draw (GskRenderNode *node,
+                      cairo_t       *cr)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+
+  cairo_save (cr);
+
+  gsk_cairo_rectangle (cr, &self->child->bounds);
+  cairo_clip (cr);
+
+  cairo_push_group (cr);
+  gsk_render_node_draw (self->child, cr);
+  cairo_pop_group_to_source (cr);
+
+  gsk_stroke_to_cairo (&self->stroke, cr);
+
+  gsk_path_to_cairo (self->path, cr);
+  cairo_stroke (cr);
+
+  cairo_restore (cr);
+}
+
+static void
+gsk_stroke_node_diff (GskRenderNode  *node1,
+                    GskRenderNode  *node2,
+                    cairo_region_t *region)
+{
+  GskStrokeNode *self1 = (GskStrokeNode *) node1;
+  GskStrokeNode *self2 = (GskStrokeNode *) node2;
+
+  if (self1->path == self2->path &&
+      gsk_stroke_equal (&self1->stroke, &self2->stroke))
+    {
+      cairo_region_t *sub;
+
+      sub = cairo_region_create();
+      gsk_render_node_diff (self1->child, self2->child, sub);
+      cairo_region_union (region, sub);
+      cairo_region_destroy (sub);
+    }
+  else
+    {
+      gsk_render_node_diff_impossible (node1, node2, region);
+    }
+}
+
+static void
+gsk_stroke_node_class_init (gpointer g_class,
+                          gpointer class_data)
+{
+  GskRenderNodeClass *node_class = g_class;
+
+  node_class->node_type = GSK_STROKE_NODE;
+
+  node_class->finalize = gsk_stroke_node_finalize;
+  node_class->draw = gsk_stroke_node_draw;
+  node_class->diff = gsk_stroke_node_diff;
+}
+
+/**
+ * gsk_stroke_node_new:
+ * @child: The node to stroke the area with
+ * @path: (transfer none): The path describing the area to stroke
+ * @stroke: (transfer none): The stroke attributes to use
+ *
+ * Creates a #GskRenderNode that will stroke the @child along the given
+ * @path using the attributes defined in @stroke.
+ *
+ * Returns: (transfer none) (type GskStrokeNode): A new #GskRenderNode
+ */
+GskRenderNode *
+gsk_stroke_node_new (GskRenderNode   *child,
+                     GskPath         *path,
+                     const GskStroke *stroke)
+{
+  GskStrokeNode *self;
+  GskRenderNode *node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
+  g_return_val_if_fail (path != NULL, NULL);
+  g_return_val_if_fail (stroke != NULL, NULL);
+
+  self = gsk_render_node_alloc (GSK_STROKE_NODE);
+  node = (GskRenderNode *) self;
+
+  self->child = gsk_render_node_ref (child);
+  self->path = gsk_path_ref (path);
+  gsk_stroke_init_copy (&self->stroke, stroke);
+
+  /* XXX: Figure out a way to compute bounds from the path */
+  graphene_rect_init_from_rect (&node->bounds, &child->bounds);
+
+  return node;
+}
+
+/**
+ * gsk_stroke_node_get_child:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Gets the child node that is getting drawn by the given @node.
+ *
+ * Returns: (transfer none): The child that is getting drawn
+ **/
+GskRenderNode *
+gsk_stroke_node_get_child (GskRenderNode *node)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return self->child;
+}
+
+/**
+ * gsk_stroke_node_get_path:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Retrievs the path that will be stroked with the contents of
+ * the @node.
+ *
+ * Returns: (transfer none): a #GskPath
+ */
+GskPath *
+gsk_stroke_node_get_path (GskRenderNode *node)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return self->path;
+}
+
+/**
+ * gsk_stroke_node_get_stroke:
+ * @node: (type GskStrokeNode): a stroke #GskRenderNode
+ *
+ * Retrievs the stroke attributes used in this @node.
+ *
+ * Returns: a #GskStroke
+ */
+const GskStroke *
+gsk_stroke_node_get_stroke (GskRenderNode *node)
+{
+  GskStrokeNode *self = (GskStrokeNode *) node;
+
+  g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_STROKE_NODE), NULL);
+
+  return &self->stroke;
+}
+
 /* }}} */
 /* {{{ GSK_SHADOW_NODE */
 
@@ -5646,50 +6014,6 @@ gsk_mask_node_finalize (GskRenderNode *node)
   parent_class->finalize (node);
 }
 
-static void
-apply_luminance_to_pattern (cairo_pattern_t *pattern,
-                            gboolean         invert_luminance)
-{
-  cairo_surface_t *surface, *image_surface;
-  guchar *data;
-  gsize x, y, width, height, stride;
-  int red, green, blue, alpha, luminance;
-  guint32* pixel_data;
-
-  cairo_pattern_get_surface (pattern, &surface);
-  image_surface = cairo_surface_map_to_image (surface, NULL);
-
-  data = cairo_image_surface_get_data (image_surface);
-  width = cairo_image_surface_get_width (image_surface);
-  height = cairo_image_surface_get_height (image_surface);
-  stride = cairo_image_surface_get_stride (image_surface);
-
-  for (y = 0; y < height; y++)
-    {
-      pixel_data = (guint32 *) data;
-      for (x = 0; x < width; x++)
-        {
-          alpha = (pixel_data[x] >> 24) & 0xFF;
-          red   = (pixel_data[x] >> 16) & 0xFF;
-          green = (pixel_data[x] >>  8) & 0xFF;
-          blue  = (pixel_data[x] >>  0) & 0xFF;
-
-          luminance = 2126 * red + 7152 * green + 722 * blue;
-          if (invert_luminance)
-            luminance = 10000 * alpha - luminance;
-          luminance = (luminance + 5000) / 10000;
-
-          pixel_data[x] = luminance * 0x1010101;
-        }
-      data += stride;
-    }
-
-  cairo_surface_mark_dirty (image_surface);
-  cairo_surface_unmap_image (surface, image_surface);
-  /* https://gitlab.freedesktop.org/cairo/cairo/-/merge_requests/487 */
-  cairo_surface_mark_dirty (surface);
-}
-
 static void
 gsk_mask_node_draw (GskRenderNode *node,
                     cairo_t       *cr)
@@ -5712,18 +6036,28 @@ gsk_mask_node_draw (GskRenderNode *node,
     case GSK_MASK_MODE_ALPHA:
       break;
     case GSK_MASK_MODE_INVERTED_ALPHA:
-      graphene_matrix_init_from_float (&color_matrix, (float[]){  0,  0,  0,  0,
-                                                                  0,  0,  0,  0,
-                                                                  0,  0,  0,  0,
-                                                                 -1, -1, -1, -1 });
-      graphene_vec4_init (&color_offset, 1, 1, 1, 1);
-      apply_color_matrix_to_pattern (mask_pattern, &color_matrix, &color_offset);
+      graphene_matrix_init_from_float (&color_matrix, (float[]){ 1, 0, 0, 0,
+                                                                 0, 1, 0, 0,
+                                                                 0, 0, 1, 0,
+                                                                 0, 0, 0, -1 });
+      graphene_vec4_init (&color_offset, 0, 0, 0, 1);
+      apply_color_matrix_to_pattern (mask_pattern, &color_matrix, &color_offset, FALSE);
       break;
     case GSK_MASK_MODE_LUMINANCE:
-      apply_luminance_to_pattern (mask_pattern, FALSE);
+      graphene_matrix_init_from_float (&color_matrix, (float[]){ 1, 0, 0, 0.2126,
+                                                                 0, 1, 0, 0.7152,
+                                                                 0, 0, 1, 0.0722,
+                                                                 0, 0, 0, 0 });
+      graphene_vec4_init (&color_offset, 0, 0, 0, 0);
+      apply_color_matrix_to_pattern (mask_pattern, &color_matrix, &color_offset, TRUE);
       break;
     case GSK_MASK_MODE_INVERTED_LUMINANCE:
-      apply_luminance_to_pattern (mask_pattern, TRUE);
+      graphene_matrix_init_from_float (&color_matrix, (float[]){ 1, 0, 0, -0.2126,
+                                                                 0, 1, 0, -0.7152,
+                                                                 0, 0, 1, -0.0722,
+                                                                 0, 0, 0,  0 });
+      graphene_vec4_init (&color_offset, 0, 0, 0, 1);
+      apply_color_matrix_to_pattern (mask_pattern, &color_matrix, &color_offset, TRUE);
       break;
     default:
       g_assert_not_reached ();
@@ -5745,12 +6079,6 @@ gsk_mask_node_diff (GskRenderNode  *node1,
   GskMaskNode *self1 = (GskMaskNode *) node1;
   GskMaskNode *self2 = (GskMaskNode *) node2;
 
-  if (self1->mask_mode != self2->mask_mode)
-    {
-      gsk_render_node_diff_impossible (node1, node2, region);
-      return;
-    }
-
   gsk_render_node_diff (self1->source, self2->source, region);
   gsk_render_node_diff (self1->mask, self2->mask, region);
 }
@@ -6259,6 +6587,8 @@ GSK_DEFINE_RENDER_NODE_TYPE (gsk_color_matrix_node, GSK_COLOR_MATRIX_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_repeat_node, GSK_REPEAT_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_clip_node, GSK_CLIP_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_rounded_clip_node, GSK_ROUNDED_CLIP_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_fill_node, GSK_FILL_NODE)
+GSK_DEFINE_RENDER_NODE_TYPE (gsk_stroke_node, GSK_STROKE_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_shadow_node, GSK_SHADOW_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_blend_node, GSK_BLEND_NODE)
 GSK_DEFINE_RENDER_NODE_TYPE (gsk_cross_fade_node, GSK_CROSS_FADE_NODE)
@@ -6407,6 +6737,16 @@ gsk_render_node_init_types_once (void)
                                                     sizeof (GskDebugNode),
                                                     gsk_debug_node_class_init);
   gsk_render_node_types[GSK_DEBUG_NODE] = node_type;
+
+  node_type = gsk_render_node_type_register_static (I_("GskFillNode"),
+                                                    sizeof (GskFillNode),
+                                                    gsk_fill_node_class_init);
+  gsk_render_node_types[GSK_FILL_NODE] = node_type;
+
+  node_type = gsk_render_node_type_register_static (I_("GskStrokeNode"),
+                                                    sizeof (GskStrokeNode),
+                                                    gsk_stroke_node_class_init);
+  gsk_render_node_types[GSK_STROKE_NODE] = node_type;
 }
 
 static void

gsk/gskrendernodeparser.c

@@ -23,9 +23,13 @@
 
 #include "gskrendernodeparserprivate.h"
 
+#include "gskpath.h"
+#include "gskpathbuilder.h"
 #include "gskroundedrectprivate.h"
 #include "gskrendernodeprivate.h"
+#include "gskstroke.h"
 #include "gsktransformprivate.h"
+#include "gskenumtypes.h"
 
 #include "gdk/gdkrgbaprivate.h"
 #include "gdk/gdktextureprivate.h"
@@ -453,21 +457,6 @@ parse_double (GtkCssParser *parser,
   return gtk_css_parser_consume_number (parser, out_double);
 }
 
-static gboolean
-parse_positive_double (GtkCssParser *parser,
-                       Context      *context,
-                       gpointer      out_double)
-{
-  if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNED_NUMBER)
-      || gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNED_INTEGER))
-    {
-      gtk_css_parser_error_syntax (parser, "Expected a positive number");
-      return FALSE;
-    }
-
-  return gtk_css_parser_consume_number (parser, out_double);
-}
-
 static gboolean
 parse_point (GtkCssParser *parser,
              Context      *context,
@@ -1174,6 +1163,26 @@ create_default_render_node (void)
   return gsk_color_node_new (&GDK_RGBA("FF00CC"), &GRAPHENE_RECT_INIT (0, 0, 50, 50));
 }
 
+static GskPath *
+create_default_path (void)
+{
+  GskPathBuilder *builder;
+  guint i;
+
+  builder = gsk_path_builder_new ();
+
+  gsk_path_builder_move_to (builder, 25, 0);
+  for (i = 1; i < 5; i++)
+    {
+      gsk_path_builder_line_to (builder,
+                                sin (i * G_PI * 0.8) * 25 + 25,
+                                -cos (i * G_PI * 0.8) * 25 + 25);
+    }
+  gsk_path_builder_close (builder);
+
+  return gsk_path_builder_free_to_path (builder);
+}
+
 static GskRenderNode *
 parse_color_node (GtkCssParser *parser,
                   Context      *context)
@@ -1257,10 +1266,10 @@ parse_radial_gradient_node_internal (GtkCssParser *parser,
   const Declaration declarations[] = {
     { "bounds", parse_rect, NULL, &bounds },
     { "center", parse_point, NULL, &center },
-    { "hradius", parse_positive_double, NULL, &hradius },
-    { "vradius", parse_positive_double, NULL, &vradius },
-    { "start", parse_positive_double, NULL, &start },
-    { "end", parse_positive_double, NULL, &end },
+    { "hradius", parse_double, NULL, &hradius },
+    { "vradius", parse_double, NULL, &vradius },
+    { "start", parse_double, NULL, &start },
+    { "end", parse_double, NULL, &end },
     { "stops", parse_stops, clear_stops, &stops },
   };
   GskRenderNode *result;
@@ -1350,7 +1359,7 @@ parse_inset_shadow_node (GtkCssParser *parser,
     { "dx", parse_double, NULL, &dx },
     { "dy", parse_double, NULL, &dy },
     { "spread", parse_double, NULL, &spread },
-    { "blur", parse_positive_double, NULL, &blur }
+    { "blur", parse_double, NULL, &blur }
   };
 
   parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
@@ -1752,7 +1761,7 @@ parse_outset_shadow_node (GtkCssParser *parser,
     { "dx", parse_double, NULL, &dx },
     { "dy", parse_double, NULL, &dy },
     { "spread", parse_double, NULL, &spread },
-    { "blur", parse_positive_double, NULL, &blur }
+    { "blur", parse_double, NULL, &blur }
   };
 
   parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
@@ -2032,7 +2041,7 @@ parse_blur_node (GtkCssParser *parser,
   GskRenderNode *child = NULL;
   double blur_radius = 1.0;
   const Declaration declarations[] = {
-    { "blur", parse_positive_double, NULL, &blur_radius },
+    { "blur", parse_double, NULL, &blur_radius },
     { "child", parse_node, clear_node, &child },
   };
   GskRenderNode *result;
@@ -2097,6 +2106,215 @@ parse_rounded_clip_node (GtkCssParser *parser,
   return result;
 }
 
+static gboolean
+parse_path (GtkCssParser *parser,
+            Context      *context,
+            gpointer      out_path)
+{
+  GskPath *path;
+  char *str = NULL;
+
+  if (!parse_string (parser, context, &str))
+    return FALSE;
+
+  path = gsk_path_parse (str);
+  g_free (str);
+
+  if (path == NULL)
+    {
+      gtk_css_parser_error_value (parser, "Invalid path");
+      return FALSE;
+    }
+
+  *((GskPath **) out_path) = path;
+
+  return TRUE;
+}
+
+static void
+clear_path (gpointer inout_path)
+{
+  g_clear_pointer ((GskPath **) inout_path, gsk_path_unref);
+}
+
+static gboolean
+parse_dash (GtkCssParser *parser,
+            Context      *context,
+            gpointer      out_dash)
+{
+  GArray *dash;
+  double d;
+
+  /* because CSS does this, too */
+  if (gtk_css_parser_try_ident (parser, "none"))
+    {
+      *((GArray **) out_dash) = NULL;
+      return TRUE;
+    }
+
+  dash = g_array_new (FALSE, FALSE, sizeof (float));
+  do {
+    if (!gtk_css_parser_consume_number (parser, &d))
+      {
+        g_array_free (dash, TRUE);
+        return FALSE;
+      }
+
+    g_array_append_vals (dash, (float[1]) { d }, 1);
+  } while (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNLESS_NUMBER) ||
+           gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_SIGNLESS_INTEGER));
+
+  *((GArray **) out_dash) = dash;
+
+  return TRUE;
+}
+
+static void
+clear_dash (gpointer inout_array)
+{
+  g_clear_pointer ((GArray **) inout_array, g_array_unref);
+}
+
+static gboolean
+parse_enum (GtkCssParser *parser,
+            GType         type,
+            gpointer      out_value)
+{
+  GEnumClass *class;
+  GEnumValue *v;
+  char *enum_name;
+
+  enum_name = gtk_css_parser_consume_ident (parser);
+  if (enum_name == NULL)
+    return FALSE;
+
+  class = g_type_class_ref (type);
+
+  v = g_enum_get_value_by_nick (class, enum_name);
+  if (v == NULL)
+    {
+      gtk_css_parser_error_value (parser, "Unknown value \"%s\" for enum \"%s\"",
+                                  enum_name, g_type_name (type));
+      g_free (enum_name);
+      g_type_class_unref (class);
+      return FALSE;
+    }
+
+  *(int*)out_value = v->value;
+
+  g_free (enum_name);
+  g_type_class_unref (class);
+
+  gtk_css_parser_consume_token (parser);
+
+  return TRUE;
+}
+
+static gboolean
+parse_fill_rule (GtkCssParser *parser,
+                 Context      *context,
+                 gpointer      out_rule)
+{
+  return parse_enum (parser, GSK_TYPE_FILL_RULE, out_rule);
+}
+
+static GskRenderNode *
+parse_fill_node (GtkCssParser *parser,
+                 Context      *context)
+{
+  GskRenderNode *child = NULL;
+  GskPath *path = NULL;
+  int rule = GSK_FILL_RULE_WINDING;
+  const Declaration declarations[] = {
+    { "child", parse_node, clear_node, &child },
+    { "path", parse_path, clear_path, &path },
+    { "fill-rule", parse_fill_rule, NULL, &rule },
+  };
+  GskRenderNode *result;
+
+  parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
+  if (child == NULL)
+    child = create_default_render_node ();
+  if (path == NULL)
+    path = create_default_path ();
+
+  result = gsk_fill_node_new (child, path, rule);
+
+  gsk_path_unref (path);
+
+  gsk_render_node_unref (child);
+
+  return result;
+}
+
+static gboolean
+parse_line_cap (GtkCssParser *parser,
+                Context      *context,
+                gpointer      out)
+{
+  return parse_enum (parser, GSK_TYPE_LINE_CAP, out);
+}
+
+static gboolean
+parse_line_join (GtkCssParser *parser,
+                 Context      *context,
+                 gpointer      out)
+{
+  return parse_enum (parser, GSK_TYPE_LINE_JOIN, out);
+}
+
+static GskRenderNode *
+parse_stroke_node (GtkCssParser *parser,
+                   Context      *context)
+{
+  GskRenderNode *child = NULL;
+  GskPath *path = NULL;
+  double line_width = 1.0;
+  int line_cap = GSK_LINE_CAP_BUTT;
+  int line_join = GSK_LINE_JOIN_MITER;
+  double miter_limit = 4.0;
+  GArray *dash = NULL;
+  double dash_offset = 0.0;
+  GskStroke *stroke;
+
+  const Declaration declarations[] = {
+    { "child", parse_node, clear_node, &child },
+    { "path", parse_path, clear_path, &path },
+    { "line-width", parse_double, NULL, &line_width },
+    { "line-cap", parse_line_cap, NULL, &line_cap },
+    { "line-join", parse_line_join, NULL, &line_join },
+    { "miter-limit", parse_double, NULL, &miter_limit },
+    { "dash", parse_dash, clear_dash, &dash },
+    { "dash-offset", parse_double, NULL, &dash_offset},
+  };
+  GskRenderNode *result;
+
+  parse_declarations (parser, context, declarations, G_N_ELEMENTS (declarations));
+  if (child == NULL)
+    child = create_default_render_node ();
+  if (path == NULL)
+    path = create_default_path ();
+
+  stroke = gsk_stroke_new (line_width);
+  gsk_stroke_set_line_cap (stroke, line_cap);
+  gsk_stroke_set_line_join (stroke, line_join);
+  gsk_stroke_set_miter_limit (stroke, miter_limit);
+  if (dash)
+    {
+      gsk_stroke_set_dash (stroke, (float *) dash->data, dash->len);
+      g_array_free (dash, TRUE);
+    }
+  gsk_stroke_set_dash_offset (stroke, dash_offset);
+
+  result = gsk_stroke_node_new (child, path, stroke);
+
+  gsk_path_unref (path);
+  gsk_stroke_free (stroke);
+  gsk_render_node_unref (child);
+
+  return result;
+}
+
 static GskRenderNode *
 parse_shadow_node (GtkCssParser *parser,
                    Context      *context)
@@ -2179,6 +2397,8 @@ parse_node (GtkCssParser *parser,
     { "repeating-linear-gradient", parse_repeating_linear_gradient_node },
     { "repeating-radial-gradient", parse_repeating_radial_gradient_node },
     { "rounded-clip", parse_rounded_clip_node },
+    { "fill", parse_fill_node },
+    { "stroke", parse_stroke_node },
     { "shadow", parse_shadow_node },
     { "text", parse_text_node },
     { "texture", parse_texture_node },
@@ -2433,6 +2653,14 @@ printer_init_duplicates_for_node (Printer       *printer,
       printer_init_duplicates_for_node (printer, gsk_debug_node_get_child (node));
       break;
 
+    case GSK_FILL_NODE:
+      printer_init_duplicates_for_node (printer, gsk_fill_node_get_child (node));
+      break;
+
+    case GSK_STROKE_NODE:
+      printer_init_duplicates_for_node (printer, gsk_stroke_node_get_child (node));
+      break;
+
     case GSK_BLEND_NODE:
       printer_init_duplicates_for_node (printer, gsk_blend_node_get_bottom_child (node));
       printer_init_duplicates_for_node (printer, gsk_blend_node_get_top_child (node));
@@ -2658,7 +2886,7 @@ append_float_param (Printer    *p,
                     float       value,
                     float       default_value)
 {
-  /* Don't approximate-compare here, better be topo verbose */
+  /* Don't approximate-compare here, better be too verbose */
   if (value == default_value)
     return;
 
@@ -2833,8 +3061,11 @@ append_escaping_newlines (GString    *str,
     len = strcspn (string, "\n");
     g_string_append_len (str, string, len);
     string += len;
-    g_string_append (str, "\\\n");
-    string++;
+    if (*string)
+      {
+        g_string_append (str, "\\\n");
+        string++;
+      }
   } while (*string);
 }
 
@@ -3033,6 +3264,83 @@ gsk_text_node_serialize_glyphs (GskRenderNode *node,
     pango_glyph_string_free (ascii);
 }
 
+static const char *
+enum_to_nick (GType type,
+              int   value)
+{
+  GEnumClass *class;
+  GEnumValue *v;
+
+  class = g_type_class_ref (type);
+  v = g_enum_get_value (class, value);
+  g_type_class_unref (class);
+
+  return v->value_nick;
+}
+
+static void
+append_enum_param (Printer    *p,
+                   const char *param_name,
+                   GType       type,
+                   int         value)
+{
+  _indent (p);
+  g_string_append_printf (p->str, "%s: ", param_name);
+  g_string_append (p->str, enum_to_nick (type, value));
+  g_string_append_c (p->str, ';');
+  g_string_append_c (p->str, '\n');
+}
+
+static void
+append_path_param (Printer    *p,
+                   const char *param_name,
+                   GskPath    *path)
+{
+  char *str, *s;
+
+  _indent (p);
+  g_string_append (p->str, "path: \"\\\n");
+  str = gsk_path_to_string (path);
+  /* Put each command on a new line */
+  for (s = str; *s; s++)
+    {
+      if (*s == ' ' &&
+          (s[1] == 'M' || s[1] == 'C' || s[1] == 'Z' || s[1] == 'L'))
+        *s = '\n';
+    }
+  append_escaping_newlines (p->str, str);
+  g_string_append (p->str, "\";\n");
+  g_free (str);
+}
+
+static void
+append_dash_param (Printer     *p,
+                   const char  *param_name,
+                   const float *dash,
+                   gsize        n_dash)
+{
+  _indent (p);
+  g_string_append (p->str, "dash: ");
+
+  if (n_dash == 0)
+    {
+      g_string_append (p->str, "none");
+    }
+  else
+    {
+      gsize i;
+
+      string_append_double (p->str, dash[0]);
+      for (i = 1; i < n_dash; i++)
+        {
+          g_string_append_c (p->str, ' ');
+          string_append_double (p->str, dash[i]);
+        }
+    }
+
+  g_string_append (p->str, ";\n");
+}
+
 static void
 render_node_print (Printer       *p,
                    GskRenderNode *node)
@@ -3202,6 +3510,42 @@ render_node_print (Printer       *p,
         append_rounded_rect_param (p, "clip", gsk_rounded_clip_node_get_clip (node));
         append_node_param (p, "child", gsk_rounded_clip_node_get_child (node));
 
+        end_node (p);
+      }
+      break;
+
+    case GSK_FILL_NODE:
+      {
+        start_node (p, "fill", node_name);
+
+        append_node_param (p, "child", gsk_fill_node_get_child (node));
+        append_path_param (p, "path", gsk_fill_node_get_path (node));
+        append_enum_param (p, "fill-rule", GSK_TYPE_FILL_RULE, gsk_fill_node_get_fill_rule (node));
+
+        end_node (p);
+      }
+      break;
+
+    case GSK_STROKE_NODE:
+      {
+        const GskStroke *stroke;
+        const float *dash;
+        gsize n_dash;
+
+        start_node (p, "stroke", node_name);
+
+        append_node_param (p, "child", gsk_stroke_node_get_child (node));
+        append_path_param (p, "path", gsk_stroke_node_get_path (node));
+
+        stroke = gsk_stroke_node_get_stroke (node);
+        append_float_param (p, "line-width", gsk_stroke_get_line_width (stroke), 0.0f);
+        append_enum_param (p, "line-cap", GSK_TYPE_LINE_CAP, gsk_stroke_get_line_cap (stroke));
+        append_enum_param (p, "line-join", GSK_TYPE_LINE_JOIN, gsk_stroke_get_line_join (stroke));
+        append_float_param (p, "miter-limit", gsk_stroke_get_miter_limit (stroke), 4.0f);
+        dash = gsk_stroke_get_dash (stroke, &n_dash);
+        if (dash)
+          append_dash_param (p, "dash", dash, n_dash);
+        append_float_param (p, "dash-offset", gsk_stroke_get_dash_offset (stroke), 0.0f);
 
         end_node (p);
       }

gsk/gskroundedrect.c

@@ -945,44 +945,3 @@ gsk_rounded_rect_to_string (const GskRoundedRect *self)
                           self->corner[3].width,
                           self->corner[3].height);
 }
-
-/*
- * gsk_rounded_rect_get_largest_cover:
- * @self: the rounded rect to intersect with
- * @rect: the rectangle to intersect
- * @result: (out caller-allocates): The resulting rectangle
- *
- * Computes the largest rectangle that is fully covered by both
- * the given rect and the rounded rect.  
- * In particular, this function respects corners, so
- *   gsk_rounded_rect_get_largest_cover(self, &self->bounds, &rect)
- * can be used to compute a decomposition for a rounded rect itself.
- **/
-void
-gsk_rounded_rect_get_largest_cover (const GskRoundedRect  *self,
-                                    const graphene_rect_t *rect,
-                                    graphene_rect_t       *result)
-{
-  graphene_rect_t wide, high;
-  double start, end;
-
-  wide = self->bounds;
-  start = MAX(self->corner[GSK_CORNER_TOP_LEFT].height, self->corner[GSK_CORNER_TOP_RIGHT].height);
-  end = MAX(self->corner[GSK_CORNER_BOTTOM_LEFT].height, self->corner[GSK_CORNER_BOTTOM_RIGHT].height);
-  wide.size.height -= MIN (wide.size.height, start + end);
-  wide.origin.y += start;
-  graphene_rect_intersection (&wide, rect, &wide);
-
-  high = self->bounds;
-  start = MAX(self->corner[GSK_CORNER_TOP_LEFT].width, self->corner[GSK_CORNER_BOTTOM_LEFT].width);
-  end = MAX(self->corner[GSK_CORNER_TOP_RIGHT].width, self->corner[GSK_CORNER_BOTTOM_RIGHT].width);
-  high.size.width -= MIN (high.size.width, start + end);
-  high.origin.x += start;
-  graphene_rect_intersection (&high, rect, &high);
-
-  if (wide.size.width * wide.size.height > high.size.width * high.size.height)
-    *result = wide;
-  else
-    *result = high;
-}
-

gsk/gskroundedrectprivate.h

@@ -53,10 +53,6 @@ gboolean                 gsk_rounded_rect_equal                 (gconstpointer
                                                                  gconstpointer             rect2) G_GNUC_PURE;
 char *                   gsk_rounded_rect_to_string             (const GskRoundedRect     *self) G_GNUC_MALLOC;
 
-void                     gsk_rounded_rect_get_largest_cover     (const GskRoundedRect     *self,
-                                                                 const graphene_rect_t    *rect,
-                                                                 graphene_rect_t          *result);
-
 typedef enum {
   GSK_INTERSECTION_EMPTY,
   GSK_INTERSECTION_NONEMPTY,

gsk/gskspline.c

@@ -25,6 +25,215 @@
 
 #include <math.h>
 
+typedef struct
+{
+  graphene_point_t last_point;
+  float last_progress;
+  float tolerance;
+  GskSplineAddPointFunc func;
+  gpointer user_data;
+} GskCubicDecomposition;
+
+static void
+gsk_spline_decompose_add_point (GskCubicDecomposition  *decomp,
+                                const graphene_point_t *pt,
+                                float                   progress)
+{
+  if (graphene_point_equal (&decomp->last_point, pt))
+    return;
+
+  decomp->func (&decomp->last_point, pt, decomp->last_progress, decomp->last_progress + progress, decomp->user_data);
+  decomp->last_point = *pt;
+  decomp->last_progress += progress;
+}
+
+static void
+gsk_spline_cubic_get_coefficients (graphene_point_t       coeffs[4],
+                                   const graphene_point_t pts[4])
+{
+  coeffs[0] = GRAPHENE_POINT_INIT (pts[3].x - 3.0f * pts[2].x + 3.0f * pts[1].x - pts[0].x,
+                                   pts[3].y - 3.0f * pts[2].y + 3.0f * pts[1].y - pts[0].y);
+  coeffs[1] = GRAPHENE_POINT_INIT (3.0f * pts[2].x - 6.0f * pts[1].x + 3.0f * pts[0].x,
+                                   3.0f * pts[2].y - 6.0f * pts[1].y + 3.0f * pts[0].y);
+  coeffs[2] = GRAPHENE_POINT_INIT (3.0f * pts[1].x - 3.0f * pts[0].x,
+                                   3.0f * pts[1].y - 3.0f * pts[0].y);
+  coeffs[3] = pts[0];
+}
+
+void
+gsk_spline_get_point_cubic (const graphene_point_t  pts[4],
+                            float                   progress,
+                            graphene_point_t       *pos,
+                            graphene_vec2_t        *tangent)
+{
+  graphene_point_t c[4];
+
+  gsk_spline_cubic_get_coefficients (c, pts);
+
+  if (pos)
+    *pos = GRAPHENE_POINT_INIT (((c[0].x * progress + c[1].x) * progress +c[2].x) * progress + c[3].x,
+                                ((c[0].y * progress + c[1].y) * progress +c[2].y) * progress + c[3].y);
+  if (tangent)
+    {
+      graphene_vec2_init (tangent,
+                          (3.0f * c[0].x * progress + 2.0f * c[1].x) * progress + c[2].x,
+                          (3.0f * c[0].y * progress + 2.0f * c[1].y) * progress + c[2].y);
+      graphene_vec2_normalize (tangent, tangent);
+    }
+}
+
+void
+gsk_spline_split_cubic (const graphene_point_t pts[4],
+                        graphene_point_t       result1[4],
+                        graphene_point_t       result2[4],
+                        float                  progress)
+{
+    graphene_point_t ab, bc, cd;
+    graphene_point_t abbc, bccd;
+    graphene_point_t final;
+
+    graphene_point_interpolate (&pts[0], &pts[1], progress, &ab);
+    graphene_point_interpolate (&pts[1], &pts[2], progress, &bc);
+    graphene_point_interpolate (&pts[2], &pts[3], progress, &cd);
+    graphene_point_interpolate (&ab, &bc, progress, &abbc);
+    graphene_point_interpolate (&bc, &cd, progress, &bccd);
+    graphene_point_interpolate (&abbc, &bccd, progress, &final);
+
+    memcpy (result1, (graphene_point_t[4]) { pts[0], ab, abbc, final }, sizeof (graphene_point_t[4]));
+    memcpy (result2, (graphene_point_t[4]) { final, bccd, cd, pts[3] }, sizeof (graphene_point_t[4]));
+}
+
+#if 0
+/* Return an upper bound on the error (squared) that could result from
+ * approximating a spline as a line segment connecting the two endpoints. */
+static float
+gsk_spline_error_squared (const graphene_point_t pts[4])
+{
+  float bdx, bdy, berr;
+  float cdx, cdy, cerr;
+
+  /* We are going to compute the distance (squared) between each of the the b
+   * and c control points and the segment a-b. The maximum of these two
+   * distances will be our approximation error. */
+
+  bdx = pts[1].x - pts[0].x;
+  bdy = pts[1].y - pts[0].y;
+
+  cdx = pts[2].x - pts[0].x;
+  cdy = pts[2].y - pts[0].y;
+
+  if (!graphene_point_equal (&pts[0], &pts[3]))
+    {
+      float dx, dy, u, v;
+
+      /* Intersection point (px):
+       *     px = p1 + u(p2 - p1)
+       *     (p - px) ∙ (p2 - p1) = 0
+       * Thus:
+       *     u = ((p - p1) ∙ (p2 - p1)) / ∥p2 - p1∥²;
+       */
+
+      dx = pts[3].x - pts[0].x;
+      dy = pts[3].y - pts[0].y;
+      v = dx * dx + dy * dy;
+
+      u = bdx * dx + bdy * dy;
+      if (u <= 0)
+        {
+          /* bdx -= 0;
+           * bdy -= 0;
+           */
+        }
+      else if (u >= v)
+        {
+          bdx -= dx;
+          bdy -= dy;
+        }
+      else
+        {
+          bdx -= u/v * dx;
+          bdy -= u/v * dy;
+        }
+
+      u = cdx * dx + cdy * dy;
+      if (u <= 0)
+        {
+          /* cdx -= 0;
+           * cdy -= 0;
+           */
+        }
+      else if (u >= v)
+        {
+          cdx -= dx;
+          cdy -= dy;
+        }
+      else
+        {
+          cdx -= u/v * dx;
+          cdy -= u/v * dy;
+        }
+    }
+
+    berr = bdx * bdx + bdy * bdy;
+    cerr = cdx * cdx + cdy * cdy;
+    if (berr > cerr)
+      return berr;
+    else
+      return cerr;
+}
+#endif
+
+/* taken from Skia, including the very descriptive name */
+static gboolean
+gsk_spline_cubic_too_curvy (const graphene_point_t pts[4],
+                            float                  tolerance)
+{
+  graphene_point_t p;
+
+  graphene_point_interpolate (&pts[0], &pts[3], 1.0f / 3, &p);
+  if (ABS (p.x - pts[1].x) + ABS (p.y - pts[1].y)  > tolerance)
+    return TRUE;
+
+  graphene_point_interpolate (&pts[0], &pts[3], 2.0f / 3, &p);
+  if (ABS (p.x - pts[2].x) + ABS (p.y - pts[2].y)  > tolerance)
+    return TRUE;
+
+  return FALSE;
+}
+
+static void
+gsk_spline_decompose_into (GskCubicDecomposition  *decomp,
+                           const graphene_point_t  pts[4],
+                           float                   progress)
+{
+  graphene_point_t left[4], right[4];
+
+  if (!gsk_spline_cubic_too_curvy (pts, decomp->tolerance) || progress < 1 / 1024.f)
+    {
+      gsk_spline_decompose_add_point (decomp, &pts[3], progress);
+      return;
+    }
+
+  gsk_spline_split_cubic (pts, left, right, 0.5);
+
+  gsk_spline_decompose_into (decomp, left, progress / 2);
+  gsk_spline_decompose_into (decomp, right, progress / 2);
+}
+
+void 
+gsk_spline_decompose_cubic (const graphene_point_t pts[4],
+                            float                  tolerance,
+                            GskSplineAddPointFunc  add_point_func,
+                            gpointer               user_data)
+{
+  GskCubicDecomposition decomp = { pts[0], 0.0f, tolerance, add_point_func, user_data };
+
+  gsk_spline_decompose_into (&decomp, pts, 1.0f);
+
+  g_assert (graphene_point_equal (&decomp.last_point, &pts[3]));
+  g_assert (decomp.last_progress == 1.0f || decomp.last_progress == 0.0f);
+}
+
 /* Spline deviation from the circle in radius would be given by:
 
         error = sqrt (x**2 + y**2) - 1

gsk/gsksplineprivate.h

@@ -25,6 +25,25 @@
 
 G_BEGIN_DECLS
 
+typedef void (* GskSplineAddPointFunc) (const graphene_point_t *from,
+                                        const graphene_point_t *to,
+                                        float                   from_progress,
+                                        float                   to_progress,
+                                        gpointer                user_data);
+
+void                    gsk_spline_get_point_cubic              (const graphene_point_t  pts[4],
+                                                                 float                   progress,
+                                                                 graphene_point_t       *pos,
+                                                                 graphene_vec2_t        *tangent);
+void                    gsk_spline_split_cubic                  (const graphene_point_t  pts[4],
+                                                                 graphene_point_t        result1[4],
+                                                                 graphene_point_t        result2[4],
+                                                                 float                   progress);
+void                    gsk_spline_decompose_cubic              (const graphene_point_t  pts[4],
+                                                                 float                   tolerance,
+                                                                 GskSplineAddPointFunc   add_point_func,
+                                                                 gpointer                user_data);
+
 typedef gboolean (* GskSplineAddCurveFunc) (const graphene_point_t curve[4],
                                             gpointer               user_data);
 gboolean                gsk_spline_decompose_arc                (const graphene_point_t *center,

gsk/gskstroke.c

@@ -0,0 +1,441 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#include "config.h"
+
+#include "gskstrokeprivate.h"
+
+/**
+ * SECTION:gskstroke
+ * @Title: Stroke
+ * @Short_description: Properties of a stroke operation
+ * @See_also: #GskPath, gsk_stroke_node_new()
+ *
+ * This section describes the #GskStroke structure that is used to
+ * describe lines and curves that are more complex than simple rectangles.
+ *
+ * #GskStroke is an immutable struct. After creation, you cannot change
+ * the types it represents. Instead, new #GskStroke have to be created.
+ * The #GskStrokeBuilder structure is meant to help in this endeavor.
+ */
+
+/**
+ * GskStroke:
+ *
+ * A #GskStroke struct is an opaque struct that should be copied
+ * on use.
+ */
+
+G_DEFINE_BOXED_TYPE (GskStroke, gsk_stroke,
+                     gsk_stroke_copy,
+                     gsk_stroke_free)
+
+
+/**
+ * gsk_stroke_new:
+ * @line_width: line width of the stroke. Must be > 0
+ *
+ * Creates a new #GskStroke with the given @line_width.
+ *
+ * Returns: a new #GskStroke
+ **/
+GskStroke *
+gsk_stroke_new (float line_width)
+{
+  GskStroke *self;
+
+  g_return_val_if_fail (line_width > 0, NULL);
+
+  self = g_new0 (GskStroke, 1);
+
+  self->line_width = line_width;
+  self->line_cap = GSK_LINE_CAP_BUTT;
+  self->line_join = GSK_LINE_JOIN_MITER;
+  self->miter_limit = 4.f; /* following svg */
+
+  return self;
+}
+
+/**
+ * gsk_stroke_copy:
+ * @other: #GskStroke to copy
+ *
+ * Creates a copy of the given @other stroke.
+ *
+ * Returns: a new #GskStroke. Use gsk_stroke_free() to free it.
+ **/
+GskStroke *
+gsk_stroke_copy (const GskStroke *other)
+{
+  GskStroke *self;
+
+  g_return_val_if_fail (other != NULL, NULL);
+
+  self = g_new (GskStroke, 1);
+
+  gsk_stroke_init_copy (self, other);
+
+  return self;
+}
+
+/**
+ * gsk_stroke_free:
+ * @self: a #GskStroke
+ *
+ * Frees a #GskStroke.
+ **/
+void
+gsk_stroke_free (GskStroke *self)
+{
+  if (self == NULL)
+    return;
+
+  gsk_stroke_clear (self);
+
+  g_free (self);
+}
+
+void
+gsk_stroke_to_cairo (const GskStroke *self,
+                     cairo_t         *cr)
+{
+  cairo_set_line_width (cr, self->line_width);
+
+  /* gcc can optimize that to a direct case. This catches later additions to the enum */
+  switch (self->line_cap)
+    {
+      case GSK_LINE_CAP_BUTT:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_BUTT);
+        break;
+      case GSK_LINE_CAP_ROUND:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+        break;
+      case GSK_LINE_CAP_SQUARE:
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
+        break;
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  /* gcc can optimize that to a direct case. This catches later additions to the enum */
+  switch (self->line_join)
+    {
+      case GSK_LINE_JOIN_MITER:
+      case GSK_LINE_JOIN_MITER_CLIP:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
+        break;
+      case GSK_LINE_JOIN_ROUND:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+        break;
+      case GSK_LINE_JOIN_BEVEL:
+        cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL);
+        break;
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  cairo_set_miter_limit (cr, self->miter_limit);
+
+  if (self->dash_length)
+    {
+      gsize i;
+      double *dash = g_newa (double, self->n_dash);
+
+      for (i = 0; i < self->n_dash; i++)
+        {
+          dash[i] = self->dash[i];
+        }
+      cairo_set_dash (cr, dash, self->n_dash, self->dash_offset);
+    }
+  else
+    cairo_set_dash (cr, NULL, 0, 0.0);
+}
+
+/**
+ * gsk_stroke_equal:
+ * @stroke1: the first #GskStroke
+ * @stroke2: the second #GskStroke
+ *
+ * Checks if 2 strokes are identical.
+ *
+ * Returns: %TRUE if the 2 strokes are equal, %FALSE otherwise
+ **/
+gboolean
+gsk_stroke_equal (gconstpointer stroke1,
+                  gconstpointer stroke2)
+{
+  const GskStroke *self1 = stroke1;
+  const GskStroke *self2 = stroke2;
+
+  return self1->line_width == self2->line_width;
+}
+
+/**
+ * gsk_stroke_set_line_width:
+ * @self: a #GskStroke
+ * @line_width: width of the line in pixels
+ *
+ * Sets the line width to be used when stroking. The line width
+ * must be > 0.
+ **/
+void
+gsk_stroke_set_line_width (GskStroke *self,
+                           float      line_width)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (line_width > 0);
+
+  self->line_width = line_width;
+}
+
+/**
+ * gsk_stroke_get_line_width:
+ * @self: a #GskStroke
+ *
+ * Gets the line width used.
+ *
+ * Returns: The line width
+ **/
+float
+gsk_stroke_get_line_width (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_width;
+}
+
+/**
+ * gsk_stroke_set_line_cap:
+ * @self: a #GskStroke
+ * @line_cap: the #GskLineCap
+ *
+ * Sets the line cap to be used when stroking.
+ * See #GskLineCap for details.
+ **/
+void
+gsk_stroke_set_line_cap (GskStroke  *self,
+                         GskLineCap  line_cap)
+{
+  g_return_if_fail (self != NULL);
+
+  self->line_cap = line_cap;
+}
+
+/**
+ * gsk_stroke_get_line_cap:
+ * @self: a #GskStroke
+ *
+ * Gets the line cap used. See #GskLineCap for details.
+ *
+ * Returns: The line cap
+ **/
+GskLineCap
+gsk_stroke_get_line_cap (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_cap;
+}
+
+/**
+ * gsk_stroke_set_line_join:
+ * @self: a #GskStroke
+ * @line_join: The line join to use
+ *
+ * Sets the line join to be used when stroking.
+ * See #GskLineJoin for details.
+ **/
+void
+gsk_stroke_set_line_join (GskStroke   *self,
+                          GskLineJoin  line_join)
+{
+  g_return_if_fail (self != NULL);
+
+  self->line_join = line_join;
+}
+
+/**
+ * gsk_stroke_get_line_join:
+ * @self: a #GskStroke
+ *
+ * Gets the line join used. See #GskLineJoin for details.
+ *
+ * Returns: The line join
+ **/
+GskLineJoin
+gsk_stroke_get_line_join (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 0.0);
+
+  return self->line_join;
+}
+
+/**
+ * gsk_stroke_set_miter_limit:
+ * @self: a #GskStroke
+ * @limit: the miter limit, must be non-negative
+ *
+ * Sets the limit for the distance from the corner where sharp
+ * turns of joins get cut off. The miter limit is in units of
+ * line width.
+ *
+ * For joins of type %GSK_LINE_JOIN_MITER that exceed the miter
+ * limit, the join gets rendered as if it was of type
+ * %GSK_LINE_JOIN_BEVEL. For joins of type %GSK_LINE_JOIN_MITER_CLIP,
+ * the miter is clipped at a distance of half the miter limit.
+ */
+void
+gsk_stroke_set_miter_limit (GskStroke  *self,
+                            float       limit)
+{
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (limit >= 0);
+
+  self->miter_limit = limit;
+}
+
+/**
+ * gsk_stroke_get_miter_limit:
+ * @self: a #GskStroke
+ *
+ * Returns the miter limit of a #GskStroke.
+ */
+float
+gsk_stroke_get_miter_limit (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 4.f);
+
+  return self->miter_limit;
+}
+
+/**
+ * gsk_stroke_set_dash:
+ * @self: a #GskStroke
+ * @dash: (array length=n_dash) (transfer none) (nullable):
+ *     the array of dashes 
+ * @n_dash: number of elements in @dash
+ *
+ * Sets the dash pattern to use by this stroke. A dash pattern is specified by
+ * an array of alternating non-negative values. Each value provides the length
+ * of alternate "on" and "off" portions of the stroke.  
+ * 
+ * Each "on" segment will have caps applied as if the segment were a separate
+ * contour. In particular, it is valid to use an "on" length of 0 with
+ * @GSK_LINE_CAP_ROUND or @GSK_LINE_CAP_SQUARE to draw dots or squares along
+ * a path.
+ *
+ * If @n_dash is 0, if all elements in @dash are 0, or if there are negative
+ * values in @dash, then dashing is disabled.
+ *
+ * If @n_dash is 1, an alternating "on" and "off" pattern with the single
+ * dash length provided is assumed.
+ *
+ * If @n_dash is uneven, the dash array will be used with the first element
+ * in @dash defining an "on" or "off" in alternating passes through the array.
+ *
+ * You can specify a starting offset into the dash with
+ * @gsk_stroke_set_dash_offset().
+ **/
+void
+gsk_stroke_set_dash (GskStroke   *self,
+                     const float *dash,
+                     gsize        n_dash)
+{
+  float dash_length;
+  gsize i;
+
+  g_return_if_fail (self != NULL);
+  g_return_if_fail (dash != NULL || n_dash == 0);
+
+  dash_length = 0;
+  for (i = 0; i < n_dash; i++)
+    {
+      if (!(dash[i] >= 0)) /* should catch NaN */
+        {
+          g_critical ("invalid value in dash array at position %zu", i);
+          return;
+        }
+      dash_length += dash[i];
+    }
+
+  self->dash_length = dash_length;
+  g_free (self->dash);
+  self->dash = g_memdup (dash, sizeof (gfloat) * n_dash);
+  self->n_dash = n_dash;
+
+}
+
+/**
+ * gsk_stroke_get_dash:
+ * @self: a #GskStroke
+ * @n_dash: (out caller-allocates): number of elements
+ *     in the array returned
+ *
+ * Gets the dash array in use or %NULL if dashing is disabled.
+ *
+ * Returns: (array length=n_dash) (transfer none) (nullable):
+ *     The dash array or %NULL if the dash array is empty.
+ **/
+const float *
+gsk_stroke_get_dash (const GskStroke *self,
+                     gsize           *n_dash)
+{
+  g_return_val_if_fail (self != NULL, NULL);
+  g_return_val_if_fail (n_dash != NULL, NULL);
+
+  *n_dash = self->n_dash;
+
+  return self->dash;
+}
+
+/**
+ * gsk_stroke_set_dash_offset:
+ * @self: a #GskStroke
+ * @offset: offset into the dash pattern
+ *
+ * Sets the offset into the dash pattern set via gsk_stroke_set_dash() where
+ * dashing should begin.
+ *
+ * This is an offset into the length of the path, not an index into the array values of
+ * the dash array.
+ **/
+void
+gsk_stroke_set_dash_offset (GskStroke *self,
+                            float      offset)
+{
+  g_return_if_fail (self != NULL);
+
+  self->dash_offset = offset;
+}
+
+/**
+ * gsk_stroke_get_dash_offset:
+ * @self: a #GskStroke
+ *
+ * Returns the dash_offset of a #GskStroke.
+ */
+float
+gsk_stroke_get_dash_offset (const GskStroke *self)
+{
+  g_return_val_if_fail (self != NULL, 4.f);
+
+  return self->dash_offset;
+}

gsk/gskstroke.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#ifndef __GSK_STROKE_H__
+#define __GSK_STROKE_H__
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_STROKE (gsk_stroke_get_type ())
+
+GDK_AVAILABLE_IN_ALL
+GType                   gsk_stroke_get_type                     (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskStroke *             gsk_stroke_new                          (float                   line_width);
+GDK_AVAILABLE_IN_ALL
+GskStroke *             gsk_stroke_copy                         (const GskStroke        *other);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_free                         (GskStroke              *self);
+
+GDK_AVAILABLE_IN_ALL
+gboolean                gsk_stroke_equal                        (gconstpointer           stroke1,
+                                                                 gconstpointer           stroke2);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_line_width               (GskStroke              *self,
+                                                                 float                   line_width);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_stroke_get_line_width               (const GskStroke        *self);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_line_cap                 (GskStroke              *self,
+                                                                 GskLineCap              line_cap);
+GDK_AVAILABLE_IN_ALL
+GskLineCap              gsk_stroke_get_line_cap                 (const GskStroke        *self);
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_line_join                (GskStroke              *self,
+                                                                 GskLineJoin             line_join);
+GDK_AVAILABLE_IN_ALL
+GskLineJoin             gsk_stroke_get_line_join                (const GskStroke        *self);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_miter_limit              (GskStroke              *self,
+                                                                 float                   limit);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_stroke_get_miter_limit              (const GskStroke        *self);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_dash                     (GskStroke              *self,
+                                                                 const float            *dash,
+                                                                 gsize                   n_dash);
+GDK_AVAILABLE_IN_ALL
+const float *           gsk_stroke_get_dash                     (const GskStroke        *self,
+                                                                 gsize                  *n_dash);
+
+GDK_AVAILABLE_IN_ALL
+void                    gsk_stroke_set_dash_offset              (GskStroke              *self,
+                                                                 float                   offset);
+GDK_AVAILABLE_IN_ALL
+float                   gsk_stroke_get_dash_offset              (const GskStroke        *self);
+
+
+
+G_END_DECLS
+
+#endif /* __GSK_STROKE_H__ */

gsk/gskstrokeprivate.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2020 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+
+#ifndef __GSK_STROKE_PRIVATE_H__
+#define __GSK_STROKE_PRIVATE_H__
+
+#include "gskstroke.h"
+
+G_BEGIN_DECLS
+
+struct _GskStroke
+{
+  float line_width;
+  GskLineCap line_cap;
+  GskLineJoin line_join;
+  float miter_limit;
+
+  float *dash;
+  gsize n_dash;
+  float dash_length; /* sum of all dashes in the array */
+  float dash_offset;
+};
+
+static inline void
+gsk_stroke_init_copy (GskStroke       *stroke,
+                      const GskStroke *other)
+{
+  *stroke = *other;
+
+  stroke->dash = g_memdup (other->dash, stroke->n_dash * sizeof (float));
+}
+
+static inline void
+gsk_stroke_clear (GskStroke *stroke)
+{
+  g_clear_pointer (&stroke->dash, g_free);
+  stroke->n_dash = 0; /* better safe than sorry */
+}
+
+void                    gsk_stroke_to_cairo                     (const GskStroke        *self,
+                                                                 cairo_t                *cr);
+
+G_END_DECLS
+
+#endif /* __GSK_STROKE_PRIVATE_H__ */
+

gsk/gsktypes.h

@@ -28,7 +28,7 @@
 typedef struct _GskPath                 GskPath;
 typedef struct _GskPathBuilder          GskPathBuilder;
 typedef struct _GskPathMeasure          GskPathMeasure;
-typedef struct _GskPathPoint            GskPathPoint;
 typedef struct _GskRenderer             GskRenderer;
+typedef struct _GskStroke               GskStroke;
 typedef struct _GskTransform            GskTransform;
 

gsk/meson.build

@@ -20,35 +20,28 @@ gsk_private_gl_shaders = [
   'gl/resources/custom.glsl',
   'gl/resources/filled_border.glsl',
   'gl/resources/mask.glsl',
-  'gl/resources/glyphy.atlas.glsl',
-  'gl/resources/glyphy.fs.glsl',
-  'gl/resources/glyphy.vs.glsl',
 ]
 
 gsk_public_sources = files([
-  'gskcairorenderer.c',
   'gskdiff.c',
+  'gskcairorenderer.c',
   'gskglshader.c',
+  'gskpath.c',
+  'gskpathbuilder.c',
+  'gskpathmeasure.c',
   'gskrenderer.c',
   'gskrendernode.c',
   'gskrendernodeimpl.c',
   'gskrendernodeparser.c',
   'gskroundedrect.c',
+  'gskstroke.c',
   'gsktransform.c',
   'gl/gskglrenderer.c',
 ])
 
 gsk_private_sources = files([
   'gskcairoblur.c',
-  'gskcontour.c',
-  'gskcurve.c',
-  'gskcurveintersect.c',
   'gskdebug.c',
-  'gskpath.c',
-  'gskpathbuilder.c',
-  'gskpathmeasure.c',
-  'gskpathops.c',
-  'gskpathpoint.c',
   'gskprivate.c',
   'gskprofiler.c',
   'gskspline.c',
@@ -58,7 +51,6 @@ gsk_private_sources = files([
   'gl/gskglcompiler.c',
   'gl/gskgldriver.c',
   'gl/gskglglyphlibrary.c',
-  'gl/gskglglyphylibrary.c',
   'gl/gskgliconlibrary.c',
   'gl/gskglprogram.c',
   'gl/gskglrenderjob.c',
@@ -79,9 +71,13 @@ gsk_public_headers = files([
   'gskcairorenderer.h',
   'gskenums.h',
   'gskglshader.h',
+  'gskpath.h',
+  'gskpathbuilder.h',
+  'gskpathmeasure.h',
   'gskrenderer.h',
   'gskrendernode.h',
   'gskroundedrect.h',
+  'gskstroke.h',
   'gsktransform.h',
   'gsktypes.h',
 ])
@@ -120,35 +116,29 @@ gsk_private_vulkan_shader_headers = []
 
 if have_vulkan
   gsk_private_sources += files([
-    'vulkan/gskvulkanblendmodeop.c',
-    'vulkan/gskvulkanblurop.c',
-    'vulkan/gskvulkanborderop.c',
+    'vulkan/gskvulkanblendmodepipeline.c',
+    'vulkan/gskvulkanblurpipeline.c',
+    'vulkan/gskvulkanborderpipeline.c',
+    'vulkan/gskvulkanboxshadowpipeline.c',
     'vulkan/gskvulkanbuffer.c',
-    'vulkan/gskvulkanclearop.c',
     'vulkan/gskvulkanclip.c',
-    'vulkan/gskvulkancolormatrixop.c',
-    'vulkan/gskvulkancolorop.c',
+    'vulkan/gskvulkancolorpipeline.c',
+    'vulkan/gskvulkancolortextpipeline.c',
+    'vulkan/gskvulkancrossfadepipeline.c',
     'vulkan/gskvulkancommandpool.c',
-    'vulkan/gskvulkancrossfadeop.c',
-    'vulkan/gskvulkandownloadop.c',
+    'vulkan/gskvulkaneffectpipeline.c',
     'vulkan/gskvulkanglyphcache.c',
-    'vulkan/gskvulkanglyphop.c',
+    'vulkan/gskvulkanlineargradientpipeline.c',
     'vulkan/gskvulkanimage.c',
-    'vulkan/gskvulkaninsetshadowop.c',
-    'vulkan/gskvulkanlineargradientop.c',
-    'vulkan/gskvulkanmaskop.c',
+    'vulkan/gskvulkantextpipeline.c',
+    'vulkan/gskvulkantexturepipeline.c',
     'vulkan/gskvulkanmemory.c',
-    'vulkan/gskvulkanop.c',
-    'vulkan/gskvulkanoutsetshadowop.c',
-    'vulkan/gskvulkanpushconstantsop.c',
+    'vulkan/gskvulkanpipeline.c',
+    'vulkan/gskvulkanpushconstants.c',
     'vulkan/gskvulkanrender.c',
     'vulkan/gskvulkanrenderer.c',
     'vulkan/gskvulkanrenderpass.c',
-    'vulkan/gskvulkanrenderpassop.c',
-    'vulkan/gskvulkanscissorop.c',
-    'vulkan/gskvulkanshaderop.c',
-    'vulkan/gskvulkantextureop.c',
-    'vulkan/gskvulkanuploadop.c',
+    'vulkan/gskvulkanshader.c',
   ])
 
   subdir('vulkan/resources')
@@ -198,7 +188,6 @@ gsk_deps = [
   cairo_csi_dep,
   pixbuf_dep,
   libgdk_dep,
-  libglyphy_dep
 ]
 
 libgsk_f16c = static_library('gsk_f16c',

gsk/vulkan/gskvulkanblendmodeop.c

@@ -1,119 +0,0 @@
-#include "config.h"
-
-#include "gskvulkanblendmodeopprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-
-#include "vulkan/resources/blend-mode.vert.h"
-
-typedef struct _GskVulkanBlendModeOp GskVulkanBlendModeOp;
-
-struct _GskVulkanBlendModeOp
-{
-  GskVulkanShaderOp op;
-
-  graphene_rect_t bounds;
-  GskBlendMode blend_mode;
-
-  struct {
-    graphene_rect_t rect;
-    graphene_rect_t tex_rect;
-    guint32 image_descriptor;
-  } top, bottom;
-};
-
-static void
-gsk_vulkan_blend_mode_op_print (GskVulkanOp *op,
-                                GString     *string,
-                                guint        indent)
-{
-  GskVulkanBlendModeOp *self = (GskVulkanBlendModeOp *) op;
-
-  print_indent (string, indent);
-  print_rect (string, &self->bounds);
-  g_string_append_printf (string, "blend-mode %d%% ", self->blend_mode);
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_blend_mode_op_collect_vertex_data (GskVulkanOp *op,
-                                              guchar      *data)
-{
-  GskVulkanBlendModeOp *self = (GskVulkanBlendModeOp *) op;
-  GskVulkanBlendModeInstance *instance = (GskVulkanBlendModeInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-
-  gsk_vulkan_rect_to_float (&self->bounds, instance->rect);
-  gsk_vulkan_rect_to_float (&self->top.rect, instance->top_rect);
-  gsk_vulkan_rect_to_float (&self->bottom.rect, instance->bottom_rect);
-  gsk_vulkan_rect_to_float (&self->top.tex_rect, instance->top_tex_rect);
-  gsk_vulkan_rect_to_float (&self->bottom.tex_rect, instance->bottom_tex_rect);
-
-  instance->top_tex_id = self->top.image_descriptor;
-  instance->bottom_tex_id = self->bottom.image_descriptor;
-  instance->blend_mode = self->blend_mode;
-}
-
-static void
-gsk_vulkan_blend_mode_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                                  GskVulkanRender *render)
-{
-  GskVulkanBlendModeOp *self = (GskVulkanBlendModeOp *) op;
-  GskVulkanShaderOp *shader = (GskVulkanShaderOp *) op;
-
-  self->top.image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                       shader->images[0],
-                                                                       GSK_VULKAN_SAMPLER_DEFAULT);
-  self->bottom.image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                          shader->images[1],
-                                                                          GSK_VULKAN_SAMPLER_DEFAULT);
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_BLEND_MODE_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanBlendModeOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_shader_op_finish,
-    gsk_vulkan_blend_mode_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_blend_mode_op_collect_vertex_data,
-    gsk_vulkan_blend_mode_op_reserve_descriptor_sets,
-    gsk_vulkan_shader_op_command
-  },
-  "blend-mode",
-  2,
-  &gsk_vulkan_blend_mode_info,
-};
-
-void
-gsk_vulkan_blend_mode_op (GskVulkanRender        *render,
-                          GskVulkanShaderClip     clip,
-                          const graphene_rect_t  *bounds,
-                          const graphene_point_t *offset,
-                          GskBlendMode            blend_mode,
-                          GskVulkanImage         *top_image,
-                          const graphene_rect_t  *top_rect,
-                          const graphene_rect_t  *top_tex_rect,
-                          GskVulkanImage         *bottom_image,
-                          const graphene_rect_t  *bottom_rect,
-                          const graphene_rect_t  *bottom_tex_rect)
-{
-  GskVulkanBlendModeOp *self;
-
-  self = (GskVulkanBlendModeOp *) gsk_vulkan_shader_op_alloc (render,
-                                                              &GSK_VULKAN_BLEND_MODE_OP_CLASS,
-                                                              clip,
-                                                              (GskVulkanImage *[2]) {
-                                                                  top_image,
-                                                                  bottom_image
-                                                              });
-
-  graphene_rect_offset_r (bounds, offset->x, offset->y, &self->bounds);
-  self->blend_mode = blend_mode;
-
-  graphene_rect_offset_r (top_rect, offset->x, offset->y, &self->top.rect);
-  gsk_vulkan_normalize_tex_coords (&self->top.tex_rect, bounds, top_tex_rect);
-
-  graphene_rect_offset_r (bottom_rect, offset->x, offset->y, &self->bottom.rect);
-  gsk_vulkan_normalize_tex_coords (&self->bottom.tex_rect, bounds, bottom_tex_rect);
-}

gsk/vulkan/gskvulkanblendmodeopprivate.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_blend_mode_op                        (GskVulkanRender                *render,
-                                                                         GskVulkanShaderClip             clip,
-                                                                         const graphene_rect_t          *bounds,
-                                                                         const graphene_point_t         *offset,
-                                                                         GskBlendMode                    blend_mode,
-                                                                         GskVulkanImage                 *top_image,
-                                                                         const graphene_rect_t          *top_rect,
-                                                                         const graphene_rect_t          *top_tex_rect,
-                                                                         GskVulkanImage                 *bottom_image,
-                                                                         const graphene_rect_t          *bottom_rect,
-                                                                         const graphene_rect_t          *bottom_tex_rect);
-
-
-G_END_DECLS
-

gsk/vulkan/gskvulkanblendmodepipeline.c

@@ -0,0 +1,112 @@
+#include "config.h"
+
+#include "gskvulkanblendmodepipelineprivate.h"
+
+#include "vulkan/resources/blend-mode.vert.h"
+
+struct _GskVulkanBlendModePipeline
+{
+  GObject parent_instance;
+};
+
+typedef struct _GskVulkanBlendModeInstance GskVulkanBlendModeInstance;
+
+G_DEFINE_TYPE (GskVulkanBlendModePipeline, gsk_vulkan_blend_mode_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_blend_mode_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_blend_mode_info;
+}
+
+static void
+gsk_vulkan_blend_mode_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanBlendModePipeline *self = GSK_VULKAN_BLUR_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_blend_mode_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_blend_mode_pipeline_class_init (GskVulkanBlendModePipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_blend_mode_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_blend_mode_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_blend_mode_pipeline_init (GskVulkanBlendModePipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_blend_mode_pipeline_new (GdkVulkanContext        *context,
+                                    VkPipelineLayout         layout,
+                                    const char              *shader_name,
+                                    VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_BLEND_MODE_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_blend_mode_pipeline_collect_vertex_data (GskVulkanBlendModePipeline *pipeline,
+                                                    guchar                     *data,
+                                                    guint32                     top_tex_id[2],
+                                                    guint32                     bottom_tex_id[2],
+                                                    const graphene_point_t     *offset,
+                                                    const graphene_rect_t      *bounds,
+                                                    const graphene_rect_t      *top_bounds,
+                                                    const graphene_rect_t      *bottom_bounds,
+                                                    const graphene_rect_t      *top_tex_rect,
+                                                    const graphene_rect_t      *bottom_tex_rect,
+                                                    GskBlendMode                blend_mode)
+{
+  GskVulkanBlendModeInstance *instance = (GskVulkanBlendModeInstance *) data;
+
+  instance->rect[0] = bounds->origin.x + offset->x;
+  instance->rect[1] = bounds->origin.y + offset->y;
+  instance->rect[2] = bounds->size.width;
+  instance->rect[3] = bounds->size.height;
+
+  instance->top_rect[0] = top_bounds->origin.x + offset->x;
+  instance->top_rect[1] = top_bounds->origin.y + offset->y;
+  instance->top_rect[2] = top_bounds->size.width;
+  instance->top_rect[3] = top_bounds->size.height;
+
+  instance->bottom_rect[0] = bottom_bounds->origin.x + offset->x;
+  instance->bottom_rect[1] = bottom_bounds->origin.y + offset->y;
+  instance->bottom_rect[2] = bottom_bounds->size.width;
+  instance->bottom_rect[3] = bottom_bounds->size.height;
+
+  instance->top_tex_rect[0] = top_tex_rect->origin.x;
+  instance->top_tex_rect[1] = top_tex_rect->origin.y;
+  instance->top_tex_rect[2] = top_tex_rect->size.width;
+  instance->top_tex_rect[3] = top_tex_rect->size.height;
+
+  instance->bottom_tex_rect[0] = bottom_tex_rect->origin.x;
+  instance->bottom_tex_rect[1] = bottom_tex_rect->origin.y;
+  instance->bottom_tex_rect[2] = bottom_tex_rect->size.width;
+  instance->bottom_tex_rect[3] = bottom_tex_rect->size.height;
+
+  instance->top_tex_id[0] = top_tex_id[0];
+  instance->top_tex_id[1] = top_tex_id[1];
+  instance->bottom_tex_id[0] = bottom_tex_id[0];
+  instance->bottom_tex_id[1] = bottom_tex_id[1];
+  instance->blend_mode = blend_mode;
+}
+
+gsize
+gsk_vulkan_blend_mode_pipeline_draw (GskVulkanBlendModePipeline *pipeline,
+                                     VkCommandBuffer        command_buffer,
+                                     gsize                  offset,
+                                     gsize                  n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkanblendmodepipelineprivate.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+#include "gskenums.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanBlendModePipelineLayout GskVulkanBlendModePipelineLayout;
+
+#define GSK_TYPE_VULKAN_BLEND_MODE_PIPELINE (gsk_vulkan_blend_mode_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanBlendModePipeline, gsk_vulkan_blend_mode_pipeline, GSK, VULKAN_BLEND_MODE_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline * gsk_vulkan_blend_mode_pipeline_new                 (GdkVulkanContext           *context,
+                                                                        VkPipelineLayout            layout,
+                                                                        const char                 *shader_name,
+                                                                        VkRenderPass                render_pass);
+
+void                gsk_vulkan_blend_mode_pipeline_collect_vertex_data (GskVulkanBlendModePipeline *pipeline,
+                                                                        guchar                     *data,
+                                                                        guint32                     top_tex_id[2],
+                                                                        guint32                     bottom_tex_id[2],
+                                                                        const graphene_point_t     *offset,
+                                                                        const graphene_rect_t      *bounds,
+                                                                        const graphene_rect_t      *top_bounds,
+                                                                        const graphene_rect_t      *bottom_bounds,
+                                                                        const graphene_rect_t      *top_tex_rect,
+                                                                        const graphene_rect_t      *bottom_tex_rect,
+                                                                        GskBlendMode                blend_mode);
+gsize               gsk_vulkan_blend_mode_pipeline_draw                (GskVulkanBlendModePipeline *pipeline,
+                                                                        VkCommandBuffer             command_buffer,
+                                                                        gsize                       offset,
+                                                                        gsize                       n_commands);
+
+
+G_END_DECLS
+

gsk/vulkan/gskvulkanblurop.c

@@ -1,97 +0,0 @@
-#include "config.h"
-
-#include "gskvulkanbluropprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-
-#include "vulkan/resources/blur.vert.h"
-
-typedef struct _GskVulkanBlurOp GskVulkanBlurOp;
-
-struct _GskVulkanBlurOp
-{
-  GskVulkanShaderOp op;
-
-  graphene_rect_t rect;
-  graphene_rect_t tex_rect;
-  float radius;
-
-  guint32 image_descriptor;
-};
-
-static void
-gsk_vulkan_blur_op_print (GskVulkanOp *op,
-                          GString     *string,
-                          guint        indent)
-{
-  GskVulkanBlurOp *self = (GskVulkanBlurOp *) op;
-
-  print_indent (string, indent);
-  print_rect (string, &self->rect);
-  g_string_append_printf (string, "blur %g",
-                          self->radius);
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_blur_op_collect_vertex_data (GskVulkanOp *op,
-                                        guchar      *data)
-{
-  GskVulkanBlurOp *self = (GskVulkanBlurOp *) op;
-  GskVulkanBlurInstance *instance = (GskVulkanBlurInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-
-  gsk_vulkan_rect_to_float (&self->rect, instance->rect);
-  gsk_vulkan_rect_to_float (&self->tex_rect, instance->tex_rect);
-  instance->tex_id = self->image_descriptor;
-  instance->radius = self->radius;
-}
-
-static void
-gsk_vulkan_blur_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                            GskVulkanRender *render)
-{
-  GskVulkanBlurOp *self = (GskVulkanBlurOp *) op;
-  GskVulkanShaderOp *shader = (GskVulkanShaderOp *) op;
-
-  self->image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                   shader->images[0],
-                                                                   GSK_VULKAN_SAMPLER_DEFAULT);
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_BLUR_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanBlurOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_shader_op_finish,
-    gsk_vulkan_blur_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_blur_op_collect_vertex_data,
-    gsk_vulkan_blur_op_reserve_descriptor_sets,
-    gsk_vulkan_shader_op_command
-  },
-  "blur",
-  1,
-  &gsk_vulkan_blur_info,
-};
-
-void
-gsk_vulkan_blur_op (GskVulkanRender         *render,
-                    GskVulkanShaderClip      clip,
-                    GskVulkanImage          *image,
-                    const graphene_rect_t   *rect,
-                    const graphene_point_t  *offset,
-                    const graphene_rect_t   *tex_rect,
-                    float                    radius)
-{
-  GskVulkanBlurOp *self;
-
-  g_assert (radius > 0);
-
-  self = (GskVulkanBlurOp *) gsk_vulkan_shader_op_alloc (render, &GSK_VULKAN_BLUR_OP_CLASS, clip, &image);
-
-  graphene_rect_offset_r (rect, offset->x, offset->y, &self->rect);
-  gsk_vulkan_normalize_tex_coords (&self->tex_rect, rect, tex_rect);
-  self->radius = radius;
-}
-

gsk/vulkan/gskvulkanbluropprivate.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_blur_op                              (GskVulkanRender                *render,
-                                                                         GskVulkanShaderClip             clip,
-                                                                         GskVulkanImage                 *image,
-                                                                         const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
-                                                                         const graphene_rect_t          *tex_rect,
-                                                                         float                           radius);
-
-G_END_DECLS
-

gsk/vulkan/gskvulkanblurpipeline.c

@@ -0,0 +1,87 @@
+#include "config.h"
+
+#include "gskvulkanblurpipelineprivate.h"
+
+#include "vulkan/resources/blur.vert.h"
+
+struct _GskVulkanBlurPipeline
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (GskVulkanBlurPipeline, gsk_vulkan_blur_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_blur_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_blur_info;
+}
+
+static void
+gsk_vulkan_blur_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanBlurPipeline *self = GSK_VULKAN_BLUR_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_blur_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_blur_pipeline_class_init (GskVulkanBlurPipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_blur_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_blur_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_blur_pipeline_init (GskVulkanBlurPipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_blur_pipeline_new (GdkVulkanContext        *context,
+                              VkPipelineLayout         layout,
+                              const char              *shader_name,
+                              VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_BLUR_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_blur_pipeline_collect_vertex_data (GskVulkanBlurPipeline  *pipeline,
+                                              guchar                 *data,
+                                              guint32                 tex_id[2],
+                                              const graphene_point_t *offset,
+                                              const graphene_rect_t  *rect,
+                                              const graphene_rect_t  *tex_rect,
+                                              double                  radius)
+{
+  GskVulkanBlurInstance *instance = (GskVulkanBlurInstance *) data;
+
+  instance->rect[0] = rect->origin.x + offset->x;
+  instance->rect[1] = rect->origin.y + offset->y;
+  instance->rect[2] = rect->size.width;
+  instance->rect[3] = rect->size.height;
+  instance->tex_rect[0] = tex_rect->origin.x;
+  instance->tex_rect[1] = tex_rect->origin.y;
+  instance->tex_rect[2] = tex_rect->size.width;
+  instance->tex_rect[3] = tex_rect->size.height;
+  instance->radius = radius;
+  instance->tex_id[0] = tex_id[0];
+  instance->tex_id[1] = tex_id[1];
+}
+
+gsize
+gsk_vulkan_blur_pipeline_draw (GskVulkanBlurPipeline *pipeline,
+                               VkCommandBuffer        command_buffer,
+                               gsize                  offset,
+                               gsize                  n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkanblurpipelineprivate.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanBlurPipelineLayout GskVulkanBlurPipelineLayout;
+
+#define GSK_TYPE_VULKAN_BLUR_PIPELINE (gsk_vulkan_blur_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanBlurPipeline, gsk_vulkan_blur_pipeline, GSK, VULKAN_BLUR_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline *     gsk_vulkan_blur_pipeline_new                   (GdkVulkanContext        *context,
+                                                                        VkPipelineLayout         layout,
+                                                                        const char              *shader_name,
+                                                                        VkRenderPass             render_pass);
+
+void                    gsk_vulkan_blur_pipeline_collect_vertex_data   (GskVulkanBlurPipeline   *pipeline,
+                                                                        guchar                  *data,
+                                                                        guint32                  tex_id[2],
+                                                                        const graphene_point_t  *offset,
+                                                                        const graphene_rect_t   *rect,
+                                                                        const graphene_rect_t   *tex_rect,
+                                                                        double                   radius);
+gsize                   gsk_vulkan_blur_pipeline_draw                  (GskVulkanBlurPipeline   *pipeline,
+                                                                        VkCommandBuffer          command_buffer,
+                                                                        gsize                    offset,
+                                                                        gsize                    n_commands);
+
+G_END_DECLS
+

gsk/vulkan/gskvulkanborderop.c

@@ -1,123 +0,0 @@
-#include "config.h"
-
-#include "gskvulkanborderopprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-#include "gsk/gskroundedrectprivate.h"
-
-#include "vulkan/resources/border.vert.h"
-
-typedef struct _GskVulkanBorderOp GskVulkanBorderOp;
-
-struct _GskVulkanBorderOp
-{
-  GskVulkanShaderOp op;
-
-  GskRoundedRect outline;
-  float widths[4];
-  GdkRGBA colors[4];
-};
-
-static void
-gsk_vulkan_border_op_finish (GskVulkanOp *op)
-{
-}
-
-static void
-gsk_vulkan_border_op_print (GskVulkanOp *op,
-                            GString     *string,
-                            guint        indent)
-{
-  GskVulkanBorderOp *self = (GskVulkanBorderOp *) op;
-
-  print_indent (string, indent);
-  print_rounded_rect (string, &self->outline);
-  g_string_append (string, "border ");
-  print_rgba (string, &self->colors[0]);
-  if (!gdk_rgba_equal (&self->colors[3], &self->colors[0]) ||
-      !gdk_rgba_equal (&self->colors[2], &self->colors[0]) ||
-      !gdk_rgba_equal (&self->colors[1], &self->colors[0]))
-    {
-      print_rgba (string, &self->colors[1]);
-      print_rgba (string, &self->colors[2]);
-      print_rgba (string, &self->colors[3]);
-    }
-  g_string_append_printf (string, "%g ", self->widths[0]);
-  if (self->widths[0] != self->widths[1] ||
-      self->widths[0] != self->widths[2] ||
-      self->widths[0] != self->widths[3])
-    g_string_append_printf (string, "%g %g %g ", self->widths[1], self->widths[2], self->widths[3]);
-
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_border_op_collect_vertex_data (GskVulkanOp *op,
-                                          guchar      *data)
-{
-  GskVulkanBorderOp *self = (GskVulkanBorderOp *) op;
-  GskVulkanBorderInstance *instance = (GskVulkanBorderInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-  guint i;
-
-  gsk_rounded_rect_to_float (&self->outline, graphene_point_zero (), instance->rect);
-  for (i = 0; i < 4; i++)
-    {
-      instance->border_widths[i] = self->widths[i];
-      gsk_vulkan_rgba_to_float (&self->colors[i], (gpointer) &instance->border_colors[4 * i]);
-    }
-}
-
-static void
-gsk_vulkan_border_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                              GskVulkanRender *render)
-{
-}
-
-static GskVulkanOp *
-gsk_vulkan_border_op_command (GskVulkanOp     *op,
-                              GskVulkanRender *render,
-                              VkRenderPass     render_pass,
-                              VkCommandBuffer  command_buffer)
-{
-  return gsk_vulkan_shader_op_command_n (op, render, render_pass, command_buffer, 8);
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_BORDER_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanBorderOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_border_op_finish,
-    gsk_vulkan_border_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_border_op_collect_vertex_data,
-    gsk_vulkan_border_op_reserve_descriptor_sets,
-    gsk_vulkan_border_op_command
-  },
-  "border",
-  0,
-  &gsk_vulkan_border_info,
-};
-
-void
-gsk_vulkan_border_op (GskVulkanRender         *render,
-                      GskVulkanShaderClip      clip,
-                      const GskRoundedRect    *outline,
-                      const graphene_point_t  *offset,
-                      const float              widths[4],
-                      const GdkRGBA            colors[4])
-{
-  GskVulkanBorderOp *self;
-  guint i;
-
-  self = (GskVulkanBorderOp *) gsk_vulkan_shader_op_alloc (render, &GSK_VULKAN_BORDER_OP_CLASS, clip, NULL);
-
-  self->outline = *outline;
-  gsk_rounded_rect_offset (&self->outline, offset->x, offset->y);
-  for (i = 0; i < 4; i++)
-    {
-      self->widths[i] = widths[i];
-      self->colors[i] = colors[i];
-    }
-}
-

gsk/vulkan/gskvulkanborderopprivate.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_border_op                            (GskVulkanRender                *render,
-                                                                         GskVulkanShaderClip             clip,
-                                                                         const GskRoundedRect           *outline,
-                                                                         const graphene_point_t         *offset,
-                                                                         const float                     widths[4],
-                                                                         const GdkRGBA                   colors[4]);
-
-
-G_END_DECLS
-

gsk/vulkan/gskvulkanborderpipeline.c

@@ -0,0 +1,87 @@
+#include "config.h"
+
+#include "gskvulkanborderpipelineprivate.h"
+
+#include "gskroundedrectprivate.h"
+
+#include "vulkan/resources/border.vert.h"
+
+struct _GskVulkanBorderPipeline
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (GskVulkanBorderPipeline, gsk_vulkan_border_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_border_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_border_info;
+}
+
+static void
+gsk_vulkan_border_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanBorderPipeline *self = GSK_VULKAN_BORDER_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_border_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_border_pipeline_class_init (GskVulkanBorderPipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_border_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_border_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_border_pipeline_init (GskVulkanBorderPipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_border_pipeline_new (GdkVulkanContext        *context,
+                                VkPipelineLayout         layout,
+                                const char              *shader_name,
+                                VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_BORDER_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_border_pipeline_collect_vertex_data (GskVulkanBorderPipeline *pipeline,
+                                                guchar                  *data,
+                                                const graphene_point_t  *offset,
+                                                const GskRoundedRect    *rect,
+                                                const float              widths[4],
+                                                const GdkRGBA            colors[4])
+{
+  GskVulkanBorderInstance *instance = (GskVulkanBorderInstance *) data;
+  guint i;
+
+  gsk_rounded_rect_to_float (rect, offset, instance->rect);
+  for (i = 0; i < 4; i++)
+    {
+      instance->border_widths[i] = widths[i];
+      instance->border_colors[4 * i + 0] = colors[i].red;
+      instance->border_colors[4 * i + 1] = colors[i].green;
+      instance->border_colors[4 * i + 2] = colors[i].blue;
+      instance->border_colors[4 * i + 3] = colors[i].alpha;
+    }
+}
+
+gsize
+gsk_vulkan_border_pipeline_draw (GskVulkanBorderPipeline *pipeline,
+                                VkCommandBuffer         command_buffer,
+                                gsize                   offset,
+                                gsize                   n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6 * 8, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkanborderpipelineprivate.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+#include "gskroundedrect.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanBorderPipelineLayout GskVulkanBorderPipelineLayout;
+
+#define GSK_TYPE_VULKAN_BORDER_PIPELINE (gsk_vulkan_border_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanBorderPipeline, gsk_vulkan_border_pipeline, GSK, VULKAN_BORDER_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline *     gsk_vulkan_border_pipeline_new                  (GdkVulkanContext               *context,
+                                                                         VkPipelineLayout                layout,
+                                                                         const char                     *shader_name,
+                                                                         VkRenderPass                    render_pass);
+
+void                    gsk_vulkan_border_pipeline_collect_vertex_data  (GskVulkanBorderPipeline        *pipeline,
+                                                                         guchar                         *data,
+                                                                         const graphene_point_t         *offset,
+                                                                         const GskRoundedRect           *rect,
+                                                                         const float                     widths[4],
+                                                                         const GdkRGBA                   colors[4]);
+gsize                   gsk_vulkan_border_pipeline_draw                 (GskVulkanBorderPipeline        *pipeline,
+                                                                         VkCommandBuffer                 command_buffer,
+                                                                         gsize                           offset,
+                                                                         gsize                           n_commands);
+
+G_END_DECLS
+

gsk/vulkan/gskvulkanboxshadowpipeline.c

@@ -0,0 +1,89 @@
+#include "config.h"
+
+#include "gskvulkanboxshadowpipelineprivate.h"
+
+#include "vulkan/resources/inset-shadow.vert.h"
+
+#include "gskroundedrectprivate.h"
+
+struct _GskVulkanBoxShadowPipeline
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (GskVulkanBoxShadowPipeline, gsk_vulkan_box_shadow_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_box_shadow_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_inset_shadow_info;
+}
+
+static void
+gsk_vulkan_box_shadow_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanBoxShadowPipeline *self = GSK_VULKAN_BOX_SHADOW_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_box_shadow_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_box_shadow_pipeline_class_init (GskVulkanBoxShadowPipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_box_shadow_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_box_shadow_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_box_shadow_pipeline_init (GskVulkanBoxShadowPipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_box_shadow_pipeline_new (GdkVulkanContext        *context,
+                                    VkPipelineLayout         layout,
+                                    const char              *shader_name,
+                                    VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_BOX_SHADOW_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_box_shadow_pipeline_collect_vertex_data (GskVulkanBoxShadowPipeline *pipeline,
+                                                    guchar                     *data,
+                                                    const graphene_point_t     *offset,
+                                                    const GskRoundedRect       *outline,
+                                                    const GdkRGBA              *color,
+                                                    float                      dx,
+                                                    float                      dy,
+                                                    float                      spread,
+                                                    float                      blur_radius)
+{
+  GskVulkanInsetShadowInstance *instance = (GskVulkanInsetShadowInstance *) data;
+
+  gsk_rounded_rect_to_float (outline, offset, instance->outline);
+  instance->color[0] = color->red;
+  instance->color[1] = color->green;
+  instance->color[2] = color->blue;
+  instance->color[3] = color->alpha;
+  instance->offset[0] = dx;
+  instance->offset[1] = dy;
+  instance->spread = spread;
+  instance->blur_radius = blur_radius;
+}
+
+gsize
+gsk_vulkan_box_shadow_pipeline_draw (GskVulkanBoxShadowPipeline *pipeline,
+                                     VkCommandBuffer         command_buffer,
+                                     gsize                   offset,
+                                     gsize                   n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6 * 8, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkanboxshadowpipelineprivate.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+#include "gskroundedrect.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanBoxShadowPipelineLayout GskVulkanBoxShadowPipelineLayout;
+
+#define GSK_TYPE_VULKAN_BOX_SHADOW_PIPELINE (gsk_vulkan_box_shadow_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanBoxShadowPipeline, gsk_vulkan_box_shadow_pipeline, GSK, VULKAN_BOX_SHADOW_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline *     gsk_vulkan_box_shadow_pipeline_new              (GdkVulkanContext               *context,
+                                                                         VkPipelineLayout                layout,
+                                                                         const char                     *shader_name,
+                                                                         VkRenderPass                    render_pass);
+
+void                    gsk_vulkan_box_shadow_pipeline_collect_vertex_data (GskVulkanBoxShadowPipeline  *pipeline,
+                                                                         guchar                         *data,
+                                                                         const graphene_point_t         *offset,
+                                                                         const GskRoundedRect           *outline,
+                                                                         const GdkRGBA                  *color,
+                                                                         float                           dx,
+                                                                         float                           dy,
+                                                                         float                           spread,
+                                                                         float                           blur_radius);
+
+gsize                   gsk_vulkan_box_shadow_pipeline_draw             (GskVulkanBoxShadowPipeline     *pipeline,
+                                                                         VkCommandBuffer                 command_buffer,
+                                                                         gsize                           offset,
+                                                                         gsize                           n_commands);
+
+G_END_DECLS
+

gsk/vulkan/gskvulkanbuffer.c

@@ -1,9 +1,8 @@
 #include "config.h"
 
 #include "gskvulkanbufferprivate.h"
-
 #include "gskvulkanmemoryprivate.h"
-#include "gskvulkanprivate.h"
+#include "gskvulkanpipelineprivate.h"
 
 struct _GskVulkanBuffer
 {
@@ -103,12 +102,6 @@ gsk_vulkan_buffer_get_buffer (GskVulkanBuffer *self)
   return self->vk_buffer;
 }
 
-gsize
-gsk_vulkan_buffer_get_size (GskVulkanBuffer *self)
-{
-  return self->size;
-}
-
 guchar *
 gsk_vulkan_buffer_map (GskVulkanBuffer *self)
 {

gsk/vulkan/gskvulkanbufferprivate.h

@@ -23,7 +23,6 @@ GskVulkanBuffer *       gsk_vulkan_buffer_new_map                       (GdkVulk
 void                    gsk_vulkan_buffer_free                          (GskVulkanBuffer        *buffer);
 
 VkBuffer                gsk_vulkan_buffer_get_buffer                    (GskVulkanBuffer        *self);
-gsize                   gsk_vulkan_buffer_get_size                      (GskVulkanBuffer        *self);
 
 guchar *                gsk_vulkan_buffer_map                           (GskVulkanBuffer        *self);
 void                    gsk_vulkan_buffer_unmap                         (GskVulkanBuffer        *self);

gsk/vulkan/gskvulkanclearop.c

@@ -1,115 +0,0 @@
-#include "config.h"
-
-#include "gskvulkanclearopprivate.h"
-
-#include "gskvulkanprivate.h"
-
-typedef struct _GskVulkanClearOp GskVulkanClearOp;
-
-struct _GskVulkanClearOp
-{
-  GskVulkanOp op;
-
-  cairo_rectangle_int_t rect;
-  GdkRGBA color;
-};
-
-static void
-gsk_vulkan_clear_op_finish (GskVulkanOp *op)
-{
-}
-
-static void
-gsk_vulkan_clear_op_print (GskVulkanOp *op,
-                           GString     *string,
-                           guint        indent)
-{
-  GskVulkanClearOp *self = (GskVulkanClearOp *) op;
-
-  print_indent (string, indent);
-  print_int_rect (string, &self->rect);
-  g_string_append_printf (string, "clear ");
-  print_rgba (string, &self->color);
-  print_newline (string);
-}
-
-static gsize
-gsk_vulkan_clear_op_count_vertex_data (GskVulkanOp *op,
-                                       gsize        n_bytes)
-{
-  return n_bytes;
-}
-
-static void
-gsk_vulkan_clear_op_collect_vertex_data (GskVulkanOp *op,
-                                         guchar      *data)
-{
-}
-
-static void
-gsk_vulkan_clear_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                             GskVulkanRender *render)
-{
-}
-
-static void
-gsk_vulkan_init_clear_value (VkClearValue  *value,
-                             const GdkRGBA *rgba)
-{
-  gsk_vulkan_rgba_to_float (rgba, value->color.float32);
-}
-
-static GskVulkanOp *
-gsk_vulkan_clear_op_command (GskVulkanOp      *op,
-                             GskVulkanRender  *render,
-                             VkRenderPass      render_pass,
-                             VkCommandBuffer   command_buffer)
-{
-  GskVulkanClearOp *self = (GskVulkanClearOp *) op;
-  VkClearValue clear_value;
-
-  gsk_vulkan_init_clear_value (&clear_value, &self->color);
-
-  vkCmdClearAttachments (command_buffer,
-                         1,
-                         &(VkClearAttachment) {
-                           VK_IMAGE_ASPECT_COLOR_BIT,
-                           0,
-                           clear_value,
-                         },
-                         1,
-                         &(VkClearRect) {
-                           {
-                             { self->rect.x, self->rect.y },
-                             { self->rect.width, self->rect.height },
-                           },
-                           0,
-                           1
-                         });
-
-  return op->next;
-}
-
-static const GskVulkanOpClass GSK_VULKAN_SCISSOR_OP_CLASS = {
-  GSK_VULKAN_OP_SIZE (GskVulkanClearOp),
-  GSK_VULKAN_STAGE_COMMAND,
-  gsk_vulkan_clear_op_finish,
-  gsk_vulkan_clear_op_print,
-  gsk_vulkan_clear_op_count_vertex_data,
-  gsk_vulkan_clear_op_collect_vertex_data,
-  gsk_vulkan_clear_op_reserve_descriptor_sets,
-  gsk_vulkan_clear_op_command
-};
-
-void
-gsk_vulkan_clear_op (GskVulkanRender             *render,
-                     const cairo_rectangle_int_t *rect,
-                     const GdkRGBA               *color)
-{
-  GskVulkanClearOp *self;
-
-  self = (GskVulkanClearOp *) gsk_vulkan_op_alloc (render, &GSK_VULKAN_SCISSOR_OP_CLASS);
-
-  self->rect = *rect;
-  self->color = *color;
-}

gsk/vulkan/gskvulkanclearopprivate.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_clear_op                             (GskVulkanRender                *render,
-                                                                         const cairo_rectangle_int_t    *rect,
-                                                                         const GdkRGBA                  *color);
-
-
-G_END_DECLS
-

gsk/vulkan/gskvulkanclip.c

@@ -236,9 +236,9 @@ gsk_vulkan_clip_transform (GskVulkanClip         *dest,
 }
 
 gboolean
-gsk_vulkan_clip_may_intersect_rect (const GskVulkanClip    *self,
-                                    const graphene_point_t *offset,
-                                    const graphene_rect_t  *rect)
+gsk_vulkan_clip_intersects_rect (const GskVulkanClip    *self,
+                                 const graphene_point_t *offset,
+                                 const graphene_rect_t  *rect)
 {
   graphene_rect_t r = *rect;
   r.origin.x += offset->x;
@@ -252,9 +252,13 @@ gsk_vulkan_clip_may_intersect_rect (const GskVulkanClip    *self,
       return FALSE;
 
     case GSK_VULKAN_CLIP_NONE:
+      return r.size.width > 0 && r.size.height > 0;
+
     case GSK_VULKAN_CLIP_RECT:
-    case GSK_VULKAN_CLIP_ROUNDED:
       return graphene_rect_intersection (&self->rect.bounds, &r, NULL);
+
+    case GSK_VULKAN_CLIP_ROUNDED:
+      return gsk_rounded_rect_intersects_rect (&self->rect, &r);
     }
 }
 
@@ -284,17 +288,3 @@ gsk_vulkan_clip_contains_rect (const GskVulkanClip    *self,
       return gsk_rounded_rect_contains_rect (&self->rect, &r);
     }
 }
-
-GskVulkanShaderClip
-gsk_vulkan_clip_get_shader_clip (const GskVulkanClip    *self,
-                                 const graphene_point_t *offset,
-                                 const graphene_rect_t  *rect)
-{
-  if (gsk_vulkan_clip_contains_rect (self, offset, rect))
-    return GSK_VULKAN_SHADER_CLIP_NONE;
-  else if (self->type == GSK_VULKAN_CLIP_RECT)
-    return GSK_VULKAN_SHADER_CLIP_RECT;
-  else
-    return GSK_VULKAN_SHADER_CLIP_ROUNDED;
-}
-

gsk/vulkan/gskvulkanclipprivate.h

@@ -6,12 +6,6 @@
 
 G_BEGIN_DECLS
 
-typedef enum {
-  GSK_VULKAN_SHADER_CLIP_NONE,
-  GSK_VULKAN_SHADER_CLIP_RECT,
-  GSK_VULKAN_SHADER_CLIP_ROUNDED
-} GskVulkanShaderClip;
-
 typedef enum {
   /* The whole area is clipped, no drawing is necessary.
    * This can't be handled by return values because for return
@@ -61,12 +55,9 @@ gboolean                gsk_vulkan_clip_transform                       (GskVulk
 gboolean                gsk_vulkan_clip_contains_rect                   (const GskVulkanClip    *self,
                                                                          const graphene_point_t *offset,
                                                                          const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-gboolean                gsk_vulkan_clip_may_intersect_rect              (const GskVulkanClip    *self,
+gboolean                gsk_vulkan_clip_intersects_rect                 (const GskVulkanClip    *self,
                                                                          const graphene_point_t *offset,
                                                                          const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-GskVulkanShaderClip     gsk_vulkan_clip_get_shader_clip                 (const GskVulkanClip    *self,
-                                                                         const graphene_point_t *offset,
-                                                                         const graphene_rect_t  *rect);
 
 G_END_DECLS
 

gsk/vulkan/gskvulkancolormatrixop.c

@@ -1,135 +0,0 @@
-#include "config.h"
-
-#include "gskvulkancolormatrixopprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-
-#include "vulkan/resources/color-matrix.vert.h"
-
-typedef struct _GskVulkanColorMatrixOp GskVulkanColorMatrixOp;
-
-struct _GskVulkanColorMatrixOp
-{
-  GskVulkanShaderOp op;
-
-  graphene_matrix_t color_matrix;
-  graphene_vec4_t color_offset;
-  graphene_rect_t rect;
-  graphene_rect_t tex_rect;
-
-  guint32 image_descriptor;
-};
-
-static void
-gsk_vulkan_color_matrix_op_print (GskVulkanOp *op,
-                                  GString     *string,
-                                  guint        indent)
-{
-  GskVulkanColorMatrixOp *self = (GskVulkanColorMatrixOp *) op;
-
-  print_indent (string, indent);
-  print_rect (string, &self->rect);
-  g_string_append (string, "color-matrix ");
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_color_matrix_op_collect_vertex_data (GskVulkanOp *op,
-                                                guchar      *data)
-{
-  GskVulkanColorMatrixOp *self = (GskVulkanColorMatrixOp *) op;
-  GskVulkanColorMatrixInstance *instance = (GskVulkanColorMatrixInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-
-  instance->rect[0] = self->rect.origin.x;
-  instance->rect[1] = self->rect.origin.y;
-  instance->rect[2] = self->rect.size.width;
-  instance->rect[3] = self->rect.size.height;
-  instance->tex_rect[0] = self->tex_rect.origin.x;
-  instance->tex_rect[1] = self->tex_rect.origin.y;
-  instance->tex_rect[2] = self->tex_rect.size.width;
-  instance->tex_rect[3] = self->tex_rect.size.height;
-  graphene_matrix_to_float (&self->color_matrix, instance->color_matrix);
-  graphene_vec4_to_float (&self->color_offset, instance->color_offset);
-  instance->tex_id = self->image_descriptor;
-}
-
-static void
-gsk_vulkan_color_matrix_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                                    GskVulkanRender *render)
-{
-  GskVulkanColorMatrixOp *self = (GskVulkanColorMatrixOp *) op;
-  GskVulkanShaderOp *shader = (GskVulkanShaderOp *) op;
-
-  self->image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                   shader->images[0],
-                                                                   GSK_VULKAN_SAMPLER_DEFAULT);
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_COLOR_MATRIX_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanColorMatrixOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_shader_op_finish,
-    gsk_vulkan_color_matrix_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_color_matrix_op_collect_vertex_data,
-    gsk_vulkan_color_matrix_op_reserve_descriptor_sets,
-    gsk_vulkan_shader_op_command
-  },
-  "color-matrix",
-  1,
-  &gsk_vulkan_color_matrix_info,
-};
-
-void
-gsk_vulkan_color_matrix_op (GskVulkanRender         *render,
-                            GskVulkanShaderClip      clip,
-                            GskVulkanImage          *image,
-                            const graphene_rect_t   *rect,
-                            const graphene_point_t  *offset,
-                            const graphene_rect_t   *tex_rect,
-                            const graphene_matrix_t *color_matrix,
-                            const graphene_vec4_t   *color_offset)
-{
-  GskVulkanColorMatrixOp *self;
-
-  self = (GskVulkanColorMatrixOp *) gsk_vulkan_shader_op_alloc (render, &GSK_VULKAN_COLOR_MATRIX_OP_CLASS, clip, &image);
-
-  graphene_rect_offset_r (rect, offset->x, offset->y, &self->rect);
-  gsk_vulkan_normalize_tex_coords (&self->tex_rect, rect, tex_rect);
-  self->color_matrix = *color_matrix;
-  self->color_offset = *color_offset;
-}
-
-void
-gsk_vulkan_color_matrix_op_opacity (GskVulkanRender        *render,
-                                    GskVulkanShaderClip     clip,
-                                    GskVulkanImage         *image,
-                                    const graphene_rect_t  *rect,
-                                    const graphene_point_t *offset,
-                                    const graphene_rect_t  *tex_rect,
-                                    float                   opacity)
-{
-  graphene_matrix_t color_matrix;
-  graphene_vec4_t color_offset;
-
-  graphene_matrix_init_from_float (&color_matrix,
-                                   (float[16]) {
-                                       1.0, 0.0, 0.0, 0.0,
-                                       0.0, 1.0, 0.0, 0.0,
-                                       0.0, 0.0, 1.0, 0.0,
-                                       0.0, 0.0, 0.0, opacity
-                                   });
-  graphene_vec4_init (&color_offset, 0.0, 0.0, 0.0, 0.0);
-
-  gsk_vulkan_color_matrix_op (render,
-                              clip,
-                              image,
-                              rect,
-                              offset,
-                              tex_rect,
-                              &color_matrix,
-                              &color_offset);
-}
-

gsk/vulkan/gskvulkancolorop.c

@@ -1,91 +0,0 @@
-#include "config.h"
-
-#include "gskvulkancoloropprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-
-#include "vulkan/resources/color.vert.h"
-
-typedef struct _GskVulkanColorOp GskVulkanColorOp;
-
-struct _GskVulkanColorOp
-{
-  GskVulkanShaderOp op;
-
-  graphene_rect_t rect;
-  GdkRGBA color;
-};
-
-static void
-gsk_vulkan_color_op_finish (GskVulkanOp *op)
-{
-}
-
-static void
-gsk_vulkan_color_op_print (GskVulkanOp *op,
-                           GString     *string,
-                           guint        indent)
-{
-  GskVulkanColorOp *self = (GskVulkanColorOp *) op;
-
-  print_indent (string, indent);
-  print_rect (string, &self->rect);
-  g_string_append (string, "color ");
-  print_rgba (string, &self->color);
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_color_op_collect_vertex_data (GskVulkanOp *op,
-                                         guchar      *data)
-{
-  GskVulkanColorOp *self = (GskVulkanColorOp *) op;
-  GskVulkanColorInstance *instance = (GskVulkanColorInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-
-  instance->rect[0] = self->rect.origin.x;
-  instance->rect[1] = self->rect.origin.y;
-  instance->rect[2] = self->rect.size.width;
-  instance->rect[3] = self->rect.size.height;
-  instance->color[0] = self->color.red;
-  instance->color[1] = self->color.green;
-  instance->color[2] = self->color.blue;
-  instance->color[3] = self->color.alpha;
-}
-
-static void
-gsk_vulkan_color_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                             GskVulkanRender *render)
-{
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_COLOR_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanColorOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_color_op_finish,
-    gsk_vulkan_color_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_color_op_collect_vertex_data,
-    gsk_vulkan_color_op_reserve_descriptor_sets,
-    gsk_vulkan_shader_op_command
-  },
-  "color",
-  0,
-  &gsk_vulkan_color_info,
-};
-
-void
-gsk_vulkan_color_op (GskVulkanRender        *render,
-                     GskVulkanShaderClip     clip,
-                     const graphene_rect_t  *rect,
-                     const graphene_point_t *offset,
-                     const GdkRGBA          *color)
-{
-  GskVulkanColorOp *self;
-
-  self = (GskVulkanColorOp *) gsk_vulkan_shader_op_alloc (render, &GSK_VULKAN_COLOR_OP_CLASS, clip, NULL);
-
-  graphene_rect_offset_r (rect, offset->x, offset->y, &self->rect);
-  self->color = *color;
-}

gsk/vulkan/gskvulkancoloropprivate.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_color_op                             (GskVulkanRender                *render,
-                                                                         GskVulkanShaderClip             clip,
-                                                                         const graphene_rect_t          *rect,
-                                                                         const graphene_point_t         *offset,
-                                                                         const GdkRGBA                  *color);
-
-
-G_END_DECLS
-

gsk/vulkan/gskvulkancolorpipeline.c

@@ -0,0 +1,82 @@
+#include "config.h"
+
+#include "gskvulkancolorpipelineprivate.h"
+
+#include "vulkan/resources/color.vert.h"
+
+struct _GskVulkanColorPipeline
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (GskVulkanColorPipeline, gsk_vulkan_color_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_color_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_color_info;
+}
+
+static void
+gsk_vulkan_color_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanColorPipeline *self = GSK_VULKAN_COLOR_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_color_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_color_pipeline_class_init (GskVulkanColorPipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_color_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_color_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_color_pipeline_init (GskVulkanColorPipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_color_pipeline_new (GdkVulkanContext         *context,
+                               VkPipelineLayout         layout,
+                               const char              *shader_name,
+                               VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_COLOR_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_color_pipeline_collect_vertex_data (GskVulkanColorPipeline *pipeline,
+                                               guchar                 *data,
+                                               const graphene_point_t *offset,
+                                               const graphene_rect_t  *rect,
+                                               const GdkRGBA          *color)
+{
+  GskVulkanColorInstance *instance = (GskVulkanColorInstance *) data;
+
+  instance->rect[0] = rect->origin.x + offset->x;
+  instance->rect[1] = rect->origin.y + offset->y;
+  instance->rect[2] = rect->size.width;
+  instance->rect[3] = rect->size.height;
+  instance->color[0] = color->red;
+  instance->color[1] = color->green;
+  instance->color[2] = color->blue;
+  instance->color[3] = color->alpha;
+}
+
+gsize
+gsk_vulkan_color_pipeline_draw (GskVulkanColorPipeline *pipeline,
+                                VkCommandBuffer         command_buffer,
+                                gsize                   offset,
+                                gsize                   n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkancolorpipelineprivate.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanColorPipelineLayout GskVulkanColorPipelineLayout;
+
+#define GSK_TYPE_VULKAN_COLOR_PIPELINE (gsk_vulkan_color_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanColorPipeline, gsk_vulkan_color_pipeline, GSK, VULKAN_COLOR_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline *     gsk_vulkan_color_pipeline_new                   (GdkVulkanContext               *context,
+                                                                         VkPipelineLayout                layout,
+                                                                         const char                     *shader_name,
+                                                                         VkRenderPass                    render_pass);
+
+void                    gsk_vulkan_color_pipeline_collect_vertex_data   (GskVulkanColorPipeline         *pipeline,
+                                                                         guchar                         *data,
+                                                                         const graphene_point_t         *offset,
+                                                                         const graphene_rect_t          *rect,
+                                                                         const GdkRGBA                  *color);
+gsize                   gsk_vulkan_color_pipeline_draw                  (GskVulkanColorPipeline         *pipeline,
+                                                                         VkCommandBuffer                 command_buffer,
+                                                                         gsize                           offset,
+                                                                         gsize                           n_commands);
+
+G_END_DECLS
+

gsk/vulkan/gskvulkancolortextpipeline.c

@@ -0,0 +1,122 @@
+#include "config.h"
+
+#include "gskvulkancolortextpipelineprivate.h"
+
+#include "vulkan/resources/texture.vert.h"
+
+struct _GskVulkanColorTextPipeline
+{
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE (GskVulkanColorTextPipeline, gsk_vulkan_color_text_pipeline, GSK_TYPE_VULKAN_PIPELINE)
+
+static const VkPipelineVertexInputStateCreateInfo *
+gsk_vulkan_color_text_pipeline_get_input_state_create_info (GskVulkanPipeline *self)
+{
+  return &gsk_vulkan_texture_info;
+}
+
+static void
+gsk_vulkan_color_text_pipeline_finalize (GObject *gobject)
+{
+  //GskVulkanColorTextPipeline *self = GSK_VULKAN_COLOR_TEXT_PIPELINE (gobject);
+
+  G_OBJECT_CLASS (gsk_vulkan_color_text_pipeline_parent_class)->finalize (gobject);
+}
+
+static void
+gsk_vulkan_color_text_pipeline_class_init (GskVulkanColorTextPipelineClass *klass)
+{
+  GskVulkanPipelineClass *pipeline_class = GSK_VULKAN_PIPELINE_CLASS (klass);
+
+  G_OBJECT_CLASS (klass)->finalize = gsk_vulkan_color_text_pipeline_finalize;
+
+  pipeline_class->get_input_state_create_info = gsk_vulkan_color_text_pipeline_get_input_state_create_info;
+}
+
+static void
+gsk_vulkan_color_text_pipeline_init (GskVulkanColorTextPipeline *self)
+{
+}
+
+GskVulkanPipeline *
+gsk_vulkan_color_text_pipeline_new (GdkVulkanContext        *context,
+                                    VkPipelineLayout         layout,
+                                    const char              *shader_name,
+                                    VkRenderPass             render_pass)
+{
+  return gsk_vulkan_pipeline_new (GSK_TYPE_VULKAN_COLOR_TEXT_PIPELINE, context, layout, shader_name, render_pass);
+}
+
+void
+gsk_vulkan_color_text_pipeline_collect_vertex_data (GskVulkanColorTextPipeline *pipeline,
+                                                    guchar                     *data,
+                                                    GskVulkanRenderer          *renderer,
+                                                    const graphene_rect_t      *rect,
+                                                    guint                       tex_id[2],
+                                                    PangoFont                  *font,
+                                                    guint                       total_glyphs,
+                                                    const PangoGlyphInfo       *glyphs,
+                                                    const graphene_point_t     *offset,
+                                                    guint                       start_glyph,
+                                                    guint                       num_glyphs,
+                                                    float                       scale)
+{
+  GskVulkanTextureInstance *instances = (GskVulkanTextureInstance *) data;
+  int i;
+  int count = 0;
+  int x_position = 0;
+
+  for (i = 0; i < start_glyph; i++)
+    x_position += glyphs[i].geometry.width;
+
+  for (; i < total_glyphs && count < num_glyphs; i++)
+    {
+      const PangoGlyphInfo *gi = &glyphs[i];
+
+      if (gi->glyph != PANGO_GLYPH_EMPTY)
+        {
+          double cx = (x_position + gi->geometry.x_offset) / PANGO_SCALE;
+          double cy = gi->geometry.y_offset / PANGO_SCALE;
+          GskVulkanTextureInstance *instance = &instances[count];
+          GskVulkanCachedGlyph *glyph;
+
+          glyph = gsk_vulkan_renderer_get_cached_glyph (renderer,
+                                                        font,
+                                                        gi->glyph,
+                                                        x_position + gi->geometry.x_offset,
+                                                        gi->geometry.y_offset,
+                                                        scale);
+
+          instance->rect[0] = offset->x + cx + glyph->draw_x;
+          instance->rect[1] = offset->y + cy + glyph->draw_y;
+          instance->rect[2] = glyph->draw_width;
+          instance->rect[3] = glyph->draw_height;
+
+          instance->tex_rect[0] = glyph->tx;
+          instance->tex_rect[1] = glyph->ty;
+          instance->tex_rect[2] = glyph->tw;
+          instance->tex_rect[3] = glyph->th;
+
+          instance->tex_id[0] = tex_id[0];
+          instance->tex_id[1] = tex_id[1];
+
+          count++;
+       }
+     x_position += gi->geometry.width;
+   }
+}
+
+gsize
+gsk_vulkan_color_text_pipeline_draw (GskVulkanColorTextPipeline *pipeline,
+                                     VkCommandBuffer             command_buffer,
+                                     gsize                       offset,
+                                     gsize                       n_commands)
+{
+  vkCmdDraw (command_buffer,
+             6, n_commands,
+             0, offset);
+
+  return n_commands;
+}

gsk/vulkan/gskvulkancolortextpipelineprivate.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <graphene.h>
+
+#include "gskvulkanpipelineprivate.h"
+#include "gskvulkanrendererprivate.h"
+
+G_BEGIN_DECLS
+
+typedef struct _GskVulkanColorTextPipelineLayout GskVulkanColorTextPipelineLayout;
+
+#define GSK_TYPE_VULKAN_COLOR_TEXT_PIPELINE (gsk_vulkan_color_text_pipeline_get_type ())
+
+G_DECLARE_FINAL_TYPE (GskVulkanColorTextPipeline, gsk_vulkan_color_text_pipeline, GSK, VULKAN_COLOR_TEXT_PIPELINE, GskVulkanPipeline)
+
+GskVulkanPipeline *     gsk_vulkan_color_text_pipeline_new                   (GdkVulkanContext               *context,
+                                                                              VkPipelineLayout                layout,
+                                                                              const char                     *shader_name,
+                                                                              VkRenderPass                    render_pass);
+
+void                    gsk_vulkan_color_text_pipeline_collect_vertex_data   (GskVulkanColorTextPipeline     *pipeline,
+                                                                              guchar                         *data,
+                                                                              GskVulkanRenderer              *renderer,
+                                                                              const graphene_rect_t          *rect,
+                                                                              guint                           tex_id[2],
+                                                                              PangoFont                      *font,
+                                                                              guint                           total_glyphs,
+                                                                              const PangoGlyphInfo           *glyphs,
+                                                                              const graphene_point_t         *offset,
+                                                                              guint                           start_glyph,
+                                                                              guint                           num_glyphs,
+                                                                              float                           scale);
+gsize                   gsk_vulkan_color_text_pipeline_draw                  (GskVulkanColorTextPipeline     *pipeline,
+                                                                              VkCommandBuffer                 command_buffer,
+                                                                              gsize                           offset,
+                                                                              gsize                           n_commands);
+
+G_END_DECLS
+

gsk/vulkan/gskvulkancommandpool.c

@@ -1,7 +1,7 @@
 #include "config.h"
 
 #include "gskvulkancommandpoolprivate.h"
-#include "gskvulkanprivate.h"
+#include "gskvulkanpipelineprivate.h"
 
 struct _GskVulkanCommandPool
 {

gsk/vulkan/gskvulkancrossfadeop.c

@@ -1,119 +0,0 @@
-#include "config.h"
-
-#include "gskvulkancrossfadeopprivate.h"
-
-#include "gskvulkanprivate.h"
-#include "gskvulkanshaderopprivate.h"
-
-#include "vulkan/resources/cross-fade.vert.h"
-
-typedef struct _GskVulkanCrossFadeOp GskVulkanCrossFadeOp;
-
-struct _GskVulkanCrossFadeOp
-{
-  GskVulkanShaderOp op;
-
-  graphene_rect_t bounds;
-  float progress;
-
-  struct {
-    graphene_rect_t rect;
-    graphene_rect_t tex_rect;
-    guint32 image_descriptor;
-  } start, end;
-};
-
-static void
-gsk_vulkan_cross_fade_op_print (GskVulkanOp *op,
-                                GString     *string,
-                                guint        indent)
-{
-  GskVulkanCrossFadeOp *self = (GskVulkanCrossFadeOp *) op;
-
-  print_indent (string, indent);
-  print_rect (string, &self->bounds);
-  g_string_append_printf (string, "cross-fade %d%% ", (int) (self->progress * 100 + 0.5));
-  print_newline (string);
-}
-
-static void
-gsk_vulkan_cross_fade_op_collect_vertex_data (GskVulkanOp *op,
-                                              guchar      *data)
-{
-  GskVulkanCrossFadeOp *self = (GskVulkanCrossFadeOp *) op;
-  GskVulkanCrossFadeInstance *instance = (GskVulkanCrossFadeInstance *) (data + ((GskVulkanShaderOp *) op)->vertex_offset);
-
-  gsk_vulkan_rect_to_float (&self->bounds, instance->rect);
-  gsk_vulkan_rect_to_float (&self->start.rect, instance->start_rect);
-  gsk_vulkan_rect_to_float (&self->end.rect, instance->end_rect);
-  gsk_vulkan_rect_to_float (&self->start.tex_rect, instance->start_tex_rect);
-  gsk_vulkan_rect_to_float (&self->end.tex_rect, instance->end_tex_rect);
-
-  instance->start_tex_id = self->start.image_descriptor;
-  instance->end_tex_id = self->end.image_descriptor;
-  instance->progress = self->progress;
-}
-
-static void
-gsk_vulkan_cross_fade_op_reserve_descriptor_sets (GskVulkanOp     *op,
-                                                  GskVulkanRender *render)
-{
-  GskVulkanCrossFadeOp *self = (GskVulkanCrossFadeOp *) op;
-  GskVulkanShaderOp *shader = (GskVulkanShaderOp *) op;
-
-  self->start.image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                         shader->images[0],
-                                                                         GSK_VULKAN_SAMPLER_DEFAULT);
-  self->end.image_descriptor = gsk_vulkan_render_get_image_descriptor (render,
-                                                                       shader->images[1],
-                                                                       GSK_VULKAN_SAMPLER_DEFAULT);
-}
-
-static const GskVulkanShaderOpClass GSK_VULKAN_CROSS_FADE_OP_CLASS = {
-  {
-    GSK_VULKAN_OP_SIZE (GskVulkanCrossFadeOp),
-    GSK_VULKAN_STAGE_SHADER,
-    gsk_vulkan_shader_op_finish,
-    gsk_vulkan_cross_fade_op_print,
-    gsk_vulkan_shader_op_count_vertex_data,
-    gsk_vulkan_cross_fade_op_collect_vertex_data,
-    gsk_vulkan_cross_fade_op_reserve_descriptor_sets,
-    gsk_vulkan_shader_op_command
-  },
-  "cross-fade",
-  2,
-  &gsk_vulkan_cross_fade_info,
-};
-
-void
-gsk_vulkan_cross_fade_op (GskVulkanRender        *render,
-                          GskVulkanShaderClip     clip,
-                          const graphene_rect_t  *bounds,
-                          const graphene_point_t *offset,
-                          float                   progress,
-                          GskVulkanImage         *start_image,
-                          const graphene_rect_t  *start_rect,
-                          const graphene_rect_t  *start_tex_rect,
-                          GskVulkanImage         *end_image,
-                          const graphene_rect_t  *end_rect,
-                          const graphene_rect_t  *end_tex_rect)
-{
-  GskVulkanCrossFadeOp *self;
-
-  self = (GskVulkanCrossFadeOp *) gsk_vulkan_shader_op_alloc (render,
-                                                              &GSK_VULKAN_CROSS_FADE_OP_CLASS,
-                                                              clip,
-                                                              (GskVulkanImage *[2]) {
-                                                                  start_image,
-                                                                  end_image
-                                                              });
-
-  graphene_rect_offset_r (bounds, offset->x, offset->y, &self->bounds);
-  self->progress = progress;
-
-  graphene_rect_offset_r (start_rect, offset->x, offset->y, &self->start.rect);
-  gsk_vulkan_normalize_tex_coords (&self->start.tex_rect, bounds, start_tex_rect);
-
-  graphene_rect_offset_r (end_rect, offset->x, offset->y, &self->end.rect);
-  gsk_vulkan_normalize_tex_coords (&self->end.tex_rect, bounds, end_tex_rect);
-}

gsk/vulkan/gskvulkancrossfadeopprivate.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "gskvulkanopprivate.h"
-
-G_BEGIN_DECLS
-
-void                    gsk_vulkan_cross_fade_op                        (GskVulkanRender                *render,
-                                                                         GskVulkanShaderClip             clip,
-                                                                         const graphene_rect_t          *bounds,
-                                                                         const graphene_point_t         *offset,
-                                                                         float                           progress,
-                                                                         GskVulkanImage                 *start_image,
-                                                                         const graphene_rect_t          *start_rect,
-                                                                         const graphene_rect_t          *start_tex_rect,
-                                                                         GskVulkanImage                 *end_image,
-                                                                         const graphene_rect_t          *end_rect,
-                                                                         const graphene_rect_t          *end_tex_rect);
-
-
-G_END_DECLS
-