5cae59bc

Add text coverage comparison mode

a73x 2026-04-09 08:32

Commit message

Add text coverage comparison mode

src/main.zig

@@ @@ -5,6 +5,7 @@ const wayland_client = @import("wayland-client"); @@
+const renderer = @import("renderer");
+const font = @import("font");
+const config = @import("config");
+const vk = @field(renderer, "vk");
+const c = @cImport({
+    @cInclude("xkbcommon/xkbcommon-keysyms.h");
@@ @@ -56,6 +57,10 @@ pub fn main() !void { @@
+        return runDrawSmokeTest(alloc);
+    if (args.len >= 2 and std.mem.eql(u8, args[1], "--text-compare")) {
+        return runTextCoverageCompare(alloc);
+    }
+    return runTerminal(alloc);
+    return origins;
+const ComparisonPanelDraw = struct {
+    instance_offset_instances: u32,
+    instance_count: u32,
+    coverage: [2]f32,
+    origin_col: u32,
+};
+const TextCoverageCompareScene = struct {
+    instances: std.ArrayListUnmanaged(renderer.Instance) = .empty,
+    panel_draws: [4]ComparisonPanelDraw,
+    panel_cols: u32,
+    window_cols: u32,
+    window_rows: u32,
+    fn deinit(self: *TextCoverageCompareScene, alloc: std.mem.Allocator) void {
+        self.instances.deinit(alloc);
+    }
+};
+fn comparisonPanelCols(lines: []const []const u8) u32 {
+    var max_cols: u32 = 0;
+    for (lines) |line| {
+        max_cols = @max(max_cols, @as(u32, @intCast(line.len)));
+    }
+    return max_cols + 4;
+}
+fn comparisonVisibleGlyphCount(lines: []const []const u8) u32 {
+    var count: u32 = 0;
+    for (lines) |line| {
+        for (line) |char| {
+            if (char != ' ') count += 1;
+        }
+    }
+    return count;
+}
+fn buildTextCoverageCompareScene(
+    alloc: std.mem.Allocator,
+    face: *font.Face,
+    atlas: *font.Atlas,
+) !TextCoverageCompareScene {
+    const specimen_lines = comparisonSpecimenLines();
+    const variants = comparisonVariants();
+    const top_margin_rows: u32 = 2;
+    const panel_cols = comparisonPanelCols(specimen_lines);
+    const panel_origins = comparisonPanelOrigins(panel_cols, top_margin_rows);
+    const panel_glyph_count = comparisonVisibleGlyphCount(specimen_lines);
+    var instances: std.ArrayListUnmanaged(renderer.Instance) = .empty;
+    errdefer instances.deinit(alloc);
+    try instances.ensureTotalCapacity(alloc, @as(usize, panel_glyph_count) * variants.len);
+    const baseline = face.baseline();
+    const fg = [4]f32{ 1.0, 1.0, 1.0, 1.0 };
+    const bg = [4]f32{ 0.0, 0.0, 0.0, 1.0 };
+    var panel_draws: [4]ComparisonPanelDraw = undefined;
+    for (variants, 0..) |variant, panel_idx| {
+        const origin = panel_origins[panel_idx];
+        const instance_offset_instances: u32 = @intCast(instances.items.len);
+        for (specimen_lines, 0..) |line, row_idx| {
+            for (line, 0..) |char, col_idx| {
+                if (char == ' ') continue;
+                const glyph_uv = try atlas.getOrInsert(face, char);
+                try instances.append(alloc, .{
+                    .cell_pos = .{
+                        origin[0] + @as(f32, @floatFromInt(col_idx)),
+                        origin[1] + @as(f32, @floatFromInt(row_idx)),
+                    },
+                    .glyph_size = .{
+                        @floatFromInt(glyph_uv.width),
+                        @floatFromInt(glyph_uv.height),
+                    },
+                    .glyph_bearing = .{
+                        @floatFromInt(glyph_uv.bearing_x),
+                        glyphTopOffset(baseline, glyph_uv.bearing_y),
+                    },
+                    .uv_rect = .{
+                        glyph_uv.u0,
+                        glyph_uv.v0,
+                        glyph_uv.u1,
+                        glyph_uv.v1,
+                    },
+                    .fg = fg,
+                    .bg = bg,
+                });
+            }
+        }
+        panel_draws[panel_idx] = .{
+            .instance_offset_instances = instance_offset_instances,
+            .instance_count = @as(u32, @intCast(instances.items.len)) - instance_offset_instances,
+            .coverage = variant.coverage,
+            .origin_col = @as(u32, @intCast(panel_idx)) * panel_cols,
+        };
+    }
+    return .{
+        .instances = instances,
+        .panel_draws = panel_draws,
+        .panel_cols = panel_cols,
+        .window_cols = panel_cols * @as(u32, @intCast(variants.len)),
+        .window_rows = top_margin_rows + @as(u32, @intCast(specimen_lines.len)) + 2,
+    };
+}
+fn drawTextCoverageCompareFrame(
+    ctx: *renderer.Context,
+    scene: *const TextCoverageCompareScene,
+    cell_w_px: u32,
+    cell_h_px: u32,
+    clear_color: [4]f32,
+) !void {
+    _ = try ctx.vkd.waitForFences(
+        ctx.device,
+,
+        @ptrCast(&ctx.in_flight_fence),
+        .true,
+        std.math.maxInt(u64),
+    );
+    try ctx.vkd.resetFences(ctx.device, 1, @ptrCast(&ctx.in_flight_fence));
+    const acquire = ctx.vkd.acquireNextImageKHR(
+        ctx.device,
+        ctx.swapchain,
+        std.math.maxInt(u64),
+        ctx.image_available,
+        .null_handle,
+    ) catch |err| switch (err) {
+        error.OutOfDateKHR => return error.OutOfDateKHR,
+        else => return err,
+    };
+    if (acquire.result == .suboptimal_khr) return error.OutOfDateKHR;
+    const image_index = acquire.image_index;
+    try ctx.vkd.resetCommandBuffer(ctx.command_buffer, .{});
+    try ctx.vkd.beginCommandBuffer(ctx.command_buffer, &vk.CommandBufferBeginInfo{
+        .flags = .{ .one_time_submit_bit = true },
+    });
+    const clear_value = vk.ClearValue{ .color = .{ .float_32 = clear_color } };
+    ctx.vkd.cmdBeginRenderPass(ctx.command_buffer, &vk.RenderPassBeginInfo{
+        .render_pass = ctx.render_pass,
+        .framebuffer = ctx.framebuffers[image_index],
+        .render_area = .{
+            .offset = .{ .x = 0, .y = 0 },
+            .extent = ctx.swapchain_extent,
+        },
+        .clear_value_count = 1,
+        .p_clear_values = @ptrCast(&clear_value),
+    }, .@"inline");
+    ctx.vkd.cmdBindPipeline(ctx.command_buffer, .graphics, ctx.pipeline);
+    const viewport = vk.Viewport{
+        .x = 0.0,
+        .y = 0.0,
+        .width = @floatFromInt(ctx.swapchain_extent.width),
+        .height = @floatFromInt(ctx.swapchain_extent.height),
+        .min_depth = 0.0,
+        .max_depth = 1.0,
+    };
+    ctx.vkd.cmdSetViewport(ctx.command_buffer, 0, 1, @ptrCast(&viewport));
+    ctx.vkd.cmdBindDescriptorSets(
+        ctx.command_buffer,
+        .graphics,
+        ctx.pipeline_layout,
+,
+,
+        @ptrCast(&ctx.descriptor_set),
+,
+        null,
+    );
+    const buffers = [_]vk.Buffer{ ctx.quad_vertex_buffer, ctx.instance_buffer };
+    const panel_width_px = scene.panel_cols * cell_w_px;
+    for (scene.panel_draws) |panel_draw| {
+        const scissor_x_px = panel_draw.origin_col * cell_w_px;
+        if (scissor_x_px >= ctx.swapchain_extent.width) continue;
+        const scissor = vk.Rect2D{
+            .offset = .{ .x = @intCast(scissor_x_px), .y = 0 },
+            .extent = .{
+                .width = @min(panel_width_px, ctx.swapchain_extent.width - scissor_x_px),
+                .height = ctx.swapchain_extent.height,
+            },
+        };
+        ctx.vkd.cmdSetScissor(ctx.command_buffer, 0, 1, @ptrCast(&scissor));
+        const push_constants = renderer.PushConstants{
+            .viewport_size = .{
+                @floatFromInt(ctx.swapchain_extent.width),
+                @floatFromInt(ctx.swapchain_extent.height),
+            },
+            .cell_size = .{
+                @floatFromInt(cell_w_px),
+                @floatFromInt(cell_h_px),
+            },
+            .coverage_params = panel_draw.coverage,
+        };
+        ctx.vkd.cmdPushConstants(
+            ctx.command_buffer,
+            ctx.pipeline_layout,
+            .{ .vertex_bit = true, .fragment_bit = true },
+,
+            @sizeOf(renderer.PushConstants),
+            @ptrCast(&push_constants),
+        );
+        const offsets = [_]vk.DeviceSize{
+,
+            @as(vk.DeviceSize, panel_draw.instance_offset_instances) * @sizeOf(renderer.Instance),
+        };
+        ctx.vkd.cmdBindVertexBuffers(ctx.command_buffer, 0, 2, &buffers, &offsets);
+        ctx.vkd.cmdDraw(ctx.command_buffer, 6, panel_draw.instance_count, 0, 0);
+    }
+    ctx.vkd.cmdEndRenderPass(ctx.command_buffer);
+    try ctx.vkd.endCommandBuffer(ctx.command_buffer);
+    const wait_stage = vk.PipelineStageFlags{ .color_attachment_output_bit = true };
+    try ctx.vkd.queueSubmit(ctx.graphics_queue, 1, @ptrCast(&vk.SubmitInfo{
+        .wait_semaphore_count = 1,
+        .p_wait_semaphores = @ptrCast(&ctx.image_available),
+        .p_wait_dst_stage_mask = @ptrCast(&wait_stage),
+        .command_buffer_count = 1,
+        .p_command_buffers = @ptrCast(&ctx.command_buffer),
+        .signal_semaphore_count = 1,
+        .p_signal_semaphores = @ptrCast(&ctx.render_finished),
+    }), ctx.in_flight_fence);
+    const present_result = ctx.vkd.queuePresentKHR(ctx.present_queue, &vk.PresentInfoKHR{
+        .wait_semaphore_count = 1,
+        .p_wait_semaphores = @ptrCast(&ctx.render_finished),
+        .swapchain_count = 1,
+        .p_swapchains = @ptrCast(&ctx.swapchain),
+        .p_image_indices = @ptrCast(&image_index),
+    }) catch |err| switch (err) {
+        error.OutOfDateKHR => return error.OutOfDateKHR,
+        else => return err,
+    };
+    if (present_result == .suboptimal_khr) return error.OutOfDateKHR;
+}
+const RowRefreshState = enum {
+    full,
+    partial,
@@ @@ -1469,6 +1723,86 @@ fn makeTestInstances( @@
+    return instances;
+fn runTextCoverageCompare(alloc: std.mem.Allocator) !void {
+    var conn = try wayland_client.Connection.init();
+    defer conn.deinit();
+    const window = try conn.createWindow(alloc, "waystty-text-compare");
+    defer window.deinit();
+    _ = conn.display.roundtrip();
+    var font_lookup = try font.lookupConfiguredFont(alloc);
+    defer font_lookup.deinit(alloc);
+    var face = try font.Face.init(alloc, font_lookup.path, font_lookup.index, config.font_size_px);
+    defer face.deinit();
+    var atlas = try font.Atlas.init(alloc, 1024, 1024);
+    defer atlas.deinit();
+    var scene = try buildTextCoverageCompareScene(alloc, &face, &atlas);
+    defer scene.deinit(alloc);
+    const cell_w = face.cellWidth();
+    const cell_h = face.cellHeight();
+    window.width = scene.window_cols * cell_w;
+    window.height = scene.window_rows * cell_h;
+    var ctx = try renderer.Context.init(
+        alloc,
+        @ptrCast(conn.display),
+        @ptrCast(window.surface),
+        window.width,
+        window.height,
+    );
+    defer ctx.deinit();
+    try ctx.uploadAtlas(atlas.pixels);
+    atlas.dirty = false;
+    try ctx.uploadInstances(scene.instances.items);
+    var last_window_w = window.width;
+    var last_window_h = window.height;
+    while (!window.should_close) {
+        _ = conn.display.flush();
+        if (conn.display.prepareRead()) {
+            _ = conn.display.readEvents();
+        }
+        _ = conn.display.dispatchPending();
+        if (window.width != last_window_w or window.height != last_window_h) {
+            _ = try ctx.vkd.deviceWaitIdle(ctx.device);
+            try ctx.recreateSwapchain(window.width, window.height);
+            last_window_w = window.width;
+            last_window_h = window.height;
+        }
+        drawTextCoverageCompareFrame(
+            &ctx,
+            &scene,
+            cell_w,
+            cell_h,
+            .{ 0.0, 0.0, 0.0, 1.0 },
+        ) catch |err| switch (err) {
+            error.OutOfDateKHR => {
+                _ = try ctx.vkd.deviceWaitIdle(ctx.device);
+                try ctx.recreateSwapchain(window.width, window.height);
+                last_window_w = window.width;
+                last_window_h = window.height;
+                continue;
+            },
+            else => return err,
+        };
+        _ = conn.display.flush();
+        std.Thread.sleep(16 * std.time.ns_per_ms);
+    }
+    _ = try ctx.vkd.deviceWaitIdle(ctx.device);
+}
+fn runDrawSmokeTest(alloc: std.mem.Allocator) !void {
+    var conn = try wayland_client.Connection.init();
+    defer conn.deinit();
+test "buildTextCoverageCompareScene repeats the same specimen in four panels" {
+    var lookup = try font.lookupConfiguredFont(std.testing.allocator);
+    defer lookup.deinit(std.testing.allocator);
+    var face = try font.Face.init(std.testing.allocator, lookup.path, lookup.index, config.font_size_px);
+    defer face.deinit();
+    var atlas = try font.Atlas.init(std.testing.allocator, 256, 256);
+    defer atlas.deinit();
+    var scene = try buildTextCoverageCompareScene(std.testing.allocator, &face, &atlas);
+    defer scene.deinit(std.testing.allocator);
+    const variants = comparisonVariants();
+    const first_draw = scene.panel_draws[0];
+    try std.testing.expect(first_draw.instance_count > 0);
+    var idx: usize = 0;
+    while (idx < scene.panel_draws.len) : (idx += 1) {
+        try std.testing.expectEqual(first_draw.instance_count, scene.panel_draws[idx].instance_count);
+        try std.testing.expectEqualDeep(variants[idx].coverage, scene.panel_draws[idx].coverage);
+    }
+    const panel0_first = scene.instances.items[first_draw.instance_offset_instances];
+    const panel1_first = scene.instances.items[scene.panel_draws[1].instance_offset_instances];
+    try std.testing.expectEqual(panel0_first.cell_pos[1], panel1_first.cell_pos[1]);
+    try std.testing.expectEqual(
+        @as(f32, @floatFromInt(scene.panel_cols)),
+        panel1_first.cell_pos[0] - panel0_first.cell_pos[0],
+    );
+}
+fn runRenderSmokeTest(alloc: std.mem.Allocator) !void {
+    var conn = try wayland_client.Connection.init();
+    defer conn.deinit();