gsk: Use gsk_text_node_use_font_hinting

The render node now provides this information, so we don't need
to recompute it ourselves.

gsk/gpu/gskgpunodeprocessor.c

@@ -36,7 +36,6 @@
 #include "gskdebugprivate.h"
 #include "gskpath.h"
 #include "gskrectprivate.h"
-#include "gskvec2private.h"
 #include "gskrendernodeprivate.h"
 #include "gskroundedrectprivate.h"
 #include "gskstrokeprivate.h"
@@ -196,9 +195,9 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor         *self,
 
   self->modelview = NULL;
   gsk_gpu_image_get_projection_matrix (target, &self->projection);
-  gsk_vec2_init (&self->scale,
-                 width / viewport->size.width,
-                 height / viewport->size.height);
+  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;
@@ -320,8 +319,8 @@ rect_round_to_pixels (const graphene_rect_t  *src,
 {
   float x, y, xscale, yscale, inv_xscale, inv_yscale;
 
-  xscale = gsk_vec2_get_x (pixel_scale);
-  yscale = gsk_vec2_get_y (pixel_scale);
+  xscale = graphene_vec2_get_x (pixel_scale);
+  yscale = graphene_vec2_get_y (pixel_scale);
   inv_xscale = 1.0f / xscale;
   inv_yscale = 1.0f / yscale;
 
@@ -346,8 +345,8 @@ gsk_gpu_node_processor_init_draw (GskGpuNodeProcessor   *self,
 
   area.x = 0;
   area.y = 0;
-  area.width = ceilf (gsk_vec2_get_x (scale) * viewport->size.width - EPSILON);
-  area.height = ceilf (gsk_vec2_get_y (scale) * viewport->size.height - EPSILON);
+  area.width = ceilf (graphene_vec2_get_x (scale) * viewport->size.width - EPSILON);
+  area.height = ceilf (graphene_vec2_get_y (scale) * viewport->size.height - EPSILON);
 
   image = gsk_gpu_device_create_offscreen_image (gsk_gpu_frame_get_device (frame),
                                                  FALSE,
@@ -630,8 +629,8 @@ gsk_gpu_node_processor_rect_is_integer (GskGpuNodeProcessor   *self,
                                         cairo_rectangle_int_t *int_rect)
 {
   graphene_rect_t transformed_rect;
-  float scale_x = gsk_vec2_get_x (&self->scale);
-  float scale_y = gsk_vec2_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))
     {
@@ -1031,7 +1030,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
 
   gsk_gpu_node_processor_sync_globals (&other, 0);
 
-  gsk_vec2_init (&direction, blur_radius, 0.0f);
+  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,
@@ -1045,7 +1044,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor       *self,
 
   real_offset = GRAPHENE_POINT_INIT (self->offset.x + shadow_offset->x,
                                      self->offset.y + shadow_offset->y);
-  gsk_vec2_init (&direction, 0.0f, blur_radius);
+  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)
     {
@@ -1582,8 +1581,8 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         gsk_gpu_clip_scale (&self->clip, &old_clip, scale_x, scale_y);
         self->offset.x = (self->offset.x + dx) / scale_x;
         self->offset.y = (self->offset.y + dy) / scale_y;
-        gsk_vec2_init (&self->scale, fabs (scale_x), fabs (scale_y));
-        gsk_vec2_multiply (&self->scale, &old_scale, &self->scale);
+        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 / fabs (scale_x),
                                                scale_y / fabs (scale_y));
@@ -1643,15 +1642,15 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
         old_modelview = gsk_transform_ref (self->modelview);
 
         self->modelview = gsk_transform_scale (self->modelview,
-                                               gsk_vec2_get_x (&self->scale),
-                                               gsk_vec2_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);
 
         extract_scale_from_transform (self->modelview, &scale_x, &scale_y);
 
-        old_pixels = MAX (gsk_vec2_get_x (&old_scale) * old_clip.rect.bounds.size.width,
-                          gsk_vec2_get_y (&old_scale) * old_clip.rect.bounds.size.height);
+        old_pixels = MAX (graphene_vec2_get_x (&old_scale) * old_clip.rect.bounds.size.width,
+                          graphene_vec2_get_y (&old_scale) * old_clip.rect.bounds.size.height);
         new_pixels = MAX (scale_x * self->clip.rect.bounds.size.width,
                           scale_y * self->clip.rect.bounds.size.height);
 
@@ -1664,7 +1663,7 @@ gsk_gpu_node_processor_add_transform_node (GskGpuNodeProcessor *self,
           }
 
         self->modelview = gsk_transform_scale (self->modelview, 1 / scale_x, 1 / scale_y);
-        gsk_vec2_init (&self->scale, scale_x, scale_y);
+        graphene_vec2_init (&self->scale, scale_x, scale_y);
         self->offset = *graphene_point_zero ();
       }
       break;
@@ -1736,8 +1735,8 @@ gsk_gpu_node_processor_create_transform_pattern (GskGpuPatternWriter *self,
         self->bounds.size.width *= inv_sx;
         self->bounds.size.height *= inv_sy;
         self->offset = GRAPHENE_POINT_INIT (0, 0);
-        gsk_vec2_init (&self->scale, fabs (sx), fabs (sy));
-        gsk_vec2_multiply (&self->scale, &old_scale, &self->scale);
+        graphene_vec2_init (&self->scale, fabs (sx), fabs (sy));
+        graphene_vec2_multiply (&self->scale, &old_scale, &self->scale);
       }
       break;
 
@@ -1821,8 +1820,8 @@ gsk_gpu_node_processor_add_color_node (GskGpuNodeProcessor *self,
               return;
             }
 
-          scale_x = gsk_vec2_get_x (&self->scale);
-          scale_y = gsk_vec2_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, graphene_point_zero(), &clipped);
@@ -1949,8 +1948,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_vec2_get_x (&self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_vec2_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;
 
@@ -2016,8 +2015,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_vec2_get_x (&self->scale) ||
-       gdk_texture_get_height (texture) > 2 * node->bounds.size.height * gsk_vec2_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,
@@ -2061,7 +2060,7 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self,
   gboolean need_mipmap, need_offscreen;
 
   need_offscreen = self->modelview != NULL ||
-                   gsk_vec2_equal (&self->scale, graphene_vec2_one ());
+            !graphene_vec2_equal (&self->scale, graphene_vec2_one ());
   if (need_offscreen)
     {
       GskGpuImage *offscreen;
@@ -3018,15 +3017,15 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *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);
+  hinting = gsk_text_node_use_font_hinting (node);
   offset = *gsk_text_node_get_offset (node);
   offset.x += self->offset.x;
   offset.y += self->offset.y;
 
-  scale = MAX (gsk_vec2_get_x (&self->scale), gsk_vec2_get_y (&self->scale));
+  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
   inv_scale = 1.f / scale;
 
   glyph_align = gsk_gpu_frame_should_optimize (self->frame, GSK_GPU_OPTIMIZE_GLYPH_ALIGN);
-  hinting = gsk_font_get_hint_style (font) != CAIRO_HINT_STYLE_NONE;
 
   for (i = 0; i < num_glyphs; i++)
     {
@@ -3136,7 +3135,7 @@ gsk_gpu_node_processor_create_glyph_pattern (GskGpuPatternWriter *self,
   offset.x += self->offset.x;
   offset.y += self->offset.y;
 
-  scale = MAX (gsk_vec2_get_x (&self->scale), gsk_vec2_get_y (&self->scale));
+  scale = MAX (graphene_vec2_get_x (&self->scale), graphene_vec2_get_y (&self->scale));
   inv_scale = 1.f / scale;
 
   gsk_gpu_pattern_writer_append_uint (self, GSK_GPU_PATTERN_GLYPHS);

gsk/gpu/gskgpuuploadop.c

@@ -14,7 +14,6 @@
 
 #include "gdk/gdkglcontextprivate.h"
 #include "gsk/gskdebugprivate.h"
-#include "gskvec2private.h"
 
 static GskGpuOp *
 gsk_gpu_upload_op_gl_command_with_area (GskGpuOp                    *op,
@@ -466,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_vec2_get_x (scale) * viewport->size.width),
-                                                    ceil (gsk_vec2_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/gskrendernodeimpl.c

@@ -5833,6 +5833,7 @@ gsk_text_node_new (PangoFont              *font,
   self = gsk_render_node_alloc (GSK_TEXT_NODE);
   node = (GskRenderNode *) self;
   node->offscreen_for_opacity = FALSE;
+  node->font_hinting = gsk_font_get_hint_style (font) != CAIRO_HINT_STYLE_NONE;
 
   self->fontmap = g_object_ref (pango_font_get_font_map (font));
   self->font = g_object_ref (font);

gsk/gskrendernodeprivate.h

@@ -34,6 +34,7 @@ struct _GskRenderNode
 
   guint preferred_depth : 2;
   guint offscreen_for_opacity : 1;
+  guint font_hinting  : 1;
 };
 
 typedef struct
@@ -100,6 +101,12 @@ gboolean        gsk_container_node_is_disjoint          (const GskRenderNode
 
 gboolean        gsk_render_node_use_offscreen_for_opacity (const GskRenderNode       *node) G_GNUC_PURE;
 
+static inline gboolean
+gsk_text_node_use_font_hinting (const GskRenderNode *node)
+{
+  return node->font_hinting;
+}
+
 #define gsk_render_node_ref(node)   _gsk_render_node_ref(node)
 #define gsk_render_node_unref(node) _gsk_render_node_unref(node)
 

gsk/gskvec2private.h

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