Add an simd implementation

This is strongly based on graphenes simd plumbing.
All three types get represented as graphene_simf4d_t,
scale as {x,y,0,0}, point as {x,y,0,0} and box as
{x0,y0,x1,y1}.

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

@@ -1567,23 +1567,6 @@ 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,
@@ -1660,8 +1643,6 @@ 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

@@ -222,7 +222,6 @@ gdk_parse_debug_var (const char        *variable,
         }
       else
         {
-          char *val = g_strndup (p, q - p);
           for (i = 0; i < nkeys; i++)
             {
               if (strlen (keys[i].key) == q - p &&
@@ -233,8 +232,7 @@ gdk_parse_debug_var (const char        *variable,
                 }
             }
           if (i == nkeys)
-            fprintf (stderr, "Unrecognized value \"%s\". Try %s=help\n", val, variable);
-          g_free (val);
+            fprintf (stderr, "Unrecognized value \"%.*s\". Try %s=help\n", (int) (q - p), p, variable);
          }
 
       p = q;

gdk/gdkdisplay.c

@@ -1363,7 +1363,7 @@ gdk_display_init_gl (GdkDisplay *self)
       return;
     }
 
-  gdk_profiler_end_mark (before2, "realize OpenGL context", NULL);
+  gdk_profiler_end_mark (before2, "Realize OpenGL context", NULL);
 
   /* Only assign after realize, so GdkGLContext::realize() can use
    * gdk_display_get_gl_context() == NULL to differentiate between
@@ -1373,7 +1373,7 @@ gdk_display_init_gl (GdkDisplay *self)
 
   gdk_gl_backend_use (GDK_GL_CONTEXT_GET_CLASS (context)->backend_type);
 
-  gdk_profiler_end_mark (before, "initialize OpenGL", NULL);
+  gdk_profiler_end_mark (before, "Init OpenGL", NULL);
 }
 
 /**
@@ -1768,7 +1768,6 @@ gdk_display_init_egl (GdkDisplay  *self,
 {
   GdkDisplayPrivate *priv = gdk_display_get_instance_private (self);
   G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
-  G_GNUC_UNUSED gint64 start_time2;
   int major, minor;
 
   if (!gdk_gl_backend_can_be_used (GDK_GL_EGL, error))
@@ -1795,7 +1794,6 @@ gdk_display_init_egl (GdkDisplay  *self,
       return FALSE;
     }
 
-  start_time2 = GDK_PROFILER_CURRENT_TIME;
   if (!eglInitialize (priv->egl_display, &major, &minor))
     {
       priv->egl_display = NULL;
@@ -1804,7 +1802,6 @@ gdk_display_init_egl (GdkDisplay  *self,
                            _("Could not initialize EGL display"));
       return FALSE;
     }
-  gdk_profiler_end_mark (start_time2, "eglInitialize", NULL);
 
   if (major < GDK_EGL_MIN_VERSION_MAJOR ||
       (major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
@@ -1894,7 +1891,7 @@ gdk_display_init_egl (GdkDisplay  *self,
       g_free (ext);
     }
 
-  gdk_profiler_end_mark (start_time, "init EGL", NULL);
+  gdk_profiler_end_mark (start_time, "Init EGL", NULL);
 
   return TRUE;
 }

gdk/gdkframeclock.c

@@ -687,7 +687,7 @@ _gdk_frame_clock_emit_update (GdkFrameClock *frame_clock)
 
   g_signal_emit (frame_clock, signals[UPDATE], 0);
 
-  gdk_profiler_end_mark (before, "frameclock update", NULL);
+  gdk_profiler_end_mark (before, "Frameclock update", NULL);
 }
 
 void
@@ -699,7 +699,7 @@ _gdk_frame_clock_emit_layout (GdkFrameClock *frame_clock)
 
   g_signal_emit (frame_clock, signals[LAYOUT], 0);
 
-  gdk_profiler_end_mark (before, "frameclock layout", NULL);
+  gdk_profiler_end_mark (before, "Frameclock layout", NULL);
 }
 
 void
@@ -711,7 +711,7 @@ _gdk_frame_clock_emit_paint (GdkFrameClock *frame_clock)
 
   g_signal_emit (frame_clock, signals[PAINT], 0);
 
-  gdk_profiler_end_mark (before, "frameclock paint", NULL);
+  gdk_profiler_end_mark (before, "Frameclock paint", NULL);
 }
 
 void
@@ -811,12 +811,12 @@ _gdk_frame_clock_add_timings_to_profiler (GdkFrameClock   *clock,
 {
   if (timings->drawn_time != 0)
     {
-      gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "drawn window", NULL);
+      gdk_profiler_add_mark (1000 * timings->drawn_time, 0, "Drawn window", NULL);
     }
 
   if (timings->presentation_time != 0)
     {
-      gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "presented window", NULL);
+      gdk_profiler_add_mark (1000 * timings->presentation_time, 0, "Presented window", NULL);
     }
 
   gdk_profiler_set_counter (fps_counter, gdk_frame_clock_get_fps (clock));

gdk/gdkframeclockidle.c

@@ -694,7 +694,7 @@ gdk_frame_clock_paint_idle (void *data)
   if (!gdk_frame_clock_idle_is_frozen (clock_idle))
     priv->sleep_serial = get_sleep_serial ();
 
-  gdk_profiler_end_mark (before, "frameclock cycle", NULL);
+  gdk_profiler_end_mark (before, "Frameclock cycle", NULL);
 
   return FALSE;
 }

gdk/gdkglcontext.c

@@ -386,7 +386,7 @@ gdk_gl_context_create_egl_context (GdkGLContext *context,
   else if (epoxy_has_egl_extension (egl_display, "EGL_EXT_swap_buffers_with_damage"))
     priv->eglSwapBuffersWithDamage = (gpointer) epoxy_eglGetProcAddress ("eglSwapBuffersWithDamageEXT");
 
-  gdk_profiler_end_mark (start_time, "realize GdkWaylandGLContext", NULL);
+  gdk_profiler_end_mark (start_time, "Create EGL context", NULL);
 
   return api;
 }
@@ -669,7 +669,7 @@ gdk_gl_context_real_end_frame (GdkDrawContext *draw_context,
 
   egl_surface = gdk_surface_get_egl_surface (surface);
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "EGL", "swap buffers");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "EGL swap buffers", NULL);
 
   if (priv->eglSwapBuffersWithDamage)
     {
@@ -2042,15 +2042,6 @@ gdk_gl_context_has_sync (GdkGLContext *self)
   return priv->has_sync;
 }
 
-/* Return if GL_BGRA works with glTexImage2D */
-gboolean
-gdk_gl_context_has_bgra (GdkGLContext *self)
-{
-  GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
-
-  return priv->has_bgra;
-}
-
 /* Return if glGenVertexArrays, glBindVertexArray and glDeleteVertexArrays
  * can be used
  */

gdk/gdkglcontextprivate.h

@@ -171,8 +171,6 @@ gboolean                gdk_gl_context_has_vertex_half_float    (GdkGLContext
 
 gboolean                gdk_gl_context_has_sync                 (GdkGLContext    *self) G_GNUC_PURE;
 
-gboolean                gdk_gl_context_has_bgra                 (GdkGLContext    *self) G_GNUC_PURE;
-
 gboolean                gdk_gl_context_has_vertex_arrays        (GdkGLContext    *self) G_GNUC_PURE;
 
 double                  gdk_gl_context_get_scale                (GdkGLContext    *self);

gdk/gdkprofiler.c

@@ -32,6 +32,7 @@
 #include "version/gdkversionmacros.h"
 #include "gdkframeclockprivate.h"
 
+#define CATEGORY "GTK"
 
 gboolean
 gdk_profiler_is_running (void)
@@ -50,7 +51,7 @@ void
                          const char *message)
 {
 #ifdef HAVE_SYSPROF
-  sysprof_collector_mark (begin_time, duration, "gtk", name, message);
+  sysprof_collector_mark (begin_time, duration, CATEGORY, name, message);
 #endif
 }
 
@@ -60,7 +61,7 @@ void
                          const char *message)
 {
 #ifdef HAVE_SYSPROF
-  sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message);
+  sysprof_collector_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, CATEGORY, name, message);
 #endif
 }
 
@@ -74,7 +75,7 @@ void
 #ifdef HAVE_SYSPROF
   va_list args;
   va_start (args, message_format);
-  sysprof_collector_mark_vprintf (begin_time, duration, "gtk", name, message_format, args);
+  sysprof_collector_mark_vprintf (begin_time, duration, CATEGORY, name, message_format, args);
   va_end (args);
 #endif  /* HAVE_SYSPROF */
 }
@@ -88,7 +89,7 @@ void
 #ifdef HAVE_SYSPROF
   va_list args;
   va_start (args, message_format);
-  sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "gtk", name, message_format, args);
+  sysprof_collector_mark_vprintf (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, CATEGORY, name, message_format, args);
   va_end (args);
 #endif  /* HAVE_SYSPROF */
 }
@@ -103,7 +104,7 @@ guint
   counter.id = sysprof_collector_request_counters (1);
   counter.type = SYSPROF_CAPTURE_COUNTER_DOUBLE;
   counter.value.vdbl = 0.0;
-  g_strlcpy (counter.category, "gtk", sizeof counter.category);
+  g_strlcpy (counter.category, CATEGORY, sizeof counter.category);
   g_strlcpy (counter.name, name, sizeof counter.name);
   g_strlcpy (counter.description, description, sizeof counter.name);
 
@@ -125,7 +126,7 @@ guint
   counter.id = sysprof_collector_request_counters (1);
   counter.type = SYSPROF_CAPTURE_COUNTER_INT64;
   counter.value.v64 = 0;
-  g_strlcpy (counter.category, "gtk", sizeof counter.category);
+  g_strlcpy (counter.category, CATEGORY, sizeof counter.category);
   g_strlcpy (counter.name, name, sizeof counter.name);
   g_strlcpy (counter.description, description, sizeof counter.name);
 

gdk/gdksurface.c

@@ -2839,7 +2839,7 @@ add_event_mark (GdkEvent *event,
   class = g_type_class_ref (GDK_TYPE_EVENT_TYPE);
   value = g_enum_get_value (class, event_type);
   g_type_class_unref (class);
-  kind = value ? value->value_nick : "event";
+  kind = value ? value->value_nick : "Event";
 
   switch ((int) event_type)
     {
@@ -2909,7 +2909,7 @@ add_event_mark (GdkEvent *event,
       break;
     }
 
-  gdk_profiler_add_mark (time, end_time - time, "event", message ? message : kind);
+  gdk_profiler_add_mark (time, end_time - time, "Event", message ? message : kind);
 
   g_free (message);
 #endif

gdk/loaders/gdkjpeg.c

@@ -237,7 +237,7 @@ gdk_load_jpeg (GBytes  *input_bytes,
 
   g_bytes_unref (bytes);
 
-  gdk_profiler_end_mark (before, "jpeg load", NULL);
+  gdk_profiler_end_mark (before, "Load jpeg", NULL);
  
   return texture;
 }

gdk/loaders/gdkpng.c

@@ -304,7 +304,7 @@ gdk_load_png (GBytes  *bytes,
     {
       gint64 end = GDK_PROFILER_CURRENT_TIME;
       if (end - before > 500000)
-        gdk_profiler_add_mark (before, end - before, "png load", NULL);
+        gdk_profiler_add_mark (before, end - before, "Load png", NULL);
     }
 
   return texture;

gdk/loaders/gdktiff.c

@@ -504,7 +504,7 @@ gdk_load_tiff (GBytes  *input_bytes,
     {
       gint64 end = GDK_PROFILER_CURRENT_TIME;
       if (end - before > 500000)
-        gdk_profiler_add_mark (before, end - before, "tiff load", NULL);
+        gdk_profiler_add_mark (before, end - before, "Load tiff", NULL);
     }
 
   return texture;

gdk/wayland/gdkcairocontext-wayland.c

@@ -186,7 +186,7 @@ gdk_wayland_cairo_context_end_frame (GdkDrawContext *draw_context,
   gdk_wayland_surface_attach_image (surface, self->paint_surface, painted);
   gdk_wayland_surface_request_frame (surface);
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
   gdk_wayland_surface_commit (surface);
   gdk_wayland_surface_notify_committed (surface);
 
@@ -206,7 +206,7 @@ gdk_wayland_cairo_context_empty_frame (GdkDrawContext *draw_context)
   gdk_wayland_surface_sync (surface);
   gdk_wayland_surface_request_frame (surface);
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
   gdk_wayland_surface_commit (surface);
   gdk_wayland_surface_notify_committed (surface);
 }

gdk/wayland/gdkdisplay-wayland.c

@@ -1253,7 +1253,7 @@ _gdk_wayland_display_load_cursor_theme (GdkWaylandDisplay *display_wayland)
   gdk_wayland_display_set_cursor_theme (GDK_DISPLAY (display_wayland), name, size);
   g_value_unset (&v);
 
-  gdk_profiler_end_mark (before, "wayland", "load cursor theme");
+  gdk_profiler_end_mark (before, "Wayland cursor theme load", NULL);
 
 }
 

gdk/wayland/gdkpopup-wayland.c

@@ -1012,7 +1012,7 @@ gdk_wayland_surface_create_xdg_popup (GdkWaylandPopup *wayland_popup,
         }
     }
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
   wl_surface_commit (impl->display_server.wl_surface);
 
   if (GDK_IS_POPUP (surface))

gdk/wayland/gdksurface-wayland.c

@@ -274,7 +274,7 @@ gdk_wayland_surface_frame_callback (GdkSurface *surface,
   GdkFrameClock *clock = gdk_surface_get_frame_clock (surface);
   GdkFrameTimings *timings;
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "frame event");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland frame event", NULL);
   GDK_DISPLAY_DEBUG (GDK_DISPLAY (display_wayland), EVENTS, "frame %p", surface);
 
   g_clear_pointer (&impl->frame_callback, wl_callback_destroy);

gdk/wayland/gdktoplevel-wayland.c

@@ -830,7 +830,7 @@ gdk_wayland_surface_create_xdg_toplevel (GdkWaylandToplevel *wayland_toplevel)
   maybe_set_gtk_surface_dbus_properties (wayland_toplevel);
   maybe_set_gtk_surface_modal (wayland_toplevel);
 
-  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "surface commit");
+  gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "Wayland surface commit", NULL);
   wl_surface_commit (wayland_surface->display_server.wl_surface);
 }
 

gsk/boxprivate.h

@@ -0,0 +1,479 @@
+#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/gl/gskglcommandqueue.c

@@ -1608,8 +1608,8 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
 
   if (gdk_profiler_is_running ())
     {
-      gdk_profiler_add_markf (start_time, GDK_PROFILER_CURRENT_TIME-start_time,
-                              "Download Texture chunk",
+      gdk_profiler_end_markf (start_time,
+                              "Download texture chunk",
                               "Tile %dx%d Size %dx%d", x, y, width, height);
       start_time = GDK_PROFILER_CURRENT_TIME;
     }
@@ -1654,8 +1654,8 @@ gsk_gl_command_queue_do_upload_texture_chunk (GskGLCommandQueue *self,
   g_bytes_unref (bytes);
 
   if (gdk_profiler_is_running ())
-    gdk_profiler_add_markf (start_time, GDK_PROFILER_CURRENT_TIME-start_time,
-                            "Upload Texture chunk",
+    gdk_profiler_end_markf (start_time,
+                            "Upload texture chunk",
                             "Tile %dx%d Size %dx%d", x, y, width, height);
 }
 

gsk/gl/gskgldriver.c

@@ -424,7 +424,7 @@ gsk_gl_driver_load_programs (GskGLDriver  *self,
 failure:
   g_clear_object (&compiler);
 
-  gdk_profiler_end_mark (start_time, "load programs", NULL);
+  gdk_profiler_end_mark (start_time, "Load GL programs", NULL);
 
   return ret;
 }
@@ -477,7 +477,7 @@ gsk_gl_driver_new (GskGLCommandQueue  *command_queue,
   self->icons_library = gsk_gl_icon_library_new (self);
   self->shadows_library = gsk_gl_shadow_library_new (self);
 
-  gdk_profiler_end_mark (before, "create GskGLDriver", NULL);
+  gdk_profiler_end_mark (before, "Create GL driver", NULL);
 
   return g_steal_pointer (&self);
 }

gsk/gl/gskglglyphlibrary.c

@@ -119,11 +119,7 @@ gsk_gl_glyph_library_init_atlas (GskGLTextureLibrary *self,
 
   memset (pixel_data, 255, sizeof pixel_data);
 
-  if (!gdk_gl_context_has_bgra (gdk_gl_context_get_current ())
-#if G_BYTE_ORDER == G_BIG_ENDIAN
-      || gdk_gl_context_get_use_es (gdk_gl_context_get_current ())
-#endif
-     )
+  if (gdk_gl_context_get_use_es (gdk_gl_context_get_current ()))
     {
       gl_format = GL_RGBA;
       gl_type = GL_UNSIGNED_BYTE;
@@ -380,7 +376,7 @@ gsk_gl_glyph_library_upload_glyph (GskGLGlyphLibrary     *self,
     {
       char message[64];
       g_snprintf (message, sizeof message, "Size %dx%d", width, height);
-      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload Glyph", message);
+      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload glyph", message);
     }
 }
 

gsk/gl/gskgliconlibrary.c

@@ -211,6 +211,6 @@ gsk_gl_icon_library_add (GskGLIconLibrary     *self,
     {
       char message[64];
       g_snprintf (message, sizeof message, "Size %dx%d", width, height);
-      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload Icon", message);
+      gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Upload icon", message);
     }
 }

gsk/gl/gskglrenderjob.c

@@ -4544,7 +4544,7 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
   gsk_gl_render_job_visit_node (job, root);
   gdk_gl_context_pop_debug_group (job->command_queue->context);
 
-  gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Build GL command queue", "");
+  gdk_profiler_end_mark (start_time, "Build GL command queue", "");
 
 #if 0
   /* At this point the atlases have uploaded content while we processed
@@ -4562,7 +4562,7 @@ gsk_gl_render_job_render (GskGLRenderJob *job,
   gdk_gl_context_push_debug_group (job->command_queue->context, "Executing command queue");
   gsk_gl_command_queue_execute (job->command_queue, surface_height, scale, job->region, job->default_framebuffer);
   gdk_gl_context_pop_debug_group (job->command_queue->context);
-  gdk_profiler_add_mark (start_time, GDK_PROFILER_CURRENT_TIME-start_time, "Execute GL command queue", "");
+  gdk_profiler_end_mark (start_time, "Execute GL command queue", "");
 }
 
 static int

gsk/gpu/gskgpublendmodeop.c

@@ -60,7 +60,7 @@ gsk_gpu_blend_mode_op (GskGpuFrame            *frame,
                        GskGpuShaderClip        clip,
                        GskGpuDescriptors      *desc,
                        const graphene_rect_t  *rect,
-                       const GskPoint         *offset,
+                       const graphene_point_t *offset,
                        float                   opacity,
                        GskBlendMode            blend_mode,
                        guint32                 bottom_descriptor,

gsk/gpu/gskgpublendmodeopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_blend_mode_op                           (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          GskBlendMode                    blend_mode,
                                                                          guint32                         start_descriptor,

gsk/gpu/gskgpublurop.c

@@ -63,9 +63,9 @@ gsk_gpu_blur_op_full (GskGpuFrame            *frame,
                       GskGpuDescriptors      *desc,
                       guint32                 descriptor,
                       const graphene_rect_t  *rect,
-                      const GskPoint         *offset,
+                      const graphene_point_t *offset,
                       const graphene_rect_t  *tex_rect,
-                      const graphene_point_t *blur_direction,
+                      const graphene_vec2_t  *blur_direction,
                       const GdkRGBA          *blur_color)
 {
   GskGpuBlurInstance *instance;
@@ -79,8 +79,7 @@ gsk_gpu_blur_op_full (GskGpuFrame            *frame,
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect);
-  instance->blur_direction[0] = blur_direction->x;
-  instance->blur_direction[1] = blur_direction->y;
+  graphene_vec2_to_float (blur_direction, instance->blur_direction);
   gsk_gpu_rgba_to_float (blur_color, instance->blur_color);
   instance->tex_id = descriptor;
 }
@@ -91,9 +90,9 @@ gsk_gpu_blur_op (GskGpuFrame            *frame,
                  GskGpuDescriptors      *desc,
                  guint32                 descriptor,
                  const graphene_rect_t  *rect,
-                 const GskPoint         *offset,
+                 const graphene_point_t *offset,
                  const graphene_rect_t  *tex_rect,
-                 const graphene_point_t *blur_direction)
+                 const graphene_vec2_t  *blur_direction)
 {
   gsk_gpu_blur_op_full (frame,
                         0,
@@ -113,9 +112,9 @@ gsk_gpu_blur_shadow_op (GskGpuFrame            *frame,
                         GskGpuDescriptors      *desc,
                         guint32                 descriptor,
                         const graphene_rect_t  *rect,
-                        const GskPoint         *offset,
+                        const graphene_point_t *offset,
                         const graphene_rect_t  *tex_rect,
-                        const graphene_point_t *blur_direction,
+                        const graphene_vec2_t  *blur_direction,
                         const GdkRGBA          *shadow_color)
 {
   gsk_gpu_blur_op_full (frame,

gsk/gpu/gskgpubluropprivate.h

@@ -11,18 +11,18 @@ void                    gsk_gpu_blur_op                                 (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect,
-                                                                         const graphene_point_t         *blur_direction);
+                                                                         const graphene_vec2_t          *blur_direction);
 
 void                    gsk_gpu_blur_shadow_op                          (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect,
-                                                                         const graphene_point_t         *blur_direction,
+                                                                         const graphene_vec2_t          *blur_direction,
                                                                          const GdkRGBA                  *shadow_color);
 
 

gsk/gpu/gskgpuborderop.c

@@ -103,7 +103,7 @@ void
 gsk_gpu_border_op (GskGpuFrame            *frame,
                    GskGpuShaderClip        clip,
                    const GskRoundedRect   *outline,
-                   const GskPoint         *offset,
+                   const graphene_point_t *offset,
                    const graphene_point_t *inside_offset,
                    const float             widths[4],
                    const GdkRGBA           colors[4])
@@ -118,7 +118,7 @@ gsk_gpu_border_op (GskGpuFrame            *frame,
                            NULL,
                            &instance);
 
-  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_rounded_rect_to_float (outline, offset, instance->outline);
 
   for (i = 0; i < 4; i++)
     {

gsk/gpu/gskgpuborderopprivate.h

@@ -10,7 +10,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_border_op                               (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          const GskRoundedRect           *outline,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_point_t         *inside_offset,
                                                                          const float                     widths[4],
                                                                          const GdkRGBA                   colors[4]);

gsk/gpu/gskgpuboxshadowop.c

@@ -86,7 +86,7 @@ gsk_gpu_box_shadow_op (GskGpuFrame            *frame,
                        const graphene_point_t *shadow_offset,
                        float                   spread,
                        float                   blur_radius,
-                       const GskPoint         *offset,
+                       const graphene_point_t *offset,
                        const GdkRGBA          *color)
 {
   GskGpuBoxshadowInstance *instance;
@@ -102,10 +102,11 @@ gsk_gpu_box_shadow_op (GskGpuFrame            *frame,
                            &instance);
 
   gsk_gpu_rect_to_float (bounds, offset, instance->bounds);
-  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_rounded_rect_to_float (outline, offset, instance->outline);
   gsk_gpu_rgba_to_float (color, instance->color);
   instance->shadow_offset[0] = shadow_offset->x;
   instance->shadow_offset[1] = shadow_offset->y;
   instance->shadow_spread = spread;
   instance->blur_radius = blur_radius;
 }
+

gsk/gpu/gskgpuboxshadowopprivate.h

@@ -15,7 +15,7 @@ void                    gsk_gpu_box_shadow_op                                  (
                                                                                 const graphene_point_t         *shadow_offset,
                                                                                 float                           spread,
                                                                                 float                           blur_radius,
-                                                                                const GskPoint                 *offset,
+                                                                                const graphene_point_t         *offset,
                                                                                 const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpuclip.c

@@ -238,10 +238,12 @@ gsk_gpu_clip_transform (GskGpuClip            *dest,
 
 gboolean
 gsk_gpu_clip_may_intersect_rect (const GskGpuClip       *self,
-                                 const GskPoint         *offset,
+                                 const graphene_point_t *offset,
                                  const graphene_rect_t  *rect)
 {
-  graphene_rect_t r = gsk_rect_add_offset (*rect, *offset);
+  graphene_rect_t r = *rect;
+  r.origin.x += offset->x;
+  r.origin.y += offset->y;
 
   switch (self->type)
     {
@@ -260,10 +262,12 @@ gsk_gpu_clip_may_intersect_rect (const GskGpuClip       *self,
 
 gboolean
 gsk_gpu_clip_contains_rect (const GskGpuClip       *self,
-                            const GskPoint         *offset,
+                            const graphene_point_t *offset,
                             const graphene_rect_t  *rect)
 {
-  graphene_rect_t r = gsk_rect_add_offset (*rect, *offset);
+  graphene_rect_t r = *rect;
+  r.origin.x += offset->x;
+  r.origin.y += offset->y;
 
   switch (self->type)
     {
@@ -284,7 +288,7 @@ gsk_gpu_clip_contains_rect (const GskGpuClip       *self,
 
 GskGpuShaderClip
 gsk_gpu_clip_get_shader_clip (const GskGpuClip       *self,
-                              const GskPoint         *offset,
+                              const graphene_point_t *offset,
                               const graphene_rect_t  *rect)
 {
   if (self->type == GSK_GPU_CLIP_NONE ||
@@ -297,3 +301,42 @@ 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,6 +5,7 @@
 #include <gdk/gdk.h>
 #include <graphene.h>
 #include <gsk/gskroundedrect.h>
+#include "boxprivate.h"
 
 G_BEGIN_DECLS
 
@@ -59,15 +60,22 @@ gboolean                gsk_gpu_clip_transform                          (GskGpuC
                                                                          GskTransform           *transform,
                                                                          const graphene_rect_t  *viewport) G_GNUC_WARN_UNUSED_RESULT;
 
-gboolean                gsk_gpu_clip_contains_rect                      (const GskGpuClip       *self,
-                                                                         const GskPoint         *offset,
+gboolean                gsk_gpu_clip_contains_rect                      (const GskGpuClip    *self,
+                                                                         const graphene_point_t *offset,
                                                                          const graphene_rect_t  *rect) G_GNUC_WARN_UNUSED_RESULT;
-gboolean                gsk_gpu_clip_may_intersect_rect                 (const GskGpuClip      *self,
-                                                                         const GskPoint        *offset,
-                                                                         const graphene_rect_t *rect) G_GNUC_WARN_UNUSED_RESULT;
-GskGpuShaderClip        gsk_gpu_clip_get_shader_clip                    (const GskGpuClip      *self,
-                                                                         const GskPoint        *offset,
-                                                                         const graphene_rect_t *rect);
+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,
+                                                                         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/gskgpucolorizeop.c

@@ -59,7 +59,7 @@ gsk_gpu_colorize_op (GskGpuFrame            *frame,
                      GskGpuDescriptors      *descriptors,
                      guint32                 descriptor,
                      const graphene_rect_t  *rect,
-                     const GskPoint         *offset,
+                     const graphene_point_t *offset,
                      const graphene_rect_t  *tex_rect,
                      const GdkRGBA          *color)
 {

gsk/gpu/gskgpucolorizeopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_colorize_op                             (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          const GdkRGBA                  *color);
 

gsk/gpu/gskgpucolormatrixop.c

@@ -58,7 +58,7 @@ gsk_gpu_color_matrix_op (GskGpuFrame             *frame,
                          GskGpuDescriptors       *desc,
                          guint32                  descriptor,
                          const graphene_rect_t   *rect,
-                         const GskPoint          *offset,
+                         const graphene_point_t  *offset,
                          const graphene_rect_t   *tex_rect,
                          const graphene_matrix_t *color_matrix,
                          const graphene_vec4_t   *color_offset)
@@ -85,7 +85,7 @@ gsk_gpu_color_matrix_op_opacity (GskGpuFrame             *frame,
                                  GskGpuDescriptors       *desc,
                                  guint32                  descriptor,
                                  const graphene_rect_t   *rect,
-                                 const GskPoint          *offset,
+                                 const graphene_point_t  *offset,
                                  const graphene_rect_t   *tex_rect,
                                  float                    opacity)
 {

gsk/gpu/gskgpucolormatrixopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_color_matrix_op                         (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          const graphene_matrix_t        *color_matrix,
                                                                          const graphene_vec4_t          *color_offset);
@@ -21,7 +21,7 @@ void                    gsk_gpu_color_matrix_op_opacity                 (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect,
                                                                          float                           opacity);
 

gsk/gpu/gskgpucolorop.c

@@ -57,7 +57,7 @@ void
 gsk_gpu_color_op (GskGpuFrame            *frame,
                   GskGpuShaderClip        clip,
                   const graphene_rect_t  *rect,
-                  const GskPoint         *offset,
+                  const graphene_point_t *offset,
                   const GdkRGBA          *color)
 {
   GskGpuColorInstance *instance;

gsk/gpu/gskgpucoloropprivate.h

@@ -9,7 +9,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_color_op                                (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpuconicgradientop.c

@@ -59,7 +59,7 @@ gsk_gpu_conic_gradient_op (GskGpuFrame            *frame,
                            const graphene_rect_t  *rect,
                            const graphene_point_t *center,
                            float                   angle,
-                           const GskPoint         *offset,
+                           const graphene_point_t *offset,
                            const GskColorStop     *stops,
                            gsize                   n_stops)
 {

gsk/gpu/gskgpuconicgradientopprivate.h

@@ -13,7 +13,7 @@ void                    gsk_gpu_conic_gradient_op                       (GskGpuF
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *center,
                                                                          float                           angle,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpucrossfadeop.c

@@ -59,7 +59,7 @@ gsk_gpu_cross_fade_op (GskGpuFrame            *frame,
                        GskGpuShaderClip        clip,
                        GskGpuDescriptors      *desc,
                        const graphene_rect_t  *rect,
-                       const GskPoint         *offset,
+                       const graphene_point_t *offset,
                        float                   opacity,
                        float                   progress,
                        guint32                 start_descriptor,

gsk/gpu/gskgpucrossfadeopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_cross_fade_op                           (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          float                           progress,
                                                                          guint32                         start_descriptor,

gsk/gpu/gskgpudevice.c

@@ -517,15 +517,21 @@ gsk_gpu_cached_atlas_allocate (GskGpuCachedAtlas *atlas,
 
   if (best_slice >= i && i == atlas->n_slices)
     {
+      gsize slice_height;
+
       if (!can_add_slice)
         return FALSE;
 
+      slice_height = round_up_atlas_size (MAX (height, 4));
+      if (slice_height > ATLAS_SIZE - y)
+        return FALSE;
+
       atlas->n_slices++;
       if (atlas->n_slices == MAX_SLICES_PER_ATLAS)
-        atlas->slices[i].height = ATLAS_SIZE - y;
-      else
-        atlas->slices[i].height = round_up_atlas_size (MAX (height, 4));
+        slice_height = ATLAS_SIZE - y;
+
       atlas->slices[i].width = 0;
+      atlas->slices[i].height = slice_height;
       best_y = y;
       best_slice = i;
     }
@@ -650,6 +656,7 @@ 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)
@@ -661,11 +668,13 @@ 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);
-  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;
+  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;
   padding = 1;
 
   image = gsk_gpu_device_add_atlas_image (self,
@@ -694,8 +703,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 + (flags & 3) / 4.f,
-                                       - origin.y + ((flags >> 2) & 3) / 4.f);
+  cache->origin = GRAPHENE_POINT_INIT (- origin.x + subpixel_x,
+                                       - origin.y + subpixel_y);
 
   gsk_gpu_upload_glyph_op (frame,
                            cache->image,

gsk/gpu/gskgpuglobalsop.c

@@ -12,8 +12,6 @@
 #include "gskvulkandescriptorsprivate.h"
 #endif
 
-#include "gskrectprivate.h"
-
 typedef struct _GskGpuGlobalsOp GskGpuGlobalsOp;
 
 struct _GskGpuGlobalsOp
@@ -89,16 +87,15 @@ static const GskGpuOpClass GSK_GPU_GLOBALS_OP_CLASS = {
 
 void
 gsk_gpu_globals_op (GskGpuFrame             *frame,
-                    const GskScale          *scale,
+                    const graphene_vec2_t   *scale,
                     const graphene_matrix_t *mvp,
                     const GskRoundedRect    *clip)
 {
   GskGpuGlobalsOp *self;
-  GskPoint zero = gsk_point_init (0, 0);
 
   self = (GskGpuGlobalsOp *) gsk_gpu_op_alloc (frame, &GSK_GPU_GLOBALS_OP_CLASS);
 
   graphene_matrix_to_float (mvp, self->instance.mvp);
-  gsk_gpu_rounded_rect_to_float (clip, &zero, self->instance.clip);
-  gsk_scale_to_float (scale, self->instance.scale);
+  gsk_rounded_rect_to_float (clip, graphene_point_zero (), self->instance.clip);
+  graphene_vec2_to_float (scale, self->instance.scale);
 }

gsk/gpu/gskgpuglobalsopprivate.h

@@ -3,7 +3,6 @@
 #include "gskgpuopprivate.h"
 
 #include <gsk/gskroundedrect.h>
-#include "gsk/gskscaleprivate.h"
 #include <graphene.h>
 
 G_BEGIN_DECLS
@@ -18,7 +17,7 @@ struct _GskGpuGlobalsInstance
 };
 
 void                    gsk_gpu_globals_op                              (GskGpuFrame                    *frame,
-                                                                         const GskScale                 *scale,
+                                                                         const graphene_vec2_t          *scale,
                                                                          const graphene_matrix_t        *mvp,
                                                                          const GskRoundedRect           *clip);
 

gsk/gpu/gskgpulineargradientop.c

@@ -64,7 +64,7 @@ gsk_gpu_linear_gradient_op (GskGpuFrame            *frame,
                             const graphene_rect_t  *rect,
                             const graphene_point_t *start,
                             const graphene_point_t *end,
-                            const GskPoint         *offset,
+                            const graphene_point_t *offset,
                             const GskColorStop     *stops,
                             gsize                   n_stops)
 {

gsk/gpu/gskgpulineargradientopprivate.h

@@ -14,7 +14,7 @@ void                    gsk_gpu_linear_gradient_op                      (GskGpuF
                                                                          const graphene_rect_t          *rect,
                                                                          const graphene_point_t         *start,
                                                                          const graphene_point_t         *end,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpumaskop.c

@@ -58,7 +58,7 @@ gsk_gpu_mask_op (GskGpuFrame            *frame,
                  GskGpuShaderClip        clip,
                  GskGpuDescriptors      *desc,
                  const graphene_rect_t  *rect,
-                 const GskPoint         *offset,
+                 const graphene_point_t *offset,
                  float                   opacity,
                  GskMaskMode             mask_mode,
                  guint32                 source_descriptor,

gsk/gpu/gskgpumaskopprivate.h

@@ -10,7 +10,7 @@ void                    gsk_gpu_mask_op                                 (GskGpuF
                                                                          GskGpuShaderClip                clip,
                                                                          GskGpuDescriptors              *desc,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          float                           opacity,
                                                                          GskMaskMode                     mask_mode,
                                                                          guint32                         source_descriptor,

gsk/gpu/gskgpunodeprocessor.c

@@ -40,11 +40,13 @@
 #include "gskroundedrectprivate.h"
 #include "gskstrokeprivate.h"
 #include "gsktransformprivate.h"
-#include "gskscaleprivate.h"
-#include "gskpointprivate.h"
 
 #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
@@ -106,12 +108,12 @@ struct _GskGpuNodeProcessor
   GskGpuFrame                   *frame;
   GskGpuDescriptors             *desc;
   cairo_rectangle_int_t          scissor;
-  GskGpuClip                     clip;
   GskGpuBlend                    blend;
-  GskPoint                       offset;
-  GskScale                       scale;
-  GskTransform                  *modelview;
+  graphene_point_t               offset;
   graphene_matrix_t              projection;
+  graphene_vec2_t                scale;
+  GskTransform                  *modelview;
+  GskGpuClip                     clip;
   float                          opacity;
 
   GskGpuGlobals                  pending_globals;
@@ -131,8 +133,8 @@ struct _GskGpuPatternWriter
   GskGpuDescriptors             *desc;
 
   graphene_rect_t                bounds;
-  GskPoint                       offset;
-  GskScale                       scale;
+  graphene_point_t               offset;
+  graphene_vec2_t                scale;
   guint                          stack;
 
   PatternBuffer                  buffer;
@@ -177,20 +179,24 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
     }
   else
     {
-      graphene_rect_t rect;
-
-      rect = gsk_rect_scale (GRAPHENE_RECT_INIT (clip->x, clip->y, clip->width, clip->height),
-                             gsk_scale_init (viewport->size.width / width,
-                                             viewport->size.height / height));
-      gsk_gpu_clip_init_rect (&self->clip, &rect);
+      float scale_x = viewport->size.width / width;
+      float scale_y = viewport->size.height / height;
+      gsk_gpu_clip_init_rect (&self->clip,
+                              &GRAPHENE_RECT_INIT (
+                                  scale_x * clip->x,
+                                  scale_y * clip->y,
+                                  scale_x * clip->width,
+                                  scale_y * clip->height
+                              ));
     }
 
   self->modelview = NULL;
   gsk_gpu_image_get_projection_matrix (target, &self->projection);
-  self->scale = gsk_scale_init (width / viewport->size.width,
-                                height / viewport->size.height);
-  self->offset = gsk_point_init (-viewport->origin.x,
-                                 -viewport->origin.y);
+  graphene_vec2_init (&self->scale,
+                      width / viewport->size.width,
+                      height / viewport->size.height);
+  self->offset = GRAPHENE_POINT_INIT (-viewport->origin.x,
+                                      -viewport->origin.y);
   self->opacity = 1.0;
   self->pending_globals = GSK_GPU_GLOBAL_MATRIX | GSK_GPU_GLOBAL_SCALE | GSK_GPU_GLOBAL_CLIP | GSK_GPU_GLOBAL_SCISSOR | GSK_GPU_GLOBAL_BLEND;
 }
@@ -302,20 +308,42 @@ gsk_gpu_node_processor_add_images (GskGpuNodeProcessor *self,
   while (desc != self->desc);
 }
 
+static void
+rect_round_to_pixels (const graphene_rect_t  *src,
+                      const graphene_vec2_t  *pixel_scale,
+                      const graphene_point_t *pixel_offset,
+                      graphene_rect_t        *dest)
+{
+  float x, y, xscale, yscale, inv_xscale, inv_yscale;
+
+  xscale = graphene_vec2_get_x (pixel_scale);
+  yscale = graphene_vec2_get_y (pixel_scale);
+  inv_xscale = 1.0f / xscale;
+  inv_yscale = 1.0f / yscale;
+
+  x = floorf ((src->origin.x + pixel_offset->x) * xscale);
+  y = floorf ((src->origin.y + pixel_offset->y) * yscale);
+  *dest = GRAPHENE_RECT_INIT (
+      x * inv_xscale - pixel_offset->x,
+      y * inv_yscale - pixel_offset->y,
+      (ceilf ((src->origin.x + pixel_offset->x + src->size.width) * xscale) - x) * inv_xscale,
+      (ceilf ((src->origin.y + pixel_offset->y + src->size.height) * yscale) - y) * inv_yscale);
+}
+
 static GskGpuImage *
-gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor    *self,
-                                  GskGpuFrame            *frame,
-                                  GdkMemoryDepth          depth,
-                                  const GskScale         *scale,
-                                  const graphene_rect_t  *viewport)
+gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor   *self,
+                                  GskGpuFrame           *frame,
+                                  GdkMemoryDepth         depth,
+                                  const graphene_vec2_t *scale,
+                                  const graphene_rect_t *viewport)
 {
   GskGpuImage *image;
   cairo_rectangle_int_t area;
 
   area.x = 0;
   area.y = 0;
-  area.width = ceilf (gsk_scale_get_x (*scale) * viewport->size.width);
-  area.height = ceilf (gsk_scale_get_y (*scale) * viewport->size.height);
+  area.width = ceilf (graphene_vec2_get_x (scale) * viewport->size.width);
+  area.height = ceilf (graphene_vec2_get_y (scale) * viewport->size.height);
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,
@@ -374,13 +402,16 @@ gsk_gpu_node_processor_process (GskGpuFrame                 *frame,
 static void
 gsk_gpu_pattern_writer_init (GskGpuPatternWriter    *self,
                              GskGpuFrame            *frame,
-                             const GskScale         *scale,
-                             const GskPoint         *offset,
+                             const graphene_vec2_t  *scale,
+                             const graphene_point_t *offset,
                              const graphene_rect_t  *bounds)
 {
   self->frame = frame;
   self->desc = NULL;
-  self->bounds = gsk_rect_add_offset (*bounds, *offset);
+  self->bounds = GRAPHENE_RECT_INIT (bounds->origin.x + offset->x,
+                                     bounds->origin.y + offset->y,
+                                     bounds->size.width,
+                                     bounds->size.height);
   self->offset = *offset;
   self->scale = *scale;
   self->stack = 0;
@@ -449,12 +480,12 @@ gsk_gpu_pattern_writer_append_vec4 (GskGpuPatternWriter   *self,
 static void
 gsk_gpu_pattern_writer_append_point (GskGpuPatternWriter    *self,
                                      const graphene_point_t *point,
-                                     const GskPoint         *offset)
+                                     const graphene_point_t *offset)
 {
   float f[2];
 
-  f[0] = point->x + gsk_point_get_x (*offset);
-  f[1] = point->y + gsk_point_get_y (*offset);
+  f[0] = point->x + offset->x;
+  f[1] = point->y + offset->y;
 
   gsk_gpu_pattern_writer_append (self, G_ALIGNOF (float), (guchar *) f, sizeof (f));
 }
@@ -462,7 +493,7 @@ gsk_gpu_pattern_writer_append_point (GskGpuPatternWriter    *self,
 static void
 gsk_gpu_pattern_writer_append_rect (GskGpuPatternWriter    *self,
                                     const graphene_rect_t  *rect,
-                                    const GskPoint         *offset)
+                                    const graphene_point_t *offset)
 {
   float f[4];
 
@@ -471,6 +502,18 @@ 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)
@@ -526,14 +569,78 @@ gsk_gpu_pattern_writer_add_image (GskGpuPatternWriter *self,
   return gsk_gpu_descriptors_add_image (self->desc, image, sampler, out_descriptor);
 }
 
+static void
+extract_scale_from_transform (GskTransform *transform,
+                              float        *out_scale_x,
+                              float        *out_scale_y)
+{
+  switch (gsk_transform_get_category (transform))
+    {
+    default:
+      g_assert_not_reached ();
+      G_GNUC_FALLTHROUGH;
+    case GSK_TRANSFORM_CATEGORY_IDENTITY:
+    case GSK_TRANSFORM_CATEGORY_2D_TRANSLATE:
+      *out_scale_x = 1.0f;
+      *out_scale_y = 1.0f;
+      return;
+
+    case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
+      {
+        float scale_x, scale_y, dx, dy;
+        gsk_transform_to_affine (transform, &scale_x, &scale_y, &dx, &dy);
+        *out_scale_x = fabs (scale_x);
+        *out_scale_y = fabs (scale_y);
+      }
+      return;
+
+    case GSK_TRANSFORM_CATEGORY_2D:
+      {
+        float skew_x, skew_y, scale_x, scale_y, angle, dx, dy;
+        gsk_transform_to_2d_components (transform,
+                                        &skew_x, &skew_y,
+                                        &scale_x, &scale_y,
+                                        &angle,
+                                        &dx, &dy);
+        *out_scale_x = fabs (scale_x);
+        *out_scale_y = fabs (scale_y);
+      }
+      return;
+
+    case GSK_TRANSFORM_CATEGORY_UNKNOWN:
+    case GSK_TRANSFORM_CATEGORY_ANY:
+    case GSK_TRANSFORM_CATEGORY_3D:
+      {
+        graphene_quaternion_t rotation;
+        graphene_matrix_t matrix;
+        graphene_vec4_t perspective;
+        graphene_vec3_t translation;
+        graphene_vec3_t matrix_scale;
+        graphene_vec3_t shear;
+
+        gsk_transform_to_matrix (transform, &matrix);
+        graphene_matrix_decompose (&matrix,
+                                   &translation,
+                                   &matrix_scale,
+                                   &rotation,
+                                   &shear,
+                                   &perspective);
+
+        *out_scale_x = fabs (graphene_vec3_get_x (&matrix_scale));
+        *out_scale_y = fabs (graphene_vec3_get_y (&matrix_scale));
+      }
+      return;
+    }
+}
+
 static gboolean
 gsk_gpu_node_processor_rect_is_integer (GskGpuNodeProcessor   *self,
                                         const graphene_rect_t *rect,
                                         cairo_rectangle_int_t *int_rect)
 {
   graphene_rect_t transformed_rect;
-  float scale_x = gsk_scale_get_x (self->scale);
-  float scale_y = gsk_scale_get_y (self->scale);
+  float scale_x = graphene_vec2_get_x (&self->scale);
+  float scale_y = graphene_vec2_get_y (&self->scale);
 
   switch (gsk_transform_get_category (self->modelview))
     {
@@ -571,8 +678,10 @@ static void
 gsk_gpu_node_processor_get_clip_bounds (GskGpuNodeProcessor *self,
                                         graphene_rect_t     *out_bounds)
 {
-  *out_bounds = gsk_rect_init_offset (self->clip.rect.bounds,
-                                      gsk_point_negate (self->offset));
+  graphene_rect_offset_r (&self->clip.rect.bounds,
+                          - self->offset.x,
+                          - self->offset.y,
+                          out_bounds);
  
   /* FIXME: We could try the scissor rect here.
    * But how often is that smaller than the clip bounds?
@@ -665,7 +774,7 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor   *self,
 static GskGpuImage *
 gsk_gpu_get_node_as_image (GskGpuFrame            *frame,
                            const graphene_rect_t  *clip_bounds,
-                           const GskScale         *scale,
+                           const graphene_vec2_t  *scale,
                            GskRenderNode          *node,
                            graphene_rect_t        *out_bounds)
 {
@@ -845,7 +954,7 @@ gsk_gpu_node_processor_get_node_as_image (GskGpuNodeProcessor   *self,
         return NULL;
       clip_bounds = &clip;
     }
-  clip = gsk_rect_round_to_pixels (*clip_bounds, self->scale, self->offset);
+  rect_round_to_pixels (clip_bounds, &self->scale, &self->offset, &clip);
 
   image = gsk_gpu_get_node_as_image (self->frame,
                                      &clip,
@@ -887,8 +996,9 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
   GskGpuNodeProcessor other;
   GskGpuImage *intermediate;
   guint32 intermediate_descriptor;
+  graphene_vec2_t direction;
   graphene_rect_t clip_rect, intermediate_rect;
-  GskPoint real_offset;
+  graphene_point_t real_offset;
   int width, height;
   float clip_radius;
 
@@ -900,8 +1010,8 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
   if (!gsk_rect_intersection (rect, &clip_rect, &intermediate_rect))
     return;
 
-  width = ceilf (gsk_scale_get_x (self->scale) * intermediate_rect.size.width);
-  height = ceilf (gsk_scale_get_y (self->scale) * intermediate_rect.size.height);
+  width = ceilf (graphene_vec2_get_x (&self->scale) * intermediate_rect.size.width);
+  height = ceilf (graphene_vec2_get_y (&self->scale) * intermediate_rect.size.height);
 
   intermediate = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (self->frame),
                                                         FALSE,
@@ -922,6 +1032,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
 
   gsk_gpu_node_processor_sync_globals (&other, 0);
 
+  graphene_vec2_init (&direction, blur_radius, 0.0f);
   gsk_gpu_blur_op (other.frame,
                    gsk_gpu_clip_get_shader_clip (&other.clip, &other.offset, &intermediate_rect),
                    source_desc,
@@ -929,7 +1040,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
                    &intermediate_rect,
                    &other.offset,
                    source_rect,
-                   &GRAPHENE_POINT_INIT (blur_radius, 0));
+                   &direction);
 
   gsk_gpu_render_pass_end_op (other.frame,
                               intermediate,
@@ -937,7 +1048,9 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
 
   gsk_gpu_node_processor_finish (&other);
 
-  real_offset = gsk_point_add (self->offset, gsk_point_init (shadow_offset->x, shadow_offset->y));
+  real_offset = GRAPHENE_POINT_INIT (self->offset.x + shadow_offset->x,
+                                     self->offset.y + shadow_offset->y);
+  graphene_vec2_init (&direction, 0.0f, blur_radius);
   intermediate_descriptor = gsk_gpu_node_processor_add_image (self, intermediate, GSK_GPU_SAMPLER_TRANSPARENT);
   if (shadow_color)
     {
@@ -948,7 +1061,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
                               rect,
                               &real_offset,
                               &intermediate_rect,
-                              &GRAPHENE_POINT_INIT (0, blur_radius),
+                              &direction,
                               shadow_color);
     }
   else
@@ -960,7 +1073,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
                        rect,
                        &real_offset,
                        &intermediate_rect,
-                       &GRAPHENE_POINT_INIT (0, blur_radius));
+                       &direction);
     }
 
   g_object_unref (intermediate);
@@ -976,7 +1089,7 @@ gsk_gpu_node_processor_add_fallback_node (GskGpuNodeProcessor *self,
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clipped_bounds))
     return;
 
-  clipped_bounds = gsk_rect_round_to_pixels (clipped_bounds, self->scale, self->offset);
+  rect_round_to_pixels (&clipped_bounds, &self->scale, &self->offset, &clipped_bounds);
 
   gsk_gpu_node_processor_sync_globals (self, 0);
 
@@ -1198,7 +1311,9 @@ gsk_gpu_node_processor_add_node_clipped (GskGpuNodeProcessor   *self,
       return;
     }
 
-  clip = gsk_rect_add_offset (*clip_bounds, self->offset);
+  graphene_rect_offset_r (clip_bounds,
+                          self->offset.x, self->offset.y,
+                          &clip);
 
   gsk_gpu_clip_init_copy (&old_clip, &self->clip);
 
@@ -1329,8 +1444,7 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
     return;
-
-  clip_bounds = gsk_rect_round_to_pixels (clip_bounds, self->scale, self->offset);
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);
 
   child_image = gsk_gpu_node_processor_get_node_as_image (self,
                                                           0,
@@ -1407,7 +1521,7 @@ gsk_gpu_node_processor_add_rounded_clip_node (GskGpuNodeProcessor *self,
   gsk_gpu_clip_init_copy (&old_clip, &self->clip);
 
   clip = *original_clip;
-  gsk_rounded_rect_offset (&clip, gsk_point_get_x (self->offset), gsk_point_get_y (self->offset));
+  gsk_rounded_rect_offset (&clip, self->offset.x, self->offset.y);
 
   if (!gsk_gpu_clip_intersect_rounded_rect (&self->clip, &old_clip, &clip))
     {
@@ -1436,8 +1550,8 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
 {
   GskRenderNode *child;
   GskTransform *transform;
-  GskPoint old_offset;
-  GskScale old_scale;
+  graphene_point_t old_offset;
+  graphene_vec2_t old_scale;
   GskTransform *old_modelview;
   GskGpuClip old_clip;
 
@@ -1452,7 +1566,8 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         float dx, dy;
         gsk_transform_to_translate (transform, &dx, &dy);
         old_offset = self->offset;
-        self->offset = gsk_point_add (self->offset, gsk_point_init (dx,dy));
+        self->offset.x += dx;
+        self->offset.y += dy;
         gsk_gpu_node_processor_add_node (self, child);
         self->offset = old_offset;
       }
@@ -1469,11 +1584,13 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
 
         gsk_transform_to_affine (transform, &scale_x, &scale_y, &dx, &dy);
         gsk_gpu_clip_scale (&self->clip, &old_clip, scale_x, scale_y);
-        self->offset = gsk_point_divide (gsk_point_add (self->offset, gsk_point_init (dx, dy)), gsk_scale_init (scale_x, scale_y));
-        self->scale = gsk_scale_multiply (old_scale, gsk_scale_init (fabsf (scale_x), fabsf (scale_y)));
+        self->offset.x = (self->offset.x + dx) / scale_x;
+        self->offset.y = (self->offset.y + dy) / scale_y;
+        graphene_vec2_init (&self->scale, fabs (scale_x), fabs (scale_y));
+        graphene_vec2_multiply (&self->scale, &old_scale, &self->scale);
         self->modelview = gsk_transform_scale (self->modelview,
-                                               scale_x / fabsf (scale_x),
-                                               scale_y / fabsf (scale_y));
+                                               scale_x / fabs (scale_x),
+                                               scale_y / fabs (scale_y));
       }
       break;
 
@@ -1483,10 +1600,9 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
     case GSK_TRANSFORM_CATEGORY_3D:
       {
         GskTransform *clip_transform;
-        float old_pixels, new_pixels;
-        GskScale scale;
+        float scale_x, scale_y, old_pixels, new_pixels;
 
-        clip_transform = gsk_transform_transform (gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (gsk_point_get_x (self->offset), gsk_point_get_y (self->offset))), transform);
+        clip_transform = gsk_transform_transform (gsk_transform_translate (NULL, &self->offset), transform);
         gsk_gpu_clip_init_copy (&old_clip, &self->clip);
 
         if (gsk_gpu_clip_contains_rect (&self->clip, &self->offset, &node->bounds))
@@ -1531,25 +1647,26 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         old_modelview = gsk_transform_ref (self->modelview);
 
         self->modelview = gsk_transform_scale (self->modelview,
-                                               gsk_scale_get_x (self->scale),
-                                               gsk_scale_get_y (self->scale));
+                                               graphene_vec2_get_x (&self->scale),
+                                               graphene_vec2_get_y (&self->scale));
         self->modelview = gsk_transform_transform (self->modelview, clip_transform);
         gsk_transform_unref (clip_transform);
 
-        scale = gsk_scale_extract_from_transform (self->modelview);
+        extract_scale_from_transform (self->modelview, &scale_x, &scale_y);
 
-        old_pixels = gsk_scale_get_x (old_scale) * gsk_scale_get_y (old_scale) *
+        old_pixels = graphene_vec2_get_x (&old_scale) * graphene_vec2_get_y (&old_scale) *
                      old_clip.rect.bounds.size.width * old_clip.rect.bounds.size.height;
-        new_pixels = gsk_scale_get_x (scale) * gsk_scale_get_y (scale) *
-                     self->clip.rect.bounds.size.width * self->clip.rect.bounds.size.height;
+        new_pixels = scale_x * scale_y * self->clip.rect.bounds.size.width * self->clip.rect.bounds.size.height;
         if (new_pixels > 2 * old_pixels)
-          scale = gsk_scale_multiply (scale, gsk_scale_init_uniform (2 * old_pixels / new_pixels));
+          {
+            float forced_downscale = 2 * old_pixels / new_pixels;
+            scale_x *= forced_downscale;
+            scale_y *= forced_downscale;
+          }
 
-        self->modelview = gsk_transform_scale (self->modelview,
-                                               1 / gsk_scale_get_x (scale),
-                                               1 / gsk_scale_get_y (scale));
-        self->scale = scale;
-        self->offset = gsk_point_init (0, 0);
+        self->modelview = gsk_transform_scale (self->modelview, 1 / scale_x, 1 / scale_y);
+        graphene_vec2_init (&self->scale, scale_x, scale_y);
+        self->offset = *graphene_point_zero ();
       }
       break;
 
@@ -1576,8 +1693,8 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
 {
   GskRenderNode *child;
   GskTransform *transform;
-  GskPoint old_offset;
-  GskScale old_scale;
+  graphene_point_t old_offset;
+  graphene_vec2_t old_scale;
   graphene_rect_t old_bounds;
   gboolean result;
 
@@ -1596,7 +1713,8 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
       {
         float dx, dy;
         gsk_transform_to_translate (transform, &dx, &dy);
-        self->offset = gsk_point_add (self->offset, gsk_point_init (dx, dy));
+        self->offset.x += dx;
+        self->offset.y += dy;
         result = gsk_gpu_node_processor_create_node_pattern (self, child);
         self->offset = old_offset;
         return result;
@@ -1605,21 +1723,22 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
     case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
       {
         float sx, sy, dx, dy, inv_sx, inv_sy;
-        GskPoint p;
         graphene_vec4_t vec4;
         if (!gsk_gpu_pattern_writer_push_stack (self))
           return FALSE;
         gsk_transform_to_affine (transform, &sx, &sy, &dx, &dy);
         inv_sx = 1.f / sx;
         inv_sy = 1.f / sy;
-        p = gsk_point_add (self->offset, gsk_point_init (dx, dy));
         gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_AFFINE);
-        graphene_vec4_init (&vec4, gsk_point_get_x (p), gsk_point_get_y (p), inv_sx, inv_sy);
+        graphene_vec4_init (&vec4, self->offset.x + dx, self->offset.y + dy, inv_sx, inv_sy);
         gsk_gpu_pattern_writer_append_vec4 (self, &vec4);
-        self->bounds = gsk_rect_scale (gsk_rect_subtract_offset (self->bounds, p),
-                                       gsk_scale_init (inv_sx, inv_sy));
-        self->offset = gsk_point_init (0, 0);
-        self->scale = gsk_scale_multiply (gsk_scale_init (fabsf (sx), fabsf (sy)), old_scale);
+        self->bounds.origin.x = (self->bounds.origin.x - self->offset.x - dx) * inv_sx;
+        self->bounds.origin.y = (self->bounds.origin.y - self->offset.y - dy) * inv_sy;
+        self->bounds.size.width *= inv_sx;
+        self->bounds.size.height *= inv_sy;
+        self->offset = GRAPHENE_POINT_INIT (0, 0);
+        graphene_vec2_init (&self->scale, fabs (sx), fabs (sy));
+        graphene_vec2_multiply (&self->scale, &old_scale, &self->scale);
       }
       break;
 
@@ -1641,9 +1760,9 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
     gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_POSITION_POP);
 
   gsk_gpu_pattern_writer_pop_stack (self);
-  self->scale = old_scale;
-  self->bounds = old_bounds;
-  self->offset = old_offset;
+  self->scale = old_scale; 
+  self->bounds = old_bounds; 
+  self->offset = old_offset; 
 
   return result;
 }
@@ -1668,10 +1787,11 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
   cairo_rectangle_int_t int_clipped;
   graphene_rect_t rect, clipped;
   const GdkRGBA *color;
-  GskPoint zero = gsk_point_init (0, 0);
 
   color = gsk_color_node_get_color (node);
-  rect = gsk_rect_add_offset (node->bounds, self->offset);
+  graphene_rect_offset_r (&node->bounds,
+                          self->offset.x, self->offset.y,
+                          &rect);
   gsk_rect_intersection (&self->clip.rect.bounds, &rect, &clipped);
 
   if (gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_CLEAR) &&
@@ -1702,11 +1822,11 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
               return;
             }
 
-          scale_x = gsk_scale_get_x (self->scale);
-          scale_y = gsk_scale_get_y (self->scale);
+          scale_x = graphene_vec2_get_x (&self->scale);
+          scale_y = graphene_vec2_get_y (&self->scale);
           clipped = GRAPHENE_RECT_INIT (int_clipped.x / scale_x, int_clipped.y / scale_y,
                                         int_clipped.width / scale_x, int_clipped.height / scale_y);
-          shader_clip = gsk_gpu_clip_get_shader_clip (&self->clip, &zero, &clipped);
+          shader_clip = gsk_gpu_clip_get_shader_clip (&self->clip, graphene_point_zero(), &clipped);
           if (shader_clip != GSK_GPU_SHADER_CLIP_NONE)
             {
               gsk_rounded_rect_get_largest_cover (&self->clip.rect, &clipped, &cover);
@@ -1719,7 +1839,7 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
                   gsk_gpu_color_op (self->frame,
                                     shader_clip,
                                     &clipped,
-                                    &zero,
+                                    graphene_point_zero (),
                                     color);
                   return;
                 }
@@ -1729,13 +1849,13 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
                 gsk_gpu_color_op (self->frame,
                                   shader_clip,
                                   &GRAPHENE_RECT_INIT (clipped.origin.x, clipped.origin.y, cover.origin.x - clipped.origin.x, clipped.size.height),
-                                  &zero,
+                                  graphene_point_zero (),
                                   color);
               if (clipped.origin.y != cover.origin.y)
                 gsk_gpu_color_op (self->frame,
                                   shader_clip,
                                   &GRAPHENE_RECT_INIT (clipped.origin.x, clipped.origin.y, clipped.size.width, cover.origin.y - clipped.origin.y),
-                                  &zero,
+                                  graphene_point_zero (),
                                   color);
               if (clipped.origin.x + clipped.size.width != cover.origin.x + cover.size.width)
                 gsk_gpu_color_op (self->frame,
@@ -1744,7 +1864,7 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
                                                        clipped.origin.y,
                                                        clipped.origin.x + clipped.size.width - cover.origin.x - cover.size.width,
                                                        clipped.size.height),
-                                  &zero,
+                                  graphene_point_zero (),
                                   color);
               if (clipped.origin.y + clipped.size.height != cover.origin.y + cover.size.height)
                 gsk_gpu_color_op (self->frame,
@@ -1753,7 +1873,7 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
                                                        cover.origin.y + cover.size.height,
                                                        clipped.size.width,
                                                        clipped.origin.y + clipped.size.height - cover.origin.y - cover.size.height),
-                                  &zero,
+                                  graphene_point_zero (),
                                   color);
             }
         }
@@ -1830,8 +1950,8 @@ gsk_gpu_node_processor_add_texture_node (GskGpuNodeProcessor *self,
     }
 
   if (gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_MIPMAP) &&
-      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * gsk_scale_get_x (self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_scale_get_y (self->scale)))
+      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * graphene_vec2_get_x (&self->scale) ||
+       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * graphene_vec2_get_y (&self->scale)))
     {
       guint32 descriptor;
 
@@ -1897,8 +2017,8 @@ gsk_gpu_node_processor_create_texture_pattern (GskGpuPatternWriter *self,
     }
 
   if (gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_MIPMAP) &&
-      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * gsk_scale_get_x (self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_scale_get_y (self->scale)))
+      (gdk_texture_get_width (texture) > 2 * node->bounds.size.width * graphene_vec2_get_x (&self->scale) ||
+       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * graphene_vec2_get_y (&self->scale)))
     {
       image = gsk_gpu_node_processor_ensure_image (self->frame,
                                                    image,
@@ -1941,18 +2061,18 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
   guint32 descriptor;
   gboolean need_mipmap, need_offscreen;
 
-  need_offscreen = self->modelview != NULL || !gsk_scale_is_one (self->scale);
+  need_offscreen = self->modelview != NULL || 
+            !graphene_vec2_equal (&self->scale, graphene_vec2_one ());
   if (need_offscreen)
     {
       GskGpuImage *offscreen;
       graphene_rect_t clip_bounds;
-      GskScale one = gsk_scale_init (1, 1);
 
       if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
         return;
-      clip_bounds = gsk_rect_round_larger (clip_bounds);
+      gsk_rect_round_larger (&clip_bounds);
       offscreen = gsk_gpu_render_pass_op_offscreen (self->frame,
-                                                    &one,
+                                                    graphene_vec2_one (),
                                                     &clip_bounds,
                                                     node);
       descriptor = gsk_gpu_node_processor_add_image (self, offscreen, GSK_GPU_SAMPLER_DEFAULT);
@@ -2148,8 +2268,7 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self,
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &bounds))
     return;
-
-  bounds = gsk_rect_round_to_pixels (bounds, self->scale, self->offset);
+  rect_round_to_pixels (&bounds, &self->scale, &self->offset, &bounds);
 
   image = gsk_gpu_node_processor_init_draw (&other,
                                             self->frame,
@@ -2444,7 +2563,8 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self,
       const GskShadow *shadow = gsk_shadow_node_get_shadow (node, i);
       if (shadow->radius == 0)
         {
-          GskPoint shadow_offset = gsk_point_add (self->offset, gsk_point_init (shadow->dx, shadow->dy));
+          graphene_point_t shadow_offset = GRAPHENE_POINT_INIT (self->offset.x + shadow->dx,
+                                                                self->offset.y + shadow->dy);
           gsk_gpu_colorize_op (self->frame,
                                gsk_gpu_clip_get_shader_clip (&self->clip, &shadow_offset, &child->bounds),
                                desc,
@@ -2870,10 +2990,11 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self,
   GskGpuDevice *device;
   const PangoGlyphInfo *glyphs;
   PangoFont *font;
-  GskPoint offset;
+  Point offset;
+  Scale scale, s4, pango_scale;
   guint i, num_glyphs;
-  GskScale scale, inv;
   GdkRGBA color;
+  gboolean glyph_align;
 
   if (self->opacity < 1.0 &&
       gsk_text_node_has_color_glyphs (node))
@@ -2882,60 +3003,83 @@ 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_point_add (gsk_point_init_from_graphene (gsk_text_node_get_offset (node)), self->offset);
 
-  scale = gsk_scale_max (self->scale);
-  inv = gsk_scale_invert (scale);
+  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);
 
   for (i = 0; i < num_glyphs; i++)
     {
       GskGpuImage *image;
-      graphene_rect_t glyph_bounds, glyph_tex_rect;
-      graphene_point_t glyph_offset;
-      GskPoint g_offset;
+      graphene_rect_t glyph_bds;
+      graphene_point_t glyph_ofs;
+      Box glyph_bounds, glyph_tex_rect;
+      Point g_ofs, glyph_origin;
       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,
-                                                 0,
-                                                 gsk_scale_get_x (scale),
-                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 flags,
+                                                 scale_x (scale),
+                                                 &glyph_bds,
+                                                 &glyph_ofs);
 
-      glyph_tex_rect = 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);
-      glyph_bounds = gsk_rect_scale (GRAPHENE_RECT_INIT (0, 0, glyph_bounds.size.width, glyph_bounds.size.height), inv);
-      g_offset  = gsk_point_add (gsk_point_add (offset, gsk_point_divide (gsk_point_init_from_graphene (&glyph_offset), scale)),
-                                     gsk_point_init (glyphs[i].geometry.x_offset/(float)PANGO_SCALE,
-                                                     glyphs[i].geometry.y_offset/(float)PANGO_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);
+
+      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));
 
       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_clip (&self->clip, &g_offset, &glyph_bounds),
+                            gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
                             self->desc,
                             descriptor,
-                            &glyph_bounds,
-                            &g_offset,
-                            &glyph_tex_rect);
+                            &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)));
       else
         gsk_gpu_colorize_op (self->frame,
-                             gsk_gpu_clip_get_shader_clip (&self->clip, &g_offset, &glyph_bounds),
+                             gsk_gpu_clip_get_shader_clip2 (&self->clip, &g_ofs, &glyph_bounds),
                              self->desc,
                              descriptor,
-                             &glyph_bounds,
-                             &g_offset,
-                             &glyph_tex_rect,
+                             &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)),
                              &color);
 
-      offset = gsk_point_add (offset, gsk_point_init ((float) glyphs[i].geometry.width / PANGO_SCALE, 0));
+      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
     }
 }
 
@@ -2948,10 +3092,10 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   PangoFont *font;
   guint num_glyphs;
   gsize i;
-  GskScale scale, inv;
+  Scale scale, pango_scale;
   guint32 tex_id;
   GskGpuImage *last_image;
-  GskPoint offset;
+  Point offset;
 
   if (gsk_text_node_has_color_glyphs (node))
     return FALSE;
@@ -2960,10 +3104,11 @@ 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_point_add (gsk_point_init_from_graphene (gsk_text_node_get_offset (node)), self->offset);
 
-  scale = gsk_scale_max (self->scale);
-  inv = gsk_scale_invert (scale);
+  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);
 
   gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_GLYPHS);
   gsk_gpu_pattern_writer_append_rgba (self, gsk_text_node_get_color (node));
@@ -2973,19 +3118,20 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   for (i = 0; i < num_glyphs; i++)
     {
       GskGpuImage *image;
-      graphene_rect_t glyph_bounds;
-      graphene_point_t glyph_offset;
-      GskPoint g_offset;
-      graphene_rect_t rect;
+      graphene_rect_t glyph_bds;
+      graphene_point_t glyph_ofs;
+      Point glyph_offset;
+      Box glyph_bounds;
+      Box glyph_tex_rect;
 
       image = gsk_gpu_device_lookup_glyph_image (device,
                                                  self->frame,
                                                  font,
                                                  glyphs[i].glyph,
                                                  0,
-                                                 gsk_scale_get_x (scale),
-                                                 &glyph_bounds,
-                                                 &glyph_offset);
+                                                 scale_x (scale),
+                                                 &glyph_bds,
+                                                 &glyph_ofs);
 
       if (image != last_image)
         {
@@ -2995,22 +3141,15 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
           last_image = image;
         }
 
-      g_offset = gsk_point_add (gsk_point_add (offset, gsk_point_divide (gsk_point_init_from_graphene (&glyph_offset), scale)),
-                                    gsk_point_init (glyphs[i].geometry.x_offset / (float)PANGO_SCALE,
-                                                    glyphs[i].geometry.y_offset / (float)PANGO_SCALE));
+      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_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);
-      rect = gsk_rect_scale (GRAPHENE_RECT_INIT (0, 0, glyph_bounds.size.width, glyph_bounds.size.height),
-                             inv);
-      gsk_gpu_pattern_writer_append_rect (self, &rect, &g_offset);
-      rect = 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);
-      gsk_gpu_pattern_writer_append_rect (self, &rect, &g_offset);
+      gsk_gpu_pattern_writer_append_box (self, glyph_bounds, glyph_offset);
+      gsk_gpu_pattern_writer_append_box (self, glyph_tex_rect, glyph_offset);
 
-      offset = gsk_point_add (offset, gsk_point_init ((float) glyphs[i].geometry.width / PANGO_SCALE, 0));
+      offset = point_add (offset, point (glyphs[i].geometry.width / (float)PANGO_SCALE, 0));
     }
 
   return TRUE;
@@ -3110,10 +3249,10 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor    *self,
   graphene_rect_t clipped_child_bounds, offset_rect;
   guint32 descriptor;
 
-  offset_rect = gsk_rect_init_offset (*rect,
-                                      gsk_point_multiply (gsk_point_init (child_bounds->size.width, child_bounds->size.height),
-                                                          gsk_scale_init (-x, -y)));
-
+  gsk_rect_init_offset (&offset_rect,
+                        rect,
+                        - x * child_bounds->size.width,
+                        - y * child_bounds->size.height);
   if (!gsk_rect_intersection (&offset_rect, child_bounds, &clipped_child_bounds))
     {
       /* The math has gone wrong probably, someone should look at this. */
@@ -3138,8 +3277,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
                       ));
@@ -3242,21 +3381,23 @@ gsk_gpu_node_processor_add_repeat_node (GskGpuNodeProcessor *self,
   else
     {
       /* repeat in both directions */
-      GskPoint old_offset, offset;
+      graphene_point_t old_offset, offset;
       graphene_rect_t clip_bounds;
-      float x, y, offset_x, offset_y;
+      float x, y;
 
       old_offset = self->offset;
 
       for (x = floorf (tile_left); x < ceilf (tile_right); x++)
         {
-          offset_x = x * child_bounds->size.width;
+          offset.x = x * child_bounds->size.width;
           for (y = floorf (tile_top); y < ceilf (tile_bottom); y++)
             {
-              offset_y = y * child_bounds->size.height;
-              offset = gsk_point_init (offset_x, offset_y);
-              self->offset = gsk_point_add (old_offset, offset);
-              clip_bounds = gsk_rect_subtract_offset (bounds, offset);
+              offset.y = y * child_bounds->size.height;
+              self->offset = GRAPHENE_POINT_INIT (old_offset.x + offset.x, old_offset.y + offset.y);
+              clip_bounds = GRAPHENE_RECT_INIT (bounds.origin.x - offset.x,
+                                                bounds.origin.y - offset.y,
+                                                bounds.size.width,
+                                                bounds.size.height);
               if (!gsk_rect_intersection (&clip_bounds, child_bounds, &clip_bounds))
                 continue;
               gsk_gpu_node_processor_add_node_clipped (self,
@@ -3297,7 +3438,10 @@ gsk_gpu_node_processor_create_repeat_pattern (GskGpuPatternWriter *self,
   gsk_gpu_pattern_writer_append_rect (self, child_bounds, &self->offset);
 
   old_bounds = self->bounds;
-  self->bounds = gsk_rect_add_offset (*child_bounds, self->offset);
+  self->bounds = GRAPHENE_RECT_INIT (child_bounds->origin.x + self->offset.x,
+                                     child_bounds->origin.y + self->offset.y,
+                                     child_bounds->size.width,
+                                     child_bounds->size.height);
 
   if (!gsk_gpu_node_processor_create_node_pattern (self, child))
     {
@@ -3369,8 +3513,7 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self,
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
     return;
-
-  clip_bounds = gsk_rect_round_to_pixels (clip_bounds, self->scale, self->offset);
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);
 
   child = gsk_fill_node_get_child (node);
 
@@ -3467,8 +3610,7 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self,
 
   if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds))
     return;
-
-  clip_bounds = gsk_rect_round_to_pixels (clip_bounds, self->scale, self->offset);
+  rect_round_to_pixels (&clip_bounds, &self->scale, &self->offset, &clip_bounds);
 
   child = gsk_stroke_node_get_child (node);
 
@@ -3542,9 +3684,15 @@ gsk_gpu_node_processor_add_subsurface_node (GskGpuNodeProcessor *self,
   if (!gdk_subsurface_is_above_parent (subsurface))
     {
       cairo_rectangle_int_t int_rect;
-      graphene_rect_t r = gsk_rect_add_offset (node->bounds, self->offset);
 
-      if (!gsk_gpu_node_processor_rect_is_integer (self, &r, &int_rect))
+      if (!gsk_gpu_node_processor_rect_is_integer (self,
+                                                   &GRAPHENE_RECT_INIT (
+                                                     node->bounds.origin.x + self->offset.x,
+                                                     node->bounds.origin.y + self->offset.y,
+                                                     node->bounds.size.width,
+                                                     node->bounds.size.height
+                                                   ),
+                                                   &int_rect))
         {
           g_warning ("FIXME: non-integer aligned subsurface?!");
         }
@@ -3798,7 +3946,6 @@ gsk_gpu_node_processor_add_node (GskGpuNodeProcessor *self,
    * there's quaranteed to be at least 1 pixel that needs to be drawn */
   if (node->bounds.size.width == 0 || node->bounds.size.height == 0)
     return;
-
   if (!gsk_gpu_clip_may_intersect_rect (&self->clip, &self->offset, &node->bounds))
     return;
 
@@ -3862,9 +4009,15 @@ gsk_gpu_node_processor_create_node_pattern (GskGpuPatternWriter *self,
         gsk_gpu_descriptors_set_size (self->desc, images_before, buffers_before);
     }
 
-  bounds = gsk_rect_round_to_pixels (gsk_rect_subtract_offset (self->bounds, self->offset),
-                                     self->scale,
-                                     self->offset);
+  rect_round_to_pixels (&GRAPHENE_RECT_INIT (
+                            self->bounds.origin.x - self->offset.x,
+                            self->bounds.origin.y - self->offset.y,
+                            self->bounds.size.width,
+                            self->bounds.size.height
+                        ),
+                        &self->scale,
+                        &self->offset,
+                        &bounds);
   image = gsk_gpu_get_node_as_image (self->frame,
                                      &bounds,
                                      &self->scale,

gsk/gpu/gskgpuradialgradientop.c

@@ -66,12 +66,11 @@ gsk_gpu_radial_gradient_op (GskGpuFrame            *frame,
                             const graphene_point_t *radius,
                             float                   start,
                             float                   end,
-                            const GskPoint         *offset,
+                            const graphene_point_t *offset,
                             const GskColorStop     *stops,
                             gsize                   n_stops)
 {
   GskGpuRadialgradientInstance *instance;
-  GskPoint zero = gsk_point_init (0, 0);
 
   g_assert (n_stops > 1);
   g_assert (n_stops <= 7);
@@ -86,7 +85,7 @@ gsk_gpu_radial_gradient_op (GskGpuFrame            *frame,
 
   gsk_gpu_rect_to_float (rect, offset, instance->rect);
   gsk_gpu_point_to_float (center, offset, instance->center_radius);
-  gsk_gpu_point_to_float (radius, &zero, &instance->center_radius[2]);
+  gsk_gpu_point_to_float (radius, graphene_point_zero(), &instance->center_radius[2]);
   instance->startend[0] = start;
   instance->startend[1] = end;
   gsk_gpu_rgba_to_float (&stops[MIN (n_stops - 1, 6)].color, instance->color6);

gsk/gpu/gskgpuradialgradientopprivate.h

@@ -16,7 +16,7 @@ void                    gsk_gpu_radial_gradient_op                      (GskGpuF
                                                                          const graphene_point_t         *radius,
                                                                          float                           start,
                                                                          float                           end,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const GskColorStop             *stops,
                                                                          gsize                           n_stops);
 

gsk/gpu/gskgpurenderer.c

@@ -30,6 +30,7 @@ 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/gskgpurenderpassop.c

@@ -335,16 +335,16 @@ gsk_gpu_render_pass_end_op (GskGpuFrame       *frame,
 }
 
 GskGpuImage *
-gsk_gpu_render_pass_op_offscreen (GskGpuFrame            *frame,
-                                  const GskScale         *scale,
-                                  const graphene_rect_t  *viewport,
-                                  GskRenderNode          *node)
+gsk_gpu_render_pass_op_offscreen (GskGpuFrame           *frame,
+                                  const graphene_vec2_t *scale,
+                                  const graphene_rect_t *viewport,
+                                  GskRenderNode         *node)
 {
   GskGpuImage *image;
   int width, height;
 
-  width = ceil (gsk_scale_get_x (*scale) * viewport->size.width);
-  height = ceil (gsk_scale_get_y (*scale) * viewport->size.height);
+  width = ceil (graphene_vec2_get_x (scale) * viewport->size.width);
+  height = ceil (graphene_vec2_get_y (scale) * viewport->size.height);
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,

gsk/gpu/gskgpurenderpassopprivate.h

@@ -6,8 +6,6 @@
 
 #include <graphene.h>
 
-#include "gsk/gskscaleprivate.h"
-
 G_BEGIN_DECLS
 
 /* We only need this for the final VkImageLayout, but don't tell anyone */
@@ -26,7 +24,7 @@ void                    gsk_gpu_render_pass_end_op                      (GskGpuF
                                                                          GskRenderPassType               pass_type);
 
 GskGpuImage *           gsk_gpu_render_pass_op_offscreen                (GskGpuFrame                    *frame,
-                                                                         const GskScale                 *scale,
+                                                                         const graphene_vec2_t          *scale,
                                                                          const graphene_rect_t          *viewport,
                                                                          GskRenderNode                  *node);
 

gsk/gpu/gskgpuroundedcolorop.c

@@ -57,7 +57,7 @@ void
 gsk_gpu_rounded_color_op (GskGpuFrame            *frame,
                           GskGpuShaderClip        clip,
                           const GskRoundedRect   *outline,
-                          const GskPoint         *offset,
+                          const graphene_point_t *offset,
                           const GdkRGBA          *color)
 {
   GskGpuRoundedcolorInstance *instance;
@@ -69,7 +69,7 @@ gsk_gpu_rounded_color_op (GskGpuFrame            *frame,
                            NULL,
                            &instance);
 
-  gsk_gpu_rounded_rect_to_float (outline, offset, instance->outline);
+  gsk_rounded_rect_to_float (outline, offset, instance->outline);
   gsk_gpu_rgba_to_float (color, instance->color);
 }
 

gsk/gpu/gskgpuroundedcoloropprivate.h

@@ -10,7 +10,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_rounded_color_op                               (GskGpuFrame                    *frame,
                                                                                 GskGpuShaderClip                clip,
                                                                                 const GskRoundedRect           *outline,
-                                                                                const GskPoint                 *offset,
+                                                                                const graphene_point_t         *offset,
                                                                                 const GdkRGBA                  *color);
 
 

gsk/gpu/gskgpushaderopprivate.h

@@ -3,7 +3,6 @@
 #include "gskgpuopprivate.h"
 
 #include "gskgputypesprivate.h"
-#include "gskpointprivate.h"
 
 G_BEGIN_DECLS
 
@@ -70,11 +69,11 @@ gsk_gpu_rgba_to_float (const GdkRGBA *rgba,
 
 static inline void
 gsk_gpu_point_to_float (const graphene_point_t *point,
-                        const GskPoint         *offset,
+                        const graphene_point_t *offset,
                         float                   values[2])
 {
-  values[0] = point->x + gsk_point_get_x (*offset);
-  values[1] = point->y + gsk_point_get_y (*offset);
+  values[0] = point->x + offset->x;
+  values[1] = point->y + offset->y;
 }
 
 G_END_DECLS

gsk/gpu/gskgpustraightalphaop.c

@@ -62,7 +62,7 @@ gsk_gpu_straight_alpha_op (GskGpuFrame            *frame,
                            GskGpuDescriptors      *desc,
                            guint32                 descriptor,
                            const graphene_rect_t  *rect,
-                           const GskPoint         *offset,
+                           const graphene_point_t *offset,
                            const graphene_rect_t  *tex_rect)
 {
   GskGpuStraightalphaInstance *instance;

gsk/gpu/gskgpustraightalphaopprivate.h

@@ -12,7 +12,7 @@ void                    gsk_gpu_straight_alpha_op                       (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect);
 
 

gsk/gpu/gskgputextureop.c

@@ -58,7 +58,7 @@ gsk_gpu_texture_op (GskGpuFrame            *frame,
                     GskGpuDescriptors      *desc,
                     guint32                 descriptor,
                     const graphene_rect_t  *rect,
-                    const GskPoint         *offset,
+                    const graphene_point_t *offset,
                     const graphene_rect_t  *tex_rect)
 {
   GskGpuTextureInstance *instance;

gsk/gpu/gskgputextureopprivate.h

@@ -11,7 +11,7 @@ void                    gsk_gpu_texture_op                              (GskGpuF
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         descriptor,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          const graphene_rect_t          *tex_rect);
 
 

gsk/gpu/gskgputypesprivate.h

@@ -2,7 +2,6 @@
 
 #include <gdk/gdk.h>
 #include "gsk/gskenums.h"
-#include "gsk/gsktypes.h"
 
 #include "gdk/gdkmemoryformatprivate.h"
 
@@ -118,7 +117,8 @@ 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 <<  6,
+  GSK_GPU_OPTIMIZE_GL_BASE_INSTANCE     = 1 <<  7,
 } GskGpuOptimizations;
 

gsk/gpu/gskgpuuberop.c

@@ -56,7 +56,7 @@ void
 gsk_gpu_uber_op (GskGpuFrame             *frame,
                  GskGpuShaderClip         clip,
                  const graphene_rect_t   *rect,
-                 const GskPoint          *offset,
+                 const graphene_point_t  *offset,
                  GskGpuDescriptors       *desc,
                  guint32                  pattern_id)
 {

gsk/gpu/gskgpuuberopprivate.h

@@ -9,7 +9,7 @@ G_BEGIN_DECLS
 void                    gsk_gpu_uber_op                                 (GskGpuFrame                    *frame,
                                                                          GskGpuShaderClip                clip,
                                                                          const graphene_rect_t          *rect,
-                                                                         const GskPoint                 *offset,
+                                                                         const graphene_point_t         *offset,
                                                                          GskGpuDescriptors              *desc,
                                                                          guint32                         pattern_id);
 

gsk/gpu/gskgpuuploadop.c

@@ -451,12 +451,12 @@ static const GskGpuOpClass GSK_GPU_UPLOAD_CAIRO_OP_CLASS = {
 };
 
 GskGpuImage *
-gsk_gpu_upload_cairo_op (GskGpuFrame            *frame,
-                         const GskScale         *scale,
-                         const graphene_rect_t  *viewport,
-                         GskGpuCairoFunc         func,
-                         gpointer                user_data,
-                         GDestroyNotify          user_destroy)
+gsk_gpu_upload_cairo_op (GskGpuFrame           *frame,
+                         const graphene_vec2_t *scale,
+                         const graphene_rect_t *viewport,
+                         GskGpuCairoFunc        func,
+                         gpointer               user_data,
+                         GDestroyNotify         user_destroy)
 {
   GskGpuUploadCairoOp *self;
 
@@ -465,8 +465,8 @@ gsk_gpu_upload_cairo_op (GskGpuFrame            *frame,
   self->image = gsk_gpu_device_create_upload_image (gsk_gpu_frame_get_device (frame),
                                                     FALSE,
                                                     GDK_MEMORY_DEFAULT,
-                                                    ceil (gsk_scale_get_x (*scale) * viewport->size.width),
-                                                    ceil (gsk_scale_get_y (*scale) * viewport->size.height));
+                                                    ceil (graphene_vec2_get_x (scale) * viewport->size.width),
+                                                    ceil (graphene_vec2_get_y (scale) * viewport->size.height));
   self->viewport = *viewport;
   self->func = func;
   self->user_data = user_data;

gsk/gpu/gskgpuuploadopprivate.h

@@ -3,7 +3,6 @@
 #include "gskgpuopprivate.h"
 
 #include "gsktypes.h"
-#include "gsk/gskscaleprivate.h"
 
 G_BEGIN_DECLS
 
@@ -15,7 +14,7 @@ GskGpuImage *           gsk_gpu_upload_texture_op_try                   (GskGpuF
                                                                          GdkTexture                     *texture);
 
 GskGpuImage *           gsk_gpu_upload_cairo_op                         (GskGpuFrame                    *frame,
-                                                                         const GskScale                 *scale,
+                                                                         const graphene_vec2_t          *scale,
                                                                          const graphene_rect_t          *viewport,
                                                                          GskGpuCairoFunc                 func,
                                                                          gpointer                        user_data,

gsk/gskpointprivate.h

@@ -1,157 +1,20 @@
 #pragma once
 
-#include "gsktypes.h"
 #include <graphene.h>
-#include <math.h>
-#include <smmintrin.h>
 
-#include "gskscaleprivate.h"
-
-struct _GskPoint
+static inline void G_GNUC_PURE
+gsk_point_interpolate (const graphene_point_t *p1,
+                       const graphene_point_t *p2,
+                       float t,
+                       graphene_point_t *p)
 {
-  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
-};
-
-static inline float
-gsk_point_get_x (const GskPoint p)
-{
-  return graphene_simd4f_get_x (p.v);
+  p->x = p1->x * (1 - t) + p2->x * t;
+  p->Y = p1->y * (1 - t) + p2->y * t;
 }
 
-static inline float
-gsk_point_get_y (const GskPoint p)
+static inline float G_GNUC_PURE
+gsk_point_distance (const graphene_point_t *p1,
+                    const graphene_point_t *p2)
 {
-  return graphene_simd4f_get_y (p.v);
+  return sqrtf ((p1->x - p2->x)*(p1->x - p2->x) + (p1->y - p2->y)*(p1->y - p2->y));
 }
-
-static inline GskPoint
-gsk_point_init (float x,
-                float y)
-{
-  GskPoint p;
-
-  p.v = graphene_simd4f_init (x, y, 0.f, 0.f);
-
-  return p;
-}
-
-static inline GskPoint
-gsk_point_init_from_graphene (const graphene_point_t *p)
-{
-  return gsk_point_init (p->x, p->y);
-}
-
-static inline void
-gsk_point_to_float (const GskPoint *p,
-                    float           v[2])
-{
-  graphene_simd4f_dup_2f (p->v, v);
-}
-
-static inline gboolean
-gsk_point_is_zero (const GskPoint p)
-{
-  return gsk_point_get_x (p) == 0 && gsk_point_get_y (p) == 0;
-}
-
-static inline GskPoint
-gsk_point_negate (const GskPoint p)
-{
-  GskPoint neg;
-
-  neg.v = graphene_simd4f_neg (p.v);
-
-  return neg;
-}
-
-static inline GskPoint
-gsk_point_multiply (const GskPoint p,
-                    const GskScale s)
-{
-  GskPoint q;
-
-  q.v = graphene_simd4f_mul (p.v, s.v);
-
-  return q;
-}
-
-static inline GskPoint
-gsk_point_divide (const GskPoint p,
-                  const GskScale s)
-{
-  GskPoint q;
-
-  q.v = graphene_simd4f_div (p.v, s.v);
-
-  return q;
-}
-
-static inline GskPoint
-gsk_point_add (const GskPoint p1,
-               const GskPoint p2)
-{
-  GskPoint p;
-
-  p.v = graphene_simd4f_add (p1.v, p2.v);
-
-  return p;
-}
-
-static inline GskPoint
-gsk_point_subtract (const GskPoint p1,
-                    const GskPoint p2)
-{
-  GskPoint p;
-
-  p.v = graphene_simd4f_sub (p1.v, p2.v);
-
-  return p;
-}
-
-#ifdef HAVE_SSE4
-
-#  define graphene_simd4f_floor(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_floor_ps ((v)); \
-  }))
-
-#  define graphene_simd4f_ceil(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_ceil_ps ((v)); \
-  }))
-
-static inline GskPoint
-gsk_point_floor (const GskPoint p)
-{
-  GskPoint q;
-
-  q.v = graphene_simd4f_floor (p.v);
-
-  return q;
-}
-
-static inline GskPoint
-gsk_point_ceil (const GskPoint p)
-{
-  GskPoint q;
-
-  q.v = graphene_simd4f_ceil (p.v);
-
-  return q;
-}
-
-#else
-
-static inline GskPoint
-gsk_point_floor (const GskPoint p)
-{
-  return gsk_point_init (floorf (gsk_point_get_x (p)), floorf (gsk_point_get_y (p)));
-}
-
-static inline GskPoint
-gsk_point_ceil (const GskPoint p)
-{
-  return gsk_point_init (ceilf (gsk_point_get_x (p)), ceilf (gsk_point_get_y (p)));
-}
-
-#endif

gsk/gskrectprivate.h

@@ -2,9 +2,6 @@
 
 #include <graphene.h>
 #include <math.h>
-#include "gskscaleprivate.h"
-#include "gskpointprivate.h"
-
 
 static inline void
 gsk_rect_init (graphene_rect_t *r,
@@ -26,14 +23,13 @@ gsk_rect_init_from_rect (graphene_rect_t       *r,
   gsk_rect_init (r, r1->origin.x, r1->origin.y, r1->size.width, r1->size.height);
 }
 
-static inline graphene_rect_t
-gsk_rect_init_offset (const graphene_rect_t src,
-                      const GskPoint        offset)
+static inline void
+gsk_rect_init_offset (graphene_rect_t       *r,
+                      const graphene_rect_t *src,
+                      float                  dx,
+                      float                  dy)
 {
-  return GRAPHENE_RECT_INIT (src.origin.x + gsk_point_get_x (offset),
-                             src.origin.y + gsk_point_get_y (offset),
-                             src.size.width,
-                             src.size.height);
+  gsk_rect_init (r, src->origin.x + dx, src->origin.y + dy, src->size.width, src->size.height);
 }
 
 static inline gboolean G_GNUC_PURE
@@ -117,98 +113,39 @@ gsk_rect_equal (const graphene_rect_t *r1,
 
 static inline void
 gsk_gpu_rect_to_float (const graphene_rect_t  *rect,
-                       const GskPoint         *offset,
+                       const graphene_point_t *offset,
                        float                   values[4])
 {
-  values[0] = rect->origin.x + gsk_point_get_x (*offset);
-  values[1] = rect->origin.y + gsk_point_get_y (*offset);
+  values[0] = rect->origin.x + offset->x;
+  values[1] = rect->origin.y + offset->y;
   values[2] = rect->size.width;
   values[3] = rect->size.height;
 }
 
-static inline graphene_rect_t
-gsk_rect_round_larger (const graphene_rect_t rect)
+static inline void
+gsk_rect_round_larger (graphene_rect_t *rect)
 {
-  float x = floorf (rect.origin.x);
-  float y = floorf (rect.origin.y);
-
-  return GRAPHENE_RECT_INIT (x, y,
-                             ceilf (rect.origin.x + rect.size.width) - x,
-                             ceilf (rect.origin.y + rect.size.height) - y);
+  float x = floor (rect->origin.x);
+  float y = floor (rect->origin.y);
+  *rect = GRAPHENE_RECT_INIT (x, y,
+                              ceil (rect->origin.x + rect->size.width) - x,
+                              ceil (rect->origin.y + rect->size.height) - y);
 }
 
-static inline graphene_rect_t
-gsk_rect_scale (const graphene_rect_t r,
-                const GskScale        scale)
+static inline void
+gsk_rect_scale (const graphene_rect_t *r,
+                float                  sx,
+                float                  sy,
+                graphene_rect_t       *res)
 {
-  float sx = gsk_scale_get_x (scale);
-  float sy = gsk_scale_get_y (scale);
-
   if (G_UNLIKELY (sx < 0 || sy < 0))
     {
-      graphene_rect_t res;
-      graphene_rect_scale (&r, sx, sy, &res);
-      return res;
+      graphene_rect_scale (r, sx, sy, res);
+      return;
     }
 
-  return GRAPHENE_RECT_INIT (r.origin.x * sx,
-                             r.origin.y * sy,
-                             r.size.width * sx,
-                             r.size.height * sy);
-}
-
-static inline graphene_rect_t
-gsk_rect_add_offset (const graphene_rect_t r,
-                     const GskPoint        offset)
-{
-  return GRAPHENE_RECT_INIT (r.origin.x + gsk_point_get_x (offset),
-                             r.origin.y + gsk_point_get_y (offset),
-                             r.size.width,
-                             r.size.height);
-}
-
-static inline graphene_rect_t
-gsk_rect_subtract_offset (const graphene_rect_t r,
-                          const GskPoint        offset)
-{
-  return GRAPHENE_RECT_INIT (r.origin.x - gsk_point_get_x (offset),
-                             r.origin.y - gsk_point_get_y (offset),
-                             r.size.width,
-                             r.size.height);
-}
-
-static inline graphene_rect_t
-gsk_rect_from_points (GskPoint p0,
-                      GskPoint p1)
-{
-  return GRAPHENE_RECT_INIT (gsk_point_get_x (p0),
-                             gsk_point_get_y (p0),
-                             gsk_point_get_x (p1) - gsk_point_get_x (p0),
-                             gsk_point_get_y (p1) - gsk_point_get_y (p0));
-}
-
-static inline GskPoint
-gsk_rect_get_origin (const graphene_rect_t rect)
-{
-  return gsk_point_init (rect.origin.x, rect.origin.y);
-}
-
-static inline GskPoint
-gsk_rect_get_opposite (const graphene_rect_t rect)
-{
-  return gsk_point_init (rect.origin.x + rect.size.width, rect.origin.y + rect.size.height);
-}
-
-static inline graphene_rect_t
-gsk_rect_round_to_pixels (const graphene_rect_t src,
-                          const GskScale        scale,
-                          const GskPoint        offset)
-{
-  GskPoint p0, p1;
-
-  p0 = gsk_point_subtract (gsk_point_divide (gsk_point_floor (gsk_point_multiply (gsk_point_add (gsk_rect_get_origin (src), offset), scale)), scale), offset);
-
-  p1 = gsk_point_divide (gsk_point_subtract (gsk_point_ceil (gsk_point_multiply (gsk_point_add (gsk_rect_get_opposite (src), offset), scale)), p0), scale);
-
-  return gsk_rect_from_points (p0, p1);
+  res->origin.x = r->origin.x * sx;
+  res->origin.y = r->origin.y * sy;
+  res->size.width = r->size.width * sx;
+  res->size.height = r->size.height * sy;
 }

gsk/gskrendernodeimpl.c

@@ -3335,6 +3335,7 @@ gsk_container_node_new (GskRenderNode **children,
       self->children = g_malloc_n (n_children, sizeof (GskRenderNode *));
 
       self->children[0] = gsk_render_node_ref (children[0]);
+      node->offscreen_for_opacity = children[0]->offscreen_for_opacity;
       gsk_rect_init_from_rect (&bounds, &(children[0]->bounds));
       node->preferred_depth = gdk_memory_depth_merge (node->preferred_depth,
                                                       gsk_render_node_get_preferred_depth (children[0]));
@@ -4091,6 +4092,7 @@ 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 */
@@ -4107,6 +4109,11 @@ 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/gskrendernodeparser.c

@@ -981,7 +981,7 @@ ensure_fontmap (Context *context)
   g_object_set_data_full (G_OBJECT (context->fontmap), "font-files", files, (GDestroyNotify) g_ptr_array_unref);
 }
 
-static void
+static gboolean
 add_font_from_file (Context     *context,
                     const char  *path,
                     GError     **error)
@@ -997,7 +997,7 @@ add_font_from_file (Context     *context,
                    GTK_CSS_PARSER_ERROR,
                    GTK_CSS_PARSER_ERROR_FAILED,
                    "Custom fonts are not implemented for %s", G_OBJECT_TYPE_NAME (context->fontmap));
-      return;
+      return FALSE;
     }
 
   config = pango_fc_font_map_get_config (PANGO_FC_FONT_MAP (context->fontmap));
@@ -1006,18 +1006,20 @@ add_font_from_file (Context     *context,
     {
       g_set_error (error,
                    GTK_CSS_PARSER_ERROR,
-                   GTK_CSS_PARSER_ERROR_FAILED,
-                   "Failed to add %s to FcConfig", path);
-      return;
+                   GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
+                   "Failed to load font");
+      return FALSE;
     }
 
   files = (GPtrArray *) g_object_get_data (G_OBJECT (context->fontmap), "font-files");
   g_ptr_array_add (files, g_strdup (path));
 
   pango_fc_font_map_config_changed (PANGO_FC_FONT_MAP (context->fontmap));
+
+  return TRUE;
 }
 
-static void
+static gboolean
 add_font_from_bytes (Context  *context,
                      GBytes   *bytes,
                      GError  **error)
@@ -1025,10 +1027,11 @@ add_font_from_bytes (Context  *context,
   GFile *file;
   GIOStream *iostream;
   GOutputStream *ostream;
+  gboolean result;
 
   file = g_file_new_tmp ("gtk4-font-XXXXXX.ttf", (GFileIOStream **) &iostream, error);
   if (!file)
-    return;
+    return FALSE;
 
   ostream = g_io_stream_get_output_stream (iostream);
   if (g_output_stream_write_bytes (ostream, bytes, NULL, error) == -1)
@@ -1036,20 +1039,22 @@ add_font_from_bytes (Context  *context,
       g_object_unref (file);
       g_object_unref (iostream);
 
-      return;
+      return FALSE;
     }
 
   g_io_stream_close (iostream, NULL, NULL);
   g_object_unref (iostream);
 
-  add_font_from_file (context, g_file_peek_path (file), error);
+  result = add_font_from_file (context, g_file_peek_path (file), error);
 
   g_object_unref (file);
+
+  return result;
 }
 
 #else /* !HAVE_PANGOFT */
 
-static void
+static gboolean
 add_font_from_bytes (Context  *context,
                      GBytes   *bytes,
                      GError  **error)
@@ -1058,6 +1063,7 @@ add_font_from_bytes (Context  *context,
                GTK_CSS_PARSER_ERROR,
                GTK_CSS_PARSER_ERROR_FAILED,
                "Not implemented");
+  return FALSE;
 }
 
 #endif
@@ -1068,94 +1074,105 @@ parse_font (GtkCssParser *parser,
             gpointer      out_font)
 {
   PangoFont *font = NULL;
-  char *s;
-  GtkCssLocation start_location;
-  PangoFontMap *fontmap;
+  char *font_name;
 
-  fontmap = pango_cairo_font_map_get_default ();
-
-  s = gtk_css_parser_consume_string (parser);
-  if (s == NULL)
+  font_name = gtk_css_parser_consume_string (parser);
+  if (font_name == NULL)
     return FALSE;
 
-  start_location = *gtk_css_parser_get_start_location (parser);
+  if (context->fontmap)
+    font = font_from_string (context->fontmap, font_name);
 
-  if (gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_URL) ||
-      gtk_css_parser_has_function (parser, "url"))
+  if (gtk_css_parser_has_url (parser))
     {
       char *url;
-      char *scheme;
-      GBytes *bytes = NULL;
-      GError *error = NULL;
 
-      /* If we have a url, it is a bug if the font already exists in our custom fontmap */
-      if (context->fontmap)
+      if (font != NULL)
         {
-          font = font_from_string (context->fontmap, s);
-          if (font)
+          gtk_css_parser_error_value (parser, "A font with this name already exists.");
+          /* consume the url to avoid more errors */
+          url = gtk_css_parser_consume_url (parser);
+          g_free (url);
+        }
+      else
+        {
+          char *scheme;
+          GBytes *bytes;
+          GError *error = NULL;
+          GtkCssLocation start_location;
+          gboolean success = FALSE;
+
+          start_location = *gtk_css_parser_get_start_location (parser);
+          url = gtk_css_parser_consume_url (parser);
+
+          if (url != NULL)
             {
-              g_object_unref (font);
-              gtk_css_parser_error_value (parser, "This font already exists.");
-              return FALSE;
+              scheme = g_uri_parse_scheme (url);
+              if (scheme && g_ascii_strcasecmp (scheme, "data") == 0)
+                {
+                  bytes = gtk_css_data_url_parse (url, NULL, &error);
+                }
+              else
+                {
+                  GFile *file;
+
+                  file = g_file_new_for_uri (url);
+                  bytes = g_file_load_bytes (file, NULL, NULL, &error);
+                  g_object_unref (file);
+                }
+
+              g_free (scheme);
+              g_free (url);
+              if (bytes != NULL)
+                {
+                  success = add_font_from_bytes (context, bytes, &error);
+                  g_bytes_unref (bytes);
+                }
+
+              if (!success)
+                {
+                  gtk_css_parser_emit_error (parser,
+                                             &start_location,
+                                             gtk_css_parser_get_end_location (parser),
+                                             error);
+                }
+            }
+
+          if (success)
+            {
+              font = font_from_string (context->fontmap, font_name);
+              if (!font)
+                {
+                  gtk_css_parser_error (parser,
+                                        GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
+                                        &start_location,
+                                        gtk_css_parser_get_end_location (parser),
+                                        "The given url does not define a font named \"%s\"",
+                                        font_name);
+                }
             }
         }
+    }
+  else
+    {
+      if (!font)
+        font = font_from_string (pango_cairo_font_map_get_default (), font_name);
 
-      url = gtk_css_parser_consume_url (parser);
-
-      scheme = g_uri_parse_scheme (url);
-      if (scheme && g_ascii_strcasecmp (scheme, "data") == 0)
-        {
-          bytes = gtk_css_data_url_parse (url, NULL, &error);
-        }
-      else
-        {
-          GFile *file;
-
-          file = g_file_new_for_uri (url);
-          bytes = g_file_load_bytes (file, NULL, NULL, &error);
-          g_object_unref (file);
-        }
-
-      g_free (scheme);
-      g_free (url);
-
-      if (bytes)
-        {
-          add_font_from_bytes (context, bytes, &error);
-          g_bytes_unref (bytes);
-
-          fontmap = context->fontmap;
-        }
-      else
-        {
-          g_assert (error != NULL);
-
-          gtk_css_parser_emit_error (parser,
-                                     &start_location,
-                                     gtk_css_parser_get_end_location (parser),
-                                     error);
-          g_clear_error (&error);
-
-          return FALSE;
-        }
+      if (!font)
+        gtk_css_parser_error_value (parser, "The font \"%s\" does not exist", font_name);
     }
 
-  font = font_from_string (fontmap, s);
+  g_free (font_name);
 
-  if (!font && context->fontmap && fontmap != context->fontmap)
-    font = font_from_string (context->fontmap, s);
-
-  if (!font)
+  if (font)
+    {
+      *((PangoFont**)out_font) = font;
+      return TRUE;
+    }
+  else
     {
-      gtk_css_parser_error_value (parser, "This font does not exist.");
       return FALSE;
     }
-
-  *((PangoFont**)out_font) = font;
-
-  g_free (s);
-
-  return TRUE;
 }
 
 static void

gsk/gskroundedrectprivate.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "gskroundedrect.h"
-#include "gskrectprivate.h"
 
 #include <cairo.h>
 
@@ -49,21 +48,6 @@ void                     gsk_rounded_rect_path                  (const GskRounde
 void                     gsk_rounded_rect_to_float              (const GskRoundedRect     *self,
                                                                  const graphene_point_t   *offset,
                                                                  float                     rect[12]);
-static inline void
-gsk_gpu_rounded_rect_to_float (const GskRoundedRect *self,
-                               const GskPoint       *offset,
-                               float                 rect[12])
-{
-  guint i;
-
-  gsk_gpu_rect_to_float (&self->bounds, offset, rect);
-
-  for (i = 0; i < 4; i++)
-    {
-      rect[4 + i] = self->corner[i].width;
-      rect[8 + i] = self->corner[i].height;
-    }
-}
 
 gboolean                 gsk_rounded_rect_equal                 (gconstpointer             rect1,
                                                                  gconstpointer             rect2) G_GNUC_PURE;

gsk/gskscale.c

@@ -1,59 +0,0 @@
-#include "config.h"
-#include "gskscaleprivate.h"
-#include "gsktransform.h"
-
-GskScale
-gsk_scale_extract_from_transform (GskTransform *transform)
-{
-  switch (gsk_transform_get_category (transform))
-    {
-    default:
-      g_assert_not_reached ();
-      G_GNUC_FALLTHROUGH;
-
-    case GSK_TRANSFORM_CATEGORY_IDENTITY:
-    case GSK_TRANSFORM_CATEGORY_2D_TRANSLATE:
-      return gsk_scale_init (1, 1);
-
-    case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
-      {
-        float scale_x, scale_y, dx, dy;
-        gsk_transform_to_affine (transform, &scale_x, &scale_y, &dx, &dy);
-        return gsk_scale_init (fabsf (scale_x), fabsf (scale_y));
-      }
-
-    case GSK_TRANSFORM_CATEGORY_2D:
-      {
-        float skew_x, skew_y, scale_x, scale_y, angle, dx, dy;
-        gsk_transform_to_2d_components (transform,
-                                        &skew_x, &skew_y,
-                                        &scale_x, &scale_y,
-                                        &angle,
-                                        &dx, &dy);
-        return gsk_scale_init (fabsf (scale_x), fabsf (scale_y));
-      }
-
-    case GSK_TRANSFORM_CATEGORY_UNKNOWN:
-    case GSK_TRANSFORM_CATEGORY_ANY:
-    case GSK_TRANSFORM_CATEGORY_3D:
-      {
-        graphene_quaternion_t rotation;
-        graphene_matrix_t matrix;
-        graphene_vec4_t perspective;
-        graphene_vec3_t translation;
-        graphene_vec3_t matrix_scale;
-        graphene_vec3_t shear;
-
-        gsk_transform_to_matrix (transform, &matrix);
-        graphene_matrix_decompose (&matrix,
-                                   &translation,
-                                   &matrix_scale,
-                                   &rotation,
-                                   &shear,
-                                   &perspective);
-
-        return gsk_scale_init (fabsf (graphene_vec3_get_x (&matrix_scale)),
-                               fabsf (graphene_vec3_get_y (&matrix_scale)));
-      }
-    }
-}

gsk/gskscaleprivate.h

@@ -1,108 +0,0 @@
-#pragma once
-
-#include "gsktypes.h"
-#include <graphene.h>
-#include <math.h>
-
-struct _GskScale
-{
-  GRAPHENE_ALIGNED_DECL (graphene_simd4f_t v, 16);
-};
-
-static inline float
-gsk_scale_get_x (const GskScale s)
-{
-  return graphene_simd4f_get_x (s.v);
-}
-
-static inline float
-gsk_scale_get_y (const GskScale s)
-{
-  return graphene_simd4f_get_y (s.v);
-}
-
-static inline GskScale
-gsk_scale_init (float x,
-                float y)
-{
-  GskScale s;
-
-  s.v = graphene_simd4f_init (x, y, 0.f, 0.f);
-
-  return s;
-}
-
-static inline GskScale
-gsk_scale_init_uniform (float x)
-{
-  return gsk_scale_init (x, x);
-}
-
-static inline void
-gsk_scale_to_float (const GskScale *s,
-                    float           v[2])
-{
-  graphene_simd4f_dup_2f (s->v, v);
-}
-
-static inline gboolean
-gsk_scale_is_one (const GskScale s)
-{
-  return gsk_scale_get_x (s) == 1 && gsk_scale_get_y (s) == 1;
-}
-
-static inline gboolean
-gsk_scale_is_uniform (const GskScale s)
-{
-  return gsk_scale_get_x (s) == gsk_scale_get_y (s);
-}
-
-static inline GskScale
-gsk_scale_invert (const GskScale s)
-{
-  GskScale inv;
-
-  inv.v = graphene_simd4f_reciprocal (s.v);
-
-  return inv;
-}
-
-static inline GskScale
-gsk_scale_multiply (const GskScale s1,
-                    const GskScale s2)
-{
-  GskScale s;
-
-  s.v = graphene_simd4f_mul (s1.v, s2.v);
-
-  return s;
-}
-
-static inline GskScale
-gsk_scale_divide (const GskScale s1,
-                  const GskScale s2)
-{
-  GskScale s;
-
-  s.v = graphene_simd4f_div (s1.v, s2.v);
-
-  return s;
-}
-
-#  define graphene_simd4f_shuffle_yxzw(v) \
-  (__extension__ ({ \
-    (graphene_simd4f_t) _mm_shuffle_ps ((v), (v), _MM_SHUFFLE (1, 0, 2, 3)); \
-  }))
-
-
-static inline GskScale
-gsk_scale_max (const GskScale s)
-{
-  GskScale m;
-
-  m.v = graphene_simd4f_max (graphene_simd4f_shuffle_yxzw (s.v), s.v);
-
-  return m;
-}
-
-GskScale gsk_scale_extract_from_transform (GskTransform *transform);

gsk/gsktypes.h

@@ -34,5 +34,4 @@ typedef struct _GskRenderNode           GskRenderNode;
 typedef struct _GskRoundedRect          GskRoundedRect;
 typedef struct _GskStroke               GskStroke;
 typedef struct _GskTransform            GskTransform;
-typedef struct _GskScale                GskScale;
-typedef struct _GskPoint                GskPoint;
+

gsk/gsktypesprivate.h

@@ -0,0 +1,22 @@
+/* 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/meson.build

@@ -51,7 +51,6 @@ gsk_private_sources = files([
   'gskdebug.c',
   'gskprivate.c',
   'gskprofiler.c',
-  'gskscale.c',
   'gl/gskglattachmentstate.c',
   'gl/gskglbuffer.c',
   'gl/gskglcommandqueue.c',

gsk/pointprivate.h

@@ -0,0 +1,252 @@
+#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

@@ -0,0 +1,183 @@
+#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

gtk/css/gtkcssparser.c

@@ -957,6 +957,14 @@ gtk_css_parser_parse_url_arg (GtkCssParser *parser,
   return 1;
 }
 
+gboolean
+gtk_css_parser_has_url (GtkCssParser *self)
+{
+  return gtk_css_parser_has_token (self, GTK_CSS_TOKEN_URL)
+      || gtk_css_parser_has_token (self, GTK_CSS_TOKEN_BAD_URL)
+      || gtk_css_parser_has_function (self, "url");
+}
+
 /**
  * gtk_css_parser_consume_url:
  * @self: a `GtkCssParser`

gtk/css/gtkcssparserprivate.h

@@ -116,6 +116,7 @@ gboolean                gtk_css_parser_has_token                (GtkCssParser
                                                                  GtkCssTokenType                 token_type);
 gboolean                gtk_css_parser_has_ident                (GtkCssParser                   *self,
                                                                  const char                     *ident);
+gboolean                gtk_css_parser_has_url                  (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_number               (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_integer              (GtkCssParser                   *self);
 gboolean                gtk_css_parser_has_function             (GtkCssParser                   *self,

gtk/gtkapplication.c

@@ -257,14 +257,14 @@ gtk_application_startup (GApplication *g_application)
 
   before2 = GDK_PROFILER_CURRENT_TIME;
   gtk_init ();
-  gdk_profiler_end_mark (before2, "gtk init", NULL);
+  gdk_profiler_end_mark (before2, "gtk_init", NULL);
 
   priv->impl = gtk_application_impl_new (application, gdk_display_get_default ());
   gtk_application_impl_startup (priv->impl, priv->register_session);
 
   gtk_application_load_resources (application);
 
-  gdk_profiler_end_mark (before, "gtk application startup", NULL);
+  gdk_profiler_end_mark (before, "Application startup", NULL);
 }
 
 static void

gtk/gtkbuilderparser.c

@@ -2251,7 +2251,7 @@ _gtk_builder_parser_parse_buffer (GtkBuilder   *builder,
       guint64 after = GDK_PROFILER_CURRENT_TIME;
       if (after - before > 500000) /* half a millisecond */
         {
-          gdk_profiler_add_mark (before, after - before, "builder load", filename);
+          gdk_profiler_add_mark (before, after - before, "Builder load", filename);
         }
     }
 }

gtk/gtkcssnode.c

@@ -1363,7 +1363,7 @@ gtk_css_node_validate (GtkCssNode *cssnode)
 
   if (GDK_PROFILER_IS_RUNNING)
     {
-      gdk_profiler_end_mark (before,  "css validation", "");
+      gdk_profiler_end_mark (before,  "Validate CSS", "");
       gdk_profiler_set_int_counter (invalidated_nodes_counter, invalidated_nodes);
       gdk_profiler_set_int_counter (created_styles_counter, created_styles);
       invalidated_nodes = 0;

gtk/gtkcssprovider.c

@@ -1016,7 +1016,7 @@ gtk_css_provider_postprocess (GtkCssProvider *css_provider)
     }
 #endif
 
-  gdk_profiler_end_mark (before, "create selector tree", NULL);
+  gdk_profiler_end_mark (before, "Create CSS selector tree", NULL);
 }
 
 static void
@@ -1081,7 +1081,7 @@ gtk_css_provider_load_internal (GtkCssProvider *self,
   if (GDK_PROFILER_IS_RUNNING)
     {
       char *uri = g_file_get_uri (file);
-      gdk_profiler_end_mark (before, "theme load", uri);
+      gdk_profiler_end_mark (before, "CSS theme load", uri);
       g_free (uri);
     }
 }

gtk/gtkdroptarget.c

@@ -75,7 +75,7 @@
  *
  *   // This widget accepts two types of drop types: GFile objects
  *   // and GdkPixbuf objects
- *   gtk_drop_target_set_gtypes (target, (GTypes [2]) {
+ *   gtk_drop_target_set_gtypes (target, (GType [2]) {
  *     G_TYPE_FILE,
  *     GDK_TYPE_PIXBUF,
  *   }, 2);
@@ -935,7 +935,7 @@ gtk_drop_target_get_formats (GtkDropTarget *self)
  *   that can be dropped on the target
  * @n_types: number of @types
  *
- * Sets the supported `GTypes` for this drop target.
+ * Sets the supported `GType`s for this drop target.
  */
 void
 gtk_drop_target_set_gtypes (GtkDropTarget *self,

gtk/gtkemojichooser.c

@@ -761,7 +761,7 @@ populate_emoji_chooser (gpointer data)
       now = g_get_monotonic_time ();
       if (now > start + 200) /* 2 ms */
         {
-          gdk_profiler_add_mark (start * 1000, (now - start) * 1000, "emojichooser", "populate");
+          gdk_profiler_add_mark (start * 1000, (now - start) * 1000, "Emojichooser populate", NULL);
           return G_SOURCE_CONTINUE;
         }
     }
@@ -771,7 +771,7 @@ populate_emoji_chooser (gpointer data)
   chooser->box = NULL;
   chooser->populate_idle = 0;
 
-  gdk_profiler_end_mark (start, "emojichooser", "populate (finish)");
+  gdk_profiler_end_mark (start, "Emojichooser populate (finish)", NULL);
 
   return G_SOURCE_REMOVE;
 }

gtk/gtkicontheme.c

@@ -2069,7 +2069,7 @@ ensure_valid_themes (GtkIconTheme *self,
 
       load_themes (self);
 
-      gdk_profiler_end_mark (before, "icon theme load", self->current_theme);
+      gdk_profiler_end_mark (before, "Icon theme load", self->current_theme);
 
       if (was_valid)
         queue_theme_changed (self);
@@ -3822,7 +3822,7 @@ icon_ensure_texture__locked (GtkIconPaintable *icon,
       /* Don't report quick (< 0.5 msec) parses */
       if (end - before > 500000 || !in_thread)
         {
-          gdk_profiler_add_markf (before, (end - before), in_thread ?  "icon load (thread)" : "icon load" ,
+          gdk_profiler_add_markf (before, (end - before), in_thread ?  "Icon load (thread)" : "Icon load" ,
                                   "%s size %d@%d", icon->filename, icon->desired_size, icon->desired_scale);
         }
     }

gtk/gtkimcontextsimple.c

@@ -353,7 +353,7 @@ init_compose_table_thread_cb (GTask            *task,
 
   g_task_return_boolean (task, TRUE);
 
-  gdk_profiler_end_mark (before, "im compose table load (thread)", NULL);
+  gdk_profiler_end_mark (before, "Compose table load (thread)", NULL);
 }
 
 static void

gtk/gtkmain.c

@@ -549,7 +549,7 @@ do_post_parse_initialization (void)
   gsk_render_node_init_types ();
   _gtk_ensure_resources ();
 
-  gdk_profiler_end_mark (before, "basic initialization", NULL);
+  gdk_profiler_end_mark (before, "Basic initialization", NULL);
 
   gtk_initialized = TRUE;
 
@@ -559,13 +559,13 @@ do_post_parse_initialization (void)
 #endif
   gtk_im_modules_init ();
   gtk_media_file_extension_init ();
-  gdk_profiler_end_mark (before, "init modules", NULL);
+  gdk_profiler_end_mark (before, "Init modules", NULL);
 
   before = GDK_PROFILER_CURRENT_TIME;
   display_manager = gdk_display_manager_get ();
   if (gdk_display_manager_get_default_display (display_manager) != NULL)
     default_display_notify_cb (display_manager);
-  gdk_profiler_end_mark (before, "create display", NULL);
+  gdk_profiler_end_mark (before, "Create display", NULL);
 
   g_signal_connect (display_manager, "notify::default-display",
                     G_CALLBACK (default_display_notify_cb),

gtk/gtkwidget.c

@@ -11956,7 +11956,7 @@ gtk_widget_render (GtkWidget            *widget,
   if (GDK_PROFILER_IS_RUNNING)
     {
       before_render = GDK_PROFILER_CURRENT_TIME;
-      gdk_profiler_add_mark (before_snapshot, (before_render - before_snapshot), "widget snapshot", "");
+      gdk_profiler_add_mark (before_snapshot, (before_render - before_snapshot), "Widget snapshot", "");
     }
 
   if (root != NULL)
@@ -11972,7 +11972,7 @@ gtk_widget_render (GtkWidget            *widget,
 
       gsk_render_node_unref (root);
 
-      gdk_profiler_end_mark (before_render, "widget render", "");
+      gdk_profiler_end_mark (before_render, "Widget render", "");
     }
 }
 

po/fr.po

@@ -22,9 +22,9 @@ msgid ""
 msgstr ""
 "Project-Id-Version: gtk master\n"
 "Report-Msgid-Bugs-To: https://gitlab.gnome.org/GNOME/gtk/-/issues/\n"
-"POT-Creation-Date: 2023-09-19 01:36+0000\n"
+"POT-Creation-Date: 2023-11-18 03:13+0000\n"
 "PO-Revision-Date: 2023-09-19 18:38+0200\n"
-"Last-Translator: Guillaume Bernard <associations@guillaume-bernard.fr>\n"
+"Last-Translator: AesirIvy <aesir.ivy@gmx.com>\n"
 "Language-Team: GNOME French Team <gnomefr@traduc.org>\n"
 "Language: fr\n"
 "MIME-Version: 1.0\n"
@@ -61,59 +61,59 @@ msgstr "Impossible de fournir le contenu comme « %s »"
 msgid "Cannot provide contents as %s"
 msgstr "Impossible de fournir le contenu comme %s"
 
-#: gdk/gdkdisplay.c:156 gdk/gdkglcontext.c:442
+#: gdk/gdkdisplay.c:156 gdk/gdkglcontext.c:443
 msgid "The current backend does not support OpenGL"
 msgstr "Le moteur actuel ne gère pas OpenGL"
 
-#: gdk/gdkdisplay.c:1245 gdk/gdksurface.c:1252
+#: gdk/gdkdisplay.c:1244 gdk/gdksurface.c:1252
 msgid "Vulkan support disabled via GDK_DEBUG"
 msgstr "Prise en charge de Vulkan désactivée via GDK_DEBUG"
 
-#: gdk/gdkdisplay.c:1277
+#: gdk/gdkdisplay.c:1276
 msgid "GL support disabled via GDK_DEBUG"
 msgstr "Prise en charge de GL désactivée via GDK_DEBUG"
 
-#: gdk/gdkdisplay.c:1575
+#: gdk/gdkdisplay.c:1574
 msgid "No EGL configuration available"
 msgstr "Aucune configuration EGL disponible"
 
-#: gdk/gdkdisplay.c:1583
+#: gdk/gdkdisplay.c:1582
 msgid "Failed to get EGL configurations"
 msgstr "Impossible d’obtenir les configurations EGL"
 
-#: gdk/gdkdisplay.c:1613
+#: gdk/gdkdisplay.c:1612
 msgid "No EGL configuration with required features found"
 msgstr ""
 "Aucune configuration EGL avec les fonctionnalités requises n’a été trouvée"
 
-#: gdk/gdkdisplay.c:1620
+#: gdk/gdkdisplay.c:1619
 msgid "No perfect EGL configuration found"
 msgstr "Aucune configuration EGL idéale trouvée"
 
-#: gdk/gdkdisplay.c:1662
+#: gdk/gdkdisplay.c:1661
 #, c-format
 msgid "EGL implementation is missing extension %s"
 msgid_plural "EGL implementation is missing %2$d extensions: %1$s"
 msgstr[0] "L’extension %s manque dans l’implémentation EGL"
 msgstr[1] "%2$d extensions manquent dans l’implémentation EGL : %1$s"
 
-#: gdk/gdkdisplay.c:1695
+#: gdk/gdkdisplay.c:1694
 msgid "libEGL not available in this sandbox"
 msgstr "libEGL n’est pas disponible dans ce bac à sable"
 
-#: gdk/gdkdisplay.c:1696
+#: gdk/gdkdisplay.c:1695
 msgid "libEGL not available"
 msgstr "libEGL non disponible"
 
-#: gdk/gdkdisplay.c:1706
+#: gdk/gdkdisplay.c:1705
 msgid "Failed to create EGL display"
 msgstr "Impossible de créer l’affichage EGL"
 
-#: gdk/gdkdisplay.c:1716
+#: gdk/gdkdisplay.c:1715
 msgid "Could not initialize EGL display"
 msgstr "Impossible d’initialiser l’affichage EGL"
 
-#: gdk/gdkdisplay.c:1727
+#: gdk/gdkdisplay.c:1726
 #, c-format
 msgid "EGL version %d.%d is too old. GTK requires %d.%d"
 msgstr "La version %d.%d d’EGL est trop ancienne. GTK requiert %d.%d"
@@ -127,33 +127,33 @@ msgstr ""
 msgid "No compatible formats to transfer contents."
 msgstr "Aucun format compatible pour le transfert du contenu."
 
-#: gdk/gdkglcontext.c:401 gdk/x11/gdkglcontext-glx.c:642
+#: gdk/gdkglcontext.c:402 gdk/x11/gdkglcontext-glx.c:642
 msgid "No GL API allowed."
 msgstr "Aucune API GL autorisée."
 
-#: gdk/gdkglcontext.c:425 gdk/win32/gdkglcontext-win32-wgl.c:387
+#: gdk/gdkglcontext.c:426 gdk/win32/gdkglcontext-win32-wgl.c:387
 #: gdk/win32/gdkglcontext-win32-wgl.c:530
 #: gdk/win32/gdkglcontext-win32-wgl.c:574 gdk/x11/gdkglcontext-glx.c:691
 msgid "Unable to create a GL context"
 msgstr "Impossible de créer un contexte GL"
 
-#: gdk/gdkglcontext.c:1280
+#: gdk/gdkglcontext.c:1281
 msgid "Anything but OpenGL ES disabled via GDK_DEBUG"
 msgstr "Tout sauf OpenGL ES est désactivé via GTK_DEBUG"
 
-#: gdk/gdkglcontext.c:1289
+#: gdk/gdkglcontext.c:1290
 #, c-format
 msgid "Application does not support %s API"
 msgstr "L’application ne prend pas en charge l’API %s"
 
 #. translators: This is about OpenGL backend names, like
 #. * "Trying to use X11 GLX, but EGL is already in use"
-#: gdk/gdkglcontext.c:1864
+#: gdk/gdkglcontext.c:1899
 #, c-format
 msgid "Trying to use %s, but %s is already in use"
 msgstr "Tentative d’utilisation de %s, mais %s est déjà utilisé"
 
-#: gdk/gdktexture.c:528
+#: gdk/gdktexture.c:530
 msgid "Unknown image format."
 msgstr "Format d’image inconnu."
 
@@ -752,8 +752,7 @@ msgstr "Aucune implémentation GL disponible"
 #: gdk/win32/gdkglcontext-win32-wgl.c:396
 #, c-format
 msgid "WGL version %d.%d is too low, need at least %d.%d"
-msgstr ""
-"La version %d.%d d’EGL est trop basse, elle doit être au moins à %d.%d"
+msgstr "La version %d.%d d’EGL est trop basse, elle doit être au moins à %d.%d"
 
 #: gdk/win32/gdkglcontext-win32-wgl.c:414
 #, c-format
@@ -1084,18 +1083,18 @@ msgctxt "progress bar label"
 msgid "%d %%"
 msgstr "%d %%"
 
-#: gtk/deprecated/gtkcolorbutton.c:183 gtk/deprecated/gtkcolorbutton.c:311
+#: gtk/deprecated/gtkcolorbutton.c:183 gtk/deprecated/gtkcolorbutton.c:314
 #: gtk/gtkcolordialog.c:411
 msgid "Pick a Color"
 msgstr "Choisissez une couleur"
 
-#: gtk/deprecated/gtkcolorbutton.c:502 gtk/gtkcolorchooserwidget.c:313
+#: gtk/deprecated/gtkcolorbutton.c:505 gtk/gtkcolorchooserwidget.c:313
 #: gtk/gtkcolordialogbutton.c:335
 #, c-format
 msgid "Red %d%%, Green %d%%, Blue %d%%, Alpha %d%%"
 msgstr "Rouge %d%%, Vert %d%%, Bleu %d%%, Alpha %d%%"
 
-#: gtk/deprecated/gtkcolorbutton.c:508 gtk/gtkcolorchooserwidget.c:319
+#: gtk/deprecated/gtkcolorbutton.c:511 gtk/gtkcolorchooserwidget.c:319
 #: gtk/gtkcolordialogbutton.c:341
 #, c-format
 msgid "Red %d%%, Green %d%%, Blue %d%%"
@@ -1105,17 +1104,17 @@ msgstr "Rouge %d%%, Vert %d%%, Bleu %d%%"
 msgid "Sans 12"
 msgstr "Sans 12"
 
-#: gtk/deprecated/gtkfontbutton.c:507 gtk/deprecated/gtkfontbutton.c:621
+#: gtk/deprecated/gtkfontbutton.c:507 gtk/deprecated/gtkfontbutton.c:624
 #: gtk/gtkfontdialog.c:596
 msgid "Pick a Font"
 msgstr "Choisissez une police"
 
-#: gtk/deprecated/gtkfontbutton.c:597 gtk/gtkfilechooserwidget.c:3871
+#: gtk/deprecated/gtkfontbutton.c:600 gtk/gtkfilechooserwidget.c:3871
 #: gtk/gtkfontdialogbutton.c:126 gtk/inspector/visual.ui:169
 msgid "Font"
 msgstr "Police"
 
-#: gtk/deprecated/gtkfontbutton.c:1152 gtk/gtkfontdialogbutton.c:652
+#: gtk/deprecated/gtkfontbutton.c:1155 gtk/gtkfontdialogbutton.c:652
 msgctxt "font"
 msgid "None"
 msgstr "Aucune"
@@ -2179,7 +2178,7 @@ msgstr "_Droite :"
 msgid "Paper Margins"
 msgstr "Marges du papier"
 
-#: gtk/gtkentry.c:3673
+#: gtk/gtkentry.c:3685
 msgid "Insert Emoji"
 msgstr "Insérer un émoji"
 
@@ -2249,7 +2248,7 @@ msgstr "Un fichier avec ce nom existe déjà"
 #: gtk/gtkmessagedialog.c:179 gtk/gtkmountoperation.c:608
 #: gtk/print/gtkpagesetupunixdialog.c:282 gtk/print/gtkprintbackend.c:638
 #: gtk/print/gtkprintunixdialog.c:682 gtk/print/gtkprintunixdialog.c:839
-#: gtk/gtkwindow.c:6242 gtk/ui/gtkappchooserdialog.ui:48
+#: gtk/gtkwindow.c:6233 gtk/ui/gtkappchooserdialog.ui:48
 #: gtk/ui/gtkassistant.ui:52 gtk/ui/gtkcolorchooserdialog.ui:36
 #: gtk/ui/gtkfontchooserdialog.ui:27
 msgid "_Cancel"
@@ -2339,7 +2338,7 @@ msgid "If you delete an item, it will be permanently lost."
 msgstr "Si vous supprimez un élément, il sera définitivement perdu."
 
 #: gtk/gtkfilechooserwidget.c:1185 gtk/gtkfilechooserwidget.c:1815
-#: gtk/gtklabel.c:5695 gtk/gtktext.c:6145 gtk/gtktextview.c:9018
+#: gtk/gtklabel.c:5695 gtk/gtktext.c:6147 gtk/gtktextview.c:9018
 msgid "_Delete"
 msgstr "_Supprimer"
 
@@ -2465,6 +2464,7 @@ msgid "Yesterday"
 msgstr "Hier"
 
 #: gtk/gtkfilechooserwidget.c:3823
+#, c-format
 msgid "%-e %b"
 msgstr "%-e %b"
 
@@ -2677,19 +2677,19 @@ msgstr "Fermer"
 msgid "Close the infobar"
 msgstr "Fermer la barre d’information"
 
-#: gtk/gtklabel.c:5692 gtk/gtktext.c:6133 gtk/gtktextview.c:9006
+#: gtk/gtklabel.c:5692 gtk/gtktext.c:6135 gtk/gtktextview.c:9006
 msgid "Cu_t"
 msgstr "Co_uper"
 
-#: gtk/gtklabel.c:5693 gtk/gtktext.c:6137 gtk/gtktextview.c:9010
+#: gtk/gtklabel.c:5693 gtk/gtktext.c:6139 gtk/gtktextview.c:9010
 msgid "_Copy"
 msgstr "_Copier"
 
-#: gtk/gtklabel.c:5694 gtk/gtktext.c:6141 gtk/gtktextview.c:9014
+#: gtk/gtklabel.c:5694 gtk/gtktext.c:6143 gtk/gtktextview.c:9014
 msgid "_Paste"
 msgstr "C_oller"
 
-#: gtk/gtklabel.c:5700 gtk/gtktext.c:6154 gtk/gtktextview.c:9039
+#: gtk/gtklabel.c:5700 gtk/gtktext.c:6156 gtk/gtktextview.c:9039
 msgid "Select _All"
 msgstr "_Tout sélectionner"
 
@@ -2772,7 +2772,7 @@ msgid "Play"
 msgstr "Lecture"
 
 #: gtk/gtkmessagedialog.c:162 gtk/gtkmessagedialog.c:180
-#: gtk/print/gtkprintbackend.c:639 gtk/gtkwindow.c:6243
+#: gtk/print/gtkprintbackend.c:639 gtk/gtkwindow.c:6234
 msgid "_OK"
 msgstr "_Valider"
 
@@ -3377,8 +3377,8 @@ msgstr ""
 
 #. window
 #: gtk/print/gtkprintoperation-portal.c:264
-#: gtk/print/gtkprintoperation-portal.c:584
-#: gtk/print/gtkprintoperation-portal.c:653 gtk/print/gtkprintunixdialog.c:3008
+#: gtk/print/gtkprintoperation-portal.c:594
+#: gtk/print/gtkprintoperation-portal.c:663 gtk/print/gtkprintunixdialog.c:3008
 msgid "Print"
 msgstr "Imprimer"
 
@@ -3553,7 +3553,7 @@ msgstr ""
 "Impossible de trouver une application enregistrée sous le nom « %s » pour "
 "l’élément dont l’URI est « %s »"
 
-#: gtk/gtksearchentry.c:758
+#: gtk/gtksearchentry.c:767
 msgid "Clear Entry"
 msgstr "Efface la saisie"
 
@@ -3644,7 +3644,7 @@ msgctxt "accessibility"
 msgid "Sidebar"
 msgstr "Panneau latéral"
 
-#: gtk/gtktext.c:6159 gtk/gtktextview.c:9044
+#: gtk/gtktext.c:6161 gtk/gtktextview.c:9044
 msgid "Insert _Emoji"
 msgstr "Insérer un _émoji"
 
@@ -3656,12 +3656,12 @@ msgstr "Ann_uler"
 msgid "_Redo"
 msgstr "_Rétablir"
 
-#: gtk/gtkwindow.c:6231
+#: gtk/gtkwindow.c:6222
 #, c-format
 msgid "Do you want to use GTK Inspector?"
 msgstr "Voulez-vous utiliser l’Inspecteur GTK ?"
 
-#: gtk/gtkwindow.c:6233
+#: gtk/gtkwindow.c:6224
 #, c-format
 msgid ""
 "GTK Inspector is an interactive debugger that lets you explore and modify "
@@ -3672,7 +3672,7 @@ msgstr ""
 "modifier les éléments internes de toute application GTK. Son utilisation "
 "peut causer une interruption ou un plantage de l’application."
 
-#: gtk/gtkwindow.c:6238
+#: gtk/gtkwindow.c:6229
 msgid "Don’t show this message again"
 msgstr "Ne plus afficher ce message"
 
@@ -4024,8 +4024,8 @@ msgid "Surface"
 msgstr "Surface"
 
 #: gtk/inspector/misc-info.ui:365 gtk/inspector/misc-info.ui:400
-#: gtk/inspector/misc-info.ui:435 gtk/inspector/prop-editor.c:1150
-#: gtk/inspector/prop-editor.c:1533 gtk/inspector/window.ui:396
+#: gtk/inspector/misc-info.ui:435 gtk/inspector/prop-editor.c:1153
+#: gtk/inspector/prop-editor.c:1536 gtk/inspector/window.ui:396
 msgid "Properties"
 msgstr "Propriétés"
 
@@ -4077,7 +4077,7 @@ msgstr "Pointeur : %p"
 #. Translators: %s is a type name, for example
 #. * GtkPropertyExpression with value \"2.5\"
 #.
-#: gtk/inspector/prop-editor.c:824
+#: gtk/inspector/prop-editor.c:827
 #, c-format
 msgid "%s with value \"%s\""
 msgstr "%s avec valeur « %s »"
@@ -4085,7 +4085,7 @@ msgstr "%s avec valeur « %s »"
 #. Translators: Both %s are type names, for example
 #. * GtkPropertyExpression with type GObject
 #.
-#: gtk/inspector/prop-editor.c:835
+#: gtk/inspector/prop-editor.c:838
 #, c-format
 msgid "%s with type %s"
 msgstr "%s de type %s"
@@ -4093,7 +4093,7 @@ msgstr "%s de type %s"
 #. Translators: Both %s are type names, for example
 #. * GtkObjectExpression for GtkStringObject 0x23456789
 #.
-#: gtk/inspector/prop-editor.c:848
+#: gtk/inspector/prop-editor.c:851
 #, c-format
 msgid "%s for %s %p"
 msgstr "%s pour %s %p"
@@ -4101,71 +4101,71 @@ msgstr "%s pour %s %p"
 #. Translators: Both %s are type names, for example
 #. * GtkPropertyExpression with value type: gchararray
 #.
-#: gtk/inspector/prop-editor.c:878
+#: gtk/inspector/prop-editor.c:881
 #, c-format
 msgid "%s with value type %s"
 msgstr "%s avec type de valeur %s"
 
-#: gtk/inspector/prop-editor.c:1227
+#: gtk/inspector/prop-editor.c:1230
 #, c-format
 msgid "Uneditable property type: %s"
 msgstr "Type de propriété non éditable : %s"
 
-#: gtk/inspector/prop-editor.c:1385
+#: gtk/inspector/prop-editor.c:1388
 msgctxt "column number"
 msgid "None"
 msgstr "Aucun"
 
-#: gtk/inspector/prop-editor.c:1422
+#: gtk/inspector/prop-editor.c:1425
 msgid "Attribute:"
 msgstr "Attribut :"
 
-#: gtk/inspector/prop-editor.c:1425
+#: gtk/inspector/prop-editor.c:1428
 msgid "Model"
 msgstr "Modèle"
 
-#: gtk/inspector/prop-editor.c:1430
+#: gtk/inspector/prop-editor.c:1433
 msgid "Column:"
 msgstr "Colonne :"
 
 #. Translators: %s is a type name, for example
 #. * Action from 0x2345678 (GtkApplicationWindow)
 #.
-#: gtk/inspector/prop-editor.c:1529
+#: gtk/inspector/prop-editor.c:1532
 #, c-format
 msgid "Action from: %p (%s)"
 msgstr "Action de : %p (%s)"
 
-#: gtk/inspector/prop-editor.c:1584
+#: gtk/inspector/prop-editor.c:1587
 msgid "Reset"
 msgstr "Réinitialiser"
 
-#: gtk/inspector/prop-editor.c:1592
+#: gtk/inspector/prop-editor.c:1595
 msgctxt "GtkSettings source"
 msgid "Default"
 msgstr "Par défaut"
 
-#: gtk/inspector/prop-editor.c:1595
+#: gtk/inspector/prop-editor.c:1598
 msgctxt "GtkSettings source"
 msgid "Theme"
 msgstr "Thème"
 
-#: gtk/inspector/prop-editor.c:1598
+#: gtk/inspector/prop-editor.c:1601
 msgctxt "GtkSettings source"
 msgid "XSettings"
 msgstr "Paramètres X"
 
-#: gtk/inspector/prop-editor.c:1602
+#: gtk/inspector/prop-editor.c:1605
 msgctxt "GtkSettings source"
 msgid "Application"
 msgstr "Application"
 
-#: gtk/inspector/prop-editor.c:1605
+#: gtk/inspector/prop-editor.c:1608
 msgctxt "GtkSettings source"
 msgid "Unknown"
 msgstr "Inconnue"
 
-#: gtk/inspector/prop-editor.c:1608
+#: gtk/inspector/prop-editor.c:1611
 msgid "Source:"
 msgstr "Source :"
 
@@ -7228,7 +7228,7 @@ msgstr ""
 #: tools/gtk-builder-tool-enumerate.c:56 tools/gtk-builder-tool-preview.c:179
 #: tools/gtk-builder-tool-preview.c:180 tools/gtk-builder-tool-screenshot.c:360
 #: tools/gtk-builder-tool-simplify.c:2529 tools/gtk-builder-tool-validate.c:261
-#: tools/gtk-rendernode-tool-info.c:200 tools/gtk-rendernode-tool-show.c:102
+#: tools/gtk-rendernode-tool-info.c:202 tools/gtk-rendernode-tool-show.c:106
 msgid "FILE"
 msgstr "FICHIER"
 
@@ -7260,7 +7260,7 @@ msgid "Use style from CSS file"
 msgstr "Utiliser le style d’un fichier CSS"
 
 #: tools/gtk-builder-tool-preview.c:187 tools/gtk-builder-tool-screenshot.c:370
-#: tools/gtk-builder-tool-validate.c:268 tools/gtk-rendernode-tool-show.c:109
+#: tools/gtk-builder-tool-validate.c:268 tools/gtk-rendernode-tool-show.c:113
 #: tools/gtk-rendernode-tool-render.c:204
 #, c-format
 msgid "Could not initialize windowing system\n"
@@ -7515,47 +7515,50 @@ msgstr ""
 "  render       Prendre une capture d’écran du nœud\n"
 "\n"
 
-#: tools/gtk-rendernode-tool-info.c:177
+#: tools/gtk-rendernode-tool-info.c:179
 #, c-format
 msgid "Number of nodes: %u\n"
 msgstr "Nombre de nœuds : %u\n"
 
-#: tools/gtk-rendernode-tool-info.c:184
+#: tools/gtk-rendernode-tool-info.c:186
 #, c-format
 msgid "Depth: %u\n"
 msgstr "Profondeur : %u\n"
 
-#: tools/gtk-rendernode-tool-info.c:187
+#: tools/gtk-rendernode-tool-info.c:189
 #, c-format
 msgid "Bounds: %g x %g\n"
 msgstr "Limites : %g × %g\n"
 
-#: tools/gtk-rendernode-tool-info.c:188
+#: tools/gtk-rendernode-tool-info.c:190
 #, c-format
 msgid "Origin: %g %g\n"
 msgstr "Origine : %g %g\n"
 
-#: tools/gtk-rendernode-tool-info.c:209
+#: tools/gtk-rendernode-tool-info.c:211
 msgid "Provide information about the render node."
 msgstr "Fournir des informations sur le nœud de rendu."
 
-#: tools/gtk-rendernode-tool-info.c:222 tools/gtk-rendernode-tool-show.c:130
+#: tools/gtk-rendernode-tool-info.c:224 tools/gtk-rendernode-tool-show.c:134
 #: tools/gtk-rendernode-tool-render.c:225
 #, c-format
 msgid "No .node file specified\n"
 msgstr "Aucun fichier .node indiqué\n"
 
-#: tools/gtk-rendernode-tool-info.c:228
+#: tools/gtk-rendernode-tool-info.c:230
 #, c-format
 msgid "Can only accept a single .node file\n"
-msgstr ""
-"N’accepte qu’un unique fichier .node\n"
+msgstr "N’accepte qu’un unique fichier .node\n"
 
-#: tools/gtk-rendernode-tool-show.c:117
+#: tools/gtk-rendernode-tool-show.c:105
+msgid "Don't add a titlebar"
+msgstr "Ne pas ajouter de barre de titre"
+
+#: tools/gtk-rendernode-tool-show.c:121
 msgid "Show the render node."
 msgstr "Afficher le nœud de rendu."
 
-#: tools/gtk-rendernode-tool-show.c:136
+#: tools/gtk-rendernode-tool-show.c:140
 #, c-format
 msgid "Can only preview a single .node file\n"
 msgstr "Ne peut afficher l’aperçu que d’un unique fichier .node\n"
@@ -7590,14 +7593,19 @@ msgstr "Réaliser le rendu du fichier .node vers une image."
 #, c-format
 msgid "Can only render a single .node file to a single output file\n"
 msgstr ""
-"Ne peut effectuer le rendu que d’un unique fichier .node vers un seul fichier "
-"de sortie\n"
+"Ne peut effectuer le rendu que d’un unique fichier .node vers un seul "
+"fichier de sortie\n"
 
 #: tools/gtk-rendernode-tool-utils.c:51
 #, c-format
 msgid "Error at %s: %s\n"
 msgstr "Erreur à %s : %s\n"
 
+#: tools/gtk-rendernode-tool-utils.c:69
+#, c-format
+msgid "Failed to load node file: %s\n"
+msgstr "Impossible de charger le fichier de nœud : %s\n"
+
 #: tools/updateiconcache.c:1391
 #, c-format
 msgid "Failed to write header\n"

testsuite/gsk/compare/container-single-child-offscreen-for-opacity.node

@@ -0,0 +1,15 @@
+opacity {
+  opacity: 0.6;
+  child: container {
+    container {
+      color {
+        bounds: 0 0 40 40;
+        color: rgb(255,0,0);
+      }
+      color {
+        bounds: 10 10 40 40;
+        color: rgb(0,255,0);
+      }
+    }
+  }
+}

testsuite/gsk/compare/glyph-cache-overflow-slices.node

@@ -0,0 +1,181 @@
+clip {
+  clip: 0 -15 1024 1024;
+  child: container {
+
+    color {
+      color: black;
+      bounds: 0 -15 1024 1024;
+    }
+
+    text {
+      color: red;
+      font: "Font 13px" url("data://;base64,\
+AAEAAAAIAIAAAwAAY21hcAAIAKUAAAIMAAAALGdseWZFxbN2AAACvAAABhZoZWFkvj7BOAAAAIwA\
+AAA2aGhlYQFBAXIAAADEAAAAJGhtdHhMoAAAAAABCAAAAQRsb2NhMYAzCwAAAjgAAACEbWF4cABD\
+AAUAAADoAAAAIG5hbWVuh0Z1AAAI1AAAABYAAQAAAAEZmoDtU+9fDzz1AAIAEAAAAAB8JbCAAAAA\
+AOHTuggAAAAAATAAEAAAAAEAAgAAAAAAAAABAAAAEAAAAAABMAAAAAABMAABAAAAAAAAAAAAAAAA\
+AAAAQQABAAAAQQAEAAEAAAAAAAEAAAAAAAAAAAAAAAAAAAAAATAAAAEwAAABMAAAATAAAAEwAAAB\
+MAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEw\
+AAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAA\
+AAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAA\
+ATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAAB\
+MAAAATAAAACgAAAAAAABAAAAAwAAAAwABAAgAAAABAAEAAEAAABw//8AAAAw////0AABAAAAAAAA\
+AAwAGAAkADAAPABIAFQAYABsAHgAhACQAJwAqAC0AMAAzADYAOQA8AD8AQgBFAEgASwBOAFEAVAB\
+XAFoAXQBgAGMAZgBpAGwAbwByAHUAeAB7AH4AgQCEAIcAigCNAJAAkwCWAJkAnACfAKIApQCoAKs\
+ArgCxALQAtwC6AL0AwADCwABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAACgABAAAwAAMTM1I6CgEAAAAAAAAAEAEgABAAAAAAABAAQAAEZv\
+bnQAAA==");
+      glyphs: 0 0 1 1, 1 0 257 1, 2 0 513 1, 3 0 769 1,
+    4 0 1 17, 5 0 257 17, 6 0 513 17, 7 0 769 17,
+    8 0 1 33, 9 0 257 33, 10 0 513 33, 11 0 769 33,
+    12 0 1 49, 13 0 257 49, 14 0 513 49, 15 0 769 49,
+    16 0 1 65, 17 0 257 65, 18 0 513 65, 19 0 769 65,
+    20 0 1 81, 21 0 257 81, 22 0 513 81, 23 0 769 81,
+    24 0 1 97, 25 0 257 97, 26 0 513 97, 27 0 769 97,
+    28 0 1 113, 29 0 257 113, 30 0 513 113, 31 0 769 113,
+    32 0 1 129, 33 0 257 129, 34 0 513 129, 35 0 769 129,
+    36 0 1 145, 37 0 257 145, 38 0 513 145, 39 0 769 145,
+    40 0 1 161, 41 0 257 161, 42 0 513 161, 43 0 769 161,
+    44 0 1 177, 45 0 257 177, 46 0 513 177, 47 0 769 177,
+    48 0 1 193, 49 0 257 193, 50 0 513 193, 51 0 769 193,
+    52 0 1 209, 53 0 257 209, 54 0 513 209, 55 0 769 209,
+    56 0 1 225, 57 0 257 225, 58 0 513 225, 59 0 769 225,
+    60 0 1 241, 61 0 257 241, 62 0 513 241, 63 0 769 241;
+    }
+
+    text {
+      color: red;
+      font: "Font 12px";
+      glyphs: 0 0 1 257, 1 0 257 257, 2 0 513 257, 3 0 769 257,
+    4 0 1 273, 5 0 257 273, 6 0 513 273, 7 0 769 273,
+    8 0 1 289, 9 0 257 289, 10 0 513 289, 11 0 769 289,
+    12 0 1 305, 13 0 257 305, 14 0 513 305, 15 0 769 305,
+    16 0 1 321, 17 0 257 321, 18 0 513 321, 19 0 769 321,
+    20 0 1 337, 21 0 257 337, 22 0 513 337, 23 0 769 337,
+    24 0 1 353, 25 0 257 353, 26 0 513 353, 27 0 769 353,
+    28 0 1 369, 29 0 257 369, 30 0 513 369, 31 0 769 369,
+    32 0 1 385, 33 0 257 385, 34 0 513 385, 35 0 769 385,
+    36 0 1 401, 37 0 257 401, 38 0 513 401, 39 0 769 401,
+    40 0 1 417, 41 0 257 417, 42 0 513 417, 43 0 769 417,
+    44 0 1 433, 45 0 257 433, 46 0 513 433, 47 0 769 433,
+    48 0 1 449, 49 0 257 449, 50 0 513 449, 51 0 769 449,
+    52 0 1 465, 53 0 257 465, 54 0 513 465, 55 0 769 465,
+    56 0 1 481, 57 0 257 481, 58 0 513 481, 59 0 769 481,
+    60 0 1 497, 61 0 257 497, 62 0 513 497, 63 0 769 497;
+    }
+
+    text {
+      color: red;
+      font: "Font 2 13px" url("data://;base64,\
+AAEAAAAIAIAAAwAAY21hcAAIAKUAAAIMAAAALGdseWZFxbN2AAACvAAABhZoZWFkvj7C5QAAAIwA\
+AAA2aGhlYQFBAXIAAADEAAAAJGhtdHhMoAAAAAABCAAAAQRsb2NhMYAzCwAAAjgAAACEbWF4cABD\
+AAUAAADoAAAAIG5hbWVuh2apAAAI1AAAABgAAQAAAAEZmoDtECtfDzz1AAIAEAAAAAB8JbCAAAAA\
+AOHTu7UAAAAAATAAEAAAAAEAAgAAAAAAAAABAAAAEAAAAAABMAAAAAABMAABAAAAAAAAAAAAAAAA\
+AAAAQQABAAAAQQAEAAEAAAAAAAEAAAAAAAAAAAAAAAAAAAAAATAAAAEwAAABMAAAATAAAAEwAAAB\
+MAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEw\
+AAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAA\
+AAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAA\
+ATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAABMAAAATAAAAEwAAAB\
+MAAAATAAAACgAAAAAAABAAAAAwAAAAwABAAgAAAABAAEAAEAAABw//8AAAAw////0AABAAAAAAAA\
+AAwAGAAkADAAPABIAFQAYABsAHgAhACQAJwAqAC0AMAAzADYAOQA8AD8AQgBFAEgASwBOAFEAVAB\
+XAFoAXQBgAGMAZgBpAGwAbwByAHUAeAB7AH4AgQCEAIcAigCNAJAAkwCWAJkAnACfAKIApQCoAKs\
+ArgCxALQAtwC6AL0AwADCwABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw\
+/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAA\
+AAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAA\
+MSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQ\
+AAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEw\
+ABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1\
+IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAAB\
+AAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAAAwAAMSE1IQEw/tAQAAABAAAAAAEwABAA\
+AwAAMSE1IQEw/tAQAAABAAAAAACgABAAAwAAMTM1I6CgEAAAAAAAAAEAEgABAAAAAAABAAYAAEZv\
+bnQgMg==");
+      glyphs: 0 0 1 513, 1 0 257 513, 2 0 513 513, 3 0 769 513,
+    4 0 1 529, 5 0 257 529, 6 0 513 529, 7 0 769 529,
+    8 0 1 545, 9 0 257 545, 10 0 513 545, 11 0 769 545,
+    12 0 1 561, 13 0 257 561, 14 0 513 561, 15 0 769 561,
+    16 0 1 577, 17 0 257 577, 18 0 513 577, 19 0 769 577,
+    20 0 1 593, 21 0 257 593, 22 0 513 593, 23 0 769 593,
+    24 0 1 609, 25 0 257 609, 26 0 513 609, 27 0 769 609,
+    28 0 1 625, 29 0 257 625, 30 0 513 625, 31 0 769 625,
+    32 0 1 641, 33 0 257 641, 34 0 513 641, 35 0 769 641,
+    36 0 1 657, 37 0 257 657, 38 0 513 657, 39 0 769 657,
+    40 0 1 673, 41 0 257 673, 42 0 513 673, 43 0 769 673,
+    44 0 1 689, 45 0 257 689, 46 0 513 689, 47 0 769 689,
+    48 0 1 705, 49 0 257 705, 50 0 513 705, 51 0 769 705,
+    52 0 1 721, 53 0 257 721, 54 0 513 721, 55 0 769 721,
+    56 0 1 737, 57 0 257 737, 58 0 513 737, 59 0 769 737,
+    60 0 1 753, 61 0 257 753, 62 0 513 753, 63 0 769 753;
+    }
+
+    text {
+      color: red;
+      font: "Font 2 12px";
+      glyphs: 0 0 1 769, 1 0 257 769, 2 0 513 769, 3 0 769 769,
+    4 0 1 785, 5 0 257 785, 6 0 513 785, 7 0 769 785,
+    8 0 1 801, 9 0 257 801, 10 0 513 801, 11 0 769 801,
+    12 0 1 817, 13 0 257 817, 14 0 513 817, 15 0 769 817,
+    16 0 1 833, 17 0 257 833, 18 0 513 833, 19 0 769 833,
+    20 0 1 849, 21 0 257 849, 22 0 513 849, 23 0 769 849,
+    24 0 1 865, 25 0 257 865, 26 0 513 865, 27 0 769 865,
+    28 0 1 881, 29 0 257 881, 30 0 513 881, 31 0 769 881,
+    32 0 1 897, 33 0 257 897, 34 0 513 897, 35 0 769 897,
+    36 0 1 913, 37 0 257 913, 38 0 513 913, 39 0 769 913,
+    40 0 1 929, 41 0 257 929, 42 0 513 929, 43 0 769 929,
+    44 0 1 945, 45 0 257 945, 46 0 513 945, 47 0 769 945,
+    48 0 1 961, 49 0 257 961, 50 0 513 961, 51 0 769 961,
+    52 0 1 977, 53 0 257 977, 54 0 513 977, 55 0 769 977,
+    56 0 1 993, 57 0 257 993, 58 0 513 993, 59 0 769 993;
+    }
+
+    text {
+      color: red;
+      font: "Font 15px";
+      glyphs: 64 0 0 1009;
+    }
+  }
+}

testsuite/gsk/compare/glyph-cache-overflow.node

@@ -0,0 +1,508 @@
+text {
+  color: red;
+  font: "BlockBlockBlock 210px" url("data://;base64,\
+AAEAAAAIAIAAAwAAY21hcAByAD0AAAEUAAAANGdseWY/ZsNsAAABVAAAAEhoZWFkJqsy2gAAAIwA\
+AAA2aGhlYQwBBAIAAADEAAAAJGhtdHgEAAAAAAABCAAAAApsb2NhADAAGAAAAUgAAAAKbWF4cAAG\
+AAUAAADoAAAAIG5hbWWJUoCNAAABnAAAACEAAQAAAAEZmmVCT9xfDzz1AAIIAAAAAADhwj0AAAAA\
+AOHTj0oAAAAABAAIAAAAAAEAAgAAAAAAAAABAAAIAAAAAAAEAAAAAAAEAAABAAAAAAAAAAAAAAAA\
+AAAAAQABAAAABAAEAAEAAAAAAAEAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAQAAAAMA\
+AAAMAAQAKAAAAAYABAABAAIAIABD//8AAAAgAEH////g/8AAAQAAAAAAAAAAAAAADAAYACQAAAAB\
+AAAAAAQACAAAAwAAMSERIQQA/AAIAAABAAAAAAQACAAAAwAAMSERIQQA/AAIAAABAAAAAAQACAAA\
+AwAAMSERIQQA/AAIAAAAAAEAEgABAAAAAAABAA8AAEJsb2NrQmxvY2tCbG9jawAAAA==");
+  glyphs: 1 150, 2 150, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 208px";
+  glyphs: 1 150, 2 151, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 206px";
+  glyphs: 1 151, 2 151, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 204px";
+  glyphs: 1 151, 2 152, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 202px";
+  glyphs: 1 152, 2 152, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 200px";
+  glyphs: 1 152, 2 153, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 198px";
+  glyphs: 1 153, 2 153, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 196px";
+  glyphs: 1 153, 2 154, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 194px";
+  glyphs: 1 154, 2 154, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 192px";
+  glyphs: 1 154, 2 155, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 190px";
+  glyphs: 1 155, 2 155, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 188px";
+  glyphs: 1 155, 2 156, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 186px";
+  glyphs: 1 156, 2 156, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 184px";
+  glyphs: 1 156, 2 157, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 182px";
+  glyphs: 1 157, 2 157, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 180px";
+  glyphs: 1 157, 2 158, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 178px";
+  glyphs: 1 158, 2 158, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 176px";
+  glyphs: 1 158, 2 159, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 174px";
+  glyphs: 1 159, 2 159, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 172px";
+  glyphs: 1 159, 2 160, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 170px";
+  glyphs: 1 160, 2 160, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 168px";
+  glyphs: 1 160, 2 161, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 166px";
+  glyphs: 1 161, 2 161, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 164px";
+  glyphs: 1 161, 2 162, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 162px";
+  glyphs: 1 162, 2 162, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 160px";
+  glyphs: 1 162, 2 163, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 158px";
+  glyphs: 1 163, 2 163, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 156px";
+  glyphs: 1 163, 2 164, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 154px";
+  glyphs: 1 164, 2 164, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 152px";
+  glyphs: 1 164, 2 165, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 150px";
+  glyphs: 1 165, 2 165, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 148px";
+  glyphs: 1 165, 2 166, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 146px";
+  glyphs: 1 166, 2 166, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 144px";
+  glyphs: 1 166, 2 167, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 142px";
+  glyphs: 1 167, 2 167, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 140px";
+  glyphs: 1 167, 2 168, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 138px";
+  glyphs: 1 168, 2 168, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 136px";
+  glyphs: 1 168, 2 169, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 134px";
+  glyphs: 1 169, 2 169, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 132px";
+  glyphs: 1 169, 2 170, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 130px";
+  glyphs: 1 170, 2 170, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 128px";
+  glyphs: 1 170, 2 171, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 126px";
+  glyphs: 1 171, 2 171, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 124px";
+  glyphs: 1 171, 2 172, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 122px";
+  glyphs: 1 172, 2 172, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 120px";
+  glyphs: 1 172, 2 173, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 118px";
+  glyphs: 1 173, 2 173, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 116px";
+  glyphs: 1 173, 2 174, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 114px";
+  glyphs: 1 174, 2 174, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 112px";
+  glyphs: 1 174, 2 175, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 110px";
+  glyphs: 1 175, 2 175, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 108px";
+  glyphs: 1 175, 2 176, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 106px";
+  glyphs: 1 176, 2 176, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 104px";
+  glyphs: 1 176, 2 177, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 102px";
+  glyphs: 1 177, 2 177, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 100px";
+  glyphs: 1 177, 2 178, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 98px";
+  glyphs: 1 178, 2 178, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 96px";
+  glyphs: 1 178, 2 179, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 94px";
+  glyphs: 1 179, 2 179, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 92px";
+  glyphs: 1 179, 2 180, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 90px";
+  glyphs: 1 180, 2 180, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 88px";
+  glyphs: 1 180, 2 181, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 86px";
+  glyphs: 1 181, 2 181, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 84px";
+  glyphs: 1 181, 2 182, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 82px";
+  glyphs: 1 182, 2 182, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 80px";
+  glyphs: 1 182, 2 183, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 78px";
+  glyphs: 1 183, 2 183, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 76px";
+  glyphs: 1 183, 2 184, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 74px";
+  glyphs: 1 184, 2 184, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 72px";
+  glyphs: 1 184, 2 185, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 70px";
+  glyphs: 1 185, 2 185, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 68px";
+  glyphs: 1 185, 2 186, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 66px";
+  glyphs: 1 186, 2 186, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 64px";
+  glyphs: 1 186, 2 187, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 62px";
+  glyphs: 1 187, 2 187, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 60px";
+  glyphs: 1 187, 2 188, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 58px";
+  glyphs: 1 188, 2 188, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 56px";
+  glyphs: 1 188, 2 189, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 54px";
+  glyphs: 1 189, 2 189, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 52px";
+  glyphs: 1 189, 2 190, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 50px";
+  glyphs: 1 190, 2 190, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 48px";
+  glyphs: 1 190, 2 191, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 46px";
+  glyphs: 1 191, 2 191, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 44px";
+  glyphs: 1 191, 2 192, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 42px";
+  glyphs: 1 192, 2 192, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 40px";
+  glyphs: 1 192, 2 193, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 38px";
+  glyphs: 1 193, 2 193, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 36px";
+  glyphs: 1 193, 2 194, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 34px";
+  glyphs: 1 194, 2 194, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 32px";
+  glyphs: 1 194, 2 195, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 30px";
+  glyphs: 1 195, 2 195, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 28px";
+  glyphs: 1 195, 2 196, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 26px";
+  glyphs: 1 196, 2 196, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 24px";
+  glyphs: 1 196, 2 197, 3 0;
+}
+text {
+  color: magenta;
+  font: "BlockBlockBlock 22px";
+  glyphs: 1 197, 2 197, 3 0;
+}
+text {
+  color: teal;
+  font: "BlockBlockBlock 20px";
+  glyphs: 1 197, 2 198, 3 0;
+}
+text {
+  color: red;
+  font: "BlockBlockBlock 18px";
+  glyphs: 1 198, 2 198, 3 0;
+}
+text {
+  color: lime;
+  font: "BlockBlockBlock 16px";
+  glyphs: 1 198, 2 199, 3 0;
+}
+text {
+  color: blue;
+  font: "BlockBlockBlock 14px";
+  glyphs: 1 199, 2 199, 3 0;
+}
+text {
+  color: yellow;
+  font: "BlockBlockBlock 12px";
+  glyphs: 1 199, 2 200, 3 0;
+}