/* * Copyright © 2026 Google, Inc. * * 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. */ #ifndef HB_VECTOR_OUTPUT_HH #define HB_VECTOR_OUTPUT_HH #include #include #include #include #include "helper-extents-overlay.hh" #include "output-options.hh" #include "view-options.hh" #include "hb-vector.h" #include "hb-ot.h" static const char *vector_supported_formats[] = { "svg", "pdf", nullptr }; struct vector_output_t : output_options_t<>, view_options_t { static const bool repeat_shape = false; ~vector_output_t () { hb_font_destroy (font); } void add_options (option_parser_t *parser) { parser->set_summary ("Draw text with given font."); parser->set_description ("Shows shaped glyph outlines as SVG or PDF."); output_options_t::add_options (parser, vector_supported_formats); view_options_t::add_options (parser); GOptionEntry entries[] = { {"precision", 0, 0, G_OPTION_ARG_INT, &this->precision, "Decimal precision (default: 2)", "N"}, {nullptr} }; parser->add_group (entries, "vector", "Vector options:", "Options for vector output", this); } void post_parse (GError **error) { view_options_t::post_parse (error); if (error && *error) return; if (precision < 0) { g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "precision must be non-negative"); return; } if (output_format && g_ascii_strcasecmp (output_format, "svg") != 0 && g_ascii_strcasecmp (output_format, "pdf") != 0) { char *items = g_strjoinv ("/", const_cast (vector_supported_formats)); g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Unknown output format `%s'; supported formats are: %s", output_format, items); g_free (items); return; } foreground = HB_COLOR (foreground_color.b, foreground_color.g, foreground_color.r, foreground_color.a); background = HB_COLOR (background_color.b, background_color.g, background_color.r, background_color.a); load_custom_palette_overrides_from_view (); } template void init (hb_buffer_t *buffer HB_UNUSED, const app_t *font_opts) { lines.clear (); direction = HB_DIRECTION_INVALID; font = hb_font_reference (font_opts->font); subpixel_bits = font_opts->subpixel_bits; normalized_stroke_width = get_normalized_stroke_width (); } void new_line () { lines.emplace_back (); } void consume_text (hb_buffer_t * HB_UNUSED, const char * HB_UNUSED, unsigned int HB_UNUSED, hb_bool_t HB_UNUSED) {} void error (const char *message) { g_printerr ("%s: %s\n", g_get_prgname (), message); } void consume_glyphs (hb_buffer_t *buffer, const char * HB_UNUSED, unsigned int HB_UNUSED, hb_bool_t HB_UNUSED) { if (lines.empty ()) lines.emplace_back (); line_t &line = lines.back (); hb_direction_t line_direction = hb_buffer_get_direction (buffer); if (line_direction == HB_DIRECTION_INVALID) line_direction = HB_DIRECTION_LTR; if (direction == HB_DIRECTION_INVALID) direction = line_direction; unsigned int count = 0; const hb_glyph_info_t *infos = hb_buffer_get_glyph_infos (buffer, &count); const hb_glyph_position_t *positions = hb_buffer_get_glyph_positions (buffer, &count); hb_position_t pen_x = 0; hb_position_t pen_y = 0; line.glyphs.reserve (line.glyphs.size () + count); for (unsigned i = 0; i < count; i++) { line.glyphs.push_back ({ infos[i].codepoint, (float) (pen_x + positions[i].x_offset), (float) (pen_y + positions[i].y_offset), (float) positions[i].x_advance, (float) positions[i].y_advance, }); pen_x += positions[i].x_advance; pen_y += positions[i].y_advance; } line.advance_x = (float) pen_x; line.advance_y = (float) pen_y; } template void finish (hb_buffer_t *buffer HB_UNUSED, const app_t *app HB_UNUSED) { hb_vector_extents_t extents = {}; if (!compute_extents (&extents)) return; final_extents = extents; hb_vector_format_t fmt = HB_VECTOR_FORMAT_SVG; if (output_format && g_ascii_strcasecmp (output_format, "pdf") == 0) fmt = HB_VECTOR_FORMAT_PDF; hb_vector_draw_t *draw = hb_vector_draw_create_or_fail (fmt); hb_vector_paint_t *paint = hb_vector_paint_create_or_fail (fmt); float scale = scalbnf (1.f, (int) subpixel_bits); hb_vector_draw_set_scale_factor (draw, scale, scale); hb_vector_draw_set_extents (draw, &extents); hb_vector_draw_set_precision (draw, precision); hb_vector_draw_set_foreground (draw, foreground); hb_vector_draw_set_background (draw, background); if (paint) { hb_vector_paint_set_scale_factor (paint, scale, scale); hb_vector_paint_set_extents (paint, &extents); hb_vector_paint_set_foreground (paint, foreground); hb_vector_paint_set_background (paint, background); hb_vector_paint_set_palette (paint, this->palette); apply_custom_palette (paint); hb_vector_paint_set_precision (paint, precision); } bool had_draw = false; bool had_paint = false; hb_vector_extents_mode_t extents_mode = HB_VECTOR_EXTENTS_MODE_NONE; const bool use_foreground_palette = foreground_use_palette && foreground_palette && foreground_palette->len; unsigned palette_glyph_index = 0; /* Pick draw vs paint mode. --paint wins over --draw; * otherwise auto-detect via the font's color tables. * hb_vector_paint_glyph synthesizes paint from outlines * for mono fonts, so --paint works even without color. */ hb_face_t *face = hb_font_get_face (font); bool font_has_color = hb_ot_color_has_paint (face) || hb_ot_color_has_layers (face) || hb_ot_color_has_png (face); bool use_paint = force_paint ? true : force_draw ? false : font_has_color; hb_direction_t dir = direction; if (dir == HB_DIRECTION_INVALID) dir = HB_DIRECTION_LTR; bool vertical = HB_DIRECTION_IS_VERTICAL (dir); float asc = 0.f, desc = 0.f, gap = 0.f; get_line_metrics (dir, &asc, &desc, &gap); float step = fabsf (asc - desc + gap + (float) line_space); if (!(step > 0.f)) step = scale; line_step = step; for (unsigned li = 0; li < lines.size (); li++) { float off_x = vertical ? -(step * (float) li) : 0.f; float off_y = vertical ? 0.f : -(step * (float) li); for (const auto &g : lines[li].glyphs) { float pen_x = g.x + off_x; float pen_y = g.y + off_y; if (use_paint && paint) { if (use_foreground_palette) { const rgba_color_t &c = g_array_index (foreground_palette, rgba_color_t, palette_glyph_index++ % foreground_palette->len); hb_vector_paint_set_foreground (paint, HB_COLOR (c.b, c.g, c.r, c.a)); } hb_vector_paint_set_transform (paint, 1.f, 0.f, 0.f, 1.f, pen_x, pen_y); hb_vector_paint_glyph (paint, font, g.gid, extents_mode); had_paint = true; if (show_extents) { hb_glyph_extents_t ge; if (hb_font_get_glyph_extents (font, g.gid, &ge)) util_emit_extents_overlay_into_paint ( hb_vector_paint_get_funcs (paint), paint, &ge, pen_x, pen_y, (float) normalized_stroke_width); } } else { if (use_foreground_palette) { const rgba_color_t &c = g_array_index (foreground_palette, rgba_color_t, palette_glyph_index++ % foreground_palette->len); hb_vector_draw_set_foreground (draw, HB_COLOR (c.b, c.g, c.r, c.a)); } hb_vector_draw_set_transform (draw, 1.f, 0.f, 0.f, 1.f, pen_x, pen_y); hb_vector_draw_glyph (draw, font, g.gid, extents_mode); had_draw = true; if (show_extents) { hb_glyph_extents_t ge; if (hb_font_get_glyph_extents (font, g.gid, &ge)) util_emit_extents_overlay_into_draw ( hb_vector_draw_get_funcs (draw), draw, &ge, pen_x, pen_y, (float) normalized_stroke_width); } } } } hb_blob_t *blob = had_paint ? hb_vector_paint_render (paint) : had_draw ? hb_vector_draw_render (draw) : nullptr; if (blob && blob != hb_blob_get_empty ()) write_blob (blob, !had_paint); hb_blob_destroy (blob); hb_vector_draw_destroy (draw); hb_vector_paint_destroy (paint); hb_font_destroy (font); font = nullptr; lines.clear (); } private: struct glyph_instance_t { hb_codepoint_t gid; float x; float y; float ax; float ay; }; struct line_t { float advance_x = 0.f; float advance_y = 0.f; std::vector glyphs; }; bool compute_extents (hb_vector_extents_t *extents) { if (lines.empty ()) { extents->x = 0; extents->y = 0; extents->width = 1; extents->height = 1; return true; } hb_direction_t dir = direction; if (dir == HB_DIRECTION_INVALID) dir = HB_DIRECTION_LTR; bool vertical = HB_DIRECTION_IS_VERTICAL (dir); float scale = scalbnf (1.f, (int) subpixel_bits); float asc = 0.f, desc = 0.f, gap = 0.f; get_line_metrics (dir, &asc, &desc, &gap); float step = fabsf (asc - desc + gap + (float) line_space); if (!(step > 0.f)) step = scale; bool valid = false; float x1 = 0, y1 = 0, x2 = 0, y2 = 0; bool include_logical = include_logical_extents (); bool include_ink = include_ink_extents (); auto include_point = [&] (float x, float y) { if (!valid) { x1 = x2 = x; y1 = y2 = y; valid = true; return; } x1 = hb_min (x1, x); y1 = hb_min (y1, y); x2 = hb_max (x2, x); y2 = hb_max (y2, y); }; for (unsigned li = 0; li < lines.size (); li++) { float off_x = vertical ? -(step * (float) li) : 0.f; float off_y = vertical ? 0.f : -(step * (float) li); const line_t &line = lines[li]; if (include_logical) { float log_min = hb_min (desc, asc); float log_max = hb_max (desc, asc); if (vertical) { include_point (off_x + log_min, hb_min (0.f, line.advance_y)); include_point (off_x + log_max, hb_max (0.f, line.advance_y)); } else { include_point (hb_min (0.f, line.advance_x), off_y + log_min); include_point (hb_max (0.f, line.advance_x), off_y + log_max); } } if (include_ink) for (const auto &g : line.glyphs) { hb_glyph_extents_t ge; if (!hb_font_get_glyph_extents (font, g.gid, &ge)) continue; float gx = g.x + off_x; float gy = g.y + off_y; float xa = gx + ge.x_bearing; float ya = gy + ge.y_bearing; float xb = xa + ge.width; float yb = ya + ge.height; include_point (xa, ya); include_point (xb, yb); } } if (!valid) { extents->x = 0; extents->y = 0; extents->width = 1; extents->height = 1; return true; } if (x2 <= x1) x2 = x1 + 1; if (y2 <= y1) y2 = y1 + 1; /* Margin is in pixels; extents are in font-scale (pixel * SCALE). */ x1 -= (float) margin.l * scale; y1 -= (float) margin.t * scale; x2 += (float) margin.r * scale; y2 += (float) margin.b * scale; extents->x = x1; extents->y = y1; extents->width = x2 - x1; extents->height = y2 - y1; return true; } double get_normalized_stroke_width () const { if (stroke_width <= 0.) return stroke_width; /* Stroke width is in pixels; geometry is in font-scale * (pixel * SCALE), so multiply by SCALE. */ return stroke_width * scalbn (1., (int) subpixel_bits); } void write_blob (hb_blob_t *blob, hb_bool_t is_draw_blob HB_UNUSED) { unsigned in_len = 0; const char *in_data = hb_blob_get_data (blob, &in_len); if (!in_data || !in_len) return; fwrite (in_data, 1, in_len, out_fp); } void apply_custom_palette (hb_vector_paint_t *paint) { hb_vector_paint_clear_custom_palette_colors (paint); for (unsigned idx = 0; idx < custom_palette_values.size (); idx++) if (idx < custom_palette_has_value.size () && custom_palette_has_value[idx]) hb_vector_paint_set_custom_palette_color (paint, idx, custom_palette_values[idx]); } void load_custom_palette_overrides_from_view () { custom_palette_values.clear (); custom_palette_has_value.clear (); if (!custom_palette_entries) return; for (unsigned i = 0; i < custom_palette_entries->len; i++) { const custom_palette_entry_t &entry = g_array_index (custom_palette_entries, custom_palette_entry_t, i); unsigned idx = entry.index; if (custom_palette_values.size () <= idx) { custom_palette_values.resize (idx + 1, HB_COLOR (0, 0, 0, 255)); custom_palette_has_value.resize (idx + 1, false); } custom_palette_values[idx] = HB_COLOR (entry.color.b, entry.color.g, entry.color.r, entry.color.a); custom_palette_has_value[idx] = true; } } void get_line_metrics (hb_direction_t dir, float *asc, float *desc, float *gap) const { if (have_font_extents) { float s = scalbnf (1.f, (int) subpixel_bits); if (asc) *asc = (float) font_extents.ascent * s; if (desc) *desc = (float) (-font_extents.descent) * s; if (gap) *gap = (float) font_extents.line_gap * s; return; } hb_font_extents_t fext = {0, 0, 0}; hb_font_get_extents_for_direction (font, dir, &fext); if (asc) *asc = (float) fext.ascender; if (desc) *desc = (float) fext.descender; if (gap) *gap = (float) fext.line_gap; } int precision = 2; hb_color_t background = HB_COLOR (255, 255, 255, 255); hb_color_t foreground = HB_COLOR (0, 0, 0, 255); hb_font_t *font = nullptr; std::vector lines; hb_direction_t direction = HB_DIRECTION_INVALID; unsigned subpixel_bits = 0; double normalized_stroke_width = DEFAULT_STROKE_WIDTH; float line_step = 0.f; hb_vector_extents_t final_extents = {0, 0, 1, 1}; std::vector custom_palette_values; std::vector custom_palette_has_value; }; #endif