summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build.zig10
-rw-r--r--src/font/Atlas.zig510
-rw-r--r--src/gpu/Cells.zig181
-rw-r--r--src/gpu/shaders/decor.frag.glsl26
-rw-r--r--src/gpu/shaders/image.frag.glsl17
-rw-r--r--src/gpu/shaders/image.vert.glsl33
-rw-r--r--src/gpu/shaders/overlay.frag.glsl17
-rw-r--r--src/gpu/shaders/overlay.vert.glsl11
-rw-r--r--src/gpu/shaders/prebuilt/decor.frag.spvbin0 -> 2176 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.frag.spvbin0 -> 1344 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.vert.spvbin0 -> 3152 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.frag.spvbin0 -> 1008 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.vert.spvbin0 -> 1040 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.frag.spvbin0 -> 3184 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.vert.spvbin0 -> 3848 bytes
-rw-r--r--src/gpu/shaders/ui.frag.glsl39
-rw-r--r--src/gpu/shaders/ui.vert.glsl53
-rw-r--r--vendor/README.md4
-rw-r--r--vendor/font.c471
-rw-r--r--vendor/font.h98
20 files changed, 1470 insertions, 0 deletions
diff --git a/build.zig b/build.zig
index 41502b1..dc58962 100644
--- a/build.zig
+++ b/build.zig
@@ -54,6 +54,16 @@ pub fn build(b: *Build) void {
const abi = b.addModule("abi", .{ .root_source_file = b.path("src/abi.zig"), .imports = &.{.{ .name = "abi_hash", .module = b.createModule(.{ .root_source_file = abi_hash }) }} });
const gpu = b.addModule("gpu", .{ .root_source_file = b.path("src/gpu/Executor.zig"), .imports = &.{.{ .name = "abi", .module = abi }} });
_ = b.addModule("gpu_scene", .{ .root_source_file = b.path("src/gpu/scene.zig"), .imports = &.{.{ .name = "abi", .module = abi }} });
+ // The cell renderer's shaders (src/gpu/Cells.zig): embedders compile the
+ // GLSL or embed these committed copies; this refreshes the copies.
+ const update_shaders = b.addUpdateSourceFiles();
+ for ([_][]const u8{ "ui.vert", "ui.frag", "decor.frag", "overlay.vert", "overlay.frag", "image.vert", "image.frag" }) |name| {
+ const glslc = b.addSystemCommand(&.{ "glslc", b.fmt("-fshader-stage={s}", .{if (std.mem.endsWith(u8, name, ".vert")) "vertex" else "fragment"}) });
+ glslc.addFileArg(b.path(b.fmt("src/gpu/shaders/{s}.glsl", .{name})));
+ glslc.addArg("-o");
+ update_shaders.addCopyFileToSource(glslc.addOutputFileArg(b.fmt("{s}.spv", .{name})), b.fmt("src/gpu/shaders/prebuilt/{s}.spv", .{name}));
+ }
+ b.step("shaders", "refresh the committed src/gpu/shaders/prebuilt/*.spv (glslc)").dependOn(&update_shaders.step);
// Embedders provide their existing SDL translation and device.
if (b.option(bool, "gpu-only", "export GPU modules without building the sketch host") orelse false) return;
// The host's session database (src/host/Sessions.zig).
diff --git a/src/font/Atlas.zig b/src/font/Atlas.zig
new file mode 100644
index 0000000..d05bff4
--- /dev/null
+++ b/src/font/Atlas.zig
@@ -0,0 +1,510 @@
+//! pardes's glyph atlas: its faces (a primary and fallbacks over vendor/font.c,
+//! FreeType and HarfBuzz), one 2048x2048 R8 stage filled pen-style a cell row
+//! at a time, the slot of every glyph drawn, and the rows drawn since the
+//! last upload; moved from pardes's gui.zig as it was. CPU only: uploading the
+//! rows is the owner's. `c` is the embedder's translation of vendor/font.h,
+//! so the embedder's FreeType and HarfBuzz are the ones linked, and the
+//! embedder exports ui_malloc and friends (font.h) over its allocator.
+//! What a glyph is drawn at (the sizes, a centred glyph's cells, the line
+//! thickness) is the caller's, passed to each `cachedGlyph`.
+const Atlas = @This();
+const std = @import("std");
+const c = @import("c");
+
+pub const atlas_w: u32 = 2048;
+pub const atlas_h: u32 = 2048;
+pub const Slot = struct { u: u32, v: u32 };
+/// An atlas entry is a glyph of a face (0 the primary font, i the fallback
+/// i - 1) at a role's size, drawn `span` cells wide with its own cell `lead`
+/// cells in: a ligature is one strip whose cells sample their own slices.
+/// Packed, so the atlas map hashes one word instead of walking fields.
+pub const Key = packed struct(u64) {
+ face: u8,
+ glyph: u32,
+ role: Role,
+ decoration: Decoration = .{},
+ centered: bool = false,
+ lead: u4 = 0,
+ span: u4 = 1,
+ /// A light box-drawing rule (`ruleArms`), drawn edge to edge rather
+ /// than from the font; `glyph` is its codepoint.
+ rule: bool = false,
+ _: u1 = 0,
+};
+
+/// The size a glyph is drawn at: the body's, or the tagline's (pardes's
+/// FontRole, in its order).
+pub const Role = enum(u8) { body, tagline };
+/// pardes's CellStyle.ul, in its order.
+pub const Underline = enum(u3) { off, single, double, curly, dotted, dashed };
+pub const Decoration = packed struct(u5) {
+ bold: bool = false,
+ underline: Underline = .off,
+ strikethrough: bool = false,
+};
+
+/// A role's raster size: the face's pixel size, the width of its cell, the
+/// height of its band and its baseline from the band's top.
+pub const Size = struct { px: f32, cell_w: u32, height: u32, baseline: i32 };
+
+/// The light box-drawing rules drawn by hand, as Ghostty and kitty draw
+/// them: a logical pixel thick through the cell's middle, out to its edges,
+/// so a markdown table's `|` (Tables.zig) joins the rows above and below it
+/// and its delimiter row is one line across, at any line height a font's
+/// own glyph would leave gaps in. The arms each one has: left, right, up, down.
+pub fn ruleArms(cp: u32) ?[4]bool {
+ return switch (cp) {
+ 0x2500 => .{ true, true, false, false }, // ─
+ 0x2502 => .{ false, false, true, true }, // │
+ 0x250c => .{ false, true, false, true }, // ┌
+ 0x2510 => .{ true, false, false, true }, // ┐
+ 0x2514 => .{ false, true, true, false }, // └
+ 0x2518 => .{ true, false, true, false }, // ┘
+ 0x251c => .{ false, true, true, true }, // ├
+ 0x2524 => .{ true, false, true, true }, // ┤
+ 0x252c => .{ true, true, false, true }, // ┬
+ 0x2534 => .{ true, true, true, false }, // ┴
+ 0x253c => .{ true, true, true, true }, // ┼
+ else => null,
+ };
+}
+
+/// `line_px`: the rule's thickness, the caller's logical pixel (pardes: dp(1)).
+fn drawRule(out: [*]u8, stride: usize, width: usize, height: usize, arms: [4]bool, line_px: usize) void {
+ if (width == 0 or height == 0) return;
+ const t: usize = @min(@max(1, line_px), @min(width, height));
+ const mx = (width - t) / 2;
+ const my = (height - t) / 2;
+ for (0..height) |y| @memset(out[y * stride ..][0..width], 0);
+ if (arms[0] or arms[1]) for (0..t) |k| {
+ const from: usize = if (arms[0]) 0 else mx;
+ const to: usize = if (arms[1]) width else mx + t;
+ @memset(out[(my + k) * stride + from ..][0 .. to - from], 255);
+ };
+ if (arms[2] or arms[3]) {
+ const from: usize = if (arms[2]) 0 else my;
+ const to: usize = if (arms[3]) height else my + t;
+ for (from..to) |y| @memset(out[y * stride + mx ..][0..t], 255);
+ }
+}
+
+pub const InkBounds = struct { min_x: usize, min_y: usize, max_x: usize, max_y: usize };
+
+pub fn inkBounds(bitmap: []const u8, stride: usize, w: usize, h: usize) ?InkBounds {
+ var bounds: ?InkBounds = null;
+ for (0..h) |y| for (0..w) |x| {
+ if (bitmap[y * stride + x] == 0) continue;
+ if (bounds) |*b| {
+ b.min_x = @min(b.min_x, x);
+ b.min_y = @min(b.min_y, y);
+ b.max_x = @max(b.max_x, x);
+ b.max_y = @max(b.max_y, y);
+ } else bounds = .{ .min_x = x, .min_y = y, .max_x = x, .max_y = y };
+ };
+ return bounds;
+}
+
+pub const max_fallbacks = 15;
+pub const LoadedFallback = struct {
+ face: *c.UIFont,
+ bytes: []u8 = &.{},
+};
+
+/// The primary face (Key.face 0) and its bytes, the atlas's when not empty.
+font: *c.UIFont,
+font_bytes: []u8 = &.{},
+fallbacks: [max_fallbacks]?LoadedFallback = @splat(null),
+fallback_count: usize = 0,
+
+atlas_stage: []u8,
+glyphs: std.AutoHashMap(Key, Slot),
+pen_x: u32 = 0,
+pen_y: u32 = 0,
+/// The atlas rows drawn into since the last upload, [top, bottom): the
+/// whole atlas at first, since the texture starts undefined.
+atlas_dirty_top: u32 = 0,
+atlas_dirty_bottom: u32 = atlas_h,
+space_slot: Slot = .{ .u = 0, .v = 0 },
+
+/// An atlas over the primary face in `bytes`, borrowed for the face's life,
+/// its stage cleared; `reset` puts the pen after the space slot.
+pub fn init(gpa: std.mem.Allocator, bytes: []const u8) !Atlas {
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ errdefer c.ui_font_free(font);
+ const atlas_stage = try gpa.alloc(u8, atlas_w * atlas_h);
+ @memset(atlas_stage, 0);
+ return .{ .font = font, .atlas_stage = atlas_stage, .glyphs = std.AutoHashMap(Key, Slot).init(gpa) };
+}
+
+pub fn deinit(a: *Atlas, gpa: std.mem.Allocator) void {
+ for (a.fallbacks[0..a.fallback_count]) |loaded| {
+ const fallback = loaded.?;
+ c.ui_font_free(fallback.face);
+ if (fallback.bytes.len != 0) gpa.free(fallback.bytes);
+ }
+ c.ui_font_free(a.font);
+ if (a.font_bytes.len != 0) gpa.free(a.font_bytes);
+ a.glyphs.deinit();
+ gpa.free(a.atlas_stage);
+}
+
+/// The primary face from `bytes`, made with `gpa` and now the atlas's
+/// (FreeType borrows them for the face lifetime): false, and `bytes` freed,
+/// when FreeType refuses them. What was drawn stays until `reset`.
+pub fn setFont(a: *Atlas, gpa: std.mem.Allocator, bytes: []u8) bool {
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse {
+ gpa.free(bytes);
+ return false;
+ };
+ c.ui_font_free(a.font);
+ if (a.font_bytes.len != 0) gpa.free(a.font_bytes);
+ a.font = font;
+ a.font_bytes = bytes; // FreeType borrows them for the face lifetime
+ return true;
+}
+
+/// The next fallback face, from `bytes`: borrowed, or the atlas's to free
+/// with `gpa` when `owned`. False (owned bytes freed) when FreeType refuses
+/// them or every fallback is taken.
+pub fn addFallback(a: *Atlas, gpa: std.mem.Allocator, bytes: []const u8, owned: bool) bool {
+ const len = std.math.cast(c_int, bytes.len);
+ const face = if (a.fallback_count < a.fallbacks.len and len != null) c.ui_font_new(bytes.ptr, len.?) else null;
+ if (face == null) {
+ if (owned) gpa.free(bytes);
+ return false;
+ }
+ a.fallbacks[a.fallback_count] = .{ .face = face.?, .bytes = if (owned) @constCast(bytes) else &.{} };
+ a.fallback_count += 1;
+ return true;
+}
+
+/// HarfBuzz's process-wide objects, made with the primary face (font.h's
+/// ui_font_prime): the caller says what allocates them.
+pub fn prime(a: *Atlas) void {
+ c.ui_font_prime(a.font);
+}
+
+/// The primary face's PostScript name, else its family's (font.h).
+pub fn fontName(a: *const Atlas) [*c]const u8 {
+ return c.ui_font_name(a.font);
+}
+
+/// The primary face's cell at `px`: its width, height and ascent (font.h).
+pub fn cellMetrics(a: *const Atlas, px: f32, cell_w: *c_int, cell_h: *c_int, ascent: *c_int) void {
+ c.ui_font_cell_metrics(a.font, px, cell_w, cell_h, ascent);
+}
+
+pub const FaceGlyph = struct { face: u8, glyph: u32 };
+
+/// The face and glyph that draw `cp`, the face as a Key face: 0 is the
+/// primary font and i the fallback i - 1. A codepoint no face has draws the
+/// primary's .notdef.
+pub fn glyphForCodepoint(a: *const Atlas, cp: u32) FaceGlyph {
+ const primary = c.ui_font_glyph(a.font, @intCast(cp));
+ if (primary != 0) return .{ .face = 0, .glyph = primary };
+ for (a.fallbacks[0..a.fallback_count], 1..) |loaded, face| {
+ const glyph = c.ui_font_glyph(loaded.?.face, @intCast(cp));
+ if (glyph != 0) return .{ .face = @intCast(face), .glyph = glyph };
+ }
+ return .{ .face = 0, .glyph = 0 };
+}
+
+/// Whether shaping could replace `glyph` of the face `face` (a Key face):
+/// font.h's ui_font_substitutes.
+pub fn substitutes(a: *const Atlas, face: u8, glyph: u32) bool {
+ const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face;
+ return c.ui_font_substitutes(font, glyph) != 0;
+}
+
+/// A run of codepoints all of the face `face`, one cell each, shaped at `px`
+/// on a grid `cell_w` wide into `out`: font.h's ui_font_shape.
+pub fn shape(a: *const Atlas, face: u8, px: f32, cell_w: u32, cps: []const u32, out: []c.UIShapedCell) void {
+ const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face;
+ c.ui_font_shape(font, px, @intCast(cell_w), cps.ptr, @intCast(cps.len), out.ptr);
+}
+
+// The first cell of the cleared atlas stays blank: the space slot, `cell_w`
+// wide (the body's).
+pub fn reset(a: *Atlas, cell_w: u32) void {
+ a.glyphs.clearRetainingCapacity();
+ @memset(a.atlas_stage, 0);
+ a.space_slot = .{ .u = 0, .v = 0 };
+ a.pen_x = cell_w;
+ a.pen_y = 0;
+ a.atlas_dirty_top = 0;
+ a.atlas_dirty_bottom = atlas_h;
+}
+
+/// The atlas slot of `key`, rasterized on first use at `body`'s or
+/// `tagline`'s size (Key.role). A strip is `span` cells wide (a grip glyph
+/// `centered_cells` cells, centered); a cell samples its slice of it. Pen
+/// rows are `body`'s cell tall. Rules and decorations are `line_px` thick.
+/// Null when the atlas is full.
+pub fn cachedGlyph(a: *Atlas, key: Key, body: Size, tagline: Size, centered_cells: u32, line_px: usize) ?Slot {
+ if (a.glyphs.get(key)) |s| return s;
+ const slot_w = body.cell_w * (if (key.centered) centered_cells else key.span);
+ if (a.pen_x + slot_w > atlas_w) {
+ a.pen_x = 0;
+ a.pen_y += body.height;
+ }
+ if (a.pen_y + body.height > atlas_h) return null; // atlas full: fall back
+ const s = Slot{ .u = a.pen_x, .v = a.pen_y };
+ const out = a.atlas_stage.ptr + @as(usize, s.v) * atlas_w + s.u;
+ const face = if (key.face == 0) a.font else a.fallbacks[key.face - 1].?.face;
+ const px = if (key.role == .tagline) tagline.px else body.px;
+ const baseline = if (key.role == .tagline) tagline.baseline else body.baseline;
+ const cell_w = if (key.role == .tagline) tagline.cell_w else body.cell_w;
+ const raster_w = if (key.centered) slot_w else cell_w * key.span;
+ const raster_h = if (key.role == .tagline) tagline.height else body.height;
+ const bold = @intFromBool(key.decoration.bold);
+ if (key.rule) {
+ drawRule(out, atlas_w, raster_w, raster_h, ruleArms(key.glyph).?, line_px);
+ } else if (key.centered) {
+ _ = c.ui_font_raster_centered(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h));
+ } else {
+ _ = c.ui_font_raster(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), @intCast(cell_w * key.lead), @intCast(cell_w), baseline);
+ }
+ decorateLine(out, atlas_w, raster_w, raster_h, baseline, key.decoration, line_px);
+ if (key.centered) centerGlyphInk(out, raster_w, raster_h);
+ a.atlas_dirty_top = @min(a.atlas_dirty_top, s.v);
+ a.atlas_dirty_bottom = @max(a.atlas_dirty_bottom, s.v + raster_h);
+ a.glyphs.put(key, s) catch return null;
+ a.pen_x += slot_w;
+ return s;
+}
+
+// Run once when a grip glyph enters the atlas, after decorations. Copy only
+// visible ink so bearings, empty bitmap margins and bold all share one center.
+fn centerGlyphInk(out: [*]u8, width: usize, height: usize) void {
+ const b = inkBounds(out[0 .. (height - 1) * atlas_w + width], atlas_w, width, height) orelse return;
+ const w = b.max_x - b.min_x + 1;
+ const h = b.max_y - b.min_y + 1;
+ const left = (width - w) / 2;
+ const top = (height - h) / 2;
+ var scratch: [atlas_w]u8 = undefined;
+ for (0..h) |step| {
+ const row = if (top > b.min_y) h - 1 - step else step;
+ const source = (b.min_y + row) * atlas_w + b.min_x;
+ const target = (top + row) * atlas_w;
+ @memcpy(scratch[0..w], out[source..][0..w]);
+ @memset(out[target..][0..width], 0);
+ @memcpy(out[target + left ..][0..w], scratch[0..w]);
+ }
+ for (0..height) |row| {
+ if (row < top or row >= top + h) @memset(out[row * atlas_w ..][0..width], 0);
+ }
+}
+
+// Underline and strikethrough stay inside the existing atlas slot, so text
+// advance, caret and selection geometry are identical to the regular glyph.
+// The cached mask keeps this work out of steady-state rendering and also
+// decorates terminal spaces. Bold is not drawn here: the rasterizer emboldens
+// the outline.
+fn decorateLine(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: Decoration, line_px: usize) void {
+ if (width == 0 or height == 0) return;
+ // A line is a logical pixel thick, its dots and waves as long: the same
+ // weight at any density (`line_px`, pardes's dp(1)).
+ const t: usize = line_px;
+ if (decoration.underline != .off) {
+ const base: usize = @intCast(@max(0, baseline));
+ const row = @min(base + 1, height -| t);
+ for (0..width) |x| {
+ const top = switch (decoration.underline) {
+ .off => unreachable,
+ .single => row,
+ .double => {
+ const upper = @min(base + 1, height -| 3 * t);
+ for (0..t) |k| {
+ out[@min(upper + k, height - 1) * stride + x] = 255;
+ out[@min(upper + 2 * t + k, height - 1) * stride + x] = 255;
+ }
+ continue;
+ },
+ .curly => row -| @as(usize, if (x % (4 * t) < 2 * t) t else 0),
+ .dotted => if (x % (3 * t) < t) row else continue,
+ .dashed => if (x % (6 * t) < 4 * t) row else continue,
+ };
+ for (0..t) |k| out[@min(top + k, height - 1) * stride + x] = 255;
+ }
+ }
+ if (decoration.strikethrough) {
+ const row = @min(height -| t, @as(usize, @intCast(@max(0, baseline))) * 2 / 3);
+ for (0..t) |k| @memset(out[@min(row + k, height - 1) * stride ..][0..width], 255);
+ }
+}
+
+/// ui_malloc and friends for this file's own test binary, which has no
+/// embedder to export them: C's heap. A test that reaches FreeType or
+/// HarfBuzz names it, so only that binary exports them.
+const TestHeap = struct {
+ fn malloc(size: usize) callconv(.c) ?*anyopaque {
+ return std.c.malloc(size);
+ }
+ fn calloc(count: usize, size: usize) callconv(.c) ?*anyopaque {
+ return std.c.calloc(count, size);
+ }
+ fn realloc(block: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
+ return std.c.realloc(block, size);
+ }
+ fn free(block: ?*anyopaque) callconv(.c) void {
+ std.c.free(block);
+ }
+ comptime {
+ @export(&malloc, .{ .name = "ui_malloc" });
+ @export(&calloc, .{ .name = "ui_calloc" });
+ @export(&realloc, .{ .name = "ui_realloc" });
+ @export(&free, .{ .name = "ui_free" });
+ }
+};
+
+test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
+ _ = TestHeap;
+ const font_ttf = @embedFile("AdwaitaMono-Regular.ttf");
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ const h = c.ui_font_glyph(font, 'H');
+ try std.testing.expect(h != 0);
+ try std.testing.expectEqual(@as(u32, 0), c.ui_font_glyph(font, 0x10ffff));
+
+ const size: f32 = 13.0;
+ var cell_w: c_int = 0;
+ var cell_h: c_int = 0;
+ var ascent: c_int = 0;
+ c.ui_font_cell_metrics(font, size, &cell_w, &cell_h, &ascent);
+ try std.testing.expect(cell_w > 0 and cell_w <= 128);
+ try std.testing.expect(cell_h > 0 and cell_h <= 128);
+
+ const stride: c_int = 128;
+ var bitmap: [128 * 128]u8 = @splat(0xaa);
+ try std.testing.expectEqual(
+ @as(c_int, 1),
+ c.ui_font_raster(font, size, h, 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
+ );
+
+ var ink: usize = 0;
+ var soft: usize = 0;
+ var regular_coverage: usize = 0;
+ for (0..@intCast(cell_h)) |y| {
+ for (0..@intCast(cell_w)) |x| {
+ const coverage = bitmap[y * @as(usize, @intCast(stride)) + x];
+ if (coverage > 0) ink += 1;
+ if (coverage > 0 and coverage < 255) soft += 1;
+ regular_coverage += coverage;
+ }
+ }
+ try std.testing.expect(ink > 0);
+ try std.testing.expect(soft > 0);
+ // Synthetic bold thickens the outline inside the same cell.
+ try std.testing.expectEqual(
+ @as(c_int, 1),
+ c.ui_font_raster(font, size, h, 1, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
+ );
+ var bold_coverage: usize = 0;
+ for (0..@intCast(cell_h)) |y| {
+ for (0..@intCast(cell_w)) |x| bold_coverage += bitmap[y * @as(usize, @intCast(stride)) + x];
+ for (bitmap[y * @as(usize, @intCast(stride)) + @as(usize, @intCast(cell_w)) ..][0..@intCast(stride - cell_w)]) |guard|
+ try std.testing.expectEqual(@as(u8, 0xaa), guard);
+ }
+ try std.testing.expect(bold_coverage > regular_coverage);
+
+ try std.testing.expectEqual(
+ @as(c_int, 0),
+ c.ui_font_raster(font, size, c.ui_font_glyph(font, ' '), 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
+ );
+ for (0..@intCast(cell_h)) |y|
+ for (0..@intCast(cell_w)) |x|
+ try std.testing.expectEqual(
+ @as(u8, 0),
+ bitmap[y * @as(usize, @intCast(stride)) + x],
+ );
+}
+
+test "a box-drawing rule reaches its cell's edges, and only its arms do" {
+ const stride = 12;
+ const width = 9;
+ const height = 15;
+ var mask: [stride * height]u8 = @splat(0xa5);
+ drawRule(&mask, stride, width, height, ruleArms(0x253c).?, 1);
+ // ┼: ink on all four edges, none in the corners, nothing past the slot.
+ try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height - 1) * stride + width / 2]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride + width - 1]);
+ try std.testing.expectEqual(@as(u8, 0), mask[0]);
+ for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard);
+ drawRule(&mask, stride, width, height, ruleArms(0x2502).?, 1);
+ try std.testing.expectEqual(@as(u8, 0), mask[(height / 2) * stride]);
+ try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]);
+ try std.testing.expect(ruleArms('|') == null);
+}
+
+test "glyph decorations render spaces and stay inside their atlas slot" {
+ const stride = 9;
+ const width = 5;
+ const height = 7;
+ for ([_]Decoration{
+ .{ .underline = .single },
+ .{ .underline = .double },
+ .{ .underline = .curly },
+ .{ .underline = .dotted },
+ .{ .underline = .dashed },
+ .{ .strikethrough = true },
+ }) |decoration| {
+ var mask: [stride * (height + 1)]u8 = @splat(0xa5);
+ for (0..height) |y| @memset(mask[y * stride ..][0..width], 0);
+ decorateLine(&mask, stride, width, height, 5, decoration, 1);
+ try std.testing.expect(inkBounds(&mask, stride, width, height) != null);
+ for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard|
+ try std.testing.expectEqual(@as(u8, 0xa5), guard);
+ for (mask[stride * height ..]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard);
+ }
+}
+
+test "the atlas's dirty rows hold every row a new glyph draws into, and a reset dirties them all" {
+ _ = TestHeap;
+ var a = try Atlas.init(std.testing.allocator, @embedFile("AdwaitaMono-Regular.ttf"));
+ defer a.deinit(std.testing.allocator);
+ // The body at 18 px, the tagline at 14 px in the body's cell (pardes
+ // sizes it so, at its tagline percent).
+ var cell_w: c_int = 0;
+ var cell_h: c_int = 0;
+ var ascent: c_int = 0;
+ a.cellMetrics(18, &cell_w, &cell_h, &ascent);
+ const body: Size = .{ .px = 18, .cell_w = @intCast(cell_w), .height = @intCast(cell_h), .baseline = ascent };
+ a.cellMetrics(14, &cell_w, &cell_h, &ascent);
+ const tagline: Size = .{ .px = 14, .cell_w = @intCast(@min(cell_w, body.cell_w)), .height = @intCast(@min(cell_h, body.height)), .baseline = @min(ascent, cell_h) };
+ a.reset(body.cell_w);
+ // The texture as an upload of the dirty rows leaves it, which starts undefined.
+ const texture = try std.testing.allocator.alloc(u8, atlas_w * atlas_h);
+ defer std.testing.allocator.free(texture);
+ @memset(texture, 0xa5);
+ var glyph: u32 = 0;
+ for (0..40) |frame| {
+ if (frame == 30) a.reset(body.cell_w); // a font change
+ // Plain glyphs, strips, taglines, grip glyphs and decorations.
+ for (0..25) |_| {
+ glyph += 1;
+ const span: u4 = @intCast(1 + glyph % 3);
+ _ = a.cachedGlyph(.{
+ .face = 0,
+ .glyph = glyph,
+ .role = if (glyph % 4 == 0) .tagline else .body,
+ .decoration = .{ .bold = glyph % 2 == 0, .underline = if (glyph % 5 == 0) .curly else .off, .strikethrough = glyph % 11 == 0 },
+ .centered = glyph % 13 == 0,
+ .lead = @intCast(glyph % span),
+ .span = span,
+ }, body, tagline, 2, 1) orelse return error.AtlasFull;
+ }
+ for (0..atlas_h) |row| {
+ const stage = a.atlas_stage[row * atlas_w ..][0..atlas_w];
+ const uploaded = texture[row * atlas_w ..][0..atlas_w];
+ if (row >= a.atlas_dirty_top and row < a.atlas_dirty_bottom)
+ @memcpy(uploaded, stage)
+ else
+ try std.testing.expect(std.mem.eql(u8, stage, uploaded));
+ }
+ a.atlas_dirty_top = atlas_h;
+ a.atlas_dirty_bottom = 0;
+ }
+ try std.testing.expect(a.pen_y >= 2 * body.height);
+}
diff --git a/src/gpu/Cells.zig b/src/gpu/Cells.zig
new file mode 100644
index 0000000..78d7f22
--- /dev/null
+++ b/src/gpu/Cells.zig
@@ -0,0 +1,181 @@
+//! pardes's cell renderer on SDL_GPU, part 1: the shaders' instance ABI
+//! (src/gpu/shaders/*.glsl), the pipelines over it and the resource helpers,
+//! moved from pardes's gui.zig as they were. `c` is the embedder's own SDL
+//! translation (pardes's: SDL3 and font.h), so the embedder's SDL is the one
+//! linked.
+const std = @import("std");
+const c = @import("c");
+
+pub const CellInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+ fr: f32,
+ fg: f32,
+ fb: f32,
+ br: f32,
+ bg: f32,
+ bb: f32,
+ /// The flags (the high bits, ui.vert.glsl).
+ effect: u32 = 0,
+ /// A clip rectangle in target pixels; x1 < x0 is none (ui.vert.glsl).
+ clip_x0: f32 = 0,
+ clip_y0: f32 = 0,
+ clip_x1: f32 = -1,
+ clip_y1: f32 = -1,
+};
+
+pub const OverlayVertex = extern struct {
+ x: f32,
+ y: f32,
+ r: f32,
+ g: f32,
+ b: f32,
+ a: f32,
+};
+
+pub const ImageInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+};
+
+pub const opaque_bg_bit: u32 = 0x2000_0000;
+
+/// A vertex buffer and its upload buffer holding at least `needed`
+/// elements of `stride` bytes: those there when they do, else twice as
+/// many again until they would (the old ones let go).
+pub fn growInstances(device: *c.SDL_GPUDevice, buffer: *?*c.SDL_GPUBuffer, transfer: *?*c.SDL_GPUTransferBuffer, capacity: *u32, needed: u32, stride: u32) !void {
+ if (needed <= capacity.* and buffer.* != null and transfer.* != null) return;
+ var grown = @max(@as(u32, 1), capacity.*);
+ while (grown < needed) grown = std.math.mul(u32, grown, 2) catch return error.GpuCapacity;
+ const size = std.math.mul(u32, grown, stride) catch return error.GpuCapacity;
+ var vb_info = c.SDL_GPUBufferCreateInfo{ .usage = c.SDL_GPU_BUFFERUSAGE_VERTEX, .size = size, .props = 0 };
+ const next_buffer = c.SDL_CreateGPUBuffer(device, &vb_info) orelse return error.GpuCreate;
+ errdefer c.SDL_ReleaseGPUBuffer(device, next_buffer);
+ var xf_info = c.SDL_GPUTransferBufferCreateInfo{ .usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = size, .props = 0 };
+ const next_transfer = c.SDL_CreateGPUTransferBuffer(device, &xf_info) orelse return error.GpuCreate;
+ if (buffer.*) |old| c.SDL_ReleaseGPUBuffer(device, old);
+ if (transfer.*) |old| c.SDL_ReleaseGPUTransferBuffer(device, old);
+ buffer.* = next_buffer;
+ transfer.* = next_transfer;
+ capacity.* = grown;
+}
+
+/// One vertex buffer of a pipeline: `pitch` bytes an element, read per
+/// vertex or per instance through `attrs`.
+pub const VertexInput = struct { pitch: u32, rate: c.SDL_GPUVertexInputRate, attrs: []const c.SDL_GPUVertexAttribute };
+
+/// The cells' and the decor's instances (ui.vert.glsl).
+pub const cell_input: VertexInput = .{ .pitch = @sizeOf(CellInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "u0") },
+ .{ .location = 2, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "fr") },
+ .{ .location = 3, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "br") },
+ .{ .location = 4, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_UINT, .offset = @offsetOf(CellInstance, "effect") },
+ .{ .location = 5, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "clip_x0") },
+} };
+
+pub const overlay_input: VertexInput = .{ .pitch = @sizeOf(OverlayVertex), .rate = c.SDL_GPU_VERTEXINPUTRATE_VERTEX, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, .offset = @offsetOf(OverlayVertex, "x") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(OverlayVertex, "r") },
+} };
+
+pub const image_input: VertexInput = .{ .pitch = @sizeOf(ImageInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "u0") },
+} };
+
+/// A pipeline drawing triangles into `color_format`: `vert`, and `frag`
+/// with its samplers and uniform buffers, over one vertex buffer of
+/// `input` (none: the post chain's triangle over the whole frame).
+pub fn makePipeline(
+ device: *c.SDL_GPUDevice,
+ color_format: c.SDL_GPUTextureFormat,
+ vert: []const u8,
+ frag: []const u8,
+ samplers: u32,
+ uniforms: u32,
+ input: ?VertexInput,
+ blend: c.SDL_GPUColorTargetBlendState,
+) !*c.SDL_GPUGraphicsPipeline {
+ const vs = try makeShader(device, vert, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+ defer c.SDL_ReleaseGPUShader(device, vs);
+ const fs = try makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, uniforms);
+ defer c.SDL_ReleaseGPUShader(device, fs);
+ var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = blend };
+ var vbuf_desc: c.SDL_GPUVertexBufferDescription = undefined;
+ var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
+ info.vertex_shader = vs;
+ info.fragment_shader = fs;
+ info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+ if (input) |in| {
+ vbuf_desc = .{ .slot = 0, .pitch = in.pitch, .input_rate = in.rate, .instance_step_rate = 0 };
+ info.vertex_input_state = .{
+ .vertex_buffer_descriptions = &vbuf_desc,
+ .num_vertex_buffers = 1,
+ .vertex_attributes = in.attrs.ptr,
+ .num_vertex_attributes = @intCast(in.attrs.len),
+ };
+ }
+ info.rasterizer_state.fill_mode = c.SDL_GPU_FILLMODE_FILL;
+ info.rasterizer_state.cull_mode = c.SDL_GPU_CULLMODE_NONE;
+ info.multisample_state.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ info.target_info = .{ .color_target_descriptions = &col_desc, .num_color_targets = 1 };
+ return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
+}
+
+pub fn backgroundLayerBlend() c.SDL_GPUColorTargetBlendState {
+ var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
+ blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+ blend.dst_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.color_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.src_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_CONSTANT_COLOR;
+ blend.dst_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.alpha_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.enable_blend = true;
+ return blend;
+}
+
+fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
+ var info = std.mem.zeroes(c.SDL_GPUShaderCreateInfo);
+ info.code = code.ptr;
+ info.code_size = code.len;
+ info.entrypoint = "main";
+ info.format = c.SDL_GPU_SHADERFORMAT_SPIRV;
+ info.stage = stage;
+ info.num_samplers = n_samplers;
+ info.num_uniform_buffers = n_uniform_buffers;
+ return c.SDL_CreateGPUShader(device, &info) orelse error.GpuCreate;
+}
+
+/// A 2D texture of one level, one layer and one sample.
+pub fn texture2d(device: *c.SDL_GPUDevice, format: c.SDL_GPUTextureFormat, usage: c.SDL_GPUTextureUsageFlags, width: u32, height: u32) ?*c.SDL_GPUTexture {
+ var info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
+ info.type = c.SDL_GPU_TEXTURETYPE_2D;
+ info.format = format;
+ info.usage = usage;
+ info.width = width;
+ info.height = height;
+ info.layer_count_or_depth = 1;
+ info.num_levels = 1;
+ info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ return c.SDL_CreateGPUTexture(device, &info);
+}
+
+test "the shader instance ABI: the flags after the colours, the clip after them" {
+ try std.testing.expectEqual(@as(usize, 76), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 56), @offsetOf(CellInstance, "effect"));
+ try std.testing.expectEqual(@as(usize, 60), @offsetOf(CellInstance, "clip_x0"));
+ try std.testing.expectEqual(@as(usize, 32), @sizeOf(ImageInstance));
+}
diff --git a/src/gpu/shaders/decor.frag.glsl b/src/gpu/shaders/decor.frag.glsl
new file mode 100644
index 0000000..71bb12e
--- /dev/null
+++ b/src/gpu/shaders/decor.frag.glsl
@@ -0,0 +1,26 @@
+#version 450
+
+// Decor, drawn by ui.vert.glsl like a cell, and blended as the overlay
+// pipeline blends (backgroundLayerBlend). Ink (a cursor) is drawn with the
+// opacity uniform at 1.
+//
+// A hard-edged fill (a rule, a rail, a grip mark, a bar cursor): its colour
+// rides in the cell's ground (a_bg), its coverage in a_fg.r, so the result
+// is the overlay pipeline's exactly.
+
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 1) in vec3 v_fg;
+layout(location = 2) in vec3 v_bg;
+layout(location = 5) flat in vec4 v_clip;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
+ gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
+ float opacity = clamp(u_ui.background_opacity, 0.0, 1.0);
+ o_col = vec4(v_bg * opacity, v_fg.r);
+}
diff --git a/src/gpu/shaders/image.frag.glsl b/src/gpu/shaders/image.frag.glsl
new file mode 100644
index 0000000..38a95da
--- /dev/null
+++ b/src/gpu/shaders/image.frag.glsl
@@ -0,0 +1,17 @@
+#version 450
+
+layout(set = 2, binding = 0) uniform sampler2D u_image;
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ vec4 source = texture(u_image, v_uv);
+ // Keep source coverage for destination subtraction; the pipeline scales
+ // source alpha by the same opacity through its alpha blend constant.
+ source.rgb *= clamp(u_ui.background_opacity, 0.0, 1.0);
+ o_col = source;
+}
diff --git a/src/gpu/shaders/image.vert.glsl b/src/gpu/shaders/image.vert.glsl
new file mode 100644
index 0000000..ace55a5
--- /dev/null
+++ b/src/gpu/shaders/image.vert.glsl
@@ -0,0 +1,33 @@
+#version 450
+
+// One instance per Surface image attachment. The CPU has already converted
+// the pane's cell rectangle and the aspect-preserving contain fit to NDC.
+layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1
+layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1
+
+layout(location = 0) out vec2 v_uv;
+
+void main() {
+ vec2 pos;
+ int corner = gl_VertexIndex % 6;
+ if (corner == 0) {
+ pos = vec2(a_rect.x, a_rect.y);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 1) {
+ pos = vec2(a_rect.z, a_rect.y);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.y);
+ } else if (corner == 2) {
+ pos = vec2(a_rect.z, a_rect.w);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else if (corner == 3) {
+ pos = vec2(a_rect.x, a_rect.y);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 4) {
+ pos = vec2(a_rect.z, a_rect.w);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else {
+ pos = vec2(a_rect.x, a_rect.w);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.w);
+ }
+ gl_Position = vec4(pos, 0.0, 1.0);
+}
diff --git a/src/gpu/shaders/overlay.frag.glsl b/src/gpu/shaders/overlay.frag.glsl
new file mode 100644
index 0000000..b5ac8d5
--- /dev/null
+++ b/src/gpu/shaders/overlay.frag.glsl
@@ -0,0 +1,17 @@
+#version 450
+
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec4 v_color;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ // Preserve shape coverage for destination subtraction. The pipeline uses
+ // the matching opacity blend constant for source alpha, so graphics laid
+ // over a background with the same opacity do not accumulate opaque seams.
+ // Text/cursor draw groups bind opacity 1 instead.
+ o_col = vec4(v_color.rgb * clamp(u_ui.background_opacity, 0.0, 1.0), v_color.a);
+}
diff --git a/src/gpu/shaders/overlay.vert.glsl b/src/gpu/shaders/overlay.vert.glsl
new file mode 100644
index 0000000..5f6be59
--- /dev/null
+++ b/src/gpu/shaders/overlay.vert.glsl
@@ -0,0 +1,11 @@
+#version 450
+
+layout(location = 0) in vec2 a_pos;
+layout(location = 1) in vec4 a_color;
+
+layout(location = 0) out vec4 v_color;
+
+void main() {
+ v_color = a_color;
+ gl_Position = vec4(a_pos, 0.0, 1.0);
+}
diff --git a/src/gpu/shaders/prebuilt/decor.frag.spv b/src/gpu/shaders/prebuilt/decor.frag.spv
new file mode 100644
index 0000000..0d5af9d
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/decor.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/image.frag.spv b/src/gpu/shaders/prebuilt/image.frag.spv
new file mode 100644
index 0000000..d663ed8
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/image.vert.spv b/src/gpu/shaders/prebuilt/image.vert.spv
new file mode 100644
index 0000000..1105bae
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/overlay.frag.spv b/src/gpu/shaders/prebuilt/overlay.frag.spv
new file mode 100644
index 0000000..e296e99
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/overlay.vert.spv b/src/gpu/shaders/prebuilt/overlay.vert.spv
new file mode 100644
index 0000000..a518c57
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/ui.frag.spv b/src/gpu/shaders/prebuilt/ui.frag.spv
new file mode 100644
index 0000000..91022fe
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/ui.vert.spv b/src/gpu/shaders/prebuilt/ui.vert.spv
new file mode 100644
index 0000000..ad132bf
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/ui.frag.glsl b/src/gpu/shaders/ui.frag.glsl
new file mode 100644
index 0000000..7f70629
--- /dev/null
+++ b/src/gpu/shaders/ui.frag.glsl
@@ -0,0 +1,39 @@
+#version 450
+
+// Sample the glyph atlas (R = coverage 0..1) and mix the cell's bg up to its fg
+// by that coverage. Output is PREMULTIPLIED: an opaque cell is unchanged.
+// WindowOpacity changes only the ground's coverage, never the glyph's ink.
+
+layout(set = 2, binding = 0) uniform sampler2D u_atlas;
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec3 v_fg;
+layout(location = 2) in vec3 v_bg;
+layout(location = 4) flat in uint v_effect;
+layout(location = 5) flat in vec4 v_clip;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
+ gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
+ float a = texture(u_atlas, v_uv).r;
+ // A block cursor is foreground chrome even though its fill occupies the
+ // cell background: keep it visible at WindowOpacity 0. Otherwise the
+ // ground's coverage is the setting's. The flag is shared with
+ // ui.vert.glsl and src/gui/gui.zig.
+ float bgA = (v_effect & 0x20000000u) != 0u ? 1.0 : clamp(u_ui.background_opacity, 0.0, 1.0);
+
+ // Ink over ground, both premultiplied: v_fg*a + (v_bg*bgA)*(1-a), which is
+ // mix() with the ground already premultiplied. At bgA = 1 that is exactly
+ // the mix(v_bg, v_fg, a) at alpha 1 this shader always wrote.
+ vec4 under = vec4(v_bg * bgA, bgA);
+ vec4 cell = vec4(mix(under.rgb, v_fg, a), mix(under.a, 1.0, a));
+
+ // FreeType's hinted grayscale bitmap is already the intended coverage.
+ // Preserve it exactly; weight-changing gamma hacks blur small stems.
+ o_col = cell;
+}
diff --git a/src/gpu/shaders/ui.vert.glsl b/src/gpu/shaders/ui.vert.glsl
new file mode 100644
index 0000000..e3532e6
--- /dev/null
+++ b/src/gpu/shaders/ui.vert.glsl
@@ -0,0 +1,53 @@
+#version 450
+
+// Terminal cell renderer. The CPU uploads one instance per visible cell; this
+// shader expands each instance into a two-triangle quad with gl_VertexIndex.
+// The fragment shader mixes fg/bg by the atlas's alpha (a glyph mask in the R
+// channel), so background fills and glyph foregrounds draw in a single pass.
+
+layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1
+layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1
+layout(location = 2) in vec3 a_fg;
+layout(location = 3) in vec3 a_bg;
+// Flags, the high bits: an opaque block-cursor fill (ui.frag.glsl).
+layout(location = 4) in uint a_effect;
+// A clip rectangle in target pixels (x0, y0, x1, y1): the fragment shader
+// drops what lies outside it. x1 < x0 is none.
+layout(location = 5) in vec4 a_clip;
+
+layout(location = 0) out vec2 v_uv;
+layout(location = 1) out vec3 v_fg;
+layout(location = 2) out vec3 v_bg;
+layout(location = 4) flat out uint v_effect;
+layout(location = 5) flat out vec4 v_clip;
+
+void main() {
+ vec2 pos;
+ vec2 uv;
+ int corner = gl_VertexIndex % 6;
+ if (corner == 0) {
+ pos = vec2(a_rect.x, a_rect.y);
+ uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 1) {
+ pos = vec2(a_rect.z, a_rect.y);
+ uv = vec2(a_uv_rect.z, a_uv_rect.y);
+ } else if (corner == 2) {
+ pos = vec2(a_rect.z, a_rect.w);
+ uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else if (corner == 3) {
+ pos = vec2(a_rect.x, a_rect.y);
+ uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 4) {
+ pos = vec2(a_rect.z, a_rect.w);
+ uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else {
+ pos = vec2(a_rect.x, a_rect.w);
+ uv = vec2(a_uv_rect.x, a_uv_rect.w);
+ }
+ v_uv = uv;
+ v_fg = a_fg;
+ v_bg = a_bg;
+ v_effect = a_effect;
+ v_clip = a_clip;
+ gl_Position = vec4(pos, 0.0, 1.0);
+}
diff --git a/vendor/README.md b/vendor/README.md
index c23a785..1d3e42b 100644
--- a/vendor/README.md
+++ b/vendor/README.md
@@ -9,6 +9,10 @@ Single-file codecs, vendored unchanged; `codecs.c` compiles them for the host.
`cgltf.c` compiles the unchanged cgltf header for the optional `gltf` module.
+`font.c` and `font.h` are pardes's FreeType and HarfBuzz shim, moved from its
+`src/gui/` unchanged, under `src/font/Atlas.zig`. The embedder compiles them
+against its own FreeType and HarfBuzz and exports `ui_malloc` and friends.
+
`presentation-time/presentation-time.xml` is the Wayland presentation-time v3
protocol description (the client binds v1; its license is included in the XML).
On Linux, `build.zig` runs `wayland-scanner` to generate a client header and C
diff --git a/vendor/font.c b/vendor/font.c
new file mode 100644
index 0000000..aebe26e
--- /dev/null
+++ b/vendor/font.c
@@ -0,0 +1,471 @@
+// FreeType and HarfBuzz wrapper for gui.zig. The policy intentionally follows
+// Ghostty's FreeType backend: native hinting enabled, the auto-hinter available
+// as a fallback, and the light target for shape-preserving grayscale text.
+// HarfBuzz only picks glyphs (liga, calt); the grid, not the font's advances,
+// places them.
+#include "font.h"
+#include <freetype-zig.h>
+#include <freetype/ftbitmap.h>
+#include <freetype/ftmodapi.h>
+#include <hb-ft.h>
+#include <hb-ot.h>
+#include <hb.h>
+
+#include <string.h>
+
+struct UIFont {
+ // FreeType allocates through ui_malloc and friends: the library holds a
+ // pointer to this for its lifetime, which the UIFont outlives.
+ struct FT_MemoryRec_ memory;
+ FT_Library library;
+ FT_Face face;
+ FT_F26Dot6 size;
+ // The charmap's answer for ASCII, which is most of every screen: a word the
+ // renderer has not seen before looks up each of its cells.
+ uint32_t ascii[128];
+ // HarfBuzz state, made by the first ui_font_substitutes question (most
+ // fallback faces are never asked).
+ hb_font_t *hb;
+ hb_buffer_t *buffer;
+ FT_F26Dot6 hb_size;
+ // Every glyph a lookup of a ligature feature could replace. Nothing else
+ // can change a glyph, so a cell outside it is its nominal glyph without
+ // shaping: every cell, in a font without ligatures.
+ hb_set_t *substitutes;
+ // ui_font_shape's per-cell scratch, grown to the longest run seen
+ uint32_t *own;
+ uint8_t *state;
+ int32_t scratch;
+};
+
+static FT_F26Dot6 size_26_6(float px) {
+ if (px < 1.0f)
+ px = 1.0f;
+ return (FT_F26Dot6)(px * 64.0f + 0.5f);
+}
+
+static int set_size(UIFont *f, float px) {
+ const FT_F26Dot6 size = size_26_6(px);
+ if (f->size == size)
+ return 1;
+ if (FT_Set_Char_Size(f->face, 0, size, 72, 72) != 0)
+ return 0;
+ f->size = size;
+ return 1;
+}
+
+static int ceil_26_6(FT_Pos value) { return (int)((value + 63) >> 6); }
+
+static FT_Int32 load_flags(void) {
+ // Hinting is on because FT_LOAD_NO_HINTING is absent. Likewise, leaving
+ // FT_LOAD_NO_AUTOHINT absent lets FreeType fall back to its auto-hinter
+ // when the face has no native instructions. This is Ghostty's default.
+ return FT_LOAD_DEFAULT | FT_LOAD_TARGET_LIGHT;
+}
+
+static void *ft_alloc(FT_Memory memory, long size) {
+ (void)memory;
+ return ui_malloc((size_t)size);
+}
+
+static void ft_free(FT_Memory memory, void *block) {
+ (void)memory;
+ ui_free(block);
+}
+
+static void *ft_realloc(FT_Memory memory, long cur_size, long new_size,
+ void *block) {
+ (void)memory;
+ (void)cur_size;
+ return ui_realloc(block, (size_t)new_size);
+}
+
+UIFont *ui_font_new(const uint8_t *data, int32_t len) {
+ if (!data || len <= 0)
+ return NULL;
+
+ UIFont *f = (UIFont *)ui_calloc(1, sizeof(UIFont));
+ if (!f)
+ return NULL;
+ // FT_Init_FreeType is exactly FT_New_Library over FT_New_Memory's malloc
+ // manager, then the default modules and properties: the same, over ours.
+ f->memory = (struct FT_MemoryRec_){NULL, ft_alloc, ft_free, ft_realloc};
+ if (FT_New_Library(&f->memory, &f->library) != 0) {
+ ui_free(f);
+ return NULL;
+ }
+ FT_Add_Default_Modules(f->library);
+ FT_Set_Default_Properties(f->library);
+ if (FT_New_Memory_Face(f->library, data, (FT_Long)len, 0, &f->face) != 0) {
+ FT_Done_Library(f->library);
+ ui_free(f);
+ return NULL;
+ }
+ // Some symbol fonts do not expose a Unicode charmap. FreeType already
+ // selects a usable default for those, so failure here is non-fatal.
+ (void)FT_Select_Charmap(f->face, FT_ENCODING_UNICODE);
+ for (uint32_t cp = 0; cp < 128; cp++)
+ f->ascii[cp] = FT_Get_Char_Index(f->face, cp);
+ return f;
+}
+
+// HarfBuzz reads this same face (and its charmap) through FreeType, so shaping
+// and rasterizing agree on glyph ids. None of these calls returns NULL: a
+// failure is an inert empty object, and shaping then yields nominal glyphs.
+static void start_harfbuzz(UIFont *f) {
+ f->hb = hb_ft_font_create_referenced(f->face);
+ f->buffer = hb_buffer_create();
+ f->substitutes = hb_set_create();
+ static const hb_tag_t features[] = {
+ HB_TAG('l', 'i', 'g', 'a'), HB_TAG('c', 'a', 'l', 't'),
+ HB_TAG('c', 'l', 'i', 'g'), HB_TAG('r', 'l', 'i', 'g'),
+ HB_TAG('r', 'c', 'l', 't'), HB_TAG_NONE};
+ hb_face_t *face = hb_font_get_face(f->hb);
+ hb_set_t *lookups = hb_set_create();
+ hb_ot_layout_collect_lookups(face, HB_OT_TAG_GSUB, NULL, NULL, features,
+ lookups);
+ hb_codepoint_t lookup = HB_SET_VALUE_INVALID;
+ while (hb_set_next(lookups, &lookup))
+ hb_ot_layout_lookup_collect_glyphs(face, HB_OT_TAG_GSUB, lookup, NULL,
+ f->substitutes, NULL, NULL);
+ hb_set_destroy(lookups);
+}
+
+const char *ui_font_name(UIFont *f) {
+ if (!f || !f->face)
+ return NULL;
+ const char *postscript = FT_Get_Postscript_Name(f->face);
+ if (postscript && postscript[0])
+ return postscript;
+ if (f->face->family_name && f->face->family_name[0])
+ return f->face->family_name;
+ return NULL;
+}
+
+uint32_t ui_font_glyph(UIFont *f, int32_t cp) {
+ if (!f || cp < 0)
+ return 0;
+ if (cp < 128)
+ return f->ascii[cp];
+ return FT_Get_Char_Index(f->face, (FT_ULong)(uint32_t)cp);
+}
+
+void ui_font_free(UIFont *f) {
+ if (!f)
+ return;
+ // The HarfBuzz font holds a reference on the face: release it first. (All
+ // three accept NULL, a face that never shaped.)
+ hb_set_destroy(f->substitutes);
+ hb_buffer_destroy(f->buffer);
+ hb_font_destroy(f->hb);
+ if (f->face)
+ FT_Done_Face(f->face);
+ if (f->library)
+ FT_Done_Library(f->library);
+ ui_free(f->own);
+ ui_free(f->state);
+ ui_free(f);
+}
+
+void ui_font_prime(UIFont *f) {
+ if (!f)
+ return;
+ hb_font_destroy(hb_ft_font_create_referenced(f->face));
+ hb_buffer_t *buffer = hb_buffer_create();
+ hb_buffer_add_utf8(buffer, "a", 1, 0, 1);
+ hb_buffer_guess_segment_properties(buffer);
+ hb_buffer_destroy(buffer);
+}
+
+void ui_font_cell_metrics(UIFont *f, float px, int32_t *cell_w, int32_t *cell_h,
+ int32_t *ascent) {
+ if (!f || !cell_w || !cell_h || !ascent || !set_size(f, px)) {
+ if (cell_w)
+ *cell_w = 1;
+ if (cell_h)
+ *cell_h = 1;
+ if (ascent)
+ *ascent = 1;
+ return;
+ }
+
+ const FT_Size_Metrics metrics = f->face->size->metrics;
+ const int asc = ceil_26_6(metrics.ascender);
+ const int desc = ceil_26_6(-metrics.descender);
+ int height = ceil_26_6(metrics.height);
+ if (height < asc + desc)
+ height = asc + desc;
+
+ int width = ceil_26_6(metrics.max_advance);
+ const FT_UInt m = FT_Get_Char_Index(f->face, 'M');
+ if (FT_Load_Glyph(f->face, m, load_flags()) == 0) {
+ const int advance = ceil_26_6(f->face->glyph->advance.x);
+ if (advance > 0)
+ width = advance;
+ }
+
+ *cell_w = width > 0 ? width : 1;
+ *cell_h = height > 0 ? height : 1;
+ *ascent = asc > 0 ? asc : 1;
+}
+
+static int raster(UIFont *f, float px, uint32_t glyph_index, int bold,
+ uint8_t *out, int32_t stride, int32_t width, int32_t height,
+ int32_t cell_x, int32_t cell_w, int32_t ascent,
+ int centered) {
+ if (!f || !out || stride < width || width <= 0 || height <= 0)
+ return 0;
+ for (int y = 0; y < height; y++)
+ memset(out + (size_t)y * (size_t)stride, 0, (size_t)width);
+ if (!set_size(f, px))
+ return 0;
+
+ if (FT_Load_Glyph(f->face, glyph_index, load_flags()) != 0)
+ return 0;
+ if (bold) {
+ // Synthetic bold thickens the hinted outline before it is rendered, so
+ // the wider stems are rasterized as one shape and keep hinted edges; the
+ // advance is untouched, as the cell grid requires. Strength is Ghostty's
+ // heuristic: 1/32 of the line height in 26.6, rounded up (one pixel at a
+ // 32 px line). A bitmap strike has no outline: widen it by one whole pixel,
+ // the classic overstrike, which keeps its pixels sharp.
+ FT_GlyphSlot slot = f->face->glyph;
+ if (slot->format == FT_GLYPH_FORMAT_OUTLINE) {
+ const FT_Pos height = f->face->size->metrics.height;
+ FT_Outline_Embolden(&slot->outline, (height + 31) / 32);
+ } else if (slot->format == FT_GLYPH_FORMAT_BITMAP &&
+ FT_GlyphSlot_Own_Bitmap(slot) == 0) {
+ FT_Bitmap_Embolden(f->library, &slot->bitmap, 64, 0);
+ }
+ }
+ if (FT_Render_Glyph(f->face->glyph, FT_RENDER_MODE_NORMAL) != 0)
+ return 0;
+
+ const FT_GlyphSlot glyph = f->face->glyph;
+ const FT_Bitmap *bitmap = &glyph->bitmap;
+ if (!bitmap->buffer || bitmap->width == 0 || bitmap->rows == 0)
+ return 0;
+
+ const int advance = ceil_26_6(glyph->advance.x);
+ // Fallbacks may be proportional. Center their advance in the primary face's
+ // fixed cell, exactly as Ghostty centers a narrower fallback face.
+ const int gx = centered
+ ? (width - (int)bitmap->width) / 2
+ : cell_x + glyph->bitmap_left + (cell_w - advance) / 2;
+ const int gy =
+ centered ? (height - (int)bitmap->rows) / 2 : ascent - glyph->bitmap_top;
+ const int pitch = bitmap->pitch;
+ const int row_bytes = pitch < 0 ? -pitch : pitch;
+
+ for (unsigned int y = 0; y < bitmap->rows; y++) {
+ const int dy = gy + (int)y;
+ if (dy < 0 || dy >= height)
+ continue;
+ const unsigned int source_y = pitch < 0 ? bitmap->rows - 1 - y : y;
+ const uint8_t *src = bitmap->buffer + (size_t)source_y * (size_t)row_bytes;
+
+ for (unsigned int x = 0; x < bitmap->width; x++) {
+ const int dx = gx + (int)x;
+ if (dx < 0 || dx >= width)
+ continue;
+
+ uint8_t coverage;
+ if (bitmap->pixel_mode == FT_PIXEL_MODE_MONO) {
+ coverage = (src[x >> 3] & (0x80u >> (x & 7))) ? 255 : 0;
+ } else if (bitmap->pixel_mode == FT_PIXEL_MODE_GRAY) {
+ coverage = src[x];
+ if (bitmap->num_grays > 1 && bitmap->num_grays != 256)
+ coverage = (uint8_t)((unsigned int)coverage * 255u /
+ (bitmap->num_grays - 1u));
+ } else {
+ continue;
+ }
+ out[(size_t)dy * (size_t)stride + (size_t)dx] = coverage;
+ }
+ }
+ return 1;
+}
+
+int ui_font_raster(UIFont *f, float px, uint32_t glyph, int bold, uint8_t *out,
+ int32_t stride, int32_t width, int32_t height,
+ int32_t cell_x, int32_t cell_w, int32_t ascent) {
+ return raster(f, px, glyph, bold, out, stride, width, height, cell_x, cell_w,
+ ascent, 0);
+}
+
+int ui_font_raster_centered(UIFont *f, float px, uint32_t glyph, int bold,
+ uint8_t *out, int32_t stride, int32_t width,
+ int32_t height) {
+ return raster(f, px, glyph, bold, out, stride, width, height, 0, width, 0, 1);
+}
+
+// The horizontal ink of `glyph` placed as ui_font_raster places it in a cell
+// `cell` wide (26.6), relative to the cell's left edge. 0 when it has no ink.
+static int ink(UIFont *f, uint32_t glyph, FT_Pos cell, FT_Pos *left,
+ FT_Pos *right) {
+ if (FT_Load_Glyph(f->face, glyph, load_flags()) != 0)
+ return 0;
+ const FT_GlyphSlot slot = f->face->glyph;
+ if (slot->metrics.width <= 0 || slot->metrics.height <= 0)
+ return 0;
+ const FT_Pos origin =
+ (FT_Pos)(((int)(cell >> 6) - ceil_26_6(slot->advance.x)) / 2) * 64;
+ *left = origin + slot->metrics.horiBearingX;
+ *right = *left + slot->metrics.width;
+ return 1;
+}
+
+// ui_font_shape's per-cell marks: no glyph of its own, keep the nominal glyph,
+// drawn as a slice of another cell's glyph.
+#define NONE UINT32_MAX
+#define PLAIN 1
+#define CLAIMED 2
+
+int ui_font_substitutes(UIFont *f, uint32_t glyph) {
+ if (!f)
+ return 0;
+ if (!f->hb)
+ start_harfbuzz(f);
+ return hb_set_has(f->substitutes, glyph);
+}
+
+// The GSUB features shaping leaves on are the ligature ones; the others
+// HarfBuzz would apply (glyph composition, local forms, fractions around
+// U+2044, ...) are off, so a cell is either its nominal glyph, as the renderer
+// always drew it, or part of a ligature. Positioning is untouched: the grid
+// ignores advances and keeps nominal glyphs where marks would move.
+static const hb_feature_t shaping_features[] = {
+ {HB_TAG('c', 'c', 'm', 'p'), 0, 0, (unsigned int)-1},
+ {HB_TAG('l', 'o', 'c', 'l'), 0, 0, (unsigned int)-1},
+ {HB_TAG('r', 'v', 'r', 'n'), 0, 0, (unsigned int)-1},
+ {HB_TAG('l', 't', 'r', 'a'), 0, 0, (unsigned int)-1},
+ {HB_TAG('l', 't', 'r', 'm'), 0, 0, (unsigned int)-1},
+ {HB_TAG('r', 'a', 'n', 'd'), 0, 0, (unsigned int)-1},
+ {HB_TAG('f', 'r', 'a', 'c'), 0, 0, (unsigned int)-1},
+ {HB_TAG('n', 'u', 'm', 'r'), 0, 0, (unsigned int)-1},
+ {HB_TAG('d', 'n', 'o', 'm'), 0, 0, (unsigned int)-1},
+};
+
+void ui_font_shape(UIFont *f, float px, int32_t cell_w, const uint32_t *cps,
+ int32_t n, UIShapedCell *out) {
+ if (!f || !cps || !out || n <= 0)
+ return;
+ for (int32_t i = 0; i < n; i++)
+ out[i] = (UIShapedCell){ui_font_glyph(f, (int32_t)cps[i]), 0, 1, 0};
+ if (!f->hb)
+ start_harfbuzz(f);
+ int substitutable = 0;
+ for (int32_t i = 0; i < n && !substitutable; i++)
+ substitutable = hb_set_has(f->substitutes, out[i].glyph);
+ if (!substitutable || cell_w <= 0 || !set_size(f, px))
+ return;
+ if (n > f->scratch) {
+ uint32_t *own = (uint32_t *)ui_realloc(f->own, (size_t)n * sizeof *own);
+ if (!own)
+ return;
+ f->own = own;
+ uint8_t *state = (uint8_t *)ui_realloc(f->state, (size_t)n);
+ if (!state)
+ return;
+ f->state = state;
+ f->scratch = n;
+ }
+ // hb-ft reads the FreeType size when told; positions are only consulted
+ // for being nonzero, but a zero scale would hide exactly that.
+ if (f->hb_size != f->size) {
+ hb_ft_font_changed(f->hb);
+ f->hb_size = f->size;
+ }
+ hb_buffer_clear_contents(f->buffer);
+ // One codepoint per cell, so a cluster value IS a cell index.
+ hb_buffer_add_codepoints(f->buffer, cps, n, 0, n);
+ hb_buffer_set_direction(f->buffer, HB_DIRECTION_LTR);
+ hb_buffer_guess_segment_properties(f->buffer);
+ hb_shape(f->hb, f->buffer, shaping_features,
+ sizeof shaping_features / sizeof shaping_features[0]);
+ unsigned int count = 0;
+ const hb_glyph_info_t *info = hb_buffer_get_glyph_infos(f->buffer, &count);
+ const hb_glyph_position_t *pos =
+ hb_buffer_get_glyph_positions(f->buffer, &count);
+
+ // Each cell's own glyph is the one HarfBuzz left in its cluster. A cell a
+ // ligature merged into an earlier cluster has NONE. A cluster the grid
+ // cannot place (several glyphs, a positioned mark) is PLAIN, and so are the
+ // cells merged into it: they keep their nominal glyphs.
+ uint32_t *own = f->own;
+ uint8_t *state = f->state;
+ for (int32_t i = 0; i < n; i++) {
+ own[i] = NONE;
+ state[i] = 0;
+ }
+ for (unsigned int k = 0; k < count; k++) {
+ const uint32_t cluster = info[k].cluster;
+ if (cluster >= (uint32_t)n)
+ continue;
+ if (own[cluster] != NONE || pos[k].x_offset != 0 || pos[k].y_offset != 0)
+ state[cluster] = PLAIN;
+ else
+ own[cluster] = info[k].codepoint;
+ }
+ for (int32_t i = 1; i < n; i++)
+ if (own[i] == NONE && (state[i - 1] & PLAIN))
+ state[i] = PLAIN;
+
+ // A substituted glyph (or one whose cluster swallowed cells) may reach over
+ // its neighbours: it claims those that draw nothing of their own, nearest
+ // first, and each draws its slice of the one strip. Ink past a cell edge by
+ // half a pixel or less is noise.
+ const FT_Pos cell = (FT_Pos)cell_w * 64;
+ for (int32_t i = 0; i < n; i++) {
+ if ((state[i] & (PLAIN | CLAIMED)) || own[i] == NONE)
+ continue;
+ int32_t merged = 0;
+ while (i + 1 + merged < n && own[i + 1 + merged] == NONE &&
+ !(state[i + 1 + merged] & PLAIN))
+ merged++;
+ if (own[i] == out[i].glyph && merged == 0)
+ continue;
+ FT_Pos left = 0, right = 0;
+ if (!ink(f, own[i], cell, &left, &right))
+ continue; // a spacer: claimed, never claiming
+ int32_t want_left =
+ left < -32 ? (int32_t)((-left - 32 + cell - 1) / cell) : 0;
+ int32_t want_right = right > cell + 32
+ ? (int32_t)((right - cell - 32 + cell - 1) / cell)
+ : 0;
+ if (want_right < merged)
+ want_right = merged;
+ int32_t lead = 0, trail = 0;
+ while (lead < want_left && 1 + lead + trail < UI_MAX_SPAN) {
+ const int32_t j = i - lead - 1;
+ FT_Pos l, r;
+ if (j < 0 || (state[j] & (PLAIN | CLAIMED)) ||
+ (own[j] != NONE &&
+ (own[j] == out[j].glyph || ink(f, own[j], cell, &l, &r))))
+ break;
+ lead++;
+ }
+ while (trail < want_right && 1 + lead + trail < UI_MAX_SPAN) {
+ const int32_t j = i + trail + 1;
+ FT_Pos l, r;
+ if (j >= n || (state[j] & (PLAIN | CLAIMED)) ||
+ (own[j] != NONE &&
+ (own[j] == out[j].glyph || ink(f, own[j], cell, &l, &r))))
+ break;
+ trail++;
+ }
+ for (int32_t j = i - lead; j <= i + trail; j++) {
+ out[j] =
+ (UIShapedCell){own[i], (uint8_t)lead, (uint8_t)(1 + lead + trail),
+ (uint8_t)(j - (i - lead))};
+ state[j] |= CLAIMED;
+ }
+ }
+ // The rest draw their own glyph; a merged cell nothing claimed draws blank.
+ const uint32_t space = f->ascii[' '];
+ for (int32_t i = 0; i < n; i++) {
+ if (state[i] & (PLAIN | CLAIMED))
+ continue;
+ out[i].glyph = own[i] == NONE ? space : own[i];
+ }
+}
diff --git a/vendor/font.h b/vendor/font.h
new file mode 100644
index 0000000..db964fb
--- /dev/null
+++ b/vendor/font.h
@@ -0,0 +1,98 @@
+// Tiny C shim over FreeType and HarfBuzz, so gui.zig only imports the stable
+// renderer API. The implementation owns FreeType's library and face objects
+// and HarfBuzz's font and buffer, and keeps the caller's font bytes borrowed
+// for the face lifetime.
+#ifndef UI_FONT_H
+#define UI_FONT_H
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct UIFont UIFont;
+
+// Every allocation FreeType, HarfBuzz and this shim make: C's malloc, calloc,
+// realloc and free, implemented by gui.zig over a Zig allocator. HarfBuzz is
+// compiled to call them (hb_malloc_impl and friends); FreeType gets them as
+// each library's memory manager.
+void *ui_malloc(size_t size);
+void *ui_calloc(size_t count, size_t size);
+void *ui_realloc(void *block, size_t size);
+void ui_free(void *block);
+
+// Parse the first face in an in-memory font. `data` must stay alive for the
+// lifetime of the font. Returns NULL on failure.
+UIFont *ui_font_new(const uint8_t *data, int32_t len);
+
+// The face FreeType actually accepted. Prefer its PostScript name (the same
+// identity the macOS shell reports); fall back to the family name when the
+// font has no PostScript table. Borrowed for the UIFont lifetime.
+const char *ui_font_name(UIFont *f);
+
+// The glyph the selected Unicode charmap maps `cp` to. Glyph zero is the
+// face's .notdef box: the codepoint is missing, which is what fallback choice
+// asks.
+uint32_t ui_font_glyph(UIFont *f, int32_t cp);
+
+// `px` is the pixel height. Metrics and rasterization both configure FreeType
+// at that size, so hinted advances, baseline and bitmaps stay in step.
+void ui_font_cell_metrics(UIFont *f, float px, int32_t *cell_w, int32_t *cell_h,
+ int32_t *ascent);
+
+// What one grid cell draws: `slice` of the glyph `glyph` rasterized across
+// `span` cells with its own cell `lead` cells from the left. A plain cell is
+// its own glyph, lead 0, span 1, slice 0.
+typedef struct {
+ uint32_t glyph;
+ uint8_t lead;
+ uint8_t span;
+ uint8_t slice;
+} UIShapedCell;
+
+// The longest glyph strip a ligature may claim, in cells.
+#define UI_MAX_SPAN 8
+
+// Whether a lookup of the font's ligature features (liga, calt, clig, rlig,
+// rclt) could replace `glyph`. When it cannot, shaping leaves the glyph alone
+// and its cell needs no shaping at all.
+int ui_font_substitutes(UIFont *f, uint32_t glyph);
+
+// One cell per codepoint of `cps`, all in this face, shaped by HarfBuzz with
+// the font's ligature features (a run with no glyph ui_font_substitutes
+// reports comes back nominal without it). A substituted glyph whose ink
+// reaches over neighbouring cells that draw nothing of their own (a
+// ligature's spacers, or the cells a merged cluster swallowed) claims them as
+// a strip. Otherwise, and for anything the grid cannot place (several glyphs
+// in one cell, positioned marks), each cell is its nominal glyph.
+void ui_font_shape(UIFont *f, float px, int32_t cell_w, const uint32_t *cps,
+ int32_t n, UIShapedCell *out);
+
+// Rasterize `glyph` into `out` as a hinted grayscale mask of `width` x
+// `height` (`stride` bytes per row). The glyph's advance is centered in the
+// `cell_w` pixels that start at `cell_x`, and its baseline is `ascent` pixels
+// from the top; ink outside the mask is clipped. `bold` emboldens the outline
+// before rendering (synthetic bold, same advance). Returns 1 when the glyph
+// produced coverage, 0 for blank/error.
+int ui_font_raster(UIFont *f, float px, uint32_t glyph, int bold, uint8_t *out,
+ int32_t stride, int32_t width, int32_t height,
+ int32_t cell_x, int32_t cell_w, int32_t ascent);
+
+// Center bitmap ink bounds, independent of advance and baseline bearings.
+int ui_font_raster_centered(UIFont *f, float px, uint32_t glyph, int bold,
+ uint8_t *out, int32_t stride, int32_t width,
+ int32_t height);
+
+void ui_font_free(UIFont *f);
+
+// HarfBuzz makes a few process-wide objects on first use and keeps them for
+// the life of the process (the default Unicode functions, the locale's
+// language, hb-ft's font functions). Making them here, with `f`'s face, lets
+// the caller hand them an allocator that does not count them as leaks.
+void ui_font_prime(UIFont *f);
+
+#ifdef __cplusplus
+}
+#endif
+#endif