From f8e201c5c4b1ee078219207c3c464c821194b685 Mon Sep 17 00:00:00 2001 From: Gabriel Dinner-David Date: Wed, 20 Nov 2024 23:58:45 -0500 Subject: [PATCH] wasm shaping and atlas rendering again --- build.zig | 152 +++++++++++---------- example/app.ts | 169 ++++++++++++------------ example/package-lock.json | 35 ++--- example/package.json | 2 +- pkg/sentry/build.zig | 2 +- src/App.zig | 2 +- src/Surface.zig | 8 +- src/build_config.zig | 4 +- src/cli/args.zig | 2 +- src/config/Config.zig | 24 ++-- src/config/theme.zig | 2 +- src/font/Collection.zig | 21 +++ src/font/DeferredFace.zig | 4 +- src/font/SharedGrid.zig | 48 +++++++ src/font/face/web_canvas.zig | 19 ++- src/font/main.zig | 2 + src/font/shaper/web_canvas.zig | 81 ++++++------ src/main_wasm.zig | 15 ++- src/os/desktop.zig | 2 + src/os/homedir.zig | 2 + src/os/main.zig | 7 + src/terminal/kitty/graphics_image.zig | 4 +- src/terminal/kitty/graphics_storage.zig | 3 +- src/terminal/page.zig | 2 +- src/termio/Exec.zig | 6 +- src/termio/Termio.zig | 4 +- 26 files changed, 358 insertions(+), 264 deletions(-) diff --git a/build.zig b/build.zig index 15fed7ed6..5410b793c 100644 --- a/build.zig +++ b/build.zig @@ -748,7 +748,7 @@ pub fn build(b: *std.Build) !void { break :config copy; }; - const wasm = b.addSharedLibrary(.{ + const wasm = b.addExecutable(.{ .name = "ghostty-wasm", .root_source_file = b.path("src/main_wasm.zig"), .target = b.resolveTargetQuery(wasm_crosstarget), @@ -757,7 +757,10 @@ pub fn build(b: *std.Build) !void { // So that we can use web workers with our wasm binary wasm.import_memory = true; - wasm.initial_memory = 65536 * 25; + wasm.initial_memory = 65536 * 512; + wasm.entry = .disabled; + // wasm.wasi_exec_model = .reactor; + wasm.rdynamic = true; wasm.max_memory = 65536 * 65536; // Maximum number of pages in wasm32 wasm.shared_memory = wasm_shared; @@ -769,10 +772,11 @@ pub fn build(b: *std.Build) !void { // Install const wasm_install = b.addInstallArtifact(wasm, .{}); - wasm_install.dest_dir = .{ .prefix = {} }; + const install = b.addInstallFile(wasm.getEmittedBin(), "../example/ghostty-wasm.wasm"); + wasm_install.step.dependOn(&install.step); const step = b.step("wasm", "Build the wasm library"); - step.dependOn(&wasm_install.step); + step.dependOn(&install.step); // We support tests via wasmtime. wasmtime uses WASI so this // isn't an exact match to our freestanding target above but @@ -1073,81 +1077,82 @@ fn addDeps( try static_libs.append(fontconfig_dep.artifact("fontconfig").getEmittedBin()); } } + if (step.rootModuleTarget().cpu.arch != .wasm32) { + // Libpng - Ghostty doesn't actually use this directly, its only used + // through dependencies, so we only need to add it to our static + // libs list if we're not using system integration. The dependencies + // will handle linking it. + if (!b.systemIntegrationOption("libpng", .{})) { + const libpng_dep = b.dependency("libpng", .{ + .target = target, + .optimize = optimize, + }); + step.linkLibrary(libpng_dep.artifact("png")); + try static_libs.append(libpng_dep.artifact("png").getEmittedBin()); + } - // Libpng - Ghostty doesn't actually use this directly, its only used - // through dependencies, so we only need to add it to our static - // libs list if we're not using system integration. The dependencies - // will handle linking it. - if (!b.systemIntegrationOption("libpng", .{})) { - const libpng_dep = b.dependency("libpng", .{ + // Zlib - same as libpng, only used through dependencies. + if (!b.systemIntegrationOption("zlib", .{})) { + const zlib_dep = b.dependency("zlib", .{ + .target = target, + .optimize = optimize, + }); + step.linkLibrary(zlib_dep.artifact("z")); + try static_libs.append(zlib_dep.artifact("z").getEmittedBin()); + } + + // Oniguruma + const oniguruma_dep = b.dependency("oniguruma", .{ .target = target, .optimize = optimize, }); - step.linkLibrary(libpng_dep.artifact("png")); - try static_libs.append(libpng_dep.artifact("png").getEmittedBin()); - } + step.root_module.addImport("oniguruma", oniguruma_dep.module("oniguruma")); + if (b.systemIntegrationOption("oniguruma", .{})) { + // Oniguruma is compiled and distributed as libonig.so + step.linkSystemLibrary2("onig", dynamic_link_opts); + } else { + step.linkLibrary(oniguruma_dep.artifact("oniguruma")); + try static_libs.append(oniguruma_dep.artifact("oniguruma").getEmittedBin()); + } - // Zlib - same as libpng, only used through dependencies. - if (!b.systemIntegrationOption("zlib", .{})) { - const zlib_dep = b.dependency("zlib", .{ + // Glslang + const glslang_dep = b.dependency("glslang", .{ .target = target, .optimize = optimize, }); - step.linkLibrary(zlib_dep.artifact("z")); - try static_libs.append(zlib_dep.artifact("z").getEmittedBin()); - } + step.root_module.addImport("glslang", glslang_dep.module("glslang")); + if (b.systemIntegrationOption("glslang", .{})) { + step.linkSystemLibrary2("glslang", dynamic_link_opts); + step.linkSystemLibrary2("glslang-default-resource-limits", dynamic_link_opts); + } else { + step.linkLibrary(glslang_dep.artifact("glslang")); + try static_libs.append(glslang_dep.artifact("glslang").getEmittedBin()); + } - // Oniguruma - const oniguruma_dep = b.dependency("oniguruma", .{ - .target = target, - .optimize = optimize, - }); - step.root_module.addImport("oniguruma", oniguruma_dep.module("oniguruma")); - if (b.systemIntegrationOption("oniguruma", .{})) { - // Oniguruma is compiled and distributed as libonig.so - step.linkSystemLibrary2("onig", dynamic_link_opts); - } else { - step.linkLibrary(oniguruma_dep.artifact("oniguruma")); - try static_libs.append(oniguruma_dep.artifact("oniguruma").getEmittedBin()); - } - - // Glslang - const glslang_dep = b.dependency("glslang", .{ - .target = target, - .optimize = optimize, - }); - step.root_module.addImport("glslang", glslang_dep.module("glslang")); - if (b.systemIntegrationOption("glslang", .{})) { - step.linkSystemLibrary2("glslang", dynamic_link_opts); - step.linkSystemLibrary2("glslang-default-resource-limits", dynamic_link_opts); - } else { - step.linkLibrary(glslang_dep.artifact("glslang")); - try static_libs.append(glslang_dep.artifact("glslang").getEmittedBin()); - } - - // Spirv-cross - const spirv_cross_dep = b.dependency("spirv_cross", .{ - .target = target, - .optimize = optimize, - }); - step.root_module.addImport("spirv_cross", spirv_cross_dep.module("spirv_cross")); - if (b.systemIntegrationOption("spirv-cross", .{})) { - step.linkSystemLibrary2("spirv-cross", dynamic_link_opts); - } else { - step.linkLibrary(spirv_cross_dep.artifact("spirv_cross")); - try static_libs.append(spirv_cross_dep.artifact("spirv_cross").getEmittedBin()); - } - - // Simdutf - if (b.systemIntegrationOption("simdutf", .{})) { - step.linkSystemLibrary2("simdutf", dynamic_link_opts); - } else { - const simdutf_dep = b.dependency("simdutf", .{ + // Spirv-cross + const spirv_cross_dep = b.dependency("spirv_cross", .{ .target = target, .optimize = optimize, }); - step.linkLibrary(simdutf_dep.artifact("simdutf")); - try static_libs.append(simdutf_dep.artifact("simdutf").getEmittedBin()); + step.root_module.addImport("spirv_cross", spirv_cross_dep.module("spirv_cross")); + if (b.systemIntegrationOption("spirv-cross", .{})) { + step.linkSystemLibrary2("spirv-cross", dynamic_link_opts); + } else { + step.linkLibrary(spirv_cross_dep.artifact("spirv_cross")); + try static_libs.append(spirv_cross_dep.artifact("spirv_cross").getEmittedBin()); + } + + // Simdutf + if (b.systemIntegrationOption("simdutf", .{})) { + step.linkSystemLibrary2("simdutf", dynamic_link_opts); + } else { + const simdutf_dep = b.dependency("simdutf", .{ + .target = target, + .optimize = optimize, + }); + step.linkLibrary(simdutf_dep.artifact("simdutf")); + try static_libs.append(simdutf_dep.artifact("simdutf").getEmittedBin()); + } } // Sentry @@ -1157,7 +1162,7 @@ fn addDeps( .backend = .breakpad, }); step.root_module.addImport("sentry", sentry_dep.module("sentry")); - if (target.result.os.tag != .windows) { + if (target.result.os.tag != .windows and target.result.cpu.arch != .wasm32) { // Sentry step.linkLibrary(sentry_dep.artifact("sentry")); try static_libs.append(sentry_dep.artifact("sentry").getEmittedBin()); @@ -1177,6 +1182,17 @@ fn addDeps( .optimize = optimize, }); step.root_module.addImport("zig-js", js_dep.module("zig-js")); + step.root_module.addImport("ziglyph", b.dependency("ziglyph", .{ + .target = target, + .optimize = optimize, + }).module("ziglyph")); + step.root_module.addImport("z2d", b.addModule("z2d", .{ + .root_source_file = b.dependency("z2d", .{}).path("src/z2d.zig"), + .target = target, + .optimize = optimize, + })); + // step.linkLibC(); + try addUnicodeTables(b, step); return static_libs; } diff --git a/example/app.ts b/example/app.ts index 5b426a333..0168e030d 100644 --- a/example/app.ts +++ b/example/app.ts @@ -1,11 +1,11 @@ -import { ZigJS } from "zig-js"; +import { ZigJS } from "zig-js/src/index.ts"; const zjs = new ZigJS(); const importObject = { module: {}, env: { memory: new WebAssembly.Memory({ - initial: 25, + initial: 512, maximum: 65536, shared: true, }), @@ -27,38 +27,36 @@ fetch(url.href) .then((results) => { const memory = importObject.env.memory; const { - malloc, - free, - config_new, - config_free, - config_load_string, - config_finalize, - face_new, - face_free, - face_render_glyph, - face_debug_canvas, - deferred_face_new, - deferred_face_free, - deferred_face_load, - deferred_face_face, - group_new, - group_free, - group_add_face, - group_init_sprite_face, - group_index_for_codepoint, - group_render_glyph, - group_cache_new, - group_cache_free, - group_cache_index_for_codepoint, - group_cache_render_glyph, - group_cache_atlas_grayscale, - group_cache_atlas_color, - atlas_new, - atlas_free, - atlas_debug_canvas, - shaper_new, - shaper_free, - shaper_test, + atlas_clear, + atlas_debug_canvas, + atlas_free, + atlas_grow, + atlas_new, + atlas_reserve, + atlas_set, + config_finalize, + config_free, + config_load_string, + config_new, + deferred_face_free, + deferred_face_load, + deferred_face_new, + face_debug_canvas, + face_free, + face_new, + face_render_glyph, + free, + malloc, + shaper_free, + shaper_new, + shaper_test, + collection_new, + collection_add_deferred_face, + shared_grid_new, + shared_grid_atlas_grayscale, + shared_grid_atlas_color, + shared_grid_index_for_codepoint, + shared_grid_render_glyph, } = results.instance.exports; // Give us access to the zjs value for debugging. globalThis.zjs = zjs; @@ -81,109 +79,110 @@ fetch(url.href) config_load_string(config, config_str.ptr, config_str.len); config_finalize(config); free(config_str.ptr); - + // Create our atlas // const atlas = atlas_new(512, 0 /* grayscale */); - + // Create some memory for our string const font_name = makeStr("monospace"); - + // Initialize our deferred face // const df = deferred_face_new(font_ptr, font.byteLength, 0 /* text */); //deferred_face_load(df, 72 /* size */); //const face = deferred_face_face(df); - + // Initialize our font face //const face = face_new(font_ptr, font.byteLength, 72 /* size in px */); //free(font_ptr); - + // Create our group - const group = group_new(32 /* size */); - group_add_face( - group, + const collection = collection_new(24); + collection_add_deferred_face( + collection, 0 /* regular */, deferred_face_new(font_name.ptr, font_name.len, 0 /* text */), ); - group_add_face( - group, + collection_add_deferred_face( + collection, 0 /* regular */, deferred_face_new(font_name.ptr, font_name.len, 1 /* emoji */), ); - + const grid = shared_grid_new(collection); + // Initialize our sprite font, without this we just use the browser. - group_init_sprite_face(group); - - // Create our group cache - const group_cache = group_cache_new(group); - + // group_init_sprite_face(group); + + // // Create our group cache + // const group_cache = group_cache_new(group); + // Render a glyph - // for (let i = 33; i <= 126; i++) { - // const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - // group_cache_render_glyph(group_cache, font_idx, i, 0); - // //face_render_glyph(face, atlas, i); - // } + for (let i = 33; i <= 126; i++) { + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); + //face_render_glyph(face, atlas, i); + } // - // const emoji = ["🐏","🌞","🌚","🍱","πŸ’Ώ","🐈","πŸ“ƒ","πŸ“€","πŸ•‘","πŸ™ƒ"]; - // for (let i = 0; i < emoji.length; i++) { - // const cp = emoji[i].codePointAt(0); - // const font_idx = group_cache_index_for_codepoint(group_cache, cp, 0, -1 /* best choice */); - // group_cache_render_glyph(group_cache, font_idx, cp, 0); - // } - + const emoji = ["🐏","🌞","🌚","🍱","πŸ’Ώ","🐈","πŸ“ƒ","πŸ“€","πŸ•‘","πŸ™ƒ"]; + for (let i = 0; i < emoji.length; i++) { + const cp = emoji[i].codePointAt(0); + const font_idx = shared_grid_index_for_codepoint(grid, cp, 0, -1 /* best choice */); + shared_grid_render_glyph(grid, font_idx, cp, 0); + } + for (let i = 0x2500; i <= 0x257f; i++) { - const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - group_cache_render_glyph(group_cache, font_idx, i, 0); + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); } for (let i = 0x2580; i <= 0x259f; i++) { - const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - group_cache_render_glyph(group_cache, font_idx, i, 0); + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); } for (let i = 0x2800; i <= 0x28ff; i++) { - const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - group_cache_render_glyph(group_cache, font_idx, i, 0); + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); } for (let i = 0x1fb00; i <= 0x1fb3b; i++) { - const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - group_cache_render_glyph(group_cache, font_idx, i, 0); + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); } for (let i = 0x1fb3c; i <= 0x1fb6b; i++) { - const font_idx = group_cache_index_for_codepoint(group_cache, i, 0, -1); - group_cache_render_glyph(group_cache, font_idx, i, 0); + const font_idx = shared_grid_index_for_codepoint(grid, i, 0, -1); + shared_grid_render_glyph(grid, font_idx, i, 0); } - + //face_render_glyph(face, atlas, "ζ©‹".codePointAt(0)); //face_render_glyph(face, atlas, "p".codePointAt(0)); - + // Debug our canvas //face_debug_canvas(face); - + // Let's try shaping const shaper = shaper_new(120); //const input = makeStr("hello🐏"); const input = makeStr("helloπŸπŸ‘πŸ½"); - shaper_test(shaper, group_cache, input.ptr, input.len); - + shaper_test(shaper, grid, input.ptr, input.len); + const cp = 1114112; - const font_idx = group_cache_index_for_codepoint( - group_cache, + const font_idx = shared_grid_index_for_codepoint( + grid, cp, 0, -1 /* best choice */, ); - group_cache_render_glyph(group_cache, font_idx, cp, -1); - + shared_grid_render_glyph(grid, font_idx, cp, -1); + // Debug our atlas canvas { - const atlas = group_cache_atlas_grayscale(group_cache); + const atlas = shared_grid_atlas_grayscale(grid); const id = atlas_debug_canvas(atlas); document.getElementById("atlas-canvas").append(zjs.deleteValue(id)); } - + { - const atlas = group_cache_atlas_color(group_cache); + const atlas = shared_grid_atlas_color(grid); const id = atlas_debug_canvas(atlas); document.getElementById("atlas-color-canvas").append(zjs.deleteValue(id)); } - + //face_free(face); }); diff --git a/example/package-lock.json b/example/package-lock.json index 3cb4de6f0..c18a6b878 100644 --- a/example/package-lock.json +++ b/example/package-lock.json @@ -9,7 +9,7 @@ "version": "0.1.0", "license": "MIT", "dependencies": { - "zig-js": "file:../vendor/zig-js/js" + "zig-js": "https://gitpkg.vercel.app/mitchellh/zig-js/js?main" }, "devDependencies": { "@parcel/transformer-inline-string": "^2.8.0", @@ -20,20 +20,6 @@ "../js": { "extraneous": true }, - "../vendor/zig-js/js": { - "name": "zig-js-glue", - "version": "0.1.2", - "license": "MIT", - "devDependencies": { - "@parcel/packager-ts": "^2.8.0", - "@parcel/transformer-typescript-types": "^2.8.0", - "@types/jest": "^29.2.3", - "jest": "^29.3.1", - "parcel": "^2.8.0", - "ts-jest": "^29.0.3", - "typescript": "^4.9.3" - } - }, "node_modules/@babel/code-frame": { "version": "7.18.6", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", @@ -2693,8 +2679,11 @@ } }, "node_modules/zig-js": { - "resolved": "../vendor/zig-js/js", - "link": true + "name": "zig-js-glue", + "version": "0.1.3", + "resolved": "https://gitpkg.vercel.app/mitchellh/zig-js/js?main", + "integrity": "sha512-CdM4TmAINU1fsZMm0S3dH4XzQgCIC4AWfztA2eGRD9Tfk/2LfCZ7RgOED7i26P1Jf2+BCQIBMbxXocV7oxR3Ig==", + "license": "MIT" } }, "dependencies": { @@ -4421,16 +4410,8 @@ "dev": true }, "zig-js": { - "version": "file:../vendor/zig-js/js", - "requires": { - "@parcel/packager-ts": "^2.8.0", - "@parcel/transformer-typescript-types": "^2.8.0", - "@types/jest": "^29.2.3", - "jest": "^29.3.1", - "parcel": "^2.8.0", - "ts-jest": "^29.0.3", - "typescript": "^4.9.3" - } + "version": "https://gitpkg.vercel.app/mitchellh/zig-js/js?main", + "integrity": "sha512-CdM4TmAINU1fsZMm0S3dH4XzQgCIC4AWfztA2eGRD9Tfk/2LfCZ7RgOED7i26P1Jf2+BCQIBMbxXocV7oxR3Ig==" } } } diff --git a/example/package.json b/example/package.json index e884e5c6c..b031a6cc9 100644 --- a/example/package.json +++ b/example/package.json @@ -17,6 +17,6 @@ "typescript": "^4.9.3" }, "dependencies": { - "zig-js": "file:../vendor/zig-js/js" + "zig-js": "https://gitpkg.vercel.app/mitchellh/zig-js/js?main" } } diff --git a/pkg/sentry/build.zig b/pkg/sentry/build.zig index 855490c0a..c3e360b48 100644 --- a/pkg/sentry/build.zig +++ b/pkg/sentry/build.zig @@ -116,7 +116,7 @@ pub fn build(b: *std.Build) !void { .flags = flags.items, }), - .freestanding => {}, + .freestanding, .wasi => {}, else => { std.log.warn("target={} not supported", .{target.result.os.tag}); diff --git a/src/App.zig b/src/App.zig index 279c4e497..24d9018bc 100644 --- a/src/App.zig +++ b/src/App.zig @@ -64,7 +64,7 @@ font_grid_set: font.SharedGridSet, // Used to rate limit desktop notifications. Some platforms (notably macOS) will // run out of resources if desktop notifications are sent too fast and the OS // will kill Ghostty. -last_notification_time: ?std.time.Instant = null, +last_notification_time: ?internal_os.Instant = null, last_notification_digest: u64 = 0, /// The conditional state of the configuration. See the equivalent field diff --git a/src/Surface.zig b/src/Surface.zig index b2530936a..4d2cff165 100644 --- a/src/Surface.zig +++ b/src/Surface.zig @@ -174,7 +174,7 @@ const Mouse = struct { /// The left click time was the last time the left click was done. This /// is always set on the first left click. left_click_count: u8 = 0, - left_click_time: std.time.Instant = undefined, + left_click_time: internal_os.Instant = undefined, /// The last x/y sent for mouse reports. event_point: ?terminal.point.Coordinate = null, @@ -2724,7 +2724,7 @@ pub fn mouseButtonCallback( // If we are within the interval that the click would register // an increment then we do not extend the selection. - if (std.time.Instant.now()) |now| { + if (internal_os.Instant.now()) |now| { const since = now.since(self.mouse.left_click_time); if (since <= self.config.mouse_interval) { // Click interval very short, we may be increasing @@ -2870,7 +2870,7 @@ pub fn mouseButtonCallback( self.mouse.left_click_ypos = pos.y; // Setup our click counter and timer - if (std.time.Instant.now()) |now| { + if (internal_os.Instant.now()) |now| { // If we have mouse clicks, then we check if the time elapsed // is less than and our interval and if so, increase the count. if (self.mouse.left_click_count > 0) { @@ -4478,7 +4478,7 @@ fn showDesktopNotification(self: *Surface, title: [:0]const u8, body: [:0]const // how fast identical notifications can be sent sequentially. const hash_algorithm = std.hash.Wyhash; - const now = try std.time.Instant.now(); + const now = try internal_os.Instant.now(); // Set a limit of one desktop notification per second so that the OS // doesn't kill us when we run out of resources. diff --git a/src/build_config.zig b/src/build_config.zig index 715552e03..8f9df129c 100644 --- a/src/build_config.zig +++ b/src/build_config.zig @@ -128,8 +128,8 @@ pub const Artifact = enum { pub fn detect() Artifact { if (builtin.target.isWasm()) { - assert(builtin.output_mode == .Obj); - assert(builtin.link_mode == .Static); + // assert(builtin.output_mode == .Obj); + // assert(builtin.link_mode == .Static); return .wasm_module; } diff --git a/src/cli/args.zig b/src/cli/args.zig index 3e378f347..466404500 100644 --- a/src/cli/args.zig +++ b/src/cli/args.zig @@ -1275,7 +1275,7 @@ pub fn LineIterator(comptime ReaderType: type) type { } // Constructs a LineIterator (see docs for that). -fn lineIterator(reader: anytype) LineIterator(@TypeOf(reader)) { +pub fn lineIterator(reader: anytype) LineIterator(@TypeOf(reader)) { return .{ .r = reader }; } diff --git a/src/config/Config.zig b/src/config/Config.zig index 66e9e9ff9..319504088 100644 --- a/src/config/Config.zig +++ b/src/config/Config.zig @@ -2752,19 +2752,21 @@ fn loadTheme(self: *Config, theme: Theme) !void { pub fn finalize(self: *Config) !void { // We always load the theme first because it may set other fields // in our config. - if (self.theme) |theme| { - const different = !std.mem.eql(u8, theme.light, theme.dark); + if (builtin.cpu.arch != .wasm32) { + if (self.theme) |theme| { + const different = !std.mem.eql(u8, theme.light, theme.dark); - // Warning: loadTheme will deinit our existing config and replace - // it so all memory from self prior to this point will be freed. - try self.loadTheme(theme); + // Warning: loadTheme will deinit our existing config and replace + // it so all memory from self prior to this point will be freed. + try self.loadTheme(theme); - // If we have different light vs dark mode themes, disable - // window-theme = auto since that breaks it. - if (different) { - // This setting doesn't make sense with different light/dark themes - // because it'll force the theme based on the Ghostty theme. - if (self.@"window-theme" == .auto) self.@"window-theme" = .system; + // If we have different light vs dark mode themes, disable + // window-theme = auto since that breaks it. + if (different) { + // This setting doesn't make sense with different light/dark themes + // because it'll force the theme based on the Ghostty theme. + if (self.@"window-theme" == .auto) self.@"window-theme" = .system; + } } } diff --git a/src/config/theme.zig b/src/config/theme.zig index b851ec3d4..2ad5cd76d 100644 --- a/src/config/theme.zig +++ b/src/config/theme.zig @@ -39,7 +39,7 @@ pub const Location = enum { // error set since some platforms don't support some // error types. const Error = @TypeOf(err) || switch (builtin.os.tag) { - .ios => error{BufferTooSmall}, + .ios, .wasi => error{BufferTooSmall}, else => error{}, }; diff --git a/src/font/Collection.zig b/src/font/Collection.zig index f79c80936..5168b2dc8 100644 --- a/src/font/Collection.zig +++ b/src/font/Collection.zig @@ -659,6 +659,27 @@ pub const Index = packed struct(Index.Backing) { } }; +/// The wasm-compatible API. +pub const Wasm = struct { + const wasm = @import("../os/wasm.zig"); + const alloc = wasm.alloc; + export fn collection_new(points: f32) ?*Collection { + const result = alloc.create(Collection) catch |err| { + log.warn("error creating collection err={}", .{err}); + return null; + }; + result.* = Collection.init(); + result.load_options = .{ .library = Library.init() catch unreachable, .size = .{ .points = points } }; + return result; + } + export fn collection_add_deferred_face(self: *Collection, style: u8, face: *DeferredFace) u16 { + return @bitCast(self.add(alloc, @enumFromInt(style), .{ .deferred = face.* }) catch |err| { + log.warn("error adding deferred face to collection err={}", .{err}); + return 0; + }); + } +}; + test init { const testing = std.testing; const alloc = testing.allocator; diff --git a/src/font/DeferredFace.zig b/src/font/DeferredFace.zig index 3ee104386..f47904e95 100644 --- a/src/font/DeferredFace.zig +++ b/src/font/DeferredFace.zig @@ -254,7 +254,7 @@ fn loadWebCanvas( opts: font.face.Options, ) !Face { const wc = self.wc.?; - return try Face.initNamed(wc.alloc, wc.font_str, opts, wc.presentation); + return try Face.initNamed(wc.alloc, wc.font_str, opts.size, wc.presentation); } /// Returns true if this face can satisfy the given codepoint and @@ -392,7 +392,7 @@ pub const Wasm = struct { } export fn deferred_face_load(self: *DeferredFace, pts: f32) void { - self.load(.{}, .{ .points = pts }) catch |err| { + _ = self.load(.{}, .{ .size = .{ .points = pts } }) catch |err| { log.warn("error loading deferred face err={}", .{err}); return; }; diff --git a/src/font/SharedGrid.zig b/src/font/SharedGrid.zig index 8af385b84..40a4f877b 100644 --- a/src/font/SharedGrid.zig +++ b/src/font/SharedGrid.zig @@ -322,6 +322,54 @@ const GlyphKey = struct { const TestMode = enum { normal }; +/// The wasm-compatible API. +pub const Wasm = struct { + const wasm = @import("../os/wasm.zig"); + const alloc = wasm.alloc; + export fn shared_grid_new(c: *Collection) ?*SharedGrid { + const result = alloc.create(SharedGrid) catch |err| { + log.warn("error creating SharedGrid err={}", .{err}); + return null; + }; + result.* = SharedGrid.init(wasm.alloc, .{ .collection = c.* }) catch |err| { + log.warn("error initializing SharedGrid err={}", .{err}); + return null; + }; + return result; + } + export fn shared_grid_atlas_grayscale(self: *SharedGrid) ?*Atlas { + return &self.atlas_grayscale; + } + export fn shared_grid_atlas_color(self: *SharedGrid) ?*Atlas { + return &self.atlas_color; + } + export fn shared_grid_index_for_codepoint(self: *SharedGrid, code: u32, style: u8, presentation: i8) ?*Collection.Index { + const get = self.getIndex(wasm.alloc, code, @enumFromInt(style), if (presentation < 0) null else @enumFromInt(presentation)) catch |err| { + log.warn("error getting SharedGrid index for codepoint err={}", .{err}); + return null; + }; + if (get) |thing| { + const index = wasm.alloc.create(Collection.Index) catch unreachable; + index.* = thing; + return index; + } + return null; + } + + export fn shared_grid_render_glyph(self: *SharedGrid, font_idx: *Collection.Index, code: u32, _: u8) void { + const glyph_index = glyph_index: { + if (font_idx.special()) |special| break :glyph_index switch (special) { + .sprite => code, + }; + self.lock.lockShared(); + defer self.lock.unlockShared(); + const face = self.resolver.collection.getFace(font_idx.*) catch unreachable; + break :glyph_index face.glyphIndex(code) orelse return; + }; + _ = self.renderGlyph(wasm.alloc, font_idx.*, glyph_index, .{}) catch unreachable; + } +}; + fn testGrid(mode: TestMode, alloc: Allocator, lib: Library) !SharedGrid { const testFont = font.embedded.regular; diff --git a/src/font/face/web_canvas.zig b/src/font/face/web_canvas.zig index 60846f350..51c76712a 100644 --- a/src/font/face/web_canvas.zig +++ b/src/font/face/web_canvas.zig @@ -325,6 +325,23 @@ pub const Face = struct { return ctx; } + pub fn isColorGlyph(self: *const Face, cp: u32) bool { + // Render the glyph + var render = self.renderGlyphInternal(self.alloc, cp) catch unreachable; + defer render.deinit(); + + // Inspect the image data for any non-zeros in the RGB value. + // NOTE(perf): this is an easy candidate for SIMD. + var i: usize = 0; + while (i < render.bitmap.len) : (i += 4) { + if (render.bitmap[i] > 0 or + render.bitmap[i + 1] > 0 or + render.bitmap[i + 2] > 0) return true; + } + + return false; + } + /// An internal (web-canvas-only) format for rendered glyphs /// since we do render passes in multiple different situations. const RenderedGlyph = struct { @@ -494,7 +511,7 @@ pub const Wasm = struct { const alloc = wasm.alloc; export fn face_new(ptr: [*]const u8, len: usize, pts: u16, p: u16) ?*Face { - return face_new_(ptr, len, pts, p) catch null; + return face_new_(ptr, len, @floatFromInt(pts), p) catch null; } fn face_new_(ptr: [*]const u8, len: usize, pts: f32, presentation: u16) !*Face { diff --git a/src/font/main.zig b/src/font/main.zig index 60e7593cb..413788c31 100644 --- a/src/font/main.zig +++ b/src/font/main.zig @@ -33,6 +33,8 @@ comptime { if (builtin.target.isWasm()) { _ = Atlas.Wasm; _ = DeferredFace.Wasm; + _ = SharedGrid.Wasm; + _ = @import("Collection.zig").Wasm; _ = face.web_canvas.Wasm; _ = shape.web_canvas.Wasm; } diff --git a/src/font/shaper/web_canvas.zig b/src/font/shaper/web_canvas.zig index f38ab885a..37bfe70b2 100644 --- a/src/font/shaper/web_canvas.zig +++ b/src/font/shaper/web_canvas.zig @@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator; const ziglyph = @import("ziglyph"); const font = @import("../main.zig"); const terminal = @import("../../terminal/main.zig"); +const SharedGrid = font.SharedGrid; const log = std.log.scoped(.font_shaper); @@ -30,19 +31,19 @@ pub const Shaper = struct { alloc: Allocator, /// The shared memory used for shaping results. - cell_buf: []font.shape.Cell, + cell_buf: std.ArrayListUnmanaged(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 { + pub fn init(alloc: Allocator, _: font.shape.Options) !Shaper { // Note: we do not support opts.font_features return Shaper{ .alloc = alloc, - .cell_buf = opts.cell_buf, + .cell_buf = .{}, .run_buf = .{}, }; } @@ -61,14 +62,16 @@ pub const Shaper = struct { /// for a Shaper struct since they share state. pub fn runIterator( self: *Shaper, - group: *font.GroupCache, - row: terminal.Screen.Row, + grid: *SharedGrid, + screen: *const terminal.Screen, + row: terminal.Pin, selection: ?terminal.Selection, cursor_x: ?usize, ) font.shape.RunIterator { return .{ .hooks = .{ .shaper = self }, - .group = group, + .grid = grid, + .screen = screen, .row = row, .selection = selection, .cursor_x = cursor_x, @@ -90,21 +93,22 @@ pub const Shaper = struct { const clusters = self.run_buf.items(.cluster); assert(codepoints.len == clusters.len); + self.cell_buf.clearRetainingCapacity(); 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], + 0 => return self.cell_buf.items[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] = .{ + try self.cell_buf.append(self.alloc, .{ .x = @intCast(clusters[0]), .glyph_index = codepoints[0], - }; + }); - return self.cell_buf[0..1]; + return self.cell_buf.items[0..1]; }, else => {}, @@ -151,10 +155,10 @@ pub const Shaper = struct { switch (len) { // If we have only a single codepoint then just render it // as-is. - 1 => self.cell_buf[cur] = .{ + 1 => try self.cell_buf.append(self.alloc, .{ .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 @@ -190,13 +194,13 @@ pub const Shaper = struct { }; defer self.alloc.free(cluster); - var face = try run.group.group.faceFromIndex(run.font_index); + var face = try run.grid.resolver.collection.getFace(run.font_index); const index = try face.graphemeGlyphIndex(cluster); - self.cell_buf[cur] = .{ + try self.cell_buf.append(self.alloc, .{ .x = @intCast(clusters[start]), .glyph_index = index, - }; + }); }, } @@ -204,7 +208,7 @@ pub const Shaper = struct { cur += 1; } - return self.cell_buf[0..cur]; + return self.cell_buf.items[0..cur]; } /// The hooks for RunIterator. @@ -238,15 +242,12 @@ 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; + export fn shaper_new() ?*Shaper { + return shaper_new_() 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 }); + fn shaper_new_() !*Shaper { + var shaper = try Shaper.init(alloc, .{}); errdefer shaper.deinit(); const result = try alloc.create(Shaper); @@ -257,7 +258,6 @@ pub const Wasm = struct { export fn shaper_free(ptr: ?*Shaper) void { if (ptr) |v| { - alloc.free(v.cell_buf); v.deinit(); alloc.destroy(v); } @@ -266,38 +266,33 @@ pub const Wasm = struct { /// Runs a test to verify shaping works properly. export fn shaper_test( self: *Shaper, - group: *font.GroupCache, + grid: *SharedGrid, str: [*]const u8, len: usize, ) void { - shaper_test_(self, group, str[0..len]) catch |err| { + shaper_test_(self, grid, 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); + fn shaper_test_(self: *Shaper, grid: *SharedGrid, str: []const u8) !void { + // Make a screen with some data + var term = try terminal.Terminal.init(alloc, .{ .cols = 6, .rows = 5 }); defer term.deinit(alloc); + try term.printString(str); - // 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); - } - } + // Get our run iterator - // Iterate over the rows and print out all the runs we get. - var rowIter = term.screen.rowIterator(.viewport); + var row_it = term.screen.pages.rowIterator(.right_down, .{ .viewport = .{} }, null); var y: usize = 0; - while (rowIter.next()) |row| { + while (row_it.next()) |row| { defer y += 1; - - var iter = self.runIterator(group, row, null, null); - while (try iter.next(alloc)) |run| { + var it = self.runIterator(grid, &term.screen, row, null, null); + while (try it.next(alloc)) |run| { const cells = try self.shape(run); + for (cells) |cell| { + _ = try grid.renderGlyph(wasm.alloc, run.font_index, cell.glyph_index, .{}); + } log.info("y={} run={d} shape={any} idx={}", .{ y, run.cells, diff --git a/src/main_wasm.zig b/src/main_wasm.zig index bffe5e4b7..d4b7d63e5 100644 --- a/src/main_wasm.zig +++ b/src/main_wasm.zig @@ -11,16 +11,17 @@ comptime { _ = @import("App.zig").Wasm; } -pub const std_options = struct { +pub const std_options: std.Options = .{ // Set our log level. We try to get as much logging as possible but in // ReleaseSmall mode where we're optimizing for space, we elevate the // log level. - pub const log_level: std.log.Level = switch (builtin.mode) { - .Debug => .debug, - .ReleaseSmall => .warn, - else => .info, - }; + // .log_level = switch (builtin.mode) { + // .Debug => .debug, + // .ReleaseSmall => .warn, + // else => .info, + // }, + .log_level = .info, // Set our log function - pub const logFn = @import("os/wasm/log.zig").log; + .logFn = @import("os/wasm/log.zig").log, }; diff --git a/src/os/desktop.zig b/src/os/desktop.zig index 103127dfa..eb4ac1a59 100644 --- a/src/os/desktop.zig +++ b/src/os/desktop.zig @@ -56,6 +56,8 @@ pub fn launchedFromDesktop() bool { // iPhone/iPad is always launched from the "desktop" .ios => true, + .freestanding => false, + else => @compileError("unsupported platform"), }; } diff --git a/src/os/homedir.zig b/src/os/homedir.zig index cf6931f22..b299563fb 100644 --- a/src/os/homedir.zig +++ b/src/os/homedir.zig @@ -20,6 +20,8 @@ pub inline fn home(buf: []u8) !?[]u8 { // iOS doesn't have a user-writable home directory .ios => null, + .wasi => null, + else => @compileError("unimplemented"), }; } diff --git a/src/os/main.zig b/src/os/main.zig index 22765f546..d545f3475 100644 --- a/src/os/main.zig +++ b/src/os/main.zig @@ -13,6 +13,8 @@ const mouse = @import("mouse.zig"); const openpkg = @import("open.zig"); const pipepkg = @import("pipe.zig"); const resourcesdir = @import("resourcesdir.zig"); +const builtin = @import("builtin"); +const std = @import("std"); // Namespaces pub const args = @import("args.zig"); @@ -42,3 +44,8 @@ pub const clickInterval = mouse.clickInterval; pub const open = openpkg.open; pub const pipe = pipepkg.pipe; pub const resourcesDir = resourcesdir.resourcesDir; +pub const Instant = if (builtin.cpu.arch != .wasm32) std.time.Instant else struct { + fn now() !@This() { + return .{}; + } +}; diff --git a/src/terminal/kitty/graphics_image.zig b/src/terminal/kitty/graphics_image.zig index 931d068f9..f461757f3 100644 --- a/src/terminal/kitty/graphics_image.zig +++ b/src/terminal/kitty/graphics_image.zig @@ -346,7 +346,7 @@ pub const LoadingImage = struct { } // Set our time - self.image.transmit_time = std.time.Instant.now() catch |err| { + self.image.transmit_time = internal_os.Instant.now() catch |err| { log.warn("failed to get time: {}", .{err}); return error.InternalError; }; @@ -453,7 +453,7 @@ pub const Image = struct { format: command.Transmission.Format = .rgb, compression: command.Transmission.Compression = .none, data: []const u8 = "", - transmit_time: std.time.Instant = undefined, + transmit_time: internal_os.Instant = undefined, pub const Error = error{ InternalError, diff --git a/src/terminal/kitty/graphics_storage.zig b/src/terminal/kitty/graphics_storage.zig index bf8633c88..3a4501922 100644 --- a/src/terminal/kitty/graphics_storage.zig +++ b/src/terminal/kitty/graphics_storage.zig @@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator; const ArenaAllocator = std.heap.ArenaAllocator; const terminal = @import("../main.zig"); +const internal_os = @import("../../os/main.zig"); const point = @import("../point.zig"); const size = @import("../size.zig"); const command = @import("graphics_command.zig"); @@ -495,7 +496,7 @@ pub const ImageStorage = struct { // bit is fine compared to the megabytes we're looking to save. const Candidate = struct { id: u32, - time: std.time.Instant, + time: internal_os.Instant, used: bool, }; diff --git a/src/terminal/page.zig b/src/terminal/page.zig index 8c470d726..5cc24d01f 100644 --- a/src/terminal/page.zig +++ b/src/terminal/page.zig @@ -320,7 +320,7 @@ pub const Page = struct { /// when runtime safety is enabled. This is a no-op when runtime /// safety is disabled. This uses the libc allocator. pub fn assertIntegrity(self: *const Page) void { - if (comptime build_config.slow_runtime_safety) { + if (comptime build_config.slow_runtime_safety and builtin.cpu.arch != .wasm32) { self.verifyIntegrity(std.heap.c_allocator) catch |err| { log.err("page integrity violation, crashing. err={}", .{err}); @panic("page integrity violation"); diff --git a/src/termio/Exec.zig b/src/termio/Exec.zig index 07aa43c42..3b4e0c6a9 100644 --- a/src/termio/Exec.zig +++ b/src/termio/Exec.zig @@ -102,7 +102,7 @@ pub fn threadEnter( }; // Track our process start time for abnormal exits - const process_start = try std.time.Instant.now(); + const process_start = try internal_os.Instant.now(); // Create our pipe that we'll use to kill our read thread. // pipe[0] is the read end, pipe[1] is the write end. @@ -345,7 +345,7 @@ fn processExit( // Determine how long the process was running for. const runtime_ms: ?u64 = runtime: { - const process_end = std.time.Instant.now() catch break :runtime null; + const process_end = internal_os.now() catch break :runtime null; const runtime_ns = process_end.since(execdata.start); const runtime_ms = runtime_ns / std.time.ns_per_ms; break :runtime runtime_ms; @@ -603,7 +603,7 @@ pub const ThreadData = struct { const WRITE_REQ_PREALLOC = std.math.pow(usize, 2, 5); /// Process start time and boolean of whether its already exited. - start: std.time.Instant, + start: internal_os.Instant, exited: bool = false, /// The number of milliseconds below which we consider a process diff --git a/src/termio/Termio.zig b/src/termio/Termio.zig index 9ed3ffc94..bdc743949 100644 --- a/src/termio/Termio.zig +++ b/src/termio/Termio.zig @@ -68,7 +68,7 @@ terminal_stream: terminal.Stream(StreamHandler), /// Last time the cursor was reset. This is used to prevent message /// flooding with cursor resets. -last_cursor_reset: ?std.time.Instant = null, +last_cursor_reset: ?internal_os.Instant = null, /// The configuration for this IO that is derived from the main /// configuration. This must be exported so that we don't need to @@ -552,7 +552,7 @@ fn processOutputLocked(self: *Termio, buf: []const u8) void { // non-blink state so it is rendered if visible. If we're under // HEAVY read load, we don't want to send a ton of these so we // use a timer under the covers - if (std.time.Instant.now()) |now| cursor_reset: { + if (internal_os.Instant.now()) |now| cursor_reset: { if (self.last_cursor_reset) |last| { if (now.since(last) <= (500 * std.time.ns_per_ms)) { break :cursor_reset;