Extend debug var support

Make our debug variable parser handle key=value strings, provided
that a callback is provided for the key. This may be used in the
future to accept settings like

GDK_DEBUG=vsync=144fps

demos/node-editor/node-editor-window.c

@@ -1567,6 +1567,23 @@ edit_action_cb (GtkWidget  *widget,
   node_editor_window_edit (self, &start);
 }
 
+static void
+node_editor_window_map (GtkWidget *widget)
+{
+  char *path;
+
+  GTK_WIDGET_CLASS (node_editor_window_parent_class)->map (widget);
+
+  path = get_autosave_path (NULL);
+  if (g_file_test (path, G_FILE_TEST_EXISTS))
+    {
+      g_free (path);
+      return;
+    }
+
+  g_free (path);
+}
+
 static void
 node_editor_window_set_property (GObject      *object,
                                  guint         prop_id,
@@ -1643,6 +1660,8 @@ node_editor_window_class_init (NodeEditorWindowClass *class)
   widget_class->realize = node_editor_window_realize;
   widget_class->unrealize = node_editor_window_unrealize;
 
+  widget_class->map = node_editor_window_map;
+
   properties[PROP_AUTO_RELOAD] = g_param_spec_boolean ("auto-reload", NULL, NULL,
                                                        TRUE,
                                                        G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_NAME);

gdk/gdk.c

@@ -193,8 +193,7 @@ gdk_parse_debug_var (const char        *variable,
   guint i;
   guint result = 0;
   const char *string;
-  const char *p;
-  const char *q;
+  const char *p, *q, *s;
   gboolean invert;
   gboolean help;
 
@@ -222,17 +221,42 @@ gdk_parse_debug_var (const char        *variable,
         }
       else
         {
+          s = strchr (p, '=');
+          if (!s || s > q)
+            s = q;
+
           for (i = 0; i < nkeys; i++)
             {
-              if (strlen (keys[i].key) == q - p &&
-                  g_ascii_strncasecmp (keys[i].key, p, q - p) == 0)
+              if (strlen (keys[i].key) == s - p &&
+                  g_ascii_strncasecmp (keys[i].key, p, s - p) == 0)
                 {
-                  result |= keys[i].value;
-                  break;
+                  if (s == q)
+                    {
+                      if (keys[i].callback)
+                        {
+                          if (!keys[i].callback (&keys[i], NULL))
+                            fprintf (stderr, "Setting value \"%.*s\" failed.", (int)(q - p), p);
+                        }
+                      else
+                        result |= keys[i].value;
+
+                      break;
+                    }
+                  else if (keys[i].callback)
+                    {
+                      char *val;
+
+                      val = g_strndup (s + 1, q - (s + 1));
+                      if (!keys[i].callback (&keys[i], val))
+                        fprintf (stderr, "Setting value \"%.*s\" failed.", (int)(q - p), p);
+                      g_free (val);
+
+                      break;
+                    }
                 }
             }
           if (i == nkeys)
-            fprintf (stderr, "Unrecognized value \"%.*s\". Try %s=help\n", (int) (q - p), p, variable);
+            fprintf (stderr, "Unrecognized value \"%.*s\". Try %s=help\n", (int)(q - p), p, variable);
          }
 
       p = q;
@@ -244,13 +268,26 @@ gdk_parse_debug_var (const char        *variable,
     {
       int max_width = 4;
       for (i = 0; i < nkeys; i++)
-        max_width = MAX (max_width, strlen (keys[i].key));
+        {
+          int width = strlen (keys[i].key);
+          if (keys[i].callback)
+            width += strlen ("=VALUE");
+          max_width = MAX (max_width, width);
+        }
       max_width += 4;
 
       fprintf (stderr, "Supported %s values:\n", variable);
-      for (i = 0; i < nkeys; i++) {
-        fprintf (stderr, "  %s%*s%s\n", keys[i].key, (int)(max_width - strlen (keys[i].key)), " ", keys[i].help);
-      }
+      for (i = 0; i < nkeys; i++)
+        {
+          int width = strlen (keys[i].key);
+          if (keys[i].callback)
+            width += strlen ("=VALUE");
+          fprintf (stderr, "  %s%s%*s%s\n",
+                   keys[i].key,
+                   keys[i].callback ? "=VALUE" : "",
+                   (int)(max_width - width), " ",
+                   keys[i].help);
+        }
       fprintf (stderr, "  %s%*s%s\n", "all", max_width - 3, " ", "Enable all values. Other given values are subtracted");
       fprintf (stderr, "  %s%*s%s\n", "help", max_width - 4, " ", "Print this help");
       fprintf (stderr, "\nMultiple values can be given, separated by : or space.\n");

gdk/gdkdebugprivate.h

@@ -97,14 +97,17 @@ gdk_debug_message (const char *format, ...)
 #define GDK_DEBUG_CHECK(type) GDK_DISPLAY_DEBUG_CHECK (NULL,type)
 #define GDK_DEBUG(type,...) GDK_DISPLAY_DEBUG (NULL,type,__VA_ARGS__)
 
-typedef struct
+typedef struct _GdkDebugKey GdkDebugKey;
+
+struct _GdkDebugKey
 {
   const char *key;
   guint value;
   const char *help;
-} GdkDebugKey;
+  gboolean (* callback) (const GdkDebugKey *key,
+                         const char        *value);
+};
 
 guint gdk_parse_debug_var (const char        *variable,
                            const GdkDebugKey *keys,
                            guint              nkeys);
-

gdk/gdkframeclock.c

@@ -79,7 +79,7 @@ static guint signals[LAST_SIGNAL];
 
 static guint fps_counter;
 
-#define FRAME_HISTORY_MAX_LENGTH 128
+#define FRAME_HISTORY_MAX_LENGTH 1000
 
 struct _GdkFrameClockPrivate
 {

gsk/boxprivate.h

@@ -1,479 +0,0 @@
-#pragma once
-
-#include <graphene.h>
-#include <math.h>
-#include "gsktypesprivate.h"
-#include "scaleprivate.h"
-#include "pointprivate.h"
-
-#ifndef USE_SIMD
-
-struct _Box
-{
-  float x0, y0, x1, y1;
-};
-
-static inline float
-box_x0 (const Box box)
-{
-  return box.x0;
-}
-
-static inline float
-box_y0 (const Box box)
-{
-  return box.y0;
-}
-
-static inline float
-box_x1 (const Box box)
-{
-  return box.x1;
-}
-
-static inline float
-box_y1 (const Box box)
-{
-  return box.y1;
-}
-
-static inline float
-box_width (const Box box)
-{
-  return box.x1 - box.x0;
-}
-
-static inline float
-box_height (const Box box)
-{
-  return box.y1 - box.y0;
-}
-
-/* Assumes x0 <= x1 && y0 <= y1 */
-static inline Box
-box (float x0,
-     float y0,
-     float x1,
-     float y1)
-{
-  return (Box) { .x0 = x0, .y0 = y0, .x1 = x1, .y1 = y1 };
-}
-
-static inline Box
-box_from_rect (float x,
-               float y,
-               float w,
-               float h)
-{
-  return box (x, y, x + w, y + h);
-}
-
-static inline Box
-box_from_graphene (const graphene_rect_t *rect)
-{
-  return box_from_rect (rect->origin.x,
-                        rect->origin.y,
-                        rect->size.width,
-                        rect->size.height);
-}
-
-/* Assumes p0.x <= p1.x && p0.y <= p1.y */
-static inline Box
-box_from_points (Point p0,
-                 Point p1)
-{
-  return box (p0.x, p0.y, p1.x, p1.y);
-}
-
-static inline Point
-box_origin (const Box box)
-{
-  return point (box.x0, box.y0);
-}
-
-static inline Point
-box_opposite (const Box box)
-{
-  return point (box.x1, box.y1);
-}
-
-static inline void
-box_to_float (const Box box,
-              float     v[4])
-{
-  v[0] = box.x0;
-  v[1] = box.y0;
-  v[2] = box.x1 - box.x0;
-  v[3] = box.y1 - box.y0;
-}
-
-static inline Box
-box_inset (const Box box,
-           float     dx,
-           float     dy)
-{
-  return (Box) { .x0 = box.x0 + dx, .y0 = box.y0 + dy,
-                 .x1 = box.x1 - dx, .y1 = box.y1 - dy };
-}
-
-static inline gboolean
-box_intersect (const Box  box1,
-               const Box  box2,
-               Box       *box)
-{
-  Box b;
-
-  b.x0 = MAX (box1.x0, box2.x0);
-  b.y0 = MAX (box1.y0, box2.y0);
-  b.x1 = MIN (box1.x1, box2.x1);
-  b.y1 = MIN (box1.y1, box2.y1);
-
-  if (b.x0 <= b.x1 && b.y0 <= b.x1)
-    {
-      if (box)
-        *box = b;
-
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-static inline gboolean
-box_equal (const Box box1,
-           const Box box2)
-{
-  return memcmp (&box1, &box2, sizeof (Box)) == 0;
-}
-
-static inline gboolean
-box_contains (const Box box1,
-              const Box box2)
-{
-  Box box;
-
-  if (box_intersect (box1, box2, &box))
-    return box_equal (box, box2);
-
-  return FALSE;
-}
-
-static inline gboolean
-box_empty (const Box box)
-{
-  return box.x0 == box.x1 || box.y0 == box.y1;
-}
-
-static inline Box
-box_add (const Box   box,
-         const Point offset)
-{
-  return (Box) { .x0 = box.x0 + offset.x, .y0 = box.y0 + offset.y,
-                 .x1 = box.x1 + offset.x, .y1 = box.y1 + offset.y };
-}
-
-static inline Box
-box_sub (const Box   box,
-         const Point offset)
-{
-  return (Box) { .x0 = box.x0 - offset.x, .y0 = box.y0 - offset.y,
-                 .x1 = box.x1 - offset.x, .y1 = box.y1 - offset.y };
-}
-
-static inline Box
-box_mul (const Box   box,
-         const Scale scale)
-{
-  Box b = (Box) { .x0 = box.x0 * scale.x, .y0 = box.y0 * scale.y,
-                  .x1 = box.x1 * scale.x, .y1 = box.y1 * scale.y };
-
-  if (G_UNLIKELY (scale.x < 0 || scale.y < 0))
-    return (Box) { .x0 = MIN (b.x0, b.x1), .y0 = MIN (b.y0, b.y1),
-                   .x1 = MAX (b.x0, b.x1), .y1 = MAX (b.y0, b.y1) };
-
-  return b;
-}
-
-static inline Box
-box_div (const Box   box,
-         const Scale scale)
-{
-  return box_mul (box, scale_inv (scale));
-}
-
-static inline void
-box_offset_to_float (const Box   box,
-                     const Point offset,
-                     float       v[4])
-{
-  box_to_float (box_add (box, offset), v);
-}
-
-static inline Box
-box_round_larger (const Box box)
-{
-  return (Box) { .x0 = floorf (box.x0), .y0 = floorf (box.y0),
-                 .x1 = ceilf (box.x1), .y1 = ceilf (box.y1) };
-}
-
-static inline Box
-box_round_to_pixels (const Box   box,
-                     const Scale scale,
-                     const Point offset)
-{
-  return box_sub (box_div (box_round_larger (box_mul (box_add (box, offset), scale)), scale), offset);
-}
-
-#else  /* USE_SIMD */
-
-struct _Box
-{
-  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
-};
-
-static inline float
-box_x0 (const Box box)
-{
-  return graphene_simd4f_get_x (box.v);
-}
-
-static inline float
-box_y0 (const Box box)
-{
-  return graphene_simd4f_get_y (box.v);
-}
-
-static inline float
-box_x1 (const Box box)
-{
-  return graphene_simd4f_get_z (box.v);
-}
-
-static inline float
-box_y1 (const Box box)
-{
-  return graphene_simd4f_get_w (box.v);
-}
-
-static inline float
-box_width (const Box box)
-{
-  return box_x1 (box) - box_x0 (box);
-}
-
-static inline float
-box_height (const Box box)
-{
-  return box_y1 (box) - box_y0 (box);
-}
-
-static inline Box
-box (float x0,
-     float y0,
-     float x1,
-     float y1)
-{
-  return (Box) { .v = graphene_simd4f_init (x0, y0, x1, y1) };
-}
-
-static inline Box
-box_from_rect (float x,
-               float y,
-               float w,
-               float h)
-{
-  return box (x, y, x + w, y + h);
-}
-
-static inline Box
-box_from_graphene (const graphene_rect_t *rect)
-{
-  return box_from_rect (rect->origin.x,
-                        rect->origin.y,
-                        rect->size.width,
-                        rect->size.height);
-}
-
-/* { a[0], a[1], b[0], b[1] }  */
-#  define graphene_simd4f_splat_xyxy(a,b) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_shuffle_ps ((a), (b), _MM_SHUFFLE (1, 0, 1, 0)); \
-  }))
-
-static inline Box
-box_from_points (Point p0,
-                 Point p1)
-{
-  return (Box) { .v = graphene_simd4f_splat_xyxy (p0.v, p1.v) };
-}
-
-static inline Point
-box_origin (const Box box)
-{
-  return (Point) { .v = graphene_simd4f_zero_zw (box.v) };
-}
-
-static inline Point
-box_opposite (const Box box)
-{
-  return (Point) { .v = graphene_simd4f_zero_zw (graphene_simd4f_shuffle_zwxy (box.v)) };
-}
-
-static inline void
-box_to_float (const Box box,
-              float     v[4])
-{
-  graphene_simd4f_dup_4f (box.v, v);
-  v[2] -= v[0];
-  v[3] -= v[1];
-}
-
-static inline Box
-box_inset (const Box box,
-           float     dx,
-           float     dy)
-{
-  return (Box) { .v = graphene_simd4f_add (box.v, graphene_simd4f_init (dx, dy, -dx, -dy)) };
-}
-
-/* return  a[0] < b[0] && a[1] < b[1] */
-#ifndef graphene_simd4f_cmple_xy
-#  define graphene_simd4f_cmple_xy(a,b) \
-  (__extension__ ({ \
-    __m128i __res = (__m128i) _mm_cmple_ps ((a), (b)); \
-    (bool) ((_mm_movemask_epi8 (__res) & 0xff) == 0xff); \
-  }))
-#endif
-
-static inline gboolean
-box_intersect (const Box  box1,
-               const Box  box2,
-               Box       *box)
-{
-  graphene_simd4f_t s, t, t1;
-
-  s = graphene_simd4f_max (box1.v, box2.v);
-  t = graphene_simd4f_min (box1.v, box2.v);
-  t1 = graphene_simd4f_shuffle_zwxy (t);
-
-  if (graphene_simd4f_cmple_xy (s, t1))
-    {
-      if (box)
-        box->v = graphene_simd4f_splat_xyxy (s, t);
-      return TRUE;
-    }
-
-  return FALSE;
-}
-
-static inline gboolean
-box_equal (const Box box1,
-           const Box box2)
-{
-  return (gboolean) !!graphene_simd4f_cmp_eq (box1.v, box2.v);
-}
-
-static inline gboolean
-box_contains (const Box box1,
-              const Box box2)
-{
-  Box box;
-
-  if (box_intersect (box1, box2, &box))
-    return box_equal (box, box2);
-
-  return FALSE;
-}
-
-static inline gboolean
-box_empty (const Box box)
-{
-  /* FIXME simd */
-  return box_x0 (box) == box_x1 (box) || box_y0 (box) == box_y1 (box);
-}
-
-/* a splat variation */
-#ifndef graphene_simd4f_shuffle_xyxy
-#  define graphene_simd4f_shuffle_xyxy(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_shuffle_ps ((v), (v), _MM_SHUFFLE (1, 0, 1, 0)); \
-  }))
-#endif
-
-static inline Box
-box_add (const Box   box,
-         const Point offset)
-{
-  return (Box) { .v = graphene_simd4f_add (box.v, graphene_simd4f_shuffle_xyxy (offset.v)) };
-}
-
-static inline Box
-box_sub (const Box   box,
-         const Point offset)
-{
-  return (Box) { .v = graphene_simd4f_sub (box.v, graphene_simd4f_shuffle_xyxy (offset.v)) };
-}
-
-static inline Box
-box_mul (const Box   box,
-         const Scale scale)
-{
-  Box b =  (Box) { .v = graphene_simd4f_mul (box.v, graphene_simd4f_shuffle_xyxy (scale.v)) };
-
-  if (G_UNLIKELY (!graphene_simd4f_cmple_xy (graphene_simd4f_init (0, 0, 0, 0), scale.v)))
-    {
-      graphene_simd4f_t v = graphene_simd4f_shuffle_zwxy (b.v);
-      graphene_simd4f_t s = graphene_simd4f_min (b.v, v);
-      graphene_simd4f_t t = graphene_simd4f_max (b.v, v);
-
-      return (Box) { .v = graphene_simd4f_splat_xyxy (s, t) };
-    }
-
-  return b;
-}
-
-static inline Box
-box_div (const Box   box,
-         const Scale scale)
-{
-  return box_mul (box, scale_inv (scale));
-}
-
-static inline void
-box_offset_to_float (const Box   box,
-                     const Point offset,
-                     float       v[4])
-{
-  box_to_float (box_add (box, offset), v);
-}
-
-#ifdef __SSE4_1__
-
-static inline Box
-box_round_larger (const Box box)
-{
-  return { (Box) .v = graphene_simd4f_splat_xyxy (graphene_simd4f_floor (b.v), graphene_simd4f_ceil (b.v)) };
-}
-
-#else
-
-static inline Box
-box_round_larger (const Box b)
-{
-  return box (floorf (box_x0 (b)),
-              floorf (box_y0 (b)),
-              ceilf (box_x1 (b)),
-              ceilf (box_y1 (b)));
-}
-
-#endif
-
-static inline Box
-box_round_to_pixels (const Box   box,
-                     const Scale scale,
-                     const Point offset)
-{
-  return box_sub (box_div (box_round_larger (box_mul (box_add (box, offset), scale)), scale), offset);
-}
-
-#endif

gsk/gpu/gskgpuclip.c

@@ -301,42 +301,3 @@ gsk_gpu_clip_get_shader_clip (const GskGpuClip       *self,
     return GSK_GPU_SHADER_CLIP_ROUNDED;
 }
 
-gboolean
-gsk_gpu_clip_contains_box (const GskGpuClip *self,
-                           const Point      *offset,
-                           const Box        *box)
-{
-  Box b = box_add (*box, *offset);
-
-  switch (self->type)
-    {
-    default:
-      g_assert_not_reached();
-    case GSK_GPU_CLIP_ALL_CLIPPED:
-      return FALSE;
-
-    case GSK_GPU_CLIP_NONE:
-    case GSK_GPU_CLIP_CONTAINED:
-    case GSK_GPU_CLIP_RECT:
-      return box_contains (box_from_graphene (&self->rect.bounds), b);
-
-    case GSK_GPU_CLIP_ROUNDED:
-      return gsk_rounded_rect_contains_rect (&self->rect, &GRAPHENE_RECT_INIT (box_x0 (b), box_y0 (b), box_width (b), box_height (b)));
-    }
-}
-
-GskGpuShaderClip
-gsk_gpu_clip_get_shader_clip2 (const GskGpuClip *self,
-                               const Point      *offset,
-                               const Box        *box)
-{
-  if (self->type == GSK_GPU_CLIP_NONE ||
-      self->type == GSK_GPU_CLIP_CONTAINED ||
-      gsk_gpu_clip_contains_box (self, offset, box))
-    return GSK_GPU_SHADER_CLIP_NONE;
-  else if (self->type == GSK_GPU_CLIP_RECT)
-    return GSK_GPU_SHADER_CLIP_RECT;
-  else
-    return GSK_GPU_SHADER_CLIP_ROUNDED;
-}
-

gsk/gpu/gskgpuclipprivate.h

@@ -5,7 +5,6 @@
 #include <gdk/gdk.h>
 #include <graphene.h>
 #include <gsk/gskroundedrect.h>
-#include "boxprivate.h"
 
 G_BEGIN_DECLS
 
@@ -66,16 +65,9 @@ gboolean                gsk_gpu_clip_contains_rect                      (const G
 gboolean                gsk_gpu_clip_may_intersect_rect                 (const GskGpuClip    *self,
                                                                          const graphene_point_t *offset,
                                                                          const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip       *self,
+GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip    *self,
                                                                          const graphene_point_t *offset,
                                                                          const graphene_rect_t  *rect);
 
-gboolean                gsk_gpu_clip_contains_box                       (const GskGpuClip       *self,
-                                                                         const Point            *offset,
-                                                                         const Box              *box) G_GNUC_WARN_UNUSED_RESULT;
-GskGpuShaderClip        gsk_gpu_clip_get_shader_clip2                   (const GskGpuClip       *self,
-                                                                         const Point            *offset,
-                                                                         const Box              *box);
-
 G_END_DECLS
 

gsk/gpu/gskgpudevice.c

@@ -656,7 +656,6 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
   graphene_point_t origin;
   GskGpuImage *image;
   gsize atlas_x, atlas_y, padding;
-  float subpixel_x, subpixel_y;
 
   cache = g_hash_table_lookup (priv->glyph_cache, &lookup);
   if (cache)
@@ -668,13 +667,11 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
       return cache->image;
     }
 
-  subpixel_x = (flags & 3) / 4.f;
-  subpixel_y = ((flags >> 2) & 3) / 4.f;
   pango_font_get_glyph_extents (font, glyph, &ink_rect, NULL);
-  origin.x = floor (ink_rect.x * scale / PANGO_SCALE + subpixel_x);
-  origin.y = floor (ink_rect.y * scale / PANGO_SCALE + subpixel_y);
-  rect.size.width = ceil ((ink_rect.x + ink_rect.width) * scale / PANGO_SCALE + subpixel_x) - origin.x;
-  rect.size.height = ceil ((ink_rect.y + ink_rect.height) * scale / PANGO_SCALE + subpixel_y) - origin.y;
+  origin.x = floor (ink_rect.x * scale / PANGO_SCALE);
+  origin.y = floor (ink_rect.y * scale / PANGO_SCALE);
+  rect.size.width = ceil ((ink_rect.x + ink_rect.width) * scale / PANGO_SCALE) - origin.x;
+  rect.size.height = ceil ((ink_rect.y + ink_rect.height) * scale / PANGO_SCALE) - origin.y;
   padding = 1;
 
   image = gsk_gpu_device_add_atlas_image (self,
@@ -703,8 +700,8 @@ gsk_gpu_device_lookup_glyph_image (GskGpuDevice           *self,
   cache->scale = scale,
   cache->bounds = rect,
   cache->image = image,
-  cache->origin = GRAPHENE_POINT_INIT (- origin.x + subpixel_x,
-                                       - origin.y + subpixel_y);
+  cache->origin = GRAPHENE_POINT_INIT (- origin.x + (flags & 3) / 4.f,
+                                       - origin.y + ((flags >> 2) & 3) / 4.f);
 
   gsk_gpu_upload_glyph_op (frame,
                            cache->image,

gsk/gpu/gskgpunodeprocessor.c

@@ -43,10 +43,6 @@
 
 #include "gdk/gdkrgbaprivate.h"
 
-#include "scaleprivate.h"
-#include "pointprivate.h"
-#include "boxprivate.h"
-
 /* A note about coordinate systems
  *
  * The rendering code keeps track of multiple coordinate systems to optimize rendering as
@@ -502,18 +498,6 @@ gsk_gpu_pattern_writer_append_rect (GskGpuPatternWriter    *self,
   gsk_gpu_pattern_writer_append (self, G_ALIGNOF (float), (guchar *) f, sizeof (f));
 }
 
-static void
-gsk_gpu_pattern_writer_append_box (GskGpuPatternWriter *self,
-                                   const Box            box,
-                                   const Point          offset)
-{
-  float f[4];
-
-  box_offset_to_float (box, offset, f);
-
-  gsk_gpu_pattern_writer_append (self, G_ALIGNOF (float), (guchar *) f, sizeof (f));
-}
-
 static void
 gsk_gpu_pattern_writer_append_rgba (GskGpuPatternWriter *self,
                                     const GdkRGBA       *rgba)
@@ -2990,11 +2974,10 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
   GskGpuDevice *device;
   const PangoGlyphInfo *glyphs;
   PangoFont *font;
-  Point offset;
-  Scale scale, s4, pango_scale;
+  graphene_point_t offset;
   guint i, num_glyphs;
+  float scale, inv_scale;
   GdkRGBA color;
-  gboolean glyph_align;
 
   if (self->opacity < 1.0 &&
       gsk_text_node_has_color_glyphs (node))
@@ -3003,83 +2986,59 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
       return;
     }
 
-  glyph_align = gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_GLYPH_ALIGN) &&
-                gsk_transform_get_category (self->modelview) >= GSK_TRANSFORM_CATEGORY_2D;
   device = gsk_gpu_frame_get_device (self->frame);
   color = *gsk_text_node_get_color (node);
   color.alpha *= self->opacity;
   num_glyphs = gsk_text_node_get_num_glyphs (node);
   glyphs = gsk_text_node_get_glyphs (node, NULL);
   font = gsk_text_node_get_font (node);
+  offset = *gsk_text_node_get_offset (node);
+  offset.x += self->offset.x;
+  offset.y += self->offset.y;
 
-  offset = point_add (point_from_graphene (gsk_text_node_get_offset (node)),
-                      point_from_graphene (&self->offset));
-  scale = scale_max (scale_from_graphene (&self->scale));
-  s4 = scale_mul (scale, scale_from_float (4));
-  pango_scale = scale_from_float (PANGO_SCALE);
+  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
+  inv_scale = 1.f / scale;
 
   for (i = 0; i < num_glyphs; i++)
     {
       GskGpuImage *image;
-      graphene_rect_t glyph_bds;
-      graphene_point_t glyph_ofs;
-      Box glyph_bounds, glyph_tex_rect;
-      Point g_ofs, glyph_origin;
+      graphene_rect_t glyph_bounds, glyph_tex_rect;
+      graphene_point_t glyph_offset;
       guint32 descriptor;
-      GskGpuGlyphLookupFlags flags;
-
-      glyph_origin = point_add (offset, point_div (point (glyphs[i].geometry.x_offset, glyphs[i].geometry.y_offset), pango_scale));
-
-      if (glyph_align)
-        {
-          glyph_origin = point_round (point_mul (glyph_origin, s4));
-
-          flags = ((int) point_x (glyph_origin) & 3) |
-                  (((int) point_y (glyph_origin) & 3) << 2);
-
-          glyph_origin = point_div (glyph_origin, s4);
-        }
-      else
-        {
-          flags = 0;
-        }
 
       image = gsk_gpu_device_lookup_glyph_image (device,
                                                  self->frame,
                                                  font,
                                                  glyphs[i].glyph,
-                                                 flags,
-                                                 scale_x (scale),
-                                                 &glyph_bds,
-                                                 &glyph_ofs);
-
-      glyph_tex_rect = box_div (box_from_rect (-glyph_bds.origin.x, -glyph_bds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), scale);
-
-      glyph_bounds = box_div (box_from_rect (0, 0, glyph_bds.size.width, glyph_bds.size.height), scale);
-
-      g_ofs = point_from_graphene (&glyph_ofs);
-      glyph_origin = point_sub (glyph_origin, point_div (g_ofs, scale));
+                                                 0,
+                                                 scale,
+                                                 &glyph_bounds,
+                                                 &glyph_offset);
 
+      gsk_rect_scale (&GRAPHENE_RECT_INIT (-glyph_bounds.origin.x, -glyph_bounds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), inv_scale, inv_scale, &glyph_tex_rect);
+      gsk_rect_scale (&GRAPHENE_RECT_INIT(0, 0, glyph_bounds.size.width, glyph_bounds.size.height), inv_scale, inv_scale, &glyph_bounds);
+      glyph_offset = GRAPHENE_POINT_INIT (offset.x - glyph_offset.x * inv_scale + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
+                                          offset.y - glyph_offset.y * inv_scale + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);
       descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT);
       if (glyphs[i].attr.is_color)
         gsk_gpu_texture_op (self->frame,
-                            gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
+                            gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
                             self->desc,
                             descriptor,
-                            &GRAPHENE_RECT_INIT (box_x0 (glyph_bounds), box_y0 (glyph_bounds), box_width (glyph_bounds), box_height (glyph_bounds)),
-                            &GRAPHENE_POINT_INIT (point_x (glyph_origin), point_y (glyph_origin)),
-                            &GRAPHENE_RECT_INIT (box_x0 (glyph_tex_rect), box_y0 (glyph_tex_rect), box_width (glyph_tex_rect), box_height (glyph_tex_rect)));
+                            &glyph_bounds,
+                            &glyph_offset,
+                            &glyph_tex_rect);
       else
         gsk_gpu_colorize_op (self->frame,
-                             gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
+                             gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds),
                              self->desc,
                              descriptor,
-                             &GRAPHENE_RECT_INIT (box_x0 (glyph_bounds), box_y0 (glyph_bounds), box_width (glyph_bounds), box_height (glyph_bounds)),
-                             &GRAPHENE_POINT_INIT (point_x (glyph_origin), point_y (glyph_origin)),
-                             &GRAPHENE_RECT_INIT (box_x0 (glyph_tex_rect), box_y0 (glyph_tex_rect), box_width (glyph_tex_rect), box_height (glyph_tex_rect)),
+                             &glyph_bounds,
+                             &glyph_offset,
+                             &glyph_tex_rect,
                              &color);
 
-      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
+      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
     }
 }
 
@@ -3092,10 +3051,10 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   PangoFont *font;
   guint num_glyphs;
   gsize i;
-  Scale scale, pango_scale;
+  float scale, inv_scale;
   guint32 tex_id;
   GskGpuImage *last_image;
-  Point offset;
+  graphene_point_t offset;
 
   if (gsk_text_node_has_color_glyphs (node))
     return FALSE;
@@ -3104,11 +3063,12 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   num_glyphs = gsk_text_node_get_num_glyphs (node);
   glyphs = gsk_text_node_get_glyphs (node, NULL);
   font = gsk_text_node_get_font (node);
+  offset = *gsk_text_node_get_offset (node);
+  offset.x += self->offset.x;
+  offset.y += self->offset.y;
 
-  offset = point_add (point_from_graphene (gsk_text_node_get_offset (node)),
-                      point_from_graphene (&self->offset));
-  scale = scale_max (scale_from_graphene (&self->scale));
-  pango_scale = scale_from_float (PANGO_SCALE);
+  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
+  inv_scale = 1.f / scale;
 
   gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_GLYPHS);
   gsk_gpu_pattern_writer_append_rgba (self, gsk_text_node_get_color (node));
@@ -3118,20 +3078,17 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   for (i = 0; i < num_glyphs; i++)
     {
       GskGpuImage *image;
-      graphene_rect_t glyph_bds;
-      graphene_point_t glyph_ofs;
-      Point glyph_offset;
-      Box glyph_bounds;
-      Box glyph_tex_rect;
+      graphene_rect_t glyph_bounds;
+      graphene_point_t glyph_offset;
 
       image = gsk_gpu_device_lookup_glyph_image (device,
                                                  self->frame,
                                                  font,
                                                  glyphs[i].glyph,
                                                  0,
-                                                 scale_x (scale),
-                                                 &glyph_bds,
-                                                 &glyph_ofs);
+                                                 scale,
+                                                 &glyph_bounds,
+                                                 &glyph_offset);
 
       if (image != last_image)
         {
@@ -3141,15 +3098,28 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
           last_image = image;
         }
 
-      glyph_offset = point_add (point_sub (offset, point_div (glyph_offset, scale)), point_div (point (glyphs[i].geometry.x_offset, glyphs[i].geometry.y_offset), pango_scale));
+      glyph_offset = GRAPHENE_POINT_INIT (offset.x - glyph_offset.x * inv_scale + (float) glyphs[i].geometry.x_offset / PANGO_SCALE,
+                                          offset.y - glyph_offset.y * inv_scale + (float) glyphs[i].geometry.y_offset / PANGO_SCALE);
 
-      glyph_bounds = box_div (box_from_rect (0, 0, glyph_bds.size.width, glyph_bds.size.height), scale);
-      glyph_tex_rect = box_div (box_from_rect (-glyph_bds.origin.x, - glyph_bds.origin.y, gsk_gpu_image_get_width (image), gsk_gpu_image_get_height (image)), scale);
       gsk_gpu_pattern_writer_append_uint (self, tex_id);
-      gsk_gpu_pattern_writer_append_box (self, glyph_bounds, glyph_offset);
-      gsk_gpu_pattern_writer_append_box (self, glyph_tex_rect, glyph_offset);
+      gsk_gpu_pattern_writer_append_rect (self,
+                                          &GRAPHENE_RECT_INIT (
+                                              0,
+                                              0,
+                                              glyph_bounds.size.width * inv_scale,
+                                              glyph_bounds.size.height * inv_scale
+                                          ),
+                                          &glyph_offset);
+      gsk_gpu_pattern_writer_append_rect (self,
+                                          &GRAPHENE_RECT_INIT (
+                                              - glyph_bounds.origin.x * inv_scale,
+                                              - glyph_bounds.origin.y * inv_scale,
+                                              gsk_gpu_image_get_width (image) * inv_scale,
+                                              gsk_gpu_image_get_height (image) * inv_scale
+                                          ),
+                                          &glyph_offset);
 
-      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
+      offset.x += (float) glyphs[i].geometry.width / PANGO_SCALE;
     }
 
   return TRUE;
@@ -3277,8 +3247,8 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor    *self,
                       rect,
                       &self->offset,
                       &GRAPHENE_RECT_INIT (
-                          clipped_child_bounds.origin.x + x * child_bounds->size.width,
-                          clipped_child_bounds.origin.y + y * child_bounds->size.height,
+                          clipped_child_bounds.origin.x - x * child_bounds->size.width,
+                          clipped_child_bounds.origin.y - y * child_bounds->size.height,
                           clipped_child_bounds.size.width,
                           clipped_child_bounds.size.height
                       ));

gsk/gpu/gskgpurenderer.c

@@ -30,7 +30,6 @@ static const GdkDebugKey gsk_gpu_optimization_keys[] = {
   { "blit", GSK_GPU_OPTIMIZE_BLIT, "Use shaders instead of vkCmdBlit()/glBlitFramebuffer()" },
   { "gradients", GSK_GPU_OPTIMIZE_GRADIENTS, "Don't supersample gradients" },
   { "mipmap", GSK_GPU_OPTIMIZE_MIPMAP, "Avoid creating mipmaps" },
-  { "glyph-align", GSK_GPU_OPTIMIZE_GLYPH_ALIGN, "Never align glyphs to the subpixel grid" },
 
   { "gl-baseinstance", GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE, "Assume no ARB/EXT_base_instance support" },
 };

gsk/gpu/gskgputypesprivate.h

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

gsk/gskrendernodeimpl.c

@@ -4092,7 +4092,6 @@ gsk_repeat_node_draw_tiled (cairo_t                *cr,
                             const graphene_rect_t  *child_bounds)
 {
   cairo_pattern_t *pattern;
-  cairo_matrix_t matrix;
 
   cairo_save (cr);
   /* reset the clip so we get an unclipped pattern for repeating */
@@ -4109,11 +4108,6 @@ gsk_repeat_node_draw_tiled (cairo_t                *cr,
   cairo_restore (cr);
 
   cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
-  cairo_pattern_get_matrix (pattern, &matrix);
-  cairo_matrix_translate (&matrix,
-                          - x * child_bounds->size.width,
-                          - y * child_bounds->size.height);
-  cairo_pattern_set_matrix (pattern, &matrix);
   cairo_set_source (cr, pattern);
   cairo_pattern_destroy (pattern);
 

gsk/gsktypesprivate.h

@@ -1,22 +0,0 @@
-/* GSK - The GTK Scene Kit
- * Copyright 2024 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 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/>.
- */
-
-#pragma once
-
-typedef struct _Scale   Scale;
-typedef struct _Point   Point;
-typedef struct _Box     Box;

gsk/pointprivate.h

@@ -1,252 +0,0 @@
-#pragma once
-
-#include "gsktypesprivate.h"
-#include <graphene.h>
-#include <math.h>
-#include <smmintrin.h>
-
-#include "scaleprivate.h"
-
-#ifndef USE_SIMD
-
-struct _Point
-{
-  float x, y;
-};
-
-static inline float
-point_x (const Point p)
-{
-  return p.x;
-}
-
-static inline float
-point_y (const Point p)
-{
-  return p.y;
-}
-
-static inline Point
-point (float x,
-       float y)
-{
-  return (Point) { .x = x, .y = y };
-}
-
-static inline Point
-point_from_graphene (const graphene_point_t *p)
-{
-  return point (p->x, p->y);
-}
-
-static inline void
-point_to_float (const Point p,
-                float       v[2])
-{
-  v[0] = p.x;
-  v[1] = p.y;
-}
-
-static inline Point
-point_zero (void)
-{
-  return point (0, 0);
-}
-
-static inline Point
-point_neg (const Point p)
-{
-  return (Point) { .x = -p.x, .y = -p.y };
-}
-
-static inline Point
-point_mul (const Point p,
-           const Scale s)
-{
-  return (Point) { .x = p.x * s.x, .y = p.y * s.y };
-}
-
-static inline Point
-point_div (const Point p,
-           const Scale s)
-{
-  return (Point) { .x = p.x / s.x, .y = p.y / s.y };
-}
-
-static inline Point
-point_add (const Point p1,
-           const Point p2)
-{
-  return (Point) { .x = p1.x + p2.x, .y = p1.y + p2.y };
-}
-
-static inline Point
-point_sub (const Point p1,
-           const Point p2)
-{
-  return (Point) { .x = p1.x - p2.x, .y = p1.y - p2.y };
-}
-
-static inline Point
-point_floor (const Point p)
-{
-  return (Point) { .x = floorf (p.x), .y = floorf (p.y) };
-}
-
-static inline Point
-point_ceil (const Point p)
-{
-  return (Point) { .x = ceilf (p.x), .y = ceilf (p.y) };
-}
-
-static inline Point
-point_round (const Point p)
-{
-  return (Point) { .x = roundf (p.x), .y = roundf (p.y) };
-}
-
-#else  /* USE_SIMD */
-
-#include <smmintrin.h>
-
-struct _Point
-{
-  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
-};
-
-static inline float
-point_x (const Point p)
-{
-  return graphene_simd4f_get_x (p.v);
-}
-
-static inline float
-point_y (const Point p)
-{
-  return graphene_simd4f_get_y (p.v);
-}
-
-static inline Point
-point (float x,
-       float y)
-{
-  return (Point) { .v = graphene_simd4f_init (x, y, 0.f, 0.f) };
-}
-
-static inline Point
-point_from_graphene (const graphene_point_t *p)
-{
-  return point (p->x, p->y);
-}
-
-static inline void
-point_to_float (const Point p,
-                float       v[2])
-{
-  graphene_simd4f_dup_2f (p.v, v);
-}
-
-static inline Point
-point_zero (void)
-{
-  return point (0, 0);
-}
-
-static inline Point
-point_neg (const Point p)
-{
-  return (Point) { .v = graphene_simd4f_neg (p.v) };
-}
-
-static inline Point
-point_mul (const Point p,
-           const Scale s)
-{
-  return (Point) { .v = graphene_simd4f_mul (p.v, s.v) };
-}
-
-static inline Point
-point_div (const Point p,
-           const Scale s)
-{
-  return (Point) { .v = graphene_simd4f_div (p.v, s.v) };
-}
-
-static inline Point
-point_add (const Point p1,
-           const Point p2)
-{
-  return (Point) { .v = graphene_simd4f_add (p1.v, p2.v) };
-}
-
-static inline Point
-point_sub (const Point p1,
-           const Point p2)
-{
-  return (Point) { .v = graphene_simd4f_sub (p1.v, p2.v) };
-}
-
-#ifdef __SSE4_1__
-
-#ifndef graphene_simd4f_floor
-#  define graphene_simd4f_floor(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_floor_ps ((v)); \
-  }))
-#endif
-
-#ifndef graphene_simd4f_ceil
-#  define graphene_simd4f_ceil(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_ceil_ps ((v)); \
-  }))
-#endif
-
-#ifndef graphene_simd4f_round
-#  define graphene_simd4f_round(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_round_ps ((v)); \
-  }))
-#endif
-
-static inline Point
-point_floor (const Point p)
-{
-  return (Point) { .v = graphene_simd4f_floor (p.v) };
-}
-
-static inline Point
-point_ceil (const Point p)
-{
-  return (Point) { .v = graphene_simd4f_ceil (p.v) };
-}
-
-static inline Point
-point_round (const Point p)
-{
-  return (Point) { .v = graphene_simd4f_round (p.v) };
-}
-
-#else
-
-static inline Point
-point_floor (const Point p)
-{
-  return point (floorf (point_x (p)), floorf (point_y (p)));
-}
-
-static inline Point
-point_ceil (const Point p)
-{
-  return point (ceilf (point_x (p)), ceilf (point_y (p)));
-}
-
-static inline Point
-point_round (const Point p)
-{
-  return point (roundf (point_x (p)), roundf (point_y (p)));
-}
-
-#endif
-
-#endif

gsk/scaleprivate.h

@@ -1,183 +0,0 @@
-#pragma once
-
-#include "gsktypesprivate.h"
-#include <graphene.h>
-#include <math.h>
-
-#ifndef USE_SIMD
-
-struct _Scale
-{
-  float x, y;
-};
-
-static inline float
-scale_x (const Scale s)
-{
-  return s.x;
-}
-
-static inline float
-scale_y (const Scale s)
-{
-  return s.y;
-}
-
-static inline Scale
-scale (float x,
-       float y)
-{
-  return (Scale) { .x = x, .y = y };
-}
-
-static inline Scale
-scale_from_float (float s)
-{
-  return scale (s, s);
-}
-
-static inline Scale
-scale_from_graphene (const graphene_vec2_t *v)
-{
-  return (Scale) { .x = graphene_vec2_get_x (v), .y = graphene_vec2_get_y (v) };
-}
-
-static inline void
-scale_to_float (const Scale s,
-                float       v[2])
-{
-  v[0] = s.x;
-  v[1] = s.y;
-}
-
-static inline gboolean
-scale_equal (const Scale s1,
-             const Scale s2)
-{
-  return (gboolean) (s1.x == s2.x && s1.y == s2.y);
-}
-
-static inline Scale
-scale_one (void)
-{
-  return scale (1, 1);
-}
-
-static inline Scale
-scale_inv (const Scale s)
-{
-  return (Scale) { .x = 1 / s.x, .y = 1 / s.y };
-}
-
-static inline Scale
-scale_mul (const Scale s1,
-           const Scale s2)
-{
-  return (Scale) { .x = s1.x * s2.x, .y = s1.y * s2.y };
-}
-
-static inline Scale
-scale_div (const Scale s1,
-           const Scale s2)
-{
-  return (Scale) { .x = s1.x / s2.x, .y = s1.y / s2.y };
-}
-
-static inline Scale
-scale_max (const Scale s)
-{
-  return (Scale) { .x = MAX (s.x, s.y), .y = MAX (s.x, s.y) };
-}
-
-#else  /* USE_SIMD */
-
-struct _Scale
-{
-  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
-};
-
-static inline float
-scale_x (const Scale s)
-{
-  return graphene_simd4f_get_x (s.v);
-}
-
-static inline float
-scale_y (const Scale s)
-{
-  return graphene_simd4f_get_y (s.v);
-}
-
-static inline Scale
-scale (float x,
-       float y)
-{
-  return (Scale) { .v = graphene_simd4f_init (x, y, 0.f, 0.f) };
-}
-
-static inline Scale
-scale_from_float (float s)
-{
-  return scale (s, s);
-}
-
-static inline Scale
-scale_from_graphene (const graphene_vec2_t *v)
-{
-  return (Scale) { .v = v->__graphene_private_value };
-}
-
-static inline void
-scale_to_float (const Scale s,
-                float       v[2])
-{
-  graphene_simd4f_dup_2f (s.v, v);
-}
-
-static inline gboolean
-scale_equal (const Scale s1,
-             const Scale s2)
-{
-  return (gboolean) graphene_simd4f_cmp_eq (s1.v, s2.v);
-}
-
-static inline Scale
-scale_one (void)
-{
-  return scale (1, 1);
-}
-
-static inline Scale
-scale_inv (const Scale s)
-{
-  return (Scale) { .v = graphene_simd4f_reciprocal (s.v) };
-}
-
-static inline Scale
-scale_mul (const Scale s1,
-           const Scale s2)
-{
-  return (Scale) { .v = graphene_simd4f_mul (s1.v, s2.v) };
-}
-
-static inline Scale
-scale_div (const Scale s1,
-           const Scale s2)
-{
-  return (Scale) { .v = graphene_simd4f_div (s1.v, s2.v) };
-}
-
-#ifndef graphene_simd4f_shuffle_yxzw
-#  define graphene_simd4f_shuffle_yxzw(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_shuffle_ps ((v), (v), _MM_SHUFFLE (3, 2, 0, 1)); \
-  }))
-#endif
-
-static inline Scale
-scale_max (const Scale s)
-{
-  return (Scale) { .v = graphene_simd4f_max (graphene_simd4f_shuffle_yxzw (s.v), s.v) };
-}
-
-#endif

testsuite/gsk/compare/repeat-node-tiling-horizontal.node

@@ -1,9 +0,0 @@
-repeat {
-  bounds: 105 0 80 100;
-  child: linear-gradient {
-    bounds: 0 0 50 10;
-    start: 0 0;
-    end: 50 0;
-    stops: 0.5 rgb(255,0,0), 0.5 rgb(0,255,0);
-  }
-}

testsuite/gsk/compare/repeat-node-tiling-vertical.node

@@ -1,9 +0,0 @@
-repeat {
-  bounds: 0 105 100 80;
-  child: linear-gradient {
-    bounds: 0 0 10 50;
-    start: 0 0;
-    end: 0 50;
-    stops: 0.5 rgb(255,0,0), 0.5 rgb(0,255,0);
-  }
-}

testsuite/gsk/meson.build

@@ -116,8 +116,6 @@ compare_render_tests = [
   'repeat-huge-overdraw',
   'repeat-negative-coords',
   'repeat-no-repeat',
-  'repeat-node-tiling-horizontal',
-  'repeat-node-tiling-vertical',
   'repeat-repeats',
   'repeat-repeats-nested-nogl',
   'repeat-scaling',
@@ -141,8 +139,6 @@ compare_render_tests = [
   'stroke-fractional-translate-nogl',
   'stroke-opacity',
   'stroke-with-3d-contents-nogl-nocairo',
-  'subpixel-positioning',
-  'subpixel-positioning-hidpi-nogl-nocairo',
   'text-color-mix',
   'text-glyph-lsb',
   'text-mixed-color-nocairo',