replace harfbuzz with kb-text-shape

Signed-off-by: Emi <emi@hexops.com>

Author: emidoots

build.zig

@@ -126,11 +126,10 @@ pub fn build(b: *std.Build) !void {
                 .target = target,
                 .optimize = optimize,
             })) |dep| module.linkLibrary(dep.artifact("freetype"));
-            if (b.lazyDependency("harfbuzz", .{
+            if (b.lazyDependency("kb-text-shape", .{
                 .target = target,
                 .optimize = optimize,
-                .enable_freetype = true,
-            })) |dep| module.linkLibrary(dep.artifact("harfbuzz"));
+            })) |dep| module.linkLibrary(dep.artifact("kb-text-shape"));
             if (b.lazyDependency("opusfile", .{
                 .target = target,
                 .optimize = .ReleaseFast,
@@ -140,7 +139,7 @@ pub fn build(b: *std.Build) !void {
                 .optimize = .ReleaseFast,
             })) |dep| module.linkLibrary(dep.artifact("opusenc"));
         }
-        
+
         if (want_examples) {
             for (examples) |example| b.getInstallStep().dependOn(example.install_step);
         }
@@ -244,11 +243,10 @@ pub fn build(b: *std.Build) !void {
                 .target = target,
                 .optimize = optimize,
             })) |dep| unit_tests.root_module.linkLibrary(dep.artifact("freetype"));
-            if (b.lazyDependency("harfbuzz", .{
+            if (b.lazyDependency("kb-text-shape", .{
                 .target = target,
                 .optimize = optimize,
-                .enable_freetype = true,
-            })) |dep| unit_tests.root_module.linkLibrary(dep.artifact("harfbuzz"));
+            })) |dep| unit_tests.root_module.linkLibrary(dep.artifact("kb-text-shape"));
         }
 
         // Documentation

build.zig.zon

@@ -17,9 +17,10 @@
             .hash = "12204cba3a237cd2c4ab983f5a28d9b54e7a9912d8c7c6e38e23140b0171d6e1ebf8",
             .lazy = true,
         },
-        .harfbuzz = .{
-            .url = "https://pkg.hexops.org/pkg/hexops/harfbuzz/c514da98afcf5d9ad6854a7f09192f9ecfaeb061.tar.gz",
-            .hash = "1220203218ac17e497f3399e08115e73cb9505f1b9f07738eb0c5cc38ca443dec953",
+
+        .@"kb-text-shape" = .{
+            .url = "https://pkg.hexops.org/pkg/hexops/kb-text-shape/89affbcf1b82a3846d43d112e2943db438a3896a.tar.gz",
+            .hash = "122046928448999745c1d175432205ac99e4cee6e32e0babf0e004340205ab5ba187",
             .lazy = true,
         },
         .mach_objc = .{

src/gfx/font/main.zig

@@ -11,7 +11,7 @@ pub const TextRun = TextRunInterface(if (@import("builtin").cpu.arch == .wasm32)
 
 fn FontInterface(comptime T: type) type {
     assertDecl(T, "initBytes", fn (font_bytes: []const u8) anyerror!T);
-    assertDecl(T, "shape", fn (f: *const T, r: *TextRun) anyerror!void);
+    assertDecl(T, "shape", fn (f: *T, r: *TextRun) anyerror!void);
     assertDecl(T, "render", fn (f: *T, allocator: std.mem.Allocator, glyph_index: u32, opt: RenderOptions) anyerror!RenderedGlyph);
     assertDecl(T, "deinit", fn (*T, allocator: std.mem.Allocator) void);
     return T;
@@ -21,7 +21,7 @@ fn TextRunInterface(comptime T: type) type {
     assertField(T, "font_size_px", f32);
     assertField(T, "px_density", u8);
     assertDecl(T, "init", fn () anyerror!T);
-    assertDecl(T, "addText", fn (s: *const T, []const u8) void);
+    assertDecl(T, "addText", fn (s: *T, []const u8) void);
     assertDecl(T, "next", fn (s: *T) ?Glyph);
     assertDecl(T, "deinit", fn (s: *const T) void);
     return T;

src/gfx/font/native/Font.zig

@@ -1,5 +1,6 @@
 const std = @import("std");
-const c = @import("ft.zig").c;
+const ft = @import("ft.zig").c;
+const kb = @import("ft.zig").kb;
 const TextRun = @import("TextRun.zig");
 const px_per_pt = @import("../main.zig").px_per_pt;
 const RenderedGlyph = @import("../main.zig").RenderedGlyph;
@@ -10,75 +11,64 @@ const Font = @This();
 
 var freetype_ready_mu: std.Thread.Mutex = .{};
 var freetype_ready: bool = false;
-var ft_library: c.FT_Library = null;
+var ft_library: ft.FT_Library = null;
 
-face: c.FT_Face,
+face: ft.FT_Face,
+font_bytes: []const u8,
 bitmap: std.ArrayListUnmanaged(RGBA32) = .{},
 
 pub fn initFreetype() !void {
     freetype_ready_mu.lock();
     defer freetype_ready_mu.unlock();
     if (!freetype_ready) {
-        if (c.FT_Init_FreeType(&ft_library) != 0) return error.FreetypeInitFailed;
+        if (ft.FT_Init_FreeType(&ft_library) != 0) return error.FreetypeInitFailed;
         freetype_ready = true;
     }
 }
 
+/// font_bytes must remain valid until .deinit() is called.
 pub fn initBytes(font_bytes: []const u8) anyerror!Font {
     try initFreetype();
-    var face: c.FT_Face = null;
-    if (c.FT_New_Memory_Face(ft_library, font_bytes.ptr, @intCast(font_bytes.len), 0, &face) != 0)
+    var face: ft.FT_Face = null;
+    if (ft.FT_New_Memory_Face(ft_library, font_bytes.ptr, @intCast(font_bytes.len), 0, &face) != 0)
         return error.FreetypeError;
-    return .{ .face = face };
+    return .{ .face = face, .font_bytes = font_bytes };
 }
 
-pub fn shape(f: *const Font, r: *TextRun) anyerror!void {
-    // Guess text segment properties.
-    c.hb_buffer_guess_segment_properties(r.buffer);
-    // TODO: Optionally override specific text segment properties?
-    // hb_buffer_set_direction(r.buffer, ...);
-    // hb_buffer_set_script(r.buffer, ...);
-    // hb_buffer_set_language(r.buffer, hb_language_from_string("en", -1));
-
+pub fn shape(f: *Font, r: *TextRun) anyerror!void {
+    const kb_font = kb.kbts_ShapePushFontFromMemory(
+        r.context,
+        @constCast(f.font_bytes.ptr),
+        @intCast(f.font_bytes.len),
+        0,
+    ) orelse return error.RenderError;
+
+    // Get font metrics to know UnitsPerEm for scaling.
+    var info: kb.kbts_font_info2_1 = std.mem.zeroes(kb.kbts_font_info2_1);
+    info.Base.Size = @sizeOf(kb.kbts_font_info2_1);
+    kb.kbts_GetFontInfo2(kb_font, @ptrCast(&info));
+    if (info.UnitsPerEm == 0) return error.InvalidFont;
+    r.units_per_em = @floatFromInt(info.UnitsPerEm);
+
+    // Set FreeType face size for glyph rendering (still needed for rasterization).
     const font_size_pt = r.font_size_px / px_per_pt;
     const font_size_pt_frac: i32 = @intFromFloat(font_size_pt * 64.0);
-    if (c.FT_Set_Char_Size(f.face, font_size_pt_frac, font_size_pt_frac, 0, 0) != 0)
+    if (ft.FT_Set_Char_Size(f.face, font_size_pt_frac, font_size_pt_frac, 0, 0) != 0)
         return error.RenderError;
 
-    const hb_face = c.hb_ft_face_create_referenced(f.face) orelse return error.RenderError;
-    const hb_font = c.hb_font_create(hb_face) orelse return error.RenderError;
-    defer c.hb_font_destroy(hb_font);
-
-    c.hb_font_set_scale(hb_font, font_size_pt_frac, font_size_pt_frac);
-    c.hb_font_set_ptem(hb_font, font_size_pt);
-
-    // TODO: optionally pass shaping features?
-    c.hb_shape(hb_font, r.buffer, null, 0);
-
-    r.index = 0;
-    var info_count: u32 = 0;
-    const infos_ptr = c.hb_buffer_get_glyph_infos(r.buffer, &info_count);
-    r.infos = if (infos_ptr) |p| p[0..info_count] else return error.OutOfMemory;
-
-    var pos_count: u32 = 0;
-    const pos_ptr = c.hb_buffer_get_glyph_positions(r.buffer, &pos_count);
-    r.positions = if (pos_ptr) |p| p[0..pos_count] else return error.OutOfMemory;
-
-    for (r.positions, r.infos) |*pos, info| {
-        const glyph_index = info.codepoint;
-        if (c.FT_Load_Glyph(f.face, glyph_index, c.FT_LOAD_DEFAULT) != 0)
-            return error.RenderError;
-        const glyph = f.face.*.glyph;
-        const metrics = glyph.*.metrics;
-        pos.*.x_offset += @intCast(metrics.horiBearingX);
-        pos.*.y_offset += @intCast(metrics.horiBearingY);
-        // TODO: use vertBearingX / vertBearingY for vertical layouts
-    }
+    // Store FreeType face for bearing lookups during glyph iteration.
+    r.ft_face = f.face;
+
+    // Perform the full shaping pass: begin → add text → end.
+    // TODO(font): allow configuration of direction/language by user
+    kb.kbts_ShapeBegin(r.context, kb.KBTS_DIRECTION_DONT_KNOW, kb.KBTS_LANGUAGE_DONT_KNOW);
+    kb.kbts_ShapeUtf8(r.context, r.utf8_text.ptr, @intCast(r.utf8_text.len), kb.KBTS_USER_ID_GENERATION_MODE_CODEPOINT_INDEX);
+    kb.kbts_ShapeEnd(r.context);
 }
 
 pub fn render(f: *Font, allocator: std.mem.Allocator, glyph_index: u32, opt: RenderOptions) anyerror!RenderedGlyph {
     _ = opt;
-    if (c.FT_Load_Glyph(f.face, glyph_index, c.FT_LOAD_RENDER) != 0)
+    if (ft.FT_Load_Glyph(f.face, glyph_index, ft.FT_LOAD_RENDER) != 0)
         return error.RenderError;
 
     const glyph = f.face.*.glyph;
@@ -120,6 +110,6 @@ pub fn render(f: *Font, allocator: std.mem.Allocator, glyph_index: u32, opt: Ren
 }
 
 pub fn deinit(f: *Font, allocator: std.mem.Allocator) void {
-    _ = c.FT_Done_Face(f.face);
+    _ = ft.FT_Done_Face(f.face);
     f.bitmap.deinit(allocator);
 }

src/gfx/font/native/TextRun.zig

@@ -1,47 +1,83 @@
 const std = @import("std");
-const c = @import("ft.zig").c;
+const ft = @import("ft.zig").c;
+const kb = @import("ft.zig").kb;
 const math = @import("../../../main.zig").math;
 const vec2 = math.vec2;
 const Vec2 = math.Vec2;
 const Glyph = @import("../main.zig").Glyph;
+const px_per_pt = @import("../main.zig").px_per_pt;
 
 const TextRun = @This();
 
 font_size_px: f32 = 16.0,
 px_density: u8 = 1,
 
 // Internal / private fields.
-buffer: *c.hb_buffer_t,
-index: usize = 0,
-infos: []c.hb_glyph_info_t = undefined,
-positions: []c.hb_glyph_position_t = undefined,
+context: *kb.kbts_shape_context,
+utf8_text: []const u8 = &.{},
+run: kb.kbts_run = undefined,
+has_run: bool = false,
+units_per_em: f32 = undefined,
+ft_face: ft.FT_Face = null,
 
 pub fn init() anyerror!TextRun {
     return TextRun{
-        .buffer = c.hb_buffer_create() orelse return error.OutOfMemory,
+        .context = kb.kbts_CreateShapeContext(null, null) orelse return error.OutOfMemory,
     };
 }
 
-pub fn addText(s: *const TextRun, utf8_text: []const u8) void {
-    c.hb_buffer_add_utf8(s.buffer, utf8_text.ptr, @intCast(utf8_text.len), 0, @intCast(utf8_text.len));
+/// utf8_text must remain valid until .deinit() is called.
+pub fn addText(s: *TextRun, utf8_text: []const u8) void {
+    s.utf8_text = utf8_text;
 }
 
 pub fn next(s: *TextRun) ?Glyph {
-    if (s.index >= s.infos.len) return null;
-    const info = s.infos[s.index];
-    const pos = s.positions[s.index];
-    s.index += 1;
-    return Glyph{
-        .glyph_index = info.codepoint,
-        // TODO: should we expose this? Is there a browser equivalent? do we need it?
-        // .var1 = @intCast(info.var1),
-        // .var2 = @intCast(info.var2),
-        .cluster = info.cluster,
-        .advance = vec2(@floatFromInt(pos.x_advance), @floatFromInt(pos.y_advance)).div(&Vec2.splat(64.0)),
-        .offset = vec2(@floatFromInt(pos.x_offset), @floatFromInt(pos.y_offset)).div(&Vec2.splat(64.0)),
-    };
+    while (true) {
+        if (s.has_run) {
+            var glyph_ptr: ?*kb.kbts_glyph = null;
+            if (kb.kbts_GlyphIteratorNext(&s.run.Glyphs, &glyph_ptr) != 0) {
+                const glyph = glyph_ptr.?;
+                // Scale from font design units to points (not pixels) to match
+                // the convention used by FreeType's bearing metrics.
+                const font_size_pt = s.font_size_px / px_per_pt;
+                const scale = font_size_pt / s.units_per_em;
+
+                // Get FreeType bearing offsets for baseline-relative positioning.
+                // kb handles shaping but not rasterization metrics; FreeType's
+                // horiBearingX/Y position the bitmap relative to the pen/baseline.
+                var bearing_x: f32 = 0;
+                var bearing_y: f32 = 0;
+                if (ft.FT_Load_Glyph(s.ft_face, glyph.Id, ft.FT_LOAD_DEFAULT) == 0) {
+                    const metrics = s.ft_face.*.glyph.*.metrics;
+                    bearing_x = @as(f32, @floatFromInt(metrics.horiBearingX)) / 64.0;
+                    bearing_y = @as(f32, @floatFromInt(metrics.horiBearingY)) / 64.0;
+                }
+
+                return Glyph{
+                    .glyph_index = @intCast(glyph.Id),
+                    .cluster = @intCast(glyph.UserIdOrCodepointIndex),
+                    .advance = vec2(
+                        @as(f32, @floatFromInt(glyph.AdvanceX)) * scale,
+                        @as(f32, @floatFromInt(glyph.AdvanceY)) * scale,
+                    ),
+                    .offset = vec2(
+                        @as(f32, @floatFromInt(glyph.OffsetX)) * scale + bearing_x,
+                        @as(f32, @floatFromInt(glyph.OffsetY)) * scale + bearing_y,
+                    ),
+                };
+            }
+        }
+        // Try to get the next run.
+        if (kb.kbts_ShapeRun(s.context, &s.run) != 0) {
+            s.has_run = true;
+            continue;
+        }
+        // No more runs.
+        s.has_run = false;
+        return null;
+    }
 }
 
 pub fn deinit(s: *const TextRun) void {
-    c.hb_buffer_destroy(s.buffer);
+    kb.kbts_DestroyShapeContext(s.context);
 }

src/gfx/font/native/ft.zig

@@ -1,6 +1,8 @@
 pub const c = @cImport({
     @cInclude("ft2build.h");
     @cInclude("freetype/freetype.h");
-    @cInclude("harfbuzz/hb.h");
-    @cInclude("harfbuzz/hb-ft.h");
+});
+
+pub const kb = @cImport({
+    @cInclude("kb_text_shape.h");
 });