/* * Copyright © 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Author(s): Behdad Esfahbod */ #include "hb.hh" #include "hb-vector-paint.hh" #include "hb-paint.hh" #include "hb-vector-path.hh" #include static const char * hb_vector_svg_extend_mode_str (hb_paint_extend_t ext) { switch (ext) { case HB_PAINT_EXTEND_PAD: return "pad"; case HB_PAINT_EXTEND_REPEAT: return "repeat"; case HB_PAINT_EXTEND_REFLECT: return "reflect"; default: return "pad"; } } static void hb_vector_svg_emit_color_stops (hb_vector_paint_t *paint, hb_vector_buf_t *buf, hb_vector_t *stops) { for (unsigned i = 0; i < stops->length; i++) { hb_color_t c = stops->arrayZ[i].color; buf->append_str ("append_num (stops->arrayZ[i].offset, 4); buf->append_str ("\" stop-color=\"rgb("); buf->append_unsigned (hb_color_get_red (c)); buf->append_c (','); buf->append_unsigned (hb_color_get_green (c)); buf->append_c (','); buf->append_unsigned (hb_color_get_blue (c)); buf->append_str (")\""); if (hb_color_get_alpha (c) != 255) { buf->append_str (" stop-opacity=\""); buf->append_num (hb_color_get_alpha (c) / 255.f, 4); buf->append_c ('"'); } buf->append_str ("/>\n"); } } static const char * hb_vector_svg_composite_mode_str (hb_paint_composite_mode_t mode) { switch (mode) { /* Porter-Duff modes have no SVG mix-blend-mode equivalent; * approximate the two that have a plausible color-blend analog, * and let the rest fall through to normal (SRC_OVER). */ case HB_PAINT_COMPOSITE_MODE_PLUS: return "screen"; case HB_PAINT_COMPOSITE_MODE_XOR: return "difference"; case HB_PAINT_COMPOSITE_MODE_CLEAR: case HB_PAINT_COMPOSITE_MODE_SRC: case HB_PAINT_COMPOSITE_MODE_DEST: case HB_PAINT_COMPOSITE_MODE_DEST_OVER: case HB_PAINT_COMPOSITE_MODE_SRC_IN: case HB_PAINT_COMPOSITE_MODE_DEST_IN: case HB_PAINT_COMPOSITE_MODE_SRC_OUT: case HB_PAINT_COMPOSITE_MODE_DEST_OUT: case HB_PAINT_COMPOSITE_MODE_SRC_ATOP: case HB_PAINT_COMPOSITE_MODE_DEST_ATOP: return nullptr; case HB_PAINT_COMPOSITE_MODE_SRC_OVER: return "normal"; case HB_PAINT_COMPOSITE_MODE_SCREEN: return "screen"; case HB_PAINT_COMPOSITE_MODE_OVERLAY: return "overlay"; case HB_PAINT_COMPOSITE_MODE_DARKEN: return "darken"; case HB_PAINT_COMPOSITE_MODE_LIGHTEN: return "lighten"; case HB_PAINT_COMPOSITE_MODE_COLOR_DODGE: return "color-dodge"; case HB_PAINT_COMPOSITE_MODE_COLOR_BURN: return "color-burn"; case HB_PAINT_COMPOSITE_MODE_HARD_LIGHT: return "hard-light"; case HB_PAINT_COMPOSITE_MODE_SOFT_LIGHT: return "soft-light"; case HB_PAINT_COMPOSITE_MODE_DIFFERENCE: return "difference"; case HB_PAINT_COMPOSITE_MODE_EXCLUSION: return "exclusion"; case HB_PAINT_COMPOSITE_MODE_MULTIPLY: return "multiply"; case HB_PAINT_COMPOSITE_MODE_HSL_HUE: return "hue"; case HB_PAINT_COMPOSITE_MODE_HSL_SATURATION: return "saturation"; case HB_PAINT_COMPOSITE_MODE_HSL_COLOR: return "color"; case HB_PAINT_COMPOSITE_MODE_HSL_LUMINOSITY: return "luminosity"; default: return nullptr; } } struct hb_vector_svg_point_t { float x, y; }; struct hb_vector_svg_rgba_t { float r, g, b, a; }; static inline float hb_vector_svg_lerp (float a, float b, float t) { return a + (b - a) * t; } static inline float hb_vector_svg_clamp01 (float v) { if (v < 0.f) return 0.f; if (v > 1.f) return 1.f; return v; } static inline hb_vector_svg_rgba_t hb_vector_svg_rgba_from_hb_color (hb_color_t c) { return {(float) hb_color_get_red (c) / 255.f, (float) hb_color_get_green (c) / 255.f, (float) hb_color_get_blue (c) / 255.f, (float) hb_color_get_alpha (c) / 255.f}; } static inline hb_color_t hb_vector_svg_hb_color_from_rgba (const hb_vector_svg_rgba_t &c) { unsigned r = (unsigned) roundf (hb_vector_svg_clamp01 (c.r) * 255.f); unsigned g = (unsigned) roundf (hb_vector_svg_clamp01 (c.g) * 255.f); unsigned b = (unsigned) roundf (hb_vector_svg_clamp01 (c.b) * 255.f); unsigned a = (unsigned) roundf (hb_vector_svg_clamp01 (c.a) * 255.f); return HB_COLOR (b, g, r, a); } static inline hb_vector_svg_rgba_t hb_vector_svg_lerp_rgba (const hb_vector_svg_rgba_t &c0, const hb_vector_svg_rgba_t &c1, float t) { return {hb_vector_svg_lerp (c0.r, c1.r, t), hb_vector_svg_lerp (c0.g, c1.g, t), hb_vector_svg_lerp (c0.b, c1.b, t), hb_vector_svg_lerp (c0.a, c1.a, t)}; } static inline float hb_vector_svg_dot (const hb_vector_svg_point_t &p, const hb_vector_svg_point_t &q) { return p.x * q.x + p.y * q.y; } static inline hb_vector_svg_point_t hb_vector_svg_add (const hb_vector_svg_point_t &p, const hb_vector_svg_point_t &q) { return {p.x + q.x, p.y + q.y}; } static inline hb_vector_svg_point_t hb_vector_svg_sub (const hb_vector_svg_point_t &p, const hb_vector_svg_point_t &q) { return {p.x - q.x, p.y - q.y}; } static inline hb_vector_svg_point_t hb_vector_svg_scale (const hb_vector_svg_point_t &p, float f) { return {p.x * f, p.y * f}; } static inline hb_vector_svg_point_t hb_vector_svg_normalize (const hb_vector_svg_point_t &p) { float len = sqrtf (hb_vector_svg_dot (p, p)); if (len == 0.f) return {0.f, 0.f}; return hb_vector_svg_scale (p, 1.f / len); } static void hb_vector_svg_add_sweep_patch (hb_vector_buf_t *body, unsigned precision, float cx, float cy, float radius, float a0, const hb_vector_svg_rgba_t &c0_in, float a1, const hb_vector_svg_rgba_t &c1_in) { static const float max_angle = HB_PI / 16.f; hb_vector_svg_point_t center = {cx, cy}; int num_splits = (int) ceilf (fabsf (a1 - a0) / max_angle); if (num_splits < 1) num_splits = 1; hb_vector_svg_point_t p0 = {cosf (a0), sinf (a0)}; hb_vector_svg_rgba_t color0 = c0_in; for (int a = 0; a < num_splits; a++) { float k = (a + 1.f) / num_splits; float angle1 = hb_vector_svg_lerp (a0, a1, k); hb_vector_svg_rgba_t color1 = hb_vector_svg_lerp_rgba (c0_in, c1_in, k); hb_vector_svg_point_t p1 = {cosf (angle1), sinf (angle1)}; hb_vector_svg_point_t sp0 = hb_vector_svg_add (center, hb_vector_svg_scale (p0, radius)); hb_vector_svg_point_t sp1 = hb_vector_svg_add (center, hb_vector_svg_scale (p1, radius)); hb_vector_svg_point_t A = hb_vector_svg_normalize (hb_vector_svg_add (p0, p1)); hb_vector_svg_point_t U = {-A.y, A.x}; float up0 = hb_vector_svg_dot (U, p0); float up1 = hb_vector_svg_dot (U, p1); if (fabsf (up0) < 1e-6f || fabsf (up1) < 1e-6f) { p0 = p1; color0 = color1; continue; } hb_vector_svg_point_t C0 = hb_vector_svg_add (A, hb_vector_svg_scale (U, hb_vector_svg_dot (hb_vector_svg_sub (p0, A), p0) / up0)); hb_vector_svg_point_t C1 = hb_vector_svg_add (A, hb_vector_svg_scale (U, hb_vector_svg_dot (hb_vector_svg_sub (p1, A), p1) / up1)); hb_vector_svg_point_t sc0 = hb_vector_svg_add (center, hb_vector_svg_scale (hb_vector_svg_add (C0, hb_vector_svg_scale (hb_vector_svg_sub (C0, p0), 0.33333f)), radius)); hb_vector_svg_point_t sc1 = hb_vector_svg_add (center, hb_vector_svg_scale (hb_vector_svg_add (C1, hb_vector_svg_scale (hb_vector_svg_sub (C1, p1), 0.33333f)), radius)); hb_vector_svg_rgba_t mid_color = hb_vector_svg_lerp_rgba (color0, color1, 0.5f); hb_color_t mid = hb_vector_svg_hb_color_from_rgba (mid_color); body->append_str ("append_num (center.x, precision); body->append_c (','); body->append_num (center.y, precision); body->append_str ("L"); body->append_num (sp0.x, precision); body->append_c (','); body->append_num (sp0.y, precision); body->append_str ("C"); body->append_num (sc0.x, precision); body->append_c (','); body->append_num (sc0.y, precision); body->append_c (' '); body->append_num (sc1.x, precision); body->append_c (','); body->append_num (sc1.y, precision); body->append_c (' '); body->append_num (sp1.x, precision); body->append_c (','); body->append_num (sp1.y, precision); body->append_str ("Z\" fill=\""); body->append_svg_color (mid, true); body->append_str ("\"/>\n"); p0 = p1; color0 = color1; } } /* Callback context + trampoline for hb_paint_sweep_gradient_tiles. */ struct hb_vector_svg_sweep_ctx_t { hb_vector_buf_t *body; unsigned precision; float cx, cy, radius; }; static void hb_vector_svg_sweep_emit_patch (float a0, hb_color_t c0, float a1, hb_color_t c1, void *user_data) { auto *ctx = (hb_vector_svg_sweep_ctx_t *) user_data; hb_vector_svg_add_sweep_patch (ctx->body, ctx->precision, ctx->cx, ctx->cy, ctx->radius, a0, hb_vector_svg_rgba_from_hb_color (c0), a1, hb_vector_svg_rgba_from_hb_color (c1)); } static void hb_vector_paint_push_transform (hb_paint_funcs_t *, void *, float, float, float, float, float, float, void *); static void hb_vector_paint_pop_transform (hb_paint_funcs_t *, void *, void *); static void hb_vector_paint_push_clip_glyph (hb_paint_funcs_t *, void *, hb_codepoint_t, hb_font_t *, void *); static void hb_vector_paint_push_clip_rectangle (hb_paint_funcs_t *, void *, float, float, float, float, void *); static hb_draw_funcs_t * hb_vector_paint_push_clip_path_start (hb_paint_funcs_t *, void *, void **, void *); static void hb_vector_paint_push_clip_path_end (hb_paint_funcs_t *, void *, void *); static void hb_vector_paint_pop_clip (hb_paint_funcs_t *, void *, void *); static void hb_vector_paint_color (hb_paint_funcs_t *, void *, hb_bool_t, hb_color_t, void *); static hb_bool_t hb_vector_paint_image (hb_paint_funcs_t *, void *, hb_blob_t *, unsigned, unsigned, hb_tag_t, float, hb_glyph_extents_t *, void *); static void hb_vector_paint_linear_gradient (hb_paint_funcs_t *, void *, hb_color_line_t *, float, float, float, float, float, float, void *); static void hb_vector_paint_radial_gradient (hb_paint_funcs_t *, void *, hb_color_line_t *, float, float, float, float, float, float, void *); static void hb_vector_paint_sweep_gradient (hb_paint_funcs_t *, void *, hb_color_line_t *, float, float, float, float, void *); static void hb_vector_paint_push_group (hb_paint_funcs_t *, void *, void *); static void hb_vector_paint_pop_group (hb_paint_funcs_t *, void *, hb_paint_composite_mode_t, void *); static hb_bool_t hb_vector_paint_color_glyph (hb_paint_funcs_t *, void *, hb_codepoint_t, hb_font_t *, void *); static hb_bool_t hb_vector_paint_custom_palette_color (hb_paint_funcs_t *pfuncs HB_UNUSED, void *paint_data, unsigned color_index, hb_color_t *color, void *user_data HB_UNUSED) { hb_vector_paint_t *paint = (hb_vector_paint_t *) paint_data; if (!color) return false; hb_color_t *value = nullptr; if (!paint->custom_palette_colors.has (color_index, &value) || !value) return false; *color = *value; return true; } static inline void free_static_vector_paint_funcs (); static struct hb_vector_paint_funcs_lazy_loader_t : hb_paint_funcs_lazy_loader_t { static hb_paint_funcs_t *create () { hb_paint_funcs_t *funcs = hb_paint_funcs_create (); hb_paint_funcs_set_push_transform_func (funcs, (hb_paint_push_transform_func_t) hb_vector_paint_push_transform, nullptr, nullptr); hb_paint_funcs_set_pop_transform_func (funcs, (hb_paint_pop_transform_func_t) hb_vector_paint_pop_transform, nullptr, nullptr); hb_paint_funcs_set_push_clip_glyph_func (funcs, (hb_paint_push_clip_glyph_func_t) hb_vector_paint_push_clip_glyph, nullptr, nullptr); hb_paint_funcs_set_push_clip_rectangle_func (funcs, (hb_paint_push_clip_rectangle_func_t) hb_vector_paint_push_clip_rectangle, nullptr, nullptr); hb_paint_funcs_set_push_clip_path_start_func (funcs, (hb_paint_push_clip_path_start_func_t) hb_vector_paint_push_clip_path_start, nullptr, nullptr); hb_paint_funcs_set_push_clip_path_end_func (funcs, (hb_paint_push_clip_path_end_func_t) hb_vector_paint_push_clip_path_end, nullptr, nullptr); hb_paint_funcs_set_pop_clip_func (funcs, (hb_paint_pop_clip_func_t) hb_vector_paint_pop_clip, nullptr, nullptr); hb_paint_funcs_set_color_func (funcs, (hb_paint_color_func_t) hb_vector_paint_color, nullptr, nullptr); hb_paint_funcs_set_image_func (funcs, (hb_paint_image_func_t) hb_vector_paint_image, nullptr, nullptr); hb_paint_funcs_set_linear_gradient_func (funcs, (hb_paint_linear_gradient_func_t) hb_vector_paint_linear_gradient, nullptr, nullptr); hb_paint_funcs_set_radial_gradient_func (funcs, (hb_paint_radial_gradient_func_t) hb_vector_paint_radial_gradient, nullptr, nullptr); hb_paint_funcs_set_sweep_gradient_func (funcs, (hb_paint_sweep_gradient_func_t) hb_vector_paint_sweep_gradient, nullptr, nullptr); hb_paint_funcs_set_push_group_func (funcs, (hb_paint_push_group_func_t) hb_vector_paint_push_group, nullptr, nullptr); hb_paint_funcs_set_pop_group_func (funcs, (hb_paint_pop_group_func_t) hb_vector_paint_pop_group, nullptr, nullptr); hb_paint_funcs_set_color_glyph_func (funcs, (hb_paint_color_glyph_func_t) hb_vector_paint_color_glyph, nullptr, nullptr); hb_paint_funcs_set_custom_palette_color_func (funcs, (hb_paint_custom_palette_color_func_t) hb_vector_paint_custom_palette_color, nullptr, nullptr); hb_paint_funcs_make_immutable (funcs); hb_atexit (free_static_vector_paint_funcs); return funcs; } } static_vector_paint_funcs; static inline void free_static_vector_paint_funcs () { static_vector_paint_funcs.free_instance (); } hb_paint_funcs_t * hb_vector_paint_svg_funcs_get () { return static_vector_paint_funcs.get_unconst (); } static void hb_vector_paint_push_transform (hb_paint_funcs_t *, void *paint_data, float xx, float yx, float xy, float yy, float dx, float dy, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (unlikely (paint->transform_group_overflow_depth)) { paint->transform_group_overflow_depth++; return; } if (unlikely (paint->transform_group_depth >= 64)) { paint->transform_group_overflow_depth = 1; return; } hb_bool_t opened = !(fabsf (xx - 1.f) < 1e-6f && fabsf (yx) < 1e-6f && fabsf (xy) < 1e-6f && fabsf (yy - 1.f) < 1e-6f && fabsf (paint->sx (dx)) < 1e-6f && fabsf (paint->sy (dy)) < 1e-6f); paint->transform_group_open_mask = (paint->transform_group_open_mask << 1) | (opened ? 1ull : 0ull); paint->transform_group_depth++; if (!opened) return; auto &body = paint->current_body (); unsigned sprec = paint->defs.scale_precision (); body.append_str ("sx (dx)); body.append_c (','); body.append_num (paint->sy (dy)); body.append_str (")\">\n"); } static void hb_vector_paint_pop_transform (hb_paint_funcs_t *, void *paint_data, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (unlikely (paint->transform_group_overflow_depth)) { paint->transform_group_overflow_depth--; return; } if (!paint->transform_group_depth) return; paint->transform_group_depth--; hb_bool_t opened = !!(paint->transform_group_open_mask & 1ull); paint->transform_group_open_mask >>= 1; if (opened) paint->current_body ().append_str ("\n"); } static void hb_vector_paint_push_clip_glyph (hb_paint_funcs_t *, void *paint_data, hb_codepoint_t glyph, hb_font_t *font, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; const char *pfx = paint->id_prefix; unsigned pfx_len = paint->id_prefix_length; paint->path.clear (); { hb_vector_path_sink_t sink = {&paint->path, paint->get_precision (), paint->x_scale_factor, paint->y_scale_factor}; hb_font_draw_glyph (font, glyph, hb_vector_svg_path_draw_funcs_get (), &sink); } unsigned def_id = paint->path_def_count++; paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_c ('p'); paint->defs.append_unsigned (def_id); paint->defs.append_str ("\" d=\""); paint->defs.append_len (paint->path.arrayZ, paint->path.length); paint->defs.append_str ("\"/>\n"); paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_str ("clip-p"); paint->defs.append_unsigned (def_id); paint->defs.append_str ("\">defs.append_len (pfx, pfx_len); paint->defs.append_c ('p'); paint->defs.append_unsigned (def_id); paint->defs.append_str ("\"/>\n"); paint->current_body ().append_str ("current_body ().append_len (pfx, pfx_len); paint->current_body ().append_str ("clip-p"); paint->current_body ().append_unsigned (def_id); paint->current_body ().append_str (")\">\n"); } static void hb_vector_paint_push_clip_rectangle (hb_paint_funcs_t *, void *paint_data, float xmin, float ymin, float xmax, float ymax, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; const char *pfx = paint->id_prefix; unsigned pfx_len = paint->id_prefix_length; unsigned clip_id = paint->clip_rect_counter++; paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_c ('c'); paint->defs.append_unsigned (clip_id); paint->defs.append_str ("\">defs.append_num (paint->sx (xmin)); paint->defs.append_str ("\" y=\""); paint->defs.append_num (paint->sy (ymin)); paint->defs.append_str ("\" width=\""); paint->defs.append_num (paint->sx (xmax - xmin)); paint->defs.append_str ("\" height=\""); paint->defs.append_num (paint->sy (ymax - ymin)); paint->defs.append_str ("\"/>\n"); paint->current_body ().append_str ("current_body ().append_len (pfx, pfx_len); paint->current_body ().append_c ('c'); paint->current_body ().append_unsigned (clip_id); paint->current_body ().append_str (")\">\n"); } static hb_draw_funcs_t * hb_vector_paint_push_clip_path_start (hb_paint_funcs_t *, void *paint_data, void **draw_data, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) { *draw_data = nullptr; return nullptr; } paint->path.clear (); paint->clip_path_sink = {&paint->path, paint->get_precision (), paint->x_scale_factor, paint->y_scale_factor}; *draw_data = &paint->clip_path_sink; return hb_vector_svg_path_draw_funcs_get (); } static void hb_vector_paint_push_clip_path_end (hb_paint_funcs_t *, void *paint_data, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; const char *pfx = paint->id_prefix; unsigned pfx_len = paint->id_prefix_length; unsigned clip_id = paint->clip_path_counter++; /* The accumulated path is in font Y-up coords (the * convention used inside per-glyph * wrappers); this clip is emitted at base body level * (free-form between glyphs), so flip its geometry inside * the clipPath via the path's own transform attribute, * keeping the body's at body Y-down. */ paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_str ("cp"); paint->defs.append_unsigned (clip_id); paint->defs.append_str ("\">defs.append_len (paint->path.arrayZ, paint->path.length); paint->defs.append_str ("\"/>\n"); paint->current_body ().append_str ("current_body ().append_len (pfx, pfx_len); paint->current_body ().append_str ("cp"); paint->current_body ().append_unsigned (clip_id); paint->current_body ().append_str (")\">\n"); } static void hb_vector_paint_pop_clip (hb_paint_funcs_t *, void *paint_data, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; paint->current_body ().append_str ("\n"); } static void hb_vector_paint_color (hb_paint_funcs_t *, void *paint_data, hb_bool_t, hb_color_t color, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; auto &body = paint->current_body (); body.append_str ("\n"); } static hb_bool_t hb_vector_paint_image (hb_paint_funcs_t *, void *paint_data, hb_blob_t *image, unsigned width, unsigned height, hb_tag_t format, float slant HB_UNUSED, hb_glyph_extents_t *extents, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return false; auto &body = paint->current_body (); if (format == HB_TAG ('p','n','g',' ')) { if (!extents || !width || !height) return false; unsigned len = 0; const char *png_data = hb_blob_get_data (image, &len); if (!png_data || !len) return false; body.append_str ("sx ((float) extents->x_bearing)); body.append_c (','); body.append_num (paint->sy ((float) extents->y_bearing)); body.append_str (") scale("); body.append_num (paint->sx ((float) extents->width) / width); body.append_c (','); body.append_num (paint->sy ((float) extents->height) / height); body.append_str (")\">\n"); body.append_str ("\n\n"); return true; } return false; } static void hb_vector_paint_linear_gradient (hb_paint_funcs_t *, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float x1, float y1, float x2, float y2, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (!paint->fetch_color_stops (color_line)) return; hb_vector_t &stops = paint->color_stops_scratch; /* Sort + rescale stops to [0, 1]; shift the gradient axis * by the original (mn, mx) so the visible gradient stays * put. SVG requires offsets in [0,1]; * out-of-range stops would otherwise be silently clamped. */ float mn, mx; hb_paint_normalize_color_line (stops.arrayZ, stops.length, &mn, &mx); const char *pfx = paint->id_prefix; unsigned pfx_len = paint->id_prefix_length; unsigned grad_id = paint->gradient_counter++; /* Reduce COLR's 3-anchor (P0, P1, P2) to SVG's 2-point * (start, end) gradient. */ float lx0, ly0, lx1, ly1; hb_paint_reduce_linear_anchors (x0, y0, x1, y1, x2, y2, &lx0, &ly0, &lx1, &ly1); float gx0 = lx0 + mn * (lx1 - lx0); float gy0 = ly0 + mn * (ly1 - ly0); float gx1 = lx0 + mx * (lx1 - lx0); float gy1 = ly0 + mx * (ly1 - ly0); paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_str ("gr"); paint->defs.append_unsigned (grad_id); paint->defs.append_str ("\" gradientUnits=\"userSpaceOnUse\" x1=\""); paint->defs.append_num (paint->sx (gx0)); paint->defs.append_str ("\" y1=\""); paint->defs.append_num (paint->sy (gy0)); paint->defs.append_str ("\" x2=\""); paint->defs.append_num (paint->sx (gx1)); paint->defs.append_str ("\" y2=\""); paint->defs.append_num (paint->sy (gy1)); paint->defs.append_str ("\" spreadMethod=\""); paint->defs.append_str (hb_vector_svg_extend_mode_str (hb_color_line_get_extend (color_line))); paint->defs.append_str ("\">\n"); hb_vector_svg_emit_color_stops (paint, &paint->defs, &stops); paint->defs.append_str ("\n"); paint->current_body ().append_str ( "current_body ().append_len (pfx, pfx_len); paint->current_body ().append_str ("gr"); paint->current_body ().append_unsigned (grad_id); paint->current_body ().append_str (")\"/>\n"); } static void hb_vector_paint_radial_gradient (hb_paint_funcs_t *, void *paint_data, hb_color_line_t *color_line, float x0, float y0, float r0, float x1, float y1, float r1, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (!paint->fetch_color_stops (color_line)) return; hb_vector_t &stops = paint->color_stops_scratch; float mn, mx; hb_paint_normalize_color_line (stops.arrayZ, stops.length, &mn, &mx); /* Shift centers + radii by (mn, mx) along the gradient axis * to compensate for rescaling stops to [0, 1]. */ float gx0 = x0 + mn * (x1 - x0); float gy0 = y0 + mn * (y1 - y0); float gr0 = r0 + mn * (r1 - r0); float gx1 = x0 + mx * (x1 - x0); float gy1 = y0 + mx * (y1 - y0); float gr1 = r0 + mx * (r1 - r0); const char *pfx = paint->id_prefix; unsigned pfx_len = paint->id_prefix_length; unsigned grad_id = paint->gradient_counter++; paint->defs.append_str ("defs.append_len (pfx, pfx_len); paint->defs.append_str ("gr"); paint->defs.append_unsigned (grad_id); paint->defs.append_str ("\" gradientUnits=\"userSpaceOnUse\" cx=\""); paint->defs.append_num (paint->sx (gx1)); paint->defs.append_str ("\" cy=\""); paint->defs.append_num (paint->sy (gy1)); paint->defs.append_str ("\" r=\""); paint->defs.append_num (paint->sx (gr1)); paint->defs.append_str ("\" fx=\""); paint->defs.append_num (paint->sx (gx0)); paint->defs.append_str ("\" fy=\""); paint->defs.append_num (paint->sy (gy0)); if (gr0 > 0) { paint->defs.append_str ("\" fr=\""); paint->defs.append_num (paint->sx (gr0)); } paint->defs.append_str ("\" spreadMethod=\""); paint->defs.append_str (hb_vector_svg_extend_mode_str (hb_color_line_get_extend (color_line))); paint->defs.append_str ("\">\n"); hb_vector_svg_emit_color_stops (paint, &paint->defs, &stops); paint->defs.append_str ("\n"); paint->current_body ().append_str ( "current_body ().append_len (pfx, pfx_len); paint->current_body ().append_str ("gr"); paint->current_body ().append_unsigned (grad_id); paint->current_body ().append_str (")\"/>\n"); } static void hb_vector_paint_sweep_gradient (hb_paint_funcs_t *, void *paint_data, hb_color_line_t *color_line, float cx, float cy, float start_angle, float end_angle, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (!paint->fetch_color_stops (color_line)) return; hb_vector_t &stops = paint->color_stops_scratch; float mn, mx; hb_paint_normalize_color_line (stops.arrayZ, stops.length, &mn, &mx); /* Shift the angle range to compensate for rescaling stops * to [0, 1]. */ float ga0 = start_angle + mn * (end_angle - start_angle); float ga1 = start_angle + mx * (end_angle - start_angle); hb_vector_svg_sweep_ctx_t ctx { &paint->current_body (), paint->get_precision (), paint->sx (cx), paint->sy (cy), 32767.f }; hb_paint_sweep_gradient_tiles (stops.arrayZ, stops.length, hb_color_line_get_extend (color_line), ga0, ga1, hb_vector_svg_sweep_emit_patch, &ctx); } static void hb_vector_paint_push_group (hb_paint_funcs_t *, void *paint_data, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (unlikely (!paint->group_stack.push_or_fail (hb_vector_buf_t {}))) return; } static void hb_vector_paint_pop_group (hb_paint_funcs_t *, void *paint_data, hb_paint_composite_mode_t mode, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return; if (paint->group_stack.length < 2) return; hb_vector_buf_t group = paint->group_stack.pop (); auto &body = paint->current_body (); const char *blend = hb_vector_svg_composite_mode_str (mode); if (blend) { body.append_str ("\n"); body.append_len (group.arrayZ, group.length); body.append_str ("\n"); } else body.append_len (group.arrayZ, group.length); } static hb_bool_t hb_vector_paint_color_glyph (hb_paint_funcs_t *, void *paint_data, hb_codepoint_t glyph, hb_font_t *font, void *) { auto *paint = (hb_vector_paint_t *) paint_data; if (unlikely (!paint->ensure_initialized ())) return false; if (unlikely (paint->color_glyph_depth >= HB_MAX_NESTING_LEVEL)) return false; if (unlikely (hb_set_has (paint->active_color_glyphs, glyph))) return false; paint->color_glyph_depth++; hb_set_add (paint->active_color_glyphs, glyph); hb_font_paint_glyph (font, glyph, hb_vector_paint_svg_funcs_get (), paint, paint->palette, paint->foreground); hb_set_del (paint->active_color_glyphs, glyph); paint->color_glyph_depth--; return true; } hb_blob_t * hb_vector_paint_render_svg (hb_vector_paint_t *paint) { if (!paint->has_extents) return nullptr; if (unlikely (!paint->ensure_initialized ())) return nullptr; hb_vector_buf_t out; hb_buf_recover_recycled (paint->recycled_blob, &out); unsigned estimated = paint->defs.length + paint->group_stack.arrayZ[0].length + 320; out.alloc (estimated); float vb_x = paint->extents.x; float vb_y = -(paint->extents.y + paint->extents.height); float vb_w = paint->extents.width; float vb_h = paint->extents.height; out.append_str ("\n"); if (paint->defs.length) { out.append_str ("\n"); out.append_len (paint->defs.arrayZ, paint->defs.length); out.append_str ("\n"); } if (hb_color_get_alpha (paint->background)) { out.append_str ("background)); out.append_c (','); out.append_unsigned (hb_color_get_green (paint->background)); out.append_c (','); out.append_unsigned (hb_color_get_blue (paint->background)); out.append_str (")\""); if (hb_color_get_alpha (paint->background) < 255) { out.append_str (" fill-opacity=\""); out.append_num (hb_color_get_alpha (paint->background) / 255.f, 4); out.append_c ('"'); } out.append_str ("/>\n"); } out.append_str ("\n"); out.append_len (paint->group_stack.arrayZ[0].arrayZ, paint->group_stack.arrayZ[0].length); out.append_str ("\n"); out.append_str ("\n"); hb_blob_t *blob = hb_buf_blob_from (&paint->recycled_blob, &out); hb_vector_paint_clear (paint); return blob; }