aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/font/shaper/web_canvas.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/font/shaper/web_canvas.zig
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/font/shaper/web_canvas.zig')
-rw-r--r--vendor/libghostty-vt/src/font/shaper/web_canvas.zig305
1 files changed, 305 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/font/shaper/web_canvas.zig b/vendor/libghostty-vt/src/font/shaper/web_canvas.zig
new file mode 100644
index 00000000..d16bd968
--- /dev/null
+++ b/vendor/libghostty-vt/src/font/shaper/web_canvas.zig
@@ -0,0 +1,305 @@
+const std = @import("std");
+const assert = @import("../../quirks.zig").inlineAssert;
+const Allocator = std.mem.Allocator;
+const font = @import("../main.zig");
+const terminal = @import("../../terminal/main.zig");
+const unicode = @import("../../unicode/main.zig");
+const uucode = @import("uucode");
+
+const log = std.log.scoped(.font_shaper);
+
+pub const Shaper = struct {
+ const RunBuf = std.MultiArrayList(struct {
+ /// The codepoint for this cell. This must be used in conjunction
+ /// with cluster to find the total set of codepoints for a given
+ /// cell. See cluster for more information.
+ codepoint: u32,
+
+ /// Cluster is set to the X value of the cell that this codepoint
+ /// is part of. Note that a cell can have multiple codepoints
+ /// with zero-width joiners (ZWJ) and such. Note that terminals
+ /// do NOT handle full extended grapheme clustering well so it
+ /// is possible a single grapheme extends multiple clusters.
+ /// For example, skin tone emoji thumbs up may show up as two
+ /// clusters: one with thumbs up and the ZWJ, and a second
+ /// cluster with the tone block. It is up to the shaper to handle
+ /// shaping these together into a single glyph, if it wishes.
+ cluster: u32,
+ });
+
+ /// The allocator used for run_buf.
+ alloc: Allocator,
+
+ /// The shared memory used for shaping results.
+ cell_buf: []font.shape.Cell,
+
+ /// The shared memory used for storing information about a run.
+ run_buf: RunBuf,
+
+ /// The cell_buf argument is the buffer to use for storing shaped results.
+ /// This should be at least the number of columns in the terminal.
+ pub fn init(alloc: Allocator, opts: font.shape.Options) !Shaper {
+ // Note: we do not support opts.font_features
+
+ return Shaper{
+ .alloc = alloc,
+ .cell_buf = opts.cell_buf,
+ .run_buf = .{},
+ };
+ }
+
+ pub fn deinit(self: *Shaper) void {
+ self.run_buf.deinit(self.alloc);
+ self.* = undefined;
+ }
+
+ pub fn endFrame(self: *const Shaper) void {
+ _ = self;
+ }
+
+ /// Returns an iterator that returns one text run at a time for the
+ /// given terminal row. Note that text runs are only valid one at a time
+ /// for a Shaper struct since they share state.
+ pub fn runIterator(
+ self: *Shaper,
+ opts: font.shape.RunOptions,
+ ) font.shape.RunIterator {
+ return .{
+ .hooks = .{ .shaper = self },
+ .opts = opts,
+ };
+ }
+
+ /// Shape the given text run. The text run must be the immediately
+ /// previous text run that was iterated since the text run does share
+ /// state with the Shaper struct.
+ ///
+ /// The return value is only valid until the next shape call is called.
+ ///
+ /// If there is not enough space in the cell buffer, an error is
+ /// returned.
+ pub fn shape(self: *Shaper, run: font.shape.TextRun) ![]font.shape.Cell {
+ // TODO: memory check that cell_buf can fit results
+
+ const codepoints = self.run_buf.items(.codepoint);
+ const clusters = self.run_buf.items(.cluster);
+ assert(codepoints.len == clusters.len);
+
+ switch (codepoints.len) {
+ // Special cases: if we have no codepoints (is this possible?)
+ // then our result is also an empty cell run.
+ 0 => return self.cell_buf[0..0],
+
+ // If we have only 1 codepoint, then we assume that it is
+ // a single grapheme and just let it through. At this point,
+ // we can't have any more information to do anything else.
+ 1 => {
+ self.cell_buf[0] = .{
+ .x = @intCast(clusters[0]),
+ .glyph_index = codepoints[0],
+ };
+
+ return self.cell_buf[0..1];
+ },
+
+ else => {},
+ }
+
+ // We know we have at least two codepoints, so we now go through
+ // each and perform grapheme clustering.
+ //
+ // Note that due to limitations of canvas, we can NOT support
+ // font ligatures. However, we do support grapheme clustering.
+ // This means we can render things like skin tone emoji but
+ // we can't render things like single glyph "=>".
+ var break_state: uucode.grapheme.BreakState = .default;
+ var cp1: u21 = @intCast(codepoints[0]);
+
+ var start: usize = 0;
+ var i: usize = 1;
+ var cur: usize = 0;
+ while (i <= codepoints.len) : (i += 1) {
+ // We loop to codepoints.len so that we can handle the end
+ // case. In the end case, we always assume it is a grapheme
+ // break. This isn't strictly true but its how terminals
+ // work today.
+ const grapheme_break = i == codepoints.len or blk: {
+ const cp2: u21 = @intCast(codepoints[i]);
+ defer cp1 = cp2;
+
+ break :blk unicode.graphemeBreak(
+ cp1,
+ cp2,
+ &break_state,
+ );
+ };
+
+ // If this is NOT a grapheme break, cp2 is part of a single
+ // grapheme cluster and we expect there could be more. We
+ // move on to the next codepoint to try again.
+ if (!grapheme_break) continue;
+
+ // This IS a grapheme break, meaning that cp2 is NOT part
+ // of cp1. So we need to render the prior grapheme.
+ const len = i - start;
+ assert(len > 0);
+ switch (len) {
+ // If we have only a single codepoint then just render it
+ // as-is.
+ 1 => self.cell_buf[cur] = .{
+ .x = @intCast(clusters[start]),
+ .glyph_index = codepoints[start],
+ },
+
+ // We must have multiple codepoints (see assert above). In
+ // this case we UTF-8 encode the codepoints and send them
+ // to the face to reserve a private glyph index.
+ else => {
+ // UTF-8 encode the codepoints in this cluster.
+ const cluster = cluster: {
+ const cluster_points = codepoints[start..i];
+ assert(cluster_points.len == len);
+
+ const buf_len = buf_len: {
+ var acc: usize = 0;
+ for (cluster_points) |cp| {
+ acc += try std.unicode.utf8CodepointSequenceLength(
+ @intCast(cp),
+ );
+ }
+
+ break :buf_len acc;
+ };
+
+ var buf = try self.alloc.alloc(u8, buf_len);
+ errdefer self.alloc.free(buf);
+ var buf_i: usize = 0;
+ for (cluster_points) |cp| {
+ buf_i += try std.unicode.utf8Encode(
+ @intCast(cp),
+ buf[buf_i..],
+ );
+ }
+
+ break :cluster buf;
+ };
+ defer self.alloc.free(cluster);
+
+ var face = try run.group.group.faceFromIndex(run.font_index);
+ const index = try face.graphemeGlyphIndex(cluster);
+
+ self.cell_buf[cur] = .{
+ .x = @intCast(clusters[start]),
+ .glyph_index = index,
+ };
+ },
+ }
+
+ start = i;
+ cur += 1;
+ }
+
+ return self.cell_buf[0..cur];
+ }
+
+ /// The hooks for RunIterator.
+ pub const RunIteratorHook = struct {
+ shaper: *Shaper,
+
+ pub fn prepare(self: RunIteratorHook) !void {
+ // Reset the buffer for our current run
+ self.shaper.run_buf.shrinkRetainingCapacity(0);
+ }
+
+ pub fn addCodepoint(
+ self: RunIteratorHook,
+ cp: u32,
+ cluster: u32,
+ ) !void {
+ try self.shaper.run_buf.append(self.shaper.alloc, .{
+ .codepoint = cp,
+ .cluster = cluster,
+ });
+ }
+
+ pub fn finalize(self: RunIteratorHook) !void {
+ _ = self;
+ }
+ };
+};
+
+/// The wasm-compatible API.
+pub const Wasm = struct {
+ const wasm = @import("../../os/wasm.zig");
+ const alloc = wasm.alloc;
+
+ export fn shaper_new(cap: usize) ?*Shaper {
+ return shaper_new_(cap) catch null;
+ }
+
+ fn shaper_new_(cap: usize) !*Shaper {
+ const cell_buf = try alloc.alloc(font.shape.Cell, cap);
+ errdefer alloc.free(cell_buf);
+
+ var shaper = try Shaper.init(alloc, .{ .cell_buf = cell_buf });
+ errdefer shaper.deinit();
+
+ const result = try alloc.create(Shaper);
+ errdefer alloc.destroy(result);
+ result.* = shaper;
+ return result;
+ }
+
+ export fn shaper_free(ptr: ?*Shaper) void {
+ if (ptr) |v| {
+ alloc.free(v.cell_buf);
+ v.deinit();
+ alloc.destroy(v);
+ }
+ }
+
+ /// Runs a test to verify shaping works properly.
+ export fn shaper_test(
+ self: *Shaper,
+ group: *font.GroupCache,
+ str: [*]const u8,
+ len: usize,
+ ) void {
+ shaper_test_(self, group, str[0..len]) catch |err| {
+ log.warn("error during shaper test err={}", .{err});
+ };
+ }
+
+ fn shaper_test_(self: *Shaper, group: *font.GroupCache, str: []const u8) !void {
+ // Create a terminal and print all our characters into it.
+ var term = try terminal.Terminal.init(alloc, self.cell_buf.len, 80);
+ defer term.deinit(alloc);
+
+ // Iterate over unicode codepoints and add to terminal
+ {
+ const view = try std.unicode.Utf8View.init(str);
+ var iter = view.iterator();
+ while (iter.nextCodepoint()) |c| {
+ try term.print(c);
+ }
+ }
+
+ // Iterate over the rows and print out all the runs we get.
+ var rowIter = term.screen.rowIterator(.viewport);
+ var y: usize = 0;
+ while (rowIter.next()) |row| {
+ defer y += 1;
+
+ var iter = self.runIterator(group, row, null, null);
+ while (try iter.next(alloc)) |run| {
+ const cells = try self.shape(run);
+ log.info("y={} run={d} shape={any} idx={}", .{
+ y,
+ run.cells,
+ cells,
+ run.font_index,
+ });
+ }
+ }
+ }
+};