| /* | |
| * 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 <algorithm> | |
| #include <math.h> | |
| #include <string> | |
| #include <vector> | |
| #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<char **> (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 <typename app_t> | |
| 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 <typename app_t> | |
| 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<glyph_instance_t> 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<line_t> 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<hb_color_t> custom_palette_values; | |
| std::vector<bool> custom_palette_has_value; | |
| }; | |
| #endif |